void set_group_member_numbers (entity *en)
{
int
number;
entity
*member;
ASSERT (en);
ASSERT (get_comms_model () == COMMS_MODEL_SERVER);
number = 0;
member = get_local_entity_first_child (en, LIST_TYPE_MEMBER);
while (member)
{
set_client_server_entity_int_value (member, INT_TYPE_GROUP_MEMBER_NUMBER, number);
member = get_local_entity_child_succ (member, LIST_TYPE_MEMBER);
number ++;
}
}
void initialise_attack_guide (entity *en)
{
entity
*task,
*aggressor,
*target;
ASSERT (en);
task = get_local_entity_parent (en, LIST_TYPE_GUIDE);
ASSERT (task);
ASSERT (get_local_entity_int_value (task, INT_TYPE_ENTITY_SUB_TYPE) == ENTITY_SUB_TYPE_TASK_ENGAGE);
aggressor = get_local_entity_ptr_value (en, PTR_TYPE_TASK_LEADER);
ASSERT (aggressor);
target = get_local_entity_parent (task, LIST_TYPE_TASK_DEPENDENT);
ASSERT (target);
if (!get_local_entity_int_value (aggressor, INT_TYPE_IDENTIFY_AIRCRAFT))
{
//
// Surface-Air & Surface-Surface
//
entity_sub_types
best_weapon;
//
// find best weapon for target
//
best_weapon = get_best_weapon_for_target (aggressor, target, BEST_WEAPON_CRITERIA_ALL);
set_client_server_entity_int_value (aggressor, INT_TYPE_SELECTED_WEAPON, best_weapon);
return;
}
//
// Air-Air & Air-Surface
//
if (get_local_entity_int_value (target, INT_TYPE_AIRBORNE_AIRCRAFT))
{
initialise_air_to_air_attack_guide (en, aggressor, target);
}
else
{
initialise_air_to_ground_attack_guide (en, aggressor, target);
}
}
void toggle_viper_radar_jammer_manual (void)
{
if (!viper_damage.radar_jammer)
{
if (!get_global_auto_counter_measures ())
{
if (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_RADAR_JAMMER_ON))
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_RADAR_JAMMER_ON, FALSE);
}
else
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_RADAR_JAMMER_ON, TRUE);
}
}
}
play_common_cpg_radar_jammer_speech (viper_damage.radar_jammer);
}
void toggle_ka50_infra_red_jammer_manual (void)
{
if (!ka50_damage.infra_red_jammer)
{
if (!get_global_auto_counter_measures ())
{
if (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON))
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON, FALSE);
}
else
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON, TRUE);
}
}
}
play_common_cpg_infra_red_jammer_speech (ka50_damage.infra_red_jammer);
}
static void toggle_navigation_lights_event (event *ev)
{
int
status;
status = get_local_entity_int_value (get_gunship_entity (), INT_TYPE_LIGHTS_ON);
status ^= 1;
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_LIGHTS_ON, status);
}
void set_ka50_radar_jammer_manual (int state)
{
if (!ka50_damage.radar_jammer)
{
if (!get_global_auto_counter_measures ())
{
if (state != get_local_entity_int_value (get_gunship_entity (), INT_TYPE_RADAR_JAMMER_ON))
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_RADAR_JAMMER_ON, state);
}
}
}
}
void set_ka50_infra_red_jammer_auto (int state)
{
if (!ka50_damage.infra_red_jammer)
{
if (get_global_auto_counter_measures ())
{
if (state != get_local_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON))
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON, state);
}
}
}
}
void weapon_loading_set_default_air_to_ground_config (entity *en)
{
ASSERT (en);
set_client_server_entity_int_value (en, INT_TYPE_WEAPON_CONFIG_TYPE, get_local_entity_int_value (en, INT_TYPE_AIR_TO_SURFACE_WEAPON_CONFIG_TYPE));
weapon_loading_update_currently_selected_weapons (en);
if (en == get_gunship_entity ())
{
set_flight_dynamics_mass ();
}
}
int attack_guide_find_best_weapon (entity *en)
{
entity
*target,
*aggressor;
entity_sub_types
best_weapon;
//
// check weapon
//
aggressor = get_local_entity_ptr_value (en, PTR_TYPE_TASK_LEADER);
ASSERT (aggressor);
target = get_local_entity_parent (aggressor, LIST_TYPE_TARGET);
ASSERT (target);
best_weapon = get_best_weapon_for_target (aggressor, target, BEST_WEAPON_RANGE_CHECK);
if (best_weapon == ENTITY_SUB_TYPE_WEAPON_NO_WEAPON)
{
//
// No suitable weapon at current range
//
best_weapon = get_best_weapon_for_target (aggressor, target, BEST_WEAPON_CRITERIA_MINIMAL);
if (best_weapon == ENTITY_SUB_TYPE_WEAPON_NO_WEAPON)
{
//
// Entity is not capable of destroying the target - abort the attack
//
delete_group_member_from_engage_guide (aggressor, en, TRUE);
return FALSE;
}
}
set_client_server_entity_int_value (aggressor, INT_TYPE_SELECTED_WEAPON, best_weapon);
return TRUE;
}
void set_group_formation_positions (entity *en)
{
entity
*member;
ASSERT (en);
ASSERT (get_comms_model () == COMMS_MODEL_SERVER);
member = get_local_entity_first_child (en, LIST_TYPE_MEMBER);
while (member)
{
set_client_server_entity_int_value (member, INT_TYPE_FORMATION_POSITION, get_local_entity_int_value (member, INT_TYPE_GROUP_MEMBER_NUMBER));
member = get_local_entity_child_succ (member, LIST_TYPE_MEMBER);
}
}
void initialise_common_weapon_systems (void)
{
fire_continuous_weapon = FALSE;
fire_single_weapon = 0;
rocket_salvo_size = 1;
rocket_salvo_count = 0;
good_tone = FALSE;
good_tone_delay = 0.0;
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_LOCK_ON_AFTER_LAUNCH, FALSE);
set_gunship_weapon (ENTITY_SUB_TYPE_WEAPON_NO_WEAPON);
}
void set_group_verbose_operational_state (entity *en, int state)
{
group
*raw;
if (get_comms_model () == COMMS_MODEL_CLIENT)
{
return;
}
raw = get_local_entity_data (en);
if (raw->verbose_operational_state == state)
{
return;
}
set_client_server_entity_int_value (en, INT_TYPE_VERBOSE_OPERATIONAL_STATE, state);
}
static void notify_default_payload_list (ui_object *obj, void *arg)
{
entity
*en;
int
config_type;
en = get_local_entity_safe_ptr (get_ui_object_item_number (page_member_list));
if (en)
{
if (get_helicopter_allowed_to_rearm (en))
{
config_type = get_ui_object_item_number (obj);
if (config_type != ENTITY_INDEX_DONT_CARE)
{
ASSERT (
(config_type == INT_TYPE_AIR_TO_SURFACE_WEAPON_CONFIG_TYPE) ||
(config_type == INT_TYPE_AIR_TO_AIR_WEAPON_CONFIG_TYPE) ||
(config_type == INT_TYPE_SCOUT_WEAPON_CONFIG_TYPE)
);
set_client_server_entity_int_value (en, INT_TYPE_WEAPON_CONFIG_TYPE, get_local_entity_int_value (en, config_type));
weapon_loading_update_currently_selected_weapons (en);
if (en == get_gunship_entity ())
{
set_flight_dynamics_mass ();
}
}
}
rebuild_default_payload_list (en);
}
}
void set_gunship_weapon (entity_sub_types weapon_sub_type)
{
entity
*en;
ASSERT (entity_sub_type_weapon_valid (weapon_sub_type));
en = get_gunship_entity ();
if (weapon_sub_type != get_local_entity_int_value (en, INT_TYPE_SELECTED_WEAPON))
{
set_client_server_entity_int_value (en, INT_TYPE_SELECTED_WEAPON, weapon_sub_type);
}
//
// ensure navigation HUD mode is set
//
if (weapon_sub_type == ENTITY_SUB_TYPE_WEAPON_NO_WEAPON)
{
hud_mode = HUD_MODE_NAVIGATION;
}
}
static void damage_systems (kiowa_damage_flags damage)
{
entity
*en;
en = get_gunship_entity ();
////////////////////////////////////////
if (damage.flir)
{
if (!kiowa_damage.flir)
{
activate_kiowa_master_caution ();
kiowa_damage.flir = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_FLIR_FAILURE);
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_FLIR)
{
select_kiowa_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
////////////////////////////////////////
if (damage.dtv)
{
if (!kiowa_damage.dtv)
{
activate_kiowa_master_caution ();
kiowa_damage.dtv = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_DTV_FAILURE);
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_DTV)
{
select_kiowa_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
////////////////////////////////////////
if (damage.laser_designator)
{
if (!kiowa_damage.laser_designator)
{
activate_kiowa_master_caution ();
kiowa_damage.laser_designator = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_laser_is_active(FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_LASER_DESIGNATOR_FAILURE);
}
}
////////////////////////////////////////
if (damage.infra_red_jammer)
{
if (!kiowa_damage.infra_red_jammer)
{
activate_kiowa_master_caution ();
kiowa_damage.infra_red_jammer = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_IR_JAMMER_FAILURE);
if (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON))
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON, FALSE);
}
}
}
////////////////////////////////////////
if (damage.navigation_computer)
{
if (!kiowa_damage.navigation_computer)
{
activate_kiowa_master_caution ();
kiowa_damage.navigation_computer = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_NAV_COMPUTER_FAILURE);
}
}
////////////////////////////////////////
if (damage.communications)
{
if (!kiowa_damage.communications)
{
activate_kiowa_master_caution ();
kiowa_damage.communications = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_COMMS_FAILURE);
}
}
////////////////////////////////////////
if (damage.radar_warning_system)
{
if (!kiowa_damage.radar_warning_system)
{
activate_kiowa_master_caution ();
kiowa_damage.radar_warning_system = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_RADAR_WARNING_FAILURE);
}
}
////////////////////////////////////////
if (damage.co_pilot_main_mfd)
{
if (!kiowa_damage.co_pilot_main_mfd)
{
activate_kiowa_master_caution ();
kiowa_damage.co_pilot_main_mfd = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_MFD_FAILURE);
select_kiowa_main_mfd_mode (KIOWA_MAIN_MFD_MODE_DAMAGED, KIOWA_MAIN_MFD_LOCATION_CO_PILOT);
}
}
////////////////////////////////////////
if (damage.pilot_main_mfd)
{
if (!kiowa_damage.pilot_main_mfd)
{
activate_kiowa_master_caution ();
kiowa_damage.pilot_main_mfd = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_MFD_FAILURE);
select_kiowa_main_mfd_mode (KIOWA_MAIN_MFD_MODE_DAMAGED, KIOWA_MAIN_MFD_LOCATION_PILOT);
}
}
////////////////////////////////////////
if (damage.center_main_mfd)
{
if (!kiowa_damage.center_main_mfd)
{
activate_kiowa_master_caution ();
kiowa_damage.center_main_mfd = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_MFD_FAILURE);
select_kiowa_main_mfd_mode (KIOWA_MAIN_MFD_MODE_DAMAGED, KIOWA_MAIN_MFD_LOCATION_CENTER);
}
}
////////////////////////////////////////
if (damage.pnvs)
{
if (!kiowa_damage.pnvs)
{
activate_kiowa_master_caution ();
kiowa_damage.pnvs = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_PNVS_FAILURE);
night_vision_system_active = FALSE;
}
}
////////////////////////////////////////
if (damage.lh_pylon)
{
if (!kiowa_damage.lh_pylon)
{
activate_kiowa_master_caution ();
kiowa_damage.lh_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.rh_pylon)
{
if (!kiowa_damage.rh_pylon)
{
activate_kiowa_master_caution ();
kiowa_damage.rh_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.chaff_dispenser)
{
if (!kiowa_damage.chaff_dispenser)
{
activate_kiowa_master_caution ();
kiowa_damage.chaff_dispenser = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_CHAFF_DISPENSER_DAMAGED);
}
}
////////////////////////////////////////
if (damage.flare_dispenser)
{
if (!kiowa_damage.flare_dispenser)
{
activate_kiowa_master_caution ();
kiowa_damage.flare_dispenser = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_FLARE_DISPENSER_DAMAGED);
}
}
////////////////////////////////////////
if (damage.hud)
{
if (!kiowa_damage.hud)
{
activate_kiowa_master_caution ();
kiowa_damage.hud = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
play_client_server_warning_message (en, SPEECH_SYSTEM_HUD_FAILURE);
}
}
////////////////////////////////////////
set_kiowa_weapon_damage_status ();
}
static void damage_systems (havoc_damage_flags damage)
{
entity
*en;
en = get_gunship_entity ();
////////////////////////////////////////
if (damage.radar)
{
if (!havoc_damage.radar)
{
activate_havoc_master_caution_lamp ();
havoc_damage.radar = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("RADAR", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_RADAR_FAILURE);
if
(
(target_acquisition_system == TARGET_ACQUISITION_SYSTEM_GROUND_RADAR) ||
(target_acquisition_system == TARGET_ACQUISITION_SYSTEM_AIR_RADAR)
)
{
select_havoc_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
////////////////////////////////////////
if (damage.flir)
{
if (!havoc_damage.flir)
{
activate_havoc_master_caution_lamp ();
havoc_damage.flir = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("FLIR", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_FLIR_FAILURE);
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_FLIR)
{
select_havoc_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
////////////////////////////////////////
if (damage.llltv)
{
if (!havoc_damage.llltv)
{
activate_havoc_master_caution_lamp ();
havoc_damage.llltv = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("LLLTV", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_LLLTV_FAILURE);
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_LLLTV)
{
select_havoc_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
////////////////////////////////////////
if (damage.laser_range_finder)
{
if (!havoc_damage.laser_range_finder)
{
activate_havoc_master_caution_lamp ();
havoc_damage.laser_range_finder = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("LASER", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_LASER_RANGE_FINDER_FAILURE);
}
}
////////////////////////////////////////
if (damage.radar_jammer)
{
if (!havoc_damage.radar_jammer)
{
activate_havoc_master_caution_lamp ();
havoc_damage.radar_jammer = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("RD JAMMER", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_RADAR_JAMMER_FAILURE);
if (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_RADAR_JAMMER_ON))
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_RADAR_JAMMER_ON, FALSE);
}
}
}
////////////////////////////////////////
if (damage.infra_red_jammer)
{
if (!havoc_damage.infra_red_jammer)
{
activate_havoc_master_caution_lamp ();
havoc_damage.infra_red_jammer = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("IR JAMMER", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_IR_JAMMER_FAILURE);
if (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON))
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON, FALSE);
}
}
}
////////////////////////////////////////
if (damage.navigation_computer)
{
if (!havoc_damage.navigation_computer)
{
activate_havoc_master_caution_lamp ();
havoc_damage.navigation_computer = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("NAV COMP", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_NAV_COMPUTER_FAILURE);
}
}
////////////////////////////////////////
if (damage.communications)
{
if (!havoc_damage.communications)
{
activate_havoc_master_caution_lamp ();
havoc_damage.communications = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("COMMS", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_COMMS_FAILURE);
}
}
////////////////////////////////////////
if (damage.radar_warning_system)
{
if (!havoc_damage.radar_warning_system)
{
activate_havoc_master_caution_lamp ();
havoc_damage.radar_warning_system = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("RWS", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_RADAR_WARNING_FAILURE);
}
}
////////////////////////////////////////
if (!get_global_simple_avionics ())
{
if (damage.head_up_display)
{
if (!havoc_damage.head_up_display)
{
activate_havoc_master_caution_lamp ();
havoc_damage.head_up_display = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("HUD", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_HUD_FAILURE);
}
}
}
////////////////////////////////////////
if (!get_global_simple_avionics ())
{
if (damage.helmet_mounted_sight)
{
if (!havoc_damage.helmet_mounted_sight)
{
activate_havoc_master_caution_lamp ();
havoc_damage.helmet_mounted_sight = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("HMS", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_HELMET_MOUNTED_SIGHT_FAILURE);
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_HMS)
{
select_havoc_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
}
////////////////////////////////////////
if (damage.tv_display)
{
if (!havoc_damage.tv_display)
{
activate_havoc_master_caution_lamp ();
havoc_damage.tv_display = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("TV", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_TV_DISPLAY_FAILURE);
}
}
////////////////////////////////////////
if (damage.threat_warning_display)
{
if (!havoc_damage.threat_warning_display)
{
activate_havoc_master_caution_lamp ();
havoc_damage.threat_warning_display = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("TWD", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_THREAT_WARNING_DISPLAY_FAILURE);
}
}
////////////////////////////////////////
if (damage.night_vision_goggles)
{
if (!havoc_damage.night_vision_goggles)
{
activate_havoc_master_caution_lamp ();
havoc_damage.night_vision_goggles = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("NVG", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_NIGHT_VISION_GOGGLES_FAILURE);
night_vision_system_active = FALSE;
}
}
////////////////////////////////////////
if (damage.gun_jammed)
{
if (!havoc_damage.gun_jammed)
{
activate_havoc_master_caution_lamp ();
havoc_damage.gun_jammed = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("GUN", "JAMMED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_GUN_JAMMED);
}
}
////////////////////////////////////////
if (damage.lh_outer_pylon)
{
if (!havoc_damage.lh_outer_pylon)
{
activate_havoc_master_caution_lamp ();
havoc_damage.lh_outer_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("HARDPOINT", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.lh_inner_pylon)
{
if (!havoc_damage.lh_inner_pylon)
{
activate_havoc_master_caution_lamp ();
havoc_damage.lh_inner_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("HARDPOINT", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.rh_outer_pylon)
{
if (!havoc_damage.rh_outer_pylon)
{
activate_havoc_master_caution_lamp ();
havoc_damage.rh_outer_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("HARDPOINT", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.rh_inner_pylon)
{
if (!havoc_damage.rh_inner_pylon)
{
activate_havoc_master_caution_lamp ();
havoc_damage.rh_inner_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("HARDPOINT", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.chaff_dispenser)
{
if (!havoc_damage.chaff_dispenser)
{
activate_havoc_master_caution_lamp ();
havoc_damage.chaff_dispenser = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("CHAFF", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_CHAFF_DISPENSER_DAMAGED);
}
}
////////////////////////////////////////
if (damage.flare_dispenser)
{
if (!havoc_damage.flare_dispenser)
{
activate_havoc_master_caution_lamp ();
havoc_damage.flare_dispenser = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_havoc_ekran_display_text ("FLARES", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_FLARE_DISPENSER_DAMAGED);
}
}
////////////////////////////////////////
set_havoc_weapon_damage_status ();
}
static void kill_local (entity *en)
{
int
losses;
helicopter
*raw;
entity
*task,
*group,
*member,
*destroy_task;
////////////////////////////////////////
//
// PRE-AMBLE
//
////////////////////////////////////////
#if DEBUG_MODULE >= 2
debug_log_entity_args (ENTITY_DEBUG_LOCAL, ENTITY_DEBUG_KILL, en);
#endif
if (!get_local_entity_int_value (en, INT_TYPE_ALIVE))
{
return;
}
raw = get_local_entity_data (en);
group = get_local_entity_parent (en, LIST_TYPE_MEMBER);
ASSERT (group);
//
// update force info
//
remove_from_force_info (get_local_force_entity (raw->ac.mob.side), en);
if (en == get_gunship_entity ())
{
//
// Award Points for mission
//
task = get_local_entity_primary_task (en);
if (task)
{
if (get_local_entity_int_value (task, INT_TYPE_TASK_STATE) == TASK_STATE_COMPLETED)
{
//
// Only award points for COMPLETE missions (also means player can't rejoin that mission and get points again)
//
notify_gunship_entity_mission_terminated (en, task);
}
}
}
////////////////////////////////////////
//
// VALIDATE
//
////////////////////////////////////////
////////////////////////////////////////
//
// DESTROY COMPONENTS
//
////////////////////////////////////////
#if DEBUG_MODULE
debug_log ("HC_DSTRY: killing helicopter %s", entity_sub_type_aircraft_names [raw->ac.mob.sub_type]);
#endif
if (get_comms_model () == COMMS_MODEL_SERVER)
{
// notify regen of kill
add_entity_to_regen_queue
(
get_local_entity_int_value(en, INT_TYPE_SIDE),
get_local_entity_type(en),
get_local_entity_int_value (en, INT_TYPE_ENTITY_SUB_TYPE),
get_local_entity_int_value (group, INT_TYPE_ENTITY_SUB_TYPE)
);
//
// notify task dependents
//
task = get_local_entity_first_child (en, LIST_TYPE_TASK_DEPENDENT);
while (task)
{
destroy_task = task;
task = get_local_entity_child_succ (task, LIST_TYPE_TASK_DEPENDENT);
if (destroy_task->type == ENTITY_TYPE_TASK)
{
#if DEBUG_MODULE
debug_log ("HC_DSTRY: killing helicopter, notifying task %s complete", entity_sub_type_task_names [get_local_entity_int_value (destroy_task, INT_TYPE_ENTITY_SUB_TYPE)]);
#endif
notify_local_entity (ENTITY_MESSAGE_TASK_COMPLETED, destroy_task, en, TASK_TERMINATED_OBJECTIVE_MESSAGE);
}
}
//
// Release landing lock (if any)
//
release_mobile_entity_landing_locks (en);
//
// if group contains player, set all helicopters in group to "weapons free", and clear "hold position" flag
//
if (get_local_entity_int_value (en, INT_TYPE_PLAYER) != ENTITY_PLAYER_AI)
{
member = get_local_entity_first_child (group, LIST_TYPE_MEMBER);
while (member)
{
set_client_server_entity_int_value (member, INT_TYPE_WEAPONS_HOLD, FALSE);
set_client_server_entity_int_value (member, INT_TYPE_POSITION_HOLD, FALSE);
member = get_local_entity_child_succ (member, LIST_TYPE_MEMBER);
}
}
}
////////////////////////////////////////
//
// UNLINK FROM SYSTEM
//
////////////////////////////////////////
//
// helicopter
//
unlink_local_entity_children (en, LIST_TYPE_GUNSHIP_TARGET);
unlink_local_entity_children (en, LIST_TYPE_PADLOCK);
//
// aircraft
//
// aircrew_root
unlink_local_entity_children (en, LIST_TYPE_TASK_DEPENDENT);
////////////////////////////////////////
//
// the eject sequence relies on launched weapons NOT being unlinked
//
// unlink_local_entity_children (en, LIST_TYPE_LAUNCHED_WEAPON);
//
////////////////////////////////////////
delete_local_entity_from_parents_child_list (en, LIST_TYPE_FOLLOWER);
delete_local_entity_from_parents_child_list (en, LIST_TYPE_MEMBER);
// gunship_target_link
// member_link
delete_local_entity_from_parents_child_list (en, LIST_TYPE_MOVEMENT_DEPENDENT);
// view_link
delete_local_entity_from_parents_child_list (en, LIST_TYPE_TAKEOFF_QUEUE);
//
// mobile
//
//
// kill weapon sound effects
//
kill_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_CHAIN_GUN);
//
// kill engine sound effects
//
kill_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_ROTOR_LOOPING);
kill_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_ROTOR_WIND_UP);
kill_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_ROTOR_WIND_DOWN);
//
// kill radio / warning effects
//
kill_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_INCOMING_MISSILE_WARNING);
kill_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_LOCK_ON_TONE);
kill_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_MCA);
kill_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_RADAR_LOCKED);
kill_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_RADAR_TRACKED);
kill_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_CPG_MESSAGE);
kill_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_RADIO_MESSAGE);
kill_local_entity_sound_type (en, ENTITY_SUB_TYPE_EFFECT_SOUND_WARNING_MESSAGE);
notify_speech_buffers_entity_killed (en);
unlink_local_entity_children (en, LIST_TYPE_TARGET);
delete_local_entity_from_parents_child_list (en, LIST_TYPE_PADLOCK);
// sector_link
delete_local_entity_from_parents_child_list (en, LIST_TYPE_TARGET);
// update_link
//
// death timer (set time after which entity is totally destroyed)
//
set_local_entity_float_value (en, FLOAT_TYPE_DEATH_TIMER, calculate_mobile_death_timer_value (en));
////////////////////////////////////////
//
// KILL
//
////////////////////////////////////////
damage_helicopter_3d_object (en);
// must be done before alive flag set to FALSE
remove_mobile_values_from_sector (get_local_entity_parent (en, LIST_TYPE_SECTOR), en);
set_local_entity_int_value (en, INT_TYPE_ALIVE, FALSE);
//
// group losses
//
losses = get_local_entity_int_value (group, INT_TYPE_LOSSES);
losses ++;
set_local_entity_int_value (group, INT_TYPE_LOSSES, losses);
//
// task losses
//
task = get_local_group_primary_task (group);
if (task)
{
losses = get_local_entity_int_value (task, INT_TYPE_LOSSES);
losses ++;
set_local_entity_int_value (task, INT_TYPE_LOSSES, losses);
}
//
// Notify Campaign Screen
//
notify_campaign_screen (CAMPAIGN_SCREEN_GROUP_REMOVE_MEMBER, group);
//
// Notify the GROUP that the mobile has been killed (N.B. must be done AFTER mobile is unlinked from member list)
//
if (get_comms_model () == COMMS_MODEL_SERVER)
{
notify_local_entity (ENTITY_MESSAGE_MOBILE_KILLED, group, en);
}
//
// Notify force to check campaign criteria
//
if (get_comms_model () == COMMS_MODEL_SERVER)
{
entity
*force;
force = get_local_entity_first_child (get_session_entity (), LIST_TYPE_FORCE);
while (force)
{
notify_local_entity (ENTITY_MESSAGE_CHECK_CAMPAIGN_OBJECTIVES, force, en);
force = get_local_entity_child_succ (force, LIST_TYPE_FORCE);
}
}
////////////////////////////////////////
//
// SPECIAL EFFECTS
//
////////////////////////////////////////
helicopter_impact_movement (en);
if (get_comms_model () == COMMS_MODEL_SERVER)
{
vec3d
*position;
sound_sample_indices
sound_sample_index;
set_client_server_entity_int_value (en, INT_TYPE_MAIN_ROTOR_DAMAGED, TRUE);
set_client_server_entity_int_value (en, INT_TYPE_TAIL_ROTOR_DAMAGED, TRUE);
create_client_server_object_killed_explosion_effect (en);
position = get_local_entity_vec3d_ptr (en, VEC3D_TYPE_POSITION);
sound_sample_index = SOUND_SAMPLE_INDEX_SHOT_DOWN_HELICOPTER;
create_client_server_sound_effect_entity
(
en,
ENTITY_SIDE_NEUTRAL,
ENTITY_SUB_TYPE_EFFECT_SOUND_ROTOR_LOOPING,
SOUND_CHANNEL_SOUND_EFFECT,
SOUND_LOCALITY_ALL,
NULL, // position
1.0, // amplification
TRUE, // valid sound effect
TRUE, // looping
1, // sample count
&sound_sample_index // sample index list
);
}
set_local_entity_int_value (en, INT_TYPE_OPERATIONAL_STATE, OPERATIONAL_STATE_DYING);
////////////////////////////////////////
//
// VIEWS
//
////////////////////////////////////////
if ((en == get_gunship_entity ()) && (!get_local_entity_int_value (en, INT_TYPE_EJECTED)))
{
set_gunship_entity (NULL);
}
#if LANDING_ROUTE_CHECK
destroy_debug_entity_landing_route_check (en);
#endif
/////////////////////////////////////////////////////////////////
//
// SPECIAL_EFFECT_HOOK FOR BEING_DESTROYED
//
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
//
//
/////////////////////////////////////////////////////////////////
}
void dynamics_damage_model (unsigned int damage, int random)
{
dynamics_damage_types
damage_array [NUM_DYNAMIC_DAMAGES];
int
count;
dynamics_damage_types
this_damage;
if (!get_session_entity ())
{
return;
}
if (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_INVULNERABLE_FROM_COLLISIONS))
{
// if invulnerable only allow damage/use of fire extinguisher
damage = damage & DYNAMICS_DAMAGE_FIRE_EXTINGUISHER;
}
if (random)
{
damage_array [0] = DYNAMICS_DAMAGE_NONE;
this_damage = DYNAMICS_DAMAGE_NONE;
count = 1;
while (this_damage < NUM_DYNAMICS_DAMAGE_TYPES)
{
if (damage & this_damage)
{
damage_array [count] = this_damage;
count ++;
}
this_damage = this_damage << 1;
}
damage = damage_array [rand16 () % count];
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: randomly selecting damage %d", damage);
#endif
}
notify_avionics_of_dynamics_fault (damage);
this_damage = DYNAMICS_DAMAGE_NONE;
while (this_damage < NUM_DYNAMICS_DAMAGE_TYPES)
{
if ((damage & this_damage) && (!(current_flight_dynamics->dynamics_damage & this_damage)))
{
switch (this_damage)
{
case DYNAMICS_DAMAGE_NONE:
{
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: no damage");
#endif
current_flight_dynamics->dynamics_damage = DYNAMICS_DAMAGE_NONE;
current_flight_dynamics->main_blade_pitch.damaged = FALSE;
current_flight_dynamics->main_rotor_roll_angle.damaged = FALSE;
current_flight_dynamics->main_rotor_pitch_angle.damaged = FALSE;
current_flight_dynamics->main_rotor_rpm.damaged = FALSE;
current_flight_dynamics->tail_blade_pitch.damaged = FALSE;
current_flight_dynamics->tail_rotor_rpm.damaged = FALSE;
current_flight_dynamics->left_engine_torque.damaged = FALSE;
current_flight_dynamics->left_engine_rpm.damaged = FALSE;
current_flight_dynamics->right_engine_torque.damaged = FALSE;
current_flight_dynamics->right_engine_rpm.damaged = FALSE;
current_flight_dynamics->cross_coupling_effect.damaged = FALSE;
current_flight_dynamics->input_data.cyclic_x.damaged = FALSE;
current_flight_dynamics->input_data.cyclic_y.damaged = FALSE;
current_flight_dynamics->input_data.cyclic_x_trim.damaged = FALSE;
current_flight_dynamics->input_data.cyclic_y_trim.damaged = FALSE;
break;
}
case DYNAMICS_DAMAGE_MAIN_ROTOR:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: main rotor damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_MAIN_ROTOR;
current_flight_dynamics->main_blade_pitch.damaged = TRUE;
current_flight_dynamics->main_rotor_roll_angle.damaged = TRUE;
current_flight_dynamics->main_rotor_pitch_angle.damaged = TRUE;
current_flight_dynamics->main_rotor_rpm.damaged = TRUE;
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_MAIN_ROTOR_DAMAGED, TRUE);
play_client_server_warning_message (get_gunship_entity (), SPEECH_SYSTEM_MAIN_ROTOR_DAMAGED);
set_current_flight_dynamics_auto_hover (HOVER_HOLD_NONE);
set_current_flight_dynamics_auto_pilot (FALSE);
break;
}
case DYNAMICS_DAMAGE_TAIL_ROTOR:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: tail rotor damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_TAIL_ROTOR;
current_flight_dynamics->tail_blade_pitch.damaged = TRUE;
current_flight_dynamics->tail_rotor_rpm.damaged = TRUE;
current_flight_dynamics->cross_coupling_effect.damaged = TRUE;
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_TAIL_ROTOR_DAMAGED, TRUE);
play_client_server_warning_message (get_gunship_entity (), SPEECH_SYSTEM_TAIL_ROTOR_DAMAGED);
set_current_flight_dynamics_auto_hover (HOVER_HOLD_NONE);
set_current_flight_dynamics_auto_pilot (FALSE);
break;
}
case DYNAMICS_DAMAGE_LEFT_ENGINE:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: left engine damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_LEFT_ENGINE;
current_flight_dynamics->left_engine_torque.damaged = TRUE;
current_flight_dynamics->left_engine_rpm.damaged = TRUE;
play_client_server_warning_message (get_gunship_entity (), SPEECH_SYSTEM_LEFT_ENGINE_FAILURE);
set_current_flight_dynamics_auto_hover (HOVER_HOLD_NONE);
set_current_flight_dynamics_auto_pilot (FALSE);
break;
}
case DYNAMICS_DAMAGE_RIGHT_ENGINE:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: right engine damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_RIGHT_ENGINE;
current_flight_dynamics->right_engine_torque.damaged = TRUE;
current_flight_dynamics->right_engine_rpm.damaged = TRUE;
play_client_server_warning_message (get_gunship_entity (), SPEECH_SYSTEM_RIGHT_ENGINE_FAILURE);
set_current_flight_dynamics_auto_hover (HOVER_HOLD_NONE);
set_current_flight_dynamics_auto_pilot (FALSE);
break;
}
case DYNAMICS_DAMAGE_LEFT_ENGINE_FIRE:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: left engine fire damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_LEFT_ENGINE_FIRE;
play_client_server_warning_message (get_gunship_entity (), SPEECH_SYSTEM_LEFT_ENGINE_FIRE);
set_current_flight_dynamics_auto_hover (HOVER_HOLD_NONE);
set_current_flight_dynamics_auto_pilot (FALSE);
break;
}
case DYNAMICS_DAMAGE_RIGHT_ENGINE_FIRE:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: right engine fire damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_RIGHT_ENGINE_FIRE;
play_client_server_warning_message (get_gunship_entity (), SPEECH_SYSTEM_RIGHT_ENGINE_FIRE);
set_current_flight_dynamics_auto_hover (HOVER_HOLD_NONE);
set_current_flight_dynamics_auto_pilot (FALSE);
break;
}
case DYNAMICS_DAMAGE_LOW_HYDRAULICS:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: LOW HYDRAULICS damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_LOW_HYDRAULICS;
current_flight_dynamics->input_data.cyclic_x.damaged = TRUE;
current_flight_dynamics->input_data.cyclic_y.damaged = TRUE;
if (sfrand1 () < 0.0)
{
play_client_server_warning_message (get_gunship_entity (), SPEECH_SYSTEM_HYDRAULIC_PRESSURE_FAILURE);
}
else
{
play_client_server_cpg_message (get_gunship_entity (), 0.5, 1.0, SPEECH_CATEGORY_CPG_SYSTEMS, 1.0, SPEECH_CPG_CONTROL_SYSTEMS_DAMAGED);
}
set_current_flight_dynamics_auto_hover (HOVER_HOLD_NONE);
set_current_flight_dynamics_auto_pilot (FALSE);
break;
}
case DYNAMICS_DAMAGE_STABILISER:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: STABILISER damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_STABILISER;
set_current_flight_dynamics_auto_hover (HOVER_HOLD_NONE);
set_current_flight_dynamics_auto_pilot (FALSE);
if (sfrand1 () < 0.0)
{
play_client_server_warning_message (get_gunship_entity (), SPEECH_SYSTEM_STABILISER_DAMAGED);
}
else
{
play_client_server_cpg_message (get_gunship_entity (), 0.5, 1.0, SPEECH_CATEGORY_CPG_SYSTEMS, 1.0, SPEECH_CPG_CONTROL_SYSTEMS_DAMAGED);
}
break;
}
case DYNAMICS_DAMAGE_FUEL_LEAK:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: FUEL_LEAK damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_FUEL_LEAK;
play_client_server_warning_message (get_gunship_entity (), SPEECH_SYSTEM_FUEL_LEAK);
break;
}
case DYNAMICS_DAMAGE_LOW_OIL_PRESSURE:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: LOW_OIL_PRESSURE damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_LOW_OIL_PRESSURE;
current_flight_dynamics->input_data.cyclic_y.damaged = TRUE;
if (sfrand1 () < 0.0)
{
play_client_server_warning_message (get_gunship_entity (), SPEECH_SYSTEM_LOW_ENGINE_OIL_PRESSURE);
}
else
{
play_client_server_cpg_message (get_gunship_entity (), 0.5, 1.0, SPEECH_CATEGORY_CPG_SYSTEMS, 1.0, SPEECH_CPG_CONTROL_SYSTEMS_DAMAGED);
}
set_current_flight_dynamics_auto_hover (HOVER_HOLD_NONE);
set_current_flight_dynamics_auto_pilot (FALSE);
break;
}
case DYNAMICS_DAMAGE_HIGH_OIL_PRESSURE:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: HIGH_OIL_PRESSURE damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_HIGH_OIL_PRESSURE;
current_flight_dynamics->input_data.collective.damaged = TRUE;
if (sfrand1 () < 0.0)
{
play_client_server_warning_message (get_gunship_entity (), SPEECH_SYSTEM_HIGH_ENGINE_OIL_TEMPERATURE);
}
else
{
play_client_server_cpg_message (get_gunship_entity (), 0.5, 1.0, SPEECH_CATEGORY_CPG_SYSTEMS, 1.0, SPEECH_CPG_CONTROL_SYSTEMS_DAMAGED);
}
set_current_flight_dynamics_auto_hover (HOVER_HOLD_NONE);
set_current_flight_dynamics_auto_pilot (FALSE);
break;
}
case DYNAMICS_DAMAGE_AVIONICS:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: AVIONICS damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_AVIONICS;
break;
}
case DYNAMICS_DAMAGE_FIRE_EXTINGUISHER:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: FIRE_EXTINGUISHER damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_FIRE_EXTINGUISHER;
break;
}
case DYNAMICS_DAMAGE_UNDERCARRIAGE:
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: UNDERCARRIAGE damage");
//#endif
current_flight_dynamics->dynamics_damage |= DYNAMICS_DAMAGE_UNDERCARRIAGE;
current_flight_dynamics->undercarriage_state.damaged = TRUE;
play_client_server_warning_message (get_gunship_entity (), SPEECH_SYSTEM_GEAR_DAMAGED);
break;
}
default:
{
debug_fatal ("DYNAMICS: unknown damage %d", this_damage);
}
}
}
this_damage = this_damage << 1;
}
}
void update_dynamics_at_keysite (void)
{
unsigned int
model_damage,
damage_count,
this_damage;
if ((!get_keysite_currently_landed_at ()) || (!get_gunship_entity ()))
{
return;
}
//
// Refuel, only set if inside keysite
//
#if !DEMO_VERSION
if (current_flight_dynamics->refuelling)
{
entity
*keysite;
float
max_fuel;
if (!(current_flight_dynamics->dynamics_damage & DYNAMICS_DAMAGE_FUEL_LEAK))
{
//#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: refuelling, fuel = %f (max = %f)", current_flight_dynamics->fuel_weight.value, current_flight_dynamics->fuel_weight.max);
//#endif
max_fuel = current_flight_dynamics->fuel_weight.max;
keysite = get_keysite_currently_landed_at ();
if (keysite)
{
if (get_local_entity_float_value (keysite, FLOAT_TYPE_FUEL_SUPPLY_LEVEL) <= 0.0)
{
if (!get_connection_list_head ())
{
max_fuel *= 0.25;
}
}
}
if (current_flight_dynamics->fuel_weight.value >= max_fuel)
{
current_flight_dynamics->refuelling = FALSE;
}
else
{
current_flight_dynamics->fuel_weight.value += REFUELLING_RATE * get_delta_time ();
}
current_flight_dynamics->fuel_weight.value = bound (current_flight_dynamics->fuel_weight.value,
current_flight_dynamics->fuel_weight.min,
current_flight_dynamics->fuel_weight.max);
}
else
{
debug_log ("DYNAMICS: can't refuel till leak is fixed");
}
}
#endif
//
// Repair, only set if inside keysite
//
if (current_flight_dynamics->repairing)
{
if (current_flight_dynamics->dynamics_damage != DYNAMICS_DAMAGE_NONE)
{
current_flight_dynamics->damage_repair_time -= get_delta_time ();
current_flight_dynamics->damage_repair_time = max (current_flight_dynamics->damage_repair_time, 0.0);
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: repairing %d, repair time %f seconds", current_flight_dynamics->damage_repair_time, current_flight_dynamics->damage_repair_time);
#endif
//
// set repair timer to time to repair each part in turn
//
if (current_flight_dynamics->damage_repair_time <= 0.0)
{
// clear repaired damage
if ((current_flight_dynamics->repairing_damage != DYNAMICS_DAMAGE_NONE) &&
(current_flight_dynamics->dynamics_damage & current_flight_dynamics->repairing_damage))
{
repair_damage_model (current_flight_dynamics->repairing_damage);
}
current_flight_dynamics->repairing_damage = DYNAMICS_DAMAGE_NONE;
// start repairing next
this_damage = DYNAMICS_DAMAGE_NONE;
damage_count = 0;
model_damage = current_flight_dynamics->dynamics_damage;
while (this_damage < NUM_DYNAMICS_DAMAGE_TYPES)
{
if ((model_damage & this_damage) && (dynamics_damage_database [damage_count].repairable))
{
current_flight_dynamics->damage_repair_time = dynamics_damage_database [damage_count].repair_time;
current_flight_dynamics->repairing_damage = this_damage;
#if DEBUG_MODULE
debug_log ("DYNAMICS: repairing %s, repair time %f seconds", dynamics_damage_database [damage_count].name, current_flight_dynamics->damage_repair_time);
#endif
break;
}
damage_count ++;
this_damage = this_damage << 1;
}
if (current_flight_dynamics->repairing_damage == DYNAMICS_DAMAGE_NONE)
{
#if DEBUG_MODULE
debug_log ("DYNAMICS: model fully repaired");
#endif
restore_helicopter_entity (get_gunship_entity (), NULL, get_local_entity_int_value (get_gunship_entity (), INT_TYPE_OPERATIONAL_STATE));
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_DAMAGE_LEVEL, get_local_entity_int_value (get_gunship_entity (), INT_TYPE_INITIAL_DAMAGE_LEVEL));
transmit_entity_comms_message (ENTITY_COMMS_RESTORE_ENTITY, get_gunship_entity (), get_local_entity_vec3d_ptr (get_gunship_entity (), VEC3D_TYPE_POSITION), get_local_entity_int_value (get_gunship_entity (), INT_TYPE_OPERATIONAL_STATE));
}
}
}
}
}
void repair_damage_model (unsigned int damage)
{
unsigned int
this_damage;
if (!get_gunship_entity ())
{
return;
}
this_damage = DYNAMICS_DAMAGE_NONE;
while (this_damage < NUM_DYNAMICS_DAMAGE_TYPES)
{
if ((damage & this_damage) && ((current_flight_dynamics->dynamics_damage & this_damage)))
{
current_flight_dynamics->dynamics_damage -= this_damage;
switch (this_damage)
{
case DYNAMICS_DAMAGE_NONE:
{
break;
}
case DYNAMICS_DAMAGE_MAIN_ROTOR:
{
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: main rotor repaired");
#endif
current_flight_dynamics->main_blade_pitch.damaged = FALSE;
current_flight_dynamics->main_rotor_roll_angle.damaged = FALSE;
current_flight_dynamics->main_rotor_pitch_angle.damaged = FALSE;
current_flight_dynamics->main_rotor_rpm.damaged = FALSE;
restore_helicopter_main_rotors (get_gunship_entity ());
transmit_entity_comms_message (ENTITY_COMMS_RESTORE_ENTITY, get_gunship_entity (), get_local_entity_vec3d_ptr (get_gunship_entity (), VEC3D_TYPE_POSITION), get_local_entity_int_value (get_gunship_entity (), INT_TYPE_OPERATIONAL_STATE));
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_MAIN_ROTOR_DAMAGED, FALSE);
break;
}
case DYNAMICS_DAMAGE_TAIL_ROTOR:
{
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: tail rotor repaired");
#endif
current_flight_dynamics->tail_blade_pitch.damaged = FALSE;
current_flight_dynamics->tail_rotor_rpm.damaged = FALSE;
current_flight_dynamics->cross_coupling_effect.damaged = FALSE;
restore_helicopter_tail_rotors (get_gunship_entity ());
break;
}
case DYNAMICS_DAMAGE_LEFT_ENGINE:
{
current_flight_dynamics->left_engine_torque.damaged = FALSE;
current_flight_dynamics->left_engine_rpm.damaged = FALSE;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: left engine repaired");
#endif
break;
}
case DYNAMICS_DAMAGE_RIGHT_ENGINE:
{
current_flight_dynamics->right_engine_torque.damaged = FALSE;
current_flight_dynamics->right_engine_rpm.damaged = FALSE;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: right engine repaired");
#endif
break;
}
case DYNAMICS_DAMAGE_LEFT_ENGINE_FIRE:
{
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: left engine fire repaired");
#endif
break;
}
case DYNAMICS_DAMAGE_RIGHT_ENGINE_FIRE:
{
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: right engine fire repaired");
#endif
break;
}
case DYNAMICS_DAMAGE_LOW_HYDRAULICS:
{
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: LOW HYDRAULICS repaired");
#endif
current_flight_dynamics->input_data.cyclic_x.damaged = FALSE;
current_flight_dynamics->input_data.cyclic_y.damaged = FALSE;
break;
}
case DYNAMICS_DAMAGE_STABILISER:
{
switch (current_flight_dynamics->sub_type)
{
case ENTITY_SUB_TYPE_AIRCRAFT_AH64D_APACHE_LONGBOW:
{
apache_restore_damage_values ();
break;
}
case ENTITY_SUB_TYPE_AIRCRAFT_MI28N_HAVOC_B:
{
havoc_restore_damage_values ();
break;
}
case ENTITY_SUB_TYPE_AIRCRAFT_RAH66_COMANCHE:
{
comanche_restore_damage_values ();
break;
}
case ENTITY_SUB_TYPE_AIRCRAFT_KA52_HOKUM_B:
{
hokum_restore_damage_values ();
break;
}
}
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: STABILISER repaired");
#endif
break;
}
case DYNAMICS_DAMAGE_FUEL_LEAK:
{
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: FUEL_LEAK repaired");
#endif
break;
}
case DYNAMICS_DAMAGE_LOW_OIL_PRESSURE:
{
current_flight_dynamics->input_data.cyclic_y.damaged = FALSE;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: LOW_OIL_PRESSURE repaired");
#endif
break;
}
case DYNAMICS_DAMAGE_HIGH_OIL_PRESSURE:
{
current_flight_dynamics->input_data.collective.damaged = FALSE;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: HIGH_OIL_PRESSURE repaired");
#endif
break;
}
case DYNAMICS_DAMAGE_AVIONICS:
{
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: AVIONICS repaired");
#endif
if (get_keysite_currently_landed_at ())
{
// sort out what avionics to repair.
switch (get_local_entity_int_value (get_keysite_currently_landed_at (), INT_TYPE_ENTITY_SUB_TYPE))
{
case ENTITY_SUB_TYPE_KEYSITE_FARP:
{
partially_repair_local_entity_avionics (get_gunship_entity ());
break;
}
default:
{
fully_repair_local_entity_avionics (get_gunship_entity ());
break;
}
}
}
else
{
fully_repair_local_entity_avionics (get_gunship_entity ());
}
break;
}
case DYNAMICS_DAMAGE_FIRE_EXTINGUISHER:
{
#if DEBUG_MODULE
debug_log ("DYNAMICS: FIRE EXTINGUISHER repaired");
#endif
fire_extinguisher_used = FALSE;
break;
}
case DYNAMICS_DAMAGE_UNDERCARRIAGE:
{
#if DEBUG_MODULE
debug_log ("DYNAMICS: UNDERCARRIAGE repaired");
#endif
current_flight_dynamics->undercarriage_state.damaged = FALSE;
break;
}
default:
{
debug_fatal ("DYNAMICS: unknown damage %d", this_damage);
}
}
}
this_damage = this_damage << 1;
}
}
void damage_entity_to_flight_model (entity *en)
{
float
damage_level;
unsigned int
this_damage;
if (!current_flight_dynamics)
{
return;
}
this_damage = DYNAMICS_DAMAGE_NONE;
damage_level = 0.0;
while (this_damage < NUM_DYNAMICS_DAMAGE_TYPES)
{
if (current_flight_dynamics->dynamics_damage & this_damage)
{
switch (this_damage)
{
case DYNAMICS_DAMAGE_NONE:
{
break;
}
case DYNAMICS_DAMAGE_MAIN_ROTOR:
{
damage_level += 0.6;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: main rotor damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_TAIL_ROTOR:
{
damage_level += 0.8;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: tail rotor damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_LEFT_ENGINE:
{
damage_level += 0.4;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: left engine damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_RIGHT_ENGINE:
{
damage_level += 0.4;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: right engine damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_LEFT_ENGINE_FIRE:
{
damage_level += 0.2;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: left engine fire damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_RIGHT_ENGINE_FIRE:
{
damage_level += 0.2;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: right engine fire damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_LOW_HYDRAULICS:
{
damage_level += 0.2;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: LOW HYDRAULICS damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_STABILISER:
{
damage_level += 0.2;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: STABILISER damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_FUEL_LEAK:
{
damage_level += 0.1;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: FUEL_LEAK damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_LOW_OIL_PRESSURE:
{
damage_level += 0.1;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: LOW_OIL_PRESSURE damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_HIGH_OIL_PRESSURE:
{
damage_level += 0.1;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: HIGH_OIL_PRESSURE damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_AVIONICS:
{
damage_level += 0.1;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: AVIONICS damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_FIRE_EXTINGUISHER:
{
damage_level += 0.0;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: FIRE_EXTINGUISHER damaged");
#endif
break;
}
case DYNAMICS_DAMAGE_UNDERCARRIAGE:
{
damage_level += 0.1;
#if DYNAMICS_DEBUG
debug_log ("DYNAMICS: UNDERCARRIAGE damaged");
#endif
break;
}
default:
{
debug_fatal ("DYNAMICS: unknown damage %d", this_damage);
}
}
}
this_damage = this_damage << 1;
}
damage_level = bound (damage_level, 0.0, 0.9);
damage_level = 1.0 - damage_level;
damage_level *= get_local_entity_int_value (en, INT_TYPE_INITIAL_DAMAGE_LEVEL);
set_client_server_entity_int_value (en, INT_TYPE_DAMAGE_LEVEL, damage_level);
}
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 void damage_systems (apache_damage_flags damage)
{
entity
*en;
en = get_gunship_entity ();
////////////////////////////////////////
if (damage.radar)
{
if (!apache_damage.radar)
{
apache_damage.radar = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("RADAR FAILURE", "", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_RADAR_FAILURE);
if
(
(target_acquisition_system == TARGET_ACQUISITION_SYSTEM_GROUND_RADAR) ||
(target_acquisition_system == TARGET_ACQUISITION_SYSTEM_AIR_RADAR)
)
{
select_apache_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
////////////////////////////////////////
if (damage.flir)
{
if (!apache_damage.flir)
{
apache_damage.flir = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("FLIR FAILURE", "", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_FLIR_FAILURE);
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_FLIR)
{
select_apache_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
////////////////////////////////////////
if (damage.dtv)
{
if (!apache_damage.dtv)
{
apache_damage.dtv = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("DTV FAILURE", "", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_DTV_FAILURE);
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_DTV)
{
select_apache_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
////////////////////////////////////////
if (damage.dvo)
{
if (!apache_damage.dvo)
{
apache_damage.dvo = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("DVO FAILURE", "", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_DVO_FAILURE);
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_DVO)
{
select_apache_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
////////////////////////////////////////
if (damage.laser_designator)
{
if (!apache_damage.laser_designator)
{
apache_damage.laser_designator = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("LASER DESIG", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_LASER_DESIGNATOR_FAILURE);
}
}
////////////////////////////////////////
if (damage.radar_jammer)
{
if (!apache_damage.radar_jammer)
{
apache_damage.radar_jammer = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("RADAR JAMMER", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_RADAR_JAMMER_FAILURE);
if (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_RADAR_JAMMER_ON))
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_RADAR_JAMMER_ON, FALSE);
}
}
}
////////////////////////////////////////
if (damage.infra_red_jammer)
{
if (!apache_damage.infra_red_jammer)
{
apache_damage.infra_red_jammer = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("IR JAMMER", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_IR_JAMMER_FAILURE);
if (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON))
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON, FALSE);
}
}
}
////////////////////////////////////////
if (damage.navigation_computer)
{
if (!apache_damage.navigation_computer)
{
apache_damage.navigation_computer = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("NAV COMPUTER", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_NAV_COMPUTER_FAILURE);
}
}
////////////////////////////////////////
if (damage.communications)
{
if (!apache_damage.communications)
{
apache_damage.communications = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("COMMS FAILURE", "", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_COMMS_FAILURE);
}
}
////////////////////////////////////////
if (damage.radar_warning_system)
{
if (!apache_damage.radar_warning_system)
{
apache_damage.radar_warning_system = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("RADAR WARNING", "FAILURE", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_RADAR_WARNING_FAILURE);
}
}
////////////////////////////////////////
if (!get_global_simple_avionics ())
{
if (damage.ihadss)
{
if (!apache_damage.ihadss)
{
apache_damage.ihadss = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("IHADSS FAILURE", "", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_IHADSS_FAILURE);
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_IHADSS)
{
select_apache_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
}
////////////////////////////////////////
if (damage.lh_mfd)
{
if (!apache_damage.lh_mfd)
{
apache_damage.lh_mfd = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("MFD FAILURE", "", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_MFD_FAILURE);
select_apache_mfd_mode (MFD_MODE_DAMAGED, MFD_LOCATION_LHS);
}
}
////////////////////////////////////////
if (damage.rh_mfd)
{
if (!apache_damage.rh_mfd)
{
apache_damage.rh_mfd = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("MFD FAILURE", "", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_MFD_FAILURE);
select_apache_mfd_mode (MFD_MODE_DAMAGED, MFD_LOCATION_RHS);
}
}
////////////////////////////////////////
if (damage.pnvs)
{
if (!apache_damage.pnvs)
{
apache_damage.pnvs = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("PNVS FAILURE", "", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_PNVS_FAILURE);
night_vision_system_active = FALSE;
}
}
////////////////////////////////////////
if (damage.gun_jammed)
{
if (!apache_damage.gun_jammed)
{
apache_damage.gun_jammed = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("GUN JAMMED", "", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_GUN_JAMMED);
}
}
////////////////////////////////////////
if (damage.lh_wing_tip_mount)
{
if (!apache_damage.lh_wing_tip_mount)
{
apache_damage.lh_wing_tip_mount = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("HARDPOINT", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.lh_outer_pylon)
{
if (!apache_damage.lh_outer_pylon)
{
apache_damage.lh_outer_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("HARDPOINT", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.lh_inner_pylon)
{
if (!apache_damage.lh_inner_pylon)
{
apache_damage.lh_inner_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("HARDPOINT", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.rh_wing_tip_mount)
{
if (!apache_damage.rh_wing_tip_mount)
{
apache_damage.rh_wing_tip_mount = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("HARDPOINT", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.rh_outer_pylon)
{
if (!apache_damage.rh_outer_pylon)
{
apache_damage.rh_outer_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("HARDPOINT", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.rh_inner_pylon)
{
if (!apache_damage.rh_inner_pylon)
{
apache_damage.rh_inner_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("HARDPOINT", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.chaff_dispenser)
{
if (!apache_damage.chaff_dispenser)
{
apache_damage.chaff_dispenser = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("CHAFF DISPNSR", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_CHAFF_DISPENSER_DAMAGED);
}
}
////////////////////////////////////////
if (damage.flare_dispenser)
{
if (!apache_damage.flare_dispenser)
{
apache_damage.flare_dispenser = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_apache_upfront_display_text ("FLARE DISPNSR", "DAMAGED", NULL, NULL);
play_client_server_warning_message (en, SPEECH_SYSTEM_FLARE_DISPENSER_DAMAGED);
}
}
////////////////////////////////////////
set_apache_weapon_damage_status ();
}
int assign_primary_task_to_group (entity *group_en, entity *task_en)
{
entity_sub_types
task_type,
group_type;
entity
*force,
*keysite;
int
side,
formation,
air_threat,
enemy_sectors;
unsigned int
threat;
ASSERT (get_comms_model () == COMMS_MODEL_SERVER);
task_type = get_local_entity_int_value (task_en, INT_TYPE_ENTITY_SUB_TYPE);
ASSERT (task_database [task_type].primary_task);
group_type = get_local_entity_int_value (group_en, INT_TYPE_ENTITY_SUB_TYPE);
ASSERT (!get_local_group_primary_task (group_en));
if (assign_task_to_group (group_en, task_en, TASK_ASSIGN_ALL_MEMBERS))
{
//
// set default group formation
//
formation = get_local_entity_int_value (group_en, INT_TYPE_GROUP_DEFAULT_FORMATION);
if (formation != get_local_entity_int_value (group_en, INT_TYPE_GROUP_FORMATION))
{
set_client_server_entity_int_value (group_en, INT_TYPE_GROUP_FORMATION, formation);
}
//
// Link to new keysite
//
if (get_local_entity_int_value (group_en, INT_TYPE_GROUP_LIST_TYPE) == LIST_TYPE_KEYSITE_GROUP)
{
keysite = ( entity * ) get_local_entity_ptr_value (task_en, PTR_TYPE_RETURN_KEYSITE);
if (keysite)
{
set_client_server_entity_parent (group_en, LIST_TYPE_KEYSITE_GROUP, keysite);
}
}
//
// Notify Force
//
side = get_local_entity_int_value (group_en, INT_TYPE_SIDE);
force = get_local_force_entity ( ( entity_sides ) side );
ASSERT (force);
notify_local_entity (ENTITY_MESSAGE_TASK_ASSIGNED, force, task_en);
//
// Assess for Escort task
//
if (task_database [task_type].escort_required_threshold != ESCORT_NEVER)
{
threat = assess_task_difficulty (task_en, &air_threat, &enemy_sectors);
#if DEBUG_ESCORT_TASK_CREATION
debug_filtered_log ("(ASSIGN) Side %s: Assigned %s to %s, objective %s",
entity_side_short_names [side],
get_local_entity_string (group_en, STRING_TYPE_FULL_NAME),
get_local_entity_string (task_en, STRING_TYPE_FULL_NAME),
get_task_objective_string (task_en)
);
debug_filtered_log ("Threat: %d (air_threat: %d, enemy_sectors: %d) - Threshold %d",
threat, air_threat, enemy_sectors,
task_database [task_type].escort_required_threshold);
#endif
if (threat >= task_database [task_type].escort_required_threshold)
{
create_escort_task (group_en, (threat >= ESCORT_CRITICAL), task_database [ENTITY_SUB_TYPE_TASK_ESCORT].task_priority, NULL, NULL);
ai_log ("(ASSIGN) Created Escort Task for %s :- Threat %d / Threshold %d",
get_local_entity_string (task_en, STRING_TYPE_FULL_NAME),
threat,
task_database [task_type].escort_required_threshold
);
}
}
//
// Store Start Time
//
set_client_server_entity_float_value (task_en, FLOAT_TYPE_START_TIME, get_local_entity_float_value (get_session_entity (), FLOAT_TYPE_ELAPSED_TIME));
//
// Clear Expire Timer (now also used for destroying completed tasks)
//
set_local_entity_float_value (task_en, FLOAT_TYPE_EXPIRE_TIMER, 0.0);
ai_log ("(ASSIGN) Side %s: Assigned %s (%d) to %s (%d) - Priority %f",
entity_side_short_names [side],
get_local_entity_string (group_en, STRING_TYPE_FULL_NAME),
get_local_entity_safe_index (group_en),
get_local_entity_string (task_en, STRING_TYPE_FULL_NAME),
get_local_entity_safe_index (task_en),
get_local_entity_float_value (task_en, FLOAT_TYPE_TASK_PRIORITY));
return TRUE;
}
return FALSE;
}
void create_client_server_entity_weapon (entity *launcher, entity_sub_types weapon_sub_type, int weapon_index, int burst_size, int *smoke_trail_indices)
{
entity
*force,
*target,
*weapon;
meta_smoke_list_types
smoke_trail_type;
int
i,
num_smoke_trail_entities,
valid_sound_effect,
current_weapon_count,
new_weapon_count;
ASSERT (launcher);
ASSERT (entity_sub_type_weapon_valid (weapon_sub_type));
//
// get target
//
if (!(weapon_database[weapon_sub_type].weapon_class & (WEAPON_CLASS_DECOY | WEAPON_CLASS_CARGO | WEAPON_CLASS_DEBRIS)))
{
target = get_local_entity_parent (launcher, LIST_TYPE_TARGET);
/* if (weapon_database[weapon_sub_type].hellfire_flight_profile)
{
if (get_local_entity_int_value (launcher, INT_TYPE_LOCK_ON_AFTER_LAUNCH))
{
target = NULL;
}
} */
}
else
{
target = NULL;
}
if (get_comms_model () == COMMS_MODEL_SERVER)
{
////////////////////////////////////////
//
// SERVER/TX and SERVER/RX
//
////////////////////////////////////////
ASSERT (weapon_index == ENTITY_INDEX_DONT_CARE);
ASSERT (burst_size == BURST_SIZE_DONT_CARE);
ASSERT (!smoke_trail_indices);
// NOTE: The clients' weapon counters lag the servers' so it is possible that the
// client may unknowingly attempt to create more weapons than are available.
// This is prone to happen during rapid firing.
current_weapon_count = get_local_entity_weapon_count (launcher, weapon_sub_type);
if (current_weapon_count > 0)
{
int loal_mode = weapon_database[weapon_sub_type].hellfire_flight_profile && get_local_entity_int_value (launcher, INT_TYPE_LOCK_ON_AFTER_LAUNCH);
if (get_comms_data_flow () == COMMS_DATA_FLOW_RX)
{
set_force_local_entity_create_stack_attributes (TRUE);
}
//
// get burst size wrt rate of fire
//
if (weapon_database[weapon_sub_type].rate_of_fire != FIRE_SINGLE_WEAPON)
{
float time_per_shot = weapon_database[weapon_sub_type].inverse_rate_of_fire * ONE_MINUTE;
unsigned int* last_shot = NULL;
switch (launcher->type)
{
case ENTITY_TYPE_HELICOPTER:
last_shot = &((helicopter*)get_local_entity_data(launcher))->ac.weapon_salvo_timer;
break;
case ENTITY_TYPE_FIXED_WING:
last_shot = &((fixed_wing*)get_local_entity_data(launcher))->ac.weapon_salvo_timer;
break;
case ENTITY_TYPE_ANTI_AIRCRAFT:
last_shot = &((anti_aircraft*)get_local_entity_data(launcher))->vh.weapon_salvo_timer;
break;
case ENTITY_TYPE_PERSON:
last_shot = &((person*)get_local_entity_data(launcher))->vh.weapon_salvo_timer;
break;
case ENTITY_TYPE_ROUTED_VEHICLE:
last_shot = &((routed_vehicle*)get_local_entity_data(launcher))->vh.weapon_salvo_timer;
break;
case ENTITY_TYPE_SHIP_VEHICLE:
last_shot = &((ship_vehicle*)get_local_entity_data(launcher))->vh.weapon_salvo_timer;
break;
}
if (last_shot)
{
unsigned int current_time = get_system_time();
float elapsed_time = 1;
if (*last_shot > 0)
{
if (current_time < *last_shot)
return;
elapsed_time = (current_time - *last_shot) * 0.001;
}
else
elapsed_time = get_delta_time();
burst_size = (int)(weapon_database[weapon_sub_type].rate_of_fire * ONE_OVER_ONE_MINUTE * elapsed_time);
if (burst_size < 1)
{
if (*last_shot == 0) // first shot in salvo always get fired
burst_size = 1;
else
return;
}
if (*last_shot)
*last_shot += (int)(burst_size * time_per_shot * 1000.0);
else
*last_shot = current_time;
}
else
{
ASSERT(FALSE);
burst_size = 1;
}
}
else
{
burst_size = 1;
}
//
// set burst timer
//
valid_sound_effect = FALSE;
if (get_local_entity_float_value (launcher, FLOAT_TYPE_WEAPON_BURST_TIMER) == 0.0)
{
set_local_entity_float_value (launcher, FLOAT_TYPE_WEAPON_BURST_TIMER, weapon_database[weapon_sub_type].burst_duration);
valid_sound_effect = TRUE;
}
//
// create weapon
//
weapon = create_local_entity
(
ENTITY_TYPE_WEAPON,
ENTITY_INDEX_DONT_CARE,
ENTITY_ATTR_INT_VALUE (INT_TYPE_ENTITY_SUB_TYPE, weapon_sub_type),
ENTITY_ATTR_INT_VALUE (INT_TYPE_WEAPON_BURST_SIZE, burst_size),
ENTITY_ATTR_INT_VALUE (INT_TYPE_WEAPON_MISSILE_PHASE, MISSILE_PHASE1),
ENTITY_ATTR_INT_VALUE (INT_TYPE_LOCK_ON_AFTER_LAUNCH, loal_mode),
ENTITY_ATTR_PARENT (LIST_TYPE_LAUNCHED_WEAPON, launcher),
ENTITY_ATTR_PARENT (LIST_TYPE_TARGET, target),
ENTITY_ATTR_END
);
if (weapon)
{
//
// send FIRE message to force (unless it's a decoy/cargo/debris being launched)
//
if ((target) && (!(weapon_database[weapon_sub_type].weapon_class & (WEAPON_CLASS_DECOY | WEAPON_CLASS_CARGO | WEAPON_CLASS_DEBRIS))))
{
force = get_local_force_entity ((entity_sides) get_local_entity_int_value (target, INT_TYPE_SIDE));
if (force)
{
notify_local_entity (ENTITY_MESSAGE_ENTITY_FIRED_AT, force, launcher, target);
}
}
//
// create sound effect(s)
//
if (valid_sound_effect)
{
create_weapon_launched_sound_effects (launcher, weapon_sub_type);
}
//
// create smoke trail
//
smoke_trail_type = (meta_smoke_list_types) get_local_entity_int_value (weapon, INT_TYPE_WEAPON_SMOKE_TRAIL_TYPE);
if (smoke_trail_type != META_SMOKE_LIST_TYPE_NONE)
{
struct OBJECT_3D_BOUNDS
*bounding_box;
vec3d
exhaust_offset;
num_smoke_trail_entities = count_entities_in_meta_smoke_list (smoke_trail_type);
ASSERT (num_smoke_trail_entities > 0);
smoke_trail_indices = (int *) malloc_fast_mem (sizeof (int) * num_smoke_trail_entities);
for (i = 0; i < num_smoke_trail_entities; i++)
{
smoke_trail_indices[i] = ENTITY_INDEX_DONT_CARE;
}
bounding_box = get_object_3d_bounding_box (get_local_entity_int_value (weapon, INT_TYPE_DEFAULT_3D_SHAPE));
if ((weapon_sub_type == ENTITY_SUB_TYPE_WEAPON_HOKUM_PILOT) ||(weapon_sub_type == ENTITY_SUB_TYPE_WEAPON_HOKUM_CO_PILOT))
{
exhaust_offset.x = 0.0;
exhaust_offset.y = 0.0;
exhaust_offset.z = 0.0;
}
else
{
exhaust_offset.x = 0.0;
exhaust_offset.y = 0.0;
exhaust_offset.z = bounding_box->zmin;
}
create_meta_smoke_list_specified_offset (smoke_trail_type, weapon, &exhaust_offset, smoke_trail_indices);
}
transmit_entity_comms_message
(
ENTITY_COMMS_CREATE_WEAPON,
NULL,
launcher,
weapon_sub_type,
get_local_entity_safe_index (weapon),
burst_size,
smoke_trail_indices
);
if (smoke_trail_indices)
{
free_mem (smoke_trail_indices);
}
//
// out of weapons (if infinite weapons then reload else select next weapon)
//
new_weapon_count = get_local_entity_weapon_count (launcher, weapon_sub_type);
if (new_weapon_count <= 0)
{
#if !DEMO_VERSION
if (get_local_entity_int_value (get_session_entity (), INT_TYPE_INFINITE_WEAPONS))
{
weapon_config_types
config_type;
config_type = (weapon_config_types) get_local_entity_int_value (launcher, INT_TYPE_WEAPON_CONFIG_TYPE);
set_client_server_entity_int_value (launcher, INT_TYPE_WEAPON_CONFIG_TYPE, config_type);
}
else
#endif
{
//
// play weapon out of ammo speech
//
play_entity_weapon_out_speech (launcher, weapon_sub_type);
//
// select next weapon
//
/*
if (!(weapon_database[weapon_sub_type].weapon_class & (WEAPON_CLASS_DECOY | WEAPON_CLASS_CARGO | WEAPON_CLASS_DEBRIS)))
{
entity_sub_types
next_weapon_sub_type;
if (get_local_entity_int_value (launcher, INT_TYPE_PLAYER) != ENTITY_PLAYER_AI)
{
next_weapon_sub_type = get_next_available_weapon_sub_type (launcher);
}
else
{
next_weapon_sub_type = ENTITY_SUB_TYPE_WEAPON_NO_WEAPON;
}
set_client_server_entity_int_value (launcher, INT_TYPE_SELECTED_WEAPON, next_weapon_sub_type);
}
*/
}
}
else
{
int
report_ammo_low_count;
report_ammo_low_count = weapon_database[weapon_sub_type].report_ammo_low_count;
if ((current_weapon_count > report_ammo_low_count) && (new_weapon_count <= report_ammo_low_count))
{
//
// play weapon low speech
//
play_entity_weapon_low_speech (launcher, weapon_sub_type);
}
else
{
//
// weapon launch speech
//
play_entity_weapon_launched_speech (launcher, weapon_sub_type);
}
}
}
set_force_local_entity_create_stack_attributes (FALSE);
}
else
{
pause_client_server_continuous_weapon_sound_effect (launcher, weapon_sub_type);
}
}
else
{
if (get_comms_data_flow () == COMMS_DATA_FLOW_TX)
{
////////////////////////////////////////
//
// CLIENT/TX
//
////////////////////////////////////////
ASSERT (weapon_index == ENTITY_INDEX_DONT_CARE);
ASSERT (burst_size == BURST_SIZE_DONT_CARE);
ASSERT (!smoke_trail_indices);
// NOTE: The clients' weapon counters lag the servers' so it is possible that the
// client may unknowingly attempt to create more weapons than are available.
// This is prone to happen during rapid firing.
if (get_local_entity_weapon_available (launcher, weapon_sub_type))
{
transmit_entity_comms_message
(
ENTITY_COMMS_CREATE_WEAPON,
NULL,
launcher,
weapon_sub_type,
ENTITY_INDEX_DONT_CARE,
burst_size,
NULL
);
}
}
else
{
////////////////////////////////////////
//
// CLIENT/RX
//
////////////////////////////////////////
ASSERT (weapon_index != ENTITY_INDEX_DONT_CARE);
ASSERT (burst_size > 0);
set_force_local_entity_create_stack_attributes (TRUE);
weapon = create_local_entity
(
ENTITY_TYPE_WEAPON,
weapon_index,
ENTITY_ATTR_INT_VALUE (INT_TYPE_ENTITY_SUB_TYPE, weapon_sub_type),
ENTITY_ATTR_INT_VALUE (INT_TYPE_WEAPON_BURST_SIZE, burst_size),
ENTITY_ATTR_PARENT (LIST_TYPE_LAUNCHED_WEAPON, launcher),
ENTITY_ATTR_PARENT (LIST_TYPE_TARGET, target),
ENTITY_ATTR_END
);
ASSERT (weapon);
//
// create smoke trail
//
smoke_trail_type = (meta_smoke_list_types) get_local_entity_int_value (weapon, INT_TYPE_WEAPON_SMOKE_TRAIL_TYPE);
if (smoke_trail_type != META_SMOKE_LIST_TYPE_NONE)
{
struct OBJECT_3D_BOUNDS
*bounding_box;
vec3d
exhaust_offset;
ASSERT (smoke_trail_indices);
bounding_box = get_object_3d_bounding_box (get_local_entity_int_value (weapon, INT_TYPE_DEFAULT_3D_SHAPE));
if ((weapon_sub_type == ENTITY_SUB_TYPE_WEAPON_HOKUM_PILOT) ||(weapon_sub_type == ENTITY_SUB_TYPE_WEAPON_HOKUM_CO_PILOT))
{
exhaust_offset.x = 0.0;
exhaust_offset.y = 0.0;
exhaust_offset.z = 0.0;
}
else
{
exhaust_offset.x = 0.0;
exhaust_offset.y = 0.0;
exhaust_offset.z = bounding_box->zmin;
}
create_meta_smoke_list_specified_offset (smoke_trail_type, weapon, &exhaust_offset, smoke_trail_indices);
}
else
{
ASSERT (!smoke_trail_indices);
}
set_force_local_entity_create_stack_attributes (FALSE);
}
}
}
void comms_process_data (void)
{
session_list_data_type
*current_session;
connection_list_type
*this_connection,
*connection;
char
*received_data;
int
planner_event,
frame_id,
packet_id,
receive_flag,
received_size;
GUID
received_id = 0;
entity
*member;
send_types
send_type;
packet_types
type;
// receive all packets in queue
current_session = get_current_game_session ();
received_size = MAX_RECEIVE_SIZE;
connection = get_connection_list_head ();
while (connection)
{
this_connection = connection;
connection = connection->next;
send_type = SEND_TYPE_GROUP;
while (send_type >= SEND_TYPE_PERSONAL)
{
receive_flag = TRUE;
while (receive_flag)
{
type = process_packet_list (send_type, this_connection, &received_id, &received_data, &received_size);
switch (type)
{
///////////////////////////////////////////////////////////////////////////////////////////////
//
// System packets, used internally
//
///////////////////////////////////////////////////////////////////////////////////////////////
case PACKET_TYPE_INVALID:
{
receive_flag = FALSE;
if (get_comms_model () == COMMS_MODEL_SERVER)
{
if (this_connection->packet_rerequested > command_line_comms_packet_rerequest_limit)
{
debug_log ("COMM_MAN: REJECTING CONNECTION. CONNECTION TOO BAD (re-request limit %d reached)", command_line_comms_packet_rerequest_limit);
send_packet (this_connection->connection_id, PACKET_TYPE_SERVER_REJECTED, NULL, 0, SEND_TYPE_PERSONAL);
}
}
break;
}
case PACKET_TYPE_RESEND_PACKET:
{
send_types
resend_send_type;
frame_id = get_list_item (received_data, int);
packet_id = get_list_item (received_data, int);
resend_send_type = get_list_item (received_data, send_types);
#if DEBUG_MODULE
if (this_connection->pilot_entity)
{
debug_log ("COMMS MAN: received RESEND PACKET for frame %d packet %d from %s (dpid %d)",
frame_id, packet_id,
get_local_entity_string (this_connection->pilot_entity, STRING_TYPE_PILOTS_NAME),
received_id);
}
else
{
debug_log ("COMMS MAN: received RESEND PACKET by unknown (pdid %d)",
received_id);
}
#endif
resend_packet (received_id, frame_id, packet_id, resend_send_type);
break;
}
///////////////////////////////////////////////////////////////////////////////////////////////
//
// Packets for initialisation and joining
//
///////////////////////////////////////////////////////////////////////////////////////////////
case PACKET_TYPE_SESSION_QUERY:
{
char
*ptr;
int
server_version_number,
player_count,
size;
connection_list_type
*new_connection;
if (get_comms_model () == COMMS_MODEL_SERVER)
{
#if DEBUG_MODULE
if (this_connection->pilot_entity)
{
debug_log ("COMMS MAN: RECEIVED SESSION QUERY from %s (dpid %d)",
get_local_entity_string (this_connection->pilot_entity, STRING_TYPE_PILOTS_NAME),
received_id);
}
else
{
debug_log ("COMMS MAN: RECEIVED SESSION QUERY from %d", received_id);
}
#endif
new_connection = get_connection_list_item (received_id);
if (!new_connection->already_sent_query_data)
{
new_connection->already_sent_query_data = TRUE;
while (TRUE)
{
ptr = new_connection->connection_receive_buffer;
size = 0;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Check both client and server are running same campaign data
//
server_version_number = get_local_entity_int_value (get_session_entity (), INT_TYPE_VERSION_NUMBER);
quick_set_list_item (ptr, int, server_version_number);
size += sizeof (int);
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// map details
quick_set_list_item (ptr, int, NUM_MAP_X_SECTORS);
quick_set_list_item (ptr, int, NUM_MAP_Z_SECTORS);
quick_set_list_item (ptr, int, SECTOR_SIDE_LENGTH);
size += sizeof (int) * 3;
// data path
strcpy (ptr, current_session->data_path);
ptr += strlen (current_session->data_path) + 1;
size += strlen (current_session->data_path) + 1;
// population_placement filename
if (population_placement_filename)
{
strcpy (ptr, population_placement_filename);
ptr += strlen (population_placement_filename) + 1;
size += strlen (population_placement_filename) + 1;
}
else
{
strcpy (ptr, "\0");
ptr += strlen ("\0") + 1;
size += strlen ("\0") + 1;
}
//
// side_data filename
if (side_data_filename)
{
strcpy (ptr, side_data_filename);
ptr += strlen (side_data_filename) + 1;
size += strlen (side_data_filename) + 1;
}
else
{
strcpy (ptr, "\0");
ptr += strlen ("\0") + 1;
size += strlen ("\0") + 1;
}
// campaign_population filename
if (campaign_population_filename)
{
strcpy (ptr, campaign_population_filename);
ptr += strlen (campaign_population_filename) + 1;
size += strlen (campaign_population_filename) + 1;
}
else
{
strcpy (ptr, "\0");
ptr += strlen ("\0") + 1;
size += strlen ("\0") + 1;
}
//
// planner position and zoom
//
// quick_set_list_item (ptr, float, planner_map_data.centre_map_x);
// quick_set_list_item (ptr, float, planner_map_data.centre_map_z);
// size += sizeof (float) * 2;
// quick_set_list_item (ptr, int, planner_map_data.map_zoom);
// size += sizeof (int);
//
// Pilots
//
player_count = get_number_of_connected_players ();
quick_set_list_item (ptr, int, player_count);
size += sizeof (int);
//
//
//
#if DEBUG_MODULE
debug_log ("COMM_MAN: sending data path %s, population placement %s, side data %s, campaign_pop file %s",
current_session->data_path, population_placement_filename, side_data_filename, campaign_population_filename);
#endif
new_connection->connection_receive_buffer_size -= size;
if (!pack_session (ptr, &new_connection->connection_receive_buffer_size, PACK_MODE_BROWSE_SESSION))
{
break;
}
new_connection->connection_receive_buffer_size *= 2;
#if DEBUG_MODULE
debug_log ("COMMS MAN: Browse: connection_receive_buffer too small, mallocing to %d", new_connection->connection_receive_buffer_size);
#endif
free_mem (new_connection->connection_receive_buffer);
new_connection->connection_receive_buffer = malloc_heap_mem (new_connection->connection_receive_buffer_size);
}
//
//
//
send_packet (received_id, PACKET_TYPE_SESSION_INFO, new_connection->connection_receive_buffer, new_connection->connection_receive_buffer_size + size, SEND_TYPE_PERSONAL);
/*
{
FILE
*test_ptr;
test_ptr = fopen ("out.txt", "wb");
fwrite (new_connection->connection_receive_buffer, 1, new_connection->connection_receive_buffer_size + size, test_ptr);
fclose (test_ptr);
}
*/
}
else
{
debug_log ("COMM_MAN: not resending query data");
}
}
break;
}
case PACKET_TYPE_CONNECTION_VALIDATION:
{
debug_log ("COMM_MAN: received CONNECTION_VALIDATION, sending RESPONSE");
send_packet (received_id, PACKET_TYPE_CONNECTION_RESPONSE, NULL, 0, SEND_TYPE_PERSONAL);
break;
}
case PACKET_TYPE_CONNECTION_RESPONSE:
{
connection_list_type
*connection;
connection = get_connection_list_item (received_id);
connection->validation_count = 0;
debug_log ("COMM_MAN: received CONNECTION_RESPONSE, connection still alive");
break;
}
case PACKET_TYPE_SESSION_INFO:
{
entity
*force,
*pilot;
int
client_version_number,
server_version_number;
int
size,
x_size,
z_size,
sector_size,
player_count,
loop;
char
*ptr,
warzone_ffp_filename [256],
temp_campaign_population_filename [256],
temp_population_placement_filename [256],
temp_side_data_filename [256],
buffer [128];
session_data = FALSE;
reinitialise_entity_system ();
ptr = received_data;
size = 0;
set_ui_object_redraw (gunships_screen, TRUE);
ui_force_update ();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Check both client and server are running same campaign data
//
client_version_number = get_global_version_number ();
server_version_number = get_list_item (ptr, int);
size += sizeof (int);
if (client_version_number != server_version_number)
{
debug_fatal ("COMM_MAN: Incorrect version. Server Version No. %d, Client Version No. %d", server_version_number, client_version_number);
}
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// map details
x_size = get_list_item (ptr, int);
z_size = get_list_item (ptr, int);
sector_size = get_list_item (ptr, int);
size += (sizeof (int) * 3);
set_entity_world_map_size (x_size, z_size, sector_size);
// data path
strncpy (current_session->data_path, ptr, sizeof (current_session->data_path));
ptr += strlen (current_session->data_path) + 1;
size += strlen (current_session->data_path) + 1;
// population_placement_filename
strncpy (temp_population_placement_filename, ptr, sizeof (temp_population_placement_filename));
ptr += strlen (temp_population_placement_filename) + 1;
size += strlen (temp_population_placement_filename) + 1;
if (population_placement_filename)
{
free_mem (population_placement_filename);
}
if (strlen (temp_population_placement_filename) > 0)
{
population_placement_filename = (char *) malloc_heap_mem (strlen (temp_population_placement_filename) + 1);
sprintf (population_placement_filename, "%s", temp_population_placement_filename);
}
else
{
population_placement_filename = NULL;
}
// side_data filename
strncpy (temp_side_data_filename, ptr, sizeof (temp_side_data_filename));
ptr += strlen (temp_side_data_filename) + 1;
size += strlen (temp_side_data_filename) + 1;
if (side_data_filename)
{
free_mem (side_data_filename);
}
if (strlen (temp_side_data_filename) > 0)
{
side_data_filename = (char *) malloc_heap_mem (strlen (temp_side_data_filename) + 1);
sprintf (side_data_filename, "%s", temp_side_data_filename);
}
else
{
side_data_filename = NULL;
}
// campaign_population_filename
strncpy (temp_campaign_population_filename, ptr, sizeof (temp_campaign_population_filename));
ptr += strlen (temp_campaign_population_filename) + 1;
size += strlen (temp_campaign_population_filename) + 1;
if (campaign_population_filename)
{
free_mem (campaign_population_filename);
}
if (strlen (temp_campaign_population_filename) > 0)
{
campaign_population_filename = (char *) malloc_heap_mem (strlen (temp_campaign_population_filename) + 1);
sprintf (campaign_population_filename, "%s", temp_campaign_population_filename);
}
else
{
campaign_population_filename = NULL;
}
//
//
//
player_count = get_list_item (ptr, int);
size += sizeof (int);
//
//
//
received_size -= size;
#if DEBUG_MODULE
debug_log ("COMM_MAN: data path %s population placement filename %s, side data filename %s", current_session->data_path, population_placement_filename, side_data_filename);
debug_log ("COMM_MAN: campaign data path = %s", current_session->data_path);
#endif
//
// check we have the correct warzone locally
//
sprintf (warzone_ffp_filename, "%s\\terrain\\terrain.ffp", current_session->data_path);
if (!file_exist (warzone_ffp_filename))
{
add_to_pop_up_list_with_word_wrap (get_trans ("UNRECOGNISED_WARZONE"), session_info_list, NULL, 0, UI_FONT_ARIAL_10, sys_col_white);
//add_to_pop_up_list (get_trans ("Server using unrecognised warzone"), session_info_list, NULL, 0, UI_FONT_ARIAL_10, sys_col_white);
break;
}
//
//
//
create_local_only_entities (PACK_MODE_BROWSE_SESSION);
if (unpack_session (ptr, received_size, PACK_MODE_BROWSE_SESSION))
{
debug_fatal ("COMMS MAN: browse: received size overflow");
}
#if DEBUG_MODULE
if (this_connection->pilot_entity)
{
debug_log ("COMMS MAN: received SESSION INFO from %s (dpid %d) (setting server id)",
get_local_entity_string (this_connection->pilot_entity, STRING_TYPE_PILOTS_NAME),
received_id);
}
else
{
debug_log ("COMMS MAN: RECEIVED SESSION INFO from %d", received_id);
}
debug_log ("COMMS MAN: session info: time of day = %f",
get_local_entity_float_value (get_session_entity (), FLOAT_TYPE_TIME_OF_DAY));
debug_log ("COMMS MAN: map dimensions %d, %d, sector size %d", x_size, z_size, sector_size);
#endif
set_ui_object_drawable (session_screen_next_button, TRUE);
//
// Display game info
//
ui_object_destroy_list_items (session_info_list);
if (get_local_entity_int_value (get_session_entity (), INT_TYPE_CAMPAIGN_REQUIRES_APACHE_HAVOC))
{
// campaign requires apache havoc to be installed
// check it is...
if (!get_global_apache_havoc_installed ())
{
add_to_pop_up_list_with_word_wrap (get_trans ("REQUIRES_APACHE_HAVOC"), session_info_list, NULL, 0, UI_FONT_ARIAL_10, sys_col_white);
set_ui_object_drawable (session_screen_next_button, FALSE);
break;
}
}
loop = 3;
sprintf (buffer, "%s : %d", get_trans ("Players"), player_count);
add_to_pop_up_list_with_word_wrap (buffer, session_info_list, NULL, 0, UI_FONT_ARIAL_10, sys_col_white);
force = get_local_entity_first_child (get_session_entity (), LIST_TYPE_FORCE);
while (force)
{
pilot = get_local_entity_first_child (force, LIST_TYPE_PILOT);
while (pilot)
{
{
rgb_colour
col;
sprintf (buffer, "%2d ", loop - 2);
strncat (buffer, get_local_entity_string (pilot, STRING_TYPE_PILOTS_NAME), 64);
switch (get_local_entity_int_value (pilot, INT_TYPE_SIDE))
{
case ENTITY_SIDE_BLUE_FORCE:
{
col.r = 120;
col.g = 158;
col.b = 255;
col.a = 255;
break;
}
case ENTITY_SIDE_RED_FORCE:
{
col.r = 255;
col.g = 120;
col.b = 80;
col.a = 255;
break;
}
default:
{
col = ui_colour_white;
break;
}
}
add_to_pop_up_list_with_word_wrap (buffer, session_info_list, NULL, 0, UI_FONT_ARIAL_10, col);
loop ++;
}
pilot = get_local_entity_child_succ (pilot, LIST_TYPE_PILOT);
}
force = get_local_entity_child_succ (force, LIST_TYPE_FORCE);
}
set_server_id (received_id);
//
// destroy all entities created by browse info
//
reinitialise_entity_system ();
break;
}
case PACKET_TYPE_CLIENT_PILOT_REQUEST:
{
connection_list_type
*new_connection;
client_pilot_request_data
pilot_data;
entity
*new_pilot;
int
index;
ASSERT (get_comms_model () == COMMS_MODEL_SERVER);
// #if DEBUG_MODULE
debug_log ("COMMS MAN: RECEIVED PILOT REQUEST from %d", received_id);
// #endif
//
// unpack name
//
memcpy (&pilot_data, (client_pilot_request_data *) received_data, sizeof (client_pilot_request_data));
new_pilot = create_new_pilot_entity
(
pilot_data.name,
pilot_data.side,
pilot_data.rank,
pilot_data.sub_type,
pilot_data.unique_id,
pilot_data.difficulty
);
ASSERT (new_pilot);
index = get_local_entity_safe_index (new_pilot);
new_connection = get_connection_list_item (received_id);
transmit_entity_comms_message (ENTITY_COMMS_PILOT_REQUEST_ACCEPTED, NULL, received_id, index);
new_connection->pilot_entity = new_pilot;
break;
}
case PACKET_TYPE_CLIENT_GUNSHIP_REQUEST:
{
connection_list_type
*new_connection;
client_gunship_request_data
pilot_data;
int
index_number,
buffer [2];
if (get_comms_model () == COMMS_MODEL_SERVER)
{
// #if DEBUG_MODULE
if (this_connection->pilot_entity)
{
debug_log ("COMMS MAN: RECEIVED GUNSHIP REQUEST from %s (dpid %d)",
get_local_entity_string (this_connection->pilot_entity, STRING_TYPE_PILOTS_NAME),
received_id);
}
else
{
debug_log ("COMMS MAN: RECEIVED GUNSHIP REQUEST from %d", received_id);
}
// #endif
memcpy (&pilot_data, (client_gunship_request_data *) received_data, sizeof (client_gunship_request_data));
index_number = pilot_data.gunship_index;
ASSERT (index_number != ENTITY_INDEX_DONT_CARE);
member = get_local_entity_safe_ptr (index_number);
if (!member)
{
// #if DEBUG_MODULE
if (this_connection->pilot_entity)
{
debug_log ("COMMS MAN: REFUSING GUNSHIP FOR PLAYER %s (dpid %d) for helicopter %d",
get_local_entity_string (this_connection->pilot_entity, STRING_TYPE_PILOTS_NAME),
received_id, pilot_data.gunship_index);
}
else
{
debug_log ("COMMS MAN: Refusing gunship for player %d to helicopter %d", received_id, pilot_data.gunship_index);
}
// #endif
send_packet (received_id, PACKET_TYPE_GUNSHIP_REQUEST_REFUSED, NULL, 0, SEND_TYPE_PERSONAL);
break;
}
new_connection = get_connection_list_item (received_id);
//
// send acceptance
//
buffer [0] = index_number;
// #if DEBUG_MODULE
debug_log ("COMMS MAN: sending gunship request accepted for gunship %d pilot id %d", index_number, received_id);
// #endif
send_packet (received_id, PACKET_TYPE_GUNSHIP_REQUEST_ACCEPTED, (void *) &buffer, 4, SEND_TYPE_PERSONAL);
new_connection->gunship_number = pilot_data.gunship_index;
new_connection->gunship_entity = member;
}
break;
}
case PACKET_TYPE_CLIENT_CAMPAIGN_DATA_REQUEST:
{
connection_list_type
*new_connection;
int
index_number;
if (get_comms_model () == COMMS_MODEL_SERVER)
{
#if DEBUG_MODULE
if (this_connection->pilot_entity)
{
debug_log ("COMMS MAN: RECEIVED JOIN REQUEST by %s (dpid %d)",
get_local_entity_string (this_connection->pilot_entity, STRING_TYPE_PILOTS_NAME),
received_id);
}
else
{
debug_log ("COMMS MAN: received JOIN REQUEST by %d", received_id);
}
#endif
//
// flush group send buffer
//
send_comms_data ();
//
// pack mission data into packet
//
new_connection = get_connection_list_item (received_id);
//
// Store entity data
//
while (pack_session (new_connection->connection_receive_buffer, &new_connection->connection_receive_buffer_size, PACK_MODE_CLIENT_SESSION))
{
new_connection->connection_receive_buffer_size *= 2;
#if DEBUG_MODULE
debug_log ("COMMS MAN: Mission data: connection_receive_buffer too small, mallocing to %d", new_connection->connection_receive_buffer_size);
#endif
free_mem (new_connection->connection_receive_buffer);
new_connection->connection_receive_buffer = malloc_heap_mem (new_connection->connection_receive_buffer_size);
memset (new_connection->connection_receive_buffer, 0, new_connection->connection_receive_buffer_size);
}
// add frame id
index_number = get_group_frame_id ();
memcpy (&new_connection->connection_receive_buffer [new_connection->connection_receive_buffer_size], (void *) &index_number, sizeof (int));
new_connection->connection_receive_buffer_size += sizeof (int);
send_packet (received_id, PACKET_TYPE_MISSION_DATA, new_connection->connection_receive_buffer, new_connection->connection_receive_buffer_size, SEND_TYPE_PERSONAL);
memset (new_connection->connection_receive_buffer, 0, new_connection->connection_receive_buffer_size);
//
// send group frame id
//
SDL_Delay (100);
index_number = get_group_frame_id ();
//send_packet (received_id, PACKET_TYPE_FRAME_ID, (void *) &index_number, 4, SEND_TYPE_PERSONAL);
zero_average_pack_size ();
}
break;
}
case PACKET_TYPE_CLIENT_FRAME_ID:
{
int
loop1,
loop2,
index_number;
stub_packet_type
*stub_packet;
connection_list_type
*new_connection;
index_number = get_list_item (received_data, int);
new_connection = get_connection_list_item (received_id);
//#if DEBUG_MODULE
if (new_connection)
{
debug_log ("COMMS MAN: received CLIENT FRAME ID (%d) by %d %s", index_number, received_id, direct_play_get_player_name (received_id));
}
//#endif
//
// send all packets between when the client started to join and when it actually joined.
//
for (loop1 = index_number; loop1 < get_group_frame_id () - 1; loop1 ++)
{
//#if DEBUG_MODULE
debug_log ("COMMS MAN: sending packet %d frame %d to recently joined client", loop1, 0);
//#endif
stub_packet = resend_packet (received_id, loop1, 1, SEND_TYPE_GROUP);
ASSERT (stub_packet);
for (loop2 = 2; loop2 <= stub_packet->packet->number_of_packets; loop2 ++)
{
//#if DEBUG_MODULE
debug_log ("COMMS MAN: sending packet %d frame %d to recently joined client", loop1, loop2);
//#endif
stub_packet = resend_packet (received_id, loop1, loop2, SEND_TYPE_GROUP);
}
}
break;
}
case PACKET_TYPE_GUNSHIP_REQUEST_REFUSED:
{
// #if DEBUG_MODULE
debug_log ("COMMS MAN: Gunship refused");
// #endif
set_server_response (SERVER_RESPONSE_REFUSE);
break;
}
case PACKET_TYPE_GUNSHIP_REQUEST_ACCEPTED:
{
entity
*gunship;
int
index_number;
// #if DEBUG_MODULE
debug_log ("COMMS MAN: received GUNSHIP ACCEPTED by %d", received_id);
// #endif
//
// set gunship
//
index_number = get_list_item (received_data, int);
ASSERT (get_pilot_entity ());
gunship = get_local_entity_safe_ptr (index_number);
debug_filtered_log ("COMM_MAN: setting gunship");
planner_event = FALSE;
if (get_event_stack_head_function() == ingame_screen_set_events)
{
pop_event (ingame_screen_set_events);
planner_event = TRUE;
}
assign_entity_to_user (gunship);
if (planner_event)
{
push_event (ingame_screen_set_events, "ingame screen events");
}
debug_filtered_log ("COMM_MAN: gunship set");
////////////////////////////////////////////////////////////////////////
break;
}
case PACKET_TYPE_PILOT_REQUEST_ACCEPTED:
{
int
index_number;
ASSERT (get_comms_model () == COMMS_MODEL_CLIENT);
// #if DEBUG_MODULE
debug_log ("COMMS MAN: received PILOT ACCEPTED by %d", received_id);
// #endif
index_number = get_list_item (received_data, int);
set_pilot_entity (get_local_entity_safe_ptr (index_number));
break;
}
case PACKET_TYPE_MISSION_DATA:
{
#if DEBUG_MODULE
debug_log ("COMMS MAN: received MISSION DATA by %d", received_id);
#endif
set_mouse_graphic_off ();
//
// LOAD TERRAIN DATA
//
load_3d_terrain_game_data ();
initialise_population_name_database ();
load_route_data (); // might need to send what route filename to load...
//
// Initialise stuff
//
create_local_only_entities (PACK_MODE_CLIENT_SESSION);
/////////////////////////////////////////////////////////////////
if (strstr ((char*) stoupper (side_data_filename), "SID"))
{
read_sector_side_file (side_data_filename);
}
else if (strstr ((char*) stoupper (side_data_filename), "DAT"))
{
load_ai_sector_data (side_data_filename);
}
/////////////////////////////////////////////////////////////////
deinitialise_formation_database ();
initialise_formation_database ();
deinitialise_formation_component_database ();
initialise_formation_component_database ();
if (unpack_session (received_data, received_size - 4, PACK_MODE_CLIENT_SESSION))
{
debug_fatal ("COMMS MAN: received size overflow");
}
/*
force = get_local_entity_first_child (get_session_entity (), LIST_TYPE_FORCE);
while (force)
{
create_frontline (force);
force = get_local_entity_child_succ (force, LIST_TYPE_FORCE);
}
*/
{
int
index_number;
connection_list_type
*new_connection;
received_data += received_size - 4;
index_number = get_list_item (received_data, int);
new_connection = get_connection_list_item (received_id);
new_connection->receive_group_frame_id = index_number;
send_packet (get_server_id (), PACKET_TYPE_CLIENT_FRAME_ID, (void *) &index_number, 4, SEND_TYPE_PERSONAL);
}
session_data = TRUE;
//direct_play_join_group ();
set_gunship_waiting_for_connection ( FALSE );
zero_average_pack_size ();
set_mouse_graphic_on ();
break;
}
case PACKET_TYPE_FRAME_ID:
{
int
index_number;
connection_list_type
*new_connection;
index_number = get_list_item (received_data, int);
#if DEBUG_MODULE
debug_log ("COMMS MAN: received FRAME ID (%d) by %d", index_number, received_id);
#endif
new_connection = get_connection_list_item (received_id);
new_connection->receive_group_frame_id = index_number;
send_packet (get_server_id (), PACKET_TYPE_CLIENT_FRAME_ID, (void *) &index_number, 4, SEND_TYPE_PERSONAL);
break;
}
///////////////////////////////////////////////////////////////////////////////////////////////
//
// In game packets
//
///////////////////////////////////////////////////////////////////////////////////////////////
case PACKET_TYPE_AI_DATA:
{
int
//padding,
data_size;
#if DEBUG_MODULE >= 2
debug_log ("COMMS MAN: received AI DATA by %d", received_id);
#endif
if (get_comms_model () == COMMS_MODEL_CLIENT)
{
ASSERT (session_data);
}
data_size = get_list_item (received_data, int);
//debug
//padding = get_list_item (received_data, int);
//end
open_unpack_buffer (received_data, received_size);
process_received_entity_comms_messages ();
ASSERT (!get_unpack_buffer_overflow ());
close_unpack_buffer ();
//debug
//padding = get_list_item (received_data, int);
//end
memset (received_data, 0, this_connection->connection_receive_buffer_size);
break;
}
case PACKET_TYPE_END_GAME:
{
debug_log ("COMMS MAN: received END GAME from %d", received_id);
if (get_comms_model () == COMMS_MODEL_SERVER)
{
if (this_connection->gunship_entity)
{
set_client_server_entity_int_value (this_connection->gunship_entity, INT_TYPE_PLAYER, ENTITY_PLAYER_AI);
}
if (this_connection->pilot_entity)
{
debug_log (" from %s ", get_local_entity_string (this_connection->pilot_entity, STRING_TYPE_PILOTS_NAME));
}
unregister_connection (received_id);
}
else
{
if (received_id == get_server_id ())
{
//setup_campaign_over_screen (get_local_force_entity (get_global_gunship_side ()), CAMPAIGN_RESULT_STALEMATE);
start_game_exit (GAME_EXIT_KICKOUT, FALSE);
}
}
receive_flag = FALSE;
break;
}
case PACKET_TYPE_SERVER_REJECTED:
{
debug_log ("COMMS MAN: received SERVER REJECTED (server id %d)", received_id);
//setup_campaign_over_screen (get_local_force_entity (get_global_gunship_side ()), CAMPAIGN_RESULT_SERVER_REJECTED);
start_game_exit (GAME_EXIT_KICKOUT, FALSE);
break;
}
default:
{
debug_fatal ("ERROR: Data Exchange, unknown packet type %d", type);
break;
}
}
}
send_type --;
}
}
}
void update_comanche_target_acquisition_system (void)
{
switch (target_acquisition_system)
{
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_OFF:
////////////////////////////////////////
{
target_locked = FALSE;
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_OFF);
slave_common_eo_to_current_target ();
slave_comanche_eo_to_current_target ();
break;
}
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_GROUND_RADAR:
////////////////////////////////////////
{
update_comanche_ground_radar ();
update_common_ground_radar ();
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_GROUND_RADAR);
slave_common_eo_to_current_target ();
slave_comanche_eo_to_current_target ();
break;
}
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_AIR_RADAR:
////////////////////////////////////////
{
update_comanche_air_radar ();
update_common_air_radar ();
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_AIR_RADAR);
slave_common_eo_to_current_target ();
slave_comanche_eo_to_current_target ();
break;
}
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_FLIR:
////////////////////////////////////////
{
update_comanche_eo (&comanche_flir);
update_common_eo ();
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_FLIR);
break;
}
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_DTV:
////////////////////////////////////////
{
update_comanche_eo (&comanche_dtv);
update_common_eo ();
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_DTV);
break;
}
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_DVO:
////////////////////////////////////////
{
update_comanche_eo (&comanche_dvo);
update_common_eo ();
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_DVO);
break;
}
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_HIDSS:
////////////////////////////////////////
{
update_comanche_hms ();
update_common_hms ();
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_HIDSS);
slave_common_eo_to_current_target ();
slave_comanche_eo_to_current_target ();
break;
}
}
////////////////////////////////////////
//
// radar / laser / los to target
//
////////////////////////////////////////
{
entity
*source,
*target;
int
radar_on,
laser_on,
los_to_target;
source = get_gunship_entity ();
target = get_local_entity_parent (source, LIST_TYPE_TARGET);
//
// radar on/off
//
radar_on = FALSE;
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_GROUND_RADAR)
{
if (ground_radar.sweep_mode != RADAR_SWEEP_MODE_SINGLE_INACTIVE)
{
radar_on = TRUE;
}
}
else if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_AIR_RADAR)
{
if (air_radar.sweep_mode != RADAR_SWEEP_MODE_SINGLE_INACTIVE)
{
radar_on = TRUE;
}
}
if (radar_on != get_local_entity_int_value (source, INT_TYPE_RADAR_ON))
{
set_client_server_entity_int_value (source, INT_TYPE_RADAR_ON, radar_on);
}
//
// laser on/off
//
laser_on = FALSE;
if (target_acquisition_system != TARGET_ACQUISITION_SYSTEM_OFF)
{
if (!comanche_damage.laser_designator)
{
laser_on = TRUE;
}
}
if (laser_on != get_local_entity_int_value (source, INT_TYPE_LASER_ON))
{
set_client_server_entity_int_value (source, INT_TYPE_LASER_ON, laser_on);
}
//
// line of sight to target
//
if (target)
{
switch (target_acquisition_system)
{
case TARGET_ACQUISITION_SYSTEM_OFF:
{
los_to_target = FALSE;
break;
}
case TARGET_ACQUISITION_SYSTEM_GROUND_RADAR:
case TARGET_ACQUISITION_SYSTEM_AIR_RADAR:
{
los_to_target = get_local_entity_int_value (target, INT_TYPE_GUNSHIP_RADAR_LOS_CLEAR);
break;
}
case TARGET_ACQUISITION_SYSTEM_FLIR:
case TARGET_ACQUISITION_SYSTEM_DTV:
case TARGET_ACQUISITION_SYSTEM_DVO:
{
los_to_target = TRUE;
break;
}
case TARGET_ACQUISITION_SYSTEM_HIDSS:
{
los_to_target = TRUE;
break;
}
}
}
else
{
los_to_target = FALSE;
}
if (los_to_target != get_local_entity_int_value (source, INT_TYPE_LOS_TO_TARGET))
{
set_client_server_entity_int_value (source, INT_TYPE_LOS_TO_TARGET, los_to_target);
}
}
}
void update_hokum_target_acquisition_system (void)
{
if (hokum_damage.helmet_mounted_sight)
{
if (hud_mode == HUD_MODE_WEAPON)
{
hud_mode = HUD_MODE_NAVIGATION;
}
}
switch (target_acquisition_system)
{
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_OFF:
////////////////////////////////////////
{
target_locked = FALSE;
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_OFF);
slave_common_eo_to_current_target ();
slave_hokum_eo_to_current_target ();
break;
}
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_GROUND_RADAR:
////////////////////////////////////////
{
update_hokum_ground_radar ();
update_common_ground_radar ();
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_GROUND_RADAR);
slave_common_eo_to_current_target ();
slave_hokum_eo_to_current_target ();
break;
}
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_AIR_RADAR:
////////////////////////////////////////
{
update_hokum_air_radar ();
update_common_air_radar ();
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_AIR_RADAR);
slave_common_eo_to_current_target ();
slave_hokum_eo_to_current_target ();
break;
}
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_FLIR:
////////////////////////////////////////
{
update_hokum_eo (&hokum_flir);
update_common_eo ();
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_FLIR);
break;
}
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_LLLTV:
////////////////////////////////////////
{
update_hokum_eo (&hokum_llltv);
update_common_eo ();
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_LLLTV);
break;
}
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_PERISCOPE:
////////////////////////////////////////
{
update_hokum_eo (&hokum_periscope);
update_common_eo ();
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_PERISCOPE);
break;
}
////////////////////////////////////////
case TARGET_ACQUISITION_SYSTEM_HMS:
////////////////////////////////////////
{
update_hokum_hms ();
update_common_hms ();
update_weapon_lock_type (TARGET_ACQUISITION_SYSTEM_HMS);
slave_common_eo_to_current_target ();
slave_hokum_eo_to_current_target ();
break;
}
}
////////////////////////////////////////
//
// radar / laser / los to target
//
////////////////////////////////////////
{
entity
*source,
*target;
int
radar_on,
laser_on,
los_to_target;
source = get_gunship_entity ();
target = get_local_entity_parent (source, LIST_TYPE_TARGET);
//
// radar on/off
//
radar_on = FALSE;
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_GROUND_RADAR)
{
if (ground_radar.sweep_mode != RADAR_SWEEP_MODE_SINGLE_INACTIVE)
{
radar_on = TRUE;
}
}
else if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_AIR_RADAR)
{
if (air_radar.sweep_mode != RADAR_SWEEP_MODE_SINGLE_INACTIVE)
{
radar_on = TRUE;
}
}
if (radar_on != get_local_entity_int_value (source, INT_TYPE_RADAR_ON))
{
set_client_server_entity_int_value (source, INT_TYPE_RADAR_ON, radar_on);
}
//
// laser on/off
//
laser_on = FALSE;
if (target_acquisition_system != TARGET_ACQUISITION_SYSTEM_OFF)
{
if (!hokum_damage.laser_designator)
{
laser_on = TRUE;
}
}
if (laser_on != get_local_entity_int_value (source, INT_TYPE_LASER_ON))
{
set_client_server_entity_int_value (source, INT_TYPE_LASER_ON, laser_on);
}
//
// line of sight to target
//
if (target)
{
switch (target_acquisition_system)
{
case TARGET_ACQUISITION_SYSTEM_OFF:
{
los_to_target = FALSE;
break;
}
case TARGET_ACQUISITION_SYSTEM_GROUND_RADAR:
case TARGET_ACQUISITION_SYSTEM_AIR_RADAR:
{
los_to_target = get_local_entity_int_value (target, INT_TYPE_GUNSHIP_RADAR_LOS_CLEAR);
break;
}
case TARGET_ACQUISITION_SYSTEM_FLIR:
case TARGET_ACQUISITION_SYSTEM_LLLTV:
case TARGET_ACQUISITION_SYSTEM_PERISCOPE:
{
los_to_target = TRUE;
break;
}
case TARGET_ACQUISITION_SYSTEM_HMS:
{
los_to_target = TRUE;
break;
}
}
}
else
{
los_to_target = FALSE;
}
if (los_to_target != get_local_entity_int_value (source, INT_TYPE_LOS_TO_TARGET))
{
set_client_server_entity_int_value (source, INT_TYPE_LOS_TO_TARGET, los_to_target);
}
}
}
static void damage_systems (ka50_damage_flags damage)
{
entity
*en;
en = get_gunship_entity ();
////////////////////////////////////////
if (damage.flir)
{
if (!ka50_damage.flir)
{
activate_ka50_master_caution ();
ka50_damage.flir = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("FLIR", "FAILURE", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_FLIR_FAILURE);
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_FLIR)
{
select_ka50_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
////////////////////////////////////////
if (damage.laser_designator)
{
if (!ka50_damage.laser_designator)
{
activate_ka50_master_caution ();
ka50_damage.laser_designator = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_laser_is_active(FALSE);
set_ka50_text_display_text ("LASER", "DESIGNATOR", "FAILURE");
play_client_server_warning_message (en, SPEECH_SYSTEM_LASER_DESIGNATOR_FAILURE);
}
}
////////////////////////////////////////
if (damage.radar_jammer)
{
if (!ka50_damage.radar_jammer)
{
activate_ka50_master_caution ();
ka50_damage.radar_jammer = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("RADAR", "JAMMER", "FAILURE");
play_client_server_warning_message (en, SPEECH_SYSTEM_RADAR_JAMMER_FAILURE);
if (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_RADAR_JAMMER_ON))
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_RADAR_JAMMER_ON, FALSE);
}
}
}
////////////////////////////////////////
if (damage.infra_red_jammer)
{
if (!ka50_damage.infra_red_jammer)
{
activate_ka50_master_caution ();
ka50_damage.infra_red_jammer = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("IR JAMMER", "FAILURE", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_IR_JAMMER_FAILURE);
if (get_local_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON))
{
set_client_server_entity_int_value (get_gunship_entity (), INT_TYPE_INFRA_RED_JAMMER_ON, FALSE);
}
}
}
////////////////////////////////////////
if (damage.navigation_computer)
{
if (!ka50_damage.navigation_computer)
{
activate_ka50_master_caution ();
ka50_damage.navigation_computer = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("NAVIGATION", "COMPUTER", "FAILURE");
play_client_server_warning_message (en, SPEECH_SYSTEM_NAV_COMPUTER_FAILURE);
}
}
////////////////////////////////////////
if (damage.communications)
{
if (!ka50_damage.communications)
{
activate_ka50_master_caution ();
ka50_damage.communications = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("COMMS", "FAILURE", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_COMMS_FAILURE);
}
}
////////////////////////////////////////
if (damage.radar_warning_system)
{
if (!ka50_damage.radar_warning_system)
{
activate_ka50_master_caution ();
ka50_damage.radar_warning_system = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("RADAR", "WARNING", "FAILURE");
play_client_server_warning_message (en, SPEECH_SYSTEM_RADAR_WARNING_FAILURE);
}
}
////////////////////////////////////////
if (!get_global_simple_avionics ())
{
if (damage.head_up_display)
{
if (!ka50_damage.head_up_display)
{
activate_ka50_master_caution ();
ka50_damage.head_up_display = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("HUD", "FAILURE", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_HUD_FAILURE);
}
}
}
////////////////////////////////////////
if (!get_global_simple_avionics ())
{
if (damage.helmet_mounted_sight)
{
if (!ka50_damage.helmet_mounted_sight)
{
activate_ka50_master_caution ();
ka50_damage.helmet_mounted_sight = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("HMS", "FAILURE", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_HELMET_MOUNTED_SIGHT_FAILURE);
if (target_acquisition_system == TARGET_ACQUISITION_SYSTEM_HMS)
{
select_ka50_target_acquisition_system (TARGET_ACQUISITION_SYSTEM_OFF);
}
}
}
}
////////////////////////////////////////
if (damage.shkval_mfd)
{
if (!ka50_damage.shkval_mfd)
{
activate_ka50_master_caution ();
ka50_damage.shkval_mfd = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("SHKVAL", "FAILURE", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_MFD_FAILURE);
select_ka50_mfd_mode (KA50_MFD_MODE_DAMAGED, KA50_MFD_LOCATION_SHKVAL);
}
}
////////////////////////////////////////
if (damage.abris_mfd)
{
if (!ka50_damage.abris_mfd)
{
activate_ka50_master_caution ();
ka50_damage.abris_mfd = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("ABRIS", "FAILURE", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_MFD_FAILURE);
select_ka50_mfd_mode (KA50_MFD_MODE_DAMAGED, KA50_MFD_LOCATION_ABRIS);
}
}
////////////////////////////////////////
if (damage.night_vision_goggles)
{
if (!ka50_damage.night_vision_goggles)
{
activate_ka50_master_caution ();
ka50_damage.night_vision_goggles = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("NVG", "DAMAGED", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_NIGHT_VISION_GOGGLES_FAILURE);
night_vision_system_active = FALSE;
}
}
////////////////////////////////////////
if (damage.gun_jammed)
{
if (!ka50_damage.gun_jammed)
{
activate_ka50_master_caution ();
ka50_damage.gun_jammed = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("GUN", "JAMMED", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_GUN_JAMMED);
}
}
////////////////////////////////////////
if (damage.lh_outer_pylon)
{
if (!ka50_damage.lh_outer_pylon)
{
activate_ka50_master_caution ();
ka50_damage.lh_outer_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("HARDPOINT", "DAMAGED", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.lh_inner_pylon)
{
if (!ka50_damage.lh_inner_pylon)
{
activate_ka50_master_caution ();
ka50_damage.lh_inner_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("HARDPOINT", "DAMAGED", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.rh_outer_pylon)
{
if (!ka50_damage.rh_outer_pylon)
{
activate_ka50_master_caution ();
ka50_damage.rh_outer_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("HARDPOINT", "DAMAGED", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.rh_inner_pylon)
{
if (!ka50_damage.rh_inner_pylon)
{
activate_ka50_master_caution ();
ka50_damage.rh_inner_pylon = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("HARDPOINT", "DAMAGED", "");
play_client_server_warning_message (en, SPEECH_SYSTEM_HARDPOINT_DAMAGED);
}
}
////////////////////////////////////////
if (damage.lh_chaff_dispensers)
{
if (!ka50_damage.lh_chaff_dispensers)
{
activate_ka50_master_caution ();
ka50_damage.lh_chaff_dispensers = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("CHAFF", "DISPENSER", "DAMAGED");
play_client_server_warning_message (en, SPEECH_SYSTEM_CHAFF_DISPENSER_DAMAGED);
}
}
////////////////////////////////////////
if (damage.rh_chaff_dispensers)
{
if (!ka50_damage.rh_chaff_dispensers)
{
activate_ka50_master_caution ();
ka50_damage.rh_chaff_dispensers = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("CHAFF", "DISPENSER", "DAMAGED");
play_client_server_warning_message (en, SPEECH_SYSTEM_CHAFF_DISPENSER_DAMAGED);
}
}
////////////////////////////////////////
if (damage.lh_flare_dispensers)
{
if (!ka50_damage.lh_flare_dispensers)
{
activate_ka50_master_caution ();
ka50_damage.lh_flare_dispensers = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("FLARE", "DISPENSER", "DAMAGED");
play_client_server_warning_message (en, SPEECH_SYSTEM_FLARE_DISPENSER_DAMAGED);
}
}
////////////////////////////////////////
if (damage.rh_flare_dispensers)
{
if (!ka50_damage.rh_flare_dispensers)
{
activate_ka50_master_caution ();
ka50_damage.rh_flare_dispensers = TRUE;
dynamics_damage_model (DYNAMICS_DAMAGE_AVIONICS, FALSE);
set_ka50_text_display_text ("FLARE", "DISPENSER", "DAMAGED");
play_client_server_warning_message (en, SPEECH_SYSTEM_FLARE_DISPENSER_DAMAGED);
}
}
////////////////////////////////////////
set_ka50_weapon_damage_status ();
}
int amalgamate_groups (entity *receiving_group, entity *donating_group)
{
entity
*this_member,
*member;
int
group_type,
group_kills,
group_losses,
donating_group_count,
receiving_group_count;
ASSERT (get_comms_model () == COMMS_MODEL_SERVER);
// check both groups are not doing any tasks
ASSERT (get_local_entity_int_value (receiving_group, INT_TYPE_GROUP_MODE) == GROUP_MODE_IDLE);
ASSERT (get_local_entity_int_value (donating_group, INT_TYPE_GROUP_MODE) == GROUP_MODE_IDLE);
// check group type are the same
group_type = get_local_entity_int_value (receiving_group, INT_TYPE_ENTITY_SUB_TYPE);
if (group_type != get_local_entity_int_value (donating_group, INT_TYPE_ENTITY_SUB_TYPE))
{
return FALSE;
}
ASSERT (group_database [group_type].amalgamate);
ASSERT (get_local_entity_int_value (donating_group, INT_TYPE_SIDE) == get_local_entity_int_value (receiving_group, INT_TYPE_SIDE));
donating_group_count = get_local_entity_int_value (donating_group, INT_TYPE_MEMBER_COUNT);
receiving_group_count = get_local_entity_int_value (receiving_group, INT_TYPE_MEMBER_COUNT);
if ((donating_group_count + receiving_group_count) <= group_database [group_type].maximum_member_count)
{
#ifdef DEBUG
//#if DEBUG_MODULE
if ((get_local_entity_parent (donating_group, LIST_TYPE_KEYSITE_GROUP)) && (get_local_entity_parent (receiving_group, LIST_TYPE_KEYSITE_GROUP)))
{
ASSERT (get_local_entity_type (get_local_entity_parent (donating_group, LIST_TYPE_KEYSITE_GROUP)) == get_local_entity_type (get_local_entity_parent (receiving_group, LIST_TYPE_KEYSITE_GROUP)));
}
debug_log ("GROUP: amalgamating group %s %d (count %d) with group %s %d (count %d)",
entity_sub_type_group_names [group_type], get_local_entity_index (donating_group), donating_group_count,
entity_sub_type_group_names [group_type], get_local_entity_index (receiving_group), receiving_group_count);
member = get_local_entity_first_child (donating_group, LIST_TYPE_MEMBER);
while (member)
{
debug_log ("GROUP: donating group member %s (%d)", get_local_entity_string (member, STRING_TYPE_FULL_NAME), get_local_entity_index (member));
ASSERT (get_local_entity_int_value (member, INT_TYPE_OPERATIONAL_STATE) == OPERATIONAL_STATE_LANDED);
member = get_local_entity_child_succ (member, LIST_TYPE_MEMBER);
}
member = get_local_entity_first_child (receiving_group, LIST_TYPE_MEMBER);
while (member)
{
debug_log ("GROUP: receiving group member %s (%d)", get_local_entity_string (member, STRING_TYPE_FULL_NAME), get_local_entity_index (member));
ASSERT (get_local_entity_int_value (member, INT_TYPE_OPERATIONAL_STATE) == OPERATIONAL_STATE_LANDED);
member = get_local_entity_child_succ (member, LIST_TYPE_MEMBER);
}
//#endif
#endif
member = get_local_entity_first_child (donating_group, LIST_TYPE_MEMBER);
while (member)
{
this_member = member;
member = get_local_entity_child_succ (member, LIST_TYPE_MEMBER);
set_client_server_entity_parent (this_member, LIST_TYPE_MEMBER, receiving_group);
}
group_kills = get_local_entity_int_value (receiving_group, INT_TYPE_KILLS);
group_losses = get_local_entity_int_value (receiving_group, INT_TYPE_LOSSES);
group_kills += get_local_entity_int_value (donating_group, INT_TYPE_KILLS);
group_losses += get_local_entity_int_value (donating_group, INT_TYPE_LOSSES);
if (get_local_entity_int_value (receiving_group, INT_TYPE_KILLS) != group_kills)
{
set_client_server_entity_int_value (receiving_group, INT_TYPE_KILLS, group_kills);
}
if (get_local_entity_int_value (receiving_group, INT_TYPE_LOSSES) != group_losses)
{
set_client_server_entity_int_value (receiving_group, INT_TYPE_LOSSES, group_losses);
}
//
// renumber the group members
//
set_group_member_numbers (receiving_group);
//
// place empty donating group on free list
//
ASSERT (get_local_entity_int_value (donating_group, INT_TYPE_MEMBER_COUNT) == 0);
kill_client_server_group_entity (donating_group);
#ifdef DEBUG
{
vec3d
*pos1,
*test_pos;
float
amalgamate_max_range = 10 * KILOMETRE;
member = get_local_entity_first_child (receiving_group, LIST_TYPE_MEMBER);
ASSERT (member);
pos1 = get_local_entity_vec3d_ptr (member, VEC3D_TYPE_POSITION);
member = get_local_entity_child_succ (member, LIST_TYPE_MEMBER);
while (member)
{
test_pos = get_local_entity_vec3d_ptr (member, VEC3D_TYPE_POSITION);
if (get_2d_range (pos1, test_pos) > amalgamate_max_range)
{
debug_log ("GROUP: WARNING: Amalgamated group with members (%s (%d) and %s (%d)) %f apart -------------------------",
get_local_entity_string (get_local_entity_first_child (receiving_group, LIST_TYPE_MEMBER), STRING_TYPE_FULL_NAME),
get_local_entity_index (get_local_entity_first_child (receiving_group, LIST_TYPE_MEMBER)),
get_local_entity_string (member, STRING_TYPE_FULL_NAME),
get_local_entity_index (member),
get_2d_range (pos1, test_pos));
}
member = get_local_entity_child_succ (member, LIST_TYPE_MEMBER);
}
}
#endif
return TRUE;
}
return FALSE;
}
