Update scripts to better decompiled scripts.

MP/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;
+}

MP/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" );
+}

MP/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;
+}

MP/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;
+    }
+}

MP/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;
+}

MP/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;
+}

MP/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" );
+}

MP/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();
+}

MP/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();
+    }
+}

MP/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;
+    }
+}

MP/Core/maps/mp/animscripts/traverse/jump_down_40.gsc

@@ -0,0 +1,9 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\traverse\shared;
+
+main()
+{
+    if ( self.type == "dog" )
+        dog_jump_down( 40, 3 );
+}

MP/Core/maps/mp/animscripts/traverse/jump_down_56.gsc

@@ -0,0 +1,9 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\traverse\shared;
+
+main()
+{
+    if ( self.type == "dog" )
+        dog_jump_down( 56, 7 );
+}

MP/Core/maps/mp/animscripts/traverse/jump_down_96.gsc

@@ -0,0 +1,9 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\traverse\shared;
+
+main()
+{
+    if ( self.type == "dog" )
+        dog_jump_down_far( 96, 11, 0.65 );
+}

MP/Core/maps/mp/animscripts/traverse/mantle_on_40.gsc

@@ -0,0 +1,9 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\traverse\shared;
+
+main()
+{
+    if ( self.type == "dog" )
+        dog_jump_up( 40, 3 );
+}

MP/Core/maps/mp/animscripts/traverse/mantle_on_56.gsc

@@ -0,0 +1,9 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\traverse\shared;
+
+main()
+{
+    if ( self.type == "dog" )
+        dog_jump_up( 56.0, 5 );
+}

MP/Core/maps/mp/animscripts/traverse/mantle_on_80.gsc

@@ -0,0 +1,9 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\traverse\shared;
+
+main()
+{
+    if ( self.type == "dog" )
+        dog_jump_up_high( 80.0, 8 );
+}

MP/Core/maps/mp/animscripts/traverse/mantle_on_96.gsc

@@ -0,0 +1,9 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\traverse\shared;
+
+main()
+{
+    if ( self.type == "dog" )
+        dog_jump_up_high( 96.0, 9 );
+}

MP/Core/maps/mp/animscripts/traverse/mantle_over_40.gsc

@@ -0,0 +1,9 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\traverse\shared;
+
+main()
+{
+    if ( self.type == "dog" )
+        dog_wall_and_window_hop( "traverse_window", 40 );
+}

MP/Core/maps/mp/animscripts/traverse/mantle_window_36.gsc

@@ -0,0 +1,9 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\traverse\shared;
+
+main()
+{
+    if ( self.type == "dog" )
+        dog_wall_and_window_hop( "traverse_window", 36 );
+}

MP/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;
+}

MP/Core/maps/mp/animscripts/traverse/through_hole_42.gsc

@@ -0,0 +1,27 @@
+// T6 GSC SOURCE
+// Decompiled by https://github.com/xensik/gsc-tool
+#include maps\mp\animscripts\traverse\shared;
+#include maps\mp\animscripts\utility;
+#include maps\mp\animscripts\shared;
+
+main()
+{
+    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 );
+    }
+
+    debug_anim_print( "traverse::through_hole()" );
+    self setanimstate( "traverse_through_hole_42" );
+    maps\mp\animscripts\shared::donotetracksfortime( 1.0, "done" );
+    debug_anim_print( "traverse::through_hole()" );
+    self.traversecomplete = 1;
+}

MP/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;
+}