From 18b5824147abdf6cf6eedcafe6f67c8c47ebf2f3 Mon Sep 17 00:00:00 2001 From: JezuzLizard Date: Wed, 29 Apr 2020 11:02:01 -0700 Subject: [PATCH] properly uploaded mp scripts instead of zm versions Checked_weapon_utils for both mp and zm. --- patch_mp/maps/mp/gametypes/_callbacksetup.gsc | 48 +- .../maps/mp/gametypes/_damagefeedback.gsc | 4 +- patch_mp/maps/mp/gametypes/_dev.gsc | 3500 ++++++++++++++++- patch_mp/maps/mp/gametypes/_gameobjects.gsc | 505 ++- .../maps/mp/gametypes/_globallogic_actor.gsc | 34 +- .../maps/mp/gametypes/_globallogic_audio.gsc | 256 +- .../mp/gametypes/_globallogic_defaults.gsc | 103 +- .../maps/mp/gametypes/_globallogic_player.gsc | 1518 ++++--- .../maps/mp/gametypes/_globallogic_score.gsc | 853 +++- .../maps/mp/gametypes/_globallogic_spawn.gsc | 321 +- .../maps/mp/gametypes/_globallogic_ui.gsc | 219 +- .../maps/mp/gametypes/_globallogic_utils.gsc | 76 +- .../mp/gametypes/_globallogic_vehicle.gsc | 167 +- patch_mp/maps/mp/gametypes/_gv_actions.gsc | 995 ----- patch_mp/maps/mp/gametypes/_healthoverlay.gsc | 4 +- patch_mp/maps/mp/gametypes/_hostmigration.gsc | 346 +- patch_mp/maps/mp/gametypes/_hud.gsc | 53 +- patch_mp/maps/mp/gametypes/_hud_message.gsc | 232 +- patch_mp/maps/mp/gametypes/_hud_util.gsc | 91 +- patch_mp/maps/mp/gametypes/_menus.gsc | 15 +- patch_mp/maps/mp/gametypes/_scoreboard.gsc | 7 - patch_mp/maps/mp/gametypes/_shellshock.gsc | 14 +- patch_mp/maps/mp/gametypes/_spawning.gsc | 347 +- patch_mp/maps/mp/gametypes/_spawnlogic.gsc | 265 +- patch_mp/maps/mp/gametypes/_weapon_utils.gsc | 49 +- patch_mp/maps/mp/gametypes/_weaponobjects.gsc | 353 +- patch_mp/maps/mp/gametypes/_weapons.gsc | 821 ++-- patch_mp/readme.md | 3 +- .../maps/mp/gametypes_zm/_weapon_utils.gsc | 35 +- patch_zm/readme.md | 2 +- 30 files changed, 7796 insertions(+), 3440 deletions(-) delete mode 100644 patch_mp/maps/mp/gametypes/_gv_actions.gsc diff --git a/patch_mp/maps/mp/gametypes/_callbacksetup.gsc b/patch_mp/maps/mp/gametypes/_callbacksetup.gsc index b96ee03..6fdc5e3 100644 --- a/patch_mp/maps/mp/gametypes/_callbacksetup.gsc +++ b/patch_mp/maps/mp/gametypes/_callbacksetup.gsc @@ -1,7 +1,8 @@ -#include maps/mp/gametypes_zm/_hostmigration; -#include maps/mp/gametypes_zm/_globallogic_actor; -#include maps/mp/gametypes_zm/_globallogic_player; -#include maps/mp/gametypes_zm/_globallogic; +#include maps/mp/gametypes/_hostmigration; +#include maps/mp/gametypes/_globallogic_vehicle; +#include maps/mp/gametypes/_globallogic_actor; +#include maps/mp/gametypes/_globallogic_player; +#include maps/mp/gametypes/_globallogic; #include maps/mp/_audio; #include maps/mp/_utility; @@ -29,6 +30,7 @@ codecallback_playerconnect() codecallback_playerdisconnect() { self notify( "disconnect" ); + level notify( "disconnect" ); client_num = self getentitynumber(); [[ level.callbackplayerdisconnect ]](); } @@ -49,14 +51,6 @@ codecallback_hostmigrationsave() [[ level.callbackhostmigrationsave ]](); } -codecallback_prehostmigrationsave() -{ -/# - println( "****CodeCallback_PreHostMigrationSave****" ); -#/ - [[ level.callbackprehostmigrationsave ]](); -} - codecallback_playermigrated() { /# @@ -106,6 +100,7 @@ codecallback_vehicledamage( einflictor, eattacker, idamage, idflags, smeansofdea codecallback_vehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, timeoffset ) { + [[ level.callbackvehicleradiusdamage ]]( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, timeoffset ); } codecallback_faceeventnotify( notify_msg, ent ) @@ -163,19 +158,20 @@ setupcallbacks() setdefaultcallbacks() { - level.callbackstartgametype = ::maps/mp/gametypes_zm/_globallogic::callback_startgametype; - level.callbackplayerconnect = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerconnect; - level.callbackplayerdisconnect = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerdisconnect; - level.callbackplayerdamage = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerdamage; - level.callbackplayerkilled = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerkilled; - level.callbackplayermelee = ::maps/mp/gametypes_zm/_globallogic_player::callback_playermelee; - level.callbackplayerlaststand = ::maps/mp/gametypes_zm/_globallogic_player::callback_playerlaststand; - level.callbackactordamage = ::maps/mp/gametypes_zm/_globallogic_actor::callback_actordamage; - level.callbackactorkilled = ::maps/mp/gametypes_zm/_globallogic_actor::callback_actorkilled; - level.callbackplayermigrated = ::maps/mp/gametypes_zm/_globallogic_player::callback_playermigrated; - level.callbackhostmigration = ::maps/mp/gametypes_zm/_hostmigration::callback_hostmigration; - level.callbackhostmigrationsave = ::maps/mp/gametypes_zm/_hostmigration::callback_hostmigrationsave; - level.callbackprehostmigrationsave = ::maps/mp/gametypes_zm/_hostmigration::callback_prehostmigrationsave; + level.callbackstartgametype = ::maps/mp/gametypes/_globallogic::callback_startgametype; + level.callbackplayerconnect = ::maps/mp/gametypes/_globallogic_player::callback_playerconnect; + level.callbackplayerdisconnect = ::maps/mp/gametypes/_globallogic_player::callback_playerdisconnect; + level.callbackplayerdamage = ::maps/mp/gametypes/_globallogic_player::callback_playerdamage; + level.callbackplayerkilled = ::maps/mp/gametypes/_globallogic_player::callback_playerkilled; + level.callbackplayermelee = ::maps/mp/gametypes/_globallogic_player::callback_playermelee; + level.callbackplayerlaststand = ::maps/mp/gametypes/_globallogic_player::callback_playerlaststand; + level.callbackactordamage = ::maps/mp/gametypes/_globallogic_actor::callback_actordamage; + level.callbackactorkilled = ::maps/mp/gametypes/_globallogic_actor::callback_actorkilled; + level.callbackvehicledamage = ::maps/mp/gametypes/_globallogic_vehicle::callback_vehicledamage; + level.callbackvehicleradiusdamage = ::maps/mp/gametypes/_globallogic_vehicle::callback_vehicleradiusdamage; + level.callbackplayermigrated = ::maps/mp/gametypes/_globallogic_player::callback_playermigrated; + level.callbackhostmigration = ::maps/mp/gametypes/_hostmigration::callback_hostmigration; + level.callbackhostmigrationsave = ::maps/mp/gametypes/_hostmigration::callback_hostmigrationsave; } abortlevel() @@ -188,8 +184,8 @@ abortlevel() level.callbackplayerdisconnect = ::callbackvoid; level.callbackplayerdamage = ::callbackvoid; level.callbackplayerkilled = ::callbackvoid; - level.callbackplayermelee = ::callbackvoid; level.callbackplayerlaststand = ::callbackvoid; + level.callbackplayermelee = ::callbackvoid; level.callbackactordamage = ::callbackvoid; level.callbackactorkilled = ::callbackvoid; level.callbackvehicledamage = ::callbackvoid; diff --git a/patch_mp/maps/mp/gametypes/_damagefeedback.gsc b/patch_mp/maps/mp/gametypes/_damagefeedback.gsc index 5bf5a09..39ece6a 100644 --- a/patch_mp/maps/mp/gametypes/_damagefeedback.gsc +++ b/patch_mp/maps/mp/gametypes/_damagefeedback.gsc @@ -37,7 +37,7 @@ updatedamagefeedback( mod, inflictor, perkfeedback ) switch( inflictor.soundmod ) { case "player": - self thread playhitsound( mod, "mpl_hit_alert" ); + self playlocalsound( "mpl_hit_alert" ); break; case "heli": self thread playhitsound( mod, "mpl_hit_alert_air" ); @@ -58,7 +58,7 @@ updatedamagefeedback( mod, inflictor, perkfeedback ) break; } } - else self thread playhitsound( mod, "mpl_hit_alert_low" ); + else self playlocalsound( "mpl_hit_alert_low" ); } if ( isDefined( perkfeedback ) ) { diff --git a/patch_mp/maps/mp/gametypes/_dev.gsc b/patch_mp/maps/mp/gametypes/_dev.gsc index 86a3a5e..0c8ba67 100644 --- a/patch_mp/maps/mp/gametypes/_dev.gsc +++ b/patch_mp/maps/mp/gametypes/_dev.gsc @@ -1,17 +1,247 @@ +#include maps/mp/bots/_bot; +#include maps/mp/killstreaks/_supplydrop; +#include maps/mp/killstreaks/_killstreakrules; +#include maps/mp/killstreaks/_radar; +#include maps/mp/killstreaks/_helicopter_gunner; +#include maps/mp/killstreaks/_helicopter; +#include maps/mp/gametypes/_killcam; +#include maps/mp/gametypes/_hud_message; +#include maps/mp/gametypes/_rank; +#include maps/mp/gametypes/_globallogic; +#include maps/mp/gametypes/_globallogic_utils; +#include maps/mp/killstreaks/_killstreaks; +#include maps/mp/gametypes/_globallogic_score; +#include maps/mp/gametypes/_dev_class; #include maps/mp/_utility; #include common_scripts/utility; init() { /# + if ( sessionmodeiszombiesgame() ) + { + for ( ;; ) + { + updatedevsettingszm(); + wait 0,5; + } + return; + } + if ( getDvar( "scr_showspawns" ) == "" ) + { + setdvar( "scr_showspawns", "0" ); + } + if ( getDvar( "scr_showstartspawns" ) == "" ) + { + setdvar( "scr_showstartspawns", "0" ); + } + if ( getDvar( "scr_botsHasPlayerWeapon" ) == "" ) + { + setdvar( "scr_botsHasPlayerWeapon", "0" ); + } + if ( getDvar( "scr_botsGrenadesOnly" ) == "" ) + { + setdvar( "scr_botsGrenadesOnly", "0" ); + } + if ( getDvar( "scr_botsSpecialGrenadesOnly" ) == "" ) + { + setdvar( "scr_botsSpecialGrenadesOnly", "0" ); + } + if ( getDvar( "scr_devHeliPathsDebugDraw" ) == "" ) + { + setdvar( "scr_devHeliPathsDebugDraw", "0" ); + } + if ( getDvar( "scr_devStrafeRunPathDebugDraw" ) == "" ) + { + setdvar( "scr_devStrafeRunPathDebugDraw", "0" ); + } + if ( getDvar( "scr_show_hq_spawns" ) == "" ) + { + setdvar( "scr_show_hq_spawns", "" ); + } + if ( getDvar( "scr_testScriptRuntimeError" ) == "" ) + { + setdvar( "scr_testScriptRuntimeError", "0" ); + } + precachemodel( "defaultactor" ); + precachestring( &"testPlayerScoreForTan" ); + thread testscriptruntimeerror(); + thread testdvars(); + thread addtestclients(); + thread addenemyheli(); + thread addenemyu2(); + thread addtestcarepackage(); + thread removetestclients(); + thread watch_botsdvars(); + thread devhelipathdebugdraw(); + thread devstraferunpathdebugdraw(); + thread maps/mp/gametypes/_dev_class::dev_cac_init(); + thread maps/mp/gametypes/_globallogic_score::setplayermomentumdebug(); + setdvar( "scr_giveperk", "" ); + setdvar( "scr_forceevent", "" ); + setdvar( "scr_draw_triggers", "0" ); + thread engagement_distance_debug_toggle(); + thread equipment_dev_gui(); + thread grenade_dev_gui(); + setdvar( "debug_dynamic_ai_spawning", "0" ); + level.bot_overlay = 0; + level.bot_threat = 0; + level.bot_path = 0; + level.dem_spawns = []; + while ( level.gametype == "dem" ) + { + extra_spawns = []; + extra_spawns[ 0 ] = "mp_dem_spawn_attacker_a"; + extra_spawns[ 1 ] = "mp_dem_spawn_attacker_b"; + extra_spawns[ 2 ] = "mp_dem_spawn_defender_a"; + extra_spawns[ 3 ] = "mp_dem_spawn_defender_b"; + i = 0; + while ( i < extra_spawns.size ) + { + points = getentarray( extra_spawns[ i ], "classname" ); + if ( isDefined( points ) && points.size > 0 ) + { + level.dem_spawns = arraycombine( level.dem_spawns, points, 1, 0 ); + } + i++; + } + } + thread onplayerconnect(); for ( ;; ) { - updatedevsettingszm(); + updatedevsettings(); wait 0,5; #/ } } +onplayerconnect() +{ +/# + for ( ;; ) + { + level waittill( "connecting", player ); +#/ + } +} + +updatehardpoints() +{ +/# + keys = getarraykeys( level.killstreaks ); + i = 0; + while ( i < keys.size ) + { + if ( !isDefined( level.killstreaks[ keys[ i ] ].devdvar ) ) + { + i++; + continue; + } + else + { + dvar = level.killstreaks[ keys[ i ] ].devdvar; + if ( getDvarInt( dvar ) == 1 ) + { + _a148 = level.players; + _k148 = getFirstArrayKey( _a148 ); + while ( isDefined( _k148 ) ) + { + player = _a148[ _k148 ]; + if ( isDefined( level.usingmomentum ) && level.usingmomentum && isDefined( level.usingscorestreaks ) && level.usingscorestreaks ) + { + player maps/mp/killstreaks/_killstreaks::givekillstreak( keys[ i ] ); + } + else + { + if ( player is_bot() ) + { + player.bot[ "killstreaks" ] = []; + player.bot[ "killstreaks" ][ 0 ] = maps/mp/killstreaks/_killstreaks::getkillstreakmenuname( keys[ i ] ); + killstreakweapon = maps/mp/killstreaks/_killstreaks::getkillstreakweapon( keys[ i ] ); + player maps/mp/killstreaks/_killstreaks::givekillstreakweapon( killstreakweapon, 1 ); + maps/mp/gametypes/_globallogic_score::_setplayermomentum( player, 2000 ); + break; + } + else + { + player maps/mp/killstreaks/_killstreaks::givekillstreak( keys[ i ] ); + } + } + _k148 = getNextArrayKey( _a148, _k148 ); + } + setdvar( dvar, "0" ); + } + } + i++; +#/ + } +} + +warpalltohost( team ) +{ +/# + host = gethostplayer(); + players = get_players(); + origin = host.origin; + nodes = getnodesinradius( origin, 128, 32, 128, "Path" ); + angles = host getplayerangles(); + yaw = ( 0, angles[ 1 ], 0 ); + forward = anglesToForward( yaw ); + spawn_origin = origin + ( forward * 128 ) + vectorScale( ( 0, 1, 0 ), 16 ); + if ( !bullettracepassed( host geteye(), spawn_origin, 0, host ) ) + { + spawn_origin = undefined; + } + i = 0; + while ( i < players.size ) + { + if ( players[ i ] == host ) + { + i++; + continue; + } + else if ( isDefined( team ) ) + { + if ( team == "enemies_host" && host.team == players[ i ].team ) + { + i++; + continue; + } + else + { + if ( team == "friendlies_host" && host.team != players[ i ].team ) + { + i++; + continue; + } + } + else + { + if ( isDefined( spawn_origin ) ) + { + players[ i ] setorigin( spawn_origin ); + i++; + continue; + } + else if ( nodes.size > 0 ) + { + node = random( nodes ); + players[ i ] setorigin( node.origin ); + i++; + continue; + } + else + { + players[ i ] setorigin( origin ); + } + } + } + i++; + } + setdvar( "scr_playerwarp", "" ); +#/ +} + updatedevsettingszm() { /# @@ -40,27 +270,27 @@ updatedevsettingszm() structs = getstructarray( "initial_spawn", "script_noteworthy" ); while ( isDefined( structs ) ) { - _a46 = structs; - _k46 = getFirstArrayKey( _a46 ); - while ( isDefined( _k46 ) ) + _a260 = structs; + _k260 = getFirstArrayKey( _a260 ); + while ( isDefined( _k260 ) ) { - struct = _a46[ _k46 ]; + struct = _a260[ _k260 ]; while ( isDefined( struct.script_string ) ) { tokens = strtok( struct.script_string, " " ); - _a51 = tokens; - _k51 = getFirstArrayKey( _a51 ); - while ( isDefined( _k51 ) ) + _a265 = tokens; + _k265 = getFirstArrayKey( _a265 ); + while ( isDefined( _k265 ) ) { - token = _a51[ _k51 ]; + token = _a265[ _k265 ]; if ( token == match_string ) { spawnpoints[ spawnpoints.size ] = struct; } - _k51 = getNextArrayKey( _a51, _k51 ); + _k265 = getNextArrayKey( _a265, _k265 ); } } - _k46 = getNextArrayKey( _a46, _k46 ); + _k260 = getNextArrayKey( _a260, _k260 ); } } if ( !isDefined( spawnpoints ) || spawnpoints.size == 0 ) @@ -80,16 +310,16 @@ updatedevsettingszm() } else { - averageorigin = ( 0, 0, 0 ); - averageangles = ( 0, 0, 0 ); - _a80 = spawnpoints; - _k80 = getFirstArrayKey( _a80 ); - while ( isDefined( _k80 ) ) + averageorigin = ( 0, 1, 0 ); + averageangles = ( 0, 1, 0 ); + _a294 = spawnpoints; + _k294 = getFirstArrayKey( _a294 ); + while ( isDefined( _k294 ) ) { - spawnpoint = _a80[ _k80 ]; + spawnpoint = _a294[ _k294 ]; averageorigin += spawnpoint.origin / numpoints; averageangles += spawnpoint.angles / numpoints; - _k80 = getNextArrayKey( _a80, _k80 ); + _k294 = getNextArrayKey( _a294, _k294 ); } level.players[ 0 ] setplayerangles( averageangles ); level.players[ 0 ] setorigin( averageorigin ); @@ -100,3 +330,3237 @@ updatedevsettingszm() } } } + +updatedevsettings() +{ +/# + show_spawns = getDvarInt( "scr_showspawns" ); + show_start_spawns = getDvarInt( "scr_showstartspawns" ); + player = gethostplayer(); + if ( show_spawns >= 1 ) + { + show_spawns = 1; + } + else + { + show_spawns = 0; + } + if ( show_start_spawns >= 1 ) + { + show_start_spawns = 1; + } + else + { + show_start_spawns = 0; + } + if ( !isDefined( level.show_spawns ) || level.show_spawns != show_spawns ) + { + level.show_spawns = show_spawns; + setdvar( "scr_showspawns", level.show_spawns ); + if ( level.show_spawns ) + { + showspawnpoints(); + } + else + { + hidespawnpoints(); + } + } + if ( !isDefined( level.show_start_spawns ) || level.show_start_spawns != show_start_spawns ) + { + level.show_start_spawns = show_start_spawns; + setdvar( "scr_showstartspawns", level.show_start_spawns ); + if ( level.show_start_spawns ) + { + showstartspawnpoints(); + } + else + { + hidestartspawnpoints(); + } + } + updateminimapsetting(); + if ( level.players.size > 0 ) + { + updatehardpoints(); + if ( getDvar( "scr_playerwarp" ) == "host" ) + { + warpalltohost(); + } + else if ( getDvar( "scr_playerwarp" ) == "enemies_host" ) + { + warpalltohost( getDvar( "scr_playerwarp" ) ); + } + else if ( getDvar( "scr_playerwarp" ) == "friendlies_host" ) + { + warpalltohost( getDvar( "scr_playerwarp" ) ); + } + else if ( getDvar( "scr_playerwarp" ) == "next_start_spawn" ) + { + players = get_players(); + setdvar( "scr_playerwarp", "" ); + if ( !isDefined( level.devgui_start_spawn_index ) ) + { + level.devgui_start_spawn_index = 0; + } + player = gethostplayer(); + spawns = level.spawn_start[ player.pers[ "team" ] ]; + if ( !isDefined( spawns ) || spawns.size <= 0 ) + { + return; + } + i = 0; + while ( i < players.size ) + { + players[ i ] setorigin( spawns[ level.devgui_start_spawn_index ].origin ); + players[ i ] setplayerangles( spawns[ level.devgui_start_spawn_index ].angles ); + i++; + } + level.devgui_start_spawn_index++; + if ( level.devgui_start_spawn_index >= spawns.size ) + { + level.devgui_start_spawn_index = 0; + } + } + else if ( getDvar( "scr_playerwarp" ) == "prev_start_spawn" ) + { + players = get_players(); + setdvar( "scr_playerwarp", "" ); + if ( !isDefined( level.devgui_start_spawn_index ) ) + { + level.devgui_start_spawn_index = 0; + } + player = gethostplayer(); + spawns = level.spawn_start[ player.pers[ "team" ] ]; + if ( !isDefined( spawns ) || spawns.size <= 0 ) + { + return; + } + i = 0; + while ( i < players.size ) + { + players[ i ] setorigin( spawns[ level.devgui_start_spawn_index ].origin ); + players[ i ] setplayerangles( spawns[ level.devgui_start_spawn_index ].angles ); + i++; + } + level.devgui_start_spawn_index--; + + if ( level.devgui_start_spawn_index < 0 ) + { + level.devgui_start_spawn_index = spawns.size - 1; + } + } + else if ( getDvar( "scr_playerwarp" ) == "next_spawn" ) + { + players = get_players(); + setdvar( "scr_playerwarp", "" ); + if ( !isDefined( level.devgui_spawn_index ) ) + { + level.devgui_spawn_index = 0; + } + spawns = level.spawnpoints; + spawns = arraycombine( spawns, level.dem_spawns, 1, 0 ); + if ( !isDefined( spawns ) || spawns.size <= 0 ) + { + return; + } + i = 0; + while ( i < players.size ) + { + players[ i ] setorigin( spawns[ level.devgui_spawn_index ].origin ); + players[ i ] setplayerangles( spawns[ level.devgui_spawn_index ].angles ); + i++; + } + level.devgui_spawn_index++; + if ( level.devgui_spawn_index >= spawns.size ) + { + level.devgui_spawn_index = 0; + } + } + else if ( getDvar( "scr_playerwarp" ) == "prev_spawn" ) + { + players = get_players(); + setdvar( "scr_playerwarp", "" ); + if ( !isDefined( level.devgui_spawn_index ) ) + { + level.devgui_spawn_index = 0; + } + spawns = level.spawnpoints; + spawns = arraycombine( spawns, level.dem_spawns, 1, 0 ); + if ( !isDefined( spawns ) || spawns.size <= 0 ) + { + return; + } + i = 0; + while ( i < players.size ) + { + players[ i ] setorigin( spawns[ level.devgui_spawn_index ].origin ); + players[ i ] setplayerangles( spawns[ level.devgui_spawn_index ].angles ); + i++; + } + level.devgui_spawn_index--; + + if ( level.devgui_spawn_index < 0 ) + { + level.devgui_spawn_index = spawns.size - 1; + } + } + else if ( getDvar( "scr_devgui_spawn" ) != "" ) + { + player = gethostplayer(); + if ( !isDefined( player.devgui_spawn_active ) ) + { + player.devgui_spawn_active = 0; + } + if ( !player.devgui_spawn_active ) + { + iprintln( "Previous spawn bound to D-Pad Left" ); + iprintln( "Next spawn bound to D-Pad Right" ); + player.devgui_spawn_active = 1; + player thread devgui_spawn_think(); + } + else + { + player notify( "devgui_spawn_think" ); + player.devgui_spawn_active = 0; + player setactionslot( 3, "altMode" ); + player setactionslot( 4, "nightvision" ); + } + setdvar( "scr_devgui_spawn", "" ); + } + else if ( getDvar( "scr_player_ammo" ) != "" ) + { + players = get_players(); + if ( !isDefined( level.devgui_unlimited_ammo ) ) + { + level.devgui_unlimited_ammo = 1; + } + else + { + level.devgui_unlimited_ammo = !level.devgui_unlimited_ammo; + } + if ( level.devgui_unlimited_ammo ) + { + iprintln( "Giving unlimited ammo to all players" ); + } + else + { + iprintln( "Stopping unlimited ammo for all players" ); + } + i = 0; + while ( i < players.size ) + { + if ( level.devgui_unlimited_ammo ) + { + players[ i ] thread devgui_unlimited_ammo(); + i++; + continue; + } + else + { + players[ i ] notify( "devgui_unlimited_ammo" ); + } + i++; + } + setdvar( "scr_player_ammo", "" ); + } + else if ( getDvar( "scr_player_momentum" ) != "" ) + { + if ( !isDefined( level.devgui_unlimited_momentum ) ) + { + level.devgui_unlimited_momentum = 1; + } + else + { + level.devgui_unlimited_momentum = !level.devgui_unlimited_momentum; + } + if ( level.devgui_unlimited_momentum ) + { + iprintln( "Giving unlimited momentum to all players" ); + level thread devgui_unlimited_momentum(); + } + else + { + iprintln( "Stopping unlimited momentum for all players" ); + level notify( "devgui_unlimited_momentum" ); + } + setdvar( "scr_player_momentum", "" ); + } + else if ( getDvar( "scr_give_player_score" ) != "" ) + { + level thread devgui_increase_momentum( getDvarInt( "scr_give_player_score" ) ); + setdvar( "scr_give_player_score", "" ); + } + else if ( getDvar( "scr_player_zero_ammo" ) != "" ) + { + players = get_players(); + i = 0; + while ( i < players.size ) + { + player = players[ i ]; + weapons = player getweaponslist(); + arrayremovevalue( weapons, "knife_mp" ); + j = 0; + while ( j < weapons.size ) + { + if ( weapons[ j ] == "none" ) + { + j++; + continue; + } + else + { + player setweaponammostock( weapons[ j ], 0 ); + player setweaponammoclip( weapons[ j ], 0 ); + } + j++; + } + i++; + } + setdvar( "scr_player_zero_ammo", "" ); + } + else if ( getDvar( "scr_emp_jammed" ) != "" ) + { + players = get_players(); + i = 0; + while ( i < players.size ) + { + player = players[ i ]; + if ( getDvar( "scr_emp_jammed" ) == "0" ) + { + player setempjammed( 0 ); + i++; + continue; + } + else + { + player setempjammed( 1 ); + } + i++; + } + setdvar( "scr_emp_jammed", "" ); + } + else if ( getDvar( "scr_round_pause" ) != "" ) + { + if ( !level.timerstopped ) + { + iprintln( "Pausing Round Timer" ); + maps/mp/gametypes/_globallogic_utils::pausetimer(); + } + else + { + iprintln( "Resuming Round Timer" ); + maps/mp/gametypes/_globallogic_utils::resumetimer(); + } + setdvar( "scr_round_pause", "" ); + } + else if ( getDvar( "scr_round_end" ) != "" ) + { + level maps/mp/gametypes/_globallogic::forceend(); + setdvar( "scr_round_end", "" ); + } + else if ( getDvar( "scr_health_debug" ) != "" ) + { + players = get_players(); + host = gethostplayer(); + if ( !isDefined( host.devgui_health_debug ) ) + { + host.devgui_health_debug = 0; + } + if ( host.devgui_health_debug ) + { + host.devgui_health_debug = 0; + i = 0; + while ( i < players.size ) + { + players[ i ] notify( "devgui_health_debug" ); + if ( isDefined( players[ i ].debug_health_bar ) ) + { + players[ i ].debug_health_bar destroy(); + players[ i ].debug_health_text destroy(); + players[ i ].debug_health_bar = undefined; + players[ i ].debug_health_text = undefined; + } + i++; + } + } + else host.devgui_health_debug = 1; + i = 0; + while ( i < players.size ) + { + players[ i ] thread devgui_health_debug(); + i++; + } + setdvar( "scr_health_debug", "" ); + } + else + { + if ( getDvar( "scr_show_hq_spawns" ) != "" ) + { + if ( !isDefined( level.devgui_show_hq ) ) + { + level.devgui_show_hq = 0; + } + if ( level.gametype == "koth" && isDefined( level.radios ) ) + { + if ( !level.devgui_show_hq ) + { + i = 0; + while ( i < level.radios.size ) + { + color = ( 0, 1, 0 ); + level showonespawnpoint( level.radios[ i ], color, "hide_hq_points", 32, "hq_spawn" ); + i++; + } + } + else level notify( "hide_hq_points" ); + level.devgui_show_hq = !level.devgui_show_hq; + } + setdvar( "scr_show_hq_spawns", "" ); + } + } + if ( getDvar( "r_streamDumpDistance" ) == "3" ) + { + if ( !isDefined( level.streamdumpteamindex ) ) + { + level.streamdumpteamindex = 0; + } + else + { + level.streamdumpteamindex++; + } + numpoints = 0; + if ( level.streamdumpteamindex < level.teams.size ) + { + teamname = getarraykeys( level.teams )[ level.streamdumpteamindex ]; + if ( isDefined( level.spawn_start[ teamname ] ) ) + { + numpoints = level.spawn_start[ teamname ].size; + } + } + if ( numpoints == 0 ) + { + setdvar( "r_streamDumpDistance", "0" ); + level.streamdumpteamindex = -1; + } + else + { + averageorigin = ( 0, 1, 0 ); + averageangles = ( 0, 1, 0 ); + _a761 = level.spawn_start[ teamname ]; + _k761 = getFirstArrayKey( _a761 ); + while ( isDefined( _k761 ) ) + { + spawnpoint = _a761[ _k761 ]; + averageorigin += spawnpoint.origin / numpoints; + averageangles += spawnpoint.angles / numpoints; + _k761 = getNextArrayKey( _a761, _k761 ); + } + level.players[ 0 ] setplayerangles( averageangles ); + level.players[ 0 ] setorigin( averageorigin ); + wait 0,05; + setdvar( "r_streamDumpDistance", "2" ); + } + } + } + if ( getDvar( "scr_giveperk" ) == "0" ) + { + players = get_players(); + iprintln( "Taking all perks from all players" ); + i = 0; + while ( i < players.size ) + { + players[ i ] clearperks(); + i++; + } + setdvar( "scr_giveperk", "" ); + } + if ( getDvar( "scr_giveperk" ) != "" ) + { + perk = getDvar( "scr_giveperk" ); + specialties = strtok( perk, "|" ); + players = get_players(); + iprintln( "Giving all players perk: '" + perk + "'" ); + i = 0; + while ( i < players.size ) + { + j = 0; + while ( j < specialties.size ) + { + players[ i ] setperk( specialties[ j ] ); + players[ i ].extraperks[ specialties[ j ] ] = 1; + j++; + } + i++; + } + setdvar( "scr_giveperk", "" ); + } + if ( getDvar( "scr_forcegrenade" ) != "" ) + { + force_grenade_throw( getDvar( "scr_forcegrenade" ) ); + setdvar( "scr_forcegrenade", "" ); + } + if ( getDvar( "scr_forceevent" ) != "" ) + { + event = getDvar( "scr_forceevent" ); + player = gethostplayer(); + forward = anglesToForward( player.angles ); + right = anglesToRight( player.angles ); + if ( event == "painfront" ) + { + player dodamage( 1, player.origin + forward ); + } + else if ( event == "painback" ) + { + player dodamage( 1, player.origin - forward ); + } + else if ( event == "painleft" ) + { + player dodamage( 1, player.origin - right ); + } + else + { + if ( event == "painright" ) + { + player dodamage( 1, player.origin + right ); + } + } + setdvar( "scr_forceevent", "" ); + } + if ( getDvar( "scr_takeperk" ) != "" ) + { + perk = getDvar( "scr_takeperk" ); + i = 0; + while ( i < level.players.size ) + { + level.players[ i ] unsetperk( perk ); + i++; + } + setdvar( "scr_takeperk", "" ); + } + if ( getDvar( "scr_x_kills_y" ) != "" ) + { + nametokens = strtok( getDvar( "scr_x_kills_y" ), " " ); + if ( nametokens.size > 1 ) + { + thread xkillsy( nametokens[ 0 ], nametokens[ 1 ] ); + } + setdvar( "scr_x_kills_y", "" ); + } + if ( getDvar( "scr_usedogs" ) != "" ) + { + ownername = getDvar( "scr_usedogs" ); + setdvar( "scr_usedogs", "" ); + owner = undefined; + index = 0; + while ( index < level.players.size ) + { + if ( level.players[ index ].name == ownername ) + { + owner = level.players[ index ]; + } + index++; + } + if ( isDefined( owner ) ) + { + owner maps/mp/killstreaks/_killstreaks::triggerkillstreak( "dogs_mp" ); + } + } + while ( getDvar( "scr_set_level" ) != "" ) + { + player.pers[ "rank" ] = 0; + player.pers[ "rankxp" ] = 0; + newrank = min( getDvarInt( "scr_set_level" ), 54 ); + newrank = max( newrank, 1 ); + setdvar( "scr_set_level", "" ); + lastxp = 0; + index = 0; + while ( index <= newrank ) + { + newxp = maps/mp/gametypes/_rank::getrankinfominxp( index ); + player thread maps/mp/gametypes/_rank::giverankxp( "kill", newxp - lastxp ); + lastxp = newxp; + wait 0,25; + self notify( "cancel_notify" ); + index++; + } + } + if ( getDvar( "scr_givexp" ) != "" ) + { + player thread maps/mp/gametypes/_rank::giverankxp( "challenge", getDvarInt( "scr_givexp" ), 1 ); + setdvar( "scr_givexp", "" ); + } + if ( getDvar( "scr_do_notify" ) != "" ) + { + i = 0; + while ( i < level.players.size ) + { + level.players[ i ] maps/mp/gametypes/_hud_message::oldnotifymessage( getDvar( "scr_do_notify" ), getDvar( "scr_do_notify" ), game[ "icons" ][ "allies" ] ); + i++; + } + announcement( getDvar( "scr_do_notify" ), 0 ); + setdvar( "scr_do_notify", "" ); + } + while ( getDvar( #"4F1284FA" ) != "" ) + { + ents = getentarray(); + level.entarray = []; + level.entcounts = []; + level.entgroups = []; + index = 0; + while ( index < ents.size ) + { + classname = ents[ index ].classname; + if ( !issubstr( classname, "_spawn" ) ) + { + curent = ents[ index ]; + level.entarray[ level.entarray.size ] = curent; + if ( !isDefined( level.entcounts[ classname ] ) ) + { + level.entcounts[ classname ] = 0; + } + level.entcounts[ classname ]++; + if ( !isDefined( level.entgroups[ classname ] ) ) + { + level.entgroups[ classname ] = []; + } + level.entgroups[ classname ][ level.entgroups[ classname ].size ] = curent; + } + index++; + } + } + if ( getDvar( "debug_dynamic_ai_spawning" ) == "1" && !isDefined( level.larry ) ) + { + thread larry_thread(); + } + else + { + if ( getDvar( "debug_dynamic_ai_spawning" ) == "0" ) + { + level notify( "kill_larry" ); + } + } + if ( level.bot_overlay == 0 && getDvarInt( #"1CBC4852" ) == 1 ) + { + level thread bot_overlay_think(); + level.bot_overlay = 1; + } + else + { + if ( level.bot_overlay == 1 && getDvarInt( #"1CBC4852" ) == 0 ) + { + level bot_overlay_stop(); + level.bot_overlay = 0; + } + } + if ( level.bot_threat == 0 && getDvarInt( #"68A98D18" ) == 1 ) + { + level thread bot_threat_think(); + level.bot_threat = 1; + } + else + { + if ( level.bot_threat == 1 && getDvarInt( #"68A98D18" ) == 0 ) + { + level bot_threat_stop(); + level.bot_threat = 0; + } + } + if ( level.bot_path == 0 && getDvarInt( #"D6F2CC5D" ) == 1 ) + { + level thread bot_path_think(); + level.bot_path = 1; + } + else + { + if ( level.bot_path == 1 && getDvarInt( #"D6F2CC5D" ) == 0 ) + { + level bot_path_stop(); + level.bot_path = 0; + } + } + if ( getDvarInt( "scr_force_finalkillcam" ) == 1 ) + { + level thread maps/mp/gametypes/_killcam::dofinalkillcam(); + level thread waitthennotifyfinalkillcam(); + } + if ( getDvarInt( "scr_force_roundkillcam" ) == 1 ) + { + level thread maps/mp/gametypes/_killcam::dofinalkillcam(); + level thread waitthennotifyroundkillcam(); + } + if ( !level.bot_overlay && !level.bot_threat && !level.bot_path ) + { + level notify( "bot_dpad_terminate" ); +#/ + } +} + +waitthennotifyroundkillcam() +{ +/# + wait 0,05; + level notify( "play_final_killcam" ); + setdvar( "scr_force_roundkillcam", 0 ); +#/ +} + +waitthennotifyfinalkillcam() +{ +/# + wait 0,05; + level notify( "play_final_killcam" ); + wait 0,05; + setdvar( "scr_force_finalkillcam", 0 ); +#/ +} + +devgui_spawn_think() +{ +/# + self notify( "devgui_spawn_think" ); + self endon( "devgui_spawn_think" ); + self endon( "disconnect" ); + dpad_left = 0; + dpad_right = 0; + for ( ;; ) + { + self setactionslot( 3, "" ); + self setactionslot( 4, "" ); + if ( !dpad_left && self buttonpressed( "DPAD_LEFT" ) ) + { + setdvar( "scr_playerwarp", "prev_spawn" ); + dpad_left = 1; + } + else + { + if ( !self buttonpressed( "DPAD_LEFT" ) ) + { + dpad_left = 0; + } + } + if ( !dpad_right && self buttonpressed( "DPAD_RIGHT" ) ) + { + setdvar( "scr_playerwarp", "next_spawn" ); + dpad_right = 1; + } + else + { + if ( !self buttonpressed( "DPAD_RIGHT" ) ) + { + dpad_right = 0; + } + } + wait 0,05; +#/ + } +} + +devgui_unlimited_ammo() +{ +/# + self notify( "devgui_unlimited_ammo" ); + self endon( "devgui_unlimited_ammo" ); + self endon( "disconnect" ); + for ( ;; ) + { + wait 0,1; + weapons = []; + weapons[ 0 ] = self getcurrentweapon(); + weapons[ 1 ] = self getcurrentoffhand(); + i = 0; + while ( i < weapons.size ) + { + if ( weapons[ i ] == "none" ) + { + i++; + continue; + } + else if ( maps/mp/killstreaks/_killstreaks::iskillstreakweapon( weapons[ i ] ) ) + { + i++; + continue; + } + else + { + self givemaxammo( weapons[ i ] ); + } + i++; + } +#/ + } +} + +devgui_unlimited_momentum() +{ +/# + level notify( "devgui_unlimited_momentum" ); + level endon( "devgui_unlimited_momentum" ); + for ( ;; ) + { + wait 1; + players = get_players(); + _a1088 = players; + _k1088 = getFirstArrayKey( _a1088 ); + while ( isDefined( _k1088 ) ) + { + player = _a1088[ _k1088 ]; + if ( !isDefined( player ) ) + { + } + else if ( !isalive( player ) ) + { + } + else if ( player.sessionstate != "playing" ) + { + } + else + { + maps/mp/gametypes/_globallogic_score::_setplayermomentum( player, 5000 ); + } + _k1088 = getNextArrayKey( _a1088, _k1088 ); + } +#/ + } +} + +devgui_increase_momentum( score ) +{ +/# + players = get_players(); + _a1114 = players; + _k1114 = getFirstArrayKey( _a1114 ); + while ( isDefined( _k1114 ) ) + { + player = _a1114[ _k1114 ]; + if ( !isDefined( player ) ) + { + } + else if ( !isalive( player ) ) + { + } + else if ( player.sessionstate != "playing" ) + { + } + else + { + player maps/mp/gametypes/_globallogic_score::giveplayermomentumnotification( score, &"testPlayerScoreForTan", "PLAYER_SCORE", 0 ); + } + _k1114 = getNextArrayKey( _a1114, _k1114 ); +#/ + } +} + +devgui_health_debug() +{ +/# + self notify( "devgui_health_debug" ); + self endon( "devgui_health_debug" ); + self endon( "disconnect" ); + x = 80; + y = 40; + self.debug_health_bar = newclienthudelem( self ); + self.debug_health_bar.x = x + 80; + self.debug_health_bar.y = y + 2; + self.debug_health_bar.alignx = "left"; + self.debug_health_bar.aligny = "top"; + self.debug_health_bar.horzalign = "fullscreen"; + self.debug_health_bar.vertalign = "fullscreen"; + self.debug_health_bar.alpha = 1; + self.debug_health_bar.foreground = 1; + self.debug_health_bar setshader( "black", 1, 8 ); + self.debug_health_text = newclienthudelem( self ); + self.debug_health_text.x = x + 80; + self.debug_health_text.y = y; + self.debug_health_text.alignx = "left"; + self.debug_health_text.aligny = "top"; + self.debug_health_text.horzalign = "fullscreen"; + self.debug_health_text.vertalign = "fullscreen"; + self.debug_health_text.alpha = 1; + self.debug_health_text.fontscale = 1; + self.debug_health_text.foreground = 1; + if ( !isDefined( self.maxhealth ) || self.maxhealth <= 0 ) + { + self.maxhealth = 100; + } + for ( ;; ) + { + wait 0,05; + width = ( self.health / self.maxhealth ) * 300; + width = int( max( width, 1 ) ); + self.debug_health_bar setshader( "black", width, 8 ); + self.debug_health_text setvalue( self.health ); +#/ + } +} + +giveextraperks() +{ +/# + if ( !isDefined( self.extraperks ) ) + { + return; + } + perks = getarraykeys( self.extraperks ); + i = 0; + while ( i < perks.size ) + { + self setperk( perks[ i ] ); + i++; +#/ + } +} + +xkillsy( attackername, victimname ) +{ +/# + attacker = undefined; + victim = undefined; + index = 0; + while ( index < level.players.size ) + { + if ( level.players[ index ].name == attackername ) + { + attacker = level.players[ index ]; + index++; + continue; + } + else + { + if ( level.players[ index ].name == victimname ) + { + victim = level.players[ index ]; + } + } + index++; + } + if ( !isalive( attacker ) || !isalive( victim ) ) + { + return; + } + victim thread [[ level.callbackplayerdamage ]]( attacker, attacker, 1000, 0, "MOD_RIFLE_BULLET", "none", ( 0, 1, 0 ), ( 0, 1, 0 ), "none", 0, 0 ); +#/ +} + +updateminimapsetting() +{ +/# + requiredmapaspectratio = getDvarFloat( "scr_RequiredMapAspectratio" ); + if ( !isDefined( level.minimapheight ) ) + { + setdvar( "scr_minimap_height", "0" ); + level.minimapheight = 0; + } + minimapheight = getDvarFloat( "scr_minimap_height" ); + if ( minimapheight != level.minimapheight ) + { + if ( minimapheight <= 0 ) + { + gethostplayer() cameraactivate( 0 ); + level.minimapheight = minimapheight; + level notify( "end_draw_map_bounds" ); + } + if ( minimapheight > 0 ) + { + level.minimapheight = minimapheight; + players = get_players(); + if ( players.size > 0 ) + { + player = gethostplayer(); + corners = getentarray( "minimap_corner", "targetname" ); + if ( corners.size == 2 ) + { + viewpos = corners[ 0 ].origin + corners[ 1 ].origin; + viewpos = ( viewpos[ 0 ] * 0,5, viewpos[ 1 ] * 0,5, viewpos[ 2 ] * 0,5 ); + level thread minimapwarn( corners ); + maxcorner = ( corners[ 0 ].origin[ 0 ], corners[ 0 ].origin[ 1 ], viewpos[ 2 ] ); + mincorner = ( corners[ 0 ].origin[ 0 ], corners[ 0 ].origin[ 1 ], viewpos[ 2 ] ); + if ( corners[ 1 ].origin[ 0 ] > corners[ 0 ].origin[ 0 ] ) + { + maxcorner = ( corners[ 1 ].origin[ 0 ], maxcorner[ 1 ], maxcorner[ 2 ] ); + } + else + { + mincorner = ( corners[ 1 ].origin[ 0 ], mincorner[ 1 ], mincorner[ 2 ] ); + } + if ( corners[ 1 ].origin[ 1 ] > corners[ 0 ].origin[ 1 ] ) + { + maxcorner = ( maxcorner[ 0 ], corners[ 1 ].origin[ 1 ], maxcorner[ 2 ] ); + } + else + { + mincorner = ( mincorner[ 0 ], corners[ 1 ].origin[ 1 ], mincorner[ 2 ] ); + } + viewpostocorner = maxcorner - viewpos; + viewpos = ( viewpos[ 0 ], viewpos[ 1 ], viewpos[ 2 ] + minimapheight ); + northvector = ( cos( getnorthyaw() ), sin( getnorthyaw() ), 0 ); + eastvector = ( northvector[ 1 ], 0 - northvector[ 0 ], 0 ); + disttotop = vectordot( northvector, viewpostocorner ); + if ( disttotop < 0 ) + { + disttotop = 0 - disttotop; + } + disttoside = vectordot( eastvector, viewpostocorner ); + if ( disttoside < 0 ) + { + disttoside = 0 - disttoside; + } + if ( requiredmapaspectratio > 0 ) + { + mapaspectratio = disttoside / disttotop; + if ( mapaspectratio < requiredmapaspectratio ) + { + incr = requiredmapaspectratio / mapaspectratio; + disttoside *= incr; + addvec = vecscale( eastvector, vectordot( eastvector, maxcorner - viewpos ) * ( incr - 1 ) ); + mincorner -= addvec; + maxcorner += addvec; + } + else + { + incr = mapaspectratio / requiredmapaspectratio; + disttotop *= incr; + addvec = vecscale( northvector, vectordot( northvector, maxcorner - viewpos ) * ( incr - 1 ) ); + mincorner -= addvec; + maxcorner += addvec; + } + } + if ( level.console ) + { + aspectratioguess = 1,777778; + angleside = 2 * atan( ( disttoside * 0,8 ) / minimapheight ); + angletop = 2 * atan( ( disttotop * aspectratioguess * 0,8 ) / minimapheight ); + } + else + { + aspectratioguess = 1,333333; + angleside = 2 * atan( disttoside / minimapheight ); + angletop = 2 * atan( ( disttotop * aspectratioguess ) / minimapheight ); + } + if ( angleside > angletop ) + { + angle = angleside; + } + else + { + angle = angletop; + } + znear = minimapheight - 1000; + if ( znear < 16 ) + { + znear = 16; + } + if ( znear > 10000 ) + { + znear = 10000; + } + player camerasetposition( viewpos, ( 90, getnorthyaw(), 0 ) ); + player cameraactivate( 1 ); + player takeallweapons(); + setdvar( "cg_drawGun", 0 ); + setdvar( "cg_draw2D", 0 ); + setdvar( "cg_drawFPS", 0 ); + setdvar( "fx_enable", 0 ); + setdvar( "r_fog", 0 ); + setdvar( "r_highLodDist", 0 ); + setdvar( "r_znear", znear ); + setdvar( "r_lodscale", 0 ); + setdvar( "r_lodScaleRigid", 0 ); + setdvar( "cg_drawVersion", 0 ); + setdvar( "sm_enable", 1 ); + setdvar( "player_view_pitch_down", 90 ); + setdvar( "player_view_pitch_up", 0 ); + setdvar( "cg_fov", angle ); + setdvar( "cg_fovMin", 1 ); + setdvar( "debug_show_viewpos", "0" ); + if ( isDefined( level.objpoints ) ) + { + i = 0; + while ( i < level.objpointnames.size ) + { + if ( isDefined( level.objpoints[ level.objpointnames[ i ] ] ) ) + { + level.objpoints[ level.objpointnames[ i ] ] destroy(); + } + i++; + } + level.objpoints = []; + level.objpointnames = []; + } + thread drawminimapbounds( viewpos, mincorner, maxcorner ); + } + else + { + println( "^1Error: There are not exactly 2 "minimap_corner" entities in the level." ); + } + return; + } + else + { + setdvar( "scr_minimap_height", "0" ); +#/ + } + } + } +} + +vecscale( vec, scalar ) +{ +/# + return ( vec[ 0 ] * scalar, vec[ 1 ] * scalar, vec[ 2 ] * scalar ); +#/ +} + +drawminimapbounds( viewpos, mincorner, maxcorner ) +{ +/# + level notify( "end_draw_map_bounds" ); + level endon( "end_draw_map_bounds" ); + viewheight = viewpos[ 2 ] - maxcorner[ 2 ]; + north = ( cos( getnorthyaw() ), sin( getnorthyaw() ), 0 ); + diaglen = length( mincorner - maxcorner ); + mincorneroffset = mincorner - viewpos; + mincorneroffset = vectornormalize( ( mincorneroffset[ 0 ], mincorneroffset[ 1 ], 0 ) ); + mincorner += vecscale( mincorneroffset, ( diaglen * 1 ) / 800 ); + maxcorneroffset = maxcorner - viewpos; + maxcorneroffset = vectornormalize( ( maxcorneroffset[ 0 ], maxcorneroffset[ 1 ], 0 ) ); + maxcorner += vecscale( maxcorneroffset, ( diaglen * 1 ) / 800 ); + diagonal = maxcorner - mincorner; + side = vecscale( north, vectordot( diagonal, north ) ); + sidenorth = vecscale( north, abs( vectordot( diagonal, north ) ) ); + corner0 = mincorner; + corner1 = mincorner + side; + corner2 = maxcorner; + corner3 = maxcorner - side; + toppos = vecscale( mincorner + maxcorner, 0,5 ) + vecscale( sidenorth, 0,51 ); + textscale = diaglen * 0,003; + while ( 1 ) + { + line( corner0, corner1 ); + line( corner1, corner2 ); + line( corner2, corner3 ); + line( corner3, corner0 ); + print3d( toppos, "This Side Up", ( 0, 1, 0 ), 1, textscale ); + wait 0,05; +#/ + } +} + +minimapwarn( corners ) +{ +/# + threshold = 10; + width = abs( corners[ 0 ].origin[ 0 ] - corners[ 1 ].origin[ 0 ] ); + width = int( width ); + height = abs( corners[ 0 ].origin[ 1 ] - corners[ 1 ].origin[ 1 ] ); + height = int( height ); + while ( abs( width - height ) > threshold ) + { + for ( ;; ) + { + iprintln( "^1Warning: Minimap corners do not form a square (width: " + width + " height: " + height + ")\n" ); + if ( height > width ) + { + scale = height / width; + iprintln( "^1Warning: The compass minimap might be scaled: " + scale + " units in height more than width\n" ); + } + else + { + scale = width / height; + iprintln( "^1Warning: The compass minimap might be scaled: " + scale + " units in width more than height\n" ); + } + wait 10; +#/ + } + } +} + +testscriptruntimeerrorassert() +{ +/# + wait 1; + assert( 0 ); +#/ +} + +testscriptruntimeerror2() +{ +/# + myundefined = "test"; + if ( myundefined == 1 ) + { + println( "undefined in testScriptRuntimeError2\n" ); +#/ + } +} + +testscriptruntimeerror1() +{ +/# + testscriptruntimeerror2(); +#/ +} + +testscriptruntimeerror() +{ +/# + wait 5; + for ( ;; ) + { + if ( getDvar( "scr_testScriptRuntimeError" ) != "0" ) + { + break; + } + else + { + wait 1; + } + } + myerror = getDvar( "scr_testScriptRuntimeError" ); + setdvar( "scr_testScriptRuntimeError", "0" ); + if ( myerror == "assert" ) + { + testscriptruntimeerrorassert(); + } + else + { + testscriptruntimeerror1(); + } + thread testscriptruntimeerror(); +#/ +} + +testdvars() +{ +/# + wait 5; + for ( ;; ) + { + if ( getDvar( "scr_testdvar" ) != "" ) + { + break; + } + else + { + wait 1; + } + } + tokens = strtok( getDvar( "scr_testdvar" ), " " ); + dvarname = tokens[ 0 ]; + dvarvalue = tokens[ 1 ]; + setdvar( dvarname, dvarvalue ); + setdvar( "scr_testdvar", "" ); + thread testdvars(); +#/ +} + +addtestclients() +{ +/# + wait 5; + for ( ;; ) + { + if ( getDvarInt( "scr_testclients" ) > 0 ) + { + break; + } + else + { + wait 1; + } + } + playsoundonplayers( "vox_kls_dav_spawn" ); + testclients = getDvarInt( "scr_testclients" ); + setdvar( "scr_testclients", 0 ); + i = 0; + while ( i < testclients ) + { + ent[ i ] = addtestclient(); + if ( !isDefined( ent[ i ] ) ) + { + println( "Could not add test client" ); + wait 1; + i++; + continue; + } + else + { + ent[ i ].pers[ "isBot" ] = 1; + ent[ i ] thread testclient( "autoassign" ); + } + i++; + } + thread addtestclients(); +#/ +} + +addenemyheli() +{ +/# + wait 5; + for ( ;; ) + { + if ( getDvarInt( "scr_spawnenemyheli" ) > 0 ) + { + break; + } + else + { + wait 1; + } + } + enemyheli = getDvarInt( "scr_spawnenemyheli" ); + setdvar( "scr_spawnenemyheli", 0 ); + team = "autoassign"; + player = gethostplayer(); + if ( isDefined( player.pers[ "team" ] ) ) + { + team = getotherteam( player.pers[ "team" ] ); + } + ent = getormakebot( team ); + if ( !isDefined( ent ) ) + { + println( "Could not add test client" ); + wait 1; + thread addenemyheli(); + return; + } + switch( enemyheli ) + { + case 1: + level.helilocation = ent.origin; + ent thread maps/mp/killstreaks/_helicopter::usekillstreakhelicopter( "helicopter_comlink_mp" ); + wait 0,5; + ent notify( "confirm_location" ); + break; + case 2: + ent thread maps/mp/killstreaks/_helicopter_gunner::heli_gunner_killstreak( "helicopter_player_gunner_mp" ); + break; + } + thread addenemyheli(); +#/ +} + +getormakebot( team ) +{ +/# + i = 0; + while ( i < level.players.size ) + { + if ( level.players[ i ].team == team ) + { + if ( isDefined( level.players[ i ].pers[ "isBot" ] ) && level.players[ i ].pers[ "isBot" ] ) + { + return level.players[ i ]; + } + } + i++; + } + ent = addtestclient(); + if ( isDefined( ent ) ) + { + playsoundonplayers( "vox_kls_dav_spawn" ); + ent.pers[ "isBot" ] = 1; + ent thread testclient( team ); + wait 1; + } + return ent; +#/ +} + +addenemyu2() +{ +/# + wait 5; + for ( ;; ) + { + if ( getDvarInt( "scr_spawnenemyu2" ) > 0 ) + { + break; + } + else + { + wait 1; + } + } + type = getDvarInt( "scr_spawnenemyu2" ); + setdvar( "scr_spawnenemyu2", 0 ); + team = "autoassign"; + player = gethostplayer(); + if ( isDefined( player.team ) ) + { + team = getotherteam( player.team ); + } + ent = getormakebot( team ); + if ( !isDefined( ent ) ) + { + println( "Could not add test client" ); + wait 1; + thread addenemyu2(); + return; + } + if ( type == 3 ) + { + ent thread maps/mp/killstreaks/_radar::usekillstreaksatellite( "radardirection_mp" ); + } + else if ( type == 2 ) + { + ent thread maps/mp/killstreaks/_radar::usekillstreakcounteruav( "counteruav_mp" ); + } + else + { + ent thread maps/mp/killstreaks/_radar::usekillstreakradar( "radar_mp" ); + } + thread addenemyu2(); +#/ +} + +addtestcarepackage() +{ +/# + wait 5; + for ( ;; ) + { + if ( getDvarInt( "scr_givetestsupplydrop" ) > 0 ) + { + break; + } + else + { + wait 1; + } + } + supplydrop = getDvarInt( "scr_givetestsupplydrop" ); + team = "autoassign"; + player = gethostplayer(); + if ( isDefined( player.pers[ "team" ] ) ) + { + switch( supplydrop ) + { + case 2: + team = getotherteam( player.pers[ "team" ] ); + break; + case 1: + default: + team = player.pers[ "team" ]; + break; + } + } + setdvar( "scr_givetestsupplydrop", 0 ); + ent = getormakebot( team ); + if ( !isDefined( ent ) ) + { + println( "Could not add test client" ); + wait 1; + thread addtestcarepackage(); + return; + } + ent maps/mp/killstreaks/_killstreakrules::killstreakstart( "supply_drop_mp", team ); + ent thread maps/mp/killstreaks/_supplydrop::helidelivercrate( ent.origin, "supplydrop_mp", ent, team ); + thread addtestcarepackage(); +#/ +} + +removetestclients() +{ +/# + wait 5; + for ( ;; ) + { + if ( getDvarInt( "scr_testclientsremove" ) > 0 ) + { + break; + } + else + { + wait 1; + } + } + playsoundonplayers( "vox_kls_dav_kill" ); + removetype = getDvarInt( "scr_testclientsremove" ); + setdvar( "scr_testclientsremove", 0 ); + host = gethostplayer(); + players = level.players; + i = 0; + while ( i < players.size ) + { + if ( isDefined( players[ i ].pers[ "isBot" ] ) && players[ i ].pers[ "isBot" ] == 1 ) + { + if ( removetype == 2 && host.team != players[ i ].team ) + { + i++; + continue; + } + else + { + if ( removetype == 3 && host.team == players[ i ].team ) + { + i++; + continue; + } + else + { + kick( players[ i ] getentitynumber() ); + } + } + } + i++; + } + thread removetestclients(); +#/ +} + +testclient( team ) +{ +/# + self endon( "disconnect" ); + while ( !isDefined( self.pers[ "team" ] ) ) + { + wait 0,05; + } + if ( level.teambased ) + { + self notify( "menuresponse" ); + wait 0,5; + } + while ( 1 ) + { + classes = maps/mp/bots/_bot::bot_build_classes(); + self notify( "menuresponse" ); + self waittill( "spawned_player" ); + wait 0,1; +#/ + } +} + +showonespawnpoint( spawn_point, color, notification, height, print ) +{ +/# + if ( !isDefined( height ) || height <= 0 ) + { + height = get_player_height(); + } + if ( !isDefined( print ) ) + { + print = spawn_point.classname; + } + center = spawn_point.origin; + forward = anglesToForward( spawn_point.angles ); + right = anglesToRight( spawn_point.angles ); + forward = vectorScale( forward, 16 ); + right = vectorScale( right, 16 ); + a = ( center + forward ) - right; + b = center + forward + right; + c = ( center - forward ) + right; + d = center - forward - right; + thread lineuntilnotified( a, b, color, 0, notification ); + thread lineuntilnotified( b, c, color, 0, notification ); + thread lineuntilnotified( c, d, color, 0, notification ); + thread lineuntilnotified( d, a, color, 0, notification ); + thread lineuntilnotified( a, a + ( 0, 0, height ), color, 0, notification ); + thread lineuntilnotified( b, b + ( 0, 0, height ), color, 0, notification ); + thread lineuntilnotified( c, c + ( 0, 0, height ), color, 0, notification ); + thread lineuntilnotified( d, d + ( 0, 0, height ), color, 0, notification ); + a += ( 0, 0, height ); + b += ( 0, 0, height ); + c += ( 0, 0, height ); + d += ( 0, 0, height ); + thread lineuntilnotified( a, b, color, 0, notification ); + thread lineuntilnotified( b, c, color, 0, notification ); + thread lineuntilnotified( c, d, color, 0, notification ); + thread lineuntilnotified( d, a, color, 0, notification ); + center += ( 0, 0, height / 2 ); + arrow_forward = anglesToForward( spawn_point.angles ); + arrowhead_forward = anglesToForward( spawn_point.angles ); + arrowhead_right = anglesToRight( spawn_point.angles ); + arrow_forward = vectorScale( arrow_forward, 32 ); + arrowhead_forward = vectorScale( arrowhead_forward, 24 ); + arrowhead_right = vectorScale( arrowhead_right, 8 ); + a = center + arrow_forward; + b = ( center + arrowhead_forward ) - arrowhead_right; + c = center + arrowhead_forward + arrowhead_right; + thread lineuntilnotified( center, a, color, 0, notification ); + thread lineuntilnotified( a, b, color, 0, notification ); + thread lineuntilnotified( a, c, color, 0, notification ); + thread print3duntilnotified( spawn_point.origin + ( 0, 0, height ), print, color, 1, 1, notification ); + return; +#/ +} + +showspawnpoints() +{ +/# + while ( isDefined( level.spawnpoints ) ) + { + color = ( 0, 1, 0 ); + spawn_point_index = 0; + while ( spawn_point_index < level.spawnpoints.size ) + { + showonespawnpoint( level.spawnpoints[ spawn_point_index ], color, "hide_spawnpoints" ); + spawn_point_index++; + } + } + i = 0; + while ( i < level.dem_spawns.size ) + { + color = ( 0, 1, 0 ); + showonespawnpoint( level.dem_spawns[ i ], color, "hide_spawnpoints" ); + i++; + } + return; +#/ +} + +hidespawnpoints() +{ +/# + level notify( "hide_spawnpoints" ); + return; +#/ +} + +showstartspawnpoints() +{ +/# + if ( !level.teambased ) + { + return; + } + if ( !isDefined( level.spawn_start ) ) + { + return; + } + team_colors = []; + team_colors[ "axis" ] = ( 0, 1, 0 ); + team_colors[ "allies" ] = ( 0, 1, 1 ); + team_colors[ "team3" ] = ( 0, 1, 0 ); + team_colors[ "team4" ] = ( 0, 1, 0 ); + team_colors[ "team5" ] = ( 0, 1, 0 ); + team_colors[ "team6" ] = ( 1, 0,7, 0 ); + team_colors[ "team7" ] = ( 0,25, 0,25, 1 ); + team_colors[ "team8" ] = ( 0,88, 0, 1 ); + _a1908 = level.teams; + _k1908 = getFirstArrayKey( _a1908 ); + while ( isDefined( _k1908 ) ) + { + team = _a1908[ _k1908 ]; + color = team_colors[ team ]; + _a1912 = level.spawn_start[ team ]; + _k1912 = getFirstArrayKey( _a1912 ); + while ( isDefined( _k1912 ) ) + { + spawnpoint = _a1912[ _k1912 ]; + showonespawnpoint( spawnpoint, color, "hide_startspawnpoints" ); + _k1912 = getNextArrayKey( _a1912, _k1912 ); + } + _k1908 = getNextArrayKey( _a1908, _k1908 ); + } + return; +#/ +} + +hidestartspawnpoints() +{ +/# + level notify( "hide_startspawnpoints" ); + return; +#/ +} + +print3duntilnotified( origin, text, color, alpha, scale, notification ) +{ +/# + level endon( notification ); + for ( ;; ) + { + print3d( origin, text, color, alpha, scale ); + wait 0,05; +#/ + } +} + +lineuntilnotified( start, end, color, depthtest, notification ) +{ +/# + level endon( notification ); + for ( ;; ) + { + line( start, end, color, depthtest ); + wait 0,05; +#/ + } +} + +engagement_distance_debug_toggle() +{ +/# + level endon( "kill_engage_dist_debug_toggle_watcher" ); + if ( !isDefined( getDvarInt( "debug_engage_dists" ) ) ) + { + setdvar( "debug_engage_dists", "0" ); + } + laststate = getDvarInt( "debug_engage_dists" ); + while ( 1 ) + { + currentstate = getDvarInt( "debug_engage_dists" ); + if ( dvar_turned_on( currentstate ) && !dvar_turned_on( laststate ) ) + { + weapon_engage_dists_init(); + thread debug_realtime_engage_dist(); + laststate = currentstate; + } + else + { + if ( !dvar_turned_on( currentstate ) && dvar_turned_on( laststate ) ) + { + level notify( "kill_all_engage_dist_debug" ); + laststate = currentstate; + } + } + wait 0,3; +#/ + } +} + +dvar_turned_on( val ) +{ +/# + if ( val <= 0 ) + { + return 0; + } + else + { + return 1; +#/ + } +} + +engagement_distance_debug_init() +{ +/# + level.debug_xpos = -50; + level.debug_ypos = 250; + level.debug_yinc = 18; + level.debug_fontscale = 1,5; + level.white = ( 0, 1, 0 ); + level.green = ( 0, 1, 0 ); + level.yellow = ( 0, 1, 0 ); + level.red = ( 0, 1, 0 ); + level.realtimeengagedist = newhudelem(); + level.realtimeengagedist.alignx = "left"; + level.realtimeengagedist.fontscale = level.debug_fontscale; + level.realtimeengagedist.x = level.debug_xpos; + level.realtimeengagedist.y = level.debug_ypos; + level.realtimeengagedist.color = level.white; + level.realtimeengagedist settext( "Current Engagement Distance: " ); + xpos = level.debug_xpos + 207; + level.realtimeengagedist_value = newhudelem(); + level.realtimeengagedist_value.alignx = "left"; + level.realtimeengagedist_value.fontscale = level.debug_fontscale; + level.realtimeengagedist_value.x = xpos; + level.realtimeengagedist_value.y = level.debug_ypos; + level.realtimeengagedist_value.color = level.white; + level.realtimeengagedist_value setvalue( 0 ); + xpos += 37; + level.realtimeengagedist_middle = newhudelem(); + level.realtimeengagedist_middle.alignx = "left"; + level.realtimeengagedist_middle.fontscale = level.debug_fontscale; + level.realtimeengagedist_middle.x = xpos; + level.realtimeengagedist_middle.y = level.debug_ypos; + level.realtimeengagedist_middle.color = level.white; + level.realtimeengagedist_middle settext( " units, SHORT/LONG by " ); + xpos += 105; + level.realtimeengagedist_offvalue = newhudelem(); + level.realtimeengagedist_offvalue.alignx = "left"; + level.realtimeengagedist_offvalue.fontscale = level.debug_fontscale; + level.realtimeengagedist_offvalue.x = xpos; + level.realtimeengagedist_offvalue.y = level.debug_ypos; + level.realtimeengagedist_offvalue.color = level.white; + level.realtimeengagedist_offvalue setvalue( 0 ); + hudobjarray = []; + hudobjarray[ 0 ] = level.realtimeengagedist; + hudobjarray[ 1 ] = level.realtimeengagedist_value; + hudobjarray[ 2 ] = level.realtimeengagedist_middle; + hudobjarray[ 3 ] = level.realtimeengagedist_offvalue; + return hudobjarray; +#/ +} + +engage_dist_debug_hud_destroy( hudarray, killnotify ) +{ +/# + level waittill( killnotify ); + i = 0; + while ( i < hudarray.size ) + { + hudarray[ i ] destroy(); + i++; +#/ + } +} + +weapon_engage_dists_init() +{ +/# + level.engagedists = []; + genericpistol = spawnstruct(); + genericpistol.engagedistmin = 125; + genericpistol.engagedistoptimal = 225; + genericpistol.engagedistmulligan = 50; + genericpistol.engagedistmax = 400; + shotty = spawnstruct(); + shotty.engagedistmin = 50; + shotty.engagedistoptimal = 200; + shotty.engagedistmulligan = 75; + shotty.engagedistmax = 350; + genericsmg = spawnstruct(); + genericsmg.engagedistmin = 100; + genericsmg.engagedistoptimal = 275; + genericsmg.engagedistmulligan = 100; + genericsmg.engagedistmax = 500; + genericlmg = spawnstruct(); + genericlmg.engagedistmin = 325; + genericlmg.engagedistoptimal = 550; + genericlmg.engagedistmulligan = 150; + genericlmg.engagedistmax = 850; + genericriflesa = spawnstruct(); + genericriflesa.engagedistmin = 325; + genericriflesa.engagedistoptimal = 550; + genericriflesa.engagedistmulligan = 150; + genericriflesa.engagedistmax = 850; + genericriflebolt = spawnstruct(); + genericriflebolt.engagedistmin = 350; + genericriflebolt.engagedistoptimal = 600; + genericriflebolt.engagedistmulligan = 150; + genericriflebolt.engagedistmax = 900; + generichmg = spawnstruct(); + generichmg.engagedistmin = 390; + generichmg.engagedistoptimal = 600; + generichmg.engagedistmulligan = 100; + generichmg.engagedistmax = 900; + genericsniper = spawnstruct(); + genericsniper.engagedistmin = 950; + genericsniper.engagedistoptimal = 1700; + genericsniper.engagedistmulligan = 300; + genericsniper.engagedistmax = 3000; + engage_dists_add( "colt_mp", genericpistol ); + engage_dists_add( "nambu_mp", genericpistol ); + engage_dists_add( "tokarev_mp", genericpistol ); + engage_dists_add( "walther_mp", genericpistol ); + engage_dists_add( "thompson_mp", genericsmg ); + engage_dists_add( "type100_smg_mp", genericsmg ); + engage_dists_add( "ppsh_mp", genericsmg ); + engage_dists_add( "mp40_mp", genericsmg ); + engage_dists_add( "stg44_mp", genericsmg ); + engage_dists_add( "sten_mp", genericsmg ); + engage_dists_add( "sten_silenced_mp", genericsmg ); + engage_dists_add( "shotgun_mp", shotty ); + engage_dists_add( "bar_mp", genericlmg ); + engage_dists_add( "bar_bipod_mp", genericlmg ); + engage_dists_add( "type99_lmg_mp", genericlmg ); + engage_dists_add( "type99_lmg_bipod_mp", genericlmg ); + engage_dists_add( "dp28_mp", genericlmg ); + engage_dists_add( "dp28_bipod_mp", genericlmg ); + engage_dists_add( "fg42_mp", genericlmg ); + engage_dists_add( "fg42_bipod_mp", genericlmg ); + engage_dists_add( "bren_mp", genericlmg ); + engage_dists_add( "bren_bipod_mp", genericlmg ); + engage_dists_add( "m1garand_mp", genericriflesa ); + engage_dists_add( "m1garand_bayonet_mp", genericriflesa ); + engage_dists_add( "m1carbine_mp", genericriflesa ); + engage_dists_add( "m1carbine_bayonet_mp", genericriflesa ); + engage_dists_add( "svt40_mp", genericriflesa ); + engage_dists_add( "gewehr43_mp", genericriflesa ); + engage_dists_add( "springfield_mp", genericriflebolt ); + engage_dists_add( "springfield_bayonet_mp", genericriflebolt ); + engage_dists_add( "type99_rifle_mp", genericriflebolt ); + engage_dists_add( "type99_rifle_bayonet_mp", genericriflebolt ); + engage_dists_add( "mosin_rifle_mp", genericriflebolt ); + engage_dists_add( "mosin_rifle_bayonet_mp", genericriflebolt ); + engage_dists_add( "kar98k_mp", genericriflebolt ); + engage_dists_add( "kar98k_bayonet_mp", genericriflebolt ); + engage_dists_add( "lee_enfield_mp", genericriflebolt ); + engage_dists_add( "lee_enfield_bayonet_mp", genericriflebolt ); + engage_dists_add( "30cal_mp", generichmg ); + engage_dists_add( "30cal_bipod_mp", generichmg ); + engage_dists_add( "mg42_mp", generichmg ); + engage_dists_add( "mg42_bipod_mp", generichmg ); + engage_dists_add( "springfield_scoped_mp", genericsniper ); + engage_dists_add( "type99_rifle_scoped_mp", genericsniper ); + engage_dists_add( "mosin_rifle_scoped_mp", genericsniper ); + engage_dists_add( "kar98k_scoped_mp", genericsniper ); + engage_dists_add( "fg42_scoped_mp", genericsniper ); + engage_dists_add( "lee_enfield_scoped_mp", genericsniper ); + level thread engage_dists_watcher(); +#/ +} + +engage_dists_add( weapontypestr, values ) +{ +/# + level.engagedists[ weapontypestr ] = values; +#/ +} + +get_engage_dists( weapontypestr ) +{ +/# + if ( isDefined( level.engagedists[ weapontypestr ] ) ) + { + return level.engagedists[ weapontypestr ]; + } + else + { + return undefined; +#/ + } +} + +engage_dists_watcher() +{ +/# + level endon( "kill_all_engage_dist_debug" ); + level endon( "kill_engage_dists_watcher" ); + while ( 1 ) + { + player = gethostplayer(); + playerweapon = player getcurrentweapon(); + if ( !isDefined( player.lastweapon ) ) + { + player.lastweapon = playerweapon; + } + else + { + while ( player.lastweapon == playerweapon ) + { + wait 0,05; + } + } + values = get_engage_dists( playerweapon ); + if ( isDefined( values ) ) + { + level.weaponengagedistvalues = values; + } + else + { + level.weaponengagedistvalues = undefined; + } + player.lastweapon = playerweapon; + wait 0,05; +#/ + } +} + +debug_realtime_engage_dist() +{ +/# + level endon( "kill_all_engage_dist_debug" ); + level endon( "kill_realtime_engagement_distance_debug" ); + hudobjarray = engagement_distance_debug_init(); + level thread engage_dist_debug_hud_destroy( hudobjarray, "kill_all_engage_dist_debug" ); + level.debugrtengagedistcolor = level.green; + player = gethostplayer(); + while ( 1 ) + { + lasttracepos = ( 0, 1, 0 ); + direction = player getplayerangles(); + direction_vec = anglesToForward( direction ); + eye = player geteye(); + eye = ( eye[ 0 ], eye[ 1 ], eye[ 2 ] + 20 ); + trace = bullettrace( eye, eye + vectorScale( direction_vec, 10000 ), 1, player ); + tracepoint = trace[ "position" ]; + tracenormal = trace[ "normal" ]; + tracedist = int( distance( eye, tracepoint ) ); + if ( tracepoint != lasttracepos ) + { + lasttracepos = tracepoint; + if ( !isDefined( level.weaponengagedistvalues ) ) + { + hudobj_changecolor( hudobjarray, level.white ); + hudobjarray engagedist_hud_changetext( "nodata", tracedist ); + break; + } + else engagedistmin = level.weaponengagedistvalues.engagedistmin; + engagedistoptimal = level.weaponengagedistvalues.engagedistoptimal; + engagedistmulligan = level.weaponengagedistvalues.engagedistmulligan; + engagedistmax = level.weaponengagedistvalues.engagedistmax; + if ( tracedist >= engagedistmin && tracedist <= engagedistmax ) + { + if ( tracedist >= ( engagedistoptimal - engagedistmulligan ) && tracedist <= ( engagedistoptimal + engagedistmulligan ) ) + { + hudobjarray engagedist_hud_changetext( "optimal", tracedist ); + hudobj_changecolor( hudobjarray, level.green ); + } + else + { + hudobjarray engagedist_hud_changetext( "ok", tracedist ); + hudobj_changecolor( hudobjarray, level.yellow ); + } + break; + } + else + { + if ( tracedist < engagedistmin ) + { + hudobj_changecolor( hudobjarray, level.red ); + hudobjarray engagedist_hud_changetext( "short", tracedist ); + break; + } + else + { + if ( tracedist > engagedistmax ) + { + hudobj_changecolor( hudobjarray, level.red ); + hudobjarray engagedist_hud_changetext( "long", tracedist ); + } + } + } + } + thread plot_circle_fortime( 1, 5, 0,05, level.debugrtengagedistcolor, tracepoint, tracenormal ); + thread plot_circle_fortime( 1, 1, 0,05, level.debugrtengagedistcolor, tracepoint, tracenormal ); + wait 0,05; +#/ + } +} + +hudobj_changecolor( hudobjarray, newcolor ) +{ +/# + i = 0; + while ( i < hudobjarray.size ) + { + hudobj = hudobjarray[ i ]; + if ( hudobj.color != newcolor ) + { + hudobj.color = newcolor; + level.debugrtengagedistcolor = newcolor; + } + i++; +#/ + } +} + +engagedist_hud_changetext( engagedisttype, units ) +{ +/# + if ( !isDefined( level.lastdisttype ) ) + { + level.lastdisttype = "none"; + } + if ( engagedisttype == "optimal" ) + { + self[ 1 ] setvalue( units ); + self[ 2 ] settext( "units: OPTIMAL!" ); + self[ 3 ].alpha = 0; + } + else if ( engagedisttype == "ok" ) + { + self[ 1 ] setvalue( units ); + self[ 2 ] settext( "units: OK!" ); + self[ 3 ].alpha = 0; + } + else if ( engagedisttype == "short" ) + { + amountunder = level.weaponengagedistvalues.engagedistmin - units; + self[ 1 ] setvalue( units ); + self[ 3 ] setvalue( amountunder ); + self[ 3 ].alpha = 1; + if ( level.lastdisttype != engagedisttype ) + { + self[ 2 ] settext( "units: SHORT by " ); + } + } + else if ( engagedisttype == "long" ) + { + amountover = units - level.weaponengagedistvalues.engagedistmax; + self[ 1 ] setvalue( units ); + self[ 3 ] setvalue( amountover ); + self[ 3 ].alpha = 1; + if ( level.lastdisttype != engagedisttype ) + { + self[ 2 ] settext( "units: LONG by " ); + } + } + else + { + if ( engagedisttype == "nodata" ) + { + self[ 1 ] setvalue( units ); + self[ 2 ] settext( " units: (NO CURRENT WEAPON VALUES)" ); + self[ 3 ].alpha = 0; + } + } + level.lastdisttype = engagedisttype; +#/ +} + +plot_circle_fortime( radius1, radius2, time, color, origin, normal ) +{ +/# + if ( !isDefined( color ) ) + { + color = ( 0, 1, 0 ); + } + hangtime = 0,05; + circleres = 6; + hemires = circleres / 2; + circleinc = 360 / circleres; + circleres++; + plotpoints = []; + rad = 0; + timer = getTime() + ( time * 1000 ); + radius = radius1; + while ( getTime() < timer ) + { + radius = radius2; + angletoplayer = vectorToAngle( normal ); + i = 0; + while ( i < circleres ) + { + plotpoints[ plotpoints.size ] = origin + vectorScale( anglesToForward( angletoplayer + ( rad, 90, 0 ) ), radius ); + rad += circleinc; + i++; + } + maps/mp/_utility::plot_points( plotpoints, color[ 0 ], color[ 1 ], color[ 2 ], hangtime ); + plotpoints = []; + wait hangtime; +#/ + } +} + +larry_thread() +{ +/# + setdvar( "bot_AllowMovement", "0" ); + setdvar( "bot_PressAttackBtn", "0" ); + setdvar( "bot_PressMeleeBtn", "0" ); + level.larry = spawnstruct(); + player = gethostplayer(); + player thread larry_init( level.larry ); + level waittill( "kill_larry" ); + larry_hud_destroy( level.larry ); + if ( isDefined( level.larry.model ) ) + { + level.larry.model delete(); + } + while ( isDefined( level.larry.ai ) ) + { + i = 0; + while ( i < level.larry.ai.size ) + { + kick( level.larry.ai[ i ] getentitynumber() ); + i++; + } + } + level.larry = undefined; +#/ +} + +larry_init( larry ) +{ +/# + level endon( "kill_larry" ); + larry_hud_init( larry ); + larry.model = spawn( "script_model", ( 0, 1, 0 ) ); + larry.model setmodel( "defaultactor" ); + larry.ai = []; + wait 0,1; + for ( ;; ) + { + wait 0,05; + if ( larry.ai.size > 0 ) + { + larry.model hide(); + continue; + } + else + { + direction = self getplayerangles(); + direction_vec = anglesToForward( direction ); + eye = self geteye(); + trace = bullettrace( eye, eye + vectorScale( direction_vec, 8000 ), 0, undefined ); + dist = distance( eye, trace[ "position" ] ); + position = eye + vectorScale( direction_vec, dist - 64 ); + larry.model.origin = position; + larry.model.angles = self.angles + vectorScale( ( 0, 1, 0 ), 180 ); + while ( self usebuttonpressed() ) + { + self larry_ai( larry ); + while ( self usebuttonpressed() ) + { + wait 0,05; + } + } + } +#/ + } +} + +larry_ai( larry ) +{ +/# + larry.ai[ larry.ai.size ] = addtestclient(); + i = larry.ai.size - 1; + larry.ai[ i ].pers[ "isBot" ] = 1; + larry.ai[ i ] thread testclient( "autoassign" ); + larry.ai[ i ] thread larry_ai_thread( larry, larry.model.origin, larry.model.angles ); + larry.ai[ i ] thread larry_ai_damage( larry ); + larry.ai[ i ] thread larry_ai_health( larry ); +#/ +} + +larry_ai_thread( larry, origin, angles ) +{ +/# + level endon( "kill_larry" ); + for ( ;; ) + { + self waittill( "spawned_player" ); + larry.menu[ larry.menu_health ] setvalue( self.health ); + larry.menu[ larry.menu_damage ] settext( "" ); + larry.menu[ larry.menu_range ] settext( "" ); + larry.menu[ larry.menu_hitloc ] settext( "" ); + larry.menu[ larry.menu_weapon ] settext( "" ); + larry.menu[ larry.menu_perks ] settext( "" ); + self setorigin( origin ); + self setplayerangles( angles ); + self clearperks(); +#/ + } +} + +larry_ai_damage( larry ) +{ +/# + level endon( "kill_larry" ); + for ( ;; ) + { + self waittill( "damage", damage, attacker, dir, point ); + if ( !isDefined( attacker ) ) + { + continue; + } + else player = gethostplayer(); + if ( !isDefined( player ) ) + { + continue; + } + else if ( attacker != player ) + { + continue; + } + else eye = player geteye(); + range = int( distance( eye, point ) ); + larry.menu[ larry.menu_health ] setvalue( self.health ); + larry.menu[ larry.menu_damage ] setvalue( damage ); + larry.menu[ larry.menu_range ] setvalue( range ); + if ( isDefined( self.cac_debug_location ) ) + { + larry.menu[ larry.menu_hitloc ] settext( self.cac_debug_location ); + } + else + { + larry.menu[ larry.menu_hitloc ] settext( "" ); + } + if ( isDefined( self.cac_debug_weapon ) ) + { + larry.menu[ larry.menu_weapon ] settext( self.cac_debug_weapon ); + continue; + } + else + { + larry.menu[ larry.menu_weapon ] settext( "" ); + } +#/ + } +} + +larry_ai_health( larry ) +{ +/# + level endon( "kill_larry" ); + for ( ;; ) + { + wait 0,05; + larry.menu[ larry.menu_health ] setvalue( self.health ); +#/ + } +} + +larry_hud_init( larry ) +{ +/# + x = -45; + y = 275; + menu_name = "larry_menu"; + larry.hud = new_hud( menu_name, undefined, x, y, 1 ); + larry.hud setshader( "white", 135, 65 ); + larry.hud.alignx = "left"; + larry.hud.aligny = "top"; + larry.hud.sort = 10; + larry.hud.alpha = 0,6; + larry.hud.color = vectorScale( ( 0, 1, 0 ), 0,5 ); + larry.menu[ 0 ] = new_hud( menu_name, "Larry Health:", x + 5, y + 10, 1 ); + larry.menu[ 1 ] = new_hud( menu_name, "Damage:", x + 5, y + 20, 1 ); + larry.menu[ 2 ] = new_hud( menu_name, "Range:", x + 5, y + 30, 1 ); + larry.menu[ 3 ] = new_hud( menu_name, "Hit Location:", x + 5, y + 40, 1 ); + larry.menu[ 4 ] = new_hud( menu_name, "Weapon:", x + 5, y + 50, 1 ); + larry.cleartextmarker = newdebughudelem(); + larry.cleartextmarker.alpha = 0; + larry.cleartextmarker settext( "marker" ); + larry.menu_health = larry.menu.size; + larry.menu_damage = larry.menu.size + 1; + larry.menu_range = larry.menu.size + 2; + larry.menu_hitloc = larry.menu.size + 3; + larry.menu_weapon = larry.menu.size + 4; + larry.menu_perks = larry.menu.size + 5; + x_offset = 70; + larry.menu[ larry.menu_health ] = new_hud( menu_name, "", x + x_offset, y + 10, 1 ); + larry.menu[ larry.menu_damage ] = new_hud( menu_name, "", x + x_offset, y + 20, 1 ); + larry.menu[ larry.menu_range ] = new_hud( menu_name, "", x + x_offset, y + 30, 1 ); + larry.menu[ larry.menu_hitloc ] = new_hud( menu_name, "", x + x_offset, y + 40, 1 ); + larry.menu[ larry.menu_weapon ] = new_hud( menu_name, "", x + x_offset, y + 50, 1 ); + larry.menu[ larry.menu_perks ] = new_hud( menu_name, "", x + x_offset, y + 60, 1 ); +#/ +} + +larry_hud_destroy( larry ) +{ +/# + if ( isDefined( larry.hud ) ) + { + larry.hud destroy(); + i = 0; + while ( i < larry.menu.size ) + { + larry.menu[ i ] destroy(); + i++; + } + larry.cleartextmarker destroy(); +#/ + } +} + +new_hud( hud_name, msg, x, y, scale ) +{ +/# + if ( !isDefined( level.hud_array ) ) + { + level.hud_array = []; + } + if ( !isDefined( level.hud_array[ hud_name ] ) ) + { + level.hud_array[ hud_name ] = []; + } + hud = set_hudelem( msg, x, y, scale ); + level.hud_array[ hud_name ][ level.hud_array[ hud_name ].size ] = hud; + return hud; +#/ +} + +set_hudelem( text, x, y, scale, alpha, sort, debug_hudelem ) +{ +/# + if ( !isDefined( alpha ) ) + { + alpha = 1; + } + if ( !isDefined( scale ) ) + { + scale = 1; + } + if ( !isDefined( sort ) ) + { + sort = 20; + } + hud = newdebughudelem(); + hud.debug_hudelem = 1; + hud.location = 0; + hud.alignx = "left"; + hud.aligny = "middle"; + hud.foreground = 1; + hud.fontscale = scale; + hud.sort = sort; + hud.alpha = alpha; + hud.x = x; + hud.y = y; + hud.og_scale = scale; + if ( isDefined( text ) ) + { + hud settext( text ); + } + return hud; +#/ +} + +watch_botsdvars() +{ +/# + hasplayerweaponprev = getDvarInt( "scr_botsHasPlayerWeapon" ); + grenadesonlyprev = getDvarInt( "scr_botsGrenadesOnly" ); + secondarygrenadesonlyprev = getDvarInt( "scr_botsSpecialGrenadesOnly" ); + while ( 1 ) + { + if ( hasplayerweaponprev != getDvarInt( "scr_botsHasPlayerWeapon" ) ) + { + hasplayerweaponprev = getDvarInt( "scr_botsHasPlayerWeapon" ); + if ( hasplayerweaponprev ) + { + iprintlnbold( "LARRY has player weapon: ON" ); + break; + } + else + { + iprintlnbold( "LARRY has player weapon: OFF" ); + } + } + if ( grenadesonlyprev != getDvarInt( "scr_botsGrenadesOnly" ) ) + { + grenadesonlyprev = getDvarInt( "scr_botsGrenadesOnly" ); + if ( grenadesonlyprev ) + { + iprintlnbold( "LARRY using grenades only: ON" ); + break; + } + else + { + iprintlnbold( "LARRY using grenades only: OFF" ); + } + } + if ( secondarygrenadesonlyprev != getDvarInt( "scr_botsSpecialGrenadesOnly" ) ) + { + secondarygrenadesonlyprev = getDvarInt( "scr_botsSpecialGrenadesOnly" ); + if ( secondarygrenadesonlyprev ) + { + iprintlnbold( "LARRY using secondary grenades only: ON" ); + break; + } + else + { + iprintlnbold( "LARRY using secondary grenades only: OFF" ); + } + } + wait 1; +#/ + } +} + +getattachmentchangemodifierbutton() +{ +/# + return "BUTTON_X"; +#/ +} + +watchattachmentchange() +{ +/# + self endon( "disconnect" ); + clientnum = self getentitynumber(); + if ( clientnum != 0 ) + { + return; + } + dpad_left = 0; + dpad_right = 0; + dpad_up = 0; + dpad_down = 0; + lstick_down = 0; + dpad_modifier_button = getattachmentchangemodifierbutton(); + for ( ;; ) + { + if ( self buttonpressed( dpad_modifier_button ) ) + { + if ( !dpad_left && self buttonpressed( "DPAD_LEFT" ) ) + { + self giveweaponnextattachment( "muzzle" ); + dpad_left = 1; + self thread print_weapon_name(); + } + if ( !dpad_right && self buttonpressed( "DPAD_RIGHT" ) ) + { + self giveweaponnextattachment( "trigger" ); + dpad_right = 1; + self thread print_weapon_name(); + } + if ( !dpad_up && self buttonpressed( "DPAD_UP" ) ) + { + self giveweaponnextattachment( "top" ); + dpad_up = 1; + self thread print_weapon_name(); + } + if ( !dpad_down && self buttonpressed( "DPAD_DOWN" ) ) + { + self giveweaponnextattachment( "bottom" ); + dpad_down = 1; + self thread print_weapon_name(); + } + if ( !lstick_down && self buttonpressed( "BUTTON_LSTICK" ) ) + { + self giveweaponnextattachment( "gunperk" ); + lstick_down = 1; + self thread print_weapon_name(); + } + } + if ( !self buttonpressed( "DPAD_LEFT" ) ) + { + dpad_left = 0; + } + if ( !self buttonpressed( "DPAD_RIGHT" ) ) + { + dpad_right = 0; + } + if ( !self buttonpressed( "DPAD_UP" ) ) + { + dpad_up = 0; + } + if ( !self buttonpressed( "DPAD_DOWN" ) ) + { + dpad_down = 0; + } + if ( !self buttonpressed( "BUTTON_LSTICK" ) ) + { + lstick_down = 0; + } + wait 0,05; +#/ + } +} + +print_weapon_name() +{ +/# + self notify( "print_weapon_name" ); + self endon( "print_weapon_name" ); + wait 0,2; + if ( self isswitchingweapons() ) + { + self waittill( "weapon_change_complete", weapon_name ); + fail_safe = 0; + while ( weapon_name == "none" ) + { + self waittill( "weapon_change_complete", weapon_name ); + wait 0,05; + fail_safe++; + if ( fail_safe > 120 ) + { + break; + } + else + { + } + } + } + else weapon_name = self getcurrentweapon(); + printweaponname = getdvarintdefault( "scr_print_weapon_name", 1 ); + if ( printweaponname ) + { + iprintlnbold( weapon_name ); +#/ + } +} + +set_equipment_list() +{ +/# + if ( isDefined( level.dev_equipment ) ) + { + return; + } + level.dev_equipment = []; + level.dev_equipment[ 1 ] = "acoustic_sensor_mp"; + level.dev_equipment[ 2 ] = "camera_spike_mp"; + level.dev_equipment[ 3 ] = "claymore_mp"; + level.dev_equipment[ 4 ] = "satchel_charge_mp"; + level.dev_equipment[ 5 ] = "scrambler_mp"; + level.dev_equipment[ 6 ] = "tactical_insertion_mp"; + level.dev_equipment[ 7 ] = "bouncingbetty_mp"; + level.dev_equipment[ 8 ] = "trophy_system_mp"; + level.dev_equipment[ 9 ] = "pda_hack_mp"; +#/ +} + +set_grenade_list() +{ +/# + if ( isDefined( level.dev_grenade ) ) + { + return; + } + level.dev_grenade = []; + level.dev_grenade[ 1 ] = "frag_grenade_mp"; + level.dev_grenade[ 2 ] = "sticky_grenade_mp"; + level.dev_grenade[ 3 ] = "hatchet_mp"; + level.dev_grenade[ 4 ] = "willy_pete_mp"; + level.dev_grenade[ 5 ] = "proximity_grenade_mp"; + level.dev_grenade[ 6 ] = "flash_grenade_mp"; + level.dev_grenade[ 7 ] = "concussion_grenade_mp"; + level.dev_grenade[ 8 ] = "nightingale_mp"; + level.dev_grenade[ 9 ] = "emp_grenade_mp"; + level.dev_grenade[ 10 ] = "sensor_grenade_mp"; +#/ +} + +take_all_grenades_and_equipment( player ) +{ +/# + i = 0; + while ( i < level.dev_equipment.size ) + { + player takeweapon( level.dev_equipment[ i + 1 ] ); + i++; + } + i = 0; + while ( i < level.dev_grenade.size ) + { + player takeweapon( level.dev_grenade[ i + 1 ] ); + i++; +#/ + } +} + +equipment_dev_gui() +{ +/# + set_equipment_list(); + set_grenade_list(); + setdvar( "scr_give_equipment", "" ); + while ( 1 ) + { + wait 0,5; + devgui_int = getDvarInt( "scr_give_equipment" ); + if ( devgui_int != 0 ) + { + i = 0; + while ( i < level.players.size ) + { + take_all_grenades_and_equipment( level.players[ i ] ); + level.players[ i ] giveweapon( level.dev_equipment[ devgui_int ] ); + i++; + } + setdvar( "scr_give_equipment", "0" ); + } +#/ + } +} + +grenade_dev_gui() +{ +/# + set_equipment_list(); + set_grenade_list(); + setdvar( "scr_give_grenade", "" ); + while ( 1 ) + { + wait 0,5; + devgui_int = getDvarInt( "scr_give_grenade" ); + if ( devgui_int != 0 ) + { + i = 0; + while ( i < level.players.size ) + { + take_all_grenades_and_equipment( level.players[ i ] ); + level.players[ i ] giveweapon( level.dev_grenade[ devgui_int ] ); + i++; + } + setdvar( "scr_give_grenade", "0" ); + } +#/ + } +} + +force_grenade_throw( weapon ) +{ +/# + setdvar( "bot_AllowMovement", "0" ); + setdvar( "bot_PressAttackBtn", "0" ); + setdvar( "bot_PressMeleeBtn", "0" ); + setdvar( "scr_botsAllowKillstreaks", "0" ); + host = gethostplayer(); + if ( !isDefined( host.team ) ) + { + iprintln( "Unable to determine host player team" ); + return; + } + bot = getormakebot( getotherteam( host.team ) ); + if ( !isDefined( bot ) ) + { + iprintln( "Could not add test client" ); + return; + } + angles = host getplayerangles(); + angles = ( 0, angles[ 1 ], 0 ); + dir = anglesToForward( angles ); + dir = vectornormalize( dir ); + origin = host geteye() + vectorScale( dir, 256 ); + velocity = vectorScale( dir, -1024 ); + grenade = bot magicgrenade( weapon, origin, velocity ); + grenade setteam( bot.team ); + grenade setowner( bot ); +#/ +} + +bot_dpad_think() +{ +/# + level notify( "bot_dpad_stop" ); + level endon( "bot_dpad_stop" ); + level endon( "bot_dpad_terminate" ); + if ( !isDefined( level.bot_index ) ) + { + level.bot_index = 0; + } + host = gethostplayer(); + while ( !isDefined( host ) ) + { + wait 0,5; + host = gethostplayer(); + level.bot_index = 0; + } + dpad_left = 0; + dpad_right = 0; + for ( ;; ) + { + wait 0,05; + host setactionslot( 3, "" ); + host setactionslot( 4, "" ); + players = get_players(); + max = players.size; + if ( !dpad_left && host buttonpressed( "DPAD_LEFT" ) ) + { + level.bot_index--; + + if ( level.bot_index < 0 ) + { + level.bot_index = max - 1; + } + if ( !players[ level.bot_index ] is_bot() ) + { + continue; + } + else dpad_left = 1; + } + else + { + if ( !host buttonpressed( "DPAD_LEFT" ) ) + { + dpad_left = 0; + } + } + if ( !dpad_right && host buttonpressed( "DPAD_RIGHT" ) ) + { + level.bot_index++; + if ( level.bot_index >= max ) + { + level.bot_index = 0; + } + if ( !players[ level.bot_index ] is_bot() ) + { + continue; + } + else + { + dpad_right = 1; + } + else + { + if ( !host buttonpressed( "DPAD_RIGHT" ) ) + { + dpad_right = 0; + } + } + level notify( "bot_index_changed" ); + } +#/ + } +} + +bot_overlay_think() +{ +/# + level endon( "bot_overlay_stop" ); + level thread bot_dpad_think(); + iprintln( "Previous Bot bound to D-Pad Left" ); + iprintln( "Next Bot bound to D-Pad Right" ); + for ( ;; ) + { + if ( getDvarInt( "bot_Debug" ) != level.bot_index ) + { + setdvar( "bot_Debug", level.bot_index ); + } + level waittill( "bot_index_changed" ); +#/ + } +} + +bot_threat_think() +{ +/# + level endon( "bot_threat_stop" ); + level thread bot_dpad_think(); + iprintln( "Previous Bot bound to D-Pad Left" ); + iprintln( "Next Bot bound to D-Pad Right" ); + for ( ;; ) + { + if ( getDvarInt( "bot_DebugThreat" ) != level.bot_index ) + { + setdvar( "bot_DebugThreat", level.bot_index ); + } + level waittill( "bot_index_changed" ); +#/ + } +} + +bot_path_think() +{ +/# + level endon( "bot_path_stop" ); + level thread bot_dpad_think(); + iprintln( "Previous Bot bound to D-Pad Left" ); + iprintln( "Next Bot bound to D-Pad Right" ); + for ( ;; ) + { + if ( getDvarInt( "bot_DebugPaths" ) != level.bot_index ) + { + setdvar( "bot_DebugPaths", level.bot_index ); + } + level waittill( "bot_index_changed" ); +#/ + } +} + +bot_overlay_stop() +{ +/# + level notify( "bot_overlay_stop" ); + setdvar( "bot_Debug", "-1" ); +#/ +} + +bot_path_stop() +{ +/# + level notify( "bot_path_stop" ); + setdvar( "bot_DebugPaths", "-1" ); +#/ +} + +bot_threat_stop() +{ +/# + level notify( "bot_threat_stop" ); + setdvar( "bot_DebugThreat", "-1" ); +#/ +} + +devstraferunpathdebugdraw() +{ +/# + white = ( 0, 1, 0 ); + red = ( 0, 1, 0 ); + green = ( 0, 1, 0 ); + blue = ( 0, 1, 0 ); + violet = ( 0,4, 0, 0,6 ); + maxdrawtime = 10; + drawtime = maxdrawtime; + origintextoffset = vectorScale( ( 0, 1, 0 ), 50 ); + endonmsg = "devStopStrafeRunPathDebugDraw"; + while ( 1 ) + { + if ( getDvarInt( "scr_devStrafeRunPathDebugDraw" ) > 0 ) + { + nodes = []; + end = 0; + node = getvehiclenode( "warthog_start", "targetname" ); + while ( !isDefined( node ) ) + { + println( "No strafe run path found" ); + setdvar( "scr_devStrafeRunPathDebugDraw", "0" ); + } + while ( isDefined( node.target ) ) + { + new_node = getvehiclenode( node.target, "targetname" ); + _a3325 = nodes; + _k3325 = getFirstArrayKey( _a3325 ); + while ( isDefined( _k3325 ) ) + { + n = _a3325[ _k3325 ]; + if ( n == new_node ) + { + end = 1; + } + _k3325 = getNextArrayKey( _a3325, _k3325 ); + } + textscale = 30; + if ( drawtime == maxdrawtime ) + { + node thread drawpathsegment( new_node, violet, violet, 1, textscale, origintextoffset, drawtime, endonmsg ); + } + if ( isDefined( node.script_noteworthy ) ) + { + textscale = 10; + switch( node.script_noteworthy ) + { + case "strafe_start": + textcolor = green; + textalpha = 1; + break; + case "strafe_stop": + textcolor = red; + textalpha = 1; + break; + case "strafe_leave": + textcolor = white; + textalpha = 1; + break; + } + switch( node.script_noteworthy ) + { + case "strafe_leave": + case "strafe_start": + case "strafe_stop": + sides = 10; + radius = 100; + if ( drawtime == maxdrawtime ) + { + sphere( node.origin, radius, textcolor, textalpha, 1, sides, drawtime * 1000 ); + } + node draworiginlines(); + node drawnoteworthytext( textcolor, textalpha, textscale ); + break; + break; + } + } + if ( end ) + { + break; + } + else nodes[ nodes.size ] = new_node; + node = new_node; + } + drawtime -= 0,05; + if ( drawtime < 0 ) + { + drawtime = maxdrawtime; + } + wait 0,05; + continue; + } + else + { + wait 1; + } +#/ + } +} + +devhelipathdebugdraw() +{ +/# + white = ( 0, 1, 0 ); + red = ( 0, 1, 0 ); + green = ( 0, 1, 0 ); + blue = ( 0, 1, 0 ); + textcolor = white; + textalpha = 1; + textscale = 1; + maxdrawtime = 10; + drawtime = maxdrawtime; + origintextoffset = vectorScale( ( 0, 1, 0 ), 50 ); + endonmsg = "devStopHeliPathsDebugDraw"; + while ( 1 ) + { + if ( getDvarInt( "scr_devHeliPathsDebugDraw" ) > 0 ) + { + script_origins = getentarray( "script_origin", "classname" ); + _a3424 = script_origins; + _k3424 = getFirstArrayKey( _a3424 ); + while ( isDefined( _k3424 ) ) + { + ent = _a3424[ _k3424 ]; + if ( isDefined( ent.targetname ) ) + { + switch( ent.targetname ) + { + case "heli_start": + textcolor = blue; + textalpha = 1; + textscale = 3; + break; + case "heli_loop_start": + textcolor = green; + textalpha = 1; + textscale = 3; + break; + case "heli_attack_area": + textcolor = red; + textalpha = 1; + textscale = 3; + break; + case "heli_leave": + textcolor = white; + textalpha = 1; + textscale = 3; + break; + } + switch( ent.targetname ) + { + case "heli_attack_area": + case "heli_leave": + case "heli_loop_start": + case "heli_start": + if ( drawtime == maxdrawtime ) + { + ent thread drawpath( textcolor, white, textalpha, textscale, origintextoffset, drawtime, endonmsg ); + } + ent draworiginlines(); + ent drawtargetnametext( textcolor, textalpha, textscale ); + ent draworigintext( textcolor, textalpha, textscale, origintextoffset ); + break; + break; + } + } + _k3424 = getNextArrayKey( _a3424, _k3424 ); + } + drawtime -= 0,05; + if ( drawtime < 0 ) + { + drawtime = maxdrawtime; + } + } + if ( getDvarInt( "scr_devHeliPathsDebugDraw" ) == 0 ) + { + level notify( endonmsg ); + drawtime = maxdrawtime; + wait 1; + } + wait 0,05; +#/ + } +} + +draworiginlines() +{ +/# + red = ( 0, 1, 0 ); + green = ( 0, 1, 0 ); + blue = ( 0, 1, 0 ); + line( self.origin, self.origin + ( anglesToForward( self.angles ) * 10 ), red ); + line( self.origin, self.origin + ( anglesToRight( self.angles ) * 10 ), green ); + line( self.origin, self.origin + ( anglesToUp( self.angles ) * 10 ), blue ); +#/ +} + +drawtargetnametext( textcolor, textalpha, textscale, textoffset ) +{ +/# + if ( !isDefined( textoffset ) ) + { + textoffset = ( 0, 1, 0 ); + } + print3d( self.origin + textoffset, self.targetname, textcolor, textalpha, textscale ); +#/ +} + +drawnoteworthytext( textcolor, textalpha, textscale, textoffset ) +{ +/# + if ( !isDefined( textoffset ) ) + { + textoffset = ( 0, 1, 0 ); + } + print3d( self.origin + textoffset, self.script_noteworthy, textcolor, textalpha, textscale ); +#/ +} + +draworigintext( textcolor, textalpha, textscale, textoffset ) +{ +/# + if ( !isDefined( textoffset ) ) + { + textoffset = ( 0, 1, 0 ); + } + originstring = "(" + self.origin[ 0 ] + ", " + self.origin[ 1 ] + ", " + self.origin[ 2 ] + ")"; + print3d( self.origin + textoffset, originstring, textcolor, textalpha, textscale ); +#/ +} + +drawspeedacceltext( textcolor, textalpha, textscale, textoffset ) +{ +/# + if ( isDefined( self.script_airspeed ) ) + { + print3d( self.origin + ( 0, 0, textoffset[ 2 ] * 2 ), "script_airspeed:" + self.script_airspeed, textcolor, textalpha, textscale ); + } + if ( isDefined( self.script_accel ) ) + { + print3d( self.origin + ( 0, 0, textoffset[ 2 ] * 3 ), "script_accel:" + self.script_accel, textcolor, textalpha, textscale ); +#/ + } +} + +drawpath( linecolor, textcolor, textalpha, textscale, textoffset, drawtime, endonmsg ) +{ +/# + level endon( endonmsg ); + ent = self; + entfirsttarget = ent.targetname; + while ( isDefined( ent.target ) ) + { + enttarget = getent( ent.target, "targetname" ); + ent thread drawpathsegment( enttarget, linecolor, textcolor, textalpha, textscale, textoffset, drawtime, endonmsg ); + if ( ent.targetname == "heli_loop_start" ) + { + entfirsttarget = ent.target; + } + else + { + if ( ent.target == entfirsttarget ) + { + return; + } + } + else + { + ent = enttarget; + wait 0,05; +#/ + } + } +} + +drawpathsegment( enttarget, linecolor, textcolor, textalpha, textscale, textoffset, drawtime, endonmsg ) +{ +/# + level endon( endonmsg ); + while ( drawtime > 0 ) + { + if ( isDefined( self.targetname ) && self.targetname == "warthog_start" ) + { + print3d( self.origin + textoffset, self.targetname, textcolor, textalpha, textscale ); + } + line( self.origin, enttarget.origin, linecolor ); + self drawspeedacceltext( textcolor, textalpha, textscale, textoffset ); + drawtime -= 0,05; + wait 0,05; +#/ + } +} + +get_lookat_origin( player ) +{ +/# + angles = player getplayerangles(); + forward = anglesToForward( angles ); + dir = vectorScale( forward, 8000 ); + eye = player geteye(); + trace = bullettrace( eye, eye + dir, 0, undefined ); + return trace[ "position" ]; +#/ +} + +draw_pathnode( node, color ) +{ +/# + if ( !isDefined( color ) ) + { + color = ( 0, 1, 0 ); + } + box( node.origin, vectorScale( ( 0, 1, 0 ), 16 ), vectorScale( ( 0, 1, 0 ), 16 ), 0, color, 1, 0, 1 ); +#/ +} + +draw_pathnode_think( node, color ) +{ +/# + level endon( "draw_pathnode_stop" ); + for ( ;; ) + { + draw_pathnode( node, color ); + wait 0,05; +#/ + } +} + +draw_pathnodes_stop() +{ +/# + wait 5; + level notify( "draw_pathnode_stop" ); +#/ +} + +node_get( player ) +{ +/# + for ( ;; ) + { + wait 0,05; + origin = get_lookat_origin( player ); + node = getnearestnode( origin ); + if ( !isDefined( node ) ) + { + continue; + } + else if ( player buttonpressed( "BUTTON_A" ) ) + { + return node; + } + else + { + if ( player buttonpressed( "BUTTON_B" ) ) + { + return undefined; + } + } + if ( node.type == "Path" ) + { + draw_pathnode( node, ( 0, 1, 0 ) ); + continue; + } + else + { + draw_pathnode( node, ( 0,85, 0,85, 0,1 ) ); + } +#/ + } +} + +dev_get_node_pair() +{ +/# + player = gethostplayer(); + start = undefined; + while ( !isDefined( start ) ) + { + start = node_get( player ); + if ( player buttonpressed( "BUTTON_B" ) ) + { + level notify( "draw_pathnode_stop" ); + return undefined; + } + } + level thread draw_pathnode_think( start, ( 0, 1, 0 ) ); + while ( player buttonpressed( "BUTTON_A" ) ) + { + wait 0,05; + } + end = undefined; + while ( !isDefined( end ) ) + { + end = node_get( player ); + if ( player buttonpressed( "BUTTON_B" ) ) + { + level notify( "draw_pathnode_stop" ); + return undefined; + } + } + level thread draw_pathnode_think( end, ( 0, 1, 0 ) ); + level thread draw_pathnodes_stop(); + array = []; + array[ 0 ] = start; + array[ 1 ] = end; + return array; +#/ +} diff --git a/patch_mp/maps/mp/gametypes/_gameobjects.gsc b/patch_mp/maps/mp/gametypes/_gameobjects.gsc index d5054cd..949ca75 100644 --- a/patch_mp/maps/mp/gametypes/_gameobjects.gsc +++ b/patch_mp/maps/mp/gametypes/_gameobjects.gsc @@ -1,7 +1,10 @@ -#include maps/mp/gametypes_zm/_tweakables; -#include maps/mp/gametypes_zm/_hostmigration; -#include maps/mp/gametypes_zm/_weapons; -#include maps/mp/gametypes_zm/_hud_util; +#include maps/mp/gametypes/_tweakables; +#include maps/mp/killstreaks/_radar; +#include maps/mp/killstreaks/_killstreaks; +#include maps/mp/gametypes/_hostmigration; +#include maps/mp/gametypes/_weapons; +#include maps/mp/gametypes/_objpoints; +#include maps/mp/gametypes/_hud_util; #include maps/mp/_utility; #include common_scripts/utility; @@ -63,44 +66,6 @@ entity_is_allowed( entity, allowed_game_modes ) return allowed; } -location_is_allowed( entity, location ) -{ - allowed = 1; - location_list = undefined; - if ( isDefined( entity.script_noteworthy ) ) - { - location_list = entity.script_noteworthy; - } - if ( isDefined( entity.script_location ) ) - { - location_list = entity.script_location; - } - while ( isDefined( location_list ) ) - { - if ( location_list == "[all_modes]" ) - { - allowed = 1; - break; - } - else allowed = 0; - gameobjectlocations = strtok( location_list, " " ); - j = 0; - while ( j < gameobjectlocations.size ) - { - if ( gameobjectlocations[ j ] == location ) - { - allowed = 1; - break; - } - else - { - j++; - } - } - } - return allowed; -} - filter_script_vehicles_from_vehicle_descriptors( allowed_game_modes ) { vehicle_descriptors = getentarray( "vehicle_descriptor", "targetname" ); @@ -185,7 +150,6 @@ onplayerspawned() ondeath() { level endon( "game_ended" ); - self endon( "spawned_player" ); self waittill( "death" ); if ( isDefined( self.carryobject ) ) { @@ -247,18 +211,38 @@ createcarryobject( ownerteam, trigger, visuals, offset, objectivename ) carryobject.objid = []; while ( !carryobject.newstyle ) { - _a319 = level.teams; - _k319 = getFirstArrayKey( _a319 ); - while ( isDefined( _k319 ) ) + _a269 = level.teams; + _k269 = getFirstArrayKey( _a269 ); + while ( isDefined( _k269 ) ) { - team = _a319[ _k319 ]; + team = _a269[ _k269 ]; carryobject.objid[ team ] = getnextobjid(); - _k319 = getNextArrayKey( _a319, _k319 ); + _k269 = getNextArrayKey( _a269, _k269 ); } } carryobject.objidpingfriendly = 0; carryobject.objidpingenemy = 0; level.objidstart += 2; + if ( !carryobject.newstyle ) + { + if ( level.teambased ) + { + _a283 = level.teams; + _k283 = getFirstArrayKey( _a283 ); + while ( isDefined( _k283 ) ) + { + team = _a283[ _k283 ]; + objective_add( carryobject.objid[ team ], "invisible", carryobject.curorigin ); + objective_team( carryobject.objid[ team ], team ); + carryobject.objpoints[ team ] = maps/mp/gametypes/_objpoints::createteamobjpoint( "objpoint_" + team + "_" + carryobject.entnum, carryobject.curorigin + offset, team, undefined ); + carryobject.objpoints[ team ].alpha = 0; + _k283 = getNextArrayKey( _a283, _k283 ); + } + } + else objective_add( carryobject.objid[ level.nonteambasedteam ], "invisible", carryobject.curorigin ); + carryobject.objpoints[ level.nonteambasedteam ] = maps/mp/gametypes/_objpoints::createteamobjpoint( "objpoint_" + level.nonteambasedteam + "_" + carryobject.entnum, carryobject.curorigin + offset, "all", undefined ); + carryobject.objpoints[ level.nonteambasedteam ].alpha = 0; + } carryobject.objectiveid = getnextobjid(); objective_add( carryobject.objectiveid, "invisible", carryobject.curorigin, objectivename ); carryobject.carrier = undefined; @@ -280,7 +264,34 @@ createcarryobject( ownerteam, trigger, visuals, offset, objectivename ) } else { - carryobject thread carryobjectproxthink(); + carryobject.numtouching[ "neutral" ] = 0; + carryobject.numtouching[ "none" ] = 0; + carryobject.touchlist[ "neutral" ] = []; + carryobject.touchlist[ "none" ] = []; + _a339 = level.teams; + _k339 = getFirstArrayKey( _a339 ); + while ( isDefined( _k339 ) ) + { + team = _a339[ _k339 ]; + carryobject.numtouching[ team ] = 0; + carryobject.touchlist[ team ] = []; + _k339 = getNextArrayKey( _a339, _k339 ); + } + carryobject.curprogress = 0; + carryobject.usetime = 0; + carryobject.userate = 0; + carryobject.claimteam = "none"; + carryobject.claimplayer = undefined; + carryobject.lastclaimteam = "none"; + carryobject.lastclaimtime = 0; + carryobject.claimgraceperiod = 0; + carryobject.mustmaintainclaim = 0; + carryobject.cancontestclaim = 0; + carryobject.decayprogress = 0; + carryobject.teamusetimes = []; + carryobject.teamusetexts = []; + carryobject.onuse = ::setpickedup; + carryobject thread useobjectproxthink(); } carryobject thread updatecarryobjectorigin(); carryobject thread updatecarryobjectobjectiveorigin(); @@ -411,9 +422,13 @@ pickupobjectdelay( origin ) setpickedup( player ) { + if ( !isalive( player ) ) + { + return; + } if ( isDefined( player.carryobject ) ) { - if ( isDefined( player.carryobject.swappable ) && player.carryobject.swappable ) + if ( is_true( player.carryobject.swappable ) ) { player.carryobject thread setdropped(); } @@ -492,13 +507,21 @@ updatecarryobjectorigin() if ( isDefined( self.carrier ) && level.teambased ) { self.curorigin = self.carrier.origin + vectorScale( ( 0, 0, 1 ), 75 ); + _a606 = level.teams; + _k606 = getFirstArrayKey( _a606 ); + while ( isDefined( _k606 ) ) + { + team = _a606[ _k606 ]; + self.objpoints[ team ] maps/mp/gametypes/_objpoints::updateorigin( self.curorigin ); + _k606 = getNextArrayKey( _a606, _k606 ); + } while ( self.visibleteam != "friendly" && self.visibleteam == "any" && self.objidpingfriendly ) { - _a626 = level.teams; - _k626 = getFirstArrayKey( _a626 ); - while ( isDefined( _k626 ) ) + _a613 = level.teams; + _k613 = getFirstArrayKey( _a613 ); + while ( isDefined( _k613 ) ) { - team = _a626[ _k626 ]; + team = _a613[ _k613 ]; if ( self isfriendlyteam( team ) ) { if ( self.objpoints[ team ].isshown ) @@ -509,7 +532,7 @@ updatecarryobjectorigin() } objective_position( self.objid[ team ], self.curorigin ); } - _k626 = getNextArrayKey( _a626, _k626 ); + _k613 = getNextArrayKey( _a613, _k613 ); } } if ( self.visibleteam != "enemy" && self.visibleteam == "any" && self.objidpingenemy ) @@ -533,11 +556,25 @@ updatecarryobjectorigin() if ( isDefined( self.carrier ) ) { self.curorigin = self.carrier.origin + vectorScale( ( 0, 0, 1 ), 75 ); + self.objpoints[ level.nonteambasedteam ] maps/mp/gametypes/_objpoints::updateorigin( self.curorigin ); + objective_position( self.objid[ level.nonteambasedteam ], self.curorigin ); wait 0,05; break; } else { + if ( level.teambased ) + { + _a656 = level.teams; + _k656 = getFirstArrayKey( _a656 ); + while ( isDefined( _k656 ) ) + { + team = _a656[ _k656 ]; + self.objpoints[ team ] maps/mp/gametypes/_objpoints::updateorigin( self.curorigin + self.offset3d ); + _k656 = getNextArrayKey( _a656, _k656 ); + } + } + else self.objpoints[ level.nonteambasedteam ] maps/mp/gametypes/_objpoints::updateorigin( self.curorigin + self.offset3d ); wait 0,05; } } @@ -585,7 +622,7 @@ giveobject( object ) self.disallowvehicleusage = 1; if ( isDefined( object.visiblecarriermodel ) ) { - self maps/mp/gametypes_zm/_weapons::forcestowedweaponupdate(); + self maps/mp/gametypes/_weapons::forcestowedweaponupdate(); } if ( !object.newstyle ) { @@ -842,7 +879,7 @@ takeobject( object ) } if ( isDefined( object.visiblecarriermodel ) ) { - self maps/mp/gametypes_zm/_weapons::detach_all_weapons(); + self maps/mp/gametypes/_weapons::detach_all_weapons(); } self.carryobject = undefined; if ( !isalive( self ) ) @@ -857,7 +894,7 @@ takeobject( object ) } if ( isDefined( object.visiblecarriermodel ) ) { - self maps/mp/gametypes_zm/_weapons::forcestowedweaponupdate(); + self maps/mp/gametypes/_weapons::forcestowedweaponupdate(); } if ( !object.allowweapons ) { @@ -951,30 +988,47 @@ createuseobject( ownerteam, trigger, visuals, offset, objectivename ) useobject.objid = []; if ( !useobject.newstyle ) { - _a1185 = level.teams; - _k1185 = getFirstArrayKey( _a1185 ); - while ( isDefined( _k1185 ) ) + _a1172 = level.teams; + _k1172 = getFirstArrayKey( _a1172 ); + while ( isDefined( _k1172 ) ) { - team = _a1185[ _k1185 ]; + team = _a1172[ _k1172 ]; useobject.objid[ team ] = getnextobjid(); - _k1185 = getNextArrayKey( _a1185, _k1185 ); + _k1172 = getNextArrayKey( _a1172, _k1172 ); } if ( level.teambased ) { - _a1192 = level.teams; - _k1192 = getFirstArrayKey( _a1192 ); - while ( isDefined( _k1192 ) ) + _a1179 = level.teams; + _k1179 = getFirstArrayKey( _a1179 ); + while ( isDefined( _k1179 ) ) { - team = _a1192[ _k1192 ]; + team = _a1179[ _k1179 ]; objective_add( useobject.objid[ team ], "invisible", useobject.curorigin ); objective_team( useobject.objid[ team ], team ); - _k1192 = getNextArrayKey( _a1192, _k1192 ); + _k1179 = getNextArrayKey( _a1179, _k1179 ); } } else objective_add( useobject.objid[ level.nonteambasedteam ], "invisible", useobject.curorigin ); } useobject.objectiveid = getnextobjid(); - objective_add( useobject.objectiveid, "invisible", useobject.curorigin, objectivename ); + objective_add( useobject.objectiveid, "invisible", useobject.curorigin + offset, objectivename ); + if ( !useobject.newstyle ) + { + if ( level.teambased ) + { + _a1203 = level.teams; + _k1203 = getFirstArrayKey( _a1203 ); + while ( isDefined( _k1203 ) ) + { + team = _a1203[ _k1203 ]; + useobject.objpoints[ team ] = maps/mp/gametypes/_objpoints::createteamobjpoint( "objpoint_" + team + "_" + useobject.entnum, useobject.curorigin + offset, team, undefined ); + useobject.objpoints[ team ].alpha = 0; + _k1203 = getNextArrayKey( _a1203, _k1203 ); + } + } + else useobject.objpoints[ level.nonteambasedteam ] = maps/mp/gametypes/_objpoints::createteamobjpoint( "objpoint_allies_" + useobject.entnum, useobject.curorigin + offset, "all", undefined ); + useobject.objpoints[ level.nonteambasedteam ].alpha = 0; + } useobject.interactteam = "none"; useobject.worldicons = []; useobject.visibleteam = "none"; @@ -991,15 +1045,17 @@ createuseobject( ownerteam, trigger, visuals, offset, objectivename ) useobject.numtouching[ "none" ] = 0; useobject.touchlist[ "neutral" ] = []; useobject.touchlist[ "none" ] = []; - _a1255 = level.teams; - _k1255 = getFirstArrayKey( _a1255 ); - while ( isDefined( _k1255 ) ) + _a1242 = level.teams; + _k1242 = getFirstArrayKey( _a1242 ); + while ( isDefined( _k1242 ) ) { - team = _a1255[ _k1255 ]; + team = _a1242[ _k1242 ]; useobject.numtouching[ team ] = 0; useobject.touchlist[ team ] = []; - _k1255 = getNextArrayKey( _a1255, _k1255 ); + _k1242 = getNextArrayKey( _a1242, _k1242 ); } + useobject.teamusetimes = []; + useobject.teamusetexts = []; useobject.userate = 0; useobject.claimteam = "none"; useobject.claimplayer = undefined; @@ -1146,8 +1202,11 @@ useobjectproxthink() { self [[ self.onuse ]]( creditplayer ); } - self setclaimteam( "none" ); - self.claimplayer = undefined; + if ( !self.mustmaintainclaim ) + { + self setclaimteam( "none" ); + self.claimplayer = undefined; + } } if ( self.claimteam != "none" ) { @@ -1161,7 +1220,7 @@ useobjectproxthink() self.claimplayer = undefined; self clearprogress(); } - else if ( self.usetime ) + else if ( self.usetime || !self.mustmaintainclaim && self getownerteam() != self getclaimteam() ) { if ( self.decayprogress && !self.numtouching[ self.claimteam ] ) { @@ -1216,53 +1275,80 @@ useobjectproxthink() } } } - else if ( !self.mustmaintainclaim ) + else { - if ( isDefined( self.onuse ) ) - { - self [[ self.onuse ]]( self.claimplayer ); - } if ( !self.mustmaintainclaim ) { + if ( isDefined( self.onuse ) ) + { + self [[ self.onuse ]]( self.claimplayer ); + } + if ( !self.mustmaintainclaim ) + { + self setclaimteam( "none" ); + self.claimplayer = undefined; + } + break; + } + else if ( !self.numtouching[ self.claimteam ] ) + { + if ( isDefined( self.onunoccupied ) ) + { + self [[ self.onunoccupied ]](); + } self setclaimteam( "none" ); self.claimplayer = undefined; + break; + } + else + { + if ( self.cancontestclaim ) + { + numother = getnumtouchingexceptteam( self.claimteam ); + if ( numother > 0 ) + { + if ( isDefined( self.oncontested ) ) + { + self [[ self.oncontested ]](); + } + self setclaimteam( "none" ); + self.claimplayer = undefined; + } + } } } - else if ( !self.numtouching[ self.claimteam ] ) + } + else if ( self.curprogress > 0 && ( getTime() - self.lastclaimtime ) > ( self.claimgraceperiod * 1000 ) ) + { + self clearprogress(); + } + if ( self.mustmaintainclaim && self getownerteam() != "none" ) + { + if ( !self.numtouching[ self getownerteam() ] ) { if ( isDefined( self.onunoccupied ) ) { self [[ self.onunoccupied ]](); } - self setclaimteam( "none" ); - self.claimplayer = undefined; + break; } else { - if ( self.cancontestclaim ) + if ( self.cancontestclaim && self.lastclaimteam != "none" && self.numtouching[ self.lastclaimteam ] ) { - numother = getnumtouchingexceptteam( self.claimteam ); - if ( numother > 0 ) + numother = getnumtouchingexceptteam( self.lastclaimteam ); + if ( numother == 0 ) { - if ( isDefined( self.oncontested ) ) + if ( isDefined( self.onuncontested ) ) { - self [[ self.oncontested ]](); + self [[ self.onuncontested ]]( self.lastclaimteam ); } - self setclaimteam( "none" ); - self.claimplayer = undefined; } } } } - else - { - if ( self.curprogress > 0 && ( getTime() - self.lastclaimtime ) > ( self.claimgraceperiod * 1000 ) ) - { - self clearprogress(); - } - } wait 0,05; - maps/mp/gametypes_zm/_hostmigration::waittillhostmigrationdone(); + maps/mp/gametypes/_hostmigration::waittillhostmigrationdone(); } } @@ -1277,6 +1363,10 @@ useobjectlockedforteam( team ) canclaim( player ) { + if ( isDefined( self.carrier ) ) + { + return 0; + } if ( self.cancontestclaim ) { numother = getnumtouchingexceptteam( player.pers[ "team" ] ); @@ -1304,7 +1394,7 @@ proxtriggerthink() { continue; } - while ( player isinvehicle() ) + while ( player.spawntime == getTime() ) { continue; } @@ -1312,12 +1402,21 @@ proxtriggerthink() { continue; } + while ( self isexcluded( player ) ) + { + continue; + } if ( self caninteractwith( player ) && self.claimteam == "none" ) { if ( self canclaim( player ) ) { setclaimteam( player.pers[ "team" ] ); self.claimplayer = player; + relativeteam = self getrelativeteam( player.pers[ "team" ] ); + if ( isDefined( self.teamusetimes[ relativeteam ] ) ) + { + self.usetime = self.teamusetimes[ relativeteam ]; + } if ( self.usetime && isDefined( self.onbeginuse ) ) { self [[ self.onbeginuse ]]( self.claimplayer ); @@ -1339,6 +1438,26 @@ proxtriggerthink() } } +isexcluded( player ) +{ + if ( !isDefined( self.exclusions ) ) + { + return 0; + } + _a1676 = self.exclusions; + _k1676 = getFirstArrayKey( _a1676 ); + while ( isDefined( _k1676 ) ) + { + exclusion = _a1676[ _k1676 ]; + if ( exclusion istouching( player ) ) + { + return 1; + } + _k1676 = getNextArrayKey( _a1676, _k1676 ); + } + return 0; +} + clearprogress() { self.curprogress = 0; @@ -1386,10 +1505,6 @@ continuetriggertouchthink( team, object ) { return 0; } - if ( self isinvehicle() ) - { - return 0; - } if ( !self istouching( object.trigger ) ) { return 0; @@ -1516,7 +1631,7 @@ updateproxbar( object, forceremove ) } if ( !isDefined( self.proxbar ) ) { - self.proxbar = self createprimaryprogressbar(); + self.proxbar = createprimaryprogressbar(); self.proxbar.lastuserate = -1; self.proxbar.lasthostmigrationstate = 0; } @@ -1528,7 +1643,7 @@ updateproxbar( object, forceremove ) } if ( !isDefined( self.proxbartext ) ) { - self.proxbartext = self createprimaryprogressbartext(); + self.proxbartext = createprimaryprogressbartext(); self.proxbartext settext( object.usetext ); } if ( self.proxbartext.hidden ) @@ -1573,11 +1688,11 @@ updateproxbar( object, forceremove ) getnumtouchingexceptteam( ignoreteam ) { numtouching = 0; - _a1902 = level.teams; - _k1902 = getFirstArrayKey( _a1902 ); - while ( isDefined( _k1902 ) ) + _a1944 = level.teams; + _k1944 = getFirstArrayKey( _a1944 ); + while ( isDefined( _k1944 ) ) { - team = _a1902[ _k1902 ]; + team = _a1944[ _k1944 ]; if ( ignoreteam == team ) { } @@ -1585,7 +1700,7 @@ getnumtouchingexceptteam( ignoreteam ) { numtouching += self.numtouching[ team ]; } - _k1902 = getNextArrayKey( _a1902, _k1902 ); + _k1944 = getNextArrayKey( _a1944, _k1944 ); } return numtouching; } @@ -1633,7 +1748,7 @@ updateuserate() useholdthink( player ) { player notify( "use_hold" ); - if ( isDefined( self.dontlinkplayertotrigger ) && !self.dontlinkplayertotrigger ) + if ( !is_true( self.dontlinkplayertotrigger ) ) { player playerlinkto( self.trigger ); player playerlinkedoffsetenable(); @@ -1698,13 +1813,14 @@ useholdthink( player ) if ( isDefined( useweapon ) ) { ammo = player getweaponammoclip( lastweapon ); - if ( lastweapon != "none" && isweaponequipment( lastweapon ) && player getweaponammoclip( lastweapon ) != 0 ) + if ( lastweapon != "none" && !maps/mp/killstreaks/_killstreaks::iskillstreakweapon( lastweapon ) && isweaponequipment( lastweapon ) && player getweaponammoclip( lastweapon ) != 0 ) { player switchtoweapon( lastweapon ); } else { player takeweapon( useweapon ); + player switchtolastnonkillstreakweapon(); } } else @@ -1714,7 +1830,7 @@ useholdthink( player ) player _enableweapon(); } } - if ( isDefined( self.dontlinkplayertotrigger ) && !self.dontlinkplayertotrigger ) + if ( !is_true( self.dontlinkplayertotrigger ) ) { player unlink(); } @@ -1806,7 +1922,14 @@ updatecurrentprogress() { if ( self.usetime ) { - progress = float( self.curprogress ) / self.usetime; + if ( isDefined( self.curprogress ) ) + { + progress = float( self.curprogress ) / self.usetime; + } + else + { + progress = 0; + } objective_setprogress( self.objectiveid, clamp( progress, 0, 1 ) ); } } @@ -1840,22 +1963,21 @@ useholdthinkloop( player, lastweapon ) player.claimtrigger = undefined; if ( isDefined( useweapon ) ) { - player setweaponammostock( useweapon, 1 ); - player setweaponammoclip( useweapon, 1 ); - if ( lastweapon != "none" && isweaponequipment( lastweapon ) && player getweaponammoclip( lastweapon ) != 0 ) + if ( lastweapon != "none" && !maps/mp/killstreaks/_killstreaks::iskillstreakweapon( lastweapon ) && isweaponequipment( lastweapon ) && player getweaponammoclip( lastweapon ) != 0 ) { player switchtoweapon( lastweapon ); } else { player takeweapon( useweapon ); + player switchtolastnonkillstreakweapon(); } } else { player _enableweapon(); } - if ( isDefined( self.dontlinkplayertotrigger ) && !self.dontlinkplayertotrigger ) + if ( !is_true( self.dontlinkplayertotrigger ) ) { player unlink(); } @@ -1863,7 +1985,7 @@ useholdthinkloop( player, lastweapon ) return isalive( player ); } wait 0,05; - maps/mp/gametypes_zm/_hostmigration::waittillhostmigrationdone(); + maps/mp/gametypes/_hostmigration::waittillhostmigrationdone(); } return 0; } @@ -1879,8 +2001,8 @@ personalusebar( object ) { return; } - self.usebar = self createprimaryprogressbar(); - self.usebartext = self createprimaryprogressbartext(); + self.usebar = createprimaryprogressbar(); + self.usebartext = createprimaryprogressbartext(); self.usebartext settext( object.usetext ); usetime = object.usetime; lastrate = -1; @@ -2043,6 +2165,73 @@ updateworldicons() updateworldicon( relativeteam, showicon ) { + if ( self.newstyle ) + { + return; + } + if ( !isDefined( self.worldicons[ relativeteam ] ) ) + { + showicon = 0; + } + updateteams = getupdateteams( relativeteam ); + index = 0; + while ( index < updateteams.size ) + { + if ( !level.teambased && updateteams[ index ] != level.nonteambasedteam ) + { + index++; + continue; + } + else + { + opname = "objpoint_" + updateteams[ index ] + "_" + self.entnum; + objpoint = maps/mp/gametypes/_objpoints::getobjpointbyname( opname ); + objpoint notify( "stop_flashing_thread" ); + objpoint thread maps/mp/gametypes/_objpoints::stopflashing(); + if ( showicon ) + { + objpoint setshader( self.worldicons[ relativeteam ], level.objpointsize, level.objpointsize ); + objpoint fadeovertime( 0,05 ); + objpoint.alpha = objpoint.basealpha; + objpoint.isshown = 1; + iswaypoint = 1; + if ( isDefined( self.worldiswaypoint[ relativeteam ] ) ) + { + iswaypoint = self.worldiswaypoint[ relativeteam ]; + } + if ( isDefined( self.compassicons[ relativeteam ] ) ) + { + objpoint setwaypoint( iswaypoint, self.worldicons[ relativeteam ] ); + } + else + { + objpoint setwaypoint( iswaypoint ); + } + if ( self.type == "carryObject" ) + { + if ( isDefined( self.carrier ) && !shouldpingobject( relativeteam ) ) + { + objpoint settargetent( self.carrier ); + break; + } + else + { + objpoint cleartargetent(); + } + } + index++; + continue; + } + else + { + objpoint fadeovertime( 0,05 ); + objpoint.alpha = 0; + objpoint.isshown = 0; + objpoint cleartargetent(); + } + } + index++; + } } updatecompassicons() @@ -2143,30 +2332,30 @@ getupdateteams( relativeteam ) { if ( relativeteam == "friendly" ) { - _a2526 = level.teams; - _k2526 = getFirstArrayKey( _a2526 ); - while ( isDefined( _k2526 ) ) + _a2569 = level.teams; + _k2569 = getFirstArrayKey( _a2569 ); + while ( isDefined( _k2569 ) ) { - team = _a2526[ _k2526 ]; + team = _a2569[ _k2569 ]; if ( self isfriendlyteam( team ) ) { updateteams[ updateteams.size ] = team; } - _k2526 = getNextArrayKey( _a2526, _k2526 ); + _k2569 = getNextArrayKey( _a2569, _k2569 ); } } else while ( relativeteam == "enemy" ) { - _a2534 = level.teams; - _k2534 = getFirstArrayKey( _a2534 ); - while ( isDefined( _k2534 ) ) + _a2577 = level.teams; + _k2577 = getFirstArrayKey( _a2577 ); + while ( isDefined( _k2577 ) ) { - team = _a2534[ _k2534 ]; + team = _a2577[ _k2577 ]; if ( !self isfriendlyteam( team ) ) { updateteams[ updateteams.size ] = team; } - _k2534 = getNextArrayKey( _a2534, _k2534 ); + _k2577 = getNextArrayKey( _a2577, _k2577 ); } } } @@ -2184,6 +2373,21 @@ getupdateteams( relativeteam ) shouldshowcompassduetoradar( team ) { showcompass = 0; + if ( !isDefined( self.carrier ) ) + { + return 0; + } + if ( self.carrier hasperk( "specialty_gpsjammer" ) == 0 ) + { + if ( maps/mp/killstreaks/_radar::teamhasspyplane( team ) ) + { + showcompass = 1; + } + } + if ( maps/mp/killstreaks/_radar::teamhassatellite( team ) ) + { + showcompass = 1; + } return showcompass; } @@ -2227,6 +2431,16 @@ setusetext( text ) self.usetext = text; } +setteamusetime( relativeteam, time ) +{ + self.teamusetimes[ relativeteam ] = int( time * 1000 ); +} + +setteamusetext( relativeteam, text ) +{ + self.teamusetexts[ relativeteam ] = text; +} + setusehinttext( text ) { self.trigger sethintstring( text ); @@ -2234,7 +2448,7 @@ setusehinttext( text ) allowcarry( relativeteam ) { - self.interactteam = relativeteam; + allowuse( relativeteam ); } allowuse( relativeteam ) @@ -2246,7 +2460,7 @@ allowuse( relativeteam ) setvisibleteam( relativeteam ) { self.visibleteam = relativeteam; - if ( !maps/mp/gametypes_zm/_tweakables::gettweakablevalue( "hud", "showobjicons" ) ) + if ( !maps/mp/gametypes/_tweakables::gettweakablevalue( "hud", "showobjicons" ) ) { self.visibleteam = "none"; } @@ -2368,17 +2582,17 @@ destroyobject( deletetrigger, forcehide ) forcehide = 1; } self disableobject( forcehide ); - _a2742 = self.visuals; - _k2742 = getFirstArrayKey( _a2742 ); - while ( isDefined( _k2742 ) ) + _a2795 = self.visuals; + _k2795 = getFirstArrayKey( _a2795 ); + while ( isDefined( _k2795 ) ) { - visual = _a2742[ _k2742 ]; + visual = _a2795[ _k2795 ]; visual hide(); visual delete(); - _k2742 = getNextArrayKey( _a2742, _k2742 ); + _k2795 = getNextArrayKey( _a2795, _k2795 ); } self.trigger notify( "destroyed" ); - if ( isDefined( deletetrigger ) && deletetrigger ) + if ( is_true( deletetrigger ) ) { self.trigger delete(); } @@ -2607,8 +2821,15 @@ getnextobjid() level.numgametypereservedobjectives++; } /# - assert( nextid < 32, "Ran out of objective IDs" ); + if ( nextid >= 32 ) + { + println( "^3SCRIPT WARNING: Ran out of objective IDs" ); #/ + } + if ( nextid > 31 ) + { + nextid = 31; + } return nextid; } diff --git a/patch_mp/maps/mp/gametypes/_globallogic_actor.gsc b/patch_mp/maps/mp/gametypes/_globallogic_actor.gsc index 08518fb..700c908 100644 --- a/patch_mp/maps/mp/gametypes/_globallogic_actor.gsc +++ b/patch_mp/maps/mp/gametypes/_globallogic_actor.gsc @@ -1,8 +1,10 @@ #include maps/mp/_challenges; -#include maps/mp/gametypes_zm/_damagefeedback; -#include maps/mp/gametypes_zm/_weapons; -#include maps/mp/gametypes_zm/_globallogic_utils; -#include maps/mp/gametypes_zm/_globallogic_player; +#include maps/mp/_scoreevents; +#include maps/mp/gametypes/_damagefeedback; +#include maps/mp/gametypes/_weapons; +#include maps/mp/_burnplayer; +#include maps/mp/gametypes/_globallogic_utils; +#include maps/mp/gametypes/_globallogic_player; #include maps/mp/_utility; callback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex ) @@ -21,7 +23,7 @@ callback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sw } self.idflags = idflags; self.idflagstime = getTime(); - eattacker = maps/mp/gametypes_zm/_globallogic_player::figureoutattacker( eattacker ); + eattacker = maps/mp/gametypes/_globallogic_player::figureoutattacker( eattacker ); if ( !isDefined( vdir ) ) { idflags |= level.idflags_no_knockback; @@ -33,7 +35,7 @@ callback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sw self.attackerdata = []; self.attackerdamage = []; } - if ( maps/mp/gametypes_zm/_globallogic_utils::isheadshot( sweapon, shitloc, smeansofdeath, einflictor ) ) + if ( maps/mp/gametypes/_globallogic_utils::isheadshot( sweapon, shitloc, smeansofdeath, einflictor ) ) { smeansofdeath = "MOD_HEAD_SHOT"; } @@ -51,6 +53,17 @@ callback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sw } } } + if ( smeansofdeath == "MOD_BURNED" ) + { + if ( sweapon == "none" ) + { + self maps/mp/_burnplayer::walkedthroughflames(); + } + if ( sweapon == "m2_flamethrower_mp" ) + { + self maps/mp/_burnplayer::burnedwithflamethrower(); + } + } if ( sweapon == "none" && isDefined( einflictor ) ) { if ( isDefined( einflictor.targetname ) && einflictor.targetname == "explodable_barrel" ) @@ -122,7 +135,7 @@ callback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sw } if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( sweapon ) && !issubstr( smeansofdeath, "MOD_MELEE" ) ) { - eattacker thread maps/mp/gametypes_zm/_weapons::checkhit( sweapon ); + eattacker thread maps/mp/gametypes/_weapons::checkhit( sweapon ); } if ( issubstr( smeansofdeath, "MOD_GRENADE" ) && isDefined( einflictor ) && isDefined( einflictor.iscooked ) ) { @@ -144,7 +157,7 @@ callback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sw { if ( idamage > 0 ) { - eattacker thread maps/mp/gametypes_zm/_damagefeedback::updatedamagefeedback( smeansofdeath, einflictor ); + eattacker thread maps/mp/gametypes/_damagefeedback::updatedamagefeedback( smeansofdeath, einflictor ); } } } @@ -152,7 +165,7 @@ callback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sw /# if ( getDvarInt( "g_debugDamage" ) ) { - println( "actor:" + self getentitynumber() + " health:" + self.health + " attacker:" + eattacker.clientid + " inflictor is player:" + isplayer( einflictor ) + " damage:" + idamage + shitloc + ";" + boneindex + "\n" ); + println( "actor:" + self getentitynumber() + " health:" + self.health + " attacker:" + eattacker.clientid + " inflictor is player:" + isplayer( einflictor ) + " damage:" + idamage + " hitLoc:" + shitloc ); #/ } if ( 1 ) @@ -174,7 +187,7 @@ callback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sw lpattackname = ""; lpattackerteam = "world"; } - logprint( "AD;" + lpselfnum + ";" + lpselfteam + ";" + lpattackguid + ";" + lpattacknum + ";" + lpattackerteam + ";" + lpattackname + ";" + sweapon + ";" + idamage + ";" + smeansofdeath + ";" + shitloc + "\n" ); + logprint( "AD;" + lpselfnum + ";" + lpselfteam + ";" + lpattackguid + ";" + lpattacknum + ";" + lpattackerteam + ";" + lpattackname + ";" + sweapon + ";" + idamage + ";" + smeansofdeath + ";" + shitloc + ";" + boneindex + "\n" ); } } @@ -201,6 +214,7 @@ callback_actorkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdi { level.globalkillstreaksdestroyed++; attacker addweaponstat( "dogs_mp", "destroyed", 1 ); + maps/mp/_scoreevents::processscoreevent( "killed_dog", attacker, self, sweapon ); attacker maps/mp/_challenges::killeddog(); } } diff --git a/patch_mp/maps/mp/gametypes/_globallogic_audio.gsc b/patch_mp/maps/mp/gametypes/_globallogic_audio.gsc index 2618bd9..457444c 100644 --- a/patch_mp/maps/mp/gametypes/_globallogic_audio.gsc +++ b/patch_mp/maps/mp/gametypes/_globallogic_audio.gsc @@ -1,6 +1,6 @@ #include maps/mp/_music; -#include maps/mp/gametypes_zm/_globallogic_audio; -#include maps/mp/gametypes_zm/_globallogic_utils; +#include maps/mp/gametypes/_globallogic_audio; +#include maps/mp/gametypes/_globallogic_utils; #include maps/mp/_utility; init() @@ -76,7 +76,7 @@ init() game[ "dialog" ][ "defend" ] = "defend"; game[ "dialog" ][ "offense" ] = "offense"; game[ "dialog" ][ "defense" ] = "defense"; - game[ "dialog" ][ "halftime" ] = "halftime"; + game[ "dialog" ][ "halftime" ] = "sd_halftime"; game[ "dialog" ][ "overtime" ] = "overtime"; game[ "dialog" ][ "side_switch" ] = "switchingsides"; game[ "dialog" ][ "flag_taken" ] = "ourflag"; @@ -111,6 +111,12 @@ init() game[ "dialog" ][ "lost_d" ] = "dom_lost_d"; game[ "dialog" ][ "lost_e" ] = "dom_lost_e"; game[ "dialog" ][ "lost_f" ] = "dom_lost_f"; + game[ "dialog" ][ "enemy_a" ] = "dom_enemy_a"; + game[ "dialog" ][ "enemy_b" ] = "dom_enemy_b"; + game[ "dialog" ][ "enemy_c" ] = "dom_enemy_c"; + game[ "dialog" ][ "enemy_d" ] = "dom_enemy_d"; + game[ "dialog" ][ "enemy_e" ] = "dom_enemy_e"; + game[ "dialog" ][ "enemy_f" ] = "dom_enemy_f"; game[ "dialog" ][ "secure_flag" ] = "secure_flag"; game[ "dialog" ][ "securing_flag" ] = "securing_flag"; game[ "dialog" ][ "losing_flag" ] = "losing_flag"; @@ -138,6 +144,8 @@ init() game[ "dialog" ][ "hacked_equip" ] = "hacked_equip"; game[ "dialog" ][ "uav_destroyed" ] = "kls_u2_destroyed"; game[ "dialog" ][ "cuav_destroyed" ] = "kls_cu2_destroyed"; + game[ "dialog" ][ "wm_in_the_money" ] = "mpl_wager_top3_gain"; + game[ "dialog" ][ "wm_oot_money" ] = "mpl_wager_top3_loss"; level.dialoggroups = []; level thread post_match_snapshot_watcher(); } @@ -152,7 +160,9 @@ registerdialoggroup( group, skipifcurrentlyplayinggroup ) { if ( isDefined( level.dialoggroup[ group ] ) ) { +/# error( "registerDialogGroup: Dialog group " + group + " already registered." ); +#/ return; } } @@ -177,7 +187,7 @@ sndstartmusicsystem() println( "Music System - music state is undefined Waiting 15 seconds to set music state" ); #/ } - wait 30; + wait 45; if ( !isDefined( level.nextmusicstate ) ) { self.pers[ "music" ].currentstate = "UNDERSCORE"; @@ -262,16 +272,16 @@ suspensemusic( random ) leaderdialogforotherteams( dialog, skip_team, squad_dialog ) { - _a339 = level.teams; - _k339 = getFirstArrayKey( _a339 ); - while ( isDefined( _k339 ) ) + _a350 = level.teams; + _k350 = getFirstArrayKey( _a350 ); + while ( isDefined( _k350 ) ) { - team = _a339[ _k339 ]; + team = _a350[ _k350 ]; if ( team != skip_team ) { leaderdialog( dialog, team, undefined, undefined, squad_dialog ); } - _k339 = getNextArrayKey( _a339, _k339 ); + _k350 = getNextArrayKey( _a350, _k350 ); } } @@ -292,13 +302,13 @@ announceroundwinner( winner, delay ) } else { - _a365 = level.teams; - _k365 = getFirstArrayKey( _a365 ); - while ( isDefined( _k365 ) ) + _a376 = level.teams; + _k376 = getFirstArrayKey( _a376 ); + while ( isDefined( _k376 ) ) { - team = _a365[ _k365 ]; + team = _a376[ _k376 ]; thread playsoundonplayers( "mus_round_draw" + "_" + level.teampostfix[ team ] ); - _k365 = getNextArrayKey( _a365, _k365 ); + _k376 = getNextArrayKey( _a376, _k376 ); } leaderdialog( "round_draw" ); } @@ -346,10 +356,6 @@ leaderdialog( dialog, team, group, excludelist, squaddialog ) /# assert( isDefined( level.players ) ); #/ - if ( level.splitscreen ) - { - return; - } if ( level.wagermatch ) { return; @@ -357,32 +363,24 @@ leaderdialog( dialog, team, group, excludelist, squaddialog ) if ( !isDefined( team ) ) { dialogs = []; - _a425 = level.teams; - _k425 = getFirstArrayKey( _a425 ); - while ( isDefined( _k425 ) ) + _a433 = level.teams; + _k433 = getFirstArrayKey( _a433 ); + while ( isDefined( _k433 ) ) { - team = _a425[ _k425 ]; + team = _a433[ _k433 ]; dialogs[ team ] = dialog; - _k425 = getNextArrayKey( _a425, _k425 ); + _k433 = getNextArrayKey( _a433, _k433 ); } leaderdialogallteams( dialogs, group, excludelist ); return; } - if ( level.splitscreen ) - { - if ( level.players.size ) - { - level.players[ 0 ] leaderdialogonplayer( dialog, group ); - } - return; - } if ( isDefined( excludelist ) ) { i = 0; while ( i < level.players.size ) { player = level.players[ i ]; - if ( isDefined( player.pers[ "team" ] ) && player.pers[ "team" ] == team && !maps/mp/gametypes_zm/_globallogic_utils::isexcluded( player, excludelist ) ) + if ( isDefined( player.pers[ "team" ] ) && player.pers[ "team" ] == team && !maps/mp/gametypes/_globallogic_utils::isexcluded( player, excludelist ) ) { player leaderdialogonplayer( dialog, group ); } @@ -406,18 +404,6 @@ leaderdialogallteams( dialogs, group, excludelist ) /# assert( isDefined( level.players ) ); #/ - if ( level.splitscreen ) - { - return; - } - if ( level.splitscreen ) - { - if ( level.players.size ) - { - level.players[ 0 ] leaderdialogonplayer( dialogs[ level.players[ 0 ].team ], group ); - } - return; - } i = 0; while ( i < level.players.size ) { @@ -433,7 +419,7 @@ leaderdialogallteams( dialogs, group, excludelist ) i++; continue; } - else if ( isDefined( excludelist ) && maps/mp/gametypes_zm/_globallogic_utils::isexcluded( player, excludelist ) ) + else if ( isDefined( excludelist ) && maps/mp/gametypes/_globallogic_utils::isexcluded( player, excludelist ) ) { i++; continue; @@ -448,13 +434,13 @@ leaderdialogallteams( dialogs, group, excludelist ) flushdialog() { - _a495 = level.players; - _k495 = getFirstArrayKey( _a495 ); - while ( isDefined( _k495 ) ) + _a485 = level.players; + _k485 = getFirstArrayKey( _a485 ); + while ( isDefined( _k485 ) ) { - player = _a495[ _k495 ]; + player = _a485[ _k485 ]; player flushdialogonplayer(); - _k495 = getNextArrayKey( _a495, _k495 ); + _k485 = getNextArrayKey( _a485, _k485 ); } } @@ -464,31 +450,27 @@ flushdialogonplayer() self.leaderdialogqueue = []; self.leaderdialogactive = 0; self.currentleaderdialoggroup = ""; + self notify( "flush_dialog" ); } flushgroupdialog( group ) { - _a512 = level.players; - _k512 = getFirstArrayKey( _a512 ); - while ( isDefined( _k512 ) ) + _a503 = level.players; + _k503 = getFirstArrayKey( _a503 ); + while ( isDefined( _k503 ) ) { - player = _a512[ _k512 ]; + player = _a503[ _k503 ]; player flushgroupdialogonplayer( group ); - _k512 = getNextArrayKey( _a512, _k512 ); + _k503 = getNextArrayKey( _a503, _k503 ); } } flushgroupdialogonplayer( group ) { - _a522 = self.leaderdialogqueue; - key = getFirstArrayKey( _a522 ); - while ( isDefined( key ) ) + arrayremovevalue( self.leaderdialogqueue, group ); + if ( self.leaderdialogqueue.size == 0 ) { - dialog = _a522[ key ]; - if ( dialog == group ) - { - } - key = getNextArrayKey( _a522, key ); + self flushdialogonplayer(); } } @@ -496,7 +478,9 @@ addgroupdialogtoplayer( dialog, group ) { if ( !isDefined( level.dialoggroup[ group ] ) ) { +/# error( "leaderDialogOnPlayer: Dialog group " + group + " is not registered" ); +#/ return 0; } addtoqueue = 0; @@ -508,25 +492,10 @@ addgroupdialogtoplayer( dialog, group ) { if ( self.currentleaderdialog == dialog && ( self.currentleaderdialogtime + 2000 ) > getTime() ) { - _a552 = self.leaderdialogqueue; - key = getFirstArrayKey( _a552 ); - while ( isDefined( key ) ) + arrayremovevalue( self.leaderdialogqueue, group ); + if ( self.leaderdialogqueue.size == 0 ) { - leader_dialog = _a552[ key ]; - if ( leader_dialog == group ) - { - i = key + 1; - while ( i < self.leaderdialogqueue.size ) - { - self.leaderdialogqueue[ i - 1 ] = self.leaderdialogqueue[ i ]; - i++; - } - break; - } - else - { - key = getNextArrayKey( _a552, key ); - } + self flushdialogonplayer(); } return 0; } @@ -542,35 +511,12 @@ addgroupdialogtoplayer( dialog, group ) return addtoqueue; } -testdialogqueue( group ) -{ -/# - count = 0; - _a585 = self.leaderdialogqueue; - _k585 = getFirstArrayKey( _a585 ); - while ( isDefined( _k585 ) ) - { - temp = _a585[ _k585 ]; - if ( temp == group ) - { - count++; - } - _k585 = getNextArrayKey( _a585, _k585 ); - } - if ( count > 1 ) - { - shit = 0; -#/ - } -} - leaderdialogonplayer( dialog, group ) { +/# + assert( isDefined( dialog ) ); +#/ team = self.pers[ "team" ]; - if ( level.splitscreen ) - { - return; - } if ( !isDefined( team ) ) { return; @@ -583,19 +529,18 @@ leaderdialogonplayer( dialog, group ) { if ( !addgroupdialogtoplayer( dialog, group ) ) { - self testdialogqueue( group ); return; } dialog = group; } - if ( !self.leaderdialogactive ) - { - self thread playleaderdialogonplayer( dialog ); - } - else + if ( self.leaderdialogqueue.size < 10 ) { self.leaderdialogqueue[ self.leaderdialogqueue.size ] = dialog; } + if ( !self.leaderdialogactive ) + { + self thread playnextleaderdialog(); + } } waitforsound( sound, extratime ) @@ -615,23 +560,32 @@ waitforsound( sound, extratime ) } } -playleaderdialogonplayer( dialog ) +playnextleaderdialog() { + self endon( "disconnect" ); + self endon( "flush_dialog" ); if ( isDefined( level.allowannouncer ) && !level.allowannouncer ) { return; } - team = self.pers[ "team" ]; - self endon( "disconnect" ); self.leaderdialogactive = 1; + waittillframeend; +/# + assert( self.leaderdialogqueue.size > 0 ); +#/ + dialog = self.leaderdialogqueue[ 0 ]; +/# + assert( isDefined( dialog ) ); +#/ + arrayremoveindex( self.leaderdialogqueue, 0 ); + team = self.pers[ "team" ]; if ( isDefined( self.leaderdialoggroups[ dialog ] ) ) { group = dialog; dialog = self.leaderdialoggroups[ group ]; self.currentleaderdialoggroup = group; - self testdialogqueue( group ); } - if ( level.wagermatch || !isDefined( game[ "voice" ] ) ) + if ( level.wagermatch ) { faction = "vox_wm_"; } @@ -639,6 +593,10 @@ playleaderdialogonplayer( dialog ) { faction = game[ "voice" ][ team ]; } + if ( !isDefined( faction ) ) + { + return; + } sound_name = faction + game[ "dialog" ][ dialog ]; if ( level.allowannouncer ) { @@ -652,29 +610,18 @@ playleaderdialogonplayer( dialog ) self.currentleaderdialog = ""; if ( self.leaderdialogqueue.size > 0 ) { - nextdialog = self.leaderdialogqueue[ 0 ]; - i = 1; - while ( i < self.leaderdialogqueue.size ) - { - self.leaderdialogqueue[ i - 1 ] = self.leaderdialogqueue[ i ]; - i++; - } - if ( isDefined( self.leaderdialoggroups[ dialog ] ) ) - { - self testdialogqueue( dialog ); - } - self thread playleaderdialogonplayer( nextdialog ); + self thread playnextleaderdialog(); } } isteamwinning( checkteam ) { score = game[ "teamScores" ][ checkteam ]; - _a702 = level.teams; - _k702 = getFirstArrayKey( _a702 ); - while ( isDefined( _k702 ) ) + _a678 = level.teams; + _k678 = getFirstArrayKey( _a678 ); + while ( isDefined( _k678 ) ) { - team = _a702[ _k702 ]; + team = _a678[ _k678 ]; if ( team != checkteam ) { if ( game[ "teamScores" ][ team ] >= score ) @@ -682,25 +629,25 @@ isteamwinning( checkteam ) return 0; } } - _k702 = getNextArrayKey( _a702, _k702 ); + _k678 = getNextArrayKey( _a678, _k678 ); } return 1; } announceteamiswinning() { - _a716 = level.teams; - _k716 = getFirstArrayKey( _a716 ); - while ( isDefined( _k716 ) ) + _a692 = level.teams; + _k692 = getFirstArrayKey( _a692 ); + while ( isDefined( _k692 ) ) { - team = _a716[ _k716 ]; + team = _a692[ _k692 ]; if ( isteamwinning( team ) ) { leaderdialog( "winning", team, undefined, undefined, "squad_winning" ); leaderdialogforotherteams( "losing", team, "squad_losing" ); return 1; } - _k716 = getNextArrayKey( _a716, _k716 ); + _k692 = getNextArrayKey( _a692, _k692 ); } return 0; } @@ -712,25 +659,22 @@ musiccontroller() level waittill( "match_ending_soon" ); if ( islastround() || isoneround() ) { - while ( !level.splitscreen ) + if ( level.teambased ) { - if ( level.teambased ) + if ( !announceteamiswinning() ) { - if ( !announceteamiswinning() ) - { - leaderdialog( "min_draw" ); - } - } - level waittill( "match_ending_very_soon" ); - _a751 = level.teams; - _k751 = getFirstArrayKey( _a751 ); - while ( isDefined( _k751 ) ) - { - team = _a751[ _k751 ]; - leaderdialog( "timesup", team, undefined, undefined, "squad_30sec" ); - _k751 = getNextArrayKey( _a751, _k751 ); + leaderdialog( "min_draw" ); } } + level waittill( "match_ending_very_soon" ); + _a725 = level.teams; + _k725 = getFirstArrayKey( _a725 ); + while ( isDefined( _k725 ) ) + { + team = _a725[ _k725 ]; + leaderdialog( "timesup", team, undefined, undefined, "squad_30sec" ); + _k725 = getNextArrayKey( _a725, _k725 ); + } } else level waittill( "match_ending_vox" ); leaderdialog( "timesup" ); @@ -740,7 +684,7 @@ musictimesout() { level endon( "game_ended" ); level waittill( "match_ending_very_soon" ); - thread maps/mp/gametypes_zm/_globallogic_audio::set_music_on_team( "TIME_OUT", "both", 1, 0 ); + thread maps/mp/gametypes/_globallogic_audio::set_music_on_team( "TIME_OUT", "both", 1, 0 ); } actionmusicset() diff --git a/patch_mp/maps/mp/gametypes/_globallogic_defaults.gsc b/patch_mp/maps/mp/gametypes/_globallogic_defaults.gsc index 059642d..7363578 100644 --- a/patch_mp/maps/mp/gametypes/_globallogic_defaults.gsc +++ b/patch_mp/maps/mp/gametypes/_globallogic_defaults.gsc @@ -1,8 +1,10 @@ -#include maps/mp/gametypes_zm/_spawnlogic; -#include maps/mp/gametypes_zm/_globallogic_audio; -#include maps/mp/gametypes_zm/_globallogic_score; -#include maps/mp/gametypes_zm/_globallogic; -#include maps/mp/gametypes_zm/_globallogic_utils; +#include maps/mp/gametypes/_rank; +#include maps/mp/killstreaks/_killstreaks; +#include maps/mp/gametypes/_spawnlogic; +#include maps/mp/gametypes/_globallogic_audio; +#include maps/mp/gametypes/_globallogic_score; +#include maps/mp/gametypes/_globallogic; +#include maps/mp/gametypes/_globallogic_utils; #include maps/mp/_utility; #include common_scripts/utility; @@ -34,7 +36,13 @@ default_onforfeit( team ) announcement( game[ "strings" ][ "opponent_forfeiting_in" ], 10, 0 ); wait 10; endreason = &""; - if ( !isDefined( team ) ) + if ( level.multiteam ) + { + setdvar( "ui_text_endreason", game[ "strings" ][ "other_teams_forfeited" ] ); + endreason = game[ "strings" ][ "other_teams_forfeited" ]; + winner = team; + } + else if ( !isDefined( team ) ) { setdvar( "ui_text_endreason", game[ "strings" ][ "players_forfeited" ] ); endreason = game[ "strings" ][ "players_forfeited" ]; @@ -63,9 +71,9 @@ default_onforfeit( team ) } else { - maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "forfeit", winner ); + maps/mp/gametypes/_globallogic_utils::logteamwinstring( "forfeit", winner ); } - thread maps/mp/gametypes_zm/_globallogic::endgame( winner, endreason ); + thread maps/mp/gametypes/_globallogic::endgame( winner, endreason ); } default_ondeadevent( team ) @@ -77,19 +85,44 @@ default_ondeadevent( team ) makedvarserverinfo( "ui_text_endreason", eliminatedstring ); setdvar( "ui_text_endreason", eliminatedstring ); winner = getwinningteamfromloser( team ); - maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "team eliminated", winner ); - thread maps/mp/gametypes_zm/_globallogic::endgame( winner, eliminatedstring ); + maps/mp/gametypes/_globallogic_utils::logteamwinstring( "team eliminated", winner ); + thread maps/mp/gametypes/_globallogic::endgame( winner, eliminatedstring ); } else makedvarserverinfo( "ui_text_endreason", game[ "strings" ][ "tie" ] ); setdvar( "ui_text_endreason", game[ "strings" ][ "tie" ] ); - maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "tie" ); + maps/mp/gametypes/_globallogic_utils::logteamwinstring( "tie" ); if ( level.teambased ) { - thread maps/mp/gametypes_zm/_globallogic::endgame( "tie", game[ "strings" ][ "tie" ] ); + thread maps/mp/gametypes/_globallogic::endgame( "tie", game[ "strings" ][ "tie" ] ); } else { - thread maps/mp/gametypes_zm/_globallogic::endgame( undefined, game[ "strings" ][ "tie" ] ); + thread maps/mp/gametypes/_globallogic::endgame( undefined, game[ "strings" ][ "tie" ] ); + } +} + +default_onlastteamaliveevent( team ) +{ + if ( isDefined( level.teams[ team ] ) ) + { + eliminatedstring = game[ "strings" ][ "enemies_eliminated" ]; + iprintln( eliminatedstring ); + makedvarserverinfo( "ui_text_endreason", eliminatedstring ); + setdvar( "ui_text_endreason", eliminatedstring ); + winner = maps/mp/gametypes/_globallogic::determineteamwinnerbygamestat( "teamScores" ); + maps/mp/gametypes/_globallogic_utils::logteamwinstring( "team eliminated", winner ); + thread maps/mp/gametypes/_globallogic::endgame( winner, eliminatedstring ); + } + else makedvarserverinfo( "ui_text_endreason", game[ "strings" ][ "tie" ] ); + setdvar( "ui_text_endreason", game[ "strings" ][ "tie" ] ); + maps/mp/gametypes/_globallogic_utils::logteamwinstring( "tie" ); + if ( level.teambased ) + { + thread maps/mp/gametypes/_globallogic::endgame( "tie", game[ "strings" ][ "tie" ] ); + } + else + { + thread maps/mp/gametypes/_globallogic::endgame( undefined, game[ "strings" ][ "tie" ] ); } } @@ -106,7 +139,7 @@ default_ononeleftevent( team ) { if ( !level.teambased ) { - winner = maps/mp/gametypes_zm/_globallogic_score::gethighestscoringplayer(); + winner = maps/mp/gametypes/_globallogic_score::gethighestscoringplayer(); if ( isDefined( winner ) ) { logstring( "last one alive, win: " + winner.name ); @@ -115,7 +148,7 @@ default_ononeleftevent( team ) { logstring( "last one alive, win: unknown" ); } - thread maps/mp/gametypes_zm/_globallogic::endgame( winner, &"MP_ENEMIES_ELIMINATED" ); + thread maps/mp/gametypes/_globallogic::endgame( winner, &"MP_ENEMIES_ELIMINATED" ); } else { @@ -135,7 +168,7 @@ default_ononeleftevent( team ) } else { - player maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "sudden_death" ); + player maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "sudden_death" ); } index++; } @@ -147,10 +180,10 @@ default_ontimelimit() winner = undefined; if ( level.teambased ) { - winner = maps/mp/gametypes_zm/_globallogic::determineteamwinnerbygamestat( "teamScores" ); - maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "time limit", winner ); + winner = maps/mp/gametypes/_globallogic::determineteamwinnerbygamestat( "teamScores" ); + maps/mp/gametypes/_globallogic_utils::logteamwinstring( "time limit", winner ); } - else winner = maps/mp/gametypes_zm/_globallogic_score::gethighestscoringplayer(); + else winner = maps/mp/gametypes/_globallogic_score::gethighestscoringplayer(); if ( isDefined( winner ) ) { logstring( "time limit, win: " + winner.name ); @@ -161,7 +194,7 @@ default_ontimelimit() } makedvarserverinfo( "ui_text_endreason", game[ "strings" ][ "time_limit_reached" ] ); setdvar( "ui_text_endreason", game[ "strings" ][ "time_limit_reached" ] ); - thread maps/mp/gametypes_zm/_globallogic::endgame( winner, game[ "strings" ][ "time_limit_reached" ] ); + thread maps/mp/gametypes/_globallogic::endgame( winner, game[ "strings" ][ "time_limit_reached" ] ); } default_onscorelimit() @@ -173,10 +206,10 @@ default_onscorelimit() winner = undefined; if ( level.teambased ) { - winner = maps/mp/gametypes_zm/_globallogic::determineteamwinnerbygamestat( "teamScores" ); - maps/mp/gametypes_zm/_globallogic_utils::logteamwinstring( "scorelimit", winner ); + winner = maps/mp/gametypes/_globallogic::determineteamwinnerbygamestat( "teamScores" ); + maps/mp/gametypes/_globallogic_utils::logteamwinstring( "scorelimit", winner ); } - else winner = maps/mp/gametypes_zm/_globallogic_score::gethighestscoringplayer(); + else winner = maps/mp/gametypes/_globallogic_score::gethighestscoringplayer(); if ( isDefined( winner ) ) { logstring( "scorelimit, win: " + winner.name ); @@ -187,7 +220,7 @@ default_onscorelimit() } makedvarserverinfo( "ui_text_endreason", game[ "strings" ][ "score_limit_reached" ] ); setdvar( "ui_text_endreason", game[ "strings" ][ "score_limit_reached" ] ); - thread maps/mp/gametypes_zm/_globallogic::endgame( winner, game[ "strings" ][ "score_limit_reached" ] ); + thread maps/mp/gametypes/_globallogic::endgame( winner, game[ "strings" ][ "score_limit_reached" ] ); return 1; } @@ -203,7 +236,7 @@ default_onspawnspectator( origin, angles ) /# assert( spawnpoints.size, "There are no mp_global_intermission spawn points in the map. There must be at least one." ); #/ - spawnpoint = maps/mp/gametypes_zm/_spawnlogic::getspawnpoint_random( spawnpoints ); + spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_random( spawnpoints ); self spawn( spawnpoint.origin, spawnpoint.angles ); } @@ -228,3 +261,23 @@ default_gettimelimit() { return clamp( getgametypesetting( "timeLimit" ), level.timelimitmin, level.timelimitmax ); } + +default_getteamkillpenalty( einflictor, attacker, smeansofdeath, sweapon ) +{ + teamkill_penalty = 1; + score = maps/mp/gametypes/_globallogic_score::_getplayerscore( attacker ); + if ( score == 0 ) + { + teamkill_penalty = 2; + } + if ( maps/mp/killstreaks/_killstreaks::iskillstreakweapon( sweapon ) ) + { + teamkill_penalty *= maps/mp/killstreaks/_killstreaks::getkillstreakteamkillpenaltyscale( sweapon ); + } + return teamkill_penalty; +} + +default_getteamkillscore( einflictor, attacker, smeansofdeath, sweapon ) +{ + return maps/mp/gametypes/_rank::getscoreinfovalue( "team_kill" ); +} diff --git a/patch_mp/maps/mp/gametypes/_globallogic_player.gsc b/patch_mp/maps/mp/gametypes/_globallogic_player.gsc index 2de5b99..b8378dc 100644 --- a/patch_mp/maps/mp/gametypes/_globallogic_player.gsc +++ b/patch_mp/maps/mp/gametypes/_globallogic_player.gsc @@ -1,20 +1,36 @@ -#include maps/mp/gametypes_zm/_globallogic_audio; -#include maps/mp/gametypes_zm/_tweakables; -#include maps/mp/_challenges; -#include maps/mp/gametypes_zm/_spawnlogic; -#include maps/mp/gametypes_zm/_weapons; +#include maps/mp/gametypes/_globallogic_vehicle; +#include maps/mp/_burnplayer; +#include maps/mp/gametypes/_deathicons; +#include maps/mp/gametypes/_tweakables; +#include maps/mp/gametypes/_globallogic_audio; +#include maps/mp/gametypes/_killcam; +#include maps/mp/gametypes/_spawnlogic; +#include maps/mp/_medals; +#include maps/mp/killstreaks/_straferun; +#include maps/mp/gametypes/_rank; +#include maps/mp/teams/_teams; #include maps/mp/_demo; -#include maps/mp/gametypes_zm/_hud_util; -#include maps/mp/gametypes_zm/_hud_message; -#include maps/mp/gametypes_zm/_spawning; -#include maps/mp/gametypes_zm/_globallogic_utils; -#include maps/mp/gametypes_zm/_spectating; -#include maps/mp/gametypes_zm/_globallogic_spawn; -#include maps/mp/gametypes_zm/_globallogic_ui; -#include maps/mp/gametypes_zm/_hostmigration; -#include maps/mp/gametypes_zm/_globallogic_score; -#include maps/mp/zombies/_zm_stats; -#include maps/mp/gametypes_zm/_globallogic; +#include maps/mp/gametypes/_weapon_utils; +#include maps/mp/gametypes/_damagefeedback; +#include maps/mp/gametypes/_weapons; +#include maps/mp/_scoreevents; +#include maps/mp/_vehicles; +#include maps/mp/gametypes/_class; +#include maps/mp/gametypes/_hud_message; +#include maps/mp/gametypes/_hud_util; +#include maps/mp/gametypes/_spawning; +#include maps/mp/gametypes/_globallogic_utils; +#include maps/mp/gametypes/_spectating; +#include maps/mp/gametypes/_globallogic_spawn; +#include maps/mp/gametypes/_globallogic_ui; +#include maps/mp/gametypes/_hostmigration; +#include maps/mp/_flashgrenades; +#include maps/mp/gametypes/_globallogic_score; +#include maps/mp/_gamerep; +#include maps/mp/gametypes/_persistence; +#include maps/mp/gametypes/_globallogic; +#include maps/mp/killstreaks/_killstreak_weapons; +#include maps/mp/killstreaks/_killstreaks; #include common_scripts/utility; #include maps/mp/_utility; @@ -27,6 +43,10 @@ freezeplayerforroundend() if ( !sessionmodeiszombiesgame() ) { currentweapon = self getcurrentweapon(); + if ( maps/mp/killstreaks/_killstreaks::iskillstreakweapon( currentweapon ) && !maps/mp/killstreaks/_killstreak_weapons::isheldkillstreakweapon( currentweapon ) ) + { + self takeweapon( currentweapon ); + } } } @@ -42,11 +62,12 @@ callback_playerconnect() waittillframeend; self.statusicon = ""; self.guid = self getguid(); + matchrecorderincrementheaderstat( "playerCountJoined", 1 ); profilelog_begintiming( 4, "ship" ); level notify( "connected" ); if ( self ishost() ) { - self thread maps/mp/gametypes_zm/_globallogic::listenforgameend(); + self thread maps/mp/gametypes/_globallogic::listenforgameend(); } if ( !level.splitscreen && !isDefined( self.pers[ "score" ] ) ) { @@ -54,20 +75,30 @@ callback_playerconnect() } if ( !isDefined( self.pers[ "score" ] ) ) { - self thread maps/mp/zombies/_zm_stats::adjustrecentstats(); + self thread maps/mp/gametypes/_persistence::adjustrecentstats(); + self maps/mp/gametypes/_persistence::setafteractionreportstat( "valid", 0 ); + if ( gamemodeismode( level.gamemode_wager_match ) && !self ishost() ) + { + self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerMatchFailed", 1 ); + } + else + { + self maps/mp/gametypes/_persistence::setafteractionreportstat( "wagerMatchFailed", 0 ); + } } - if ( gamemodeismode( level.gamemode_public_match ) && !isDefined( self.pers[ "matchesPlayedStatsTracked" ] ) ) + if ( !level.rankedmatch && !level.wagermatch && level.leaguematch && !isDefined( self.pers[ "matchesPlayedStatsTracked" ] ) ) { - gamemode = maps/mp/gametypes_zm/_globallogic::getcurrentgamemode(); - self maps/mp/gametypes_zm/_globallogic::incrementmatchcompletionstat( gamemode, "played", "started" ); + gamemode = maps/mp/gametypes/_globallogic::getcurrentgamemode(); + self maps/mp/gametypes/_globallogic::incrementmatchcompletionstat( gamemode, "played", "started" ); if ( !isDefined( self.pers[ "matchesHostedStatsTracked" ] ) && self islocaltohost() ) { - self maps/mp/gametypes_zm/_globallogic::incrementmatchcompletionstat( gamemode, "hosted", "started" ); + self maps/mp/gametypes/_globallogic::incrementmatchcompletionstat( gamemode, "hosted", "started" ); self.pers[ "matchesHostedStatsTracked" ] = 1; } self.pers[ "matchesPlayedStatsTracked" ] = 1; - self thread maps/mp/zombies/_zm_stats::uploadstatssoon(); + self thread maps/mp/gametypes/_persistence::uploadstatssoon(); } + self maps/mp/_gamerep::gamerepplayerconnected(); lpselfnum = self getentitynumber(); lpguid = self getguid(); logprint( "J;" + lpguid + ";" + lpselfnum + ";" + self.name + "\n" ); @@ -103,65 +134,75 @@ callback_playerconnect() } else { - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "score" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "score" ); if ( level.resetplayerscoreeveryround ) { self.pers[ "score" ] = 0; } self.score = self.pers[ "score" ]; - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "momentum", 0 ); - self.momentum = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "momentum" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "suicides" ); - self.suicides = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "suicides" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "headshots" ); - self.headshots = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "headshots" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "challenges" ); - self.challenges = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "challenges" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "kills" ); - self.kills = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "kills" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "deaths" ); - self.deaths = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "deaths" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "assists" ); - self.assists = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "assists" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "defends", 0 ); - self.defends = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "defends" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "offends", 0 ); - self.offends = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "offends" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "plants", 0 ); - self.plants = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "plants" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "defuses", 0 ); - self.defuses = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "defuses" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "returns", 0 ); - self.returns = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "returns" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "captures", 0 ); - self.captures = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "captures" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "destructions", 0 ); - self.destructions = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "destructions" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "backstabs", 0 ); - self.backstabs = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "backstabs" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "longshots", 0 ); - self.longshots = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "longshots" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "survived", 0 ); - self.survived = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "survived" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "stabs", 0 ); - self.stabs = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "stabs" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "tomahawks", 0 ); - self.tomahawks = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "tomahawks" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "humiliated", 0 ); - self.humiliated = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "humiliated" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "x2score", 0 ); - self.x2score = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "x2score" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "agrkills", 0 ); - self.x2score = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "agrkills" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "hacks", 0 ); - self.x2score = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "hacks" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "sessionbans", 0 ); - self.sessionbans = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "sessionbans" ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "gametypeban", 0 ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "time_played_total", 0 ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "time_played_alive", 0 ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "teamkills", 0 ); - self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "teamkills_nostats", 0 ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "pointstowin" ); + if ( level.scoreroundbased ) + { + self.pers[ "pointstowin" ] = 0; + } + self.pointstowin = self.pers[ "pointstowin" ]; + self maps/mp/gametypes/_globallogic_score::initpersstat( "momentum", 0 ); + self.momentum = self maps/mp/gametypes/_globallogic_score::getpersstat( "momentum" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "suicides" ); + self.suicides = self maps/mp/gametypes/_globallogic_score::getpersstat( "suicides" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "headshots" ); + self.headshots = self maps/mp/gametypes/_globallogic_score::getpersstat( "headshots" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "challenges" ); + self.challenges = self maps/mp/gametypes/_globallogic_score::getpersstat( "challenges" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "kills" ); + self.kills = self maps/mp/gametypes/_globallogic_score::getpersstat( "kills" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "deaths" ); + self.deaths = self maps/mp/gametypes/_globallogic_score::getpersstat( "deaths" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "assists" ); + self.assists = self maps/mp/gametypes/_globallogic_score::getpersstat( "assists" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "defends", 0 ); + self.defends = self maps/mp/gametypes/_globallogic_score::getpersstat( "defends" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "offends", 0 ); + self.offends = self maps/mp/gametypes/_globallogic_score::getpersstat( "offends" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "plants", 0 ); + self.plants = self maps/mp/gametypes/_globallogic_score::getpersstat( "plants" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "defuses", 0 ); + self.defuses = self maps/mp/gametypes/_globallogic_score::getpersstat( "defuses" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "returns", 0 ); + self.returns = self maps/mp/gametypes/_globallogic_score::getpersstat( "returns" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "captures", 0 ); + self.captures = self maps/mp/gametypes/_globallogic_score::getpersstat( "captures" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "destructions", 0 ); + self.destructions = self maps/mp/gametypes/_globallogic_score::getpersstat( "destructions" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "backstabs", 0 ); + self.backstabs = self maps/mp/gametypes/_globallogic_score::getpersstat( "backstabs" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "longshots", 0 ); + self.longshots = self maps/mp/gametypes/_globallogic_score::getpersstat( "longshots" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "survived", 0 ); + self.survived = self maps/mp/gametypes/_globallogic_score::getpersstat( "survived" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "stabs", 0 ); + self.stabs = self maps/mp/gametypes/_globallogic_score::getpersstat( "stabs" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "tomahawks", 0 ); + self.tomahawks = self maps/mp/gametypes/_globallogic_score::getpersstat( "tomahawks" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "humiliated", 0 ); + self.humiliated = self maps/mp/gametypes/_globallogic_score::getpersstat( "humiliated" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "x2score", 0 ); + self.x2score = self maps/mp/gametypes/_globallogic_score::getpersstat( "x2score" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "agrkills", 0 ); + self.x2score = self maps/mp/gametypes/_globallogic_score::getpersstat( "agrkills" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "hacks", 0 ); + self.x2score = self maps/mp/gametypes/_globallogic_score::getpersstat( "hacks" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "killsconfirmed", 0 ); + self.killsconfirmed = self maps/mp/gametypes/_globallogic_score::getpersstat( "killsconfirmed" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "killsdenied", 0 ); + self.killsdenied = self maps/mp/gametypes/_globallogic_score::getpersstat( "killsdenied" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "sessionbans", 0 ); + self.sessionbans = self maps/mp/gametypes/_globallogic_score::getpersstat( "sessionbans" ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "gametypeban", 0 ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "time_played_total", 0 ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "time_played_alive", 0 ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "teamkills", 0 ); + self maps/mp/gametypes/_globallogic_score::initpersstat( "teamkills_nostats", 0 ); self.teamkillpunish = 0; if ( level.minimumallowedteamkills >= 0 && self.pers[ "teamkills_nostats" ] > level.minimumallowedteamkills ) { @@ -228,6 +269,14 @@ callback_playerconnect() { self.pers[ "held_killstreak_ammo_count" ] = []; } + if ( isDefined( level.usingscorestreaks ) && level.usingscorestreaks && !isDefined( self.pers[ "held_killstreak_clip_count" ] ) ) + { + self.pers[ "held_killstreak_clip_count" ] = []; + } + if ( !isDefined( self.pers[ "changed_class" ] ) ) + { + self.pers[ "changed_class" ] = 0; + } self.lastkilltime = 0; self.cur_death_streak = 0; self disabledeathstreak(); @@ -236,6 +285,12 @@ callback_playerconnect() self.gametype_kill_streak = 0; self.spawnqueueindex = -1; self.deathtime = 0; + if ( level.onlinegame ) + { + self.death_streak = self getdstat( "HighestStats", "death_streak" ); + self.kill_streak = self getdstat( "HighestStats", "kill_streak" ); + self.gametype_kill_streak = self maps/mp/gametypes/_persistence::statgetwithgametype( "kill_streak" ); + } self.lastgrenadesuicidetime = -1; self.teamkillsthisround = 0; if ( isDefined( level.livesdonotreset ) || !level.livesdonotreset && !isDefined( self.pers[ "lives" ] ) ) @@ -250,6 +305,7 @@ callback_playerconnect() self.wantsafespawn = 0; self.deathcount = 0; self.wasaliveatmatchstart = 0; + self thread maps/mp/_flashgrenades::monitorflash(); level.players[ level.players.size ] = self; if ( level.splitscreen ) { @@ -267,29 +323,32 @@ callback_playerconnect() profilelog_endtiming( 4, "gs=" + game[ "state" ] + " zom=" + sessionmodeiszombiesgame() ); return; } - if ( level.scr_zm_ui_gametype_group == "zencounter" ) + if ( !level.rankedmatch && !level.wagermatch && level.leaguematch && !isDefined( self.pers[ "lossAlreadyReported" ] ) ) { - self maps/mp/zombies/_zm_stats::increment_client_stat( "losses" ); - self updatestatratio( "wlratio", "wins", "losses" ); - if ( gamemodeismode( level.gamemode_public_match ) ) + if ( level.leaguematch ) { - self maps/mp/zombies/_zm_stats::add_location_gametype_stat( level.scr_zm_map_start_location, level.scr_zm_ui_gametype, "losses", 1 ); + self recordleaguepreloser(); } + maps/mp/gametypes/_globallogic_score::updatelossstats( self ); + self.pers[ "lossAlreadyReported" ] = 1; } - else + if ( !isDefined( self.pers[ "winstreakAlreadyCleared" ] ) ) { - if ( level.scr_zm_ui_gametype_group == "zsurvival" ) - { - if ( is_true( level.should_use_cia ) ) - { - self luinotifyevent( &"hud_update_survival_team", 1, 2 ); - } - } + self maps/mp/gametypes/_globallogic_score::backupandclearwinstreaks(); + self.pers[ "winstreakAlreadyCleared" ] = 1; + } + if ( self istestclient() ) + { + self.pers[ "isBot" ] = 1; + } + if ( level.rankedmatch || level.leaguematch ) + { + self maps/mp/gametypes/_persistence::setafteractionreportstat( "demoFileID", "0" ); } level endon( "game_ended" ); if ( isDefined( level.hostmigrationtimer ) ) { - self thread maps/mp/gametypes_zm/_hostmigration::hostmigrationtimerthink(); + self thread maps/mp/gametypes/_hostmigration::hostmigrationtimerthink(); } if ( level.oldschool ) { @@ -308,16 +367,12 @@ callback_playerconnect() self.pers[ "team" ] = "spectator"; self.team = "spectator"; self.sessionstate = "dead"; - self maps/mp/gametypes_zm/_globallogic_ui::updateobjectivetext(); + self maps/mp/gametypes/_globallogic_ui::updateobjectivetext(); [[ level.spawnspectator ]](); - if ( level.rankedmatch ) + [[ level.autoassign ]]( 0 ); + if ( level.rankedmatch || level.leaguematch ) { - [[ level.autoassign ]]( 0 ); - self thread maps/mp/gametypes_zm/_globallogic_spawn::kickifdontspawn(); - } - else - { - [[ level.autoassign ]]( 0 ); + self thread maps/mp/gametypes/_globallogic_spawn::kickifdontspawn(); } if ( self.pers[ "team" ] == "spectator" ) { @@ -335,7 +390,7 @@ callback_playerconnect() { self.statusicon = "hud_status_dead"; } - self thread maps/mp/gametypes_zm/_spectating::setspectatepermissions(); + self thread maps/mp/gametypes/_spectating::setspectatepermissions(); } } else @@ -360,22 +415,22 @@ callback_playerconnect() { self.ffateam = self.pers[ "team" ]; } - self maps/mp/gametypes_zm/_globallogic_ui::updateobjectivetext(); + self maps/mp/gametypes/_globallogic_ui::updateobjectivetext(); [[ level.spawnspectator ]](); - if ( maps/mp/gametypes_zm/_globallogic_utils::isvalidclass( self.pers[ "class" ] ) ) + if ( maps/mp/gametypes/_globallogic_utils::isvalidclass( self.pers[ "class" ] ) ) { self thread [[ level.spawnclient ]](); } else { - self maps/mp/gametypes_zm/_globallogic_ui::showmainmenuforteam(); + self maps/mp/gametypes/_globallogic_ui::showmainmenuforteam(); } - self thread maps/mp/gametypes_zm/_spectating::setspectatepermissions(); + self thread maps/mp/gametypes/_spectating::setspectatepermissions(); } } if ( self.sessionteam != "spectator" ) { - self thread maps/mp/gametypes_zm/_spawning::onspawnplayer_unified( 1 ); + self thread maps/mp/gametypes/_spawning::onspawnplayer_unified( 1 ); } profilelog_endtiming( 4, "gs=" + game[ "state" ] + " zom=" + sessionmodeiszombiesgame() ); if ( isDefined( self.pers[ "isBot" ] ) ) @@ -387,29 +442,26 @@ callback_playerconnect() spectate_player_watcher() { self endon( "disconnect" ); + if ( !level.splitscreen && !level.hardcoremode && getDvarInt( "scr_showperksonspawn" ) == 1 && game[ "state" ] != "postgame" && !isDefined( self.perkhudelem ) ) + { + if ( level.perksenabled == 1 ) + { + self maps/mp/gametypes/_hud_util::showperks(); + } + self thread maps/mp/gametypes/_globallogic_ui::hideloadoutaftertime( 0 ); + } self.watchingactiveclient = 1; self.waitingforplayerstext = undefined; while ( 1 ) { if ( self.pers[ "team" ] != "spectator" || level.gameended ) { - self maps/mp/gametypes_zm/_hud_message::clearshoutcasterwaitingmessage(); -/# - println( " Unfreeze controls 1" ); -#/ + self maps/mp/gametypes/_hud_message::clearshoutcasterwaitingmessage(); self freezecontrols( 0 ); self.watchingactiveclient = 0; return; } - else if ( !level.splitscreen && !level.hardcoremode && getDvarInt( "scr_showperksonspawn" ) == 1 && game[ "state" ] != "postgame" && !isDefined( self.perkhudelem ) ) - { - if ( level.perksenabled == 1 ) - { - self maps/mp/gametypes_zm/_hud_util::showperks(); - } - self thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutaftertime( 0 ); - } - count = 0; + else count = 0; i = 0; while ( i < level.players.size ) { @@ -427,11 +479,8 @@ spectate_player_watcher() { if ( !self.watchingactiveclient ) { - self maps/mp/gametypes_zm/_hud_message::clearshoutcasterwaitingmessage(); + self maps/mp/gametypes/_hud_message::clearshoutcasterwaitingmessage(); self freezecontrols( 0 ); -/# - println( " Unfreeze controls 2" ); -#/ } self.watchingactiveclient = 1; } @@ -441,7 +490,7 @@ spectate_player_watcher() { [[ level.onspawnspectator ]](); self freezecontrols( 1 ); - self maps/mp/gametypes_zm/_hud_message::setshoutcasterwaitingmessage(); + self maps/mp/gametypes/_hud_message::setshoutcasterwaitingmessage(); } self.watchingactiveclient = 0; } @@ -456,9 +505,8 @@ callback_playermigrated() #/ if ( isDefined( self.connected ) && self.connected ) { - self maps/mp/gametypes_zm/_globallogic_ui::updateobjectivetext(); + self maps/mp/gametypes/_globallogic_ui::updateobjectivetext(); } - self thread inform_clientvm_of_migration(); level.hostmigrationreturnedplayercount++; if ( level.hostmigrationreturnedplayercount >= ( ( level.players.size * 2 ) / 3 ) ) { @@ -469,23 +517,13 @@ callback_playermigrated() } } -inform_clientvm_of_migration() -{ - self endon( "disconnect" ); - wait 1; - self clientnotify( "hmo" ); -/# - println( "SERVER : Sent HMO to client " + self getentitynumber() ); -#/ -} - callback_playerdisconnect() { profilelog_begintiming( 5, "ship" ); if ( game[ "state" ] != "postgame" && !level.gameended ) { - gamelength = maps/mp/gametypes_zm/_globallogic::getgamelength(); - self maps/mp/gametypes_zm/_globallogic::bbplayermatchend( gamelength, "MP_PLAYER_DISCONNECT", 0 ); + gamelength = maps/mp/gametypes/_globallogic::getgamelength(); + self maps/mp/gametypes/_globallogic::bbplayermatchend( gamelength, "MP_PLAYER_DISCONNECT", 0 ); } self removeplayerondisconnect(); if ( level.splitscreen ) @@ -493,7 +531,7 @@ callback_playerdisconnect() players = level.players; if ( players.size <= 1 ) { - level thread maps/mp/gametypes_zm/_globallogic::forceend(); + level thread maps/mp/gametypes/_globallogic::forceend(); } setdvar( "splitscreen_playerNum", players.size ); } @@ -506,6 +544,7 @@ callback_playerdisconnect() lpselfnum = self getentitynumber(); lpguid = self getguid(); logprint( "Q;" + lpguid + ";" + lpselfnum + ";" + self.name + "\n" ); + self maps/mp/_gamerep::gamerepplayerdisconnected(); entry = 0; while ( entry < level.players.size ) { @@ -546,9 +585,9 @@ callback_playerdisconnect() } if ( level.gameended ) { - self maps/mp/gametypes_zm/_globallogic::removedisconnectedplayerfromplacement(); + self maps/mp/gametypes/_globallogic::removedisconnectedplayerfromplacement(); } - level thread maps/mp/gametypes_zm/_globallogic::updateteamstatus(); + level thread maps/mp/gametypes/_globallogic::updateteamstatus(); profilelog_endtiming( 5, "gs=" + game[ "state" ] + " zom=" + sessionmodeiszombiesgame() ); } @@ -757,8 +796,16 @@ callback_playerdamage( einflictor, eattacker, idamage, idflags, smeansofdeath, s } if ( sweapon == "emp_grenade_mp" ) { + if ( self hasperk( "specialty_immuneemp" ) ) + { + return; + } self notify( "emp_grenaded" ); } + if ( isDefined( eattacker ) ) + { + idamage = maps/mp/gametypes/_class::cac_modified_damage( self, eattacker, idamage, smeansofdeath, sweapon, einflictor, shitloc ); + } idamage = custom_gamemodes_modified_damage( self, eattacker, idamage, smeansofdeath, sweapon, einflictor, shitloc ); idamage = int( idamage ); self.idflags = idflags; @@ -774,15 +821,22 @@ callback_playerdamage( einflictor, eattacker, idamage, idflags, smeansofdeath, s { self notify( "snd_pain_player" ); } - if ( isDefined( einflictor ) && isDefined( einflictor.script_noteworthy ) && einflictor.script_noteworthy == "ragdoll_now" ) + if ( isDefined( einflictor ) && isDefined( einflictor.script_noteworthy ) ) { - smeansofdeath = "MOD_FALLING"; + if ( einflictor.script_noteworthy == "ragdoll_now" ) + { + smeansofdeath = "MOD_FALLING"; + } + if ( isDefined( level.overrideweaponfunc ) ) + { + sweapon = [[ level.overrideweaponfunc ]]( sweapon, einflictor.script_noteworthy ); + } } - if ( maps/mp/gametypes_zm/_globallogic_utils::isheadshot( sweapon, shitloc, smeansofdeath, einflictor ) && isplayer( eattacker ) ) + if ( maps/mp/gametypes/_globallogic_utils::isheadshot( sweapon, shitloc, smeansofdeath, einflictor ) && isplayer( eattacker ) ) { smeansofdeath = "MOD_HEAD_SHOT"; } - if ( level.onplayerdamage != ::maps/mp/gametypes_zm/_globallogic::blank ) + if ( level.onplayerdamage != ::maps/mp/gametypes/_globallogic::blank ) { modifieddamage = [[ level.onplayerdamage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime ); if ( isDefined( modifieddamage ) ) @@ -808,12 +862,20 @@ callback_playerdamage( einflictor, eattacker, idamage, idflags, smeansofdeath, s } } } + if ( self maps/mp/_vehicles::player_is_occupant_invulnerable( smeansofdeath ) ) + { + return; + } if ( isDefined( eattacker ) && isplayer( eattacker ) && self.team != eattacker.team ) { self.lastattackweapon = sweapon; } sweapon = figureoutweapon( sweapon, einflictor ); pixendevent(); + if ( idflags & level.idflags_penetration && isplayer( eattacker ) && eattacker hasperk( "specialty_bulletpenetration" ) ) + { + self thread maps/mp/gametypes/_battlechatter_mp::perkspecificbattlechatter( "deepimpact", 1 ); + } if ( isplayer( eattacker ) ) { attackerishittingteammate = self isenemyplayer( eattacker ) == 0; @@ -824,21 +886,29 @@ callback_playerdamage( einflictor, eattacker, idamage, idflags, smeansofdeath, s { return; } - if ( smeansofdeath == "MOD_PISTOL_BULLET" || smeansofdeath == "MOD_RIFLE_BULLET" && !attackerishittingteammate ) + if ( smeansofdeath != "MOD_PISTOL_BULLET" && smeansofdeath == "MOD_RIFLE_BULLET" && !maps/mp/killstreaks/_killstreaks::iskillstreakweapon( sweapon ) && !attackerishittingteammate ) { - previous_shield_damage = self.shielddamageblocked; - self.shielddamageblocked += idamage; - if ( isplayer( eattacker ) ) + if ( self.hasriotshieldequipped ) { - eattacker.lastattackedshieldplayer = self; - eattacker.lastattackedshieldtime = getTime(); - } - if ( ( self.shielddamageblocked % 400 ) < ( previous_shield_damage % 400 ) ) - { - score_event = "shield_blocked_damage"; - if ( self.shielddamageblocked > 2000 ) + if ( isplayer( eattacker ) ) { - score_event = "shield_blocked_damage_reduced"; + eattacker.lastattackedshieldplayer = self; + eattacker.lastattackedshieldtime = getTime(); + } + previous_shield_damage = self.shielddamageblocked; + self.shielddamageblocked += idamage; + if ( ( self.shielddamageblocked % 400 ) < ( previous_shield_damage % 400 ) ) + { + score_event = "shield_blocked_damage"; + if ( self.shielddamageblocked > 2000 ) + { + score_event = "shield_blocked_damage_reduced"; + } + if ( isDefined( level.scoreinfo[ score_event ][ "value" ] ) ) + { + self addweaponstat( "riotshield_mp", "score_from_blocked_damage", level.scoreinfo[ score_event ][ "value" ] ); + } + thread maps/mp/_scoreevents::processscoreevent( score_event, self ); } } } @@ -863,6 +933,208 @@ callback_playerdamage( einflictor, eattacker, idamage, idflags, smeansofdeath, s return; } } + if ( idflags & level.idflags_no_protection ) + { + if ( isDefined( einflictor ) || smeansofdeath == "MOD_GAS" && maps/mp/gametypes/_class::isexplosivedamage( undefined, smeansofdeath ) ) + { + if ( einflictor.classname != "grenade" && sweapon == "tabun_gas_mp" && ( self.lastspawntime + 3500 ) > getTime() && distancesquared( einflictor.origin, self.lastspawnpoint.origin ) < 62500 ) + { + return; + } + if ( self isplayerimmunetokillstreak( eattacker, sweapon ) ) + { + return; + } + self.explosiveinfo = []; + self.explosiveinfo[ "damageTime" ] = getTime(); + self.explosiveinfo[ "damageId" ] = einflictor getentitynumber(); + self.explosiveinfo[ "originalOwnerKill" ] = 0; + self.explosiveinfo[ "bulletPenetrationKill" ] = 0; + self.explosiveinfo[ "chainKill" ] = 0; + self.explosiveinfo[ "damageExplosiveKill" ] = 0; + self.explosiveinfo[ "chainKill" ] = 0; + self.explosiveinfo[ "cookedKill" ] = 0; + self.explosiveinfo[ "weapon" ] = sweapon; + self.explosiveinfo[ "originalowner" ] = einflictor.originalowner; + isfrag = sweapon == "frag_grenade_mp"; + if ( isDefined( eattacker ) && eattacker != self ) + { + if ( isDefined( eattacker ) && isDefined( einflictor.owner ) && sweapon != "satchel_charge_mp" || sweapon == "claymore_mp" && sweapon == "bouncingbetty_mp" ) + { + self.explosiveinfo[ "originalOwnerKill" ] = einflictor.owner == self; + self.explosiveinfo[ "damageExplosiveKill" ] = isDefined( einflictor.wasdamaged ); + self.explosiveinfo[ "chainKill" ] = isDefined( einflictor.waschained ); + self.explosiveinfo[ "wasJustPlanted" ] = isDefined( einflictor.wasjustplanted ); + self.explosiveinfo[ "bulletPenetrationKill" ] = isDefined( einflictor.wasdamagedfrombulletpenetration ); + self.explosiveinfo[ "cookedKill" ] = 0; + } + if ( sweapon != "sticky_grenade_mp" && sweapon == "explosive_bolt_mp" && isDefined( einflictor ) && isDefined( einflictor.stucktoplayer ) ) + { + self.explosiveinfo[ "stuckToPlayer" ] = einflictor.stucktoplayer; + } + if ( sweapon == "proximity_grenade_mp" || sweapon == "proximity_grenade_aoe_mp" ) + { + self.laststunnedby = eattacker; + self.laststunnedtime = self.idflagstime; + } + if ( isDefined( eattacker.lastgrenadesuicidetime ) && eattacker.lastgrenadesuicidetime >= ( getTime() - 50 ) && isfrag ) + { + self.explosiveinfo[ "suicideGrenadeKill" ] = 1; + } + else + { + self.explosiveinfo[ "suicideGrenadeKill" ] = 0; + } + } + if ( isfrag ) + { + self.explosiveinfo[ "cookedKill" ] = isDefined( einflictor.iscooked ); + self.explosiveinfo[ "throwbackKill" ] = isDefined( einflictor.threwback ); + } + if ( isDefined( eattacker ) && isplayer( eattacker ) && eattacker != self ) + { + self maps/mp/gametypes/_globallogic_score::setinflictorstat( einflictor, eattacker, sweapon ); + } + } + if ( smeansofdeath == "MOD_IMPACT" && isDefined( eattacker ) && isplayer( eattacker ) && eattacker != self ) + { + if ( sweapon != "knife_ballistic_mp" ) + { + self maps/mp/gametypes/_globallogic_score::setinflictorstat( einflictor, eattacker, sweapon ); + } + if ( sweapon == "hatchet_mp" && isDefined( einflictor ) ) + { + self.explosiveinfo[ "projectile_bounced" ] = isDefined( einflictor.bounced ); + } + } + if ( isplayer( eattacker ) ) + { + eattacker.pers[ "participation" ]++; + } + prevhealthratio = self.health / self.maxhealth; + if ( level.teambased && isplayer( eattacker ) && self != eattacker && self.team == eattacker.team ) + { + pixmarker( "BEGIN: PlayerDamage player" ); + if ( level.friendlyfire == 0 ) + { + if ( sweapon != "artillery_mp" && sweapon != "airstrike_mp" || sweapon == "napalm_mp" && sweapon == "mortar_mp" ) + { + self damageshellshockandrumble( eattacker, einflictor, sweapon, smeansofdeath, idamage ); + } + return; + } + else if ( level.friendlyfire == 1 ) + { + if ( idamage < 1 ) + { + idamage = 1; + } + if ( level.friendlyfiredelay && level.friendlyfiredelaytime >= ( ( getTime() - level.starttime - level.discardtime ) / 1000 ) ) + { + eattacker.lastdamagewasfromenemy = 0; + eattacker.friendlydamage = 1; + eattacker finishplayerdamagewrapper( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex ); + eattacker.friendlydamage = undefined; + } + else + { + self.lastdamagewasfromenemy = 0; + self finishplayerdamagewrapper( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex ); + } + } + else if ( level.friendlyfire == 2 && isalive( eattacker ) ) + { + idamage = int( idamage * 0,5 ); + if ( idamage < 1 ) + { + idamage = 1; + } + eattacker.lastdamagewasfromenemy = 0; + eattacker.friendlydamage = 1; + eattacker finishplayerdamagewrapper( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex ); + eattacker.friendlydamage = undefined; + } + else + { + if ( level.friendlyfire == 3 && isalive( eattacker ) ) + { + idamage = int( idamage * 0,5 ); + if ( idamage < 1 ) + { + idamage = 1; + } + self.lastdamagewasfromenemy = 0; + eattacker.lastdamagewasfromenemy = 0; + self finishplayerdamagewrapper( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex ); + eattacker.friendlydamage = 1; + eattacker finishplayerdamagewrapper( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex ); + eattacker.friendlydamage = undefined; + } + } + friendly = 1; + pixmarker( "END: PlayerDamage player" ); + } + else + { + if ( idamage < 1 ) + { + idamage = 1; + } + if ( isDefined( eattacker ) && isplayer( eattacker ) && allowedassistweapon( sweapon ) ) + { + self trackattackerdamage( eattacker, idamage, smeansofdeath, sweapon ); + } + giveinflictorownerassist( eattacker, einflictor, idamage, smeansofdeath, sweapon ); + if ( isDefined( eattacker ) ) + { + level.lastlegitimateattacker = eattacker; + } + if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( sweapon ) && !issubstr( smeansofdeath, "MOD_MELEE" ) ) + { + eattacker thread maps/mp/gametypes/_weapons::checkhit( sweapon ); + } + if ( smeansofdeath != "MOD_GRENADE" && smeansofdeath == "MOD_GRENADE_SPLASH" && isDefined( einflictor.iscooked ) ) + { + self.wascooked = getTime(); + } + else + { + self.wascooked = undefined; + } + if ( isDefined( eattacker ) ) + { + self.lastdamagewasfromenemy = eattacker != self; + } + if ( self.lastdamagewasfromenemy ) + { + if ( isplayer( eattacker ) ) + { + if ( isDefined( eattacker.damagedplayers[ self.clientid ] ) == 0 ) + { + eattacker.damagedplayers[ self.clientid ] = spawnstruct(); + } + eattacker.damagedplayers[ self.clientid ].time = getTime(); + eattacker.damagedplayers[ self.clientid ].entity = self; + } + } + self finishplayerdamagewrapper( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex ); + } + if ( isDefined( eattacker ) && isplayer( eattacker ) && eattacker != self ) + { + if ( dodamagefeedback( sweapon, einflictor, idamage, smeansofdeath ) ) + { + if ( idamage > 0 ) + { + if ( self.health > 0 ) + { + perkfeedback = doperkfeedback( self, sweapon, smeansofdeath, einflictor ); + } + eattacker thread maps/mp/gametypes/_damagefeedback::updatedamagefeedback( smeansofdeath, einflictor, perkfeedback ); + } + } + } + self.hasdonecombat = 1; + } if ( isDefined( eattacker ) && eattacker != self && !friendly ) { level.usestartspawns = 0; @@ -961,6 +1233,21 @@ istacticalhitmarker( sweapon, smeansofdeath, idamage ) doperkfeedback( player, sweapon, smeansofdeath, einflictor ) { perkfeedback = undefined; + hastacticalmask = maps/mp/gametypes/_class::hastacticalmask( player ); + hasflakjacket = player hasperk( "specialty_flakjacket" ); + isexplosivedamage = maps/mp/gametypes/_class::isexplosivedamage( sweapon, smeansofdeath ); + isflashorstundamage = maps/mp/gametypes/_weapon_utils::isflashorstundamage( sweapon, smeansofdeath ); + if ( isflashorstundamage && hastacticalmask ) + { + perkfeedback = "tacticalMask"; + } + else + { + if ( isexplosivedamage && hasflakjacket && !isaikillstreakdamage( sweapon, einflictor ) ) + { + perkfeedback = "flakjacket"; + } + } return perkfeedback; } @@ -1007,7 +1294,434 @@ finishplayerdamagewrapper( einflictor, eattacker, idamage, idflags, smeansofdeat allowedassistweapon( weapon ) { - return 1; + if ( !maps/mp/killstreaks/_killstreaks::iskillstreakweapon( weapon ) ) + { + return 1; + } + if ( maps/mp/killstreaks/_killstreaks::iskillstreakweaponassistallowed( weapon ) ) + { + return 1; + } + return 0; +} + +playerkilled_killstreaks( attacker, sweapon ) +{ + if ( !isDefined( self.switching_teams ) ) + { + if ( isplayer( attacker ) && level.teambased && attacker != self && self.team == attacker.team ) + { + self.pers[ "cur_kill_streak" ] = 0; + self.pers[ "cur_total_kill_streak" ] = 0; + self.pers[ "totalKillstreakCount" ] = 0; + self.pers[ "killstreaksEarnedThisKillstreak" ] = 0; + self setplayercurrentstreak( 0 ); + } + else + { + self maps/mp/gametypes/_globallogic_score::incpersstat( "deaths", 1, 1, 1 ); + self.deaths = self maps/mp/gametypes/_globallogic_score::getpersstat( "deaths" ); + self updatestatratio( "kdratio", "kills", "deaths" ); + if ( self.pers[ "cur_kill_streak" ] > self.pers[ "best_kill_streak" ] ) + { + self.pers[ "best_kill_streak" ] = self.pers[ "cur_kill_streak" ]; + } + self.pers[ "kill_streak_before_death" ] = self.pers[ "cur_kill_streak" ]; + self.pers[ "cur_kill_streak" ] = 0; + self.pers[ "cur_total_kill_streak" ] = 0; + self.pers[ "totalKillstreakCount" ] = 0; + self.pers[ "killstreaksEarnedThisKillstreak" ] = 0; + self setplayercurrentstreak( 0 ); + self.cur_death_streak++; + if ( self.cur_death_streak > self.death_streak ) + { + if ( level.rankedmatch && !level.disablestattracking ) + { + self setdstat( "HighestStats", "death_streak", self.cur_death_streak ); + } + self.death_streak = self.cur_death_streak; + } + if ( self.cur_death_streak >= getDvarInt( "perk_deathStreakCountRequired" ) ) + { + self enabledeathstreak(); + } + } + } + else + { + self.pers[ "totalKillstreakCount" ] = 0; + self.pers[ "killstreaksEarnedThisKillstreak" ] = 0; + } + if ( !sessionmodeiszombiesgame() && maps/mp/killstreaks/_killstreaks::iskillstreakweapon( sweapon ) ) + { + level.globalkillstreaksdeathsfrom++; + } +} + +playerkilled_weaponstats( attacker, sweapon, smeansofdeath, wasinlaststand, lastweaponbeforedroppingintolaststand, inflictor ) +{ + if ( isplayer( attacker ) && attacker != self || !level.teambased && level.teambased && self.team != attacker.team ) + { + self addweaponstat( sweapon, "deaths", 1 ); + if ( wasinlaststand && isDefined( lastweaponbeforedroppingintolaststand ) ) + { + weaponname = lastweaponbeforedroppingintolaststand; + } + else + { + weaponname = self.lastdroppableweapon; + } + if ( isDefined( weaponname ) ) + { + self addweaponstat( weaponname, "deathsDuringUse", 1 ); + } + if ( smeansofdeath != "MOD_FALLING" ) + { + if ( sweapon == "explosive_bolt_mp" && isDefined( inflictor ) && isDefined( inflictor.ownerweaponatlaunch ) && inflictor.owneradsatlaunch ) + { + attacker addweaponstat( inflictor.ownerweaponatlaunch, "kills", 1, attacker.class_num, 1 ); + } + else + { + attacker addweaponstat( sweapon, "kills", 1, attacker.class_num ); + } + } + if ( smeansofdeath == "MOD_HEAD_SHOT" ) + { + attacker addweaponstat( sweapon, "headshots", 1 ); + } + if ( smeansofdeath == "MOD_PROJECTILE" ) + { + attacker addweaponstat( sweapon, "direct_hit_kills", 1 ); + } + } +} + +playerkilled_obituary( attacker, einflictor, sweapon, smeansofdeath ) +{ + if ( isplayer( attacker ) || self isenemyplayer( attacker ) == 0 && isDefined( sweapon ) && maps/mp/killstreaks/_killstreaks::iskillstreakweapon( sweapon ) ) + { + level notify( "reset_obituary_count" ); + level.lastobituaryplayercount = 0; + level.lastobituaryplayer = undefined; + } + else + { + if ( isDefined( level.lastobituaryplayer ) && level.lastobituaryplayer == attacker ) + { + level.lastobituaryplayercount++; + } + else + { + level notify( "reset_obituary_count" ); + level.lastobituaryplayer = attacker; + level.lastobituaryplayercount = 1; + } + level thread maps/mp/_scoreevents::decrementlastobituaryplayercountafterfade(); + if ( level.lastobituaryplayercount >= 4 ) + { + level notify( "reset_obituary_count" ); + level.lastobituaryplayercount = 0; + level.lastobituaryplayer = undefined; + self thread uninterruptedobitfeedkills( attacker, sweapon ); + } + } + overrideentitycamera = maps/mp/killstreaks/_killstreaks::shouldoverrideentitycameraindemo( attacker, sweapon ); + if ( level.teambased && isDefined( attacker.pers ) && self.team == attacker.team && smeansofdeath == "MOD_GRENADE" && level.friendlyfire == 0 ) + { + obituary( self, self, sweapon, smeansofdeath ); + maps/mp/_demo::bookmark( "kill", getTime(), self, self, 0, einflictor, overrideentitycamera ); + } + else + { + obituary( self, attacker, sweapon, smeansofdeath ); + maps/mp/_demo::bookmark( "kill", getTime(), self, attacker, 0, einflictor, overrideentitycamera ); + } +} + +playerkilled_suicide( einflictor, attacker, smeansofdeath, sweapon, shitloc ) +{ + awardassists = 0; + if ( isDefined( self.switching_teams ) ) + { + if ( !level.teambased && isDefined( level.teams[ self.leaving_team ] ) && isDefined( level.teams[ self.joining_team ] ) && level.teams[ self.leaving_team ] != level.teams[ self.joining_team ] ) + { + playercounts = self maps/mp/teams/_teams::countplayers(); + playercounts[ self.leaving_team ]--; + + playercounts[ self.joining_team ]++; + if ( ( playercounts[ self.joining_team ] - playercounts[ self.leaving_team ] ) > 1 ) + { + thread maps/mp/_scoreevents::processscoreevent( "suicide", self ); + self thread maps/mp/gametypes/_rank::giverankxp( "suicide" ); + self maps/mp/gametypes/_globallogic_score::incpersstat( "suicides", 1 ); + self.suicides = self maps/mp/gametypes/_globallogic_score::getpersstat( "suicides" ); + } + } + } + else + { + thread maps/mp/_scoreevents::processscoreevent( "suicide", self ); + self maps/mp/gametypes/_globallogic_score::incpersstat( "suicides", 1 ); + self.suicides = self maps/mp/gametypes/_globallogic_score::getpersstat( "suicides" ); + if ( smeansofdeath == "MOD_SUICIDE" && shitloc == "none" && self.throwinggrenade ) + { + self.lastgrenadesuicidetime = getTime(); + } + if ( level.maxsuicidesbeforekick > 0 && level.maxsuicidesbeforekick <= self.suicides ) + { + self notify( "teamKillKicked" ); + self suicidekick(); + } + thread maps/mp/gametypes/_battlechatter_mp::onplayersuicideorteamkill( self, "suicide" ); + awardassists = 1; + self.suicide = 1; + } + if ( isDefined( self.friendlydamage ) ) + { + self iprintln( &"MP_FRIENDLY_FIRE_WILL_NOT" ); + if ( level.teamkillpointloss ) + { + scoresub = self [[ level.getteamkillscore ]]( einflictor, attacker, smeansofdeath, sweapon ); + score = maps/mp/gametypes/_globallogic_score::_getplayerscore( attacker ) - scoresub; + if ( score < 0 ) + { + score = 0; + } + maps/mp/gametypes/_globallogic_score::_setplayerscore( attacker, score ); + } + } + return awardassists; +} + +playerkilled_teamkill( einflictor, attacker, smeansofdeath, sweapon, shitloc ) +{ + thread maps/mp/_scoreevents::processscoreevent( "team_kill", attacker ); + self.teamkilled = 1; + if ( !ignoreteamkills( sweapon, smeansofdeath ) ) + { + teamkill_penalty = self [[ level.getteamkillpenalty ]]( einflictor, attacker, smeansofdeath, sweapon ); + attacker maps/mp/gametypes/_globallogic_score::incpersstat( "teamkills_nostats", teamkill_penalty, 0 ); + attacker maps/mp/gametypes/_globallogic_score::incpersstat( "teamkills", 1 ); + attacker.teamkillsthisround++; + if ( level.teamkillpointloss ) + { + scoresub = self [[ level.getteamkillscore ]]( einflictor, attacker, smeansofdeath, sweapon ); + score = maps/mp/gametypes/_globallogic_score::_getplayerscore( attacker ) - scoresub; + if ( score < 0 ) + { + score = 0; + } + maps/mp/gametypes/_globallogic_score::_setplayerscore( attacker, score ); + } + if ( maps/mp/gametypes/_globallogic_utils::gettimepassed() < 5000 ) + { + teamkilldelay = 1; + } + else if ( attacker.pers[ "teamkills_nostats" ] > 1 && maps/mp/gametypes/_globallogic_utils::gettimepassed() < ( 8000 + ( attacker.pers[ "teamkills_nostats" ] * 1000 ) ) ) + { + teamkilldelay = 1; + } + else + { + teamkilldelay = attacker teamkilldelay(); + } + if ( teamkilldelay > 0 ) + { + attacker.teamkillpunish = 1; + attacker thread wait_and_suicide(); + if ( attacker shouldteamkillkick( teamkilldelay ) ) + { + attacker notify( "teamKillKicked" ); + attacker teamkillkick(); + } + attacker thread reduceteamkillsovertime(); + } + if ( isplayer( attacker ) ) + { + thread maps/mp/gametypes/_battlechatter_mp::onplayersuicideorteamkill( attacker, "teamkill" ); + } + } +} + +wait_and_suicide() +{ + self endon( "disconnect" ); + self freezecontrolswrapper( 1 ); + wait 0,25; + self suicide(); +} + +playerkilled_awardassists( einflictor, attacker, sweapon, lpattackteam ) +{ + pixbeginevent( "PlayerKilled assists" ); + while ( isDefined( self.attackers ) ) + { + j = 0; + while ( j < self.attackers.size ) + { + player = self.attackers[ j ]; + if ( !isDefined( player ) ) + { + j++; + continue; + } + else if ( player == attacker ) + { + j++; + continue; + } + else if ( player.team != lpattackteam ) + { + j++; + continue; + } + else + { + damage_done = self.attackerdamage[ player.clientid ].damage; + player thread maps/mp/gametypes/_globallogic_score::processassist( self, damage_done, self.attackerdamage[ player.clientid ].weapon ); + } + j++; + } + } + if ( level.teambased ) + { + self maps/mp/gametypes/_globallogic_score::processkillstreakassists( attacker, einflictor, sweapon ); + } + if ( isDefined( self.lastattackedshieldplayer ) && isDefined( self.lastattackedshieldtime ) && self.lastattackedshieldplayer != attacker ) + { + if ( ( getTime() - self.lastattackedshieldtime ) < 4000 ) + { + self.lastattackedshieldplayer thread maps/mp/gametypes/_globallogic_score::processshieldassist( self ); + } + } + pixendevent(); +} + +playerkilled_kill( einflictor, attacker, smeansofdeath, sweapon, shitloc ) +{ + maps/mp/gametypes/_globallogic_score::inctotalkills( attacker.team ); + attacker thread maps/mp/gametypes/_globallogic_score::givekillstats( smeansofdeath, sweapon, self ); + if ( isalive( attacker ) ) + { + pixbeginevent( "killstreak" ); + if ( isDefined( einflictor ) || !isDefined( einflictor.requireddeathcount ) && attacker.deathcount == einflictor.requireddeathcount ) + { + shouldgivekillstreak = maps/mp/killstreaks/_killstreaks::shouldgivekillstreak( sweapon ); + if ( shouldgivekillstreak ) + { + attacker maps/mp/killstreaks/_killstreaks::addtokillstreakcount( sweapon ); + } + attacker.pers[ "cur_total_kill_streak" ]++; + attacker setplayercurrentstreak( attacker.pers[ "cur_total_kill_streak" ] ); + if ( isDefined( level.killstreaks ) && shouldgivekillstreak ) + { + attacker.pers[ "cur_kill_streak" ]++; + if ( attacker.pers[ "cur_kill_streak" ] >= 2 ) + { + if ( attacker.pers[ "cur_kill_streak" ] == 10 ) + { + attacker maps/mp/_challenges::killstreakten(); + } + if ( attacker.pers[ "cur_kill_streak" ] <= 30 ) + { + maps/mp/_scoreevents::processscoreevent( "killstreak_" + attacker.pers[ "cur_kill_streak" ], attacker, self, sweapon ); + } + else + { + maps/mp/_scoreevents::processscoreevent( "killstreak_more_than_30", attacker, self, sweapon ); + } + } + if ( !isDefined( level.usingmomentum ) || !level.usingmomentum ) + { + attacker thread maps/mp/killstreaks/_killstreaks::givekillstreakforstreak(); + } + } + } + if ( isplayer( attacker ) ) + { + self thread maps/mp/gametypes/_battlechatter_mp::onplayerkillstreak( attacker ); + } + pixendevent(); + } + if ( attacker.pers[ "cur_kill_streak" ] > attacker.kill_streak ) + { + if ( level.rankedmatch && !level.disablestattracking ) + { + attacker setdstat( "HighestStats", "kill_streak", attacker.pers[ "totalKillstreakCount" ] ); + } + attacker.kill_streak = attacker.pers[ "cur_kill_streak" ]; + } + if ( attacker.pers[ "cur_kill_streak" ] > attacker.gametype_kill_streak ) + { + attacker maps/mp/gametypes/_persistence::statsetwithgametype( "kill_streak", attacker.pers[ "cur_kill_streak" ] ); + attacker.gametype_kill_streak = attacker.pers[ "cur_kill_streak" ]; + } + killstreak = maps/mp/killstreaks/_killstreaks::getkillstreakforweapon( sweapon ); + if ( isDefined( killstreak ) ) + { + if ( maps/mp/_scoreevents::isregisteredevent( killstreak ) ) + { + maps/mp/_scoreevents::processscoreevent( killstreak, attacker, self, sweapon ); + } + if ( sweapon == "straferun_gun_mp" || sweapon == "straferun_rockets_mp" ) + { + attacker maps/mp/killstreaks/_straferun::addstraferunkill(); + } + } + else if ( smeansofdeath == "MOD_MELEE" && level.gametype == "gun" ) + { + } + else + { + maps/mp/_scoreevents::processscoreevent( "kill", attacker, self, sweapon ); + } + if ( smeansofdeath == "MOD_HEAD_SHOT" ) + { + maps/mp/_scoreevents::processscoreevent( "headshot", attacker, self, sweapon ); + } + else if ( smeansofdeath == "MOD_MELEE" ) + { + if ( sweapon == "riotshield_mp" ) + { + maps/mp/_scoreevents::processscoreevent( "melee_kill_with_riot_shield", attacker, self, sweapon ); + if ( isDefined( attacker.class_num ) ) + { + primaryweaponnum = attacker getloadoutitem( attacker.class_num, "primary" ); + secondaryweaponnum = attacker getloadoutitem( attacker.class_num, "secondary" ); + if ( primaryweaponnum && level.tbl_weaponids[ primaryweaponnum ][ "reference" ] == "riotshield" || !secondaryweaponnum && secondaryweaponnum && level.tbl_weaponids[ secondaryweaponnum ][ "reference" ] == "riotshield" && !primaryweaponnum ) + { + attacker addweaponstat( sweapon, "NoLethalKills", 1 ); + } + } + } + else + { + maps/mp/_scoreevents::processscoreevent( "melee_kill", attacker, self, sweapon ); + } + } + attacker thread maps/mp/gametypes/_globallogic_score::trackattackerkill( self.name, self.pers[ "rank" ], self.pers[ "rankxp" ], self.pers[ "prestige" ], self getxuid( 1 ) ); + attackername = attacker.name; + self thread maps/mp/gametypes/_globallogic_score::trackattackeedeath( attackername, attacker.pers[ "rank" ], attacker.pers[ "rankxp" ], attacker.pers[ "prestige" ], attacker getxuid( 1 ) ); + self thread maps/mp/_medals::setlastkilledby( attacker ); + attacker thread maps/mp/gametypes/_globallogic_score::inckillstreaktracker( sweapon ); + if ( level.teambased && attacker.team != "spectator" ) + { + if ( isai( attacker ) ) + { + maps/mp/gametypes/_globallogic_score::giveteamscore( "kill", attacker.aiteam, attacker, self ); + } + else + { + maps/mp/gametypes/_globallogic_score::giveteamscore( "kill", attacker.team, attacker, self ); + } + } + scoresub = level.deathpointloss; + if ( scoresub != 0 ) + { + maps/mp/gametypes/_globallogic_score::_setplayerscore( self, maps/mp/gametypes/_globallogic_score::_getplayerscore( self ) - scoresub ); + } + level thread playkillbattlechatter( attacker, sweapon, self ); } callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration ) @@ -1029,6 +1743,7 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd self setburn( 0 ); } self.suicide = 0; + self.teamkilled = 0; if ( isDefined( level.takelivesondeath ) && level.takelivesondeath == 1 ) { if ( self.pers[ "lives" ] ) @@ -1069,6 +1784,7 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd shitloc = self.laststandparams.shitloc; self.vattackerorigin = self.laststandparams.vattackerorigin; deathtimeoffset = ( getTime() - self.laststandparams.laststandstarttime ) / 1000; + self thread maps/mp/gametypes/_battlechatter_mp::perkspecificbattlechatter( "secondchance" ); if ( isDefined( self.previousprimary ) ) { wasinlaststand = 1; @@ -1081,7 +1797,8 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd bestplayermeansofdeath = undefined; obituarymeansofdeath = undefined; bestplayerweapon = undefined; - obituaryweapon = undefined; + obituaryweapon = sweapon; + assistedsuicide = 0; if ( isDefined( attacker ) && attacker.classname != "trigger_hurt" && attacker.classname != "worldspawn" && isDefined( attacker.ismagicbullet ) && attacker.ismagicbullet != 1 && attacker == self && isDefined( self.attackers ) ) { while ( !isDefined( bestplayer ) ) @@ -1143,7 +1860,9 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd } if ( isDefined( bestplayer ) ) { + maps/mp/_scoreevents::processscoreevent( "assisted_suicide", bestplayer, self, sweapon ); self recordkillmodifier( "assistedsuicide" ); + assistedsuicide = 1; } } if ( isDefined( bestplayer ) ) @@ -1151,19 +1870,22 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd attacker = bestplayer; obituarymeansofdeath = bestplayermeansofdeath; obituaryweapon = bestplayerweapon; + if ( isDefined( bestplayerweapon ) ) + { + sweapon = bestplayerweapon; + } } if ( isplayer( attacker ) ) { } - if ( maps/mp/gametypes_zm/_globallogic_utils::isheadshot( sweapon, shitloc, smeansofdeath, einflictor ) && isplayer( attacker ) ) - { - attacker playlocalsound( "prj_bullet_impact_headshot_helmet_nodie_2d" ); - smeansofdeath = "MOD_HEAD_SHOT"; - } self.deathtime = getTime(); attacker = updateattacker( attacker, sweapon ); einflictor = updateinflictor( einflictor ); - smeansofdeath = updatemeansofdeath( sweapon, smeansofdeath ); + smeansofdeath = self playerkilled_updatemeansofdeath( attacker, einflictor, sweapon, smeansofdeath, shitloc ); + if ( !isDefined( obituarymeansofdeath ) ) + { + obituarymeansofdeath = smeansofdeath; + } if ( isDefined( self.hasriotshieldequipped ) && self.hasriotshieldequipped == 1 ) { self detachshieldmodel( level.carriedshieldmodel, "tag_weapon_left" ); @@ -1171,85 +1893,9 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd self.hasriotshieldequipped = 0; } self thread updateglobalbotkilledcounter(); - if ( isplayer( attacker ) && attacker != self || !level.teambased && level.teambased && self.team != attacker.team ) - { - self addweaponstat( sweapon, "deaths", 1 ); - if ( wasinlaststand && isDefined( lastweaponbeforedroppingintolaststand ) ) - { - weaponname = lastweaponbeforedroppingintolaststand; - } - else - { - weaponname = self.lastdroppableweapon; - } - if ( isDefined( weaponname ) && !issubstr( weaponname, "gl_" ) || issubstr( weaponname, "mk_" ) && issubstr( weaponname, "ft_" ) ) - { - weaponname = self.currentweapon; - } - if ( isDefined( weaponname ) ) - { - self addweaponstat( weaponname, "deathsDuringUse", 1 ); - } - if ( smeansofdeath != "MOD_FALLING" ) - { - attacker addweaponstat( sweapon, "kills", 1 ); - } - if ( smeansofdeath == "MOD_HEAD_SHOT" ) - { - attacker addweaponstat( sweapon, "headshots", 1 ); - } - } - if ( !isDefined( obituarymeansofdeath ) ) - { - obituarymeansofdeath = smeansofdeath; - } - if ( !isDefined( obituaryweapon ) ) - { - obituaryweapon = sweapon; - } - if ( !isplayer( attacker ) || self isenemyplayer( attacker ) == 0 ) - { - level notify( "reset_obituary_count" ); - level.lastobituaryplayercount = 0; - level.lastobituaryplayer = undefined; - } - else - { - if ( isDefined( level.lastobituaryplayer ) && level.lastobituaryplayer == attacker ) - { - level.lastobituaryplayercount++; - } - else - { - level notify( "reset_obituary_count" ); - level.lastobituaryplayer = attacker; - level.lastobituaryplayercount = 1; - } - if ( level.lastobituaryplayercount >= 4 ) - { - level notify( "reset_obituary_count" ); - level.lastobituaryplayercount = 0; - level.lastobituaryplayer = undefined; - } - } - overrideentitycamera = 0; - if ( level.teambased && isDefined( attacker.pers ) && self.team == attacker.team && obituarymeansofdeath == "MOD_GRENADE" && level.friendlyfire == 0 ) - { - obituary( self, self, obituaryweapon, obituarymeansofdeath ); - maps/mp/_demo::bookmark( "kill", getTime(), self, self, 0, einflictor, overrideentitycamera ); - } - else - { - obituary( self, attacker, obituaryweapon, obituarymeansofdeath ); - maps/mp/_demo::bookmark( "kill", getTime(), self, attacker, 0, einflictor, overrideentitycamera ); - } - if ( !level.ingraceperiod ) - { - self maps/mp/gametypes_zm/_weapons::dropscavengerfordeath( attacker ); - self maps/mp/gametypes_zm/_weapons::dropweaponfordeath( attacker ); - self maps/mp/gametypes_zm/_weapons::dropoffhand(); - } - maps/mp/gametypes_zm/_spawnlogic::deathoccured( self, attacker ); + self playerkilled_weaponstats( attacker, sweapon, smeansofdeath, wasinlaststand, lastweaponbeforedroppingintolaststand, einflictor ); + self playerkilled_obituary( attacker, einflictor, obituaryweapon, obituarymeansofdeath ); + maps/mp/gametypes/_spawnlogic::deathoccured( self, attacker ); self.sessionstate = "dead"; self.statusicon = "hud_status_dead"; self.killedplayerscurrent = []; @@ -1257,51 +1903,7 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd /# println( "players(" + self.clientid + ") death count ++: " + self.deathcount ); #/ - if ( !isDefined( self.switching_teams ) ) - { - if ( isplayer( attacker ) && level.teambased && attacker != self && self.team == attacker.team ) - { - self.pers[ "cur_kill_streak" ] = 0; - self.pers[ "cur_total_kill_streak" ] = 0; - self.pers[ "totalKillstreakCount" ] = 0; - self.pers[ "killstreaksEarnedThisKillstreak" ] = 0; - self setplayercurrentstreak( 0 ); - } - else - { - self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "deaths", 1, 1, 1 ); - self.deaths = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "deaths" ); - self updatestatratio( "kdratio", "kills", "deaths" ); - if ( self.pers[ "cur_kill_streak" ] > self.pers[ "best_kill_streak" ] ) - { - self.pers[ "best_kill_streak" ] = self.pers[ "cur_kill_streak" ]; - } - self.pers[ "kill_streak_before_death" ] = self.pers[ "cur_kill_streak" ]; - self.pers[ "cur_kill_streak" ] = 0; - self.pers[ "cur_total_kill_streak" ] = 0; - self.pers[ "totalKillstreakCount" ] = 0; - self.pers[ "killstreaksEarnedThisKillstreak" ] = 0; - self setplayercurrentstreak( 0 ); - self.cur_death_streak++; - if ( self.cur_death_streak > self.death_streak ) - { - if ( level.rankedmatch ) - { - self setdstat( "HighestStats", "death_streak", self.cur_death_streak ); - } - self.death_streak = self.cur_death_streak; - } - if ( self.cur_death_streak >= getDvarInt( "perk_deathStreakCountRequired" ) ) - { - self enabledeathstreak(); - } - } - } - else - { - self.pers[ "totalKillstreakCount" ] = 0; - self.pers[ "killstreaksEarnedThisKillstreak" ] = 0; - } + self playerkilled_killstreaks( attacker, sweapon ); lpselfnum = self getentitynumber(); lpselfname = self.name; lpattackguid = ""; @@ -1312,34 +1914,22 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd lpattackorigin = ( 0, 0, 0 ); lpattacknum = -1; awardassists = 0; + wasteamkill = 0; + wassuicide = 0; pixendevent(); - self resetplayermomentumondeath(); + maps/mp/_scoreevents::processscoreevent( "death", self, self, sweapon ); + self.pers[ "resetMomentumOnSpawn" ] = 1; if ( isplayer( attacker ) ) { lpattackguid = attacker getguid(); lpattackname = attacker.name; lpattackteam = attacker.team; lpattackorigin = attacker.origin; - if ( attacker == self ) + if ( attacker == self || assistedsuicide == 1 ) { dokillcam = 0; - self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "suicides", 1 ); - self.suicides = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "suicides" ); - if ( smeansofdeath == "MOD_SUICIDE" && shitloc == "none" && self.throwinggrenade ) - { - self.lastgrenadesuicidetime = getTime(); - } - awardassists = 1; - self.suicide = 1; - if ( isDefined( self.friendlydamage ) ) - { - self iprintln( &"MP_FRIENDLY_FIRE_WILL_NOT" ); - if ( level.teamkillpointloss ) - { - scoresub = self [[ level.getteamkillscore ]]( einflictor, attacker, smeansofdeath, sweapon ); - maps/mp/gametypes_zm/_globallogic_score::_setplayerscore( attacker, maps/mp/gametypes_zm/_globallogic_score::_getplayerscore( attacker ) - scoresub ); - } - } + wassuicide = 1; + awardassists = self playerkilled_suicide( einflictor, attacker, smeansofdeath, sweapon, shitloc ); } else { @@ -1353,108 +1943,12 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd { if ( level.teambased && self.team == attacker.team ) { - if ( !ignoreteamkills( sweapon, smeansofdeath ) ) - { - teamkill_penalty = self [[ level.getteamkillpenalty ]]( einflictor, attacker, smeansofdeath, sweapon ); - attacker maps/mp/gametypes_zm/_globallogic_score::incpersstat( "teamkills_nostats", teamkill_penalty, 0 ); - attacker maps/mp/gametypes_zm/_globallogic_score::incpersstat( "teamkills", 1 ); - attacker.teamkillsthisround++; - if ( level.teamkillpointloss ) - { - scoresub = self [[ level.getteamkillscore ]]( einflictor, attacker, smeansofdeath, sweapon ); - maps/mp/gametypes_zm/_globallogic_score::_setplayerscore( attacker, maps/mp/gametypes_zm/_globallogic_score::_getplayerscore( attacker ) - scoresub ); - } - if ( maps/mp/gametypes_zm/_globallogic_utils::gettimepassed() < 5000 ) - { - teamkilldelay = 1; - } - else if ( attacker.pers[ "teamkills_nostats" ] > 1 && maps/mp/gametypes_zm/_globallogic_utils::gettimepassed() < ( 8000 + ( attacker.pers[ "teamkills_nostats" ] * 1000 ) ) ) - { - teamkilldelay = 1; - } - else - { - teamkilldelay = attacker teamkilldelay(); - } - if ( teamkilldelay > 0 ) - { - attacker.teamkillpunish = 1; - attacker suicide(); - if ( attacker shouldteamkillkick( teamkilldelay ) ) - { - attacker teamkillkick(); - } - attacker thread reduceteamkillsovertime(); - } - } + wasteamkill = 1; + self playerkilled_teamkill( einflictor, attacker, smeansofdeath, sweapon, shitloc ); } else { - maps/mp/gametypes_zm/_globallogic_score::inctotalkills( attacker.team ); - attacker thread maps/mp/gametypes_zm/_globallogic_score::givekillstats( smeansofdeath, sweapon, self ); - if ( isalive( attacker ) ) - { - pixbeginevent( "killstreak" ); - if ( isDefined( einflictor ) || !isDefined( einflictor.requireddeathcount ) && attacker.deathcount == einflictor.requireddeathcount ) - { - shouldgivekillstreak = 0; - attacker.pers[ "cur_total_kill_streak" ]++; - attacker setplayercurrentstreak( attacker.pers[ "cur_total_kill_streak" ] ); - if ( isDefined( level.killstreaks ) && shouldgivekillstreak ) - { - attacker.pers[ "cur_kill_streak" ]++; - if ( attacker.pers[ "cur_kill_streak" ] >= 3 ) - { - if ( attacker.pers[ "cur_kill_streak" ] <= 30 ) - { - } - } - } - } - pixendevent(); - } - if ( attacker.pers[ "cur_kill_streak" ] > attacker.kill_streak ) - { - if ( level.rankedmatch ) - { - attacker setdstat( "HighestStats", "kill_streak", attacker.pers[ "totalKillstreakCount" ] ); - } - attacker.kill_streak = attacker.pers[ "cur_kill_streak" ]; - } - killstreak = undefined; - if ( isDefined( killstreak ) ) - { - } - else if ( smeansofdeath == "MOD_HEAD_SHOT" ) - { - } - else if ( smeansofdeath == "MOD_MELEE" ) - { - if ( sweapon == "riotshield_mp" ) - { - } - } - attacker thread maps/mp/gametypes_zm/_globallogic_score::trackattackerkill( self.name, self.pers[ "rank" ], self.pers[ "rankxp" ], self.pers[ "prestige" ], self getxuid( 1 ) ); - attackername = attacker.name; - self thread maps/mp/gametypes_zm/_globallogic_score::trackattackeedeath( attackername, attacker.pers[ "rank" ], attacker.pers[ "rankxp" ], attacker.pers[ "prestige" ], attacker getxuid( 1 ) ); - attacker thread maps/mp/gametypes_zm/_globallogic_score::inckillstreaktracker( sweapon ); - if ( level.teambased && attacker.team != "spectator" ) - { - if ( isai( attacker ) ) - { - maps/mp/gametypes_zm/_globallogic_score::giveteamscore( "kill", attacker.aiteam, attacker, self ); - } - else - { - maps/mp/gametypes_zm/_globallogic_score::giveteamscore( "kill", attacker.team, attacker, self ); - } - } - scoresub = level.deathpointloss; - if ( scoresub != 0 ) - { - maps/mp/gametypes_zm/_globallogic_score::_setplayerscore( self, maps/mp/gametypes_zm/_globallogic_score::_getplayerscore( self ) - scoresub ); - } - level thread playkillbattlechatter( attacker, sweapon, self ); + self playerkilled_kill( einflictor, attacker, smeansofdeath, sweapon, shitloc ); if ( level.teambased ) { awardassists = 1; @@ -1471,9 +1965,17 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd lpattackguid = ""; lpattackname = ""; lpattackteam = "world"; - self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "suicides", 1 ); - self.suicides = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "suicides" ); + thread maps/mp/_scoreevents::processscoreevent( "suicide", self ); + self maps/mp/gametypes/_globallogic_score::incpersstat( "suicides", 1 ); + self.suicides = self maps/mp/gametypes/_globallogic_score::getpersstat( "suicides" ); + self.suicide = 1; + thread maps/mp/gametypes/_battlechatter_mp::onplayersuicideorteamkill( self, "suicide" ); awardassists = 1; + if ( level.maxsuicidesbeforekick > 0 && level.maxsuicidesbeforekick <= self.suicides ) + { + self notify( "teamKillKicked" ); + self suicidekick(); + } } else { @@ -1482,10 +1984,12 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd lpattackguid = ""; lpattackname = ""; lpattackteam = "world"; + wassuicide = 1; if ( isDefined( einflictor ) && isDefined( einflictor.killcament ) ) { dokillcam = 1; lpattacknum = self getentitynumber(); + wassuicide = 0; } if ( isDefined( attacker ) && isDefined( attacker.team ) && isDefined( level.teams[ attacker.team ] ) ) { @@ -1493,56 +1997,32 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd { if ( level.teambased ) { - maps/mp/gametypes_zm/_globallogic_score::giveteamscore( "kill", attacker.team, attacker, self ); + maps/mp/gametypes/_globallogic_score::giveteamscore( "kill", attacker.team, attacker, self ); } + wassuicide = 0; } } awardassists = 1; } + if ( !level.ingraceperiod ) + { + if ( smeansofdeath != "MOD_GRENADE" && smeansofdeath != "MOD_GRENADE_SPLASH" && smeansofdeath != "MOD_EXPLOSIVE" && smeansofdeath != "MOD_EXPLOSIVE_SPLASH" && smeansofdeath != "MOD_PROJECTILE_SPLASH" ) + { + self maps/mp/gametypes/_weapons::dropscavengerfordeath( attacker ); + } + if ( !wasteamkill && !wassuicide ) + { + self maps/mp/gametypes/_weapons::dropweaponfordeath( attacker, sweapon, smeansofdeath ); + self maps/mp/gametypes/_weapons::dropoffhand(); + } + } if ( sessionmodeiszombiesgame() ) { awardassists = 0; } if ( awardassists ) { - pixbeginevent( "PlayerKilled assists" ); - while ( isDefined( self.attackers ) ) - { - j = 0; - while ( j < self.attackers.size ) - { - player = self.attackers[ j ]; - if ( !isDefined( player ) ) - { - j++; - continue; - } - else if ( player == attacker ) - { - j++; - continue; - } - else if ( player.team != lpattackteam ) - { - j++; - continue; - } - else - { - damage_done = self.attackerdamage[ player.clientid ].damage; - player thread maps/mp/gametypes_zm/_globallogic_score::processassist( self, damage_done, self.attackerdamage[ player.clientid ].weapon ); - } - j++; - } - } - if ( isDefined( self.lastattackedshieldplayer ) && isDefined( self.lastattackedshieldtime ) && self.lastattackedshieldplayer != attacker ) - { - if ( ( getTime() - self.lastattackedshieldtime ) < 4000 ) - { - self.lastattackedshieldplayer thread maps/mp/gametypes_zm/_globallogic_score::processshieldassist( self ); - } - } - pixendevent(); + self playerkilled_awardassists( einflictor, attacker, sweapon, lpattackteam ); } pixbeginevent( "PlayerKilled post constants" ); self.lastattacker = attacker; @@ -1561,7 +2041,15 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd } if ( isplayer( attacker ) ) { - bbprint( "mpattacks", "gametime %d attackerspawnid %d attackerweapon %s attackerx %d attackery %d attackerz %d victimspawnid %d victimx %d victimy %d victimz %d damage %d damagetype %s damagelocation %s death %d", getTime(), getplayerspawnid( attacker ), sweapon, lpattackorigin, getplayerspawnid( self ), self.origin, idamage, smeansofdeath, shitloc, 1 ); + if ( maps/mp/killstreaks/_killstreaks::iskillstreakweapon( sweapon ) ) + { + killstreak = maps/mp/killstreaks/_killstreaks::getkillstreakforweapon( sweapon ); + bbprint( "mpattacks", "gametime %d attackerspawnid %d attackerweapon %s attackerx %d attackery %d attackerz %d victimspawnid %d victimx %d victimy %d victimz %d damage %d damagetype %s damagelocation %s death %d killstreak %s", getTime(), getplayerspawnid( attacker ), sweapon, lpattackorigin, getplayerspawnid( self ), self.origin, idamage, smeansofdeath, shitloc, 1, killstreak ); + } + else + { + bbprint( "mpattacks", "gametime %d attackerspawnid %d attackerweapon %s attackerx %d attackery %d attackerz %d victimspawnid %d victimx %d victimy %d victimz %d damage %d damagetype %s damagelocation %s death %d", getTime(), getplayerspawnid( attacker ), sweapon, lpattackorigin, getplayerspawnid( self ), self.origin, idamage, smeansofdeath, shitloc, 1 ); + } } else { @@ -1574,7 +2062,7 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd attackerstring = attacker getxuid() + "(" + lpattackname + ")"; } self logstring( "d " + smeansofdeath + "(" + sweapon + ") a:" + attackerstring + " d:" + idamage + " l:" + shitloc + " @ " + int( self.origin[ 0 ] ) + " " + int( self.origin[ 1 ] ) + " " + int( self.origin[ 2 ] ) ); - level thread maps/mp/gametypes_zm/_globallogic::updateteamstatus(); + level thread maps/mp/gametypes/_globallogic::updateteamstatus(); killcamentity = self getkillcamentity( attacker, einflictor, sweapon ); killcamentityindex = -1; killcamentitystarttime = 0; @@ -1598,15 +2086,20 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd { dokillcam = 0; } - self maps/mp/gametypes_zm/_weapons::detachcarryobjectmodel(); + self maps/mp/gametypes/_weapons::detachcarryobjectmodel(); died_in_vehicle = 0; if ( isDefined( self.diedonvehicle ) ) { died_in_vehicle = self.diedonvehicle; } + hit_by_train = 0; + if ( isDefined( attacker ) && isDefined( attacker.targetname ) && attacker.targetname == "train" ) + { + hit_by_train = 1; + } pixendevent(); pixbeginevent( "PlayerKilled body and gibbing" ); - if ( !died_in_vehicle ) + if ( !died_in_vehicle && !hit_by_train ) { vattackerorigin = undefined; if ( isDefined( attacker ) ) @@ -1619,10 +2112,13 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd ragdoll_now = 1; } body = self cloneplayer( deathanimduration ); - self createdeadbody( idamage, smeansofdeath, sweapon, shitloc, vdir, vattackerorigin, deathanimduration, einflictor, ragdoll_now, body ); + if ( isDefined( body ) ) + { + self createdeadbody( idamage, smeansofdeath, sweapon, shitloc, vdir, vattackerorigin, deathanimduration, einflictor, ragdoll_now, body ); + } } pixendevent(); - thread maps/mp/gametypes_zm/_globallogic_spawn::spawnqueuedclient( self.team, attacker ); + thread maps/mp/gametypes/_globallogic_spawn::spawnqueuedclient( self.team, attacker ); self.switching_teams = undefined; self.joining_team = undefined; self.leaving_team = undefined; @@ -1635,21 +2131,34 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd } self.wantsafespawn = 0; perks = []; - killstreaks = maps/mp/gametypes_zm/_globallogic::getkillstreaks( attacker ); + killstreaks = maps/mp/gametypes/_globallogic::getkillstreaks( attacker ); if ( !isDefined( self.killstreak_waitamount ) ) { self thread [[ level.spawnplayerprediction ]](); } profilelog_endtiming( 7, "gs=" + game[ "state" ] + " zom=" + sessionmodeiszombiesgame() ); + if ( wasteamkill == 0 && assistedsuicide == 0 && hit_by_train == 0 && smeansofdeath != "MOD_SUICIDE" && isDefined( attacker ) && attacker.classname != "trigger_hurt" && attacker.classname != "worldspawn" && self != attacker && !isDefined( attacker.disablefinalkillcam ) ) + { + level thread maps/mp/gametypes/_killcam::recordkillcamsettings( lpattacknum, self getentitynumber(), sweapon, self.deathtime, deathtimeoffset, psoffsettime, killcamentityindex, killcamentitystarttime, perks, killstreaks, attacker ); + } wait 0,25; weaponclass = getweaponclass( sweapon ); + if ( weaponclass == "weapon_sniper" ) + { + self thread maps/mp/gametypes/_battlechatter_mp::killedbysniper( attacker ); + } + else + { + self thread maps/mp/gametypes/_battlechatter_mp::playerkilled( attacker ); + } self.cancelkillcam = 0; + self thread maps/mp/gametypes/_killcam::cancelkillcamonuse(); defaultplayerdeathwatchtime = 1,75; if ( isDefined( level.overrideplayerdeathwatchtimer ) ) { defaultplayerdeathwatchtime = [[ level.overrideplayerdeathwatchtimer ]]( defaultplayerdeathwatchtime ); } - maps/mp/gametypes_zm/_globallogic_utils::waitfortimeornotifies( defaultplayerdeathwatchtime ); + maps/mp/gametypes/_globallogic_utils::waitfortimeornotifies( defaultplayerdeathwatchtime ); self notify( "death_delay_finished" ); /# if ( getDvarInt( #"C1849218" ) != 0 ) @@ -1661,6 +2170,13 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd #/ } } + if ( hit_by_train ) + { + if ( killcamentitystarttime > ( self.deathtime - 2500 ) ) + { + dokillcam = 0; + } + } if ( game[ "state" ] != "playing" ) { return; @@ -1669,11 +2185,12 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd if ( !self.cancelkillcam && dokillcam && level.killcam ) { if ( level.numliveslivesleft = self.pers[ "lives" ]; - timeuntilspawn = maps/mp/gametypes_zm/_globallogic_spawn::timeuntilspawn( 1 ); + timeuntilspawn = maps/mp/gametypes/_globallogic_spawn::timeuntilspawn( 1 ); && livesleft && timeuntilspawn <= 0 ) { willrespawnimmediately = !level.playerqueuedrespawn; } + self maps/mp/gametypes/_killcam::killcam( lpattacknum, self getentitynumber(), killcamentity, killcamentityindex, killcamentitystarttime, sweapon, self.deathtime, deathtimeoffset, psoffsettime, willrespawnimmediately, maps/mp/gametypes/_globallogic_utils::timeuntilroundend(), perks, killstreaks, attacker ); } if ( game[ "state" ] != "playing" ) { @@ -1686,10 +2203,16 @@ callback_playerkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vd return; } waittillkillstreakdone(); - if ( maps/mp/gametypes_zm/_globallogic_utils::isvalidclass( self.class ) ) + userespawntime = 1; + if ( isDefined( level.hostmigrationtimer ) ) + { + userespawntime = 0; + } + maps/mp/gametypes/_hostmigration::waittillhostmigrationcountdown(); + if ( maps/mp/gametypes/_globallogic_utils::isvalidclass( self.class ) ) { timepassed = undefined; - if ( isDefined( self.respawntimerstarttime ) ) + if ( isDefined( self.respawntimerstarttime ) && userespawntime ) { timepassed = ( getTime() - self.respawntimerstarttime ) / 1000; } @@ -1721,13 +2244,23 @@ waittillkillstreakdone() } } -teamkillkick() +suicidekick() { - self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "sessionbans", 1 ); + self maps/mp/gametypes/_globallogic_score::incpersstat( "sessionbans", 1 ); self endon( "disconnect" ); waittillframeend; - playlistbanquantum = maps/mp/gametypes_zm/_tweakables::gettweakablevalue( "team", "teamkillerplaylistbanquantum" ); - playlistbanpenalty = maps/mp/gametypes_zm/_tweakables::gettweakablevalue( "team", "teamkillerplaylistbanpenalty" ); + maps/mp/gametypes/_globallogic::gamehistoryplayerkicked(); + ban( self getentitynumber() ); + maps/mp/gametypes/_globallogic_audio::leaderdialog( "kicked" ); +} + +teamkillkick() +{ + self maps/mp/gametypes/_globallogic_score::incpersstat( "sessionbans", 1 ); + self endon( "disconnect" ); + waittillframeend; + playlistbanquantum = maps/mp/gametypes/_tweakables::gettweakablevalue( "team", "teamkillerplaylistbanquantum" ); + playlistbanpenalty = maps/mp/gametypes/_tweakables::gettweakablevalue( "team", "teamkillerplaylistbanpenalty" ); if ( playlistbanquantum > 0 && playlistbanpenalty > 0 ) { timeplayedtotal = self getdstat( "playerstatslist", "time_played_total", "StatValue" ); @@ -1739,12 +2272,9 @@ teamkillkick() self setdstat( "playerstatslist", "gametypeban", "StatValue", timeplayedtotal + ( playlistbanpenalty * 60 ) ); } } - if ( self is_bot() ) - { - level notify( "bot_kicked" ); - } + maps/mp/gametypes/_globallogic::gamehistoryplayerkicked(); ban( self getentitynumber() ); - maps/mp/gametypes_zm/_globallogic_audio::leaderdialog( "kicked" ); + maps/mp/gametypes/_globallogic_audio::leaderdialog( "kicked" ); } teamkilldelay() @@ -1762,7 +2292,7 @@ shouldteamkillkick( teamkilldelay ) { if ( teamkilldelay && level.minimumallowedteamkills >= 0 ) { - if ( maps/mp/gametypes_zm/_globallogic_utils::gettimepassed() >= 5000 ) + if ( maps/mp/gametypes/_globallogic_utils::gettimepassed() >= 5000 ) { return 1; } @@ -1823,7 +2353,7 @@ callback_playerlaststand( einflictor, attacker, idamage, smeansofdeath, sweapon, damageshellshockandrumble( eattacker, einflictor, sweapon, smeansofdeath, idamage ) { - self thread maps/mp/gametypes_zm/_weapons::onweapondamage( eattacker, einflictor, sweapon, smeansofdeath, idamage ); + self thread maps/mp/gametypes/_weapons::onweapondamage( eattacker, einflictor, sweapon, smeansofdeath, idamage ); self playrumbleonentity( "damage_heavy" ); } @@ -1832,9 +2362,13 @@ createdeadbody( idamage, smeansofdeath, sweapon, shitloc, vdir, vattackerorigin, if ( smeansofdeath == "MOD_HIT_BY_OBJECT" && self getstance() == "prone" ) { self.body = body; + if ( !isDefined( self.switching_teams ) ) + { + thread maps/mp/gametypes/_deathicons::adddeathicon( body, self, self.team, 5 ); + } return; } - if ( isDefined( level.ragdoll_override ) && self [[ level.ragdoll_override ]]() ) + if ( isDefined( level.ragdoll_override ) && self [[ level.ragdoll_override ]]( idamage, smeansofdeath, sweapon, shitloc, vdir, vattackerorigin, deathanimduration, einflictor, ragdoll_jib, body ) ) { return; } @@ -1854,7 +2388,19 @@ createdeadbody( idamage, smeansofdeath, sweapon, shitloc, vdir, vattackerorigin, body start_explosive_ragdoll( vdir, sweapon ); } thread delaystartragdoll( body, shitloc, vdir, sweapon, einflictor, smeansofdeath ); + if ( smeansofdeath == "MOD_BURNED" || isDefined( self.burning ) ) + { + body maps/mp/_burnplayer::burnedtodeath(); + } + if ( smeansofdeath == "MOD_CRUSH" ) + { + body maps/mp/gametypes/_globallogic_vehicle::vehiclecrush(); + } self.body = body; + if ( !isDefined( self.switching_teams ) ) + { + thread maps/mp/gametypes/_deathicons::adddeathicon( body, self, self.team, 5 ); + } } is_explosive_ragdoll( weapon, inflictor ) @@ -1937,7 +2483,7 @@ delaystartragdoll( ent, shitloc, vdir, sweapon, einflictor, smeansofdeath ) { vdir = ( 0, 0, 0 ); } - explosionpos = ent.origin + ( 0, 0, maps/mp/gametypes_zm/_globallogic_utils::gethitlocheight( shitloc ) ); + explosionpos = ent.origin + ( 0, 0, maps/mp/gametypes/_globallogic_utils::gethitlocheight( shitloc ) ); explosionpos -= vdir * 20; explosionradius = 40; explosionforce = 0,75; @@ -2011,7 +2557,7 @@ trackattackerdamage( eattacker, idamage, smeansofdeath, sweapon ) } } self.attackerdamage[ eattacker.clientid ].lasttimedamaged = getTime(); - if ( maps/mp/gametypes_zm/_weapons::isprimaryweapon( sweapon ) ) + if ( maps/mp/gametypes/_weapons::isprimaryweapon( sweapon ) ) { self.attackerdata[ eattacker.clientid ] = 1; } @@ -2041,8 +2587,12 @@ giveinflictorownerassist( eattacker, einflictor, idamage, smeansofdeath, sweapon self trackattackerdamage( einflictor.owner, idamage, smeansofdeath, sweapon ); } -updatemeansofdeath( sweapon, smeansofdeath ) +playerkilled_updatemeansofdeath( attacker, einflictor, sweapon, smeansofdeath, shitloc ) { + if ( maps/mp/gametypes/_globallogic_utils::isheadshot( sweapon, shitloc, smeansofdeath, einflictor ) && isplayer( attacker ) ) + { + return "MOD_HEAD_SHOT"; + } switch( sweapon ) { case "crossbow_mp": @@ -2095,6 +2645,13 @@ updateattacker( attacker, weapon ) } attacker.planemortarbda++; } + if ( isDefined( attacker ) && isDefined( weapon ) || weapon == "straferun_rockets_mp" && weapon == "straferun_gun_mp" ) + { + if ( isDefined( attacker.straferunbda ) ) + { + attacker.straferunbda++; + } + } return attacker; } @@ -2140,11 +2697,11 @@ getclosestkillcamentity( attacker, killcamentities, depth ) closestkillcamentindex = undefined; closestkillcamentdist = undefined; origin = undefined; - _a2796 = killcamentities; - killcamentindex = getFirstArrayKey( _a2796 ); + _a2977 = killcamentities; + killcamentindex = getFirstArrayKey( _a2977 ); while ( isDefined( killcamentindex ) ) { - killcament = _a2796[ killcamentindex ]; + killcament = _a2977[ killcamentindex ]; if ( killcament == attacker ) { } @@ -2163,7 +2720,7 @@ getclosestkillcamentity( attacker, killcamentities, depth ) closestkillcamentindex = killcamentindex; } } - killcamentindex = getNextArrayKey( _a2796, killcamentindex ); + killcamentindex = getNextArrayKey( _a2977, killcamentindex ); } if ( depth < 3 && isDefined( closestkillcament ) ) { @@ -2235,4 +2792,11 @@ getkillcamentity( attacker, einflictor, sweapon ) playkillbattlechatter( attacker, sweapon, victim ) { + if ( isplayer( attacker ) ) + { + if ( !maps/mp/killstreaks/_killstreaks::iskillstreakweapon( sweapon ) ) + { + level thread maps/mp/gametypes/_battlechatter_mp::saykillbattlechatter( attacker, sweapon, victim ); + } + } } diff --git a/patch_mp/maps/mp/gametypes/_globallogic_score.gsc b/patch_mp/maps/mp/gametypes/_globallogic_score.gsc index a5610a2..2d05766 100644 --- a/patch_mp/maps/mp/gametypes/_globallogic_score.gsc +++ b/patch_mp/maps/mp/gametypes/_globallogic_score.gsc @@ -1,18 +1,211 @@ -#include maps/mp/gametypes_zm/_globallogic_utils; +#include maps/mp/bots/_bot; +#include maps/mp/gametypes/_globallogic_audio; +#include maps/mp/gametypes/_globallogic_score; #include maps/mp/_challenges; -#include maps/mp/gametypes_zm/_globallogic_audio; -#include maps/mp/gametypes_zm/_globallogic_score; -#include maps/mp/gametypes_zm/_globallogic; +#include maps/mp/gametypes/_class; +#include maps/mp/killstreaks/_killstreak_weapons; +#include maps/mp/killstreaks/_killstreaks; +#include maps/mp/gametypes/_globallogic; +#include maps/mp/gametypes/_wager; +#include maps/mp/gametypes/_persistence; #include maps/mp/_bb; +#include maps/mp/_scoreevents; +#include maps/mp/gametypes/_rank; +#include maps/mp/gametypes/_globallogic_utils; #include maps/mp/_utility; #include common_scripts/utility; updatematchbonusscores( winner ) { + if ( !game[ "timepassed" ] ) + { + return; + } + if ( !level.rankedmatch ) + { + return; + } + if ( level.teambased && isDefined( winner ) ) + { + if ( winner == "endregulation" ) + { + return; + } + } + if ( !level.timelimit || level.forcedend ) + { + gamelength = maps/mp/gametypes/_globallogic_utils::gettimepassed() / 1000; + gamelength = min( gamelength, 1200 ); + if ( level.gametype == "twar" && game[ "roundsplayed" ] > 0 ) + { + gamelength += level.timelimit * 60; + } + } + else + { + gamelength = level.timelimit * 60; + } + if ( level.teambased ) + { + winningteam = "tie"; + _a40 = level.teams; + _k40 = getFirstArrayKey( _a40 ); + while ( isDefined( _k40 ) ) + { + team = _a40[ _k40 ]; + if ( winner == team ) + { + winningteam = team; + break; + } + else + { + _k40 = getNextArrayKey( _a40, _k40 ); + } + } + if ( winningteam != "tie" ) + { + winnerscale = 1; + loserscale = 0,5; + } + else + { + winnerscale = 0,75; + loserscale = 0,75; + } + players = level.players; + i = 0; + while ( i < players.size ) + { + player = players[ i ]; + if ( player.timeplayed[ "total" ] < 1 || player.pers[ "participation" ] < 1 ) + { + player thread maps/mp/gametypes/_rank::endgameupdate(); + i++; + continue; + } + else + { + totaltimeplayed = player.timeplayed[ "total" ]; + if ( totaltimeplayed > gamelength ) + { + totaltimeplayed = gamelength; + } + if ( level.hostforcedend && player ishost() ) + { + i++; + continue; + } + else + { + if ( player.pers[ "score" ] < 0 ) + { + i++; + continue; + } + else spm = player maps/mp/gametypes/_rank::getspm(); + if ( winningteam == "tie" ) + { + playerscore = int( ( winnerscale * ( gamelength / 60 ) * spm ) * ( totaltimeplayed / gamelength ) ); + player thread givematchbonus( "tie", playerscore ); + player.matchbonus = playerscore; + i++; + continue; + } + else if ( isDefined( player.pers[ "team" ] ) && player.pers[ "team" ] == winningteam ) + { + playerscore = int( ( winnerscale * ( gamelength / 60 ) * spm ) * ( totaltimeplayed / gamelength ) ); + player thread givematchbonus( "win", playerscore ); + player.matchbonus = playerscore; + i++; + continue; + } + else + { + if ( isDefined( player.pers[ "team" ] ) && player.pers[ "team" ] != "spectator" ) + { + playerscore = int( ( loserscale * ( gamelength / 60 ) * spm ) * ( totaltimeplayed / gamelength ) ); + player thread givematchbonus( "loss", playerscore ); + player.matchbonus = playerscore; + } + } + } + } + i++; + } + } + else if ( isDefined( winner ) ) + { + winnerscale = 1; + loserscale = 0,5; + } + else + { + winnerscale = 0,75; + loserscale = 0,75; + } + players = level.players; + i = 0; + while ( i < players.size ) + { + player = players[ i ]; + if ( player.timeplayed[ "total" ] < 1 || player.pers[ "participation" ] < 1 ) + { + player thread maps/mp/gametypes/_rank::endgameupdate(); + i++; + continue; + } + else + { + totaltimeplayed = player.timeplayed[ "total" ]; + if ( totaltimeplayed > gamelength ) + { + totaltimeplayed = gamelength; + } + spm = player maps/mp/gametypes/_rank::getspm(); + iswinner = 0; + pidx = 0; + while ( pidx < min( level.placement[ "all" ][ 0 ].size, 3 ) ) + { + if ( level.placement[ "all" ][ pidx ] != player ) + { + pidx++; + continue; + } + else + { + iswinner = 1; + } + pidx++; + } + if ( iswinner ) + { + playerscore = int( ( winnerscale * ( gamelength / 60 ) * spm ) * ( totaltimeplayed / gamelength ) ); + player thread givematchbonus( "win", playerscore ); + player.matchbonus = playerscore; + i++; + continue; + } + else + { + playerscore = int( ( loserscale * ( gamelength / 60 ) * spm ) * ( totaltimeplayed / gamelength ) ); + player thread givematchbonus( "loss", playerscore ); + player.matchbonus = playerscore; + } + } + i++; + } } givematchbonus( scoretype, score ) { + self endon( "disconnect" ); + level waittill( "give_match_bonus" ); + if ( maps/mp/_scoreevents::shouldaddrankxp( self ) ) + { + self addrankxpvalue( scoretype, score ); + } + self maps/mp/gametypes/_rank::endgameupdate(); } doskillupdate( winner ) @@ -28,17 +221,17 @@ gethighestscoringplayer() i = 0; while ( i < players.size ) { - if ( !isDefined( players[ i ].score ) ) + if ( !isDefined( players[ i ].pointstowin ) ) { i++; continue; } - else if ( players[ i ].score < 1 ) + else if ( players[ i ].pointstowin < 1 ) { i++; continue; } - else if ( !isDefined( winner ) || players[ i ].score > winner.score ) + else if ( !isDefined( winner ) || players[ i ].pointstowin > winner.pointstowin ) { winner = players[ i ]; tie = 0; @@ -47,7 +240,7 @@ gethighestscoringplayer() } else { - if ( players[ i ].score == winner.score ) + if ( players[ i ].pointstowin == winner.pointstowin ) { tie = 1; } @@ -117,16 +310,20 @@ giveplayermomentumnotification( score, label, descvalue, countstowardrampage ) if ( score != 0 ) { self luinotifyevent( &"score_event", 3, label, score, rampagebonus ); + self luinotifyeventtospectators( &"score_event", 3, label, score, rampagebonus ); } score += rampagebonus; if ( score > 0 && self hasperk( "specialty_earnmoremomentum" ) ) { score = roundtonearestfive( int( ( score * getDvarFloat( "perk_killstreakMomentumMultiplier" ) ) + 0,5 ) ); } - _setplayermomentum( self, self.pers[ "momentum" ] + score ); + if ( isalive( self ) ) + { + _setplayermomentum( self, self.pers[ "momentum" ] + score ); + } } -resetplayermomentumondeath() +resetplayermomentumonspawn() { if ( isDefined( level.usingscorestreaks ) && level.usingscorestreaks ) { @@ -137,6 +334,37 @@ resetplayermomentumondeath() giveplayermomentum( event, player, victim, weapon, descvalue ) { + if ( isDefined( level.disablemomentum ) && level.disablemomentum == 1 ) + { + return; + } + score = maps/mp/gametypes/_rank::getscoreinfovalue( event ); +/# + assert( isDefined( score ) ); +#/ + label = maps/mp/gametypes/_rank::getscoreinfolabel( event ); + countstowardrampage = maps/mp/gametypes/_rank::doesscoreinfocounttowardrampage( event ); + if ( event == "death" ) + { + _setplayermomentum( victim, victim.pers[ "momentum" ] + score ); + } + if ( score == 0 ) + { + return; + } + if ( !isDefined( label ) ) + { +/# + assertmsg( event + " label undefined" ); +#/ + player giveplayermomentumnotification( score, "", descvalue, countstowardrampage ); + return; + } + if ( level.gameended ) + { + return; + } + player giveplayermomentumnotification( score, label, descvalue, countstowardrampage ); } giveplayerscore( event, player, victim, weapon, descvalue ) @@ -163,21 +391,67 @@ giveplayerscore( event, player, victim, weapon, descvalue ) pixbeginevent( "givePlayerScore" ); recordplayerstats( player, "score", newscore ); scorediff = newscore - score; + challengesenabled = !level.disablechallenges; player addplayerstatwithgametype( "score", scorediff ); - if ( isDefined( player.pers[ "lastHighestScore" ] ) && newscore > player.pers[ "lastHighestScore" ] ) + if ( challengesenabled ) + { + player addplayerstat( "CAREER_SCORE", scorediff ); + } + if ( level.hardcoremode ) + { + player addplayerstat( "SCORE_HC", scorediff ); + if ( challengesenabled ) + { + player addplayerstat( "CAREER_SCORE_HC", scorediff ); + } + } + if ( level.multiteam ) + { + player addplayerstat( "SCORE_MULTITEAM", scorediff ); + if ( challengesenabled ) + { + player addplayerstat( "CAREER_SCORE_MULTITEAM", scorediff ); + } + } + if ( !level.disablestattracking && isDefined( player.pers[ "lastHighestScore" ] ) && newscore > player.pers[ "lastHighestScore" ] ) { player setdstat( "HighestStats", "highest_score", newscore ); } + player maps/mp/gametypes/_persistence::addrecentstat( 0, 0, "score", scorediff ); pixendevent(); return scorediff; } default_onplayerscore( event, player, victim ) { + score = maps/mp/gametypes/_rank::getscoreinfovalue( event ); +/# + assert( isDefined( score ) ); +#/ + if ( level.wagermatch ) + { + player thread maps/mp/gametypes/_rank::updaterankscorehud( score ); + } + _setplayerscore( player, player.pers[ "score" ] + score ); } _setplayerscore( player, score ) { + if ( score == player.pers[ "score" ] ) + { + return; + } + if ( !level.rankedmatch ) + { + player thread maps/mp/gametypes/_rank::updaterankscorehud( score - player.pers[ "score" ] ); + } + player.pers[ "score" ] = score; + player.score = player.pers[ "score" ]; + recordplayerstats( player, "score", player.pers[ "score" ] ); + if ( level.wagermatch ) + { + player thread maps/mp/gametypes/_wager::playerscored(); + } } _getplayerscore( player ) @@ -185,6 +459,51 @@ _getplayerscore( player ) return player.pers[ "score" ]; } +playtop3sounds() +{ + wait 0,05; + maps/mp/gametypes/_globallogic::updateplacement(); + i = 0; + while ( i < level.placement[ "all" ].size ) + { + prevscoreplace = level.placement[ "all" ][ i ].prevscoreplace; + if ( !isDefined( prevscoreplace ) ) + { + prevscoreplace = 1; + } + currentscoreplace = i + 1; + j = i - 1; + while ( j >= 0 ) + { + if ( level.placement[ "all" ][ i ].score == level.placement[ "all" ][ j ].score ) + { + currentscoreplace--; + + } + j--; + + } + wasinthemoney = prevscoreplace <= 3; + isinthemoney = currentscoreplace <= 3; + level.placement[ "all" ][ i ].prevscoreplace = currentscoreplace; + i++; + } +} + +setpointstowin( points ) +{ + self.pers[ "pointstowin" ] = clamp( points, 0, 65000 ); + self.pointstowin = self.pers[ "pointstowin" ]; + self thread maps/mp/gametypes/_globallogic::checkscorelimit(); + self thread maps/mp/gametypes/_globallogic::checkplayerscorelimitsoon(); + level thread playtop3sounds(); +} + +givepointstowin( points ) +{ + self setpointstowin( self.pers[ "pointstowin" ] + points ); +} + _setplayermomentum( player, momentum ) { momentum = clamp( momentum, 0, 2000 ); @@ -194,11 +513,37 @@ _setplayermomentum( player, momentum ) return; } player maps/mp/_bb::bbaddtostat( "momentum", momentum - oldmomentum ); - if ( momentum > oldmomentum ) + while ( momentum > oldmomentum ) { highestmomentumcost = 0; - numkillstreaks = player.killstreak.size; + numkillstreaks = 0; + if ( isDefined( player.killstreak ) ) + { + numkillstreaks = player.killstreak.size; + } killstreaktypearray = []; + currentkillstreak = 0; + while ( currentkillstreak < numkillstreaks ) + { + killstreaktype = maps/mp/killstreaks/_killstreaks::getkillstreakbymenuname( player.killstreak[ currentkillstreak ] ); + if ( isDefined( killstreaktype ) ) + { + momentumcost = level.killstreaks[ killstreaktype ].momentumcost; + if ( momentumcost > highestmomentumcost ) + { + highestmomentumcost = momentumcost; + } + killstreaktypearray[ killstreaktypearray.size ] = killstreaktype; + } + currentkillstreak++; + } + _giveplayerkillstreakinternal( player, momentum, oldmomentum, killstreaktypearray ); + while ( highestmomentumcost > 0 && momentum >= highestmomentumcost ) + { + oldmomentum = 0; + momentum -= highestmomentumcost; + _giveplayerkillstreakinternal( player, momentum, oldmomentum, killstreaktypearray ); + } } player.pers[ "momentum" ] = momentum; player.momentum = player.pers[ "momentum" ]; @@ -206,6 +551,66 @@ _setplayermomentum( player, momentum ) _giveplayerkillstreakinternal( player, momentum, oldmomentum, killstreaktypearray ) { + killstreaktypeindex = 0; + while ( killstreaktypeindex < killstreaktypearray.size ) + { + killstreaktype = killstreaktypearray[ killstreaktypeindex ]; + momentumcost = level.killstreaks[ killstreaktype ].momentumcost; + if ( momentumcost > oldmomentum && momentumcost <= momentum ) + { + weapon = maps/mp/killstreaks/_killstreaks::getkillstreakweapon( killstreaktype ); + if ( isDefined( level.usingscorestreaks ) && level.usingscorestreaks ) + { + if ( maps/mp/killstreaks/_killstreak_weapons::isheldkillstreakweapon( weapon ) ) + { + if ( !isDefined( player.pers[ "held_killstreak_ammo_count" ][ weapon ] ) ) + { + player.pers[ "held_killstreak_ammo_count" ][ weapon ] = 0; + } + if ( !isDefined( player.pers[ "killstreak_quantity" ][ weapon ] ) ) + { + player.pers[ "killstreak_quantity" ][ weapon ] = 0; + } + currentweapon = player getcurrentweapon(); + if ( currentweapon == weapon ) + { + if ( player.pers[ "killstreak_quantity" ][ weapon ] < level.scorestreaksmaxstacking ) + { + player.pers[ "killstreak_quantity" ][ weapon ]++; + } + } + else + { + player.pers[ "held_killstreak_clip_count" ][ weapon ] = weaponclipsize( weapon ); + player.pers[ "held_killstreak_ammo_count" ][ weapon ] = weaponmaxammo( weapon ); + player maps/mp/gametypes/_class::setweaponammooverall( weapon, player.pers[ "held_killstreak_ammo_count" ][ weapon ] ); + } + } + else + { + player maps/mp/_challenges::earnedkillstreak(); + player maps/mp/killstreaks/_killstreaks::changekillstreakquantity( weapon, 1 ); + } + player maps/mp/killstreaks/_killstreaks::addkillstreaktoqueue( level.killstreaks[ killstreaktype ].menuname, 0, killstreaktype ); + killstreaktypeindex++; + continue; + } + else + { + player maps/mp/killstreaks/_killstreaks::addkillstreaktoqueue( level.killstreaks[ killstreaktype ].menuname, 0, killstreaktype ); + activeeventname = "reward_active"; + if ( isDefined( weapon ) ) + { + neweventname = weapon + "_active"; + if ( maps/mp/_scoreevents::isregisteredevent( neweventname ) ) + { + activeeventname = neweventname; + } + } + } + } + killstreaktypeindex++; + } } setplayermomentumdebug() @@ -249,11 +654,41 @@ giveteamscore( event, team, player, victim ) return; } updateteamscores( team ); - thread maps/mp/gametypes_zm/_globallogic::checkscorelimit(); + thread maps/mp/gametypes/_globallogic::checkscorelimit(); +} + +giveteamscoreforobjective_delaypostprocessing( team, score ) +{ + teamscore = game[ "teamScores" ][ team ]; + onteamscore_incrementscore( score, team ); + newscore = game[ "teamScores" ][ team ]; + bbprint( "mpteamobjscores", "gametime %d team %d diff %d score %d", getTime(), team, newscore - teamscore, newscore ); + if ( teamscore == newscore ) + { + return; + } + updateteamscores( team ); +} + +postprocessteamscores( teams ) +{ + _a660 = teams; + _k660 = getFirstArrayKey( _a660 ); + while ( isDefined( _k660 ) ) + { + team = _a660[ _k660 ]; + onteamscore_postprocess( team ); + _k660 = getNextArrayKey( _a660, _k660 ); + } + thread maps/mp/gametypes/_globallogic::checkscorelimit(); } giveteamscoreforobjective( team, score ) { + if ( !isDefined( level.teams[ team ] ) ) + { + return; + } teamscore = game[ "teamScores" ][ team ]; onteamscore( score, team ); newscore = game[ "teamScores" ][ team ]; @@ -263,7 +698,7 @@ giveteamscoreforobjective( team, score ) return; } updateteamscores( team ); - thread maps/mp/gametypes_zm/_globallogic::checkscorelimit(); + thread maps/mp/gametypes/_globallogic::checkscorelimit(); } _setteamscore( team, teamscore ) @@ -272,25 +707,25 @@ _setteamscore( team, teamscore ) { return; } - game[ "teamScores" ][ team ] = teamscore; + game[ "teamScores" ][ team ] = clamp( teamscore, 0, 1000000 ); updateteamscores( team ); - thread maps/mp/gametypes_zm/_globallogic::checkscorelimit(); + thread maps/mp/gametypes/_globallogic::checkscorelimit(); } resetteamscores() { while ( isDefined( level.roundscorecarry ) || level.roundscorecarry == 0 && maps/mp/_utility::isfirstround() ) { - _a591 = level.teams; - _k591 = getFirstArrayKey( _a591 ); - while ( isDefined( _k591 ) ) + _a705 = level.teams; + _k705 = getFirstArrayKey( _a705 ); + while ( isDefined( _k705 ) ) { - team = _a591[ _k591 ]; + team = _a705[ _k705 ]; game[ "teamScores" ][ team ] = 0; - _k591 = getNextArrayKey( _a591, _k591 ); + _k705 = getNextArrayKey( _a705, _k705 ); } } - maps/mp/gametypes_zm/_globallogic_score::updateallteamscores(); + maps/mp/gametypes/_globallogic_score::updateallteamscores(); } resetallscores() @@ -318,18 +753,18 @@ resetplayerscores() updateteamscores( team ) { setteamscore( team, game[ "teamScores" ][ team ] ); - level thread maps/mp/gametypes_zm/_globallogic::checkteamscorelimitsoon( team ); + level thread maps/mp/gametypes/_globallogic::checkteamscorelimitsoon( team ); } updateallteamscores() { - _a629 = level.teams; - _k629 = getFirstArrayKey( _a629 ); - while ( isDefined( _k629 ) ) + _a743 = level.teams; + _k743 = getFirstArrayKey( _a743 ); + while ( isDefined( _k743 ) ) { - team = _a629[ _k629 ]; + team = _a743[ _k743 ]; updateteamscores( team ); - _k629 = getNextArrayKey( _a629, _k629 ); + _k743 = getNextArrayKey( _a743, _k743 ); } } @@ -342,11 +777,11 @@ gethighestteamscoreteam() { score = 0; winning_teams = []; - _a645 = level.teams; - _k645 = getFirstArrayKey( _a645 ); - while ( isDefined( _k645 ) ) + _a759 = level.teams; + _k759 = getFirstArrayKey( _a759 ); + while ( isDefined( _k759 ) ) { - team = _a645[ _k645 ]; + team = _a759[ _k759 ]; team_score = game[ "teamScores" ][ team ]; if ( team_score > score ) { @@ -357,7 +792,7 @@ gethighestteamscoreteam() { winning_teams[ team ] = team; } - _k645 = getNextArrayKey( _a645, _k645 ); + _k759 = getNextArrayKey( _a759, _k759 ); } return winning_teams; } @@ -368,27 +803,41 @@ areteamarraysequal( teamsa, teamsb ) { return 0; } - _a668 = teamsa; - _k668 = getFirstArrayKey( _a668 ); - while ( isDefined( _k668 ) ) + _a782 = teamsa; + _k782 = getFirstArrayKey( _a782 ); + while ( isDefined( _k782 ) ) { - team = _a668[ _k668 ]; + team = _a782[ _k782 ]; if ( !isDefined( teamsb[ team ] ) ) { return 0; } - _k668 = getNextArrayKey( _a668, _k668 ); + _k782 = getNextArrayKey( _a782, _k782 ); } return 1; } onteamscore( score, team ) +{ + onteamscore_incrementscore( score, team ); + onteamscore_postprocess( team ); +} + +onteamscore_incrementscore( score, team ) { game[ "teamScores" ][ team ] += score; + if ( game[ "teamScores" ][ team ] < 0 ) + { + game[ "teamScores" ][ team ] = 0; + } if ( level.scorelimit && game[ "teamScores" ][ team ] > level.scorelimit ) { game[ "teamScores" ][ team ] = level.scorelimit; } +} + +onteamscore_postprocess( team ) +{ if ( level.splitscreen ) { return; @@ -410,14 +859,14 @@ onteamscore( score, team ) { return; } - level.laststatustime = getTime(); - while ( iswinning.size == 1 ) + if ( iswinning.size == 1 ) { - _a707 = iswinning; - _k707 = getFirstArrayKey( _a707 ); - while ( isDefined( _k707 ) ) + level.laststatustime = getTime(); + _a835 = iswinning; + _k835 = getFirstArrayKey( _a835 ); + while ( isDefined( _k835 ) ) { - team = _a707[ _k707 ]; + team = _a835[ _k835 ]; if ( isDefined( level.waswinning[ team ] ) ) { if ( level.waswinning.size == 1 ) @@ -426,18 +875,19 @@ onteamscore( score, team ) } else { - maps/mp/gametypes_zm/_globallogic_audio::leaderdialog( "lead_taken", team, "status" ); + maps/mp/gametypes/_globallogic_audio::leaderdialog( "lead_taken", team, "status" ); } - _k707 = getNextArrayKey( _a707, _k707 ); + _k835 = getNextArrayKey( _a835, _k835 ); } } + else return; while ( level.waswinning.size == 1 ) { - _a726 = level.waswinning; - _k726 = getFirstArrayKey( _a726 ); - while ( isDefined( _k726 ) ) + _a858 = level.waswinning; + _k858 = getFirstArrayKey( _a858 ); + while ( isDefined( _k858 ) ) { - team = _a726[ _k726 ]; + team = _a858[ _k858 ]; if ( isDefined( iswinning[ team ] ) ) { if ( iswinning.size == 1 ) @@ -449,9 +899,9 @@ onteamscore( score, team ) } else { - maps/mp/gametypes_zm/_globallogic_audio::leaderdialog( "lead_lost", team, "status" ); + maps/mp/gametypes/_globallogic_audio::leaderdialog( "lead_lost", team, "status" ); } - _k726 = getNextArrayKey( _a726, _k726 ); + _k858 = getNextArrayKey( _a858, _k858 ); } } level.waswinning = iswinning; @@ -459,9 +909,14 @@ onteamscore( score, team ) default_onteamscore( event, team ) { + score = maps/mp/gametypes/_rank::getscoreinfovalue( event ); +/# + assert( isDefined( score ) ); +#/ + onteamscore( score, team ); } -initpersstat( dataname, record_stats, init_to_stat_value ) +initpersstat( dataname, record_stats ) { if ( !isDefined( self.pers[ dataname ] ) ) { @@ -471,10 +926,6 @@ initpersstat( dataname, record_stats, init_to_stat_value ) { recordplayerstats( self, dataname, int( self.pers[ dataname ] ) ); } - if ( isDefined( init_to_stat_value ) && init_to_stat_value == 1 ) - { - self.pers[ dataname ] = self getdstat( "PlayerStatsList", dataname, "StatValue" ); - } } getpersstat( dataname ) @@ -510,6 +961,36 @@ threadedrecordplayerstats( dataname ) updatewinstats( winner ) { + winner addplayerstatwithgametype( "losses", -1 ); + winner addplayerstatwithgametype( "wins", 1 ); + if ( level.hardcoremode ) + { + winner addplayerstat( "wins_HC", 1 ); + } + if ( level.multiteam ) + { + winner addplayerstat( "wins_MULTITEAM", 1 ); + } + winner updatestatratio( "wlratio", "wins", "losses" ); + restorewinstreaks( winner ); + winner addplayerstatwithgametype( "cur_win_streak", 1 ); + winner notify( "win" ); + cur_gamemode_win_streak = winner maps/mp/gametypes/_persistence::statgetwithgametype( "cur_win_streak" ); + gamemode_win_streak = winner maps/mp/gametypes/_persistence::statgetwithgametype( "win_streak" ); + cur_win_streak = winner getdstat( "playerstatslist", "cur_win_streak", "StatValue" ); + if ( !level.disablestattracking && cur_win_streak > winner getdstat( "HighestStats", "win_streak" ) ) + { + winner setdstat( "HighestStats", "win_streak", cur_win_streak ); + } + if ( cur_gamemode_win_streak > gamemode_win_streak ) + { + winner maps/mp/gametypes/_persistence::statsetwithgametype( "win_streak", cur_gamemode_win_streak ); + } + if ( maps/mp/bots/_bot::is_bot_ranked_match() ) + { + combattrainingwins = winner getdstat( "combatTrainingWins" ); + winner setdstat( "combatTrainingWins", combattrainingwins + 1 ); + } } updatelossstats( loser ) @@ -524,7 +1005,10 @@ updatetiestats( loser ) loser addplayerstatwithgametype( "losses", -1 ); loser addplayerstatwithgametype( "ties", 1 ); loser updatestatratio( "wlratio", "wins", "losses" ); - loser setdstat( "playerstatslist", "cur_win_streak", "StatValue", 0 ); + if ( !level.disablestattracking ) + { + loser setdstat( "playerstatslist", "cur_win_streak", "StatValue", 0 ); + } loser notify( "tie" ); } @@ -564,52 +1048,76 @@ updatewinlossstats( winner ) return; } updatewinstats( winner ); - } - else - { - i = 0; - while ( i < players.size ) + while ( !level.teambased ) { - if ( !isDefined( players[ i ].pers[ "team" ] ) ) + placement = level.placement[ "all" ]; + topthreeplayers = min( 3, placement.size ); + index = 1; + while ( index < topthreeplayers ) { + nexttopplayer = placement[ index ]; + updatewinstats( nexttopplayer ); + index++; + } + } + } + else i = 0; + while ( i < players.size ) + { + if ( !isDefined( players[ i ].pers[ "team" ] ) ) + { + i++; + continue; + } + else if ( level.hostforcedend && players[ i ] ishost() ) + { + i++; + continue; + } + else + { + if ( winner == "tie" ) + { + updatetiestats( players[ i ] ); i++; continue; } - else if ( level.hostforcedend && players[ i ] ishost() ) + else if ( players[ i ].pers[ "team" ] == winner ) { + updatewinstats( players[ i ] ); i++; continue; } else { - if ( winner == "tie" ) - { - updatetiestats( players[ i ] ); - i++; - continue; - } - else if ( players[ i ].pers[ "team" ] == winner ) - { - updatewinstats( players[ i ] ); - i++; - continue; - } - else + if ( !level.disablestattracking ) { players[ i ] setdstat( "playerstatslist", "cur_win_streak", "StatValue", 0 ); } } - i++; } + i++; } } backupandclearwinstreaks() { + self.pers[ "winStreak" ] = self getdstat( "playerstatslist", "cur_win_streak", "StatValue" ); + if ( !level.disablestattracking ) + { + self setdstat( "playerstatslist", "cur_win_streak", "StatValue", 0 ); + } + self.pers[ "winStreakForGametype" ] = maps/mp/gametypes/_persistence::statgetwithgametype( "cur_win_streak" ); + self maps/mp/gametypes/_persistence::statsetwithgametype( "cur_win_streak", 0 ); } restorewinstreaks( winner ) { + if ( !level.disablestattracking ) + { + winner setdstat( "playerstatslist", "cur_win_streak", "StatValue", winner.pers[ "winStreak" ] ); + } + winner maps/mp/gametypes/_persistence::statsetwithgametype( "cur_win_streak", winner.pers[ "winStreakForGametype" ] ); } inckillstreaktracker( sweapon ) @@ -667,6 +1175,25 @@ trackattackerkill( name, rank, xp, prestige, xuid ) attacker.pers[ "nemesis_xp" ] = xp; } } + if ( !isDefined( attacker.lastkilledvictim ) || !isDefined( attacker.lastkilledvictimcount ) ) + { + attacker.lastkilledvictim = name; + attacker.lastkilledvictimcount = 0; + } + if ( attacker.lastkilledvictim == name ) + { + attacker.lastkilledvictimcount++; + if ( attacker.lastkilledvictimcount >= 5 ) + { + attacker.lastkilledvictimcount = 0; + attacker addplayerstat( "streaker", 1 ); + } + } + else + { + attacker.lastkilledvictim = name; + attacker.lastkilledvictimcount = 1; + } pixendevent(); } @@ -729,15 +1256,18 @@ givekillstats( smeansofdeath, sweapon, evictim ) return; } pixbeginevent( "giveKillStats" ); - self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "kills", 1, 1, 1 ); - self.kills = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "kills" ); + self maps/mp/gametypes/_globallogic_score::incpersstat( "kills", 1, 1, 1 ); + self.kills = self maps/mp/gametypes/_globallogic_score::getpersstat( "kills" ); self updatestatratio( "kdratio", "kills", "deaths" ); attacker = self; - if ( smeansofdeath == "MOD_HEAD_SHOT" ) + if ( smeansofdeath == "MOD_HEAD_SHOT" && !maps/mp/killstreaks/_killstreaks::iskillstreakweapon( sweapon ) ) { attacker thread incpersstat( "headshots", 1, 1, 0 ); attacker.headshots = attacker.pers[ "headshots" ]; - evictim recordkillmodifier( "headshot" ); + if ( isDefined( evictim ) ) + { + evictim recordkillmodifier( "headshot" ); + } } pixendevent(); } @@ -796,7 +1326,7 @@ processshieldassist( killedplayer ) self endon( "disconnect" ); killedplayer endon( "disconnect" ); wait 0,05; - maps/mp/gametypes_zm/_globallogic_utils::waittillslowprocessallowed(); + maps/mp/gametypes/_globallogic_utils::waittillslowprocessallowed(); if ( !isDefined( level.teams[ self.pers[ "team" ] ] ) ) { return; @@ -809,8 +1339,9 @@ processshieldassist( killedplayer ) { return; } - self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "assists", 1, 1, 1 ); - self.assists = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "assists" ); + self maps/mp/gametypes/_globallogic_score::incpersstat( "assists", 1, 1, 1 ); + self.assists = self maps/mp/gametypes/_globallogic_score::getpersstat( "assists" ); + maps/mp/_scoreevents::processscoreevent( "shield_assist", self, killedplayer, "riotshield_mp" ); } processassist( killedplayer, damagedone, weapon ) @@ -818,7 +1349,7 @@ processassist( killedplayer, damagedone, weapon ) self endon( "disconnect" ); killedplayer endon( "disconnect" ); wait 0,05; - maps/mp/gametypes_zm/_globallogic_utils::waittillslowprocessallowed(); + maps/mp/gametypes/_globallogic_utils::waittillslowprocessallowed(); if ( !isDefined( level.teams[ self.pers[ "team" ] ] ) ) { return; @@ -845,8 +1376,12 @@ processassist( killedplayer, damagedone, weapon ) } } assist_level = ( assist_level + "_" ) + ( assist_level_value * 25 ); - self maps/mp/gametypes_zm/_globallogic_score::incpersstat( "assists", 1, 1, 1 ); - self.assists = self maps/mp/gametypes_zm/_globallogic_score::getpersstat( "assists" ); + self maps/mp/gametypes/_globallogic_score::incpersstat( "assists", 1, 1, 1 ); + self.assists = self maps/mp/gametypes/_globallogic_score::getpersstat( "assists" ); + if ( isDefined( weapon ) ) + { + self addweaponstat( weapon, "assists", 1 ); + } switch( weapon ) { case "concussion_grenade_mp": @@ -864,10 +1399,148 @@ processassist( killedplayer, damagedone, weapon ) break; } self maps/mp/_challenges::assisted(); + maps/mp/_scoreevents::processscoreevent( assist_level, self, killedplayer, weapon ); +} + +processkillstreakassists( attacker, inflictor, weaponname ) +{ + if ( isDefined( attacker ) || !isDefined( attacker.team ) && self isenemyplayer( attacker ) == 0 ) + { + return; + } + if ( self == attacker || attacker.classname == "trigger_hurt" && attacker.classname == "worldspawn" ) + { + return; + } + enemycuavactive = 0; + while ( attacker hasperk( "specialty_immunecounteruav" ) == 0 ) + { + _a1403 = level.teams; + _k1403 = getFirstArrayKey( _a1403 ); + while ( isDefined( _k1403 ) ) + { + team = _a1403[ _k1403 ]; + if ( team == attacker.team ) + { + } + else + { + if ( level.activecounteruavs[ team ] > 0 ) + { + enemycuavactive = 1; + } + } + _k1403 = getNextArrayKey( _a1403, _k1403 ); + } + } + _a1417 = level.players; + _k1417 = getFirstArrayKey( _a1417 ); + while ( isDefined( _k1417 ) ) + { + player = _a1417[ _k1417 ]; + if ( player.team != attacker.team ) + { + } + else if ( player.team == "spectator" ) + { + } + else if ( player == attacker ) + { + } + else if ( player.sessionstate != "playing" ) + { + } + else + { +/# + assert( isDefined( player.activecounteruavs ) ); +#/ +/# + assert( isDefined( player.activeuavs ) ); +#/ +/# + assert( isDefined( player.activesatellites ) ); +#/ + if ( player.activecounteruavs > 0 && !maps/mp/killstreaks/_killstreaks::iskillstreakweapon( weaponname ) ) + { + scoregiven = thread maps/mp/_scoreevents::processscoreevent( "counter_uav_assist", player ); + if ( isDefined( scoregiven ) ) + { + player maps/mp/_challenges::earnedcuavassistscore( scoregiven ); + } + } + if ( enemycuavactive == 0 ) + { + if ( player.activeuavs > 0 && !maps/mp/killstreaks/_killstreaks::iskillstreakweapon( weaponname ) ) + { + scoregiven = thread maps/mp/_scoreevents::processscoreevent( "uav_assist", player ); + if ( isDefined( scoregiven ) ) + { + player maps/mp/_challenges::earneduavassistscore( scoregiven ); + } + } + if ( player.activesatellites > 0 && !maps/mp/killstreaks/_killstreaks::iskillstreakweapon( weaponname ) ) + { + scoregiven = thread maps/mp/_scoreevents::processscoreevent( "satellite_assist", player ); + if ( isDefined( scoregiven ) ) + { + player maps/mp/_challenges::earnedsatelliteassistscore( scoregiven ); + } + } + } + } + _k1417 = getNextArrayKey( _a1417, _k1417 ); + } + _a1466 = level.teams; + _k1466 = getFirstArrayKey( _a1466 ); + while ( isDefined( _k1466 ) ) + { + assistteam = _a1466[ _k1466 ]; + if ( assistteam == self.team ) + { + } + else if ( attacker.team != assistteam ) + { + } + else + { + activeempowner = level.empowners[ assistteam ]; + if ( isDefined( activeempowner ) && isplayer( activeempowner ) ) + { + if ( isDefined( attacker ) && activeempowner != attacker ) + { + if ( isDefined( activeempowner.emptime ) && activeempowner.spawntime < activeempowner.emptime ) + { + scoregiven = maps/mp/_scoreevents::processscoreevent( "emp_assist", activeempowner ); + if ( isDefined( scoregiven ) ) + { + activeempowner maps/mp/_challenges::earnedempassistscore( scoregiven ); + } + } + } + } + } + _k1466 = getNextArrayKey( _a1466, _k1466 ); + } } xpratethread() { /# + self endon( "death" ); + self endon( "disconnect" ); + level endon( "game_ended" ); + while ( level.inprematchperiod ) + { + wait 0,05; + } + for ( ;; ) + { + wait 5; + if ( isDefined( level.teams[ level.players[ 0 ].pers[ "team" ] ] ) ) + { + self maps/mp/gametypes/_rank::giverankxp( "kill", int( min( getDvarInt( #"F8D00F60" ), 50 ) ) ); + } #/ + } } diff --git a/patch_mp/maps/mp/gametypes/_globallogic_spawn.gsc b/patch_mp/maps/mp/gametypes/_globallogic_spawn.gsc index fd882a8..f7332dc 100644 --- a/patch_mp/maps/mp/gametypes/_globallogic_spawn.gsc +++ b/patch_mp/maps/mp/gametypes/_globallogic_spawn.gsc @@ -1,17 +1,21 @@ -#include maps/mp/gametypes_zm/_spawnlogic; -#include maps/mp/gametypes_zm/_globallogic_defaults; -#include maps/mp/gametypes_zm/_hostmigration; -#include maps/mp/gametypes_zm/_spectating; -#include maps/mp/zombies/_zm_perks; -#include maps/mp/gametypes_zm/_globallogic_score; -#include maps/mp/gametypes_zm/_globallogic_ui; -#include maps/mp/gametypes_zm/_hud_util; -#include maps/mp/gametypes_zm/_hud_message; -#include maps/mp/gametypes_zm/_globallogic; -#include maps/mp/gametypes_zm/_globallogic_utils; -#include maps/mp/gametypes_zm/_globallogic_audio; -#include maps/mp/gametypes_zm/_spawning; -#include maps/mp/gametypes_zm/_globallogic_player; +#include maps/mp/gametypes/_spawnlogic; +#include maps/mp/gametypes/_globallogic_defaults; +#include maps/mp/gametypes/_hostmigration; +#include maps/mp/gametypes/_spectating; +#include maps/mp/_vehicles; +#include maps/mp/killstreaks/_killstreaks; +#include maps/mp/bots/_bot; +#include maps/mp/gametypes/_globallogic_ui; +#include maps/mp/gametypes/_hud_util; +#include maps/mp/gametypes/_class; +#include maps/mp/gametypes/_globallogic; +#include maps/mp/gametypes/_globallogic_utils; +#include maps/mp/gametypes/_globallogic_score; +#include maps/mp/gametypes/_globallogic_audio; +#include maps/mp/gametypes/_persistence; +#include maps/mp/gametypes/_hud_message; +#include maps/mp/gametypes/_spawning; +#include maps/mp/gametypes/_globallogic_player; #include maps/mp/_utility; #include common_scripts/utility; @@ -33,9 +37,17 @@ timeuntilspawn( includeteamkilldelay ) { respawndelay = level.playerrespawndelay; } - if ( includeteamkilldelay && isDefined( self.teamkillpunish ) && self.teamkillpunish ) + if ( self.suicide && level.suicidespawndelay > 0 ) { - respawndelay += maps/mp/gametypes_zm/_globallogic_player::teamkilldelay(); + respawndelay += level.suicidespawndelay; + } + if ( self.teamkilled && level.teamkilledspawndelay > 0 ) + { + respawndelay += level.teamkilledspawndelay; + } + if ( includeteamkilldelay && is_true( self.teamkillpunish ) ) + { + respawndelay += maps/mp/gametypes/_globallogic_player::teamkilldelay(); } } wavebased = level.waverespawndelay > 0; @@ -48,16 +60,16 @@ timeuntilspawn( includeteamkilldelay ) allteamshaveexisted() { - _a34 = level.teams; - _k34 = getFirstArrayKey( _a34 ); - while ( isDefined( _k34 ) ) + _a42 = level.teams; + _k42 = getFirstArrayKey( _a42 ); + while ( isDefined( _k42 ) ) { - team = _a34[ _k34 ]; + team = _a42[ _k42 ]; if ( !level.everexisted[ team ] ) { return 0; } - _k34 = getNextArrayKey( _a34, _k34 ); + _k42 = getNextArrayKey( _a42, _k42 ); } return 1; } @@ -92,7 +104,7 @@ mayspawn() } } } - if ( !self.pers[ "lives" ] && gamehasstarted ) + if ( !self.pers[ "lives" ] ) { return 0; } @@ -150,7 +162,7 @@ spawnplayerprediction() wait 0,5; if ( isDefined( level.onspawnplayerunified ) && getDvarInt( #"CF6EEB8B" ) == 0 ) { - maps/mp/gametypes_zm/_spawning::onspawnplayer_unified( 1 ); + maps/mp/gametypes/_spawning::onspawnplayer_unified( 1 ); continue; } else @@ -160,18 +172,46 @@ spawnplayerprediction() } } -giveloadoutlevelspecific( team, class ) +doinitialspawnmessaging() { - pixbeginevent( "giveLoadoutLevelSpecific" ); - if ( isDefined( level.givecustomcharacters ) ) + self endon( "disconnect" ); + if ( isDefined( level.disableprematchmessages ) && level.disableprematchmessages ) { - self [[ level.givecustomcharacters ]](); + return; } - if ( isDefined( level.givecustomloadout ) ) + team = self.pers[ "team" ]; + thread maps/mp/gametypes/_hud_message::showinitialfactionpopup( team ); + if ( isDefined( game[ "dialog" ][ "gametype" ] ) || !level.splitscreen && self == level.players[ 0 ] ) { - self [[ level.givecustomloadout ]](); + if ( !isDefined( level.infinalfight ) || !level.infinalfight ) + { + if ( level.hardcoremode && maps/mp/gametypes/_persistence::ispartygamemode() == 0 ) + { + self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "gametype_hardcore" ); + } + else + { + self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "gametype" ); + } + } + } + while ( level.inprematchperiod ) + { + wait 0,05; + } + hintmessage = getobjectivehinttext( team ); + if ( isDefined( hintmessage ) ) + { + self thread maps/mp/gametypes/_hud_message::hintmessage( hintmessage ); + } + if ( team == game[ "attackers" ] ) + { + self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "offense_obj", "introboost" ); + } + else + { + self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "defense_obj", "introboost" ); } - pixendevent(); } spawnplayer() @@ -186,7 +226,11 @@ spawnplayer() if ( !self.hasspawned ) { self.underscorechance = 70; - self thread maps/mp/gametypes_zm/_globallogic_audio::sndstartmusicsystem(); + self thread maps/mp/gametypes/_globallogic_audio::sndstartmusicsystem(); + } + if ( isDefined( self.pers[ "resetMomentumOnSpawn" ] ) && self.pers[ "resetMomentumOnSpawn" ] ) + { + self maps/mp/gametypes/_globallogic_score::resetplayermomentumonspawn(); } if ( level.teambased ) { @@ -238,11 +282,11 @@ spawnplayer() self.deathmachinekills = 0; self.disabledweapon = 0; self resetusability(); - self maps/mp/gametypes_zm/_globallogic_player::resetattackerlist(); + self maps/mp/gametypes/_globallogic_player::resetattackerlist(); self.diedonvehicle = undefined; if ( !self.wasaliveatmatchstart ) { - if ( level.ingraceperiod || maps/mp/gametypes_zm/_globallogic_utils::gettimepassed() < 20000 ) + if ( level.ingraceperiod || maps/mp/gametypes/_globallogic_utils::gettimepassed() < 20000 ) { self.wasaliveatmatchstart = 1; } @@ -264,14 +308,23 @@ spawnplayer() } pixendevent(); pixendevent(); - level thread maps/mp/gametypes_zm/_globallogic::updateteamstatus(); + level thread maps/mp/gametypes/_globallogic::updateteamstatus(); pixbeginevent( "spawnPlayer_postUTS" ); self thread stoppoisoningandflareonspawn(); + self.sensorgrenadedata = undefined; self stopburning(); /# - assert( maps/mp/gametypes_zm/_globallogic_utils::isvalidclass( self.class ) ); + assert( maps/mp/gametypes/_globallogic_utils::isvalidclass( self.class ) ); #/ - self giveloadoutlevelspecific( self.team, self.class ); + if ( sessionmodeiszombiesgame() ) + { + self maps/mp/gametypes/_class::giveloadoutlevelspecific( self.team, self.class ); + } + else + { + self maps/mp/gametypes/_class::setclass( self.class ); + self maps/mp/gametypes/_class::giveloadout( self.team, self.class ); + } if ( level.inprematchperiod ) { self freeze_player_controls( 1 ); @@ -286,7 +339,7 @@ spawnplayer() { music = game[ "music" ][ "spawn_" + team ]; } - self thread maps/mp/gametypes_zm/_globallogic_audio::set_music_on_player( music, 0, 0 ); + self thread maps/mp/gametypes/_globallogic_audio::set_music_on_player( music, 0, 0 ); self.pers[ "music" ].spawn = 1; } if ( level.splitscreen ) @@ -300,37 +353,7 @@ spawnplayer() level.playedstartingmusic = 1; } } - if ( !isDefined( level.disableprematchmessages ) || level.disableprematchmessages == 0 ) - { - thread maps/mp/gametypes_zm/_hud_message::showinitialfactionpopup( team ); - hintmessage = getobjectivehinttext( self.pers[ "team" ] ); - if ( isDefined( hintmessage ) ) - { - self thread maps/mp/gametypes_zm/_hud_message::hintmessage( hintmessage ); - } - if ( isDefined( game[ "dialog" ][ "gametype" ] ) || !level.splitscreen && self == level.players[ 0 ] ) - { - if ( !isDefined( level.infinalfight ) || !level.infinalfight ) - { - if ( level.hardcoremode ) - { - self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "gametype_hardcore" ); - } - else - { - self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "gametype" ); - } - } - } - if ( team == game[ "attackers" ] ) - { - self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "offense_obj", "introboost" ); - } - else - { - self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "defense_obj", "introboost" ); - } - } + self thread doinitialspawnmessaging(); } else { @@ -342,7 +365,8 @@ spawnplayer() team = self.team; if ( isDefined( self.pers[ "music" ].spawn ) && self.pers[ "music" ].spawn == 0 ) { - self thread maps/mp/gametypes_zm/_globallogic_audio::set_music_on_player( "SPAWN_SHORT", 0, 0 ); + music = game[ "music" ][ "spawn_short" + team ]; + self thread maps/mp/gametypes/_globallogic_audio::set_music_on_player( music, 0, 0 ); self.pers[ "music" ].spawn = 1; } if ( level.splitscreen ) @@ -356,37 +380,7 @@ spawnplayer() level.playedstartingmusic = 1; } } - if ( !isDefined( level.disableprematchmessages ) || level.disableprematchmessages == 0 ) - { - thread maps/mp/gametypes_zm/_hud_message::showinitialfactionpopup( team ); - hintmessage = getobjectivehinttext( self.pers[ "team" ] ); - if ( isDefined( hintmessage ) ) - { - self thread maps/mp/gametypes_zm/_hud_message::hintmessage( hintmessage ); - } - if ( isDefined( game[ "dialog" ][ "gametype" ] ) || !level.splitscreen && self == level.players[ 0 ] ) - { - if ( !isDefined( level.infinalfight ) || !level.infinalfight ) - { - if ( level.hardcoremode ) - { - self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "gametype_hardcore" ); - } - else - { - self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "gametype" ); - } - } - } - if ( team == game[ "attackers" ] ) - { - self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "offense_obj", "introboost" ); - } - else - { - self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "defense_obj", "introboost" ); - } - } + self thread doinitialspawnmessaging(); pixendevent(); } } @@ -398,15 +392,15 @@ spawnplayer() { setdvar( "scr_showperksonspawn", "0" ); } - if ( !level.splitscreen && getDvarInt( "scr_showperksonspawn" ) == 1 && game[ "state" ] != "postgame" ) + if ( getDvarInt( "scr_showperksonspawn" ) == 1 && game[ "state" ] != "postgame" ) { pixbeginevent( "showperksonspawn" ); if ( level.perksenabled == 1 ) { - self maps/mp/gametypes_zm/_hud_util::showperks(); + self maps/mp/gametypes/_hud_util::showperks(); } - self thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutaftertime( 3 ); - self thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutondeath(); + self thread maps/mp/gametypes/_globallogic_ui::hideloadoutaftertime( 3 ); + self thread maps/mp/gametypes/_globallogic_ui::hideloadoutondeath(); pixendevent(); } if ( isDefined( self.pers[ "momentum" ] ) ) @@ -418,19 +412,30 @@ spawnplayer() self notify( "spawned_player" ); self logstring( "S " + self.origin[ 0 ] + " " + self.origin[ 1 ] + " " + self.origin[ 2 ] ); setdvar( "scr_selecting_location", "" ); + if ( self is_bot() ) + { + pixbeginevent( "bot" ); + self thread maps/mp/bots/_bot::bot_spawn(); + pixendevent(); + } + if ( !sessionmodeiszombiesgame() ) + { + self thread maps/mp/killstreaks/_killstreaks::killstreakwaiter(); + self thread maps/mp/_vehicles::vehicledeathwaiter(); + self thread maps/mp/_vehicles::turretdeathwaiter(); + } /# if ( getDvarInt( #"F8D00F60" ) > 0 ) { - self thread maps/mp/gametypes_zm/_globallogic_score::xpratethread(); + self thread maps/mp/gametypes/_globallogic_score::xpratethread(); #/ } - self maps/mp/zombies/_zm_perks::perk_set_max_health_if_jugg( "health_reboot", 1, 0 ); if ( game[ "state" ] == "postgame" ) { /# assert( !level.intermission ); #/ - self maps/mp/gametypes_zm/_globallogic_player::freezeplayerforroundend(); + self maps/mp/gametypes/_globallogic_player::freezeplayerforroundend(); } } @@ -468,13 +473,13 @@ in_spawnspectator( origin, angles ) { self.statusicon = "hud_status_dead"; } - maps/mp/gametypes_zm/_spectating::setspectatepermissionsformachine(); + maps/mp/gametypes/_spectating::setspectatepermissionsformachine(); [[ level.onspawnspectator ]]( origin, angles ); if ( level.teambased && !level.splitscreen ) { self thread spectatorthirdpersonness(); } - level thread maps/mp/gametypes_zm/_globallogic::updateteamstatus(); + level thread maps/mp/gametypes/_globallogic::updateteamstatus(); pixmarker( "END: in_spawnSpectator" ); } @@ -505,12 +510,12 @@ forcespawn( time ) { return; } - if ( !maps/mp/gametypes_zm/_globallogic_utils::isvalidclass( self.pers[ "class" ] ) ) + if ( !maps/mp/gametypes/_globallogic_utils::isvalidclass( self.pers[ "class" ] ) ) { self.pers[ "class" ] = "CLASS_CUSTOM1"; self.class = self.pers[ "class" ]; } - self maps/mp/gametypes_zm/_globallogic_ui::closemenus(); + self maps/mp/gametypes/_globallogic_ui::closemenus(); self thread [[ level.spawnclient ]](); } @@ -563,13 +568,18 @@ kickifidontspawninternal() { return; } + if ( !mayspawn() ) + { + return; + } + maps/mp/gametypes/_globallogic::gamehistoryplayerkicked(); kick( self getentitynumber() ); } kickwait( waittime ) { level endon( "game_ended" ); - maps/mp/gametypes_zm/_hostmigration::waitlongdurationwithhostmigrationpause( waittime ); + maps/mp/gametypes/_hostmigration::waitlongdurationwithhostmigrationpause( waittime ); } spawninterroundintermission() @@ -585,7 +595,7 @@ spawninterroundintermission() self.archivetime = 0; self.psoffsettime = 0; self.friendlydamage = undefined; - self maps/mp/gametypes_zm/_globallogic_defaults::default_onspawnintermission(); + self maps/mp/gametypes/_globallogic_defaults::default_onspawnintermission(); self setorigin( self.origin ); self setplayerangles( self.angles ); self setdepthoffield( 0, 128, 512, 4000, 6, 1,8 ); @@ -599,37 +609,6 @@ spawnintermission( usedefaultcallback ) self setspawnvariables(); self clearlowermessage(); self freeze_player_controls( 0 ); - if ( level.rankedmatch && waslastround() ) - { - if ( !self.postgamemilestones || self.postgamecontracts && self.postgamepromotion ) - { - if ( self.postgamepromotion ) - { - self playlocalsound( "mus_level_up" ); - } - else if ( self.postgamecontracts ) - { - self playlocalsound( "mus_challenge_complete" ); - } - else - { - if ( self.postgamemilestones ) - { - self playlocalsound( "mus_contract_complete" ); - } - } - self closeingamemenu(); - self openmenu( game[ "menu_endgameupdate" ] ); - waittime = 4; - while ( waittime ) - { - wait 0,25; - waittime -= 0,25; - self openmenu( game[ "menu_endgameupdate" ] ); - } - self closemenu(); - } - } self.sessionstate = "intermission"; self.spectatorclient = -1; self.killcamentity = -1; @@ -638,7 +617,7 @@ spawnintermission( usedefaultcallback ) self.friendlydamage = undefined; if ( isDefined( usedefaultcallback ) && usedefaultcallback ) { - maps/mp/gametypes_zm/_globallogic_defaults::default_onspawnintermission(); + maps/mp/gametypes/_globallogic_defaults::default_onspawnintermission(); } else { @@ -669,7 +648,7 @@ spawnqueuedclientonteam( team ) if ( isDefined( player_to_spawn ) ) { player_to_spawn.allowqueuespawn = 1; - player_to_spawn maps/mp/gametypes_zm/_globallogic_ui::closemenus(); + player_to_spawn maps/mp/gametypes/_globallogic_ui::closemenus(); player_to_spawn thread [[ level.spawnclient ]](); } } @@ -680,7 +659,7 @@ spawnqueuedclient( dead_player_team, killer ) { return; } - maps/mp/gametypes_zm/_globallogic_utils::waittillslowprocessallowed(); + maps/mp/gametypes/_globallogic_utils::waittillslowprocessallowed(); spawn_team = undefined; if ( isDefined( killer ) && isDefined( killer.team ) && isDefined( level.teams[ killer.team ] ) ) { @@ -691,11 +670,11 @@ spawnqueuedclient( dead_player_team, killer ) spawnqueuedclientonteam( spawn_team ); return; } - _a746 = level.teams; - _k746 = getFirstArrayKey( _a746 ); - while ( isDefined( _k746 ) ) + _a730 = level.teams; + _k730 = getFirstArrayKey( _a730 ); + while ( isDefined( _k730 ) ) { - team = _a746[ _k746 ]; + team = _a730[ _k730 ]; if ( team == dead_player_team ) { } @@ -703,7 +682,7 @@ spawnqueuedclient( dead_player_team, killer ) { spawnqueuedclientonteam( team ); } - _k746 = getNextArrayKey( _a746, _k746 ); + _k730 = getNextArrayKey( _a730, _k730 ); } } @@ -717,16 +696,16 @@ allteamsnearscorelimit() { return 0; } - _a763 = level.teams; - _k763 = getFirstArrayKey( _a763 ); - while ( isDefined( _k763 ) ) + _a747 = level.teams; + _k747 = getFirstArrayKey( _a747 ); + while ( isDefined( _k747 ) ) { - team = _a763[ _k763 ]; + team = _a747[ _k747 ]; if ( ( level.scorelimit - 1 ) < game[ "teamScores" ][ team ] ) { return 0; } - _k763 = getNextArrayKey( _a763, _k763 ); + _k747 = getNextArrayKey( _a747, _k747 ); } return 1; } @@ -755,7 +734,7 @@ shouldshowrespawnmessage() default_spawnmessage() { setlowermessage( game[ "strings" ][ "spawn_next_round" ] ); - self thread maps/mp/gametypes_zm/_globallogic_ui::removespawnmessageshortly( 3 ); + self thread maps/mp/gametypes/_globallogic_ui::removespawnmessageshortly( 3 ); } showspawnmessage() @@ -773,7 +752,7 @@ spawnclient( timealreadypassed ) assert( isDefined( self.team ) ); #/ /# - assert( maps/mp/gametypes_zm/_globallogic_utils::isvalidclass( self.class ) ); + assert( maps/mp/gametypes/_globallogic_utils::isvalidclass( self.class ) ); #/ if ( !self mayspawn() ) { @@ -809,9 +788,9 @@ waitandspawnclient( timealreadypassed ) timealreadypassed = 0; } spawnedasspectator = 0; - if ( isDefined( self.teamkillpunish ) && self.teamkillpunish ) + if ( is_true( self.teamkillpunish ) ) { - teamkilldelay = maps/mp/gametypes_zm/_globallogic_player::teamkilldelay(); + teamkilldelay = maps/mp/gametypes/_globallogic_player::teamkilldelay(); if ( teamkilldelay > timealreadypassed ) { teamkilldelay -= timealreadypassed; @@ -867,7 +846,7 @@ waitandspawnclient( timealreadypassed ) spawnangles = self.angles; if ( isDefined( level.useintermissionpointsonwavespawn ) && [[ level.useintermissionpointsonwavespawn ]]() == 1 ) { - spawnpoint = maps/mp/gametypes_zm/_spawnlogic::getrandomintermissionpoint(); + spawnpoint = maps/mp/gametypes/_spawnlogic::getrandomintermissionpoint(); if ( isDefined( spawnpoint ) ) { spawnorigin = spawnpoint.origin; @@ -877,9 +856,25 @@ waitandspawnclient( timealreadypassed ) self thread respawn_asspectator( spawnorigin, spawnangles ); } spawnedasspectator = 1; - self maps/mp/gametypes_zm/_globallogic_utils::waitfortimeornotify( timeuntilspawn, "force_spawn" ); + self maps/mp/gametypes/_globallogic_utils::waitfortimeornotify( timeuntilspawn, "force_spawn" ); self notify( "stop_wait_safe_spawn_button" ); } + if ( isDefined( level.gametypespawnwaiter ) ) + { + if ( !spawnedasspectator ) + { + self thread respawn_asspectator( self.origin + vectorScale( ( 0, 0, 1 ), 60 ), self.angles ); + } + spawnedasspectator = 1; + if ( !( self [[ level.gametypespawnwaiter ]]() ) ) + { + self.waitingtospawn = 0; + self clearlowermessage(); + self.wavespawnindex = undefined; + self.respawntimerstarttime = undefined; + return; + } + } wavebased = level.waverespawndelay > 0; if ( !level.playerforcerespawn && self.hasspawned && !wavebased && !self.wantsafespawn && !level.playerqueuedrespawn ) { diff --git a/patch_mp/maps/mp/gametypes/_globallogic_ui.gsc b/patch_mp/maps/mp/gametypes/_globallogic_ui.gsc index 00d91fe..2aff74d 100644 --- a/patch_mp/maps/mp/gametypes/_globallogic_ui.gsc +++ b/patch_mp/maps/mp/gametypes/_globallogic_ui.gsc @@ -1,7 +1,13 @@ -#include maps/mp/gametypes_zm/_globallogic_player; -#include maps/mp/gametypes_zm/_spectating; -#include maps/mp/gametypes_zm/_globallogic; -#include maps/mp/gametypes_zm/_hud_util; +#include maps/mp/gametypes/_class; +#include maps/mp/gametypes/_globallogic_player; +#include maps/mp/gametypes/_spectating; +#include maps/mp/gametypes/_globallogic; +#include maps/mp/gametypes/_pregame; +#include maps/mp/teams/_teams; +#include maps/mp/bots/_bot; +#include maps/mp/killstreaks/_killstreaks; +#include maps/mp/gametypes/_hud_util; +#include common_scripts/utility; #include maps/mp/_utility; init() @@ -21,10 +27,6 @@ init() precachestring( &"rank_up" ); precachestring( &"gun_level_complete" ); precachestring( &"challenge_complete" ); - if ( sessionmodeiszombiesgame() ) - { - precachestring( &"hud_update_survival_team" ); - } if ( level.splitscreen ) { precachestring( &"MP_ENDED_GAME" ); @@ -134,16 +136,17 @@ freegameplayhudelems() { self.carryicon destroyelem(); } + maps/mp/killstreaks/_killstreaks::destroykillstreaktimers(); } teamplayercountsequal( playercounts ) { count = undefined; - _a150 = level.teams; - _k150 = getFirstArrayKey( _a150 ); - while ( isDefined( _k150 ) ) + _a146 = level.teams; + _k146 = getFirstArrayKey( _a146 ); + while ( isDefined( _k146 ) ) { - team = _a150[ _k150 ]; + team = _a146[ _k146 ]; if ( !isDefined( count ) ) { count = playercounts[ team ]; @@ -155,7 +158,7 @@ teamplayercountsequal( playercounts ) return 0; } } - _k150 = getNextArrayKey( _a150, _k150 ); + _k146 = getNextArrayKey( _a146, _k146 ); } return 1; } @@ -164,17 +167,17 @@ teamwithlowestplayercount( playercounts, ignore_team ) { count = 9999; lowest_team = undefined; - _a169 = level.teams; - _k169 = getFirstArrayKey( _a169 ); - while ( isDefined( _k169 ) ) + _a165 = level.teams; + _k165 = getFirstArrayKey( _a165 ); + while ( isDefined( _k165 ) ) { - team = _a169[ _k169 ]; + team = _a165[ _k165 ]; if ( count > playercounts[ team ] ) { count = playercounts[ team ]; lowest_team = team; } - _k169 = getNextArrayKey( _a169, _k169 ); + _k165 = getNextArrayKey( _a165, _k165 ); } return lowest_team; } @@ -242,6 +245,45 @@ menuautoassign( comingfrommenu ) { assignment = "allies"; } + else if ( maps/mp/bots/_bot::is_bot_comp_stomp() ) + { + host = gethostplayerforbots(); +/# + assert( isDefined( host ) ); +#/ + if ( !isDefined( host.team ) || host.team == "spectator" ) + { + host.team = random( teamkeys ); + } + if ( !self is_bot() ) + { + assignment = host.team; + } + else + { + assignment = getotherteam( host.team ); + } + } + else playercounts = self maps/mp/teams/_teams::countplayers(); + if ( teamplayercountsequal( playercounts ) ) + { + if ( !level.splitscreen && self issplitscreen() ) + { + assignment = self getsplitscreenteam(); + if ( assignment == "" ) + { + assignment = pickteamfromscores( teamkeys ); + } + } + else + { + assignment = pickteamfromscores( teamkeys ); + } + } + else + { + assignment = teamwithlowestplayercount( playercounts, "none" ); + } } if ( assignment == self.pers[ "team" ] || self.sessionstate == "playing" && self.sessionstate == "dead" ) { @@ -296,6 +338,31 @@ menuautoassign( comingfrommenu ) self notify( "joined_team" ); level notify( "joined_team" ); self notify( "end_respawn" ); + if ( ispregame() ) + { + if ( !self is_bot() ) + { + pclass = self maps/mp/gametypes/_pregame::get_pregame_class(); + self closemenu(); + self closeingamemenu(); + self.selectedclass = 1; + self [[ level.class ]]( pclass ); + self setclientscriptmainmenu( game[ "menu_class" ] ); + return; + } + } + if ( ispregamegamestarted() ) + { + if ( self is_bot() && isDefined( self.pers[ "class" ] ) ) + { + pclass = self.pers[ "class" ]; + self closemenu(); + self closeingamemenu(); + self.selectedclass = 1; + self [[ level.class ]]( pclass ); + return; + } + } self beginclasschoice(); self setclientscriptmainmenu( game[ "menu_class" ] ); } @@ -303,11 +370,11 @@ menuautoassign( comingfrommenu ) teamscoresequal() { score = undefined; - _a413 = level.teams; - _k413 = getFirstArrayKey( _a413 ); - while ( isDefined( _k413 ) ) + _a397 = level.teams; + _k397 = getFirstArrayKey( _a397 ); + while ( isDefined( _k397 ) ) { - team = _a413[ _k413 ]; + team = _a397[ _k397 ]; if ( !isDefined( score ) ) { score = getteamscore( team ); @@ -319,7 +386,7 @@ teamscoresequal() return 0; } } - _k413 = getNextArrayKey( _a413, _k413 ); + _k397 = getNextArrayKey( _a397, _k397 ); } return 1; } @@ -328,16 +395,16 @@ teamwithlowestscore() { score = 99999999; lowest_team = undefined; - _a432 = level.teams; - _k432 = getFirstArrayKey( _a432 ); - while ( isDefined( _k432 ) ) + _a416 = level.teams; + _k416 = getFirstArrayKey( _a416 ); + while ( isDefined( _k416 ) ) { - team = _a432[ _k432 ]; + team = _a416[ _k416 ]; if ( score > getteamscore( team ) ) { lowest_team = team; } - _k432 = getNextArrayKey( _a432, _k432 ); + _k416 = getNextArrayKey( _a416, _k416 ); } return lowest_team; } @@ -418,7 +485,7 @@ beginclasschoice( forcenewchoice ) assert( isDefined( level.teams[ self.pers[ "team" ] ] ) ); #/ team = self.pers[ "team" ]; - if ( level.disablecac == 1 ) + if ( level.disableclassselection == 1 || getDvarInt( "migration_soak" ) == 1 ) { self.pers[ "class" ] = level.defaultclass; self.class = level.defaultclass; @@ -426,8 +493,8 @@ beginclasschoice( forcenewchoice ) { self thread [[ level.spawnclient ]](); } - level thread maps/mp/gametypes_zm/_globallogic::updateteamstatus(); - self thread maps/mp/gametypes_zm/_spectating::setspectatepermissionsformachine(); + level thread maps/mp/gametypes/_globallogic::updateteamstatus(); + self thread maps/mp/gametypes/_spectating::setspectatepermissionsformachine(); return; } if ( level.wagermatch ) @@ -484,6 +551,10 @@ menuteam( team ) self.team = team; self.class = undefined; self updateobjectivetext(); + if ( !level.rankedmatch && !level.leaguematch ) + { + self.sessionstate = "spectator"; + } if ( level.teambased ) { self.sessionteam = team; @@ -523,7 +594,7 @@ menuspectator() self.ffateam = "spectator"; } [[ level.spawnspectator ]](); - self thread maps/mp/gametypes_zm/_globallogic_player::spectate_player_watcher(); + self thread maps/mp/gametypes/_globallogic_player::spectate_player_watcher(); self setclientscriptmainmenu( game[ "menu_class" ] ); self notify( "joined_spectators" ); } @@ -532,6 +603,90 @@ menuspectator() menuclass( response ) { self closemenus(); + if ( !isDefined( self.pers[ "team" ] ) || !isDefined( level.teams[ self.pers[ "team" ] ] ) ) + { + return; + } + class = self maps/mp/gametypes/_class::getclasschoice( response ); + if ( isDefined( self.pers[ "class" ] ) && self.pers[ "class" ] == class ) + { + return; + } + self.pers[ "changed_class" ] = 1; + self notify( "changed_class" ); + if ( isDefined( self.curclass ) && self.curclass == class ) + { + self.pers[ "changed_class" ] = 0; + } + if ( ispregame() ) + { + self maps/mp/gametypes/_pregame::onplayerclasschange( response ); + } + if ( self.sessionstate == "playing" ) + { + self.pers[ "class" ] = class; + self.class = class; + if ( game[ "state" ] == "postgame" ) + { + return; + } + if ( isDefined( self.usingsupplystation ) ) + { + supplystationclasschange = self.usingsupplystation; + } + self.usingsupplystation = 0; + if ( level.ingraceperiod || !self.hasdonecombat && supplystationclasschange ) + { + self maps/mp/gametypes/_class::setclass( self.pers[ "class" ] ); + self.tag_stowed_back = undefined; + self.tag_stowed_hip = undefined; + self maps/mp/gametypes/_class::giveloadout( self.pers[ "team" ], self.pers[ "class" ] ); + self maps/mp/killstreaks/_killstreaks::giveownedkillstreak(); + } + else + { + if ( !self issplitscreen() ) + { + self iprintlnbold( game[ "strings" ][ "change_class" ] ); + } + } + } + else + { + self.pers[ "class" ] = class; + self.class = class; + if ( game[ "state" ] == "postgame" ) + { + return; + } + if ( self.sessionstate != "spectator" ) + { + if ( self isinvehicle() ) + { + return; + } + if ( self isremotecontrolling() ) + { + return; + } + if ( self isweaponviewonlylinked() ) + { + return 0; + } + } + if ( game[ "state" ] == "playing" ) + { + timepassed = undefined; + if ( isDefined( self.respawntimerstarttime ) ) + { + timepassed = ( getTime() - self.respawntimerstarttime ) / 1000; + } + self thread [[ level.spawnclient ]]( timepassed ); + self.respawntimerstarttime = undefined; + } + } + level thread maps/mp/gametypes/_globallogic::updateteamstatus(); + self thread maps/mp/gametypes/_spectating::setspectatepermissionsformachine(); } removespawnmessageshortly( delay ) diff --git a/patch_mp/maps/mp/gametypes/_globallogic_utils.gsc b/patch_mp/maps/mp/gametypes/_globallogic_utils.gsc index 4de74a7..7e172c9 100644 --- a/patch_mp/maps/mp/gametypes/_globallogic_utils.gsc +++ b/patch_mp/maps/mp/gametypes/_globallogic_utils.gsc @@ -1,6 +1,7 @@ -#include maps/mp/gametypes_zm/_globallogic_score; -#include maps/mp/gametypes_zm/_hostmigration; -#include maps/mp/gametypes_zm/_hud_message; +#include maps/mp/gametypes/_globallogic_score; +#include maps/mp/gametypes/_hostmigration; +#include maps/mp/killstreaks/_killstreaks; +#include maps/mp/gametypes/_hud_message; #include maps/mp/_utility; waittillslowprocessallowed() @@ -23,7 +24,7 @@ testmenu() notifydata.titletext = &"MP_CHALLENGE_COMPLETED"; notifydata.notifytext = "wheee"; notifydata.sound = "mp_challenge_complete"; - self thread maps/mp/gametypes_zm/_hud_message::notifymessage( notifydata ); + self thread maps/mp/gametypes/_hud_message::notifymessage( notifydata ); } } @@ -57,6 +58,10 @@ testhps() for ( ;; ) { hp = "radar_mp"; + if ( self thread maps/mp/killstreaks/_killstreaks::givekillstreak( hp ) ) + { + self playlocalsound( level.killstreaks[ hp ].informdialog ); + } wait 20; } } @@ -141,10 +146,10 @@ assertproperplacement() { /# numplayers = level.placement[ "all" ].size; - i = 0; - while ( i < ( numplayers - 1 ) ) + if ( level.teambased ) { - if ( isDefined( level.placement[ "all" ][ i ] ) && isDefined( level.placement[ "all" ][ i + 1 ] ) ) + i = 0; + while ( i < ( numplayers - 1 ) ) { if ( level.placement[ "all" ][ i ].score < level.placement[ "all" ][ i + 1 ].score ) { @@ -157,8 +162,29 @@ assertproperplacement() i++; } assertmsg( "Placement array was not properly sorted" ); - return; + break; } + else + { + i++; + } + } + } + else i = 0; + while ( i < ( numplayers - 1 ) ) + { + if ( level.placement[ "all" ][ i ].pointstowin < level.placement[ "all" ][ i + 1 ].pointstowin ) + { + println( "^1Placement array:" ); + i = 0; + while ( i < numplayers ) + { + player = level.placement[ "all" ][ i ]; + println( "^1" + i + ". " + player.name + ": " + player.pointstowin ); + i++; + } + assertmsg( "Placement array was not properly sorted" ); + return; } else { @@ -212,7 +238,7 @@ playtickingsound( gametype_tick_sound ) time -= 0,3; wait 0,3; } - maps/mp/gametypes_zm/_hostmigration::waittillhostmigrationdone(); + maps/mp/gametypes/_hostmigration::waittillhostmigrationdone(); } } @@ -290,7 +316,7 @@ getscoreremaining( team ) scorelimit = level.scorelimit; if ( isplayer( self ) ) { - return scorelimit - maps/mp/gametypes_zm/_globallogic_score::_getplayerscore( self ); + return scorelimit - maps/mp/gametypes/_globallogic_score::_getplayerscore( self ); } else { @@ -298,6 +324,15 @@ getscoreremaining( team ) } } +getteamscoreforround( team ) +{ + if ( level.roundscorecarry && isDefined( game[ "lastroundscore" ][ team ] ) ) + { + return getteamscore( team ) - game[ "lastroundscore" ][ team ]; + } + return getteamscore( team ); +} + getscoreperminute( team ) { /# @@ -311,11 +346,11 @@ getscoreperminute( team ) minutespassed = ( gettimepassed() / 60000 ) + 0,0001; if ( isplayer( self ) ) { - return maps/mp/gametypes_zm/_globallogic_score::_getplayerscore( self ) / minutespassed; + return maps/mp/gametypes/_globallogic_score::_getplayerscore( self ) / minutespassed; } else { - return getteamscore( team ) / minutespassed; + return getteamscoreforround( team ) / minutespassed; } } @@ -382,6 +417,13 @@ isheadshot( sweapon, shitloc, smeansofdeath, einflictor ) return 0; } } + if ( maps/mp/killstreaks/_killstreaks::iskillstreakweapon( sweapon ) ) + { + if ( isDefined( einflictor ) || !isDefined( einflictor.controlled ) && einflictor.controlled == 0 ) + { + return 0; + } + } return 1; } @@ -466,13 +508,13 @@ logteamwinstring( wintype, winner ) { log_string = ( log_string + ", win: " ) + winner; } - _a469 = level.teams; - _k469 = getFirstArrayKey( _a469 ); - while ( isDefined( _k469 ) ) + _a495 = level.teams; + _k495 = getFirstArrayKey( _a495 ); + while ( isDefined( _k495 ) ) { - team = _a469[ _k469 ]; + team = _a495[ _k495 ]; log_string = ( log_string + ", " ) + team + ": " + game[ "teamScores" ][ team ]; - _k469 = getNextArrayKey( _a469, _k469 ); + _k495 = getNextArrayKey( _a495, _k495 ); } logstring( log_string ); } diff --git a/patch_mp/maps/mp/gametypes/_globallogic_vehicle.gsc b/patch_mp/maps/mp/gametypes/_globallogic_vehicle.gsc index 9bfb41d..46a7a9f 100644 --- a/patch_mp/maps/mp/gametypes/_globallogic_vehicle.gsc +++ b/patch_mp/maps/mp/gametypes/_globallogic_vehicle.gsc @@ -1,10 +1,16 @@ -#include maps/mp/gametypes_zm/_damagefeedback; -#include maps/mp/gametypes_zm/_globallogic_player; -#include maps/mp/gametypes_zm/_weapons; +#include maps/mp/gametypes/_damagefeedback; +#include maps/mp/gametypes/_globallogic_player; +#include maps/mp/gametypes/_weapons; +#include maps/mp/_vehicles; +#include maps/mp/gametypes/_class; #include maps/mp/_utility; callback_vehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname ) { + if ( level.idflags_radius & idflags ) + { + idamage = maps/mp/gametypes/_class::cac_modified_vehicle_damage( self, eattacker, idamage, smeansofdeath, sweapon, einflictor ); + } self.idflags = idflags; self.idflagstime = getTime(); if ( game[ "state" ] == "postgame" ) @@ -84,6 +90,10 @@ callback_vehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, { team = self.owner.pers[ "team" ]; } + else + { + team = self maps/mp/_vehicles::vehicle_get_occupant_team(); + } if ( level.teambased && isplayer( eattacker ) && team == eattacker.pers[ "team" ] ) { if ( level.friendlyfire == 0 ) @@ -138,54 +148,61 @@ callback_vehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, } else { - if ( !level.teambased && isDefined( self.targetname ) && self.targetname == "rcbomb" ) + if ( !level.hardcoremode && isDefined( self.owner ) && isDefined( eattacker.owner ) && self.owner == eattacker.owner ) { + return; } else { - if ( isDefined( self.owner ) && isDefined( eattacker ) && self.owner == eattacker ) + if ( !level.teambased && isDefined( self.targetname ) && self.targetname == "rcbomb" ) { - return; } - } - if ( idamage < 1 ) - { - idamage = 1; - } - if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( sweapon ) ) - { - eattacker thread maps/mp/gametypes_zm/_weapons::checkhit( sweapon ); - } - if ( issubstr( smeansofdeath, "MOD_GRENADE" ) && isDefined( einflictor.iscooked ) ) - { - self.wascooked = getTime(); - } - else - { - self.wascooked = undefined; - } - attacker_seat = undefined; - if ( isDefined( eattacker ) ) - { - attacker_seat = self getoccupantseat( eattacker ); - } - if ( isDefined( eattacker ) ) - { - self.lastdamagewasfromenemy = !isDefined( attacker_seat ); - } - self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 0 ); - if ( level.gametype == "hack" && sweapon != "emp_grenade_mp" ) - { - idamage = 0; + else + { + if ( isDefined( self.owner ) && isDefined( eattacker ) && self.owner == eattacker ) + { + return; + } + } + if ( idamage < 1 ) + { + idamage = 1; + } + if ( isDefined( eattacker ) && isplayer( eattacker ) && isDefined( sweapon ) ) + { + eattacker thread maps/mp/gametypes/_weapons::checkhit( sweapon ); + } + if ( issubstr( smeansofdeath, "MOD_GRENADE" ) && isDefined( einflictor.iscooked ) ) + { + self.wascooked = getTime(); + } + else + { + self.wascooked = undefined; + } + attacker_seat = undefined; + if ( isDefined( eattacker ) ) + { + attacker_seat = self getoccupantseat( eattacker ); + } + if ( isDefined( eattacker ) ) + { + self.lastdamagewasfromenemy = !isDefined( attacker_seat ); + } + self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 0 ); + if ( level.gametype == "hack" && sweapon != "emp_grenade_mp" ) + { + idamage = 0; + } } } if ( isDefined( eattacker ) && eattacker != self ) { - if ( maps/mp/gametypes_zm/_globallogic_player::dodamagefeedback( sweapon, einflictor ) ) + if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( sweapon, einflictor ) ) { if ( idamage > 0 ) { - eattacker thread maps/mp/gametypes_zm/_damagefeedback::updatedamagefeedback( smeansofdeath, einflictor ); + eattacker thread maps/mp/gametypes/_damagefeedback::updatedamagefeedback( smeansofdeath, einflictor ); } } } @@ -221,9 +238,9 @@ callback_vehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, callback_vehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime ) { - idamage = 0; - finnerdamage = 0; - fouterdamage = 0; + idamage = maps/mp/gametypes/_class::cac_modified_vehicle_damage( self, eattacker, idamage, smeansofdeath, sweapon, einflictor ); + finnerdamage = maps/mp/gametypes/_class::cac_modified_vehicle_damage( self, eattacker, finnerdamage, smeansofdeath, sweapon, einflictor ); + fouterdamage = maps/mp/gametypes/_class::cac_modified_vehicle_damage( self, eattacker, fouterdamage, smeansofdeath, sweapon, einflictor ); self.idflags = idflags; self.idflagstime = getTime(); if ( game[ "state" ] == "postgame" ) @@ -256,7 +273,7 @@ callback_vehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fout idamage = 1; } } - occupant_team = undefined; + occupant_team = self maps/mp/_vehicles::vehicle_get_occupant_team(); if ( level.teambased && isplayer( eattacker ) && occupant_team == eattacker.pers[ "team" ] ) { if ( level.friendlyfire == 0 ) @@ -312,11 +329,19 @@ callback_vehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fout } else { - if ( idamage < 1 ) + if ( !level.hardcoremode && isDefined( self.owner ) && isDefined( eattacker.owner ) && self.owner == eattacker.owner ) { - idamage = 1; + return; + return; + } + else + { + if ( idamage < 1 ) + { + idamage = 1; + } + self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime ); } - self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime ); } } } @@ -333,19 +358,7 @@ vehiclecrush() getvehicleprojectilescalar( sweapon ) { - if ( sweapon == "satchel_charge_mp" ) - { - scale = 1; - } - else if ( sweapon == "sticky_grenade_mp" ) - { - scale = 1; - } - else if ( sweapon == "claymore_mp" ) - { - scale = 1; - } - else if ( sweapon == "remote_missile_missile_mp" ) + if ( sweapon == "remote_missile_missile_mp" ) { scale = 10; } @@ -361,18 +374,6 @@ getvehicleprojectilescalar( sweapon ) { scale = 0,2; } - else if ( issubstr( sweapon, "gl_" ) ) - { - scale = 1; - } - else if ( issubstr( sweapon, "turret_mp" ) ) - { - scale = 1; - } - else if ( issubstr( sweapon, "grenade" ) ) - { - scale = 1; - } else { scale = 1; @@ -382,19 +383,7 @@ getvehicleprojectilescalar( sweapon ) getvehicleprojectilesplashscalar( sweapon ) { - if ( sweapon == "satchel_charge_mp" ) - { - scale = 1; - } - else if ( sweapon == "sticky_grenade_mp" ) - { - scale = 1; - } - else if ( sweapon == "claymore_mp" ) - { - scale = 1; - } - else if ( sweapon == "remote_missile_missile_mp" ) + if ( sweapon == "remote_missile_missile_mp" ) { scale = 10; } @@ -406,18 +395,6 @@ getvehicleprojectilesplashscalar( sweapon ) { scale = 0,5; } - else if ( issubstr( sweapon, "gl_" ) ) - { - scale = 0,5; - } - else if ( issubstr( sweapon, "turrent_mp" ) ) - { - scale = 0,1; - } - else if ( issubstr( sweapon, "grenade" ) ) - { - scale = 1; - } else { scale = 1; diff --git a/patch_mp/maps/mp/gametypes/_gv_actions.gsc b/patch_mp/maps/mp/gametypes/_gv_actions.gsc deleted file mode 100644 index 0b42480..0000000 --- a/patch_mp/maps/mp/gametypes/_gv_actions.gsc +++ /dev/null @@ -1,995 +0,0 @@ -#include maps/mp/gametypes_zm/_globallogic_ui; -#include maps/mp/gametypes_zm/_hud_util; -#include maps/mp/gametypes_zm/_globallogic_score; -#include maps/mp/gametypes_zm/_globallogic; -#include common_scripts/utility; -#include maps/mp/_utility; - -initializeactionarray() -{ - level.gametypeactions = []; - level.gametypeactions[ "GiveAmmo" ] = ::dogiveammo; - level.gametypeactions[ "RemoveAmmo" ] = ::doremoveammo; - level.gametypeactions[ "PlaySound" ] = ::doplaysound; - level.gametypeactions[ "EnableUAV" ] = ::doenableuav; - level.gametypeactions[ "GiveScore" ] = ::dogivescore; - level.gametypeactions[ "RemoveScore" ] = ::doremovescore; - level.gametypeactions[ "SetHeader" ] = ::dosetheader; - level.gametypeactions[ "SetSubHeader" ] = ::dosetsubheader; - level.gametypeactions[ "DisplayMessage" ] = ::dodisplaymessage; - level.gametypeactions[ "GiveHealth" ] = ::dogivehealth; - level.gametypeactions[ "RemoveHealth" ] = ::doremovehealth; - level.gametypeactions[ "SetHealthRegen" ] = ::dosethealthregen; - level.gametypeactions[ "ChangeClass" ] = ::dochangeclass; - level.gametypeactions[ "ChangeTeam" ] = ::dochangeteam; - level.gametypeactions[ "GivePerk" ] = ::dogiveperk; - level.gametypeactions[ "RemovePerk" ] = ::doremoveperk; - level.gametypeactions[ "GiveInvuln" ] = ::dogiveinvuln; - level.gametypeactions[ "RemoveInvuln" ] = ::doremoveinvuln; - level.gametypeactions[ "SetDamageModifier" ] = ::dosetdamagemodifier; - level.gametypeactions[ "GiveKillstreak" ] = ::dogivekillstreak; - level.gametypeactions[ "RemoveKillstreak" ] = ::doremovekillstreak; - level.gametypeactions[ "GiveLives" ] = ::dogivelives; - level.gametypeactions[ "RemoveLives" ] = ::doremovelives; - level.gametypeactions[ "ScaleMoveSpeed" ] = ::doscalemovespeed; - level.gametypeactions[ "ShowOnRadar" ] = ::doshowonradar; - level.conditionals = []; - level.conditionals[ "Equals" ] = ::equals; - level.conditionals[ "==" ] = ::equals; - level.conditionals[ "!=" ] = ::notequals; - level.conditionals[ "<" ] = ::lessthan; - level.conditionals[ "<=" ] = ::lessthanequals; - level.conditionals[ ">" ] = ::greaterthan; - level.conditionals[ ">=" ] = ::greaterthanequals; - level.conditionals[ "InPlace" ] = ::inplace; - level.conditionallefthandside = []; - level.conditionallefthandside[ "PlayersLeft" ] = ::playersleft; - level.conditionallefthandside[ "RoundsPlayed" ] = ::roundsplayed; - level.conditionallefthandside[ "HitBy" ] = ::hitby; - level.conditionallefthandside[ "PlayersClass" ] = ::playersclass; - level.conditionallefthandside[ "VictimsClass" ] = ::playersclass; - level.conditionallefthandside[ "AttackersClass" ] = ::attackersclass; - level.conditionallefthandside[ "PlayersPlace" ] = ::playersplace; - level.conditionallefthandside[ "VictimsPlace" ] = ::playersplace; - level.conditionallefthandside[ "AttackersPlace" ] = ::attackersplace; - level.targets = []; - level.targets[ "Everyone" ] = ::gettargeteveryone; - level.targets[ "PlayersLeft" ] = ::gettargetplayersleft; - level.targets[ "PlayersEliminated" ] = ::gettargetplayerseliminated; - level.targets[ "PlayersTeam" ] = ::gettargetplayersteam; - level.targets[ "VictimsTeam" ] = ::gettargetplayersteam; - level.targets[ "OtherTeam" ] = ::gettargetotherteam; - level.targets[ "AttackersTeam" ] = ::gettargetotherteam; - level.targets[ "PlayersLeftOnPlayersTeam" ] = ::gettargetplayersleftonplayersteam; - level.targets[ "PlayersLeftOnOtherTeam" ] = ::gettargetplayersleftonotherteam; - level.targets[ "PlayersLeftOnVictimsTeam" ] = ::gettargetplayersleftonplayersteam; - level.targets[ "PlayersLeftOnAttackersTeam" ] = ::gettargetplayersleftonotherteam; - level.targets[ "PlayersEliminatedOnPlayersTeam" ] = ::gettargetplayerseliminatedonplayersteam; - level.targets[ "PlayersEliminatedOnOtherTeam" ] = ::gettargetplayerseliminatedonotherteam; - level.targets[ "PlayersEliminatedOnVictimsTeam" ] = ::gettargetplayerseliminatedonplayersteam; - level.targets[ "PlayersEliminatedOnAttackersTeam" ] = ::gettargetplayerseliminatedonotherteam; - level.targets[ "AssistingPlayers" ] = ::getassistingplayers; -} - -equals( param1, param2 ) -{ - return param1 == param2; -} - -notequals( param1, param2 ) -{ - return param1 != param2; -} - -lessthan( param1, param2 ) -{ - return param1 < param2; -} - -lessthanequals( param1, param2 ) -{ - return param1 <= param2; -} - -greaterthan( param1, param2 ) -{ - return param1 > param2; -} - -greaterthanequals( param1, param2 ) -{ - return param1 >= param2; -} - -inplace( param1, param2 ) -{ - if ( param1 == param2 ) - { - return 1; - } - if ( param2 == "top3" && param1 == "first" ) - { - return 1; - } - return 0; -} - -playersleft( rule ) -{ - return 0; -} - -roundsplayed( rule ) -{ - return game[ "roundsplayed" ] + 1; -} - -hitby( rule ) -{ - meansofdeath = rule.target[ "MeansOfDeath" ]; - weapon = rule.target[ "Weapon" ]; - if ( !isDefined( meansofdeath ) || !isDefined( weapon ) ) - { - return undefined; - } - switch( weapon ) - { - case "knife_ballistic_mp": - return "knife"; - } - switch( meansofdeath ) - { - case "MOD_PISTOL_BULLET": - case "MOD_RIFLE_BULLET": - return "bullet"; - case "MOD_BAYONET": - case "MOD_MELEE": - return "knife"; - case "MOD_HEAD_SHOT": - return "headshot"; - case "MOD_EXPLOSIVE": - case "MOD_GRENADE": - case "MOD_GRENADE_SPLASH": - case "MOD_PROJECTILE": - case "MOD_PROJECTILE_SPLASH": - return "explosive"; - } - return undefined; -} - -getplayersclass( player ) -{ - return player.pers[ "class" ]; -} - -playersclass( rule ) -{ - player = rule.target[ "Player" ]; - return getplayersclass( player ); -} - -attackersclass( rule ) -{ - player = rule.target[ "Attacker" ]; - return getplayersclass( player ); -} - -getplayersplace( player ) -{ - maps/mp/gametypes_zm/_globallogic::updateplacement(); - if ( !isDefined( level.placement[ "all" ] ) ) - { - return; - } - place = 0; - while ( place < level.placement[ "all" ].size ) - { - if ( level.placement[ "all" ][ place ] == player ) - { - place++; - continue; - } - else - { - place++; - } - } - place++; - if ( place == 1 ) - { - return "first"; - } - else - { - if ( place <= 3 ) - { - return "top3"; - } - else - { - if ( place == level.placement[ "all" ].size ) - { - return "last"; - } - } - } - return "middle"; -} - -playersplace( rule ) -{ - player = rule.target[ "Player" ]; - return getplayersplace( player ); -} - -attackersplace( rule ) -{ - player = rule.target[ "Attacker" ]; - return getplayersplace( player ); -} - -gettargeteveryone( rule ) -{ - return level.players; -} - -gettargetplayersleft( rule ) -{ - return 0; -} - -gettargetplayerseliminated( rule ) -{ - return 0; -} - -gettargetplayersteam( rule ) -{ - player = rule.target[ "Player" ]; - if ( !isDefined( player ) ) - { - return []; - } - return getplayersonteam( level.players, player.pers[ "team" ] ); -} - -gettargetotherteam( rule ) -{ - player = rule.target[ "Player" ]; - if ( !isDefined( player ) ) - { - return []; - } - return getplayersonteam( level.players, getotherteam( player.pers[ "team" ] ) ); -} - -gettargetplayersleftonplayersteam( rule ) -{ - return []; -} - -gettargetplayersleftonotherteam( rule ) -{ - return []; -} - -gettargetplayerseliminatedonplayersteam( rule ) -{ - return []; -} - -gettargetplayerseliminatedonotherteam( rule ) -{ - return []; -} - -getassistingplayers( rule ) -{ - assisters = []; - attacker = rule.target[ "Attacker" ]; - if ( !isDefined( rule.target[ "Assisters" ] ) || !isDefined( attacker ) ) - { - return assisters; - } - j = 0; - while ( j < rule.target[ "Assisters" ].size ) - { - player = rule.target[ "Assisters" ][ j ]; - if ( !isDefined( player ) ) - { - j++; - continue; - } - else if ( player == attacker ) - { - j++; - continue; - } - else - { - assisters[ assisters.size ] = player; - } - j++; - } - return assisters; -} - -executegametypeeventrule( rule ) -{ - if ( !aregametypeeventruleconditionalsmet( rule ) ) - { - return; - } - if ( !isDefined( level.gametypeactions[ rule.action ] ) ) - { -/# - error( "GAMETYPE VARIANTS - unknown action: " + rule.action + "!" ); -#/ - return; - } - thread internalexecuterule( rule ); -} - -internalexecuterule( rule ) -{ -} - -aregametypeeventruleconditionalsmet( rule ) -{ - if ( !isDefined( rule.conditionals ) || rule.conditionals.size == 0 ) - { - return 1; - } - combinedresult = 1; - if ( rule.conditionaleval == "OR" ) - { - combinedresult = 0; - } - i = 0; - while ( i < rule.conditionals.size ) - { - conditionalresult = evaluategametypeeventruleconditional( rule, rule.conditionals[ i ] ); - switch( rule.conditionaleval ) - { - case "AND": - if ( combinedresult ) - { - combinedresult = conditionalresult; - } - break; - case "OR": - if ( !combinedresult ) - { - combinedresult = conditionalresult; - } - break; - } - if ( rule.conditionaleval == "AND" && !combinedresult ) - { - break; - } - else - { - if ( rule.conditionaleval == "OR" && combinedresult ) - { - break; - } - else - { - i++; - } - } - } - return combinedresult; -} - -evaluategametypeeventruleconditional( rule, conditional ) -{ - if ( isDefined( conditional.lhs ) || !isDefined( conditional.operand ) && !isDefined( conditional.rhs ) ) - { - return 0; - } - if ( !isDefined( level.conditionallefthandside[ conditional.lhs ] ) ) - { - return 0; - } - lhsvalue = [[ level.conditionallefthandside[ conditional.lhs ] ]]( rule ); - if ( !isDefined( lhsvalue ) || !isDefined( level.conditionals[ conditional.operand ] ) ) - { - return 0; - } - return [[ level.conditionals[ conditional.operand ] ]]( lhsvalue, conditional.rhs ); -} - -getplayersonteam( players, team ) -{ - playersonteam = []; - i = 0; - while ( i < players.size ) - { - player = players[ i ]; - if ( player.pers[ "team" ] == team ) - { - playersonteam[ playersonteam.size ] = player; - } - i++; - } - return playersonteam; -} - -gettargetsforgametypeeventrule( rule ) -{ - targets = []; - if ( !isDefined( rule.targetname ) ) - { - return targets; - } - if ( isDefined( rule.target[ rule.targetname ] ) ) - { - targets[ targets.size ] = rule.target[ rule.targetname ]; - } - else - { - if ( isDefined( level.targets[ rule.targetname ] ) ) - { - targets = [[ level.targets[ rule.targetname ] ]]( rule ); - } - } - return targets; -} - -doesrulehavevalidparam( rule ) -{ - if ( isDefined( rule.params ) && isarray( rule.params ) ) - { - return rule.params.size > 0; - } -} - -sortplayersbylivesdescending( players ) -{ - if ( !isDefined( players ) ) - { - return undefined; - } - swapped = 1; - n = players.size; - while ( swapped ) - { - swapped = 0; - i = 0; - while ( i < ( n - 1 ) ) - { - if ( players[ i ].pers[ "lives" ] < players[ i + 1 ].pers[ "lives" ] ) - { - temp = players[ i ]; - players[ i ] = players[ i + 1 ]; - players[ i + 1 ] = temp; - swapped = 1; - } - i++; - } - n--; - - } - return players; -} - -giveammo( players, amount ) -{ - i = 0; - while ( i < players.size ) - { - wait 0,5; - player = players[ i ]; - currentweapon = player getcurrentweapon(); - clipammo = player getweaponammoclip( currentweapon ); - player setweaponammoclip( currentweapon, clipammo + amount ); - i++; - } -} - -dogiveammo( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - targets = gettargetsforgametypeeventrule( rule ); - giveammo( targets, rule.params[ 0 ] ); -} - -doremoveammo( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - targets = gettargetsforgametypeeventrule( rule ); - giveammo( targets, 0 - rule.params[ 0 ] ); -} - -doplaysound( rule ) -{ - if ( doesrulehavevalidparam( rule ) ) - { - playsoundonplayers( rule.params[ 0 ] ); - } -} - -doenableuav( rule ) -{ - targets = gettargetsforgametypeeventrule( rule ); - targetindex = 0; - while ( targetindex < targets.size ) - { - targets[ targetindex ].pers[ "hasRadar" ] = 1; - targets[ targetindex ].hasspyplane = 1; - targetindex++; - } -} - -givescore( players, amount ) -{ - i = 0; - while ( i < players.size ) - { - player = players[ i ]; - score = maps/mp/gametypes_zm/_globallogic_score::_getplayerscore( player ); - maps/mp/gametypes_zm/_globallogic_score::_setplayerscore( player, score + amount ); - i++; - } -} - -dogivescore( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - targets = gettargetsforgametypeeventrule( rule ); - givescore( targets, rule.params[ 0 ] ); -} - -doremovescore( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - targets = gettargetsforgametypeeventrule( rule ); - givescore( targets, 0 - rule.params[ 0 ] ); -} - -dosetheader( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - targets = gettargetsforgametypeeventrule( rule ); - targetindex = 0; - while ( targetindex < targets.size ) - { - target = targets[ targetindex ]; - displaytextonhudelem( target, target.customgametypeheader, rule.params[ 0 ], rule.params[ 1 ], "gv_header", rule.params[ 2 ] ); - targetindex++; - } -} - -dosetsubheader( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - targets = gettargetsforgametypeeventrule( rule ); - targetindex = 0; - while ( targetindex < targets.size ) - { - target = targets[ targetindex ]; - displaytextonhudelem( target, target.customgametypesubheader, rule.params[ 0 ], rule.params[ 1 ], "gv_subheader", rule.params[ 2 ] ); - targetindex++; - } -} - -displaytextonhudelem( target, texthudelem, text, secondstodisplay, notifyname, valueparam ) -{ - texthudelem.alpha = 1; - if ( isDefined( valueparam ) ) - { - texthudelem settext( text, valueparam ); - } - else - { - texthudelem settext( text ); - } - if ( !isDefined( secondstodisplay ) || secondstodisplay <= 0 ) - { - target.doingnotify = 0; - target notify( notifyname ); - return; - } - target thread fadecustomgametypehudelem( texthudelem, secondstodisplay, notifyname ); -} - -fadecustomgametypehudelem( hudelem, seconds, notifyname ) -{ - self endon( "disconnect" ); - self notify( notifyname ); - self endon( notifyname ); - if ( seconds <= 0 ) - { - return; - } - self.doingnotify = 1; - wait seconds; - while ( hudelem.alpha > 0 ) - { - hudelem.alpha -= 0,05; - if ( hudelem.alpha < 0 ) - { - hudelem.alpha = 0; - } - wait 0,05; - } - self.doingnotify = 0; -} - -dodisplaymessage( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - targets = gettargetsforgametypeeventrule( rule ); - targetindex = 0; - while ( targetindex < targets.size ) - { - thread announcemessage( targets[ targetindex ], rule.params[ 0 ], 2 ); - targetindex++; - } -} - -announcemessage( target, messagetext, time ) -{ - target endon( "disconnect" ); - clientannouncement( target, messagetext, int( time * 1000 ) ); - if ( time == 0 ) - { - time = getDvarFloat( #"E8C4FC20" ); - } - target.doingnotify = 1; - wait time; - target.doingnotify = 0; -} - -givehealth( players, amount ) -{ - i = 0; - while ( i < players.size ) - { - player = players[ i ]; - player.health += amount; - i++; - } -} - -dogivehealth( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - givehealth( gettargetsforgametypeeventrule( rule ), rule.params[ 0 ] ); -} - -doremovehealth( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - givehealth( gettargetsforgametypeeventrule( rule ), 0 - rule.params[ 0 ] ); -} - -dosethealthregen( rule ) -{ - targets = gettargetsforgametypeeventrule( rule ); - targetindex = 0; - while ( targetindex < targets.size ) - { - player = targets[ targetindex ]; - player.regenrate = rule.params[ 0 ]; - targetindex++; - } -} - -dochangeclass( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } -} - -dochangeteam( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - team = rule.params[ 0 ]; - teamkeys = getarraykeys( level.teams ); - targets = gettargetsforgametypeeventrule( rule ); - targetindex = 0; - while ( targetindex < targets.size ) - { - target = targets[ targetindex ]; - if ( target.pers[ "team" ] == team ) - { - targetindex++; - continue; - } - else - { - while ( team == "toggle" ) - { - team = teamkeys[ randomint( teamkeys.size ) ]; - teamindex = 0; - while ( teamindex < teamkeys.size ) - { - if ( target.pers[ "team" ] == teamkeys[ teamindex ] ) - { - team = teamkeys[ ( teamindex + 1 ) % teamkeys.size ]; - break; - } - else - { - teamindex++; - } - } - } - target.pers[ "team" ] = team; - target.team = team; - if ( level.teambased ) - { - target.sessionteam = team; - } - else - { - target.sessionteam = "none"; - } - target notify( "joined_team" ); - level notify( "joined_team" ); - } - targetindex++; - } -} - -displayperk( player, imagename ) -{ - index = 0; - if ( isDefined( player.perkicon ) ) - { - index = -1; - i = 0; - while ( i < player.perkicon.size ) - { - if ( player.perkicon[ i ].alpha == 0 ) - { - index = i; - break; - } - else - { - i++; - } - } - if ( index == -1 ) - { - return; - } - } - player maps/mp/gametypes_zm/_hud_util::showperk( index, imagename, 10 ); - player thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutaftertime( 3 ); - player thread maps/mp/gametypes_zm/_globallogic_ui::hideloadoutondeath(); -} - -setorunsetperk( players, perks, shouldset ) -{ - if ( level.perksenabled == 0 ) - { - return; - } - if ( perks.size < 2 ) - { - return; - } - hasperkalready = 0; - imagename = perks[ perks.size - 1 ]; - i = 0; - while ( i < players.size ) - { - player = players[ i ]; - perkindex = 0; - while ( perkindex < ( perks.size - 1 ) ) - { - perk = perks[ perkindex ]; - if ( player hasperk( perk ) ) - { - hasperkalready = 1; - } - if ( shouldset ) - { - player setperk( perk ); - perkindex++; - continue; - } - else - { - player unsetperk( perk ); - } - perkindex++; - } - if ( shouldset && !hasperkalready && getDvarInt( "scr_showperksonspawn" ) == 1 ) - { - displayperk( player, imagename ); - } - i++; - } -} - -dogiveperk( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - setorunsetperk( gettargetsforgametypeeventrule( rule ), rule.params, 1 ); -} - -doremoveperk( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - setorunsetperk( gettargetsforgametypeeventrule( rule ), rule.params, 0 ); -} - -giveorremovekillstreak( rule, shouldgive ) -{ -} - -dogivekillstreak( rule ) -{ - giveorremovekillstreak( rule, 1 ); -} - -doremovekillstreak( rule ) -{ - giveorremovekillstreak( rule, 0 ); -} - -givelives( players, amount ) -{ - i = 0; - while ( i < players.size ) - { - player = players[ i ]; - player.pers[ "lives" ] += amount; - if ( player.pers[ "lives" ] < 0 ) - { - player.pers[ "lives" ] = 0; - } - i++; - } -} - -dogivelives( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - givelives( gettargetsforgametypeeventrule( rule ), rule.params[ 0 ] ); -} - -doremovelives( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - givelives( gettargetsforgametypeeventrule( rule ), 0 - rule.params[ 0 ] ); -} - -giveorremoveinvuln( players, shouldgiveinvuln ) -{ - i = 0; - while ( i < players.size ) - { - player = players[ i ]; - i++; - } -} - -dogiveinvuln( rule ) -{ - giveorremoveinvuln( gettargetsforgametypeeventrule( rule ), 1 ); -} - -doremoveinvuln( rule ) -{ - giveorremoveinvuln( gettargetsforgametypeeventrule( rule ), 0 ); -} - -dosetdamagemodifier( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - players = gettargetsforgametypeeventrule( rule ); - i = 0; - while ( i < players.size ) - { - player = players[ i ]; - player.damagemodifier = rule.params[ 0 ]; - i++; - } -} - -doscalemovespeed( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - movespeedscale = rule.params[ 0 ]; - targets = gettargetsforgametypeeventrule( rule ); - targetindex = 0; - while ( targetindex < targets.size ) - { - target = targets[ targetindex ]; - target.movementspeedmodifier = movespeedscale * target getmovespeedscale(); - if ( target.movementspeedmodifier < 0,1 ) - { - target.movementspeedmodifier = 0,1; - } - else - { - if ( target.movementspeedmodifier > 4 ) - { - target.movementspeedmodifier = 4; - } - } - target setmovespeedscale( target.movementspeedmodifier ); - targetindex++; - } -} - -doshowonradar( rule ) -{ - if ( !doesrulehavevalidparam( rule ) ) - { - return; - } - targets = gettargetsforgametypeeventrule( rule ); - targetindex = 0; - while ( targetindex < targets.size ) - { - if ( rule.params[ 0 ] == "enable" ) - { - targets[ targetindex ] setperk( "specialty_showonradar" ); - targetindex++; - continue; - } - else - { - targets[ targetindex ] unsetperk( "specialty_showonradar" ); - } - targetindex++; - } -} diff --git a/patch_mp/maps/mp/gametypes/_healthoverlay.gsc b/patch_mp/maps/mp/gametypes/_healthoverlay.gsc index a7d8f4b..cfda647 100644 --- a/patch_mp/maps/mp/gametypes/_healthoverlay.gsc +++ b/patch_mp/maps/mp/gametypes/_healthoverlay.gsc @@ -1,4 +1,4 @@ -#include maps/mp/gametypes_zm/_globallogic_player; +#include maps/mp/gametypes/_globallogic_player; init() { @@ -170,7 +170,7 @@ playerhealthregen() } if ( newhealth >= 1 ) { - self maps/mp/gametypes_zm/_globallogic_player::resetattackerlist(); + self maps/mp/gametypes/_globallogic_player::resetattackerlist(); newhealth = 1; } if ( newhealth <= 0 ) diff --git a/patch_mp/maps/mp/gametypes/_hostmigration.gsc b/patch_mp/maps/mp/gametypes/_hostmigration.gsc index 7eca73c..1718fec 100644 --- a/patch_mp/maps/mp/gametypes/_hostmigration.gsc +++ b/patch_mp/maps/mp/gametypes/_hostmigration.gsc @@ -1,7 +1,5 @@ -#include maps/mp/zombies/_zm; -#include maps/mp/gametypes_zm/_hud; -#include maps/mp/zombies/_zm_utility; -#include maps/mp/gametypes_zm/_hud_util; +#include maps/mp/gametypes/_hud; +#include maps/mp/gametypes/_hud_util; #include common_scripts/utility; #include maps/mp/_utility; @@ -55,22 +53,6 @@ callback_hostmigrationsave() { } -callback_prehostmigrationsave() -{ - undo_link_changes(); - disablezombies( 1 ); - if ( is_true( level._hm_should_pause_spawning ) ) - { - flag_set( "spawn_zombies" ); - } - i = 0; - while ( i < level.players.size ) - { - level.players[ i ] enableinvulnerability(); - i++; - } -} - pausetimer() { level.migrationtimerpausetime = getTime(); @@ -98,10 +80,13 @@ locktimer() callback_hostmigration() { - redo_link_changes(); setslowmotion( 1, 1, 0 ); makedvarserverinfo( "ui_guncycle", 0 ); level.hostmigrationreturnedplayercount = 0; + if ( level.inprematchperiod ) + { + level waittill( "prematch_over" ); + } if ( level.gameended ) { /# @@ -109,131 +94,46 @@ callback_hostmigration() #/ return; } - sethostmigrationstatus( 1 ); - level notify( "host_migration_begin" ); - i = 0; - while ( i < level.players.size ) - { - if ( isDefined( level.hostmigration_link_entity_callback ) ) - { - if ( !isDefined( level.players[ i ]._host_migration_link_entity ) ) - { - level.players[ i ]._host_migration_link_entity = level.players[ i ] [[ level.hostmigration_link_entity_callback ]](); - } - } - level.players[ i ] thread hostmigrationtimerthink(); - i++; - } - while ( isDefined( level.hostmigration_ai_link_entity_callback ) ) - { - zombies = getaiarray( level.zombie_team ); - while ( isDefined( zombies ) && zombies.size > 0 ) - { - _a133 = zombies; - _k133 = getFirstArrayKey( _a133 ); - while ( isDefined( _k133 ) ) - { - zombie = _a133[ _k133 ]; - if ( !isDefined( zombie._host_migration_link_entity ) ) - { - zombie._host_migration_link_entity = zombie [[ level.hostmigration_ai_link_entity_callback ]](); - } - _k133 = getNextArrayKey( _a133, _k133 ); - } - } - } - if ( level.inprematchperiod ) - { - level waittill( "prematch_over" ); - } /# println( "Migration starting at time " + getTime() ); #/ level.hostmigrationtimer = 1; + sethostmigrationstatus( 1 ); + level notify( "host_migration_begin" ); thread locktimer(); - zombies = getaiarray( level.zombie_team ); - while ( isDefined( zombies ) && zombies.size > 0 ) + players = level.players; + i = 0; + while ( i < players.size ) { - _a156 = zombies; - _k156 = getFirstArrayKey( _a156 ); - while ( isDefined( _k156 ) ) - { - zombie = _a156[ _k156 ]; - if ( isDefined( zombie._host_migration_link_entity ) ) - { - ent = spawn( "script_origin", zombie.origin ); - ent.angles = zombie.angles; - zombie linkto( ent ); - ent linkto( zombie._host_migration_link_entity, "tag_origin", zombie._host_migration_link_entity worldtolocalcoords( ent.origin ), ent.angles + zombie._host_migration_link_entity.angles ); - zombie._host_migration_link_helper = ent; - zombie linkto( zombie._host_migration_link_helper ); - } - _k156 = getNextArrayKey( _a156, _k156 ); - } + player = players[ i ]; + player thread hostmigrationtimerthink(); + i++; } level endon( "host_migration_begin" ); - level._hm_should_pause_spawning = flag( "spawn_zombies" ); - if ( level._hm_should_pause_spawning ) - { - flag_clear( "spawn_zombies" ); - } hostmigrationwait(); - _a185 = level.players; - _k185 = getFirstArrayKey( _a185 ); - while ( isDefined( _k185 ) ) - { - player = _a185[ _k185 ]; - player thread post_migration_become_vulnerable(); - _k185 = getNextArrayKey( _a185, _k185 ); - } - zombies = getaiarray( level.zombie_team ); - while ( isDefined( zombies ) && zombies.size > 0 ) - { - _a193 = zombies; - _k193 = getFirstArrayKey( _a193 ); - while ( isDefined( _k193 ) ) - { - zombie = _a193[ _k193 ]; - if ( isDefined( zombie._host_migration_link_entity ) ) - { - zombie unlink(); - zombie._host_migration_link_helper delete(); - zombie._host_migration_link_helper = undefined; - zombie._host_migration_link_entity = undefined; - } - _k193 = getNextArrayKey( _a193, _k193 ); - } - } - enablezombies( 1 ); - if ( level._hm_should_pause_spawning ) - { - flag_set( "spawn_zombies" ); - } level.hostmigrationtimer = undefined; - level._hm_should_pause_spawning = undefined; sethostmigrationstatus( 0 ); /# println( "Migration finished at time " + getTime() ); #/ + recordmatchbegin(); level notify( "host_migration_end" ); } -post_migration_become_vulnerable() -{ - self endon( "disconnect" ); - wait 3; - self disableinvulnerability(); -} - matchstarttimerconsole_internal( counttime, matchstarttimer ) { waittillframeend; + visionsetnaked( "mpIntro", 0 ); level endon( "match_start_timer_beginning" ); while ( counttime > 0 && !level.gameended ) { - matchstarttimer thread maps/mp/gametypes_zm/_hud::fontpulse( level ); + matchstarttimer thread maps/mp/gametypes/_hud::fontpulse( level ); wait ( matchstarttimer.inframes * 0,05 ); matchstarttimer setvalue( counttime ); + if ( counttime == 2 ) + { + visionsetnaked( getDvar( "mapname" ), 3 ); + } counttime--; wait ( 1 - ( matchstarttimer.inframes * 0,05 ) ); @@ -257,11 +157,17 @@ matchstarttimerconsole( type, duration ) matchstarttimer.color = ( 1, 1, 0 ); matchstarttimer.foreground = 0; matchstarttimer.hidewheninmenu = 1; - matchstarttimer maps/mp/gametypes_zm/_hud::fontpulseinit(); + matchstarttimer maps/mp/gametypes/_hud::fontpulseinit(); counttime = int( duration ); if ( counttime >= 2 ) { matchstarttimerconsole_internal( counttime, matchstarttimer ); + visionsetnaked( getDvar( "mapname" ), 3 ); + } + else + { + visionsetnaked( "mpIntro", 0 ); + visionsetnaked( getDvar( "mapname" ), 1 ); } matchstarttimer destroyelem(); matchstarttext destroyelem(); @@ -275,10 +181,21 @@ hostmigrationwait() thread matchstarttimerconsole( "waiting_for_teams", 20 ); hostmigrationwaitforplayers(); } + level notify( "host_migration_countdown_begin" ); thread matchstarttimerconsole( "match_starting_in", 5 ); wait 5; } +waittillhostmigrationcountdown() +{ + level endon( "host_migration_end" ); + if ( !isDefined( level.hostmigrationtimer ) ) + { + return; + } + level waittill( "host_migration_countdown_begin" ); +} + hostmigrationwaitforplayers() { level endon( "hostmigration_enoughplayers" ); @@ -294,17 +211,6 @@ hostmigrationtimerthink_internal() { self waittill( "spawned" ); } - if ( isDefined( self._host_migration_link_entity ) ) - { - ent = spawn( "script_origin", self.origin ); - ent.angles = self.angles; - self linkto( ent ); - ent linkto( self._host_migration_link_entity, "tag_origin", self._host_migration_link_entity worldtolocalcoords( ent.origin ), ent.angles + self._host_migration_link_entity.angles ); - self._host_migration_link_helper = ent; -/# - println( "Linking player to ent " + self._host_migration_link_entity.targetname ); -#/ - } self.hostmigrationcontrolsfrozen = 1; self freezecontrols( 1 ); level waittill( "host_migration_end" ); @@ -318,21 +224,6 @@ hostmigrationtimerthink() if ( self.hostmigrationcontrolsfrozen ) { self freezecontrols( 0 ); - self.hostmigrationcontrolsfrozen = 0; -/# - println( " Host migration unfreeze controls" ); -#/ - } - if ( isDefined( self._host_migration_link_entity ) ) - { - self unlink(); - self._host_migration_link_helper delete(); - self._host_migration_link_helper = undefined; - if ( isDefined( self._host_migration_link_entity._post_host_migration_thread ) ) - { - self thread [[ self._host_migration_link_entity._post_host_migration_thread ]]( self._host_migration_link_entity ); - } - self._host_migration_link_entity = undefined; } } @@ -377,9 +268,9 @@ waitlongdurationwithhostmigrationpause( duration ) endtime += timepassed; } } +/# if ( getTime() != endtime ) { -/# println( "SCRIPT WARNING: gettime() = " + getTime() + " NOT EQUAL TO endtime = " + endtime ); #/ } @@ -387,6 +278,41 @@ waitlongdurationwithhostmigrationpause( duration ) return getTime() - starttime; } +waitlongdurationwithhostmigrationpauseemp( duration ) +{ + if ( duration == 0 ) + { + return; + } +/# + assert( duration > 0 ); +#/ + starttime = getTime(); + empendtime = getTime() + ( duration * 1000 ); + level.empendtime = empendtime; + while ( getTime() < empendtime ) + { + waittillhostmigrationstarts( ( empendtime - getTime() ) / 1000 ); + if ( isDefined( level.hostmigrationtimer ) ) + { + timepassed = waittillhostmigrationdone(); + if ( isDefined( empendtime ) ) + { + empendtime += timepassed; + } + } + } +/# + if ( getTime() != empendtime ) + { + println( "SCRIPT WARNING: gettime() = " + getTime() + " NOT EQUAL TO empendtime = " + empendtime ); +#/ + } + waittillhostmigrationdone(); + level.empendtime = undefined; + return getTime() - starttime; +} + waitlongdurationwithgameendtimeupdate( duration ) { if ( duration == 0 ) @@ -422,125 +348,3 @@ waitlongdurationwithgameendtimeupdate( duration ) } return getTime() - starttime; } - -find_alternate_player_place( v_origin, min_radius, max_radius, max_height, ignore_targetted_nodes ) -{ - found_node = undefined; - a_nodes = getnodesinradiussorted( v_origin, max_radius, min_radius, max_height, "pathnodes" ); - while ( isDefined( a_nodes ) && a_nodes.size > 0 ) - { - a_player_volumes = getentarray( "player_volume", "script_noteworthy" ); - index = a_nodes.size - 1; - i = index; - while ( i >= 0 ) - { - n_node = a_nodes[ i ]; - if ( ignore_targetted_nodes == 1 ) - { - if ( isDefined( n_node.target ) ) - { - i--; - continue; - } - } - else - { - if ( !positionwouldtelefrag( n_node.origin ) ) - { - if ( maps/mp/zombies/_zm_utility::check_point_in_enabled_zone( n_node.origin, 1, a_player_volumes ) ) - { - v_start = ( n_node.origin[ 0 ], n_node.origin[ 1 ], n_node.origin[ 2 ] + 30 ); - v_end = ( n_node.origin[ 0 ], n_node.origin[ 1 ], n_node.origin[ 2 ] - 30 ); - trace = bullettrace( v_start, v_end, 0, undefined ); - if ( trace[ "fraction" ] < 1 ) - { - override_abort = 0; - if ( isDefined( level._chugabud_reject_node_override_func ) ) - { - override_abort = [[ level._chugabud_reject_node_override_func ]]( v_origin, n_node ); - } - if ( !override_abort ) - { - found_node = n_node; - break; - } - } - } - } - } - else - { - i--; - - } - } - } - return found_node; -} - -hostmigration_put_player_in_better_place() -{ - spawnpoint = undefined; - spawnpoint = find_alternate_player_place( self.origin, 50, 150, 64, 1 ); - if ( !isDefined( spawnpoint ) ) - { - spawnpoint = find_alternate_player_place( self.origin, 150, 400, 64, 1 ); - } - if ( !isDefined( spawnpoint ) ) - { - spawnpoint = find_alternate_player_place( self.origin, 50, 400, 256, 0 ); - } - if ( !isDefined( spawnpoint ) ) - { - spawnpoint = maps/mp/zombies/_zm::check_for_valid_spawn_near_team( self, 1 ); - } - if ( !isDefined( spawnpoint ) ) - { - match_string = ""; - location = level.scr_zm_map_start_location; - if ( location != "default" && location == "" && isDefined( level.default_start_location ) ) - { - location = level.default_start_location; - } - match_string = ( level.scr_zm_ui_gametype + "_" ) + location; - spawnpoints = []; - structs = getstructarray( "initial_spawn", "script_noteworthy" ); - while ( isDefined( structs ) ) - { - _a559 = structs; - _k559 = getFirstArrayKey( _a559 ); - while ( isDefined( _k559 ) ) - { - struct = _a559[ _k559 ]; - while ( isDefined( struct.script_string ) ) - { - tokens = strtok( struct.script_string, " " ); - _a565 = tokens; - _k565 = getFirstArrayKey( _a565 ); - while ( isDefined( _k565 ) ) - { - token = _a565[ _k565 ]; - if ( token == match_string ) - { - spawnpoints[ spawnpoints.size ] = struct; - } - _k565 = getNextArrayKey( _a565, _k565 ); - } - } - _k559 = getNextArrayKey( _a559, _k559 ); - } - } - if ( !isDefined( spawnpoints ) || spawnpoints.size == 0 ) - { - spawnpoints = getstructarray( "initial_spawn_points", "targetname" ); - } -/# - assert( isDefined( spawnpoints ), "Could not find initial spawn points!" ); -#/ - spawnpoint = maps/mp/zombies/_zm::getfreespawnpoint( spawnpoints, self ); - } - if ( isDefined( spawnpoint ) ) - { - self setorigin( spawnpoint.origin ); - } -} diff --git a/patch_mp/maps/mp/gametypes/_hud.gsc b/patch_mp/maps/mp/gametypes/_hud.gsc index 529ea3f..31aa28a 100644 --- a/patch_mp/maps/mp/gametypes/_hud.gsc +++ b/patch_mp/maps/mp/gametypes/_hud.gsc @@ -31,11 +31,14 @@ init() level.primaryprogressbartexty = -75; level.primaryprogressbartextx = 0; level.primaryprogressbarfontsize = 1,4; - level.primaryprogressbarx_ss = 20; - level.primaryprogressbartextx_ss = 20; - level.primaryprogressbary_ss = 30; - level.primaryprogressbartexty_ss = 33; - level.primaryprogressbarheight_ss = 2; + if ( level.splitscreen ) + { + level.primaryprogressbarx = 20; + level.primaryprogressbartextx = 20; + level.primaryprogressbary = 15; + level.primaryprogressbartexty = 0; + level.primaryprogressbarheight = 2; + } level.secondaryprogressbary = -85; level.secondaryprogressbarx = 0; level.secondaryprogressbarheight = 9; @@ -43,23 +46,32 @@ init() level.secondaryprogressbartexty = -100; level.secondaryprogressbartextx = 0; level.secondaryprogressbarfontsize = 1,4; - level.secondaryprogressbarx_ss = 20; - level.secondaryprogressbartextx_ss = 20; - level.secondaryprogressbary_ss = 15; - level.secondaryprogressbartexty_ss = 0; - level.secondaryprogressbarheight_ss = 2; + if ( level.splitscreen ) + { + level.secondaryprogressbarx = 20; + level.secondaryprogressbartextx = 20; + level.secondaryprogressbary = 15; + level.secondaryprogressbartexty = 0; + level.secondaryprogressbarheight = 2; + } level.teamprogressbary = 32; level.teamprogressbarheight = 14; level.teamprogressbarwidth = 192; level.teamprogressbartexty = 8; level.teamprogressbarfontsize = 1,65; setdvar( "ui_generic_status_bar", 0 ); - level.lowertextyalign = "BOTTOM"; - level.lowertexty = -42; - level.lowertextfontsize = 1,4; - level.lowertextyalign_ss = "CENTER"; - level.lowertexty_ss = 40; - level.lowertextfontsize_ss = 1,4; + if ( level.splitscreen ) + { + level.lowertextyalign = "BOTTOM"; + level.lowertexty = -42; + level.lowertextfontsize = 1,4; + } + else + { + level.lowertextyalign = "CENTER"; + level.lowertexty = 40; + level.lowertextfontsize = 1,4; + } } fontpulseinit() @@ -106,12 +118,8 @@ fontpulse( player ) } } -fadetoblackforxsec( startwait, blackscreenwait, fadeintime, fadeouttime, shadername, n_sort ) +fadetoblackforxsec( startwait, blackscreenwait, fadeintime, fadeouttime, shadername ) { - if ( !isDefined( n_sort ) ) - { - n_sort = 50; - } wait startwait; if ( !isDefined( self ) ) { @@ -128,7 +136,8 @@ fadetoblackforxsec( startwait, blackscreenwait, fadeintime, fadeouttime, shadern self.blackscreen.foreground = 0; self.blackscreen.hidewhendead = 0; self.blackscreen.hidewheninmenu = 1; - self.blackscreen.sort = n_sort; + self.blackscreen.immunetodemogamehudsettings = 1; + self.blackscreen.sort = 50; if ( isDefined( shadername ) ) { self.blackscreen setshader( shadername, 640, 480 ); diff --git a/patch_mp/maps/mp/gametypes/_hud_message.gsc b/patch_mp/maps/mp/gametypes/_hud_message.gsc index 2425d13..678ca05 100644 --- a/patch_mp/maps/mp/gametypes/_hud_message.gsc +++ b/patch_mp/maps/mp/gametypes/_hud_message.gsc @@ -1,8 +1,8 @@ #include maps/mp/_utility; -#include maps/mp/gametypes_zm/_globallogic_audio; +#include maps/mp/gametypes/_globallogic_audio; #include maps/mp/_music; -#include maps/mp/gametypes_zm/_hud_message; -#include maps/mp/gametypes_zm/_hud_util; +#include maps/mp/gametypes/_hud_message; +#include maps/mp/gametypes/_hud_util; init() { @@ -99,7 +99,7 @@ hintmessageplayers( players, hinttext, duration ) showinitialfactionpopup( team ) { self luinotifyevent( &"faction_popup", 1, game[ "strings" ][ team + "_name" ] ); - maps/mp/gametypes_zm/_hud_message::oldnotifymessage( undefined, undefined, undefined, undefined ); + maps/mp/gametypes/_hud_message::oldnotifymessage( undefined, undefined, undefined, undefined ); } initnotifymessage() @@ -111,7 +111,7 @@ initnotifymessage() titlesize = 2; textsize = 1,4; iconsize = 24; - font = "extrabig"; + font = "big"; point = "TOP"; relativepoint = "BOTTOM"; yoffset = 30; @@ -122,7 +122,7 @@ initnotifymessage() titlesize = 2,5; textsize = 1,75; iconsize = 30; - font = "extrabig"; + font = "big"; point = "TOP"; relativepoint = "BOTTOM"; yoffset = 0; @@ -134,7 +134,7 @@ initnotifymessage() titlesize = 2; textsize = 1,4; iconsize = 24; - font = "extrabig"; + font = "big"; point = "TOP"; relativepoint = "BOTTOM"; yoffset = 30; @@ -145,7 +145,7 @@ initnotifymessage() titlesize = 2,5; textsize = 1,75; iconsize = 30; - font = "extrabig"; + font = "big"; point = "BOTTOM LEFT"; relativepoint = "TOP"; yoffset = 0; @@ -205,6 +205,19 @@ notifymessage( notifydata ) self notify( "received award" ); } +playnotifyloop( duration ) +{ + playnotifyloop = spawn( "script_origin", ( 1, 1, 1 ) ); + playnotifyloop playloopsound( "uin_notify_data_loop" ); + duration -= 4; + if ( duration < 1 ) + { + duration = 1; + } + wait duration; + playnotifyloop delete(); +} + shownotifymessage( notifydata, duration ) { self endon( "disconnect" ); @@ -222,7 +235,7 @@ shownotifymessage( notifydata, duration ) } if ( isDefined( notifydata.leadersound ) ) { - self maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( notifydata.leadersound ); + self maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( notifydata.leadersound ); } if ( isDefined( notifydata.glowcolor ) ) { @@ -368,6 +381,10 @@ waitrequirevisibility( waittime ) canreadtext() { + if ( self maps/mp/_utility::isflashbanged() ) + { + return 0; + } return 1; } @@ -414,8 +431,13 @@ hintmessagedeaththink() lowermessagethink() { self endon( "disconnect" ); + messagetexty = level.lowertexty; + if ( self issplitscreen() ) + { + messagetexty = level.lowertexty - 50; + } self.lowermessage = createfontstring( "default", level.lowertextfontsize ); - self.lowermessage setpoint( "CENTER", level.lowertextyalign, 0, level.lowertexty ); + self.lowermessage setpoint( "CENTER", level.lowertextyalign, 0, messagetexty ); self.lowermessage settext( "" ); self.lowermessage.archived = 0; timerfontsize = 1,5; @@ -494,12 +516,16 @@ teamoutcomenotify( winner, isround, endreasontext ) outcometitle.glowalpha = 1; outcometitle.hidewheninmenu = 0; outcometitle.archived = 0; + outcometitle.immunetodemogamehudsettings = 1; + outcometitle.immunetodemofreecamera = 1; outcometext = createfontstring( font, 2 ); outcometext setparent( outcometitle ); outcometext setpoint( "TOP", "BOTTOM", 0, 0 ); outcometext.glowalpha = 1; outcometext.hidewheninmenu = 0; outcometext.archived = 0; + outcometext.immunetodemogamehudsettings = 1; + outcometext.immunetodemofreecamera = 1; if ( winner == "halftime" ) { outcometitle settext( game[ "strings" ][ "halftime" ] ); @@ -548,6 +574,10 @@ teamoutcomenotify( winner, isround, endreasontext ) outcometitle settext( game[ "strings" ][ "victory" ] ); } outcometitle.color = ( 0,42, 0,68, 0,46 ); + if ( isDefined( level.endvictoryreasontext ) ) + { + endreasontext = level.endvictoryreasontext; + } } else { @@ -560,6 +590,10 @@ teamoutcomenotify( winner, isround, endreasontext ) outcometitle settext( game[ "strings" ][ "defeat" ] ); } outcometitle.color = ( 0,73, 0,29, 0,19 ); + if ( isDefined( level.enddefeatreasontext ) ) + { + endreasontext = level.enddefeatreasontext; + } } outcometext settext( endreasontext ); outcometitle setcod7decodefx( 200, duration, 600 ); @@ -572,15 +606,17 @@ teamoutcomenotify( winner, isround, endreasontext ) teamicons[ team ] setpoint( "TOP", "BOTTOM", currentx, spacing ); teamicons[ team ].hidewheninmenu = 0; teamicons[ team ].archived = 0; + teamicons[ team ].immunetodemogamehudsettings = 1; + teamicons[ team ].immunetodemofreecamera = 1; teamicons[ team ].alpha = 0; teamicons[ team ] fadeovertime( 0,5 ); teamicons[ team ].alpha = 1; currentx += iconspacing; - _a607 = level.teams; - _k607 = getFirstArrayKey( _a607 ); - while ( isDefined( _k607 ) ) + _a650 = level.teams; + _k650 = getFirstArrayKey( _a650 ); + while ( isDefined( _k650 ) ) { - enemyteam = _a607[ _k607 ]; + enemyteam = _a650[ _k650 ]; if ( team == enemyteam ) { } @@ -591,12 +627,14 @@ teamoutcomenotify( winner, isround, endreasontext ) teamicons[ enemyteam ] setpoint( "TOP", "BOTTOM", currentx, spacing ); teamicons[ enemyteam ].hidewheninmenu = 0; teamicons[ enemyteam ].archived = 0; + teamicons[ enemyteam ].immunetodemogamehudsettings = 1; + teamicons[ enemyteam ].immunetodemofreecamera = 1; teamicons[ enemyteam ].alpha = 0; teamicons[ enemyteam ] fadeovertime( 0,5 ); teamicons[ enemyteam ].alpha = 1; currentx += iconspacing; } - _k607 = getNextArrayKey( _a607, _k607 ); + _k650 = getNextArrayKey( _a650, _k650 ); } teamscores = []; teamscores[ team ] = createfontstring( font, titlesize ); @@ -613,12 +651,14 @@ teamoutcomenotify( winner, isround, endreasontext ) } teamscores[ team ].hidewheninmenu = 0; teamscores[ team ].archived = 0; + teamscores[ team ].immunetodemogamehudsettings = 1; + teamscores[ team ].immunetodemofreecamera = 1; teamscores[ team ] setpulsefx( 100, duration, 1000 ); - _a641 = level.teams; - _k641 = getFirstArrayKey( _a641 ); - while ( isDefined( _k641 ) ) + _a688 = level.teams; + _k688 = getFirstArrayKey( _a688 ); + while ( isDefined( _k688 ) ) { - enemyteam = _a641[ _k641 ]; + enemyteam = _a688[ _k688 ]; if ( team == enemyteam ) { } @@ -638,22 +678,30 @@ teamoutcomenotify( winner, isround, endreasontext ) } teamscores[ enemyteam ].hidewheninmenu = 0; teamscores[ enemyteam ].archived = 0; + teamscores[ enemyteam ].immunetodemogamehudsettings = 1; + teamscores[ enemyteam ].immunetodemofreecamera = 1; teamscores[ enemyteam ] setpulsefx( 100, duration, 1000 ); } - _k641 = getNextArrayKey( _a641, _k641 ); + _k688 = getNextArrayKey( _a688, _k688 ); } font = "objective"; matchbonus = undefined; if ( isDefined( self.matchbonus ) ) { - matchbonus = createfontstring( font, 2 ); - matchbonus setparent( outcometext ); - matchbonus setpoint( "TOP", "BOTTOM", 0, iconsize + ( spacing * 3 ) + teamscores[ team ].height ); - matchbonus.glowalpha = 1; - matchbonus.hidewheninmenu = 0; - matchbonus.archived = 0; - matchbonus.label = game[ "strings" ][ "match_bonus" ]; - matchbonus setvalue( self.matchbonus ); + bonus = ceil( self.matchbonus * level.xpscale ); + if ( bonus > 0 ) + { + matchbonus = createfontstring( font, 2 ); + matchbonus setparent( outcometext ); + matchbonus setpoint( "TOP", "BOTTOM", 0, iconsize + ( spacing * 3 ) + teamscores[ team ].height ); + matchbonus.glowalpha = 1; + matchbonus.hidewheninmenu = 0; + matchbonus.archived = 0; + matchbonus.immunetodemogamehudsettings = 1; + matchbonus.immunetodemofreecamera = 1; + matchbonus.label = game[ "strings" ][ "match_bonus" ]; + matchbonus setvalue( bonus ); + } } self thread resetoutcomenotify( teamicons, teamscores, outcometitle, outcometext ); } @@ -688,7 +736,7 @@ teamoutcomenotifyzombie( winner, isround, endreasontext ) wait 0,05; } self endon( "reset_outcome" ); - if ( self issplitscreen() ) + if ( level.splitscreen ) { titlesize = 2; spacing = 10; @@ -705,11 +753,27 @@ teamoutcomenotifyzombie( winner, isround, endreasontext ) outcometitle.glowalpha = 1; outcometitle.hidewheninmenu = 0; outcometitle.archived = 0; + outcometitle.immunetodemogamehudsettings = 1; + outcometitle.immunetodemofreecamera = 1; outcometitle settext( endreasontext ); outcometitle setpulsefx( 100, 60000, 1000 ); self thread resetoutcomenotify( undefined, undefined, outcometitle ); } +isintop( players, topn ) +{ + i = 0; + while ( i < topn ) + { + if ( isDefined( players[ i ] ) && self == players[ i ] ) + { + return 1; + } + i++; + } + return 0; +} + outcomenotify( winner, isroundend, endreasontext ) { self endon( "disconnect" ); @@ -747,34 +811,26 @@ outcomenotify( winner, isroundend, endreasontext ) } else { - if ( isDefined( players[ 1 ] ) && players[ 0 ].score == players[ 1 ].score && players[ 0 ].deaths == players[ 1 ].deaths || self == players[ 0 ] && self == players[ 1 ] ) + if ( players[ 0 ].pointstowin == 0 ) { outcometitle settext( game[ "strings" ][ "tie" ] ); } + else if ( self isintop( players, 3 ) ) + { + outcometitle settext( game[ "strings" ][ "victory" ] ); + outcometitle.color = ( 0,42, 0,68, 0,46 ); + } else { - if ( isDefined( players[ 2 ] ) && players[ 0 ].score == players[ 2 ].score && players[ 0 ].deaths == players[ 2 ].deaths && self == players[ 2 ] ) - { - outcometitle settext( game[ "strings" ][ "tie" ] ); - } - else - { - if ( isDefined( players[ 0 ] ) && self == players[ 0 ] ) - { - outcometitle settext( game[ "strings" ][ "victory" ] ); - outcometitle.color = ( 0,42, 0,68, 0,46 ); - } - else - { - outcometitle settext( game[ "strings" ][ "defeat" ] ); - outcometitle.color = ( 0,73, 0,29, 0,19 ); - } - } + outcometitle settext( game[ "strings" ][ "defeat" ] ); + outcometitle.color = ( 0,73, 0,29, 0,19 ); } } outcometitle.glowalpha = 1; outcometitle.hidewheninmenu = 0; outcometitle.archived = 0; + outcometitle.immunetodemogamehudsettings = 1; + outcometitle.immunetodemofreecamera = 1; outcometitle setcod7decodefx( 200, duration, 600 ); outcometext = createfontstring( font, 2 ); outcometext setparent( outcometitle ); @@ -782,6 +838,8 @@ outcomenotify( winner, isroundend, endreasontext ) outcometext.glowalpha = 1; outcometext.hidewheninmenu = 0; outcometext.archived = 0; + outcometext.immunetodemogamehudsettings = 1; + outcometext.immunetodemofreecamera = 1; outcometext settext( endreasontext ); firsttitle = createfontstring( font, winnersize ); firsttitle setparent( outcometext ); @@ -789,6 +847,8 @@ outcomenotify( winner, isroundend, endreasontext ) firsttitle.glowalpha = 1; firsttitle.hidewheninmenu = 0; firsttitle.archived = 0; + firsttitle.immunetodemogamehudsettings = 1; + firsttitle.immunetodemofreecamera = 1; if ( isDefined( players[ 0 ] ) ) { firsttitle.label = &"MP_FIRSTPLACE_NAME"; @@ -801,6 +861,8 @@ outcomenotify( winner, isroundend, endreasontext ) secondtitle.glowalpha = 1; secondtitle.hidewheninmenu = 0; secondtitle.archived = 0; + secondtitle.immunetodemogamehudsettings = 1; + secondtitle.immunetodemofreecamera = 1; if ( isDefined( players[ 1 ] ) ) { secondtitle.label = &"MP_SECONDPLACE_NAME"; @@ -814,6 +876,8 @@ outcomenotify( winner, isroundend, endreasontext ) thirdtitle.glowalpha = 1; thirdtitle.hidewheninmenu = 0; thirdtitle.archived = 0; + thirdtitle.immunetodemogamehudsettings = 1; + thirdtitle.immunetodemofreecamera = 1; if ( isDefined( players[ 2 ] ) ) { thirdtitle.label = &"MP_THIRDPLACE_NAME"; @@ -826,10 +890,16 @@ outcomenotify( winner, isroundend, endreasontext ) matchbonus.glowalpha = 1; matchbonus.hidewheninmenu = 0; matchbonus.archived = 0; + matchbonus.immunetodemogamehudsettings = 1; + matchbonus.immunetodemofreecamera = 1; if ( isDefined( self.matchbonus ) ) { - matchbonus.label = game[ "strings" ][ "match_bonus" ]; - matchbonus setvalue( self.matchbonus ); + bonus = ceil( self.matchbonus * level.xpscale ); + if ( bonus > 0 ) + { + matchbonus.label = game[ "strings" ][ "match_bonus" ]; + matchbonus setvalue( bonus ); + } } self thread updateoutcome( firsttitle, secondtitle, thirdtitle ); self thread resetoutcomenotify( undefined, undefined, outcometitle, outcometext, firsttitle, secondtitle, thirdtitle, matchbonus ); @@ -899,6 +969,8 @@ wageroutcomenotify( winner, endreasontext ) outcometitle.glowalpha = 1; outcometitle.hidewheninmenu = 0; outcometitle.archived = 0; + outcometitle.immunetodemogamehudsettings = 1; + outcometitle.immunetodemofreecamera = 1; outcometitle setcod7decodefx( 200, duration, 600 ); outcometext = createfontstring( font, 2 ); outcometext setparent( outcometitle ); @@ -906,6 +978,8 @@ wageroutcomenotify( winner, endreasontext ) outcometext.glowalpha = 1; outcometext.hidewheninmenu = 0; outcometext.archived = 0; + outcometext.immunetodemogamehudsettings = 1; + outcometext.immunetodemofreecamera = 1; outcometext settext( endreasontext ); playernamehudelems = []; playercphudelems = []; @@ -929,6 +1003,8 @@ wageroutcomenotify( winner, endreasontext ) secondtitle.glowalpha = 1; secondtitle.hidewheninmenu = 0; secondtitle.archived = 0; + secondtitle.immunetodemogamehudsettings = 1; + secondtitle.immunetodemofreecamera = 1; secondtitle.label = &"MP_WAGER_PLACE_NAME"; secondtitle.playernum = i; secondtitle setplayernamestring( players[ i ] ); @@ -939,6 +1015,8 @@ wageroutcomenotify( winner, endreasontext ) secondcp.glowalpha = 1; secondcp.hidewheninmenu = 0; secondcp.archived = 0; + secondcp.immunetodemogamehudsettings = 1; + secondcp.immunetodemofreecamera = 1; secondcp.label = &"MENU_POINTS"; secondcp.currentvalue = 0; if ( isDefined( players[ i ].wagerwinnings ) ) @@ -1039,12 +1117,16 @@ teamwageroutcomenotify( winner, isroundend, endreasontext ) outcometitle.glowalpha = 1; outcometitle.hidewheninmenu = 0; outcometitle.archived = 0; + outcometitle.immunetodemogamehudsettings = 1; + outcometitle.immunetodemofreecamera = 1; outcometext = createfontstring( font, 2 ); outcometext setparent( outcometitle ); outcometext setpoint( "TOP", "BOTTOM", 0, 0 ); outcometext.glowalpha = 1; outcometext.hidewheninmenu = 0; outcometext.archived = 0; + outcometext.immunetodemogamehudsettings = 1; + outcometext.immunetodemofreecamera = 1; if ( winner == "tie" ) { if ( isroundend ) @@ -1102,11 +1184,13 @@ teamwageroutcomenotify( winner, isroundend, endreasontext ) teamicons[ team ].alpha = 0; teamicons[ team ] fadeovertime( 0,5 ); teamicons[ team ].alpha = 1; - _a1171 = level.teams; - _k1171 = getFirstArrayKey( _a1171 ); - while ( isDefined( _k1171 ) ) + teamicons[ team ].immunetodemogamehudsettings = 1; + teamicons[ team ].immunetodemofreecamera = 1; + _a1269 = level.teams; + _k1269 = getFirstArrayKey( _a1269 ); + while ( isDefined( _k1269 ) ) { - enemyteam = _a1171[ _k1171 ]; + enemyteam = _a1269[ _k1269 ]; if ( team == enemyteam ) { } @@ -1120,8 +1204,10 @@ teamwageroutcomenotify( winner, isroundend, endreasontext ) teamicons[ enemyteam ].alpha = 0; teamicons[ enemyteam ] fadeovertime( 0,5 ); teamicons[ enemyteam ].alpha = 1; + teamicons[ enemyteam ].immunetodemogamehudsettings = 1; + teamicons[ enemyteam ].immunetodemofreecamera = 1; } - _k1171 = getNextArrayKey( _a1171, _k1171 ); + _k1269 = getNextArrayKey( _a1269, _k1269 ); } teamscores = []; teamscores[ team ] = createfontstring( font, titlesize ); @@ -1131,12 +1217,14 @@ teamwageroutcomenotify( winner, isroundend, endreasontext ) teamscores[ team ] setvalue( getteamscore( team ) ); teamscores[ team ].hidewheninmenu = 0; teamscores[ team ].archived = 0; + teamscores[ team ].immunetodemogamehudsettings = 1; + teamscores[ team ].immunetodemofreecamera = 1; teamscores[ team ] setpulsefx( 100, duration, 1000 ); - _a1197 = level.teams; - _k1197 = getFirstArrayKey( _a1197 ); - while ( isDefined( _k1197 ) ) + _a1299 = level.teams; + _k1299 = getFirstArrayKey( _a1299 ); + while ( isDefined( _k1299 ) ) { - enemyteam = _a1197[ _k1197 ]; + enemyteam = _a1299[ _k1299 ]; if ( team == enemyteam ) { } @@ -1149,9 +1237,11 @@ teamwageroutcomenotify( winner, isroundend, endreasontext ) teamscores[ enemyteam ] setvalue( getteamscore( enemyteam ) ); teamscores[ enemyteam ].hidewheninmenu = 0; teamscores[ enemyteam ].archived = 0; + teamscores[ enemyteam ].immunetodemogamehudsettings = 1; + teamscores[ enemyteam ].immunetodemofreecamera = 1; teamscores[ enemyteam ] setpulsefx( 100, duration, 1000 ); } - _k1197 = getNextArrayKey( _a1197, _k1197 ); + _k1299 = getNextArrayKey( _a1299, _k1299 ); } matchbonus = undefined; sidebetwinnings = undefined; @@ -1163,6 +1253,8 @@ teamwageroutcomenotify( winner, isroundend, endreasontext ) matchbonus.glowalpha = 1; matchbonus.hidewheninmenu = 0; matchbonus.archived = 0; + matchbonus.immunetodemogamehudsettings = 1; + matchbonus.immunetodemofreecamera = 1; matchbonus.label = game[ "strings" ][ "wager_winnings" ]; matchbonus setvalue( self.wagerwinnings ); if ( isDefined( game[ "side_bets" ] ) && game[ "side_bets" ] ) @@ -1173,6 +1265,8 @@ teamwageroutcomenotify( winner, isroundend, endreasontext ) sidebetwinnings.glowalpha = 1; sidebetwinnings.hidewheninmenu = 0; sidebetwinnings.archived = 0; + sidebetwinnings.immunetodemogamehudsettings = 1; + sidebetwinnings.immunetodemofreecamera = 1; sidebetwinnings.label = game[ "strings" ][ "wager_sidebet_winnings" ]; sidebetwinnings setvalue( self.pers[ "wager_sideBetWinnings" ] ); } @@ -1202,24 +1296,24 @@ resetoutcomenotify( hudelemlist1, hudelemlist2, hudelem3, hudelem4, hudelem5, hu destroyhudelem( hudelem10 ); while ( isDefined( hudelemlist1 ) ) { - _a1263 = hudelemlist1; - _k1263 = getFirstArrayKey( _a1263 ); - while ( isDefined( _k1263 ) ) + _a1371 = hudelemlist1; + _k1371 = getFirstArrayKey( _a1371 ); + while ( isDefined( _k1371 ) ) { - elem = _a1263[ _k1263 ]; + elem = _a1371[ _k1371 ]; destroyhudelem( elem ); - _k1263 = getNextArrayKey( _a1263, _k1263 ); + _k1371 = getNextArrayKey( _a1371, _k1371 ); } } while ( isDefined( hudelemlist2 ) ) { - _a1271 = hudelemlist2; - _k1271 = getFirstArrayKey( _a1271 ); - while ( isDefined( _k1271 ) ) + _a1379 = hudelemlist2; + _k1379 = getFirstArrayKey( _a1379 ); + while ( isDefined( _k1379 ) ) { - elem = _a1271[ _k1271 ]; + elem = _a1379[ _k1379 ]; destroyhudelem( elem ); - _k1271 = getNextArrayKey( _a1271, _k1271 ); + _k1379 = getNextArrayKey( _a1379, _k1379 ); } } } diff --git a/patch_mp/maps/mp/gametypes/_hud_util.gsc b/patch_mp/maps/mp/gametypes/_hud_util.gsc index 16b74f2..627126a 100644 --- a/patch_mp/maps/mp/gametypes/_hud_util.gsc +++ b/patch_mp/maps/mp/gametypes/_hud_util.gsc @@ -571,7 +571,7 @@ createbar( color, width, height, flashfrac ) barelemframe.hidden = 0; barelembg = newclienthudelem( self ); barelembg.elemtype = "bar"; - if ( !self issplitscreen() ) + if ( !level.splitscreen ) { barelembg.x = -2; barelembg.y = -2; @@ -587,7 +587,7 @@ createbar( color, width, height, flashfrac ) barelembg.color = ( 1, 0, 0 ); barelembg.alpha = 0,5; barelembg setparent( level.uiparent ); - if ( !self issplitscreen() ) + if ( !level.splitscreen ) { barelembg setshader( "progress_bar_bg", width + 4, height + 4 ); } @@ -619,15 +619,13 @@ getcurrentfraction() createprimaryprogressbar() { - bar = undefined; - if ( self issplitscreen() ) + bar = createbar( ( 1, 0, 0 ), level.primaryprogressbarwidth, level.primaryprogressbarheight ); + if ( level.splitscreen ) { - bar = self createbar( ( 1, 0, 0 ), level.primaryprogressbarwidth, level.primaryprogressbarheight_ss ); - bar setpoint( "TOP", undefined, level.primaryprogressbarx_ss, level.primaryprogressbary_ss ); + bar setpoint( "TOP", undefined, level.primaryprogressbarx, level.primaryprogressbary ); } else { - bar = self createbar( ( 1, 0, 0 ), level.primaryprogressbarwidth, level.primaryprogressbarheight ); bar setpoint( "CENTER", undefined, level.primaryprogressbarx, level.primaryprogressbary ); } return bar; @@ -636,9 +634,9 @@ createprimaryprogressbar() createprimaryprogressbartext() { text = createfontstring( "objective", level.primaryprogressbarfontsize ); - if ( self issplitscreen() ) + if ( level.splitscreen ) { - text setpoint( "TOP", undefined, level.primaryprogressbartextx_ss, level.primaryprogressbartexty_ss ); + text setpoint( "TOP", undefined, level.primaryprogressbartextx, level.primaryprogressbartexty ); } else { @@ -653,18 +651,13 @@ createsecondaryprogressbar() secondaryprogressbarheight = getdvarintdefault( "scr_secondaryProgressBarHeight", level.secondaryprogressbarheight ); secondaryprogressbarx = getdvarintdefault( "scr_secondaryProgressBarX", level.secondaryprogressbarx ); secondaryprogressbary = getdvarintdefault( "scr_secondaryProgressBarY", level.secondaryprogressbary ); - secondaryprogressbarheight_ss = getdvarintdefault( "scr_secondaryProgressBarHeight", level.secondaryprogressbarheight_ss ); - secondaryprogressbarx_ss = getdvarintdefault( "scr_secondaryProgressBarX", level.secondaryprogressbarx_ss ); - secondaryprogressbary_ss = getdvarintdefault( "scr_secondaryProgressBarY", level.secondaryprogressbary_ss ); - bar = undefined; - if ( self issplitscreen() ) + bar = createbar( ( 1, 0, 0 ), level.secondaryprogressbarwidth, secondaryprogressbarheight ); + if ( level.splitscreen ) { - bar = self createbar( ( 1, 0, 0 ), level.secondaryprogressbarwidth, secondaryprogressbarheight_ss ); - bar setpoint( "TOP", undefined, secondaryprogressbarx_ss, secondaryprogressbary_ss ); + bar setpoint( "TOP", undefined, secondaryprogressbarx, secondaryprogressbary ); } else { - bar = self createbar( ( 1, 0, 0 ), level.secondaryprogressbarwidth, secondaryprogressbarheight ); bar setpoint( "CENTER", undefined, secondaryprogressbarx, secondaryprogressbary ); } return bar; @@ -674,12 +667,10 @@ createsecondaryprogressbartext() { secondaryprogressbartextx = getdvarintdefault( "scr_btx", level.secondaryprogressbartextx ); secondaryprogressbartexty = getdvarintdefault( "scr_bty", level.secondaryprogressbartexty ); - secondaryprogressbartextx_ss = getdvarintdefault( "scr_btx", level.secondaryprogressbartextx_ss ); - secondaryprogressbartexty_ss = getdvarintdefault( "scr_bty", level.secondaryprogressbartexty_ss ); text = createfontstring( "objective", level.primaryprogressbarfontsize ); - if ( self issplitscreen() ) + if ( level.splitscreen ) { - text setpoint( "TOP", undefined, secondaryprogressbartextx_ss, secondaryprogressbartexty_ss ); + text setpoint( "TOP", undefined, secondaryprogressbartextx, secondaryprogressbartexty ); } else { @@ -858,25 +849,15 @@ updatechildren() } } -createloadouticon( verindex, horindex, xpos, ypos ) +createloadouticon( player, verindex, horindex, xpos, ypos ) { iconsize = 32; - if ( level.splitscreen ) + if ( player issplitscreen() ) { - ypos -= 80 + ( iconsize * ( 3 - verindex ) ); - } - else - { - ypos -= 90 + ( iconsize * ( 3 - verindex ) ); - } - if ( level.splitscreen ) - { - xpos -= 5 + ( iconsize * horindex ); - } - else - { - xpos -= 10 + ( iconsize * horindex ); + iconsize = 22; } + ypos -= 90 + ( iconsize * ( 3 - verindex ) ); + xpos -= 10 + ( iconsize * horindex ); icon = createicon( "white", iconsize, iconsize ); icon setpoint( "BOTTOM RIGHT", "BOTTOM RIGHT", xpos, ypos ); icon.horzalign = "user_right"; @@ -886,25 +867,15 @@ createloadouticon( verindex, horindex, xpos, ypos ) return icon; } -setloadouticoncoords( verindex, horindex, xpos, ypos ) +setloadouticoncoords( player, verindex, horindex, xpos, ypos ) { iconsize = 32; - if ( level.splitscreen ) + if ( player issplitscreen() ) { - ypos -= 80 + ( iconsize * ( 3 - verindex ) ); - } - else - { - ypos -= 90 + ( iconsize * ( 3 - verindex ) ); - } - if ( level.splitscreen ) - { - xpos -= 5 + ( iconsize * horindex ); - } - else - { - xpos -= 10 + ( iconsize * horindex ); + iconsize = 22; } + ypos -= 90 + ( iconsize * ( 3 - verindex ) ); + xpos -= 10 + ( iconsize * horindex ); self setpoint( "BOTTOM RIGHT", "BOTTOM RIGHT", xpos, ypos ); self.horzalign = "user_right"; self.vertalign = "user_bottom"; @@ -974,16 +945,20 @@ hideloadoutattribute( iconelem, fadetime, textelem, hidetextonly ) showperks() { ypos = 40; + if ( self issplitscreen() ) + { + ypos = 5; + } if ( !isDefined( self.perkhudelem ) ) { - self.perkhudelem = createloadouticon( 0, 0, 200, ypos ); + self.perkhudelem = createloadouticon( self, 0, 0, 200, ypos ); } else { - self.perkhudelem setloadouticoncoords( 0, 0, 200, ypos ); + self.perkhudelem setloadouticoncoords( self, 0, 0, 200, ypos ); } self.perkhudelem setperks( self ); - self.perkhudelem.x = -10; + self.perkhudelem.x = -20; self.perkhudelem.alpha = 0; self.perkhudelem fadeovertime( 0,4 ); self.perkhudelem.alpha = 1; @@ -1005,12 +980,12 @@ showperk( index, perk, ypos ) /# assert( !isDefined( self.perkname[ index ] ) ); #/ - self.perkicon[ index ] = createloadouticon( index, 0, 200, ypos ); + self.perkicon[ index ] = createloadouticon( self, index, 0, 200, ypos ); self.perkname[ index ] = createloadouttext( self.perkicon[ index ], 160 ); } else { - self.perkicon[ index ] setloadouticoncoords( index, 0, 200, ypos ); + self.perkicon[ index ] setloadouticoncoords( self, index, 0, 200, ypos ); self.perkname[ index ] setloadouttextcoords( 160 ); } if ( perk != "perk_null" || perk == "weapon_null" && perk == "specialty_null" ) @@ -1107,7 +1082,7 @@ showkillstreak( index, killstreak, xpos, ypos ) } if ( !isDefined( self.killstreakicon[ index ] ) ) { - self.killstreakicon[ index ] = createloadouticon( 3, ( self.killstreak.size - 1 ) - index, xpos, ypos ); + self.killstreakicon[ index ] = createloadouticon( self, 3, ( self.killstreak.size - 1 ) - index, xpos, ypos ); } if ( killstreak == "killstreak_null" || killstreak == "weapon_null" ) { @@ -1143,7 +1118,7 @@ hidekillstreak( index, fadetime ) setgamemodeinfopoint() { - self.x = 5; + self.x = 11; self.y = 120; self.horzalign = "user_left"; self.vertalign = "user_top"; diff --git a/patch_mp/maps/mp/gametypes/_menus.gsc b/patch_mp/maps/mp/gametypes/_menus.gsc index 97f9513..1a4d0db 100644 --- a/patch_mp/maps/mp/gametypes/_menus.gsc +++ b/patch_mp/maps/mp/gametypes/_menus.gsc @@ -1,5 +1,5 @@ -#include maps/mp/gametypes_zm/_rank; -#include maps/mp/gametypes_zm/_globallogic; +#include maps/mp/gametypes/_rank; +#include maps/mp/gametypes/_globallogic; #include maps/mp/_utility; init() @@ -97,26 +97,27 @@ onmenuresponse() } if ( response == "endgame" ) { - if ( self issplitscreen() ) + if ( level.splitscreen ) { level.skipvote = 1; if ( !level.gameended ) { - level thread maps/mp/gametypes_zm/_globallogic::forceend(); + level thread maps/mp/gametypes/_globallogic::forceend(); } } continue; } else if ( response == "killserverpc" ) { - level thread maps/mp/gametypes_zm/_globallogic::killserverpc(); + level thread maps/mp/gametypes/_globallogic::killserverpc(); continue; } else if ( response == "endround" ) { if ( !level.gameended ) { - level thread maps/mp/gametypes_zm/_globallogic::forceend(); + self gamehistoryplayerquit(); + level thread maps/mp/gametypes/_globallogic::forceend(); } else { @@ -150,7 +151,7 @@ onmenuresponse() self closeingamemenu(); if ( level.rankedmatch && issubstr( response, "custom" ) ) { - if ( self isitemlocked( maps/mp/gametypes_zm/_rank::getitemindex( "feature_cac" ) ) ) + if ( self isitemlocked( maps/mp/gametypes/_rank::getitemindex( "feature_cac" ) ) ) { kick( self getentitynumber() ); } diff --git a/patch_mp/maps/mp/gametypes/_scoreboard.gsc b/patch_mp/maps/mp/gametypes/_scoreboard.gsc index 9c57984..d3c2dc3 100644 --- a/patch_mp/maps/mp/gametypes/_scoreboard.gsc +++ b/patch_mp/maps/mp/gametypes/_scoreboard.gsc @@ -1,13 +1,6 @@ init() { - setdvar( "g_ScoresColor_Spectator", ".25 .25 .25" ); - setdvar( "g_ScoresColor_Free", ".76 .78 .10" ); - setdvar( "g_teamColor_MyTeam", ".4 .7 .4" ); - setdvar( "g_teamColor_EnemyTeam", "1 .315 0.35" ); - setdvar( "g_teamColor_MyTeamAlt", ".35 1 1" ); - setdvar( "g_teamColor_EnemyTeamAlt", "1 .5 0" ); - setdvar( "g_teamColor_Squad", ".315 0.35 1" ); if ( level.createfx_enabled ) { return; diff --git a/patch_mp/maps/mp/gametypes/_shellshock.gsc b/patch_mp/maps/mp/gametypes/_shellshock.gsc index c718e80..8a29ed1 100644 --- a/patch_mp/maps/mp/gametypes/_shellshock.gsc +++ b/patch_mp/maps/mp/gametypes/_shellshock.gsc @@ -11,7 +11,11 @@ init() shellshockondamage( cause, damage ) { - if ( cause != "MOD_EXPLOSIVE" && cause != "MOD_GRENADE" && cause != "MOD_GRENADE_SPLASH" || cause == "MOD_PROJECTILE" && cause == "MOD_PROJECTILE_SPLASH" ) + if ( self maps/mp/_utility::isflashbanged() ) + { + return; + } + if ( cause == "MOD_EXPLOSIVE" || cause == "MOD_GRENADE" || cause == "MOD_GRENADE_SPLASH" || cause == "MOD_PROJECTILE" || cause == "MOD_PROJECTILE_SPLASH" ) { time = 0; if ( damage >= 90 ) @@ -26,12 +30,9 @@ shellshockondamage( cause, damage ) { time = 2; } - else + if ( damage > 10 ) { - if ( damage > 10 ) - { - time = 2; - } + time = 2; } if ( time ) { @@ -62,4 +63,3 @@ rcbomb_earthquake( position ) playrumbleonposition( "grenade_rumble", position ); earthquake( 0.5, 0.5, self.origin, 512 ); } - diff --git a/patch_mp/maps/mp/gametypes/_spawning.gsc b/patch_mp/maps/mp/gametypes/_spawning.gsc index ce29a09..be6ca8b 100644 --- a/patch_mp/maps/mp/gametypes/_spawning.gsc +++ b/patch_mp/maps/mp/gametypes/_spawning.gsc @@ -1,4 +1,7 @@ -#include maps/mp/gametypes_zm/_spawnlogic; +#include maps/mp/gametypes/_spawnlogic; +#include maps/mp/gametypes/_callbacksetup; +#include maps/mp/_tacticalinsertion; +#include maps/mp/killstreaks/_airsupport; #include common_scripts/utility; #include maps/mp/_utility; @@ -102,9 +105,9 @@ onplayerspawned() for ( ;; ) { self waittill( "spawned_player" ); - self thread initialspawnprotection( "specialty_nottargetedbyairsupport", 1 ); - self thread initialspawnprotection( "specialty_nokillstreakreticle", 0 ); - self thread initialspawnprotection( "specialty_nottargettedbysentry", 0 ); + self maps/mp/killstreaks/_airsupport::clearmonitoredspeed(); + self thread initialspawnprotection(); + self thread monitorgpsjammer(); if ( isDefined( self.pers[ "hasRadar" ] ) && self.pers[ "hasRadar" ] ) { self.hasspyplane = 1; @@ -114,6 +117,108 @@ onplayerspawned() } } +monitorgpsjammer() +{ + self endon( "death" ); + self endon( "disconnect" ); + if ( self hasperk( "specialty_gpsjammer" ) == 0 ) + { + return; + } + self gpsjammeractive(); + graceperiods = getdvarintdefault( "perk_gpsjammer_graceperiods", 4 ); + minspeed = getdvarintdefault( "perk_gpsjammer_min_speed", 100 ); + mindistance = getdvarintdefault( "perk_gpsjammer_min_distance", 10 ); + timeperiod = getdvarintdefault( "perk_gpsjammer_time_period", 200 ); + timeperiodsec = timeperiod / 1000; + minspeedsq = minspeed * minspeed; + mindistancesq = mindistance * mindistance; + if ( minspeedsq == 0 ) + { + return; + } +/# + assert( timeperiodsec >= 0,05 ); +#/ + if ( timeperiodsec < 0,05 ) + { + return; + } + hasperk = 1; + statechange = 0; + faileddistancecheck = 0; + currentfailcount = 0; + timepassed = 0; + timesincedistancecheck = 0; + previousorigin = self.origin; + gpsjammerprotection = 0; + while ( 1 ) + { +/# + graceperiods = getdvarintdefault( "perk_gpsjammer_graceperiods", graceperiods ); + minspeed = getdvarintdefault( "perk_gpsjammer_min_speed", minspeed ); + mindistance = getdvarintdefault( "perk_gpsjammer_min_distance", mindistance ); + timeperiod = getdvarintdefault( "perk_gpsjammer_time_period", timeperiod ); + timeperiodsec = timeperiod / 1000; + minspeedsq = minspeed * minspeed; + mindistancesq = mindistance * mindistance; +#/ + gpsjammerprotection = 0; + if ( !isusingremote() || is_true( self.isplanting ) && is_true( self.isdefusing ) ) + { + gpsjammerprotection = 1; + } + else + { + if ( timesincedistancecheck > 1 ) + { + timesincedistancecheck = 0; + if ( distancesquared( previousorigin, self.origin ) < mindistancesq ) + { + faileddistancecheck = 1; + } + else + { + faileddistancecheck = 0; + } + previousorigin = self.origin; + } + velocity = self getvelocity(); + speedsq = lengthsquared( velocity ); + if ( speedsq > minspeedsq && faileddistancecheck == 0 ) + { + gpsjammerprotection = 1; + } + } + if ( gpsjammerprotection == 1 ) + { + currentfailcount = 0; + if ( hasperk == 0 ) + { + statechange = 0; + hasperk = 1; + self gpsjammeractive(); + } + } + else + { + currentfailcount++; + if ( hasperk == 1 && currentfailcount >= graceperiods ) + { + statechange = 1; + hasperk = 0; + self gpsjammerinactive(); + } + } + if ( statechange == 1 ) + { + level notify( "radar_status_change" ); + } + timesincedistancecheck += timeperiodsec; + wait timeperiodsec; + } +} + ondeath() { self endon( "disconnect" ); @@ -400,6 +505,21 @@ create_auto_turret_influencer( point, parent_team, angles ) return influencerid; } +create_auto_turret_influencer_close( point, parent_team, angles ) +{ + if ( !level.teambased ) + { + weapon_team_mask = level.spawnsystem.ispawn_teammask_free; + } + else + { + weapon_team_mask = getotherteamsmask( parent_team ); + } + projected_point = point + vectorScale( anglesToForward( angles ), level.spawnsystem.auto_turret_influencer_close_radius * 0,7 ); + influencerid = addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, projected_point, level.spawnsystem.auto_turret_influencer_close_radius, level.spawnsystem.auto_turret_influencer_close_score, weapon_team_mask, "auto_turret_close,r,s", get_score_curve_index( level.spawnsystem.auto_turret_influencer_close_score_curve ) ); + return influencerid; +} + create_dog_influencers() { if ( !level.teambased ) @@ -629,38 +749,38 @@ create_enemy_spawned_influencers( origin, team ) { other_team_mask = getotherteamsmask( team ); } - return addsphereinfluencer( level.spawnsystem.einfluencer_type_enemy_spawned, origin, level.spawnsystem.enemy_spawned_influencer_radius, level.spawnsystem.enemy_spawned_influencer_score, other_team_mask, "enemy_spawned,r,s", get_score_curve_index( level.spawnsystem.enemy_spawned_influencer_score_curve ), 7 ); + return addsphereinfluencer( level.spawnsystem.einfluencer_type_enemy_spawned, origin, level.spawnsystem.enemy_spawned_influencer_radius, level.spawnsystem.enemy_spawned_influencer_score, other_team_mask, "enemy_spawned,r,s", get_score_curve_index( level.spawnsystem.enemy_spawned_influencer_score_curve ), level.spawnsystem.enemy_spawned_influencer_timeout_seconds ); } updateallspawnpoints() { - _a1046 = level.teams; - _k1046 = getFirstArrayKey( _a1046 ); - while ( isDefined( _k1046 ) ) + _a1176 = level.teams; + _k1176 = getFirstArrayKey( _a1176 ); + while ( isDefined( _k1176 ) ) { - team = _a1046[ _k1046 ]; + team = _a1176[ _k1176 ]; gatherspawnentities( team ); - _k1046 = getNextArrayKey( _a1046, _k1046 ); + _k1176 = getNextArrayKey( _a1176, _k1176 ); } clearspawnpoints(); if ( level.teambased ) { - _a1055 = level.teams; - _k1055 = getFirstArrayKey( _a1055 ); - while ( isDefined( _k1055 ) ) + _a1185 = level.teams; + _k1185 = getFirstArrayKey( _a1185 ); + while ( isDefined( _k1185 ) ) { - team = _a1055[ _k1055 ]; + team = _a1185[ _k1185 ]; addspawnpoints( team, level.unified_spawn_points[ team ].a ); - _k1055 = getNextArrayKey( _a1055, _k1055 ); + _k1185 = getNextArrayKey( _a1185, _k1185 ); } } - else _a1062 = level.teams; - _k1062 = getFirstArrayKey( _a1062 ); - while ( isDefined( _k1062 ) ) + else _a1192 = level.teams; + _k1192 = getFirstArrayKey( _a1192 ); + while ( isDefined( _k1192 ) ) { - team = _a1062[ _k1062 ]; + team = _a1192[ _k1192 ]; addspawnpoints( "free", level.unified_spawn_points[ team ].a ); - _k1062 = getNextArrayKey( _a1062, _k1062 ); + _k1192 = getNextArrayKey( _a1192, _k1192 ); } remove_unused_spawn_entities(); } @@ -688,15 +808,24 @@ get_player_spawning_dvars( reset_dvars ) dog_influencer_radius = 10 * k_player_height; dog_influencer_score = 150; ss.script_based_influencer_system = set_dvar_int_if_unset( "scr_script_based_influencer_system", "0", reset_dvars ); - ss.randomness_range = set_dvar_float_if_unset( "scr_spawn_randomness_range", "10", reset_dvars ); - ss.objective_facing_bonus = set_dvar_float_if_unset( "scr_spawn_objective_facing_bonus", "50", reset_dvars ); - ss.friend_weak_influencer_score = set_dvar_float_if_unset( "scr_spawn_friend_weak_influencer_score", "10", reset_dvars ); - ss.friend_weak_influencer_score_curve = set_dvar_if_unset( "scr_spawn_friend_weak_influencer_score_curve", "steep", reset_dvars ); - ss.friend_weak_influencer_radius = set_dvar_float_if_unset( "scr_spawn_friend_weak_influencer_radius", player_height_times_10, reset_dvars ); + ss.randomness_range = set_dvar_float_if_unset( "scr_spawn_randomness_range", "0", reset_dvars ); + ss.objective_facing_bonus = set_dvar_float_if_unset( "scr_spawn_objective_facing_bonus", "0", reset_dvars ); + if ( level.multiteam ) + { + ss.friend_weak_influencer_score = set_dvar_float_if_unset( "scr_spawn_friend_weak_influencer_score", "200", reset_dvars ); + ss.friend_weak_influencer_score_curve = set_dvar_if_unset( "scr_spawn_friend_weak_influencer_score_curve", "linear", reset_dvars ); + ss.friend_weak_influencer_radius = set_dvar_float_if_unset( "scr_spawn_friend_weak_influencer_radius", "1200", reset_dvars ); + } + else + { + ss.friend_weak_influencer_score = set_dvar_float_if_unset( "scr_spawn_friend_weak_influencer_score", "20", reset_dvars ); + ss.friend_weak_influencer_score_curve = set_dvar_if_unset( "scr_spawn_friend_weak_influencer_score_curve", "linear", reset_dvars ); + ss.friend_weak_influencer_radius = set_dvar_float_if_unset( "scr_spawn_friend_weak_influencer_radius", "700", reset_dvars ); + } ss.enemy_influencer_score = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_score", "-150", reset_dvars ); - ss.enemy_influencer_score_curve = set_dvar_if_unset( "scr_spawn_enemy_influencer_score_curve", "steep", reset_dvars ); + ss.enemy_influencer_score_curve = set_dvar_if_unset( "scr_spawn_enemy_influencer_score_curve", "linear", reset_dvars ); ss.enemy_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_influencer_radius", "2600", reset_dvars ); - ss.dead_friend_influencer_timeout_seconds = set_dvar_float_if_unset( "scr_spawn_dead_friend_influencer_timeout_seconds", "15", reset_dvars ); + ss.dead_friend_influencer_timeout_seconds = set_dvar_float_if_unset( "scr_spawn_dead_friend_influencer_timeout_seconds", "20", reset_dvars ); ss.dead_friend_influencer_count = set_dvar_float_if_unset( "scr_spawn_dead_friend_influencer_count", "7", reset_dvars ); ss.dead_friend_influencer_score = set_dvar_float_if_unset( "scr_spawn_dead_friend_influencer_score", "-100", reset_dvars ); ss.dead_friend_influencer_score_curve = set_dvar_if_unset( "scr_spawn_dead_friend_influencer_score_curve", "steep", reset_dvars ); @@ -725,6 +854,9 @@ get_player_spawning_dvars( reset_dvars ) ss.auto_turret_influencer_score = set_dvar_float_if_unset( "scr_spawn_auto_turret_influencer_score", "-650", reset_dvars ); ss.auto_turret_influencer_score_curve = set_dvar_if_unset( "scr_spawn_auto_turret_influencer_score_curve", "linear", reset_dvars ); ss.auto_turret_influencer_radius = set_dvar_float_if_unset( "scr_spawn_auto_turret_influencer_radius", "" + 1200, reset_dvars ); + ss.auto_turret_influencer_close_score = set_dvar_float_if_unset( "scr_spawn_auto_turret_influencer_close_score", "-250000", reset_dvars ); + ss.auto_turret_influencer_close_score_curve = set_dvar_if_unset( "scr_spawn_auto_turret_influencer_close_score_curve", "constant", reset_dvars ); + ss.auto_turret_influencer_close_radius = set_dvar_float_if_unset( "scr_spawn_auto_turret_influencer_close_radius", "" + 500, reset_dvars ); ss.rcbomb_influencer_score = set_dvar_float_if_unset( "scr_spawn_rcbomb_influencer_score", "-200", reset_dvars ); ss.rcbomb_influencer_score_curve = set_dvar_if_unset( "scr_spawn_rcbomb_influencer_score_curve", "steep", reset_dvars ); ss.rcbomb_influencer_radius = set_dvar_float_if_unset( "scr_spawn_rcbomb_influencer_radius", "" + ( 25 * k_player_height ), reset_dvars ); @@ -739,16 +871,22 @@ get_player_spawning_dvars( reset_dvars ) ss.aitank_influencer_score_curve = set_dvar_if_unset( "scr_spawn_aitank_influencer_score_curve", "linear", reset_dvars ); ss.aitank_influencer_radius = set_dvar_float_if_unset( "scr_spawn_aitank_influencer_radius", "" + ( 25 * k_player_height ), reset_dvars ); ss.enemy_spawned_influencer_score_curve = set_dvar_if_unset( "scr_spawn_enemy_spawned_influencer_score_curve", "constant", reset_dvars ); - if ( level.teambased ) + if ( level.multiteam ) { - ss.enemy_spawned_influencer_score = set_dvar_float_if_unset( "scr_spawn_enemy_spawned_influencer_score", "-200", reset_dvars ); + ss.enemy_spawned_influencer_score = set_dvar_float_if_unset( "scr_spawn_enemy_spawned_influencer_score", "-400", reset_dvars ); + ss.enemy_spawned_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_spawned_influencer_radius", "" + 1100, reset_dvars ); + } + else if ( level.teambased ) + { + ss.enemy_spawned_influencer_score = set_dvar_float_if_unset( "scr_spawn_enemy_spawned_influencer_score", "-400", reset_dvars ); ss.enemy_spawned_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_spawned_influencer_radius", "" + 1100, reset_dvars ); } else { - ss.enemy_spawned_influencer_score = set_dvar_float_if_unset( "scr_spawn_enemy_spawned_influencer_score", "-100", reset_dvars ); - ss.enemy_spawned_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_spawned_influencer_radius", "" + 400, reset_dvars ); + ss.enemy_spawned_influencer_score = set_dvar_float_if_unset( "scr_spawn_enemy_spawned_influencer_score", "-400", reset_dvars ); + ss.enemy_spawned_influencer_radius = set_dvar_float_if_unset( "scr_spawn_enemy_spawned_influencer_radius", "" + 1000, reset_dvars ); } + ss.enemy_spawned_influencer_timeout_seconds = set_dvar_float_if_unset( "scr_spawn_enemy_spawned_influencer_timeout_seconds", "7", reset_dvars ); ss.helicopter_influencer_score = set_dvar_float_if_unset( "scr_spawn_helicopter_influencer_score", "-500", reset_dvars ); ss.helicopter_influencer_score_curve = set_dvar_if_unset( "scr_spawn_helicopter_influencer_score_curve", "linear", reset_dvars ); ss.helicopter_influencer_radius = set_dvar_float_if_unset( "scr_spawn_helicopter_influencer_radius", "" + 2000, reset_dvars ); @@ -764,7 +902,6 @@ get_player_spawning_dvars( reset_dvars ) { ss.unifiedsideswitching = 1; } - set_dvar_int_if_unset( "spawnsystem_allow_non_team_spawns", "0", reset_dvars ); [[ level.gamemodespawndvars ]]( reset_dvars ); if ( isDefined( level.levelspawndvars ) ) { @@ -791,7 +928,7 @@ onspawnplayer_unified( predictedspawn ) return; #/ } - use_new_spawn_system = 0; + use_new_spawn_system = 1; initial_spawn = 1; if ( isDefined( self.uspawn_already_spawned ) ) { @@ -806,7 +943,52 @@ onspawnplayer_unified( predictedspawn ) use_new_spawn_system = 0; } set_dvar_if_unset( "scr_spawn_force_unified", "0" ); - [[ level.onspawnplayer ]]( predictedspawn ); + spawnoverride = self maps/mp/_tacticalinsertion::overridespawn( predictedspawn ); + if ( use_new_spawn_system || getDvarInt( #"0BD11226" ) != 0 ) + { + if ( !spawnoverride ) + { + spawn_point = getspawnpoint( self, predictedspawn ); + if ( isDefined( spawn_point ) ) + { + if ( predictedspawn ) + { + self predictspawnpoint( spawn_point.origin, spawn_point.angles ); + } + else + { + create_enemy_spawned_influencers( spawn_point.origin, self.pers[ "team" ] ); + self spawn( spawn_point.origin, spawn_point.angles ); + } + } + else + { +/# + println( "ERROR: unable to locate a usable spawn point for player" ); +#/ + maps/mp/gametypes/_callbacksetup::abortlevel(); + } + } + else + { + if ( predictedspawn && isDefined( self.tacticalinsertion ) ) + { + self predictspawnpoint( self.tacticalinsertion.origin, self.tacticalinsertion.angles ); + } + } + if ( !predictedspawn ) + { + self.lastspawntime = getTime(); + self enable_player_influencers( 1 ); + } + } + else + { + if ( !spawnoverride ) + { + [[ level.onspawnplayer ]]( predictedspawn ); + } + } if ( !predictedspawn ) { self.uspawn_already_spawned = 1; @@ -857,31 +1039,31 @@ get_debug_spawnpoint( player ) if ( team == "free" ) { spawn_counts = 0; - _a1409 = level.teams; - _k1409 = getFirstArrayKey( _a1409 ); - while ( isDefined( _k1409 ) ) + _a1556 = level.teams; + _k1556 = getFirstArrayKey( _a1556 ); + while ( isDefined( _k1556 ) ) { - team = _a1409[ _k1409 ]; + team = _a1556[ _k1556 ]; spawn_counts += level.unified_spawn_points[ team ].a.size; - _k1409 = getNextArrayKey( _a1409, _k1409 ); + _k1556 = getNextArrayKey( _a1556, _k1556 ); } if ( level.test_spawn_point_index >= spawn_counts ) { level.test_spawn_point_index = 0; } count = 0; - _a1420 = level.teams; - _k1420 = getFirstArrayKey( _a1420 ); - while ( isDefined( _k1420 ) ) + _a1567 = level.teams; + _k1567 = getFirstArrayKey( _a1567 ); + while ( isDefined( _k1567 ) ) { - team = _a1420[ _k1420 ]; + team = _a1567[ _k1567 ]; size = level.unified_spawn_points[ team ].a.size; if ( level.test_spawn_point_index < ( count + size ) ) { return level.unified_spawn_points[ team ].a[ level.test_spawn_point_index - count ]; } count += size; - _k1420 = getNextArrayKey( _a1420, _k1420 ); + _k1567 = getNextArrayKey( _a1567, _k1567 ); } } else if ( level.test_spawn_point_index >= level.unified_spawn_points[ team ].a.size ) @@ -934,7 +1116,7 @@ gatherspawnentities( player_team ) { spawn_entities_s.a = []; } - legacy_spawn_points = maps/mp/gametypes_zm/_spawnlogic::getteamspawnpoints( player_team ); + legacy_spawn_points = maps/mp/gametypes/_spawnlogic::getteamspawnpoints( player_team ); legacy_spawn_index = 0; while ( legacy_spawn_index < legacy_spawn_points.size ) { @@ -971,6 +1153,12 @@ remove_unused_spawn_entities() spawn_entity_types[ spawn_entity_types.size ] = "mp_dm_spawn"; spawn_entity_types[ spawn_entity_types.size ] = "mp_tdm_spawn_allies_start"; spawn_entity_types[ spawn_entity_types.size ] = "mp_tdm_spawn_axis_start"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_tdm_spawn_team1_start"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_tdm_spawn_team2_start"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_tdm_spawn_team3_start"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_tdm_spawn_team4_start"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_tdm_spawn_team5_start"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_tdm_spawn_team6_start"; spawn_entity_types[ spawn_entity_types.size ] = "mp_tdm_spawn"; spawn_entity_types[ spawn_entity_types.size ] = "mp_ctf_spawn_allies_start"; spawn_entity_types[ spawn_entity_types.size ] = "mp_ctf_spawn_axis_start"; @@ -978,6 +1166,9 @@ remove_unused_spawn_entities() spawn_entity_types[ spawn_entity_types.size ] = "mp_ctf_spawn_axis"; spawn_entity_types[ spawn_entity_types.size ] = "mp_dom_spawn_allies_start"; spawn_entity_types[ spawn_entity_types.size ] = "mp_dom_spawn_axis_start"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_dom_spawn_flag_a"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_dom_spawn_flag_b"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_dom_spawn_flag_c"; spawn_entity_types[ spawn_entity_types.size ] = "mp_dom_spawn"; spawn_entity_types[ spawn_entity_types.size ] = "mp_sab_spawn_allies_start"; spawn_entity_types[ spawn_entity_types.size ] = "mp_sab_spawn_axis_start"; @@ -985,6 +1176,12 @@ remove_unused_spawn_entities() spawn_entity_types[ spawn_entity_types.size ] = "mp_sab_spawn_axis"; spawn_entity_types[ spawn_entity_types.size ] = "mp_sd_spawn_attacker"; spawn_entity_types[ spawn_entity_types.size ] = "mp_sd_spawn_defender"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_dem_spawn_attacker_start"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_dem_spawn_defender_start"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_dem_spawn_attackerOT_start"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_dem_spawn_defenderOT_start"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_dem_spawn_attacker"; + spawn_entity_types[ spawn_entity_types.size ] = "mp_dem_spawn_defender"; spawn_entity_types[ spawn_entity_types.size ] = "mp_twar_spawn_axis_start"; spawn_entity_types[ spawn_entity_types.size ] = "mp_twar_spawn_allies_start"; spawn_entity_types[ spawn_entity_types.size ] = "mp_twar_spawn"; @@ -998,7 +1195,7 @@ remove_unused_spawn_entities() } else { - spawnpoints = maps/mp/gametypes_zm/_spawnlogic::getspawnpointarray( spawn_entity_types[ i ] ); + spawnpoints = maps/mp/gametypes/_spawnlogic::getspawnpointarray( spawn_entity_types[ i ] ); delete_all_spawns( spawnpoints ); } i++; @@ -1035,39 +1232,65 @@ spawn_point_class_name_being_used( name ) codecallback_updatespawnpoints() { - _a1624 = level.teams; - _k1624 = getFirstArrayKey( _a1624 ); - while ( isDefined( _k1624 ) ) + _a1788 = level.teams; + _k1788 = getFirstArrayKey( _a1788 ); + while ( isDefined( _k1788 ) ) { - team = _a1624[ _k1624 ]; - maps/mp/gametypes_zm/_spawnlogic::rebuildspawnpoints( team ); - _k1624 = getNextArrayKey( _a1624, _k1624 ); + team = _a1788[ _k1788 ]; + maps/mp/gametypes/_spawnlogic::rebuildspawnpoints( team ); + _k1788 = getNextArrayKey( _a1788, _k1788 ); } level.unified_spawn_points = undefined; updateallspawnpoints(); } -initialspawnprotection( specialtyname, spawnmonitorspeed ) +initialspawnprotection() { self endon( "death" ); self endon( "disconnect" ); + self thread maps/mp/killstreaks/_airsupport::monitorspeed( level.spawnprotectiontime ); if ( !isDefined( level.spawnprotectiontime ) || level.spawnprotectiontime == 0 ) { return; } - if ( specialtyname == "specialty_nottargetedbyairsupport" ) + self.specialty_nottargetedbyairsupport = 1; + self spawnprotectionactive(); + wait level.spawnprotectiontime; + self spawnprotectioninactive(); + self.specialty_nottargetedbyairsupport = undefined; +} + +getteamstartspawnname( team, spawnpointnamebase ) +{ + spawn_point_team_name = team; + if ( !level.multiteam && game[ "switchedsides" ] ) { - self.specialty_nottargetedbyairsupport = 1; - wait level.spawnprotectiontime; - self.specialty_nottargetedbyairsupport = undefined; + spawn_point_team_name = getotherteam( team ); } - else + if ( level.multiteam ) { - if ( !self hasperk( specialtyname ) ) + if ( team == "axis" ) { - self setperk( specialtyname ); - wait level.spawnprotectiontime; - self unsetperk( specialtyname ); + spawn_point_team_name = "team1"; + } + else + { + if ( team == "allies" ) + { + spawn_point_team_name = "team2"; + } + } + if ( !isoneround() ) + { + number = int( getsubstr( spawn_point_team_name, 4, 5 ) ) - 1; + number = ( ( number + game[ "roundsplayed" ] ) % level.teams.size ) + 1; + spawn_point_team_name = "team" + number; } } + return ( spawnpointnamebase + "_" ) + spawn_point_team_name + "_start"; +} + +gettdmstartspawnname( team ) +{ + return getteamstartspawnname( team, "mp_tdm_spawn" ); } diff --git a/patch_mp/maps/mp/gametypes/_spawnlogic.gsc b/patch_mp/maps/mp/gametypes/_spawnlogic.gsc index ba21d0f..999fbed 100644 --- a/patch_mp/maps/mp/gametypes/_spawnlogic.gsc +++ b/patch_mp/maps/mp/gametypes/_spawnlogic.gsc @@ -1,6 +1,6 @@ -#include maps/mp/gametypes_zm/_spawnlogic; -#include maps/mp/gametypes_zm/_gameobjects; -#include maps/mp/gametypes_zm/_callbacksetup; +#include maps/mp/gametypes/_spawnlogic; +#include maps/mp/gametypes/_gameobjects; +#include maps/mp/gametypes/_callbacksetup; #include maps/mp/_utility; #include common_scripts/utility; @@ -91,7 +91,7 @@ addspawnpointsinternal( team, spawnpointname ) /# println( "^1ERROR: No " + spawnpointname + " spawnpoints found in level!" ); #/ - maps/mp/gametypes_zm/_callbacksetup::abortlevel(); + maps/mp/gametypes/_callbacksetup::abortlevel(); wait 1; return; } @@ -144,7 +144,7 @@ placespawnpoints( spawnpointname ) /# println( "^1No " + spawnpointname + " spawnpoints found in level!" ); #/ - maps/mp/gametypes_zm/_callbacksetup::abortlevel(); + maps/mp/gametypes/_callbacksetup::abortlevel(); wait 1; return; } @@ -564,7 +564,7 @@ storespawndata( spawnpoints, useweights, bestspawnpoint ) index = otherdata.size; otherdata[ index ] = spawnstruct(); otherdata[ index ].origin = level.flags[ i ].origin; - otherdata[ index ].text = level.flags[ i ].useobj maps/mp/gametypes_zm/_gameobjects::getownerteam() + " flag"; + otherdata[ index ].text = level.flags[ i ].useobj maps/mp/gametypes/_gameobjects::getownerteam() + " flag"; i++; } } @@ -924,18 +924,7 @@ getallotherplayers() } else { - if ( isDefined( level.customalivecheck ) ) - { - if ( !( [[ level.customalivecheck ]]( player ) ) ) - { - i++; - continue; - } - } - else - { - aliveplayers[ aliveplayers.size ] = player; - } + aliveplayers[ aliveplayers.size ] = player; } i++; } @@ -949,44 +938,32 @@ getallalliedandenemyplayers( obj ) /# assert( isDefined( level.teams[ self.team ] ) ); #/ - obj.allies = []; - obj.enemies = []; - i = 0; - while ( i < level.players.size ) + obj.allies = level.aliveplayers[ self.team ]; + obj.enemies = undefined; + _a833 = level.teams; + _k833 = getFirstArrayKey( _a833 ); + while ( isDefined( _k833 ) ) { - if ( !isDefined( level.players[ i ] ) ) + team = _a833[ _k833 ]; + if ( team == self.team ) { - i++; - continue; } - else player = level.players[ i ]; - if ( player.sessionstate != "playing" || player == self ) + else if ( !isDefined( obj.enemies ) ) { - i++; - continue; + obj.enemies = level.aliveplayers[ team ]; } else { - if ( isDefined( level.customalivecheck ) ) - { - if ( !( [[ level.customalivecheck ]]( player ) ) ) - { - i++; - continue; - } - } - else if ( player.team == self.team ) - { - obj.allies[ obj.allies.size ] = player; - i++; - continue; - } - else + _a844 = level.aliveplayers[ team ]; + _k844 = getFirstArrayKey( _a844 ); + while ( isDefined( _k844 ) ) { + player = _a844[ _k844 ]; obj.enemies[ obj.enemies.size ] = player; + _k844 = getNextArrayKey( _a844, _k844 ); } } - i++; + _k833 = getNextArrayKey( _a833, _k833 ); } } else obj.allies = []; @@ -1015,57 +992,7 @@ initweights( spawnpoints ) } } -spawnpointupdate_zm( spawnpoint ) -{ - _a906 = level.teams; - _k906 = getFirstArrayKey( _a906 ); - while ( isDefined( _k906 ) ) - { - team = _a906[ _k906 ]; - spawnpoint.distsum[ team ] = 0; - spawnpoint.enemydistsum[ team ] = 0; - _k906 = getNextArrayKey( _a906, _k906 ); - } - players = get_players(); - spawnpoint.numplayersatlastupdate = players.size; - _a913 = players; - _k913 = getFirstArrayKey( _a913 ); - while ( isDefined( _k913 ) ) - { - player = _a913[ _k913 ]; - if ( !isDefined( player ) ) - { - } - else if ( player.sessionstate != "playing" ) - { - } - else if ( isDefined( level.customalivecheck ) ) - { - if ( !( [[ level.customalivecheck ]]( player ) ) ) - { - } - } - else - { - dist = distance( spawnpoint.origin, player.origin ); - spawnpoint.distsum[ player.team ] += dist; - _a924 = level.teams; - _k924 = getFirstArrayKey( _a924 ); - while ( isDefined( _k924 ) ) - { - team = _a924[ _k924 ]; - if ( team != player.team ) - { - spawnpoint.enemydistsum[ team ] += dist; - } - _k924 = getNextArrayKey( _a924, _k924 ); - } - } - _k913 = getNextArrayKey( _a913, _k913 ); - } -} - -getspawnpoint_nearteam( spawnpoints, favoredspawnpoints, forceallydistanceweight, forceenemydistanceweight ) +getspawnpoint_nearteam( spawnpoints, favoredspawnpoints ) { if ( !isDefined( spawnpoints ) ) { @@ -1092,21 +1019,11 @@ getspawnpoint_nearteam( spawnpoints, favoredspawnpoints, forceallydistanceweight getallalliedandenemyplayers( obj ); numplayers = obj.allies.size + obj.enemies.size; allieddistanceweight = 2; - if ( isDefined( forceallydistanceweight ) ) - { - allieddistanceweight = forceallydistanceweight; - } - enemydistanceweight = 1; - if ( isDefined( forceenemydistanceweight ) ) - { - enemydistanceweight = forceenemydistanceweight; - } myteam = self.team; i = 0; while ( i < spawnpoints.size ) { spawnpoint = spawnpoints[ i ]; - spawnpointupdate_zm( spawnpoint ); if ( !isDefined( spawnpoint.numplayersatlastupdate ) ) { spawnpoint.numplayersatlastupdate = 0; @@ -1115,11 +1032,11 @@ getspawnpoint_nearteam( spawnpoints, favoredspawnpoints, forceallydistanceweight { allydistsum = spawnpoint.distsum[ myteam ]; enemydistsum = spawnpoint.enemydistsum[ myteam ]; - spawnpoint.weight = ( ( enemydistanceweight * enemydistsum ) - ( allieddistanceweight * allydistsum ) ) / spawnpoint.numplayersatlastupdate; + spawnpoint.weight = ( enemydistsum - ( allieddistanceweight * allydistsum ) ) / spawnpoint.numplayersatlastupdate; /# if ( level.storespawndata || level.debugspawning ) { - spawnpoint.spawndata[ spawnpoint.spawndata.size ] = "Base weight: " + int( spawnpoint.weight ) + " = (" + enemydistanceweight + "*" + int( enemydistsum ) + " - " + allieddistanceweight + "*" + int( allydistsum ) + ") / " + spawnpoint.numplayersatlastupdate; + spawnpoint.spawndata[ spawnpoint.spawndata.size ] = "Base weight: " + int( spawnpoint.weight ) + " = (" + int( enemydistsum ) + " - " + allieddistanceweight + "*" + int( allydistsum ) + ") / " + spawnpoint.numplayersatlastupdate; #/ } i++; @@ -1216,76 +1133,6 @@ getspawnpoint_dm( spawnpoints ) return getspawnpoint_final( spawnpoints ); } -getspawnpoint_turned( spawnpoints, idealdist, baddist, idealdistteam, baddistteam ) -{ - if ( !isDefined( spawnpoints ) ) - { - return undefined; - } - spawnlogic_begin(); - initweights( spawnpoints ); - aliveplayers = getallotherplayers(); - if ( !isDefined( idealdist ) ) - { - idealdist = 1600; - } - if ( !isDefined( idealdistteam ) ) - { - idealdistteam = 1200; - } - if ( !isDefined( baddist ) ) - { - baddist = 1200; - } - if ( !isDefined( baddistteam ) ) - { - baddistteam = 600; - } - myteam = self.team; - while ( aliveplayers.size > 0 ) - { - i = 0; - while ( i < spawnpoints.size ) - { - totaldistfromideal = 0; - nearbybadamount = 0; - j = 0; - while ( j < aliveplayers.size ) - { - dist = distance( spawnpoints[ i ].origin, aliveplayers[ j ].origin ); - distfromideal = 0; - if ( aliveplayers[ j ].team == myteam ) - { - if ( dist < baddistteam ) - { - nearbybadamount += ( baddistteam - dist ) / baddistteam; - } - distfromideal = abs( dist - idealdistteam ); - } - else - { - if ( dist < baddist ) - { - nearbybadamount += ( baddist - dist ) / baddist; - } - distfromideal = abs( dist - idealdist ); - } - totaldistfromideal += distfromideal; - j++; - } - avgdistfromideal = totaldistfromideal / aliveplayers.size; - welldistancedamount = ( idealdist - avgdistfromideal ) / idealdist; - spawnpoints[ i ].weight = ( welldistancedamount - ( nearbybadamount * 2 ) ) + randomfloat( 0,2 ); - i++; - } - } - avoidsamespawn( spawnpoints ); - avoidspawnreuse( spawnpoints, 0 ); - avoidweapondamage( spawnpoints ); - avoidvisibleenemies( spawnpoints, 0 ); - return getspawnpoint_final( spawnpoints ); -} - spawnlogic_begin() { /# @@ -2039,11 +1886,11 @@ spawnperframeupdate() getnonteamsum( skip_team, sums ) { value = 0; - _a1986 = level.teams; - _k1986 = getFirstArrayKey( _a1986 ); - while ( isDefined( _k1986 ) ) + _a1836 = level.teams; + _k1836 = getFirstArrayKey( _a1836 ); + while ( isDefined( _k1836 ) ) { - team = _a1986[ _k1986 ]; + team = _a1836[ _k1836 ]; if ( team == skip_team ) { } @@ -2051,7 +1898,7 @@ getnonteamsum( skip_team, sums ) { value += sums[ team ]; } - _k1986 = getNextArrayKey( _a1986, _k1986 ); + _k1836 = getNextArrayKey( _a1836, _k1836 ); } return value; } @@ -2059,11 +1906,11 @@ getnonteamsum( skip_team, sums ) getnonteammindist( skip_team, mindists ) { dist = 9999999; - _a2000 = level.teams; - _k2000 = getFirstArrayKey( _a2000 ); - while ( isDefined( _k2000 ) ) + _a1850 = level.teams; + _k1850 = getFirstArrayKey( _a1850 ); + while ( isDefined( _k1850 ) ) { - team = _a2000[ _k2000 ]; + team = _a1850[ _k1850 ]; if ( team == skip_team ) { } @@ -2074,7 +1921,7 @@ getnonteammindist( skip_team, mindists ) dist = mindists[ team ]; } } - _k2000 = getNextArrayKey( _a2000, _k2000 ); + _k1850 = getNextArrayKey( _a1850, _k1850 ); } return dist; } @@ -2084,15 +1931,15 @@ spawnpointupdate( spawnpoint ) if ( level.teambased ) { sights = []; - _a2018 = level.teams; - _k2018 = getFirstArrayKey( _a2018 ); - while ( isDefined( _k2018 ) ) + _a1868 = level.teams; + _k1868 = getFirstArrayKey( _a1868 ); + while ( isDefined( _k1868 ) ) { - team = _a2018[ _k2018 ]; + team = _a1868[ _k1868 ]; spawnpoint.enemysights[ team ] = 0; sights[ team ] = 0; spawnpoint.nearbyplayers[ team ] = []; - _k2018 = getNextArrayKey( _a2018, _k2018 ); + _k1868 = getNextArrayKey( _a1868, _k1868 ); } } else spawnpoint.enemysights = 0; @@ -2108,16 +1955,16 @@ spawnpointupdate( spawnpoint ) { mindist[ "all" ] = 9999999; } - _a2047 = level.teams; - _k2047 = getFirstArrayKey( _a2047 ); - while ( isDefined( _k2047 ) ) + _a1897 = level.teams; + _k1897 = getFirstArrayKey( _a1897 ); + while ( isDefined( _k1897 ) ) { - team = _a2047[ _k2047 ]; + team = _a1897[ _k1897 ]; spawnpoint.distsum[ team ] = 0; spawnpoint.enemydistsum[ team ] = 0; spawnpoint.minenemydist[ team ] = 9999999; mindist[ team ] = 9999999; - _k2047 = getNextArrayKey( _a2047, _k2047 ); + _k1897 = getNextArrayKey( _a1897, _k1897 ); } spawnpoint.numplayersatlastupdate = 0; i = 0; @@ -2179,16 +2026,16 @@ spawnpointupdate( spawnpoint ) } if ( level.teambased ) { - _a2128 = level.teams; - _k2128 = getFirstArrayKey( _a2128 ); - while ( isDefined( _k2128 ) ) + _a1978 = level.teams; + _k1978 = getFirstArrayKey( _a1978 ); + while ( isDefined( _k1978 ) ) { - team = _a2128[ _k2128 ]; + team = _a1978[ _k1978 ]; spawnpoint.enemysights[ team ] = getnonteamsum( team, sights ); spawnpoint.minenemydist[ team ] = getnonteammindist( team, mindist ); spawnpoint.distsum[ team ] = distsum[ team ]; spawnpoint.enemydistsum[ team ] = getnonteamsum( team, distsum ); - _k2128 = getNextArrayKey( _a2128, _k2128 ); + _k1978 = getNextArrayKey( _a1978, _k1978 ); } } else spawnpoint.distsum[ "all" ] = distsum[ "all" ]; @@ -2215,11 +2062,11 @@ lastminutesighttraces( spawnpoint ) closestdistsq = undefined; secondclosest = undefined; secondclosestdistsq = undefined; - _a2162 = spawnpoint.nearbyplayers; - _k2162 = getFirstArrayKey( _a2162 ); - while ( isDefined( _k2162 ) ) + _a2012 = spawnpoint.nearbyplayers; + _k2012 = getFirstArrayKey( _a2012 ); + while ( isDefined( _k2012 ) ) { - team = _a2162[ _k2162 ]; + team = _a2012[ _k2012 ]; if ( team == self.team ) { } @@ -2265,7 +2112,7 @@ lastminutesighttraces( spawnpoint ) i++; } } - _k2162 = getNextArrayKey( _a2162, _k2162 ); + _k2012 = getNextArrayKey( _a2012, _k2012 ); } if ( isDefined( closest ) ) { @@ -2491,6 +2338,6 @@ getrandomintermissionpoint() /# assert( spawnpoints.size ); #/ - spawnpoint = maps/mp/gametypes_zm/_spawnlogic::getspawnpoint_random( spawnpoints ); + spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_random( spawnpoints ); return spawnpoint; } diff --git a/patch_mp/maps/mp/gametypes/_weapon_utils.gsc b/patch_mp/maps/mp/gametypes/_weapon_utils.gsc index 7359766..d5dbc82 100644 --- a/patch_mp/maps/mp/gametypes/_weapon_utils.gsc +++ b/patch_mp/maps/mp/gametypes/_weapon_utils.gsc @@ -1,7 +1,8 @@ +#include maps/mp/killstreaks/_killstreaks; #include maps/mp/_utility; #include common_scripts/utility; -isgrenadelauncherweapon( weapon ) +isgrenadelauncherweapon( weapon ) //checked matches cerberus output { if ( getsubstr( weapon, 0, 3 ) == "gl_" ) { @@ -17,7 +18,7 @@ isgrenadelauncherweapon( weapon ) } } -isdumbrocketlauncherweapon( weapon ) +isdumbrocketlauncherweapon( weapon ) //checked matches cerberus output { switch( weapon ) { @@ -29,7 +30,7 @@ isdumbrocketlauncherweapon( weapon ) } } -isguidedrocketlauncherweapon( weapon ) +isguidedrocketlauncherweapon( weapon ) //checked matches cerberus output { switch( weapon ) { @@ -44,7 +45,7 @@ isguidedrocketlauncherweapon( weapon ) } } -isrocketlauncherweapon( weapon ) +isrocketlauncherweapon( weapon ) //checked matches cerberus output { if ( isdumbrocketlauncherweapon( weapon ) ) { @@ -57,7 +58,7 @@ isrocketlauncherweapon( weapon ) return 0; } -islauncherweapon( weapon ) +islauncherweapon( weapon ) //checked matches cerberus output { if ( isrocketlauncherweapon( weapon ) ) { @@ -70,28 +71,29 @@ islauncherweapon( weapon ) return 0; } -isreducedteamkillweapon( weapon ) +ishackweapon( weapon ) //checked matches cerberus output { - switch( weapon ) + if ( maps/mp/killstreaks/_killstreaks::iskillstreakweapon( weapon ) ) { - case "planemortar_mp": - return 1; - default: - return 0; + return 1; + } + if ( weapon == "briefcase_bomb_mp" ) + { + return 1; } -} - -ishackweapon( weapon ) -{ return 0; } -ispistol( weapon ) +ispistol( weapon ) //checked changed at own discretion { - return isDefined( level.side_arm_array[ weapon ] ); + if ( isDefined( level.side_arm_array[ weapon ] ) ) + { + return 1; + } + return 0; } -isflashorstunweapon( weapon ) +isflashorstunweapon( weapon ) //checked matches cerberus output { if ( isDefined( weapon ) ) { @@ -107,13 +109,12 @@ isflashorstunweapon( weapon ) return 0; } -isflashorstundamage( weapon, meansofdeath ) +isflashorstundamage( weapon, meansofdeath ) //checked changed at own discretion { - if ( isflashorstunweapon( weapon ) ) + if ( ( meansofdeath == "MOD_GAS" || meansofdeath == "MOD_GRENADE_SPLASH" ) && isflashorstunweapon( weapon ) ) { - if ( meansofdeath != "MOD_GRENADE_SPLASH" ) - { - return meansofdeath == "MOD_GAS"; - } + return 1; } + return 0; } + diff --git a/patch_mp/maps/mp/gametypes/_weaponobjects.gsc b/patch_mp/maps/mp/gametypes/_weaponobjects.gsc index 8953fc5..42024fe 100644 --- a/patch_mp/maps/mp/gametypes/_weaponobjects.gsc +++ b/patch_mp/maps/mp/gametypes/_weaponobjects.gsc @@ -1,10 +1,23 @@ -#include maps/mp/gametypes_zm/_globallogic_audio; -#include maps/mp/gametypes_zm/_damagefeedback; -#include maps/mp/gametypes_zm/_globallogic_player; -#include maps/mp/gametypes_zm/_weaponobjects; +#include maps/mp/gametypes/_dev; +#include maps/mp/_vehicles; +#include maps/mp/gametypes/_globallogic_audio; +#include maps/mp/_entityheadicons; +#include maps/mp/gametypes/_damagefeedback; +#include maps/mp/gametypes/_globallogic_player; +#include maps/mp/_scrambler; +#include maps/mp/gametypes/_weaponobjects; +#include maps/mp/_scoreevents; #include maps/mp/_challenges; +#include maps/mp/killstreaks/_emp; +#include maps/mp/killstreaks/_qrdrone; +#include maps/mp/killstreaks/_rcbomb; #include maps/mp/_ballistic_knife; -#include maps/mp/gametypes_zm/_hud_util; +#include maps/mp/_sensor_grenade; +#include maps/mp/_trophy_system; +#include maps/mp/_bouncingbetty; +#include maps/mp/_proximity_grenade; +#include maps/mp/_satchel_charge; +#include maps/mp/gametypes/_hud_util; #include maps/mp/_utility; #include common_scripts/utility; @@ -53,7 +66,7 @@ init() level.weaponobjects_headicon_offset[ "bouncingbetty_mp" ] = vectorScale( ( 0, 0, 1 ), 20 ); level.weaponobjects_headicon_offset[ "satchel_charge_mp" ] = vectorScale( ( 0, 0, 1 ), 10 ); level.weaponobjects_headicon_offset[ "scrambler_mp" ] = vectorScale( ( 0, 0, 1 ), 20 ); - level.weaponobjects_headicon_offset[ "trophy_system_mp" ] = vectorScale( ( 0, 0, 1 ), 20 ); + level.weaponobjects_headicon_offset[ "trophy_system_mp" ] = vectorScale( ( 0, 0, 1 ), 35 ); level.weaponobjects_hacker_trigger_width = 32; level.weaponobjects_hacker_trigger_height = 32; } @@ -61,13 +74,13 @@ init() getwatchernames( weapons ) { names = []; - _a73 = weapons; - index = getFirstArrayKey( _a73 ); + _a75 = weapons; + index = getFirstArrayKey( _a75 ); while ( isDefined( index ) ) { - weapon = _a73[ index ]; + weapon = _a75[ index ]; names[ index ] = getsubstr( weapon, 0, weapon.size - 3 ); - index = getNextArrayKey( _a73, index ); + index = getNextArrayKey( _a75, index ); } return names; } @@ -100,6 +113,7 @@ setupretrievablehintstrings() createretrievablehint( "camera_spike", &"MP_CAMERA_SPIKE_PICKUP" ); createretrievablehint( "satchel_charge", &"MP_SATCHEL_CHARGE_PICKUP" ); createretrievablehint( "scrambler", &"MP_SCRAMBLER_PICKUP" ); + createretrievablehint( "proximity_grenade", &"MP_SHOCK_CHARGE_PICKUP" ); createdestroyhint( "trophy_system", &"MP_TROPHY_SYSTEM_DESTROY" ); createdestroyhint( "sensor_grenade", &"MP_SENSOR_GRENADE_DESTROY" ); createhackerhint( "claymore_mp", &"MP_CLAYMORE_HACKING" ); @@ -137,6 +151,18 @@ onplayerspawned() if ( !isDefined( self.watchersinitialized ) ) { self createbasewatchers(); + self maps/mp/_satchel_charge::createsatchelwatcher(); + self maps/mp/_proximity_grenade::createproximitygrenadewatcher(); + self maps/mp/_bouncingbetty::createbouncingbettywatcher(); + self maps/mp/_trophy_system::createtrophysystemwatcher(); + self maps/mp/_sensor_grenade::createsensorgrenadewatcher(); + self createclaymorewatcher(); + self creatercbombwatcher(); + self createqrdronewatcher(); + self createplayerhelicopterwatcher(); + self createballisticknifewatcher(); + self createhatchetwatcher(); + self createtactinsertwatcher(); self setupretrievablewatcher(); self thread watchweaponobjectusage(); self.watchersinitialized = 1; @@ -153,33 +179,33 @@ resetwatchers() return undefined; } team = self.team; - _a199 = self.weaponobjectwatcherarray; - _k199 = getFirstArrayKey( _a199 ); - while ( isDefined( _k199 ) ) + _a203 = self.weaponobjectwatcherarray; + _k203 = getFirstArrayKey( _a203 ); + while ( isDefined( _k203 ) ) { - watcher = _a199[ _k199 ]; + watcher = _a203[ _k203 ]; resetweaponobjectwatcher( watcher, team ); - _k199 = getNextArrayKey( _a199, _k199 ); + _k203 = getNextArrayKey( _a203, _k203 ); } } createbasewatchers() { - _a208 = level.watcherweapons; - index = getFirstArrayKey( _a208 ); + _a212 = level.watcherweapons; + index = getFirstArrayKey( _a212 ); while ( isDefined( index ) ) { - weapon = _a208[ index ]; + weapon = _a212[ index ]; self createweaponobjectwatcher( level.watcherweaponnames[ index ], weapon, self.team ); - index = getNextArrayKey( _a208, index ); + index = getNextArrayKey( _a212, index ); } - _a214 = level.retrievableweapons; - index = getFirstArrayKey( _a214 ); + _a218 = level.retrievableweapons; + index = getFirstArrayKey( _a218 ); while ( isDefined( index ) ) { - weapon = _a214[ index ]; + weapon = _a218[ index ]; self createweaponobjectwatcher( level.retrievableweaponnames[ index ], weapon, self.team ); - index = getNextArrayKey( _a214, index ); + index = getNextArrayKey( _a218, index ); } } @@ -219,6 +245,7 @@ createhatchetwatcher() watcher = self createuseweaponobjectwatcher( "hatchet", "hatchet_mp", self.team ); watcher.detonate = ::deleteent; watcher.onspawn = ::voidonspawn; + watcher.ondamage = ::voidondamage; watcher.onspawnretrievetriggers = ::onspawnhatchettrigger; } @@ -230,10 +257,29 @@ createtactinsertwatcher() creatercbombwatcher() { + watcher = self createuseweaponobjectwatcher( "rcbomb", "rcbomb_mp", self.team ); + watcher.altdetonate = 0; + watcher.headicon = 0; + watcher.ismovable = 1; + watcher.ownergetsassist = 1; + watcher.playdestroyeddialog = 0; + watcher.deleteonkillbrush = 0; + watcher.detonate = ::maps/mp/killstreaks/_rcbomb::blowup; + watcher.stuntime = 1; } createqrdronewatcher() { + watcher = self createuseweaponobjectwatcher( "qrdrone", "qrdrone_turret_mp", self.team ); + watcher.altdetonate = 0; + watcher.headicon = 0; + watcher.ismovable = 1; + watcher.ownergetsassist = 1; + watcher.playdestroyeddialog = 0; + watcher.deleteonkillbrush = 0; + watcher.detonate = ::maps/mp/killstreaks/_qrdrone::qrdrone_blowup; + watcher.ondamage = ::maps/mp/killstreaks/_qrdrone::qrdrone_damagewatcher; + watcher.stuntime = 5; } createplayerhelicopterwatcher() @@ -250,8 +296,8 @@ createclaymorewatcher() watcher.detonate = ::claymoredetonate; watcher.activatesound = "wpn_claymore_alert"; watcher.hackable = 1; - watcher.hackertoolradius = level.claymorehackertoolradius; - watcher.hackertooltimems = level.claymorehackertooltimems; + watcher.hackertoolradius = level.equipmenthackertoolradius; + watcher.hackertooltimems = level.equipmenthackertooltimems; watcher.reconmodel = "t6_wpn_claymore_world_detect"; watcher.ownergetsassist = 1; detectionconeangle = weapons_get_dvar_int( "scr_weaponobject_coneangle" ); @@ -260,7 +306,7 @@ createclaymorewatcher() watcher.detectiongraceperiod = weapons_get_dvar( "scr_weaponobject_graceperiod" ); watcher.detonateradius = weapons_get_dvar_int( "scr_weaponobject_radius" ); watcher.stun = ::weaponstun; - watcher.stuntime = 5; + watcher.stuntime = 1; } waittillnotmoving_and_notstunned() @@ -284,6 +330,10 @@ voidonspawn( unused0, unused1 ) { } +voidondamage( unused0 ) +{ +} + deleteent( attacker, emp ) { self delete(); @@ -305,6 +355,14 @@ deleteweaponobjectarray() { if ( isDefined( self.objectarray[ i ] ) ) { + if ( isDefined( self.objectarray[ i ].minemover ) ) + { + if ( isDefined( self.objectarray[ i ].minemover.killcament ) ) + { + self.objectarray[ i ].minemover.killcament delete(); + } + self.objectarray[ i ].minemover delete(); + } self.objectarray[ i ] delete(); } i++; @@ -315,23 +373,24 @@ deleteweaponobjectarray() claymoredetonate( attacker, weaponname ) { - from_emp = 0; + from_emp = maps/mp/killstreaks/_emp::isempkillstreakweapon( weaponname ); if ( !isDefined( from_emp ) || !from_emp ) { if ( isDefined( attacker ) ) { - if ( level.teambased || attacker.team != self.owner.team && attacker != self.owner ) + if ( self.owner isenemyplayer( attacker ) ) { - attacker maps/mp/_challenges::destroyedexplosive(); + attacker maps/mp/_challenges::destroyedexplosive( weaponname ); + maps/mp/_scoreevents::processscoreevent( "destroyed_claymore", attacker, self.owner, weaponname ); } } } - maps/mp/gametypes_zm/_weaponobjects::weapondetonate( attacker, weaponname ); + maps/mp/gametypes/_weaponobjects::weapondetonate( attacker, weaponname ); } weapondetonate( attacker, weaponname ) { - from_emp = 0; + from_emp = maps/mp/killstreaks/_emp::isempweapon( weaponname ); if ( from_emp ) { self delete(); @@ -339,10 +398,22 @@ weapondetonate( attacker, weaponname ) } if ( isDefined( attacker ) ) { - self detonate( attacker ); + if ( isDefined( self.owner ) && attacker != self.owner ) + { + self.playdialog = 1; + } + if ( isplayer( attacker ) ) + { + self detonate( attacker ); + } + else + { + self detonate(); + } } else if ( isDefined( self.owner ) && isplayer( self.owner ) ) { + self.playdialog = 0; self detonate( self.owner ); } else @@ -355,20 +426,13 @@ waitanddetonate( object, delay, attacker, weaponname ) { object endon( "death" ); object endon( "hacked" ); - from_emp = 0; - if ( from_emp ) + from_emp = maps/mp/killstreaks/_emp::isempweapon( weaponname ); + if ( from_emp && isDefined( object.name ) && object.name != "qrdrone_turret_mp" ) { object setclientflag( 15 ); object setclientflag( 9 ); object.stun_fx = 1; - if ( isDefined( object.name ) && object.name == "qrdrone_turret_mp" ) - { - playfx( level._equipment_emp_destroy_fx, object.origin + ( 0, 0, 1 ), ( 0, randomfloat( 360 ), 0 ) ); - } - else - { - playfx( level._equipment_emp_destroy_fx, object.origin + vectorScale( ( 0, 0, 1 ), 5 ), ( 0, randomfloat( 360 ), 0 ) ); - } + playfx( level._equipment_emp_destroy_fx, object.origin + vectorScale( ( 0, 0, 1 ), 5 ), ( 0, randomfloat( 360 ), 0 ) ); delay = 1,1; } if ( delay ) @@ -507,12 +571,51 @@ addweaponobject( watcher, weapon ) } if ( watcher.deleteonkillbrush ) { - weapon thread deleteonkillbrush( self ); + if ( isDefined( level.deleteonkillbrushoverride ) ) + { + weapon thread [[ level.deleteonkillbrushoverride ]]( self, watcher ); + return; + } + else + { + weapon thread deleteonkillbrush( self ); + } } } watchscramble( watcher ) { + self endon( "death" ); + self endon( "hacked" ); + self waittillnotmoving(); + if ( self maps/mp/_scrambler::checkscramblerstun() ) + { + self thread stunstart( watcher ); + } + else + { + self stunstop(); + } + for ( ;; ) + { + level waittill_any( "scrambler_spawn", "scrambler_death", "hacked" ); + if ( isDefined( self.owner ) && self.owner isempjammed() ) + { + continue; + } + else + { + if ( self maps/mp/_scrambler::checkscramblerstun() ) + { + self thread stunstart( watcher ); + break; + } + else + { + self stunstop(); + } + } + } } deleteweaponobjecthelper( weapon_ent ) @@ -578,9 +681,9 @@ weaponobjectdamage( watcher ) } if ( level.teambased && self.owner.team != attacker.team ) { - if ( maps/mp/gametypes_zm/_globallogic_player::dodamagefeedback( weaponname, attacker ) ) + if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) ) { - attacker maps/mp/gametypes_zm/_damagefeedback::updatedamagefeedback(); + attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback(); } continue; } @@ -588,9 +691,9 @@ weaponobjectdamage( watcher ) { if ( !level.teambased && self.owner != attacker ) { - if ( maps/mp/gametypes_zm/_globallogic_player::dodamagefeedback( weaponname, attacker ) ) + if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) ) { - attacker maps/mp/gametypes_zm/_damagefeedback::updatedamagefeedback(); + attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback(); } } } @@ -600,16 +703,16 @@ weaponobjectdamage( watcher ) case "emp_grenade_mp": if ( level.teambased && self.owner.team != attacker.team ) { - if ( maps/mp/gametypes_zm/_globallogic_player::dodamagefeedback( weaponname, attacker ) ) + if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) ) { - attacker maps/mp/gametypes_zm/_damagefeedback::updatedamagefeedback(); + attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback(); } } else if ( !level.teambased && self.owner != attacker ) { - if ( maps/mp/gametypes_zm/_globallogic_player::dodamagefeedback( weaponname, attacker ) ) + if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) ) { - attacker maps/mp/gametypes_zm/_damagefeedback::updatedamagefeedback(); + attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback(); } } break; @@ -628,9 +731,9 @@ weaponobjectdamage( watcher ) continue; } } - if ( maps/mp/gametypes_zm/_globallogic_player::dodamagefeedback( weaponname, attacker ) ) + if ( maps/mp/gametypes/_globallogic_player::dodamagefeedback( weaponname, attacker ) ) { - attacker maps/mp/gametypes_zm/_damagefeedback::updatedamagefeedback(); + attacker maps/mp/gametypes/_damagefeedback::updatedamagefeedback(); } if ( !isvehicle( self ) && !friendlyfirecheck( self.owner, attacker ) ) { @@ -648,6 +751,7 @@ weaponobjectdamage( watcher ) } level.weaponobjectexplodethisframe = 1; thread resetweaponobjectexplodethisframe(); + self maps/mp/_entityheadicons::setentityheadicon( "none" ); if ( isDefined( type ) && !issubstr( type, "MOD_GRENADE_SPLASH" ) || issubstr( type, "MOD_GRENADE" ) && issubstr( type, "MOD_EXPLOSIVE" ) ) { self.waschained = 1; @@ -670,7 +774,7 @@ playdialogondeath( owner ) self waittill( "death" ); if ( isDefined( self.playdialog ) && self.playdialog ) { - owner maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "equipment_destroyed", "item_destroyed" ); + owner maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "equipment_destroyed", "item_destroyed" ); } } @@ -916,6 +1020,10 @@ commononspawnuseweaponobject( watcher, owner ) { offset = level.weaponobjects_headicon_offset[ self.name ]; } + if ( isDefined( self ) ) + { + self maps/mp/_entityheadicons::setentityheadicon( owner.pers[ "team" ], owner, offset ); + } } } } @@ -1025,6 +1133,33 @@ watchweaponobjectspawn() } } +anyobjectsinworld( weapon ) +{ + objectsinworld = 0; + i = 0; + while ( i < self.weaponobjectwatcherarray.size ) + { + if ( self.weaponobjectwatcherarray[ i ].weapon != weapon ) + { + i++; + continue; + } + else + { + if ( isDefined( self.weaponobjectwatcherarray[ i ].detonate ) && self.weaponobjectwatcherarray[ i ].objectarray.size > 0 ) + { + objectsinworld = 1; + break; + } + } + else + { + i++; + } + } + return objectsinworld; +} + watchweaponprojectileobjectspawn() { self endon( "disconnect" ); @@ -1045,7 +1180,7 @@ watchweaponprojectileobjectspawn() } j++; } - if ( isDefined( watcher.detonate ) && watcher.objectarray.size > 1 ) + if ( isDefined( watcher.detonate ) && watcher.objectarray.size > 3 ) { watcher thread waitanddetonate( watcher.objectarray[ 0 ], 0,1 ); } @@ -1206,7 +1341,10 @@ hackertriggersetvisibility( owner ) self setvisibletoall(); self setteamfortrigger( "none" ); } - self setinvisibletoplayer( owner ); + if ( isDefined( owner ) ) + { + self setinvisibletoplayer( owner ); + } level waittill_any( "player_spawned", "joined_team" ); } } @@ -1265,13 +1403,16 @@ hackerthink( trigger, watcher ) else { self.owner hackerremoveweapon( self ); - self.owner maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "hacked_equip", "item_destroyed" ); + self.owner maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "hacked_equip", "item_destroyed" ); self.hacked = 1; self setmissileowner( player ); self setteam( player.pers[ "team" ] ); self.owner = player; - if ( isweaponequipment( self.name ) ) + if ( isweaponequipment( self.name ) || self.name == "proximity_grenade_mp" ) { + maps/mp/_scoreevents::processscoreevent( "hacked", player ); + player addweaponstat( "pda_hack_mp", "CombatRecordStat", 1 ); + player maps/mp/_challenges::hackedordestroyedequipment(); } if ( self.name == "satchel_charge_mp" && isDefined( player.lowermessage ) ) { @@ -1310,14 +1451,6 @@ hackerthink( trigger, watcher ) } } -ishacked() -{ - if ( isDefined( self.hacked ) ) - { - return self.hacked; - } -} - hackerunfreezeplayer( player ) { self endon( "hack_done" ); @@ -1588,6 +1721,7 @@ proximityweaponobjectdetonation( watcher ) { wait getDvarFloat( "perk_delayExplosiveTime" ); } + self maps/mp/_entityheadicons::setentityheadicon( "none" ); self.origin = traceorigin; if ( isDefined( self.owner ) && isplayer( self.owner ) ) { @@ -1598,6 +1732,12 @@ proximityweaponobjectdetonation( watcher ) shouldaffectweaponobject( object, watcher ) { + radius = getweaponexplosionradius( watcher.weapon ); + distancesqr = distancesquared( self.origin, object.origin ); + if ( ( radius * radius ) < distancesqr ) + { + return 0; + } pos = self.origin + vectorScale( ( 0, 0, 1 ), 32 ); if ( isDefined( watcher.ignoredirection ) ) { @@ -1633,12 +1773,41 @@ deleteondeath( ent ) } } +testkillbrushonstationary( killbrusharray, player ) +{ + player endon( "disconnect" ); + self endon( "death" ); + self waittill( "stationary" ); + wait 0,1; + i = 0; + while ( i < killbrusharray.size ) + { + if ( self istouching( killbrusharray[ i ] ) ) + { + if ( self.origin[ 2 ] > player.origin[ 2 ] ) + { + return; + } + else + { + if ( isDefined( self ) ) + { + self delete(); + } + return; + } + i++; + } + } +} + deleteonkillbrush( player ) { player endon( "disconnect" ); self endon( "death" ); self endon( "stationary" ); killbrushes = getentarray( "trigger_hurt", "classname" ); + self thread testkillbrushonstationary( killbrushes, player ); while ( 1 ) { i = 0; @@ -1879,6 +2048,14 @@ friendlyfirecheck( owner, attacker, forcedfriendlyfirerule ) return 1; } } + else + { + occupant_team = attacker maps/mp/_vehicles::vehicle_get_occupant_team(); + if ( occupant_team != owner.pers[ "team" ] ) + { + return 1; + } + } } } } @@ -2038,10 +2215,6 @@ onspawnretrievableweaponobject( watcher, player ) up = anglesToUp( self.angles ); triggerorigin = self.origin + up; } - if ( isDefined( watcher.adjusttriggerorigin ) ) - { - triggerorigin = self [[ watcher.adjusttriggerorigin ]]( triggerorigin ); - } self.pickuptrigger = spawn( "trigger_radius_use", triggerorigin ); self.pickuptrigger sethintlowpriority( 1 ); self.pickuptrigger setcursorhint( "HINT_NOICON", self ); @@ -2178,6 +2351,7 @@ pickup( player ) { return; } + self notify( "picked_up" ); self.playdialog = 0; self destroyent(); player giveweapon( self.name ); @@ -2194,7 +2368,7 @@ ondestroyed( attacker ) { playfx( level._effect[ "tacticalInsertionFizzle" ], self.origin ); self playsound( "dst_tac_insert_break" ); - self.owner maps/mp/gametypes_zm/_globallogic_audio::leaderdialogonplayer( "equipment_destroyed", "item_destroyed" ); + self.owner maps/mp/gametypes/_globallogic_audio::leaderdialogonplayer( "equipment_destroyed", "item_destroyed" ); self delete(); } @@ -2316,6 +2490,7 @@ attachreconmodel( modelname, owner ) reconmodel thread watchreconmodelfordeath( self ); reconmodel thread resetreconmodelonevent( "joined_team", owner ); reconmodel thread resetreconmodelonevent( "player_spawned", owner ); + self.reconmodelentity = reconmodel; } resetreconmodelvisibility( owner ) @@ -2431,5 +2606,41 @@ resetreconmodelonevent( eventname, owner ) switch_team( entity, weapon_name, owner ) { /# + self notify( "stop_disarmthink" ); + self endon( "stop_disarmthink" ); + self endon( "death" ); + setdvar( "scr_switch_team", "" ); + while ( 1 ) + { + wait 0,5; + devgui_int = getDvarInt( "scr_switch_team" ); + if ( devgui_int != 0 ) + { + team = "autoassign"; + player = maps/mp/gametypes/_dev::getormakebot( team ); + while ( !isDefined( player ) ) + { + println( "Could not add test client" ); + wait 1; + } + entity.owner hackerremoveweapon( entity ); + entity.hacked = 1; + entity setowner( player ); + entity setteam( player.pers[ "team" ] ); + entity.owner = player; + entity notify( "hacked" ); + level notify( "hacked" ); + if ( entity.name == "camera_spike_mp" && isDefined( entity.camerahead ) ) + { + entity.camerahead notify( "hacked" ); + } + wait 0,05; + if ( isDefined( player ) && player.sessionstate == "playing" ) + { + player notify( "grenade_fire" ); + } + setdvar( "scr_switch_team", "0" ); + } #/ + } } diff --git a/patch_mp/maps/mp/gametypes/_weapons.gsc b/patch_mp/maps/mp/gametypes/_weapons.gsc index c70cd9c..cac0a41 100644 --- a/patch_mp/maps/mp/gametypes/_weapons.gsc +++ b/patch_mp/maps/mp/gametypes/_weapons.gsc @@ -1,11 +1,17 @@ -#include maps/mp/gametypes_zm/_gameobjects; -#include maps/mp/gametypes_zm/_shellshock; -#include maps/mp/gametypes_zm/_globallogic_utils; -#include maps/mp/zombies/_zm_pers_upgrades_functions; +#include maps/mp/gametypes/_gameobjects; +#include maps/mp/gametypes/_shellshock; +#include maps/mp/killstreaks/_dogs; +#include maps/mp/gametypes/_globallogic_utils; +#include maps/mp/_scoreevents; +#include maps/mp/_tabun; +#include maps/mp/killstreaks/_supplydrop; #include maps/mp/_challenges; -#include maps/mp/gametypes_zm/_weapons; +#include maps/mp/gametypes/_weapons; +#include maps/mp/killstreaks/_killstreak_weapons; +#include maps/mp/gametypes/_class; #include maps/mp/_bb; -#include maps/mp/gametypes_zm/_weapon_utils; +#include maps/mp/_flashgrenades; +#include maps/mp/gametypes/_weapon_utils; #include maps/mp/_utility; #include common_scripts/utility; @@ -24,6 +30,9 @@ init() precachemodel( "t6_wpn_motion_sensor_world_detect" ); precachemodel( "t6_wpn_trophy_system_world_detect" ); precachemodel( "t6_wpn_bouncing_betty_world_detect" ); + precachemodel( "t6_wpn_tac_insert_world" ); + precachemodel( "t6_wpn_shield_stow_world" ); + precachemodel( "t6_wpn_shield_carry_world" ); precachemodel( "t5_weapon_camera_head_world" ); precacheitem( "scavenger_item_mp" ); precacheitem( "scavenger_item_hack_mp" ); @@ -36,20 +45,31 @@ init() precacheshellshock( "proximity_grenade_exit" ); level.missileentities = []; level.hackertooltargets = []; - if ( !isDefined( level.grenadelauncherdudtime ) ) + level.missileduddeletedelay = getdvarintdefault( "scr_missileDudDeleteDelay", 3 ); + thread maps/mp/_flashgrenades::main(); + thread maps/mp/_empgrenade::init(); + thread maps/mp/_entityheadicons::init(); + if ( !isDefined( level.roundstartexplosivedelay ) ) { - level.grenadelauncherdudtime = 0; - } - if ( !isDefined( level.throwngrenadedudtime ) ) - { - level.throwngrenadedudtime = 0; + level.roundstartexplosivedelay = 0; } level thread onplayerconnect(); - maps/mp/gametypes_zm/_weaponobjects::init(); - if ( !is_false( level._uses_sticky_grenades ) ) - { - maps/mp/_sticky_grenade::init(); - } + maps/mp/gametypes/_weaponobjects::init(); + maps/mp/_smokegrenade::init(); + maps/mp/_heatseekingmissile::init(); + maps/mp/_acousticsensor::init(); + maps/mp/_sensor_grenade::init(); + maps/mp/_tacticalinsertion::init(); + maps/mp/_scrambler::init(); + maps/mp/_explosive_bolt::init(); + maps/mp/_sticky_grenade::init(); + maps/mp/_proximity_grenade::init(); + maps/mp/_bouncingbetty::init(); + maps/mp/_trophy_system::init(); + maps/mp/_ballistic_knife::init(); + maps/mp/_satchel_charge::init(); + maps/mp/_riotshield::init(); + maps/mp/_hacker_tool::init(); } onplayerconnect() @@ -72,6 +92,7 @@ onplayerspawned() { self waittill( "spawned_player" ); self.concussionendtime = 0; + self.scavenged = 0; self.hasdonecombat = 0; self.shielddamageblocked = 0; self thread watchweaponusage(); @@ -132,6 +153,7 @@ watchweaponchange() { self.hitsthismag[ weapon ] = weaponclipsize( weapon ); } + self.lastweaponchange = 0; while ( 1 ) { previous_weapon = self getcurrentweapon(); @@ -139,6 +161,7 @@ watchweaponchange() if ( maydropweapon( newweapon ) ) { self.lastdroppableweapon = newweapon; + self.lastweaponchange = getTime(); } if ( newweapon != "none" ) { @@ -147,11 +170,24 @@ watchweaponchange() self.hitsthismag[ newweapon ] = weaponclipsize( newweapon ); } } + if ( doesweaponreplacespawnweapon( self.spawnweapon, newweapon ) ) + { + self.spawnweapon = newweapon; + self.pers[ "spawnWeapon" ] = newweapon; + } } } watchriotshielduse() { + self endon( "death" ); + self endon( "disconnect" ); + self thread maps/mp/_riotshield::trackriotshield(); + for ( ;; ) + { + self waittill( "raise_riotshield" ); + self thread maps/mp/_riotshield::startriotshielddeploy(); + } } updatelastheldweapontimings( newtime ) @@ -269,6 +305,7 @@ trackweapon() if ( newweapon != "none" && newweapon != currentweapon ) { updatelastheldweapontimings( newtime ); + self maps/mp/gametypes/_class::initweaponattachments( newweapon ); currentweapon = newweapon; currenttime = newtime; } @@ -276,7 +313,7 @@ trackweapon() } else { - if ( event != "disconnect" ) + if ( event != "disconnect" && isDefined( self ) ) { self maps/mp/_bb::commitweapondata( spawnid, currentweapon, currenttime ); updateweapontimings( newtime ); @@ -312,7 +349,7 @@ maydropweapon( weapon ) return 1; } -dropweaponfordeath( attacker ) +dropweaponfordeath( attacker, sweapon, smeansofdeath ) { if ( level.disableweapondrop == 1 ) { @@ -367,6 +404,10 @@ dropweaponfordeath( attacker ) { return; } + if ( maps/mp/killstreaks/_killstreak_weapons::isheldkillstreakweapon( weapon ) ) + { + return; + } clipammo = self getweaponammoclip( weapon ); stockammo = self getweaponammostock( weapon ); clip_and_stock_ammo = clipammo + stockammo; @@ -404,6 +445,8 @@ dropweaponfordeath( attacker ) item itemweaponsetammo( clipammo, stockammo ); item.owner = self; item.ownersattacker = attacker; + item.sweapon = sweapon; + item.smeansofdeath = smeansofdeath; item thread watchpickup(); item thread deletepickupafterawhile(); } @@ -523,17 +566,7 @@ watchpickup() { self endon( "death" ); weapname = self getitemweaponname(); - while ( 1 ) - { - self waittill( "trigger", player, droppeditem ); - if ( isDefined( droppeditem ) ) - { - break; - } - else - { - } - } + self waittill( "trigger", player, droppeditem ); /# if ( getDvar( #"08F7FC88" ) == "1" ) { @@ -546,19 +579,28 @@ watchpickup() /# assert( isDefined( player.pickedupweaponkills ) ); #/ - droppedweaponname = droppeditem getitemweaponname(); - if ( isDefined( player.tookweaponfrom[ droppedweaponname ] ) ) + if ( isDefined( droppeditem ) ) { - droppeditem.owner = player.tookweaponfrom[ droppedweaponname ]; - droppeditem.ownersattacker = player; + droppedweaponname = droppeditem getitemweaponname(); + if ( isDefined( player.tookweaponfrom[ droppedweaponname ] ) ) + { + droppeditem.owner = player.tookweaponfrom[ droppedweaponname ]; + droppeditem.ownersattacker = player; + } + droppeditem thread watchpickup(); } - droppeditem thread watchpickup(); if ( isDefined( self.ownersattacker ) && self.ownersattacker == player ) { - player.tookweaponfrom[ weapname ] = self.owner; + player.tookweaponfrom[ weapname ] = spawnstruct(); + player.tookweaponfrom[ weapname ].previousowner = self.owner; + player.tookweaponfrom[ weapname ].sweapon = self.sweapon; + player.tookweaponfrom[ weapname ].smeansofdeath = self.smeansofdeath; player.pickedupweaponkills[ weapname ] = 0; } - else } + else + { + } +} itemremoveammofromaltmodes() { @@ -620,7 +662,7 @@ watchweaponusage() self waittill( "weapon_fired", curweapon ); self.lastfiretime = getTime(); self.hasdonecombat = 1; - if ( maps/mp/gametypes_zm/_weapons::isprimaryweapon( curweapon ) || maps/mp/gametypes_zm/_weapons::issidearm( curweapon ) ) + if ( maps/mp/gametypes/_weapons::isprimaryweapon( curweapon ) || maps/mp/gametypes/_weapons::issidearm( curweapon ) ) { if ( isDefined( self.hitsthismag[ curweapon ] ) ) { @@ -630,29 +672,37 @@ watchweaponusage() switch( weaponclass( curweapon ) ) { case "rifle": + if ( curweapon == "crossbow_mp" ) + { + level.globalcrossbowfired++; + } if ( curweapon == "crossbow_explosive_mp" ) { level.globalcrossbowfired++; self addweaponstat( curweapon, "shots", 1 ); self thread begingrenadetracking(); break; - continue; } else case "mg": case "pistol": + case "pistol spread": case "smg": case "spread": self trackweaponfire( curweapon ); level.globalshotsfired++; break; - continue; case "grenade": case "rocketlauncher": self addweaponstat( curweapon, "shots", 1 ); break; - continue; default: } + if ( maps/mp/killstreaks/_killstreak_weapons::isheldkillstreakweapon( curweapon ) ) + { + self.pers[ "held_killstreak_ammo_count" ][ curweapon ]--; + + self.usedkillstreakweapon[ curweapon ] = 1; + } } } } @@ -687,34 +737,9 @@ checkhitsthismag( weaponname ) trackweaponfire( curweapon ) { - shotsfired = 1; - if ( isDefined( self.laststandparams ) && self.laststandparams.laststandstarttime == getTime() ) - { - self.hits = 0; - return; - } pixbeginevent( "trackWeaponFire" ); - if ( is_true( level.pers_upgrade_sniper ) ) - { - maps/mp/zombies/_zm_pers_upgrades_functions::pers_sniper_player_fires( curweapon, self.hits ); - } - self addweaponstat( curweapon, "shots", shotsfired ); - self addweaponstat( curweapon, "hits", self.hits ); - if ( isDefined( level.add_client_stat ) ) - { - self [[ level.add_client_stat ]]( "total_shots", shotsfired ); - self [[ level.add_client_stat ]]( "hits", self.hits ); - } - else - { - self addplayerstat( "total_shots", shotsfired ); - self addplayerstat( "hits", self.hits ); - self addplayerstat( "misses", int( max( 0, shotsfired - self.hits ) ) ); - } - self incrementplayerstat( "total_shots", shotsfired ); - self incrementplayerstat( "hits", self.hits ); - self incrementplayerstat( "misses", int( max( 0, shotsfired - self.hits ) ) ); - self maps/mp/_bb::bbaddtostat( "shots", shotsfired ); + self trackweaponfirenative( curweapon, 1, self.hits, 1 ); + self maps/mp/_bb::bbaddtostat( "shots", 1 ); self maps/mp/_bb::bbaddtostat( "hits", self.hits ); self.hits = 0; pixendevent(); @@ -737,14 +762,10 @@ checkhit( sweapon ) default: } waittillframeend; - if ( isDefined( self.hitsthismag ) && isDefined( self.hitsthismag[ sweapon ] ) ) + if ( isDefined( self ) && isDefined( self.hitsthismag ) && isDefined( self.hitsthismag[ sweapon ] ) ) { self thread checkhitsthismag( sweapon ); } - if ( sweapon != "bazooka_mp" || isstrstart( sweapon, "t34" ) && isstrstart( sweapon, "panzer" ) ) - { - self addweaponstat( sweapon, "hits", 1 ); - } } } @@ -769,6 +790,11 @@ watchgrenadeusage() { self thread beginsatcheltracking(); } + if ( !maps/mp/killstreaks/_supplydrop::issupplydropweapon( weaponname ) && weaponname != "sensor_grenade_mp" ) + { + self setoffhandvisible( 1 ); + self thread watchoffhandend(); + } self thread begingrenadetracking(); } } @@ -830,15 +856,53 @@ watchgrenadecancel() self endon( "death" ); self endon( "disconnect" ); self endon( "grenade_fire" ); - self waittill( "weapon_change" ); + waittillframeend; + weapon = "none"; + while ( self isthrowinggrenade() && weapon == "none" ) + { + self waittill( "weapon_change", weapon ); + } self.throwinggrenade = 0; self.gotpullbacknotify = 0; + self notify( "grenade_throw_cancelled" ); +} + +watchoffhandend() +{ + self notify( "watchOffhandEnd" ); + self endon( "watchOffhandEnd" ); + while ( self isusingoffhandequipment() ) + { + msg = self waittill_any_return( "death", "disconnect", "grenade_fire", "weapon_change" ); + if ( msg == "death" || msg == "disconnect" ) + { + break; + } + else + { + } + } + self setoffhandvisible( 0 ); +} + +isusingoffhandequipment() +{ + if ( self isusingoffhand() ) + { + weapon = self getcurrentoffhand(); + if ( isweaponequipment( weapon ) ) + { + return 1; + } + } + return 0; } begingrenadetracking() { self endon( "death" ); self endon( "disconnect" ); + self endon( "grenade_throw_cancelled" ); starttime = getTime(); self thread watchgrenadecancel(); self waittill( "grenade_fire", grenade, weaponname ); @@ -847,7 +911,7 @@ begingrenadetracking() #/ level.missileentities[ level.missileentities.size ] = grenade; grenade thread watchmissiledeath(); - if ( grenade maps/mp/gametypes_zm/_weaponobjects::ishacked() ) + if ( grenade maps/mp/_utility::ishacked() ) { return; } @@ -858,24 +922,99 @@ begingrenadetracking() } switch( weaponname ) { - case "frag_grenade_zm": - case "sticky_grenade_zm": - self addweaponstat( weaponname, "used", 1 ); - case "explosive_bolt_zm": - grenade.originalowner = self; - break; + case "frag_grenade_mp": + level.globalfraggrenadesfired++; + case "sticky_grenade_mp": + self addweaponstat( weaponname, "used", 1 ); + case "explosive_bolt_mp": + grenade.originalowner = self; + break; + case "satchel_charge_mp": + level.globalsatchelchargefired++; + break; + } + if ( weaponname == "sticky_grenade_mp" || weaponname == "frag_grenade_mp" ) + { + grenade setteam( self.pers[ "team" ] ); + grenade setowner( self ); + } + self.throwinggrenade = 0; } - if ( weaponname == "sticky_grenade_zm" || weaponname == "frag_grenade_zm" ) - { - grenade setteam( self.pers[ "team" ] ); - grenade setowner( self ); - } - self.throwinggrenade = 0; } } beginothergrenadetracking() { + self notify( "grenadeTrackingStart" ); + self endon( "grenadeTrackingStart" ); + self endon( "disconnect" ); + for ( ;; ) + { + self waittill( "grenade_fire", grenade, weaponname, parent ); + if ( grenade maps/mp/_utility::ishacked() ) + { + break; + continue; + } + else switch( weaponname ) + { + case "flash_grenade_mp": + break; + continue; + case "concussion_grenade_mp": + case "willy_pete_mp": + grenade thread maps/mp/_smokegrenade::watchsmokegrenadedetonation( self ); + break; + continue; + case "tabun_gas_mp": + grenade thread maps/mp/_tabun::watchtabungrenadedetonation( self ); + break; + continue; + case "sticky_grenade_mp": + grenade thread checkstucktoplayer( 1, 1, weaponname ); + grenade thread checkstucktoshield(); + break; + continue; + case "c4_mp": + case "satchel_charge_mp": + grenade thread checkstucktoplayer( 1, 0, weaponname ); + break; + continue; + case "proximity_grenade_mp": + grenade thread checkstucktoshield(); + grenade thread maps/mp/_proximity_grenade::watchproximitygrenadehitplayer( self ); + break; + continue; + case "tactical_insertion_mp": + grenade thread maps/mp/_tacticalinsertion::watch( self ); + break; + continue; + case "scrambler_mp": + case "explosive_bolt_mp": + grenade.ownerweaponatlaunch = self.currentweapon; + if ( self playerads() == 1 ) + { + } + else grenade.owneradsatlaunch = 0; + grenade thread maps/mp/_explosive_bolt::watch_bolt_detonation( self ); + grenade thread checkstucktoplayer( 1, 0, weaponname ); + grenade thread checkstucktoshield(); + break; + continue; + case "hatchet_mp": + grenade.lastweaponbeforetoss = self getlastweapon(); + grenade thread checkhatchetbounce(); + grenade thread checkstucktoplayer( 0, 0, weaponname ); + self addweaponstat( weaponname, "used", 1 ); + break; + continue; + case "emp_grenade_mp": + grenade thread maps/mp/_empgrenade::watchempexplosion( self, weaponname ); + break; + continue; + } + } + } } checkstucktoplayer( deleteonteamchange, awardscoreevent, weaponname ) @@ -892,12 +1031,20 @@ checkstucktoplayer( deleteonteamchange, awardscoreevent, weaponname ) { if ( self.originalowner isenemyplayer( player ) ) { + maps/mp/_scoreevents::processscoreevent( "stick_explosive_kill", self.originalowner, player, weaponname ); } } self.stucktoplayer = player; } } +checkstucktoshield() +{ + self endon( "death" ); + self waittill( "stuck_to_shield", other, owner ); + other maps/mp/_riotshield::watchriotshieldstuckentitydeath( self, owner ); +} + checkhatchetbounce() { self endon( "stuck_to_player" ); @@ -954,106 +1101,62 @@ watchforthrowbacks() } } -registergrenadelauncherduddvar( dvarstring, defaultvalue, minvalue, maxvalue ) +waitanddeletedud( waittime ) { - dvarstring = "scr_" + dvarstring + "_grenadeLauncherDudTime"; - if ( getDvar( dvarstring ) == "" ) + self endon( "death" ); + wait waittime; + if ( isDefined( self ) ) { - setdvar( dvarstring, defaultvalue ); + self delete(); } - if ( getDvarInt( dvarstring ) > maxvalue ) - { - setdvar( dvarstring, maxvalue ); - } - else - { - if ( getDvarInt( dvarstring ) < minvalue ) - { - setdvar( dvarstring, minvalue ); - } - } - level.grenadelauncherdudtimedvar = dvarstring; - level.grenadelauncherdudtimemin = minvalue; - level.grenadelauncherdudtimemax = maxvalue; - level.grenadelauncherdudtime = getDvarInt( level.grenadelauncherdudtimedvar ); } -registerthrowngrenadeduddvar( dvarstring, defaultvalue, minvalue, maxvalue ) +makeallboltsdud() { - dvarstring = "scr_" + dvarstring + "_thrownGrenadeDudTime"; - if ( getDvar( dvarstring ) == "" ) + grenades = getentarray( "grenade", "classname" ); + i = 0; + while ( i < grenades.size ) { - setdvar( dvarstring, defaultvalue ); - } - if ( getDvarInt( dvarstring ) > maxvalue ) - { - setdvar( dvarstring, maxvalue ); - } - else - { - if ( getDvarInt( dvarstring ) < minvalue ) + if ( grenades[ i ].model == "t5_weapon_crossbow_bolt" ) { - setdvar( dvarstring, minvalue ); + grenades[ i ] makegrenadedud(); + if ( !isDefined( grenades[ i ].isdud ) ) + { + grenades[ i ] thread waitanddeletedud( level.missileduddeletedelay ); + } + grenades[ i ].isdud = 1; } + i++; } - level.throwngrenadedudtimedvar = dvarstring; - level.throwngrenadedudtimemin = minvalue; - level.throwngrenadedudtimemax = maxvalue; - level.throwngrenadedudtime = getDvarInt( level.throwngrenadedudtimedvar ); -} - -registerkillstreakdelay( dvarstring, defaultvalue, minvalue, maxvalue ) -{ - dvarstring = "scr_" + dvarstring + "_killstreakDelayTime"; - if ( getDvar( dvarstring ) == "" ) - { - setdvar( dvarstring, defaultvalue ); - } - if ( getDvarInt( dvarstring ) > maxvalue ) - { - setdvar( dvarstring, maxvalue ); - } - else - { - if ( getDvarInt( dvarstring ) < minvalue ) - { - setdvar( dvarstring, minvalue ); - } - } - level.killstreakrounddelay = getDvarInt( dvarstring ); } turngrenadeintoadud( weapname, isthrowngrenade, player ) { - if ( level.grenadelauncherdudtime >= ( maps/mp/gametypes_zm/_globallogic_utils::gettimepassed() / 1000 ) && !isthrowngrenade ) + if ( level.roundstartexplosivedelay >= ( maps/mp/gametypes/_globallogic_utils::gettimepassed() / 1000 ) ) { - if ( issubstr( weapname, "gl_" ) || weapname == "china_lake_mp" ) + if ( isweapondisallowedatmatchstart( weapname ) || issubstr( weapname, "gl_" ) ) { - timeleft = int( level.grenadelauncherdudtime - ( maps/mp/gametypes_zm/_globallogic_utils::gettimepassed() / 1000 ) ); + timeleft = int( level.roundstartexplosivedelay - ( maps/mp/gametypes/_globallogic_utils::gettimepassed() / 1000 ) ); if ( !timeleft ) { timeleft = 1; } - player iprintlnbold( &"MP_LAUNCHER_UNAVAILABLE_FOR_N", " " + timeleft + " ", &"EXE_SECONDS" ); - self makegrenadedud(); - } - } - else - { - if ( level.throwngrenadedudtime >= ( maps/mp/gametypes_zm/_globallogic_utils::gettimepassed() / 1000 ) && isthrowngrenade ) - { - if ( weapname == "frag_grenade_mp" || weapname == "sticky_grenade_mp" ) + if ( weapname == "explosive_bolt_mp" ) { - if ( isDefined( player.suicide ) && player.suicide ) + self makeallboltsdud(); + player iprintlnbold( &"MP_LAUNCHER_UNAVAILABLE_FOR_N", " " + timeleft + " ", &"EXE_SECONDS" ); + return; + } + else + { + if ( isthrowngrenade ) { - return; + player iprintlnbold( &"MP_GRENADE_UNAVAILABLE_FOR_N", " " + timeleft + " ", &"EXE_SECONDS" ); } - timeleft = int( level.throwngrenadedudtime - ( maps/mp/gametypes_zm/_globallogic_utils::gettimepassed() / 1000 ) ); - if ( !timeleft ) + else { - timeleft = 1; + player iprintlnbold( &"MP_LAUNCHER_UNAVAILABLE_FOR_N", " " + timeleft + " ", &"EXE_SECONDS" ); } - player iprintlnbold( &"MP_GRENADE_UNAVAILABLE_FOR_N", " " + timeleft + " ", &"EXE_SECONDS" ); self makegrenadedud(); } } @@ -1079,6 +1182,11 @@ watchforgrenadelauncherduds() { self waittill( "grenade_launcher_fire", grenade, weapname ); grenade turngrenadeintoadud( weapname, 0, self ); +/# + assert( isDefined( grenade ) ); +#/ + level.missileentities[ level.missileentities.size ] = grenade; + grenade thread watchmissiledeath(); } } @@ -1177,6 +1285,33 @@ getdamageableents( pos, radius, dolos, startradius ) } i++; } + dogs = maps/mp/killstreaks/_dogs::dog_manager_get_dogs(); + _a1453 = dogs; + _k1453 = getFirstArrayKey( _a1453 ); + while ( isDefined( _k1453 ) ) + { + dog = _a1453[ _k1453 ]; + if ( !isalive( dog ) ) + { + } + else + { + entpos = dog.origin; + distsq = distancesquared( pos, entpos ); + if ( distsq < ( radius * radius ) || !dolos && weapondamagetracepassed( pos, entpos, startradius, dog ) ) + { + newent = spawnstruct(); + newent.isplayer = 0; + newent.isadestructable = 0; + newent.isadestructible = 0; + newent.isactor = 1; + newent.entity = dog; + newent.damagecenter = entpos; + ents[ ents.size ] = newent; + } + } + _k1453 = getNextArrayKey( _a1453, _k1453 ); + } return ents; } @@ -1281,9 +1416,13 @@ onweapondamage( eattacker, einflictor, sweapon, meansofdeath, damage ) self shellshock( "concussion_grenade_mp", time, 0 ); } self.concussionendtime = getTime() + ( time * 1000 ); + self.lastconcussedby = eattacker; + break; + case "proximity_grenade_mp": + self proximitygrenadedamageplayer( eattacker, einflictor ); break; default: - maps/mp/gametypes_zm/_shellshock::shellshockondamage( meansofdeath, damage ); + maps/mp/gametypes/_shellshock::shellshockondamage( meansofdeath, damage ); break; } } @@ -1318,6 +1457,18 @@ deleteentonownerdeath( owner ) monitor_dog_special_grenades() { + self endon( "death" ); + while ( 1 ) + { + self waittill( "damage", damage, attacker, direction_vec, point, type, modelname, tagname, partname, weaponname, idflags ); + if ( isflashorstunweapon( weaponname ) ) + { + damage_area = spawn( "trigger_radius", self.origin, 0, 128, 128 ); + attacker thread maps/mp/killstreaks/_dogs::flash_dogs( damage_area ); + wait 0,05; + damage_area delete(); + } + } } isprimaryweapon( weaponname ) @@ -1387,6 +1538,12 @@ updatestowedweapon() while ( 1 ) { self waittill( "weapon_change", newweapon ); + while ( self ismantling() ) + { + continue; + } + currentstowed = self getstowedweapon(); + hasstowed = 0; self.weapon_array_primary = []; self.weapon_array_sidearm = []; self.weapon_array_grenade = []; @@ -1397,16 +1554,17 @@ updatestowedweapon() { switch( weaponslist[ idx ] ) { - case "m202_flash_mp": - case "m220_tow_mp": case "m32_mp": case "minigun_mp": - case "mp40_blinged_mp": - case "zipline_mp": idx++; continue; default: } + if ( !hasstowed || currentstowed == weaponslist[ idx ] ) + { + currentstowed = weaponslist[ idx ]; + hasstowed = 1; + } if ( isprimaryweapon( weaponslist[ idx ] ) ) { self.weapon_array_primary[ self.weapon_array_primary.size ] = weaponslist[ idx ]; @@ -1440,9 +1598,12 @@ updatestowedweapon() } idx++; } - detach_all_weapons(); - stow_on_back(); - stow_on_hip(); + if ( newweapon != "none" || !hasstowed ) + { + detach_all_weapons(); + stow_on_back(); + stow_on_hip(); + } } } } @@ -1457,7 +1618,7 @@ forcestowedweaponupdate() detachcarryobjectmodel() { - if ( isDefined( self.carryobject ) && isDefined( self.carryobject maps/mp/gametypes_zm/_gameobjects::getvisiblecarriermodel() ) ) + if ( isDefined( self.carryobject ) && isDefined( self.carryobject maps/mp/gametypes/_gameobjects::getvisiblecarriermodel() ) ) { if ( isDefined( self.tag_stowed_back ) ) { @@ -1474,7 +1635,7 @@ detach_all_weapons() clear_weapon = 1; if ( isDefined( self.carryobject ) ) { - carriermodel = self.carryobject maps/mp/gametypes_zm/_gameobjects::getvisiblecarriermodel(); + carriermodel = self.carryobject maps/mp/gametypes/_gameobjects::getvisiblecarriermodel(); if ( isDefined( carriermodel ) && carriermodel == self.tag_stowed_back ) { self detach( self.tag_stowed_back, "tag_stowed_back" ); @@ -1511,84 +1672,65 @@ non_stowed_weapon( weapon ) stow_on_back( current ) { current = self getcurrentweapon(); + currentalt = self getcurrentweaponaltweapon(); self.tag_stowed_back = undefined; weaponoptions = 0; index_weapon = ""; - if ( isDefined( self.carryobject ) && isDefined( self.carryobject maps/mp/gametypes_zm/_gameobjects::getvisiblecarriermodel() ) ) + if ( isDefined( self.carryobject ) && isDefined( self.carryobject maps/mp/gametypes/_gameobjects::getvisiblecarriermodel() ) ) { - self.tag_stowed_back = self.carryobject maps/mp/gametypes_zm/_gameobjects::getvisiblecarriermodel(); + self.tag_stowed_back = self.carryobject maps/mp/gametypes/_gameobjects::getvisiblecarriermodel(); self attach( self.tag_stowed_back, "tag_stowed_back", 1 ); return; } else { - if ( non_stowed_weapon( current ) || self.hasriotshield ) + if ( non_stowed_weapon( current ) ) { return; } else { - idx = 0; - while ( idx < self.weapon_array_primary.size ) + while ( current != "none" ) { - temp_index_weapon = self.weapon_array_primary[ idx ]; + idx = 0; + while ( idx < self.weapon_array_primary.size ) + { + temp_index_weapon = self.weapon_array_primary[ idx ]; /# - assert( isDefined( temp_index_weapon ), "Primary weapon list corrupted." ); + assert( isDefined( temp_index_weapon ), "Primary weapon list corrupted." ); #/ - if ( temp_index_weapon == current ) - { - idx++; - continue; - } - else if ( current == "none" ) - { - idx++; - continue; - } - else if ( !issubstr( current, "gl_" ) && !issubstr( temp_index_weapon, "gl_" ) && !issubstr( current, "mk_" ) && !issubstr( temp_index_weapon, "mk_" ) && !issubstr( current, "dualoptic_" ) && !issubstr( temp_index_weapon, "dualoptic_" ) || issubstr( current, "ft_" ) && issubstr( temp_index_weapon, "ft_" ) ) - { - index_weapon_tok = strtok( temp_index_weapon, "_" ); - current_tok = strtok( current, "_" ); - i = 0; - while ( i < index_weapon_tok.size ) - { - if ( !issubstr( current, index_weapon_tok[ i ] ) || index_weapon_tok.size != current_tok.size ) - { - i = 0; - break; - } - else - { - i++; - } - } - if ( i == index_weapon_tok.size ) + if ( temp_index_weapon == current ) { idx++; continue; } - } - else - { - index_weapon = temp_index_weapon; -/# - assert( isDefined( self.curclass ), "Player missing current class" ); -#/ - if ( issubstr( index_weapon, self.pers[ "primaryWeapon" ] ) && issubstr( self.curclass, "CUSTOM" ) ) + else if ( temp_index_weapon == currentalt ) { - self.tag_stowed_back = getweaponmodel( index_weapon, self getloadoutitem( self.class_num, "primarycamo" ) ); + idx++; + continue; } else { - stowedmodelindex = getweaponstowedmodel( index_weapon ); - self.tag_stowed_back = getweaponmodel( index_weapon, stowedmodelindex ); - } - if ( issubstr( self.curclass, "CUSTOM" ) ) - { - weaponoptions = self calcweaponoptions( self.class_num, 0 ); + index_weapon = temp_index_weapon; +/# + assert( isDefined( self.curclass ), "Player missing current class" ); +#/ + if ( issubstr( index_weapon, self.pers[ "primaryWeapon" ] ) && issubstr( self.curclass, "CUSTOM" ) ) + { + self.tag_stowed_back = getweaponmodel( index_weapon ); + } + else + { + stowedmodelindex = getweaponstowedmodel( index_weapon ); + self.tag_stowed_back = getweaponmodel( index_weapon, stowedmodelindex ); + } + if ( issubstr( self.curclass, "CUSTOM" ) ) + { + weaponoptions = self calcweaponoptions( self.class_num, 0 ); + } } + idx++; } - idx++; } } } @@ -1695,49 +1837,40 @@ player_is_driver() return 0; } -loadout_get_class_num() -{ -/# - assert( isplayer( self ) ); -#/ -/# - assert( isDefined( self.class ) ); -#/ - if ( isDefined( level.classtoclassnum[ self.class ] ) ) - { - return level.classtoclassnum[ self.class ]; - } - class_num = int( self.class[ self.class.size - 1 ] ) - 1; - if ( class_num == -1 ) - { - class_num = 9; - } - return class_num; -} - loadout_get_offhand_weapon( stat ) { if ( isDefined( level.givecustomloadout ) ) { return "weapon_null_mp"; } - class_num = self loadout_get_class_num(); - index = 0; - if ( isDefined( level.tbl_weaponids[ index ] ) && isDefined( level.tbl_weaponids[ index ][ "reference" ] ) ) +/# + assert( isDefined( self.class_num ) ); +#/ + if ( isDefined( self.class_num ) ) { - return level.tbl_weaponids[ index ][ "reference" ] + "_mp"; + index = self maps/mp/gametypes/_class::getloadoutitemfromddlstats( self.class_num, stat ); + if ( isDefined( level.tbl_weaponids[ index ] ) && isDefined( level.tbl_weaponids[ index ][ "reference" ] ) ) + { + return level.tbl_weaponids[ index ][ "reference" ] + "_mp"; + } } return "weapon_null_mp"; } loadout_get_offhand_count( stat ) { + count = 0; if ( isDefined( level.givecustomloadout ) ) { return 0; } - class_num = self loadout_get_class_num(); - count = 0; +/# + assert( isDefined( self.class_num ) ); +#/ + if ( isDefined( self.class_num ) ) + { + count = self maps/mp/gametypes/_class::getloadoutitemfromddlstats( self.class_num, stat ); + } return count; } @@ -1748,18 +1881,12 @@ scavenger_think() primary_weapons = player getweaponslistprimaries(); offhand_weapons_and_alts = array_exclude( player getweaponslist( 1 ), primary_weapons ); arrayremovevalue( offhand_weapons_and_alts, "knife_mp" ); + offhand_weapons_and_alts = array_reverse( offhand_weapons_and_alts ); player playsound( "fly_equipment_pickup_npc" ); player playlocalsound( "fly_equipment_pickup_plr" ); player.scavenger_icon.alpha = 1; player.scavenger_icon fadeovertime( 2,5 ); player.scavenger_icon.alpha = 0; - scavenger_lethal_proc = 1; - scavenger_tactical_proc = 1; - if ( !isDefined( player.scavenger_lethal_proc ) ) - { - player.scavenger_lethal_proc = 0; - player.scavenger_tactical_proc = 0; - } loadout_primary = player loadout_get_offhand_weapon( "primarygrenade" ); loadout_primary_count = player loadout_get_offhand_count( "primarygrenadecount" ); loadout_secondary = player loadout_get_offhand_weapon( "specialgrenade" ); @@ -1776,11 +1903,17 @@ scavenger_think() } else switch( weapon ) { - case "bouncingbetty_mp": + case "satchel_charge_mp": + if ( player maps/mp/gametypes/_weaponobjects::anyobjectsinworld( weapon ) ) + { + break; + i++; + continue; + } + else case "bouncingbetty_mp": case "claymore_mp": case "frag_grenade_mp": case "hatchet_mp": - case "satchel_charge_mp": case "sticky_grenade_mp": if ( isDefined( player.grenadetypeprimarycount ) && player.grenadetypeprimarycount < 1 ) { @@ -1790,103 +1923,57 @@ scavenger_think() } else { - if ( player getweaponammostock( weapon ) != loadout_primary_count ) - { - if ( player.scavenger_lethal_proc < scavenger_lethal_proc ) + case "concussion_grenade_mp": + case "emp_grenade_mp": + case "flash_grenade_mp": + case "nightingale_mp": + case "pda_hack_mp": + case "proximity_grenade_mp": + case "sensor_grenade_mp": + case "tabun_gas_mp": + case "trophy_system_mp": + case "willy_pete_mp": + if ( isDefined( player.grenadetypesecondarycount ) && player.grenadetypesecondarycount < 1 ) { - player.scavenger_lethal_proc++; break; i++; continue; } - else player.scavenger_lethal_proc = 0; - player.scavenger_tactical_proc = 0; - } - case "concussion_grenade_mp": - case "emp_grenade_mp": - case "flash_grenade_mp": - case "nightingale_mp": - case "pda_hack_mp": - case "proximity_grenade_mp": - case "sensor_grenade_mp": - case "tabun_gas_mp": - case "trophy_system_mp": - case "willy_pete_mp": - if ( isDefined( player.grenadetypesecondarycount ) && player.grenadetypesecondarycount < 1 ) + else { + maxammo = weaponmaxammo( weapon ); + stock = player getweaponammostock( weapon ); + if ( isDefined( level.customloadoutscavenge ) ) + { + maxammo = self [[ level.customloadoutscavenge ]]( weapon ); + } + else if ( weapon == loadout_primary ) + { + maxammo = loadout_primary_count; + } + else + { + if ( weapon == loadout_secondary ) + { + maxammo = loadout_secondary_count; + } + } + if ( stock < maxammo ) + { + ammo = stock + 1; + if ( ammo > maxammo ) + { + ammo = maxammo; + } + player setweaponammostock( weapon, ammo ); + player.scavenged = 1; + player thread maps/mp/_challenges::scavengedgrenade(); + } break; i++; continue; } - else - { - if ( weapon == loadout_secondary && player getweaponammostock( weapon ) != loadout_secondary_count ) - { - if ( player.scavenger_tactical_proc < scavenger_tactical_proc ) - { - player.scavenger_tactical_proc++; - break; - i++; - continue; - } - else player.scavenger_tactical_proc = 0; - player.scavenger_lethal_proc = 0; - } - maxammo = weaponmaxammo( weapon ); - stock = player getweaponammostock( weapon ); - if ( isDefined( level.customloadoutscavenge ) ) - { - maxammo = self [[ level.customloadoutscavenge ]]( weapon ); - } - else if ( weapon == loadout_primary ) - { - maxammo = loadout_primary_count; - } - else - { - if ( weapon == loadout_secondary ) - { - maxammo = loadout_secondary_count; - } - } - if ( stock < maxammo ) - { - ammo = stock + 1; - if ( ammo > maxammo ) - { - ammo = maxammo; - } - player setweaponammostock( weapon, ammo ); - player thread maps/mp/_challenges::scavengedgrenade(); - } - break; - i++; - continue; - default: - if ( islauncherweapon( weapon ) ) - { - stock = player getweaponammostock( weapon ); - start = player getfractionstartammo( weapon ); - clip = weaponclipsize( weapon ); - clip *= getdvarfloatdefault( "scavenger_clip_multiplier", 2 ); - clip = int( clip ); - maxammo = weaponmaxammo( weapon ); - if ( stock < ( maxammo - clip ) ) - { - ammo = stock + clip; - player setweaponammostock( weapon, ammo ); - break; - } - else - { - player setweaponammostock( weapon, maxammo ); - } - } - break; - i++; - continue; -} -} + } } i++; } @@ -1894,30 +1981,31 @@ i = 0; while ( i < primary_weapons.size ) { weapon = primary_weapons[ i ]; -if ( ishackweapon( weapon ) || weapon == "kniferang_mp" ) +if ( ishackweapon( weapon ) ) { -i++; -continue; + i++; + continue; } -else -{ -stock = player getweaponammostock( weapon ); +else stock = player getweaponammostock( weapon ); start = player getfractionstartammo( weapon ); clip = weaponclipsize( weapon ); -clip *= getdvarfloatdefault( "scavenger_clip_multiplier", 2 ); +clip *= getdvarfloatdefault( "scavenger_clip_multiplier", 1 ); clip = int( clip ); maxammo = weaponmaxammo( weapon ); if ( stock < ( maxammo - clip ) ) { -ammo = stock + clip; -player setweaponammostock( weapon, ammo ); -i++; -continue; + ammo = stock + clip; + player setweaponammostock( weapon, ammo ); + player.scavenged = 1; + exit_early = 1; + i++; + continue; } else { -player setweaponammostock( weapon, maxammo ); -} + player setweaponammostock( weapon, maxammo ); + player.scavenged = 1; + exit_early = 1; } i++; } @@ -1932,17 +2020,16 @@ scavenger_hud_create() self.scavenger_icon = newclienthudelem( self ); self.scavenger_icon.horzalign = "center"; self.scavenger_icon.vertalign = "middle"; - self.scavenger_icon.x = -16; - self.scavenger_icon.y = 16; self.scavenger_icon.alpha = 0; - width = 32; - height = 16; - if ( self issplitscreen() ) + width = 48; + height = 24; + if ( level.splitscreen ) { width = int( width * 0,5 ); height = int( height * 0,5 ); - self.scavenger_icon.x = -8; } + self.scavenger_icon.x = ( width * -1 ) / 2; + self.scavenger_icon.y = 16; self.scavenger_icon setshader( "hud_scavenger_pickup", width, height ); } @@ -1968,10 +2055,14 @@ dropscavengerfordeath( attacker ) { item = self dropscavengeritem( "scavenger_item_hack_mp" ); } - else + else if ( isplayer( attacker ) && attacker hasperk( "specialty_scavenger" ) ) { item = self dropscavengeritem( "scavenger_item_mp" ); } + else + { + return; + } item thread scavenger_think(); } diff --git a/patch_mp/readme.md b/patch_mp/readme.md index 2277a73..cf2f0c8 100644 --- a/patch_mp/readme.md +++ b/patch_mp/readme.md @@ -19,6 +19,7 @@ patch_mp/maps/mp/gametypes/_shellshock.gsc ``` ### The following scripts have been checked, but they have not been tested yet ``` +patch_mp/maps/mp/gametypes/_weapon_utils.gsc ``` ### The following scripts are not checked yet, uploaded to setup a baseline: ``` @@ -42,7 +43,6 @@ patch_mp/maps/mp/gametypes/_globallogic_spawn.gsc patch_mp/maps/mp/gametypes/_globallogic_ui.gsc patch_mp/maps/mp/gametypes/_globallogic_utils.gsc patch_mp/maps/mp/gametypes/_globallogic_vehicle.gsc -patch_mp/maps/mp/gametypes/_gv_actions.gsc patch_mp/maps/mp/gametypes/_healthoverlay.gsc patch_mp/maps/mp/gametypes/_hostmigration.gsc patch_mp/maps/mp/gametypes/_hud.gsc @@ -61,7 +61,6 @@ patch_mp/maps/mp/gametypes/_spawnlogic.gsc patch_mp/maps/mp/gametypes/_spectating.gsc patch_mp/maps/mp/gametypes/_tweakables.gsc patch_mp/maps/mp/gametypes/_wager.gsc -patch_mp/maps/mp/gametypes/_weapon_utils.gsc patch_mp/maps/mp/gametypes/_weaponobjects.gsc patch_mp/maps/mp/gametypes/_weapons.gsc patch_mp/maps/mp/gametypes/conf.gsc diff --git a/patch_zm/maps/mp/gametypes_zm/_weapon_utils.gsc b/patch_zm/maps/mp/gametypes_zm/_weapon_utils.gsc index 7359766..3d9b204 100644 --- a/patch_zm/maps/mp/gametypes_zm/_weapon_utils.gsc +++ b/patch_zm/maps/mp/gametypes_zm/_weapon_utils.gsc @@ -1,7 +1,8 @@ +#include maps/mp/killstreaks/_killstreaks; #include maps/mp/_utility; #include common_scripts/utility; -isgrenadelauncherweapon( weapon ) +isgrenadelauncherweapon( weapon ) //checked matches cerberus output { if ( getsubstr( weapon, 0, 3 ) == "gl_" ) { @@ -17,7 +18,7 @@ isgrenadelauncherweapon( weapon ) } } -isdumbrocketlauncherweapon( weapon ) +isdumbrocketlauncherweapon( weapon ) //checked matches cerberus output { switch( weapon ) { @@ -29,7 +30,7 @@ isdumbrocketlauncherweapon( weapon ) } } -isguidedrocketlauncherweapon( weapon ) +isguidedrocketlauncherweapon( weapon ) //checked matches cerberus output { switch( weapon ) { @@ -44,7 +45,7 @@ isguidedrocketlauncherweapon( weapon ) } } -isrocketlauncherweapon( weapon ) +isrocketlauncherweapon( weapon ) //checked matches cerberus output { if ( isdumbrocketlauncherweapon( weapon ) ) { @@ -57,7 +58,7 @@ isrocketlauncherweapon( weapon ) return 0; } -islauncherweapon( weapon ) +islauncherweapon( weapon ) //checked matches cerberus output { if ( isrocketlauncherweapon( weapon ) ) { @@ -81,17 +82,21 @@ isreducedteamkillweapon( weapon ) } } -ishackweapon( weapon ) +ishackweapon( weapon ) //checked matches cerberus output { return 0; } -ispistol( weapon ) +ispistol( weapon ) //checked changed at own discretion { - return isDefined( level.side_arm_array[ weapon ] ); + if ( isDefined( level.side_arm_array[ weapon ] ) ) + { + return 1; + } + return 0; } -isflashorstunweapon( weapon ) +isflashorstunweapon( weapon ) //checked matches cerberus output { if ( isDefined( weapon ) ) { @@ -107,13 +112,13 @@ isflashorstunweapon( weapon ) return 0; } -isflashorstundamage( weapon, meansofdeath ) +isflashorstundamage( weapon, meansofdeath ) //checked changed at own discretion { - if ( isflashorstunweapon( weapon ) ) + if ( ( meansofdeath == "MOD_GAS" || meansofdeath == "MOD_GRENADE_SPLASH" ) && isflashorstunweapon( weapon ) ) { - if ( meansofdeath != "MOD_GRENADE_SPLASH" ) - { - return meansofdeath == "MOD_GAS"; - } + return 1; } + return 0; } + + diff --git a/patch_zm/readme.md b/patch_zm/readme.md index 15a698c..f678781 100644 --- a/patch_zm/readme.md +++ b/patch_zm/readme.md @@ -48,6 +48,7 @@ patch_zm/maps/mp/zombies/_zm_pers_upgrades_functions.gsc ``` ### The following scripts have been checked, but they have not been tested yet ``` +patch_zm/maps/mp/gametypes_zm/_weapon_utils.gsc patch_zm/maps/mp/zombies/_zm_blockers.gsc patch_zm/maps/mp/zombies/_zm_buildables.gsc patch_zm/maps/mp/zombies/_zm_equip_turbine.gsc @@ -92,7 +93,6 @@ patch_zm/maps/mp/gametypes_zm/_spawning.gsc patch_zm/maps/mp/gametypes_zm/_spawnlogic.gsc patch_zm/maps/mp/gametypes_zm/_spectating.gsc patch_zm/maps/mp/gametypes_zm/_tweakables.gsc -patch_zm/maps/mp/gametypes_zm/_weapon_utils.gsc patch_zm/maps/mp/gametypes_zm/_weaponobjects.gsc patch_zm/maps/mp/gametypes_zm/_weapons.gsc ```