Update scripts to better decompiled scripts.

ZM/Core/maps/mp/_art.gsc

@@ -0,0 +1,473 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+
+main()
+{
+/#
+    if ( getdvar( "scr_art_tweak" ) == "" || getdvar( "scr_art_tweak" ) == "0" )
+        setdvar( "scr_art_tweak", 0 );
+
+    if ( getdvar( "scr_dof_enable" ) == "" )
+        setdvar( "scr_dof_enable", "1" );
+
+    if ( getdvar( "scr_cinematic_autofocus" ) == "" )
+        setdvar( "scr_cinematic_autofocus", "1" );
+
+    if ( getdvar( "scr_art_visionfile" ) == "" && isdefined( level.script ) )
+        setdvar( "scr_art_visionfile", level.script );
+
+    if ( getdvar( "debug_reflection" ) == "" )
+        setdvar( "debug_reflection", "0" );
+
+    if ( getdvar( "debug_reflection_matte" ) == "" )
+        setdvar( "debug_reflection_matte", "0" );
+
+    if ( getdvar( "debug_color_pallete" ) == "" )
+        setdvar( "debug_color_pallete", "0" );
+
+    precachemodel( "test_sphere_lambert" );
+    precachemodel( "test_macbeth_chart" );
+    precachemodel( "test_macbeth_chart_unlit" );
+    precachemodel( "test_sphere_silver" );
+    level thread debug_reflection();
+    level thread debug_reflection_matte();
+    level thread debug_color_pallete();
+#/
+    if ( !isdefined( level.dofdefault ) )
+    {
+        level.dofdefault["nearStart"] = 0;
+        level.dofdefault["nearEnd"] = 1;
+        level.dofdefault["farStart"] = 8000;
+        level.dofdefault["farEnd"] = 10000;
+        level.dofdefault["nearBlur"] = 6;
+        level.dofdefault["farBlur"] = 0;
+    }
+
+    level.curdof = ( level.dofdefault["farStart"] - level.dofdefault["nearEnd"] ) / 2;
+/#
+    thread tweakart();
+#/
+    if ( !isdefined( level.script ) )
+        level.script = tolower( getdvar( "mapname" ) );
+}
+
+artfxprintln( file, string )
+{
+/#
+    if ( file == -1 )
+        return;
+
+    fprintln( file, string );
+#/
+}
+
+strtok_loc( string, par1 )
+{
+    stringlist = [];
+    indexstring = "";
+
+    for ( i = 0; i < string.size; i++ )
+    {
+        if ( string[i] == " " )
+        {
+            stringlist[stringlist.size] = indexstring;
+            indexstring = "";
+            continue;
+        }
+
+        indexstring += string[i];
+    }
+
+    if ( indexstring.size )
+        stringlist[stringlist.size] = indexstring;
+
+    return stringlist;
+}
+
+setfogsliders()
+{
+    fogall = strtok_loc( getdvar( "g_fogColorReadOnly" ), " " );
+    red = fogall[0];
+    green = fogall[1];
+    blue = fogall[2];
+    halfplane = getdvar( "g_fogHalfDistReadOnly" );
+    nearplane = getdvar( "g_fogStartDistReadOnly" );
+
+    if ( !isdefined( red ) || !isdefined( green ) || !isdefined( blue ) || !isdefined( halfplane ) )
+    {
+        red = 1;
+        green = 1;
+        blue = 1;
+        halfplane = 10000001;
+        nearplane = 10000000;
+    }
+
+    setdvar( "scr_fog_exp_halfplane", halfplane );
+    setdvar( "scr_fog_nearplane", nearplane );
+    setdvar( "scr_fog_color", red + " " + green + " " + blue );
+}
+
+tweakart()
+{
+/#
+    if ( !isdefined( level.tweakfile ) )
+        level.tweakfile = 0;
+
+    if ( getdvar( "scr_fog_baseheight" ) == "" )
+    {
+        setdvar( "scr_fog_exp_halfplane", "500" );
+        setdvar( "scr_fog_exp_halfheight", "500" );
+        setdvar( "scr_fog_nearplane", "0" );
+        setdvar( "scr_fog_baseheight", "0" );
+    }
+
+    setdvar( "scr_fog_fraction", "1.0" );
+    setdvar( "scr_art_dump", "0" );
+    setdvar( "scr_art_sun_fog_dir_set", "0" );
+    setdvar( "scr_dof_nearStart", level.dofdefault["nearStart"] );
+    setdvar( "scr_dof_nearEnd", level.dofdefault["nearEnd"] );
+    setdvar( "scr_dof_farStart", level.dofdefault["farStart"] );
+    setdvar( "scr_dof_farEnd", level.dofdefault["farEnd"] );
+    setdvar( "scr_dof_nearBlur", level.dofdefault["nearBlur"] );
+    setdvar( "scr_dof_farBlur", level.dofdefault["farBlur"] );
+    file = undefined;
+    filename = undefined;
+    tweak_toggle = 1;
+
+    for (;;)
+    {
+        while ( getdvarint( "scr_art_tweak" ) == 0 )
+        {
+            tweak_toggle = 1;
+            wait 0.05;
+        }
+
+        if ( tweak_toggle )
+        {
+            tweak_toggle = 0;
+            fogsettings = getfogsettings();
+            setdvar( "scr_fog_nearplane", fogsettings[0] );
+            setdvar( "scr_fog_exp_halfplane", fogsettings[1] );
+            setdvar( "scr_fog_exp_halfheight", fogsettings[3] );
+            setdvar( "scr_fog_baseheight", fogsettings[2] );
+            setdvar( "scr_fog_color", fogsettings[4] + " " + fogsettings[5] + " " + fogsettings[6] );
+            setdvar( "scr_fog_color_scale", fogsettings[7] );
+            setdvar( "scr_sun_fog_color", fogsettings[8] + " " + fogsettings[9] + " " + fogsettings[10] );
+            level.fogsundir = [];
+            level.fogsundir[0] = fogsettings[11];
+            level.fogsundir[1] = fogsettings[12];
+            level.fogsundir[2] = fogsettings[13];
+            setdvar( "scr_sun_fog_start_angle", fogsettings[14] );
+            setdvar( "scr_sun_fog_end_angle", fogsettings[15] );
+            setdvar( "scr_fog_max_opacity", fogsettings[16] );
+        }
+
+        level.fogexphalfplane = getdvarfloat( "scr_fog_exp_halfplane" );
+        level.fogexphalfheight = getdvarfloat( "scr_fog_exp_halfheight" );
+        level.fognearplane = getdvarfloat( "scr_fog_nearplane" );
+        level.fogbaseheight = getdvarfloat( "scr_fog_baseheight" );
+        level.fogcolorred = getdvarcolorred( "scr_fog_color" );
+        level.fogcolorgreen = getdvarcolorgreen( "scr_fog_color" );
+        level.fogcolorblue = getdvarcolorblue( "scr_fog_color" );
+        level.fogcolorscale = getdvarfloat( "scr_fog_color_scale" );
+        level.sunfogcolorred = getdvarcolorred( "scr_sun_fog_color" );
+        level.sunfogcolorgreen = getdvarcolorgreen( "scr_sun_fog_color" );
+        level.sunfogcolorblue = getdvarcolorblue( "scr_sun_fog_color" );
+        level.sunstartangle = getdvarfloat( "scr_sun_fog_start_angle" );
+        level.sunendangle = getdvarfloat( "scr_sun_fog_end_angle" );
+        level.fogmaxopacity = getdvarfloat( "scr_fog_max_opacity" );
+
+        if ( getdvarint( "scr_art_sun_fog_dir_set" ) )
+        {
+            setdvar( "scr_art_sun_fog_dir_set", "0" );
+            println( "Setting sun fog direction to facing of player" );
+            players = get_players();
+            dir = vectornormalize( anglestoforward( players[0] getplayerangles() ) );
+            level.fogsundir = [];
+            level.fogsundir[0] = dir[0];
+            level.fogsundir[1] = dir[1];
+            level.fogsundir[2] = dir[2];
+        }
+
+        fovslidercheck();
+        dumpsettings();
+
+        if ( !getdvarint( _hash_DBBD8F3B ) )
+        {
+            if ( !isdefined( level.fogsundir ) )
+            {
+                level.fogsundir = [];
+                level.fogsundir[0] = 1;
+                level.fogsundir[1] = 0;
+                level.fogsundir[2] = 0;
+            }
+
+            setvolfog( level.fognearplane, level.fogexphalfplane, level.fogexphalfheight, level.fogbaseheight, level.fogcolorred, level.fogcolorgreen, level.fogcolorblue, level.fogcolorscale, level.sunfogcolorred, level.sunfogcolorgreen, level.sunfogcolorblue, level.fogsundir[0], level.fogsundir[1], level.fogsundir[2], level.sunstartangle, level.sunendangle, 0, level.fogmaxopacity );
+        }
+        else
+            setexpfog( 100000000, 100000001, 0, 0, 0, 0 );
+
+        wait 0.1;
+    }
+#/
+}
+
+fovslidercheck()
+{
+    if ( level.dofdefault["nearStart"] >= level.dofdefault["nearEnd"] )
+    {
+        level.dofdefault["nearStart"] = level.dofdefault["nearEnd"] - 1;
+        setdvar( "scr_dof_nearStart", level.dofdefault["nearStart"] );
+    }
+
+    if ( level.dofdefault["nearEnd"] <= level.dofdefault["nearStart"] )
+    {
+        level.dofdefault["nearEnd"] = level.dofdefault["nearStart"] + 1;
+        setdvar( "scr_dof_nearEnd", level.dofdefault["nearEnd"] );
+    }
+
+    if ( level.dofdefault["farStart"] >= level.dofdefault["farEnd"] )
+    {
+        level.dofdefault["farStart"] = level.dofdefault["farEnd"] - 1;
+        setdvar( "scr_dof_farStart", level.dofdefault["farStart"] );
+    }
+
+    if ( level.dofdefault["farEnd"] <= level.dofdefault["farStart"] )
+    {
+        level.dofdefault["farEnd"] = level.dofdefault["farStart"] + 1;
+        setdvar( "scr_dof_farEnd", level.dofdefault["farEnd"] );
+    }
+
+    if ( level.dofdefault["farBlur"] >= level.dofdefault["nearBlur"] )
+    {
+        level.dofdefault["farBlur"] = level.dofdefault["nearBlur"] - 0.1;
+        setdvar( "scr_dof_farBlur", level.dofdefault["farBlur"] );
+    }
+
+    if ( level.dofdefault["farStart"] <= level.dofdefault["nearEnd"] )
+    {
+        level.dofdefault["farStart"] = level.dofdefault["nearEnd"] + 1;
+        setdvar( "scr_dof_farStart", level.dofdefault["farStart"] );
+    }
+}
+
+dumpsettings()
+{
+/#
+    if ( getdvar( "scr_art_dump" ) != "0" )
+    {
+        println( "\\tstart_dist = " + level.fognearplane + ";" );
+        println( "\\thalf_dist = " + level.fogexphalfplane + ";" );
+        println( "\\thalf_height = " + level.fogexphalfheight + ";" );
+        println( "\\tbase_height = " + level.fogbaseheight + ";" );
+        println( "\\tfog_r = " + level.fogcolorred + ";" );
+        println( "\\tfog_g = " + level.fogcolorgreen + ";" );
+        println( "\\tfog_b = " + level.fogcolorblue + ";" );
+        println( "\\tfog_scale = " + level.fogcolorscale + ";" );
+        println( "\\tsun_col_r = " + level.sunfogcolorred + ";" );
+        println( "\\tsun_col_g = " + level.sunfogcolorgreen + ";" );
+        println( "\\tsun_col_b = " + level.sunfogcolorblue + ";" );
+        println( "\\tsun_dir_x = " + level.fogsundir[0] + ";" );
+        println( "\\tsun_dir_y = " + level.fogsundir[1] + ";" );
+        println( "\\tsun_dir_z = " + level.fogsundir[2] + ";" );
+        println( "\\tsun_start_ang = " + level.sunstartangle + ";" );
+        println( "\\tsun_stop_ang = " + level.sunendangle + ";" );
+        println( "\\ttime = 0;" );
+        println( "\\tmax_fog_opacity = " + level.fogmaxopacity + ";" );
+        println( "" );
+        println( "\\tsetVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale," );
+        println( "\\t\\tsun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang, " );
+        println( "\\t\\tsun_stop_ang, time, max_fog_opacity);" );
+        setdvar( "scr_art_dump", "0" );
+    }
+#/
+}
+
+debug_reflection()
+{
+/#
+    level.debug_reflection = 0;
+
+    while ( true )
+    {
+        wait 0.1;
+
+        if ( getdvar( "debug_reflection" ) == "2" && level.debug_reflection != 2 || getdvar( "debug_reflection" ) == "3" && level.debug_reflection != 3 )
+        {
+            remove_reflection_objects();
+
+            if ( getdvar( "debug_reflection" ) == "2" )
+            {
+                create_reflection_objects();
+                level.debug_reflection = 2;
+            }
+            else
+            {
+                create_reflection_objects();
+                create_reflection_object();
+                level.debug_reflection = 3;
+            }
+        }
+        else if ( getdvar( "debug_reflection" ) == "1" && level.debug_reflection != 1 )
+        {
+            setdvar( "debug_reflection_matte", "0" );
+            setdvar( "debug_color_pallete", "0" );
+            remove_reflection_objects();
+            create_reflection_object();
+            level.debug_reflection = 1;
+        }
+        else if ( getdvar( "debug_reflection" ) == "0" && level.debug_reflection != 0 )
+        {
+            remove_reflection_objects();
+            level.debug_reflection = 0;
+        }
+    }
+#/
+}
+
+remove_reflection_objects()
+{
+/#
+    if ( ( level.debug_reflection == 2 || level.debug_reflection == 3 ) && isdefined( level.debug_reflection_objects ) )
+    {
+        for ( i = 0; i < level.debug_reflection_objects.size; i++ )
+            level.debug_reflection_objects[i] delete();
+
+        level.debug_reflection_objects = undefined;
+    }
+
+    if ( level.debug_reflection == 1 || level.debug_reflection == 3 || level.debug_reflection_matte == 1 || level.debug_color_pallete == 1 || level.debug_color_pallete == 2 )
+    {
+        if ( isdefined( level.debug_reflectionobject ) )
+            level.debug_reflectionobject delete();
+    }
+#/
+}
+
+create_reflection_objects()
+{
+/#
+    reflection_locs = getreflectionlocs();
+
+    for ( i = 0; i < reflection_locs.size; i++ )
+    {
+        level.debug_reflection_objects[i] = spawn( "script_model", reflection_locs[i] );
+        level.debug_reflection_objects[i] setmodel( "test_sphere_silver" );
+    }
+#/
+}
+
+create_reflection_object( model = "test_sphere_silver" )
+{
+/#
+    if ( isdefined( level.debug_reflectionobject ) )
+        level.debug_reflectionobject delete();
+
+    players = get_players();
+    player = players[0];
+    level.debug_reflectionobject = spawn( "script_model", player geteye() + vectorscale( anglestoforward( player.angles ), 100 ) );
+    level.debug_reflectionobject setmodel( model );
+    level.debug_reflectionobject.origin = player geteye() + vectorscale( anglestoforward( player getplayerangles() ), 100 );
+    level.debug_reflectionobject linkto( player );
+    thread debug_reflection_buttons();
+#/
+}
+
+debug_reflection_buttons()
+{
+/#
+    level notify( "new_reflection_button_running" );
+    level endon( "new_reflection_button_running" );
+    level.debug_reflectionobject endon( "death" );
+    offset = 100;
+    lastoffset = offset;
+
+    while ( getdvar( "debug_reflection" ) == "1" || getdvar( "debug_reflection" ) == "3" || getdvar( "debug_reflection_matte" ) == "1" || getdvar( "debug_color_pallete" ) == "1" || getdvar( "debug_color_pallete" ) == "2" )
+    {
+        players = get_players();
+
+        if ( players[0] buttonpressed( "BUTTON_X" ) )
+            offset += 50;
+
+        if ( players[0] buttonpressed( "BUTTON_Y" ) )
+            offset -= 50;
+
+        if ( offset > 1000 )
+            offset = 1000;
+
+        if ( offset < 64 )
+            offset = 64;
+
+        level.debug_reflectionobject unlink();
+        level.debug_reflectionobject.origin = players[0] geteye() + vectorscale( anglestoforward( players[0] getplayerangles() ), offset );
+        temp_angles = vectortoangles( players[0].origin - level.debug_reflectionobject.origin );
+        level.debug_reflectionobject.angles = ( 0, temp_angles[1], 0 );
+        lastoffset = offset;
+        line( level.debug_reflectionobject.origin, getreflectionorigin( level.debug_reflectionobject.origin ), ( 1, 0, 0 ), 1, 1 );
+        wait 0.05;
+
+        if ( isdefined( level.debug_reflectionobject ) )
+            level.debug_reflectionobject linkto( players[0] );
+    }
+#/
+}
+
+debug_reflection_matte()
+{
+/#
+    level.debug_reflection_matte = 0;
+
+    while ( true )
+    {
+        wait 0.1;
+
+        if ( getdvar( "debug_reflection_matte" ) == "1" && level.debug_reflection_matte != 1 )
+        {
+            setdvar( "debug_reflection", "0" );
+            setdvar( "debug_color_pallete", "0" );
+            remove_reflection_objects();
+            create_reflection_object( "test_sphere_lambert" );
+            level.debug_reflection_matte = 1;
+        }
+        else if ( getdvar( "debug_reflection_matte" ) == "0" && level.debug_reflection_matte != 0 )
+        {
+            remove_reflection_objects();
+            level.debug_reflection_matte = 0;
+        }
+    }
+#/
+}
+
+debug_color_pallete()
+{
+/#
+    level.debug_color_pallete = 0;
+
+    while ( true )
+    {
+        wait 0.1;
+
+        if ( getdvar( "debug_color_pallete" ) == "1" && level.debug_color_pallete != 1 )
+        {
+            setdvar( "debug_reflection", "0" );
+            setdvar( "debug_reflection_matte", "0" );
+            remove_reflection_objects();
+            create_reflection_object( "test_macbeth_chart" );
+            level.debug_color_pallete = 1;
+        }
+        else if ( getdvar( "debug_color_pallete" ) == "2" && level.debug_color_pallete != 2 )
+        {
+            remove_reflection_objects();
+            create_reflection_object( "test_macbeth_chart_unlit" );
+            level.debug_color_pallete = 2;
+        }
+        else if ( getdvar( "debug_color_pallete" ) == "0" && level.debug_color_pallete != 0 )
+        {
+            remove_reflection_objects();
+            level.debug_color_pallete = 0;
+        }
+    }
+#/
+}

ZM/Core/maps/mp/_audio.gsc

@@ -0,0 +1,139 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include common_scripts\utility;
+
+init()
+{
+
+}
+
+wait_until_first_player()
+{
+    players = get_players();
+
+    if ( !isdefined( players[0] ) )
+        level waittill( "first_player_ready" );
+
+    players = get_players();
+
+    for ( i = 0; i < players.size; i++ )
+        players[i] thread monitor_player_sprint();
+}
+
+stand_think( trig )
+{
+    killtext = "kill_stand_think" + trig getentitynumber();
+    self endon( "disconnect" );
+    self endon( "death" );
+    self endon( killtext );
+
+    while ( true )
+    {
+        if ( self.player_is_moving )
+            trig playsound( trig.script_label );
+
+        wait 1;
+    }
+}
+
+monitor_player_sprint()
+{
+    self endon( "disconnect" );
+    self thread monitor_player_movement();
+
+    for ( self._is_sprinting = 0; 1; self._is_sprinting = 0 )
+    {
+        self waittill( "sprint_begin" );
+
+        self._is_sprinting = 1;
+
+        self waittill( "sprint_end" );
+    }
+}
+
+monitor_player_movement()
+{
+    self endon( "disconnect" );
+
+    while ( true )
+    {
+        org_1 = self.origin;
+        wait 1.0;
+        org_2 = self.origin;
+        distancemoved = distancesquared( org_1, org_2 );
+
+        if ( distancemoved > 4096 )
+            self.player_is_moving = 1;
+        else
+            self.player_is_moving = 0;
+    }
+}
+
+thread_enter_exit_sound( trig )
+{
+    self endon( "death" );
+    self endon( "disconnect" );
+    trig.touchingplayers[self getentitynumber()] = 1;
+
+    if ( isdefined( trig.script_sound ) && trig.script_activated && self._is_sprinting )
+        self playsound( trig.script_sound );
+
+    self thread stand_think( trig );
+
+    while ( self istouching( trig ) )
+        wait 0.1;
+
+    self notify( "kill_stand_think" + trig getentitynumber() );
+    self playsound( trig.script_noteworthy );
+    trig.touchingplayers[self getentitynumber()] = 0;
+}
+
+thread_step_trigger()
+{
+    if ( !isdefined( self.script_activated ) )
+        self.script_activated = 1;
+
+    if ( !isdefined( self.touchingplayers ) )
+    {
+        self.touchingplayers = [];
+
+        for ( i = 0; i < 4; i++ )
+            self.touchingplayers[i] = 0;
+    }
+
+    while ( true )
+    {
+        self waittill( "trigger", who );
+
+        if ( self.touchingplayers[who getentitynumber()] == 0 )
+            who thread thread_enter_exit_sound( self );
+    }
+}
+
+disable_bump_trigger( triggername )
+{
+    triggers = getentarray( "audio_bump_trigger", "targetname" );
+
+    if ( isdefined( triggers ) )
+    {
+        for ( i = 0; i < triggers.size; i++ )
+        {
+            if ( isdefined( triggers[i].script_label ) && triggers[i].script_label == triggername )
+                triggers[i].script_activated = 0;
+        }
+    }
+}
+
+get_player_index_number( player )
+{
+    players = get_players();
+
+    for ( i = 0; i < players.size; i++ )
+    {
+        if ( players[i] == player )
+            return i;
+    }
+
+    return 1;
+}

ZM/Core/maps/mp/_ballistic_knife.gsc

@@ -0,0 +1,262 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include common_scripts\utility;
+#include maps\mp\_challenges;
+
+init()
+{
+    precachemodel( "t6_wpn_ballistic_knife_projectile" );
+    precachemodel( "t6_wpn_ballistic_knife_blade_retrieve" );
+}
+
+onspawn( watcher, player )
+{
+    player endon( "death" );
+    player endon( "disconnect" );
+    level endon( "game_ended" );
+
+    self waittill( "stationary", endpos, normal, angles, attacker, prey, bone );
+
+    isfriendly = 0;
+
+    if ( isdefined( endpos ) )
+    {
+        retrievable_model = spawn( "script_model", endpos );
+        retrievable_model setmodel( "t6_wpn_ballistic_knife_projectile" );
+        retrievable_model setteam( player.team );
+        retrievable_model setowner( player );
+        retrievable_model.owner = player;
+        retrievable_model.angles = angles;
+        retrievable_model.name = watcher.weapon;
+        retrievable_model.targetname = "sticky_weapon";
+
+        if ( isdefined( prey ) )
+        {
+            if ( level.teambased && isplayer( prey ) && player.team == prey.team )
+                isfriendly = 1;
+            else if ( level.teambased && isai( prey ) && player.team == prey.aiteam )
+                isfriendly = 1;
+
+            if ( !isfriendly )
+            {
+                if ( isalive( prey ) )
+                    retrievable_model droptoground( retrievable_model.origin, 80 );
+                else
+                    retrievable_model linkto( prey, bone );
+            }
+            else if ( isfriendly )
+            {
+                retrievable_model physicslaunch( normal, ( randomint( 10 ), randomint( 10 ), randomint( 10 ) ) );
+                normal = ( 0, 0, 1 );
+            }
+        }
+
+        watcher.objectarray[watcher.objectarray.size] = retrievable_model;
+
+        if ( isfriendly )
+            retrievable_model waittill( "stationary" );
+
+        retrievable_model thread dropknivestoground();
+
+        if ( isfriendly )
+            player notify( "ballistic_knife_stationary", retrievable_model, normal );
+        else
+            player notify( "ballistic_knife_stationary", retrievable_model, normal, prey );
+
+        retrievable_model thread wait_to_show_glowing_model( prey );
+    }
+}
+
+wait_to_show_glowing_model( prey )
+{
+    level endon( "game_ended" );
+    self endon( "death" );
+    glowing_retrievable_model = spawn( "script_model", self.origin );
+    self.glowing_model = glowing_retrievable_model;
+    glowing_retrievable_model.angles = self.angles;
+    glowing_retrievable_model linkto( self );
+
+    if ( isdefined( prey ) && !isalive( prey ) )
+        wait 2;
+
+    glowing_retrievable_model setmodel( "t6_wpn_ballistic_knife_blade_retrieve" );
+}
+
+watch_shutdown()
+{
+    pickuptrigger = self.pickuptrigger;
+    glowing_model = self.glowing_model;
+
+    self waittill( "death" );
+
+    if ( isdefined( pickuptrigger ) )
+        pickuptrigger delete();
+
+    if ( isdefined( glowing_model ) )
+        glowing_model delete();
+}
+
+onspawnretrievetrigger( watcher, player )
+{
+    player endon( "death" );
+    player endon( "disconnect" );
+    level endon( "game_ended" );
+
+    player waittill( "ballistic_knife_stationary", retrievable_model, normal, prey );
+
+    if ( !isdefined( retrievable_model ) )
+        return;
+
+    vec_scale = 10;
+    trigger_pos = [];
+
+    if ( isdefined( prey ) && ( isplayer( prey ) || isai( prey ) ) )
+    {
+        trigger_pos[0] = prey.origin[0];
+        trigger_pos[1] = prey.origin[1];
+        trigger_pos[2] = prey.origin[2] + vec_scale;
+    }
+    else
+    {
+        trigger_pos[0] = retrievable_model.origin[0] + vec_scale * normal[0];
+        trigger_pos[1] = retrievable_model.origin[1] + vec_scale * normal[1];
+        trigger_pos[2] = retrievable_model.origin[2] + vec_scale * normal[2];
+    }
+
+    trigger_pos[2] -= 50.0;
+    pickup_trigger = spawn( "trigger_radius", ( trigger_pos[0], trigger_pos[1], trigger_pos[2] ), 0, 50, 100 );
+    pickup_trigger.owner = player;
+    retrievable_model.pickuptrigger = pickup_trigger;
+    pickup_trigger enablelinkto();
+
+    if ( isdefined( prey ) )
+        pickup_trigger linkto( prey );
+    else
+        pickup_trigger linkto( retrievable_model );
+
+    retrievable_model thread watch_use_trigger( pickup_trigger, retrievable_model, ::pick_up, watcher.pickupsoundplayer, watcher.pickupsound );
+    retrievable_model thread watch_shutdown();
+}
+
+watch_use_trigger( trigger, model, callback, playersoundonuse, npcsoundonuse )
+{
+    self endon( "death" );
+    self endon( "delete" );
+    level endon( "game_ended" );
+    max_ammo = weaponmaxammo( "knife_ballistic_mp" ) + 1;
+
+    while ( true )
+    {
+        trigger waittill( "trigger", player );
+
+        if ( !isalive( player ) )
+            continue;
+
+        if ( !player isonground() )
+            continue;
+
+        if ( isdefined( trigger.triggerteam ) && player.team != trigger.triggerteam )
+            continue;
+
+        if ( isdefined( trigger.claimedby ) && player != trigger.claimedby )
+            continue;
+
+        if ( !player hasweapon( "knife_ballistic_mp" ) )
+            continue;
+
+        ammo_stock = player getweaponammostock( "knife_ballistic_mp" );
+        ammo_clip = player getweaponammoclip( "knife_ballistic_mp" );
+        current_weapon = player getcurrentweapon();
+        total_ammo = ammo_stock + ammo_clip;
+        hasreloaded = 1;
+
+        if ( total_ammo > 0 && ammo_stock == total_ammo && current_weapon == "knife_ballistic_mp" )
+            hasreloaded = 0;
+
+        if ( total_ammo >= max_ammo || !hasreloaded )
+            continue;
+
+        if ( isdefined( playersoundonuse ) )
+            player playlocalsound( playersoundonuse );
+
+        if ( isdefined( npcsoundonuse ) )
+            player playsound( npcsoundonuse );
+
+        self thread [[ callback ]]( player );
+        break;
+    }
+}
+
+pick_up( player )
+{
+    self destroy_ent();
+    current_weapon = player getcurrentweapon();
+    player maps\mp\_challenges::pickedupballisticknife();
+
+    if ( current_weapon != "knife_ballistic_mp" )
+    {
+        clip_ammo = player getweaponammoclip( "knife_ballistic_mp" );
+
+        if ( !clip_ammo )
+            player setweaponammoclip( "knife_ballistic_mp", 1 );
+        else
+        {
+            new_ammo_stock = player getweaponammostock( "knife_ballistic_mp" ) + 1;
+            player setweaponammostock( "knife_ballistic_mp", new_ammo_stock );
+        }
+    }
+    else
+    {
+        new_ammo_stock = player getweaponammostock( "knife_ballistic_mp" ) + 1;
+        player setweaponammostock( "knife_ballistic_mp", new_ammo_stock );
+    }
+}
+
+destroy_ent()
+{
+    if ( isdefined( self ) )
+    {
+        pickuptrigger = self.pickuptrigger;
+
+        if ( isdefined( pickuptrigger ) )
+            pickuptrigger delete();
+
+        if ( isdefined( self.glowing_model ) )
+            self.glowing_model delete();
+
+        self delete();
+    }
+}
+
+dropknivestoground()
+{
+    self endon( "death" );
+
+    for (;;)
+    {
+        level waittill( "drop_objects_to_ground", origin, radius );
+
+        self droptoground( origin, radius );
+    }
+}
+
+droptoground( origin, radius )
+{
+    if ( distancesquared( origin, self.origin ) < radius * radius )
+    {
+        self physicslaunch( ( 0, 0, 1 ), vectorscale( ( 1, 1, 1 ), 5.0 ) );
+        self thread updateretrievetrigger();
+    }
+}
+
+updateretrievetrigger()
+{
+    self endon( "death" );
+
+    self waittill( "stationary" );
+
+    trigger = self.pickuptrigger;
+    trigger.origin = ( self.origin[0], self.origin[1], self.origin[2] + 10 );
+    trigger linkto( self );
+}

ZM/Core/maps/mp/_bb.gsc

@@ -0,0 +1,89 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include common_scripts\utility;
+
+init()
+{
+    level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+    for (;;)
+    {
+        level waittill( "connected", player );
+
+        player thread onplayerspawned();
+        player thread onplayerdeath();
+    }
+}
+
+onplayerspawned()
+{
+    self endon( "disconnect" );
+    self._bbdata = [];
+
+    for (;;)
+    {
+        self waittill( "spawned_player" );
+
+        self._bbdata["score"] = 0;
+        self._bbdata["momentum"] = 0;
+        self._bbdata["spawntime"] = gettime();
+        self._bbdata["shots"] = 0;
+        self._bbdata["hits"] = 0;
+    }
+}
+
+onplayerdisconnect()
+{
+    for (;;)
+    {
+        self waittill( "disconnect" );
+
+        self commitspawndata();
+        break;
+    }
+}
+
+onplayerdeath()
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "death" );
+
+        self commitspawndata();
+    }
+}
+
+commitspawndata()
+{
+    assert( isdefined( self._bbdata ) );
+
+    if ( !isdefined( self._bbdata ) )
+        return;
+
+    bbprint( "mpplayerlives", "gametime %d spawnid %d lifescore %d lifemomentum %d lifetime %d name %s", gettime(), getplayerspawnid( self ), self._bbdata["score"], self._bbdata["momentum"], gettime() - self._bbdata["spawntime"], self.name );
+}
+
+commitweapondata( spawnid, currentweapon, time0 )
+{
+    assert( isdefined( self._bbdata ) );
+
+    if ( !isdefined( self._bbdata ) )
+        return;
+
+    time1 = gettime();
+    bbprint( "mpweapons", "spawnid %d name %s duration %d shots %d hits %d", spawnid, currentweapon, time1 - time0, self._bbdata["shots"], self._bbdata["hits"] );
+    self._bbdata["shots"] = 0;
+    self._bbdata["hits"] = 0;
+}
+
+bbaddtostat( statname, delta )
+{
+    if ( isdefined( self._bbdata ) && isdefined( self._bbdata[statname] ) )
+        self._bbdata[statname] += delta;
+}

ZM/Core/maps/mp/_busing.gsc

@@ -0,0 +1,18 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+
+businit()
+{
+    assert( level.clientscripts );
+    level.busstate = "";
+    registerclientsys( "busCmd" );
+}
+
+setbusstate( state )
+{
+    if ( level.busstate != state )
+        setclientsysstate( "busCmd", state );
+
+    level.busstate = state;
+}

ZM/Core/maps/mp/_compass.gsc

@@ -0,0 +1,76 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+
+setupminimap( material )
+{
+    requiredmapaspectratio = getdvarfloat( "scr_RequiredMapAspectratio" );
+    corners = getentarray( "minimap_corner", "targetname" );
+
+    if ( corners.size != 2 )
+    {
+/#
+        println( "^1Error: There are not exactly two \"minimap_corner\" entities in the map. Could not set up minimap." );
+#/
+        return;
+    }
+
+    corner0 = ( corners[0].origin[0], corners[0].origin[1], 0 );
+    corner1 = ( corners[1].origin[0], corners[1].origin[1], 0 );
+    cornerdiff = corner1 - corner0;
+    north = ( cos( getnorthyaw() ), sin( getnorthyaw() ), 0 );
+    west = ( 0 - north[1], north[0], 0 );
+
+    if ( vectordot( cornerdiff, west ) > 0 )
+    {
+        if ( vectordot( cornerdiff, north ) > 0 )
+        {
+            northwest = corner1;
+            southeast = corner0;
+        }
+        else
+        {
+            side = vecscale( north, vectordot( cornerdiff, north ) );
+            northwest = corner1 - side;
+            southeast = corner0 + side;
+        }
+    }
+    else if ( vectordot( cornerdiff, north ) > 0 )
+    {
+        side = vecscale( north, vectordot( cornerdiff, north ) );
+        northwest = corner0 + side;
+        southeast = corner1 - side;
+    }
+    else
+    {
+        northwest = corner0;
+        southeast = corner1;
+    }
+
+    if ( requiredmapaspectratio > 0 )
+    {
+        northportion = vectordot( northwest - southeast, north );
+        westportion = vectordot( northwest - southeast, west );
+        mapaspectratio = westportion / northportion;
+
+        if ( mapaspectratio < requiredmapaspectratio )
+        {
+            incr = requiredmapaspectratio / mapaspectratio;
+            addvec = vecscale( west, westportion * ( incr - 1 ) * 0.5 );
+        }
+        else
+        {
+            incr = mapaspectratio / requiredmapaspectratio;
+            addvec = vecscale( north, northportion * ( incr - 1 ) * 0.5 );
+        }
+
+        northwest += addvec;
+        southeast -= addvec;
+    }
+
+    setminimap( material, northwest[0], northwest[1], southeast[0], southeast[1] );
+}
+
+vecscale( vec, scalar )
+{
+    return ( vec[0] * scalar, vec[1] * scalar, vec[2] * scalar );
+}

ZM/Core/maps/mp/_createfxmenu.gsc

@@ -0,0 +1,941 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\_createfx;
+#include maps\mp\_createfxundo;
+
+menu( name )
+{
+/#
+    return level.create_fx_menu == name;
+#/
+}
+
+setmenu( name )
+{
+/#
+    level.create_fx_menu = name;
+#/
+}
+
+create_fx_menu()
+{
+/#
+    if ( button_is_clicked( "escape", "x" ) )
+    {
+        exit_menu();
+        return;
+    }
+
+    if ( menu( "creation" ) )
+    {
+        if ( button_is_clicked( "1" ) )
+        {
+            setmenu( "create_oneshot" );
+            draw_effects_list();
+            return;
+        }
+
+        if ( button_is_clicked( "2" ) )
+        {
+            setmenu( "create_loopfx" );
+            draw_effects_list();
+            return;
+        }
+
+        if ( button_is_clicked( "3" ) )
+        {
+            setmenu( "create_exploder" );
+            draw_effects_list();
+            return;
+        }
+
+        if ( button_is_clicked( "4" ) )
+        {
+            setmenu( "create_loopsound" );
+            ent = createloopsound();
+            finish_creating_entity( ent );
+            setmenu( "none" );
+            return;
+        }
+    }
+
+    if ( menu( "create_oneshot" ) || menu( "create_loopfx" ) || menu( "create_exploder" ) || menu( "change_fxid" ) )
+    {
+        if ( button_is_clicked( "rightarrow" ) )
+        {
+            increment_list_offset();
+            draw_effects_list();
+        }
+
+        if ( button_is_clicked( "leftarrow" ) )
+        {
+            decrement_list_offset();
+            draw_effects_list();
+        }
+
+        menu_fx_creation();
+    }
+    else if ( menu( "none" ) )
+    {
+        menu_change_selected_fx();
+
+        if ( entities_are_selected() )
+        {
+            display_fx_info( get_last_selected_entity() );
+
+            if ( button_is_clicked( "a" ) )
+            {
+                clear_settable_fx();
+                setmenu( "add_options" );
+            }
+        }
+    }
+    else if ( menu( "add_options" ) )
+    {
+        if ( !entities_are_selected() )
+        {
+            clear_fx_hudelements();
+            setmenu( "none" );
+            return;
+        }
+
+        display_fx_add_options( get_last_selected_entity() );
+
+        if ( button_is_clicked( "rightarrow" ) )
+            increment_list_offset();
+
+        if ( button_is_clicked( "leftarrow" ) )
+            decrement_list_offset();
+    }
+    else if ( menu( "jump_to_effect" ) )
+    {
+        if ( button_is_clicked( "rightarrow" ) )
+        {
+            increment_list_offset();
+            draw_effects_list( "Select effect to jump to:" );
+        }
+
+        if ( button_is_clicked( "leftarrow" ) )
+        {
+            decrement_list_offset();
+            draw_effects_list( "Select effect to jump to:" );
+        }
+
+        jump_to_effect();
+    }
+    else if ( menu( "select_by_property" ) )
+    {
+        menu_selection();
+
+        if ( button_is_clicked( "rightarrow" ) )
+            increment_list_offset();
+
+        if ( button_is_clicked( "leftarrow" ) )
+            decrement_list_offset();
+    }
+    else if ( menu( "change_type" ) )
+    {
+        if ( !entities_are_selected() )
+        {
+            clear_fx_hudelements();
+            setmenu( "none" );
+            return;
+        }
+        else
+            menu_fx_type();
+    }
+#/
+}
+
+exit_menu()
+{
+/#
+    clear_fx_hudelements();
+    clear_entity_selection();
+    update_selected_entities();
+    setmenu( "none" );
+#/
+}
+
+get_last_selected_entity()
+{
+/#
+    return level.selected_fx_ents[level.selected_fx_ents.size - 1];
+#/
+}
+
+menu_fx_creation()
+{
+/#
+    count = 0;
+    picked_fx = undefined;
+    keys = get_level_ambient_fx();
+
+    for ( i = level.effect_list_offset; i < keys.size; i++ )
+    {
+        count += 1;
+        button_to_check = count;
+
+        if ( button_to_check == 10 )
+            button_to_check = 0;
+
+        if ( button_is_clicked( button_to_check + "" ) && !button_is_held( "f" ) )
+        {
+            picked_fx = keys[i];
+            break;
+        }
+
+        if ( count > level.effect_list_offset_max )
+            break;
+    }
+
+    if ( !isdefined( picked_fx ) )
+        return;
+
+    if ( menu( "change_fxid" ) )
+    {
+        apply_option_to_selected_fx( get_option( "fxid" ), picked_fx );
+        level.effect_list_offset = 0;
+        clear_fx_hudelements();
+        setmenu( "none" );
+        return;
+    }
+
+    ent = undefined;
+
+    if ( menu( "create_loopfx" ) )
+        ent = createloopeffect( picked_fx );
+
+    if ( menu( "create_oneshot" ) )
+    {
+        ent = createoneshoteffect( picked_fx );
+        delay_min = getdvarint( "createfx_oneshot_min_delay" );
+        delay_max = getdvarint( "createfx_oneshot_max_delay" );
+
+        if ( delay_min > delay_max )
+        {
+            temp = delay_min;
+            delay_min = delay_max;
+            delay_max = temp;
+        }
+
+        ent.v["delay"] = randomintrange( delay_min, delay_max );
+    }
+
+    if ( menu( "create_exploder" ) )
+        ent = createexploder( picked_fx );
+
+    finish_creating_entity( ent );
+
+    if ( level.cfx_last_action != "none" )
+        store_undo_state( "edit", level.selected_fx_ents );
+
+    store_undo_state( "add", level.createfxent[level.createfxent.size - 1] );
+    level.cfx_last_action = "none";
+    setmenu( "none" );
+#/
+}
+
+finish_creating_entity( ent )
+{
+/#
+    ent.v["angles"] = vectortoangles( ent.v["origin"] + vectorscale( ( 0, 0, 1 ), 100.0 ) - ent.v["origin"] );
+    assert( isdefined( ent ) );
+    ent post_entity_creation_function();
+    clear_entity_selection();
+    select_last_entity( "skip_undo" );
+    move_selection_to_cursor( "skip_undo" );
+    update_selected_entities();
+#/
+}
+
+change_effect_to_oneshot( ent )
+{
+/#
+    if ( ent.v["type"] == "oneshotfx" )
+        return;
+
+    if ( ent.v["type"] == "exploder" )
+    {
+        ent.v["exploder"] = undefined;
+        ent.v["exploder_type"] = undefined;
+        ent.v["soundalias"] = undefined;
+    }
+
+    if ( !isdefined( ent.v["delay"] ) || ent.v["delay"] == 0 )
+    {
+        delay_min = getdvarint( "createfx_oneshot_min_delay" );
+        delay_max = getdvarint( "createfx_oneshot_max_delay" );
+
+        if ( delay_min > delay_max )
+        {
+            temp = delay_min;
+            delay_min = delay_max;
+            delay_max = temp;
+        }
+
+        ent.v["delay"] = randomintrange( delay_min, delay_max );
+    }
+
+    ent.v["type"] = "oneshotfx";
+#/
+}
+
+change_effect_to_loop( ent )
+{
+/#
+    if ( ent.v["type"] == "loopfx" )
+        return;
+
+    if ( ent.v["type"] == "exploder" )
+    {
+        ent.v["exploder"] = undefined;
+        ent.v["exploder_type"] = undefined;
+        ent.v["soundalias"] = undefined;
+    }
+
+    if ( !isdefined( ent.v["delay"] ) || ent.v["delay"] <= 0 )
+        ent.v["delay"] = 1;
+
+    ent.v["type"] = "loopfx";
+#/
+}
+
+change_effect_to_exploder( ent )
+{
+/#
+    if ( ent.v["type"] == "exploder" )
+        return;
+
+    ent.v["type"] = "exploder";
+
+    if ( !isdefined( ent.v["delay"] ) || ent.v["delay"] < 0 )
+        ent.v["delay"] = 0;
+
+    ent.v["exploder"] = 1;
+    ent.v["exploder_type"] = "normal";
+#/
+}
+
+change_ent_type( newtype )
+{
+/#
+    store_undo_state( "edit", level.selected_fx_ents );
+    level.cfx_last_action = "ent_type";
+
+    if ( newtype == "oneshotfx" )
+    {
+        for ( i = 0; i < level.selected_fx_ents.size; i++ )
+            change_effect_to_oneshot( level.selected_fx_ents[i] );
+    }
+    else if ( newtype == "loopfx" )
+    {
+        for ( i = 0; i < level.selected_fx_ents.size; i++ )
+            change_effect_to_loop( level.selected_fx_ents[i] );
+    }
+    else if ( newtype == "exploder" )
+    {
+        for ( i = 0; i < level.selected_fx_ents.size; i++ )
+            change_effect_to_exploder( level.selected_fx_ents[i] );
+    }
+#/
+}
+
+menu_init()
+{
+/#
+    level.createfx_options = [];
+    addoption( "string", "type", "Type", "oneshotfx", "fx" );
+    addoption( "string", "fxid", "Name", "nil", "fx" );
+    addoption( "vector", "origin", "Origin", ( 0, 0, 0 ), "fx" );
+    addoption( "vector", "angles", "Angles", ( 0, 0, 0 ), "fx" );
+    addoption( "float", "delay", "Repeat rate/start delay", 0.5, "fx" );
+    addoption( "int", "repeat", "Number of times to repeat", 5, "exploder" );
+    addoption( "float", "primlightfrac", "Primary light fraction", 1.0, "fx" );
+    addoption( "int", "lightoriginoffs", "Light origin offset", 64, "fx" );
+    addoption( "float", "delay_min", "Minimum time between repeats", 1, "exploder" );
+    addoption( "float", "delay_max", "Maximum time between repeats", 2, "exploder" );
+    addoption( "float", "fire_range", "Fire damage range", 0, "fx" );
+    addoption( "string", "firefx", "2nd FX id", "nil", "exploder" );
+    addoption( "float", "firefxdelay", "2nd FX id repeat rate", 0.5, "exploder" );
+    addoption( "float", "firefxtimeout", "2nd FX timeout", 5, "exploder" );
+    addoption( "string", "firefxsound", "2nd FX soundalias", "nil", "exploder" );
+    addoption( "string", "ender", "Level notify for ending 2nd FX", "nil", "exploder" );
+    addoption( "string", "rumble", "Rumble", "nil", "exploder" );
+    addoption( "float", "damage", "Radius damage", 150, "exploder" );
+    addoption( "float", "damage_radius", "Radius of radius damage", 250, "exploder" );
+    addoption( "int", "exploder", "Exploder", 1, "exploder" );
+    addoption( "string", "earthquake", "Earthquake", "nil", "exploder" );
+    addoption( "string", "soundalias", "Soundalias", "nil", "all" );
+    addoption( "int", "stoppable", "Can be stopped from script", "1", "all" );
+    level.effect_list_offset = 0;
+    level.effect_list_offset_max = 9;
+    level.createfxmasks = [];
+    level.createfxmasks["all"] = [];
+    level.createfxmasks["all"]["exploder"] = 1;
+    level.createfxmasks["all"]["oneshotfx"] = 1;
+    level.createfxmasks["all"]["loopfx"] = 1;
+    level.createfxmasks["all"]["soundfx"] = 1;
+    level.createfxmasks["fx"] = [];
+    level.createfxmasks["fx"]["exploder"] = 1;
+    level.createfxmasks["fx"]["oneshotfx"] = 1;
+    level.createfxmasks["fx"]["loopfx"] = 1;
+    level.createfxmasks["exploder"] = [];
+    level.createfxmasks["exploder"]["exploder"] = 1;
+    level.createfxmasks["loopfx"] = [];
+    level.createfxmasks["loopfx"]["loopfx"] = 1;
+    level.createfxmasks["oneshotfx"] = [];
+    level.createfxmasks["oneshotfx"]["oneshotfx"] = 1;
+    level.createfxmasks["soundfx"] = [];
+    level.createfxmasks["soundfx"]["soundalias"] = 1;
+#/
+}
+
+get_last_selected_ent()
+{
+/#
+    return level.selected_fx_ents[level.selected_fx_ents.size - 1];
+#/
+}
+
+entities_are_selected()
+{
+/#
+    return level.selected_fx_ents.size > 0;
+#/
+}
+
+menu_change_selected_fx()
+{
+/#
+    if ( !level.selected_fx_ents.size )
+        return;
+
+    count = 0;
+    drawncount = 0;
+    ent = get_last_selected_ent();
+
+    for ( i = 0; i < level.createfx_options.size; i++ )
+    {
+        option = level.createfx_options[i];
+
+        if ( !isdefined( ent.v[option["name"]] ) )
+            continue;
+
+        count++;
+
+        if ( count < level.effect_list_offset )
+            continue;
+
+        drawncount++;
+        button_to_check = drawncount;
+
+        if ( button_to_check == 10 )
+            button_to_check = 0;
+
+        if ( button_is_clicked( button_to_check + "" ) && !button_is_held( "f" ) )
+        {
+            prepare_option_for_change( option, drawncount );
+            break;
+        }
+
+        if ( drawncount > level.effect_list_offset_max )
+            break;
+    }
+#/
+}
+
+prepare_option_for_change( option, drawncount )
+{
+/#
+    if ( option["name"] == "fxid" )
+    {
+        setmenu( "change_fxid" );
+        draw_effects_list();
+        return;
+    }
+
+    if ( option["name"] == "type" )
+    {
+        setmenu( "change_type" );
+        return;
+    }
+
+    level.createfx_inputlocked = 1;
+    set_option_index( option["name"] );
+    setdvar( "fx", "nil" );
+    level.createfxhudelements[drawncount + 1][0].color = ( 1, 1, 0 );
+#/
+}
+
+menu_fx_option_set()
+{
+/#
+    if ( getdvar( "fx" ) == "nil" )
+        return;
+
+    option = get_selected_option();
+    setting = undefined;
+
+    if ( option["type"] == "string" )
+        setting = getdvar( "fx" );
+
+    if ( option["type"] == "int" )
+        setting = getdvarint( "fx" );
+
+    if ( option["type"] == "float" )
+        setting = getdvarfloat( "fx" );
+
+    if ( option["type"] == "vector" )
+    {
+        setting = getdvar( "fx" );
+        temparray = strtok( setting, " " );
+
+        if ( temparray.size == 3 )
+            setting = ( float( temparray[0] ), float( temparray[1] ), float( temparray[2] ) );
+        else
+        {
+            clear_settable_fx();
+            return;
+        }
+    }
+
+    apply_option_to_selected_fx( option, setting );
+#/
+}
+
+menu_fx_type()
+{
+/#
+    clear_fx_hudelements();
+    set_fx_hudelement( "Change effect type to:" );
+    set_fx_hudelement( " (1) Oneshot" );
+    set_fx_hudelement( " (2) Looped" );
+    set_fx_hudelement( " (3) Exploder" );
+    set_fx_hudelement( "(x) Exit >" );
+
+    if ( button_is_clicked( "1" ) && !button_is_held( "f" ) )
+    {
+        change_ent_type( "oneshotfx" );
+        setmenu( "none" );
+    }
+    else if ( button_is_clicked( "2" ) && !button_is_held( "f" ) )
+    {
+        change_ent_type( "loopfx" );
+        setmenu( "none" );
+    }
+    else if ( button_is_clicked( "3" ) && !button_is_held( "f" ) )
+    {
+        change_ent_type( "exploder" );
+        setmenu( "none" );
+    }
+
+    if ( menu( "none" ) )
+        update_selected_entities();
+#/
+}
+
+menu_selection()
+{
+/#
+    clear_fx_hudelements();
+    set_fx_hudelement( "Select all by property:" );
+    drawncount = 0;
+    option_number = 0;
+    ent = level.selected_fx_ents[level.selected_fx_ents.size - 1];
+
+    if ( level.selected_fx_ents.size < 1 )
+        set_fx_hudelement( "No ent is selected." );
+    else
+    {
+        for ( i = level.effect_list_offset; i < level.createfx_options.size; i++ )
+        {
+            if ( drawncount > level.effect_list_offset_max )
+                break;
+
+            if ( drawncount > ent.v.size )
+                break;
+
+            prop_name = level.createfx_options[i]["name"];
+            option_number = drawncount + 1;
+
+            if ( isdefined( ent.v[prop_name] ) )
+            {
+                if ( button_is_clicked( option_number + "" ) && !button_is_held( "f" ) )
+                {
+                    level.cfx_selected_prop = prop_name;
+                    menunone();
+                    level.effect_list_offset = 0;
+                    return;
+                }
+
+                prop_desc = level.createfx_options[i]["description"];
+                set_fx_hudelement( option_number + ". " + prop_desc + ": " + ent.v[prop_name] );
+                drawncount++;
+                continue;
+            }
+        }
+    }
+
+    if ( drawncount > level.effect_list_offset_max )
+    {
+        pages = ceil( ent.v.size / level.effect_list_offset_max );
+        current_page = level.effect_list_offset / level.effect_list_offset_max + 1;
+        set_fx_hudelement( "(<-) Page " + current_page + " of " + pages + " (->)" );
+    }
+
+    set_fx_hudelement( "(x) Exit >" );
+#/
+}
+
+apply_option_to_selected_fx( option, setting )
+{
+/#
+    if ( level.cfx_last_action != option["name"] )
+    {
+        store_undo_state( "edit", level.selected_fx_ents );
+        level.cfx_last_action = option["name"];
+    }
+
+    for ( i = 0; i < level.selected_fx_ents.size; i++ )
+    {
+        ent = level.selected_fx_ents[i];
+
+        if ( mask( option["mask"], ent.v["type"] ) )
+            ent.v[option["name"]] = setting;
+    }
+
+    update_selected_entities();
+    clear_settable_fx();
+#/
+}
+
+set_option_index( name )
+{
+/#
+    for ( i = 0; i < level.createfx_options.size; i++ )
+    {
+        if ( level.createfx_options[i]["name"] != name )
+            continue;
+
+        level.selected_fx_option_index = i;
+        return;
+    }
+#/
+}
+
+get_selected_option()
+{
+/#
+    return level.createfx_options[level.selected_fx_option_index];
+#/
+}
+
+mask( type, name )
+{
+/#
+    return isdefined( level.createfxmasks[type][name] );
+#/
+}
+
+addoption( type, name, description, defaultsetting, mask )
+{
+/#
+    option = [];
+    option["type"] = type;
+    option["name"] = name;
+    option["description"] = description;
+    option["default"] = defaultsetting;
+    option["mask"] = mask;
+    level.createfx_options[level.createfx_options.size] = option;
+#/
+}
+
+get_option( name )
+{
+/#
+    for ( i = 0; i < level.createfx_options.size; i++ )
+    {
+        if ( level.createfx_options[i]["name"] == name )
+            return level.createfx_options[i];
+    }
+#/
+}
+
+display_fx_info( ent )
+{
+/#
+    if ( !menu( "none" ) )
+        return;
+
+    clear_fx_hudelements();
+
+    if ( !level.createfx_draw_enabled )
+        return;
+
+    set_fx_hudelement( "Selected: " + level.selected_fx_ents.size + "   Distance: " + get_distance_from_ent( ent ) );
+    level.createfxhudelements[0][0].color = ( 1, 1, 0 );
+    set_fx_hudelement( "Name: " + ent.v["fxid"] );
+
+    if ( entities_are_selected() )
+    {
+        count = 0;
+        drawncount = 0;
+
+        for ( i = 0; i < level.createfx_options.size; i++ )
+        {
+            option = level.createfx_options[i];
+
+            if ( !isdefined( ent.v[option["name"]] ) )
+                continue;
+
+            count++;
+
+            if ( count < level.effect_list_offset )
+                continue;
+
+            drawncount++;
+            set_fx_hudelement( drawncount + ". " + option["description"] + ": " + ent.v[option["name"]] );
+
+            if ( drawncount > level.effect_list_offset_max )
+            {
+                more = 1;
+                break;
+            }
+        }
+
+        if ( count > level.effect_list_offset_max )
+        {
+            pages = ceil( level.createfx_options.size / level.effect_list_offset_max );
+            current_page = level.effect_list_offset / level.effect_list_offset_max + 1;
+            set_fx_hudelement( "(<-) Page " + current_page + " of " + pages + " (->)" );
+        }
+
+        set_fx_hudelement( "(a) Add >" );
+        set_fx_hudelement( "(x) Exit >" );
+    }
+    else
+    {
+        set_fx_hudelement( "Origin: " + ent.v["origin"] );
+        set_fx_hudelement( "Angles: " + ent.v["angles"] );
+    }
+#/
+}
+
+display_fx_add_options( ent )
+{
+/#
+    assert( menu( "add_options" ) );
+    assert( entities_are_selected() );
+    clear_fx_hudelements();
+    set_fx_hudelement( "Selected: " + level.selected_fx_ents.size + "   Distance: " + get_distance_from_ent( ent ) );
+    level.createfxhudelements[0][0].color = ( 1, 1, 0 );
+    set_fx_hudelement( "Name: " + ent.v["fxid"] );
+    set_fx_hudelement( "Origin: " + ent.v["origin"] );
+    set_fx_hudelement( "Angles: " + ent.v["angles"] );
+    count = 0;
+    drawncount = 0;
+
+    if ( level.effect_list_offset >= level.createfx_options.size )
+        level.effect_list_offset = 0;
+
+    for ( i = 0; i < level.createfx_options.size; i++ )
+    {
+        option = level.createfx_options[i];
+
+        if ( isdefined( ent.v[option["name"]] ) )
+            continue;
+
+        if ( !mask( option["mask"], ent.v["type"] ) )
+            continue;
+
+        count++;
+
+        if ( count < level.effect_list_offset )
+            continue;
+
+        if ( drawncount >= level.effect_list_offset_max )
+            continue;
+
+        drawncount++;
+        button_to_check = drawncount;
+
+        if ( button_to_check == 10 )
+            button_to_check = 0;
+
+        if ( button_is_clicked( button_to_check + "" ) && !button_is_held( "f" ) )
+        {
+            add_option_to_selected_entities( option );
+            menunone();
+            return;
+        }
+
+        set_fx_hudelement( button_to_check + ". " + option["description"] );
+    }
+
+    if ( count > level.effect_list_offset_max )
+    {
+        pages = ceil( level.createfx_options.size / level.effect_list_offset_max );
+        current_page = level.effect_list_offset / level.effect_list_offset_max + 1;
+        set_fx_hudelement( "(<-) Page " + current_page + " of " + pages + " (->)" );
+    }
+
+    set_fx_hudelement( "(x) Exit >" );
+#/
+}
+
+add_option_to_selected_entities( option )
+{
+/#
+    for ( i = 0; i < level.selected_fx_ents.size; i++ )
+    {
+        ent = level.selected_fx_ents[i];
+
+        if ( mask( option["mask"], ent.v["type"] ) )
+            ent.v[option["name"]] = option["default"];
+    }
+#/
+}
+
+menunone()
+{
+/#
+    level.effect_list_offset = 0;
+    clear_fx_hudelements();
+    setmenu( "none" );
+#/
+}
+
+draw_effects_list( title )
+{
+/#
+    clear_fx_hudelements();
+
+    if ( !isdefined( title ) )
+        title = "Pick an effect:";
+
+    set_fx_hudelement( title );
+    count = 0;
+    more = 0;
+    keys = get_level_ambient_fx();
+
+    if ( level.effect_list_offset >= keys.size )
+        level.effect_list_offset = 0;
+    else if ( level.effect_list_offset < 0 )
+        level.effect_list_offset = int( floor( keys.size / level.effect_list_offset_max ) * level.effect_list_offset_max );
+
+    for ( i = level.effect_list_offset; i < keys.size; i++ )
+    {
+        count += 1;
+        set_fx_hudelement( count + ". " + keys[i] );
+
+        if ( count >= level.effect_list_offset_max )
+        {
+            more = 1;
+            break;
+        }
+    }
+
+    if ( keys.size > level.effect_list_offset_max )
+    {
+        pages = ceil( keys.size / level.effect_list_offset_max );
+        current_page = level.effect_list_offset / level.effect_list_offset_max + 1;
+        set_fx_hudelement( "(<-) Page " + current_page + " of " + pages + " (->)" );
+    }
+#/
+}
+
+increment_list_offset()
+{
+/#
+    level.effect_list_offset += level.effect_list_offset_max;
+#/
+}
+
+decrement_list_offset()
+{
+/#
+    level.effect_list_offset -= level.effect_list_offset_max;
+#/
+}
+
+jump_to_effect()
+{
+/#
+    count = 0;
+    picked_fxid = undefined;
+    keys = get_level_ambient_fx();
+
+    for ( i = level.effect_list_offset; i < keys.size; i++ )
+    {
+        count += 1;
+        button_to_check = count;
+
+        if ( button_to_check == 10 )
+            button_to_check = 0;
+
+        if ( button_is_clicked( button_to_check + "" ) && !button_is_held( "f" ) )
+        {
+            picked_fxid = keys[i];
+            break;
+        }
+
+        if ( count > level.effect_list_offset_max )
+            break;
+    }
+
+    if ( !isdefined( picked_fxid ) )
+        return;
+
+    clear_entity_selection();
+    ent = get_next_ent_with_same_id( -1, picked_fxid );
+
+    if ( isdefined( ent ) )
+    {
+        level.cfx_next_ent = ent;
+        move_player_to_next_same_effect( 1 );
+    }
+    else
+        iprintln( "Effect " + picked_fxid + " has not been placed." );
+
+    level.effect_list_offset = 0;
+    clear_fx_hudelements();
+    setmenu( "none" );
+#/
+}
+
+get_level_ambient_fx()
+{
+/#
+    if ( !isdefined( level._effect_keys ) )
+    {
+        keys = getarraykeys( level._effect );
+        level._effect_keys = [];
+        k = 0;
+
+        for ( i = 0; i < keys.size; i++ )
+        {
+            if ( issubstr( keys[i], "fx_" ) )
+            {
+                level._effect_keys[k] = keys[i];
+                k++;
+            }
+        }
+
+        if ( level._effect_keys.size == 0 )
+            level._effect_keys = keys;
+    }
+
+    return level._effect_keys;
+#/
+}
+
+get_distance_from_ent( ent )
+{
+/#
+    player = get_players()[0];
+    return distance( player geteye(), ent.v["origin"] );
+#/
+}

ZM/Core/maps/mp/_createfxundo.gsc

@@ -0,0 +1,508 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\_createfx;
+#include maps\mp\_createfxmenu;
+
+store_undo_state( change_type, ents )
+{
+    if ( !isdefined( level.cfx_undo_states ) )
+    {
+        level.cfx_undo_states = [];
+        level.cfx_redo_states = [];
+        level.cfx_limbo_state = spawnstruct();
+        level.cfx_max_states = 10;
+    }
+
+    if ( !isarray( ents ) )
+        ents = array( ents );
+
+    temp_array = [];
+
+    for ( i = 0; i < ents.size; i++ )
+        temp_array[i] = copy_fx_ent( ents[i] );
+
+    state = spawnstruct();
+    state.operation = change_type;
+    state.last_action = level.cfx_last_action;
+    state.ent_array = temp_array;
+
+    if ( level.cfx_undo_states.size >= level.cfx_max_states )
+        level.cfx_undo_states = array_drop( level.cfx_undo_states );
+
+    level.cfx_undo_states[level.cfx_undo_states.size] = state;
+    level.cfx_redo_states = [];
+    level.cfx_limbo_state = undefined;
+    debug_print_latest_state( "undo" );
+}
+
+undo()
+{
+    if ( !isdefined( level.createfxent ) || !isdefined( level.cfx_undo_states ) || level.cfx_undo_states.size < 1 )
+        return;
+
+    revert_state = level.cfx_undo_states[level.cfx_undo_states.size - 1];
+
+    if ( level.cfx_last_action != "none" )
+    {
+        store_undo_state( "edit", level.selected_fx_ents );
+        move_undo_state_to_redo();
+        clear_entity_selection( "skip_undo" );
+        apply_state_change( "undo", revert_state );
+        move_undo_state_to_limbo();
+        level.cfx_last_action = "none";
+    }
+    else
+    {
+        clear_entity_selection( "skip_undo" );
+
+        if ( revert_state.operation != "edit" )
+        {
+            apply_state_change( "undo", revert_state );
+            move_undo_state_to_redo();
+            level.cfx_last_action = "none";
+        }
+        else if ( isdefined( level.cfx_limbo_state ) )
+        {
+            move_limbo_state_to_redo();
+            apply_state_change( "undo", revert_state );
+            move_undo_state_to_limbo();
+            level.cfx_last_action = "none";
+        }
+        else
+        {
+            if ( level.cfx_undo_states.size > 1 )
+            {
+                move_undo_state_to_redo();
+                revert_state = level.cfx_undo_states[level.cfx_undo_states.size - 1];
+            }
+
+            apply_state_change( "undo", revert_state );
+            move_undo_state_to_limbo();
+        }
+    }
+}
+
+apply_state_change( type, revert_state )
+{
+    if ( type == "undo" )
+    {
+/#
+        println( "^2CreateFX: Undo operation" );
+#/
+        if ( revert_state.operation == "edit" )
+            undo_edit( revert_state.ent_array );
+        else if ( revert_state.operation == "add" )
+            undo_add( revert_state.ent_array );
+        else if ( revert_state.operation == "delete" )
+            undo_delete( revert_state.ent_array );
+    }
+    else
+    {
+/#
+        println( "^2CreateFX: Redo operation" );
+#/
+        if ( revert_state.operation == "edit" )
+            undo_edit( revert_state.ent_array );
+        else if ( revert_state.operation == "add" )
+            undo_delete( revert_state.ent_array );
+        else if ( revert_state.operation == "delete" )
+            undo_add( revert_state.ent_array );
+    }
+}
+
+move_undo_state_to_redo()
+{
+    if ( level.cfx_redo_states.size >= level.cfx_max_states )
+        level.cfx_redo_states = array_drop( level.cfx_redo_states );
+
+    level.cfx_redo_states[level.cfx_redo_states.size] = level.cfx_undo_states[level.cfx_undo_states.size - 1];
+    level.cfx_undo_states = array_pop( level.cfx_undo_states );
+    debug_print_latest_state( "undo" );
+    debug_print_latest_state( "redo" );
+}
+
+move_redo_state_to_undo()
+{
+    if ( level.cfx_undo_states.size >= level.cfx_max_states )
+        level.cfx_undo_states = array_drop( level.cfx_undo_states );
+
+    level.cfx_undo_states[level.cfx_undo_states.size] = level.cfx_redo_states[level.cfx_redo_states.size - 1];
+    level.cfx_redo_states = array_pop( level.cfx_redo_states );
+    debug_print_latest_state( "undo" );
+    debug_print_latest_state( "redo" );
+}
+
+move_undo_state_to_limbo()
+{
+    level.cfx_limbo_state = level.cfx_undo_states[level.cfx_undo_states.size - 1];
+    level.cfx_undo_states = array_pop( level.cfx_undo_states );
+    debug_print_latest_state( "undo" );
+    debug_print_latest_state( "limbo" );
+}
+
+move_redo_state_to_limbo()
+{
+    level.cfx_limbo_state = level.cfx_redo_states[level.cfx_redo_states.size - 1];
+    level.cfx_redo_states = array_pop( level.cfx_redo_states );
+    debug_print_latest_state( "redo" );
+    debug_print_latest_state( "limbo" );
+}
+
+move_limbo_state_to_undo()
+{
+    if ( level.cfx_undo_states.size >= level.cfx_max_states )
+        level.cfx_undo_states = array_drop( level.cfx_undo_states );
+
+    level.cfx_undo_states[level.cfx_undo_states.size] = level.cfx_limbo_state;
+    level.cfx_limbo_state = undefined;
+    debug_print_latest_state( "undo" );
+    debug_print_latest_state( "limbo" );
+}
+
+move_limbo_state_to_redo()
+{
+    if ( level.cfx_redo_states.size >= level.cfx_max_states )
+        level.cfx_redo_states = array_drop( level.cfx_redo_states );
+
+    level.cfx_redo_states[level.cfx_redo_states.size] = level.cfx_limbo_state;
+    level.cfx_limbo_state = undefined;
+    debug_print_latest_state( "redo" );
+}
+
+undo_edit( ent_array )
+{
+    ent_array = reorder_ent_array_by_uniqueid( ent_array );
+/#
+    println( "^3CreateFX: Undoing edit" );
+    debug_print_ent_array( ent_array, "ent_array[]" );
+    debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+#/
+    last_id = ent_array[ent_array.size - 1].uniqueid;
+
+    if ( last_id > level.createfxent.size - 1 )
+        last_id = level.createfxent.size - 1;
+
+    j = ent_array.size - 1;
+    source_ent = ent_array[j];
+
+    for ( i = last_id; i >= 0; i-- )
+    {
+        target_ent = level.createfxent[i];
+
+        if ( source_ent.uniqueid == target_ent.uniqueid )
+        {
+            copy_values_between_fx_ents( source_ent, target_ent );
+            select_entity( i, target_ent, "skip_undo" );
+            j--;
+
+            if ( j < 0 )
+                break;
+
+            source_ent = ent_array[j];
+        }
+    }
+
+    update_selected_entities();
+/#
+    println( "^1CreateFX: Finished edit" );
+    debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+#/
+}
+
+undo_add( ent_array )
+{
+    ent_array = reorder_ent_array_by_uniqueid( ent_array );
+/#
+    println( "^3createfx: Undoing add." );
+    debug_print_ent_array( ent_array, "ent_array[]" );
+    debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+#/
+    last_id = ent_array[ent_array.size - 1].uniqueid;
+
+    if ( last_id > level.createfxent.size - 1 )
+        last_id = level.createfxent.size - 1;
+
+    j = ent_array.size - 1;
+    source_ent = ent_array[j];
+
+    for ( i = last_id; i >= 0; i-- )
+    {
+        target_ent = level.createfxent[i];
+
+        if ( source_ent.uniqueid == target_ent.uniqueid )
+        {
+            if ( isdefined( target_ent.looper ) )
+                target_ent.looper delete();
+
+            target_ent notify( "stop_loop" );
+            level.createfxent[i] = undefined;
+            j--;
+
+            if ( j < 0 )
+                break;
+
+            source_ent = ent_array[j];
+        }
+    }
+/#
+    debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+    println( "createfx: Starting array_remove_undefined()" );
+#/
+    arrayremovevalue( level.createfxent, undefined );
+/#
+    println( "^1CreateFX: Finished undo add." );
+    debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+#/
+    clear_fx_hudelements();
+}
+
+undo_delete( ent_array )
+{
+/#
+    println( "^3CreateFX: Undoing delete" );
+    debug_print_ent_array( ent_array, "ent_array in undo_delete()" );
+    debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+#/
+    ent_array = reorder_ent_array_by_uniqueid( ent_array );
+
+    if ( level.createfxent.size == 0 )
+    {
+        for ( i = 0; i < ent_array.size; i++ )
+            level.createfxent[i] = copy_fx_ent( ent_array[i] );
+    }
+    else
+    {
+        temp_array = [];
+        i = 0;
+
+        for ( j = 0; j < level.createfxent.size; j++ )
+        {
+            target_ent = level.createfxent[j];
+
+            if ( i >= ent_array.size )
+            {
+                temp_array[temp_array.size] = target_ent;
+                continue;
+            }
+
+            source_ent = ent_array[i];
+
+            if ( target_ent.uniqueid < source_ent.uniqueid )
+            {
+                temp_array[temp_array.size] = target_ent;
+                continue;
+            }
+
+            temp_array[temp_array.size] = copy_fx_ent( source_ent );
+            j--;
+            i++;
+        }
+
+        while ( i < ent_array.size )
+        {
+            temp_array[temp_array.size] = ent_array[i];
+            i++;
+        }
+
+        level.createfxent = temp_array;
+    }
+/#
+    println( "^1Createfx: Finished undoing delete, pre-selection" );
+    debug_print_ent_array( level.createfxent, "level.createFXent[]" );
+#/
+    last_id = ent_array[ent_array.size - 1].uniqueid;
+
+    if ( last_id > level.createfxent.size - 1 )
+        last_id = level.createfxent.size - 1;
+
+    j = ent_array.size - 1;
+    source_ent = ent_array[j];
+
+    for ( i = last_id; i >= 0; i-- )
+    {
+        target_ent = level.createfxent[i];
+
+        if ( source_ent.uniqueid == target_ent.uniqueid )
+        {
+            target_ent post_entity_creation_function();
+            select_entity( i, target_ent, "skip_undo" );
+            j--;
+
+            if ( j < 0 )
+                break;
+
+            source_ent = ent_array[j];
+        }
+    }
+
+    update_selected_entities();
+}
+
+redo()
+{
+    if ( !isdefined( level.createfxent ) || !isdefined( level.cfx_redo_states ) || level.cfx_redo_states.size < 1 )
+        return;
+
+    clear_entity_selection( "skip_undo" );
+
+    if ( isdefined( level.cfx_limbo_state ) )
+    {
+        move_limbo_state_to_undo();
+        move_redo_state_to_limbo();
+        apply_state_change( "redo", level.cfx_limbo_state );
+    }
+    else
+    {
+        revert_state = level.cfx_redo_states[level.cfx_redo_states.size - 1];
+        apply_state_change( "redo", revert_state );
+
+        if ( revert_state.operation == "edit" )
+            move_redo_state_to_limbo();
+        else
+            move_redo_state_to_undo();
+    }
+
+    level.cfx_last_action = "none";
+}
+
+reorder_ent_array_by_uniqueid( ent_array )
+{
+    if ( ent_array.size <= 1 )
+        return ent_array;
+
+    array_size = ent_array.size;
+
+    for ( i = 0; i < array_size - 1; i++ )
+    {
+        for ( j = i + 1; j < array_size; j++ )
+        {
+            if ( ent_array[i].uniqueid > ent_array[j].uniqueid )
+            {
+                temp_ent = ent_array[i];
+                ent_array[i] = ent_array[j];
+                ent_array[j] = temp_ent;
+            }
+        }
+    }
+
+    return ent_array;
+}
+
+copy_fx_ent( ent )
+{
+    temp_ent = spawnstruct();
+    temp_ent.drawn = ent.drawn;
+    temp_ent.drawn_axis_model = ent.drawn_axis_model;
+    temp_ent.last_fx_index = ent.last_fx_index;
+    temp_ent.textalpha = ent.textalpha;
+    temp_ent.uniqueid = ent.uniqueid;
+    temp_ent.v = ent.v;
+    return temp_ent;
+}
+
+copy_values_between_fx_ents( source, dest )
+{
+    dest.drawn = source.drawn;
+    dest.drawn_axis_model = source.drawn_axis_model;
+    dest.last_fx_index = source.last_fx_index;
+    dest.textalpha = source.textalpha;
+    dest.v = source.v;
+    return dest;
+}
+
+array_pop( array )
+{
+    array_size = array.size - 1;
+    temp_array = [];
+
+    if ( array_size <= 0 )
+        return temp_array;
+
+    for ( i = 0; i < array_size; i++ )
+        temp_array[i] = array[i];
+
+    array = temp_array;
+    return array;
+}
+
+array_drop( array )
+{
+    if ( array.size > 0 )
+    {
+        temp_array = [];
+
+        for ( i = 1; i < array.size; i++ )
+            temp_array[i - 1] = array[i];
+
+        array = temp_array;
+    }
+
+    return array;
+}
+
+debug_print_ent_array( array, name )
+{
+/#
+    if ( isdefined( name ) )
+        println( "Printing out " + name );
+    else
+        println( "Printing out some array" );
+
+    for ( i = 0; i < array.size; i++ )
+    {
+        if ( !isdefined( array[i] ) )
+        {
+            println( "" + i + ": deleted effect" );
+            continue;
+        }
+
+        println( "" + i + ": uniqueid: " + array[i].uniqueid + "  fxid: " + array[i].v["fxid"] );
+    }
+#/
+}
+
+debug_print_latest_state( type )
+{
+/#
+    println( "^3Saving " + type + " state" );
+
+    if ( type == "undo" )
+    {
+        if ( !isdefined( level.cfx_undo_states[level.cfx_undo_states.size - 1] ) )
+        {
+            println( "There are no undo states." );
+            return;
+        }
+
+        state = level.cfx_undo_states[level.cfx_undo_states.size - 1];
+        size = level.cfx_undo_states.size - 1;
+    }
+    else if ( type == "redo" )
+    {
+        if ( !isdefined( level.cfx_redo_states[level.cfx_redo_states.size - 1] ) )
+        {
+            println( "There are no redo states." );
+            return;
+        }
+
+        state = level.cfx_redo_states[level.cfx_redo_states.size - 1];
+        size = level.cfx_redo_states.size - 1;
+    }
+    else
+    {
+        if ( !isdefined( level.cfx_limbo_state ) )
+        {
+            println( "There is no limbo state." );
+            return;
+        }
+
+        state = level.cfx_limbo_state;
+        size = 0;
+    }
+
+    println( "State " + size + " - " + state.operation + ": " + state.last_action );
+    debug_print_ent_array( state.ent_array, "save state ent_array" );
+#/
+}

ZM/Core/maps/mp/_demo.gsc

@@ -0,0 +1,90 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+
+init()
+{
+    level.bookmark["kill"] = 0;
+    level.bookmark["event"] = 1;
+    level.bookmark["zm_round_end"] = 2;
+    level.bookmark["zm_player_downed"] = 3;
+    level.bookmark["zm_player_revived"] = 4;
+    level.bookmark["zm_player_bledout"] = 5;
+    level.bookmark["zm_player_use_magicbox"] = 6;
+    level.bookmark["score_event"] = 7;
+    level.bookmark["medal"] = 8;
+    level.bookmark["round_result"] = 9;
+    level.bookmark["game_result"] = 10;
+    level.bookmark["zm_powerup_dropped"] = 11;
+    level.bookmark["zm_player_powerup_grabbed"] = 12;
+    level.bookmark["zm_player_perk"] = 13;
+    level.bookmark["zm_power"] = 14;
+    level.bookmark["zm_player_door"] = 15;
+    level.bookmark["zm_player_buildable_placed"] = 16;
+    level.bookmark["zm_player_use_packapunch"] = 17;
+    level.bookmark["zm_player_rampage"] = 18;
+    level.bookmark["zm_player_grenade_special"] = 19;
+    level.bookmark["zm_player_grenade_multiattack"] = 20;
+    level.bookmark["zm_player_meat_stink"] = 21;
+    level.bookmark["zm_player_grabbed_magicbox"] = 22;
+    level.bookmark["zm_player_grabbed_packapunch"] = 23;
+    level.bookmark["zm_player_grenade_special_long"] = 24;
+}
+
+bookmark( type, time, clientent1, clientent2, eventpriority, inflictorent, overrideentitycamera, actorent )
+{
+    assert( isdefined( level.bookmark[type] ), "Unable to find a bookmark type for type - " + type );
+    client1 = 255;
+    client2 = 255;
+    inflictorentnum = -1;
+    inflictorenttype = 0;
+    inflictorbirthtime = 0;
+    actorentnum = undefined;
+    scoreeventpriority = 0;
+
+    if ( isdefined( clientent1 ) )
+        client1 = clientent1 getentitynumber();
+
+    if ( isdefined( clientent2 ) )
+        client2 = clientent2 getentitynumber();
+
+    if ( isdefined( eventpriority ) )
+        scoreeventpriority = eventpriority;
+
+    if ( isdefined( inflictorent ) )
+    {
+        inflictorentnum = inflictorent getentitynumber();
+        inflictorenttype = inflictorent getentitytype();
+
+        if ( isdefined( inflictorent.birthtime ) )
+            inflictorbirthtime = inflictorent.birthtime;
+    }
+
+    if ( !isdefined( overrideentitycamera ) )
+        overrideentitycamera = 0;
+
+    if ( isdefined( actorent ) )
+        actorentnum = actorent getentitynumber();
+
+    adddemobookmark( level.bookmark[type], time, client1, client2, scoreeventpriority, inflictorentnum, inflictorenttype, inflictorbirthtime, overrideentitycamera, actorentnum );
+}
+
+gameresultbookmark( type, winningteamindex, losingteamindex )
+{
+    assert( isdefined( level.bookmark[type] ), "Unable to find a bookmark type for type - " + type );
+    client1 = 255;
+    client2 = 255;
+    scoreeventpriority = 0;
+    inflictorentnum = -1;
+    inflictorenttype = 0;
+    inflictorbirthtime = 0;
+    overrideentitycamera = 0;
+    actorentnum = undefined;
+
+    if ( isdefined( winningteamindex ) )
+        client1 = winningteamindex;
+
+    if ( isdefined( losingteamindex ) )
+        client2 = losingteamindex;
+
+    adddemobookmark( level.bookmark[type], gettime(), client1, client2, scoreeventpriority, inflictorentnum, inflictorenttype, inflictorbirthtime, overrideentitycamera, actorentnum );
+}

ZM/Core/maps/mp/_fx.gsc

@@ -0,0 +1,453 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\_createfx;
+
+print_org( fxcommand, fxid, fxpos, waittime )
+{
+/#
+    if ( getdvar( _hash_F49A52C ) == "1" )
+    {
+        println( "{" );
+        println( "\"origin\" \"" + fxpos[0] + " " + fxpos[1] + " " + fxpos[2] + "\"" );
+        println( "\"classname\" \"script_model\"" );
+        println( "\"model\" \"fx\"" );
+        println( "\"script_fxcommand\" \"" + fxcommand + "\"" );
+        println( "\"script_fxid\" \"" + fxid + "\"" );
+        println( "\"script_delay\" \"" + waittime + "\"" );
+        println( "}" );
+    }
+#/
+}
+
+oneshotfx( fxid, fxpos, waittime, fxpos2 )
+{
+
+}
+
+oneshotfxthread()
+{
+    wait 0.05;
+
+    if ( self.v["delay"] > 0 )
+        wait( self.v["delay"] );
+
+    create_triggerfx();
+}
+
+create_triggerfx()
+{
+    self.looper = spawnfx_wrapper( self.v["fxid"], self.v["origin"], self.v["forward"], self.v["up"] );
+    triggerfx( self.looper, self.v["delay"] );
+    create_loopsound();
+}
+
+exploderfx( num, fxid, fxpos, waittime, fxpos2, firefx, firefxdelay, firefxsound, fxsound, fxquake, fxdamage, soundalias, repeat, delay_min, delay_max, damage_radius, firefxtimeout, exploder_group )
+{
+    if ( 1 )
+    {
+        ent = createexploder( fxid );
+        ent.v["origin"] = fxpos;
+        ent.v["angles"] = ( 0, 0, 0 );
+
+        if ( isdefined( fxpos2 ) )
+            ent.v["angles"] = vectortoangles( fxpos2 - fxpos );
+
+        ent.v["delay"] = waittime;
+        ent.v["exploder"] = num;
+        return;
+    }
+
+    fx = spawn( "script_origin", ( 0, 0, 0 ) );
+    fx.origin = fxpos;
+    fx.angles = vectortoangles( fxpos2 - fxpos );
+    fx.script_exploder = num;
+    fx.script_fxid = fxid;
+    fx.script_delay = waittime;
+    fx.script_firefx = firefx;
+    fx.script_firefxdelay = firefxdelay;
+    fx.script_firefxsound = firefxsound;
+    fx.script_sound = fxsound;
+    fx.script_earthquake = fxquake;
+    fx.script_damage = fxdamage;
+    fx.script_radius = damage_radius;
+    fx.script_soundalias = soundalias;
+    fx.script_firefxtimeout = firefxtimeout;
+    fx.script_repeat = repeat;
+    fx.script_delay_min = delay_min;
+    fx.script_delay_max = delay_max;
+    fx.script_exploder_group = exploder_group;
+    forward = anglestoforward( fx.angles );
+    forward = vectorscale( forward, 150 );
+    fx.targetpos = fxpos + forward;
+
+    if ( !isdefined( level._script_exploders ) )
+        level._script_exploders = [];
+
+    level._script_exploders[level._script_exploders.size] = fx;
+    maps\mp\_createfx::createfx_showorigin( fxid, fxpos, waittime, fxpos2, "exploderfx", fx, undefined, firefx, firefxdelay, firefxsound, fxsound, fxquake, fxdamage, soundalias, repeat, delay_min, delay_max, damage_radius, firefxtimeout );
+}
+
+loopfx( fxid, fxpos, waittime, fxpos2, fxstart, fxstop, timeout )
+{
+/#
+    println( "Loopfx is deprecated!" );
+#/
+    ent = createloopeffect( fxid );
+    ent.v["origin"] = fxpos;
+    ent.v["angles"] = ( 0, 0, 0 );
+
+    if ( isdefined( fxpos2 ) )
+        ent.v["angles"] = vectortoangles( fxpos2 - fxpos );
+
+    ent.v["delay"] = waittime;
+}
+
+create_looper()
+{
+    self.looper = playloopedfx( level._effect[self.v["fxid"]], self.v["delay"], self.v["origin"], 0, self.v["forward"], self.v["up"] );
+    create_loopsound();
+}
+
+create_loopsound()
+{
+    self notify( "stop_loop" );
+
+    if ( isdefined( self.v["soundalias"] ) && self.v["soundalias"] != "nil" )
+    {
+        if ( isdefined( self.looper ) )
+            self.looper thread maps\mp\_utility::loop_fx_sound( self.v["soundalias"], self.v["origin"], "death" );
+        else
+            thread maps\mp\_utility::loop_fx_sound( self.v["soundalias"], self.v["origin"], "stop_loop" );
+    }
+}
+
+stop_loopsound()
+{
+    self notify( "stop_loop" );
+}
+
+loopfxthread()
+{
+    wait 0.05;
+
+    if ( isdefined( self.fxstart ) )
+        level waittill( "start fx" + self.fxstart );
+
+    while ( true )
+    {
+        create_looper();
+
+        if ( isdefined( self.timeout ) )
+            thread loopfxstop( self.timeout );
+
+        if ( isdefined( self.fxstop ) )
+            level waittill( "stop fx" + self.fxstop );
+        else
+            return;
+
+        if ( isdefined( self.looper ) )
+            self.looper delete();
+
+        if ( isdefined( self.fxstart ) )
+            level waittill( "start fx" + self.fxstart );
+        else
+            return;
+    }
+}
+
+loopfxchangeid( ent )
+{
+    self endon( "death" );
+
+    ent waittill( "effect id changed", change );
+}
+
+loopfxchangeorg( ent )
+{
+    self endon( "death" );
+
+    for (;;)
+    {
+        ent waittill( "effect org changed", change );
+
+        self.origin = change;
+    }
+}
+
+loopfxchangedelay( ent )
+{
+    self endon( "death" );
+
+    ent waittill( "effect delay changed", change );
+}
+
+loopfxdeletion( ent )
+{
+    self endon( "death" );
+
+    ent waittill( "effect deleted" );
+
+    self delete();
+}
+
+loopfxstop( timeout )
+{
+    self endon( "death" );
+    wait( timeout );
+    self.looper delete();
+}
+
+loopsound( sound, pos, waittime )
+{
+    level thread loopsoundthread( sound, pos, waittime );
+}
+
+loopsoundthread( sound, pos, waittime )
+{
+    org = spawn( "script_origin", pos );
+    org.origin = pos;
+    org playloopsound( sound );
+}
+
+gunfireloopfx( fxid, fxpos, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax )
+{
+    thread gunfireloopfxthread( fxid, fxpos, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax );
+}
+
+gunfireloopfxthread( fxid, fxpos, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax )
+{
+    level endon( "stop all gunfireloopfx" );
+    wait 0.05;
+
+    if ( betweensetsmax < betweensetsmin )
+    {
+        temp = betweensetsmax;
+        betweensetsmax = betweensetsmin;
+        betweensetsmin = temp;
+    }
+
+    betweensetsbase = betweensetsmin;
+    betweensetsrange = betweensetsmax - betweensetsmin;
+
+    if ( shotdelaymax < shotdelaymin )
+    {
+        temp = shotdelaymax;
+        shotdelaymax = shotdelaymin;
+        shotdelaymin = temp;
+    }
+
+    shotdelaybase = shotdelaymin;
+    shotdelayrange = shotdelaymax - shotdelaymin;
+
+    if ( shotsmax < shotsmin )
+    {
+        temp = shotsmax;
+        shotsmax = shotsmin;
+        shotsmin = temp;
+    }
+
+    shotsbase = shotsmin;
+    shotsrange = shotsmax - shotsmin;
+    fxent = spawnfx( level._effect[fxid], fxpos );
+
+    for (;;)
+    {
+        shotnum = shotsbase + randomint( shotsrange );
+
+        for ( i = 0; i < shotnum; i++ )
+        {
+            triggerfx( fxent );
+            wait( shotdelaybase + randomfloat( shotdelayrange ) );
+        }
+
+        wait( betweensetsbase + randomfloat( betweensetsrange ) );
+    }
+}
+
+gunfireloopfxvec( fxid, fxpos, fxpos2, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax )
+{
+    thread gunfireloopfxvecthread( fxid, fxpos, fxpos2, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax );
+}
+
+gunfireloopfxvecthread( fxid, fxpos, fxpos2, shotsmin, shotsmax, shotdelaymin, shotdelaymax, betweensetsmin, betweensetsmax )
+{
+    level endon( "stop all gunfireloopfx" );
+    wait 0.05;
+
+    if ( betweensetsmax < betweensetsmin )
+    {
+        temp = betweensetsmax;
+        betweensetsmax = betweensetsmin;
+        betweensetsmin = temp;
+    }
+
+    betweensetsbase = betweensetsmin;
+    betweensetsrange = betweensetsmax - betweensetsmin;
+
+    if ( shotdelaymax < shotdelaymin )
+    {
+        temp = shotdelaymax;
+        shotdelaymax = shotdelaymin;
+        shotdelaymin = temp;
+    }
+
+    shotdelaybase = shotdelaymin;
+    shotdelayrange = shotdelaymax - shotdelaymin;
+
+    if ( shotsmax < shotsmin )
+    {
+        temp = shotsmax;
+        shotsmax = shotsmin;
+        shotsmin = temp;
+    }
+
+    shotsbase = shotsmin;
+    shotsrange = shotsmax - shotsmin;
+    fxpos2 = vectornormalize( fxpos2 - fxpos );
+    fxent = spawnfx( level._effect[fxid], fxpos, fxpos2 );
+
+    for (;;)
+    {
+        shotnum = shotsbase + randomint( shotsrange );
+
+        for ( i = 0; i < int( shotnum / level.fxfireloopmod ); i++ )
+        {
+            triggerfx( fxent );
+            delay = ( shotdelaybase + randomfloat( shotdelayrange ) ) * level.fxfireloopmod;
+
+            if ( delay < 0.05 )
+                delay = 0.05;
+
+            wait( delay );
+        }
+
+        wait( shotdelaybase + randomfloat( shotdelayrange ) );
+        wait( betweensetsbase + randomfloat( betweensetsrange ) );
+    }
+}
+
+setfireloopmod( value )
+{
+    level.fxfireloopmod = 1 / value;
+}
+
+setup_fx()
+{
+    if ( !isdefined( self.script_fxid ) || !isdefined( self.script_fxcommand ) || !isdefined( self.script_delay ) )
+        return;
+
+    org = undefined;
+
+    if ( isdefined( self.target ) )
+    {
+        ent = getent( self.target, "targetname" );
+
+        if ( isdefined( ent ) )
+            org = ent.origin;
+    }
+
+    fxstart = undefined;
+
+    if ( isdefined( self.script_fxstart ) )
+        fxstart = self.script_fxstart;
+
+    fxstop = undefined;
+
+    if ( isdefined( self.script_fxstop ) )
+        fxstop = self.script_fxstop;
+
+    if ( self.script_fxcommand == "OneShotfx" )
+        oneshotfx( self.script_fxid, self.origin, self.script_delay, org );
+
+    if ( self.script_fxcommand == "loopfx" )
+        loopfx( self.script_fxid, self.origin, self.script_delay, org, fxstart, fxstop );
+
+    if ( self.script_fxcommand == "loopsound" )
+        loopsound( self.script_fxid, self.origin, self.script_delay );
+
+    self delete();
+}
+
+script_print_fx()
+{
+/#
+    if ( !isdefined( self.script_fxid ) || !isdefined( self.script_fxcommand ) || !isdefined( self.script_delay ) )
+    {
+        println( "Effect at origin ", self.origin, " doesn't have script_fxid/script_fxcommand/script_delay" );
+        self delete();
+        return;
+    }
+
+    if ( isdefined( self.target ) )
+        org = getent( self.target, "targetname" ).origin;
+    else
+        org = "undefined";
+
+    if ( self.script_fxcommand == "OneShotfx" )
+        println( "mapsmp_fx::OneShotfx(\"" + self.script_fxid + "\", " + self.origin + ", " + self.script_delay + ", " + org + ");" );
+
+    if ( self.script_fxcommand == "loopfx" )
+        println( "mapsmp_fx::LoopFx(\"" + self.script_fxid + "\", " + self.origin + ", " + self.script_delay + ", " + org + ");" );
+
+    if ( self.script_fxcommand == "loopsound" )
+        println( "mapsmp_fx::LoopSound(\"" + self.script_fxid + "\", " + self.origin + ", " + self.script_delay + ", " + org + ");" );
+#/
+}
+
+script_playfx( id, pos, pos2 )
+{
+    if ( !id )
+        return;
+
+    if ( isdefined( pos2 ) )
+        playfx( id, pos, pos2 );
+    else
+        playfx( id, pos );
+}
+
+script_playfxontag( id, ent, tag )
+{
+    if ( !id )
+        return;
+
+    playfxontag( id, ent, tag );
+}
+
+grenadeexplosionfx( pos )
+{
+    playfx( level._effect["mechanical explosion"], pos );
+    earthquake( 0.15, 0.5, pos, 250 );
+}
+
+soundfx( fxid, fxpos, endonnotify )
+{
+    org = spawn( "script_origin", ( 0, 0, 0 ) );
+    org.origin = fxpos;
+    org playloopsound( fxid );
+
+    if ( isdefined( endonnotify ) )
+        org thread soundfxdelete( endonnotify );
+}
+
+soundfxdelete( endonnotify )
+{
+    level waittill( endonnotify );
+
+    self delete();
+}
+
+blenddelete( blend )
+{
+    self waittill( "death" );
+
+    blend delete();
+}
+
+spawnfx_wrapper( fx_id, origin, forward, up )
+{
+    assert( isdefined( level._effect[fx_id] ), "Missing level._effect[\"" + fx_id + "\"]. You did not setup the fx before calling it in createFx." );
+    fx_object = spawnfx( level._effect[fx_id], origin, forward, up );
+    return fx_object;
+}

ZM/Core/maps/mp/_fxanim.gsc

@@ -0,0 +1,8 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+
+init()
+{
+    level.scr_anim = [];
+    level.scr_anim["fxanim_props"] = [];
+}

ZM/Core/maps/mp/_global_fx.gsc

@@ -0,0 +1,53 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+
+main()
+{
+    randomstartdelay = randomfloatrange( -20, -15 );
+    global_fx( "barrel_fireFX_origin", "global_barrel_fire", "fire/firelp_barrel_pm", randomstartdelay, "fire_barrel_small" );
+    global_fx( "ch_streetlight_02_FX_origin", "ch_streetlight_02_FX", "misc/lighthaze", randomstartdelay );
+    global_fx( "me_streetlight_01_FX_origin", "me_streetlight_01_FX", "misc/lighthaze_bog_a", randomstartdelay );
+    global_fx( "ch_street_light_01_on", "lamp_glow_FX", "misc/light_glow_white", randomstartdelay );
+    global_fx( "highway_lamp_post", "ch_streetlight_02_FX", "misc/lighthaze_villassault", randomstartdelay );
+    global_fx( "cs_cargoship_spotlight_on_FX_origin", "cs_cargoship_spotlight_on_FX", "misc/lighthaze", randomstartdelay );
+    global_fx( "me_dumpster_fire_FX_origin", "me_dumpster_fire_FX", "fire/firelp_med_pm_nodistort", randomstartdelay, "fire_dumpster_medium" );
+    global_fx( "com_tires_burning01_FX_origin", "com_tires_burning01_FX", "fire/tire_fire_med", randomstartdelay );
+    global_fx( "icbm_powerlinetower_FX_origin", "icbm_powerlinetower_FX", "misc/power_tower_light_red_blink", randomstartdelay );
+}
+
+global_fx( targetname, fxname, fxfile, delay, soundalias )
+{
+    ents = getstructarray( targetname, "targetname" );
+
+    if ( !isdefined( ents ) )
+        return;
+
+    if ( ents.size <= 0 )
+        return;
+
+    for ( i = 0; i < ents.size; i++ )
+        ents[i] global_fx_create( fxname, fxfile, delay, soundalias );
+}
+
+global_fx_create( fxname, fxfile, delay, soundalias )
+{
+    if ( !isdefined( level._effect ) )
+        level._effect = [];
+
+    if ( !isdefined( level._effect[fxname] ) )
+        level._effect[fxname] = loadfx( fxfile );
+
+    if ( !isdefined( self.angles ) )
+        self.angles = ( 0, 0, 0 );
+
+    ent = createoneshoteffect( fxname );
+    ent.v["origin"] = self.origin;
+    ent.v["angles"] = self.angles;
+    ent.v["fxid"] = fxname;
+    ent.v["delay"] = delay;
+
+    if ( isdefined( soundalias ) )
+        ent.v["soundalias"] = soundalias;
+}

ZM/Core/maps/mp/_interactive_objects.gsc

@@ -0,0 +1,387 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include common_scripts\utility;
+
+init()
+{
+    level.barrelexplodingthisframe = 0;
+    qbarrels = 0;
+    all_barrels = [];
+    barrels = getentarray( "explodable_barrel", "targetname" );
+
+    if ( isdefined( barrels ) && barrels.size > 0 )
+    {
+        qbarrels = 1;
+
+        for ( i = 0; i < barrels.size; i++ )
+            all_barrels[all_barrels.size] = barrels[i];
+    }
+
+    barrels = getentarray( "explodable_barrel", "script_noteworthy" );
+
+    if ( isdefined( barrels ) && barrels.size > 0 )
+    {
+        qbarrels = 1;
+
+        for ( i = 0; i < barrels.size; i++ )
+            all_barrels[all_barrels.size] = barrels[i];
+    }
+
+    if ( qbarrels )
+    {
+        precachemodel( "global_explosive_barrel" );
+        level.barrelburn = 100;
+        level.barrelhealth = 250;
+        level.barrelingsound = "exp_redbarrel_ignition";
+        level.barrelexpsound = "exp_redbarrel";
+        level.breakables_fx["barrel"]["burn_start"] = loadfx( "destructibles/fx_barrel_ignite" );
+        level.breakables_fx["barrel"]["burn"] = loadfx( "destructibles/fx_barrel_fire_top" );
+        level.breakables_fx["barrel"]["explode"] = loadfx( "destructibles/fx_dest_barrelexp" );
+        array_thread( all_barrels, ::explodable_barrel_think );
+    }
+
+    qcrates = 0;
+    all_crates = [];
+    crates = getentarray( "flammable_crate", "targetname" );
+
+    if ( isdefined( crates ) && crates.size > 0 )
+    {
+        qcrates = 1;
+
+        for ( i = 0; i < crates.size; i++ )
+            all_crates[all_crates.size] = crates[i];
+    }
+
+    crates = getentarray( "flammable_crate", "script_noteworthy" );
+
+    if ( isdefined( crates ) && crates.size > 0 )
+    {
+        qcrates = 1;
+
+        for ( i = 0; i < crates.size; i++ )
+            all_crates[all_crates.size] = crates[i];
+    }
+
+    if ( qcrates )
+    {
+        precachemodel( "global_flammable_crate_jap_piece01_d" );
+        level.crateburn = 100;
+        level.cratehealth = 200;
+        level.breakables_fx["ammo_crate"]["burn_start"] = loadfx( "destructibles/fx_ammobox_ignite" );
+        level.breakables_fx["ammo_crate"]["burn"] = loadfx( "destructibles/fx_ammobox_fire_top" );
+        level.breakables_fx["ammo_crate"]["explode"] = loadfx( "destructibles/fx_ammoboxExp" );
+        level.crateignsound = "Ignition_ammocrate";
+        level.crateexpsound = "Explo_ammocrate";
+        array_thread( all_crates, ::flammable_crate_think );
+    }
+
+    if ( !qbarrels && !qcrates )
+        return;
+}
+
+explodable_barrel_think()
+{
+    if ( self.classname != "script_model" )
+        return;
+
+    self endon( "exploding" );
+    self breakable_clip();
+    self.health = level.barrelhealth;
+    self setcandamage( 1 );
+    self.targetname = "explodable_barrel";
+
+    if ( sessionmodeiszombiesgame() )
+        self.removeexplodable = 1;
+
+    for (;;)
+    {
+        self waittill( "damage", amount, attacker, direction_vec, p, type );
+/#
+        println( "BARRELDAMAGE: " + type );
+#/
+        if ( type == "MOD_MELEE" || type == "MOD_IMPACT" )
+            continue;
+
+        if ( isdefined( self.script_requires_player ) && self.script_requires_player && !isplayer( attacker ) )
+            continue;
+
+        if ( isdefined( self.script_selfisattacker ) && self.script_selfisattacker )
+            self.damageowner = self;
+        else
+            self.damageowner = attacker;
+
+        self.health -= amount;
+
+        if ( self.health <= level.barrelburn )
+            self thread explodable_barrel_burn();
+    }
+}
+
+explodable_barrel_burn()
+{
+    count = 0;
+    startedfx = 0;
+    up = anglestoup( vectorscale( ( 0, 1, 0 ), 90.0 ) );
+    worldup = anglestoup( vectorscale( ( 0, 1, 0 ), 90.0 ) );
+    dot = vectordot( up, worldup );
+    offset1 = ( 0, 0, 0 );
+    offset2 = up * vectorscale( ( 0, 0, 1 ), 44.0 );
+
+    if ( dot < 0.5 )
+    {
+        offset1 = up * vectorscale( ( 0, 0, 1 ), 22.0 ) - vectorscale( ( 0, 0, 1 ), 30.0 );
+        offset2 = up * vectorscale( ( 0, 0, 1 ), 22.0 ) + vectorscale( ( 0, 0, 1 ), 14.0 );
+    }
+
+    while ( self.health > 0 )
+    {
+        if ( !startedfx )
+        {
+            playfx( level.breakables_fx["barrel"]["burn_start"], self.origin + offset1 );
+            level thread play_sound_in_space( level.barrelingsound, self.origin );
+            startedfx = 1;
+        }
+
+        if ( count > 20 )
+            count = 0;
+
+        playfx( level.breakables_fx["barrel"]["burn"], self.origin + offset2 );
+        self playloopsound( "barrel_fuse" );
+
+        if ( count == 0 )
+            self.health -= 10 + randomint( 10 );
+
+        count++;
+        wait 0.05;
+    }
+
+    level notify( "explosion_started" );
+    self thread explodable_barrel_explode();
+}
+
+explodable_barrel_explode()
+{
+    self notify( "exploding" );
+    self death_notify_wrapper();
+    up = anglestoup( vectorscale( ( 0, 1, 0 ), 90.0 ) );
+    worldup = anglestoup( vectorscale( ( 0, 1, 0 ), 90.0 ) );
+    dot = vectordot( up, worldup );
+    offset = ( 0, 0, 0 );
+
+    if ( dot < 0.5 )
+    {
+        start = self.origin + vectorscale( up, 22 );
+        trace = physicstrace( start, start + vectorscale( ( 0, 0, -1 ), 64.0 ) );
+        end = trace["position"];
+        offset = end - self.origin;
+    }
+
+    offset += vectorscale( ( 0, 0, 1 ), 4.0 );
+    mindamage = 1;
+    maxdamage = 250;
+    blastradius = 250;
+    level thread play_sound_in_space( level.barrelexpsound, self.origin );
+    playfx( level.breakables_fx["barrel"]["explode"], self.origin + offset );
+    physicsexplosionsphere( self.origin + offset, 100, 80, 1, maxdamage, mindamage );
+    level.barrelexplodingthisframe = 1;
+
+    if ( isdefined( self.remove ) )
+        self.remove delete();
+
+    if ( isdefined( self.radius ) )
+        blastradius = self.radius;
+
+    self radiusdamage( self.origin + vectorscale( ( 0, 0, 1 ), 56.0 ), blastradius, maxdamage, mindamage, self.damageowner );
+    attacker = undefined;
+
+    if ( isdefined( self.damageowner ) )
+        attacker = self.damageowner;
+
+    level.lastexplodingbarrel["time"] = gettime();
+    level.lastexplodingbarrel["origin"] = self.origin + vectorscale( ( 0, 0, 1 ), 30.0 );
+
+    if ( isdefined( self.removeexplodable ) )
+        self hide();
+    else
+        self setmodel( "global_explosive_barrel" );
+
+    if ( dot < 0.5 )
+    {
+        start = self.origin + vectorscale( up, 22 );
+        trace = physicstrace( start, start + vectorscale( ( 0, 0, -1 ), 64.0 ) );
+        pos = trace["position"];
+        self.origin = pos;
+        self.angles += vectorscale( ( 0, 0, 1 ), 90.0 );
+    }
+
+    wait 0.05;
+    level.barrelexplodingthisframe = 0;
+}
+
+flammable_crate_think()
+{
+    if ( self.classname != "script_model" )
+        return;
+
+    self endon( "exploding" );
+    self breakable_clip();
+    self.health = level.cratehealth;
+    self setcandamage( 1 );
+
+    for (;;)
+    {
+        self waittill( "damage", amount, attacker, direction_vec, p, type );
+
+        if ( isdefined( self.script_requires_player ) && self.script_requires_player && !isplayer( attacker ) )
+            continue;
+
+        if ( isdefined( self.script_selfisattacker ) && self.script_selfisattacker )
+            self.damageowner = self;
+        else
+            self.damageowner = attacker;
+
+        if ( level.barrelexplodingthisframe )
+            wait( randomfloat( 1 ) );
+
+        self.health -= amount;
+
+        if ( self.health <= level.crateburn )
+            self thread flammable_crate_burn();
+    }
+}
+
+flammable_crate_burn()
+{
+    count = 0;
+    startedfx = 0;
+    up = anglestoup( vectorscale( ( 0, 1, 0 ), 90.0 ) );
+    worldup = anglestoup( vectorscale( ( 0, 1, 0 ), 90.0 ) );
+    dot = vectordot( up, worldup );
+    offset1 = ( 0, 0, 0 );
+    offset2 = up * vectorscale( ( 0, 0, 1 ), 44.0 );
+
+    if ( dot < 0.5 )
+    {
+        offset1 = up * vectorscale( ( 0, 0, 1 ), 22.0 ) - vectorscale( ( 0, 0, 1 ), 30.0 );
+        offset2 = up * vectorscale( ( 0, 0, 1 ), 22.0 ) + vectorscale( ( 0, 0, 1 ), 14.0 );
+    }
+
+    while ( self.health > 0 )
+    {
+        if ( !startedfx )
+        {
+            playfx( level.breakables_fx["ammo_crate"]["burn_start"], self.origin );
+            level thread play_sound_in_space( level.crateignsound, self.origin );
+            startedfx = 1;
+        }
+
+        if ( count > 20 )
+            count = 0;
+
+        playfx( level.breakables_fx["ammo_crate"]["burn"], self.origin );
+
+        if ( count == 0 )
+            self.health -= 10 + randomint( 10 );
+
+        count++;
+        wait 0.05;
+    }
+
+    self thread flammable_crate_explode();
+}
+
+flammable_crate_explode()
+{
+    self notify( "exploding" );
+    self death_notify_wrapper();
+    up = anglestoup( vectorscale( ( 0, 1, 0 ), 90.0 ) );
+    worldup = anglestoup( vectorscale( ( 0, 1, 0 ), 90.0 ) );
+    dot = vectordot( up, worldup );
+    offset = ( 0, 0, 0 );
+
+    if ( dot < 0.5 )
+    {
+        start = self.origin + vectorscale( up, 22 );
+        trace = physicstrace( start, start + vectorscale( ( 0, 0, -1 ), 64.0 ) );
+        end = trace["position"];
+        offset = end - self.origin;
+    }
+
+    offset += vectorscale( ( 0, 0, 1 ), 4.0 );
+    mindamage = 1;
+    maxdamage = 250;
+    blastradius = 250;
+    level thread play_sound_in_space( level.crateexpsound, self.origin );
+    playfx( level.breakables_fx["ammo_crate"]["explode"], self.origin );
+    physicsexplosionsphere( self.origin + offset, 100, 80, 1, maxdamage, mindamage );
+    level.barrelexplodingthisframe = 1;
+
+    if ( isdefined( self.remove ) )
+        self.remove delete();
+
+    if ( isdefined( self.radius ) )
+        blastradius = self.radius;
+
+    attacker = undefined;
+
+    if ( isdefined( self.damageowner ) )
+        attacker = self.damageowner;
+
+    self radiusdamage( self.origin + vectorscale( ( 0, 0, 1 ), 30.0 ), blastradius, maxdamage, mindamage, attacker );
+    self setmodel( "global_flammable_crate_jap_piece01_d" );
+
+    if ( dot < 0.5 )
+    {
+        start = self.origin + vectorscale( up, 22 );
+        trace = physicstrace( start, start + vectorscale( ( 0, 0, -1 ), 64.0 ) );
+        pos = trace["position"];
+        self.origin = pos;
+        self.angles += vectorscale( ( 0, 0, 1 ), 90.0 );
+    }
+
+    wait 0.05;
+    level.barrelexplodingthisframe = 0;
+}
+
+breakable_clip()
+{
+    if ( isdefined( self.target ) )
+    {
+        targ = getent( self.target, "targetname" );
+
+        if ( targ.classname == "script_brushmodel" )
+        {
+            self.remove = targ;
+            return;
+        }
+    }
+
+    if ( isdefined( level.breakables_clip ) && level.breakables_clip.size > 0 )
+        self.remove = getclosestent( self.origin, level.breakables_clip );
+
+    if ( isdefined( self.remove ) )
+        arrayremovevalue( level.breakables_clip, self.remove );
+}
+
+getclosestent( org, array )
+{
+    if ( array.size < 1 )
+        return;
+
+    dist = 256;
+    ent = undefined;
+
+    for ( i = 0; i < array.size; i++ )
+    {
+        newdist = distance( array[i] getorigin(), org );
+
+        if ( newdist >= dist )
+            continue;
+
+        dist = newdist;
+        ent = array[i];
+    }
+
+    return ent;
+}

ZM/Core/maps/mp/_music.gsc

@@ -0,0 +1,26 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+
+music_init()
+{
+    assert( level.clientscripts );
+    level.musicstate = "";
+    registerclientsys( "musicCmd" );
+}
+
+setmusicstate( state, player )
+{
+    if ( isdefined( level.musicstate ) )
+    {
+        if ( isdefined( player ) )
+        {
+            setclientsysstate( "musicCmd", state, player );
+            return;
+        }
+        else if ( level.musicstate != state )
+            setclientsysstate( "musicCmd", state );
+    }
+
+    level.musicstate = state;
+}

ZM/Core/maps/mp/_script_gen.gsc

@@ -0,0 +1,290 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\_script_gen;
+
+script_gen_dump_checksaved()
+{
+    signatures = getarraykeys( level.script_gen_dump );
+
+    for ( i = 0; i < signatures.size; i++ )
+    {
+        if ( !isdefined( level.script_gen_dump2[signatures[i]] ) )
+        {
+            level.script_gen_dump[signatures[i]] = undefined;
+            level.script_gen_dump_reasons[level.script_gen_dump_reasons.size] = "Signature unmatched( removed feature ): " + signatures[i];
+        }
+    }
+}
+
+script_gen_dump()
+{
+/#
+    script_gen_dump_checksaved();
+
+    if ( !level.script_gen_dump_reasons.size )
+    {
+        flag_set( "scriptgen_done" );
+        return;
+    }
+
+    firstrun = 0;
+
+    if ( level.bscriptgened )
+    {
+        println( " " );
+        println( " " );
+        println( " " );
+        println( "^2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- " );
+        println( "^3Dumping scriptgen dump for these reasons" );
+        println( "^2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- " );
+
+        for ( i = 0; i < level.script_gen_dump_reasons.size; i++ )
+        {
+            if ( issubstr( level.script_gen_dump_reasons[i], "nowrite" ) )
+            {
+                substr = getsubstr( level.script_gen_dump_reasons[i], 15 );
+                println( i + ". ) " + substr );
+            }
+            else
+                println( i + ". ) " + level.script_gen_dump_reasons[i] );
+
+            if ( level.script_gen_dump_reasons[i] == "First run" )
+                firstrun = 1;
+        }
+
+        println( "^2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- " );
+        println( " " );
+
+        if ( firstrun )
+        {
+            println( "for First Run make sure you delete all of the vehicle precache script calls, createart calls, createfx calls( most commonly placed in maps\\" + level.script + "_fx.gsc ) " );
+            println( " " );
+            println( "replace:" );
+            println( "maps\\_load::main( 1 );" );
+            println( " " );
+            println( "with( don't forget to add this file to P4 ):" );
+            println( "maps\\scriptgen\\" + level.script + "_scriptgen::main();" );
+            println( " " );
+        }
+
+        println( "^2 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- " );
+        println( " " );
+        println( "^2 / \\ / \\ / \\" );
+        println( "^2scroll up" );
+        println( "^2 / \\ / \\ / \\" );
+        println( " " );
+    }
+    else
+        return;
+
+    filename = "scriptgen/" + level.script + "_scriptgen.gsc";
+    csvfilename = "zone_source/" + level.script + ".csv";
+
+    if ( level.bscriptgened )
+        file = openfile( filename, "write" );
+    else
+        file = 0;
+
+    assert( file != -1, "File not writeable( check it and and restart the map ): " + filename );
+    script_gen_dumpprintln( file, "// script generated script do not write your own script here it will go away if you do." );
+    script_gen_dumpprintln( file, "main()" );
+    script_gen_dumpprintln( file, "{" );
+    script_gen_dumpprintln( file, "" );
+    script_gen_dumpprintln( file, "\\tlevel.script_gen_dump = [];" );
+    script_gen_dumpprintln( file, "" );
+    signatures = getarraykeys( level.script_gen_dump );
+
+    for ( i = 0; i < signatures.size; i++ )
+    {
+        if ( !issubstr( level.script_gen_dump[signatures[i]], "nowrite" ) )
+            script_gen_dumpprintln( file, "\\t" + level.script_gen_dump[signatures[i]] );
+    }
+
+    for ( i = 0; i < signatures.size; i++ )
+    {
+        if ( !issubstr( level.script_gen_dump[signatures[i]], "nowrite" ) )
+        {
+            script_gen_dumpprintln( file, "\\tlevel.script_gen_dump[ " + "\"" + signatures[i] + "\"" + " ] = " + "\"" + signatures[i] + "\"" + ";" );
+            continue;
+        }
+
+        script_gen_dumpprintln( file, "\\tlevel.script_gen_dump[ " + "\"" + signatures[i] + "\"" + " ] = " + "\"nowrite\"" + ";" );
+    }
+
+    script_gen_dumpprintln( file, "" );
+    keys1 = undefined;
+    keys2 = undefined;
+
+    if ( isdefined( level.sg_precacheanims ) )
+        keys1 = getarraykeys( level.sg_precacheanims );
+
+    if ( isdefined( keys1 ) )
+    {
+        for ( i = 0; i < keys1.size; i++ )
+            script_gen_dumpprintln( file, "\\tanim_precach_" + keys1[i] + "();" );
+    }
+
+    script_gen_dumpprintln( file, "\\tmaps\\_load::main( 1, " + level.bcsvgened + ", 1 );" );
+    script_gen_dumpprintln( file, "}" );
+    script_gen_dumpprintln( file, "" );
+
+    if ( isdefined( level.sg_precacheanims ) )
+        keys1 = getarraykeys( level.sg_precacheanims );
+
+    if ( isdefined( keys1 ) )
+    {
+        for ( i = 0; i < keys1.size; i++ )
+        {
+            script_gen_dumpprintln( file, "#using_animtree( \"" + keys1[i] + "\" );" );
+            script_gen_dumpprintln( file, "anim_precach_" + keys1[i] + "()" );
+            script_gen_dumpprintln( file, "{" );
+            script_gen_dumpprintln( file, "\\tlevel.sg_animtree[ \"" + keys1[i] + "\" ] = #animtree;" );
+            keys2 = getarraykeys( level.sg_precacheanims[keys1[i]] );
+
+            if ( isdefined( keys2 ) )
+            {
+                for ( j = 0; j < keys2.size; j++ )
+                    script_gen_dumpprintln( file, "\\tlevel.sg_anim[ \"" + keys2[j] + "\" ] = %" + keys2[j] + ";" );
+            }
+
+            script_gen_dumpprintln( file, "}" );
+            script_gen_dumpprintln( file, "" );
+        }
+    }
+
+    if ( level.bscriptgened )
+        saved = closefile( file );
+    else
+        saved = 1;
+
+    if ( level.bcsvgened )
+        csvfile = openfile( csvfilename, "write" );
+    else
+        csvfile = 0;
+
+    assert( csvfile != -1, "File not writeable( check it and and restart the map ): " + csvfilename );
+    signatures = getarraykeys( level.script_gen_dump );
+
+    for ( i = 0; i < signatures.size; i++ )
+        script_gen_csvdumpprintln( csvfile, signatures[i] );
+
+    if ( level.bcsvgened )
+        csvfilesaved = closefile( csvfile );
+    else
+        csvfilesaved = 1;
+
+    assert( csvfilesaved == 1, "csv not saved( see above message? ): " + csvfilename );
+    assert( saved == 1, "map not saved( see above message? ): " + filename );
+#/
+    assert( !level.bscriptgened, "SCRIPTGEN generated: follow instructions listed above this error in the console" );
+
+    if ( level.bscriptgened )
+    {
+/#
+        assertmsg( "SCRIPTGEN updated: Rebuild fast file and run map again" );
+#/
+    }
+
+    flag_set( "scriptgen_done" );
+}
+
+script_gen_csvdumpprintln( file, signature )
+{
+    prefix = undefined;
+    writtenprefix = undefined;
+    path = "";
+    extension = "";
+
+    if ( issubstr( signature, "ignore" ) )
+        prefix = "ignore";
+    else if ( issubstr( signature, "col_map_sp" ) )
+        prefix = "col_map_sp";
+    else if ( issubstr( signature, "gfx_map" ) )
+        prefix = "gfx_map";
+    else if ( issubstr( signature, "rawfile" ) )
+        prefix = "rawfile";
+    else if ( issubstr( signature, "sound" ) )
+        prefix = "sound";
+    else if ( issubstr( signature, "xmodel" ) )
+        prefix = "xmodel";
+    else if ( issubstr( signature, "xanim" ) )
+        prefix = "xanim";
+    else if ( issubstr( signature, "item" ) )
+    {
+        prefix = "item";
+        writtenprefix = "weapon";
+        path = "sp/";
+    }
+    else if ( issubstr( signature, "fx" ) )
+        prefix = "fx";
+    else if ( issubstr( signature, "menu" ) )
+    {
+        prefix = "menu";
+        writtenprefix = "menufile";
+        path = "ui / scriptmenus/";
+        extension = ".menu";
+    }
+    else if ( issubstr( signature, "rumble" ) )
+    {
+        prefix = "rumble";
+        writtenprefix = "rawfile";
+        path = "rumble/";
+    }
+    else if ( issubstr( signature, "shader" ) )
+    {
+        prefix = "shader";
+        writtenprefix = "material";
+    }
+    else if ( issubstr( signature, "shock" ) )
+    {
+        prefix = "shock";
+        writtenprefix = "rawfile";
+        extension = ".shock";
+        path = "shock/";
+    }
+    else if ( issubstr( signature, "string" ) )
+    {
+        prefix = "string";
+/#
+        assertmsg( "string not yet supported by scriptgen" );
+#/
+    }
+    else if ( issubstr( signature, "turret" ) )
+    {
+        prefix = "turret";
+        writtenprefix = "weapon";
+        path = "sp/";
+    }
+    else if ( issubstr( signature, "vehicle" ) )
+    {
+        prefix = "vehicle";
+        writtenprefix = "rawfile";
+        path = "vehicles/";
+    }
+
+    if ( !isdefined( prefix ) )
+        return;
+
+    if ( !isdefined( writtenprefix ) )
+        string = prefix + ", " + getsubstr( signature, prefix.size + 1, signature.size );
+    else
+        string = writtenprefix + ", " + path + getsubstr( signature, prefix.size + 1, signature.size ) + extension;
+/#
+    if ( file == -1 || !level.bcsvgened )
+        println( string );
+    else
+        fprintln( file, string );
+#/
+}
+
+script_gen_dumpprintln( file, string )
+{
+/#
+    if ( file == -1 || !level.bscriptgened )
+        println( string );
+    else
+        fprintln( file, string );
+#/
+}

ZM/Core/maps/mp/_serverfaceanim_mp.gsc

@@ -0,0 +1,61 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include common_scripts\utility;
+
+init()
+{
+    for (;;)
+    {
+        level waittill( "connecting", player );
+
+        player thread onplayerspawned();
+    }
+}
+
+onplayerspawned()
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "spawned_player" );
+
+        self thread init_serverfaceanim();
+    }
+}
+
+init_serverfaceanim()
+{
+    self.do_face_anims = 1;
+
+    if ( !isdefined( level.face_event_handler ) )
+    {
+        level.face_event_handler = spawnstruct();
+        level.face_event_handler.events = [];
+        level.face_event_handler.events["death"] = "face_death";
+        level.face_event_handler.events["grenade danger"] = "face_alert";
+        level.face_event_handler.events["bulletwhizby"] = "face_alert";
+        level.face_event_handler.events["projectile_impact"] = "face_alert";
+        level.face_event_handler.events["explode"] = "face_alert";
+        level.face_event_handler.events["alert"] = "face_alert";
+        level.face_event_handler.events["shoot"] = "face_shoot_single";
+        level.face_event_handler.events["melee"] = "face_melee";
+        level.face_event_handler.events["damage"] = "face_pain";
+        level thread wait_for_face_event();
+    }
+}
+
+wait_for_face_event()
+{
+    while ( true )
+    {
+        level waittill( "face", face_notify, ent );
+
+        if ( isdefined( ent ) && isdefined( ent.do_face_anims ) && ent.do_face_anims )
+        {
+            if ( isdefined( level.face_event_handler.events[face_notify] ) )
+                ent sendfaceevent( level.face_event_handler.events[face_notify] );
+        }
+    }
+}

ZM/Core/maps/mp/_sticky_grenade.gsc

@@ -0,0 +1,15 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include common_scripts\utility;
+
+init()
+{
+    loadfx( "weapon/crossbow/fx_trail_crossbow_blink_grn_os" );
+    loadfx( "weapon/crossbow/fx_trail_crossbow_blink_red_os" );
+}
+
+watch_bolt_detonation( owner )
+{
+
+}

ZM/Core/maps/mp/_visionset_mgr.gsc

@@ -0,0 +1,445 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+
+init()
+{
+    if ( level.createfx_enabled )
+        return;
+
+    level.vsmgr_initializing = 1;
+    level.vsmgr_default_info_name = "none";
+    level.vsmgr = [];
+    level thread register_type( "visionset" );
+    level thread register_type( "overlay" );
+    onfinalizeinitialization_callback( ::finalize_clientfields );
+    level thread monitor();
+    level thread onplayerconnect();
+}
+
+vsmgr_register_info( type, name, version, priority, lerp_step_count, activate_per_player, lerp_thread, ref_count_lerp_thread )
+{
+    if ( level.createfx_enabled )
+        return;
+
+    assert( level.vsmgr_initializing, "All info registration in the visionset_mgr system must occur during the first frame while the system is initializing" );
+    lower_name = tolower( name );
+    validate_info( type, lower_name, priority );
+    add_sorted_name_key( type, lower_name );
+    add_sorted_priority_key( type, lower_name, priority );
+    level.vsmgr[type].info[lower_name] = spawnstruct();
+    level.vsmgr[type].info[lower_name] add_info( type, lower_name, version, priority, lerp_step_count, activate_per_player, lerp_thread, ref_count_lerp_thread );
+
+    if ( level.vsmgr[type].highest_version < version )
+        level.vsmgr[type].highest_version = version;
+}
+
+vsmgr_activate( type, name, player, opt_param_1, opt_param_2 )
+{
+    if ( level.vsmgr[type].info[name].state.activate_per_player )
+    {
+        activate_per_player( type, name, player, opt_param_1, opt_param_2 );
+        return;
+    }
+
+    state = level.vsmgr[type].info[name].state;
+
+    if ( state.ref_count_lerp_thread )
+    {
+        state.ref_count++;
+
+        if ( 1 < state.ref_count )
+            return;
+    }
+
+    if ( isdefined( state.lerp_thread ) )
+        state thread lerp_thread_wrapper( state.lerp_thread, opt_param_1, opt_param_2 );
+    else
+    {
+        players = getplayers();
+
+        for ( player_index = 0; player_index < players.size; player_index++ )
+            state vsmgr_set_state_active( players[player_index], 1 );
+    }
+}
+
+vsmgr_deactivate( type, name, player )
+{
+    if ( level.vsmgr[type].info[name].state.activate_per_player )
+    {
+        deactivate_per_player( type, name, player );
+        return;
+    }
+
+    state = level.vsmgr[type].info[name].state;
+
+    if ( state.ref_count_lerp_thread )
+    {
+        state.ref_count--;
+
+        if ( 0 < state.ref_count )
+            return;
+    }
+
+    state notify( "deactivate" );
+    players = getplayers();
+
+    for ( player_index = 0; player_index < players.size; player_index++ )
+        state vsmgr_set_state_inactive( players[player_index] );
+}
+
+vsmgr_set_state_active( player, lerp )
+{
+    player_entnum = player getentitynumber();
+
+    if ( !isdefined( self.players[player_entnum] ) )
+        return;
+
+    self.players[player_entnum].active = 1;
+    self.players[player_entnum].lerp = lerp;
+}
+
+vsmgr_set_state_inactive( player )
+{
+    player_entnum = player getentitynumber();
+
+    if ( !isdefined( self.players[player_entnum] ) )
+        return;
+
+    self.players[player_entnum].active = 0;
+    self.players[player_entnum].lerp = 0;
+}
+
+vsmgr_timeout_lerp_thread( timeout, opt_param_2 )
+{
+    players = getplayers();
+
+    for ( player_index = 0; player_index < players.size; player_index++ )
+        self vsmgr_set_state_active( players[player_index], 1 );
+
+    wait( timeout );
+    vsmgr_deactivate( self.type, self.name );
+}
+
+vsmgr_timeout_lerp_thread_per_player( player, timeout, opt_param_2 )
+{
+    self vsmgr_set_state_active( player, 1 );
+    wait( timeout );
+    deactivate_per_player( self.type, self.name, player );
+}
+
+vsmgr_duration_lerp_thread( duration, max_duration )
+{
+    start_time = gettime();
+    end_time = start_time + int( duration * 1000 );
+
+    if ( isdefined( max_duration ) )
+        start_time = end_time - int( max_duration * 1000 );
+
+    while ( true )
+    {
+        lerp = calc_remaining_duration_lerp( start_time, end_time );
+
+        if ( 0 >= lerp )
+            break;
+
+        players = getplayers();
+
+        for ( player_index = 0; player_index < players.size; player_index++ )
+            self vsmgr_set_state_active( players[player_index], lerp );
+
+        wait 0.05;
+    }
+
+    vsmgr_deactivate( self.type, self.name );
+}
+
+vsmgr_duration_lerp_thread_per_player( player, duration, max_duration )
+{
+    start_time = gettime();
+    end_time = start_time + int( duration * 1000 );
+
+    if ( isdefined( max_duration ) )
+        start_time = end_time - int( max_duration * 1000 );
+
+    while ( true )
+    {
+        lerp = calc_remaining_duration_lerp( start_time, end_time );
+
+        if ( 0 >= lerp )
+            break;
+
+        self vsmgr_set_state_active( player, lerp );
+        wait 0.05;
+    }
+
+    deactivate_per_player( self.type, self.name, player );
+}
+
+register_type( type )
+{
+    level.vsmgr[type] = spawnstruct();
+    level.vsmgr[type].type = type;
+    level.vsmgr[type].in_use = 0;
+    level.vsmgr[type].highest_version = 0;
+    level.vsmgr[type].cf_slot_name = type + "_slot";
+    level.vsmgr[type].cf_lerp_name = type + "_lerp";
+    level.vsmgr[type].info = [];
+    level.vsmgr[type].sorted_name_keys = [];
+    level.vsmgr[type].sorted_prio_keys = [];
+    vsmgr_register_info( type, level.vsmgr_default_info_name, 1, 0, 1, 0, undefined );
+}
+
+finalize_clientfields()
+{
+    typekeys = getarraykeys( level.vsmgr );
+
+    for ( type_index = 0; type_index < typekeys.size; type_index++ )
+        level.vsmgr[typekeys[type_index]] thread finalize_type_clientfields();
+
+    level.vsmgr_initializing = 0;
+}
+
+finalize_type_clientfields()
+{
+    if ( 1 >= self.info.size )
+        return;
+
+    self.in_use = 1;
+    self.cf_slot_bit_count = getminbitcountfornum( self.info.size - 1 );
+    self.cf_lerp_bit_count = self.info[self.sorted_name_keys[0]].lerp_bit_count;
+
+    for ( i = 0; i < self.sorted_name_keys.size; i++ )
+    {
+        self.info[self.sorted_name_keys[i]].slot_index = i;
+
+        if ( self.info[self.sorted_name_keys[i]].lerp_bit_count > self.cf_lerp_bit_count )
+            self.cf_lerp_bit_count = self.info[self.sorted_name_keys[i]].lerp_bit_count;
+    }
+
+    registerclientfield( "toplayer", self.cf_slot_name, self.highest_version, self.cf_slot_bit_count, "int" );
+
+    if ( 1 < self.cf_lerp_bit_count )
+        registerclientfield( "toplayer", self.cf_lerp_name, self.highest_version, self.cf_lerp_bit_count, "float" );
+}
+
+validate_info( type, name, priority )
+{
+    keys = getarraykeys( level.vsmgr );
+
+    for ( i = 0; i < keys.size; i++ )
+    {
+        if ( type == keys[i] )
+            break;
+    }
+
+    assert( i < keys.size, "In visionset_mgr, type '" + type + "'is unknown" );
+    keys = getarraykeys( level.vsmgr[type].info );
+
+    for ( i = 0; i < keys.size; i++ )
+    {
+        assert( level.vsmgr[type].info[keys[i]].name != name, "In visionset_mgr of type '" + type + "': name '" + name + "' has previously been registered" );
+        assert( level.vsmgr[type].info[keys[i]].priority != priority, "In visionset_mgr of type '" + type + "': priority '" + priority + "' requested for name '" + name + "' has previously been registered under name '" + level.vsmgr[type].info[keys[i]].name + "'" );
+    }
+}
+
+add_sorted_name_key( type, name )
+{
+    for ( i = 0; i < level.vsmgr[type].sorted_name_keys.size; i++ )
+    {
+        if ( name < level.vsmgr[type].sorted_name_keys[i] )
+            break;
+    }
+
+    arrayinsert( level.vsmgr[type].sorted_name_keys, name, i );
+}
+
+add_sorted_priority_key( type, name, priority )
+{
+    for ( i = 0; i < level.vsmgr[type].sorted_prio_keys.size; i++ )
+    {
+        if ( priority > level.vsmgr[type].info[level.vsmgr[type].sorted_prio_keys[i]].priority )
+            break;
+    }
+
+    arrayinsert( level.vsmgr[type].sorted_prio_keys, name, i );
+}
+
+add_info( type, name, version, priority, lerp_step_count, activate_per_player, lerp_thread, ref_count_lerp_thread )
+{
+    self.type = type;
+    self.name = name;
+    self.version = version;
+    self.priority = priority;
+    self.lerp_step_count = lerp_step_count;
+    self.lerp_bit_count = getminbitcountfornum( lerp_step_count );
+
+    if ( !isdefined( ref_count_lerp_thread ) )
+        ref_count_lerp_thread = 0;
+
+    self.state = spawnstruct();
+    self.state.type = type;
+    self.state.name = name;
+    self.state.activate_per_player = activate_per_player;
+    self.state.lerp_thread = lerp_thread;
+    self.state.ref_count_lerp_thread = ref_count_lerp_thread;
+    self.state.players = [];
+
+    if ( ref_count_lerp_thread && !activate_per_player )
+        self.state.ref_count = 0;
+}
+
+onplayerconnect()
+{
+    for (;;)
+    {
+        level waittill( "connected", player );
+
+        player thread on_player_connect();
+    }
+}
+
+on_player_connect()
+{
+    self._player_entnum = self getentitynumber();
+    typekeys = getarraykeys( level.vsmgr );
+
+    for ( type_index = 0; type_index < typekeys.size; type_index++ )
+    {
+        type = typekeys[type_index];
+
+        if ( !level.vsmgr[type].in_use )
+            continue;
+
+        for ( name_index = 0; name_index < level.vsmgr[type].sorted_name_keys.size; name_index++ )
+        {
+            name_key = level.vsmgr[type].sorted_name_keys[name_index];
+            level.vsmgr[type].info[name_key].state.players[self._player_entnum] = spawnstruct();
+            level.vsmgr[type].info[name_key].state.players[self._player_entnum].active = 0;
+            level.vsmgr[type].info[name_key].state.players[self._player_entnum].lerp = 0;
+
+            if ( level.vsmgr[type].info[name_key].state.ref_count_lerp_thread && level.vsmgr[type].info[name_key].state.activate_per_player )
+                level.vsmgr[type].info[name_key].state.players[self._player_entnum].ref_count = 0;
+        }
+
+        level.vsmgr[type].info[level.vsmgr_default_info_name].state vsmgr_set_state_active( self, 1 );
+    }
+}
+
+monitor()
+{
+    while ( level.vsmgr_initializing )
+        wait 0.05;
+
+    typekeys = getarraykeys( level.vsmgr );
+
+    while ( true )
+    {
+        wait 0.05;
+        waittillframeend;
+        players = get_players();
+
+        for ( type_index = 0; type_index < typekeys.size; type_index++ )
+        {
+            type = typekeys[type_index];
+
+            if ( !level.vsmgr[type].in_use )
+                continue;
+
+            for ( player_index = 0; player_index < players.size; player_index++ )
+            {
+/#
+                if ( is_true( players[player_index].pers["isBot"] ) )
+                    continue;
+#/
+                update_clientfields( players[player_index], level.vsmgr[type] );
+            }
+        }
+    }
+}
+
+get_first_active_name( type_struct )
+{
+    size = type_struct.sorted_prio_keys.size;
+
+    for ( prio_index = 0; prio_index < size; prio_index++ )
+    {
+        prio_key = type_struct.sorted_prio_keys[prio_index];
+
+        if ( type_struct.info[prio_key].state.players[self._player_entnum].active )
+            return prio_key;
+    }
+
+    return level.vsmgr_default_info_name;
+}
+
+update_clientfields( player, type_struct )
+{
+    name = player get_first_active_name( type_struct );
+    player setclientfieldtoplayer( type_struct.cf_slot_name, type_struct.info[name].slot_index );
+
+    if ( 1 < type_struct.cf_lerp_bit_count )
+        player setclientfieldtoplayer( type_struct.cf_lerp_name, type_struct.info[name].state.players[player._player_entnum].lerp );
+}
+
+lerp_thread_wrapper( func, opt_param_1, opt_param_2 )
+{
+    self notify( "deactivate" );
+    self endon( "deactivate" );
+    self [[ func ]]( opt_param_1, opt_param_2 );
+}
+
+lerp_thread_per_player_wrapper( func, player, opt_param_1, opt_param_2 )
+{
+    player_entnum = player getentitynumber();
+    self notify( "deactivate" );
+    self endon( "deactivate" );
+    self.players[player_entnum] notify( "deactivate" );
+    self.players[player_entnum] endon( "deactivate" );
+    player endon( "disconnect" );
+    self [[ func ]]( player, opt_param_1, opt_param_2 );
+}
+
+activate_per_player( type, name, player, opt_param_1, opt_param_2 )
+{
+    player_entnum = player getentitynumber();
+    state = level.vsmgr[type].info[name].state;
+
+    if ( state.ref_count_lerp_thread )
+    {
+        state.players[player_entnum].ref_count++;
+
+        if ( 1 < state.players[player_entnum].ref_count )
+            return;
+    }
+
+    if ( isdefined( state.lerp_thread ) )
+        state thread lerp_thread_per_player_wrapper( state.lerp_thread, player, opt_param_1, opt_param_2 );
+    else
+        state vsmgr_set_state_active( player, 1 );
+}
+
+deactivate_per_player( type, name, player )
+{
+    player_entnum = player getentitynumber();
+    state = level.vsmgr[type].info[name].state;
+
+    if ( state.ref_count_lerp_thread )
+    {
+        state.players[player_entnum].ref_count--;
+
+        if ( 0 < state.players[player_entnum].ref_count )
+            return;
+    }
+
+    state vsmgr_set_state_inactive( player );
+    state notify( "deactivate" );
+}
+
+calc_remaining_duration_lerp( start_time, end_time )
+{
+    now = gettime();
+    frac = float( end_time - now ) / float( end_time - start_time );
+    return clamp( frac, 0, 1 );
+}

ZM/Core/maps/mp/animscripts/dog_combat.gsc

@@ -0,0 +1,105 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+
+main()
+{
+    debug_anim_print( "dog_combat::main() " );
+    self endon( "killanimscript" );
+    self setaimanimweights( 0, 0 );
+/#
+    if ( !debug_allow_combat() )
+    {
+        combatidle();
+        return;
+    }
+#/
+    if ( isdefined( level.hostmigrationtimer ) )
+    {
+        combatidle();
+        return;
+    }
+
+    assert( isdefined( self.enemy ) );
+
+    if ( !isalive( self.enemy ) )
+    {
+        combatidle();
+        return;
+    }
+
+    if ( isplayer( self.enemy ) )
+        self meleebiteattackplayer( self.enemy );
+}
+
+combatidle()
+{
+    self set_orient_mode( "face enemy" );
+    self animmode( "zonly_physics", 0 );
+    idleanims = [];
+    idleanims[0] = "combat_attackidle";
+    idleanims[1] = "combat_attackidle_bark";
+    idleanims[2] = "combat_attackidle_growl";
+    idleanim = random( idleanims );
+    debug_anim_print( "dog_combat::combatIdle() - Setting " + idleanim );
+    self setanimstate( idleanim );
+    self maps\mp\animscripts\shared::donotetracks( "done" );
+    debug_anim_print( "dog_combat::combatIdle() - " + idleanim + " notify done." );
+}
+
+meleebiteattackplayer( player )
+{
+    self set_orient_mode( "face enemy" );
+    self animmode( "gravity", 0 );
+    self.safetochangescript = 0;
+
+    if ( use_low_attack() )
+    {
+        self animmode( "angle deltas", 0 );
+        self setanimstate( "combat_attack_player_close_range" );
+        wait 0.35;
+
+        if ( isplayer( self.enemy ) && self.enemy getstance() == "prone" )
+            self meleewithoffset( vectorscale( ( 0, 0, -1 ), 9.0 ) );
+        else
+            self melee();
+
+        self maps\mp\animscripts\shared::donotetracksfortime( 1.2, "done" );
+        self animmode( "gravity", 0 );
+    }
+    else
+    {
+        attack_time = 1.2 + randomfloat( 0.4 );
+        debug_anim_print( "dog_combat::meleeBiteAttackPlayer() - Setting  combat_run_attack" );
+        self setanimstate( "combat_attack_run" );
+        self maps\mp\animscripts\shared::donotetracksfortime( attack_time, "done", ::handlemeleebiteattacknotetracks, player );
+        debug_anim_print( "dog_combat::meleeBiteAttackPlayer() - combat_attack_run notify done." );
+    }
+
+    self.safetochangescript = 1;
+    self animmode( "none", 0 );
+}
+
+handlemeleebiteattacknotetracks( note, player )
+{
+    if ( note == "dog_melee" )
+        self melee( anglestoforward( self.angles ) );
+}
+
+use_low_attack()
+{
+    if ( isplayer( self.enemy ) )
+    {
+        if ( self.enemy getstance() == "prone" )
+        {
+            attack_height = self.origin[2] + 16;
+
+            if ( self.enemy.origin[2] < attack_height )
+                return true;
+        }
+    }
+
+    return false;
+}

ZM/Core/maps/mp/animscripts/dog_death.gsc

@@ -0,0 +1,32 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\shared;
+
+main()
+{
+    debug_anim_print( "dog_death::main()" );
+    self setaimanimweights( 0, 0 );
+    self endon( "killanimscript" );
+
+    if ( isdefined( self.a.nodeath ) )
+    {
+        assert( self.a.nodeath, "Nodeath needs to be set to true or undefined." );
+        wait 3;
+        return;
+    }
+
+    self unlink();
+
+    if ( isdefined( self.enemy ) && isdefined( self.enemy.syncedmeleetarget ) && self.enemy.syncedmeleetarget == self )
+        self.enemy.syncedmeleetarget = undefined;
+
+    death_anim = "death_" + getanimdirection( self.damageyaw );
+/#
+    println( death_anim );
+#/
+    self animmode( "gravity", 0 );
+    debug_anim_print( "dog_death::main() - Setting " + death_anim );
+    self setanimstate( death_anim );
+    self maps\mp\animscripts\shared::donotetracks( "done" );
+}

ZM/Core/maps/mp/animscripts/dog_flashed.gsc

@@ -0,0 +1,28 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\shared;
+
+main()
+{
+    self endon( "killanimscript" );
+    self endon( "stop_flashbang_effect" );
+    wait( randomfloatrange( 0, 0.4 ) );
+    duration = self startflashbanged() * 0.001;
+    self setanimstate( "flashed" );
+    self maps\mp\animscripts\shared::donotetracks( "done" );
+    self setflashbanged( 0 );
+    self.flashed = 0;
+    self notify( "stop_flashbang_effect" );
+}
+
+startflashbanged()
+{
+    if ( isdefined( self.flashduration ) )
+        duration = self.flashduration;
+    else
+        duration = self getflashbangedstrength() * 1000;
+
+    self.flashendtime = gettime() + duration;
+    self notify( "flashed" );
+    return duration;
+}

ZM/Core/maps/mp/animscripts/dog_init.gsc

@@ -0,0 +1,64 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\dog_move;
+#include maps\mp\animscripts\dog_combat;
+
+main()
+{
+    level.dog_debug_orient = 0;
+    level.dog_debug_anims = 0;
+    level.dog_debug_anims_ent = 0;
+    level.dog_debug_turns = 0;
+    debug_anim_print( "dog_init::main() " );
+    maps\mp\animscripts\dog_move::setup_sound_variables();
+    anim_get_dvar_int( "debug_dog_sound", "0" );
+    anim_get_dvar_int( "debug_dog_notetracks", "0" );
+    anim_get_dvar_int( "dog_force_walk", 0 );
+    anim_get_dvar_int( "dog_force_run", 0 );
+    self.ignoresuppression = 1;
+    self.chatinitialized = 0;
+    self.nododgemove = 1;
+    level.dogrunturnspeed = 20;
+    level.dogrunpainspeed = 20;
+    self.meleeattackdist = 0;
+    self thread setmeleeattackdist();
+    self.a = spawnstruct();
+    self.a.pose = "stand";
+    self.a.nextstandinghitdying = 0;
+    self.a.movement = "run";
+    set_anim_playback_rate();
+    self.suppressionthreshold = 1;
+    self.disablearrivals = 0;
+    level.dogstoppingdistsq = 3416.82;
+    self.stopanimdistsq = level.dogstoppingdistsq;
+    self.pathenemyfightdist = 512;
+    self settalktospecies( "dog" );
+    level.lastdogmeleeplayertime = 0;
+    level.dogmeleeplayercounter = 0;
+
+    if ( !isdefined( level.dog_hits_before_kill ) )
+        level.dog_hits_before_kill = 1;
+}
+
+set_anim_playback_rate()
+{
+    self.animplaybackrate = 0.9 + randomfloat( 0.2 );
+    self.moveplaybackrate = 1;
+}
+
+setmeleeattackdist()
+{
+    self endon( "death" );
+
+    while ( true )
+    {
+        self.meleeattackdist = 0;
+
+        if ( self maps\mp\animscripts\dog_combat::use_low_attack() )
+            self.meleeattackdist = 64;
+
+        wait 1;
+    }
+}

ZM/Core/maps/mp/animscripts/dog_jump.gsc

@@ -0,0 +1,15 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\shared;
+
+main()
+{
+    self endon( "killanimscript" );
+    debug_anim_print( "dog_jump::main()" );
+    self setaimanimweights( 0, 0 );
+    self.safetochangescript = 0;
+    self setanimstate( "traverse_wallhop" );
+    maps\mp\animscripts\shared::donotetracks( "done" );
+    self.safetochangescript = 1;
+}

ZM/Core/maps/mp/animscripts/dog_move.gsc

@@ -0,0 +1,173 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\dog_stop;
+
+setup_sound_variables()
+{
+    level.dog_sounds["far"] = spawnstruct();
+    level.dog_sounds["close"] = spawnstruct();
+    level.dog_sounds["close"].minrange = 0;
+    level.dog_sounds["close"].maxrange = 500;
+    level.dog_sounds["close"].sound = "aml_dog_bark_close";
+    level.dog_sounds["close"].soundlengthplaceholder = 0.2;
+    level.dog_sounds["close"].aftersoundwaitmin = 0.1;
+    level.dog_sounds["close"].aftersoundwaitmax = 0.3;
+    level.dog_sounds["close"].minrangesqr = level.dog_sounds["close"].minrange * level.dog_sounds["close"].minrange;
+    level.dog_sounds["close"].maxrangesqr = level.dog_sounds["close"].maxrange * level.dog_sounds["close"].maxrange;
+    level.dog_sounds["far"].minrange = 500;
+    level.dog_sounds["far"].maxrange = 0;
+    level.dog_sounds["far"].sound = "aml_dog_bark";
+    level.dog_sounds["far"].soundlengthplaceholder = 0.2;
+    level.dog_sounds["far"].aftersoundwaitmin = 0.1;
+    level.dog_sounds["far"].aftersoundwaitmax = 0.3;
+    level.dog_sounds["far"].minrangesqr = level.dog_sounds["far"].minrange * level.dog_sounds["far"].minrange;
+    level.dog_sounds["far"].maxrangesqr = level.dog_sounds["far"].maxrange * level.dog_sounds["far"].maxrange;
+}
+
+main()
+{
+    self endon( "killanimscript" );
+    debug_anim_print( "dog_move::main()" );
+    self setaimanimweights( 0, 0 );
+    do_movement = 1;
+/#
+    if ( !debug_allow_movement() )
+        do_movement = 0;
+#/
+    if ( isdefined( level.hostmigrationtimer ) )
+        do_movement = 0;
+
+    if ( !isdefined( self.traversecomplete ) && !isdefined( self.skipstartmove ) && self.a.movement == "run" && do_movement )
+    {
+        self startmove();
+        blendtime = 0;
+    }
+    else
+        blendtime = 0.2;
+
+    self.traversecomplete = undefined;
+    self.skipstartmove = undefined;
+
+    if ( do_movement )
+    {
+        if ( shouldrun() )
+        {
+            debug_anim_print( "dog_move::main() - Setting move_run" );
+            self setanimstate( "move_run" );
+            maps\mp\animscripts\shared::donotetracksfortime( 0.1, "done" );
+            debug_anim_print( "dog_move::main() - move_run wait 0.1 done " );
+        }
+        else
+        {
+            debug_anim_print( "dog_move::main() - Setting move_start " );
+            self setanimstate( "move_walk" );
+            maps\mp\animscripts\shared::donotetracksfortime( 0.1, "done" );
+        }
+    }
+
+    self thread maps\mp\animscripts\dog_stop::lookattarget( "normal" );
+
+    while ( true )
+    {
+        self moveloop();
+
+        if ( self.a.movement == "run" )
+        {
+            if ( self.disablearrivals == 0 )
+                self thread stopmove();
+
+            self waittill( "run" );
+        }
+    }
+}
+
+moveloop()
+{
+    self endon( "killanimscript" );
+    self endon( "stop_soon" );
+
+    while ( true )
+    {
+        do_movement = 1;
+/#
+        if ( !debug_allow_movement() )
+            do_movement = 0;
+#/
+        if ( isdefined( level.hostmigrationtimer ) )
+            do_movement = 0;
+
+        if ( !do_movement )
+        {
+            self setaimanimweights( 0, 0 );
+            self setanimstate( "stop_idle" );
+            maps\mp\animscripts\shared::donotetracks( "done" );
+            continue;
+        }
+
+        if ( self.disablearrivals )
+            self.stopanimdistsq = 0;
+        else
+            self.stopanimdistsq = level.dogstoppingdistsq;
+
+        if ( shouldrun() )
+        {
+            debug_anim_print( "dog_move::moveLoop() - Setting move_run" );
+            self setanimstate( "move_run" );
+            maps\mp\animscripts\shared::donotetracksfortime( 0.2, "done" );
+            debug_anim_print( "dog_move::moveLoop() - move_run wait 0.2 done " );
+        }
+        else
+        {
+            debug_anim_print( "dog_move::moveLoop() - Setting move_walk " );
+            self setanimstate( "move_walk" );
+            maps\mp\animscripts\shared::donotetracksfortime( 0.2, "done" );
+            debug_anim_print( "dog_move::moveLoop() - move_walk wait 0.2 done " );
+        }
+    }
+}
+
+startmove()
+{
+    debug_anim_print( "dog_move::startMove() - Setting move_start " );
+    self setanimstate( "move_start" );
+    maps\mp\animscripts\shared::donotetracks( "done" );
+    debug_anim_print( "dog_move::startMove() - move_start notify done." );
+    self animmode( "none", 0 );
+    self set_orient_mode( "face motion" );
+}
+
+stopmove()
+{
+    self endon( "killanimscript" );
+    self endon( "run" );
+    debug_anim_print( "dog_move::stopMove() - Setting move_stop" );
+    self setanimstate( "move_stop" );
+    maps\mp\animscripts\shared::donotetracks( "done" );
+    debug_anim_print( "dog_move::stopMove() - move_stop notify done." );
+}
+
+shouldrun()
+{
+/#
+    if ( getdvarint( _hash_DFB12081 ) != 0 )
+        return true;
+    else if ( getdvarint( _hash_D5D7999B ) != 0 )
+        return false;
+#/
+    if ( isdefined( self.enemy ) )
+        return true;
+
+    if ( self.lookaheaddist <= 90 )
+        return false;
+
+    angles = vectortoangles( self.lookaheaddir );
+    yaw_desired = absangleclamp180( angles[1] );
+    yaw = absangleclamp180( self.angles[1] );
+
+    if ( abs( yaw_desired - yaw ) >= 8 )
+        return false;
+
+    return true;
+}

ZM/Core/maps/mp/animscripts/dog_pain.gsc

@@ -0,0 +1,28 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\shared;
+
+main()
+{
+    debug_anim_print( "dog_pain::main() " );
+    self endon( "killanimscript" );
+    self setaimanimweights( 0, 0 );
+
+    if ( isdefined( self.enemy ) && isdefined( self.enemy.syncedmeleetarget ) && self.enemy.syncedmeleetarget == self )
+    {
+        self unlink();
+        self.enemy.syncedmeleetarget = undefined;
+    }
+
+    speed = length( self getvelocity() );
+    pain_anim = getanimdirection( self.damageyaw );
+
+    if ( speed > level.dogrunpainspeed )
+        pain_anim = "pain_run_" + pain_anim;
+    else
+        pain_anim = "pain_" + pain_anim;
+
+    self setanimstate( pain_anim );
+    self maps\mp\animscripts\shared::donotetracksfortime( 0.2, "done" );
+}

ZM/Core/maps/mp/animscripts/dog_stop.gsc

@@ -0,0 +1,127 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+
+main()
+{
+    debug_anim_print( "dog_stop::main()" );
+    self endon( "killanimscript" );
+    self setaimanimweights( 0, 0 );
+    self thread lookattarget( "attackIdle" );
+
+    while ( true )
+    {
+        if ( shouldattackidle() )
+        {
+            self randomattackidle();
+            maps\mp\animscripts\shared::donotetracks( "done" );
+        }
+        else
+        {
+            self set_orient_mode( "face current" );
+            debug_anim_print( "dog_stop::main() - Setting stop_idle" );
+            self notify( "stop tracking" );
+            self setaimanimweights( 0, 0 );
+            self setanimstate( "stop_idle" );
+            maps\mp\animscripts\shared::donotetracks( "done" );
+            self thread lookattarget( "attackIdle" );
+        }
+
+        debug_anim_print( "dog_stop::main() - stop idle loop notify done." );
+    }
+}
+
+isfacingenemy( tolerancecosangle )
+{
+    assert( isdefined( self.enemy ) );
+    vectoenemy = self.enemy.origin - self.origin;
+    disttoenemy = length( vectoenemy );
+
+    if ( disttoenemy < 1 )
+        return 1;
+
+    forward = anglestoforward( self.angles );
+    val1 = forward[0] * vectoenemy[0] + forward[1] * vectoenemy[1];
+    val2 = ( forward[0] * vectoenemy[0] + forward[1] * vectoenemy[1] ) / disttoenemy;
+    return ( forward[0] * vectoenemy[0] + forward[1] * vectoenemy[1] ) / disttoenemy > tolerancecosangle;
+}
+
+randomattackidle()
+{
+    if ( isfacingenemy( -0.5 ) )
+        self set_orient_mode( "face current" );
+    else
+        self set_orient_mode( "face enemy" );
+
+    if ( should_growl() )
+    {
+        debug_anim_print( "dog_stop::main() - Setting stop_attackidle_growl" );
+        self setanimstate( "stop_attackidle_growl" );
+        return;
+    }
+
+    idlechance = 33;
+    barkchance = 66;
+
+    if ( isdefined( self.mode ) )
+    {
+        if ( self.mode == "growl" )
+        {
+            idlechance = 15;
+            barkchance = 30;
+        }
+        else if ( self.mode == "bark" )
+        {
+            idlechance = 15;
+            barkchance = 85;
+        }
+    }
+
+    rand = randomint( 100 );
+
+    if ( rand < idlechance )
+    {
+        debug_anim_print( "dog_stop::main() - Setting stop_attackidle" );
+        self setanimstate( "stop_attackidle" );
+    }
+    else if ( rand < barkchance )
+    {
+        debug_anim_print( "dog_stop::main() - Setting stop_attackidle_bark " );
+        self setanimstate( "stop_attackidle_bark" );
+    }
+    else
+    {
+        debug_anim_print( "dog_stop::main() - Setting stop_attackidle_growl " );
+        self setanimstate( "stop_attackidle_growl" );
+    }
+}
+
+shouldattackidle()
+{
+    return isdefined( self.enemy ) && isalive( self.enemy ) && distancesquared( self.origin, self.enemy.origin ) < 1000000;
+}
+
+should_growl()
+{
+    if ( isdefined( self.script_growl ) )
+        return 1;
+
+    if ( !isalive( self.enemy ) )
+        return 1;
+
+    return !self cansee( self.enemy );
+}
+
+lookattarget( lookposeset )
+{
+    self endon( "killanimscript" );
+    self endon( "stop tracking" );
+    debug_anim_print( "dog_stop::lookAtTarget() - Starting look at " + lookposeset );
+    self.rightaimlimit = 90;
+    self.leftaimlimit = -90;
+    self.upaimlimit = 45;
+    self.downaimlimit = -45;
+    self maps\mp\animscripts\shared::setanimaimweight( 1, 0.2 );
+    self maps\mp\animscripts\shared::trackloop();
+}

ZM/Core/maps/mp/animscripts/dog_turn.gsc

@@ -0,0 +1,123 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\shared;
+
+main()
+{
+    self endon( "killanimscript" );
+    debug_turn_print( "dog_turn::main()" );
+    self setaimanimweights( 0, 0 );
+    self.safetochangescript = 0;
+    deltayaw = self getdeltaturnyaw();
+
+    if ( need_to_turn_around( deltayaw ) )
+        turn_180( deltayaw );
+    else
+        turn_90( deltayaw );
+
+    move_out_of_turn();
+    self.skipstartmove = 1;
+    self.safetochangescript = 1;
+}
+
+need_to_turn_around( deltayaw )
+{
+    angle = getdvarfloat( "dog_turn180_angle" );
+
+    if ( deltayaw >= angle || deltayaw <= -1 * angle )
+    {
+        debug_turn_print( "dog_turn::need_to_turn_around(): " + deltayaw + " YES" );
+        return true;
+    }
+
+    debug_turn_print( "dog_turn::need_to_turn_around(): " + deltayaw + " NO" );
+    return false;
+}
+
+do_turn_anim( stopped_anim, run_anim, wait_time, run_wait_time )
+{
+    speed = length( self getvelocity() );
+    do_anim = stopped_anim;
+
+    if ( level.dogrunturnspeed < speed )
+    {
+        do_anim = run_anim;
+        wait_time = run_wait_time;
+    }
+
+    debug_turn_print( "dog_turn::do_turn_anim() - Setting " + do_anim );
+    self setanimstate( do_anim );
+    maps\mp\animscripts\shared::donotetracksfortime( run_wait_time, "done" );
+    debug_turn_print( "dog_turn::do_turn_anim() - done with " + do_anim + " wait time " + run_wait_time );
+}
+
+turn_left()
+{
+    self do_turn_anim( "move_turn_left", "move_run_turn_left", 0.5, 0.5 );
+}
+
+turn_right()
+{
+    self do_turn_anim( "move_turn_right", "move_run_turn_right", 0.5, 0.5 );
+}
+
+turn_180_left()
+{
+    self do_turn_anim( "move_turn_around_left", "move_run_turn_around_left", 0.5, 0.7 );
+}
+
+turn_180_right()
+{
+    self do_turn_anim( "move_turn_around_right", "move_run_turn_around_right", 0.5, 0.7 );
+}
+
+move_out_of_turn()
+{
+    if ( self.a.movement == "run" )
+    {
+        debug_turn_print( "dog_turn::move_out_of_turn() - Setting move_run" );
+        self setanimstate( "move_run" );
+        maps\mp\animscripts\shared::donotetracksfortime( 0.1, "done" );
+        debug_turn_print( "dog_turn::move_out_of_turn() - move_run wait 0.1 done " );
+    }
+    else
+    {
+        debug_turn_print( "dog_turn::move_out_of_turn() - Setting move_start " );
+        self setanimstate( "move_walk" );
+    }
+}
+
+turn_90( deltayaw )
+{
+    self animmode( "zonly_physics", 0 );
+    debug_turn_print( "dog_turn::turn_90() deltaYaw: " + deltayaw );
+
+    if ( deltayaw > 0 )
+    {
+        debug_turn_print( "dog_turn::turn_90() left", 1 );
+        self turn_left();
+    }
+    else
+    {
+        debug_turn_print( "dog_turn::turn_90() right", 1 );
+        self turn_right();
+    }
+}
+
+turn_180( deltayaw )
+{
+    self animmode( "zonly_physics", 0 );
+    debug_turn_print( "dog_turn::turn_180() deltaYaw: " + deltayaw );
+
+    if ( deltayaw > 0 )
+    {
+        debug_turn_print( "dog_turn::turn_180() left", 1 );
+        self turn_180_left();
+    }
+    else
+    {
+        debug_turn_print( "dog_turn::turn_180() right", 1 );
+        self turn_180_right();
+    }
+}

ZM/Core/maps/mp/animscripts/shared.gsc

@@ -0,0 +1,279 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\animscripts\utility;
+#include maps\mp\_utility;
+
+handledogsoundnotetracks( note )
+{
+    if ( note == "sound_dogstep_run_default" )
+        return true;
+
+    prefix = getsubstr( note, 0, 5 );
+
+    if ( prefix != "sound" )
+        return false;
+
+    return true;
+}
+
+growling()
+{
+    return isdefined( self.script_growl );
+}
+
+handlenotetrack( note, flagname, customfunction, var1 )
+{
+/#
+    if ( getdvarint( _hash_6EBEB982 ) )
+        println( "dog notetrack: " + flagname + " " + note + " " + gettime() );
+#/
+    if ( isai( self ) && self.type == "dog" )
+    {
+        if ( handledogsoundnotetracks( note ) )
+            return;
+    }
+
+    switch ( note )
+    {
+        case "undefined":
+        case "finish":
+        case "end":
+            return note;
+        default:
+            if ( isdefined( customfunction ) )
+            {
+                if ( !isdefined( var1 ) )
+                    return [[ customfunction ]]( note );
+                else
+                    return [[ customfunction ]]( note, var1 );
+            }
+
+            break;
+    }
+}
+
+donotetracks( flagname, customfunction, var1 )
+{
+    for (;;)
+    {
+        self waittill( flagname, note );
+
+        if ( !isdefined( note ) )
+            note = "undefined";
+
+        val = self handlenotetrack( note, flagname, customfunction, var1 );
+
+        if ( isdefined( val ) )
+            return val;
+    }
+}
+
+donotetracksforeverproc( notetracksfunc, flagname, killstring, customfunction, var1 )
+{
+    if ( isdefined( killstring ) )
+        self endon( killstring );
+
+    self endon( "killanimscript" );
+
+    for (;;)
+    {
+        time = gettime();
+        returnednote = [[ notetracksfunc ]]( flagname, customfunction, var1 );
+        timetaken = gettime() - time;
+
+        if ( timetaken < 0.05 )
+        {
+            time = gettime();
+            returnednote = [[ notetracksfunc ]]( flagname, customfunction, var1 );
+            timetaken = gettime() - time;
+
+            if ( timetaken < 0.05 )
+            {
+/#
+                println( gettime() + " mapsmpanimscriptsshared::DoNoteTracksForever is trying to cause an infinite loop on anim " + flagname + ", returned " + returnednote + "." );
+#/
+                wait( 0.05 - timetaken );
+            }
+        }
+    }
+}
+
+donotetracksforever( flagname, killstring, customfunction, var1 )
+{
+    donotetracksforeverproc( ::donotetracks, flagname, killstring, customfunction, var1 );
+}
+
+donotetracksfortimeproc( donotetracksforeverfunc, time, flagname, customfunction, ent, var1 )
+{
+    ent endon( "stop_notetracks" );
+    [[ donotetracksforeverfunc ]]( flagname, undefined, customfunction, var1 );
+}
+
+donotetracksfortime( time, flagname, customfunction, var1 )
+{
+    ent = spawnstruct();
+    ent thread donotetracksfortimeendnotify( time );
+    donotetracksfortimeproc( ::donotetracksforever, time, flagname, customfunction, ent, var1 );
+}
+
+donotetracksfortimeendnotify( time )
+{
+    wait( time );
+    self notify( "stop_notetracks" );
+}
+
+trackloop()
+{
+    players = get_players();
+    deltachangeperframe = 5;
+    aimblendtime = 0.05;
+    prevyawdelta = 0;
+    prevpitchdelta = 0;
+    maxyawdeltachange = 5;
+    maxpitchdeltachange = 5;
+    pitchadd = 0;
+    yawadd = 0;
+
+    if ( self.type == "dog" || self.type == "zombie" || self.type == "zombie_dog" )
+    {
+        domaxanglecheck = 0;
+        self.shootent = self.enemy;
+    }
+    else
+    {
+        domaxanglecheck = 1;
+
+        if ( self.a.script == "cover_crouch" && isdefined( self.a.covermode ) && self.a.covermode == "lean" )
+            pitchadd = -1 * anim.covercrouchleanpitch;
+
+        if ( ( self.a.script == "cover_left" || self.a.script == "cover_right" ) && isdefined( self.a.cornermode ) && self.a.cornermode == "lean" )
+            yawadd = self.covernode.angles[1] - self.angles[1];
+    }
+
+    yawdelta = 0;
+    pitchdelta = 0;
+    firstframe = 1;
+
+    for (;;)
+    {
+        incranimaimweight();
+        selfshootatpos = ( self.origin[0], self.origin[1], self geteye()[2] );
+        shootpos = undefined;
+
+        if ( isdefined( self.enemy ) )
+            shootpos = self.enemy getshootatpos();
+
+        if ( !isdefined( shootpos ) )
+        {
+            yawdelta = 0;
+            pitchdelta = 0;
+        }
+        else
+        {
+            vectortoshootpos = shootpos - selfshootatpos;
+            anglestoshootpos = vectortoangles( vectortoshootpos );
+            pitchdelta = 360 - anglestoshootpos[0];
+            pitchdelta = angleclamp180( pitchdelta + pitchadd );
+            yawdelta = self.angles[1] - anglestoshootpos[1];
+            yawdelta = angleclamp180( yawdelta + yawadd );
+        }
+
+        if ( domaxanglecheck && ( abs( yawdelta ) > 60 || abs( pitchdelta ) > 60 ) )
+        {
+            yawdelta = 0;
+            pitchdelta = 0;
+        }
+        else
+        {
+            if ( yawdelta > self.rightaimlimit )
+                yawdelta = self.rightaimlimit;
+            else if ( yawdelta < self.leftaimlimit )
+                yawdelta = self.leftaimlimit;
+
+            if ( pitchdelta > self.upaimlimit )
+                pitchdelta = self.upaimlimit;
+            else if ( pitchdelta < self.downaimlimit )
+                pitchdelta = self.downaimlimit;
+        }
+
+        if ( firstframe )
+            firstframe = 0;
+        else
+        {
+            yawdeltachange = yawdelta - prevyawdelta;
+
+            if ( abs( yawdeltachange ) > maxyawdeltachange )
+                yawdelta = prevyawdelta + maxyawdeltachange * sign( yawdeltachange );
+
+            pitchdeltachange = pitchdelta - prevpitchdelta;
+
+            if ( abs( pitchdeltachange ) > maxpitchdeltachange )
+                pitchdelta = prevpitchdelta + maxpitchdeltachange * sign( pitchdeltachange );
+        }
+
+        prevyawdelta = yawdelta;
+        prevpitchdelta = pitchdelta;
+        updown = 0;
+        leftright = 0;
+
+        if ( yawdelta > 0 )
+        {
+            assert( yawdelta <= self.rightaimlimit );
+            weight = yawdelta / self.rightaimlimit * self.a.aimweight;
+            leftright = weight;
+        }
+        else if ( yawdelta < 0 )
+        {
+            assert( yawdelta >= self.leftaimlimit );
+            weight = yawdelta / self.leftaimlimit * self.a.aimweight;
+            leftright = -1 * weight;
+        }
+
+        if ( pitchdelta > 0 )
+        {
+            assert( pitchdelta <= self.upaimlimit );
+            weight = pitchdelta / self.upaimlimit * self.a.aimweight;
+            updown = weight;
+        }
+        else if ( pitchdelta < 0 )
+        {
+            assert( pitchdelta >= self.downaimlimit );
+            weight = pitchdelta / self.downaimlimit * self.a.aimweight;
+            updown = -1 * weight;
+        }
+
+        self setaimanimweights( updown, leftright );
+        wait 0.05;
+    }
+}
+
+setanimaimweight( goalweight, goaltime )
+{
+    if ( !isdefined( goaltime ) || goaltime <= 0 )
+    {
+        self.a.aimweight = goalweight;
+        self.a.aimweight_start = goalweight;
+        self.a.aimweight_end = goalweight;
+        self.a.aimweight_transframes = 0;
+    }
+    else
+    {
+        self.a.aimweight = goalweight;
+        self.a.aimweight_start = self.a.aimweight;
+        self.a.aimweight_end = goalweight;
+        self.a.aimweight_transframes = int( goaltime * 20 );
+    }
+
+    self.a.aimweight_t = 0;
+}
+
+incranimaimweight()
+{
+    if ( self.a.aimweight_t < self.a.aimweight_transframes )
+    {
+        self.a.aimweight_t++;
+        t = 1.0 * self.a.aimweight_t / self.a.aimweight_transframes;
+        self.a.aimweight = self.a.aimweight_start * ( 1 - t ) + self.a.aimweight_end * t;
+    }
+}

ZM/Core/maps/mp/animscripts/traverse/shared.gsc

@@ -0,0 +1,195 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\_utility;
+#include common_scripts\utility;
+#include maps\mp\animscripts\shared;
+
+init_traverse()
+{
+    point = getent( self.target, "targetname" );
+
+    if ( isdefined( point ) )
+    {
+        self.traverse_height = point.origin[2];
+        point delete();
+    }
+    else
+    {
+        point = getstruct( self.target, "targetname" );
+
+        if ( isdefined( point ) )
+            self.traverse_height = point.origin[2];
+    }
+}
+
+teleportthread( verticaloffset )
+{
+    self endon( "killanimscript" );
+    self notify( "endTeleportThread" );
+    self endon( "endTeleportThread" );
+    reps = 5;
+    offset = ( 0, 0, verticaloffset / reps );
+
+    for ( i = 0; i < reps; i++ )
+    {
+        self teleport( self.origin + offset );
+        wait 0.05;
+    }
+}
+
+teleportthreadex( verticaloffset, delay, frames )
+{
+    self endon( "killanimscript" );
+    self notify( "endTeleportThread" );
+    self endon( "endTeleportThread" );
+
+    if ( verticaloffset == 0 )
+        return;
+
+    wait( delay );
+    amount = verticaloffset / frames;
+
+    if ( amount > 10.0 )
+        amount = 10.0;
+    else if ( amount < -10.0 )
+        amount = -10.0;
+
+    offset = ( 0, 0, amount );
+
+    for ( i = 0; i < frames; i++ )
+    {
+        self teleport( self.origin + offset );
+        wait 0.05;
+    }
+}
+
+dog_wall_and_window_hop( traversename, height )
+{
+    self endon( "killanimscript" );
+    self traversemode( "nogravity" );
+    self traversemode( "noclip" );
+    startnode = self getnegotiationstartnode();
+    assert( isdefined( startnode ) );
+    self orientmode( "face angle", startnode.angles[1] );
+
+    if ( isdefined( startnode.traverse_height ) )
+    {
+        realheight = startnode.traverse_height - startnode.origin[2];
+        self thread teleportthread( realheight - height );
+    }
+    else if ( height != 36.0 )
+        self thread teleportthreadex( height - 36.0, 0.2, 7 );
+
+    debug_anim_print( "traverse::dog_wall_and_window_hop() - Setting " + traversename );
+    self setanimstate( traversename );
+    maps\mp\animscripts\shared::donotetracksfortime( 1.0, "done" );
+    debug_anim_print( "traverse::dog_wall_and_window_hop() - " + traversename );
+    self.traversecomplete = 1;
+}
+
+dog_jump_down( height, frames, time )
+{
+    self endon( "killanimscript" );
+    self traversemode( "noclip" );
+
+    if ( !isdefined( time ) )
+        time = 0.3;
+
+    startnode = self getnegotiationstartnode();
+    assert( isdefined( startnode ) );
+    self orientmode( "face angle", startnode.angles[1] );
+
+    if ( isdefined( startnode.traverse_height ) )
+    {
+        realheight = startnode.traverse_height - startnode.origin[2];
+        self thread teleportthread( realheight - height );
+    }
+    else if ( height != 40.0 )
+        self thread teleportthreadex( height - 40.0, 0.1, frames );
+
+    debug_anim_print( "traverse::dog_jump_down() - Setting traverse_jump_down_40" );
+    self setanimstate( "traverse_jump_down_40" );
+    maps\mp\animscripts\shared::donotetracksfortime( time, "done" );
+    debug_anim_print( "traverse::dog_jump_down() - traverse_jump_down_40 " );
+    self traversemode( "gravity" );
+    self.traversecomplete = 1;
+}
+
+dog_jump_down_far( height, frames, time )
+{
+    self endon( "killanimscript" );
+    self traversemode( "noclip" );
+
+    if ( !isdefined( time ) )
+        time = 0.3;
+
+    startnode = self getnegotiationstartnode();
+    assert( isdefined( startnode ) );
+    self orientmode( "face angle", startnode.angles[1] );
+
+    if ( isdefined( startnode.traverse_height ) )
+    {
+        realheight = startnode.traverse_height - startnode.origin[2];
+        self thread teleportthread( realheight - height );
+    }
+    else if ( height != 80.0 )
+        self thread teleportthreadex( 80.0 - height, 0.1, frames );
+
+    debug_anim_print( "traverse::dog_jump_down() - Setting traverse_jump_down_80" );
+    self setanimstate( "traverse_jump_down_80" );
+    maps\mp\animscripts\shared::donotetracksfortime( time, "done" );
+    debug_anim_print( "traverse::dog_jump_down() - traverse_jump_down_80 " );
+    self traversemode( "gravity" );
+    self.traversecomplete = 1;
+}
+
+dog_jump_up( height, frames )
+{
+    self endon( "killanimscript" );
+    self traversemode( "noclip" );
+    startnode = self getnegotiationstartnode();
+    assert( isdefined( startnode ) );
+    self orientmode( "face angle", startnode.angles[1] );
+
+    if ( isdefined( startnode.traverse_height ) )
+    {
+        realheight = startnode.traverse_height - startnode.origin[2];
+        self thread teleportthread( realheight - height );
+    }
+    else if ( height != 40.0 )
+        self thread teleportthreadex( height - 40.0, 0.2, frames );
+
+    debug_anim_print( "traverse::dog_jump_up() - Setting traverse_jump_up_40" );
+    self setanimstate( "traverse_jump_up_40" );
+    maps\mp\animscripts\shared::donotetracksfortime( 0.5, "done" );
+    debug_anim_print( "traverse::dog_jump_up() - traverse_jump_up_40  " );
+    self traversemode( "gravity" );
+    self.traversecomplete = 1;
+}
+
+dog_jump_up_high( height, frames )
+{
+    assert( self.type == "dog", "Only dogs can do this traverse currently." );
+    self endon( "killanimscript" );
+    self traversemode( "nogravity" );
+    self traversemode( "noclip" );
+    startnode = self getnegotiationstartnode();
+    assert( isdefined( startnode ) );
+    self orientmode( "face angle", startnode.angles[1] );
+
+    if ( isdefined( startnode.traverse_height ) )
+    {
+        realheight = startnode.traverse_height - startnode.origin[2];
+        self thread teleportthreadex( height - 80, 0.2, frames );
+    }
+    else if ( height != 80.0 )
+        self thread teleportthreadex( height - 80.0, 0.2, frames );
+
+    debug_anim_print( "traverse::dog_jump_up_80() - Setting traverse_jump_up_80" );
+    self setanimstate( "traverse_jump_up_80" );
+    maps\mp\animscripts\shared::donotetracksfortime( 0.6, "done" );
+    debug_anim_print( "traverse::dog_jump_up_80() - traverse_jump_up_80 " );
+    self traversemode( "gravity" );
+    self.traversecomplete = 1;
+}

ZM/Core/maps/mp/animscripts/traverse/zm_mantle_over_40.gsc

@@ -0,0 +1,49 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\traverse\shared;
+#include maps\mp\animscripts\traverse\zm_shared;
+
+main()
+{
+    traversestate = "zm_traverse_barrier";
+    traversealias = "barrier_walk";
+
+    if ( self.has_legs )
+    {
+        switch ( self.zombie_move_speed )
+        {
+            case "walk_slide":
+            case "walk":
+            case "low_gravity_walk":
+                traversealias = "barrier_walk";
+                break;
+            case "run_slide":
+            case "run":
+            case "low_gravity_run":
+                traversealias = "barrier_run";
+                break;
+            case "super_sprint":
+            case "sprint_slide":
+            case "sprint":
+            case "low_gravity_sprint":
+                traversealias = "barrier_sprint";
+                break;
+            default:
+                if ( isdefined( level.zm_mantle_over_40_move_speed_override ) )
+                    traversealias = self [[ level.zm_mantle_over_40_move_speed_override ]]();
+                else
+                {
+/#
+                    assertmsg( "Zombie '" + self.classname + "' move speed of '" + self.zombie_move_speed + "' is not supported for mantle_over_40." );
+#/
+                }
+        }
+    }
+    else
+    {
+        traversestate = "zm_traverse_barrier_crawl";
+        traversealias = "barrier_crawl";
+    }
+
+    self dotraverse( traversestate, traversealias );
+}

ZM/Core/maps/mp/animscripts/traverse/zm_shared.gsc

@@ -0,0 +1,141 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\_utility;
+#include common_scripts\utility;
+#include maps\mp\animscripts\zm_shared;
+#include maps\mp\animscripts\zm_run;
+
+init_traverse()
+{
+    point = getent( self.target, "targetname" );
+
+    if ( isdefined( point ) )
+    {
+        self.traverse_height = point.origin[2];
+        point delete();
+    }
+    else
+    {
+        point = getstruct( self.target, "targetname" );
+
+        if ( isdefined( point ) )
+            self.traverse_height = point.origin[2];
+    }
+}
+
+teleportthread( verticaloffset )
+{
+    self endon( "killanimscript" );
+    self notify( "endTeleportThread" );
+    self endon( "endTeleportThread" );
+    reps = 5;
+    offset = ( 0, 0, verticaloffset / reps );
+
+    for ( i = 0; i < reps; i++ )
+    {
+        self teleport( self.origin + offset );
+        wait 0.05;
+    }
+}
+
+teleportthreadex( verticaloffset, delay, frames )
+{
+    self endon( "killanimscript" );
+    self notify( "endTeleportThread" );
+    self endon( "endTeleportThread" );
+
+    if ( verticaloffset == 0 )
+        return;
+
+    wait( delay );
+    amount = verticaloffset / frames;
+
+    if ( amount > 10.0 )
+        amount = 10.0;
+    else if ( amount < -10.0 )
+        amount = -10.0;
+
+    offset = ( 0, 0, amount );
+
+    for ( i = 0; i < frames; i++ )
+    {
+        self teleport( self.origin + offset );
+        wait 0.05;
+    }
+}
+
+handletraversealignment()
+{
+    self traversemode( "nogravity" );
+    self traversemode( "noclip" );
+
+    if ( isdefined( self.traverseheight ) && isdefined( self.traversestartnode.traverse_height ) )
+    {
+        currentheight = self.traversestartnode.traverse_height - self.traversestartz;
+        self thread teleportthread( currentheight - self.traverseheight );
+    }
+}
+
+dosimpletraverse( traversealias, no_powerups, traversestate = "zm_traverse" )
+{
+    if ( isdefined( level.ignore_traverse ) )
+    {
+        if ( self [[ level.ignore_traverse ]]() )
+            return;
+    }
+
+    if ( isdefined( level.zm_traversal_override ) )
+        traversealias = self [[ level.zm_traversal_override ]]( traversealias );
+
+    if ( !self.has_legs )
+    {
+        traversestate += "_crawl";
+        traversealias += "_crawl";
+    }
+
+    self dotraverse( traversestate, traversealias, no_powerups );
+}
+
+dotraverse( traversestate, traversealias, no_powerups )
+{
+    self endon( "killanimscript" );
+    self traversemode( "nogravity" );
+    self traversemode( "noclip" );
+    old_powerups = 0;
+
+    if ( isdefined( no_powerups ) && no_powerups )
+    {
+        old_powerups = self.no_powerups;
+        self.no_powerups = 1;
+    }
+
+    self.is_traversing = 1;
+    self notify( "zombie_start_traverse" );
+    self.traversestartnode = self getnegotiationstartnode();
+    assert( isdefined( self.traversestartnode ) );
+    self orientmode( "face angle", self.traversestartnode.angles[1] );
+    self.traversestartz = self.origin[2];
+
+    if ( isdefined( self.pre_traverse ) )
+        self [[ self.pre_traverse ]]();
+
+    self setanimstatefromasd( traversestate, traversealias );
+    self maps\mp\animscripts\zm_shared::donotetracks( "traverse_anim" );
+    self traversemode( "gravity" );
+    self.a.nodeath = 0;
+
+    if ( isdefined( self.post_traverse ) )
+        self [[ self.post_traverse ]]();
+
+    self maps\mp\animscripts\zm_run::needsupdate();
+
+    if ( !self.isdog )
+        self maps\mp\animscripts\zm_run::moverun();
+
+    self.is_traversing = 0;
+    self notify( "zombie_end_traverse" );
+
+    if ( isdefined( no_powerups ) && no_powerups )
+        self.no_powerups = old_powerups;
+}

ZM/Core/maps/mp/animscripts/utility.gsc

@@ -0,0 +1,135 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+
+anim_get_dvar_int( dvar, def )
+{
+    return int( anim_get_dvar( dvar, def ) );
+}
+
+anim_get_dvar( dvar, def )
+{
+    if ( getdvar( dvar ) != "" )
+        return getdvarfloat( dvar );
+    else
+    {
+        setdvar( dvar, def );
+        return def;
+    }
+}
+
+set_orient_mode( mode, val1 )
+{
+/#
+    if ( level.dog_debug_orient == self getentnum() )
+    {
+        if ( isdefined( val1 ) )
+            println( "DOG:  Setting orient mode: " + mode + " " + val1 + " " + gettime() );
+        else
+            println( "DOG:  Setting orient mode: " + mode + " " + gettime() );
+    }
+#/
+    if ( isdefined( val1 ) )
+        self orientmode( mode, val1 );
+    else
+        self orientmode( mode );
+}
+
+debug_anim_print( text )
+{
+/#
+    if ( level.dog_debug_anims )
+        println( text + " " + gettime() );
+
+    if ( level.dog_debug_anims_ent == self getentnum() )
+        println( text + " " + gettime() );
+#/
+}
+
+debug_turn_print( text, line )
+{
+/#
+    if ( level.dog_debug_turns == self getentnum() )
+    {
+        duration = 200;
+        currentyawcolor = ( 1, 1, 1 );
+        lookaheadyawcolor = ( 1, 0, 0 );
+        desiredyawcolor = ( 1, 1, 0 );
+        currentyaw = angleclamp180( self.angles[1] );
+        desiredyaw = angleclamp180( self.desiredangle );
+        lookaheaddir = self.lookaheaddir;
+        lookaheadangles = vectortoangles( lookaheaddir );
+        lookaheadyaw = angleclamp180( lookaheadangles[1] );
+        println( text + " " + gettime() + " cur: " + currentyaw + " look: " + lookaheadyaw + " desired: " + desiredyaw );
+    }
+#/
+}
+
+debug_allow_movement()
+{
+/#
+    return anim_get_dvar_int( "debug_dog_allow_movement", "1" );
+#/
+    return 1;
+}
+
+debug_allow_combat()
+{
+/#
+    return anim_get_dvar_int( "debug_dog_allow_combat", "1" );
+#/
+    return 1;
+}
+
+current_yaw_line_debug( duration )
+{
+/#
+    currentyawcolor = [];
+    currentyawcolor[0] = ( 0, 0, 1 );
+    currentyawcolor[1] = ( 1, 0, 1 );
+    current_color_index = 0;
+    start_time = gettime();
+
+    if ( !isdefined( level.lastdebugheight ) )
+        level.lastdebugheight = 15;
+
+    while ( gettime() - start_time < 1000 )
+    {
+        pos1 = ( self.origin[0], self.origin[1], self.origin[2] + level.lastdebugheight );
+        pos2 = pos1 + vectorscale( anglestoforward( self.angles ), ( current_color_index + 1 ) * 10 );
+        line( pos1, pos2, currentyawcolor[current_color_index], 0.3, 1, duration );
+        current_color_index = ( current_color_index + 1 ) % currentyawcolor.size;
+        wait 0.05;
+    }
+
+    if ( level.lastdebugheight == 15 )
+        level.lastdebugheight = 30;
+    else
+        level.lastdebugheight = 15;
+#/
+}
+
+getanimdirection( damageyaw )
+{
+    if ( damageyaw > 135 || damageyaw <= -135 )
+        return "front";
+    else if ( damageyaw > 45 && damageyaw <= 135 )
+        return "right";
+    else if ( damageyaw > -45 && damageyaw <= 45 )
+        return "back";
+    else
+        return "left";
+
+    return "front";
+}
+
+setfootstepeffect( name, fx )
+{
+    assert( isdefined( name ), "Need to define the footstep surface type." );
+    assert( isdefined( fx ), "Need to define the mud footstep effect." );
+
+    if ( !isdefined( anim.optionalstepeffects ) )
+        anim.optionalstepeffects = [];
+
+    anim.optionalstepeffects[anim.optionalstepeffects.size] = name;
+    level._effect["step_" + name] = fx;
+}

ZM/Core/maps/mp/animscripts/zm_combat.gsc

@@ -0,0 +1,64 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\zm_utility;
+#include maps\mp\animscripts\zm_melee;
+
+main()
+{
+    self endon( "killanimscript" );
+    self endon( "melee" );
+    maps\mp\animscripts\zm_utility::initialize( "zombie_combat" );
+    self animmode( "zonly_physics", 0 );
+
+    if ( isdefined( self.combat_animmode ) )
+        self [[ self.combat_animmode ]]();
+
+    self orientmode( "face angle", self.angles[1] );
+
+    for (;;)
+    {
+        if ( trymelee() )
+            return;
+
+        exposedwait();
+    }
+}
+
+exposedwait()
+{
+    if ( !isdefined( self.can_always_see ) && ( !isdefined( self.enemy ) || !self cansee( self.enemy ) ) )
+    {
+        self endon( "enemy" );
+        wait( 0.2 + randomfloat( 0.1 ) );
+    }
+    else if ( !isdefined( self.enemy ) )
+    {
+        self endon( "enemy" );
+        wait( 0.2 + randomfloat( 0.1 ) );
+    }
+    else
+        wait 0.05;
+}
+
+trymelee()
+{
+    if ( isdefined( self.cant_melee ) && self.cant_melee )
+        return false;
+
+    if ( !isdefined( self.enemy ) )
+        return false;
+
+    if ( distancesquared( self.origin, self.enemy.origin ) > 262144 )
+        return false;
+
+    canmelee = maps\mp\animscripts\zm_melee::canmeleedesperate();
+
+    if ( !canmelee )
+        return false;
+
+    self thread maps\mp\animscripts\zm_melee::meleecombat();
+    return true;
+}

ZM/Core/maps/mp/animscripts/zm_death.gsc

@@ -0,0 +1,406 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\zm_utility;
+#include maps\mp\_utility;
+#include maps\mp\animscripts\zm_shared;
+
+main()
+{
+    debug_anim_print( "zm_death::main()" );
+    self setaimanimweights( 0, 0 );
+    self endon( "killanimscript" );
+
+    if ( isdefined( self.deathfunction ) )
+    {
+        successful_death = self [[ self.deathfunction ]]();
+
+        if ( !isdefined( successful_death ) || successful_death )
+            return;
+    }
+
+    if ( isdefined( self.a.nodeath ) && self.a.nodeath == 1 )
+    {
+        assert( self.a.nodeath, "Nodeath needs to be set to true or undefined." );
+        wait 3;
+        return;
+    }
+
+    self unlink();
+
+    if ( isdefined( self.anchor ) )
+        self.anchor delete();
+
+    if ( isdefined( self.enemy ) && isdefined( self.enemy.syncedmeleetarget ) && self.enemy.syncedmeleetarget == self )
+        self.enemy.syncedmeleetarget = undefined;
+
+    self thread do_gib();
+
+    if ( isdefined( self.a.gib_ref ) && ( self.a.gib_ref == "no_legs" || self.a.gib_ref == "right_leg" || self.a.gib_ref == "left_leg" ) )
+        self.has_legs = 0;
+
+    if ( !isdefined( self.deathanim ) )
+    {
+        self.deathanim = "zm_death";
+        self.deathanim_substate = undefined;
+    }
+
+    self.deathanim = append_missing_legs_suffix( self.deathanim );
+    self animmode( "gravity" );
+    self setanimstatefromasd( self.deathanim, self.deathanim_substate );
+
+    if ( !self getanimhasnotetrackfromasd( "start_ragdoll" ) )
+        self thread waitforragdoll( self getanimlengthfromasd() * 0.35 );
+
+    if ( isdefined( self.skip_death_notetracks ) && self.skip_death_notetracks )
+        self waittillmatch( "death_anim", "end" );
+    else
+        self maps\mp\animscripts\zm_shared::donotetracks( "death_anim", self.handle_death_notetracks );
+}
+
+waitforragdoll( time )
+{
+    wait( time );
+    do_ragdoll = 1;
+
+    if ( isdefined( self.nodeathragdoll ) && self.nodeathragdoll )
+        do_ragdoll = 0;
+
+    if ( isdefined( self ) && do_ragdoll )
+        self startragdoll();
+}
+
+on_fire_timeout()
+{
+    self endon( "death" );
+    wait 12;
+
+    if ( isdefined( self ) && isalive( self ) )
+    {
+        self.is_on_fire = 0;
+        self notify( "stop_flame_damage" );
+    }
+}
+
+flame_death_fx()
+{
+    self endon( "death" );
+
+    if ( isdefined( self.is_on_fire ) && self.is_on_fire )
+        return;
+
+    self.is_on_fire = 1;
+    self thread on_fire_timeout();
+
+    if ( isdefined( level._effect ) && isdefined( level._effect["character_fire_death_torso"] ) )
+    {
+        if ( !self.isdog )
+            playfxontag( level._effect["character_fire_death_torso"], self, "J_SpineLower" );
+    }
+    else
+    {
+/#
+        println( "^3ANIMSCRIPT WARNING: You are missing level._effect[\"character_fire_death_torso\"], please set it in your levelname_fx.gsc. Use \"env/fire/fx_fire_player_torso\"" );
+#/
+    }
+
+    if ( isdefined( level._effect ) && isdefined( level._effect["character_fire_death_sm"] ) )
+    {
+        wait 1;
+        tagarray = [];
+        tagarray[0] = "J_Elbow_LE";
+        tagarray[1] = "J_Elbow_RI";
+        tagarray[2] = "J_Knee_RI";
+        tagarray[3] = "J_Knee_LE";
+        tagarray = randomize_array( tagarray );
+        playfxontag( level._effect["character_fire_death_sm"], self, tagarray[0] );
+        wait 1;
+        tagarray[0] = "J_Wrist_RI";
+        tagarray[1] = "J_Wrist_LE";
+
+        if ( !isdefined( self.a ) || !isdefined( self.a.gib_ref ) || self.a.gib_ref != "no_legs" )
+        {
+            tagarray[2] = "J_Ankle_RI";
+            tagarray[3] = "J_Ankle_LE";
+        }
+
+        tagarray = randomize_array( tagarray );
+        playfxontag( level._effect["character_fire_death_sm"], self, tagarray[0] );
+        playfxontag( level._effect["character_fire_death_sm"], self, tagarray[1] );
+    }
+    else
+    {
+/#
+        println( "^3ANIMSCRIPT WARNING: You are missing level._effect[\"character_fire_death_sm\"], please set it in your levelname_fx.gsc. Use \"env/fire/fx_fire_zombie_md\"" );
+#/
+    }
+}
+
+randomize_array( array )
+{
+    for ( i = 0; i < array.size; i++ )
+    {
+        j = randomint( array.size );
+        temp = array[i];
+        array[i] = array[j];
+        array[j] = temp;
+    }
+
+    return array;
+}
+
+get_tag_for_damage_location()
+{
+    tag = "J_SpineLower";
+
+    if ( self.damagelocation == "helmet" )
+        tag = "j_head";
+    else if ( self.damagelocation == "head" )
+        tag = "j_head";
+    else if ( self.damagelocation == "neck" )
+        tag = "j_neck";
+    else if ( self.damagelocation == "torso_upper" )
+        tag = "j_spineupper";
+    else if ( self.damagelocation == "torso_lower" )
+        tag = "j_spinelower";
+    else if ( self.damagelocation == "right_arm_upper" )
+        tag = "j_elbow_ri";
+    else if ( self.damagelocation == "left_arm_upper" )
+        tag = "j_elbow_le";
+    else if ( self.damagelocation == "right_arm_lower" )
+        tag = "j_wrist_ri";
+    else if ( self.damagelocation == "left_arm_lower" )
+        tag = "j_wrist_le";
+
+    return tag;
+}
+
+set_last_gib_time()
+{
+    anim notify( "stop_last_gib_time" );
+    anim endon( "stop_last_gib_time" );
+    wait 0.05;
+    anim.lastgibtime = gettime();
+    anim.totalgibs = randomintrange( anim.mingibs, anim.maxgibs );
+}
+
+get_gib_ref( direction )
+{
+    if ( isdefined( self.a.gib_ref ) )
+        return;
+
+    if ( self.damagetaken < 165 )
+        return;
+
+    if ( gettime() > anim.lastgibtime + anim.gibdelay && anim.totalgibs > 0 )
+    {
+        anim.totalgibs--;
+        anim thread set_last_gib_time();
+        refs = [];
+
+        switch ( direction )
+        {
+            case "right":
+                refs[refs.size] = "left_arm";
+                refs[refs.size] = "left_leg";
+                gib_ref = get_random( refs );
+                break;
+            case "left":
+                refs[refs.size] = "right_arm";
+                refs[refs.size] = "right_leg";
+                gib_ref = get_random( refs );
+                break;
+            case "forward":
+                refs[refs.size] = "right_arm";
+                refs[refs.size] = "left_arm";
+                refs[refs.size] = "right_leg";
+                refs[refs.size] = "left_leg";
+                refs[refs.size] = "guts";
+                refs[refs.size] = "no_legs";
+                gib_ref = get_random( refs );
+                break;
+            case "back":
+                refs[refs.size] = "right_arm";
+                refs[refs.size] = "left_arm";
+                refs[refs.size] = "right_leg";
+                refs[refs.size] = "left_leg";
+                refs[refs.size] = "no_legs";
+                gib_ref = get_random( refs );
+                break;
+            default:
+                refs[refs.size] = "right_arm";
+                refs[refs.size] = "left_arm";
+                refs[refs.size] = "right_leg";
+                refs[refs.size] = "left_leg";
+                refs[refs.size] = "no_legs";
+                refs[refs.size] = "guts";
+                gib_ref = get_random( refs );
+                break;
+        }
+
+        self.a.gib_ref = gib_ref;
+    }
+    else
+        self.a.gib_ref = undefined;
+}
+
+get_random( array )
+{
+    return array[randomint( array.size )];
+}
+
+do_gib()
+{
+    if ( !is_mature() )
+        return;
+
+    if ( !isdefined( self.a.gib_ref ) )
+        return;
+
+    if ( isdefined( self.is_on_fire ) && self.is_on_fire )
+        return;
+
+    if ( self is_zombie_gibbed() )
+        return;
+
+    self set_zombie_gibbed();
+    gib_ref = self.a.gib_ref;
+    limb_data = get_limb_data( gib_ref );
+
+    if ( !isdefined( limb_data ) )
+    {
+/#
+        println( "^3animscriptszm_death.gsc - limb_data is not setup for gib_ref on model: " + self.model + " and gib_ref of: " + self.a.gib_ref );
+#/
+        return;
+    }
+
+    if ( !( isdefined( self.dont_throw_gib ) && self.dont_throw_gib ) )
+        self thread throw_gib( limb_data["spawn_tags_array"] );
+
+    if ( gib_ref == "head" )
+    {
+        self.hat_gibbed = 1;
+        self.head_gibbed = 1;
+        size = self getattachsize();
+
+        for ( i = 0; i < size; i++ )
+        {
+            model = self getattachmodelname( i );
+
+            if ( issubstr( model, "head" ) )
+            {
+                if ( isdefined( self.hatmodel ) )
+                    self detach( self.hatmodel, "" );
+
+                self detach( model, "" );
+
+                if ( isdefined( self.torsodmg5 ) )
+                    self attach( self.torsodmg5, "", 1 );
+
+                break;
+            }
+        }
+    }
+    else
+    {
+        self setmodel( limb_data["body_model"] );
+        self attach( limb_data["legs_model"] );
+    }
+}
+
+precache_gib_fx()
+{
+    anim._effect["animscript_gib_fx"] = loadfx( "weapon/bullet/fx_flesh_gib_fatal_01" );
+    anim._effect["animscript_gibtrail_fx"] = loadfx( "trail/fx_trail_blood_streak" );
+    anim._effect["death_neckgrab_spurt"] = loadfx( "impacts/fx_flesh_hit_neck_fatal" );
+}
+
+get_limb_data( gib_ref )
+{
+    temp_array = [];
+
+    if ( "right_arm" == gib_ref && isdefined( self.torsodmg2 ) && isdefined( self.legdmg1 ) && isdefined( self.gibspawn1 ) && isdefined( self.gibspawntag1 ) )
+    {
+        temp_array["right_arm"]["body_model"] = self.torsodmg2;
+        temp_array["right_arm"]["legs_model"] = self.legdmg1;
+        temp_array["right_arm"]["spawn_tags_array"] = [];
+        temp_array["right_arm"]["spawn_tags_array"][0] = level._zombie_gib_piece_index_right_arm;
+    }
+
+    if ( "left_arm" == gib_ref && isdefined( self.torsodmg3 ) && isdefined( self.legdmg1 ) && isdefined( self.gibspawn2 ) && isdefined( self.gibspawntag2 ) )
+    {
+        temp_array["left_arm"]["body_model"] = self.torsodmg3;
+        temp_array["left_arm"]["legs_model"] = self.legdmg1;
+        temp_array["left_arm"]["spawn_tags_array"] = [];
+        temp_array["left_arm"]["spawn_tags_array"][0] = level._zombie_gib_piece_index_left_arm;
+    }
+
+    if ( "right_leg" == gib_ref && isdefined( self.torsodmg1 ) && isdefined( self.legdmg2 ) && isdefined( self.gibspawn3 ) && isdefined( self.gibspawntag3 ) )
+    {
+        temp_array["right_leg"]["body_model"] = self.torsodmg1;
+        temp_array["right_leg"]["legs_model"] = self.legdmg2;
+        temp_array["right_leg"]["spawn_tags_array"] = [];
+        temp_array["right_leg"]["spawn_tags_array"][0] = level._zombie_gib_piece_index_right_leg;
+    }
+
+    if ( "left_leg" == gib_ref && isdefined( self.torsodmg1 ) && isdefined( self.legdmg3 ) && isdefined( self.gibspawn4 ) && isdefined( self.gibspawntag4 ) )
+    {
+        temp_array["left_leg"]["body_model"] = self.torsodmg1;
+        temp_array["left_leg"]["legs_model"] = self.legdmg3;
+        temp_array["left_leg"]["spawn_tags_array"] = [];
+        temp_array["left_leg"]["spawn_tags_array"][0] = level._zombie_gib_piece_index_left_leg;
+    }
+
+    if ( "no_legs" == gib_ref && isdefined( self.torsodmg1 ) && isdefined( self.legdmg4 ) && isdefined( self.gibspawn4 ) && isdefined( self.gibspawn3 ) && isdefined( self.gibspawntag3 ) && isdefined( self.gibspawntag4 ) )
+    {
+        temp_array["no_legs"]["body_model"] = self.torsodmg1;
+        temp_array["no_legs"]["legs_model"] = self.legdmg4;
+        temp_array["no_legs"]["spawn_tags_array"] = [];
+        temp_array["no_legs"]["spawn_tags_array"][0] = level._zombie_gib_piece_index_right_leg;
+        temp_array["no_legs"]["spawn_tags_array"][1] = level._zombie_gib_piece_index_left_leg;
+    }
+
+    if ( "guts" == gib_ref && isdefined( self.torsodmg4 ) && isdefined( self.legdmg1 ) )
+    {
+        temp_array["guts"]["body_model"] = self.torsodmg4;
+        temp_array["guts"]["legs_model"] = self.legdmg1;
+        temp_array["guts"]["spawn_tags_array"] = [];
+        temp_array["guts"]["spawn_tags_array"][0] = level._zombie_gib_piece_index_guts;
+
+        if ( isdefined( self.gibspawn2 ) && isdefined( self.gibspawntag2 ) )
+            temp_array["guts"]["spawn_tags_array"][1] = level._zombie_gib_piece_index_left_arm;
+    }
+
+    if ( "head" == gib_ref && isdefined( self.torsodmg5 ) && isdefined( self.legdmg1 ) )
+    {
+        temp_array["head"]["body_model"] = self.torsodmg5;
+        temp_array["head"]["legs_model"] = self.legdmg1;
+        temp_array["head"]["spawn_tags_array"] = [];
+        temp_array["head"]["spawn_tags_array"][0] = level._zombie_gib_piece_index_head;
+
+        if ( !( isdefined( self.hat_gibbed ) && self.hat_gibbed ) && isdefined( self.gibspawn5 ) && isdefined( self.gibspawntag5 ) )
+            temp_array["head"]["spawn_tags_array"][1] = level._zombie_gib_piece_index_hat;
+    }
+
+    if ( isdefined( temp_array[gib_ref] ) )
+        return temp_array[gib_ref];
+    else
+        return undefined;
+}
+
+throw_gib( limb_tags_array )
+{
+    if ( isdefined( limb_tags_array ) )
+    {
+        if ( isdefined( level.track_gibs ) )
+            level [[ level.track_gibs ]]( self, limb_tags_array );
+
+        if ( isdefined( self.launch_gib_up ) )
+            self gib( "up", limb_tags_array );
+        else
+            self gib( "normal", limb_tags_array );
+    }
+}

ZM/Core/maps/mp/animscripts/zm_dog_combat.gsc

@@ -0,0 +1,492 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\zm_shared;
+#include maps\mp\animscripts\dog_stop;
+
+main()
+{
+    debug_anim_print( "dog_combat::main() " );
+    self endon( "killanimscript" );
+    self setaimanimweights( 0, 0 );
+/#
+    if ( !debug_allow_combat() )
+    {
+        combatidle();
+        return;
+    }
+#/
+    if ( isdefined( level.hostmigrationtimer ) )
+    {
+        combatidle();
+        return;
+    }
+
+    assert( isdefined( self.enemy ) );
+
+    if ( !isalive( self.enemy ) )
+    {
+        combatidle();
+        return;
+    }
+
+    if ( isplayer( self.enemy ) )
+        self meleebiteattackplayer( self.enemy );
+}
+
+combatidle()
+{
+    self set_orient_mode( "face enemy" );
+    self animmode( "zonly_physics" );
+    idleanim = "zm_combat_attackidle";
+    debug_anim_print( "dog_combat::combatIdle() - Setting " + idleanim );
+    self setanimstatefromasd( idleanim );
+    maps\mp\animscripts\zm_shared::donotetracks( "attack_combat" );
+    debug_anim_print( "dog_combat::combatIdle() - " + idleanim + " notify done." );
+}
+
+shouldwaitincombatidle()
+{
+    if ( isdefined( level.hostmigrationtimer ) )
+        return 1;
+
+    assert( isdefined( self.enemy ) && isalive( self.enemy ) );
+    return isdefined( self.enemy.dogattackallowtime ) && gettime() < self.enemy.dogattackallowtime;
+}
+
+setnextdogattackallowtime( time )
+{
+    self.dogattackallowtime = gettime() + time;
+}
+
+meleebiteattackplayer( player )
+{
+    self animmode( "gravity", 0 );
+    self.safetochangescript = 0;
+    prepareattackplayer( player );
+    attack_time = 1.2 + randomfloat( 0.4 );
+    debug_anim_print( "dog_combat::meleeBiteAttackPlayer() - Setting  combat_run_attack" );
+    self setanimstatefromasd( "zm_combat_attackidle" );
+    maps\mp\animscripts\zm_shared::donotetracksfortime( attack_time, "attack_combat", ::handlemeleebiteattacknotetracks, player );
+    debug_anim_print( "dog_combat::meleeBiteAttackPlayer() - combat_attack_run notify done." );
+    self.safetochangescript = 1;
+    self animmode( "none", 0 );
+}
+
+meleebiteattackplayer2( player )
+{
+    attackrangebuffer = 30;
+
+    for (;;)
+    {
+        if ( !isalive( self.enemy ) )
+            break;
+
+        meleerange = self.meleeattackdist + attackrangebuffer;
+
+        if ( isdefined( player.syncedmeleetarget ) && player.syncedmeleetarget != self )
+        {
+            if ( checkendcombat( meleerange ) )
+                break;
+            else
+            {
+                combatidle();
+                continue;
+            }
+        }
+
+        if ( self shouldwaitincombatidle() )
+        {
+            combatidle();
+            continue;
+        }
+
+        self set_orient_mode( "face enemy" );
+        self animmode( "gravity" );
+        self.safetochangescript = 0;
+/#
+        if ( getdvarint( _hash_7B06BF0D ) )
+            iprintln( "dog " + self getentnum() + " attack player " + gettime() );
+#/
+        player setnextdogattackallowtime( 200 );
+
+        if ( dog_cant_kill_in_one_hit( player ) )
+        {
+            level.lastdogmeleeplayertime = gettime();
+            level.dogmeleeplayercounter++;
+
+            if ( use_low_attack() )
+            {
+                self animmode( "angle deltas" );
+                self setanimstatefromasd( "zm_combat_attack_player_close_range" );
+                domeleeafterwait( 0.1 );
+                maps\mp\animscripts\zm_shared::donotetracksfortime( 1.4, "attack_combat" );
+                self animmode( "gravity" );
+            }
+            else
+            {
+                attack_time = 1.2 + randomfloat( 0.4 );
+                debug_anim_print( "dog_combat::meleeBiteAttackPlayer() - Setting  combat_run_attack" );
+                self setanimstatefromasd( "zm_combat_attackidle" );
+                domeleeafterwait( 0.1 );
+                maps\mp\animscripts\zm_shared::donotetracksfortime( attack_time, "attack_combat", ::handlemeleebiteattacknotetracks, player );
+                debug_anim_print( "dog_combat::meleeBiteAttackPlayer() - combat_attack_run notify done." );
+            }
+        }
+        else
+        {
+            self thread dog_melee_death( player );
+            player.attacked_by_dog = 1;
+            self thread clear_player_attacked_by_dog_on_death( player );
+            debug_anim_print( "dog_combat::meleeBiteAttackPlayer() - Setting  combat_attack_player" );
+            self setanimstate( "combat_attack_player" );
+            self maps\mp\animscripts\shared::donotetracks( "done", ::handlemeleefinishattacknotetracks, player );
+            debug_anim_print( "dog_combat::meleeBiteAttackPlayer() - combat_attack_player notify done." );
+            self notify( "dog_no_longer_melee_able" );
+            self setcandamage( 1 );
+            self unlink();
+        }
+
+        self.safetochangescript = 1;
+
+        if ( checkendcombat( meleerange ) )
+            break;
+    }
+
+    self.safetochangescript = 1;
+    self animmode( "none" );
+}
+
+domeleeafterwait( time )
+{
+    self endon( "death" );
+    wait( time );
+    hitent = self melee();
+
+    if ( isdefined( hitent ) )
+    {
+        if ( isplayer( hitent ) )
+            hitent shellshock( "dog_bite", 1 );
+    }
+}
+
+handlemeleebiteattacknotetracks2( note, player )
+{
+    if ( note == "dog_melee" )
+        self melee( anglestoforward( self.angles ) );
+}
+
+handlemeleebiteattacknotetracks( note, player )
+{
+    switch ( note )
+    {
+        case "dog_melee":
+            if ( !isdefined( level.dogmeleebiteattacktime ) )
+            {
+                level.dogmeleebiteattacktime = gettime() - level.dogmeleebiteattacktimestart;
+                level.dogmeleebiteattacktime += 50;
+            }
+
+            hitent = self melee( anglestoforward( self.angles ) );
+
+            if ( isdefined( hitent ) )
+            {
+                if ( isplayer( hitent ) )
+                    hitent shellshock( "dog_bite", 1 );
+            }
+            else if ( isdefined( level.dog_melee_miss ) )
+                self [[ level.dog_melee_miss ]]( player );
+
+            break;
+        case "stop_tracking":
+            melee_time = 200;
+
+            if ( !isdefined( level.dogmeleebiteattacktime ) )
+                level.dogmeleebiteattacktimestart = gettime();
+            else
+                melee_time = level.dogmeleebiteattacktime;
+
+            self thread orienttoplayerdeadreckoning( player, melee_time );
+            break;
+    }
+}
+
+handlemeleefinishattacknotetracks( note, player )
+{
+    switch ( note )
+    {
+        case "dog_melee":
+            if ( !isdefined( level.dogmeleefinishattacktime ) )
+            {
+                level.dogmeleefinishattacktime = gettime() - level.dogmeleefinishattacktimestart;
+                level.dogmeleefinishattacktime += 50;
+            }
+
+            hitent = self melee( anglestoforward( self.angles ) );
+
+            if ( isdefined( hitent ) && isalive( player ) )
+            {
+                if ( hitent == player )
+                    break;
+            }
+            else
+            {
+                attackmiss();
+                return 1;
+            }
+
+            break;
+        case "dog_early":
+            self notify( "dog_early_notetrack" );
+            debug_anim_print( "dog_combat::handleMeleeFinishAttackNoteTracks() - Setting  combat_attack_player_early" );
+            self setanimstate( "combat_attack_player_early" );
+            break;
+        case "dog_lunge":
+            thread set_melee_timer( player );
+            debug_anim_print( "dog_combat::handleMeleeFinishAttackNoteTracks() - Setting  combat_attack_player_lunge" );
+            self setanimstate( "combat_attack_player_lunge" );
+            break;
+        case "dogbite_damage":
+            self thread killplayer( player );
+            break;
+        case "stop_tracking":
+            melee_time = 200;
+
+            if ( !isdefined( level.dogmeleefinishattacktime ) )
+                level.dogmeleefinishattacktimestart = gettime();
+            else
+                melee_time = level.dogmeleefinishattacktime;
+
+            self thread orienttoplayerdeadreckoning( player, melee_time );
+            break;
+    }
+}
+
+orienttoplayerdeadreckoning( player, time_till_bite )
+{
+    enemy_attack_current_origin = player.origin;
+    enemy_attack_current_time = gettime();
+    enemy_motion_time_delta = enemy_attack_current_time - self.enemy_attack_start_time;
+    enemy_motion_direction = enemy_attack_current_origin - self.enemy_attack_start_origin;
+
+    if ( enemy_motion_time_delta == 0 )
+        enemy_predicted_position = player.origin;
+    else
+    {
+        enemy_velocity = enemy_motion_direction / enemy_motion_time_delta;
+        enemy_predicted_position = player.origin + enemy_velocity * time_till_bite;
+    }
+
+    self set_orient_mode( "face point", enemy_predicted_position );
+}
+
+checkendcombat( meleerange )
+{
+    if ( !isdefined( self.enemy ) )
+        return 0;
+
+    disttotargetsq = distancesquared( self.origin, self.enemy.origin );
+    return disttotargetsq > meleerange * meleerange;
+}
+
+use_low_attack( player )
+{
+    height_diff = self.enemy_attack_start_origin[2] - self.origin[2];
+    low_enough = 30.0;
+
+    if ( height_diff < low_enough && self.enemy_attack_start_stance == "prone" )
+        return true;
+
+    melee_origin = ( self.origin[0], self.origin[1], self.origin[2] + 65 );
+    enemy_origin = ( self.enemy.origin[0], self.enemy.origin[1], self.enemy.origin[2] + 32 );
+
+    if ( !bullettracepassed( melee_origin, enemy_origin, 0, self ) )
+        return true;
+
+    return false;
+}
+
+prepareattackplayer( player )
+{
+    level.dog_death_quote = &"SCRIPT_PLATFORM_DOG_DEATH_DO_NOTHING";
+    distancetotarget = distance( self.origin, self.enemy.origin );
+    targetheight = abs( self.enemy.origin[2] - self.origin[2] );
+    self.enemy_attack_start_distance = distancetotarget;
+    self.enemy_attack_start_origin = player.origin;
+    self.enemy_attack_start_time = gettime();
+    self.enemy_attack_start_stance = player getstance();
+}
+
+attackteleportthread( offset )
+{
+    self endon( "death" );
+    self endon( "killanimscript" );
+    reps = 5;
+    increment = ( offset[0] / reps, offset[1] / reps, offset[2] / reps );
+
+    for ( i = 0; i < reps; i++ )
+    {
+        self teleport( self.origin + increment );
+        wait 0.05;
+    }
+}
+
+player_attacked()
+{
+    return isalive( self ) && self meleebuttonpressed();
+}
+
+set_melee_timer( player )
+{
+    wait 0.15;
+    self.melee_able_timer = gettime();
+}
+
+clear_player_attacked_by_dog_on_death( player )
+{
+    self waittill( "death" );
+
+    player.attacked_by_dog = undefined;
+}
+
+dog_cant_kill_in_one_hit( player )
+{
+    return 1;
+
+    if ( isdefined( player.dogs_dont_instant_kill ) )
+    {
+        assert( player.dogs_dont_instant_kill, "Dont set player.dogs_dont_instant_kill to false, set to undefined" );
+        return 1;
+    }
+
+    if ( gettime() - level.lastdogmeleeplayertime > 8000 )
+        level.dogmeleeplayercounter = 0;
+
+    return level.dogmeleeplayercounter < level.dog_hits_before_kill && player.health > 25;
+}
+
+dog_melee_death( player )
+{
+    self endon( "killanimscript" );
+    self endon( "dog_no_longer_melee_able" );
+    pressed = 0;
+    press_time = anim.dog_presstime;
+
+    self waittill( "dog_early_notetrack" );
+
+    while ( player player_attacked() )
+        wait 0.05;
+
+    for (;;)
+    {
+        if ( !pressed )
+        {
+            if ( player player_attacked() )
+            {
+                pressed = 1;
+
+                if ( isdefined( self.melee_able_timer ) && isalive( player ) )
+                {
+                    if ( gettime() - self.melee_able_timer <= press_time )
+                    {
+                        player.player_view.custom_dog_save = "neck_snap";
+                        self notify( "melee_stop" );
+                        debug_anim_print( "dog_combat::dog_melee_death() - Setting  combat_player_neck_snap" );
+                        self setanimstate( "combat_player_neck_snap" );
+
+                        self waittillmatch( "done", "dog_death" );
+
+                        debug_anim_print( "dog_combat::dog_melee_death() - combat_player_neck_snap notify done." );
+                        self playsound( "aml_dog_neckbreak" );
+                        self setcandamage( 1 );
+                        self.a.nodeath = 1;
+                        dif = player.origin - self.origin;
+                        dif = ( dif[0], dif[1], 0 );
+                        self dodamage( self.health + 503, self geteye() - dif, player );
+                        self notify( "killanimscript" );
+                    }
+                    else
+                    {
+                        debug_anim_print( "dog_combat::dog_melee_death() - Setting  combat_player_neck_snap" );
+                        self setanimstate( "combat_attack_player" );
+                        level.dog_death_quote = &"SCRIPT_PLATFORM_DOG_DEATH_TOO_LATE";
+                    }
+
+                    return;
+                }
+
+                level.dog_death_quote = &"SCRIPT_PLATFORM_DOG_DEATH_TOO_SOON";
+                debug_anim_print( "dog_combat::dog_melee_death() - Setting  combat_player_neck_miss" );
+                self setanimstate( "combat_player_neck_miss" );
+                return;
+            }
+        }
+        else if ( !player player_attacked() )
+            pressed = 0;
+
+        wait 0.05;
+    }
+}
+
+attackmiss()
+{
+    if ( isdefined( self.enemy ) )
+    {
+        forward = anglestoforward( self.angles );
+        dirtoenemy = self.enemy.origin - self.origin + vectorscale( forward, 50 );
+
+        if ( vectordot( dirtoenemy, forward ) > 0 )
+        {
+            debug_anim_print( "dog_combat::attackMiss() - Setting  combat_attack_miss" );
+            self setanimstate( "combat_attack_miss" );
+            self thread maps\mp\animscripts\dog_stop::lookattarget( "normal" );
+        }
+        else
+        {
+            self.skipstartmove = 1;
+            self thread attackmisstracktargetthread();
+
+            if ( dirtoenemy[0] * forward[1] - dirtoenemy[1] * forward[0] > 0 )
+            {
+                debug_anim_print( "dog_combat::attackMiss() - Setting  combat_attack_miss_right" );
+                self setanimstate( "combat_attack_miss_right" );
+            }
+            else
+            {
+                debug_anim_print( "dog_combat::attackMiss() - Setting  combat_attack_miss_left" );
+                self setanimstate( "combat_attack_miss_left" );
+            }
+        }
+    }
+    else
+    {
+        debug_anim_print( "dog_combat::attackMiss() - Setting  combat_attack_miss" );
+        self setanimstate( "combat_attack_miss" );
+    }
+
+    self maps\mp\animscripts\shared::donotetracks( "done" );
+    debug_anim_print( "dog_combat::attackMiss() - attackMiss notify done." );
+    self notify( "stop tracking" );
+    debug_anim_print( "dog_combat::attackMiss() - Stopped tracking" );
+}
+
+attackmisstracktargetthread()
+{
+    self endon( "killanimscript" );
+    wait 0.6;
+    self set_orient_mode( "face enemy" );
+}
+
+killplayer( player )
+{
+    self endon( "pvd_melee_interrupted" );
+    player.specialdeath = 1;
+    player setcandamage( 1 );
+    wait 1;
+    damage = player.health + 1;
+
+    if ( !isalive( player ) )
+        return;
+}

ZM/Core/maps/mp/animscripts/zm_dog_death.gsc

@@ -0,0 +1,32 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\zm_shared;
+
+main()
+{
+    debug_anim_print( "dog_death::main()" );
+    self setaimanimweights( 0, 0 );
+    self endon( "killanimscript" );
+
+    if ( isdefined( self.a.nodeath ) )
+    {
+        assert( self.a.nodeath, "Nodeath needs to be set to true or undefined." );
+        wait 3;
+        return;
+    }
+
+    self unlink();
+
+    if ( isdefined( self.enemy ) && isdefined( self.enemy.syncedmeleetarget ) && self.enemy.syncedmeleetarget == self )
+        self.enemy.syncedmeleetarget = undefined;
+
+    death_anim = "death_" + getanimdirection( self.damageyaw );
+/#
+    println( death_anim );
+#/
+    self animmode( "gravity" );
+    debug_anim_print( "dog_death::main() - Setting " + death_anim );
+    self setanimstatefromasd( death_anim );
+    maps\mp\animscripts\zm_shared::donotetracks( "dead_dog" );
+}

ZM/Core/maps/mp/animscripts/zm_dog_flashed.gsc

@@ -0,0 +1,8 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+
+main()
+{
+    self endon( "killanimscript" );
+    self endon( "stop_flashbang_effect" );
+}

ZM/Core/maps/mp/animscripts/zm_dog_init.gsc

@@ -0,0 +1,59 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\dog_move;
+
+main()
+{
+    level.dog_debug_orient = 0;
+    level.dog_debug_anims = 0;
+    level.dog_debug_anims_ent = 0;
+    level.dog_debug_turns = 0;
+    debug_anim_print( "dog_init::main() " );
+    maps\mp\animscripts\dog_move::setup_sound_variables();
+    anim_get_dvar_int( "debug_dog_sound", "0" );
+    anim_get_dvar_int( "debug_dog_notetracks", "0" );
+    self.ignoresuppression = 1;
+    self.chatinitialized = 0;
+    self.nododgemove = 1;
+    level.dogattackplayerdist = 102;
+    level.dogattackplayercloserangedist = 102;
+    level.dogrunturnspeed = 20;
+    level.dogrunpainspeed = 20;
+    self.meleeattackdist = 0;
+    self thread setmeleeattackdist();
+    self.a = spawnstruct();
+    self.a.pose = "stand";
+    self.a.nextstandinghitdying = 0;
+    self.a.movement = "walk";
+    self.suppressionthreshold = 1;
+    self.disablearrivals = 0;
+    level.dogstoppingdistsq = 3416.82;
+    self.stopanimdistsq = level.dogstoppingdistsq;
+    self.pathenemyfightdist = 512;
+    self settalktospecies( "zombiedog" );
+    level.lastdogmeleeplayertime = 0;
+    level.dogmeleeplayercounter = 0;
+
+    if ( !isdefined( level.dog_hits_before_kill ) )
+        level.dog_hits_before_kill = 1;
+}
+
+setmeleeattackdist()
+{
+    self endon( "death" );
+
+    while ( true )
+    {
+        if ( isdefined( self.enemy ) )
+        {
+            if ( isplayer( self.enemy ) )
+                self.meleeattackdist = 64;
+            else
+                self.meleeattackdist = 102;
+        }
+
+        wait 1;
+    }
+}

ZM/Core/maps/mp/animscripts/zm_dog_jump.gsc

@@ -0,0 +1,16 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\zm_shared;
+
+main()
+{
+    self endon( "killanimscript" );
+    debug_anim_print( "dog_jump::main()" );
+    self setaimanimweights( 0, 0 );
+    self.safetochangescript = 0;
+    self setanimstatefromasd( "zm_traverse_wallhop" );
+    maps\mp\animscripts\zm_shared::donotetracks( "traverse_wallhop" );
+    self.safetochangescript = 1;
+}

ZM/Core/maps/mp/animscripts/zm_dog_move.gsc

@@ -0,0 +1,247 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\zm_shared;
+#include maps\mp\animscripts\dog_stop;
+#include maps\mp\animscripts\zm_utility;
+
+setup_sound_variables()
+{
+    level.dog_sounds["far"] = spawnstruct();
+    level.dog_sounds["close"] = spawnstruct();
+    level.dog_sounds["close"].minrange = 0;
+    level.dog_sounds["close"].maxrange = 500;
+    level.dog_sounds["close"].sound = "aml_dog_bark_close";
+    level.dog_sounds["close"].soundlengthplaceholder = 0.2;
+    level.dog_sounds["close"].aftersoundwaitmin = 0.1;
+    level.dog_sounds["close"].aftersoundwaitmax = 0.3;
+    level.dog_sounds["close"].minrangesqr = level.dog_sounds["close"].minrange * level.dog_sounds["close"].minrange;
+    level.dog_sounds["close"].maxrangesqr = level.dog_sounds["close"].maxrange * level.dog_sounds["close"].maxrange;
+    level.dog_sounds["far"].minrange = 500;
+    level.dog_sounds["far"].maxrange = 0;
+    level.dog_sounds["far"].sound = "aml_dog_bark";
+    level.dog_sounds["far"].soundlengthplaceholder = 0.2;
+    level.dog_sounds["far"].aftersoundwaitmin = 0.1;
+    level.dog_sounds["far"].aftersoundwaitmax = 0.3;
+    level.dog_sounds["far"].minrangesqr = level.dog_sounds["far"].minrange * level.dog_sounds["far"].minrange;
+    level.dog_sounds["far"].maxrangesqr = level.dog_sounds["far"].maxrange * level.dog_sounds["far"].maxrange;
+}
+
+main()
+{
+    self endon( "killanimscript" );
+    debug_anim_print( "dog_move::main()" );
+    self setaimanimweights( 0, 0 );
+    do_movement = 1;
+/#
+    if ( !debug_allow_movement() )
+        do_movement = 0;
+#/
+    if ( isdefined( level.hostmigrationtimer ) )
+        do_movement = 0;
+
+    if ( !isdefined( self.traversecomplete ) && !isdefined( self.skipstartmove ) && self.a.movement == "run" && do_movement )
+    {
+        self startmove();
+        blendtime = 0;
+    }
+    else
+        blendtime = 0.2;
+
+    self.traversecomplete = undefined;
+    self.skipstartmove = undefined;
+
+    if ( do_movement )
+    {
+        if ( self.a.movement == "run" )
+        {
+            debug_anim_print( "dog_move::main() - Setting move_run" );
+            self setanimstatefromasd( "zm_move_run" );
+            maps\mp\animscripts\zm_shared::donotetracksfortime( 0.1, "move_run" );
+            debug_anim_print( "dog_move::main() - move_run wait 0.1 done " );
+        }
+        else
+        {
+            debug_anim_print( "dog_move::main() - Setting move_start " );
+            self setanimstatefromasd( "zm_move_walk" );
+            maps\mp\animscripts\zm_shared::donotetracks( "move_walk" );
+        }
+    }
+
+    self thread maps\mp\animscripts\dog_stop::lookattarget( "normal" );
+
+    while ( true )
+    {
+        self moveloop();
+
+        if ( self.a.movement == "run" )
+        {
+            if ( self.disablearrivals == 0 )
+                self thread stopmove();
+
+            self waittill( "run" );
+        }
+    }
+}
+
+moveloop()
+{
+    self endon( "killanimscript" );
+    self endon( "stop_soon" );
+
+    while ( true )
+    {
+        do_movement = 1;
+/#
+        if ( !debug_allow_movement() )
+            do_movement = 0;
+#/
+        if ( isdefined( level.hostmigrationtimer ) )
+            do_movement = 0;
+
+        if ( !do_movement )
+        {
+            self setaimanimweights( 0, 0 );
+            self setanimstatefromasd( "zm_stop_idle" );
+            maps\mp\animscripts\zm_shared::donotetracks( "stop_idle" );
+            continue;
+        }
+
+        if ( self.disablearrivals )
+            self.stopanimdistsq = 0;
+        else
+            self.stopanimdistsq = level.dogstoppingdistsq;
+
+        if ( self.a.movement == "run" )
+        {
+            debug_anim_print( "dog_move::moveLoop() - Setting move_run" );
+            self setanimstatefromasd( "zm_move_run" );
+            maps\mp\animscripts\zm_shared::donotetracksfortime( 0.2, "move_run" );
+            debug_anim_print( "dog_move::moveLoop() - move_run wait 0.2 done " );
+        }
+        else
+        {
+            assert( self.a.movement == "walk" );
+            debug_anim_print( "dog_move::moveLoop() - Setting move_walk " );
+            self setanimstatefromasd( "zm_move_walk" );
+            maps\mp\animscripts\zm_shared::donotetracksfortime( 0.1, "move_walk" );
+
+            if ( self need_to_run() )
+            {
+                self.a.movement = "run";
+                self notify( "dog_running" );
+            }
+
+            debug_anim_print( "dog_move::moveLoop() - move_walk wait 0.2 done " );
+        }
+    }
+}
+
+startmovetracklookahead()
+{
+    self endon( "killanimscript" );
+
+    for ( i = 0; i < 2; i++ )
+    {
+        lookaheadangle = vectortoangles( self.lookaheaddir );
+        self set_orient_mode( "face angle", lookaheadangle );
+    }
+}
+
+startmove()
+{
+    debug_anim_print( "dog_move::startMove() - Setting move_start " );
+    self setanimstatefromasd( "zm_move_start" );
+    maps\mp\animscripts\zm_shared::donotetracks( "move_start" );
+    debug_anim_print( "dog_move::startMove() - move_start notify done." );
+    self animmode( "none" );
+    self set_orient_mode( "face motion" );
+}
+
+stopmove()
+{
+    self endon( "killanimscript" );
+    self endon( "run" );
+    debug_anim_print( "dog_move::stopMove() - Setting move_stop" );
+    self setanimstatefromasd( "zm_move_stop" );
+    maps\mp\animscripts\zm_shared::donotetracks( "move_stop" );
+    debug_anim_print( "dog_move::stopMove() - move_stop notify done." );
+}
+
+getenemydistancesqr()
+{
+    if ( isdefined( self.enemy ) )
+        return distancesquared( self.origin, self.enemy.origin );
+
+    return 100000000;
+}
+
+getsoundkey( distancesqr )
+{
+    keys = getarraykeys( level.dog_sounds );
+
+    for ( i = 0; i < keys.size; i++ )
+    {
+        sound_set = level.dog_sounds[keys[i]];
+
+        if ( sound_set.minrangesqr > distancesqr )
+            continue;
+
+        if ( sound_set.maxrangesqr && sound_set.maxrangesqr < distancesqr )
+            continue;
+
+        return keys[i];
+    }
+
+    return keys[keys.size - 1];
+}
+
+need_to_run()
+{
+    run_dist_squared = 147456;
+
+    if ( getdvar( _hash_C7E63BA4 ) != "" )
+    {
+        dist = getdvarint( _hash_C7E63BA4 );
+        run_dist_squared = dist * dist;
+    }
+
+    run_yaw = 20;
+    run_pitch = 30;
+    run_height = 64;
+
+    if ( self.a.movement != "walk" )
+        return false;
+
+    if ( self.health < self.maxhealth )
+        return true;
+
+    if ( !isdefined( self.enemy ) || !isalive( self.enemy ) )
+        return false;
+
+    if ( !self cansee( self.enemy ) )
+        return false;
+
+    dist = distancesquared( self.origin, self.enemy.origin );
+
+    if ( dist > run_dist_squared )
+        return false;
+
+    height = self.origin[2] - self.enemy.origin[2];
+
+    if ( abs( height ) > run_height )
+        return false;
+
+    yaw = self maps\mp\animscripts\zm_utility::absyawtoenemy();
+
+    if ( yaw > run_yaw )
+        return false;
+
+    pitch = angleclamp180( vectortoangles( self.origin - self.enemy.origin )[0] );
+
+    if ( abs( pitch ) > run_pitch )
+        return false;
+
+    return true;
+}

ZM/Core/maps/mp/animscripts/zm_dog_pain.gsc

@@ -0,0 +1,10 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+
+main()
+{
+    debug_anim_print( "dog_pain::main() " );
+    self endon( "killanimscript" );
+    self setaimanimweights( 0, 0 );
+}

ZM/Core/maps/mp/animscripts/zm_dog_stop.gsc

@@ -0,0 +1,143 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\zm_shared;
+
+main()
+{
+    debug_anim_print( "dog_stop::main()" );
+    self endon( "killanimscript" );
+    self setaimanimweights( 0, 0 );
+    self thread lookattarget( "attackIdle" );
+
+    while ( true )
+    {
+        if ( shouldattackidle() )
+        {
+            self randomattackidle();
+            maps\mp\animscripts\zm_shared::donotetracks( "attack_idle", ::dogidlenotetracks );
+        }
+        else
+        {
+            self set_orient_mode( "face current" );
+            debug_anim_print( "dog_stop::main() - Setting stop_idle" );
+            self notify( "stop tracking" );
+            self setaimanimweights( 0, 0 );
+            self setanimstatefromasd( "zm_stop_idle" );
+            maps\mp\animscripts\zm_shared::donotetracksfortime( 0.2, "stop_idle", ::dogidlenotetracks );
+            self thread lookattarget( "attackIdle" );
+        }
+
+        debug_anim_print( "dog_stop::main() - stop idle loop notify done." );
+    }
+}
+
+dogidlenotetracks( note )
+{
+    if ( note == "breathe_fire" )
+    {
+        if ( isdefined( level._effect["dog_breath"] ) )
+        {
+            self.breath_fx = spawn( "script_model", self gettagorigin( "TAG_MOUTH_FX" ) );
+            self.breath_fx.angles = self gettagangles( "TAG_MOUTH_FX" );
+            self.breath_fx setmodel( "tag_origin" );
+            self.breath_fx linkto( self, "TAG_MOUTH_FX" );
+            playfxontag( level._effect["dog_breath"], self.breath_fx, "tag_origin" );
+        }
+    }
+}
+
+isfacingenemy( tolerancecosangle )
+{
+    assert( isdefined( self.enemy ) );
+    vectoenemy = self.enemy.origin - self.origin;
+    disttoenemy = length( vectoenemy );
+
+    if ( disttoenemy < 1 )
+        return 1;
+
+    forward = anglestoforward( self.angles );
+    val1 = forward[0] * vectoenemy[0] + forward[1] * vectoenemy[1];
+    val2 = ( forward[0] * vectoenemy[0] + forward[1] * vectoenemy[1] ) / disttoenemy;
+    return ( forward[0] * vectoenemy[0] + forward[1] * vectoenemy[1] ) / disttoenemy > tolerancecosangle;
+}
+
+randomattackidle()
+{
+    if ( isfacingenemy( -0.5 ) )
+        self set_orient_mode( "face current" );
+    else
+        self set_orient_mode( "face enemy" );
+
+    if ( should_growl() )
+    {
+        debug_anim_print( "dog_stop::main() - Setting stop_attackidle_growl" );
+        self setanimstatefromasd( "zm_stop_attackidle_growl" );
+        return;
+    }
+
+    idlechance = 33;
+    barkchance = 66;
+
+    if ( isdefined( self.mode ) )
+    {
+        if ( self.mode == "growl" )
+        {
+            idlechance = 15;
+            barkchance = 30;
+        }
+        else if ( self.mode == "bark" )
+        {
+            idlechance = 15;
+            barkchance = 85;
+        }
+    }
+
+    rand = randomint( 100 );
+
+    if ( rand < idlechance )
+    {
+        debug_anim_print( "dog_stop::main() - Setting stop_attackidle" );
+        self setanimstatefromasd( "zm_stop_attackidle" );
+    }
+    else if ( rand < barkchance )
+    {
+        debug_anim_print( "dog_stop::main() - Setting stop_attackidle_bark " );
+        self setanimstatefromasd( "zm_stop_attackidle_bark" );
+    }
+    else
+    {
+        debug_anim_print( "dog_stop::main() - Setting stop_attackidle_growl " );
+        self setanimstatefromasd( "zm_stop_attackidle_growl" );
+    }
+}
+
+shouldattackidle()
+{
+    return isdefined( self.enemy ) && isalive( self.enemy ) && distancesquared( self.origin, self.enemy.origin ) < 1000000;
+}
+
+should_growl()
+{
+    if ( isdefined( self.script_growl ) )
+        return 1;
+
+    if ( !isalive( self.enemy ) )
+        return 1;
+
+    return !self cansee( self.enemy );
+}
+
+lookattarget( lookposeset )
+{
+    self endon( "killanimscript" );
+    self endon( "stop tracking" );
+    debug_anim_print( "dog_stop::lookAtTarget() - Starting look at " + lookposeset );
+    self.rightaimlimit = 90;
+    self.leftaimlimit = -90;
+    self.upaimlimit = 45;
+    self.downaimlimit = -45;
+    self maps\mp\animscripts\shared::setanimaimweight( 1, 0.2 );
+    self maps\mp\animscripts\shared::trackloop();
+}

ZM/Core/maps/mp/animscripts/zm_dog_turn.gsc

@@ -0,0 +1,138 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\zm_shared;
+
+main()
+{
+    self endon( "killanimscript" );
+    debug_anim_print( "dog_turn::main()" );
+    self setaimanimweights( 0, 0 );
+    self.safetochangescript = 0;
+    deltayaw = self getdeltaturnyaw();
+
+    if ( need_to_turn_around( deltayaw ) )
+        turn_180( deltayaw );
+    else
+        turn_90( deltayaw );
+
+    move_out_of_turn();
+    self.skipstartmove = 1;
+    self.safetochangescript = 1;
+}
+
+need_to_turn_around( deltayaw )
+{
+    angle = getdvarfloat( "dog_turn180_angle" );
+
+    if ( deltayaw > angle || deltayaw < -1 * angle )
+    {
+        debug_turn_print( "need_to_turn_around: " + deltayaw + " YES" );
+        return true;
+    }
+
+    debug_turn_print( "need_to_turn_around: " + deltayaw + " NO" );
+    return false;
+}
+
+do_turn_anim( stopped_anim, run_anim, wait_time, run_wait_time )
+{
+    speed = length( self getvelocity() );
+    do_anim = stopped_anim;
+
+    if ( level.dogrunturnspeed < speed )
+    {
+        do_anim = run_anim;
+        wait_time = run_wait_time;
+    }
+
+    debug_anim_print( "dog_move::do_turn_anim() - Setting " + do_anim );
+    self setanimstatefromasd( do_anim );
+    maps\mp\animscripts\zm_shared::donotetracksfortime( run_wait_time, "move_turn" );
+    debug_anim_print( "dog_move::turn_around_right() - done with " + do_anim + " wait time " + run_wait_time );
+}
+
+turn_left()
+{
+    self do_turn_anim( "move_turn_left", "move_run_turn_left", 0.5, 0.5 );
+}
+
+turn_right()
+{
+    self do_turn_anim( "move_turn_right", "move_run_turn_right", 0.5, 0.5 );
+}
+
+turn_180_left()
+{
+    self do_turn_anim( "move_turn_around_left", "move_run_turn_around_left", 0.5, 0.7 );
+}
+
+turn_180_right()
+{
+    self do_turn_anim( "move_turn_around_right", "move_run_turn_around_right", 0.5, 0.7 );
+}
+
+move_out_of_turn()
+{
+    if ( self.a.movement == "run" )
+    {
+        debug_anim_print( "dog_move::move_out_of_turn() - Setting move_run" );
+        self setanimstatefromasd( "zm_move_run" );
+        maps\mp\animscripts\zm_shared::donotetracksfortime( 0.1, "move_run" );
+        debug_anim_print( "dog_move::move_out_of_turn() - move_run wait 0.1 done " );
+    }
+    else
+    {
+        debug_anim_print( "dog_move::move_out_of_turn() - Setting move_start " );
+        self setanimstatefromasd( "zm_move_walk" );
+        maps\mp\animscripts\zm_shared::donotetracks( "move_walk" );
+    }
+}
+
+turn_90( deltayaw )
+{
+    self animmode( "zonly_physics" );
+    debug_turn_print( "turn_90 deltaYaw: " + deltayaw );
+
+    if ( deltayaw > getdvarfloat( "dog_turn90_angle" ) )
+    {
+        debug_turn_print( "turn_90 left", 1 );
+        self turn_left();
+    }
+    else
+    {
+        debug_turn_print( "turn_90 right", 1 );
+        self turn_right();
+    }
+}
+
+turn_180( deltayaw )
+{
+    self animmode( "zonly_physics" );
+    debug_turn_print( "turn_180 deltaYaw: " + deltayaw );
+
+    if ( deltayaw > 177 || deltayaw < -177 )
+    {
+        if ( randomint( 2 ) == 0 )
+        {
+            debug_turn_print( "turn_around random right", 1 );
+            self turn_180_right();
+        }
+        else
+        {
+            debug_turn_print( "turn_around random left", 1 );
+            self turn_180_left();
+        }
+    }
+    else if ( deltayaw > getdvarfloat( "dog_turn180_angle" ) )
+    {
+        debug_turn_print( "turn_around left", 1 );
+        self turn_180_left();
+    }
+    else
+    {
+        debug_turn_print( "turn_around right", 1 );
+        self turn_180_right();
+    }
+}

ZM/Core/maps/mp/animscripts/zm_flashed.gsc

@@ -0,0 +1,9 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\shared;
+
+main()
+{
+
+}

ZM/Core/maps/mp/animscripts/zm_init.gsc

@@ -0,0 +1,165 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\zm_utility;
+#include maps\mp\animscripts\zm_init;
+#include maps\mp\animscripts\zm_shared;
+
+main()
+{
+    self.a = spawnstruct();
+    self.team = level.zombie_team;
+    firstinit();
+    self.a.pose = "stand";
+    self.a.movement = "stop";
+    self.a.state = "stop";
+    self.a.special = "none";
+    self.a.combatendtime = gettime();
+    self.a.script = "init";
+    self.a.alertness = "casual";
+    self.a.lastenemytime = gettime();
+    self.a.forced_cover = "none";
+    self.a.desired_script = "none";
+    self.a.current_script = "none";
+    self.a.lookangle = 0;
+    self.a.paintime = 0;
+    self.a.nextgrenadetrytime = 0;
+    self.walk = 0;
+    self.sprint = 0;
+    self.a.runblendtime = 0.2;
+    self.a.flamepaintime = 0;
+    self.a.postscriptfunc = undefined;
+    self.a.stance = "stand";
+    self._animactive = 0;
+    self thread deathnotify();
+    self.baseaccuracy = self.accuracy;
+
+    if ( !isdefined( self.script_accuracy ) )
+        self.script_accuracy = 1;
+
+    self.a.misstime = 0;
+    self.a.yawtransition = "none";
+    self.a.nodeath = 0;
+    self.a.misstime = 0;
+    self.a.misstimedebounce = 0;
+    self.a.disablepain = 0;
+    self.accuracystationarymod = 1;
+    self.chatinitialized = 0;
+    self.sightpostime = 0;
+    self.sightposleft = 1;
+    self.precombatrunenabled = 1;
+    self.is_zombie = 1;
+    self.a.crouchpain = 0;
+    self.a.nextstandinghitdying = 0;
+
+    if ( !isdefined( self.script_forcegrenade ) )
+        self.script_forcegrenade = 0;
+/#
+    self.a.lastdebugprint = "";
+#/
+    self.lastenemysighttime = 0;
+    self.combattime = 0;
+    self.coveridleselecttime = -696969;
+    self.old = spawnstruct();
+    self.reacquire_state = 0;
+    self.a.allow_shooting = 0;
+}
+
+donothing()
+{
+
+}
+
+empty( one, two, three, whatever )
+{
+
+}
+
+clearenemy()
+{
+    self notify( "stop waiting for enemy to die" );
+    self endon( "stop waiting for enemy to die" );
+
+    self.sightenemy waittill( "death" );
+
+    self.sightpos = undefined;
+    self.sighttime = 0;
+    self.sightenemy = undefined;
+}
+
+deathnotify()
+{
+    self waittill( "death", other );
+
+    self notify( anim.scriptchange );
+}
+
+firstinit()
+{
+    if ( isdefined( anim.notfirsttime ) )
+        return;
+
+    anim.notfirsttime = 1;
+    anim.usefacialanims = 0;
+
+    if ( !isdefined( anim.dog_health ) )
+        anim.dog_health = 1;
+
+    if ( !isdefined( anim.dog_presstime ) )
+        anim.dog_presstime = 350;
+
+    if ( !isdefined( anim.dog_hits_before_kill ) )
+        anim.dog_hits_before_kill = 1;
+
+    level.nextgrenadedrop = randomint( 3 );
+    level.lastplayersighted = 100;
+    anim.defaultexception = maps\mp\animscripts\zm_init::empty;
+    setdvar( "scr_expDeathMayMoveCheck", "on" );
+    anim.lastsidestepanim = 0;
+    anim.meleerange = 64;
+    anim.meleerangesq = anim.meleerange * anim.meleerange;
+    anim.standrangesq = 262144;
+    anim.chargerangesq = 40000;
+    anim.chargelongrangesq = 262144;
+    anim.aivsaimeleerangesq = 160000;
+    anim.combatmemorytimeconst = 10000;
+    anim.combatmemorytimerand = 6000;
+    anim.scriptchange = "script_change";
+    anim.lastgibtime = 0;
+    anim.gibdelay = 3000;
+    anim.mingibs = 2;
+    anim.maxgibs = 4;
+    anim.totalgibs = randomintrange( anim.mingibs, anim.maxgibs );
+    anim.corner_straight_yaw_limit = 36;
+
+    if ( !isdefined( anim.optionalstepeffectfunction ) )
+    {
+        anim.optionalstepeffects = [];
+        anim.optionalstepeffectfunction = ::empty;
+    }
+
+    anim.notetracks = [];
+    maps\mp\animscripts\zm_shared::registernotetracks();
+
+    if ( !isdefined( level.flag ) )
+    {
+        level.flag = [];
+        level.flags_lock = [];
+    }
+
+    level.painai = undefined;
+    anim.maymovecheckenabled = 1;
+    anim.badplaces = [];
+    anim.badplaceint = 0;
+    anim.covercrouchleanpitch = -55;
+    anim.lastcarexplosiontime = -100000;
+}
+
+onplayerconnect()
+{
+    player = self;
+    firstinit();
+    player.invul = 0;
+}

ZM/Core/maps/mp/animscripts/zm_jump.gsc

@@ -0,0 +1,9 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\shared;
+
+main()
+{
+
+}

ZM/Core/maps/mp/animscripts/zm_melee.gsc

@@ -0,0 +1,269 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\zm_utility;
+#include maps\mp\animscripts\zm_combat;
+
+meleecombat()
+{
+    self endon( "end_melee" );
+    self endon( "killanimscript" );
+    assert( canmeleeanyrange() );
+    self orientmode( "face enemy" );
+
+    if ( is_true( self.sliding_on_goo ) )
+        self animmode( "slide" );
+    else
+        self animmode( "zonly_physics" );
+
+    for (;;)
+    {
+        if ( isdefined( self.marked_for_death ) )
+            return;
+
+        if ( isdefined( self.enemy ) )
+        {
+            angles = vectortoangles( self.enemy.origin - self.origin );
+            self orientmode( "face angle", angles[1] );
+        }
+
+        if ( isdefined( self.zmb_vocals_attack ) )
+            self playsound( self.zmb_vocals_attack );
+
+        if ( isdefined( self.nochangeduringmelee ) && self.nochangeduringmelee )
+            self.safetochangescript = 0;
+
+        if ( isdefined( self.is_inert ) && self.is_inert )
+            return;
+
+        set_zombie_melee_anim_state( self );
+
+        if ( isdefined( self.melee_anim_func ) )
+            self thread [[ self.melee_anim_func ]]();
+
+        while ( true )
+        {
+            self waittill( "melee_anim", note );
+
+            if ( note == "end" )
+                break;
+            else if ( note == "fire" )
+            {
+                if ( !isdefined( self.enemy ) )
+                    break;
+
+                if ( isdefined( self.dont_die_on_me ) && self.dont_die_on_me )
+                    break;
+
+                self.enemy notify( "melee_swipe", self );
+                oldhealth = self.enemy.health;
+                self melee();
+
+                if ( !isdefined( self.enemy ) )
+                    break;
+
+                if ( self.enemy.health >= oldhealth )
+                {
+                    if ( isdefined( self.melee_miss_func ) )
+                        self [[ self.melee_miss_func ]]();
+                    else if ( isdefined( level.melee_miss_func ) )
+                        self [[ level.melee_miss_func ]]();
+                }
+/#
+                if ( getdvarint( _hash_7F11F572 ) )
+                {
+                    if ( self.enemy.health < oldhealth )
+                    {
+                        zombie_eye = self geteye();
+                        player_eye = self.enemy geteye();
+                        trace = bullettrace( zombie_eye, player_eye, 1, self );
+                        hitpos = trace["position"];
+                        dist = distance( zombie_eye, hitpos );
+                        iprintln( "melee HIT " + dist );
+                    }
+                }
+#/
+            }
+            else if ( note == "stop" )
+            {
+                if ( !cancontinuetomelee() )
+                    break;
+            }
+        }
+
+        if ( is_true( self.sliding_on_goo ) )
+            self orientmode( "face enemy" );
+        else
+            self orientmode( "face default" );
+
+        if ( isdefined( self.nochangeduringmelee ) && self.nochangeduringmelee || is_true( self.sliding_on_goo ) )
+        {
+            if ( isdefined( self.enemy ) )
+            {
+                dist_sq = distancesquared( self.origin, self.enemy.origin );
+
+                if ( dist_sq > self.meleeattackdist * self.meleeattackdist )
+                {
+                    self.safetochangescript = 1;
+                    wait 0.1;
+                    break;
+                }
+            }
+            else
+            {
+                self.safetochangescript = 1;
+                wait 0.1;
+                break;
+            }
+        }
+    }
+
+    if ( is_true( self.sliding_on_goo ) )
+        self animmode( "slide" );
+    else
+        self animmode( "none" );
+
+    self thread maps\mp\animscripts\zm_combat::main();
+}
+
+cancontinuetomelee()
+{
+    return canmeleeinternal( "already started" );
+}
+
+canmeleeanyrange()
+{
+    return canmeleeinternal( "any range" );
+}
+
+canmeleedesperate()
+{
+    return canmeleeinternal( "long range" );
+}
+
+canmelee()
+{
+    return canmeleeinternal( "normal" );
+}
+
+canmeleeinternal( state )
+{
+    if ( !issentient( self.enemy ) )
+        return false;
+
+    if ( !isalive( self.enemy ) )
+        return false;
+
+    if ( isdefined( self.disablemelee ) )
+    {
+        assert( self.disablemelee );
+        return false;
+    }
+
+    yaw = abs( getyawtoenemy() );
+
+    if ( yaw > 60 && state != "already started" || yaw > 110 )
+        return false;
+
+    enemypoint = self.enemy getorigin();
+    vectoenemy = enemypoint - self.origin;
+    self.enemydistancesq = lengthsquared( vectoenemy );
+
+    if ( self.enemydistancesq <= anim.meleerangesq )
+    {
+        if ( !ismeleepathclear( vectoenemy, enemypoint ) )
+            return false;
+
+        return true;
+    }
+
+    if ( state != "any range" )
+    {
+        chargerangesq = anim.chargerangesq;
+
+        if ( state == "long range" )
+            chargerangesq = anim.chargelongrangesq;
+
+        if ( self.enemydistancesq > chargerangesq )
+            return false;
+    }
+
+    if ( state == "already started" )
+        return false;
+
+    if ( isdefined( self.check_melee_path ) && self.check_melee_path )
+    {
+        if ( !ismeleepathclear( vectoenemy, enemypoint ) )
+        {
+            self notify( "melee_path_blocked" );
+            return false;
+        }
+    }
+
+    if ( isdefined( level.can_melee ) )
+    {
+        if ( !self [[ level.can_melee ]]() )
+            return false;
+    }
+
+    return true;
+}
+
+ismeleepathclear( vectoenemy, enemypoint )
+{
+    dirtoenemy = vectornormalize( ( vectoenemy[0], vectoenemy[1], 0 ) );
+    meleepoint = enemypoint - ( dirtoenemy[0] * 28, dirtoenemy[1] * 28, 0 );
+
+    if ( !self isingoal( meleepoint ) )
+        return false;
+
+    if ( self maymovetopoint( meleepoint ) )
+        return true;
+
+    trace1 = bullettrace( self.origin + vectorscale( ( 0, 0, 1 ), 20.0 ), meleepoint + vectorscale( ( 0, 0, 1 ), 20.0 ), 1, self );
+    trace2 = bullettrace( self.origin + vectorscale( ( 0, 0, 1 ), 72.0 ), meleepoint + vectorscale( ( 0, 0, 1 ), 72.0 ), 1, self );
+
+    if ( isdefined( trace1["fraction"] ) && trace1["fraction"] == 1 && isdefined( trace2["fraction"] ) && trace2["fraction"] == 1 )
+        return true;
+
+    if ( isdefined( trace1["entity"] ) && trace1["entity"] == self.enemy && isdefined( trace2["entity"] ) && trace2["entity"] == self.enemy )
+        return true;
+
+    if ( isdefined( level.zombie_melee_in_water ) && level.zombie_melee_in_water )
+    {
+        if ( isdefined( trace1["surfacetype"] ) && trace1["surfacetype"] == "water" && isdefined( trace2["fraction"] ) && trace2["fraction"] == 1 )
+            return true;
+    }
+
+    return false;
+}
+
+set_zombie_melee_anim_state( zombie )
+{
+    if ( isdefined( level.melee_anim_state ) )
+        melee_anim_state = self [[ level.melee_anim_state ]]();
+
+    if ( !isdefined( melee_anim_state ) )
+    {
+        if ( !zombie.has_legs && zombie.a.gib_ref == "no_legs" )
+            melee_anim_state = "zm_stumpy_melee";
+        else
+        {
+            switch ( zombie.zombie_move_speed )
+            {
+                case "walk":
+                    melee_anim_state = append_missing_legs_suffix( "zm_walk_melee" );
+                    break;
+                case "sprint":
+                case "run":
+                default:
+                    melee_anim_state = append_missing_legs_suffix( "zm_run_melee" );
+                    break;
+            }
+        }
+    }
+
+    zombie setanimstatefromasd( melee_anim_state );
+}

ZM/Core/maps/mp/animscripts/zm_move.gsc

@@ -0,0 +1,255 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\zm_utility;
+#include maps\mp\animscripts\zm_run;
+#include maps\mp\animscripts\zm_shared;
+
+main()
+{
+    self endon( "killanimscript" );
+    self setaimanimweights( 0, 0 );
+    previousscript = self.a.script;
+    maps\mp\animscripts\zm_utility::initialize( "zombie_move" );
+    movemainloop();
+}
+
+movemainloop()
+{
+    self endon( "killanimscript" );
+    self endon( "stop_soon" );
+    self.needs_run_update = 1;
+    self notify( "needs_run_update" );
+    self sidestepinit();
+    self thread trysidestepthread();
+
+    for (;;)
+    {
+        self maps\mp\animscripts\zm_run::moverun();
+
+        if ( isdefined( self.zombie_can_sidestep ) && self.zombie_can_sidestep )
+            self trysidestep();
+    }
+}
+
+sidestepinit()
+{
+    self.a.steppeddir = 0;
+    self.a.lastsidesteptime = gettime();
+}
+
+trysidestepthread()
+{
+    self endon( "death" );
+    self notify( "new_trySideStepThread" );
+    self endon( "new_trySideStepThread" );
+
+    if ( !isdefined( self.zombie_can_sidestep ) )
+        return false;
+
+    if ( isdefined( self.zombie_can_sidestep ) && !self.zombie_can_sidestep )
+        return false;
+
+    while ( true )
+    {
+        self trysidestep();
+        wait 0.05;
+    }
+}
+
+trysidestep()
+{
+    if ( isdefined( self.shouldsidestepfunc ) )
+        self.sidesteptype = self [[ self.shouldsidestepfunc ]]();
+    else
+        self.sidesteptype = shouldsidestep();
+
+    if ( self.sidesteptype == "none" )
+    {
+        if ( isdefined( self.zombie_can_forwardstep ) && self.zombie_can_forwardstep )
+            self.sidesteptype = shouldforwardstep();
+    }
+
+    if ( self.sidesteptype == "none" )
+        return false;
+
+    self.desiredstepdir = getdesiredsidestepdir( self.sidesteptype );
+    self.asd_name = "zm_" + self.sidesteptype + "_" + self.desiredstepdir;
+    self.substate_index = self getanimsubstatefromasd( self.asd_name );
+    self.stepanim = self getanimfromasd( self.asd_name, self.substate_index );
+
+    if ( !self checkroomforanim( self.stepanim ) )
+        return false;
+
+    self.allowpain = 0;
+    self animcustom( ::dosidestep );
+
+    self waittill( "sidestep_done" );
+
+    self.allowpain = 1;
+}
+
+getdesiredsidestepdir( sidesteptype )
+{
+    if ( sidesteptype == "roll" || sidesteptype == "phase" )
+    {
+        self.desiredstepdir = "forward";
+        return self.desiredstepdir;
+    }
+
+    assert( sidesteptype == "step", "Unsupported SideStepType" );
+    randomroll = randomfloat( 1 );
+
+    if ( self.a.steppeddir < 0 )
+        self.desiredstepdir = "right";
+    else if ( self.a.steppeddir > 0 )
+        self.desiredstepdir = "left";
+    else if ( randomroll < 0.5 )
+        self.desiredstepdir = "right";
+    else
+        self.desiredstepdir = "left";
+
+    return self.desiredstepdir;
+}
+
+checkroomforanim( stepanim )
+{
+    if ( !self maymovefrompointtopoint( self.origin, getanimendpos( stepanim ) ) )
+        return false;
+
+    return true;
+}
+
+shouldsidestep()
+{
+    if ( cansidestep() && isplayer( self.enemy ) && self.enemy islookingat( self ) )
+    {
+        if ( self.zombie_move_speed != "sprint" || randomfloat( 1 ) < 0.7 )
+            return "step";
+        else
+            return "roll";
+    }
+
+    return "none";
+}
+
+cansidestep()
+{
+    if ( !isdefined( self.zombie_can_sidestep ) || !self.zombie_can_sidestep )
+        return false;
+
+    if ( gettime() - self.a.lastsidesteptime < 2000 )
+        return false;
+
+    if ( !isdefined( self.enemy ) )
+        return false;
+
+    if ( self.a.pose != "stand" )
+        return false;
+
+    distsqfromenemy = distancesquared( self.origin, self.enemy.origin );
+
+    if ( distsqfromenemy < 4096 )
+        return false;
+
+    if ( distsqfromenemy > 1000000 )
+        return false;
+
+    if ( !isdefined( self.pathgoalpos ) || distancesquared( self.origin, self.pathgoalpos ) < 4096 )
+        return false;
+
+    if ( abs( self getmotionangle() ) > 15 )
+        return false;
+
+    yaw = getyawtoorigin( self.enemy.origin );
+
+    if ( abs( yaw ) > 45 )
+        return false;
+
+    return true;
+}
+
+shouldforwardstep()
+{
+    if ( canforwardstep() && isplayer( self.enemy ) )
+        return "phase";
+
+    return "none";
+}
+
+canforwardstep()
+{
+    if ( isdefined( self.a.lastsidesteptime ) && gettime() - self.a.lastsidesteptime < 2000 )
+        return false;
+
+    if ( !isdefined( self.enemy ) )
+        return false;
+
+    if ( self.a.pose != "stand" )
+        return false;
+
+    distsqfromenemy = distancesquared( self.origin, self.enemy.origin );
+
+    if ( distsqfromenemy < 14400 )
+        return false;
+
+    if ( distsqfromenemy > 5760000 )
+        return false;
+
+    if ( !isdefined( self.pathgoalpos ) || distancesquared( self.origin, self.pathgoalpos ) < 4096 )
+        return false;
+
+    if ( abs( self getmotionangle() ) > 15 )
+        return false;
+
+    yaw = getyawtoorigin( self.enemy.origin );
+
+    if ( abs( yaw ) > 45 )
+        return false;
+
+    return true;
+}
+
+dosidestep()
+{
+    self endon( "death" );
+    self endon( "killanimscript" );
+    self playsidestepanim( self.stepanim, self.sidesteptype );
+
+    if ( self.desiredstepdir == "left" )
+        self.a.steppeddir--;
+    else
+        self.a.steppeddir++;
+
+    self.a.lastsidesteptime = gettime();
+    self notify( "sidestep_done" );
+}
+
+playsidestepanim( stepanim, sidesteptype )
+{
+    self animmode( "gravity", 0 );
+    self orientmode( "face angle", self.angles[1] );
+    runblendouttime = 0.2;
+
+    if ( isdefined( self.sidestepfunc ) )
+        self thread [[ self.sidestepfunc ]]( "step_anim", stepanim );
+
+    self setanimstatefromasd( self.asd_name, self.substate_index );
+    maps\mp\animscripts\zm_shared::donotetracks( "step_anim" );
+
+    if ( isalive( self ) )
+        self thread facelookaheadforabit();
+}
+
+facelookaheadforabit()
+{
+    self endon( "death" );
+    self endon( "killanimscript" );
+    lookaheadangles = vectortoangles( self.lookaheaddir );
+    self orientmode( "face angle", lookaheadangles[1] );
+    wait 0.2;
+    self animmode( "normal", 0 );
+    self orientmode( "face default" );
+}

ZM/Core/maps/mp/animscripts/zm_pain.gsc

@@ -0,0 +1,21 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\zm_utility;
+
+main()
+{
+    self setflashbanged( 0 );
+
+    if ( isdefined( self.longdeathstarting ) )
+    {
+        self waittill( "killanimscript" );
+
+        return;
+    }
+
+    if ( self.a.disablepain )
+        return;
+}

ZM/Core/maps/mp/animscripts/zm_run.gsc

@@ -0,0 +1,61 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\zm_utility;
+#include maps\mp\animscripts\zm_shared;
+
+moverun()
+{
+    self endon( "death" );
+
+    if ( isdefined( self.needs_run_update ) && !self.needs_run_update )
+        self waittill( "needs_run_update" );
+
+    if ( isdefined( self.is_inert ) && self.is_inert )
+    {
+        wait 0.1;
+        return;
+    }
+
+    self setaimanimweights( 0, 0 );
+    self setanimstatefromspeed();
+    maps\mp\animscripts\zm_shared::donotetracksfortime( 0.05, "move_anim" );
+    self.needs_run_update = 0;
+}
+
+setanimstatefromspeed()
+{
+    animstate = self append_missing_legs_suffix( "zm_move_" + self.zombie_move_speed );
+
+    if ( isdefined( self.a.gib_ref ) && self.a.gib_ref == "no_legs" )
+        animstate = "zm_move_stumpy";
+
+    if ( isdefined( self.preserve_asd_substates ) && self.preserve_asd_substates && animstate == self getanimstatefromasd() )
+    {
+        substate = self getanimsubstatefromasd();
+        self setanimstatefromasd( animstate, substate );
+    }
+    else
+        self setanimstatefromasd( animstate );
+
+    if ( isdefined( self.setanimstatefromspeed ) )
+        self [[ self.setanimstatefromspeed ]]( animstate, substate );
+}
+
+needsupdate()
+{
+    self.needs_run_update = 1;
+    self notify( "needs_run_update" );
+}
+
+needsdelayedupdate()
+{
+    self endon( "death" );
+
+    while ( isdefined( self.needs_run_update ) && self.needs_run_update )
+        wait 0.1;
+
+    self.needs_run_update = 1;
+    self notify( "needs_run_update" );
+}

ZM/Core/maps/mp/animscripts/zm_scripted.gsc

@@ -0,0 +1,39 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+
+main()
+{
+    self endon( "death" );
+    self notify( "killanimscript" );
+    self endon( "end_sequence" );
+
+    if ( !isdefined( self.codescripted["animState"] ) )
+        return;
+
+    self startscriptedanim( self.codescripted["origin"], self.codescripted["angles"], self.codescripted["animState"], self.codescripted["animSubState"], self.codescripted["AnimMode"] );
+    self.a.script = "scripted";
+    self.codescripted = undefined;
+
+    if ( isdefined( self.deathstring_passed ) )
+        self.deathstring = self.deathstring_passed;
+
+    self waittill( "killanimscript" );
+}
+
+init( origin, angles, animstate, animsubstate, animmode )
+{
+    self.codescripted["origin"] = origin;
+    self.codescripted["angles"] = angles;
+    self.codescripted["animState"] = animstate;
+    self.codescripted["animSubState"] = animsubstate;
+
+    if ( isdefined( animmode ) )
+        self.codescripted["AnimMode"] = animmode;
+    else
+        self.codescripted["AnimMode"] = "normal";
+}
+
+end_script()
+{
+
+}

ZM/Core/maps/mp/animscripts/zm_shared.gsc

@@ -0,0 +1,455 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\zm_utility;
+
+deleteatlimit()
+{
+    wait 30.0;
+    self delete();
+}
+
+lookatentity( looktargetentity, lookduration, lookspeed, eyesonly, interruptothers )
+{
+
+}
+
+lookatposition( looktargetpos, lookduration, lookspeed, eyesonly, interruptothers )
+{
+    assert( isai( self ), "Can only call this function on an AI character" );
+    assert( self.a.targetlookinitilized == 1, "LookAtPosition called on AI that lookThread was not called on" );
+    assert( lookspeed == "casual" || lookspeed == "alert", "lookSpeed must be casual or alert" );
+
+    if ( !isdefined( interruptothers ) || interruptothers == "interrupt others" || gettime() > self.a.lookendtime )
+    {
+        self.a.looktargetpos = looktargetpos;
+        self.a.lookendtime = gettime() + lookduration * 1000;
+
+        if ( lookspeed == "casual" )
+            self.a.looktargetspeed = 800;
+        else
+            self.a.looktargetspeed = 1600;
+
+        if ( isdefined( eyesonly ) && eyesonly == "eyes only" )
+            self notify( "eyes look now" );
+        else
+            self notify( "look now" );
+    }
+}
+
+lookatanimations( leftanim, rightanim )
+{
+    self.a.lookanimationleft = leftanim;
+    self.a.lookanimationright = rightanim;
+}
+
+handledogsoundnotetracks( note )
+{
+    if ( note == "sound_dogstep_run_default" || note == "dogstep_rf" || note == "dogstep_lf" )
+    {
+        self playsound( "fly_dog_step_run_default" );
+        return true;
+    }
+
+    prefix = getsubstr( note, 0, 5 );
+
+    if ( prefix != "sound" )
+        return false;
+
+    alias = "aml" + getsubstr( note, 5 );
+
+    if ( isalive( self ) )
+        self thread play_sound_on_tag_endon_death( alias, "tag_eye" );
+    else
+        self thread play_sound_in_space( alias, self gettagorigin( "tag_eye" ) );
+
+    return true;
+}
+
+growling()
+{
+    return isdefined( self.script_growl );
+}
+
+registernotetracks()
+{
+    anim.notetracks["anim_pose = \"stand\""] = ::notetrackposestand;
+    anim.notetracks["anim_pose = \"crouch\""] = ::notetrackposecrouch;
+    anim.notetracks["anim_movement = \"stop\""] = ::notetrackmovementstop;
+    anim.notetracks["anim_movement = \"walk\""] = ::notetrackmovementwalk;
+    anim.notetracks["anim_movement = \"run\""] = ::notetrackmovementrun;
+    anim.notetracks["anim_alertness = causal"] = ::notetrackalertnesscasual;
+    anim.notetracks["anim_alertness = alert"] = ::notetrackalertnessalert;
+    anim.notetracks["gravity on"] = ::notetrackgravity;
+    anim.notetracks["gravity off"] = ::notetrackgravity;
+    anim.notetracks["gravity code"] = ::notetrackgravity;
+    anim.notetracks["bodyfall large"] = ::notetrackbodyfall;
+    anim.notetracks["bodyfall small"] = ::notetrackbodyfall;
+    anim.notetracks["footstep"] = ::notetrackfootstep;
+    anim.notetracks["step"] = ::notetrackfootstep;
+    anim.notetracks["footstep_right_large"] = ::notetrackfootstep;
+    anim.notetracks["footstep_right_small"] = ::notetrackfootstep;
+    anim.notetracks["footstep_left_large"] = ::notetrackfootstep;
+    anim.notetracks["footstep_left_small"] = ::notetrackfootstep;
+    anim.notetracks["footscrape"] = ::notetrackfootscrape;
+    anim.notetracks["land"] = ::notetrackland;
+    anim.notetracks["start_ragdoll"] = ::notetrackstartragdoll;
+}
+
+notetrackstopanim( note, flagname )
+{
+
+}
+
+notetrackstartragdoll( note, flagname )
+{
+    if ( isdefined( self.noragdoll ) )
+        return;
+
+    self unlink();
+    self startragdoll();
+}
+
+notetrackmovementstop( note, flagname )
+{
+    if ( issentient( self ) )
+        self.a.movement = "stop";
+}
+
+notetrackmovementwalk( note, flagname )
+{
+    if ( issentient( self ) )
+        self.a.movement = "walk";
+}
+
+notetrackmovementrun( note, flagname )
+{
+    if ( issentient( self ) )
+        self.a.movement = "run";
+}
+
+notetrackalertnesscasual( note, flagname )
+{
+    if ( issentient( self ) )
+        self.a.alertness = "casual";
+}
+
+notetrackalertnessalert( note, flagname )
+{
+    if ( issentient( self ) )
+        self.a.alertness = "alert";
+}
+
+notetrackposestand( note, flagname )
+{
+    self.a.pose = "stand";
+    self notify( "entered_pose" + "stand" );
+}
+
+notetrackposecrouch( note, flagname )
+{
+    self.a.pose = "crouch";
+    self notify( "entered_pose" + "crouch" );
+
+    if ( self.a.crouchpain )
+    {
+        self.a.crouchpain = 0;
+        self.health = 150;
+    }
+}
+
+notetrackgravity( note, flagname )
+{
+    if ( issubstr( note, "on" ) )
+        self animmode( "gravity" );
+    else if ( issubstr( note, "off" ) )
+    {
+        self animmode( "nogravity" );
+        self.nogravity = 1;
+    }
+    else if ( issubstr( note, "code" ) )
+    {
+        self animmode( "none" );
+        self.nogravity = undefined;
+    }
+}
+
+notetrackbodyfall( note, flagname )
+{
+    if ( isdefined( self.groundtype ) )
+        groundtype = self.groundtype;
+    else
+        groundtype = "dirt";
+
+    if ( issubstr( note, "large" ) )
+        self playsound( "fly_bodyfall_large_" + groundtype );
+    else if ( issubstr( note, "small" ) )
+        self playsound( "fly_bodyfall_small_" + groundtype );
+}
+
+notetrackfootstep( note, flagname )
+{
+    if ( issubstr( note, "left" ) )
+        playfootstep( "J_Ball_LE" );
+    else
+        playfootstep( "J_BALL_RI" );
+
+    if ( !level.clientscripts )
+        self playsound( "fly_gear_run" );
+}
+
+notetrackfootscrape( note, flagname )
+{
+    if ( isdefined( self.groundtype ) )
+        groundtype = self.groundtype;
+    else
+        groundtype = "dirt";
+
+    self playsound( "fly_step_scrape_" + groundtype );
+}
+
+notetrackland( note, flagname )
+{
+    if ( isdefined( self.groundtype ) )
+        groundtype = self.groundtype;
+    else
+        groundtype = "dirt";
+
+    self playsound( "fly_land_npc_" + groundtype );
+}
+
+handlenotetrack( note, flagname, customfunction, var1 )
+{
+    if ( isai( self ) && self.isdog )
+    {
+        if ( handledogsoundnotetracks( note ) )
+            return;
+    }
+    else
+    {
+        notetrackfunc = anim.notetracks[note];
+
+        if ( isdefined( notetrackfunc ) )
+            return [[ notetrackfunc ]]( note, flagname );
+    }
+
+    switch ( note )
+    {
+        case "undefined":
+        case "finish":
+        case "end":
+            if ( isai( self ) && self.a.pose == "back" )
+            {
+
+            }
+
+            return note;
+        case "swish small":
+            self thread play_sound_in_space( "fly_gear_enemy", self gettagorigin( "TAG_WEAPON_RIGHT" ) );
+            break;
+        case "swish large":
+            self thread play_sound_in_space( "fly_gear_enemy_large", self gettagorigin( "TAG_WEAPON_RIGHT" ) );
+            break;
+        case "no death":
+            self.a.nodeath = 1;
+            break;
+        case "no pain":
+            self.allowpain = 0;
+            break;
+        case "allow pain":
+            self.allowpain = 1;
+            break;
+        case "anim_melee = right":
+        case "anim_melee = \"right\"":
+            self.a.meleestate = "right";
+            break;
+        case "anim_melee = left":
+        case "anim_melee = \"left\"":
+            self.a.meleestate = "left";
+            break;
+        case "swap taghelmet to tagleft":
+            if ( isdefined( self.hatmodel ) )
+            {
+                if ( isdefined( self.helmetsidemodel ) )
+                {
+                    self detach( self.helmetsidemodel, "TAG_HELMETSIDE" );
+                    self.helmetsidemodel = undefined;
+                }
+
+                self detach( self.hatmodel, "" );
+                self attach( self.hatmodel, "TAG_WEAPON_LEFT" );
+                self.hatmodel = undefined;
+            }
+
+            break;
+        default:
+            if ( isdefined( customfunction ) )
+            {
+                if ( !isdefined( var1 ) )
+                    return [[ customfunction ]]( note );
+                else
+                    return [[ customfunction ]]( note, var1 );
+            }
+
+            break;
+    }
+}
+
+donotetracks( flagname, customfunction, var1 )
+{
+    for (;;)
+    {
+        self waittill( flagname, note );
+
+        if ( !isdefined( note ) )
+            note = "undefined";
+
+        val = self handlenotetrack( note, flagname, customfunction, var1 );
+
+        if ( isdefined( val ) )
+            return val;
+    }
+}
+
+donotetracksforeverproc( notetracksfunc, flagname, killstring, customfunction, var1 )
+{
+    if ( isdefined( killstring ) )
+        self endon( killstring );
+
+    self endon( "killanimscript" );
+
+    for (;;)
+    {
+        time = gettime();
+        returnednote = [[ notetracksfunc ]]( flagname, customfunction, var1 );
+        timetaken = gettime() - time;
+
+        if ( timetaken < 0.05 )
+        {
+            time = gettime();
+            returnednote = [[ notetracksfunc ]]( flagname, customfunction, var1 );
+            timetaken = gettime() - time;
+
+            if ( timetaken < 0.05 )
+            {
+/#
+                println( gettime() + " mapsmpanimscriptsshared::DoNoteTracksForever is trying to cause an infinite loop on anim " + flagname + ", returned " + returnednote + "." );
+#/
+                wait( 0.05 - timetaken );
+            }
+        }
+    }
+}
+
+donotetracksforever( flagname, killstring, customfunction, var1 )
+{
+    donotetracksforeverproc( ::donotetracks, flagname, killstring, customfunction, var1 );
+}
+
+donotetracksfortimeproc( donotetracksforeverfunc, time, flagname, customfunction, ent, var1 )
+{
+    ent endon( "stop_notetracks" );
+    [[ donotetracksforeverfunc ]]( flagname, undefined, customfunction, var1 );
+}
+
+donotetracksfortime( time, flagname, customfunction, var1 )
+{
+    ent = spawnstruct();
+    ent thread donotetracksfortimeendnotify( time );
+    donotetracksfortimeproc( ::donotetracksforever, time, flagname, customfunction, ent, var1 );
+}
+
+donotetracksfortimeendnotify( time )
+{
+    wait( time );
+    self notify( "stop_notetracks" );
+}
+
+playfootstep( foot )
+{
+    if ( !level.clientscripts )
+    {
+        if ( !isai( self ) )
+        {
+            self playsound( "fly_step_run_dirt" );
+            return;
+        }
+    }
+
+    groundtype = undefined;
+
+    if ( !isdefined( self.groundtype ) )
+    {
+        if ( !isdefined( self.lastgroundtype ) )
+        {
+            if ( !level.clientscripts )
+                self playsound( "fly_step_run_dirt" );
+
+            return;
+        }
+
+        groundtype = self.lastgroundtype;
+    }
+    else
+    {
+        groundtype = self.groundtype;
+        self.lastgroundtype = self.groundtype;
+    }
+
+    if ( !level.clientscripts )
+        self playsound( "fly_step_run_" + groundtype );
+
+    [[ anim.optionalstepeffectfunction ]]( foot, groundtype );
+}
+
+playfootstepeffect( foot, groundtype )
+{
+    if ( level.clientscripts )
+        return;
+
+    for ( i = 0; i < anim.optionalstepeffects.size; i++ )
+    {
+        if ( isdefined( self.fire_footsteps ) && self.fire_footsteps )
+            groundtype = "fire";
+
+        if ( groundtype != anim.optionalstepeffects[i] )
+            continue;
+
+        org = self gettagorigin( foot );
+        playfx( level._effect["step_" + anim.optionalstepeffects[i]], org, org + vectorscale( ( 0, 0, 1 ), 100.0 ) );
+        return;
+    }
+}
+
+movetooriginovertime( origin, time )
+{
+    self endon( "killanimscript" );
+
+    if ( distancesquared( self.origin, origin ) > 256 && !self maymovetopoint( origin ) )
+    {
+/#
+        println( "^1Warning: AI starting behavior for node at " + origin + " but could not move to that point." );
+#/
+        return;
+    }
+
+    self.keepclaimednodeingoal = 1;
+    offset = self.origin - origin;
+    frames = int( time * 20 );
+    offsetreduction = vectorscale( offset, 1.0 / frames );
+
+    for ( i = 0; i < frames; i++ )
+    {
+        offset -= offsetreduction;
+        self teleport( origin + offset );
+        wait 0.05;
+    }
+
+    self.keepclaimednodeingoal = 0;
+}
+
+returntrue()
+{
+    return 1;
+}

ZM/Core/maps/mp/animscripts/zm_stop.gsc

@@ -0,0 +1,27 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\zm_utility;
+#include maps\mp\animscripts\zm_shared;
+
+main()
+{
+    self endon( "killanimscript" );
+
+    for (;;)
+    {
+        if ( isdefined( level.ignore_stop_func ) )
+        {
+            if ( self [[ level.ignore_stop_func ]]() )
+                return;
+        }
+
+        if ( !self hasanimstatefromasd( "zm_idle" ) )
+            return;
+
+        animstate = maps\mp\animscripts\zm_utility::append_missing_legs_suffix( "zm_idle" );
+        self setanimstatefromasd( animstate );
+        maps\mp\animscripts\zm_shared::donotetracks( "idle_anim" );
+    }
+}

ZM/Core/maps/mp/animscripts/zm_turn.gsc

@@ -0,0 +1,9 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\shared;
+
+main()
+{
+
+}

ZM/Core/maps/mp/gametypes_zm/_callbacksetup.gsc

@@ -0,0 +1,215 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include maps\mp\_audio;
+#include maps\mp\gametypes_zm\_globallogic;
+#include maps\mp\gametypes_zm\_globallogic_player;
+#include maps\mp\gametypes_zm\_globallogic_actor;
+#include maps\mp\gametypes_zm\_hostmigration;
+
+codecallback_startgametype()
+{
+    if ( !isdefined( level.gametypestarted ) || !level.gametypestarted )
+    {
+        [[ level.callbackstartgametype ]]();
+        level.gametypestarted = 1;
+    }
+}
+
+codecallback_finalizeinitialization()
+{
+    maps\mp\_utility::callback( "on_finalize_initialization" );
+}
+
+codecallback_playerconnect()
+{
+    self endon( "disconnect" );
+    self thread maps\mp\_audio::monitor_player_sprint();
+    [[ level.callbackplayerconnect ]]();
+}
+
+codecallback_playerdisconnect()
+{
+    self notify( "disconnect" );
+    client_num = self getentitynumber();
+    [[ level.callbackplayerdisconnect ]]();
+}
+
+codecallback_hostmigration()
+{
+/#
+    println( "****CodeCallback_HostMigration****" );
+#/
+    [[ level.callbackhostmigration ]]();
+}
+
+codecallback_hostmigrationsave()
+{
+/#
+    println( "****CodeCallback_HostMigrationSave****" );
+#/
+    [[ level.callbackhostmigrationsave ]]();
+}
+
+codecallback_prehostmigrationsave()
+{
+/#
+    println( "****CodeCallback_PreHostMigrationSave****" );
+#/
+    [[ level.callbackprehostmigrationsave ]]();
+}
+
+codecallback_playermigrated()
+{
+/#
+    println( "****CodeCallback_PlayerMigrated****" );
+#/
+    [[ level.callbackplayermigrated ]]();
+}
+
+codecallback_playerdamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex )
+{
+    self endon( "disconnect" );
+    [[ level.callbackplayerdamage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex );
+}
+
+codecallback_playerkilled( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration )
+{
+    self endon( "disconnect" );
+    [[ level.callbackplayerkilled ]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration );
+}
+
+codecallback_playerlaststand( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration )
+{
+    self endon( "disconnect" );
+    [[ level.callbackplayerlaststand ]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration );
+}
+
+codecallback_playermelee( eattacker, idamage, sweapon, vorigin, vdir, boneindex, shieldhit )
+{
+    self endon( "disconnect" );
+    [[ level.callbackplayermelee ]]( eattacker, idamage, sweapon, vorigin, vdir, boneindex, shieldhit );
+}
+
+codecallback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex )
+{
+    [[ level.callbackactordamage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex );
+}
+
+codecallback_actorkilled( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset )
+{
+    [[ level.callbackactorkilled ]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset );
+}
+
+codecallback_vehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, damagefromunderneath, modelindex, partname )
+{
+    [[ level.callbackvehicledamage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, damagefromunderneath, modelindex, partname );
+}
+
+codecallback_vehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, timeoffset )
+{
+
+}
+
+codecallback_faceeventnotify( notify_msg, ent )
+{
+    if ( isdefined( ent ) && isdefined( ent.do_face_anims ) && ent.do_face_anims )
+    {
+        if ( isdefined( level.face_event_handler ) && isdefined( level.face_event_handler.events[notify_msg] ) )
+            ent sendfaceevent( level.face_event_handler.events[notify_msg] );
+    }
+}
+
+codecallback_menuresponse( action, arg )
+{
+    if ( !isdefined( level.menuresponsequeue ) )
+    {
+        level.menuresponsequeue = [];
+        level thread menuresponsequeuepump();
+    }
+
+    index = level.menuresponsequeue.size;
+    level.menuresponsequeue[index] = spawnstruct();
+    level.menuresponsequeue[index].action = action;
+    level.menuresponsequeue[index].arg = arg;
+    level.menuresponsequeue[index].ent = self;
+    level notify( "menuresponse_queue" );
+}
+
+menuresponsequeuepump()
+{
+    while ( true )
+    {
+        level waittill( "menuresponse_queue" );
+
+        do
+        {
+            level.menuresponsequeue[0].ent notify( "menuresponse", level.menuresponsequeue[0].action, level.menuresponsequeue[0].arg );
+            arrayremoveindex( level.menuresponsequeue, 0, 0 );
+            wait 0.05;
+        }
+        while ( level.menuresponsequeue.size > 0 );
+    }
+}
+
+setupcallbacks()
+{
+    setdefaultcallbacks();
+    level.idflags_radius = 1;
+    level.idflags_no_armor = 2;
+    level.idflags_no_knockback = 4;
+    level.idflags_penetration = 8;
+    level.idflags_destructible_entity = 16;
+    level.idflags_shield_explosive_impact = 32;
+    level.idflags_shield_explosive_impact_huge = 64;
+    level.idflags_shield_explosive_splash = 128;
+    level.idflags_no_team_protection = 256;
+    level.idflags_no_protection = 512;
+    level.idflags_passthru = 1024;
+}
+
+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;
+}
+
+abortlevel()
+{
+/#
+    println( "ERROR: Aborting level - gametype is not supported" );
+#/
+    level.callbackstartgametype = ::callbackvoid;
+    level.callbackplayerconnect = ::callbackvoid;
+    level.callbackplayerdisconnect = ::callbackvoid;
+    level.callbackplayerdamage = ::callbackvoid;
+    level.callbackplayerkilled = ::callbackvoid;
+    level.callbackplayermelee = ::callbackvoid;
+    level.callbackplayerlaststand = ::callbackvoid;
+    level.callbackactordamage = ::callbackvoid;
+    level.callbackactorkilled = ::callbackvoid;
+    level.callbackvehicledamage = ::callbackvoid;
+    setdvar( "g_gametype", "dm" );
+    exitlevel( 0 );
+}
+
+codecallback_glasssmash( pos, dir )
+{
+    level notify( "glass_smash", pos, dir );
+}
+
+callbackvoid()
+{
+
+}

ZM/Core/maps/mp/gametypes_zm/_clientids.gsc

@@ -0,0 +1,19 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+
+init()
+{
+    level.clientid = 0;
+    level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+    for (;;)
+    {
+        level waittill( "connecting", player );
+
+        player.clientid = level.clientid;
+        level.clientid++;
+    }
+}

ZM/Core/maps/mp/gametypes_zm/_damagefeedback.gsc

@@ -0,0 +1,166 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+
+init()
+{
+    precacheshader( "damage_feedback" );
+    precacheshader( "damage_feedback_flak" );
+    precacheshader( "damage_feedback_tac" );
+    level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+    for (;;)
+    {
+        level waittill( "connecting", player );
+
+        player.hud_damagefeedback = newdamageindicatorhudelem( player );
+        player.hud_damagefeedback.horzalign = "center";
+        player.hud_damagefeedback.vertalign = "middle";
+        player.hud_damagefeedback.x = -12;
+        player.hud_damagefeedback.y = -12;
+        player.hud_damagefeedback.alpha = 0;
+        player.hud_damagefeedback.archived = 1;
+        player.hud_damagefeedback setshader( "damage_feedback", 24, 48 );
+        player.hitsoundtracker = 1;
+    }
+}
+
+updatedamagefeedback( mod, inflictor, perkfeedback )
+{
+    if ( !isplayer( self ) || sessionmodeiszombiesgame() )
+        return;
+
+    if ( isdefined( mod ) && mod != "MOD_CRUSH" && mod != "MOD_GRENADE_SPLASH" && mod != "MOD_HIT_BY_OBJECT" )
+    {
+        if ( isdefined( inflictor ) && isdefined( inflictor.soundmod ) )
+        {
+            switch ( inflictor.soundmod )
+            {
+                case "player":
+                    self thread playhitsound( mod, "mpl_hit_alert" );
+                    break;
+                case "heli":
+                    self thread playhitsound( mod, "mpl_hit_alert_air" );
+                    break;
+                case "hpm":
+                    self thread playhitsound( mod, "mpl_hit_alert_hpm" );
+                    break;
+                case "taser_spike":
+                    self thread playhitsound( mod, "mpl_hit_alert_taser_spike" );
+                    break;
+                case "straferun":
+                case "dog":
+                    break;
+                case "default_loud":
+                    self thread playhitsound( mod, "mpl_hit_heli_gunner" );
+                    break;
+                default:
+                    self thread playhitsound( mod, "mpl_hit_alert_low" );
+                    break;
+            }
+        }
+        else
+            self thread playhitsound( mod, "mpl_hit_alert_low" );
+    }
+
+    if ( isdefined( perkfeedback ) )
+    {
+        switch ( perkfeedback )
+        {
+            case "flakjacket":
+                self.hud_damagefeedback setshader( "damage_feedback_flak", 24, 48 );
+                break;
+            case "tacticalMask":
+                self.hud_damagefeedback setshader( "damage_feedback_tac", 24, 48 );
+                break;
+        }
+    }
+    else
+        self.hud_damagefeedback setshader( "damage_feedback", 24, 48 );
+
+    self.hud_damagefeedback.alpha = 1;
+    self.hud_damagefeedback fadeovertime( 1 );
+    self.hud_damagefeedback.alpha = 0;
+}
+
+playhitsound( mod, alert )
+{
+    self endon( "disconnect" );
+
+    if ( self.hitsoundtracker )
+    {
+        self.hitsoundtracker = 0;
+        self playlocalsound( alert );
+        wait 0.05;
+        self.hitsoundtracker = 1;
+    }
+}
+
+updatespecialdamagefeedback( hitent )
+{
+    if ( !isplayer( self ) )
+        return;
+
+    if ( !isdefined( hitent ) )
+        return;
+
+    if ( !isplayer( hitent ) )
+        return;
+
+    wait 0.05;
+
+    if ( !isdefined( self.directionalhitarray ) )
+    {
+        self.directionalhitarray = [];
+        hitentnum = hitent getentitynumber();
+        self.directionalhitarray[hitentnum] = 1;
+        self thread sendhitspecialeventatframeend( hitent );
+    }
+    else
+    {
+        hitentnum = hitent getentitynumber();
+        self.directionalhitarray[hitentnum] = 1;
+    }
+}
+
+sendhitspecialeventatframeend( hitent )
+{
+    self endon( "disconnect" );
+    waittillframeend;
+    enemyshit = 0;
+    value = 1;
+    entbitarray0 = 0;
+
+    for ( i = 0; i < 32; i++ )
+    {
+        if ( isdefined( self.directionalhitarray[i] ) && self.directionalhitarray[i] != 0 )
+        {
+            entbitarray0 += value;
+            enemyshit++;
+        }
+
+        value *= 2;
+    }
+
+    entbitarray1 = 0;
+
+    for ( i = 33; i < 64; i++ )
+    {
+        if ( isdefined( self.directionalhitarray[i] ) && self.directionalhitarray[i] != 0 )
+        {
+            entbitarray1 += value;
+            enemyshit++;
+        }
+
+        value *= 2;
+    }
+
+    if ( enemyshit )
+        self directionalhitindicator( entbitarray0, entbitarray1 );
+
+    self.directionalhitarray = undefined;
+    entbitarray0 = 0;
+    entbitarray1 = 0;
+}

ZM/Core/maps/mp/gametypes_zm/_dev.gsc

@@ -0,0 +1,90 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+
+init()
+{
+/#
+    for (;;)
+    {
+        updatedevsettingszm();
+        wait 0.5;
+    }
+#/
+}
+
+updatedevsettingszm()
+{
+/#
+    if ( level.players.size > 0 )
+    {
+        if ( getdvar( "r_streamDumpDistance" ) == "3" )
+        {
+            if ( !isdefined( level.streamdumpteamindex ) )
+                level.streamdumpteamindex = 0;
+            else
+                level.streamdumpteamindex++;
+
+            numpoints = 0;
+            spawnpoints = [];
+            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;
+
+            if ( level.streamdumpteamindex < level.teams.size )
+            {
+                structs = getstructarray( "initial_spawn", "script_noteworthy" );
+
+                if ( isdefined( structs ) )
+                {
+                    foreach ( struct in structs )
+                    {
+                        if ( isdefined( struct.script_string ) )
+                        {
+                            tokens = strtok( struct.script_string, " " );
+
+                            foreach ( token in tokens )
+                            {
+                                if ( token == match_string )
+                                    spawnpoints[spawnpoints.size] = struct;
+                            }
+                        }
+                    }
+                }
+
+                if ( !isdefined( spawnpoints ) || spawnpoints.size == 0 )
+                    spawnpoints = getstructarray( "initial_spawn_points", "targetname" );
+
+                if ( isdefined( spawnpoints ) )
+                    numpoints = spawnpoints.size;
+            }
+
+            if ( numpoints == 0 )
+            {
+                setdvar( "r_streamDumpDistance", "0" );
+                level.streamdumpteamindex = -1;
+            }
+            else
+            {
+                averageorigin = ( 0, 0, 0 );
+                averageangles = ( 0, 0, 0 );
+
+                foreach ( spawnpoint in spawnpoints )
+                {
+                    averageorigin += spawnpoint.origin / numpoints;
+                    averageangles += spawnpoint.angles / numpoints;
+                }
+
+                level.players[0] setplayerangles( averageangles );
+                level.players[0] setorigin( averageorigin );
+                wait 0.05;
+                setdvar( "r_streamDumpDistance", "2" );
+            }
+        }
+    }
+#/
+}

ZM/Core/maps/mp/gametypes_zm/_globalentities.gsc

@@ -0,0 +1,3 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+

ZM/Core/maps/mp/gametypes_zm/_globallogic_actor.gsc

@@ -0,0 +1,174 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include maps\mp\gametypes_zm\_globallogic_player;
+#include maps\mp\gametypes_zm\_globallogic_utils;
+#include maps\mp\gametypes_zm\_weapons;
+#include maps\mp\gametypes_zm\_damagefeedback;
+#include maps\mp\_challenges;
+
+callback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex )
+{
+    if ( game["state"] == "postgame" )
+        return;
+
+    if ( self.aiteam == "spectator" )
+        return;
+
+    if ( isdefined( eattacker ) && isplayer( eattacker ) && isdefined( eattacker.candocombat ) && !eattacker.candocombat )
+        return;
+
+    self.idflags = idflags;
+    self.idflagstime = gettime();
+    eattacker = maps\mp\gametypes_zm\_globallogic_player::figureoutattacker( eattacker );
+
+    if ( !isdefined( vdir ) )
+        idflags |= level.idflags_no_knockback;
+
+    friendly = 0;
+
+    if ( self.health == self.maxhealth || !isdefined( self.attackers ) )
+    {
+        self.attackers = [];
+        self.attackerdata = [];
+        self.attackerdamage = [];
+    }
+
+    if ( maps\mp\gametypes_zm\_globallogic_utils::isheadshot( sweapon, shitloc, smeansofdeath, einflictor ) )
+        smeansofdeath = "MOD_HEAD_SHOT";
+
+    if ( level.onlyheadshots )
+    {
+        if ( smeansofdeath == "MOD_PISTOL_BULLET" || smeansofdeath == "MOD_RIFLE_BULLET" )
+            return;
+        else if ( smeansofdeath == "MOD_HEAD_SHOT" )
+            idamage = 150;
+    }
+
+    if ( sweapon == "none" && isdefined( einflictor ) )
+    {
+        if ( isdefined( einflictor.targetname ) && einflictor.targetname == "explodable_barrel" )
+            sweapon = "explodable_barrel_mp";
+        else if ( isdefined( einflictor.destructible_type ) && issubstr( einflictor.destructible_type, "vehicle_" ) )
+            sweapon = "destructible_car_mp";
+    }
+
+    if ( !( idflags & level.idflags_no_protection ) )
+    {
+        if ( isplayer( eattacker ) )
+            eattacker.pers["participation"]++;
+
+        prevhealthratio = self.health / self.maxhealth;
+
+        if ( level.teambased && isplayer( eattacker ) && self != eattacker && self.aiteam == eattacker.pers["team"] )
+        {
+            if ( level.friendlyfire == 0 )
+                return;
+            else if ( level.friendlyfire == 1 )
+            {
+                if ( idamage < 1 )
+                    idamage = 1;
+
+                self.lastdamagewasfromenemy = 0;
+                self finishactordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
+            }
+            else if ( level.friendlyfire == 2 )
+                return;
+            else if ( level.friendlyfire == 3 )
+            {
+                idamage = int( idamage * 0.5 );
+
+                if ( idamage < 1 )
+                    idamage = 1;
+
+                self.lastdamagewasfromenemy = 0;
+                self finishactordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
+            }
+
+            friendly = 1;
+        }
+        else
+        {
+            if ( isdefined( eattacker ) && isdefined( self.script_owner ) && eattacker == self.script_owner && !level.hardcoremode )
+                return;
+
+            if ( isdefined( eattacker ) && isdefined( self.script_owner ) && isdefined( eattacker.script_owner ) && eattacker.script_owner == self.script_owner )
+                return;
+
+            if ( idamage < 1 )
+                idamage = 1;
+
+            if ( isdefined( eattacker ) && isplayer( eattacker ) && isdefined( sweapon ) && !issubstr( smeansofdeath, "MOD_MELEE" ) )
+                eattacker thread maps\mp\gametypes_zm\_weapons::checkhit( sweapon );
+
+            if ( issubstr( smeansofdeath, "MOD_GRENADE" ) && isdefined( einflictor ) && isdefined( einflictor.iscooked ) )
+                self.wascooked = gettime();
+            else
+                self.wascooked = undefined;
+
+            self.lastdamagewasfromenemy = isdefined( eattacker ) && eattacker != self;
+            self finishactordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
+        }
+
+        if ( isdefined( eattacker ) && eattacker != self )
+        {
+            if ( sweapon != "artillery_mp" && ( !isdefined( einflictor ) || !isai( einflictor ) ) )
+            {
+                if ( idamage > 0 )
+                    eattacker thread maps\mp\gametypes_zm\_damagefeedback::updatedamagefeedback( smeansofdeath, einflictor );
+            }
+        }
+    }
+/#
+    if ( getdvarint( "g_debugDamage" ) )
+        println( "actor:" + self getentitynumber() + " health:" + self.health + " attacker:" + eattacker.clientid + " inflictor is player:" + isplayer( einflictor ) + " damage:" + idamage + shitloc + ";" + boneindex + "\\n" );
+#/
+    if ( 1 )
+    {
+        lpselfnum = self getentitynumber();
+        lpselfteam = self.aiteam;
+        lpattackerteam = "";
+
+        if ( isplayer( eattacker ) )
+        {
+            lpattacknum = eattacker getentitynumber();
+            lpattackguid = eattacker getguid();
+            lpattackname = eattacker.name;
+            lpattackerteam = eattacker.pers["team"];
+        }
+        else
+        {
+            lpattacknum = -1;
+            lpattackguid = "";
+            lpattackname = "";
+            lpattackerteam = "world";
+        }
+
+        logprint( "AD;" + lpselfnum + ";" + lpselfteam + ";" + lpattackguid + ";" + lpattacknum + ";" + lpattackerteam + ";" + lpattackname + ";" + sweapon + ";" + idamage + ";" + smeansofdeath + ";" + shitloc + "\\n" );
+    }
+}
+
+callback_actorkilled( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime )
+{
+    if ( game["state"] == "postgame" )
+        return;
+
+    if ( isai( attacker ) && isdefined( attacker.script_owner ) )
+    {
+        if ( attacker.script_owner.team != self.aiteam )
+            attacker = attacker.script_owner;
+    }
+
+    if ( attacker.classname == "script_vehicle" && isdefined( attacker.owner ) )
+        attacker = attacker.owner;
+
+    if ( isdefined( attacker ) && isplayer( attacker ) )
+    {
+        if ( !level.teambased || self.aiteam != attacker.pers["team"] )
+        {
+            level.globalkillstreaksdestroyed++;
+            attacker addweaponstat( "dogs_mp", "destroyed", 1 );
+            attacker maps\mp\_challenges::killeddog();
+        }
+    }
+}

ZM/Core/maps/mp/gametypes_zm/_globallogic_audio.gsc

@@ -0,0 +1,904 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include maps\mp\gametypes_zm\_globallogic_utils;
+#include maps\mp\gametypes_zm\_globallogic_audio;
+#include maps\mp\_music;
+
+init()
+{
+    game["music"]["defeat"] = "mus_defeat";
+    game["music"]["victory_spectator"] = "mus_defeat";
+    game["music"]["winning"] = "mus_time_running_out_winning";
+    game["music"]["losing"] = "mus_time_running_out_losing";
+    game["music"]["match_end"] = "mus_match_end";
+    game["music"]["victory_tie"] = "mus_defeat";
+    game["music"]["suspense"] = [];
+    game["music"]["suspense"][game["music"]["suspense"].size] = "mus_suspense_01";
+    game["music"]["suspense"][game["music"]["suspense"].size] = "mus_suspense_02";
+    game["music"]["suspense"][game["music"]["suspense"].size] = "mus_suspense_03";
+    game["music"]["suspense"][game["music"]["suspense"].size] = "mus_suspense_04";
+    game["music"]["suspense"][game["music"]["suspense"].size] = "mus_suspense_05";
+    game["music"]["suspense"][game["music"]["suspense"].size] = "mus_suspense_06";
+    game["dialog"]["mission_success"] = "mission_success";
+    game["dialog"]["mission_failure"] = "mission_fail";
+    game["dialog"]["mission_draw"] = "draw";
+    game["dialog"]["round_success"] = "encourage_win";
+    game["dialog"]["round_failure"] = "encourage_lost";
+    game["dialog"]["round_draw"] = "draw";
+    game["dialog"]["timesup"] = "timesup";
+    game["dialog"]["winning"] = "winning";
+    game["dialog"]["losing"] = "losing";
+    game["dialog"]["min_draw"] = "min_draw";
+    game["dialog"]["lead_lost"] = "lead_lost";
+    game["dialog"]["lead_tied"] = "tied";
+    game["dialog"]["lead_taken"] = "lead_taken";
+    game["dialog"]["last_alive"] = "lastalive";
+    game["dialog"]["boost"] = "generic_boost";
+
+    if ( !isdefined( game["dialog"]["offense_obj"] ) )
+        game["dialog"]["offense_obj"] = "generic_boost";
+
+    if ( !isdefined( game["dialog"]["defense_obj"] ) )
+        game["dialog"]["defense_obj"] = "generic_boost";
+
+    game["dialog"]["hardcore"] = "hardcore";
+    game["dialog"]["oldschool"] = "oldschool";
+    game["dialog"]["highspeed"] = "highspeed";
+    game["dialog"]["tactical"] = "tactical";
+    game["dialog"]["challenge"] = "challengecomplete";
+    game["dialog"]["promotion"] = "promotion";
+    game["dialog"]["bomb_acquired"] = "sd_bomb_taken";
+    game["dialog"]["bomb_taken"] = "sd_bomb_taken_taken";
+    game["dialog"]["bomb_lost"] = "sd_bomb_drop";
+    game["dialog"]["bomb_defused"] = "sd_bomb_defused";
+    game["dialog"]["bomb_planted"] = "sd_bomb_planted";
+    game["dialog"]["obj_taken"] = "securedobj";
+    game["dialog"]["obj_lost"] = "lostobj";
+    game["dialog"]["obj_defend"] = "defend_start";
+    game["dialog"]["obj_destroy"] = "destroy_start";
+    game["dialog"]["obj_capture"] = "capture_obj";
+    game["dialog"]["objs_capture"] = "capture_objs";
+    game["dialog"]["hq_located"] = "hq_located";
+    game["dialog"]["hq_enemy_captured"] = "hq_capture";
+    game["dialog"]["hq_enemy_destroyed"] = "hq_defend";
+    game["dialog"]["hq_secured"] = "hq_secured";
+    game["dialog"]["hq_offline"] = "hq_offline";
+    game["dialog"]["hq_online"] = "hq_online";
+    game["dialog"]["koth_located"] = "koth_located";
+    game["dialog"]["koth_captured"] = "koth_captured";
+    game["dialog"]["koth_lost"] = "koth_lost";
+    game["dialog"]["koth_secured"] = "koth_secured";
+    game["dialog"]["koth_contested"] = "koth_contest";
+    game["dialog"]["koth_offline"] = "koth_offline";
+    game["dialog"]["koth_online"] = "koth_online";
+    game["dialog"]["move_to_new"] = "new_positions";
+    game["dialog"]["attack"] = "attack";
+    game["dialog"]["defend"] = "defend";
+    game["dialog"]["offense"] = "offense";
+    game["dialog"]["defense"] = "defense";
+    game["dialog"]["halftime"] = "halftime";
+    game["dialog"]["overtime"] = "overtime";
+    game["dialog"]["side_switch"] = "switchingsides";
+    game["dialog"]["flag_taken"] = "ourflag";
+    game["dialog"]["flag_dropped"] = "ourflag_drop";
+    game["dialog"]["flag_returned"] = "ourflag_return";
+    game["dialog"]["flag_captured"] = "ourflag_capt";
+    game["dialog"]["enemy_flag_taken"] = "enemyflag";
+    game["dialog"]["enemy_flag_dropped"] = "enemyflag_drop";
+    game["dialog"]["enemy_flag_returned"] = "enemyflag_return";
+    game["dialog"]["enemy_flag_captured"] = "enemyflag_capt";
+    game["dialog"]["securing_a"] = "dom_securing_a";
+    game["dialog"]["securing_b"] = "dom_securing_b";
+    game["dialog"]["securing_c"] = "dom_securing_c";
+    game["dialog"]["securing_d"] = "dom_securing_d";
+    game["dialog"]["securing_e"] = "dom_securing_e";
+    game["dialog"]["securing_f"] = "dom_securing_f";
+    game["dialog"]["secured_a"] = "dom_secured_a";
+    game["dialog"]["secured_b"] = "dom_secured_b";
+    game["dialog"]["secured_c"] = "dom_secured_c";
+    game["dialog"]["secured_d"] = "dom_secured_d";
+    game["dialog"]["secured_e"] = "dom_secured_e";
+    game["dialog"]["secured_f"] = "dom_secured_f";
+    game["dialog"]["losing_a"] = "dom_losing_a";
+    game["dialog"]["losing_b"] = "dom_losing_b";
+    game["dialog"]["losing_c"] = "dom_losing_c";
+    game["dialog"]["losing_d"] = "dom_losing_d";
+    game["dialog"]["losing_e"] = "dom_losing_e";
+    game["dialog"]["losing_f"] = "dom_losing_f";
+    game["dialog"]["lost_a"] = "dom_lost_a";
+    game["dialog"]["lost_b"] = "dom_lost_b";
+    game["dialog"]["lost_c"] = "dom_lost_c";
+    game["dialog"]["lost_d"] = "dom_lost_d";
+    game["dialog"]["lost_e"] = "dom_lost_e";
+    game["dialog"]["lost_f"] = "dom_lost_f";
+    game["dialog"]["secure_flag"] = "secure_flag";
+    game["dialog"]["securing_flag"] = "securing_flag";
+    game["dialog"]["losing_flag"] = "losing_flag";
+    game["dialog"]["lost_flag"] = "lost_flag";
+    game["dialog"]["oneflag_enemy"] = "oneflag_enemy";
+    game["dialog"]["oneflag_friendly"] = "oneflag_friendly";
+    game["dialog"]["lost_all"] = "dom_lock_theytake";
+    game["dialog"]["secure_all"] = "dom_lock_wetake";
+    game["dialog"]["squad_move"] = "squad_move";
+    game["dialog"]["squad_30sec"] = "squad_30sec";
+    game["dialog"]["squad_winning"] = "squad_onemin_vic";
+    game["dialog"]["squad_losing"] = "squad_onemin_loss";
+    game["dialog"]["squad_down"] = "squad_down";
+    game["dialog"]["squad_bomb"] = "squad_bomb";
+    game["dialog"]["squad_plant"] = "squad_plant";
+    game["dialog"]["squad_take"] = "squad_takeobj";
+    game["dialog"]["kicked"] = "player_kicked";
+    game["dialog"]["sentry_destroyed"] = "dest_sentry";
+    game["dialog"]["sentry_hacked"] = "kls_turret_hacked";
+    game["dialog"]["microwave_destroyed"] = "dest_microwave";
+    game["dialog"]["microwave_hacked"] = "kls_microwave_hacked";
+    game["dialog"]["sam_destroyed"] = "dest_sam";
+    game["dialog"]["tact_destroyed"] = "dest_tact";
+    game["dialog"]["equipment_destroyed"] = "dest_equip";
+    game["dialog"]["hacked_equip"] = "hacked_equip";
+    game["dialog"]["uav_destroyed"] = "kls_u2_destroyed";
+    game["dialog"]["cuav_destroyed"] = "kls_cu2_destroyed";
+    level.dialoggroups = [];
+    level thread post_match_snapshot_watcher();
+}
+
+registerdialoggroup( group, skipifcurrentlyplayinggroup )
+{
+    if ( !isdefined( level.dialoggroups ) )
+        level.dialoggroups = [];
+    else if ( isdefined( level.dialoggroup[group] ) )
+    {
+        error( "registerDialogGroup:  Dialog group " + group + " already registered." );
+        return;
+    }
+
+    level.dialoggroup[group] = spawnstruct();
+    level.dialoggroup[group].group = group;
+    level.dialoggroup[group].skipifcurrentlyplayinggroup = skipifcurrentlyplayinggroup;
+    level.dialoggroup[group].currentcount = 0;
+}
+
+sndstartmusicsystem()
+{
+    self endon( "disconnect" );
+
+    if ( game["state"] == "postgame" )
+        return;
+
+    if ( game["state"] == "pregame" )
+    {
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - music state is undefined Waiting 15 seconds to set music state" );
+#/
+        wait 30;
+
+        if ( !isdefined( level.nextmusicstate ) )
+        {
+            self.pers["music"].currentstate = "UNDERSCORE";
+            self thread suspensemusic();
+        }
+    }
+
+    if ( !isdefined( level.nextmusicstate ) )
+    {
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - music state is undefined Waiting 15 seconds to set music state" );
+#/
+        self.pers["music"].currentstate = "UNDERSCORE";
+        self thread suspensemusic();
+    }
+}
+
+suspensemusicforplayer()
+{
+    self endon( "disconnect" );
+    self thread set_music_on_player( "UNDERSCORE", 0 );
+/#
+    if ( getdvarint( _hash_BC4784C ) > 0 )
+        println( "Music System - Setting Music State Random Underscore " + self.pers["music"].returnstate + " On player " + self getentitynumber() );
+#/
+}
+
+suspensemusic( random )
+{
+    level endon( "game_ended" );
+    level endon( "match_ending_soon" );
+    self endon( "disconnect" );
+/#
+    if ( getdvarint( _hash_BC4784C ) > 0 )
+        println( "Music System - Starting random underscore" );
+#/
+    while ( true )
+    {
+        wait( randomintrange( 25, 60 ) );
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - Checking for random underscore" );
+#/
+        if ( !isdefined( self.pers["music"].inque ) )
+            self.pers["music"].inque = 0;
+
+        if ( self.pers["music"].inque )
+        {
+/#
+            if ( getdvarint( _hash_BC4784C ) > 0 )
+                println( "Music System - Inque no random underscore" );
+#/
+            continue;
+        }
+
+        if ( !isdefined( self.pers["music"].currentstate ) )
+            self.pers["music"].currentstate = "SILENT";
+
+        if ( randomint( 100 ) < self.underscorechance && self.pers["music"].currentstate != "ACTION" && self.pers["music"].currentstate != "TIME_OUT" )
+        {
+            self thread suspensemusicforplayer();
+            self.underscorechance -= 20;
+/#
+            if ( getdvarint( _hash_BC4784C ) > 0 )
+                println( "Music System - Starting random underscore" );
+#/
+        }
+    }
+}
+
+leaderdialogforotherteams( dialog, skip_team, squad_dialog )
+{
+    foreach ( team in level.teams )
+    {
+        if ( team != skip_team )
+            leaderdialog( dialog, team, undefined, undefined, squad_dialog );
+    }
+}
+
+announceroundwinner( winner, delay )
+{
+    if ( delay > 0 )
+        wait( delay );
+
+    if ( !isdefined( winner ) || isplayer( winner ) )
+        return;
+
+    if ( isdefined( level.teams[winner] ) )
+    {
+        leaderdialog( "round_success", winner );
+        leaderdialogforotherteams( "round_failure", winner );
+    }
+    else
+    {
+        foreach ( team in level.teams )
+            thread playsoundonplayers( "mus_round_draw" + "_" + level.teampostfix[team] );
+
+        leaderdialog( "round_draw" );
+    }
+}
+
+announcegamewinner( winner, delay )
+{
+    if ( delay > 0 )
+        wait( delay );
+
+    if ( !isdefined( winner ) || isplayer( winner ) )
+        return;
+
+    if ( isdefined( level.teams[winner] ) )
+    {
+        leaderdialog( "mission_success", winner );
+        leaderdialogforotherteams( "mission_failure", winner );
+    }
+    else
+        leaderdialog( "mission_draw" );
+}
+
+doflameaudio()
+{
+    self endon( "disconnect" );
+    waittillframeend;
+
+    if ( !isdefined( self.lastflamehurtaudio ) )
+        self.lastflamehurtaudio = 0;
+
+    currenttime = gettime();
+
+    if ( self.lastflamehurtaudio + level.fire_audio_repeat_duration + randomint( level.fire_audio_random_max_duration ) < currenttime )
+    {
+        self playlocalsound( "vox_pain_small" );
+        self.lastflamehurtaudio = currenttime;
+    }
+}
+
+leaderdialog( dialog, team, group, excludelist, squaddialog )
+{
+    assert( isdefined( level.players ) );
+
+    if ( level.splitscreen )
+        return;
+
+    if ( level.wagermatch )
+        return;
+
+    if ( !isdefined( team ) )
+    {
+        dialogs = [];
+
+        foreach ( team in level.teams )
+            dialogs[team] = dialog;
+
+        leaderdialogallteams( dialogs, group, excludelist );
+        return;
+    }
+
+    if ( level.splitscreen )
+    {
+        if ( level.players.size )
+            level.players[0] leaderdialogonplayer( dialog, group );
+
+        return;
+    }
+
+    if ( isdefined( excludelist ) )
+    {
+        for ( i = 0; i < level.players.size; i++ )
+        {
+            player = level.players[i];
+
+            if ( isdefined( player.pers["team"] ) && player.pers["team"] == team && !maps\mp\gametypes_zm\_globallogic_utils::isexcluded( player, excludelist ) )
+                player leaderdialogonplayer( dialog, group );
+        }
+    }
+    else
+    {
+        for ( i = 0; i < level.players.size; i++ )
+        {
+            player = level.players[i];
+
+            if ( isdefined( player.pers["team"] ) && player.pers["team"] == team )
+                player leaderdialogonplayer( dialog, group );
+        }
+    }
+}
+
+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;
+    }
+
+    for ( i = 0; i < level.players.size; i++ )
+    {
+        player = level.players[i];
+        team = player.pers["team"];
+
+        if ( !isdefined( team ) )
+            continue;
+
+        if ( !isdefined( dialogs[team] ) )
+            continue;
+
+        if ( isdefined( excludelist ) && maps\mp\gametypes_zm\_globallogic_utils::isexcluded( player, excludelist ) )
+            continue;
+
+        player leaderdialogonplayer( dialogs[team], group );
+    }
+}
+
+flushdialog()
+{
+    foreach ( player in level.players )
+        player flushdialogonplayer();
+}
+
+flushdialogonplayer()
+{
+    self.leaderdialoggroups = [];
+    self.leaderdialogqueue = [];
+    self.leaderdialogactive = 0;
+    self.currentleaderdialoggroup = "";
+}
+
+flushgroupdialog( group )
+{
+    foreach ( player in level.players )
+        player flushgroupdialogonplayer( group );
+}
+
+flushgroupdialogonplayer( group )
+{
+    self.leaderdialoggroups[group] = undefined;
+
+    foreach ( key, dialog in self.leaderdialogqueue )
+    {
+        if ( dialog == group )
+            self.leaderdialogqueue[key] = undefined;
+    }
+}
+
+addgroupdialogtoplayer( dialog, group )
+{
+    if ( !isdefined( level.dialoggroup[group] ) )
+    {
+        error( "leaderDialogOnPlayer:  Dialog group " + group + " is not registered" );
+        return 0;
+    }
+
+    addtoqueue = 0;
+
+    if ( !isdefined( self.leaderdialoggroups[group] ) )
+        addtoqueue = 1;
+
+    if ( !level.dialoggroup[group].skipifcurrentlyplayinggroup )
+    {
+        if ( self.currentleaderdialog == dialog && self.currentleaderdialogtime + 2000 > gettime() )
+        {
+            self.leaderdialoggroups[group] = undefined;
+
+            foreach ( key, leader_dialog in self.leaderdialogqueue )
+            {
+                if ( leader_dialog == group )
+                {
+                    for ( i = key + 1; i < self.leaderdialogqueue.size; i++ )
+                        self.leaderdialogqueue[i - 1] = self.leaderdialogqueue[i];
+
+                    self.leaderdialogqueue[i - 1] = undefined;
+                    break;
+                }
+            }
+
+            return 0;
+        }
+    }
+    else if ( self.currentleaderdialoggroup == group )
+        return 0;
+
+    self.leaderdialoggroups[group] = dialog;
+    return addtoqueue;
+}
+
+testdialogqueue( group )
+{
+/#
+    count = 0;
+
+    foreach ( temp in self.leaderdialogqueue )
+    {
+        if ( temp == group )
+            count++;
+    }
+
+    if ( count > 1 )
+        shit = 0;
+#/
+}
+
+leaderdialogonplayer( dialog, group )
+{
+    team = self.pers["team"];
+
+    if ( level.splitscreen )
+        return;
+
+    if ( !isdefined( team ) )
+        return;
+
+    if ( !isdefined( level.teams[team] ) )
+        return;
+
+    if ( isdefined( group ) )
+    {
+        if ( !addgroupdialogtoplayer( dialog, group ) )
+        {
+            self testdialogqueue( group );
+            return;
+        }
+
+        dialog = group;
+    }
+
+    if ( !self.leaderdialogactive )
+        self thread playleaderdialogonplayer( dialog );
+    else
+        self.leaderdialogqueue[self.leaderdialogqueue.size] = dialog;
+}
+
+waitforsound( sound, extratime = 0.1 )
+{
+    time = soundgetplaybacktime( sound );
+
+    if ( time < 0 )
+        wait( 3.0 + extratime );
+    else
+        wait( time * 0.001 + extratime );
+}
+
+playleaderdialogonplayer( dialog )
+{
+    if ( isdefined( level.allowannouncer ) && !level.allowannouncer )
+        return;
+
+    team = self.pers["team"];
+    self endon( "disconnect" );
+    self.leaderdialogactive = 1;
+
+    if ( isdefined( self.leaderdialoggroups[dialog] ) )
+    {
+        group = dialog;
+        dialog = self.leaderdialoggroups[group];
+        self.leaderdialoggroups[group] = undefined;
+        self.currentleaderdialoggroup = group;
+        self testdialogqueue( group );
+    }
+
+    if ( level.wagermatch || !isdefined( game["voice"] ) )
+        faction = "vox_wm_";
+    else
+        faction = game["voice"][team];
+
+    sound_name = faction + game["dialog"][dialog];
+
+    if ( level.allowannouncer )
+    {
+        self playlocalsound( sound_name );
+        self.currentleaderdialog = dialog;
+        self.currentleaderdialogtime = gettime();
+    }
+
+    waitforsound( sound_name );
+    self.leaderdialogactive = 0;
+    self.currentleaderdialoggroup = "";
+    self.currentleaderdialog = "";
+
+    if ( self.leaderdialogqueue.size > 0 )
+    {
+        nextdialog = self.leaderdialogqueue[0];
+
+        for ( i = 1; i < self.leaderdialogqueue.size; i++ )
+            self.leaderdialogqueue[i - 1] = self.leaderdialogqueue[i];
+
+        self.leaderdialogqueue[i - 1] = undefined;
+
+        if ( isdefined( self.leaderdialoggroups[dialog] ) )
+            self testdialogqueue( dialog );
+
+        self thread playleaderdialogonplayer( nextdialog );
+    }
+}
+
+isteamwinning( checkteam )
+{
+    score = game["teamScores"][checkteam];
+
+    foreach ( team in level.teams )
+    {
+        if ( team != checkteam )
+        {
+            if ( game["teamScores"][team] >= score )
+                return false;
+        }
+    }
+
+    return true;
+}
+
+announceteamiswinning()
+{
+    foreach ( team in level.teams )
+    {
+        if ( isteamwinning( team ) )
+        {
+            leaderdialog( "winning", team, undefined, undefined, "squad_winning" );
+            leaderdialogforotherteams( "losing", team, "squad_losing" );
+            return true;
+        }
+    }
+
+    return false;
+}
+
+musiccontroller()
+{
+    level endon( "game_ended" );
+    level thread musictimesout();
+
+    level waittill( "match_ending_soon" );
+
+    if ( islastround() || isoneround() )
+    {
+        if ( !level.splitscreen )
+        {
+            if ( level.teambased )
+            {
+                if ( !announceteamiswinning() )
+                    leaderdialog( "min_draw" );
+            }
+
+            level waittill( "match_ending_very_soon" );
+
+            foreach ( team in level.teams )
+                leaderdialog( "timesup", team, undefined, undefined, "squad_30sec" );
+        }
+    }
+    else
+    {
+        level waittill( "match_ending_vox" );
+
+        leaderdialog( "timesup" );
+    }
+}
+
+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 );
+}
+
+actionmusicset()
+{
+    level endon( "game_ended" );
+    level.playingactionmusic = 1;
+    wait 45;
+    level.playingactionmusic = 0;
+}
+
+play_2d_on_team( alias, team )
+{
+    assert( isdefined( level.players ) );
+
+    for ( i = 0; i < level.players.size; i++ )
+    {
+        player = level.players[i];
+
+        if ( isdefined( player.pers["team"] ) && player.pers["team"] == team )
+            player playlocalsound( alias );
+    }
+}
+
+set_music_on_team( state, team, save_state, return_state, wait_time )
+{
+    if ( sessionmodeiszombiesgame() )
+        return;
+
+    assert( isdefined( level.players ) );
+
+    if ( !isdefined( team ) )
+    {
+        team = "both";
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - team undefined: Setting to both" );
+#/
+    }
+
+    if ( !isdefined( save_state ) )
+    {
+        save_sate = 0;
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - save_sate undefined: Setting to false" );
+#/
+    }
+
+    if ( !isdefined( return_state ) )
+    {
+        return_state = 0;
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - Music System - return_state undefined: Setting to false" );
+#/
+    }
+
+    if ( !isdefined( wait_time ) )
+    {
+        wait_time = 0;
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - wait_time undefined: Setting to 0" );
+#/
+    }
+
+    for ( i = 0; i < level.players.size; i++ )
+    {
+        player = level.players[i];
+
+        if ( team == "both" )
+        {
+            player thread set_music_on_player( state, save_state, return_state, wait_time );
+            continue;
+        }
+
+        if ( isdefined( player.pers["team"] ) && player.pers["team"] == team )
+        {
+            player thread set_music_on_player( state, save_state, return_state, wait_time );
+/#
+            if ( getdvarint( _hash_BC4784C ) > 0 )
+                println( "Music System - Setting Music State " + state + " On player " + player getentitynumber() );
+#/
+        }
+    }
+}
+
+set_music_on_player( state, save_state, return_state, wait_time )
+{
+    self endon( "disconnect" );
+
+    if ( sessionmodeiszombiesgame() )
+        return;
+
+    assert( isplayer( self ) );
+
+    if ( !isdefined( save_state ) )
+    {
+        save_state = 0;
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - Music System - save_sate undefined: Setting to false" );
+#/
+    }
+
+    if ( !isdefined( return_state ) )
+    {
+        return_state = 0;
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - Music System - return_state undefined: Setting to false" );
+#/
+    }
+
+    if ( !isdefined( wait_time ) )
+    {
+        wait_time = 0;
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - wait_time undefined: Setting to 0" );
+#/
+    }
+
+    if ( !isdefined( state ) )
+    {
+        state = "UNDERSCORE";
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - state undefined: Setting to UNDERSCORE" );
+#/
+    }
+
+    maps\mp\_music::setmusicstate( state, self );
+
+    if ( isdefined( self.pers["music"].currentstate ) && save_state )
+    {
+        self.pers["music"].returnstate = state;
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - Saving Music State " + self.pers["music"].returnstate + " On " + self getentitynumber() );
+#/
+    }
+
+    self.pers["music"].previousstate = self.pers["music"].currentstate;
+    self.pers["music"].currentstate = state;
+/#
+    if ( getdvarint( _hash_BC4784C ) > 0 )
+        println( "Music System - Setting Music State " + state + " On player " + self getentitynumber() );
+#/
+    if ( isdefined( self.pers["music"].returnstate ) && return_state )
+    {
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - Starting Return State " + self.pers["music"].returnstate + " On " + self getentitynumber() );
+#/
+        self set_next_music_state( self.pers["music"].returnstate, wait_time );
+    }
+}
+
+return_music_state_player( wait_time )
+{
+    if ( !isdefined( wait_time ) )
+    {
+        wait_time = 0;
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - wait_time undefined: Setting to 0" );
+#/
+    }
+
+    self set_next_music_state( self.pers["music"].returnstate, wait_time );
+}
+
+return_music_state_team( team, wait_time )
+{
+    if ( !isdefined( wait_time ) )
+    {
+        wait_time = 0;
+/#
+        if ( getdvarint( _hash_BC4784C ) > 0 )
+            println( "Music System - wait_time undefined: Setting to 0" );
+#/
+    }
+
+    for ( i = 0; i < level.players.size; i++ )
+    {
+        player = level.players[i];
+
+        if ( team == "both" )
+        {
+            player thread set_next_music_state( self.pers["music"].returnstate, wait_time );
+            continue;
+        }
+
+        if ( isdefined( player.pers["team"] ) && player.pers["team"] == team )
+        {
+            player thread set_next_music_state( self.pers["music"].returnstate, wait_time );
+/#
+            if ( getdvarint( _hash_BC4784C ) > 0 )
+                println( "Music System - Setting Music State " + self.pers["music"].returnstate + " On player " + player getentitynumber() );
+#/
+        }
+    }
+}
+
+set_next_music_state( nextstate, wait_time )
+{
+    self endon( "disconnect" );
+    self.pers["music"].nextstate = nextstate;
+/#
+    if ( getdvarint( _hash_BC4784C ) > 0 )
+        println( "Music System - Setting next Music State " + self.pers["music"].nextstate + " On " + self getentitynumber() );
+#/
+    if ( !isdefined( self.pers["music"].inque ) )
+        self.pers["music"].inque = 0;
+
+    if ( self.pers["music"].inque )
+    {
+        return;
+/#
+        println( "Music System - Music state in que" );
+#/
+    }
+    else
+    {
+        self.pers["music"].inque = 1;
+
+        if ( wait_time )
+            wait( wait_time );
+
+        self set_music_on_player( self.pers["music"].nextstate, 0 );
+        self.pers["music"].inque = 0;
+    }
+}
+
+getroundswitchdialog( switchtype )
+{
+    switch ( switchtype )
+    {
+        case "halftime":
+            return "halftime";
+        case "overtime":
+            return "overtime";
+        default:
+            return "side_switch";
+    }
+}
+
+post_match_snapshot_watcher()
+{
+    level waittill( "game_ended" );
+
+    level clientnotify( "pm" );
+
+    level waittill( "sfade" );
+
+    level clientnotify( "pmf" );
+}

ZM/Core/maps/mp/gametypes_zm/_globallogic_defaults.gsc

@@ -0,0 +1,214 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes_zm\_globallogic_utils;
+#include maps\mp\gametypes_zm\_globallogic;
+#include maps\mp\gametypes_zm\_globallogic_score;
+#include maps\mp\gametypes_zm\_globallogic_audio;
+#include maps\mp\gametypes_zm\_spawnlogic;
+
+getwinningteamfromloser( losing_team )
+{
+    if ( level.multiteam )
+        return "tie";
+    else if ( losing_team == "axis" )
+        return "allies";
+
+    return "axis";
+}
+
+default_onforfeit( team )
+{
+    level.gameforfeited = 1;
+    level notify( "forfeit in progress" );
+    level endon( "forfeit in progress" );
+    level endon( "abort forfeit" );
+    forfeit_delay = 20.0;
+    announcement( game["strings"]["opponent_forfeiting_in"], forfeit_delay, 0 );
+    wait 10.0;
+    announcement( game["strings"]["opponent_forfeiting_in"], 10.0, 0 );
+    wait 10.0;
+    endreason = &"";
+
+    if ( !isdefined( team ) )
+    {
+        setdvar( "ui_text_endreason", game["strings"]["players_forfeited"] );
+        endreason = game["strings"]["players_forfeited"];
+        winner = level.players[0];
+    }
+    else if ( isdefined( level.teams[team] ) )
+    {
+        endreason = game["strings"][team + "_forfeited"];
+        setdvar( "ui_text_endreason", endreason );
+        winner = getwinningteamfromloser( team );
+    }
+    else
+    {
+        assert( isdefined( team ), "Forfeited team is not defined" );
+        assert( 0, "Forfeited team " + team + " is not allies or axis" );
+        winner = "tie";
+    }
+
+    level.forcedend = 1;
+
+    if ( isplayer( winner ) )
+        logstring( "forfeit, win: " + winner getxuid() + "(" + winner.name + ")" );
+    else
+        maps\mp\gametypes_zm\_globallogic_utils::logteamwinstring( "forfeit", winner );
+
+    thread maps\mp\gametypes_zm\_globallogic::endgame( winner, endreason );
+}
+
+default_ondeadevent( team )
+{
+    if ( isdefined( level.teams[team] ) )
+    {
+        eliminatedstring = game["strings"][team + "_eliminated"];
+        iprintln( eliminatedstring );
+        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 );
+    }
+    else
+    {
+        makedvarserverinfo( "ui_text_endreason", game["strings"]["tie"] );
+        setdvar( "ui_text_endreason", game["strings"]["tie"] );
+        maps\mp\gametypes_zm\_globallogic_utils::logteamwinstring( "tie" );
+
+        if ( level.teambased )
+            thread maps\mp\gametypes_zm\_globallogic::endgame( "tie", game["strings"]["tie"] );
+        else
+            thread maps\mp\gametypes_zm\_globallogic::endgame( undefined, game["strings"]["tie"] );
+    }
+}
+
+default_onalivecountchange( team )
+{
+
+}
+
+default_onroundendgame( winner )
+{
+    return winner;
+}
+
+default_ononeleftevent( team )
+{
+    if ( !level.teambased )
+    {
+        winner = maps\mp\gametypes_zm\_globallogic_score::gethighestscoringplayer();
+
+        if ( isdefined( winner ) )
+            logstring( "last one alive, win: " + winner.name );
+        else
+            logstring( "last one alive, win: unknown" );
+
+        thread maps\mp\gametypes_zm\_globallogic::endgame( winner, &"MP_ENEMIES_ELIMINATED" );
+    }
+    else
+    {
+        for ( index = 0; index < level.players.size; index++ )
+        {
+            player = level.players[index];
+
+            if ( !isalive( player ) )
+                continue;
+
+            if ( !isdefined( player.pers["team"] ) || player.pers["team"] != team )
+                continue;
+
+            player maps\mp\gametypes_zm\_globallogic_audio::leaderdialogonplayer( "sudden_death" );
+        }
+    }
+}
+
+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 );
+    }
+    else
+    {
+        winner = maps\mp\gametypes_zm\_globallogic_score::gethighestscoringplayer();
+
+        if ( isdefined( winner ) )
+            logstring( "time limit, win: " + winner.name );
+        else
+            logstring( "time limit, tie" );
+    }
+
+    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"] );
+}
+
+default_onscorelimit()
+{
+    if ( !level.endgameonscorelimit )
+        return false;
+
+    winner = undefined;
+
+    if ( level.teambased )
+    {
+        winner = maps\mp\gametypes_zm\_globallogic::determineteamwinnerbygamestat( "teamScores" );
+        maps\mp\gametypes_zm\_globallogic_utils::logteamwinstring( "scorelimit", winner );
+    }
+    else
+    {
+        winner = maps\mp\gametypes_zm\_globallogic_score::gethighestscoringplayer();
+
+        if ( isdefined( winner ) )
+            logstring( "scorelimit, win: " + winner.name );
+        else
+            logstring( "scorelimit, tie" );
+    }
+
+    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"] );
+    return true;
+}
+
+default_onspawnspectator( origin, angles )
+{
+    if ( isdefined( origin ) && isdefined( angles ) )
+    {
+        self spawn( origin, angles );
+        return;
+    }
+
+    spawnpointname = "mp_global_intermission";
+    spawnpoints = getentarray( spawnpointname, "classname" );
+    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 );
+    self spawn( spawnpoint.origin, spawnpoint.angles );
+}
+
+default_onspawnintermission()
+{
+    spawnpointname = "mp_global_intermission";
+    spawnpoints = getentarray( spawnpointname, "classname" );
+    spawnpoint = spawnpoints[0];
+
+    if ( isdefined( spawnpoint ) )
+        self spawn( spawnpoint.origin, spawnpoint.angles );
+    else
+    {
+/#
+        maps\mp\_utility::error( "NO " + spawnpointname + " SPAWNPOINTS IN MAP" );
+#/
+    }
+}
+
+default_gettimelimit()
+{
+    return clamp( getgametypesetting( "timeLimit" ), level.timelimitmin, level.timelimitmax );
+}

ZM/Core/maps/mp/gametypes_zm/_globallogic_score.gsc

@@ -0,0 +1,785 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\_bb;
+#include maps\mp\gametypes_zm\_globallogic;
+#include maps\mp\gametypes_zm\_globallogic_score;
+#include maps\mp\gametypes_zm\_globallogic_audio;
+#include maps\mp\_challenges;
+#include maps\mp\gametypes_zm\_globallogic_utils;
+
+updatematchbonusscores( winner )
+{
+
+}
+
+givematchbonus( scoretype, score )
+{
+
+}
+
+doskillupdate( winner )
+{
+    skillupdate( winner, level.teambased );
+}
+
+gethighestscoringplayer()
+{
+    players = level.players;
+    winner = undefined;
+    tie = 0;
+
+    for ( i = 0; i < players.size; i++ )
+    {
+        if ( !isdefined( players[i].score ) )
+            continue;
+
+        if ( players[i].score < 1 )
+            continue;
+
+        if ( !isdefined( winner ) || players[i].score > winner.score )
+        {
+            winner = players[i];
+            tie = 0;
+            continue;
+        }
+
+        if ( players[i].score == winner.score )
+            tie = 1;
+    }
+
+    if ( tie || !isdefined( winner ) )
+        return undefined;
+    else
+        return winner;
+}
+
+resetscorechain()
+{
+    self notify( "reset_score_chain" );
+    self.scorechain = 0;
+    self.rankupdatetotal = 0;
+}
+
+scorechaintimer()
+{
+    self notify( "score_chain_timer" );
+    self endon( "reset_score_chain" );
+    self endon( "score_chain_timer" );
+    self endon( "death" );
+    self endon( "disconnect" );
+    wait 20;
+    self thread resetscorechain();
+}
+
+roundtonearestfive( score )
+{
+    rounding = score % 5;
+
+    if ( rounding <= 2 )
+        return score - rounding;
+    else
+        return score + 5 - rounding;
+}
+
+giveplayermomentumnotification( score, label, descvalue, countstowardrampage )
+{
+    rampagebonus = 0;
+
+    if ( isdefined( level.usingrampage ) && level.usingrampage )
+    {
+        if ( countstowardrampage )
+        {
+            if ( !isdefined( self.scorechain ) )
+                self.scorechain = 0;
+
+            self.scorechain++;
+            self thread scorechaintimer();
+        }
+
+        if ( isdefined( self.scorechain ) && self.scorechain >= 999 )
+            rampagebonus = roundtonearestfive( int( score * level.rampagebonusscale + 0.5 ) );
+    }
+
+    if ( score != 0 )
+        self luinotifyevent( &"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 );
+}
+
+resetplayermomentumondeath()
+{
+    if ( isdefined( level.usingscorestreaks ) && level.usingscorestreaks )
+    {
+        _setplayermomentum( self, 0 );
+        self thread resetscorechain();
+    }
+}
+
+giveplayermomentum( event, player, victim, weapon, descvalue )
+{
+
+}
+
+giveplayerscore( event, player, victim, weapon, descvalue )
+{
+    scorediff = 0;
+    momentum = player.pers["momentum"];
+    giveplayermomentum( event, player, victim, weapon, descvalue );
+    newmomentum = player.pers["momentum"];
+
+    if ( level.overrideplayerscore )
+        return 0;
+
+    pixbeginevent( "level.onPlayerScore" );
+    score = player.pers["score"];
+    [[ level.onplayerscore ]]( event, player, victim );
+    newscore = player.pers["score"];
+    pixendevent();
+    bbprint( "mpplayerscore", "spawnid %d gametime %d type %s player %s delta %d deltamomentum %d team %s", getplayerspawnid( player ), gettime(), event, player.name, newscore - score, newmomentum - momentum, player.team );
+    player maps\mp\_bb::bbaddtostat( "score", newscore - score );
+
+    if ( score == newscore )
+        return 0;
+
+    pixbeginevent( "givePlayerScore" );
+    recordplayerstats( player, "score", newscore );
+    scorediff = newscore - score;
+    player addplayerstatwithgametype( "score", scorediff );
+
+    if ( isdefined( player.pers["lastHighestScore"] ) && newscore > player.pers["lastHighestScore"] )
+        player setdstat( "HighestStats", "highest_score", newscore );
+
+    pixendevent();
+    return scorediff;
+}
+
+default_onplayerscore( event, player, victim )
+{
+
+}
+
+_setplayerscore( player, score )
+{
+
+}
+
+_getplayerscore( player )
+{
+    return player.pers["score"];
+}
+
+_setplayermomentum( player, momentum )
+{
+    momentum = clamp( momentum, 0, 2000 );
+    oldmomentum = player.pers["momentum"];
+
+    if ( momentum == oldmomentum )
+        return;
+
+    player maps\mp\_bb::bbaddtostat( "momentum", momentum - oldmomentum );
+
+    if ( momentum > oldmomentum )
+    {
+        highestmomentumcost = 0;
+        numkillstreaks = player.killstreak.size;
+        killstreaktypearray = [];
+    }
+
+    player.pers["momentum"] = momentum;
+    player.momentum = player.pers["momentum"];
+}
+
+_giveplayerkillstreakinternal( player, momentum, oldmomentum, killstreaktypearray )
+{
+
+}
+
+setplayermomentumdebug()
+{
+/#
+    setdvar( "sv_momentumPercent", 0.0 );
+
+    while ( true )
+    {
+        wait 1;
+        momentumpercent = getdvarfloatdefault( "sv_momentumPercent", 0.0 );
+
+        if ( momentumpercent != 0.0 )
+        {
+            player = gethostplayer();
+
+            if ( !isdefined( player ) )
+                return;
+
+            if ( isdefined( player.killstreak ) )
+                _setplayermomentum( player, int( 2000 * momentumpercent / 100 ) );
+        }
+    }
+#/
+}
+
+giveteamscore( event, team, player, victim )
+{
+    if ( level.overrideteamscore )
+        return;
+
+    pixbeginevent( "level.onTeamScore" );
+    teamscore = game["teamScores"][team];
+    [[ level.onteamscore ]]( event, team );
+    pixendevent();
+    newscore = game["teamScores"][team];
+    bbprint( "mpteamscores", "gametime %d event %s team %d diff %d score %d", gettime(), event, team, newscore - teamscore, newscore );
+
+    if ( teamscore == newscore )
+        return;
+
+    updateteamscores( team );
+    thread maps\mp\gametypes_zm\_globallogic::checkscorelimit();
+}
+
+giveteamscoreforobjective( team, score )
+{
+    teamscore = game["teamScores"][team];
+    onteamscore( 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 );
+    thread maps\mp\gametypes_zm\_globallogic::checkscorelimit();
+}
+
+_setteamscore( team, teamscore )
+{
+    if ( teamscore == game["teamScores"][team] )
+        return;
+
+    game["teamScores"][team] = teamscore;
+    updateteamscores( team );
+    thread maps\mp\gametypes_zm\_globallogic::checkscorelimit();
+}
+
+resetteamscores()
+{
+    if ( !isdefined( level.roundscorecarry ) || level.roundscorecarry == 0 || maps\mp\_utility::isfirstround() )
+    {
+        foreach ( team in level.teams )
+            game["teamScores"][team] = 0;
+    }
+
+    maps\mp\gametypes_zm\_globallogic_score::updateallteamscores();
+}
+
+resetallscores()
+{
+    resetteamscores();
+    resetplayerscores();
+}
+
+resetplayerscores()
+{
+    players = level.players;
+    winner = undefined;
+    tie = 0;
+
+    for ( i = 0; i < players.size; i++ )
+    {
+        if ( isdefined( players[i].pers["score"] ) )
+            _setplayerscore( players[i], 0 );
+    }
+}
+
+updateteamscores( team )
+{
+    setteamscore( team, game["teamScores"][team] );
+    level thread maps\mp\gametypes_zm\_globallogic::checkteamscorelimitsoon( team );
+}
+
+updateallteamscores()
+{
+    foreach ( team in level.teams )
+        updateteamscores( team );
+}
+
+_getteamscore( team )
+{
+    return game["teamScores"][team];
+}
+
+gethighestteamscoreteam()
+{
+    score = 0;
+    winning_teams = [];
+
+    foreach ( team in level.teams )
+    {
+        team_score = game["teamScores"][team];
+
+        if ( team_score > score )
+        {
+            score = team_score;
+            winning_teams = [];
+        }
+
+        if ( team_score == score )
+            winning_teams[team] = team;
+    }
+
+    return winning_teams;
+}
+
+areteamarraysequal( teamsa, teamsb )
+{
+    if ( teamsa.size != teamsb.size )
+        return false;
+
+    foreach ( team in teamsa )
+    {
+        if ( !isdefined( teamsb[team] ) )
+            return false;
+    }
+
+    return true;
+}
+
+onteamscore( score, team )
+{
+    game["teamScores"][team] += score;
+
+    if ( level.scorelimit && game["teamScores"][team] > level.scorelimit )
+        game["teamScores"][team] = level.scorelimit;
+
+    if ( level.splitscreen )
+        return;
+
+    if ( level.scorelimit == 1 )
+        return;
+
+    iswinning = gethighestteamscoreteam();
+
+    if ( iswinning.size == 0 )
+        return;
+
+    if ( gettime() - level.laststatustime < 5000 )
+        return;
+
+    if ( areteamarraysequal( iswinning, level.waswinning ) )
+        return;
+
+    level.laststatustime = gettime();
+
+    if ( iswinning.size == 1 )
+    {
+        foreach ( team in iswinning )
+        {
+            if ( isdefined( level.waswinning[team] ) )
+            {
+                if ( level.waswinning.size == 1 )
+                    continue;
+            }
+
+            maps\mp\gametypes_zm\_globallogic_audio::leaderdialog( "lead_taken", team, "status" );
+        }
+    }
+
+    if ( level.waswinning.size == 1 )
+    {
+        foreach ( team in level.waswinning )
+        {
+            if ( isdefined( iswinning[team] ) )
+            {
+                if ( iswinning.size == 1 )
+                    continue;
+
+                if ( level.waswinning.size > 1 )
+                    continue;
+            }
+
+            maps\mp\gametypes_zm\_globallogic_audio::leaderdialog( "lead_lost", team, "status" );
+        }
+    }
+
+    level.waswinning = iswinning;
+}
+
+default_onteamscore( event, team )
+{
+
+}
+
+initpersstat( dataname, record_stats, init_to_stat_value )
+{
+    if ( !isdefined( self.pers[dataname] ) )
+        self.pers[dataname] = 0;
+
+    if ( !isdefined( record_stats ) || record_stats == 1 )
+        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 )
+{
+    return self.pers[dataname];
+}
+
+incpersstat( dataname, increment, record_stats, includegametype )
+{
+    pixbeginevent( "incPersStat" );
+    self.pers[dataname] += increment;
+
+    if ( isdefined( includegametype ) && includegametype )
+        self addplayerstatwithgametype( dataname, increment );
+    else
+        self addplayerstat( dataname, increment );
+
+    if ( !isdefined( record_stats ) || record_stats == 1 )
+        self thread threadedrecordplayerstats( dataname );
+
+    pixendevent();
+}
+
+threadedrecordplayerstats( dataname )
+{
+    self endon( "disconnect" );
+    waittillframeend;
+    recordplayerstats( self, dataname, self.pers[dataname] );
+}
+
+updatewinstats( winner )
+{
+
+}
+
+updatelossstats( loser )
+{
+    loser addplayerstatwithgametype( "losses", 1 );
+    loser updatestatratio( "wlratio", "wins", "losses" );
+    loser notify( "loss" );
+}
+
+updatetiestats( loser )
+{
+    loser addplayerstatwithgametype( "losses", -1 );
+    loser addplayerstatwithgametype( "ties", 1 );
+    loser updatestatratio( "wlratio", "wins", "losses" );
+    loser setdstat( "playerstatslist", "cur_win_streak", "StatValue", 0 );
+    loser notify( "tie" );
+}
+
+updatewinlossstats( winner )
+{
+    if ( !waslastround() && !level.hostforcedend )
+        return;
+
+    players = level.players;
+
+    if ( !isdefined( winner ) || isdefined( winner ) && !isplayer( winner ) && winner == "tie" )
+    {
+        for ( i = 0; i < players.size; i++ )
+        {
+            if ( !isdefined( players[i].pers["team"] ) )
+                continue;
+
+            if ( level.hostforcedend && players[i] ishost() )
+                continue;
+
+            updatetiestats( players[i] );
+        }
+    }
+    else if ( isplayer( winner ) )
+    {
+        if ( level.hostforcedend && winner ishost() )
+            return;
+
+        updatewinstats( winner );
+    }
+    else
+    {
+        for ( i = 0; i < players.size; i++ )
+        {
+            if ( !isdefined( players[i].pers["team"] ) )
+                continue;
+
+            if ( level.hostforcedend && players[i] ishost() )
+                continue;
+
+            if ( winner == "tie" )
+            {
+                updatetiestats( players[i] );
+                continue;
+            }
+
+            if ( players[i].pers["team"] == winner )
+            {
+                updatewinstats( players[i] );
+                continue;
+            }
+
+            players[i] setdstat( "playerstatslist", "cur_win_streak", "StatValue", 0 );
+        }
+    }
+}
+
+backupandclearwinstreaks()
+{
+
+}
+
+restorewinstreaks( winner )
+{
+
+}
+
+inckillstreaktracker( sweapon )
+{
+    self endon( "disconnect" );
+    waittillframeend;
+
+    if ( sweapon == "artillery_mp" )
+        self.pers["artillery_kills"]++;
+
+    if ( sweapon == "dog_bite_mp" )
+        self.pers["dog_kills"]++;
+}
+
+trackattackerkill( name, rank, xp, prestige, xuid )
+{
+    self endon( "disconnect" );
+    attacker = self;
+    waittillframeend;
+    pixbeginevent( "trackAttackerKill" );
+
+    if ( !isdefined( attacker.pers["killed_players"][name] ) )
+        attacker.pers["killed_players"][name] = 0;
+
+    if ( !isdefined( attacker.killedplayerscurrent[name] ) )
+        attacker.killedplayerscurrent[name] = 0;
+
+    if ( !isdefined( attacker.pers["nemesis_tracking"][name] ) )
+        attacker.pers["nemesis_tracking"][name] = 0;
+
+    attacker.pers["killed_players"][name]++;
+    attacker.killedplayerscurrent[name]++;
+    attacker.pers["nemesis_tracking"][name] += 1.0;
+
+    if ( attacker.pers["nemesis_name"] == name )
+        attacker maps\mp\_challenges::killednemesis();
+
+    if ( attacker.pers["nemesis_name"] == "" || attacker.pers["nemesis_tracking"][name] > attacker.pers["nemesis_tracking"][attacker.pers["nemesis_name"]] )
+    {
+        attacker.pers["nemesis_name"] = name;
+        attacker.pers["nemesis_rank"] = rank;
+        attacker.pers["nemesis_rankIcon"] = prestige;
+        attacker.pers["nemesis_xp"] = xp;
+        attacker.pers["nemesis_xuid"] = xuid;
+    }
+    else if ( isdefined( attacker.pers["nemesis_name"] ) && attacker.pers["nemesis_name"] == name )
+    {
+        attacker.pers["nemesis_rank"] = rank;
+        attacker.pers["nemesis_xp"] = xp;
+    }
+
+    pixendevent();
+}
+
+trackattackeedeath( attackername, rank, xp, prestige, xuid )
+{
+    self endon( "disconnect" );
+    waittillframeend;
+    pixbeginevent( "trackAttackeeDeath" );
+
+    if ( !isdefined( self.pers["killed_by"][attackername] ) )
+        self.pers["killed_by"][attackername] = 0;
+
+    self.pers["killed_by"][attackername]++;
+
+    if ( !isdefined( self.pers["nemesis_tracking"][attackername] ) )
+        self.pers["nemesis_tracking"][attackername] = 0;
+
+    self.pers["nemesis_tracking"][attackername] += 1.5;
+
+    if ( self.pers["nemesis_name"] == "" || self.pers["nemesis_tracking"][attackername] > self.pers["nemesis_tracking"][self.pers["nemesis_name"]] )
+    {
+        self.pers["nemesis_name"] = attackername;
+        self.pers["nemesis_rank"] = rank;
+        self.pers["nemesis_rankIcon"] = prestige;
+        self.pers["nemesis_xp"] = xp;
+        self.pers["nemesis_xuid"] = xuid;
+    }
+    else if ( isdefined( self.pers["nemesis_name"] ) && self.pers["nemesis_name"] == attackername )
+    {
+        self.pers["nemesis_rank"] = rank;
+        self.pers["nemesis_xp"] = xp;
+    }
+
+    if ( self.pers["nemesis_name"] == attackername && self.pers["nemesis_tracking"][attackername] >= 2 )
+        self setclientuivisibilityflag( "killcam_nemesis", 1 );
+    else
+        self setclientuivisibilityflag( "killcam_nemesis", 0 );
+
+    pixendevent();
+}
+
+default_iskillboosting()
+{
+    return 0;
+}
+
+givekillstats( smeansofdeath, sweapon, evictim )
+{
+    self endon( "disconnect" );
+    waittillframeend;
+
+    if ( level.rankedmatch && self [[ level.iskillboosting ]]() )
+    {
+/#
+        self iprintlnbold( "GAMETYPE DEBUG: NOT GIVING YOU OFFENSIVE CREDIT AS BOOSTING PREVENTION" );
+#/
+        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 updatestatratio( "kdratio", "kills", "deaths" );
+    attacker = self;
+
+    if ( smeansofdeath == "MOD_HEAD_SHOT" )
+    {
+        attacker thread incpersstat( "headshots", 1, 1, 0 );
+        attacker.headshots = attacker.pers["headshots"];
+        evictim recordkillmodifier( "headshot" );
+    }
+
+    pixendevent();
+}
+
+inctotalkills( team )
+{
+    if ( level.teambased && isdefined( level.teams[team] ) )
+        game["totalKillsTeam"][team]++;
+
+    game["totalKills"]++;
+}
+
+setinflictorstat( einflictor, eattacker, sweapon )
+{
+    if ( !isdefined( eattacker ) )
+        return;
+
+    if ( !isdefined( einflictor ) )
+    {
+        eattacker addweaponstat( sweapon, "hits", 1 );
+        return;
+    }
+
+    if ( !isdefined( einflictor.playeraffectedarray ) )
+        einflictor.playeraffectedarray = [];
+
+    foundnewplayer = 1;
+
+    for ( i = 0; i < einflictor.playeraffectedarray.size; i++ )
+    {
+        if ( einflictor.playeraffectedarray[i] == self )
+        {
+            foundnewplayer = 0;
+            break;
+        }
+    }
+
+    if ( foundnewplayer )
+    {
+        einflictor.playeraffectedarray[einflictor.playeraffectedarray.size] = self;
+
+        if ( sweapon == "concussion_grenade_mp" || sweapon == "tabun_gas_mp" )
+            eattacker addweaponstat( sweapon, "used", 1 );
+
+        eattacker addweaponstat( sweapon, "hits", 1 );
+    }
+}
+
+processshieldassist( killedplayer )
+{
+    self endon( "disconnect" );
+    killedplayer endon( "disconnect" );
+    wait 0.05;
+    maps\mp\gametypes_zm\_globallogic_utils::waittillslowprocessallowed();
+
+    if ( !isdefined( level.teams[self.pers["team"]] ) )
+        return;
+
+    if ( self.pers["team"] == killedplayer.pers["team"] )
+        return;
+
+    if ( !level.teambased )
+        return;
+
+    self maps\mp\gametypes_zm\_globallogic_score::incpersstat( "assists", 1, 1, 1 );
+    self.assists = self maps\mp\gametypes_zm\_globallogic_score::getpersstat( "assists" );
+}
+
+processassist( killedplayer, damagedone, weapon )
+{
+    self endon( "disconnect" );
+    killedplayer endon( "disconnect" );
+    wait 0.05;
+    maps\mp\gametypes_zm\_globallogic_utils::waittillslowprocessallowed();
+
+    if ( !isdefined( level.teams[self.pers["team"]] ) )
+        return;
+
+    if ( self.pers["team"] == killedplayer.pers["team"] )
+        return;
+
+    if ( !level.teambased )
+        return;
+
+    assist_level = "assist";
+    assist_level_value = int( ceil( damagedone / 25 ) );
+
+    if ( assist_level_value < 1 )
+        assist_level_value = 1;
+    else if ( assist_level_value > 3 )
+        assist_level_value = 3;
+
+    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" );
+
+    switch ( weapon )
+    {
+        case "concussion_grenade_mp":
+            assist_level = "assist_concussion";
+            break;
+        case "flash_grenade_mp":
+            assist_level = "assist_flash";
+            break;
+        case "emp_grenade_mp":
+            assist_level = "assist_emp";
+            break;
+        case "proximity_grenade_mp":
+        case "proximity_grenade_aoe_mp":
+            assist_level = "assist_proximity";
+            break;
+    }
+
+    self maps\mp\_challenges::assisted();
+}
+
+xpratethread()
+{
+/#
+
+#/
+}

ZM/Core/maps/mp/gametypes_zm/_globallogic_spawn.gsc

@@ -0,0 +1,878 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\gametypes_zm\_globallogic_player;
+#include maps\mp\gametypes_zm\_spawning;
+#include maps\mp\gametypes_zm\_globallogic_audio;
+#include maps\mp\gametypes_zm\_globallogic_utils;
+#include maps\mp\gametypes_zm\_globallogic;
+#include maps\mp\gametypes_zm\_hud_message;
+#include maps\mp\gametypes_zm\_hud_util;
+#include maps\mp\gametypes_zm\_globallogic_ui;
+#include maps\mp\gametypes_zm\_globallogic_score;
+#include maps\mp\zombies\_zm_perks;
+#include maps\mp\gametypes_zm\_spectating;
+#include maps\mp\gametypes_zm\_hostmigration;
+#include maps\mp\gametypes_zm\_globallogic_defaults;
+#include maps\mp\gametypes_zm\_spawnlogic;
+
+timeuntilspawn( includeteamkilldelay )
+{
+    if ( level.ingraceperiod && !self.hasspawned )
+        return 0;
+
+    respawndelay = 0;
+
+    if ( self.hasspawned )
+    {
+        result = self [[ level.onrespawndelay ]]();
+
+        if ( isdefined( result ) )
+            respawndelay = result;
+        else
+            respawndelay = level.playerrespawndelay;
+
+        if ( includeteamkilldelay && ( isdefined( self.teamkillpunish ) && self.teamkillpunish ) )
+            respawndelay += maps\mp\gametypes_zm\_globallogic_player::teamkilldelay();
+    }
+
+    wavebased = level.waverespawndelay > 0;
+
+    if ( wavebased )
+        return self timeuntilwavespawn( respawndelay );
+
+    return respawndelay;
+}
+
+allteamshaveexisted()
+{
+    foreach ( team in level.teams )
+    {
+        if ( !level.everexisted[team] )
+            return false;
+    }
+
+    return true;
+}
+
+mayspawn()
+{
+    if ( isdefined( level.mayspawn ) && !self [[ level.mayspawn ]]() )
+        return false;
+
+    if ( level.inovertime )
+        return false;
+
+    if ( level.playerqueuedrespawn && !isdefined( self.allowqueuespawn ) && !level.ingraceperiod && !level.usestartspawns )
+        return false;
+
+    if ( level.numlives )
+    {
+        if ( level.teambased )
+            gamehasstarted = allteamshaveexisted();
+        else
+            gamehasstarted = level.maxplayercount > 1 || !isoneround() && !isfirstround();
+
+        if ( !self.pers["lives"] && gamehasstarted )
+            return false;
+        else if ( gamehasstarted )
+        {
+            if ( !level.ingraceperiod && !self.hasspawned && !level.wagermatch )
+                return false;
+        }
+    }
+
+    return true;
+}
+
+timeuntilwavespawn( minimumwait )
+{
+    earliestspawntime = gettime() + minimumwait * 1000;
+    lastwavetime = level.lastwave[self.pers["team"]];
+    wavedelay = level.wavedelay[self.pers["team"]] * 1000;
+
+    if ( wavedelay == 0 )
+        return 0;
+
+    numwavespassedearliestspawntime = ( earliestspawntime - lastwavetime ) / wavedelay;
+    numwaves = ceil( numwavespassedearliestspawntime );
+    timeofspawn = lastwavetime + numwaves * wavedelay;
+
+    if ( isdefined( self.wavespawnindex ) )
+        timeofspawn += 50 * self.wavespawnindex;
+
+    return ( timeofspawn - gettime() ) / 1000;
+}
+
+stoppoisoningandflareonspawn()
+{
+    self endon( "disconnect" );
+    self.inpoisonarea = 0;
+    self.inburnarea = 0;
+    self.inflarevisionarea = 0;
+    self.ingroundnapalm = 0;
+}
+
+spawnplayerprediction()
+{
+    self endon( "disconnect" );
+    self endon( "end_respawn" );
+    self endon( "game_ended" );
+    self endon( "joined_spectators" );
+    self endon( "spawned" );
+
+    while ( true )
+    {
+        wait 0.5;
+
+        if ( isdefined( level.onspawnplayerunified ) && getdvarint( _hash_CF6EEB8B ) == 0 )
+            maps\mp\gametypes_zm\_spawning::onspawnplayer_unified( 1 );
+        else
+            self [[ level.onspawnplayer ]]( 1 );
+    }
+}
+
+giveloadoutlevelspecific( team, class )
+{
+    pixbeginevent( "giveLoadoutLevelSpecific" );
+
+    if ( isdefined( level.givecustomcharacters ) )
+        self [[ level.givecustomcharacters ]]();
+
+    if ( isdefined( level.givecustomloadout ) )
+        self [[ level.givecustomloadout ]]();
+
+    pixendevent();
+}
+
+spawnplayer()
+{
+    pixbeginevent( "spawnPlayer_preUTS" );
+    self endon( "disconnect" );
+    self endon( "joined_spectators" );
+    self notify( "spawned" );
+    level notify( "player_spawned" );
+    self notify( "end_respawn" );
+    self setspawnvariables();
+
+    if ( !self.hasspawned )
+    {
+        self.underscorechance = 70;
+        self thread maps\mp\gametypes_zm\_globallogic_audio::sndstartmusicsystem();
+    }
+
+    if ( level.teambased )
+        self.sessionteam = self.team;
+    else
+    {
+        self.sessionteam = "none";
+        self.ffateam = self.team;
+    }
+
+    hadspawned = self.hasspawned;
+    self.sessionstate = "playing";
+    self.spectatorclient = -1;
+    self.killcamentity = -1;
+    self.archivetime = 0;
+    self.psoffsettime = 0;
+    self.statusicon = "";
+    self.damagedplayers = [];
+
+    if ( getdvarint( "scr_csmode" ) > 0 )
+        self.maxhealth = getdvarint( "scr_csmode" );
+    else
+        self.maxhealth = level.playermaxhealth;
+
+    self.health = self.maxhealth;
+    self.friendlydamage = undefined;
+    self.hasspawned = 1;
+    self.spawntime = gettime();
+    self.afk = 0;
+
+    if ( self.pers["lives"] && ( !isdefined( level.takelivesondeath ) || level.takelivesondeath == 0 ) )
+    {
+        self.pers["lives"]--;
+
+        if ( self.pers["lives"] == 0 )
+        {
+            level notify( "player_eliminated" );
+            self notify( "player_eliminated" );
+        }
+    }
+
+    self.laststand = undefined;
+    self.revivingteammate = 0;
+    self.burning = undefined;
+    self.nextkillstreakfree = undefined;
+    self.activeuavs = 0;
+    self.activecounteruavs = 0;
+    self.activesatellites = 0;
+    self.deathmachinekills = 0;
+    self.disabledweapon = 0;
+    self resetusability();
+    self maps\mp\gametypes_zm\_globallogic_player::resetattackerlist();
+    self.diedonvehicle = undefined;
+
+    if ( !self.wasaliveatmatchstart )
+    {
+        if ( level.ingraceperiod || maps\mp\gametypes_zm\_globallogic_utils::gettimepassed() < 20000 )
+            self.wasaliveatmatchstart = 1;
+    }
+
+    self setdepthoffield( 0, 0, 512, 512, 4, 0 );
+    self resetfov();
+    pixbeginevent( "onSpawnPlayer" );
+
+    if ( isdefined( level.onspawnplayerunified ) && getdvarint( _hash_CF6EEB8B ) == 0 )
+        self [[ level.onspawnplayerunified ]]();
+    else
+        self [[ level.onspawnplayer ]]( 0 );
+
+    if ( isdefined( level.playerspawnedcb ) )
+        self [[ level.playerspawnedcb ]]();
+
+    pixendevent();
+    pixendevent();
+    level thread maps\mp\gametypes_zm\_globallogic::updateteamstatus();
+    pixbeginevent( "spawnPlayer_postUTS" );
+    self thread stoppoisoningandflareonspawn();
+    self stopburning();
+    assert( maps\mp\gametypes_zm\_globallogic_utils::isvalidclass( self.class ) );
+    self giveloadoutlevelspecific( self.team, self.class );
+
+    if ( level.inprematchperiod )
+    {
+        self freeze_player_controls( 1 );
+        team = self.pers["team"];
+
+        if ( isdefined( self.pers["music"].spawn ) && self.pers["music"].spawn == 0 )
+        {
+            if ( level.wagermatch )
+                music = "SPAWN_WAGER";
+            else
+                music = game["music"]["spawn_" + team];
+
+            self thread maps\mp\gametypes_zm\_globallogic_audio::set_music_on_player( music, 0, 0 );
+            self.pers["music"].spawn = 1;
+        }
+
+        if ( level.splitscreen )
+        {
+            if ( isdefined( level.playedstartingmusic ) )
+                music = undefined;
+            else
+                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" );
+        }
+    }
+    else
+    {
+        self freeze_player_controls( 0 );
+        self enableweapons();
+
+        if ( !hadspawned && game["state"] == "playing" )
+        {
+            pixbeginevent( "sound" );
+            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 );
+                self.pers["music"].spawn = 1;
+            }
+
+            if ( level.splitscreen )
+            {
+                if ( isdefined( level.playedstartingmusic ) )
+                    music = undefined;
+                else
+                    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" );
+            }
+
+            pixendevent();
+        }
+    }
+
+    if ( getdvar( "scr_showperksonspawn" ) == "" )
+        setdvar( "scr_showperksonspawn", "0" );
+
+    if ( level.hardcoremode )
+        setdvar( "scr_showperksonspawn", "0" );
+
+    if ( !level.splitscreen && getdvarint( "scr_showperksonspawn" ) == 1 && game["state"] != "postgame" )
+    {
+        pixbeginevent( "showperksonspawn" );
+
+        if ( level.perksenabled == 1 )
+            self maps\mp\gametypes_zm\_hud_util::showperks();
+
+        self thread maps\mp\gametypes_zm\_globallogic_ui::hideloadoutaftertime( 3.0 );
+        self thread maps\mp\gametypes_zm\_globallogic_ui::hideloadoutondeath();
+        pixendevent();
+    }
+
+    if ( isdefined( self.pers["momentum"] ) )
+        self.momentum = self.pers["momentum"];
+
+    pixendevent();
+    waittillframeend;
+    self notify( "spawned_player" );
+    self logstring( "S " + self.origin[0] + " " + self.origin[1] + " " + self.origin[2] );
+    setdvar( "scr_selecting_location", "" );
+/#
+    if ( getdvarint( _hash_F8D00F60 ) > 0 )
+        self thread maps\mp\gametypes_zm\_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();
+    }
+}
+
+spawnspectator( origin, angles )
+{
+    self notify( "spawned" );
+    self notify( "end_respawn" );
+    in_spawnspectator( origin, angles );
+}
+
+respawn_asspectator( origin, angles )
+{
+    in_spawnspectator( origin, angles );
+}
+
+in_spawnspectator( origin, angles )
+{
+    pixmarker( "BEGIN: in_spawnSpectator" );
+    self setspawnvariables();
+
+    if ( self.pers["team"] == "spectator" )
+        self clearlowermessage();
+
+    self.sessionstate = "spectator";
+    self.spectatorclient = -1;
+    self.killcamentity = -1;
+    self.archivetime = 0;
+    self.psoffsettime = 0;
+    self.friendlydamage = undefined;
+
+    if ( self.pers["team"] == "spectator" )
+        self.statusicon = "";
+    else
+        self.statusicon = "hud_status_dead";
+
+    maps\mp\gametypes_zm\_spectating::setspectatepermissionsformachine();
+    [[ level.onspawnspectator ]]( origin, angles );
+
+    if ( level.teambased && !level.splitscreen )
+        self thread spectatorthirdpersonness();
+
+    level thread maps\mp\gametypes_zm\_globallogic::updateteamstatus();
+    pixmarker( "END: in_spawnSpectator" );
+}
+
+spectatorthirdpersonness()
+{
+    self endon( "disconnect" );
+    self endon( "spawned" );
+    self notify( "spectator_thirdperson_thread" );
+    self endon( "spectator_thirdperson_thread" );
+    self.spectatingthirdperson = 0;
+}
+
+forcespawn( time )
+{
+    self endon( "death" );
+    self endon( "disconnect" );
+    self endon( "spawned" );
+
+    if ( !isdefined( time ) )
+        time = 60;
+
+    wait( time );
+
+    if ( self.hasspawned )
+        return;
+
+    if ( self.pers["team"] == "spectator" )
+        return;
+
+    if ( !maps\mp\gametypes_zm\_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 thread [[ level.spawnclient ]]();
+}
+
+kickifdontspawn()
+{
+/#
+    if ( getdvarint( "scr_hostmigrationtest" ) == 1 )
+        return;
+#/
+    if ( self ishost() )
+        return;
+
+    self kickifidontspawninternal();
+}
+
+kickifidontspawninternal()
+{
+    self endon( "death" );
+    self endon( "disconnect" );
+    self endon( "spawned" );
+    waittime = 90;
+
+    if ( getdvar( _hash_4257CF5C ) != "" )
+        waittime = getdvarfloat( _hash_4257CF5C );
+
+    mintime = 45;
+
+    if ( getdvar( _hash_DF057E0 ) != "" )
+        mintime = getdvarfloat( _hash_DF057E0 );
+
+    starttime = gettime();
+    kickwait( waittime );
+    timepassed = ( gettime() - starttime ) / 1000;
+
+    if ( timepassed < waittime - 0.1 && timepassed < mintime )
+        return;
+
+    if ( self.hasspawned )
+        return;
+
+    if ( sessionmodeisprivate() )
+        return;
+
+    if ( self.pers["team"] == "spectator" )
+        return;
+
+    kick( self getentitynumber() );
+}
+
+kickwait( waittime )
+{
+    level endon( "game_ended" );
+    maps\mp\gametypes_zm\_hostmigration::waitlongdurationwithhostmigrationpause( waittime );
+}
+
+spawninterroundintermission()
+{
+    self notify( "spawned" );
+    self notify( "end_respawn" );
+    self setspawnvariables();
+    self clearlowermessage();
+    self freeze_player_controls( 0 );
+    self.sessionstate = "spectator";
+    self.spectatorclient = -1;
+    self.killcamentity = -1;
+    self.archivetime = 0;
+    self.psoffsettime = 0;
+    self.friendlydamage = undefined;
+    self maps\mp\gametypes_zm\_globallogic_defaults::default_onspawnintermission();
+    self setorigin( self.origin );
+    self setplayerangles( self.angles );
+    self setdepthoffield( 0, 128, 512, 4000, 6, 1.8 );
+}
+
+spawnintermission( usedefaultcallback )
+{
+    self notify( "spawned" );
+    self notify( "end_respawn" );
+    self endon( "disconnect" );
+    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.0;
+
+            while ( waittime )
+            {
+                wait 0.25;
+                waittime -= 0.25;
+                self openmenu( game["menu_endgameupdate"] );
+            }
+
+            self closemenu();
+        }
+    }
+
+    self.sessionstate = "intermission";
+    self.spectatorclient = -1;
+    self.killcamentity = -1;
+    self.archivetime = 0;
+    self.psoffsettime = 0;
+    self.friendlydamage = undefined;
+
+    if ( isdefined( usedefaultcallback ) && usedefaultcallback )
+        maps\mp\gametypes_zm\_globallogic_defaults::default_onspawnintermission();
+    else
+        [[ level.onspawnintermission ]]();
+
+    self setdepthoffield( 0, 128, 512, 4000, 6, 1.8 );
+}
+
+spawnqueuedclientonteam( team )
+{
+    player_to_spawn = undefined;
+
+    for ( i = 0; i < level.deadplayers[team].size; i++ )
+    {
+        player = level.deadplayers[team][i];
+
+        if ( player.waitingtospawn )
+            continue;
+
+        player_to_spawn = player;
+        break;
+    }
+
+    if ( isdefined( player_to_spawn ) )
+    {
+        player_to_spawn.allowqueuespawn = 1;
+        player_to_spawn maps\mp\gametypes_zm\_globallogic_ui::closemenus();
+        player_to_spawn thread [[ level.spawnclient ]]();
+    }
+}
+
+spawnqueuedclient( dead_player_team, killer )
+{
+    if ( !level.playerqueuedrespawn )
+        return;
+
+    maps\mp\gametypes_zm\_globallogic_utils::waittillslowprocessallowed();
+    spawn_team = undefined;
+
+    if ( isdefined( killer ) && isdefined( killer.team ) && isdefined( level.teams[killer.team] ) )
+        spawn_team = killer.team;
+
+    if ( isdefined( spawn_team ) )
+    {
+        spawnqueuedclientonteam( spawn_team );
+        return;
+    }
+
+    foreach ( team in level.teams )
+    {
+        if ( team == dead_player_team )
+            continue;
+
+        spawnqueuedclientonteam( team );
+    }
+}
+
+allteamsnearscorelimit()
+{
+    if ( !level.teambased )
+        return false;
+
+    if ( level.scorelimit <= 1 )
+        return false;
+
+    foreach ( team in level.teams )
+    {
+        if ( !( game["teamScores"][team] >= level.scorelimit - 1 ) )
+            return false;
+    }
+
+    return true;
+}
+
+shouldshowrespawnmessage()
+{
+    if ( waslastround() )
+        return false;
+
+    if ( isoneround() )
+        return false;
+
+    if ( isdefined( level.livesdonotreset ) && level.livesdonotreset )
+        return false;
+
+    if ( allteamsnearscorelimit() )
+        return false;
+
+    return true;
+}
+
+default_spawnmessage()
+{
+    setlowermessage( game["strings"]["spawn_next_round"] );
+    self thread maps\mp\gametypes_zm\_globallogic_ui::removespawnmessageshortly( 3 );
+}
+
+showspawnmessage()
+{
+    if ( shouldshowrespawnmessage() )
+        self thread [[ level.spawnmessage ]]();
+}
+
+spawnclient( timealreadypassed )
+{
+    pixbeginevent( "spawnClient" );
+    assert( isdefined( self.team ) );
+    assert( maps\mp\gametypes_zm\_globallogic_utils::isvalidclass( self.class ) );
+
+    if ( !self mayspawn() )
+    {
+        currentorigin = self.origin;
+        currentangles = self.angles;
+        self showspawnmessage();
+        self thread [[ level.spawnspectator ]]( currentorigin + vectorscale( ( 0, 0, 1 ), 60.0 ), currentangles );
+        pixendevent();
+        return;
+    }
+
+    if ( self.waitingtospawn )
+    {
+        pixendevent();
+        return;
+    }
+
+    self.waitingtospawn = 1;
+    self.allowqueuespawn = undefined;
+    self waitandspawnclient( timealreadypassed );
+
+    if ( isdefined( self ) )
+        self.waitingtospawn = 0;
+
+    pixendevent();
+}
+
+waitandspawnclient( timealreadypassed )
+{
+    self endon( "disconnect" );
+    self endon( "end_respawn" );
+    level endon( "game_ended" );
+
+    if ( !isdefined( timealreadypassed ) )
+        timealreadypassed = 0;
+
+    spawnedasspectator = 0;
+
+    if ( isdefined( self.teamkillpunish ) && self.teamkillpunish )
+    {
+        teamkilldelay = maps\mp\gametypes_zm\_globallogic_player::teamkilldelay();
+
+        if ( teamkilldelay > timealreadypassed )
+        {
+            teamkilldelay -= timealreadypassed;
+            timealreadypassed = 0;
+        }
+        else
+        {
+            timealreadypassed -= teamkilldelay;
+            teamkilldelay = 0;
+        }
+
+        if ( teamkilldelay > 0 )
+        {
+            setlowermessage( &"MP_FRIENDLY_FIRE_WILL_NOT", teamkilldelay );
+            self thread respawn_asspectator( self.origin + vectorscale( ( 0, 0, 1 ), 60.0 ), self.angles );
+            spawnedasspectator = 1;
+            wait( teamkilldelay );
+        }
+
+        self.teamkillpunish = 0;
+    }
+
+    if ( !isdefined( self.wavespawnindex ) && isdefined( level.waveplayerspawnindex[self.team] ) )
+    {
+        self.wavespawnindex = level.waveplayerspawnindex[self.team];
+        level.waveplayerspawnindex[self.team]++;
+    }
+
+    timeuntilspawn = timeuntilspawn( 0 );
+
+    if ( timeuntilspawn > timealreadypassed )
+    {
+        timeuntilspawn -= timealreadypassed;
+        timealreadypassed = 0;
+    }
+    else
+    {
+        timealreadypassed -= timeuntilspawn;
+        timeuntilspawn = 0;
+    }
+
+    if ( timeuntilspawn > 0 )
+    {
+        if ( level.playerqueuedrespawn )
+            setlowermessage( game["strings"]["you_will_spawn"], timeuntilspawn );
+        else if ( self issplitscreen() )
+            setlowermessage( game["strings"]["waiting_to_spawn_ss"], timeuntilspawn, 1 );
+        else
+            setlowermessage( game["strings"]["waiting_to_spawn"], timeuntilspawn );
+
+        if ( !spawnedasspectator )
+        {
+            spawnorigin = self.origin + vectorscale( ( 0, 0, 1 ), 60.0 );
+            spawnangles = self.angles;
+
+            if ( isdefined( level.useintermissionpointsonwavespawn ) && [[ level.useintermissionpointsonwavespawn ]]() == 1 )
+            {
+                spawnpoint = maps\mp\gametypes_zm\_spawnlogic::getrandomintermissionpoint();
+
+                if ( isdefined( spawnpoint ) )
+                {
+                    spawnorigin = spawnpoint.origin;
+                    spawnangles = spawnpoint.angles;
+                }
+            }
+
+            self thread respawn_asspectator( spawnorigin, spawnangles );
+        }
+
+        spawnedasspectator = 1;
+        self maps\mp\gametypes_zm\_globallogic_utils::waitfortimeornotify( timeuntilspawn, "force_spawn" );
+        self notify( "stop_wait_safe_spawn_button" );
+    }
+
+    wavebased = level.waverespawndelay > 0;
+
+    if ( !level.playerforcerespawn && self.hasspawned && !wavebased && !self.wantsafespawn && !level.playerqueuedrespawn )
+    {
+        setlowermessage( game["strings"]["press_to_spawn"] );
+
+        if ( !spawnedasspectator )
+            self thread respawn_asspectator( self.origin + vectorscale( ( 0, 0, 1 ), 60.0 ), self.angles );
+
+        spawnedasspectator = 1;
+        self waitrespawnorsafespawnbutton();
+    }
+
+    self.waitingtospawn = 0;
+    self clearlowermessage();
+    self.wavespawnindex = undefined;
+    self.respawntimerstarttime = undefined;
+    self thread [[ level.spawnplayer ]]();
+}
+
+waitrespawnorsafespawnbutton()
+{
+    self endon( "disconnect" );
+    self endon( "end_respawn" );
+
+    while ( true )
+    {
+        if ( self usebuttonpressed() )
+            break;
+
+        wait 0.05;
+    }
+}
+
+waitinspawnqueue()
+{
+    self endon( "disconnect" );
+    self endon( "end_respawn" );
+
+    if ( !level.ingraceperiod && !level.usestartspawns )
+    {
+        currentorigin = self.origin;
+        currentangles = self.angles;
+        self thread [[ level.spawnspectator ]]( currentorigin + vectorscale( ( 0, 0, 1 ), 60.0 ), currentangles );
+
+        self waittill( "queue_respawn" );
+    }
+}
+
+setthirdperson( value )
+{
+    if ( !level.console )
+        return;
+
+    if ( !isdefined( self.spectatingthirdperson ) || value != self.spectatingthirdperson )
+    {
+        self.spectatingthirdperson = value;
+
+        if ( value )
+        {
+            self setclientthirdperson( 1 );
+            self setdepthoffield( 0, 128, 512, 4000, 6, 1.8 );
+        }
+        else
+        {
+            self setclientthirdperson( 0 );
+            self setdepthoffield( 0, 0, 512, 4000, 4, 0 );
+        }
+
+        self resetfov();
+    }
+}
+
+setspawnvariables()
+{
+    resettimeout();
+    self stopshellshock();
+    self stoprumble( "damage_heavy" );
+}

ZM/Core/maps/mp/gametypes_zm/_globallogic_ui.gsc

@@ -0,0 +1,490 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include maps\mp\gametypes_zm\_hud_util;
+#include maps\mp\gametypes_zm\_globallogic;
+#include maps\mp\gametypes_zm\_spectating;
+#include maps\mp\gametypes_zm\_globallogic_player;
+
+init()
+{
+    precachestring( &"MP_HALFTIME" );
+    precachestring( &"MP_OVERTIME" );
+    precachestring( &"MP_ROUNDEND" );
+    precachestring( &"MP_INTERMISSION" );
+    precachestring( &"MP_SWITCHING_SIDES_CAPS" );
+    precachestring( &"MP_FRIENDLY_FIRE_WILL_NOT" );
+    precachestring( &"MP_RAMPAGE" );
+    precachestring( &"medal_received" );
+    precachestring( &"killstreak_received" );
+    precachestring( &"prox_grenade_notify" );
+    precachestring( &"player_callout" );
+    precachestring( &"score_event" );
+    precachestring( &"rank_up" );
+    precachestring( &"gun_level_complete" );
+    precachestring( &"challenge_complete" );
+
+    if ( sessionmodeiszombiesgame() )
+        precachestring( &"hud_update_survival_team" );
+
+    if ( level.splitscreen )
+        precachestring( &"MP_ENDED_GAME" );
+    else
+        precachestring( &"MP_HOST_ENDED_GAME" );
+}
+
+setupcallbacks()
+{
+    level.autoassign = ::menuautoassign;
+    level.spectator = ::menuspectator;
+    level.class = ::menuclass;
+    level.teammenu = ::menuteam;
+}
+
+hideloadoutaftertime( delay )
+{
+    self endon( "disconnect" );
+    self endon( "perks_hidden" );
+    wait( delay );
+    self thread hideallperks( 0.4 );
+    self notify( "perks_hidden" );
+}
+
+hideloadoutondeath()
+{
+    self endon( "disconnect" );
+    self endon( "perks_hidden" );
+
+    self waittill( "death" );
+
+    self hideallperks();
+    self notify( "perks_hidden" );
+}
+
+hideloadoutonkill()
+{
+    self endon( "disconnect" );
+    self endon( "death" );
+    self endon( "perks_hidden" );
+
+    self waittill( "killed_player" );
+
+    self hideallperks();
+    self notify( "perks_hidden" );
+}
+
+freegameplayhudelems()
+{
+    if ( isdefined( self.perkicon ) )
+    {
+        for ( numspecialties = 0; numspecialties < level.maxspecialties; numspecialties++ )
+        {
+            if ( isdefined( self.perkicon[numspecialties] ) )
+            {
+                self.perkicon[numspecialties] destroyelem();
+                self.perkname[numspecialties] destroyelem();
+            }
+        }
+    }
+
+    if ( isdefined( self.perkhudelem ) )
+        self.perkhudelem destroyelem();
+
+    if ( isdefined( self.killstreakicon ) )
+    {
+        if ( isdefined( self.killstreakicon[0] ) )
+            self.killstreakicon[0] destroyelem();
+
+        if ( isdefined( self.killstreakicon[1] ) )
+            self.killstreakicon[1] destroyelem();
+
+        if ( isdefined( self.killstreakicon[2] ) )
+            self.killstreakicon[2] destroyelem();
+
+        if ( isdefined( self.killstreakicon[3] ) )
+            self.killstreakicon[3] destroyelem();
+
+        if ( isdefined( self.killstreakicon[4] ) )
+            self.killstreakicon[4] destroyelem();
+    }
+
+    self notify( "perks_hidden" );
+
+    if ( isdefined( self.lowermessage ) )
+        self.lowermessage destroyelem();
+
+    if ( isdefined( self.lowertimer ) )
+        self.lowertimer destroyelem();
+
+    if ( isdefined( self.proxbar ) )
+        self.proxbar destroyelem();
+
+    if ( isdefined( self.proxbartext ) )
+        self.proxbartext destroyelem();
+
+    if ( isdefined( self.carryicon ) )
+        self.carryicon destroyelem();
+}
+
+teamplayercountsequal( playercounts )
+{
+    count = undefined;
+
+    foreach ( team in level.teams )
+    {
+        if ( !isdefined( count ) )
+        {
+            count = playercounts[team];
+            continue;
+        }
+
+        if ( count != playercounts[team] )
+            return false;
+    }
+
+    return true;
+}
+
+teamwithlowestplayercount( playercounts, ignore_team )
+{
+    count = 9999;
+    lowest_team = undefined;
+
+    foreach ( team in level.teams )
+    {
+        if ( count > playercounts[team] )
+        {
+            count = playercounts[team];
+            lowest_team = team;
+        }
+    }
+
+    return lowest_team;
+}
+
+menuautoassign( comingfrommenu )
+{
+    teamkeys = getarraykeys( level.teams );
+    assignment = teamkeys[randomint( teamkeys.size )];
+    self closemenus();
+
+    if ( isdefined( level.forceallallies ) && level.forceallallies )
+        assignment = "allies";
+    else if ( level.teambased )
+    {
+        if ( getdvarint( "party_autoteams" ) == 1 )
+        {
+            if ( level.allow_teamchange == "1" && ( self.hasspawned || comingfrommenu ) )
+                assignment = "";
+            else
+            {
+                team = getassignedteam( self );
+
+                switch ( team )
+                {
+                    case 1:
+                        assignment = teamkeys[1];
+                        break;
+                    case 2:
+                        assignment = teamkeys[0];
+                        break;
+                    case 3:
+                        assignment = teamkeys[2];
+                        break;
+                    case 4:
+                        if ( !isdefined( level.forceautoassign ) || !level.forceautoassign )
+                        {
+                            self setclientscriptmainmenu( game["menu_class"] );
+                            return;
+                        }
+                    default:
+                        assignment = "";
+
+                        if ( isdefined( level.teams[team] ) )
+                            assignment = team;
+                        else if ( team == "spectator" && !level.forceautoassign )
+                        {
+                            self setclientscriptmainmenu( game["menu_class"] );
+                            return;
+                        }
+                }
+            }
+        }
+
+        if ( assignment == "" || getdvarint( "party_autoteams" ) == 0 )
+        {
+            if ( sessionmodeiszombiesgame() )
+                assignment = "allies";
+        }
+
+        if ( assignment == self.pers["team"] && ( self.sessionstate == "playing" || self.sessionstate == "dead" ) )
+        {
+            self beginclasschoice();
+            return;
+        }
+    }
+    else if ( getdvarint( "party_autoteams" ) == 1 )
+    {
+        if ( level.allow_teamchange != "1" || !self.hasspawned && !comingfrommenu )
+        {
+            team = getassignedteam( self );
+
+            if ( isdefined( level.teams[team] ) )
+                assignment = team;
+            else if ( team == "spectator" && !level.forceautoassign )
+            {
+                self setclientscriptmainmenu( game["menu_class"] );
+                return;
+            }
+        }
+    }
+
+    if ( assignment != self.pers["team"] && ( self.sessionstate == "playing" || self.sessionstate == "dead" ) )
+    {
+        self.switching_teams = 1;
+        self.joining_team = assignment;
+        self.leaving_team = self.pers["team"];
+        self suicide();
+    }
+
+    self.pers["team"] = assignment;
+    self.team = assignment;
+    self.pers["class"] = undefined;
+    self.class = undefined;
+    self.pers["weapon"] = undefined;
+    self.pers["savedmodel"] = undefined;
+    self updateobjectivetext();
+
+    if ( level.teambased )
+        self.sessionteam = assignment;
+    else
+    {
+        self.sessionteam = "none";
+        self.ffateam = assignment;
+    }
+
+    if ( !isalive( self ) )
+        self.statusicon = "hud_status_dead";
+
+    self notify( "joined_team" );
+    level notify( "joined_team" );
+    self notify( "end_respawn" );
+    self beginclasschoice();
+    self setclientscriptmainmenu( game["menu_class"] );
+}
+
+teamscoresequal()
+{
+    score = undefined;
+
+    foreach ( team in level.teams )
+    {
+        if ( !isdefined( score ) )
+        {
+            score = getteamscore( team );
+            continue;
+        }
+
+        if ( score != getteamscore( team ) )
+            return false;
+    }
+
+    return true;
+}
+
+teamwithlowestscore()
+{
+    score = 99999999;
+    lowest_team = undefined;
+
+    foreach ( team in level.teams )
+    {
+        if ( score > getteamscore( team ) )
+            lowest_team = team;
+    }
+
+    return lowest_team;
+}
+
+pickteamfromscores( teams )
+{
+    assignment = "allies";
+
+    if ( teamscoresequal() )
+        assignment = teams[randomint( teams.size )];
+    else
+        assignment = teamwithlowestscore();
+
+    return assignment;
+}
+
+getsplitscreenteam()
+{
+    for ( index = 0; index < level.players.size; index++ )
+    {
+        if ( !isdefined( level.players[index] ) )
+            continue;
+
+        if ( level.players[index] == self )
+            continue;
+
+        if ( !self isplayeronsamemachine( level.players[index] ) )
+            continue;
+
+        team = level.players[index].sessionteam;
+
+        if ( team != "spectator" )
+            return team;
+    }
+
+    return "";
+}
+
+updateobjectivetext()
+{
+    if ( sessionmodeiszombiesgame() || self.pers["team"] == "spectator" )
+    {
+        self setclientcgobjectivetext( "" );
+        return;
+    }
+
+    if ( level.scorelimit > 0 )
+        self setclientcgobjectivetext( getobjectivescoretext( self.pers["team"] ) );
+    else
+        self setclientcgobjectivetext( getobjectivetext( self.pers["team"] ) );
+}
+
+closemenus()
+{
+    self closemenu();
+    self closeingamemenu();
+}
+
+beginclasschoice( forcenewchoice )
+{
+    assert( isdefined( level.teams[self.pers["team"]] ) );
+    team = self.pers["team"];
+
+    if ( level.disablecac == 1 )
+    {
+        self.pers["class"] = level.defaultclass;
+        self.class = level.defaultclass;
+
+        if ( self.sessionstate != "playing" && game["state"] == "playing" )
+            self thread [[ level.spawnclient ]]();
+
+        level thread maps\mp\gametypes_zm\_globallogic::updateteamstatus();
+        self thread maps\mp\gametypes_zm\_spectating::setspectatepermissionsformachine();
+        return;
+    }
+
+    if ( level.wagermatch )
+        self openmenu( game["menu_changeclass_wager"] );
+    else if ( getdvarint( "barebones_class_mode" ) )
+        self openmenu( game["menu_changeclass_barebones"] );
+    else
+        self openmenu( game["menu_changeclass_" + team] );
+}
+
+showmainmenuforteam()
+{
+    assert( isdefined( level.teams[self.pers["team"]] ) );
+    team = self.pers["team"];
+
+    if ( level.wagermatch )
+        self openmenu( game["menu_changeclass_wager"] );
+    else
+        self openmenu( game["menu_changeclass_" + team] );
+}
+
+menuteam( team )
+{
+    self closemenus();
+
+    if ( !level.console && level.allow_teamchange == "0" && ( isdefined( self.hasdonecombat ) && self.hasdonecombat ) )
+        return;
+
+    if ( self.pers["team"] != team )
+    {
+        if ( level.ingraceperiod && ( !isdefined( self.hasdonecombat ) || !self.hasdonecombat ) )
+            self.hasspawned = 0;
+
+        if ( self.sessionstate == "playing" )
+        {
+            self.switching_teams = 1;
+            self.joining_team = team;
+            self.leaving_team = self.pers["team"];
+            self suicide();
+        }
+
+        self.pers["team"] = team;
+        self.team = team;
+        self.pers["class"] = undefined;
+        self.class = undefined;
+        self.pers["weapon"] = undefined;
+        self.pers["savedmodel"] = undefined;
+        self updateobjectivetext();
+
+        if ( level.teambased )
+            self.sessionteam = team;
+        else
+        {
+            self.sessionteam = "none";
+            self.ffateam = team;
+        }
+
+        self setclientscriptmainmenu( game["menu_class"] );
+        self notify( "joined_team" );
+        level notify( "joined_team" );
+        self notify( "end_respawn" );
+    }
+
+    self beginclasschoice();
+}
+
+menuspectator()
+{
+    self closemenus();
+
+    if ( self.pers["team"] != "spectator" )
+    {
+        if ( isalive( self ) )
+        {
+            self.switching_teams = 1;
+            self.joining_team = "spectator";
+            self.leaving_team = self.pers["team"];
+            self suicide();
+        }
+
+        self.pers["team"] = "spectator";
+        self.team = "spectator";
+        self.pers["class"] = undefined;
+        self.class = undefined;
+        self.pers["weapon"] = undefined;
+        self.pers["savedmodel"] = undefined;
+        self updateobjectivetext();
+        self.sessionteam = "spectator";
+
+        if ( !level.teambased )
+            self.ffateam = "spectator";
+
+        [[ level.spawnspectator ]]();
+        self thread maps\mp\gametypes_zm\_globallogic_player::spectate_player_watcher();
+        self setclientscriptmainmenu( game["menu_class"] );
+        self notify( "joined_spectators" );
+    }
+}
+
+menuclass( response )
+{
+    self closemenus();
+}
+
+removespawnmessageshortly( delay )
+{
+    self endon( "disconnect" );
+    waittillframeend;
+    self endon( "end_respawn" );
+    wait( delay );
+    self clearlowermessage( 2.0 );
+}

ZM/Core/maps/mp/gametypes_zm/_globallogic_utils.gsc

@@ -0,0 +1,425 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include maps\mp\gametypes_zm\_hud_message;
+#include maps\mp\gametypes_zm\_hostmigration;
+#include maps\mp\gametypes_zm\_globallogic_score;
+
+waittillslowprocessallowed()
+{
+    while ( level.lastslowprocessframe == gettime() )
+        wait 0.05;
+
+    level.lastslowprocessframe = gettime();
+}
+
+testmenu()
+{
+    self endon( "death" );
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        wait 10.0;
+        notifydata = spawnstruct();
+        notifydata.titletext = &"MP_CHALLENGE_COMPLETED";
+        notifydata.notifytext = "wheee";
+        notifydata.sound = "mp_challenge_complete";
+        self thread maps\mp\gametypes_zm\_hud_message::notifymessage( notifydata );
+    }
+}
+
+testshock()
+{
+    self endon( "death" );
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        wait 3.0;
+        numshots = randomint( 6 );
+
+        for ( i = 0; i < numshots; i++ )
+        {
+            iprintlnbold( numshots );
+            self shellshock( "frag_grenade_mp", 0.2 );
+            wait 0.1;
+        }
+    }
+}
+
+testhps()
+{
+    self endon( "death" );
+    self endon( "disconnect" );
+    hps = [];
+    hps[hps.size] = "radar_mp";
+    hps[hps.size] = "artillery_mp";
+    hps[hps.size] = "dogs_mp";
+
+    for (;;)
+    {
+        hp = "radar_mp";
+        wait 20.0;
+    }
+}
+
+timeuntilroundend()
+{
+    if ( level.gameended )
+    {
+        timepassed = ( gettime() - level.gameendtime ) / 1000;
+        timeremaining = level.postroundtime - timepassed;
+
+        if ( timeremaining < 0 )
+            return 0;
+
+        return timeremaining;
+    }
+
+    if ( level.inovertime )
+        return undefined;
+
+    if ( level.timelimit <= 0 )
+        return undefined;
+
+    if ( !isdefined( level.starttime ) )
+        return undefined;
+
+    timepassed = ( gettimepassed() - level.starttime ) / 1000;
+    timeremaining = level.timelimit * 60 - timepassed;
+    return timeremaining + level.postroundtime;
+}
+
+gettimeremaining()
+{
+    return level.timelimit * 60 * 1000 - gettimepassed();
+}
+
+registerpostroundevent( eventfunc )
+{
+    if ( !isdefined( level.postroundevents ) )
+        level.postroundevents = [];
+
+    level.postroundevents[level.postroundevents.size] = eventfunc;
+}
+
+executepostroundevents()
+{
+    if ( !isdefined( level.postroundevents ) )
+        return;
+
+    for ( i = 0; i < level.postroundevents.size; i++ )
+        [[ level.postroundevents[i] ]]();
+}
+
+getvalueinrange( value, minvalue, maxvalue )
+{
+    if ( value > maxvalue )
+        return maxvalue;
+    else if ( value < minvalue )
+        return minvalue;
+    else
+        return value;
+}
+
+assertproperplacement()
+{
+/#
+    numplayers = level.placement["all"].size;
+
+    for ( i = 0; i < numplayers - 1; i++ )
+    {
+        if ( isdefined( level.placement["all"][i] ) && isdefined( level.placement["all"][i + 1] ) )
+        {
+            if ( level.placement["all"][i].score < level.placement["all"][i + 1].score )
+            {
+                println( "^1Placement array:" );
+
+                for ( i = 0; i < numplayers; i++ )
+                {
+                    player = level.placement["all"][i];
+                    println( "^1" + i + ". " + player.name + ": " + player.score );
+                }
+/#
+                assertmsg( "Placement array was not properly sorted" );
+#/
+                break;
+            }
+        }
+    }
+#/
+}
+
+isvalidclass( class )
+{
+    if ( level.oldschool || sessionmodeiszombiesgame() )
+    {
+        assert( !isdefined( class ) );
+        return 1;
+    }
+
+    return isdefined( class ) && class != "";
+}
+
+playtickingsound( gametype_tick_sound )
+{
+    self endon( "death" );
+    self endon( "stop_ticking" );
+    level endon( "game_ended" );
+    time = level.bombtimer;
+
+    while ( true )
+    {
+        self playsound( gametype_tick_sound );
+
+        if ( time > 10 )
+        {
+            time -= 1;
+            wait 1;
+        }
+        else if ( time > 4 )
+        {
+            time -= 0.5;
+            wait 0.5;
+        }
+        else if ( time > 1 )
+        {
+            time -= 0.4;
+            wait 0.4;
+        }
+        else
+        {
+            time -= 0.3;
+            wait 0.3;
+        }
+
+        maps\mp\gametypes_zm\_hostmigration::waittillhostmigrationdone();
+    }
+}
+
+stoptickingsound()
+{
+    self notify( "stop_ticking" );
+}
+
+gametimer()
+{
+    level endon( "game_ended" );
+
+    level waittill( "prematch_over" );
+
+    level.starttime = gettime();
+    level.discardtime = 0;
+
+    if ( isdefined( game["roundMillisecondsAlreadyPassed"] ) )
+    {
+        level.starttime -= game["roundMillisecondsAlreadyPassed"];
+        game["roundMillisecondsAlreadyPassed"] = undefined;
+    }
+
+    prevtime = gettime();
+
+    while ( game["state"] == "playing" )
+    {
+        if ( !level.timerstopped )
+            game["timepassed"] += gettime() - prevtime;
+
+        prevtime = gettime();
+        wait 1.0;
+    }
+}
+
+gettimepassed()
+{
+    if ( !isdefined( level.starttime ) )
+        return 0;
+
+    if ( level.timerstopped )
+        return level.timerpausetime - level.starttime - level.discardtime;
+    else
+        return gettime() - level.starttime - level.discardtime;
+}
+
+pausetimer()
+{
+    if ( level.timerstopped )
+        return;
+
+    level.timerstopped = 1;
+    level.timerpausetime = gettime();
+}
+
+resumetimer()
+{
+    if ( !level.timerstopped )
+        return;
+
+    level.timerstopped = 0;
+    level.discardtime += gettime() - level.timerpausetime;
+}
+
+getscoreremaining( team )
+{
+    assert( isplayer( self ) || isdefined( team ) );
+    scorelimit = level.scorelimit;
+
+    if ( isplayer( self ) )
+        return scorelimit - maps\mp\gametypes_zm\_globallogic_score::_getplayerscore( self );
+    else
+        return scorelimit - getteamscore( team );
+}
+
+getscoreperminute( team )
+{
+    assert( isplayer( self ) || isdefined( team ) );
+    scorelimit = level.scorelimit;
+    timelimit = level.timelimit;
+    minutespassed = gettimepassed() / 60000 + 0.0001;
+
+    if ( isplayer( self ) )
+        return maps\mp\gametypes_zm\_globallogic_score::_getplayerscore( self ) / minutespassed;
+    else
+        return getteamscore( team ) / minutespassed;
+}
+
+getestimatedtimeuntilscorelimit( team )
+{
+    assert( isplayer( self ) || isdefined( team ) );
+    scoreperminute = self getscoreperminute( team );
+    scoreremaining = self getscoreremaining( team );
+
+    if ( !scoreperminute )
+        return 999999;
+
+    return scoreremaining / scoreperminute;
+}
+
+rumbler()
+{
+    self endon( "disconnect" );
+
+    while ( true )
+    {
+        wait 0.1;
+        self playrumbleonentity( "damage_heavy" );
+    }
+}
+
+waitfortimeornotify( time, notifyname )
+{
+    self endon( notifyname );
+    wait( time );
+}
+
+waitfortimeornotifynoartillery( time, notifyname )
+{
+    self endon( notifyname );
+    wait( time );
+
+    while ( isdefined( level.artilleryinprogress ) )
+    {
+        assert( level.artilleryinprogress );
+        wait 0.25;
+    }
+}
+
+isheadshot( sweapon, shitloc, smeansofdeath, einflictor )
+{
+    if ( shitloc != "head" && shitloc != "helmet" )
+        return false;
+
+    switch ( smeansofdeath )
+    {
+        case "MOD_MELEE":
+        case "MOD_BAYONET":
+            return false;
+        case "MOD_IMPACT":
+            if ( sweapon != "knife_ballistic_mp" )
+                return false;
+    }
+
+    return true;
+}
+
+gethitlocheight( shitloc )
+{
+    switch ( shitloc )
+    {
+        case "neck":
+        case "helmet":
+        case "head":
+            return 60;
+        case "torso_upper":
+        case "right_hand":
+        case "right_arm_upper":
+        case "right_arm_lower":
+        case "left_hand":
+        case "left_arm_upper":
+        case "left_arm_lower":
+        case "gun":
+            return 48;
+        case "torso_lower":
+            return 40;
+        case "right_leg_upper":
+        case "left_leg_upper":
+            return 32;
+        case "right_leg_lower":
+        case "left_leg_lower":
+            return 10;
+        case "right_foot":
+        case "left_foot":
+            return 5;
+    }
+
+    return 48;
+}
+
+debugline( start, end )
+{
+/#
+    for ( i = 0; i < 50; i++ )
+    {
+        line( start, end );
+        wait 0.05;
+    }
+#/
+}
+
+isexcluded( entity, entitylist )
+{
+    for ( index = 0; index < entitylist.size; index++ )
+    {
+        if ( entity == entitylist[index] )
+            return true;
+    }
+
+    return false;
+}
+
+waitfortimeornotifies( desireddelay )
+{
+    startedwaiting = gettime();
+    waitedtime = ( gettime() - startedwaiting ) / 1000;
+
+    if ( waitedtime < desireddelay )
+    {
+        wait( desireddelay - waitedtime );
+        return desireddelay;
+    }
+    else
+        return waitedtime;
+}
+
+logteamwinstring( wintype, winner )
+{
+    log_string = wintype;
+
+    if ( isdefined( winner ) )
+        log_string = log_string + ", win: " + winner;
+
+    foreach ( team in level.teams )
+        log_string = log_string + ", " + team + ": " + game["teamScores"][team];
+
+    logstring( log_string );
+}

ZM/Core/maps/mp/gametypes_zm/_globallogic_vehicle.gsc

@@ -0,0 +1,381 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include maps\mp\gametypes_zm\_weapons;
+#include maps\mp\gametypes_zm\_globallogic_player;
+#include maps\mp\gametypes_zm\_damagefeedback;
+
+callback_vehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname )
+{
+    self.idflags = idflags;
+    self.idflagstime = gettime();
+
+    if ( game["state"] == "postgame" )
+        return;
+
+    if ( isdefined( eattacker ) && isplayer( eattacker ) && isdefined( eattacker.candocombat ) && !eattacker.candocombat )
+        return;
+
+    if ( !isdefined( vdir ) )
+        idflags |= level.idflags_no_knockback;
+
+    friendly = 0;
+
+    if ( isdefined( self.maxhealth ) && self.health == self.maxhealth || !isdefined( self.attackers ) )
+    {
+        self.attackers = [];
+        self.attackerdata = [];
+        self.attackerdamage = [];
+    }
+
+    if ( sweapon == "none" && isdefined( einflictor ) )
+    {
+        if ( isdefined( einflictor.targetname ) && einflictor.targetname == "explodable_barrel" )
+            sweapon = "explodable_barrel_mp";
+        else if ( isdefined( einflictor.destructible_type ) && issubstr( einflictor.destructible_type, "vehicle_" ) )
+            sweapon = "destructible_car_mp";
+    }
+
+    if ( !( idflags & level.idflags_no_protection ) )
+    {
+        if ( self isvehicleimmunetodamage( idflags, smeansofdeath, sweapon ) )
+            return;
+
+        if ( smeansofdeath == "MOD_PISTOL_BULLET" || smeansofdeath == "MOD_RIFLE_BULLET" )
+        {
+
+        }
+        else if ( smeansofdeath == "MOD_PROJECTILE" || smeansofdeath == "MOD_GRENADE" )
+        {
+            idamage *= getvehicleprojectilescalar( sweapon );
+            idamage = int( idamage );
+
+            if ( idamage == 0 )
+                return;
+        }
+        else if ( smeansofdeath == "MOD_GRENADE_SPLASH" )
+        {
+            idamage *= getvehicleunderneathsplashscalar( sweapon );
+            idamage = int( idamage );
+
+            if ( idamage == 0 )
+                return;
+        }
+
+        idamage *= level.vehicledamagescalar;
+        idamage = int( idamage );
+
+        if ( isplayer( eattacker ) )
+            eattacker.pers["participation"]++;
+
+        prevhealthratio = self.health / self.maxhealth;
+
+        if ( isdefined( self.owner ) && isplayer( self.owner ) )
+            team = self.owner.pers["team"];
+
+        if ( level.teambased && isplayer( eattacker ) && team == eattacker.pers["team"] )
+        {
+            if ( level.friendlyfire == 0 )
+            {
+                if ( !allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon ) )
+                    return;
+
+                if ( idamage < 1 )
+                    idamage = 1;
+
+                self.lastdamagewasfromenemy = 0;
+                self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 1 );
+            }
+            else if ( level.friendlyfire == 1 )
+            {
+                if ( idamage < 1 )
+                    idamage = 1;
+
+                self.lastdamagewasfromenemy = 0;
+                self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 0 );
+            }
+            else if ( level.friendlyfire == 2 )
+            {
+                if ( !allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon ) )
+                    return;
+
+                if ( idamage < 1 )
+                    idamage = 1;
+
+                self.lastdamagewasfromenemy = 0;
+                self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 1 );
+            }
+            else if ( level.friendlyfire == 3 )
+            {
+                idamage = int( idamage * 0.5 );
+
+                if ( idamage < 1 )
+                    idamage = 1;
+
+                self.lastdamagewasfromenemy = 0;
+                self finishvehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, damagefromunderneath, modelindex, partname, 0 );
+            }
+
+            friendly = 1;
+        }
+        else
+        {
+            if ( !level.teambased && isdefined( self.targetname ) && self.targetname == "rcbomb" )
+            {
+
+            }
+            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_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 );
+
+            self.lastdamagewasfromenemy = isdefined( eattacker ) && !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 ( idamage > 0 )
+                    eattacker thread maps\mp\gametypes_zm\_damagefeedback::updatedamagefeedback( smeansofdeath, einflictor );
+            }
+        }
+    }
+/#
+    if ( getdvarint( "g_debugDamage" ) )
+        println( "actor:" + self getentitynumber() + " health:" + self.health + " attacker:" + eattacker.clientid + " inflictor is player:" + isplayer( einflictor ) + " damage:" + idamage + " hitLoc:" + shitloc );
+#/
+    if ( 1 )
+    {
+        lpselfnum = self getentitynumber();
+        lpselfteam = "";
+        lpattackerteam = "";
+
+        if ( isplayer( eattacker ) )
+        {
+            lpattacknum = eattacker getentitynumber();
+            lpattackguid = eattacker getguid();
+            lpattackname = eattacker.name;
+            lpattackerteam = eattacker.pers["team"];
+        }
+        else
+        {
+            lpattacknum = -1;
+            lpattackguid = "";
+            lpattackname = "";
+            lpattackerteam = "world";
+        }
+
+        logprint( "VD;" + lpselfnum + ";" + lpselfteam + ";" + lpattackguid + ";" + lpattacknum + ";" + lpattackerteam + ";" + lpattackname + ";" + sweapon + ";" + idamage + ";" + smeansofdeath + ";" + shitloc + "\\n" );
+    }
+}
+
+callback_vehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime )
+{
+    idamage = 0;
+    finnerdamage = 0;
+    fouterdamage = 0;
+    self.idflags = idflags;
+    self.idflagstime = gettime();
+
+    if ( game["state"] == "postgame" )
+        return;
+
+    if ( isdefined( eattacker ) && isplayer( eattacker ) && isdefined( eattacker.candocombat ) && !eattacker.candocombat )
+        return;
+
+    friendly = 0;
+
+    if ( !( idflags & level.idflags_no_protection ) )
+    {
+        if ( self isvehicleimmunetodamage( idflags, smeansofdeath, sweapon ) )
+            return;
+
+        if ( smeansofdeath == "MOD_PROJECTILE_SPLASH" || smeansofdeath == "MOD_GRENADE_SPLASH" || smeansofdeath == "MOD_EXPLOSIVE" )
+        {
+            scalar = getvehicleprojectilesplashscalar( sweapon );
+            idamage = int( idamage * scalar );
+            finnerdamage *= scalar;
+            fouterdamage *= scalar;
+
+            if ( finnerdamage == 0 )
+                return;
+
+            if ( idamage < 1 )
+                idamage = 1;
+        }
+
+        occupant_team = undefined;
+
+        if ( level.teambased && isplayer( eattacker ) && occupant_team == eattacker.pers["team"] )
+        {
+            if ( level.friendlyfire == 0 )
+            {
+                if ( !allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon ) )
+                    return;
+
+                if ( idamage < 1 )
+                    idamage = 1;
+
+                self.lastdamagewasfromenemy = 0;
+                self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
+            }
+            else if ( level.friendlyfire == 1 )
+            {
+                if ( idamage < 1 )
+                    idamage = 1;
+
+                self.lastdamagewasfromenemy = 0;
+                self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
+            }
+            else if ( level.friendlyfire == 2 )
+            {
+                if ( !allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon ) )
+                    return;
+
+                if ( idamage < 1 )
+                    idamage = 1;
+
+                self.lastdamagewasfromenemy = 0;
+                self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
+            }
+            else if ( level.friendlyfire == 3 )
+            {
+                idamage = int( idamage * 0.5 );
+
+                if ( idamage < 1 )
+                    idamage = 1;
+
+                self.lastdamagewasfromenemy = 0;
+                self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
+            }
+
+            friendly = 1;
+        }
+        else
+        {
+            if ( idamage < 1 )
+                idamage = 1;
+
+            self finishvehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, psoffsettime );
+        }
+    }
+}
+
+vehiclecrush()
+{
+    self endon( "disconnect" );
+
+    if ( isdefined( level._effect ) && isdefined( level._effect["tanksquish"] ) )
+        playfx( level._effect["tanksquish"], self.origin + vectorscale( ( 0, 0, 1 ), 30.0 ) );
+
+    self playsound( "chr_crunch" );
+}
+
+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" )
+        scale = 10.0;
+    else if ( sweapon == "remote_mortar_missile_mp" )
+        scale = 10.0;
+    else if ( sweapon == "smaw_mp" )
+        scale = 0.2;
+    else if ( sweapon == "fhj18_mp" )
+        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;
+
+    return scale;
+}
+
+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" )
+        scale = 10.0;
+    else if ( sweapon == "remote_mortar_missile_mp" )
+        scale = 4.0;
+    else if ( sweapon == "chopper_minigun_mp" )
+        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;
+
+    return scale;
+}
+
+getvehicleunderneathsplashscalar( sweapon )
+{
+    if ( sweapon == "satchel_charge_mp" )
+    {
+        scale = 10.0;
+        scale *= 3.0;
+    }
+    else
+        scale = 1.0;
+
+    return scale;
+}
+
+getvehiclebulletdamage( sweapon )
+{
+    if ( issubstr( sweapon, "ptrs41_" ) )
+        idamage = 25;
+    else if ( issubstr( sweapon, "gunner" ) )
+        idamage = 5;
+    else if ( issubstr( sweapon, "mg42_bipod" ) || issubstr( sweapon, "30cal_bipod" ) )
+        idamage = 5;
+    else
+        idamage = 1;
+
+    return idamage;
+}
+
+allowfriendlyfiredamage( einflictor, eattacker, smeansofdeath, sweapon )
+{
+    if ( isdefined( self.allowfriendlyfiredamageoverride ) )
+        return [[ self.allowfriendlyfiredamageoverride ]]( einflictor, eattacker, smeansofdeath, sweapon );
+
+    vehicle = eattacker getvehicleoccupied();
+    return 0;
+}

ZM/Core/maps/mp/gametypes_zm/_gv_actions.gsc

@@ -0,0 +1,873 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include common_scripts\utility;
+#include maps\mp\gametypes_zm\_globallogic;
+#include maps\mp\gametypes_zm\_globallogic_score;
+#include maps\mp\gametypes_zm\_hud_util;
+#include maps\mp\gametypes_zm\_globallogic_ui;
+
+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 true;
+
+    if ( param2 == "top3" && param1 == "first" )
+        return true;
+
+    return false;
+}
+
+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_RIFLE_BULLET":
+        case "MOD_PISTOL_BULLET":
+            return "bullet";
+        case "MOD_MELEE":
+        case "MOD_BAYONET":
+            return "knife";
+        case "MOD_HEAD_SHOT":
+            return "headshot";
+        case "MOD_PROJECTILE_SPLASH":
+        case "MOD_PROJECTILE":
+        case "MOD_GRENADE_SPLASH":
+        case "MOD_GRENADE":
+        case "MOD_EXPLOSIVE":
+            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;
+
+    for ( place = 0; place < level.placement["all"].size; place++ )
+    {
+        if ( level.placement["all"][place] == player )
+            break;
+    }
+
+    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;
+
+    for ( j = 0; j < rule.target["Assisters"].size; j++ )
+    {
+        player = rule.target["Assisters"][j];
+
+        if ( !isdefined( player ) )
+            continue;
+
+        if ( player == attacker )
+            continue;
+
+        assisters[assisters.size] = player;
+    }
+
+    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;
+
+    for ( i = 0; i < rule.conditionals.size; i++ )
+    {
+        conditionalresult = evaluategametypeeventruleconditional( rule, rule.conditionals[i] );
+
+        switch ( rule.conditionaleval )
+        {
+            case "AND":
+                combinedresult = combinedresult && conditionalresult;
+                break;
+            case "OR":
+                combinedresult = combinedresult || conditionalresult;
+                break;
+        }
+
+        if ( rule.conditionaleval == "AND" && !combinedresult )
+            break;
+
+        if ( rule.conditionaleval == "OR" && combinedresult )
+            break;
+    }
+
+    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 = [];
+
+    for ( i = 0; i < players.size; i++ )
+    {
+        player = players[i];
+
+        if ( player.pers["team"] == team )
+            playersonteam[playersonteam.size] = player;
+    }
+
+    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 )
+{
+    return isdefined( rule.params ) && isarray( rule.params ) && rule.params.size > 0;
+}
+
+sortplayersbylivesdescending( players )
+{
+    if ( !isdefined( players ) )
+        return undefined;
+
+    swapped = 1;
+
+    for ( n = players.size; swapped; n-- )
+    {
+        swapped = 0;
+
+        for ( i = 0; i < n - 1; i++ )
+        {
+            if ( players[i].pers["lives"] < players[i + 1].pers["lives"] )
+            {
+                temp = players[i];
+                players[i] = players[i + 1];
+                players[i + 1] = temp;
+                swapped = 1;
+            }
+        }
+    }
+
+    return players;
+}
+
+giveammo( players, amount )
+{
+    for ( i = 0; i < players.size; i++ )
+    {
+        wait 0.5;
+        player = players[i];
+        currentweapon = player getcurrentweapon();
+        clipammo = player getweaponammoclip( currentweapon );
+        player setweaponammoclip( currentweapon, clipammo + amount );
+    }
+}
+
+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 );
+
+    for ( targetindex = 0; targetindex < targets.size; targetindex++ )
+    {
+        targets[targetindex].pers["hasRadar"] = 1;
+        targets[targetindex].hasspyplane = 1;
+    }
+}
+
+givescore( players, amount )
+{
+    for ( i = 0; i < players.size; i++ )
+    {
+        player = players[i];
+        score = maps\mp\gametypes_zm\_globallogic_score::_getplayerscore( player );
+        maps\mp\gametypes_zm\_globallogic_score::_setplayerscore( player, score + amount );
+    }
+}
+
+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 );
+
+    for ( targetindex = 0; targetindex < targets.size; targetindex++ )
+    {
+        target = targets[targetindex];
+        displaytextonhudelem( target, target.customgametypeheader, rule.params[0], rule.params[1], "gv_header", rule.params[2] );
+    }
+}
+
+dosetsubheader( rule )
+{
+    if ( !doesrulehavevalidparam( rule ) )
+        return;
+
+    targets = gettargetsforgametypeeventrule( rule );
+
+    for ( targetindex = 0; targetindex < targets.size; targetindex++ )
+    {
+        target = targets[targetindex];
+        displaytextonhudelem( target, target.customgametypesubheader, rule.params[0], rule.params[1], "gv_subheader", rule.params[2] );
+    }
+}
+
+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 );
+
+    for ( targetindex = 0; targetindex < targets.size; targetindex++ )
+        thread announcemessage( targets[targetindex], rule.params[0], 2.0 );
+}
+
+announcemessage( target, messagetext, time )
+{
+    target endon( "disconnect" );
+    clientannouncement( target, messagetext, int( time * 1000 ) );
+
+    if ( time == 0 )
+        time = getdvarfloat( _hash_E8C4FC20 );
+
+    target.doingnotify = 1;
+    wait( time );
+    target.doingnotify = 0;
+}
+
+givehealth( players, amount )
+{
+    for ( i = 0; i < players.size; i++ )
+    {
+        player = players[i];
+        player.health += amount;
+    }
+}
+
+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 );
+
+    for ( targetindex = 0; targetindex < targets.size; targetindex++ )
+    {
+        player = targets[targetindex];
+        player.regenrate = rule.params[0];
+    }
+}
+
+dochangeclass( rule )
+{
+    if ( !doesrulehavevalidparam( rule ) )
+        return;
+}
+
+dochangeteam( rule )
+{
+    if ( !doesrulehavevalidparam( rule ) )
+        return;
+
+    team = rule.params[0];
+    teamkeys = getarraykeys( level.teams );
+    targets = gettargetsforgametypeeventrule( rule );
+
+    for ( targetindex = 0; targetindex < targets.size; targetindex++ )
+    {
+        target = targets[targetindex];
+
+        if ( target.pers["team"] == team )
+            continue;
+
+        if ( team == "toggle" )
+        {
+            team = teamkeys[randomint( teamkeys.size )];
+
+            for ( teamindex = 0; teamindex < teamkeys.size; teamindex++ )
+            {
+                if ( target.pers["team"] == teamkeys[teamindex] )
+                {
+                    team = teamkeys[( teamindex + 1 ) % teamkeys.size];
+                    break;
+                }
+            }
+        }
+
+        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" );
+    }
+}
+
+displayperk( player, imagename )
+{
+    index = 0;
+
+    if ( isdefined( player.perkicon ) )
+    {
+        index = -1;
+
+        for ( i = 0; i < player.perkicon.size; i++ )
+        {
+            if ( player.perkicon[i].alpha == 0 )
+            {
+                index = i;
+                break;
+            }
+        }
+
+        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.0 );
+    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];
+
+    for ( i = 0; i < players.size; i++ )
+    {
+        player = players[i];
+
+        for ( perkindex = 0; perkindex < perks.size - 1; perkindex++ )
+        {
+            perk = perks[perkindex];
+
+            if ( player hasperk( perk ) )
+                hasperkalready = 1;
+
+            if ( shouldset )
+            {
+                player setperk( perk );
+                continue;
+            }
+
+            player unsetperk( perk );
+        }
+
+        if ( shouldset && !hasperkalready && getdvarint( "scr_showperksonspawn" ) == 1 )
+            displayperk( player, imagename );
+    }
+}
+
+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 )
+{
+    for ( i = 0; i < players.size; i++ )
+    {
+        player = players[i];
+        player.pers["lives"] += amount;
+
+        if ( player.pers["lives"] < 0 )
+            player.pers["lives"] = 0;
+    }
+}
+
+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 )
+{
+    for ( i = 0; i < players.size; i++ )
+        player = players[i];
+}
+
+dogiveinvuln( rule )
+{
+    giveorremoveinvuln( gettargetsforgametypeeventrule( rule ), 1 );
+}
+
+doremoveinvuln( rule )
+{
+    giveorremoveinvuln( gettargetsforgametypeeventrule( rule ), 0 );
+}
+
+dosetdamagemodifier( rule )
+{
+    if ( !doesrulehavevalidparam( rule ) )
+        return;
+
+    players = gettargetsforgametypeeventrule( rule );
+
+    for ( i = 0; i < players.size; i++ )
+    {
+        player = players[i];
+        player.damagemodifier = rule.params[0];
+    }
+}
+
+doscalemovespeed( rule )
+{
+    if ( !doesrulehavevalidparam( rule ) )
+        return;
+
+    movespeedscale = rule.params[0];
+    targets = gettargetsforgametypeeventrule( rule );
+
+    for ( targetindex = 0; targetindex < targets.size; targetindex++ )
+    {
+        target = targets[targetindex];
+        target.movementspeedmodifier = movespeedscale * target getmovespeedscale();
+
+        if ( target.movementspeedmodifier < 0.1 )
+            target.movementspeedmodifier = 0.1;
+        else if ( target.movementspeedmodifier > 4.0 )
+            target.movementspeedmodifier = 4.0;
+
+        target setmovespeedscale( target.movementspeedmodifier );
+    }
+}
+
+doshowonradar( rule )
+{
+    if ( !doesrulehavevalidparam( rule ) )
+        return;
+
+    targets = gettargetsforgametypeeventrule( rule );
+
+    for ( targetindex = 0; targetindex < targets.size; targetindex++ )
+    {
+        if ( rule.params[0] == "enable" )
+        {
+            targets[targetindex] setperk( "specialty_showonradar" );
+            continue;
+        }
+
+        targets[targetindex] unsetperk( "specialty_showonradar" );
+    }
+}

ZM/Core/maps/mp/gametypes_zm/_healthoverlay.gsc

@@ -0,0 +1,278 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\gametypes_zm\_globallogic_player;
+
+init()
+{
+    precacheshader( "overlay_low_health" );
+    level.healthoverlaycutoff = 0.55;
+    regentime = level.playerhealthregentime;
+    level.playerhealth_regularregendelay = regentime * 1000;
+    level.healthregendisabled = level.playerhealth_regularregendelay <= 0;
+    level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+    for (;;)
+    {
+        level waittill( "connecting", player );
+
+        player thread onplayerspawned();
+        player thread onplayerkilled();
+        player thread onjoinedteam();
+        player thread onjoinedspectators();
+        player thread onplayerdisconnect();
+    }
+}
+
+onjoinedteam()
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "joined_team" );
+
+        self notify( "end_healthregen" );
+    }
+}
+
+onjoinedspectators()
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "joined_spectators" );
+
+        self notify( "end_healthregen" );
+    }
+}
+
+onplayerspawned()
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "spawned_player" );
+
+        self thread playerhealthregen();
+    }
+}
+
+onplayerkilled()
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "killed_player" );
+
+        self notify( "end_healthregen" );
+    }
+}
+
+onplayerdisconnect()
+{
+    self waittill( "disconnect" );
+
+    self notify( "end_healthregen" );
+}
+
+playerhealthregen()
+{
+    self endon( "end_healthregen" );
+
+    if ( self.health <= 0 )
+    {
+        assert( !isalive( self ) );
+        return;
+    }
+
+    maxhealth = self.health;
+    oldhealth = maxhealth;
+    player = self;
+    health_add = 0;
+    regenrate = 0.1;
+    usetrueregen = 0;
+    veryhurt = 0;
+    player.breathingstoptime = -10000;
+    thread playerbreathingsound( maxhealth * 0.35 );
+    thread playerheartbeatsound( maxhealth * 0.35 );
+    lastsoundtime_recover = 0;
+    hurttime = 0;
+    newhealth = 0;
+
+    for (;;)
+    {
+        wait 0.05;
+
+        if ( isdefined( player.regenrate ) )
+        {
+            regenrate = player.regenrate;
+            usetrueregen = 1;
+        }
+
+        if ( player.health == maxhealth )
+        {
+            veryhurt = 0;
+            self.atbrinkofdeath = 0;
+            continue;
+        }
+
+        if ( player.health <= 0 )
+            return;
+
+        if ( isdefined( player.laststand ) && player.laststand )
+            continue;
+
+        wasveryhurt = veryhurt;
+        ratio = player.health / maxhealth;
+
+        if ( ratio <= level.healthoverlaycutoff )
+        {
+            veryhurt = 1;
+            self.atbrinkofdeath = 1;
+
+            if ( !wasveryhurt )
+                hurttime = gettime();
+        }
+
+        if ( player.health >= oldhealth )
+        {
+            regentime = level.playerhealth_regularregendelay;
+
+            if ( player hasperk( "specialty_healthregen" ) )
+                regentime = int( regentime / getdvarfloat( "perk_healthRegenMultiplier" ) );
+
+            if ( gettime() - hurttime < regentime )
+                continue;
+
+            if ( level.healthregendisabled )
+                continue;
+
+            if ( gettime() - lastsoundtime_recover > regentime )
+            {
+                lastsoundtime_recover = gettime();
+                self notify( "snd_breathing_better" );
+            }
+
+            if ( veryhurt )
+            {
+                newhealth = ratio;
+                veryhurttime = 3000;
+
+                if ( player hasperk( "specialty_healthregen" ) )
+                    veryhurttime = int( veryhurttime / getdvarfloat( "perk_healthRegenMultiplier" ) );
+
+                if ( gettime() > hurttime + veryhurttime )
+                    newhealth += regenrate;
+            }
+            else if ( usetrueregen )
+                newhealth = ratio + regenrate;
+            else
+                newhealth = 1;
+
+            if ( newhealth >= 1.0 )
+            {
+                self maps\mp\gametypes_zm\_globallogic_player::resetattackerlist();
+                newhealth = 1.0;
+            }
+
+            if ( newhealth <= 0 )
+                return;
+
+            player setnormalhealth( newhealth );
+            change = player.health - oldhealth;
+
+            if ( change > 0 )
+                player decayplayerdamages( change );
+
+            oldhealth = player.health;
+            continue;
+        }
+
+        oldhealth = player.health;
+        health_add = 0;
+        hurttime = gettime();
+        player.breathingstoptime = hurttime + 6000;
+    }
+}
+
+decayplayerdamages( decay )
+{
+    if ( !isdefined( self.attackerdamage ) )
+        return;
+
+    for ( i = 0; i < self.attackerdamage.size; i++ )
+    {
+        if ( !isdefined( self.attackerdamage[i] ) || !isdefined( self.attackerdamage[i].damage ) )
+            continue;
+
+        self.attackerdamage[i].damage -= decay;
+
+        if ( self.attackerdamage[i].damage < 0 )
+            self.attackerdamage[i].damage = 0;
+    }
+}
+
+playerbreathingsound( healthcap )
+{
+    self endon( "end_healthregen" );
+    wait 2;
+    player = self;
+
+    for (;;)
+    {
+        wait 0.2;
+
+        if ( player.health <= 0 )
+            return;
+
+        if ( player.health >= healthcap )
+            continue;
+
+        if ( level.healthregendisabled && gettime() > player.breathingstoptime )
+            continue;
+
+        player notify( "snd_breathing_hurt" );
+        wait 0.784;
+        wait( 0.1 + randomfloat( 0.8 ) );
+    }
+}
+
+playerheartbeatsound( healthcap )
+{
+    self endon( "end_healthregen" );
+    self.hearbeatwait = 0.2;
+    wait 2;
+    player = self;
+
+    for (;;)
+    {
+        wait 0.2;
+
+        if ( player.health <= 0 )
+            return;
+
+        if ( player.health >= healthcap )
+        {
+            self.hearbeatwait = 0.3;
+            continue;
+        }
+
+        if ( level.healthregendisabled && gettime() > player.breathingstoptime )
+        {
+            self.hearbeatwait = 0.3;
+            continue;
+        }
+
+        player playlocalsound( "mpl_player_heartbeat" );
+        wait( self.hearbeatwait );
+
+        if ( self.hearbeatwait <= 0.6 )
+            self.hearbeatwait += 0.1;
+    }
+}

ZM/Core/maps/mp/gametypes_zm/_hostmigration.gsc

@@ -0,0 +1,518 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include common_scripts\utility;
+#include maps\mp\gametypes_zm\_hud_util;
+#include maps\mp\zombies\_zm_utility;
+#include maps\mp\gametypes_zm\_hud;
+#include maps\mp\zombies\_zm;
+
+debug_script_structs()
+{
+/#
+    if ( isdefined( level.struct ) )
+    {
+        println( "*** Num structs " + level.struct.size );
+        println( "" );
+
+        for ( i = 0; i < level.struct.size; i++ )
+        {
+            struct = level.struct[i];
+
+            if ( isdefined( struct.targetname ) )
+            {
+                println( "---" + i + " : " + struct.targetname );
+                continue;
+            }
+
+            println( "---" + i + " : " + "NONE" );
+        }
+    }
+    else
+        println( "*** No structs defined." );
+#/
+}
+
+updatetimerpausedness()
+{
+    shouldbestopped = isdefined( level.hostmigrationtimer );
+
+    if ( !level.timerstopped && shouldbestopped )
+    {
+        level.timerstopped = 1;
+        level.timerpausetime = gettime();
+    }
+    else if ( level.timerstopped && !shouldbestopped )
+    {
+        level.timerstopped = 0;
+        level.discardtime += gettime() - level.timerpausetime;
+    }
+}
+
+callback_hostmigrationsave()
+{
+
+}
+
+callback_prehostmigrationsave()
+{
+    undo_link_changes();
+    disablezombies( 1 );
+
+    if ( is_true( level._hm_should_pause_spawning ) )
+        flag_set( "spawn_zombies" );
+
+    for ( i = 0; i < level.players.size; i++ )
+        level.players[i] enableinvulnerability();
+}
+
+pausetimer()
+{
+    level.migrationtimerpausetime = gettime();
+}
+
+resumetimer()
+{
+    level.discardtime += gettime() - level.migrationtimerpausetime;
+}
+
+locktimer()
+{
+    level endon( "host_migration_begin" );
+    level endon( "host_migration_end" );
+
+    for (;;)
+    {
+        currtime = gettime();
+        wait 0.05;
+
+        if ( !level.timerstopped && isdefined( level.discardtime ) )
+            level.discardtime += gettime() - currtime;
+    }
+}
+
+callback_hostmigration()
+{
+    redo_link_changes();
+    setslowmotion( 1, 1, 0 );
+    makedvarserverinfo( "ui_guncycle", 0 );
+    level.hostmigrationreturnedplayercount = 0;
+
+    if ( level.gameended )
+    {
+/#
+        println( "Migration starting at time " + gettime() + ", but game has ended, so no countdown." );
+#/
+        return;
+    }
+
+    sethostmigrationstatus( 1 );
+    level notify( "host_migration_begin" );
+
+    for ( i = 0; i < level.players.size; i++ )
+    {
+        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();
+    }
+
+    if ( isdefined( level.hostmigration_ai_link_entity_callback ) )
+    {
+        zombies = getaiarray( level.zombie_team );
+
+        if ( isdefined( zombies ) && zombies.size > 0 )
+        {
+            foreach ( zombie in zombies )
+            {
+                if ( !isdefined( zombie._host_migration_link_entity ) )
+                    zombie._host_migration_link_entity = zombie [[ level.hostmigration_ai_link_entity_callback ]]();
+            }
+        }
+    }
+
+    if ( level.inprematchperiod )
+        level waittill( "prematch_over" );
+/#
+    println( "Migration starting at time " + gettime() );
+#/
+    level.hostmigrationtimer = 1;
+    thread locktimer();
+    zombies = getaiarray( level.zombie_team );
+
+    if ( isdefined( zombies ) && zombies.size > 0 )
+    {
+        foreach ( zombie in zombies )
+        {
+            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 );
+            }
+        }
+    }
+
+    level endon( "host_migration_begin" );
+    level._hm_should_pause_spawning = flag( "spawn_zombies" );
+
+    if ( level._hm_should_pause_spawning )
+        flag_clear( "spawn_zombies" );
+
+    hostmigrationwait();
+
+    foreach ( player in level.players )
+        player thread post_migration_become_vulnerable();
+
+    zombies = getaiarray( level.zombie_team );
+
+    if ( isdefined( zombies ) && zombies.size > 0 )
+    {
+        foreach ( zombie in zombies )
+        {
+            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;
+            }
+        }
+    }
+
+    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() );
+#/
+    level notify( "host_migration_end" );
+}
+
+post_migration_become_vulnerable()
+{
+    self endon( "disconnect" );
+    wait 3;
+    self disableinvulnerability();
+}
+
+matchstarttimerconsole_internal( counttime, matchstarttimer )
+{
+    waittillframeend;
+    level endon( "match_start_timer_beginning" );
+
+    while ( counttime > 0 && !level.gameended )
+    {
+        matchstarttimer thread maps\mp\gametypes_zm\_hud::fontpulse( level );
+        wait( matchstarttimer.inframes * 0.05 );
+        matchstarttimer setvalue( counttime );
+        counttime--;
+        wait( 1 - matchstarttimer.inframes * 0.05 );
+    }
+}
+
+matchstarttimerconsole( type, duration )
+{
+    level notify( "match_start_timer_beginning" );
+    wait 0.05;
+    matchstarttext = createserverfontstring( "objective", 1.5 );
+    matchstarttext setpoint( "CENTER", "CENTER", 0, -40 );
+    matchstarttext.sort = 1001;
+    matchstarttext settext( game["strings"]["waiting_for_teams"] );
+    matchstarttext.foreground = 0;
+    matchstarttext.hidewheninmenu = 1;
+    matchstarttext settext( game["strings"][type] );
+    matchstarttimer = createserverfontstring( "objective", 2.2 );
+    matchstarttimer setpoint( "CENTER", "CENTER", 0, 0 );
+    matchstarttimer.sort = 1001;
+    matchstarttimer.color = ( 1, 1, 0 );
+    matchstarttimer.foreground = 0;
+    matchstarttimer.hidewheninmenu = 1;
+    matchstarttimer maps\mp\gametypes_zm\_hud::fontpulseinit();
+    counttime = int( duration );
+
+    if ( counttime >= 2 )
+        matchstarttimerconsole_internal( counttime, matchstarttimer );
+    else
+    {
+
+    }
+
+    matchstarttimer destroyelem();
+    matchstarttext destroyelem();
+}
+
+hostmigrationwait()
+{
+    level endon( "game_ended" );
+
+    if ( level.hostmigrationreturnedplayercount < level.players.size * 2 / 3 )
+    {
+        thread matchstarttimerconsole( "waiting_for_teams", 20.0 );
+        hostmigrationwaitforplayers();
+    }
+
+    thread matchstarttimerconsole( "match_starting_in", 5.0 );
+    wait 5;
+}
+
+hostmigrationwaitforplayers()
+{
+    level endon( "hostmigration_enoughplayers" );
+    wait 15;
+}
+
+hostmigrationtimerthink_internal()
+{
+    level endon( "host_migration_begin" );
+    level endon( "host_migration_end" );
+    self.hostmigrationcontrolsfrozen = 0;
+
+    while ( !isalive( self ) )
+        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" );
+}
+
+hostmigrationtimerthink()
+{
+    self endon( "disconnect" );
+    level endon( "host_migration_begin" );
+    hostmigrationtimerthink_internal();
+
+    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;
+    }
+}
+
+waittillhostmigrationdone()
+{
+    if ( !isdefined( level.hostmigrationtimer ) )
+        return 0;
+
+    starttime = gettime();
+
+    level waittill( "host_migration_end" );
+
+    return gettime() - starttime;
+}
+
+waittillhostmigrationstarts( duration )
+{
+    if ( isdefined( level.hostmigrationtimer ) )
+        return;
+
+    level endon( "host_migration_begin" );
+    wait( duration );
+}
+
+waitlongdurationwithhostmigrationpause( duration )
+{
+    if ( duration == 0 )
+        return;
+
+    assert( duration > 0 );
+    starttime = gettime();
+    endtime = gettime() + duration * 1000;
+
+    while ( gettime() < endtime )
+    {
+        waittillhostmigrationstarts( ( endtime - gettime() ) / 1000 );
+
+        if ( isdefined( level.hostmigrationtimer ) )
+        {
+            timepassed = waittillhostmigrationdone();
+            endtime += timepassed;
+        }
+    }
+
+    if ( gettime() != endtime )
+    {
+/#
+        println( "SCRIPT WARNING: gettime() = " + gettime() + " NOT EQUAL TO endtime = " + endtime );
+#/
+    }
+
+    waittillhostmigrationdone();
+    return gettime() - starttime;
+}
+
+waitlongdurationwithgameendtimeupdate( duration )
+{
+    if ( duration == 0 )
+        return;
+
+    assert( duration > 0 );
+    starttime = gettime();
+    endtime = gettime() + duration * 1000;
+
+    while ( gettime() < endtime )
+    {
+        waittillhostmigrationstarts( ( endtime - gettime() ) / 1000 );
+
+        while ( isdefined( level.hostmigrationtimer ) )
+        {
+            endtime += 1000;
+            setgameendtime( int( endtime ) );
+            wait 1;
+        }
+    }
+/#
+    if ( gettime() != endtime )
+        println( "SCRIPT WARNING: gettime() = " + gettime() + " NOT EQUAL TO endtime = " + endtime );
+#/
+    while ( isdefined( level.hostmigrationtimer ) )
+    {
+        endtime += 1000;
+        setgameendtime( int( endtime ) );
+        wait 1;
+    }
+
+    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" );
+
+    if ( isdefined( a_nodes ) && a_nodes.size > 0 )
+    {
+        a_player_volumes = getentarray( "player_volume", "script_noteworthy" );
+        index = a_nodes.size - 1;
+
+        for ( i = index; i >= 0; i-- )
+        {
+            n_node = a_nodes[i];
+
+            if ( ignore_targetted_nodes == 1 )
+            {
+                if ( isdefined( n_node.target ) )
+                    continue;
+            }
+
+            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;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    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" );
+
+        if ( isdefined( structs ) )
+        {
+            foreach ( struct in structs )
+            {
+                if ( isdefined( struct.script_string ) )
+                {
+                    tokens = strtok( struct.script_string, " " );
+
+                    foreach ( token in tokens )
+                    {
+                        if ( token == match_string )
+                            spawnpoints[spawnpoints.size] = struct;
+                    }
+                }
+            }
+        }
+
+        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 );
+}

ZM/Core/maps/mp/gametypes_zm/_hud.gsc

@@ -0,0 +1,157 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+
+init()
+{
+    precacheshader( "progress_bar_bg" );
+    precacheshader( "progress_bar_fg" );
+    precacheshader( "progress_bar_fill" );
+    precacheshader( "score_bar_bg" );
+    level.uiparent = spawnstruct();
+    level.uiparent.horzalign = "left";
+    level.uiparent.vertalign = "top";
+    level.uiparent.alignx = "left";
+    level.uiparent.aligny = "top";
+    level.uiparent.x = 0;
+    level.uiparent.y = 0;
+    level.uiparent.width = 0;
+    level.uiparent.height = 0;
+    level.uiparent.children = [];
+    level.fontheight = 12;
+
+    foreach ( team in level.teams )
+        level.hud[team] = spawnstruct();
+
+    level.primaryprogressbary = -61;
+    level.primaryprogressbarx = 0;
+    level.primaryprogressbarheight = 9;
+    level.primaryprogressbarwidth = 120;
+    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;
+    level.secondaryprogressbary = -85;
+    level.secondaryprogressbarx = 0;
+    level.secondaryprogressbarheight = 9;
+    level.secondaryprogressbarwidth = 120;
+    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;
+    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;
+}
+
+fontpulseinit()
+{
+    self.basefontscale = self.fontscale;
+    self.maxfontscale = self.fontscale * 2;
+    self.inframes = 1.5;
+    self.outframes = 3;
+}
+
+fontpulse( player )
+{
+    self notify( "fontPulse" );
+    self endon( "fontPulse" );
+    self endon( "death" );
+    player endon( "disconnect" );
+    player endon( "joined_team" );
+    player endon( "joined_spectators" );
+
+    if ( self.outframes == 0 )
+        self.fontscale = 0.01;
+    else
+        self.fontscale = self.fontscale;
+
+    if ( self.inframes > 0 )
+    {
+        self changefontscaleovertime( self.inframes * 0.05 );
+        self.fontscale = self.maxfontscale;
+        wait( self.inframes * 0.05 );
+    }
+    else
+    {
+        self.fontscale = self.maxfontscale;
+        self.alpha = 0;
+        self fadeovertime( self.outframes * 0.05 );
+        self.alpha = 1;
+    }
+
+    if ( self.outframes > 0 )
+    {
+        self changefontscaleovertime( self.outframes * 0.05 );
+        self.fontscale = self.basefontscale;
+    }
+}
+
+fadetoblackforxsec( startwait, blackscreenwait, fadeintime, fadeouttime, shadername, n_sort = 50 )
+{
+    wait( startwait );
+
+    if ( !isdefined( self ) )
+        return;
+
+    if ( !isdefined( self.blackscreen ) )
+        self.blackscreen = newclienthudelem( self );
+
+    self.blackscreen.x = 0;
+    self.blackscreen.y = 0;
+    self.blackscreen.horzalign = "fullscreen";
+    self.blackscreen.vertalign = "fullscreen";
+    self.blackscreen.foreground = 0;
+    self.blackscreen.hidewhendead = 0;
+    self.blackscreen.hidewheninmenu = 1;
+    self.blackscreen.sort = n_sort;
+
+    if ( isdefined( shadername ) )
+        self.blackscreen setshader( shadername, 640, 480 );
+    else
+        self.blackscreen setshader( "black", 640, 480 );
+
+    self.blackscreen.alpha = 0;
+
+    if ( fadeintime > 0 )
+        self.blackscreen fadeovertime( fadeintime );
+
+    self.blackscreen.alpha = 1;
+    wait( fadeintime );
+
+    if ( !isdefined( self.blackscreen ) )
+        return;
+
+    wait( blackscreenwait );
+
+    if ( !isdefined( self.blackscreen ) )
+        return;
+
+    if ( fadeouttime > 0 )
+        self.blackscreen fadeovertime( fadeouttime );
+
+    self.blackscreen.alpha = 0;
+    wait( fadeouttime );
+
+    if ( isdefined( self.blackscreen ) )
+    {
+        self.blackscreen destroy();
+        self.blackscreen = undefined;
+    }
+}

ZM/Core/maps/mp/gametypes_zm/_menus.gsc

@@ -0,0 +1,174 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include maps\mp\gametypes_zm\_globallogic;
+#include maps\mp\gametypes_zm\_rank;
+
+init()
+{
+    precachestring( &"open_ingame_menu" );
+    game["menu_team"] = "team_marinesopfor";
+    game["menu_initteam_allies"] = "initteam_marines";
+    game["menu_initteam_axis"] = "initteam_opfor";
+    game["menu_class"] = "class";
+    game["menu_changeclass"] = "changeclass";
+    game["menu_changeclass_offline"] = "changeclass";
+    game["menu_wager_side_bet"] = "sidebet";
+    game["menu_wager_side_bet_player"] = "sidebet_player";
+    game["menu_changeclass_wager"] = "changeclass_wager";
+    game["menu_changeclass_custom"] = "changeclass_custom";
+    game["menu_changeclass_barebones"] = "changeclass_barebones";
+
+    foreach ( team in level.teams )
+        game["menu_changeclass_" + team] = "changeclass";
+
+    game["menu_controls"] = "ingame_controls";
+    game["menu_options"] = "ingame_options";
+    game["menu_leavegame"] = "popup_leavegame";
+    precachemenu( game["menu_controls"] );
+    precachemenu( game["menu_options"] );
+    precachemenu( game["menu_leavegame"] );
+    precachemenu( "scoreboard" );
+    precachemenu( "spectate" );
+    precachemenu( game["menu_team"] );
+    precachemenu( game["menu_changeclass_allies"] );
+    precachemenu( game["menu_initteam_allies"] );
+    precachemenu( game["menu_changeclass_axis"] );
+    precachemenu( game["menu_class"] );
+    precachemenu( game["menu_changeclass"] );
+    precachemenu( game["menu_initteam_axis"] );
+    precachemenu( game["menu_changeclass_offline"] );
+    precachemenu( game["menu_changeclass_wager"] );
+    precachemenu( game["menu_changeclass_custom"] );
+    precachemenu( game["menu_changeclass_barebones"] );
+    precachemenu( game["menu_wager_side_bet"] );
+    precachemenu( game["menu_wager_side_bet_player"] );
+    precachestring( &"MP_HOST_ENDED_GAME" );
+    precachestring( &"MP_HOST_ENDGAME_RESPONSE" );
+    level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+    for (;;)
+    {
+        level waittill( "connecting", player );
+
+        player thread onmenuresponse();
+    }
+}
+
+onmenuresponse()
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "menuresponse", menu, response );
+
+        if ( response == "back" )
+        {
+            self closemenu();
+            self closeingamemenu();
+
+            if ( level.console )
+            {
+                if ( menu == game["menu_changeclass"] || menu == game["menu_changeclass_offline"] || menu == game["menu_team"] || menu == game["menu_controls"] )
+                {
+                    if ( isdefined( level.teams[self.pers["team"]] ) )
+                        self openmenu( game["menu_class"] );
+                }
+            }
+
+            continue;
+        }
+
+        if ( response == "changeteam" && level.allow_teamchange == "1" )
+        {
+            self closemenu();
+            self closeingamemenu();
+            self openmenu( game["menu_team"] );
+        }
+
+        if ( response == "changeclass_marines_splitscreen" )
+            self openmenu( "changeclass_marines_splitscreen" );
+
+        if ( response == "changeclass_opfor_splitscreen" )
+            self openmenu( "changeclass_opfor_splitscreen" );
+
+        if ( response == "endgame" )
+        {
+            if ( self issplitscreen() )
+            {
+                level.skipvote = 1;
+
+                if ( !level.gameended )
+                    level thread maps\mp\gametypes_zm\_globallogic::forceend();
+            }
+
+            continue;
+        }
+
+        if ( response == "killserverpc" )
+        {
+            level thread maps\mp\gametypes_zm\_globallogic::killserverpc();
+            continue;
+        }
+
+        if ( response == "endround" )
+        {
+            if ( !level.gameended )
+                level thread maps\mp\gametypes_zm\_globallogic::forceend();
+            else
+            {
+                self closemenu();
+                self closeingamemenu();
+                self iprintln( &"MP_HOST_ENDGAME_RESPONSE" );
+            }
+
+            continue;
+        }
+
+        if ( menu == game["menu_team"] && level.allow_teamchange == "1" )
+        {
+            switch ( response )
+            {
+                case "autoassign":
+                    self [[ level.autoassign ]]( 1 );
+                    break;
+                case "spectator":
+                    self [[ level.spectator ]]();
+                    break;
+                default:
+                    self [[ level.teammenu ]]( response );
+                    break;
+            }
+
+            continue;
+        }
+
+        if ( menu == game["menu_changeclass"] || menu == game["menu_changeclass_offline"] || menu == game["menu_changeclass_wager"] || menu == game["menu_changeclass_custom"] || menu == game["menu_changeclass_barebones"] )
+        {
+            self closemenu();
+            self closeingamemenu();
+
+            if ( level.rankedmatch && issubstr( response, "custom" ) )
+            {
+                if ( self isitemlocked( maps\mp\gametypes_zm\_rank::getitemindex( "feature_cac" ) ) )
+                    kick( self getentitynumber() );
+            }
+
+            self.selectedclass = 1;
+            self [[ level.class ]]( response );
+            continue;
+        }
+
+        if ( menu == "spectate" )
+        {
+            player = getplayerfromclientnum( int( response ) );
+
+            if ( isdefined( player ) )
+                self setcurrentspectatorclient( player );
+        }
+    }
+}

ZM/Core/maps/mp/gametypes_zm/_perplayer.gsc

@@ -0,0 +1,179 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+
+init( id, playerbegincallback, playerendcallback )
+{
+    precacheshader( "objpoint_default" );
+    handler = spawnstruct();
+    handler.id = id;
+    handler.playerbegincallback = playerbegincallback;
+    handler.playerendcallback = playerendcallback;
+    handler.enabled = 0;
+    handler.players = [];
+    thread onplayerconnect( handler );
+    level.handlerglobalflagval = 0;
+    return handler;
+}
+
+enable( handler )
+{
+    if ( handler.enabled )
+        return;
+
+    handler.enabled = 1;
+    level.handlerglobalflagval++;
+    players = get_players();
+
+    for ( i = 0; i < players.size; i++ )
+        players[i].handlerflagval = level.handlerglobalflagval;
+
+    players = handler.players;
+
+    for ( i = 0; i < players.size; i++ )
+    {
+        if ( players[i].handlerflagval != level.handlerglobalflagval )
+            continue;
+
+        if ( players[i].handlers[handler.id].ready )
+            players[i] handleplayer( handler );
+    }
+}
+
+disable( handler )
+{
+    if ( !handler.enabled )
+        return;
+
+    handler.enabled = 0;
+    level.handlerglobalflagval++;
+    players = get_players();
+
+    for ( i = 0; i < players.size; i++ )
+        players[i].handlerflagval = level.handlerglobalflagval;
+
+    players = handler.players;
+
+    for ( i = 0; i < players.size; i++ )
+    {
+        if ( players[i].handlerflagval != level.handlerglobalflagval )
+            continue;
+
+        if ( players[i].handlers[handler.id].ready )
+            players[i] unhandleplayer( handler, 0, 0 );
+    }
+}
+
+onplayerconnect( handler )
+{
+    for (;;)
+    {
+        level waittill( "connecting", player );
+
+        if ( !isdefined( player.handlers ) )
+            player.handlers = [];
+
+        player.handlers[handler.id] = spawnstruct();
+        player.handlers[handler.id].ready = 0;
+        player.handlers[handler.id].handled = 0;
+        player.handlerflagval = -1;
+        handler.players[handler.players.size] = player;
+        player thread onplayerdisconnect( handler );
+        player thread onplayerspawned( handler );
+        player thread onjoinedteam( handler );
+        player thread onjoinedspectators( handler );
+        player thread onplayerkilled( handler );
+    }
+}
+
+onplayerdisconnect( handler )
+{
+    self waittill( "disconnect" );
+
+    newplayers = [];
+
+    for ( i = 0; i < handler.players.size; i++ )
+    {
+        if ( handler.players[i] != self )
+            newplayers[newplayers.size] = handler.players[i];
+    }
+
+    handler.players = newplayers;
+    self thread unhandleplayer( handler, 1, 1 );
+}
+
+onjoinedteam( handler )
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "joined_team" );
+
+        self thread unhandleplayer( handler, 1, 0 );
+    }
+}
+
+onjoinedspectators( handler )
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "joined_spectators" );
+
+        self thread unhandleplayer( handler, 1, 0 );
+    }
+}
+
+onplayerspawned( handler )
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "spawned_player" );
+
+        self thread handleplayer( handler );
+    }
+}
+
+onplayerkilled( handler )
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "killed_player" );
+
+        self thread unhandleplayer( handler, 1, 0 );
+    }
+}
+
+handleplayer( handler )
+{
+    self.handlers[handler.id].ready = 1;
+
+    if ( !handler.enabled )
+        return;
+
+    if ( self.handlers[handler.id].handled )
+        return;
+
+    self.handlers[handler.id].handled = 1;
+    self thread [[ handler.playerbegincallback ]]();
+}
+
+unhandleplayer( handler, unsetready, disconnected )
+{
+    if ( !disconnected && unsetready )
+        self.handlers[handler.id].ready = 0;
+
+    if ( !self.handlers[handler.id].handled )
+        return;
+
+    if ( !disconnected )
+        self.handlers[handler.id].handled = 0;
+
+    self thread [[ handler.playerendcallback ]]( disconnected );
+}

ZM/Core/maps/mp/gametypes_zm/_scoreboard.gsc

@@ -0,0 +1,27 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+
+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;
+
+    if ( sessionmodeiszombiesgame() )
+    {
+        setdvar( "g_TeamIcon_Axis", "faction_cia" );
+        setdvar( "g_TeamIcon_Allies", "faction_cdc" );
+    }
+    else
+    {
+        setdvar( "g_TeamIcon_Axis", game["icons"]["axis"] );
+        setdvar( "g_TeamIcon_Allies", game["icons"]["allies"] );
+    }
+}

ZM/Core/maps/mp/gametypes_zm/_serversettings.gsc

@@ -0,0 +1,191 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+
+init()
+{
+    level.hostname = getdvar( "sv_hostname" );
+
+    if ( level.hostname == "" )
+        level.hostname = "CoDHost";
+
+    setdvar( "sv_hostname", level.hostname );
+    setdvar( "ui_hostname", level.hostname );
+    makedvarserverinfo( "ui_hostname", "CoDHost" );
+    level.motd = getdvar( "scr_motd" );
+
+    if ( level.motd == "" )
+        level.motd = "";
+
+    setdvar( "scr_motd", level.motd );
+    setdvar( "ui_motd", level.motd );
+    makedvarserverinfo( "ui_motd", "" );
+    level.allowvote = getdvar( "g_allowVote" );
+
+    if ( level.allowvote == "" )
+        level.allowvote = "1";
+
+    setdvar( "g_allowvote", level.allowvote );
+    setdvar( "ui_allowvote", level.allowvote );
+    makedvarserverinfo( "ui_allowvote", "1" );
+    level.allow_teamchange = "0";
+
+    if ( sessionmodeisprivate() || !sessionmodeisonlinegame() )
+        level.allow_teamchange = "1";
+
+    setdvar( "ui_allow_teamchange", level.allow_teamchange );
+    level.friendlyfire = getgametypesetting( "friendlyfiretype" );
+    setdvar( "ui_friendlyfire", level.friendlyfire );
+    makedvarserverinfo( "ui_friendlyfire", "0" );
+
+    if ( getdvar( "scr_mapsize" ) == "" )
+        setdvar( "scr_mapsize", "64" );
+    else if ( getdvarfloat( "scr_mapsize" ) >= 64 )
+        setdvar( "scr_mapsize", "64" );
+    else if ( getdvarfloat( "scr_mapsize" ) >= 32 )
+        setdvar( "scr_mapsize", "32" );
+    else if ( getdvarfloat( "scr_mapsize" ) >= 16 )
+        setdvar( "scr_mapsize", "16" );
+    else
+        setdvar( "scr_mapsize", "8" );
+
+    level.mapsize = getdvarfloat( "scr_mapsize" );
+    constraingametype( getdvar( "g_gametype" ) );
+    constrainmapsize( level.mapsize );
+
+    for (;;)
+    {
+        updateserversettings();
+        wait 5;
+    }
+}
+
+updateserversettings()
+{
+    sv_hostname = getdvar( "sv_hostname" );
+
+    if ( level.hostname != sv_hostname )
+    {
+        level.hostname = sv_hostname;
+        setdvar( "ui_hostname", level.hostname );
+    }
+
+    scr_motd = getdvar( "scr_motd" );
+
+    if ( level.motd != scr_motd )
+    {
+        level.motd = scr_motd;
+        setdvar( "ui_motd", level.motd );
+    }
+
+    g_allowvote = getdvar( "g_allowVote" );
+
+    if ( level.allowvote != g_allowvote )
+    {
+        level.allowvote = g_allowvote;
+        setdvar( "ui_allowvote", level.allowvote );
+    }
+
+    scr_friendlyfire = getgametypesetting( "friendlyfiretype" );
+
+    if ( level.friendlyfire != scr_friendlyfire )
+    {
+        level.friendlyfire = scr_friendlyfire;
+        setdvar( "ui_friendlyfire", level.friendlyfire );
+    }
+}
+
+constraingametype( gametype )
+{
+    entities = getentarray();
+
+    for ( i = 0; i < entities.size; i++ )
+    {
+        entity = entities[i];
+
+        if ( gametype == "dm" )
+        {
+            if ( isdefined( entity.script_gametype_dm ) && entity.script_gametype_dm != "1" )
+                entity delete();
+
+            continue;
+        }
+
+        if ( gametype == "tdm" )
+        {
+            if ( isdefined( entity.script_gametype_tdm ) && entity.script_gametype_tdm != "1" )
+                entity delete();
+
+            continue;
+        }
+
+        if ( gametype == "ctf" )
+        {
+            if ( isdefined( entity.script_gametype_ctf ) && entity.script_gametype_ctf != "1" )
+                entity delete();
+
+            continue;
+        }
+
+        if ( gametype == "hq" )
+        {
+            if ( isdefined( entity.script_gametype_hq ) && entity.script_gametype_hq != "1" )
+                entity delete();
+
+            continue;
+        }
+
+        if ( gametype == "sd" )
+        {
+            if ( isdefined( entity.script_gametype_sd ) && entity.script_gametype_sd != "1" )
+                entity delete();
+
+            continue;
+        }
+
+        if ( gametype == "koth" )
+        {
+            if ( isdefined( entity.script_gametype_koth ) && entity.script_gametype_koth != "1" )
+                entity delete();
+        }
+    }
+}
+
+constrainmapsize( mapsize )
+{
+    entities = getentarray();
+
+    for ( i = 0; i < entities.size; i++ )
+    {
+        entity = entities[i];
+
+        if ( int( mapsize ) == 8 )
+        {
+            if ( isdefined( entity.script_mapsize_08 ) && entity.script_mapsize_08 != "1" )
+                entity delete();
+
+            continue;
+        }
+
+        if ( int( mapsize ) == 16 )
+        {
+            if ( isdefined( entity.script_mapsize_16 ) && entity.script_mapsize_16 != "1" )
+                entity delete();
+
+            continue;
+        }
+
+        if ( int( mapsize ) == 32 )
+        {
+            if ( isdefined( entity.script_mapsize_32 ) && entity.script_mapsize_32 != "1" )
+                entity delete();
+
+            continue;
+        }
+
+        if ( int( mapsize ) == 64 )
+        {
+            if ( isdefined( entity.script_mapsize_64 ) && entity.script_mapsize_64 != "1" )
+                entity delete();
+        }
+    }
+}

ZM/Core/maps/mp/gametypes_zm/_shellshock.gsc

@@ -0,0 +1,56 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include common_scripts\utility;
+
+init()
+{
+    precacheshellshock( "frag_grenade_mp" );
+    precacheshellshock( "damage_mp" );
+    precacherumble( "artillery_rumble" );
+    precacherumble( "grenade_rumble" );
+}
+
+shellshockondamage( cause, damage )
+{
+    if ( cause == "MOD_EXPLOSIVE" || cause == "MOD_GRENADE" || cause == "MOD_GRENADE_SPLASH" || cause == "MOD_PROJECTILE" || cause == "MOD_PROJECTILE_SPLASH" )
+    {
+        time = 0;
+
+        if ( damage >= 90 )
+            time = 4;
+        else if ( damage >= 50 )
+            time = 3;
+        else if ( damage >= 25 )
+            time = 2;
+        else if ( damage > 10 )
+            time = 2;
+
+        if ( time )
+        {
+            if ( self mayapplyscreeneffect() )
+                self shellshock( "frag_grenade_mp", 0.5 );
+        }
+    }
+}
+
+endondeath()
+{
+    self waittill( "death" );
+
+    waittillframeend;
+    self notify( "end_explode" );
+}
+
+endontimer( timer )
+{
+    self endon( "disconnect" );
+    wait( timer );
+    self notify( "end_on_timer" );
+}
+
+rcbomb_earthquake( position )
+{
+    playrumbleonposition( "grenade_rumble", position );
+    earthquake( 0.5, 0.5, self.origin, 512 );
+}

ZM/Core/maps/mp/gametypes_zm/_spawning.gsc

@@ -0,0 +1,942 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include common_scripts\utility;
+#include maps\mp\gametypes_zm\_spawnlogic;
+
+init()
+{
+    if ( !isdefined( level.gamemodespawndvars ) )
+        level.gamemodespawndvars = ::default_gamemodespawndvars;
+
+    level init_spawn_system();
+    level.recently_deceased = [];
+
+    foreach ( team in level.teams )
+        level.recently_deceased[team] = spawn_array_struct();
+
+    level thread onplayerconnect();
+
+    if ( getdvar( _hash_AD6C19FE ) == "" )
+        level.spawn_visibility_check_max = 20;
+    else
+        level.spawn_visibility_check_max = getdvarint( _hash_AD6C19FE );
+
+    level.spawnprotectiontime = getgametypesetting( "spawnprotectiontime" );
+/#
+    setdvar( "scr_debug_spawn_player", "" );
+    setdvar( "scr_debug_render_spawn_data", "1" );
+    setdvar( "scr_debug_render_snapshotmode", "0" );
+    setdvar( "scr_spawn_point_test_mode", "0" );
+    level.test_spawn_point_index = 0;
+    setdvar( "scr_debug_render_spawn_text", "1" );
+#/
+}
+
+default_gamemodespawndvars( reset_dvars )
+{
+
+}
+
+init_spawn_system()
+{
+    level.spawnsystem = spawnstruct();
+    spawnsystem = level.spawnsystem;
+    level get_player_spawning_dvars( 1 );
+    level thread initialize_player_spawning_dvars();
+    spawnsystem.einfluencer_shape_sphere = 0;
+    spawnsystem.einfluencer_shape_cylinder = 1;
+    spawnsystem.einfluencer_type_normal = 0;
+    spawnsystem.einfluencer_type_player = 1;
+    spawnsystem.einfluencer_type_weapon = 2;
+    spawnsystem.einfluencer_type_dog = 3;
+    spawnsystem.einfluencer_type_vehicle = 4;
+    spawnsystem.einfluencer_type_game_mode = 6;
+    spawnsystem.einfluencer_type_enemy_spawned = 7;
+    spawnsystem.einfluencer_curve_constant = 0;
+    spawnsystem.einfluencer_curve_linear = 1;
+    spawnsystem.einfluencer_curve_steep = 2;
+    spawnsystem.einfluencer_curve_inverse_linear = 3;
+    spawnsystem.einfluencer_curve_negative_to_positive = 4;
+    spawnsystem.ispawn_teammask = [];
+    spawnsystem.ispawn_teammask_free = 1;
+    spawnsystem.ispawn_teammask["free"] = spawnsystem.ispawn_teammask_free;
+    all = spawnsystem.ispawn_teammask_free;
+    count = 1;
+
+    foreach ( team in level.teams )
+    {
+        spawnsystem.ispawn_teammask[team] = 1 << count;
+        all |= spawnsystem.ispawn_teammask[team];
+        count++;
+    }
+
+    spawnsystem.ispawn_teammask["all"] = all;
+}
+
+onplayerconnect()
+{
+    level endon( "game_ended" );
+
+    for (;;)
+    {
+        level waittill( "connecting", player );
+
+        player setentertime( gettime() );
+        player thread onplayerspawned();
+        player thread ondisconnect();
+        player thread onteamchange();
+        player thread ongrenadethrow();
+    }
+}
+
+onplayerspawned()
+{
+    self endon( "disconnect" );
+    level endon( "game_ended" );
+
+    for (;;)
+    {
+        self waittill( "spawned_player" );
+
+        self thread initialspawnprotection( "specialty_nottargetedbyairsupport", 1 );
+        self thread initialspawnprotection( "specialty_nokillstreakreticle", 0 );
+        self thread initialspawnprotection( "specialty_nottargettedbysentry", 0 );
+
+        if ( isdefined( self.pers["hasRadar"] ) && self.pers["hasRadar"] )
+            self.hasspyplane = 1;
+
+        self enable_player_influencers( 1 );
+        self thread ondeath();
+    }
+}
+
+ondeath()
+{
+    self endon( "disconnect" );
+    level endon( "game_ended" );
+
+    self waittill( "death" );
+
+    self enable_player_influencers( 0 );
+    self create_body_influencers();
+}
+
+onteamchange()
+{
+    self endon( "disconnect" );
+    level endon( "game_ended" );
+
+    while ( true )
+    {
+        self waittill( "joined_team" );
+
+        self player_influencers_set_team();
+        wait 0.05;
+    }
+}
+
+ongrenadethrow()
+{
+    self endon( "disconnect" );
+    level endon( "game_ended" );
+
+    while ( true )
+    {
+        self waittill( "grenade_fire", grenade, weaponname );
+
+        level thread create_grenade_influencers( self.pers["team"], weaponname, grenade );
+        wait 0.05;
+    }
+}
+
+ondisconnect()
+{
+    level endon( "game_ended" );
+
+    self waittill( "disconnect" );
+}
+
+get_score_curve_index( curve )
+{
+    switch ( curve )
+    {
+        case "linear":
+            return level.spawnsystem.einfluencer_curve_linear;
+        case "steep":
+            return level.spawnsystem.einfluencer_curve_steep;
+        case "inverse_linear":
+            return level.spawnsystem.einfluencer_curve_linear;
+        case "negative_to_positive":
+            return level.spawnsystem.einfluencer_curve_negative_to_positive;
+        case "constant":
+        default:
+            return level.spawnsystem.einfluencer_curve_constant;
+    }
+}
+
+get_influencer_type_index( curve )
+{
+
+}
+
+create_player_influencers()
+{
+    assert( !isdefined( self.influencer_enemy_sphere ) );
+    assert( !isdefined( self.influencer_weapon_cylinder ) );
+    assert( !level.teambased || !isdefined( self.influencer_friendly_sphere ) );
+    assert( !level.teambased || !isdefined( self.influencer_friendly_cylinder ) );
+
+    if ( !level.teambased )
+    {
+        team_mask = level.spawnsystem.ispawn_teammask_free;
+        other_team_mask = level.spawnsystem.ispawn_teammask_free;
+        weapon_team_mask = level.spawnsystem.ispawn_teammask_free;
+    }
+    else if ( isdefined( self.pers["team"] ) )
+    {
+        team = self.pers["team"];
+        team_mask = getteammask( team );
+        other_team_mask = getotherteamsmask( team );
+        weapon_team_mask = getotherteamsmask( team );
+    }
+    else
+    {
+        team_mask = 0;
+        other_team_mask = 0;
+        weapon_team_mask = 0;
+    }
+
+    if ( level.hardcoremode )
+        weapon_team_mask |= team_mask;
+
+    angles = self.angles;
+    origin = self.origin;
+    up = ( 0, 0, 1 );
+    forward = ( 1, 0, 0 );
+    cylinder_forward = up;
+    cylinder_up = forward;
+    self.influencer_enemy_sphere = addsphereinfluencer( level.spawnsystem.einfluencer_type_player, origin, level.spawnsystem.enemy_influencer_radius, level.spawnsystem.enemy_influencer_score, other_team_mask, "enemy,r,s", get_score_curve_index( level.spawnsystem.enemy_influencer_score_curve ), 0, self );
+
+    if ( level.teambased )
+    {
+        cylinder_up = -1.0 * forward;
+        self.influencer_friendly_sphere = addsphereinfluencer( level.spawnsystem.einfluencer_type_player, origin, level.spawnsystem.friend_weak_influencer_radius, level.spawnsystem.friend_weak_influencer_score, team_mask, "friend_weak,r,s", get_score_curve_index( level.spawnsystem.friend_weak_influencer_score_curve ), 0, self );
+    }
+
+    self.spawn_influencers_created = 1;
+
+    if ( !isdefined( self.pers["team"] ) || self.pers["team"] == "spectator" )
+        self enable_player_influencers( 0 );
+}
+
+remove_player_influencers()
+{
+    if ( level.teambased && isdefined( self.influencer_friendly_sphere ) )
+    {
+        removeinfluencer( self.influencer_friendly_sphere );
+        self.influencer_friendly_sphere = undefined;
+    }
+
+    if ( level.teambased && isdefined( self.influencer_friendly_cylinder ) )
+    {
+        removeinfluencer( self.influencer_friendly_cylinder );
+        self.influencer_friendly_cylinder = undefined;
+    }
+
+    if ( isdefined( self.influencer_enemy_sphere ) )
+    {
+        removeinfluencer( self.influencer_enemy_sphere );
+        self.influencer_enemy_sphere = undefined;
+    }
+
+    if ( isdefined( self.influencer_weapon_cylinder ) )
+    {
+        removeinfluencer( self.influencer_weapon_cylinder );
+        self.influencer_weapon_cylinder = undefined;
+    }
+}
+
+enable_player_influencers( enabled )
+{
+    if ( !isdefined( self.spawn_influencers_created ) )
+        self create_player_influencers();
+
+    if ( isdefined( self.influencer_friendly_sphere ) )
+        enableinfluencer( self.influencer_friendly_sphere, enabled );
+
+    if ( isdefined( self.influencer_friendly_cylinder ) )
+        enableinfluencer( self.influencer_friendly_cylinder, enabled );
+
+    if ( isdefined( self.influencer_enemy_sphere ) )
+        enableinfluencer( self.influencer_enemy_sphere, enabled );
+
+    if ( isdefined( self.influencer_weapon_cylinder ) )
+        enableinfluencer( self.influencer_weapon_cylinder, enabled );
+}
+
+player_influencers_set_team()
+{
+    if ( !level.teambased )
+    {
+        team_mask = level.spawnsystem.ispawn_teammask_free;
+        other_team_mask = level.spawnsystem.ispawn_teammask_free;
+        weapon_team_mask = level.spawnsystem.ispawn_teammask_free;
+    }
+    else
+    {
+        team = self.pers["team"];
+        team_mask = getteammask( team );
+        other_team_mask = getotherteamsmask( team );
+        weapon_team_mask = getotherteamsmask( team );
+    }
+
+    if ( level.friendlyfire != 0 && level.teambased )
+        weapon_team_mask |= team_mask;
+
+    if ( isdefined( self.influencer_friendly_sphere ) )
+        setinfluencerteammask( self.influencer_friendly_sphere, team_mask );
+
+    if ( isdefined( self.influencer_friendly_cylinder ) )
+        setinfluencerteammask( self.influencer_friendly_cylinder, team_mask );
+
+    if ( isdefined( self.influencer_enemy_sphere ) )
+        setinfluencerteammask( self.influencer_enemy_sphere, other_team_mask );
+
+    if ( isdefined( self.influencer_weapon_cylinder ) )
+        setinfluencerteammask( self.influencer_weapon_cylinder, weapon_team_mask );
+}
+
+create_body_influencers()
+{
+    if ( level.teambased )
+        team_mask = getteammask( self.pers["team"] );
+    else
+        team_mask = level.spawnsystem.ispawn_teammask_free;
+
+    addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, self.origin, level.spawnsystem.dead_friend_influencer_radius, level.spawnsystem.dead_friend_influencer_score, team_mask, "dead_friend,r,s", get_score_curve_index( level.spawnsystem.dead_friend_influencer_score_curve ), level.spawnsystem.dead_friend_influencer_timeout_seconds );
+}
+
+create_grenade_influencers( parent_team, weaponname, grenade )
+{
+    pixbeginevent( "create_grenade_influencers" );
+
+    if ( !level.teambased )
+        weapon_team_mask = level.spawnsystem.ispawn_teammask_free;
+    else
+    {
+        weapon_team_mask = getotherteamsmask( parent_team );
+
+        if ( level.friendlyfire )
+            weapon_team_mask |= getteammask( parent_team );
+    }
+
+    if ( issubstr( weaponname, "napalmblob" ) || issubstr( weaponname, "gl_" ) )
+    {
+        pixendevent();
+        return;
+    }
+
+    timeout = 0;
+
+    if ( weaponname == "tabun_gas_mp" )
+        timeout = 7.0;
+
+    if ( isdefined( grenade.origin ) )
+    {
+        if ( weaponname == "claymore_mp" || weaponname == "bouncingbetty_mp" )
+            addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, grenade.origin, level.spawnsystem.claymore_influencer_radius, level.spawnsystem.claymore_influencer_score, weapon_team_mask, "claymore,r,s", get_score_curve_index( level.spawnsystem.claymore_influencer_score_curve ), timeout, grenade );
+        else
+            addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, grenade.origin, level.spawnsystem.grenade_influencer_radius, level.spawnsystem.grenade_influencer_score, weapon_team_mask, "grenade,r,s", get_score_curve_index( level.spawnsystem.grenade_influencer_score_curve ), timeout, grenade );
+    }
+
+    pixendevent();
+}
+
+create_napalm_fire_influencers( point, direction, parent_team, duration )
+{
+    timeout = duration;
+    weapon_team_mask = 0;
+    offset = vectorscale( anglestoforward( direction ), 1100 );
+    addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, point + 2.0 * offset, level.spawnsystem.napalm_influencer_radius, level.spawnsystem.napalm_influencer_score, weapon_team_mask, "napalm,r,s", get_score_curve_index( level.spawnsystem.napalm_influencer_score_curve ), timeout );
+    addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, point + offset, level.spawnsystem.napalm_influencer_radius, level.spawnsystem.napalm_influencer_score, weapon_team_mask, "napalm,r,s", get_score_curve_index( level.spawnsystem.napalm_influencer_score_curve ), timeout );
+    addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, point, level.spawnsystem.napalm_influencer_radius, level.spawnsystem.napalm_influencer_score, weapon_team_mask, "napalm,r,s", get_score_curve_index( level.spawnsystem.napalm_influencer_score_curve ), timeout );
+    addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, point - offset, level.spawnsystem.napalm_influencer_radius, level.spawnsystem.napalm_influencer_score, weapon_team_mask, "napalm,r,s", get_score_curve_index( level.spawnsystem.napalm_influencer_score_curve ), timeout );
+}
+
+create_auto_turret_influencer( 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_radius * 0.7 );
+    influencerid = addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, projected_point, level.spawnsystem.auto_turret_influencer_radius, level.spawnsystem.auto_turret_influencer_score, weapon_team_mask, "auto_turret,r,s", get_score_curve_index( level.spawnsystem.auto_turret_influencer_score_curve ) );
+    return influencerid;
+}
+
+create_dog_influencers()
+{
+    if ( !level.teambased )
+        dog_enemy_team_mask = level.spawnsystem.ispawn_teammask_free;
+    else
+        dog_enemy_team_mask = getotherteamsmask( self.aiteam );
+
+    addsphereinfluencer( level.spawnsystem.einfluencer_type_dog, self.origin, level.spawnsystem.dog_influencer_radius, level.spawnsystem.dog_influencer_score, dog_enemy_team_mask, "dog,r,s", get_score_curve_index( level.spawnsystem.dog_influencer_score_curve ), 0, self );
+}
+
+create_helicopter_influencers( parent_team )
+{
+    if ( !level.teambased )
+        team_mask = level.spawnsystem.ispawn_teammask_free;
+    else
+        team_mask = getotherteamsmask( parent_team );
+
+    self.influencer_helicopter_cylinder = addcylinderinfluencer( level.spawnsystem.einfluencer_type_normal, self.origin, ( 0, 0, 0 ), ( 0, 0, 0 ), level.spawnsystem.helicopter_influencer_radius, level.spawnsystem.helicopter_influencer_length, level.spawnsystem.helicopter_influencer_score, team_mask, "helicopter,r,s", get_score_curve_index( level.spawnsystem.helicopter_influencer_score_curve ), 0, self );
+}
+
+remove_helicopter_influencers()
+{
+    if ( isdefined( self.influencer_helicopter_cylinder ) )
+        removeinfluencer( self.influencer_helicopter_cylinder );
+
+    self.influencer_helicopter_cylinder = undefined;
+}
+
+create_tvmissile_influencers( parent_team )
+{
+    if ( !level.teambased || is_hardcore() )
+        team_mask = level.spawnsystem.ispawn_teammask_free;
+    else
+        team_mask = getotherteamsmask( parent_team );
+
+    self.influencer_tvmissile_cylinder = addcylinderinfluencer( level.spawnsystem.einfluencer_type_normal, self.origin, ( 0, 0, 0 ), ( 0, 0, 0 ), level.spawnsystem.tvmissile_influencer_radius, level.spawnsystem.tvmissile_influencer_length, level.spawnsystem.tvmissile_influencer_score, team_mask, "tvmissile,r,s", get_score_curve_index( level.spawnsystem.tvmissile_influencer_score_curve ), 0, self );
+}
+
+remove_tvmissile_influencers()
+{
+    if ( isdefined( self.influencer_tvmissile_cylinder ) )
+        removeinfluencer( self.influencer_tvmissile_cylinder );
+
+    self.influencer_tvmissile_cylinder = undefined;
+}
+
+create_artillery_influencers( point, radius )
+{
+    weapon_team_mask = 0;
+
+    if ( radius < 0 )
+        thisradius = level.spawnsystem.artillery_influencer_radius;
+    else
+        thisradius = radius;
+
+    return addcylinderinfluencer( level.spawnsystem.einfluencer_type_normal, point + vectorscale( ( 0, 0, -1 ), 2000.0 ), ( 1, 0, 0 ), ( 0, 0, 1 ), thisradius, 5000, level.spawnsystem.artillery_influencer_score, weapon_team_mask, "artillery,s,r", get_score_curve_index( level.spawnsystem.artillery_influencer_score_curve ), 7 );
+}
+
+create_vehicle_influencers()
+{
+    weapon_team_mask = 0;
+    vehicleradius = 144;
+    cylinderlength = level.spawnsystem.vehicle_influencer_lead_seconds;
+    up = ( 0, 0, 1 );
+    forward = ( 1, 0, 0 );
+    cylinder_forward = up;
+    cylinder_up = forward;
+    return addcylinderinfluencer( level.spawnsystem.einfluencer_type_vehicle, self.origin, cylinder_forward, cylinder_up, vehicleradius, cylinderlength, level.spawnsystem.vehicle_influencer_score, weapon_team_mask, "vehicle,s", get_score_curve_index( level.spawnsystem.vehicle_influencer_score_curve ), 0, self );
+}
+
+create_rcbomb_influencers( team )
+{
+    if ( !level.teambased )
+        other_team_mask = level.spawnsystem.ispawn_teammask_free;
+    else
+        other_team_mask = getotherteamsmask( team );
+
+    return addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, self.origin, level.spawnsystem.rcbomb_influencer_radius, level.spawnsystem.rcbomb_influencer_score, other_team_mask, "rcbomb,r,s", get_score_curve_index( level.spawnsystem.rcbomb_influencer_score_curve ), 0, self );
+}
+
+create_qrdrone_influencers( team )
+{
+    if ( !level.teambased )
+        other_team_mask = level.spawnsystem.ispawn_teammask_free;
+    else
+        other_team_mask = getotherteamsmask( team );
+
+    self.influencer_qrdrone_cylinder = addcylinderinfluencer( level.spawnsystem.einfluencer_type_normal, self.origin, ( 0, 0, 0 ), ( 0, 0, 0 ), level.spawnsystem.qrdrone_cylinder_influencer_radius, level.spawnsystem.qrdrone_cylinder_influencer_length, level.spawnsystem.qrdrone_cylinder_influencer_score, other_team_mask, "qrdrone_cyl,r,s", get_score_curve_index( level.spawnsystem.qrdrone_cylinder_influencer_score_curve ), 0, self );
+    return addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, self.origin, level.spawnsystem.qrdrone_influencer_radius, level.spawnsystem.qrdrone_influencer_score, other_team_mask, "qrdrone,r,s", get_score_curve_index( level.spawnsystem.qrdrone_influencer_score_curve ), 0, self );
+}
+
+create_aitank_influencers( team )
+{
+    if ( !level.teambased )
+        other_team_mask = level.spawnsystem.ispawn_teammask_free;
+    else
+        other_team_mask = getotherteamsmask( team );
+
+    return addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, self.origin, level.spawnsystem.aitank_influencer_radius, level.spawnsystem.aitank_influencer_score, other_team_mask, "aitank,r,s", get_score_curve_index( level.spawnsystem.aitank_influencer_score_curve ), 0, self );
+}
+
+create_pegasus_influencer( origin, team )
+{
+    if ( !level.teambased )
+        other_team_mask = level.spawnsystem.ispawn_teammask_free;
+    else
+        other_team_mask = getotherteamsmask( team );
+
+    return addsphereinfluencer( level.spawnsystem.einfluencer_type_normal, origin, level.spawnsystem.pegasus_influencer_radius, level.spawnsystem.pegasus_influencer_score, other_team_mask, "pegasus,r,s", get_score_curve_index( level.spawnsystem.pegasus_influencer_score_curve ), 0 );
+}
+
+create_map_placed_influencers()
+{
+    staticinfluencerents = getentarray( "mp_uspawn_influencer", "classname" );
+
+    for ( i = 0; i < staticinfluencerents.size; i++ )
+    {
+        staticinfluencerent = staticinfluencerents[i];
+
+        if ( isdefined( staticinfluencerent.script_gameobjectname ) && staticinfluencerent.script_gameobjectname == "twar" )
+            continue;
+
+        create_map_placed_influencer( staticinfluencerent );
+    }
+}
+
+create_map_placed_influencer( influencer_entity, optional_score_override )
+{
+    influencer_id = -1;
+
+    if ( isdefined( influencer_entity.script_shape ) && isdefined( influencer_entity.script_score ) && isdefined( influencer_entity.script_score_curve ) )
+    {
+        switch ( influencer_entity.script_shape )
+        {
+            case "sphere":
+                if ( isdefined( influencer_entity.radius ) )
+                {
+                    if ( isdefined( optional_score_override ) )
+                        score = optional_score_override;
+                    else
+                        score = influencer_entity.script_score;
+
+                    influencer_id = addsphereinfluencer( level.spawnsystem.einfluencer_type_game_mode, influencer_entity.origin, influencer_entity.radius, score, getteammask( influencer_entity.script_team ), "*map_defined", get_score_curve_index( influencer_entity.script_score_curve ) );
+                }
+                else
+                {
+/#
+                    assertmsg( "Radiant-placed sphere spawn influencers require 'radius' parameter" );
+#/
+                }
+
+                break;
+            case "cylinder":
+                if ( isdefined( influencer_entity.radius ) && isdefined( influencer_entity.height ) )
+                {
+                    if ( isdefined( optional_score_override ) )
+                        score = optional_score_override;
+                    else
+                        score = influencer_entity.script_score;
+
+                    influencer_id = addcylinderinfluencer( level.spawnsystem.einfluencer_type_game_mode, influencer_entity.origin, anglestoforward( influencer_entity.angles ), anglestoup( influencer_entity.angles ), influencer_entity.radius, influencer_entity.height, score, getteammask( influencer_entity.script_team ), "*map_defined", get_score_curve_index( influencer_entity.script_score_curve ) );
+                }
+                else
+                {
+/#
+                    assertmsg( "Radiant-placed cylinder spawn influencers require 'radius' and 'height' parameters" );
+#/
+                }
+
+                break;
+            default:
+/#
+                assertmsg( "Unsupported script_shape value (\"" + influencer_entity.script_shape + "\") for unified spawning system static influencer.  Supported shapes are \"cylinder\" and \"sphere\"." );
+#/
+                break;
+        }
+    }
+    else
+    {
+/#
+        assertmsg( "Radiant-placed spawn influencers require 'script_shape', 'script_score' and 'script_score_curve' parameters" );
+#/
+    }
+
+    return influencer_id;
+}
+
+create_enemy_spawned_influencers( origin, team )
+{
+    if ( !level.teambased )
+        other_team_mask = level.spawnsystem.ispawn_teammask_free;
+    else
+        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 );
+}
+
+updateallspawnpoints()
+{
+    foreach ( team in level.teams )
+        gatherspawnentities( team );
+
+    clearspawnpoints();
+
+    if ( level.teambased )
+    {
+        foreach ( team in level.teams )
+            addspawnpoints( team, level.unified_spawn_points[team].a );
+    }
+    else
+    {
+        foreach ( team in level.teams )
+            addspawnpoints( "free", level.unified_spawn_points[team].a );
+    }
+
+    remove_unused_spawn_entities();
+}
+
+initialize_player_spawning_dvars()
+{
+/#
+    reset_dvars = 1;
+
+    while ( true )
+    {
+        get_player_spawning_dvars( reset_dvars );
+        reset_dvars = 0;
+        wait 2;
+    }
+#/
+}
+
+get_player_spawning_dvars( reset_dvars )
+{
+    k_player_height = get_player_height();
+    player_height_times_10 = "" + 10.0 * k_player_height;
+    ss = level.spawnsystem;
+    player_influencer_radius = 15.0 * k_player_height;
+    player_influencer_score = 150.0;
+    dog_influencer_radius = 10.0 * k_player_height;
+    dog_influencer_score = 150.0;
+    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.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_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_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 );
+    ss.dead_friend_influencer_radius = set_dvar_float_if_unset( "scr_spawn_dead_friend_influencer_radius", player_height_times_10, reset_dvars );
+    ss.vehicle_influencer_score = set_dvar_float_if_unset( "scr_spawn_vehicle_influencer_score", "-50", reset_dvars );
+    ss.vehicle_influencer_score_curve = set_dvar_if_unset( "scr_spawn_vehicle_influencer_score_curve", "linear", reset_dvars );
+    ss.vehicle_influencer_lead_seconds = set_dvar_float_if_unset( "scr_spawn_vehicle_influencer_lead_seconds", "3", reset_dvars );
+    ss.dog_influencer_score = set_dvar_float_if_unset( "scr_spawn_dog_influencer_score", "-150", reset_dvars );
+    ss.dog_influencer_score_curve = set_dvar_if_unset( "scr_spawn_dog_influencer_score_curve", "steep", reset_dvars );
+    ss.dog_influencer_radius = set_dvar_float_if_unset( "scr_spawn_dog_influencer_radius", "" + 15.0 * k_player_height, reset_dvars );
+    ss.artillery_influencer_score = set_dvar_float_if_unset( "scr_spawn_artillery_influencer_score", "-600", reset_dvars );
+    ss.artillery_influencer_score_curve = set_dvar_if_unset( "scr_spawn_artillery_influencer_score_curve", "linear", reset_dvars );
+    ss.artillery_influencer_radius = set_dvar_float_if_unset( "scr_spawn_artillery_influencer_radius", "1200", reset_dvars );
+    ss.grenade_influencer_score = set_dvar_float_if_unset( "scr_spawn_grenade_influencer_score", "-300", reset_dvars );
+    ss.grenade_influencer_score_curve = set_dvar_if_unset( "scr_spawn_grenade_influencer_score_curve", "linear", reset_dvars );
+    ss.grenade_influencer_radius = set_dvar_float_if_unset( "scr_spawn_grenade_influencer_radius", "" + 8.0 * k_player_height, reset_dvars );
+    ss.grenade_endpoint_influencer_score = set_dvar_float_if_unset( "scr_spawn_grenade_endpoint_influencer_score", "-300", reset_dvars );
+    ss.grenade_endpoint_influencer_score_curve = set_dvar_if_unset( "scr_spawn_grenade_endpoint_influencer_score_curve", "linear", reset_dvars );
+    ss.grenade_endpoint_influencer_radius = set_dvar_float_if_unset( "scr_spawn_grenade_endpoint_influencer_radius", "" + 8.0 * k_player_height, reset_dvars );
+    ss.claymore_influencer_score = set_dvar_float_if_unset( "scr_spawn_claymore_influencer_score", "-150", reset_dvars );
+    ss.claymore_influencer_score_curve = set_dvar_if_unset( "scr_spawn_claymore_influencer_score_curve", "steep", reset_dvars );
+    ss.claymore_influencer_radius = set_dvar_float_if_unset( "scr_spawn_claymore_influencer_radius", "" + 9.0 * k_player_height, reset_dvars );
+    ss.napalm_influencer_score = set_dvar_float_if_unset( "scr_spawn_napalm_influencer_score", "-500", reset_dvars );
+    ss.napalm_influencer_score_curve = set_dvar_if_unset( "scr_spawn_napalm_influencer_score_curve", "linear", reset_dvars );
+    ss.napalm_influencer_radius = set_dvar_float_if_unset( "scr_spawn_napalm_influencer_radius", "" + 750, 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.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.0 * k_player_height, reset_dvars );
+    ss.qrdrone_influencer_score = set_dvar_float_if_unset( "scr_spawn_qrdrone_influencer_score", "-200", reset_dvars );
+    ss.qrdrone_influencer_score_curve = set_dvar_if_unset( "scr_spawn_qrdrone_influencer_score_curve", "steep", reset_dvars );
+    ss.qrdrone_influencer_radius = set_dvar_float_if_unset( "scr_spawn_qrdrone_influencer_radius", "" + 25.0 * k_player_height, reset_dvars );
+    ss.qrdrone_cylinder_influencer_score = set_dvar_float_if_unset( "scr_spawn_qrdrone_cylinder_influencer_score", "-300", reset_dvars );
+    ss.qrdrone_cylinder_influencer_score_curve = set_dvar_if_unset( "scr_spawn_qrdrone_cylinder_influencer_score_curve", "linear", reset_dvars );
+    ss.qrdrone_cylinder_influencer_radius = set_dvar_float_if_unset( "scr_spawn_qrdrone_cylinder_influencer_radius", 1000, reset_dvars );
+    ss.qrdrone_cylinder_influencer_length = set_dvar_float_if_unset( "scr_spawn_qrdrone_cylinder_influencer_length", 2000, reset_dvars );
+    ss.aitank_influencer_score = set_dvar_float_if_unset( "scr_spawn_aitank_influencer_score", "-200", 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.0 * 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 )
+    {
+        ss.enemy_spawned_influencer_score = set_dvar_float_if_unset( "scr_spawn_enemy_spawned_influencer_score", "-200", 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.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 );
+    ss.helicopter_influencer_length = set_dvar_float_if_unset( "scr_spawn_helicopter_influencer_length", "" + 3500, reset_dvars );
+    ss.tvmissile_influencer_score = set_dvar_float_if_unset( "scr_spawn_tvmissile_influencer_score", "-400", reset_dvars );
+    ss.tvmissile_influencer_score_curve = set_dvar_if_unset( "scr_spawn_tvmissile_influencer_score_curve", "linear", reset_dvars );
+    ss.tvmissile_influencer_radius = set_dvar_float_if_unset( "scr_spawn_tvmissile_influencer_radius", "" + 2000, reset_dvars );
+    ss.tvmissile_influencer_length = set_dvar_float_if_unset( "scr_spawn_tvmissile_influencer_length", "" + 3000, reset_dvars );
+    ss.pegasus_influencer_score = set_dvar_float_if_unset( "scr_spawn_pegasus_influencer_score", "-250", reset_dvars );
+    ss.pegasus_influencer_score_curve = set_dvar_if_unset( "scr_spawn_pegasus_influencer_score_curve", "linear", reset_dvars );
+    ss.pegasus_influencer_radius = set_dvar_float_if_unset( "scr_spawn_pegasus_influencer_radius", "" + 20.0 * k_player_height, reset_dvars );
+
+    if ( !isdefined( ss.unifiedsideswitching ) )
+        ss.unifiedsideswitching = 1;
+
+    set_dvar_int_if_unset( "spawnsystem_allow_non_team_spawns", "0", reset_dvars );
+    [[ level.gamemodespawndvars ]]( reset_dvars );
+
+    if ( isdefined( level.levelspawndvars ) )
+        [[ level.levelspawndvars ]]( reset_dvars );
+
+    setspawnpointrandomvariation( ss.randomness_range );
+}
+
+level_use_unified_spawning( use )
+{
+
+}
+
+onspawnplayer_unified( predictedspawn = 0 )
+{
+/#
+    if ( getdvarint( "scr_spawn_point_test_mode" ) != 0 )
+    {
+        spawn_point = get_debug_spawnpoint( self );
+        self spawn( spawn_point.origin, spawn_point.angles );
+        return;
+    }
+#/
+    use_new_spawn_system = 0;
+    initial_spawn = 1;
+
+    if ( isdefined( self.uspawn_already_spawned ) )
+        initial_spawn = !self.uspawn_already_spawned;
+
+    if ( level.usestartspawns )
+        use_new_spawn_system = 0;
+
+    if ( level.gametype == "sd" )
+        use_new_spawn_system = 0;
+
+    set_dvar_if_unset( "scr_spawn_force_unified", "0" );
+    [[ level.onspawnplayer ]]( predictedspawn );
+
+    if ( !predictedspawn )
+        self.uspawn_already_spawned = 1;
+}
+
+getspawnpoint( player_entity, predictedspawn = 0 )
+{
+    if ( level.teambased )
+    {
+        point_team = player_entity.pers["team"];
+        influencer_team = player_entity.pers["team"];
+    }
+    else
+    {
+        point_team = "free";
+        influencer_team = "free";
+    }
+
+    if ( level.teambased && isdefined( game["switchedsides"] ) && game["switchedsides"] && level.spawnsystem.unifiedsideswitching )
+        point_team = getotherteam( point_team );
+
+    best_spawn_entity = get_best_spawnpoint( point_team, influencer_team, player_entity, predictedspawn );
+
+    if ( !predictedspawn )
+        player_entity.last_spawn_origin = best_spawn_entity.origin;
+
+    return best_spawn_entity;
+}
+
+get_debug_spawnpoint( player )
+{
+    if ( level.teambased )
+        team = player.pers["team"];
+    else
+        team = "free";
+
+    index = level.test_spawn_point_index;
+    level.test_spawn_point_index++;
+
+    if ( team == "free" )
+    {
+        spawn_counts = 0;
+
+        foreach ( team in level.teams )
+            spawn_counts += level.unified_spawn_points[team].a.size;
+
+        if ( level.test_spawn_point_index >= spawn_counts )
+            level.test_spawn_point_index = 0;
+
+        count = 0;
+
+        foreach ( team in level.teams )
+        {
+            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;
+        }
+    }
+    else
+    {
+        if ( level.test_spawn_point_index >= level.unified_spawn_points[team].a.size )
+            level.test_spawn_point_index = 0;
+
+        return level.unified_spawn_points[team].a[level.test_spawn_point_index];
+    }
+}
+
+get_best_spawnpoint( point_team, influencer_team, player, predictedspawn )
+{
+    if ( level.teambased )
+        vis_team_mask = getotherteamsmask( player.pers["team"] );
+    else
+        vis_team_mask = level.spawnsystem.ispawn_teammask_free;
+
+    scored_spawn_points = getsortedspawnpoints( point_team, influencer_team, vis_team_mask, player, predictedspawn );
+    assert( scored_spawn_points.size > 0 );
+    assert( scored_spawn_points.size == 1 );
+
+    if ( !predictedspawn )
+        bbprint( "mpspawnpointsused", "reason %s x %d y %d z %d", "point used", scored_spawn_points[0].origin );
+
+    return scored_spawn_points[0];
+}
+
+gatherspawnentities( player_team )
+{
+    if ( !isdefined( level.unified_spawn_points ) )
+        level.unified_spawn_points = [];
+    else if ( isdefined( level.unified_spawn_points[player_team] ) )
+        return level.unified_spawn_points[player_team];
+
+    spawn_entities_s = spawn_array_struct();
+    spawn_entities_s.a = getentarray( "mp_uspawn_point", "classname" );
+
+    if ( !isdefined( spawn_entities_s.a ) )
+        spawn_entities_s.a = [];
+
+    legacy_spawn_points = maps\mp\gametypes_zm\_spawnlogic::getteamspawnpoints( player_team );
+
+    for ( legacy_spawn_index = 0; legacy_spawn_index < legacy_spawn_points.size; legacy_spawn_index++ )
+        spawn_entities_s.a[spawn_entities_s.a.size] = legacy_spawn_points[legacy_spawn_index];
+
+    level.unified_spawn_points[player_team] = spawn_entities_s;
+    return spawn_entities_s;
+}
+
+is_hardcore()
+{
+    return isdefined( level.hardcoremode ) && level.hardcoremode;
+}
+
+teams_have_enmity( team1, team2 )
+{
+    if ( !isdefined( team1 ) || !isdefined( team2 ) || level.gametype == "dm" )
+        return 1;
+
+    return team1 != "neutral" && team2 != "neutral" && team1 != team2;
+}
+
+remove_unused_spawn_entities()
+{
+    spawn_entity_types = [];
+    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";
+    spawn_entity_types[spawn_entity_types.size] = "mp_ctf_spawn_allies_start";
+    spawn_entity_types[spawn_entity_types.size] = "mp_ctf_spawn_axis_start";
+    spawn_entity_types[spawn_entity_types.size] = "mp_ctf_spawn_allies";
+    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";
+    spawn_entity_types[spawn_entity_types.size] = "mp_sab_spawn_allies_start";
+    spawn_entity_types[spawn_entity_types.size] = "mp_sab_spawn_axis_start";
+    spawn_entity_types[spawn_entity_types.size] = "mp_sab_spawn_allies";
+    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_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";
+
+    for ( i = 0; i < spawn_entity_types.size; i++ )
+    {
+        if ( spawn_point_class_name_being_used( spawn_entity_types[i] ) )
+            continue;
+
+        spawnpoints = maps\mp\gametypes_zm\_spawnlogic::getspawnpointarray( spawn_entity_types[i] );
+        delete_all_spawns( spawnpoints );
+    }
+}
+
+delete_all_spawns( spawnpoints )
+{
+    for ( i = 0; i < spawnpoints.size; i++ )
+        spawnpoints[i] delete();
+}
+
+spawn_point_class_name_being_used( name )
+{
+    if ( !isdefined( level.spawn_point_class_names ) )
+        return false;
+
+    for ( i = 0; i < level.spawn_point_class_names.size; i++ )
+    {
+        if ( level.spawn_point_class_names[i] == name )
+            return true;
+    }
+
+    return false;
+}
+
+codecallback_updatespawnpoints()
+{
+    foreach ( team in level.teams )
+        maps\mp\gametypes_zm\_spawnlogic::rebuildspawnpoints( team );
+
+    level.unified_spawn_points = undefined;
+    updateallspawnpoints();
+}
+
+initialspawnprotection( specialtyname, spawnmonitorspeed )
+{
+    self endon( "death" );
+    self endon( "disconnect" );
+
+    if ( !isdefined( level.spawnprotectiontime ) || level.spawnprotectiontime == 0 )
+        return;
+
+    if ( specialtyname == "specialty_nottargetedbyairsupport" )
+    {
+        self.specialty_nottargetedbyairsupport = 1;
+        wait( level.spawnprotectiontime );
+        self.specialty_nottargetedbyairsupport = undefined;
+    }
+    else if ( !self hasperk( specialtyname ) )
+    {
+        self setperk( specialtyname );
+        wait( level.spawnprotectiontime );
+        self unsetperk( specialtyname );
+    }
+}

ZM/Core/maps/mp/gametypes_zm/_spectating.gsc

@@ -0,0 +1,228 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+
+init()
+{
+    foreach ( team in level.teams )
+        level.spectateoverride[team] = spawnstruct();
+
+    level thread onplayerconnect();
+}
+
+onplayerconnect()
+{
+    for (;;)
+    {
+        level waittill( "connecting", player );
+
+        player thread onjoinedteam();
+        player thread onjoinedspectators();
+        player thread onplayerspawned();
+    }
+}
+
+onplayerspawned()
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "spawned_player" );
+
+        self setspectatepermissions();
+    }
+}
+
+onjoinedteam()
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "joined_team" );
+
+        self setspectatepermissionsformachine();
+    }
+}
+
+onjoinedspectators()
+{
+    self endon( "disconnect" );
+
+    for (;;)
+    {
+        self waittill( "joined_spectators" );
+
+        self setspectatepermissionsformachine();
+    }
+}
+
+updatespectatesettings()
+{
+    level endon( "game_ended" );
+
+    for ( index = 0; index < level.players.size; index++ )
+        level.players[index] setspectatepermissions();
+}
+
+getsplitscreenteam()
+{
+    for ( index = 0; index < level.players.size; index++ )
+    {
+        if ( !isdefined( level.players[index] ) )
+            continue;
+
+        if ( level.players[index] == self )
+            continue;
+
+        if ( !self isplayeronsamemachine( level.players[index] ) )
+            continue;
+
+        team = level.players[index].sessionteam;
+
+        if ( team != "spectator" )
+            return team;
+    }
+
+    return self.sessionteam;
+}
+
+otherlocalplayerstillalive()
+{
+    for ( index = 0; index < level.players.size; index++ )
+    {
+        if ( !isdefined( level.players[index] ) )
+            continue;
+
+        if ( level.players[index] == self )
+            continue;
+
+        if ( !self isplayeronsamemachine( level.players[index] ) )
+            continue;
+
+        if ( isalive( level.players[index] ) )
+            return true;
+    }
+
+    return false;
+}
+
+allowspectateallteams( allow )
+{
+    foreach ( team in level.teams )
+        self allowspectateteam( team, allow );
+}
+
+allowspectateallteamsexceptteam( skip_team, allow )
+{
+    foreach ( team in level.teams )
+    {
+        if ( team == skip_team )
+            continue;
+
+        self allowspectateteam( team, allow );
+    }
+}
+
+setspectatepermissions()
+{
+    team = self.sessionteam;
+
+    if ( team == "spectator" )
+    {
+        if ( self issplitscreen() && !level.splitscreen )
+            team = getsplitscreenteam();
+
+        if ( team == "spectator" )
+        {
+            self allowspectateallteams( 1 );
+            self allowspectateteam( "freelook", 0 );
+            self allowspectateteam( "none", 1 );
+            self allowspectateteam( "localplayers", 1 );
+            return;
+        }
+    }
+
+    spectatetype = level.spectatetype;
+
+    switch ( spectatetype )
+    {
+        case 0:
+            self allowspectateallteams( 0 );
+            self allowspectateteam( "freelook", 0 );
+            self allowspectateteam( "none", 1 );
+            self allowspectateteam( "localplayers", 0 );
+            break;
+        case 3:
+            if ( self issplitscreen() && self otherlocalplayerstillalive() )
+            {
+                self allowspectateallteams( 0 );
+                self allowspectateteam( "none", 0 );
+                self allowspectateteam( "freelook", 0 );
+                self allowspectateteam( "localplayers", 1 );
+                break;
+            }
+        case 1:
+            if ( !level.teambased )
+            {
+                self allowspectateallteams( 1 );
+                self allowspectateteam( "none", 1 );
+                self allowspectateteam( "freelook", 0 );
+                self allowspectateteam( "localplayers", 1 );
+            }
+            else if ( isdefined( team ) && isdefined( level.teams[team] ) )
+            {
+                self allowspectateteam( team, 1 );
+                self allowspectateallteamsexceptteam( team, 0 );
+                self allowspectateteam( "freelook", 0 );
+                self allowspectateteam( "none", 0 );
+                self allowspectateteam( "localplayers", 1 );
+            }
+            else
+            {
+                self allowspectateallteams( 0 );
+                self allowspectateteam( "freelook", 0 );
+                self allowspectateteam( "none", 0 );
+                self allowspectateteam( "localplayers", 1 );
+            }
+
+            break;
+        case 2:
+            self allowspectateallteams( 1 );
+            self allowspectateteam( "freelook", 1 );
+            self allowspectateteam( "none", 1 );
+            self allowspectateteam( "localplayers", 1 );
+            break;
+    }
+
+    if ( isdefined( team ) && isdefined( level.teams[team] ) )
+    {
+        if ( isdefined( level.spectateoverride[team].allowfreespectate ) )
+            self allowspectateteam( "freelook", 1 );
+
+        if ( isdefined( level.spectateoverride[team].allowenemyspectate ) )
+            self allowspectateallteamsexceptteam( team, 1 );
+    }
+}
+
+setspectatepermissionsformachine()
+{
+    self setspectatepermissions();
+
+    if ( !self issplitscreen() )
+        return;
+
+    for ( index = 0; index < level.players.size; index++ )
+    {
+        if ( !isdefined( level.players[index] ) )
+            continue;
+
+        if ( level.players[index] == self )
+            continue;
+
+        if ( !self isplayeronsamemachine( level.players[index] ) )
+            continue;
+
+        level.players[index] setspectatepermissions();
+    }
+}

ZM/Core/maps/mp/gametypes_zm/_tweakables.gsc

@@ -0,0 +1,378 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+
+gettweakabledvarvalue( category, name )
+{
+    switch ( category )
+    {
+        case "rule":
+            dvar = level.rules[name].dvar;
+            break;
+        case "game":
+            dvar = level.gametweaks[name].dvar;
+            break;
+        case "team":
+            dvar = level.teamtweaks[name].dvar;
+            break;
+        case "player":
+            dvar = level.playertweaks[name].dvar;
+            break;
+        case "class":
+            dvar = level.classtweaks[name].dvar;
+            break;
+        case "weapon":
+            dvar = level.weapontweaks[name].dvar;
+            break;
+        case "killstreak":
+            dvar = level.hardpointtweaks[name].dvar;
+            break;
+        case "hud":
+            dvar = level.hudtweaks[name].dvar;
+            break;
+        default:
+            dvar = undefined;
+            break;
+    }
+
+    assert( isdefined( dvar ) );
+    value = getdvarint( dvar );
+    return value;
+}
+
+gettweakabledvar( category, name )
+{
+    switch ( category )
+    {
+        case "rule":
+            value = level.rules[name].dvar;
+            break;
+        case "game":
+            value = level.gametweaks[name].dvar;
+            break;
+        case "team":
+            value = level.teamtweaks[name].dvar;
+            break;
+        case "player":
+            value = level.playertweaks[name].dvar;
+            break;
+        case "class":
+            value = level.classtweaks[name].dvar;
+            break;
+        case "weapon":
+            value = level.weapontweaks[name].dvar;
+            break;
+        case "killstreak":
+            value = level.hardpointtweaks[name].dvar;
+            break;
+        case "hud":
+            value = level.hudtweaks[name].dvar;
+            break;
+        default:
+            value = undefined;
+            break;
+    }
+
+    assert( isdefined( value ) );
+    return value;
+}
+
+gettweakablevalue( category, name )
+{
+    switch ( category )
+    {
+        case "rule":
+            value = level.rules[name].value;
+            break;
+        case "game":
+            value = level.gametweaks[name].value;
+            break;
+        case "team":
+            value = level.teamtweaks[name].value;
+            break;
+        case "player":
+            value = level.playertweaks[name].value;
+            break;
+        case "class":
+            value = level.classtweaks[name].value;
+            break;
+        case "weapon":
+            value = level.weapontweaks[name].value;
+            break;
+        case "killstreak":
+            value = level.hardpointtweaks[name].value;
+            break;
+        case "hud":
+            value = level.hudtweaks[name].value;
+            break;
+        default:
+            value = undefined;
+            break;
+    }
+
+    overridedvar = "scr_" + level.gametype + "_" + category + "_" + name;
+
+    if ( getdvar( overridedvar ) != "" )
+        return getdvarint( overridedvar );
+
+    assert( isdefined( value ) );
+    return value;
+}
+
+gettweakablelastvalue( category, name )
+{
+    switch ( category )
+    {
+        case "rule":
+            value = level.rules[name].lastvalue;
+            break;
+        case "game":
+            value = level.gametweaks[name].lastvalue;
+            break;
+        case "team":
+            value = level.teamtweaks[name].lastvalue;
+            break;
+        case "player":
+            value = level.playertweaks[name].lastvalue;
+            break;
+        case "class":
+            value = level.classtweaks[name].lastvalue;
+            break;
+        case "weapon":
+            value = level.weapontweaks[name].lastvalue;
+            break;
+        case "killstreak":
+            value = level.hardpointtweaks[name].lastvalue;
+            break;
+        case "hud":
+            value = level.hudtweaks[name].lastvalue;
+            break;
+        default:
+            value = undefined;
+            break;
+    }
+
+    assert( isdefined( value ) );
+    return value;
+}
+
+settweakablevalue( category, name, value )
+{
+    switch ( category )
+    {
+        case "rule":
+            dvar = level.rules[name].dvar;
+            break;
+        case "game":
+            dvar = level.gametweaks[name].dvar;
+            break;
+        case "team":
+            dvar = level.teamtweaks[name].dvar;
+            break;
+        case "player":
+            dvar = level.playertweaks[name].dvar;
+            break;
+        case "class":
+            dvar = level.classtweaks[name].dvar;
+            break;
+        case "weapon":
+            dvar = level.weapontweaks[name].dvar;
+            break;
+        case "killstreak":
+            dvar = level.hardpointtweaks[name].dvar;
+            break;
+        case "hud":
+            dvar = level.hudtweaks[name].dvar;
+            break;
+        default:
+            dvar = undefined;
+            break;
+    }
+
+    setdvar( dvar, value );
+}
+
+settweakablelastvalue( category, name, value )
+{
+    switch ( category )
+    {
+        case "rule":
+            level.rules[name].lastvalue = value;
+            break;
+        case "game":
+            level.gametweaks[name].lastvalue = value;
+            break;
+        case "team":
+            level.teamtweaks[name].lastvalue = value;
+            break;
+        case "player":
+            level.playertweaks[name].lastvalue = value;
+            break;
+        case "class":
+            level.classtweaks[name].lastvalue = value;
+            break;
+        case "weapon":
+            level.weapontweaks[name].lastvalue = value;
+            break;
+        case "killstreak":
+            level.hardpointtweaks[name].lastvalue = value;
+            break;
+        case "hud":
+            level.hudtweaks[name].lastvalue = value;
+            break;
+        default:
+            break;
+    }
+}
+
+registertweakable( category, name, dvar, value )
+{
+    if ( isstring( value ) )
+    {
+        if ( getdvar( dvar ) == "" )
+            setdvar( dvar, value );
+        else
+            value = getdvar( dvar );
+    }
+    else if ( getdvar( dvar ) == "" )
+        setdvar( dvar, value );
+    else
+        value = getdvarint( dvar );
+
+    switch ( category )
+    {
+        case "rule":
+            if ( !isdefined( level.rules[name] ) )
+                level.rules[name] = spawnstruct();
+
+            level.rules[name].value = value;
+            level.rules[name].lastvalue = value;
+            level.rules[name].dvar = dvar;
+            break;
+        case "game":
+            if ( !isdefined( level.gametweaks[name] ) )
+                level.gametweaks[name] = spawnstruct();
+
+            level.gametweaks[name].value = value;
+            level.gametweaks[name].lastvalue = value;
+            level.gametweaks[name].dvar = dvar;
+            break;
+        case "team":
+            if ( !isdefined( level.teamtweaks[name] ) )
+                level.teamtweaks[name] = spawnstruct();
+
+            level.teamtweaks[name].value = value;
+            level.teamtweaks[name].lastvalue = value;
+            level.teamtweaks[name].dvar = dvar;
+            break;
+        case "player":
+            if ( !isdefined( level.playertweaks[name] ) )
+                level.playertweaks[name] = spawnstruct();
+
+            level.playertweaks[name].value = value;
+            level.playertweaks[name].lastvalue = value;
+            level.playertweaks[name].dvar = dvar;
+            break;
+        case "class":
+            if ( !isdefined( level.classtweaks[name] ) )
+                level.classtweaks[name] = spawnstruct();
+
+            level.classtweaks[name].value = value;
+            level.classtweaks[name].lastvalue = value;
+            level.classtweaks[name].dvar = dvar;
+            break;
+        case "weapon":
+            if ( !isdefined( level.weapontweaks[name] ) )
+                level.weapontweaks[name] = spawnstruct();
+
+            level.weapontweaks[name].value = value;
+            level.weapontweaks[name].lastvalue = value;
+            level.weapontweaks[name].dvar = dvar;
+            break;
+        case "killstreak":
+            if ( !isdefined( level.hardpointtweaks[name] ) )
+                level.hardpointtweaks[name] = spawnstruct();
+
+            level.hardpointtweaks[name].value = value;
+            level.hardpointtweaks[name].lastvalue = value;
+            level.hardpointtweaks[name].dvar = dvar;
+            break;
+        case "hud":
+            if ( !isdefined( level.hudtweaks[name] ) )
+                level.hudtweaks[name] = spawnstruct();
+
+            level.hudtweaks[name].value = value;
+            level.hudtweaks[name].lastvalue = value;
+            level.hudtweaks[name].dvar = dvar;
+            break;
+    }
+}
+
+init()
+{
+    level.clienttweakables = [];
+    level.tweakablesinitialized = 1;
+    level.rules = [];
+    level.gametweaks = [];
+    level.teamtweaks = [];
+    level.playertweaks = [];
+    level.classtweaks = [];
+    level.weapontweaks = [];
+    level.hardpointtweaks = [];
+    level.hudtweaks = [];
+    registertweakable( "game", "arcadescoring", "scr_game_arcadescoring", 0 );
+    registertweakable( "game", "difficulty", "scr_game_difficulty", 1 );
+    registertweakable( "game", "pinups", "scr_game_pinups", 0 );
+    registertweakable( "team", "teamkillerplaylistbanquantum", "scr_team_teamkillerplaylistbanquantum", 0 );
+    registertweakable( "team", "teamkillerplaylistbanpenalty", "scr_team_teamkillerplaylistbanpenalty", 0 );
+    registertweakable( "player", "allowrevive", "scr_player_allowrevive", 1 );
+    registertweakable( "weapon", "allowfrag", "scr_weapon_allowfrags", 1 );
+    registertweakable( "weapon", "allowsmoke", "scr_weapon_allowsmoke", 1 );
+    registertweakable( "weapon", "allowflash", "scr_weapon_allowflash", 1 );
+    registertweakable( "weapon", "allowc4", "scr_weapon_allowc4", 1 );
+    registertweakable( "weapon", "allowsatchel", "scr_weapon_allowsatchel", 1 );
+    registertweakable( "weapon", "allowbetty", "scr_weapon_allowbetty", 1 );
+    registertweakable( "weapon", "allowrpgs", "scr_weapon_allowrpgs", 1 );
+    registertweakable( "weapon", "allowmines", "scr_weapon_allowmines", 1 );
+    registertweakable( "hud", "showobjicons", "ui_hud_showobjicons", 1 );
+    setclienttweakable( "hud", "showobjicons" );
+    registertweakable( "killstreak", "allowradar", "scr_hardpoint_allowradar", 1 );
+    registertweakable( "killstreak", "allowradardirection", "scr_hardpoint_allowradardirection", 1 );
+    registertweakable( "killstreak", "allowcounteruav", "scr_hardpoint_allowcounteruav", 1 );
+    registertweakable( "killstreak", "allowdogs", "scr_hardpoint_allowdogs", 1 );
+    registertweakable( "killstreak", "allowhelicopter_comlink", "scr_hardpoint_allowhelicopter_comlink", 1 );
+    registertweakable( "killstreak", "allowrcbomb", "scr_hardpoint_allowrcbomb", 1 );
+    registertweakable( "killstreak", "allowauto_turret", "scr_hardpoint_allowauto_turret", 1 );
+    level thread updateuitweakables();
+}
+
+setclienttweakable( category, name )
+{
+    level.clienttweakables[level.clienttweakables.size] = name;
+}
+
+updateuitweakables()
+{
+    for (;;)
+    {
+        for ( index = 0; index < level.clienttweakables.size; index++ )
+        {
+            clienttweakable = level.clienttweakables[index];
+            curvalue = gettweakabledvarvalue( "hud", clienttweakable );
+            lastvalue = gettweakablelastvalue( "hud", clienttweakable );
+
+            if ( curvalue != lastvalue )
+            {
+                updateserverdvar( gettweakabledvar( "hud", clienttweakable ), curvalue );
+                settweakablelastvalue( "hud", clienttweakable, curvalue );
+            }
+        }
+
+        wait 1.0;
+    }
+}
+
+updateserverdvar( dvar, value )
+{
+    makedvarserverinfo( dvar, value );
+}

ZM/Core/maps/mp/gametypes_zm/_weapon_utils.gsc

@@ -0,0 +1,111 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+
+isgrenadelauncherweapon( weapon )
+{
+    if ( getsubstr( weapon, 0, 3 ) == "gl_" )
+        return true;
+
+    switch ( weapon )
+    {
+        case "xm25_mp":
+        case "china_lake_mp":
+            return true;
+        default:
+            return false;
+    }
+}
+
+isdumbrocketlauncherweapon( weapon )
+{
+    switch ( weapon )
+    {
+        case "rpg_mp":
+        case "m220_tow_mp":
+            return true;
+        default:
+            return false;
+    }
+}
+
+isguidedrocketlauncherweapon( weapon )
+{
+    switch ( weapon )
+    {
+        case "smaw_mp":
+        case "m72_law_mp":
+        case "m202_flash_mp":
+        case "javelin_mp":
+        case "fhj18_mp":
+            return true;
+        default:
+            return false;
+    }
+}
+
+isrocketlauncherweapon( weapon )
+{
+    if ( isdumbrocketlauncherweapon( weapon ) )
+        return true;
+
+    if ( isguidedrocketlauncherweapon( weapon ) )
+        return true;
+
+    return false;
+}
+
+islauncherweapon( weapon )
+{
+    if ( isrocketlauncherweapon( weapon ) )
+        return true;
+
+    if ( isgrenadelauncherweapon( weapon ) )
+        return true;
+
+    return false;
+}
+
+isreducedteamkillweapon( weapon )
+{
+    switch ( weapon )
+    {
+        case "planemortar_mp":
+            return true;
+        default:
+            return false;
+    }
+}
+
+ishackweapon( weapon )
+{
+    return 0;
+}
+
+ispistol( weapon )
+{
+    return isdefined( level.side_arm_array[weapon] );
+}
+
+isflashorstunweapon( weapon )
+{
+    if ( isdefined( weapon ) )
+    {
+        switch ( weapon )
+        {
+            case "proximity_grenade_mp":
+            case "proximity_grenade_aoe_mp":
+            case "flash_grenade_mp":
+            case "concussion_grenade_mp":
+                return true;
+        }
+    }
+
+    return false;
+}
+
+isflashorstundamage( weapon, meansofdeath )
+{
+    return isflashorstunweapon( weapon ) && ( meansofdeath == "MOD_GRENADE_SPLASH" || meansofdeath == "MOD_GAS" );
+}

ZM/Core/maps/mp/gametypes_zm/zclassic.gsc

@@ -0,0 +1,31 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\_utility;
+#include maps\mp\gametypes_zm\_hud_util;
+#include common_scripts\utility;
+#include maps\mp\gametypes_zm\_zm_gametype;
+#include maps\mp\zombies\_zm_stats;
+
+main()
+{
+    maps\mp\gametypes_zm\_zm_gametype::main();
+    level.onprecachegametype = ::onprecachegametype;
+    level.onstartgametype = ::onstartgametype;
+    level._game_module_custom_spawn_init_func = maps\mp\gametypes_zm\_zm_gametype::custom_spawn_init_func;
+    level._game_module_stat_update_func = maps\mp\zombies\_zm_stats::survival_classic_custom_stat_update;
+    maps\mp\gametypes_zm\_zm_gametype::post_gametype_main( "zclassic" );
+}
+
+onprecachegametype()
+{
+    level.playersuicideallowed = 1;
+    level.canplayersuicide = ::canplayersuicide;
+    level.suicide_weapon = "death_self_zm";
+    precacheitem( "death_self_zm" );
+    maps\mp\gametypes_zm\_zm_gametype::rungametypeprecache( "zclassic" );
+}
+
+onstartgametype()
+{
+    maps\mp\gametypes_zm\_zm_gametype::rungametypemain( "zclassic", maps\mp\gametypes_zm\_zm_gametype::zclassic_main );
+}

ZM/Core/maps/mp/zombies/_load.gsc

@@ -0,0 +1,478 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\_script_gen;
+#include maps\mp\_interactive_objects;
+#include maps\mp\_audio;
+#include maps\mp\_busing;
+#include maps\mp\_music;
+#include maps\mp\_fxanim;
+#include maps\mp\_serverfaceanim_mp;
+#include maps\mp\_art;
+#include maps\mp\_createfx;
+#include maps\mp\_global_fx;
+#include maps\mp\_demo;
+#include maps\mp\zombies\_load;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\traverse\shared;
+#include maps\mp\gametypes_zm\_spawnlogic;
+
+main( bscriptgened, bcsvgened, bsgenabled )
+{
+    if ( !isdefined( level.script_gen_dump_reasons ) )
+        level.script_gen_dump_reasons = [];
+
+    if ( !isdefined( bsgenabled ) )
+        level.script_gen_dump_reasons[level.script_gen_dump_reasons.size] = "First run";
+
+    if ( !isdefined( bcsvgened ) )
+        bcsvgened = 0;
+
+    level.bcsvgened = bcsvgened;
+
+    if ( !isdefined( bscriptgened ) )
+        bscriptgened = 0;
+    else
+        bscriptgened = 1;
+
+    level.bscriptgened = bscriptgened;
+    level._loadstarted = 1;
+    struct_class_init();
+    level.clientscripts = getdvar( "cg_usingClientScripts" ) != "";
+    level._client_exploders = [];
+    level._client_exploder_ids = [];
+
+    if ( !isdefined( level.flag ) )
+    {
+        level.flag = [];
+        level.flags_lock = [];
+    }
+
+    if ( !isdefined( level.timeofday ) )
+        level.timeofday = "day";
+
+    flag_init( "scriptgen_done" );
+    level.script_gen_dump_reasons = [];
+
+    if ( !isdefined( level.script_gen_dump ) )
+    {
+        level.script_gen_dump = [];
+        level.script_gen_dump_reasons[0] = "First run";
+    }
+
+    if ( !isdefined( level.script_gen_dump2 ) )
+        level.script_gen_dump2 = [];
+
+    if ( isdefined( level.createfxent ) && isdefined( level.script ) )
+        script_gen_dump_addline( "maps\\mp\\createfx\\" + level.script + "_fx::main();", level.script + "_fx" );
+
+    if ( isdefined( level.script_gen_dump_preload ) )
+    {
+        for ( i = 0; i < level.script_gen_dump_preload.size; i++ )
+            script_gen_dump_addline( level.script_gen_dump_preload[i].string, level.script_gen_dump_preload[i].signature );
+    }
+
+    if ( getdvar( "scr_RequiredMapAspectratio" ) == "" )
+        setdvar( "scr_RequiredMapAspectratio", "1" );
+
+    setdvar( "r_waterFogTest", 0 );
+    precacherumble( "reload_small" );
+    precacherumble( "reload_medium" );
+    precacherumble( "reload_large" );
+    precacherumble( "reload_clipin" );
+    precacherumble( "reload_clipout" );
+    precacherumble( "reload_rechamber" );
+    precacherumble( "pullout_small" );
+    precacherumble( "buzz_high" );
+    precacherumble( "riotshield_impact" );
+    registerclientsys( "levelNotify" );
+    level.aitriggerspawnflags = getaitriggerflags();
+    level.vehicletriggerspawnflags = getvehicletriggerflags();
+    level.physicstracemaskphysics = 1;
+    level.physicstracemaskvehicle = 2;
+    level.physicstracemaskwater = 4;
+    level.physicstracemaskclip = 8;
+    level.physicstracecontentsvehicleclip = 16;
+    level.createfx_enabled = getdvar( "createfx" ) != "";
+    level thread start_intro_screen_zm();
+    thread maps\mp\_interactive_objects::init();
+    maps\mp\_audio::init();
+    thread maps\mp\_busing::businit();
+    thread maps\mp\_music::music_init();
+    thread maps\mp\_fxanim::init();
+    thread maps\mp\_serverfaceanim_mp::init();
+
+    if ( level.createfx_enabled )
+        setinitialplayersconnected();
+
+    visionsetnight( "default_night" );
+    setup_traversals();
+    maps\mp\_art::main();
+    setupexploders();
+    parse_structs();
+    thread footsteps();
+/#
+    level thread level_notify_listener();
+    level thread client_notify_listener();
+#/
+    thread maps\mp\_createfx::fx_init();
+
+    if ( level.createfx_enabled )
+    {
+        calculate_map_center();
+        maps\mp\_createfx::createfx();
+    }
+
+    if ( getdvar( "r_reflectionProbeGenerate" ) == "1" )
+    {
+        maps\mp\_global_fx::main();
+
+        level waittill( "eternity" );
+    }
+
+    thread maps\mp\_global_fx::main();
+    maps\mp\_demo::init();
+
+    for ( p = 0; p < 6; p++ )
+    {
+        switch ( p )
+        {
+            case 0:
+                triggertype = "trigger_multiple";
+                break;
+            case 1:
+                triggertype = "trigger_once";
+                break;
+            case 2:
+                triggertype = "trigger_use";
+                break;
+            case 3:
+                triggertype = "trigger_radius";
+                break;
+            case 4:
+                triggertype = "trigger_lookat";
+                break;
+            default:
+                assert( p == 5 );
+                triggertype = "trigger_damage";
+                break;
+        }
+
+        triggers = getentarray( triggertype, "classname" );
+
+        for ( i = 0; i < triggers.size; i++ )
+        {
+            if ( isdefined( triggers[i].script_prefab_exploder ) )
+                triggers[i].script_exploder = triggers[i].script_prefab_exploder;
+
+            if ( isdefined( triggers[i].script_exploder ) )
+                level thread maps\mp\zombies\_load::exploder_load( triggers[i] );
+        }
+    }
+}
+
+level_notify_listener()
+{
+    while ( true )
+    {
+        val = getdvar( "level_notify" );
+
+        if ( val != "" )
+        {
+            level notify( val );
+            setdvar( "level_notify", "" );
+        }
+
+        wait 0.2;
+    }
+}
+
+client_notify_listener()
+{
+    while ( true )
+    {
+        val = getdvar( "client_notify" );
+
+        if ( val != "" )
+        {
+            clientnotify( val );
+            setdvar( "client_notify", "" );
+        }
+
+        wait 0.2;
+    }
+}
+
+footsteps()
+{
+    if ( is_true( level.fx_exclude_footsteps ) )
+        return;
+
+    maps\mp\animscripts\utility::setfootstepeffect( "asphalt", loadfx( "bio/player/fx_footstep_dust" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "brick", loadfx( "bio/player/fx_footstep_dust" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "carpet", loadfx( "bio/player/fx_footstep_dust" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "cloth", loadfx( "bio/player/fx_footstep_dust" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "concrete", loadfx( "bio/player/fx_footstep_dust" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "dirt", loadfx( "bio/player/fx_footstep_sand" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "foliage", loadfx( "bio/player/fx_footstep_sand" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "gravel", loadfx( "bio/player/fx_footstep_dust" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "grass", loadfx( "bio/player/fx_footstep_dust" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "metal", loadfx( "bio/player/fx_footstep_dust" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "mud", loadfx( "bio/player/fx_footstep_mud" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "paper", loadfx( "bio/player/fx_footstep_dust" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "plaster", loadfx( "bio/player/fx_footstep_dust" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "rock", loadfx( "bio/player/fx_footstep_dust" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "sand", loadfx( "bio/player/fx_footstep_sand" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "water", loadfx( "bio/player/fx_footstep_water" ) );
+    maps\mp\animscripts\utility::setfootstepeffect( "wood", loadfx( "bio/player/fx_footstep_dust" ) );
+}
+
+parse_structs()
+{
+    for ( i = 0; i < level.struct.size; i++ )
+    {
+        if ( isdefined( level.struct[i].targetname ) )
+        {
+            if ( level.struct[i].targetname == "flak_fire_fx" )
+            {
+                level._effect["flak20_fire_fx"] = loadfx( "weapon/tracer/fx_tracer_flak_single_noExp" );
+                level._effect["flak38_fire_fx"] = loadfx( "weapon/tracer/fx_tracer_quad_20mm_Flak38_noExp" );
+                level._effect["flak_cloudflash_night"] = loadfx( "weapon/flak/fx_flak_cloudflash_night" );
+                level._effect["flak_burst_single"] = loadfx( "weapon/flak/fx_flak_single_day_dist" );
+            }
+
+            if ( level.struct[i].targetname == "fake_fire_fx" )
+                level._effect["distant_muzzleflash"] = loadfx( "weapon/muzzleflashes/heavy" );
+
+            if ( level.struct[i].targetname == "spotlight_fx" )
+                level._effect["spotlight_beam"] = loadfx( "env/light/fx_ray_spotlight_md" );
+        }
+    }
+}
+
+exploder_load( trigger )
+{
+    level endon( "killexplodertridgers" + trigger.script_exploder );
+
+    trigger waittill( "trigger" );
+
+    if ( isdefined( trigger.script_chance ) && randomfloat( 1 ) > trigger.script_chance )
+    {
+        if ( isdefined( trigger.script_delay ) )
+            wait( trigger.script_delay );
+        else
+            wait 4;
+
+        level thread exploder_load( trigger );
+        return;
+    }
+
+    maps\mp\_utility::exploder( trigger.script_exploder );
+    level notify( "killexplodertridgers" + trigger.script_exploder );
+}
+
+setupexploders()
+{
+    ents = getentarray( "script_brushmodel", "classname" );
+    smodels = getentarray( "script_model", "classname" );
+
+    for ( i = 0; i < smodels.size; i++ )
+        ents[ents.size] = smodels[i];
+
+    for ( i = 0; i < ents.size; i++ )
+    {
+        if ( isdefined( ents[i].script_prefab_exploder ) )
+            ents[i].script_exploder = ents[i].script_prefab_exploder;
+
+        if ( isdefined( ents[i].script_exploder ) )
+        {
+            if ( ents[i].model == "fx" && ( !isdefined( ents[i].targetname ) || ents[i].targetname != "exploderchunk" ) )
+            {
+                ents[i] hide();
+                continue;
+            }
+
+            if ( isdefined( ents[i].targetname ) && ents[i].targetname == "exploder" )
+            {
+                ents[i] hide();
+                ents[i] notsolid();
+                continue;
+            }
+
+            if ( isdefined( ents[i].targetname ) && ents[i].targetname == "exploderchunk" )
+            {
+                ents[i] hide();
+                ents[i] notsolid();
+            }
+        }
+    }
+
+    script_exploders = [];
+    potentialexploders = getentarray( "script_brushmodel", "classname" );
+
+    for ( i = 0; i < potentialexploders.size; i++ )
+    {
+        if ( isdefined( potentialexploders[i].script_prefab_exploder ) )
+            potentialexploders[i].script_exploder = potentialexploders[i].script_prefab_exploder;
+
+        if ( isdefined( potentialexploders[i].script_exploder ) )
+            script_exploders[script_exploders.size] = potentialexploders[i];
+    }
+
+    potentialexploders = getentarray( "script_model", "classname" );
+
+    for ( i = 0; i < potentialexploders.size; i++ )
+    {
+        if ( isdefined( potentialexploders[i].script_prefab_exploder ) )
+            potentialexploders[i].script_exploder = potentialexploders[i].script_prefab_exploder;
+
+        if ( isdefined( potentialexploders[i].script_exploder ) )
+            script_exploders[script_exploders.size] = potentialexploders[i];
+    }
+
+    potentialexploders = getentarray( "item_health", "classname" );
+
+    for ( i = 0; i < potentialexploders.size; i++ )
+    {
+        if ( isdefined( potentialexploders[i].script_prefab_exploder ) )
+            potentialexploders[i].script_exploder = potentialexploders[i].script_prefab_exploder;
+
+        if ( isdefined( potentialexploders[i].script_exploder ) )
+            script_exploders[script_exploders.size] = potentialexploders[i];
+    }
+
+    if ( !isdefined( level.createfxent ) )
+        level.createfxent = [];
+
+    acceptabletargetnames = [];
+    acceptabletargetnames["exploderchunk visible"] = 1;
+    acceptabletargetnames["exploderchunk"] = 1;
+    acceptabletargetnames["exploder"] = 1;
+
+    for ( i = 0; i < script_exploders.size; i++ )
+    {
+        exploder = script_exploders[i];
+        ent = createexploder( exploder.script_fxid );
+        ent.v = [];
+        ent.v["origin"] = exploder.origin;
+        ent.v["angles"] = exploder.angles;
+        ent.v["delay"] = exploder.script_delay;
+        ent.v["firefx"] = exploder.script_firefx;
+        ent.v["firefxdelay"] = exploder.script_firefxdelay;
+        ent.v["firefxsound"] = exploder.script_firefxsound;
+        ent.v["firefxtimeout"] = exploder.script_firefxtimeout;
+        ent.v["earthquake"] = exploder.script_earthquake;
+        ent.v["damage"] = exploder.script_damage;
+        ent.v["damage_radius"] = exploder.script_radius;
+        ent.v["soundalias"] = exploder.script_soundalias;
+        ent.v["repeat"] = exploder.script_repeat;
+        ent.v["delay_min"] = exploder.script_delay_min;
+        ent.v["delay_max"] = exploder.script_delay_max;
+        ent.v["target"] = exploder.target;
+        ent.v["ender"] = exploder.script_ender;
+        ent.v["type"] = "exploder";
+
+        if ( !isdefined( exploder.script_fxid ) )
+            ent.v["fxid"] = "No FX";
+        else
+            ent.v["fxid"] = exploder.script_fxid;
+
+        ent.v["exploder"] = exploder.script_exploder;
+        assert( isdefined( exploder.script_exploder ), "Exploder at origin " + exploder.origin + " has no script_exploder" );
+
+        if ( !isdefined( ent.v["delay"] ) )
+            ent.v["delay"] = 0;
+
+        if ( isdefined( exploder.target ) )
+        {
+            org = getent( ent.v["target"], "targetname" ).origin;
+            ent.v["angles"] = vectortoangles( org - ent.v["origin"] );
+        }
+
+        if ( exploder.classname == "script_brushmodel" || isdefined( exploder.model ) )
+        {
+            ent.model = exploder;
+            ent.model.disconnect_paths = exploder.script_disconnectpaths;
+        }
+
+        if ( isdefined( exploder.targetname ) && isdefined( acceptabletargetnames[exploder.targetname] ) )
+            ent.v["exploder_type"] = exploder.targetname;
+        else
+            ent.v["exploder_type"] = "normal";
+
+        ent maps\mp\_createfx::post_entity_creation_function();
+    }
+
+    level.createfxexploders = [];
+
+    for ( i = 0; i < level.createfxent.size; i++ )
+    {
+        ent = level.createfxent[i];
+
+        if ( ent.v["type"] != "exploder" )
+            continue;
+
+        ent.v["exploder_id"] = getexploderid( ent );
+
+        if ( !isdefined( level.createfxexploders[ent.v["exploder"]] ) )
+            level.createfxexploders[ent.v["exploder"]] = [];
+
+        level.createfxexploders[ent.v["exploder"]][level.createfxexploders[ent.v["exploder"]].size] = ent;
+    }
+}
+
+setup_traversals()
+{
+    potential_traverse_nodes = getallnodes();
+
+    for ( i = 0; i < potential_traverse_nodes.size; i++ )
+    {
+        node = potential_traverse_nodes[i];
+
+        if ( node.type == "Begin" )
+            node maps\mp\animscripts\traverse\shared::init_traverse();
+    }
+}
+
+calculate_map_center()
+{
+    if ( !isdefined( level.mapcenter ) )
+    {
+        level.nodesmins = ( 0, 0, 0 );
+        level.nodesmaxs = ( 0, 0, 0 );
+        level.mapcenter = maps\mp\gametypes_zm\_spawnlogic::findboxcenter( level.nodesmins, level.nodesmaxs );
+/#
+        println( "map center: ", level.mapcenter );
+#/
+        setmapcenter( level.mapcenter );
+    }
+}
+
+start_intro_screen_zm()
+{
+    if ( level.createfx_enabled )
+        return;
+
+    if ( !isdefined( level.introscreen ) )
+    {
+        level.introscreen = newhudelem();
+        level.introscreen.x = 0;
+        level.introscreen.y = 0;
+        level.introscreen.horzalign = "fullscreen";
+        level.introscreen.vertalign = "fullscreen";
+        level.introscreen.foreground = 0;
+        level.introscreen setshader( "black", 640, 480 );
+        level.introscreen.immunetodemogamehudsettings = 1;
+        level.introscreen.immunetodemofreecamera = 1;
+        wait 0.05;
+    }
+
+    level.introscreen.alpha = 1;
+    players = get_players();
+
+    for ( i = 0; i < players.size; i++ )
+        players[i] freezecontrols( 1 );
+
+    wait 1;
+}

ZM/Core/maps/mp/zombies/_zm_ai_basic.gsc

@@ -0,0 +1,554 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\zombies\_zm_utility;
+#include maps\mp\zombies\_zm_spawner;
+#include maps\mp\zombies\_zm_ai_basic;
+#include maps\mp\animscripts\zm_run;
+#include maps\mp\animscripts\zm_shared;
+
+find_flesh()
+{
+    self endon( "death" );
+    level endon( "intermission" );
+    self endon( "stop_find_flesh" );
+
+    if ( level.intermission )
+        return;
+
+    self.ai_state = "find_flesh";
+    self.helitarget = 1;
+    self.ignoreme = 0;
+    self.nododgemove = 1;
+    self.ignore_player = [];
+    self maps\mp\zombies\_zm_spawner::zombie_history( "find flesh -> start" );
+    self.goalradius = 32;
+
+    if ( isdefined( self.custom_goalradius_override ) )
+        self.goalradius = self.custom_goalradius_override;
+
+    while ( true )
+    {
+        zombie_poi = undefined;
+
+        if ( isdefined( level.zombietheaterteleporterseeklogicfunc ) )
+            self [[ level.zombietheaterteleporterseeklogicfunc ]]();
+
+        if ( isdefined( level._poi_override ) )
+            zombie_poi = self [[ level._poi_override ]]();
+
+        if ( !isdefined( zombie_poi ) )
+            zombie_poi = self get_zombie_point_of_interest( self.origin );
+
+        players = get_players();
+
+        if ( !isdefined( self.ignore_player ) || players.size == 1 )
+            self.ignore_player = [];
+        else if ( !isdefined( level._should_skip_ignore_player_logic ) || ![[ level._should_skip_ignore_player_logic ]]() )
+        {
+            i = 0;
+
+            while ( i < self.ignore_player.size )
+            {
+                if ( isdefined( self.ignore_player[i] ) && isdefined( self.ignore_player[i].ignore_counter ) && self.ignore_player[i].ignore_counter > 3 )
+                {
+                    self.ignore_player[i].ignore_counter = 0;
+                    self.ignore_player = arrayremovevalue( self.ignore_player, self.ignore_player[i] );
+
+                    if ( !isdefined( self.ignore_player ) )
+                        self.ignore_player = [];
+
+                    i = 0;
+                    continue;
+                }
+
+                i++;
+            }
+        }
+
+        player = get_closest_valid_player( self.origin, self.ignore_player );
+
+        if ( !isdefined( player ) && !isdefined( zombie_poi ) )
+        {
+            self maps\mp\zombies\_zm_spawner::zombie_history( "find flesh -> can't find player, continue" );
+
+            if ( isdefined( self.ignore_player ) )
+            {
+                if ( isdefined( level._should_skip_ignore_player_logic ) && [[ level._should_skip_ignore_player_logic ]]() )
+                {
+                    wait 1;
+                    continue;
+                }
+
+                self.ignore_player = [];
+            }
+
+            wait 1;
+            continue;
+        }
+
+        if ( !isdefined( level.check_for_alternate_poi ) || ![[ level.check_for_alternate_poi ]]() )
+        {
+            self.enemyoverride = zombie_poi;
+            self.favoriteenemy = player;
+        }
+
+        self thread zombie_pathing();
+
+        if ( players.size > 1 )
+        {
+            for ( i = 0; i < self.ignore_player.size; i++ )
+            {
+                if ( isdefined( self.ignore_player[i] ) )
+                {
+                    if ( !isdefined( self.ignore_player[i].ignore_counter ) )
+                    {
+                        self.ignore_player[i].ignore_counter = 0;
+                        continue;
+                    }
+
+                    self.ignore_player[i].ignore_counter += 1;
+                }
+            }
+        }
+
+        self thread attractors_generated_listener();
+
+        if ( isdefined( level._zombie_path_timer_override ) )
+            self.zombie_path_timer = [[ level._zombie_path_timer_override ]]();
+        else
+            self.zombie_path_timer = gettime() + randomfloatrange( 1, 3 ) * 1000;
+
+        while ( gettime() < self.zombie_path_timer )
+            wait 0.1;
+
+        self notify( "path_timer_done" );
+        self maps\mp\zombies\_zm_spawner::zombie_history( "find flesh -> bottom of loop" );
+        debug_print( "Zombie is re-acquiring enemy, ending breadcrumb search" );
+        self notify( "zombie_acquire_enemy" );
+    }
+}
+
+init_inert_zombies()
+{
+    level init_inert_substates();
+}
+
+init_inert_substates()
+{
+    level.inert_substates = [];
+    level.inert_substates[level.inert_substates.size] = "inert1";
+    level.inert_substates[level.inert_substates.size] = "inert2";
+    level.inert_substates[level.inert_substates.size] = "inert3";
+    level.inert_substates[level.inert_substates.size] = "inert4";
+    level.inert_substates[level.inert_substates.size] = "inert5";
+    level.inert_substates[level.inert_substates.size] = "inert6";
+    level.inert_substates[level.inert_substates.size] = "inert7";
+    level.inert_substates = array_randomize( level.inert_substates );
+    level.inert_substate_index = 0;
+    level.inert_trans_walk = [];
+    level.inert_trans_walk[level.inert_trans_walk.size] = "inert_2_walk_1";
+    level.inert_trans_walk[level.inert_trans_walk.size] = "inert_2_walk_2";
+    level.inert_trans_walk[level.inert_trans_walk.size] = "inert_2_walk_3";
+    level.inert_trans_walk[level.inert_trans_walk.size] = "inert_2_walk_4";
+    level.inert_trans_run = [];
+    level.inert_trans_run[level.inert_trans_run.size] = "inert_2_run_1";
+    level.inert_trans_run[level.inert_trans_run.size] = "inert_2_run_2";
+    level.inert_trans_sprint = [];
+    level.inert_trans_sprint[level.inert_trans_sprint.size] = "inert_2_sprint_1";
+    level.inert_trans_sprint[level.inert_trans_sprint.size] = "inert_2_sprint_2";
+    level.inert_crawl_substates = [];
+    level.inert_crawl_substates[level.inert_crawl_substates.size] = "inert1";
+    level.inert_crawl_substates[level.inert_crawl_substates.size] = "inert2";
+    level.inert_crawl_substates[level.inert_crawl_substates.size] = "inert3";
+    level.inert_crawl_substates[level.inert_crawl_substates.size] = "inert4";
+    level.inert_crawl_substates[level.inert_crawl_substates.size] = "inert5";
+    level.inert_crawl_substates[level.inert_crawl_substates.size] = "inert6";
+    level.inert_crawl_substates[level.inert_crawl_substates.size] = "inert7";
+    level.inert_crawl_trans_walk = [];
+    level.inert_crawl_trans_walk[level.inert_crawl_trans_walk.size] = "inert_2_walk_1";
+    level.inert_crawl_trans_run = [];
+    level.inert_crawl_trans_run[level.inert_crawl_trans_run.size] = "inert_2_run_1";
+    level.inert_crawl_trans_run[level.inert_crawl_trans_run.size] = "inert_2_run_2";
+    level.inert_crawl_trans_sprint = [];
+    level.inert_crawl_trans_sprint[level.inert_crawl_trans_sprint.size] = "inert_2_sprint_1";
+    level.inert_crawl_trans_sprint[level.inert_crawl_trans_sprint.size] = "inert_2_sprint_2";
+    level.inert_crawl_substates = array_randomize( level.inert_crawl_substates );
+    level.inert_crawl_substate_index = 0;
+}
+
+get_inert_substate()
+{
+    substate = level.inert_substates[level.inert_substate_index];
+    level.inert_substate_index++;
+
+    if ( level.inert_substate_index >= level.inert_substates.size )
+    {
+        level.inert_substates = array_randomize( level.inert_substates );
+        level.inert_substate_index = 0;
+    }
+
+    return substate;
+}
+
+get_inert_crawl_substate()
+{
+    substate = level.inert_crawl_substates[level.inert_crawl_substate_index];
+    level.inert_crawl_substate_index++;
+
+    if ( level.inert_crawl_substate_index >= level.inert_crawl_substates.size )
+    {
+        level.inert_crawl_substates = array_randomize( level.inert_crawl_substates );
+        level.inert_crawl_substate_index = 0;
+    }
+
+    return substate;
+}
+
+start_inert( in_place )
+{
+    self endon( "death" );
+
+    if ( isdefined( self.is_inert ) && self.is_inert )
+    {
+        self maps\mp\zombies\_zm_spawner::zombie_history( "is_inert already set " + gettime() );
+        return;
+    }
+
+    self.is_inert = 1;
+    self notify( "start_inert" );
+    self maps\mp\zombies\_zm_spawner::zombie_eye_glow_stop();
+    self maps\mp\zombies\_zm_spawner::zombie_history( "is_inert set " + gettime() );
+    self playsound( "zmb_zombie_go_inert" );
+
+    if ( isdefined( self.barricade_enter ) && self.barricade_enter )
+    {
+        while ( isdefined( self.barricade_enter ) && self.barricade_enter )
+            wait 0.1;
+    }
+    else if ( isdefined( self.ai_state ) && self.ai_state == "zombie_goto_entrance" )
+    {
+        self notify( "stop_zombie_goto_entrance" );
+        self maps\mp\zombies\_zm_spawner::reset_attack_spot();
+    }
+
+    if ( isdefined( self.completed_emerging_into_playable_area ) && self.completed_emerging_into_playable_area )
+    {
+        self notify( "stop_find_flesh" );
+        self notify( "zombie_acquire_enemy" );
+    }
+    else
+        in_place = 1;
+
+    if ( isdefined( self.in_the_ground ) && self.in_the_ground )
+    {
+        self waittill( "risen", find_flesh_struct_string );
+
+        if ( self maps\mp\zombies\_zm_spawner::should_skip_teardown( find_flesh_struct_string ) )
+        {
+            if ( !( isdefined( self.completed_emerging_into_playable_area ) && self.completed_emerging_into_playable_area ) )
+                self waittill( "completed_emerging_into_playable_area" );
+
+            self notify( "stop_find_flesh" );
+            self notify( "zombie_acquire_enemy" );
+        }
+    }
+
+    if ( isdefined( self.is_traversing ) && self.is_traversing )
+    {
+        while ( self isinscriptedstate() )
+            wait 0.1;
+    }
+
+    if ( isdefined( self.doing_equipment_attack ) && self.doing_equipment_attack )
+        self stopanimscripted();
+
+    if ( isdefined( self.inert_delay ) )
+    {
+        self [[ self.inert_delay ]]();
+        self maps\mp\zombies\_zm_spawner::zombie_history( "inert_delay done " + gettime() );
+    }
+
+    self inert_think( in_place );
+}
+
+inert_think( in_place )
+{
+    self endon( "death" );
+    self.ignoreall = 1;
+    self animmode( "normal" );
+
+    if ( self.has_legs )
+    {
+        if ( isdefined( in_place ) && in_place )
+        {
+            self setgoalpos( self.origin );
+
+            if ( randomint( 100 ) > 50 )
+            {
+                self maps\mp\zombies\_zm_spawner::zombie_history( "inert 1 " + gettime() );
+                self setanimstatefromasd( "zm_inert", "inert1" );
+            }
+            else
+            {
+                self maps\mp\zombies\_zm_spawner::zombie_history( "inert 2 " + gettime() );
+                self setanimstatefromasd( "zm_inert", "inert2" );
+            }
+
+            self.in_place = 1;
+        }
+        else
+        {
+            substate = get_inert_substate();
+
+            if ( isdefined( level.inert_substate_override ) )
+                substate = self [[ level.inert_substate_override ]]( substate );
+
+            self setanimstatefromasd( "zm_inert", substate );
+            self maps\mp\zombies\_zm_spawner::zombie_history( "zm_inert ASD " + gettime() );
+
+            if ( substate == "inert3" || substate == "inert4" || substate == "inert5" || substate == "inert6" )
+                self thread inert_watch_goal();
+            else
+                self.in_place = 1;
+        }
+    }
+    else
+    {
+        self setanimstatefromasd( "zm_inert_crawl", get_inert_crawl_substate() );
+        self maps\mp\zombies\_zm_spawner::zombie_history( "zm_inert_crawl ASD " + gettime() );
+    }
+
+    self thread inert_wakeup();
+
+    self waittill( "stop_zombie_inert" );
+
+    self maps\mp\zombies\_zm_spawner::zombie_history( "stop_zombie_inert " + gettime() );
+    self playsound( "zmb_zombie_end_inert" );
+    self inert_transition();
+    self maps\mp\zombies\_zm_spawner::zombie_history( "inert transition done" );
+
+    if ( isdefined( self.ai_state ) && self.ai_state == "zombie_goto_entrance" )
+        self thread maps\mp\zombies\_zm_spawner::zombie_goto_entrance( self.first_node );
+
+    if ( isdefined( self.inert_wakeup_override ) )
+        self [[ self.inert_wakeup_override ]]();
+    else if ( isdefined( self.completed_emerging_into_playable_area ) && self.completed_emerging_into_playable_area )
+    {
+        self.ignoreall = 0;
+
+        if ( isdefined( level.ignore_find_flesh ) && !self [[ level.ignore_find_flesh ]]() )
+            self thread maps\mp\zombies\_zm_ai_basic::find_flesh();
+    }
+
+    self.becoming_inert = undefined;
+    self.is_inert = undefined;
+    self.in_place = undefined;
+    self maps\mp\animscripts\zm_run::needsupdate();
+    self maps\mp\zombies\_zm_spawner::zombie_history( "is_inert cleared " + gettime() );
+}
+
+inert_watch_goal()
+{
+    self endon( "death" );
+    self endon( "stop_zombie_inert" );
+
+    while ( true )
+    {
+        self waittill( "goal" );
+
+        locs = array_randomize( level.enemy_dog_locations );
+
+        foreach ( loc in locs )
+        {
+            dist_sq = distancesquared( self.origin, loc.origin );
+
+            if ( dist_sq > 90000 )
+            {
+                self setgoalpos( loc.origin );
+                continue;
+            }
+        }
+
+        if ( locs.size > 0 )
+            self setgoalpos( locs[0].origin );
+    }
+}
+
+inert_wakeup()
+{
+    self endon( "death" );
+    self endon( "stop_zombie_inert" );
+    wait 0.1;
+    self thread inert_damage();
+    self thread inert_bump();
+
+    while ( true )
+    {
+        current_time = gettime();
+        players = get_players();
+
+        foreach ( player in players )
+        {
+            dist_sq = distancesquared( self.origin, player.origin );
+
+            if ( dist_sq < 4096 )
+            {
+                self stop_inert();
+                return;
+            }
+
+            if ( dist_sq < 360000 )
+            {
+                if ( player issprinting() )
+                {
+                    self stop_inert();
+                    return;
+                }
+            }
+
+            if ( dist_sq < 5760000 )
+            {
+                if ( current_time - player.lastfiretime < 100 )
+                {
+                    self stop_inert();
+                    return;
+                }
+            }
+        }
+
+        wait 0.1;
+    }
+}
+
+inert_bump()
+{
+    self endon( "death" );
+    self endon( "stop_zombie_inert" );
+
+    while ( true )
+    {
+        zombies = getaiarray( level.zombie_team );
+
+        foreach ( zombie in zombies )
+        {
+            if ( zombie == self )
+                continue;
+
+            if ( isdefined( zombie.is_inert ) && zombie.is_inert )
+                continue;
+
+            if ( isdefined( zombie.becoming_inert ) && zombie.becoming_inert )
+                continue;
+
+            dist_sq = distancesquared( self.origin, zombie.origin );
+
+            if ( dist_sq < 1296 )
+            {
+                self stop_inert();
+                return;
+            }
+        }
+
+        wait 0.2;
+    }
+}
+
+inert_damage()
+{
+    self endon( "death" );
+    self endon( "stop_zombie_inert" );
+
+    while ( true )
+    {
+        self waittill( "damage", amount, inflictor, direction, point, type, tagname, modelname, partname, weaponname, idflags );
+
+        if ( weaponname == "emp_grenade_zm" )
+            continue;
+
+        if ( isdefined( inflictor ) )
+        {
+            if ( isdefined( inflictor._trap_type ) && inflictor._trap_type == "fire" )
+                continue;
+        }
+    }
+
+    self stop_inert();
+}
+
+grenade_watcher( grenade )
+{
+    grenade waittill( "explode", grenade_origin );
+
+    zombies = get_array_of_closest( grenade_origin, get_round_enemy_array(), undefined, undefined, 2400 );
+
+    if ( !isdefined( zombies ) )
+        return;
+
+    foreach ( zombie in zombies )
+        zombie stop_inert();
+}
+
+stop_inert()
+{
+    self notify( "stop_zombie_inert" );
+}
+
+inert_transition()
+{
+    self endon( "death" );
+    self endon( "stop_zombie_inert_transition" );
+    trans_num = 4;
+    trans_set = level.inert_trans_walk;
+    animstate = "zm_inert_trans";
+
+    if ( !self.has_legs )
+    {
+        trans_num = 1;
+        trans_set = level.inert_crawl_trans_walk;
+        animstate = "zm_inert_crawl_trans";
+    }
+
+    if ( self.zombie_move_speed == "run" )
+    {
+        if ( self.has_legs )
+            trans_set = level.inert_trans_run;
+        else
+            trans_set = level.inert_crawl_trans_run;
+
+        trans_num = 2;
+    }
+    else if ( self.zombie_move_speed == "sprint" )
+    {
+        if ( self.has_legs )
+            trans_set = level.inert_trans_sprint;
+        else
+            trans_set = level.inert_crawl_trans_sprint;
+
+        trans_num = 2;
+    }
+
+    self thread inert_eye_glow();
+    self setanimstatefromasd( animstate, trans_set[randomint( trans_num )] );
+    self maps\mp\zombies\_zm_spawner::zombie_history( "inert_trans_anim " + gettime() );
+    maps\mp\animscripts\zm_shared::donotetracks( "inert_trans_anim" );
+}
+
+inert_eye_glow()
+{
+    self endon( "death" );
+
+    while ( true )
+    {
+        self waittill( "inert_trans_anim", note );
+
+        if ( note == "end" )
+            return;
+        else if ( note == "zmb_awaken" )
+        {
+            self maps\mp\zombies\_zm_spawner::zombie_eye_glow();
+            return;
+        }
+    }
+}

ZM/Core/maps/mp/zombies/_zm_ai_dogs.gsc

@@ -0,0 +1,732 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\zombies\_zm_utility;
+#include maps\mp\zombies\_zm_spawner;
+#include maps\mp\zombies\_zm_audio;
+#include maps\mp\zombies\_zm_powerups;
+#include maps\mp\zombies\_zm;
+#include maps\mp\zombies\_zm_score;
+#include maps\mp\zombies\_zm_stats;
+#include maps\mp\zombies\_zm_net;
+
+init()
+{
+    level.dogs_enabled = 1;
+    level.dog_rounds_enabled = 0;
+    level.dog_round_count = 1;
+    level.dog_spawners = [];
+    level.enemy_dog_spawns = [];
+    level.enemy_dog_locations = [];
+    flag_init( "dog_clips" );
+    precacherumble( "explosion_generic" );
+    precacheshellshock( "dog_bite" );
+
+    if ( getdvar( _hash_942939D4 ) == "" )
+        setdvar( "zombie_dog_animset", "zombie" );
+
+    if ( getdvar( _hash_CAA5B74F ) == "" )
+        setdvar( "scr_dog_health_walk_multiplier", "4.0" );
+
+    if ( getdvar( _hash_C7E63BA4 ) == "" )
+        setdvar( "scr_dog_run_distance", "500" );
+
+    level.melee_range_sav = getdvar( "ai_meleeRange" );
+    level.melee_width_sav = getdvar( "ai_meleeWidth" );
+    level.melee_height_sav = getdvar( "ai_meleeHeight" );
+    setdvar( "dog_MeleeDamage", "100" );
+    set_zombie_var( "dog_fire_trail_percent", 50 );
+    level._effect["lightning_dog_spawn"] = loadfx( "maps/zombie/fx_zombie_dog_lightning_buildup" );
+    level._effect["dog_eye_glow"] = loadfx( "maps/zombie/fx_zombie_dog_eyes" );
+    level._effect["dog_gib"] = loadfx( "maps/zombie/fx_zombie_dog_explosion" );
+    level._effect["dog_trail_fire"] = loadfx( "maps/zombie/fx_zombie_dog_fire_trail" );
+    level._effect["dog_trail_ash"] = loadfx( "maps/zombie/fx_zombie_dog_ash_trail" );
+    dog_spawner_init();
+    level thread dog_clip_monitor();
+}
+
+enable_dog_rounds()
+{
+    level.dog_rounds_enabled = 1;
+
+    if ( !isdefined( level.dog_round_track_override ) )
+        level.dog_round_track_override = ::dog_round_tracker;
+
+    level thread [[ level.dog_round_track_override ]]();
+}
+
+dog_spawner_init()
+{
+    level.dog_spawners = getentarray( "zombie_dog_spawner", "script_noteworthy" );
+    later_dogs = getentarray( "later_round_dog_spawners", "script_noteworthy" );
+    level.dog_spawners = arraycombine( level.dog_spawners, later_dogs, 1, 0 );
+
+    if ( level.dog_spawners.size == 0 )
+        return;
+
+    for ( i = 0; i < level.dog_spawners.size; i++ )
+    {
+        if ( maps\mp\zombies\_zm_spawner::is_spawner_targeted_by_blocker( level.dog_spawners[i] ) )
+        {
+            level.dog_spawners[i].is_enabled = 0;
+            continue;
+        }
+
+        level.dog_spawners[i].is_enabled = 1;
+        level.dog_spawners[i].script_forcespawn = 1;
+    }
+
+    assert( level.dog_spawners.size > 0 );
+    level.dog_health = 100;
+    array_thread( level.dog_spawners, ::add_spawn_function, ::dog_init );
+    level.enemy_dog_spawns = getentarray( "zombie_spawner_dog_init", "targetname" );
+}
+
+dog_round_spawning()
+{
+    level endon( "intermission" );
+    level.dog_targets = getplayers();
+
+    for ( i = 0; i < level.dog_targets.size; i++ )
+        level.dog_targets[i].hunted_by = 0;
+/#
+    level endon( "kill_round" );
+
+    if ( getdvarint( _hash_FA81816F ) == 2 || getdvarint( _hash_FA81816F ) >= 4 )
+        return;
+#/
+    if ( level.intermission )
+        return;
+
+    level.dog_intermission = 1;
+    level thread dog_round_aftermath();
+    players = get_players();
+    array_thread( players, ::play_dog_round );
+    wait 1;
+    playsoundatposition( "vox_zmba_event_dogstart_0", ( 0, 0, 0 ) );
+    wait 6;
+
+    if ( level.dog_round_count < 3 )
+        max = players.size * 6;
+    else
+        max = players.size * 8;
+/#
+    if ( getdvar( _hash_4077D7E0 ) != "" )
+        max = getdvarint( _hash_4077D7E0 );
+#/
+    level.zombie_total = max;
+    dog_health_increase();
+    count = 0;
+
+    while ( count < max )
+    {
+        for ( num_player_valid = get_number_of_valid_players(); get_current_zombie_count() >= num_player_valid * 2; num_player_valid = get_number_of_valid_players() )
+            wait 2;
+
+        players = get_players();
+        favorite_enemy = get_favorite_enemy();
+
+        if ( isdefined( level.dog_spawn_func ) )
+        {
+            spawn_loc = [[ level.dog_spawn_func ]]( level.dog_spawners, favorite_enemy );
+            ai = spawn_zombie( level.dog_spawners[0] );
+
+            if ( isdefined( ai ) )
+            {
+                ai.favoriteenemy = favorite_enemy;
+                spawn_loc thread dog_spawn_fx( ai, spawn_loc );
+                level.zombie_total--;
+                count++;
+            }
+        }
+        else
+        {
+            spawn_point = dog_spawn_factory_logic( level.enemy_dog_spawns, favorite_enemy );
+            ai = spawn_zombie( level.dog_spawners[0] );
+
+            if ( isdefined( ai ) )
+            {
+                ai.favoriteenemy = favorite_enemy;
+                spawn_point thread dog_spawn_fx( ai, spawn_point );
+                level.zombie_total--;
+                count++;
+                flag_set( "dog_clips" );
+            }
+        }
+
+        waiting_for_next_dog_spawn( count, max );
+    }
+}
+
+waiting_for_next_dog_spawn( count, max )
+{
+    default_wait = 1.5;
+
+    if ( level.dog_round_count == 1 )
+        default_wait = 3;
+    else if ( level.dog_round_count == 2 )
+        default_wait = 2.5;
+    else if ( level.dog_round_count == 3 )
+        default_wait = 2;
+    else
+        default_wait = 1.5;
+
+    default_wait -= count / max;
+    wait( default_wait );
+}
+
+dog_round_aftermath()
+{
+    level waittill( "last_dog_down" );
+
+    level thread maps\mp\zombies\_zm_audio::change_zombie_music( "dog_end" );
+    power_up_origin = level.last_dog_origin;
+
+    if ( isdefined( power_up_origin ) )
+        level thread maps\mp\zombies\_zm_powerups::specific_powerup_drop( "full_ammo", power_up_origin );
+
+    wait 2;
+    clientnotify( "dog_stop" );
+    wait 6;
+    level.dog_intermission = 0;
+}
+
+dog_spawn_fx( ai, ent )
+{
+    ai endon( "death" );
+    ai setfreecameralockonallowed( 0 );
+    playfx( level._effect["lightning_dog_spawn"], ent.origin );
+    playsoundatposition( "zmb_hellhound_prespawn", ent.origin );
+    wait 1.5;
+    playsoundatposition( "zmb_hellhound_bolt", ent.origin );
+    earthquake( 0.5, 0.75, ent.origin, 1000 );
+    playrumbleonposition( "explosion_generic", ent.origin );
+    playsoundatposition( "zmb_hellhound_spawn", ent.origin );
+    angle = vectortoangles( ai.favoriteenemy.origin - ent.origin );
+    angles = ( ai.angles[0], angle[1], ai.angles[2] );
+    ai forceteleport( ent.origin, angles );
+    assert( isdefined( ai ), "Ent isn't defined." );
+    assert( isalive( ai ), "Ent is dead." );
+    assert( ai.isdog, "Ent isn't a dog;" );
+    assert( is_magic_bullet_shield_enabled( ai ), "Ent doesn't have a magic bullet shield." );
+    ai zombie_setup_attack_properties_dog();
+    ai stop_magic_bullet_shield();
+    wait 0.1;
+    ai show();
+    ai setfreecameralockonallowed( 1 );
+    ai.ignoreme = 0;
+    ai notify( "visible" );
+}
+
+dog_spawn_sumpf_logic( dog_array, favorite_enemy )
+{
+    assert( dog_array.size > 0, "Dog Spawner array is empty." );
+    dog_array = array_randomize( dog_array );
+
+    for ( i = 0; i < dog_array.size; i++ )
+    {
+        if ( isdefined( level.old_dog_spawn ) && level.old_dog_spawn == dog_array[i] )
+            continue;
+
+        if ( distancesquared( dog_array[i].origin, favorite_enemy.origin ) > 160000 && distancesquared( dog_array[i].origin, favorite_enemy.origin ) < 640000 )
+        {
+            if ( distancesquared( ( 0, 0, dog_array[i].origin[2] ), ( 0, 0, favorite_enemy.origin[2] ) ) > 10000 )
+                continue;
+            else
+            {
+                level.old_dog_spawn = dog_array[i];
+                return dog_array[i];
+            }
+        }
+    }
+
+    return dog_array[0];
+}
+
+dog_spawn_factory_logic( dog_array, favorite_enemy )
+{
+    dog_locs = array_randomize( level.enemy_dog_locations );
+
+    for ( i = 0; i < dog_locs.size; i++ )
+    {
+        if ( isdefined( level.old_dog_spawn ) && level.old_dog_spawn == dog_locs[i] )
+            continue;
+
+        dist_squared = distancesquared( dog_locs[i].origin, favorite_enemy.origin );
+
+        if ( dist_squared > 160000 && dist_squared < 1000000 )
+        {
+            level.old_dog_spawn = dog_locs[i];
+            return dog_locs[i];
+        }
+    }
+
+    return dog_locs[0];
+}
+
+get_favorite_enemy()
+{
+    dog_targets = getplayers();
+    least_hunted = dog_targets[0];
+
+    for ( i = 0; i < dog_targets.size; i++ )
+    {
+        if ( !isdefined( dog_targets[i].hunted_by ) )
+            dog_targets[i].hunted_by = 0;
+
+        if ( !is_player_valid( dog_targets[i] ) )
+            continue;
+
+        if ( !is_player_valid( least_hunted ) )
+            least_hunted = dog_targets[i];
+
+        if ( dog_targets[i].hunted_by < least_hunted.hunted_by )
+            least_hunted = dog_targets[i];
+    }
+
+    least_hunted.hunted_by += 1;
+    return least_hunted;
+}
+
+dog_health_increase()
+{
+    players = getplayers();
+
+    if ( level.dog_round_count == 1 )
+        level.dog_health = 400;
+    else if ( level.dog_round_count == 2 )
+        level.dog_health = 900;
+    else if ( level.dog_round_count == 3 )
+        level.dog_health = 1300;
+    else if ( level.dog_round_count == 4 )
+        level.dog_health = 1600;
+
+    if ( level.dog_health > 1600 )
+        level.dog_health = 1600;
+}
+
+dog_round_tracker()
+{
+    level.dog_round_count = 1;
+    level.next_dog_round = level.round_number + randomintrange( 4, 7 );
+    old_spawn_func = level.round_spawn_func;
+    old_wait_func = level.round_wait_func;
+
+    while ( true )
+    {
+        level waittill( "between_round_over" );
+/#
+        if ( getdvarint( _hash_4077D7E0 ) > 0 )
+            level.next_dog_round = level.round_number;
+#/
+        if ( level.round_number == level.next_dog_round )
+        {
+            level.music_round_override = 1;
+            old_spawn_func = level.round_spawn_func;
+            old_wait_func = level.round_wait_func;
+            dog_round_start();
+            level.round_spawn_func = ::dog_round_spawning;
+            level.next_dog_round = level.round_number + randomintrange( 4, 6 );
+/#
+            get_players()[0] iprintln( "Next dog round: " + level.next_dog_round );
+#/
+        }
+        else if ( flag( "dog_round" ) )
+        {
+            dog_round_stop();
+            level.round_spawn_func = old_spawn_func;
+            level.round_wait_func = old_wait_func;
+            level.music_round_override = 0;
+            level.dog_round_count += 1;
+        }
+    }
+}
+
+dog_round_start()
+{
+    flag_set( "dog_round" );
+    flag_set( "dog_clips" );
+    level thread maps\mp\zombies\_zm_audio::change_zombie_music( "dog_start" );
+
+    if ( !isdefined( level.doground_nomusic ) )
+        level.doground_nomusic = 0;
+
+    level.doground_nomusic = 1;
+    level notify( "dog_round_starting" );
+    clientnotify( "dog_start" );
+
+    if ( isdefined( level.dog_melee_range ) )
+        setdvar( "ai_meleeRange", level.dog_melee_range );
+    else
+        setdvar( "ai_meleeRange", 100 );
+}
+
+dog_round_stop()
+{
+    flag_clear( "dog_round" );
+    flag_clear( "dog_clips" );
+
+    if ( !isdefined( level.doground_nomusic ) )
+        level.doground_nomusic = 0;
+
+    level.doground_nomusic = 0;
+    level notify( "dog_round_ending" );
+    clientnotify( "dog_stop" );
+    setdvar( "ai_meleeRange", level.melee_range_sav );
+    setdvar( "ai_meleeWidth", level.melee_width_sav );
+    setdvar( "ai_meleeHeight", level.melee_height_sav );
+}
+
+play_dog_round()
+{
+    self playlocalsound( "zmb_dog_round_start" );
+    variation_count = 5;
+    wait 4.5;
+    players = getplayers();
+    num = randomintrange( 0, players.size );
+    players[num] maps\mp\zombies\_zm_audio::create_and_play_dialog( "general", "dog_spawn" );
+}
+
+dog_init()
+{
+    self.targetname = "zombie_dog";
+    self.script_noteworthy = undefined;
+    self.animname = "zombie_dog";
+    self.ignoreall = 1;
+    self.ignoreme = 1;
+    self.allowdeath = 1;
+    self.allowpain = 0;
+    self.force_gib = 1;
+    self.is_zombie = 1;
+    self.has_legs = 1;
+    self.gibbed = 0;
+    self.head_gibbed = 0;
+    self.default_goalheight = 40;
+    self.ignore_inert = 1;
+    self.grenadeawareness = 0;
+    self.badplaceawareness = 0;
+    self.ignoresuppression = 1;
+    self.suppressionthreshold = 1;
+    self.nododgemove = 1;
+    self.dontshootwhilemoving = 1;
+    self.pathenemylookahead = 0;
+    self.badplaceawareness = 0;
+    self.chatinitialized = 0;
+    self.team = level.zombie_team;
+    health_multiplier = 1.0;
+
+    if ( getdvar( _hash_CAA5B74F ) != "" )
+        health_multiplier = getdvarfloat( _hash_CAA5B74F );
+
+    self.maxhealth = int( level.dog_health * health_multiplier );
+    self.health = int( level.dog_health * health_multiplier );
+    self.freezegun_damage = 0;
+    self.zombie_move_speed = "sprint";
+    self thread dog_run_think();
+    self thread dog_stalk_audio();
+    self thread maps\mp\zombies\_zm::round_spawn_failsafe();
+    self ghost();
+    self thread magic_bullet_shield();
+    self dog_fx_eye_glow();
+    self dog_fx_trail();
+    self thread dog_death();
+    level thread maps\mp\zombies\_zm_spawner::zombie_death_event( self );
+    self thread maps\mp\zombies\_zm_spawner::enemy_death_detection();
+    self.a.disablepain = 1;
+    self disable_react();
+    self clearenemy();
+    self cleargoalvolume();
+    self.flame_damage_time = 0;
+    self.meleedamage = 40;
+    self.thundergun_knockdown_func = ::dog_thundergun_knockdown;
+    self maps\mp\zombies\_zm_spawner::zombie_history( "zombie_dog_spawn_init -> Spawned = " + self.origin );
+
+    if ( isdefined( level.achievement_monitor_func ) )
+        self [[ level.achievement_monitor_func ]]();
+}
+
+dog_fx_eye_glow()
+{
+    self.fx_dog_eye = spawn( "script_model", self gettagorigin( "J_EyeBall_LE" ) );
+    assert( isdefined( self.fx_dog_eye ) );
+    self.fx_dog_eye.angles = self gettagangles( "J_EyeBall_LE" );
+    self.fx_dog_eye setmodel( "tag_origin" );
+    self.fx_dog_eye linkto( self, "J_EyeBall_LE" );
+}
+
+dog_fx_trail()
+{
+    if ( !is_mature() || randomint( 100 ) > level.zombie_vars["dog_fire_trail_percent"] )
+    {
+        self.fx_dog_trail_type = level._effect["dog_trail_ash"];
+        self.fx_dog_trail_sound = "zmb_hellhound_loop_breath";
+    }
+    else
+    {
+        self.a.nodeath = 1;
+        self.fx_dog_trail_type = level._effect["dog_trail_fire"];
+        self.fx_dog_trail_sound = "zmb_hellhound_loop_fire";
+    }
+
+    self.fx_dog_trail = spawn( "script_model", self gettagorigin( "tag_origin" ) );
+    assert( isdefined( self.fx_dog_trail ) );
+    self.fx_dog_trail.angles = self gettagangles( "tag_origin" );
+    self.fx_dog_trail setmodel( "tag_origin" );
+    self.fx_dog_trail linkto( self, "tag_origin" );
+}
+
+dog_death()
+{
+    self waittill( "death" );
+
+    if ( get_current_zombie_count() == 0 && level.zombie_total == 0 )
+    {
+        level.last_dog_origin = self.origin;
+        level notify( "last_dog_down" );
+    }
+
+    if ( isplayer( self.attacker ) )
+    {
+        event = "death";
+
+        if ( issubstr( self.damageweapon, "knife_ballistic_" ) )
+            event = "ballistic_knife_death";
+
+        self.attacker maps\mp\zombies\_zm_score::player_add_points( event, self.damagemod, self.damagelocation, 1 );
+
+        if ( randomintrange( 0, 100 ) >= 80 )
+            self.attacker maps\mp\zombies\_zm_audio::create_and_play_dialog( "kill", "hellhound" );
+
+        self.attacker maps\mp\zombies\_zm_stats::increment_client_stat( "zdogs_killed" );
+        self.attacker maps\mp\zombies\_zm_stats::increment_player_stat( "zdogs_killed" );
+    }
+
+    if ( isdefined( self.attacker ) && isai( self.attacker ) )
+        self.attacker notify( "killed", self );
+
+    self stoploopsound();
+    assert( isdefined( self.fx_dog_eye ) );
+    self.fx_dog_eye delete();
+    assert( isdefined( self.fx_dog_trail ) );
+    self.fx_dog_trail delete();
+
+    if ( isdefined( self.a.nodeath ) )
+    {
+        level thread dog_explode_fx( self.origin );
+        self delete();
+    }
+    else
+        self playsound( "zmb_hellhound_vocals_death" );
+}
+
+dog_explode_fx( origin )
+{
+    playfx( level._effect["dog_gib"], origin );
+    playsoundatposition( "zmb_hellhound_explode", origin );
+}
+
+zombie_setup_attack_properties_dog()
+{
+    self maps\mp\zombies\_zm_spawner::zombie_history( "zombie_setup_attack_properties()" );
+    self thread dog_behind_audio();
+    self.ignoreall = 0;
+    self.pathenemyfightdist = 64;
+    self.meleeattackdist = 64;
+    self.disablearrivals = 1;
+    self.disableexits = 1;
+}
+
+stop_dog_sound_on_death()
+{
+    self waittill( "death" );
+
+    self stopsounds();
+}
+
+dog_behind_audio()
+{
+    self thread stop_dog_sound_on_death();
+    self endon( "death" );
+    self waittill_any( "dog_running", "dog_combat" );
+    self playsound( "zmb_hellhound_vocals_close" );
+    wait 3;
+
+    while ( true )
+    {
+        players = get_players();
+
+        for ( i = 0; i < players.size; i++ )
+        {
+            dogangle = angleclamp180( vectortoangles( self.origin - players[i].origin )[1] - players[i].angles[1] );
+
+            if ( isalive( players[i] ) && !isdefined( players[i].revivetrigger ) )
+            {
+                if ( abs( dogangle ) > 90 && distance2d( self.origin, players[i].origin ) > 100 )
+                {
+                    self playsound( "zmb_hellhound_vocals_close" );
+                    wait 3;
+                }
+            }
+        }
+
+        wait 0.75;
+    }
+}
+
+dog_clip_monitor()
+{
+    clips_on = 0;
+    level.dog_clips = getentarray( "dog_clips", "targetname" );
+
+    while ( true )
+    {
+        for ( i = 0; i < level.dog_clips.size; i++ )
+        {
+            level.dog_clips[i] trigger_off();
+            level.dog_clips[i] connectpaths();
+        }
+
+        flag_wait( "dog_clips" );
+
+        if ( isdefined( level.no_dog_clip ) && level.no_dog_clip == 1 )
+            return;
+
+        for ( i = 0; i < level.dog_clips.size; i++ )
+        {
+            level.dog_clips[i] trigger_on();
+            level.dog_clips[i] disconnectpaths();
+            wait_network_frame();
+        }
+
+        dog_is_alive = 1;
+
+        while ( dog_is_alive || flag( "dog_round" ) )
+        {
+            dog_is_alive = 0;
+            dogs = getentarray( "zombie_dog", "targetname" );
+
+            for ( i = 0; i < dogs.size; i++ )
+            {
+                if ( isalive( dogs[i] ) )
+                    dog_is_alive = 1;
+            }
+
+            wait 1;
+        }
+
+        flag_clear( "dog_clips" );
+        wait 1;
+    }
+}
+
+special_dog_spawn( spawners, num_to_spawn )
+{
+    dogs = getaispeciesarray( "all", "zombie_dog" );
+
+    if ( isdefined( dogs ) && dogs.size >= 9 )
+        return false;
+
+    if ( !isdefined( num_to_spawn ) )
+        num_to_spawn = 1;
+
+    spawn_point = undefined;
+    count = 0;
+
+    while ( count < num_to_spawn )
+    {
+        players = get_players();
+        favorite_enemy = get_favorite_enemy();
+
+        if ( isdefined( spawners ) )
+        {
+            spawn_point = spawners[randomint( spawners.size )];
+            ai = spawn_zombie( spawn_point );
+
+            if ( isdefined( ai ) )
+            {
+                ai.favoriteenemy = favorite_enemy;
+                spawn_point thread dog_spawn_fx( ai );
+                count++;
+                flag_set( "dog_clips" );
+            }
+        }
+        else if ( isdefined( level.dog_spawn_func ) )
+        {
+            spawn_loc = [[ level.dog_spawn_func ]]( level.dog_spawners, favorite_enemy );
+            ai = spawn_zombie( level.dog_spawners[0] );
+
+            if ( isdefined( ai ) )
+            {
+                ai.favoriteenemy = favorite_enemy;
+                spawn_loc thread dog_spawn_fx( ai, spawn_loc );
+                count++;
+                flag_set( "dog_clips" );
+            }
+        }
+        else
+        {
+            spawn_point = dog_spawn_factory_logic( level.enemy_dog_spawns, favorite_enemy );
+            ai = spawn_zombie( level.dog_spawners[0] );
+
+            if ( isdefined( ai ) )
+            {
+                ai.favoriteenemy = favorite_enemy;
+                spawn_point thread dog_spawn_fx( ai, spawn_point );
+                count++;
+                flag_set( "dog_clips" );
+            }
+        }
+
+        waiting_for_next_dog_spawn( count, num_to_spawn );
+    }
+
+    return true;
+}
+
+dog_run_think()
+{
+    self endon( "death" );
+
+    self waittill( "visible" );
+
+    if ( self.health > level.dog_health )
+    {
+        self.maxhealth = level.dog_health;
+        self.health = level.dog_health;
+    }
+
+    assert( isdefined( self.fx_dog_eye ) );
+    maps\mp\zombies\_zm_net::network_safe_play_fx_on_tag( "dog_fx", 2, level._effect["dog_eye_glow"], self.fx_dog_eye, "tag_origin" );
+    assert( isdefined( self.fx_dog_trail ) );
+    maps\mp\zombies\_zm_net::network_safe_play_fx_on_tag( "dog_fx", 2, self.fx_dog_trail_type, self.fx_dog_trail, "tag_origin" );
+    self playloopsound( self.fx_dog_trail_sound );
+
+    while ( true )
+    {
+        if ( !is_player_valid( self.favoriteenemy ) )
+            self.favoriteenemy = get_favorite_enemy();
+
+        wait 0.2;
+    }
+}
+
+dog_stalk_audio()
+{
+    self endon( "death" );
+    self endon( "dog_running" );
+    self endon( "dog_combat" );
+
+    while ( true )
+    {
+        self playsound( "zmb_hellhound_vocals_amb" );
+        wait( randomfloatrange( 3, 6 ) );
+    }
+}
+
+dog_thundergun_knockdown( player, gib )
+{
+    self endon( "death" );
+    damage = int( self.maxhealth * 0.5 );
+    self dodamage( damage, player.origin, player );
+}

ZM/Core/maps/mp/zombies/_zm_ai_faller.gsc

@@ -0,0 +1,626 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include common_scripts\utility;
+#include maps\mp\_utility;
+#include maps\mp\zombies\_zm_utility;
+#include maps\mp\zombies\_zm_spawner;
+#include maps\mp\animscripts\zm_shared;
+#include maps\mp\zombies\_zm_laststand;
+
+zombie_faller_delete()
+{
+    level.zombie_total++;
+    self maps\mp\zombies\_zm_spawner::reset_attack_spot();
+
+    if ( isdefined( self.zombie_faller_location ) )
+    {
+        self.zombie_faller_location.is_enabled = 1;
+        self.zombie_faller_location = undefined;
+    }
+
+    self delete();
+}
+
+faller_script_parameters()
+{
+    if ( isdefined( self.script_parameters ) )
+    {
+        parms = strtok( self.script_parameters, ";" );
+
+        if ( isdefined( parms ) && parms.size > 0 )
+        {
+            for ( i = 0; i < parms.size; i++ )
+            {
+                if ( parms[i] == "drop_now" )
+                    self.drop_now = 1;
+
+                if ( parms[i] == "drop_not_occupied" )
+                    self.drop_not_occupied = 1;
+
+                if ( parms[i] == "emerge_top" )
+                    self.emerge_top = 1;
+
+                if ( parms[i] == "emerge_bottom" )
+                    self.emerge_bottom = 1;
+            }
+        }
+    }
+}
+
+setup_deathfunc( func_name )
+{
+    self endon( "death" );
+
+    while ( !( isdefined( self.zombie_init_done ) && self.zombie_init_done ) )
+        wait_network_frame();
+
+    if ( isdefined( func_name ) )
+        self.deathfunction = func_name;
+    else if ( isdefined( level.custom_faller_death ) )
+        self.deathfunction = level.custom_faller_death;
+    else
+        self.deathfunction = ::zombie_fall_death_func;
+}
+
+do_zombie_fall( spot )
+{
+    self endon( "death" );
+    self.zombie_faller_location = spot;
+    self.zombie_faller_location.is_enabled = 0;
+    self.zombie_faller_location faller_script_parameters();
+
+    if ( isdefined( self.zombie_faller_location.emerge_bottom ) && self.zombie_faller_location.emerge_bottom || isdefined( self.zombie_faller_location.emerge_top ) && self.zombie_faller_location.emerge_top )
+    {
+        self do_zombie_emerge( spot );
+        return;
+    }
+
+    self thread setup_deathfunc();
+    self.no_powerups = 1;
+    self.in_the_ceiling = 1;
+    self.anchor = spawn( "script_origin", self.origin );
+    self.anchor.angles = self.angles;
+    self linkto( self.anchor );
+
+    if ( !isdefined( spot.angles ) )
+        spot.angles = ( 0, 0, 0 );
+
+    anim_org = spot.origin;
+    anim_ang = spot.angles;
+    self ghost();
+    self.anchor moveto( anim_org, 0.05 );
+
+    self.anchor waittill( "movedone" );
+
+    target_org = get_desired_origin();
+
+    if ( isdefined( target_org ) )
+    {
+        anim_ang = vectortoangles( target_org - self.origin );
+        self.anchor rotateto( ( 0, anim_ang[1], 0 ), 0.05 );
+
+        self.anchor waittill( "rotatedone" );
+    }
+
+    self unlink();
+
+    if ( isdefined( self.anchor ) )
+        self.anchor delete();
+
+    self thread maps\mp\zombies\_zm_spawner::hide_pop();
+    self thread zombie_fall_death( spot );
+    self thread zombie_fall_fx( spot );
+    self thread zombie_faller_death_wait();
+    self thread zombie_faller_do_fall();
+    self.no_powerups = 0;
+    self notify( "risen", spot.script_string );
+}
+
+zombie_faller_do_fall()
+{
+    self endon( "death" );
+    self animscripted( self.origin, self.zombie_faller_location.angles, "zm_faller_emerge" );
+    self maps\mp\animscripts\zm_shared::donotetracks( "emerge_anim", ::handle_fall_notetracks, self.zombie_faller_location );
+    self.zombie_faller_wait_start = gettime();
+    self.zombie_faller_should_drop = 0;
+    self thread zombie_fall_wait();
+    self thread zombie_faller_watch_all_players();
+
+    while ( !self.zombie_faller_should_drop )
+    {
+        if ( self zombie_fall_should_attack( self.zombie_faller_location ) )
+        {
+            self animscripted( self.origin, self.zombie_faller_location.angles, "zm_faller_attack" );
+            self maps\mp\animscripts\zm_shared::donotetracks( "attack_anim", ::handle_fall_notetracks, self.zombie_faller_location );
+
+            if ( !self zombie_faller_always_drop() && randomfloat( 1 ) > 0.5 )
+                self.zombie_faller_should_drop = 1;
+        }
+        else if ( self zombie_faller_always_drop() )
+        {
+            self.zombie_faller_should_drop = 1;
+            break;
+        }
+        else if ( gettime() >= self.zombie_faller_wait_start + 20000 )
+        {
+            self.zombie_faller_should_drop = 1;
+            break;
+        }
+        else if ( self zombie_faller_drop_not_occupied() )
+        {
+            self.zombie_faller_should_drop = 1;
+            break;
+        }
+        else
+        {
+            self animscripted( self.origin, self.zombie_faller_location.angles, "zm_faller_attack" );
+            self maps\mp\animscripts\zm_shared::donotetracks( "attack_anim", ::handle_fall_notetracks, self.zombie_faller_location );
+        }
+    }
+
+    self notify( "falling" );
+    spot = self.zombie_faller_location;
+    self zombie_faller_enable_location();
+    self animscripted( self.origin, spot.angles, "zm_faller_fall" );
+    self maps\mp\animscripts\zm_shared::donotetracks( "fall_anim", ::handle_fall_notetracks, spot );
+    self.deathfunction = maps\mp\zombies\_zm_spawner::zombie_death_animscript;
+    self notify( "fall_anim_finished" );
+    spot notify( "stop_zombie_fall_fx" );
+    self stopanimscripted();
+    landanimdelta = 15;
+    ground_pos = groundpos_ignore_water_new( self.origin );
+    physdist = self.origin[2] - ground_pos[2] + landanimdelta;
+
+    if ( physdist > 0 )
+    {
+        self animcustom( ::zombie_fall_loop );
+
+        self waittill( "faller_on_ground" );
+
+        self animcustom( ::zombie_land );
+
+        self waittill( "zombie_land_done" );
+    }
+
+    self.in_the_ceiling = 0;
+    self traversemode( "gravity" );
+    self.no_powerups = 0;
+}
+
+zombie_fall_loop()
+{
+    self endon( "death" );
+    self setanimstatefromasd( "zm_faller_fall_loop" );
+
+    while ( true )
+    {
+        ground_pos = groundpos_ignore_water_new( self.origin );
+
+        if ( self.origin[2] - ground_pos[2] < 20 )
+        {
+            self notify( "faller_on_ground" );
+            break;
+        }
+
+        wait 0.05;
+    }
+}
+
+zombie_land()
+{
+    self setanimstatefromasd( "zm_faller_land" );
+    maps\mp\animscripts\zm_shared::donotetracks( "land_anim" );
+    self notify( "zombie_land_done" );
+}
+
+zombie_faller_always_drop()
+{
+    if ( isdefined( self.zombie_faller_location.drop_now ) && self.zombie_faller_location.drop_now )
+        return true;
+
+    return false;
+}
+
+zombie_faller_drop_not_occupied()
+{
+    if ( isdefined( self.zombie_faller_location.drop_not_occupied ) && self.zombie_faller_location.drop_not_occupied )
+    {
+        if ( isdefined( self.zone_name ) && isdefined( level.zones[self.zone_name] ) )
+            return !level.zones[self.zone_name].is_occupied;
+    }
+
+    return 0;
+}
+
+zombie_faller_watch_all_players()
+{
+    players = get_players();
+
+    for ( i = 0; i < players.size; i++ )
+        self thread zombie_faller_watch_player( players[i] );
+}
+
+zombie_faller_watch_player( player )
+{
+    self endon( "falling" );
+    self endon( "death" );
+    player endon( "disconnect" );
+    range = 200;
+    rangesqr = range * range;
+    timer = 5000;
+    inrange = 0;
+    inrangetime = 0;
+    closerange = 60;
+    closerangesqr = closerange * closerange;
+    dirtoplayerenter = ( 0, 0, 0 );
+    incloserange = 0;
+
+    while ( true )
+    {
+        distsqr = distance2dsquared( self.origin, player.origin );
+
+        if ( distsqr < rangesqr )
+        {
+            if ( inrange )
+            {
+                if ( inrangetime + timer < gettime() )
+                {
+                    self.zombie_faller_should_drop = 1;
+                    break;
+                }
+            }
+            else
+            {
+                inrange = 1;
+                inrangetime = gettime();
+            }
+        }
+        else
+            inrange = 0;
+
+        if ( distsqr < closerangesqr )
+        {
+            if ( !incloserange )
+            {
+                dirtoplayerenter = player.origin - self.origin;
+                dirtoplayerenter = ( dirtoplayerenter[0], dirtoplayerenter[1], 0.0 );
+                dirtoplayerenter = vectornormalize( dirtoplayerenter );
+            }
+
+            incloserange = 1;
+        }
+        else
+        {
+            if ( incloserange )
+            {
+                dirtoplayerexit = player.origin - self.origin;
+                dirtoplayerexit = ( dirtoplayerexit[0], dirtoplayerexit[1], 0.0 );
+                dirtoplayerexit = vectornormalize( dirtoplayerexit );
+
+                if ( vectordot( dirtoplayerenter, dirtoplayerexit ) < 0 )
+                {
+                    self.zombie_faller_should_drop = 1;
+                    break;
+                }
+            }
+
+            incloserange = 0;
+        }
+
+        wait 0.1;
+    }
+}
+
+zombie_fall_wait()
+{
+    self endon( "falling" );
+    self endon( "death" );
+
+    if ( isdefined( self.zone_name ) )
+    {
+        if ( isdefined( level.zones ) && isdefined( level.zones[self.zone_name] ) )
+        {
+            zone = level.zones[self.zone_name];
+
+            while ( true )
+            {
+                if ( !zone.is_enabled || !zone.is_active )
+                {
+                    if ( !self potentially_visible( 2250000 ) )
+                    {
+                        if ( self.health != level.zombie_health )
+                        {
+                            self.zombie_faller_should_drop = 1;
+                            break;
+                        }
+                        else
+                        {
+                            self zombie_faller_delete();
+                            return;
+                        }
+                    }
+                }
+
+                wait 0.5;
+            }
+        }
+    }
+}
+
+zombie_fall_should_attack( spot )
+{
+    victims = zombie_fall_get_vicitims( spot );
+    return victims.size > 0;
+}
+
+zombie_fall_get_vicitims( spot )
+{
+    ret = [];
+    players = getplayers();
+    checkdist2 = 40.0;
+    checkdist2 *= checkdist2;
+
+    for ( i = 0; i < players.size; i++ )
+    {
+        player = players[i];
+
+        if ( player maps\mp\zombies\_zm_laststand::player_is_in_laststand() )
+            continue;
+
+        stance = player getstance();
+
+        if ( stance == "crouch" || stance == "prone" )
+            continue;
+
+        zcheck = self.origin[2] - player.origin[2];
+
+        if ( zcheck < 0.0 || zcheck > 120.0 )
+            continue;
+
+        dist2 = distance2dsquared( player.origin, self.origin );
+
+        if ( dist2 < checkdist2 )
+            ret[ret.size] = player;
+    }
+
+    return ret;
+}
+
+get_fall_anim( spot )
+{
+    return level._zombie_fall_anims[self.animname]["fall"];
+}
+
+zombie_faller_enable_location()
+{
+    if ( isdefined( self.zombie_faller_location ) )
+    {
+        self.zombie_faller_location.is_enabled = 1;
+        self.zombie_faller_location = undefined;
+    }
+}
+
+zombie_faller_death_wait( endon_notify )
+{
+    self endon( "falling" );
+
+    if ( isdefined( endon_notify ) )
+        self endon( endon_notify );
+
+    self waittill( "death" );
+
+    self zombie_faller_enable_location();
+}
+
+zombie_fall_death_func()
+{
+    self animmode( "noclip" );
+    self.deathanim = "zm_faller_emerge_death";
+    return self maps\mp\zombies\_zm_spawner::zombie_death_animscript();
+}
+
+zombie_fall_death( spot )
+{
+    self endon( "fall_anim_finished" );
+
+    while ( self.health > 1 )
+        self waittill( "damage", amount, attacker, dir, p, type );
+
+    self stopanimscripted();
+    spot notify( "stop_zombie_fall_fx" );
+}
+
+_damage_mod_to_damage_type( type )
+{
+    toks = strtok( type, "_" );
+
+    if ( toks.size < 2 )
+        return type;
+
+    returnstr = toks[1];
+
+    for ( i = 2; i < toks.size; i++ )
+        returnstr += toks[i];
+
+    returnstr = tolower( returnstr );
+    return returnstr;
+}
+
+zombie_fall_fx( spot )
+{
+    spot thread zombie_fall_dust_fx( self );
+    spot thread zombie_fall_burst_fx();
+    playsoundatposition( "zmb_zombie_spawn", spot.origin );
+    self endon( "death" );
+    spot endon( "stop_zombie_fall_fx" );
+    wait 1;
+
+    if ( self.zombie_move_speed != "sprint" )
+        wait 1;
+}
+
+zombie_fall_burst_fx()
+{
+    self endon( "stop_zombie_fall_fx" );
+    self endon( "fall_anim_finished" );
+    playfx( level._effect["rise_burst"], self.origin + ( 0, 0, randomintrange( 5, 10 ) ) );
+    wait 0.25;
+    playfx( level._effect["rise_billow"], self.origin + ( randomintrange( -10, 10 ), randomintrange( -10, 10 ), randomintrange( 5, 10 ) ) );
+}
+
+zombie_fall_dust_fx( zombie )
+{
+    dust_tag = "J_SpineUpper";
+    self endon( "stop_zombie_fall_dust_fx" );
+    self thread stop_zombie_fall_dust_fx( zombie );
+    dust_time = 4.5;
+    dust_interval = 0.3;
+
+    for ( t = 0; t < dust_time; t += dust_interval )
+    {
+        playfxontag( level._effect["rise_dust"], zombie, dust_tag );
+        wait( dust_interval );
+    }
+}
+
+stop_zombie_fall_dust_fx( zombie )
+{
+    zombie waittill( "death" );
+
+    self notify( "stop_zombie_fall_dust_fx" );
+}
+
+handle_fall_notetracks( note, spot )
+{
+    if ( note == "deathout" )
+        self.deathfunction = ::faller_death_ragdoll;
+    else if ( note == "fire" )
+    {
+        victims = zombie_fall_get_vicitims( spot );
+
+        for ( i = 0; i < victims.size; i++ )
+        {
+            victims[i] dodamage( self.meleedamage, self.origin, self, self, "none", "MOD_MELEE" );
+            self.zombie_faller_should_drop = 1;
+        }
+    }
+}
+
+faller_death_ragdoll()
+{
+    self startragdoll();
+    self launchragdoll( ( 0, 0, -1 ) );
+    return self maps\mp\zombies\_zm_spawner::zombie_death_animscript();
+}
+
+in_player_fov( player )
+{
+    playerangles = player getplayerangles();
+    playerforwardvec = anglestoforward( playerangles );
+    playerunitforwardvec = vectornormalize( playerforwardvec );
+    banzaipos = self.origin;
+    playerpos = player getorigin();
+    playertobanzaivec = banzaipos - playerpos;
+    playertobanzaiunitvec = vectornormalize( playertobanzaivec );
+    forwarddotbanzai = vectordot( playerunitforwardvec, playertobanzaiunitvec );
+    anglefromcenter = acos( forwarddotbanzai );
+    playerfov = getdvarfloat( "cg_fov" );
+    banzaivsplayerfovbuffer = getdvarfloat( _hash_BCB625CF );
+
+    if ( banzaivsplayerfovbuffer <= 0 )
+        banzaivsplayerfovbuffer = 0.2;
+
+    inplayerfov = anglefromcenter <= playerfov * 0.5 * ( 1 - banzaivsplayerfovbuffer );
+    return inplayerfov;
+}
+
+potentially_visible( how_close = 1000000 )
+{
+    potentiallyvisible = 0;
+    players = getplayers();
+
+    for ( i = 0; i < players.size; i++ )
+    {
+        dist = distancesquared( self.origin, players[i].origin );
+
+        if ( dist < how_close )
+        {
+            inplayerfov = self in_player_fov( players[i] );
+
+            if ( inplayerfov )
+            {
+                potentiallyvisible = 1;
+                break;
+            }
+        }
+    }
+
+    return potentiallyvisible;
+}
+
+do_zombie_emerge( spot )
+{
+    self endon( "death" );
+    self thread setup_deathfunc( ::faller_death_ragdoll );
+    self.no_powerups = 1;
+    self.in_the_ceiling = 1;
+    anim_org = spot.origin;
+    anim_ang = spot.angles;
+    self thread zombie_emerge_fx( spot );
+    self thread zombie_faller_death_wait( "risen" );
+
+    if ( isdefined( level.custom_faller_entrance_logic ) )
+        self thread [[ level.custom_faller_entrance_logic ]]();
+
+    self zombie_faller_emerge( spot );
+    self.create_eyes = 1;
+    wait 0.1;
+    self notify( "risen", spot.script_string );
+    self zombie_faller_enable_location();
+}
+
+zombie_faller_emerge( spot )
+{
+    self endon( "death" );
+
+    if ( isdefined( self.zombie_faller_location.emerge_bottom ) && self.zombie_faller_location.emerge_bottom )
+        self animscripted( self.zombie_faller_location.origin, self.zombie_faller_location.angles, "zombie_riser_elevator_from_floor" );
+    else
+        self animscripted( self.zombie_faller_location.origin, self.zombie_faller_location.angles, "zombie_riser_elevator_from_ceiling" );
+
+    self maps\mp\animscripts\zm_shared::donotetracks( "rise_anim" );
+    self.deathfunction = maps\mp\zombies\_zm_spawner::zombie_death_animscript;
+    self.in_the_ceiling = 0;
+    self.no_powerups = 0;
+}
+
+zombie_emerge_fx( spot )
+{
+    spot thread zombie_emerge_dust_fx( self );
+    playsoundatposition( "zmb_zombie_spawn", spot.origin );
+    self endon( "death" );
+    spot endon( "stop_zombie_fall_fx" );
+    wait 1;
+}
+
+zombie_emerge_dust_fx( zombie )
+{
+    dust_tag = "J_SpineUpper";
+    self endon( "stop_zombie_fall_dust_fx" );
+    self thread stop_zombie_fall_dust_fx( zombie );
+    dust_time = 3.5;
+    dust_interval = 0.5;
+
+    for ( t = 0; t < dust_time; t += dust_interval )
+    {
+        playfxontag( level._effect["rise_dust"], zombie, dust_tag );
+        wait( dust_interval );
+    }
+}
+
+stop_zombie_emerge_dust_fx( zombie )
+{
+    zombie waittill( "death" );
+
+    self notify( "stop_zombie_fall_dust_fx" );
+}