iw/cod4-sdk
0
0
Fork 0
Code Issues Pull requests Projects Releases 2 Packages Wiki Activity
cod4-sdk/raw/maps/_cobrapilot.gsc

2430 lines
76 KiB
Text
Raw Normal View History

as released 2008-01-19
2008-01-19 00:00:00 +00:00
/* SOUNDS
helicopter_world_edge_warning
helicopter_world_edge_failure
alarm_cobra_altitude,,cobra/alarm_altitude.wav,0.99,0.99,na,,,360,6000,local,,,,,cobrapilot pilotcobra
alarm_cobra_caution,,cobra/alarm_caution.wav,0.99,0.99,na,,,360,6000,local,,,,,cobrapilot pilotcobra
alarm_cobra_pullup,,cobra/alarm_pullup.wav,0.99,0.99,na,,,360,6000,local,,,,,cobrapilot pilotcobra
alarm_cobra_warning,,cobra/alarm_warning.wav,0.99,0.99,na,,,360,6000,local,,,,,cobrapilot pilotcobra
weap_rearming,,cobra/weap_rearming.wav,0.99,0.99,wpnplyr,,,360,6000,auto,,,,,cobrapilot pilotcobra
*/
#include maps\_utility;
#include maps\_helicopter_globals;
#include common_scripts\utility;
init()
{
/******************************************************/
/* DVARS */
/******************************************************/
// dvar to give player's cobra unlimited ammo
// 0 - regular
// 1 - unlimited
if ( getdvar( "cobrapilot_unlimited_ammo") == "" )
setdvar( "cobrapilot_unlimited_ammo", "0" );
// dvar to toggle the mode at which ammo reloading points operate
// 0 - player manually hovers above the point and ammo and health is regened
// 1 - players controls are taken away and sequence is started
if ( getdvar( "cobrapilot_farp_mode") == "" )
setdvar( "cobrapilot_farp_mode", "0" );
// dvar to set how the edge of the world acts
// 0 - nothing happens, player can fly out of bounds without penalty
// 1 - control is taken away and helicopter is automatically flown in bounds
// 2 - warning message pops up and player must fly in bounds within the time limit
if ( getdvar( "cobrapilot_edge_of_world_type") == "" )
setdvar( "cobrapilot_edge_of_world_type", "2" );
// turn on/off the gunner in your chopper
// 0 - off
// 1 - on
if ( getdvar( "cobrapilot_gunner_enabled") == "" )
setdvar( "cobrapilot_gunner_enabled", "1" );
// turn on/off the wingman
// 0 - off
// 1 - on
if ( getdvar( "cobrapilot_wingman_enabled") == "" )
setdvar( "cobrapilot_wingman_enabled", "1" );
// difficulty dvar
// easy, medium, hard, insane
setdvar( "cobrapilot_difficulty", "" );
// dvar to turn on debug info ( prints, lines, etc )
if ( getdvar( "cobrapilot_debug") == "" )
setdvar( "cobrapilot_debug", "0" );
/******************************************************/
/******************************************************/
/******************************************************/
/******************************************************/
/* SETUP WEAPON TAGS */
/******************************************************/
level.cobra_weapon_tags = [];
level.cobra_weapon_tags["cobra_20mm"][0] = "tag_flash";
level.cobra_weapon_tags["cobra_FFAR"][0] = "tag_store_r_2";
level.cobra_weapon_tags["cobra_Hellfire"][0] = "tag_store_l_1_a";
level.cobra_weapon_tags["cobra_Hellfire"][1] = "tag_store_l_1_b";
level.cobra_weapon_tags["cobra_Hellfire"][2] = "tag_store_l_1_c";
level.cobra_weapon_tags["cobra_Hellfire"][3] = "tag_store_l_1_d";
level.cobra_weapon_tags["cobra_Hellfire"][4] = "tag_store_r_1_a";
level.cobra_weapon_tags["cobra_Hellfire"][5] = "tag_store_r_1_b";
level.cobra_weapon_tags["cobra_Hellfire"][6] = "tag_store_r_1_c";
level.cobra_weapon_tags["cobra_Hellfire"][7] = "tag_store_r_1_d";
level.cobra_weapon_tags["cobra_Hellfire"][8] = "tag_store_l_2_a";
level.cobra_weapon_tags["cobra_Hellfire"][9] = "tag_store_l_2_b";
level.cobra_weapon_tags["cobra_Hellfire"][10] = "tag_store_l_2_c";
level.cobra_weapon_tags["cobra_Hellfire"][11] = "tag_store_l_2_d";
level.cobra_weapon_tags["cobra_Sidewinder"][0] = "tag_store_l_wing";
level.cobra_weapon_tags["cobra_Sidewinder"][1] = "tag_store_r_wing";
level.cobra_missile_models = [];
level.cobra_missile_models["cobra_Hellfire"] = "projectile_hellfire_missile";
level.cobra_missile_models["cobra_Sidewinder"] = "projectile_sidewinder_missile";
/******************************************************/
/******************************************************/
/******************************************************/
/******************************************************/
/* SETUP WEAPONS */
/******************************************************/
// 20mm Chain Gun
weapon = weaponsSystems_Create_Weapon();
weapon.v["weapon"] = "cobra_20mm";
weapon.v["realWeaponName"] = &"COBRAPILOT_20MM";
weapon.v["weaponNameLocationX"] = 573;
weapon.v["weaponNameLocationY"] = 149;
weapon.v["equipButton"] = "BUTTON_A";
weapon.v["equipShader"] = "cobra_controls_a";
weapon.v["singleShot"] = false;
weapon.v["targetType"] = "dummy";
weapon.v["maxAmmo"] = 750;
weapon.v["ammoPickupIncrement"] = 50;
weapon.v["tags"] = level.cobra_weapon_tags["cobra_20mm"];
weaponsSystems_Add_Weapon( weapon );
// Unguided Rockets
weapon = weaponsSystems_Create_Weapon();
weapon.v["weapon"] = "cobra_FFAR";
weapon.v["realWeaponName"] = &"COBRAPILOT_FFAR";
weapon.v["weaponNameLocationX"] = 573;
weapon.v["weaponNameLocationY"] = 167;
weapon.v["equipButton"] = "BUTTON_B";
weapon.v["equipShader"] = "cobra_controls_b";
weapon.v["singleShot"] = false;
weapon.v["targetType"] = "dummy";
weapon.v["maxAmmo"] = 38;
weapon.v["ammoPickupIncrement"] = 4;
weapon.v["tags"] = level.cobra_weapon_tags["cobra_FFAR"];
weaponsSystems_Add_Weapon( weapon );
// Hellfire
weapon = weaponsSystems_Create_Weapon();
weapon.v["weapon"] = "cobra_Hellfire";
weapon.v["realWeaponName"] = &"COBRAPILOT_HELLFIRE";
weapon.v["weaponNameLocationX"] = 573;
weapon.v["weaponNameLocationY"] = 185;
weapon.v["equipButton"] = "BUTTON_X";
weapon.v["equipShader"] = "cobra_controls_x";
weapon.v["hudShader"] = "veh_hud_hellfire";
weapon.v["hudShader_size_x"] = 200;
weapon.v["hudShader_size_y"] = 200;
weapon.v["singleShot"] = true;
weapon.v["targetType"] = "ground";
weapon.v["lockonTime"] = 1500;
weapon.v["maxAmmo"] = 8;
weapon.v["ammoPickupIncrement"] = 1;
weapon.v["tags"] = level.cobra_weapon_tags["cobra_Hellfire"];
weaponsSystems_Add_Weapon( weapon );
// Sidewinder
weapon = weaponsSystems_Create_Weapon();
weapon.v["weapon"] = "cobra_Sidewinder";
weapon.v["realWeaponName"] = &"COBRAPILOT_SIDEWINDER";
weapon.v["sound_armed_loop"] = "weap_aim9_growl4";
weapon.v["weaponNameLocationX"] = 573;
weapon.v["weaponNameLocationY"] = 203;
weapon.v["equipButton"] = "BUTTON_Y";
weapon.v["equipShader"] = "cobra_controls_y";
weapon.v["hudShader"] = "veh_hud_sidewinder";
weapon.v["hudShader_size_x"] = 200;
weapon.v["hudShader_size_y"] = 200;
weapon.v["singleShot"] = true;
weapon.v["targetType"] = "air";
weapon.v["lockonTime"] = 3000;
weapon.v["maxAmmo"] = 2;
weapon.v["ammoPickupIncrement"] = 1;
weapon.v["ammoPickupDelay_Min"] = 1.0;
weapon.v["ammoPickupDelay_Max"] = 2.0;
weapon.v["tags"] = level.cobra_weapon_tags["cobra_Sidewinder"];
weaponsSystems_Add_Weapon( weapon );
/******************************************************/
/******************************************************/
/******************************************************/
precacheString( &"COBRAPILOT_EDGE_OF_WORLD_WARNING" );
precacheString( &"COBRAPILOT_EDGE_OF_WORLD_FAIL" );
precacheString( &"COBRAPILOT_NO_AMMO" );
precacheString( &"COBRAPILOT_OBJECTIVE_AMMO_RELOAD_POINT" );
level.vehicleSpawnCallbackThread = ::vehicle_Spawn_Callback_Thread;
level.cobraHealth = [];
level.cobraHealth["easy"] = 9000;
level.cobraHealth["medium"] = 6000;
level.cobraHealth["hard"] = 3000;
level.cobraHealth["insane"] = 1500;
level.flareButton1 = "BUTTON_LSHLDR";
level.flareButton2 = "BUTTON_RSHLDR";
level.stats = [];
level.stats["enemies_killed"] = 0;
level.stats["damage_taken"] = 0;
level.stats["cobra_20mm"] = 0;
level.stats["cobra_FFAR"] = 0;
level.stats["cobra_Hellfire"] = 0;
level.stats["cobra_Sidewinder"] = 0;
level.stats["flares_used"] = 0;
level.cosine = [];
level.cosine["45"] = cos(45);
level.cosine["55"] = cos(55);
level.GunnerTargetRange = 16000;
level.GunnerTargetFOV = level.cosine["55"];
level.GunnerWeapon = "cobra_20mm_copilot";
level.GunnerWeaponPlayerEquiv = "cobra_20mm";
precacheItem( level.GunnerWeapon );
level.flare_fx = [];
level.flare_fx["cobra"] = loadfx( "misc/flares_cobra" );
level.flare_fx["cobra_player"] = loadfx( "misc/flares_cobra" );
level.flare_fx["hind"] = loadfx( "misc/flares_cobra" );
level.player_death_fx = loadfx( "explosions/cobrapilot_vehicle_explosion" );
precacheShader( "compass_waypoint_farp" );
// precache gunner character
precacheModel( "body_complete_sp_cobra_pilot_desert_zack" );
// precache materials used for missile hint indicators
level.missileHintIndicator_Missile = "veh_hud_missile";
level.missileHintIndicator_Missile_Flash = "veh_hud_missile_flash";
level.missileHintIndicator_Missile_Offscreen = "veh_hud_missile_offscreen";
level.missileHintIndicator_Arrow = [];
level.missileHintIndicator_Arrow["left"] = "veh_hud_missile_arrow_left";
level.missileHintIndicator_Arrow["right"] = "veh_hud_missile_arrow_right";
level.missileHintIndicator_Arrow["forward"] = "veh_hud_missile_arrow_forward";
level.missileHintIndicator_Arrow["back"] = "veh_hud_missile_arrow_back";
precacheShader( level.missileHintIndicator_Missile );
precacheShader( level.missileHintIndicator_Missile_Flash );
precacheShader( level.missileHintIndicator_Missile_Offscreen );
precacheShader( level.missileHintIndicator_Arrow["left"] );
precacheShader( level.missileHintIndicator_Arrow["right"] );
precacheShader( level.missileHintIndicator_Arrow["forward"] );
precacheShader( level.missileHintIndicator_Arrow["back"] );
setup_player_cobra();
if ( getdvar( "cobrapilot_edge_of_world_type") == "1" )
array_thread( getentarray( "border_outer", "targetname" ), ::borderwall_method1 );
else if ( getdvar( "cobrapilot_edge_of_world_type") == "2" )
thread edge_Of_World();
level.playervehicle thread globalThink();
thread weaponsSystems();
thread ammo_Reload_Station();
thread incommingMissile_Think();
if ( getdvar( "cobrapilot_gunner_enabled") == "1" )
thread gunner_spawn();
thread debug_thread();
}
setup_player_cobra()
{
level.playervehicle = getent("cobra","targetname");
level.playervehicle.script_targetoffset_z = -100;
thread setPlayerCobraHealth();
level.playervehicle setjitterparams( (3,3,3), 0.5, 1.5 );
level.currentWeapon = 0;
flag_init( "gunner_use_turret" );
if ( level.cobraWeapon[level.currentWeapon].v["weapon"] != level.GunnerWeaponPlayerEquiv )
flag_set( "gunner_use_turret" );
if ( ( isdefined( level.cobraWeapon ) ) && ( level.cobraWeapon.size > 0 ) )
level.playervehicle setVehWeapon( level.cobraWeapon[level.currentWeapon].v["weapon"] );
level.playervehicle notify( "nodeath_thread" );
level.playervehicle notify( "no_regen_health" );
level.playervehicle notify( "stop_turret_shoot" );
level.playervehicle notify( "stop_friendlyfire_shield" );
level.playervehicle notify( "stop_vehicle_wait" );
}
difficultySettingSelectedWait()
{
level.cobrapilot_difficulty = getdvar( "cobrapilot_difficulty" );
for (;;)
{
wait 0.05;
level.cobrapilot_difficulty = getdvar( "cobrapilot_difficulty" );
if ( !isdefined( level.cobrapilot_difficulty ) )
continue;
if ( level.cobrapilot_difficulty == "" )
continue;
return;
}
}
setPlayerCobraHealth()
{
precacheShader( "cobra_health" );
difficultySettingSelectedWait();
level.cobrapilot_difficulty = getdvar( "cobrapilot_difficulty" );
assert( isdefined( level.cobraHealth[ level.cobrapilot_difficulty ] ) );
level.playervehicle_starting_health = level.cobraHealth[ level.cobrapilot_difficulty ];
level.playervehicle_healthWarning_value = 1000;
level.playervehicle_healthRegenIncrement = int( level.playervehicle_starting_health / 6 );
level.playervehicle_healthRegenRate = 1.0;
level.playervehicle_healthLeakIncrement = 30;
level.playervehicle_healthLeakRate = 1.0;
level.playervehicle.health = level.playervehicle_starting_health;
level.playervehicle.currenthealth = level.playervehicle_starting_health;
level.playervehicle.maxhealth = level.playervehicle_starting_health;
health_indicator_create();
thread health_indicator_damageWait();
thread health_think();
}
vehicle_Spawn_Callback_Thread( vehicle )
{
vehicle thread globalThink();
if ( !isdefined( vehicle.script_cobratarget ) )
return;
if ( vehicle.script_cobratarget != 1 )
return;
assert( isdefined( vehicle.script_targettype ) );
if ( !isdefined( vehicle.script_targetoffset_z ) )
vehicle.script_targetoffset_z = 0;
offset = ( 0, 0, vehicle.script_targetoffset_z );
cobraTarget_Add( vehicle, vehicle.script_targettype, offset );
}
weaponsSystems_Create_Weapon()
{
ent = spawnStruct();
ent.v = [];
/*
weapon:
name of weapon defined in asset manager
realWeaponName:
real name of weapon used for hud/info, should be a localized string name
sound_armed:
sound to play when this weapon becomes equipped
sound_armed_loop (optional):
sound to loop while this weapon is armed
weaponNameLocationX / weaponNameLocationY:
x and y coordinate for realWeaponName text on the HUD
equipButton:
button pressed to equip this weapon
equipShader:
shader to use when this weapon is equipped
hudShader (optional):
shader to use for the HUD when this vehicle is equiped
hudShader_size_x (optional) / hudShader_size_y (optional):
size of the hudShader
singleShot:
if true, player must release the fire button before firing another shot
if false, holding the fire button fires multiple shots sequentially
targetType:
dummy - no targeting, just straight projectiles
ground - targets ground targets only
air - targets air targets only
lockonTime (optional):
number of milliseconds required for lockon to engage
shader_target:
shader targets use that are valid, but not locked
shader_target_offscreen:
shader valid targets use when they are offscreen
shader_lock:
shader targets use when they are fully locked on
shader_locking:
when a target is being locked (but isn't fully locked yet) it flashes this shader until full lock is reached
shader_invalid:
shader targets use that the current weapon system can't target
shader_invalid_offscreen:
shader invalid targets use when they are offscreen
maxAmmo:
maxinum number of rounds the helicopter can hold
ammoPickupIncrement:
number of rounds picked up each time the helicopter picks up ammo
ammoPickupDelay_Min / ammoPickupDelay_Max:
min and max random wait time between weapon pickups
tags:
array of tags on the helicopter where projectiles originate from
*/
// set some defaults
ent.v["weapon"] = undefined;
ent.v["realWeaponName"] = undefined;
ent.v["sound_armed"] = "cobra_weapon_change";
ent.v["sound_armed_loop"] = undefined;
ent.v["weaponNameLocationX"] = undefined;
ent.v["weaponNameLocationY"] = undefined;
ent.v["equipButton"] = undefined;
ent.v["equipShader"] = undefined;
ent.v["hudShader"] = undefined;
ent.v["hudShader_size_x"] = undefined;
ent.v["hudShader_size_y"] = undefined;
ent.v["singleShot"] = false;
ent.v["targetType"] = undefined;
ent.v["lockonTime"] = undefined;
ent.v["shader_target"] = "veh_hud_target";
ent.v["shader_target_offscreen"] = "veh_hud_target_offscreen";
ent.v["shader_lock"] = "veh_hud_target_lock";
ent.v["shader_locking"] = "veh_hud_target_locking";
ent.v["shader_invalid"] = "veh_hud_target_invalid";
ent.v["shader_invalid_offscreen"] = "veh_hud_target_invalid_offscreen";
ent.v["maxAmmo"] = undefined;
ent.v["ammoPickupIncrement"] = undefined;
ent.v["ammoPickupDelay_Min"] = 0.5;
ent.v["ammoPickupDelay_Max"] = 1.2;
ent.v["tags"] = undefined;
return ent;
}
weaponsSystems_Add_Weapon( weapon )
{
if ( !isdefined( level.cobraWeapon ) )
level.cobraWeapon = [];
assert( isdefined( level.cobraWeapon ) );
assert( isdefined( weapon.v["weapon"] ) );
assert( isdefined( weapon.v["realWeaponName"] ) );
assert( isdefined( weapon.v["sound_armed"] ) );
assert( isdefined( weapon.v["weaponNameLocationX"] ) );
assert( isdefined( weapon.v["weaponNameLocationY"] ) );
assert( isdefined( weapon.v["equipButton"] ) );
assert( isdefined( weapon.v["equipShader"] ) );
assert( isdefined( weapon.v["singleShot"] ) );
assert( isdefined( weapon.v["targetType"] ) );
assert( isdefined( weapon.v["shader_target"] ) );
assert( isdefined( weapon.v["shader_target_offscreen"] ) );
assert( isdefined( weapon.v["shader_lock"] ) );
assert( isdefined( weapon.v["shader_locking"] ) );
assert( isdefined( weapon.v["shader_invalid"] ) );
assert( isdefined( weapon.v["shader_invalid_offscreen"] ) );
assert( isdefined( weapon.v["maxAmmo"] ) );
assert( isdefined( weapon.v["ammoPickupIncrement"] ) );
assert( isdefined( weapon.v["ammoPickupDelay_Min"] ) );
assert( isdefined( weapon.v["ammoPickupDelay_Max"] ) );
assert( isdefined( weapon.v["tags"] ) );
assert( weapon.v["tags"].size > 0 );
index = level.cobraWeapon.size;
level.cobraWeapon[index] = weapon;
level.cobraWeapon[index].v["currentAmmo"] = level.cobraWeapon[index].v["maxAmmo"];
level.cobraWeapon[index].v["nextTag"] = 0;
//precache the weapons localized string name
precacheString( level.cobraWeapon[index].v["realWeaponName"] );
//precache the weapon
precacheItem( level.cobraWeapon[index].v["weapon"] );
//precache the shaders
if ( isdefined( level.cobraWeapon[index].v["hudShader"] ) )
precacheShader( level.cobraWeapon[index].v["hudShader"] );
precacheShader( level.cobraWeapon[index].v["equipShader"] );
precacheShader( level.cobraWeapon[index].v["shader_target"] );
precacheShader( level.cobraWeapon[index].v["shader_target_offscreen"] );
precacheShader( level.cobraWeapon[index].v["shader_lock"] );
precacheShader( level.cobraWeapon[index].v["shader_locking"] );
precacheShader( level.cobraWeapon[index].v["shader_invalid"] );
precacheShader( level.cobraWeapon[index].v["shader_invalid_offscreen"] );
// create the HUD weapon name
level.cobraWeapon[index].v["weaponNameHUD"] = newHudElem();
level.cobraWeapon[index].v["weaponNameHUD"].x = level.cobraWeapon[index].v["weaponNameLocationX"];
level.cobraWeapon[index].v["weaponNameHUD"].y = level.cobraWeapon[index].v["weaponNameLocationY"];
level.cobraWeapon[index].v["weaponNameHUD"].alignX = "left";
level.cobraWeapon[index].v["weaponNameHUD"].alignY = "middle";
level.cobraWeapon[index].v["weaponNameHUD"].horzAlign = "left";
level.cobraWeapon[index].v["weaponNameHUD"].vertAlign = "middle";
level.cobraWeapon[index].v["weaponNameHUD"].foreground = true;
level.cobraWeapon[index].v["weaponNameHUD"].fontscale = 1.0;
level.cobraWeapon[index].v["weaponNameHUD"].color = ( 0, 1, 0 );
level.cobraWeapon[index].v["weaponNameHUD"] setText ( level.cobraWeapon[index].v["realWeaponName"] );
// create the HUD ammo counter
if ( getdvar( "cobrapilot_unlimited_ammo") == "0" )
{
level.cobraWeapon[index].v["ammoCounter"] = newHudElem();
level.cobraWeapon[index].v["ammoCounter"].x = level.cobraWeapon[index].v["weaponNameLocationX"] + 160;
level.cobraWeapon[index].v["ammoCounter"].y = level.cobraWeapon[index].v["weaponNameLocationY"];
level.cobraWeapon[index].v["ammoCounter"].alignX = "center";
level.cobraWeapon[index].v["ammoCounter"].alignY = "middle";
level.cobraWeapon[index].v["ammoCounter"].horzAlign = "left";
level.cobraWeapon[index].v["ammoCounter"].vertAlign = "middle";
level.cobraWeapon[index].v["ammoCounter"].foreground = true;
level.cobraWeapon[index].v["ammoCounter"].fontscale = 1.0;
level.cobraWeapon[index].v["ammoCounter"].color = ( 0, 1, 0 );
level.cobraWeapon[index].v["ammoCounter"] setValue ( level.cobraWeapon[index].v["currentAmmo"] );
}
}
weaponsSystems()
{
if ( !isdefined( level.cobraWeapon ) )
return;
if ( level.cobraWeapon.size == 0 )
return;
level endon ( "cobra_death" );
difficultySettingSelectedWait();
thread weaponsSystems_HUD();
thread weaponsSystems_Fire_Missile();
thread weaponsSystems_zoom();
for (;;)
{
for( i = 0 ; i < level.cobraWeapon.size ; i++ )
{
if( level.player buttonPressed( level.cobraWeapon[i].v["equipButton"] ) )
{
// stop the equip loop sound of the old weapon if it was playing one
weaponSystems_EquipLoopSound_Stop();
// activate the weapon
if ( level.currentWeapon == i )
{
weaponsSystems_buttonRelease_Wait( level.cobraWeapon[level.currentWeapon].v["equipButton"] );
continue;
}
level.currentWeapon = i;
if ( level.cobraWeapon[level.currentWeapon].v["weapon"] == level.GunnerWeaponPlayerEquiv )
{
flag_clear( "gunner_use_turret" );
level.playervehicle notify( "gunner_stop_firing" );
level.playervehicle clearTurretTarget();
}
else
flag_set( "gunner_use_turret" );
level.playervehicle setVehWeapon( level.cobraWeapon[level.currentWeapon].v["weapon"] );
level notify ( "weapon_armed" );
// stop any lockon sounds that might have started
if ( ( isdefined( level.cobraTarget ) ) && ( level.cobraTarget.size > 0 ) )
{
for( i = 0 ; i < level.cobraTarget.size ; i++ )
thread cobraTarget_holdWait_missileLock_Sound_Stop( level.cobraTarget[i] );
}
// play weapon equip sound and if the weapon has an armed loop sound play it now
level.player playLocalSound( level.cobraWeapon[level.currentWeapon].v["sound_armed"] );
thread weaponSystems_EquipLoopSound_Start();
cobraTarget_unlockAllTargets();
cobraTarget_UpdateShaders_All();
weaponsSystems_buttonRelease_Wait( level.cobraWeapon[level.currentWeapon].v["equipButton"] );
}
}
wait 0.05;
}
}
weaponSystems_EquipLoopSound_Start()
{
if ( !isdefined( level.cobraWeapon[level.currentWeapon].v["sound_armed_loop"] ) )
return;
if ( isdefined( level.weaponEquipLoopSoundPlaying ) )
return;
level.weaponEquipLoopSoundPlaying = true;
level.player thread playLoopSoundForSeeking( level.cobraWeapon[level.currentWeapon].v["sound_armed_loop"] );
}
weaponSystems_EquipLoopSound_Stop()
{
level.weaponEquipLoopSoundPlaying = undefined;
if ( !isdefined( level.cobraWeapon[level.currentWeapon].v["sound_armed_loop"] ) )
return;
level.player notify ( "stop sound" + level.cobraWeapon[level.currentWeapon].v["sound_armed_loop"] );
}
weaponsSystems_buttonRelease_Wait( button )
{
level endon ( "cobra_death" );
prof_begin( "cobrapilot_weapons_systems" );
while ( level.player buttonPressed( button ) )
wait 0.05;
prof_end( "cobrapilot_weapons_systems" );
}
weaponsSystems_HUD()
{
if ( !isdefined( level.cobraWeapon ) )
return;
if ( level.cobraWeapon.size == 0 )
return;
// weapon selection display
controller_layout_size_x = 300;
controller_layout_size_y = 75;
level.controller_layout = newHudElem();
level.controller_layout.x = 25;
level.controller_layout.y = 10;
level.controller_layout.alignX = "right";
level.controller_layout.alignY = "bottom";
level.controller_layout.horzAlign = "right";
level.controller_layout.vertAlign = "bottom";
level.controller_layout.foreground = true;
// weapon HUD
level.weapon_hud = newHudElem();
level.weapon_hud.x = 0;
level.weapon_hud.y = 0;
level.weapon_hud.alignX = "center";
level.weapon_hud.alignY = "middle";
level.weapon_hud.horzAlign = "center";
level.weapon_hud.vertAlign = "middle";
level.weapon_hud.foreground = true;
level.weapon_hud.alpha = 0;
level endon ( "cobra_death" );
for (;;)
{
prof_begin( "cobrapilot_weapons_systems" );
assert( isdefined ( level.currentWeapon ) );
// weapon selection display
assert( isdefined( level.cobraWeapon[level.currentWeapon].v["equipShader"] ) );
level.controller_layout setshader ( level.cobraWeapon[level.currentWeapon].v["equipShader"],
controller_layout_size_x,
controller_layout_size_y );
// weapon HUD
if ( isdefined( level.cobraWeapon[level.currentWeapon].v["hudShader"] ) )
{
assert( isdefined( level.cobraWeapon[level.currentWeapon].v["hudShader_size_x"] ) );
assert( isdefined( level.cobraWeapon[level.currentWeapon].v["hudShader_size_y"] ) );
level.weapon_hud setshader ( level.cobraWeapon[level.currentWeapon].v["hudShader"],
level.cobraWeapon[level.currentWeapon].v["hudShader_size_x"],
level.cobraWeapon[level.currentWeapon].v["hudShader_size_y"] );
level.weapon_hud.alpha = 1;
}
else
level.weapon_hud.alpha = 0;
prof_end( "cobrapilot_weapons_systems" );
level waittill ( "weapon_armed" );
}
}
weaponsSystems_Fire_Missile()
{
level.playervehicle endon ( "death" );
level endon ( "cobra_death" );
for (;;)
{
// code notify that the trigger was pulled
level.playervehicle waittill ( "turret_fire" );
// make sure the player has ammo
if ( getdvar( "cobrapilot_unlimited_ammo") != "1" )
{
if ( level.cobraWeapon[level.currentWeapon].v["currentAmmo"] <= 0 )
{
thread weaponsSystems_noAmmo_Warning();
continue;
}
}
// fire the weapon from the next tag to be used
// if there are targets that are locked, fire the missile at those targets
missileTarget = weaponsSystems_Get_Missile_Target();
eMissile = undefined;
if ( isdefined ( missileTarget ) )
{
eMissile = level.playervehicle fireWeapon( level.cobraWeapon[level.currentWeapon].v["tags"][level.cobraWeapon[level.currentWeapon].v["nextTag"]], missileTarget.targetEntity );
missileTarget.targetEntity notify ( "incomming_missile", eMissile );
if ( !isdefined( missileTarget.targetEntity.incomming_Missiles ) )
missileTarget.targetEntity.incomming_Missiles = [];
missileTarget.targetEntity.incomming_Missiles = array_add( missileTarget.targetEntity.incomming_Missiles, eMissile );
thread missile_deathWait( eMissile, missileTarget.targetEntity );
}
else
eMissile = level.playervehicle fireWeapon( level.cobraWeapon[level.currentWeapon].v["tags"][level.cobraWeapon[level.currentWeapon].v["nextTag"]] );
//iprintlnbold( level.cobraWeapon[level.currentWeapon].v["tags"][level.cobraWeapon[level.currentWeapon].v["nextTag"]] );
assert( isdefined( eMissile ) );
assert( isdefined( level.stats[ level.cobraWeapon[ level.currentWeapon ].v[ "weapon" ] ] ) );
level.stats[ level.cobraWeapon[ level.currentWeapon ].v[ "weapon" ] ]++;
if ( isdefined( level.playervehicle.hasAttachedWeapons ) )
{
if ( ( isdefined( level.cobra_missile_models ) ) && ( isdefined( level.cobra_missile_models[ level.cobraWeapon[level.currentWeapon].v["weapon"] ] ) ) )
{
modelname = level.cobra_missile_models[ level.cobraWeapon[level.currentWeapon].v["weapon"] ];
tagname = level.cobraWeapon[level.currentWeapon].v["tags"][level.cobraWeapon[level.currentWeapon].v["nextTag"]];
level.playervehicle weaponsSystems_Detach_Weapon( modelname, tagname );
}
}
// update what the next tag should be - some weapons only use one tag so it will remain the same
level.cobraWeapon[level.currentWeapon].v["nextTag"]++;
if ( level.cobraWeapon[level.currentWeapon].v["nextTag"] >= level.cobraWeapon[level.currentWeapon].v["tags"].size )
level.cobraWeapon[level.currentWeapon].v["nextTag"] = 0;
// take away ammo and update the ammo counter on the hud
if ( getdvar( "cobrapilot_unlimited_ammo") == "0" )
{
level.cobraWeapon[level.currentWeapon].v["currentAmmo"]--;
level.cobraWeapon[level.currentWeapon].v["ammoCounter"] setValue ( level.cobraWeapon[level.currentWeapon].v["currentAmmo"] );
}
// some weapons require player to release the fire button before a second shot is fired
if ( level.cobraWeapon[level.currentWeapon].v["singleShot"] )
weaponsSystems_buttonRelease_Wait( "BUTTON_RTRIG" );
}
}
weaponsSystems_Detach_Weapon( modelname, tagname )
{
if ( getdvar( "cobrapilot_unlimited_ammo") == "1" )
return;
// build list of all attached models
attachedModelCount = self getattachsize();
attachedModels = [];
for ( i = 0 ; i < attachedModelCount ; i++ )
attachedModels[ i ] = self getattachmodelname( i );
// check to see if this model is attached to this model
// if it is, see if it's on the matching tagname
qAttached = false;
for( i = 0 ; i < attachedModels.size ; i++ )
{
if ( attachedModels[i] != modelname )
continue;
sName = self getattachtagname( i );
if ( tolower( tagname ) != tolower( sName ) )
continue;
qAttached = true;
break;
}
if ( qAttached )
self detach( modelname , tagname );
else
println( "FAILED TO DETACH MODEL: " + modelname + " from tag: " + tagname );
}
weaponsSystems_Attach_Weapon( weapon )
{
if ( getdvar( "cobrapilot_unlimited_ammo") == "1" )
return;
// build list of all attached models
attachedModelCount = self getattachsize();
//attachedModels = [];
//for ( i = 0 ; i < attachedModelCount ; i++ )
// attachedModels[ i ] = self getattachmodelname( i );
// find an open tag that this model could get attached to
if ( !isdefined( level.cobra_missile_models[ weapon ] ) )
return;
missileModel = level.cobra_missile_models[ weapon ];
attachToTag = undefined;
for( i = 0 ; i < level.cobra_weapon_tags[ weapon ].size ; i++ )
{
tag = level.cobra_weapon_tags[ weapon ][ i ];
// check if a model is already attached to this tag
if ( weaponsSystems_Model_Attached_To_Tag( tag ) )
continue;
attachToTag = tag;
break;
}
if ( isdefined( attachToTag ) )
self attach( missileModel, attachToTag );
//else
//println( "FAILED TO ATTACH MODEL: " + missileModel );
}
weaponsSystems_Model_Attached_To_Tag( tagname )
{
// find if a model is attached to this tag
attachedModelCount = self getattachsize();
for( i = 0 ; i < attachedModelCount ; i++ )
{
if ( self getattachtagname( i ) == tagname )
return true;
}
return false;
}
weaponsSystems_Get_Missile_Target()
{
level endon ( "cobra_death" );
missileTarget = undefined;
if ( !isdefined( level.cobraTarget ) )
return missileTarget;
if ( !isdefined( level.cobraTarget.size ) )
return missileTarget;
prof_begin( "cobrapilot_weapons_systems" );
// find the missile with the lowest .locked time
for( i = 0 ; i < level.cobraTarget.size ; i++ )
{
if ( !isdefined( level.cobraTarget[i].locked ) )
continue;
if ( !isdefined( missileTarget ) )
missileTarget = level.cobraTarget[i];
if ( level.cobraTarget[i].locked < missileTarget.locked )
missileTarget = level.cobraTarget[i];
}
prof_end( "cobrapilot_weapons_systems" );
if ( isdefined( missileTarget ) )
missileTarget.locked = getTime();
return missileTarget;
}
weaponsSystems_noAmmo_Warning()
{
level notify ( "noammo_warning" );
level endon ( "noammo_warning" );
if ( isdefined( level.noammo_warning ) )
level.noammo_warning destroy();
level.noammo_warning = newHudElem();
level.noammo_warning.x = 0;
level.noammo_warning.y = 40;
level.noammo_warning.alignX = "center";
level.noammo_warning.alignY = "middle";
level.noammo_warning.horzAlign = "center";
level.noammo_warning.vertAlign = "middle";
level.noammo_warning.foreground = true;
level.noammo_warning setText( &"COBRAPILOT_NO_AMMO" );
level.noammo_warning.fontscale = 1.5;
level.player playLocalSound( "cobra_no_ammo" );
level.noammo_warning.alpha = 1;
wait 0.5;
level.noammo_warning fadeOverTime( 1.0 );
level.noammo_warning.alpha = 0;
wait 1.0;
level.noammo_warning destroy();
}
weaponsSystems_zoom()
{
level endon ( "cobra_death" );
level.player endon ( "death" );
wait 0.05;
level.playervehicle_fov_start = 65;
level.playervehicle_fov_zoom = 35;
setsaveddvar( "cg_fov", level.playervehicle_fov_start );
for (;;)
{
while( !level.player buttonPressed( "BUTTON_LSTICK" ) )
wait 0.05;
setsaveddvar( "cg_fov", level.playervehicle_fov_zoom );
while( level.player buttonPressed( "BUTTON_LSTICK" ) )
wait 0.05;
setsaveddvar( "cg_fov", level.playervehicle_fov_start );
}
}
cobraTarget_Add( targetEntity, targetType, targetOffset )
{
// adds a new entity target to the targets array
assert( isdefined( targetEntity ) );
assert( isdefined( targetType ) );
assert( targetType == "air" || targetType == "ground" || targetType == "dummy" );
prof_begin( "cobrapilot_weapons_systems" );
if ( !isdefined( targetOffset ) )
targetOffset = (0,0,0);
if ( !isdefined( level.cobraTarget ) )
level.cobraTarget = [];
index = level.cobraTarget.size;
level.cobraTarget[index] = spawnstruct();
level.cobraTarget[index].targetEntity = targetEntity;
level.cobraTarget[index].targetType = targetType;
level.cobraTarget[index].targetOffset = targetOffset;
target_set( level.cobraTarget[index].targetEntity, level.cobraTarget[index].targetOffset );
level.cobraTarget[index].targetEntity.target_initilized = true;
thread cobraTarget_Death( level.cobraTarget[index] );
level notify ( "targets_updated" );
prof_end( "cobrapilot_weapons_systems" );
cobraTarget_UpdateShaders_All();
thread cobraTarget_check_missileLock_All();
}
cobraTarget_Death( targetStruct )
{
targetStruct.targetEntity waittill ( "death" );
cobraTarget_holdWait_missileLock_Sound_Stop( targetStruct );
// if the sidewinder weapon was targeting this target, clear the target reticle
if ( isdefined( targetStruct.sideWinder_targeted ) )
cobraTarget_Sidewinder_ReticleLockOn_Stop( targetStruct );
level.stats["enemies_killed"]++;
cobraTarget_Remove( targetStruct );
}
cobraTarget_Remove( targetStruct )
{
prof_begin( "cobrapilot_weapons_systems" );
// previously used when passing in the entity and not the struct containing the entity
/*
// locate this target in level.cobraTarget array and remove that index from the array
for( i = 0 ; i < level.cobraTarget.size ; i++ )
{
if ( level.cobraTarget[i].targetEntity != targetEntity )
continue;
target_remove( level.cobraTarget[i].targetEntity );
level.cobraTarget = array_remove( level.cobraTarget, level.cobraTarget[i] );
break;
}
*/
target_remove( targetStruct.targetEntity );
level.cobraTarget = array_remove( level.cobraTarget, targetStruct );
level notify ( "targets_updated" );
prof_end( "cobrapilot_weapons_systems" );
}
cobraTarget_UpdateShaders_All()
{
// updates shaders for all targets in the targets array
// if ground missiles are armed ground targets show "target" shader and air targets show "invalid" shader
// if air missiles are armed air targets show "target" shader and ground targets show "invalid" shader
// if dummy missiles are armed all targets show "target" shader
if ( !isdefined( level.cobraTarget ) )
return;
if ( !isdefined( level.cobraTarget.size ) )
return;
if ( !isdefined( level.cobraWeapon ) )
return;
if ( level.cobraWeapon.size == 0 )
return;
prof_begin( "cobrapilot_weapons_systems" );
for( i = 0 ; i < level.cobraTarget.size ; i++ )
{
// if the target type matches the weapon type (ie weapon type is "ground" and target type is also "ground")
// then make this target have a valid target shader
// if the weapon type is "dummy" then all targets are valid
// otherwise give it the invalid target shader
if ( level.cobraWeapon[level.currentWeapon].v["targetType"] == "dummy" )
cobraTarget_UpdateShader( level.cobraTarget[i], "target" );
else
if ( level.cobraTarget[i].targetType == level.cobraWeapon[level.currentWeapon].v["targetType"] )
cobraTarget_UpdateShader( level.cobraTarget[i], "target" );
else
cobraTarget_UpdateShader( level.cobraTarget[i], "invalid" );
}
prof_end( "cobrapilot_weapons_systems" );
}
cobraTarget_UpdateShader( targetStruct, shader )
{
assert( isdefined( targetStruct ) );
assert( isdefined( targetStruct.targetEntity ) );
assert( isdefined( shader ) );
assertEx( isdefined( targetStruct.targetEntity.target_initilized ), "Script is trying to do setShader on a target that hasm't run target_set. This is supposed to be impossible" );
switch( shader )
{
case "target":
target_setShader( targetStruct.targetEntity, level.cobraWeapon[level.currentWeapon].v["shader_target"] );
target_setOffscreenShader( targetStruct.targetEntity, level.cobraWeapon[level.currentWeapon].v["shader_target_offscreen"] );
break;
case "lock":
target_setShader( targetStruct.targetEntity, level.cobraWeapon[level.currentWeapon].v["shader_lock"] );
target_setOffscreenShader( targetStruct.targetEntity, level.cobraWeapon[level.currentWeapon].v["shader_target_offscreen"] );
break;
case "locking":
target_setShader( targetStruct.targetEntity, level.cobraWeapon[level.currentWeapon].v["shader_locking"] );
target_setOffscreenShader( targetStruct.targetEntity, level.cobraWeapon[level.currentWeapon].v["shader_target_offscreen"] );
break;
case "invalid":
target_setShader( targetStruct.targetEntity, level.cobraWeapon[level.currentWeapon].v["shader_invalid"] );
target_setOffscreenShader( targetStruct.targetEntity, level.cobraWeapon[level.currentWeapon].v["shader_invalid_offscreen"] );
break;
default:
assertMsg ("shader must be target, lock, locking, or invalid");
break;
}
}
cobraTarget_unlockAllTargets()
{
if ( !isdefined( level.cobraTarget ) )
return;
if ( !isdefined( level.cobraTarget.size ) )
return;
prof_begin( "cobrapilot_weapons_systems" );
for( i = 0 ; i < level.cobraTarget.size ; i++ )
{
cobraTarget_Sidewinder_ReticleLockOn_Stop( level.cobraTarget[i] );
level.cobraTarget[i].sideWinder_targeted = undefined;
level.cobraTarget[i].locking = undefined;
level.cobraTarget[i].locked = undefined;
}
prof_end( "cobrapilot_weapons_systems" );
}
cobraTarget_check_missileLock_All()
{
if ( !isdefined( level.cobraWeapon ) )
return;
if ( level.cobraWeapon.size == 0 )
return;
level notify ( "checking for missile locks" );
level endon ( "checking for missile locks" );
level endon ( "cobra_death" );
for (;;)
{
prof_begin( "cobrapilot_weapons_systems" );
assert( isdefined( level.cobraTarget ) );
if ( !isdefined( level.cobraTarget.size ) )
{
level waittill ( "targets_updated" );
continue;
}
if ( !isdefined( level.cobraTarget.size ) )
continue;
if ( level.cobraWeapon[level.currentWeapon].v["targetType"] == "ground" )
{
boxHalfWidth = ( level.cobraWeapon[level.currentWeapon].v["hudShader_size_x"] / 2 ) - 25;
boxHalfHeight = ( level.cobraWeapon[level.currentWeapon].v["hudShader_size_y"] / 2 ) - 25;
// logic for hellfire missile lockons
for( i = 0 ; i < level.cobraTarget.size ; i++ )
{
if ( level.cobraTarget[i].targetType != level.cobraWeapon[level.currentWeapon].v["targetType"] )
{
prof_end( "cobrapilot_weapons_systems" );
continue;
}
cobraTarget_check_missileLock_Ground( level.cobraTarget[i], boxHalfWidth, boxHalfHeight );
}
}
else if ( level.cobraWeapon[level.currentWeapon].v["targetType"] == "air" )
{
circleRadius = ( level.cobraWeapon[level.currentWeapon].v["hudShader_size_x"] / 2 ) - 10;
for( i = 0 ; i < level.cobraTarget.size ; i++ )
{
if ( level.cobraTarget[i].targetType != level.cobraWeapon[level.currentWeapon].v["targetType"] )
{
prof_end( "cobrapilot_weapons_systems" );
continue;
}
cobraTarget_check_missileLock_Air( level.cobraTarget[i], circleRadius );
}
}
else
{
prof_end( "cobrapilot_weapons_systems" );
level waittill ( "weapon_armed" );
}
prof_end( "cobrapilot_weapons_systems" );
wait 0.05;
}
}
cobraTarget_isLockingOn( targetStruct, boxHalfWidth, boxHalfHeight, circleRadius )
{
assert( isdefined( targetStruct ) );
assert( isdefined( targetStruct.targetEntity ) );
if ( isdefined( boxHalfWidth ) )
assert( isdefined( boxHalfHeight ) );
if ( ( !isdefined( boxHalfWidth ) ) && ( !isdefined( boxHalfHeight ) ) )
assert( isdefined( circleRadius ) );
inReticle = false;
sightTrace = false;
prof_begin( "cobrapilot_weapons_systems" );
inReticle = target_isinrect( targetStruct.targetEntity, level.player, int(getdvar( "cg_fov" )), boxHalfWidth, boxHalfHeight );
if ( inReticle )
sightTrace = sighttracepassed( level.player getEye(), targetStruct.targetEntity.origin + targetStruct.targetOffset + (0,0,100), false, undefined );
prof_end( "cobrapilot_weapons_systems" );
if ( inReticle && sightTrace )
return true;
return false;
}
cobraTarget_check_missileLock_Ground( targetStruct, boxHalfWidth, boxHalfHeight )
{
level endon ( "weapon_armed" );
assert( isdefined( targetStruct ) );
assert( isdefined( targetStruct.targetEntity ) );
assert( isdefined( boxHalfWidth ) );
assert( isdefined( boxHalfHeight ) );
if ( cobraTarget_isLockingOn( targetStruct, boxHalfWidth, boxHalfHeight ) )
thread cobraTarget_holdWait_missileLock_Ground( targetStruct, boxHalfWidth, boxHalfHeight );
else
cobraTarget_UpdateShader( targetStruct, "target" );
}
cobraTarget_holdWait_missileLock_Ground( targetStruct, boxHalfWidth, boxHalfHeight )
{
level endon ( "weapon_armed" );
level endon ( "cobra_death" );
assert( isdefined( targetStruct ) );
assert( isdefined( targetStruct.targetEntity ) );
assert( isdefined( boxHalfWidth ) );
assert( isdefined( boxHalfHeight ) );
targetStruct.targetEntity endon ( "death" );
if ( isdefined( targetStruct.locking ) )
return;
if ( isdefined( targetStruct.locked ) )
return;
targetStruct.locking = getTime();
lockStartTime = getTime();
prof_begin( "cobrapilot_weapons_systems" );
thread cobraTarget_holdWait_missileLock_Sound_Start( targetStruct, "weap_hellfire_seeking" );
while( cobraTarget_isLockingOn( targetStruct, boxHalfWidth, boxHalfHeight ) )
{
cobraTarget_UpdateShader( targetStruct, "locking" );
wait 0.4;
cobraTarget_UpdateShader( targetStruct, "target" );
wait 0.4;
currentTime = getTime();
elapsedTime = currentTime - lockStartTime;
if ( elapsedTime > level.cobraWeapon[level.currentWeapon].v["lockonTime"] )
{
thread cobraTarget_holdLock_missileLock_Ground( targetStruct, boxHalfWidth, boxHalfHeight );
prof_end( "cobrapilot_weapons_systems" );
return;
}
}
thread cobraTarget_holdWait_missileLock_Sound_Stop( targetStruct );
prof_end( "cobrapilot_weapons_systems" );
targetStruct.locking = undefined;
}
cobraTarget_holdLock_missileLock_Ground( targetStruct, boxHalfWidth, boxHalfHeight )
{
level endon ( "weapon_armed" );
level endon ( "cobra_death" );
assert( isdefined( targetStruct ) );
assert( isdefined( targetStruct.targetEntity ) );
assert( isdefined( boxHalfWidth ) );
assert( isdefined( boxHalfHeight ) );
targetStruct.targetEntity endon ( "death" );
cobraTarget_UpdateShader( targetStruct, "lock" );
prof_begin( "cobrapilot_weapons_systems" );
targetStruct.locked = targetStruct.locking;
targetStruct.locking = undefined;
thread cobraTarget_holdWait_missileLock_Sound_Stop( targetStruct );
level.player playLocalSound( "weap_hellfire_lock" );
while( cobraTarget_isLockingOn( targetStruct, boxHalfWidth, boxHalfHeight ) )
wait 0.05;
targetStruct.locked = undefined;
prof_end( "cobrapilot_weapons_systems" );
}
cobraTarget_holdWait_missileLock_Sound_Start( targetStruct, alias )
{
level endon ( "cobra_death" );
level endon ( "stop_cobra_hellfire_locking_sound" );
assert( isdefined( targetStruct ) );
assert( isdefined( alias ) );
if ( isdefined( targetStruct.locking_sound_playing ) )
return;
targetStruct.locking_sound_playing = alias;
targetStruct thread playLoopSoundForSeeking( alias );
}
cobraTarget_holdWait_missileLock_Sound_Stop( targetStruct )
{
assert( isdefined( targetStruct ) );
if ( !isdefined( targetStruct.locking_sound_playing ) )
return;
targetStruct notify ( "stop sound" + targetStruct.locking_sound_playing );
targetStruct.locking_sound_playing = undefined;
}
cobraTarget_check_missileLock_Air( targetStruct, circleRadius )
{
level endon ( "weapon_armed" );
assert( isdefined( targetStruct ) );
assert( isdefined( targetStruct.targetEntity ) );
assert( isdefined( circleRadius ) );
if ( cobraTarget_Sidewinder_Has_Target() )
return;
if ( target_isincircle( targetStruct.targetEntity, level.player, int(getdvar( "cg_fov" )), circleRadius ) )
{
targetStruct.sideWinder_targeted = true;
thread cobraTarget_holdWait_missileLock_Air( targetStruct, circleRadius );
return;
}
cobraTarget_UpdateShader( targetStruct, "target" );
}
cobraTarget_holdWait_missileLock_Air( targetStruct, circleRadius )
{
level endon ( "weapon_armed" );
level endon ( "cobra_death" );
assert( isdefined( targetStruct ) );
assert( isdefined( targetStruct.targetEntity ) );
assert( isdefined( targetStruct.sideWinder_targeted ) );
assert( isdefined( circleRadius ) );
targetStruct.targetEntity endon ( "death" );
if ( isdefined( targetStruct.locking ) )
return;
if ( isdefined( targetStruct.locked ) )
return;
targetStruct.locking = getTime();
lockStartTime = getTime();
prof_begin( "cobrapilot_weapons_systems" );
thread cobraTarget_Sidewinder_ReticleLockOn_Start( targetStruct );
while( target_isincircle( targetStruct.targetEntity, level.player, int(getdvar( "cg_fov" )), circleRadius ) )
{
cobraTarget_UpdateShader( targetStruct, "locking" );
wait 0.4;
cobraTarget_UpdateShader( targetStruct, "target" );
wait 0.4;
currentTime = getTime();
elapsedTime = currentTime - lockStartTime;
if ( elapsedTime > level.cobraWeapon[level.currentWeapon].v["lockonTime"] )
{
thread cobraTarget_holdLock_missileLock_Air( targetStruct, circleRadius );
prof_end( "cobrapilot_weapons_systems" );
return;
}
}
prof_end( "cobrapilot_weapons_systems" );
cobraTarget_Sidewinder_ReticleLockOn_Stop( targetStruct );
targetStruct.locking = undefined;
}
cobraTarget_holdLock_missileLock_Air( targetStruct, circleRadius )
{
level endon ( "weapon_armed" );
level endon ( "cobra_death" );
assert( isdefined( targetStruct ) );
assert( isdefined( targetStruct.targetEntity ) );
assert( isdefined( circleRadius ) );
targetStruct.targetEntity endon ( "death" );
cobraTarget_UpdateShader( targetStruct, "lock" );
targetStruct.targetEntity notify ( "missile_lock", level.playervehicle );
prof_begin( "cobrapilot_weapons_systems" );
targetStruct.locked = targetStruct.locking;
targetStruct.locking = undefined;
thread cobraTarget_holdWait_missileLock_Sound_Stop( targetStruct );
thread cobraTarget_holdWait_missileLock_Sound_Start( targetStruct, "weap_aim9_lock" );
while( target_isincircle( targetStruct.targetEntity, level.player, int(getdvar( "cg_fov" )), circleRadius ) )
wait 0.05;
cobraTarget_Sidewinder_ReticleLockOn_Stop( targetStruct );
targetStruct.locked = undefined;
cobraTarget_UpdateShader( targetStruct, "target" );
prof_end( "cobrapilot_weapons_systems" );
}
cobraTarget_Sidewinder_Has_Target()
{
for( i = 0 ; i < level.cobraTarget.size ; i++ )
{
if ( isdefined( level.cobraTarget[i].sideWinder_targeted ) )
return true;
}
return false;
}
cobraTarget_Sidewinder_ReticleLockOn_Start( targetStruct )
{
targetStruct endon ( "Sidewinder_ReticleLockOn_Stop" );
assert( isdefined( targetStruct ) );
assert( isdefined( targetStruct.targetEntity ) );
targetStruct.targetEntity endon ( "death" );
weaponSystems_EquipLoopSound_Stop();
segmentLength = ( level.cobraWeapon[level.currentWeapon].v["lockonTime"] / 3 );
lockOnTime = ( level.cobraWeapon[level.currentWeapon].v["lockonTime"] / 1000 );
target_startreticlelockon( targetStruct.targetEntity, lockOnTime );
lockonAliasList = [];
lockonAliasList[0] = "weap_aim9_growl1";
lockonAliasList[1] = "weap_aim9_growl2";
lockonAliasList[2] = "weap_aim9_growl3";
for( i = 0 ; i < lockonAliasList.size ; i++ )
{
thread cobraTarget_holdWait_missileLock_Sound_Stop( targetStruct );
thread cobraTarget_holdWait_missileLock_Sound_Start( targetStruct, lockonAliasList[i] );
lastPhaseTime = getTime();
while ( ( getTime() - lastPhaseTime ) < segmentLength )
wait 0.05;
}
}
cobraTarget_Sidewinder_ReticleLockOn_Stop( targetStruct )
{
target_clearreticlelockon();
assert( isdefined( targetStruct ) );
targetStruct.targetEntity notify ( "missile_lock_ended", level.playervehicle );
targetStruct notify ( "Sidewinder_ReticleLockOn_Stop" );
targetStruct.sideWinder_targeted = undefined;
thread cobraTarget_holdWait_missileLock_Sound_Stop( targetStruct );
thread weaponSystems_EquipLoopSound_Start();
}
health_indicator_create()
{
// red screen overlay
level.cobra_health_overlay = newHudElem();
level.cobra_health_overlay.x = 0;
level.cobra_health_overlay.y = 0;
level.cobra_health_overlay setshader ("overlay_low_health", 640, 480);
level.cobra_health_overlay.alignX = "left";
level.cobra_health_overlay.alignY = "top";
level.cobra_health_overlay.horzAlign = "fullscreen";
level.cobra_health_overlay.vertAlign = "fullscreen";
level.cobra_health_overlay.alpha = 0;
// color changing health icon
level.cobra_health_icon = newHudElem();
level.cobra_health_icon.x = -10;
level.cobra_health_icon.y = -65;
level.cobra_health_icon.alignX = "right";
level.cobra_health_icon.alignY = "bottom";
level.cobra_health_icon.horzAlign = "right";
level.cobra_health_icon.vertAlign = "bottom";
level.cobra_health_icon.foreground = true;
level.cobra_health_icon setshader ( "cobra_health", 128, 48 );
level.cobra_health_icon.alpha = 1;
level.cobra_health_icon.color = (0,1,0);
}
health_indicator_damageWait()
{
level endon ( "cobra_death" );
for (;;)
{
level.playervehicle waittill ( "damage" );
// flash the red overlay on the screen
thread health_indicator_redScreenFlash( level.cobra_health_overlay );
newColor = health_indicator_getColor();
level.cobra_health_icon.color = ( newColor[0], newColor[1], newColor[2] );
}
}
health_indicator_getColor()
{
color = ( 1, 0, 0 );
//define what colors to use
color_severe = [];
color_severe[0] = 1.0;
color_severe[1] = 0.0;
color_severe[2] = 0.0;
color_moderate = [];
color_moderate[0] = 1.0;
color_moderate[1] = 0.5;
color_moderate[2] = 0.0;
color_repaired = [];
color_repaired[0] = 0.0;
color_repaired[1] = 1.0;
color_repaired[2] = 0.0;
//default color
SetValue = [];
SetValue[0] = color_severe[0];
SetValue[1] = color_severe[1];
SetValue[2] = color_severe[2];
//define where the non blend points are
severe = 0;
moderate = (level.playervehicle_starting_health / 2);
repaired = level.playervehicle_starting_health;
iPercentage = undefined;
difference = undefined;
increment = undefined;
value = level.playervehicle.health;
if ( ( value > severe ) && ( value <= moderate ) )
{
iPercentage = int( value * ( 100 / moderate ) );
for ( colorIndex = 0 ; colorIndex < SetValue.size ; colorIndex++ )
{
difference = ( color_moderate[colorIndex] - color_severe[colorIndex] );
increment = ( difference / 100 );
SetValue[colorIndex] = color_severe[colorIndex] + ( increment * iPercentage );
}
}
else if ( ( value > moderate ) && ( value <= repaired ) )
{
iPercentage = int( ( value - moderate ) * ( 100 / ( repaired - moderate ) ) );
for ( colorIndex = 0 ; colorIndex < SetValue.size ; colorIndex++ )
{
difference = ( color_repaired[colorIndex] - color_moderate[colorIndex] );
increment = ( difference / 100 );
SetValue[colorIndex] = color_moderate[colorIndex] + ( increment * iPercentage );
}
}
return SetValue;
}
health_warningSound_Start()
{
level endon ( "cobra_death" );
if ( isdefined( level.lowhealth_warning_playing ) )
return;
level.lowhealth_warning_playing = true;
level.player thread play_loop_sound_on_entity( "alarm_cobra_death_imminent" );
}
health_warningSound_Stop()
{
level.player notify ( "stop sound" + "alarm_cobra_death_imminent" );
level.lowhealth_warning_playing = undefined;
}
health_leak()
{
level endon ( "cobra_death" );
level.playervehicle endon ( "stop_health_leak" );
for (;;)
{
if ( level.playervehicle.health - level.playervehicle_healthLeakIncrement <= 0 )
{
thread cobra_death();
return;
}
level.playervehicle.health -= level.playervehicle_healthLeakIncrement;
level.stats["damage_taken"] += level.playervehicle_healthLeakIncrement;
level.playervehicle notify ( "damage" );
wait level.playervehicle_healthLeakRate;
}
}
health_indicator_redScreenFlash( overlay )
{
level notify ( "redScreenFlash" );
level endon ( "redScreenFlash" );
overlay fadeOverTime( 0.1 );
overlay.alpha = 1;
wait 0.2;
overlay fadeOverTime( 0.5 );
overlay.alpha = 0;
}
health_removeHudElems()
{
level waittill ( "cobra_death" );
// remove hud elements when player dies
level.controller_layout destroy();
level.weapon_hud destroy();
}
health_Regen_Station()
{
level endon ( "cobra_death" );
for (;;)
{
level waittill ( "health_regen" );
if ( level.playervehicle.health >= level.playervehicle_starting_health )
continue;
// add health
level.playervehicle.health += level.playervehicle_healthRegenIncrement;
if ( level.playervehicle.health > level.playervehicle_starting_health )
level.playervehicle.health = level.playervehicle_starting_health;
if ( level.playervehicle.health > level.playervehicle_healthWarning_value )
{
thread health_warningSound_Stop();
level.playervehicle notify ( "stop_health_leak" );
}
newColor = health_indicator_getColor();
level.cobra_health_icon.color = ( newColor[0], newColor[1], newColor[2] );
level.player playLocalSound( "cobra_health_pickup" );
wait level.playervehicle_healthRegenRate;
}
}
health_think()
{
thread health_removeHudElems();
fatalImpactRate = 1500;
thread health_Regen_Station();
for (;;)
{
level.playervehicle waittill( "veh_collision", velocity, collisionNormal );
prof_begin( "cobrapilot_health_system" );
/*
Impending Collision Notify
self waittill( "veh_predictedcollision", velocity, collisionNormal );
(use dvar g_helicopterLookaheadTime to specify how far ahead to check for impending collisions)
*/
impactVelocity = vectordot( velocity, collisionNormal );
slideVelocity = length( velocity - ( vectorscale( collisionNormal, impactVelocity ) ) );
impactVelocity = abs( impactVelocity );
// reduce damage from slide velocity
slideVelocity = ( slideVelocity / 2 );
impactAmount = impactVelocity;
if ( slideVelocity > impactVelocity )
impactAmount = slideVelocity;
//cap the impact rate to not exceed fatalImpactRate since it wont mater at that point anyways
if ( impactAmount > fatalImpactRate )
impactAmount = fatalImpactRate;
damage = int( impactAmount * ( level.playervehicle_starting_health / fatalImpactRate ) );
if ( damage <= 200 )
{
prof_end( "cobrapilot_health_system" );
continue;
}
directionOfImpact = vectorscale( collisionNormal, -1 );
directionOfImpact = level.playervehicle.origin + directionOfImpact;
prof_end( "cobrapilot_health_system" );
level.stats["damage_taken"] += damage;
bDeath = false;
if ( ( level.playervehicle.health - damage ) <= 0 )
bDeath = true;
else
{
level.player playLocalSound( "helicopter_collide" );
level.playervehicle.health -= damage;
if ( level.playervehicle.health <= level.playervehicle_healthWarning_value )
{
thread health_warningSound_Start();
thread health_leak();
}
level.playervehicle joltbody( directionOfImpact, ( damage / 1900 ) );
}
level.playervehicle notify ( "damage" );
if ( bDeath )
{
cobra_death();
return;
}
wait 0.25;
}
}
cobra_death()
{
level.player playLocalSound( "helicopter_crash" );
level.playervehicle.health = 1;
level.playervehicle useby(level.player);
level.playervehicle hide();
level.player enablehealthshield( false );
level notify ( "cobra_death" );
fxOrigin = level.player.origin;
playfx( level.player_death_fx, fxOrigin );
level.player DoDamage ( level.player.health + 500, level.player.origin );
level.player enablehealthshield( true );
}
incommingMissile_Think()
{
level endon ( "cobra_death" );
thread missileIndicator_MissileFlashNotifies();
for (;;)
{
level.playervehicle waittill ( "incomming_missile", eMissile );
assert( isdefined( eMissile ) );
thread missileIndicator( eMissile );
thread incommingMissile_Missile_Death( eMissile );
thread incommingMissile_Sound_Start();
}
}
incommingMissile_Missile_Death( eMissile )
{
level endon ( "cobra_death" );
eMissile waittill ( "death" );
incommingMissile_Sound_Stop();
}
incommingMissile_Sound_Start()
{
if ( !isdefined( level.missile_launched_warning_playing ) )
level.missile_launched_warning_playing = 0;
level.missile_launched_warning_playing++;
if ( level.missile_launched_warning_playing > 1 )
return;
level.player thread play_loop_sound_on_entity( "alarm_cobra_enemy_launch" );
}
incommingMissile_Sound_Stop()
{
level.missile_launched_warning_playing--;
if ( level.missile_launched_warning_playing > 0 )
return;
level.player notify ( "stop sound" + "alarm_cobra_enemy_launch" );
}
ammo_Reload_Station()
{
if ( !isdefined( level.cobraWeapon ) )
return;
if ( level.cobraWeapon.size == 0 )
return;
level endon ( "cobra_death" );
array_thread( getentarray( "ammo_reload", "targetname" ), ::ammo_Reload_Station_Notify, "ammo_reload" );
if ( getdvar( "cobrapilot_unlimited_ammo") == "1" )
return;
for (;;)
{
regenPoint = undefined;
level waittill ( "ammo_reload", regenPoint, trigger );
if ( getdvar( "cobrapilot_farp_mode") == "0" )
{
for( i = 0 ; i < level.cobraWeapon.size ; i++ )
thread ammo_Reload_Station_Add_Ammo( level.cobraWeapon[i] );
wait 0.05;
}
else if ( getdvar( "cobrapilot_farp_mode") == "1" )
{
thread ammo_Reload_Station_AutoLand_HintPrint( regenPoint, trigger );
ammo_Reload_Station_Cinematic_Reload( regenPoint, trigger );
}
}
}
ammo_Reload_Station_Cinematic_Reload( regenPoint, trigger )
{
assert( isdefined( regenPoint ) );
hoverPoint = regenPoint + ( 0, 0, 300 );
level.player freezeControls( true );
level.playervehicle setspeed( 30, 5 );
level.playervehicle setVehGoalPos( hoverPoint, 1 );
level.playervehicle waittill ( "goal" );
level.player unlink();
level.playervehicle useby( level.player );
level.player takeAllWeapons();
viewingEnt = undefined;
viewingEnt = trigger ammo_Reload_Station_Get_Viewing_Ent();
assert( isdefined( viewingEnt ) );
assert( viewingEnt.classname == "script_model" );
assert( viewingEnt.model == "tag_origin" );
level.player playerlinktodelta( viewingEnt, "tag_origin", 1.0 );
wait 0.05;
level.player setPlayerAngles( vectorToAngles( ( level.playervehicle.origin - ( 0, 0, 56 ) ) - viewingEnt.origin ) );
wait 5;
level.player linkto(level.playervehicle );
//level.playervehicle makevehicleusable();
level.playervehicle useby( level.player );
//level.playervehicle makevehicleunusable();
level.playervehicle returnplayercontrol();
level.player freezeControls( false );
}
ammo_Reload_Station_Get_Viewing_Ent()
{
viewingEnt = undefined;
ents = getentarray( "ammo_viewpoint", "targetname" );
viewingEnt = getClosest( self.origin, ents );
assert( isdefined( viewingEnt ) );
return viewingEnt;
}
ammo_Reload_Station_AutoLand_HintPrint( hoverPoint, trigger )
{
if ( isdefined( level.playervehicle.farp_autoland_print_on ) )
return;
level.playervehicle.farp_autoland_print_on = true;
// create print
//iprintlnbold( "in" );
while( level.playervehicle isTouching( trigger ) )
wait 0.05;
// remove print
//iprintlnbold( "out" );
level.playervehicle.farp_autoland_print_on = undefined;
}
ammo_Reload_Station_Notify( notifyString )
{
assert( isdefined( notifyString ) );
level endon ( "cobra_death" );
farpicon = newHudElem();
farpicon setShader( "compass_waypoint_farp", 6, 6 );
farpicon.x = self.origin[ 0 ];
farpicon.y = self.origin[ 1 ];
farpicon.z = self.origin[ 2 ];
farpicon.alpha = .75;
farpicon setwaypoint( true );
trig = undefined;
if ( getdvar( "cobrapilot_farp_mode") == "1" )
{
trig = spawn( "trigger_radius", self.origin, 16, 1500, 1000 );
}
for(;;)
{
vehicle = undefined;
if ( getdvar( "cobrapilot_farp_mode") == "0" )
self waittill ( "trigger", vehicle );
else if ( getdvar( "cobrapilot_farp_mode") == "1" )
{
assert( isdefined( trig ) );
trig waittill ( "trigger", vehicle );
}
if ( !isdefined( vehicle ) )
continue;
if ( vehicle != level.playervehicle )
continue;
regenPoint = self.origin;
if ( isdefined( self.target ) )
{
ent = getent( self.target, "targetname" );
if ( isdefined( ent ) )
regenPoint = ent.origin;
}
if ( isdefined( trig ) )
level notify( notifyString, regenPoint, trig );
else
level notify( notifyString, regenPoint, self );
level notify( "health_regen" );
if ( getdvar( "cobrapilot_farp_mode") == "1" )
{
while( vehicle isTouching( trig ) )
wait 0.05;
}
}
}
ammo_Reload_Station_Add_Ammo( weapon )
{
level endon ( "cobra_death" );
if ( isdefined( weapon.reloading ) )
return;
weapon.reloading = true;
wait randomFloatRange( weapon.v["ammoPickupDelay_Min"], weapon.v["ammoPickupDelay_Max"] );
if ( weapon.v["currentAmmo"] >= weapon.v["maxAmmo"] )
{
weapon.reloading = undefined;
return;
}
// add ammo and update the ammo counter on the hud
weapon.v["currentAmmo"] += weapon.v["ammoPickupIncrement"];
if ( weapon.v["currentAmmo"] > weapon.v["maxAmmo"] )
weapon.v["currentAmmo"] = weapon.v["maxAmmo"];
// attach missiles back onto the chopper since they were detached when fired
for ( i = 0 ; i < weapon.v["ammoPickupIncrement"] ; i++ )
level.playervehicle weaponsSystems_Attach_Weapon( weapon.v["weapon"] );
level.player playLocalSound( "cobra_ammo_reload" );
weapon.v["ammoCounter"] setValue ( weapon.v["currentAmmo"] );
weapon.reloading = undefined;
}
borderwall_method1()
{
// When the player hits the border wall triggers the helicopter controls are taken over and the chopper
// is turned around and flown back into the map boundaries
level endon ( "cobra_death" );
target = getent( self.target, "targetname" );
for(;;)
{
self waittill ( "trigger", vehicle );
if ( vehicle != level.playervehicle )
continue;
normalvec = vectornormalize( target.origin - level.playervehicle.origin );
movetospot = level.playervehicle.origin + vector_multiply( normalvec, 2000 );
movetospot = ( movetospot[0], movetospot[1], level.playervehicle.origin[2] );
level.playervehicle setspeed( 60, 25 );
level.playervehicle setvehgoalpos( movetospot, 0 );
level.playervehicle waittill ( "goal" );
level.playervehicle returnplayercontrol();
}
}
edge_Of_World()
{
// When the player leaves the playable area a warning is printed on the screen.
// The player must re-enter the playable area within a time limit or else the
//mission is failed
level endon ( "cobra_death" );
array_thread( getentarray( "border_inner", "targetname" ), ::edge_Of_World_Notify, "border_inner" );
array_thread( getentarray( "border_outer", "targetname" ), ::edge_Of_World_Notify, "border_outer" );
for (;;)
{
level waittill( "border_outer" );
level notify( "player_out_of_bounds" );
thread edge_Of_World_Warning();
level waittill( "border_inner" );
level notify( "player_in_bounds" );
if ( isdefined( level.edge_of_world_warning ) )
level.edge_of_world_warning destroy();
if ( isdefined( level.edge_of_world_timer ) )
level.edge_of_world_timer destroy();
}
}
edge_Of_World_Notify( notifyString )
{
assert( isdefined( notifyString ) );
level endon ( "cobra_death" );
for(;;)
{
self waittill ( "trigger", vehicle );
if ( vehicle != level.playervehicle )
continue;
level notify( notifyString );
}
}
edge_Of_World_Warning()
{
level notify( "edge_Of_World_Warning" );
level endon( "edge_Of_World_Warning" );
level endon ( "player_in_bounds" );
// max number of seconds player is allowed out of bounds
// when this time is exceeded the mission is failed
outOfBoundsMaxTime = 15;
if ( !isdefined( level.edge_of_world_warning ) )
{
level.edge_of_world_warning = newHudElem();
level.edge_of_world_warning.x = 0;
level.edge_of_world_warning.y = 0;
level.edge_of_world_warning.alignX = "center";
level.edge_of_world_warning.alignY = "middle";
level.edge_of_world_warning.horzAlign = "center";
level.edge_of_world_warning.vertAlign = "middle";
level.edge_of_world_warning.foreground = true;
level.edge_of_world_warning setText( &"COBRAPILOT_EDGE_OF_WORLD_WARNING" );
level.edge_of_world_warning.fontscale = 2;
level.edge_of_world_warning.color = ( 1, 0, 0 );
}
if ( !isdefined( level.edge_of_world_timer ) )
{
level.edge_of_world_timer = newHudElem();
level.edge_of_world_timer.x = 0;
level.edge_of_world_timer.y = 20;
level.edge_of_world_timer.alignX = "center";
level.edge_of_world_timer.alignY = "middle";
level.edge_of_world_timer.horzAlign = "center";
level.edge_of_world_timer.vertAlign = "middle";
level.edge_of_world_timer.foreground = true;
level.edge_of_world_timer.fontscale = 2;
level.edge_of_world_timer.color = ( 1, 0, 0 );
}
level.edge_of_world_timer setTimer( outOfBoundsMaxTime );
level.edge_of_world_warning.alpha = 1;
outOfBoundsTime = getTime();
wait 0.25;
while( getTime() - outOfBoundsTime < outOfBoundsMaxTime * 1000 )
{
wait 0.6;
level.edge_of_world_warning fadeOverTime( 0.2 );
level.edge_of_world_warning.alpha = 0;
level.edge_of_world_timer fadeOverTime( 0.2 );
level.edge_of_world_timer.alpha = 0;
wait 0.2;
level.edge_of_world_warning fadeOverTime( 0.2 );
level.edge_of_world_warning.alpha = 1;
level.edge_of_world_timer fadeOverTime( 0.2 );
level.edge_of_world_timer.alpha = 1;
wait 0.2;
}
edge_Of_World_Fail();
}
edge_Of_World_Fail()
{
setdvar( "ui_deadquote", "@COBRAPILOT_EDGE_OF_WORLD_FAIL" );
maps\_utility::missionFailedWrapper();
}
playLoopSoundForSeeking( alias )
{
org = spawn( "script_origin" , ( 0, 0, 0 ) );
org endon( "death" );
thread delete_on_death( org );
org.origin = level.player.origin;
org.angles = level.player.angles;
org linkto( level.player );
org playloopsound( alias );
self waittill( "stop sound" + alias );
org stoploopsound( alias );
org delete();
}
#using_animtree( "vehicles" );
gunner_spawn()
{
gunner = spawn( "script_model", level.playervehicle getTagOrigin( "tag_gunner" ) );
gunner.angles = level.playervehicle getTagAngles( "tag_gunner" );
gunner linkto( level.playervehicle, "tag_gunner" );
gunner setModel( "body_complete_sp_cobra_pilot_desert_zack" );
gunner useAnimTree( #animtree );
thread gunner_think( gunner );
}
gunner_think( gunner )
{
level.playervehicle endon( "death" );
level.player endon( "death" );
gunner thread gunner_lookAtTarget();
for (;;)
{
if ( !flag( "gunner_use_turret" ) )
{
level waittill( "gunner_use_turret" );
wait randomfloatrange( 0.5, 1.2 );
continue;
}
eTarget = level.playervehicle getEnemyTarget( level.GunnerTargetRange, level.GunnerTargetFOV, true, true );
if ( isdefined( eTarget ) )
{
gunner thread gunner_lookAtTarget( eTarget );
level.playervehicle thread shootEnemyTarget_Bullets( eTarget );
}
else if ( getdvar( "cobrapilot_debug") == "1" )
{
iprintln( "no valid targets" );
gunner thread gunner_lookAtTarget();
}
wait 2;
}
}
gunner_lookAtTarget( eTarget )
{
level.playervehicle endon( "death" );
level.player endon( "death" );
self notify( "stop_looking_at_target" );
self endon( "stop_looking_at_target" );
if ( isdefined( eTarget ) )
eTarget endon( "death" );
for (;;)
{
if ( isdefined( self.lookingAtTarget ) && isdefined( eTarget ) )
blendTime = 0.1;
else
blendTime = 1.0;
self.lookingAtTarget = true;
blendAmount = self gunner_getBlendNumber( eTarget );
self setanim( %cobra_copilot_idle_l, blendAmount[0], blendTime );
self setanim( %cobra_copilot_idle, blendAmount[1], blendTime );
self setanim( %cobra_copilot_idle_r, blendAmount[2], blendTime );
if ( !isdefined( eTarget ) )
{
self.lookingAtTarget = undefined;
return;
}
wait blendTime;
}
}
gunner_getBlendNumber( eTarget )
{
blendAmount = [];
blendAmount[0] = 0.0; // left
blendAmount[1] = 1.0; // forward
blendAmount[2] = 0.0; // right
if ( !isdefined( eTarget ) )
return blendAmount;
//prof_begin( "cobrapilot_ai" );
forward = anglesToForward( level.playervehicle.angles );
right = anglesToRight( level.playervehicle.angles );
t = ( eTarget.origin - level.playervehicle.origin );
s = vectorDot( t, right );
f = vectorDot( t, forward );
assert( f != 0 );
value = ( s / f );
if ( value < 0 )
{
// turn head to the left
value = abs( value );
if ( value > 1.0 )
value = 1.0;
blendAmount[0] = value; // left
blendAmount[1] = 1 - value; // forward
blendAmount[2] = 0.0; // right
}
else if ( value > 0 )
{
// turn head to the right
value = abs( value );
if ( value > 1.0 )
value = 1.0;
blendAmount[0] = 0.0; // left
blendAmount[1] = 1 - value; // forward
blendAmount[2] = value; // right
}
//prof_end( "cobrapilot_ai" );
return blendAmount;
}
missileIndicator( eMissile )
{
missileIndicator = spawnstruct();
missileIndicator.eMissile = eMissile;
target_set( missileIndicator.eMissile );
target_setShader( missileIndicator.eMissile, level.missileHintIndicator_Missile );
target_setOffscreenShader( missileIndicator.eMissile, level.missileHintIndicator_Missile_Offscreen );
// LEFT arrow
missileIndicator.arrowLeft = newHudElem();
missileIndicator.arrowLeft.x = -160;
missileIndicator.arrowLeft.y = 0;
missileIndicator.arrowLeft.alignX = "center";
missileIndicator.arrowLeft.alignY = "middle";
missileIndicator.arrowLeft.horzAlign = "center";
missileIndicator.arrowLeft.vertAlign = "middle";
missileIndicator.arrowLeft.foreground = true;
missileIndicator.arrowLeft.alpha = 0;
missileIndicator.arrowLeft setshader ( level.missileHintIndicator_Arrow["left"], 80, 160 );
// RIGHT arrow
missileIndicator.arrowRight = newHudElem();
missileIndicator.arrowRight.x = 160;
missileIndicator.arrowRight.y = 0;
missileIndicator.arrowRight.alignX = "center";
missileIndicator.arrowRight.alignY = "middle";
missileIndicator.arrowRight.horzAlign = "center";
missileIndicator.arrowRight.vertAlign = "middle";
missileIndicator.arrowRight.foreground = true;
missileIndicator.arrowRight.alpha = 0;
missileIndicator.arrowRight setshader ( level.missileHintIndicator_Arrow["right"], 80, 160 );
// FORWARD arrow
missileIndicator.arrowForward = newHudElem();
missileIndicator.arrowForward.x = 0;
missileIndicator.arrowForward.y = -160;
missileIndicator.arrowForward.alignX = "center";
missileIndicator.arrowForward.alignY = "middle";
missileIndicator.arrowForward.horzAlign = "center";
missileIndicator.arrowForward.vertAlign = "middle";
missileIndicator.arrowForward.foreground = true;
missileIndicator.arrowForward.alpha = 0;
missileIndicator.arrowForward setshader( level.missileHintIndicator_Arrow["forward"], 160, 80 );
// BACK arrow
missileIndicator.arrowBack = newHudElem();
missileIndicator.arrowBack.x = 0;
missileIndicator.arrowBack.y = 160;
missileIndicator.arrowBack.alignX = "center";
missileIndicator.arrowBack.alignY = "middle";
missileIndicator.arrowBack.horzAlign = "center";
missileIndicator.arrowBack.vertAlign = "middle";
missileIndicator.arrowBack.foreground = true;
missileIndicator.arrowBack.alpha = 0;
missileIndicator.arrowBack setshader( level.missileHintIndicator_Arrow["back"], 160, 80 );
thread missileIndicator_MissileDeath( missileIndicator );
thread missileIndicator_MissileFlash( missileIndicator );
// find where the missile is relative to the player so it can draw the appropriate arrows
eMissile endon( "death" );
level.player endon( "death" );
level.playervehicle endon( "death" );
for (;;)
{
// uses level.player angles instead of the cobra's angles so that it works when the player is in freelook
level waittill( "incomming_missile_blink_on" );
prof_begin( "cobrapilot_weapons_systems" );
forwardvec = anglestoforward( level.player.angles );
backvec = vectorScale( forwardvec, -1 );
rightvec = anglestoright( level.player.angles );
leftvec = vectorScale( rightVec, -1 );
vecToMissile = vectorNormalize( missileIndicator.eMissile.origin - ( level.player getOrigin() ) );
// forward arrow
missileIndicator.arrowForward.alpha = 0;
vecdot = vectordot( forwardvec, vecToMissile );
if ( vecdot > level.cosine["45"] )
missileIndicator.arrowForward.alpha = 1;
// back arrow
missileIndicator.arrowBack.alpha = 0;
vecdot = vectordot( backvec, vecToMissile );
if ( vecdot > level.cosine["45"] )
missileIndicator.arrowBack.alpha = 1;
// left arrow
missileIndicator.arrowLeft.alpha = 0;
vecdot = vectordot( leftvec, vecToMissile );
if ( vecdot > level.cosine["45"] )
missileIndicator.arrowLeft.alpha = 1;
// right arrow
missileIndicator.arrowRight.alpha = 0;
vecdot = vectordot( rightvec, vecToMissile );
if ( vecdot > level.cosine["45"] )
missileIndicator.arrowRight.alpha = 1;
prof_end( "cobrapilot_weapons_systems" );
level waittill( "incomming_missile_blink_off" );
missileIndicator.arrowForward.alpha = 0;
missileIndicator.arrowBack.alpha = 0;
missileIndicator.arrowLeft.alpha = 0;
missileIndicator.arrowRight.alpha = 0;
}
}
missileIndicator_MissileFlash( missileIndicator )
{
level.playervehicle endon( "death" );
assert( isdefined( missileIndicator.eMissile ) );
missileIndicator.eMissile endon( "death" );
for(;;)
{
level waittill( "incomming_missile_blink_off" );
target_setShader( missileIndicator.eMissile, level.missileHintIndicator_Missile_Flash );
target_setOffscreenShader( missileIndicator.eMissile, level.missileHintIndicator_Missile_Flash );
level waittill( "incomming_missile_blink_on" );
target_setShader( missileIndicator.eMissile, level.missileHintIndicator_Missile );
target_setOffscreenShader( missileIndicator.eMissile, level.missileHintIndicator_Missile_Offscreen );
}
}
missileIndicator_MissileDeath( missileIndicator )
{
level.playervehicle endon( "death" );
assert( isdefined( missileIndicator.eMissile ) );
missileIndicator.eMissile waittill( "death" );
if ( isdefined( missileIndicator.arrowLeft ) )
missileIndicator.arrowLeft destroy();
if ( isdefined( missileIndicator.arrowRight ) )
missileIndicator.arrowRight destroy();
if ( isdefined( missileIndicator.arrowForward ) )
missileIndicator.arrowForward destroy();
if ( isdefined( missileIndicator.arrowBack ) )
missileIndicator.arrowBack destroy();
}
missileIndicator_MissileFlashNotifies()
{
level.playervehicle endon( "death" );
level.player endon( "death" );
for(;;)
{
wait 0.2;
level notify( "incomming_missile_blink_off" );
wait 0.1;
level notify( "incomming_missile_blink_on" );
}
}
debug_thread()
{
/*
wait 1;
debugMissile = spawn( "script_origin", ( 0, 0, 1000 ) );
thread missileIndicator( debugMissile );
*/
/*
wait 5;
for( i = 0 ; i < level.cobraTarget.size ; i++ )
level.cobraTarget[i].targetEntity notify( "death" );
*/
/*
for (;;)
{
wait 4;
level.playervehicle notify ( "turret_fire" );
}
*/
/*
for(;;)
{
level.player notify( "menuresponse", undefined, "undefined" );
wait 0.1;
}
*/
}
Reference in a new issue Copy permalink