// IW6 GSC SOURCE
// Generated by https://github.com/xensik/gsc-tool

moveswim()
{
    self endon( "movemode" );
    self orientmode( "face enemy or motion" );

    if ( animscripts\utility::isspaceai() )
        self.turnrate = 0.16;
    else
        self.turnrate = 0.03;

    animscripts\utility::updateisincombattimer();

    if ( animscripts\utility::isincombat( 0 ) )
        moveswim_combat();
    else
        moveswim_noncombat();
}

swim_begin()
{
    self.swim = spawnstruct();
    self.swim.combatstate = "nostate";
    self.swim.movestate = "combat_stationary";
    self.swim.trackstate = "track_none";
    self.swim.statefns = [];
    self.swim.statefns["nostate"] = [ ::swim_null, ::swim_null ];
    self.swim.statefns["noncombat"] = [ ::moveswim_noncombat_enter, ::moveswim_noncombat_exit ];
    self.swim.statefns["combat"] = [ ::moveswim_combat_enter, ::moveswim_combat_exit ];
    self.swim.statefns["combat_stationary"] = [ ::swim_null, ::swim_null ];
    self.swim.statefns["combat_forward"] = [ ::moveswim_combat_forward_enter, ::moveswim_combat_forward_exit ];
    self.swim.statefns["combat_strafe"] = [ ::moveswim_combat_strafe_enter, ::moveswim_combat_strafe_exit ];
    self.swim.statefns["track_none"] = [ ::swim_null, ::swim_null ];
    self.swim.statefns["track_forward"] = [ ::swim_track_forward_enter, ::swim_track_forward_exit ];
    self.swim.statefns["track_strafe"] = [ ::swim_track_strafe_enter, ::swim_track_strafe_exit ];
    self setanimlimited( getswimanim( "aim_stand_D" ) );
    self setanimlimited( getswimanim( "aim_stand_U" ) );
    self setanimlimited( getswimanim( "aim_stand_L" ) );
    self setanimlimited( getswimanim( "aim_stand_R" ) );
    self.custommovetransition = ::swim_movebegin;
    self.permanentcustommovetransition = 1;
    self.pathturnanimoverridefunc = ::swim_pathchange_getturnanim;
    self.pathturnanimblendtime = 0.2;
}

swim_end()
{
    self.swim = undefined;

    if ( animscripts\utility::isspaceai() )
        self.turnrate = 0.16;
    else
        self.turnrate = 0.3;
}

swim_null()
{

}

swim_moveend()
{
    moveswim_set( "nostate" );
    swim_clearleananims();

    if ( isdefined( self.prevturnrate ) )
    {
        self.turnrate = self.prevturnrate;
        self.prevturnrate = undefined;
    }
}

moveswim_noncombat()
{
    if ( self.swim.combatstate != "noncombat" )
        moveswim_set( "noncombat" );

    var_0 = self.swim.move_noncombat_anim;
    var_1 = 0.4;

    if ( animscripts\utility::isspaceai() )
        var_1 = 0.2;

    self setflaggedanimknob( "swimanim", var_0, 1, var_1, self.moveplaybackrate );
    swim_updateleananim();
    animscripts\notetracks::donotetracksfortime( 0.2, "swimanim" );
}

moveswim_combat()
{
    if ( self.swim.combatstate != "combat" )
        moveswim_set( "combat" );

    if ( isdefined( self.enemy ) )
    {
        animscripts\run::setshootwhilemoving( 1 );

        if ( !self.facemotion )
        {
            swim_dostrafe();
            return;
        }
        else
        {
            if ( self.swim.movestate != "combat_forward" )
                moveswim_combat_move_set( "combat_forward" );

            if ( isdefined( self.bclearstrafeturnrate ) && self.bclearstrafeturnrate && lengthsquared( self.velocity ) )
            {
                var_0 = vectortoangles( self.velocity );

                if ( abs( angleclamp180( var_0[1] - self.angles[1] ) ) > 35 )
                {
                    self.turnrate = 0.18;

                    if ( animscripts\utility::isspaceai() )
                        self.turnrate = 0.2;
                }
                else
                {
                    if ( animscripts\utility::isspaceai() )
                        self.turnrate = 0.16;
                    else
                        self.turnrate = 0.03;

                    self.bclearstrafeturnrate = undefined;
                }
            }
            else
                self.bclearstrafeturnrate = undefined;

            var_1 = getswimanim( "forward_aim" );
        }
    }
    else
    {
        if ( self.swim.movestate != "combat_forward" )
            moveswim_combat_move_set( "combat_forward" );

        animscripts\run::setshootwhilemoving( 0 );
        var_1 = getswimanim( "forward_aim" );
    }

    var_2 = 0.4;

    if ( animscripts\utility::isspaceai() )
        var_2 = 0.2;

    swim_updateleananim();
    self setflaggedanimknob( "swimanim", var_1, 1, var_2, self.moveplaybackrate );
    animscripts\notetracks::donotetracksfortime( 0.2, "swimanim" );
}

moveswim_set( var_0 )
{
    if ( var_0 == self.swim.combatstate )
        return;

    [[ self.swim.statefns[self.swim.combatstate][1] ]]();
    [[ self.swim.statefns[var_0][0] ]]();
    self.swim.combatstate = var_0;
}

moveswim_noncombat_enter()
{
    if ( self.swim.trackstate != "track_none" )
        swim_track_set( "track_none" );

    swim_setleananims();
    thread moveswim_noncombat_twitchupdate();
}

moveswim_noncombat_exit()
{
    self notify( "end_MoveSwim_NonCombat_TwitchUpdate" );
}

#using_animtree("generic_human");

moveswim_combat_enter()
{
    self setanimknob( %combatrun, 1.0, 0.5, self.moveplaybackrate );

    if ( self.swim.movestate != "combat_forward" )
        moveswim_combat_move_set( "combat_forward" );
}

moveswim_combat_exit()
{
    moveswim_combat_move_set( "combat_stationary" );
}

moveswim_combat_move_set( var_0 )
{
    if ( var_0 == self.swim.movestate )
        return;

    [[ self.swim.statefns[self.swim.movestate][1] ]]();
    [[ self.swim.statefns[var_0][0] ]]();
    self.swim.movestate = var_0;
}

moveswim_combat_forward_enter()
{
    if ( self.swim.trackstate != "track_forward" )
        swim_track_set( "track_forward" );

    swim_setleananims();
}

moveswim_combat_forward_exit()
{

}

moveswim_combat_strafe_enter()
{
    self setanimknoblimited( getswimanim( "strafe_B" ), 1, 0.1, self.sidesteprate, 1 );
    self setanimknoblimited( getswimanim( "strafe_L" ), 1, 0.1, self.sidesteprate, 1 );
    self setanimknoblimited( getswimanim( "strafe_R" ), 1, 0.1, self.sidesteprate, 1 );

    if ( self.swim.trackstate != "track_strafe" )
        swim_track_set( "track_strafe" );

    swim_clearleananims();

    if ( animscripts\utility::isspaceai() )
        self.turnrate = 0.25;
    else
    {
        self.turnrate = 0.18;
        self.jumping = 1;
    }
}

moveswim_combat_strafe_exit()
{
    self clearanim( %combatrun_forward, 0.2 );
    self clearanim( %combatrun_backward, 0.2 );
    self clearanim( %combatrun_left, 0.2 );
    self clearanim( %combatrun_right, 0.2 );

    if ( animscripts\utility::isspaceai() )
        self.turnrate = 0.16;
    else
    {
        self.turnrate = 0.03;
        self.jumping = 0;
    }

    self.bclearstrafeturnrate = 1;
}

swim_track_set( var_0 )
{
    if ( self.swim.trackstate == var_0 )
        return;

    [[ self.swim.statefns[self.swim.trackstate][1] ]]();
    [[ self.swim.statefns[var_0][0] ]]();
    self.swim.trackstate = var_0;
}

swim_track_forward_enter()
{
    self setanimlimited( getswimanim( "aim_move_D" ) );
    self setanimlimited( getswimanim( "aim_move_L" ) );
    self setanimlimited( getswimanim( "aim_move_R" ) );
    self setanimlimited( getswimanim( "aim_move_U" ) );
    thread moveswim_track_combat();
}

swim_track_forward_exit()
{
    self clearanim( %aim_2, 0.2 );
    self clearanim( %aim_4, 0.2 );
    self clearanim( %aim_6, 0.2 );
    self clearanim( %aim_8, 0.2 );
}

swim_track_strafe_enter()
{

}

swim_track_strafe_exit()
{
    self clearanim( %w_aim_4, 0.2 );
    self clearanim( %w_aim_6, 0.2 );
    self clearanim( %w_aim_8, 0.2 );
    self clearanim( %w_aim_2, 0.2 );
}

moveswim_track_combat()
{
    self endon( "killanimscript" );
    self endon( "end_face_enemy_tracking" );

    if ( !isdefined( self.aim_while_moving_thread ) )
    {
        self.aim_while_moving_thread = 1;
        animscripts\combat::set_default_aim_limits();

        if ( animscripts\utility::isspaceai() )
        {
            self.rightaimlimit = 90;
            self.leftaimlimit = -90;
        }

        animscripts\track::trackloop( %w_aim_2, %w_aim_4, %w_aim_6, %w_aim_8 );
    }
}

getswimanim( var_0, var_1 )
{
    var_2 = animscripts\utility::lookupanim( "swim", var_0 );

    if ( isdefined( var_1 ) )
        return var_2[var_1];
    else
        return var_2;
}

moveswim_noncombat_twitchupdate()
{
    var_0 = getswimanim( "forward" );
    self.swim.move_noncombat_anim = var_0;
}

swim_shoulddonodeexit()
{
    if ( isdefined( self.disableexits ) )
        return 0;

    if ( !isdefined( self.pathgoalpos ) )
        return 0;

    var_0 = self.maxfaceenemydist;
    self.maxfaceenemydist = 128;

    if ( !self shouldfacemotion() )
    {
        self.maxfaceenemydist = var_0;
        return 0;
    }

    self.maxfaceenemydist = var_0;
    var_1 = 10000;

    if ( animscripts\utility::isspaceai() )
        var_1 = 32400;

    if ( distancesquared( self.origin, self.pathgoalpos ) < var_1 )
        return 0;

    if ( self.a.movement != "stop" )
        return 0;

    if ( lengthsquared( self.prevanimdelta ) > 1 )
    {
        var_2 = vectortoangles( self.prevanimdelta );

        if ( abs( angleclamp180( var_2[1] - self.angles[1] ) ) < 90 )
        {
            var_3 = vectortoangles( self.lookaheaddir );

            if ( abs( angleclamp180( var_3[1] - self.angles[1] ) ) < 90 )
                return 0;
        }
    }

    return 1;
}

swim_movebegin()
{
    self.a.pose = "stand";

    if ( !swim_shoulddonodeexit() )
        return;

    var_0 = swim_choosestart();

    if ( !isdefined( var_0 ) )
        return;

    var_1 = var_0.m_turnanim;
    var_2 = var_0.m_anim;
    var_3 = var_0.m_angledelta;
    var_4 = vectortoangles( self.lookaheaddir );
    var_5 = var_4 - var_3;
    var_6 = anglestoforward( var_5 );
    var_7 = animscripts\exit_node::getexitnode();

    if ( animscripts\utility::isspaceai() && isdefined( var_7 ) )
    {
        var_8 = swim_getapproachtype( var_7 );

        if ( var_8 != "exposed" )
        {
            var_9 = getnodeforwardangles( var_7 );
            var_6 = anglestoforward( var_9 );
        }
        else
            var_6 = anglestoforward( self.angles );
    }

    self animmode( "nogravity", 0 );
    var_10 = randomfloatrange( 0.9, 1.1 );
    var_11 = 0.3;
    self orientmode( "face angle 3d", self.angles );

    if ( isdefined( var_1 ) && !animscripts\utility::isspaceai() )
    {
        self setflaggedanimknoballrestart( "startturn", var_1, %body, 1, 0.3, var_10 * self.moveplaybackrate );
        animscripts\shared::donotetracks( "startturn" );
        var_11 = 0.5;
    }
    else if ( isdefined( var_1 ) && animscripts\utility::isspaceai() )
    {
        if ( isdefined( var_7 ) )
            self orientmode( "face direction", var_6 );

        self.prevturnrate = 0.16;
        self.turnrate = 5.0;
        var_11 = 0.1;
        self setflaggedanimknoballrestart( "startturn", var_1, %body, 1, var_11, var_10 * self.moveplaybackrate );
        animscripts\shared::donotetracks( "startturn" );
        var_11 = 0.5;
        self.turnrate = 0.16;
        self.prevturnrate = undefined;
        var_12 = getangledelta( var_1 );
        var_7 = animscripts\exit_node::getexitnode();
        var_6 = anglestoforward( self.angles );

        if ( isdefined( var_7 ) )
        {
            var_8 = swim_getapproachtype( var_7 );

            if ( var_8 != "exposed" )
            {
                var_9 = getnodeforwardangles( var_7 );
                var_9 = ( var_9[0], var_9[1] - var_12, var_9[2] );
                var_6 = anglestoforward( var_9 );
            }
        }
    }

    var_13 = var_4 - self.angles;
    var_14 = getanimlength( var_2 );
    var_15 = 0.001 * abs( angleclamp180( var_13[1] - var_3[1] ) ) / var_14;
    var_16 = 0.001 * abs( angleclamp180( var_13[0] - var_3[0] ) ) / var_14;
    var_17 = max( var_15, var_16 );

    if ( var_17 < 0.01 )
        var_17 = 0.01;

    if ( animscripts\utility::isspaceai() )
    {
        var_11 = 0.05;
        self.turnrate = 0.16;
        var_17 = 5.0;
    }

    self.prevturnrate = self.turnrate;
    self.turnrate = var_17;
    self orientmode( "face direction", var_6 );
    self setflaggedanimknoballrestart( "startmove", var_2, %body, 1, var_11, var_10 * self.moveplaybackrate );
    animscripts\shared::donotetracks( "startmove" );
    self.turnrate = self.prevturnrate;
    self.prevturnrate = undefined;
    self orientmode( "face default" );
    self animmode( "none", 0 );

    if ( animscripts\utility::isspaceai() )
    {
        if ( animhasnotetrack( var_2, "finish" ) )
            animscripts\shared::donotetracks( "startmove" );

        var_18 = 65536;
        var_19 = self.goalpos;

        if ( isdefined( self.node ) )
            var_19 = self.node.origin;

        if ( distance2dsquared( self.origin, var_19 ) > var_18 )
            self notify( "force_space_rotation_update", 0, 0, undefined, 1 );
    }

    if ( animscripts\utility::isspaceai() )
        return 0.2;
    else
        return 0.4;
}

swim_setleananims()
{
    self setanimlimited( getswimanim( "turn_add_l" ) );
    self setanimlimited( getswimanim( "turn_add_r" ) );
    self setanimlimited( getswimanim( "turn_add_u" ) );
    self setanimlimited( getswimanim( "turn_add_d" ) );
    self.prevleanfracyaw = 0;
    self.prevleanfracpitch = 0;
}

swim_clearleananims()
{
    self clearanim( %add_turn_l, 0.2 );
    self clearanim( %add_turn_r, 0.2 );
    self clearanim( %add_turn_u, 0.2 );
    self clearanim( %add_turn_d, 0.2 );
    self.prevleanfracyaw = undefined;
    self.prevleanfracpitch = undefined;
}

swim_choosestart()
{
    var_0 = animscripts\utility::isincombat();
    var_1 = animscripts\exit_node::getexitnode();
    var_2 = self.angles;
    var_3 = 0;
    var_4 = 0;
    var_5 = 0;
    var_6 = vectortoangles( self.lookaheaddir );
    var_7 = animscripts\utility::gettruenodeangles( var_1 );

    if ( animscripts\utility::isspaceai() && var_7[2] )
    {
        if ( var_7[2] != 0 )
        {
            var_8 = anglestoforward( var_7 );
            var_9 = self.goalpos;

            if ( isdefined( self.node ) )
                var_9 = self.node.origin;

            var_10 = rotatepointaroundvector( var_8, var_9 - self.origin, var_7[2] * -1 );
            var_11 = var_10 + self.origin;
            var_12 = var_11 - self.origin;
            var_12 = vectornormalize( var_12 );
            var_6 = vectortoangles( var_12 );
            var_5 = 1;
        }
    }

    var_13 = undefined;
    var_14 = undefined;

    if ( isdefined( var_1 ) && isdefined( var_1.type ) )
    {
        var_14 = swim_getapproachtype( var_1 );

        if ( var_14 != "exposed" )
        {
            var_13 = "exit_" + var_14;
            var_2 = var_1.angles;

            if ( animscripts\utility::isspaceai() )
            {
                var_2 = animscripts\utility::gettruenodeangles( var_1 );

                if ( var_5 == 1 )
                    var_2 = ( var_2[0], var_2[1], 0 );
            }
            else
                var_2 = var_1.angles;

            var_3 = 1;
        }
    }

    if ( !isdefined( var_13 ) )
    {
        if ( var_0 )
            var_13 = "idle_ready_to_forward";
        else
        {
            var_13 = "idle_to_forward";
            var_4 = 1;
            var_3 = 1;
        }
    }

    var_15 = getswimanim( var_13 );
    var_16 = angleclamp180( var_6[1] - var_2[1] );
    var_17 = angleclamp180( var_6[0] - var_2[0] );
    var_18 = undefined;

    if ( animscripts\utility::isspaceai() )
        var_18 = 3;

    var_19 = swim_getangleindex( var_16, var_18 );
    var_20 = swim_getangleindex( var_17, var_18 );
    var_21 = var_14;

    if ( !isdefined( var_21 ) && isdefined( self.prevnode ) && distance2dsquared( self.prevnode.origin, self.origin ) < 36 )
        var_21 = swim_getapproachtype( self.prevnode );

    if ( var_19 == 4 && isdefined( var_21 ) )
    {
        var_22 = isdefined( var_14 );

        if ( var_21 == "cover_corner_l" && var_16 < -10 && ( !var_22 || isdefined( var_15[2] ) ) )
            var_19 = 2;
        else if ( var_21 == "cover_corner_r" && var_16 > 10 && ( !var_22 || isdefined( var_15[6] ) ) )
            var_19 = 6;
    }

    if ( !isdefined( var_15[var_19] ) )
    {
        var_13 = "idle_to_forward";
        var_15 = getswimanim( var_13 );
        var_4 = 1;
    }

    var_23 = spawnstruct();

    if ( var_4 )
    {
        var_24 = getswimanim( "idle_turn" );

        if ( !isdefined( var_24[var_19] ) )
        {
            var_25 = 0;

            for ( var_26 = 8; !isdefined( var_15[var_25] ) && var_25 < 8; var_25++ )
            {

            }

            while ( !isdefined( var_15[var_26] ) && var_26 > 0 )
                var_26--;

            if ( var_19 < var_25 )
                var_19 = var_25;
            else if ( var_19 > var_26 )
                var_19 = var_26;
        }

        var_23.m_turnanim = var_24[var_19];
        var_19 = 4;
    }

    if ( isdefined( var_15[var_19] ) && isdefined( var_15[var_19][var_20] ) )
    {
        var_23.m_anim = var_15[var_19][var_20];

        if ( var_3 )
        {
            var_15 = getswimanim( var_13 + "_angleDelta" );
            var_23.m_angledelta = var_15[var_19][var_20];
        }
        else
            var_23.m_angledelta = ( 0, 0, 0 );

        return var_23;
    }

    var_23 = undefined;
    return undefined;
}

swim_setupapproach()
{
    self endon( "killanimscript" );
    self endon( "swim_cancelapproach" );
    thread swim_restartapproachlistener();

    if ( isdefined( self.disablearrivals ) && self.disablearrivals )
        return;

    self.swim.arrivalpathgoalpos = self.pathgoalpos;

    if ( isdefined( self getnegotiationstartnode() ) )
        return;

    var_0 = animscripts\cover_arrival::getapproachent();

    if ( isdefined( var_0 ) && swim_isapproachablenode( var_0 ) )
        thread swim_approachnode();
    else
        thread swim_approachpos();
}

swim_restartapproachlistener()
{
    self endon( "killanimscript" );
    self endon( "swim_killrestartlistener" );
    self waittill( "path_set" );
    var_0 = isdefined( self.pathgoalpos ) && isdefined( self.swim.arrivalpathgoalpos ) && distancesquared( self.pathgoalpos, self.swim.arrivalpathgoalpos ) < 4;

    if ( var_0 )
    {
        thread swim_restartapproachlistener();
        return;
    }

    swim_cancelcurrentapproach();
    swim_setupapproach();
}

swim_cancelcurrentapproach()
{
    self notify( "swim_cancelapproach" );
    self.stopanimdistsq = 0;
}

swim_waitforapproachpos( var_0, var_1 )
{
    self endon( "swim_cancelwaitforapproachpos" );
    var_2 = ( var_1 + 60 ) * ( var_1 + 60 );
    var_3 = distancesquared( var_0, self.origin );

    if ( var_3 <= var_2 )
        return;

    self.stopanimdistsq = var_2;
    self waittill( "stop_soon" );
    self.stopanimdistsq = 0;
}

swim_approachpos()
{
    self endon( "killanimscript" );
    self endon( "swim_cancelapproach" );
    self endon( "move_interrupt" );
    self endon( "swim_killrestartlistener" );

    if ( !isdefined( self.pathgoalpos ) )
        return;

    var_0 = swim_getmaxanimdist( "arrival_exposed" );
    swim_waitforapproachpos( self.pathgoalpos, var_0 );
    swim_doposarrival();
}

swim_approachnode()
{
    self endon( "killanimscript" );
    self endon( "swim_cancelapproach" );
    self endon( "swim_killrestartlistener" );
    var_0 = animscripts\cover_arrival::getapproachent();
    self.approachtype = swim_getapproachtype( var_0 );
    self.requestarrivalnotify = 1;
    self waittill( "cover_approach", var_1 );
    var_0 = animscripts\cover_arrival::getapproachent();
    var_2 = swim_getapproachtype( var_0 );

    if ( var_2 == "exposed" )
    {
        if ( isdefined( var_0 ) )
            var_3 = var_0.origin;
        else
            var_3 = self.pathgoalpos;

        var_4 = var_3 - self.origin;
        var_5 = vectortoangles( var_4 );
        var_6 = ( 0, var_5[1], 0 );
        var_7 = ( 0, var_5[1], 0 );
    }
    else
    {
        var_3 = var_0.origin;
        var_6 = getnodeforwardangles( var_0 );

        if ( animscripts\utility::isspaceai() )
            var_7 = animscripts\utility::gettruenodeangles( var_0 );
        else
            var_7 = var_0.angles;
    }

    thread swim_dofinalarrival( var_2, var_3, var_1, var_7, var_6 );
}

swim_doposarrival()
{
    var_0 = animscripts\cover_arrival::getapproachent();
    var_1 = self.pathgoalpos;
    var_2 = ( 0, self.angles[1], self.angles[2] );

    if ( isdefined( var_0 ) && var_0.type != "Path" && var_0.type != "Path 3D" )
        var_2 = getnodeforwardangles( var_0 );
    else if ( animscripts\cover_arrival::faceenemyatendofapproach() )
        var_2 = vectortoangles( self.enemy.origin - var_1 );

    var_3 = vectornormalize( var_1 - self.origin );

    if ( isdefined( var_0 ) && swim_isapproachablenode( var_0 ) )
    {
        var_4 = swim_getapproachtype( var_0 );
        var_5 = getnodeforwardangles( var_0 );
        var_2 = var_0.angles;

        if ( animscripts\utility::isspaceai() )
            var_2 = animscripts\utility::gettruenodeangles( var_0 );

        thread swim_dofinalarrival( var_4, var_0.origin, var_3, var_2, var_5 );
        return;
    }

    thread swim_dofinalarrival( "exposed", var_1, var_3, var_2, var_2 );
}

swim_determineapproachanim3d( var_0, var_1, var_2, var_3, var_4, var_5 )
{
    if ( animscripts\utility::isspaceai() )
    {
        var_6 = ( 0, 0, 0 );
        var_7 = ( 0, 0, 0 );
        var_8 = combineangles( invertangles( var_4 ), var_5 );
        var_9 = rotatevectorinverted( vectornormalize( self.origin - var_2 ), var_4 ) * -1.0;
        var_10 = swim_determineapproachanim( var_0, var_1, var_6, var_9, var_7, var_8, 1, var_2, var_4 );

        if ( var_10 )
            var_0.m_worldstartpos = rotatevector( var_0.m_worldstartpos, var_4 ) + var_2;

        return var_10;
    }
    else
        return swim_determineapproachanim( var_0, var_1, var_2, var_3, var_4, var_5, 0 );
}

swim_dofinalarrival( var_0, var_1, var_2, var_3, var_4 )
{
    self endon( "killanimscript" );
    self endon( "swim_cancelapproach" );
    self.approachtype = var_0;
    var_5 = spawnstruct();

    if ( !swim_determineapproachanim3d( var_5, var_0, var_1, var_2, var_3, var_4 ) )
        return;

    var_6 = anglestoforward( self.angles );
    var_7 = var_5.m_worldstartpos - self.origin;
    var_8 = length( var_7 );
    var_7 = var_7 / var_8;

    if ( animscripts\utility::isspaceai() )
    {
        var_9 = var_1 - var_5.m_worldstartpos;
        var_10 = length( var_9 );
        var_11 = vectordot( var_7, var_6 );

        if ( var_8 > var_10 * 0.4 && vectordot( var_7, var_6 ) < 0.5 )
        {
            self notify( "force_space_rotation_update", 0, 0 );
            return;
        }
    }
    else if ( var_8 < 100 && vectordot( var_7, var_6 ) < 0.5 )
        return;

    if ( var_8 > 4 )
    {
        if ( var_8 < 12 || self.fixednode || !isdefined( self.node ) || !animscripts\cover_arrival::isthreatenedbyenemy() )
        {
            self.swim.arrivalpathgoalpos = var_5.m_worldstartpos;
            self setruntopos( var_5.m_worldstartpos );

            if ( animscripts\utility::isspaceai() )
            {
                var_12 = 16384;

                for (;;)
                {
                    if ( distancesquared( self.origin, var_5.m_worldstartpos ) < var_12 )
                    {
                        self.prevturnrate = self.turnrate;
                        self.turnrate = 0.1;
                        var_13 = calculatestartorientation( var_5.m_delta, var_5.m_angledelta, var_1, var_4 );
                        self notify( "force_space_rotation_update", 0, 0, var_13[1] );
                        break;
                    }

                    wait 0.1;
                }
            }

            self waittill( "runto_arrived" );
        }
    }

    self notify( "swim_killrestartlistener" );
    var_14 = vectornormalize( var_1 - self.origin );

    if ( !swim_determineapproachanim3d( var_5, var_0, var_1, var_14, var_3, var_4 ) )
        return;

    self.swim.arrivalanim = var_5.m_anim;

    if ( animscripts\utility::isspaceai() )
        var_15 = self startcoverarrival( var_5.m_worldstartpos, var_4[1] - var_5.m_angledelta[1], var_4[0] - var_5.m_angledelta[0], var_4, var_5.m_angledelta );
    else
        self startcoverarrival( var_5.m_worldstartpos, var_4[1] - var_5.m_angledelta[1], var_4[0] - var_5.m_angledelta[0] );
}

swim_coverarrival_main()
{
    self endon( "killanimscript" );
    self endon( "abort_approach" );
    var_0 = "arrival_" + self.approachtype;
    var_1 = self.swim.arrivalanim;

    if ( !self.fixednode )
        thread animscripts\cover_arrival::abortapproachifthreatened();

    var_2 = 0.4;

    if ( animscripts\utility::isspaceai() )
    {
        var_2 = 0.2;
        thread space_arrival_turnrate_delay();
    }

    self clearanim( %body, 0.2 );
    self setflaggedanimrestart( "coverArrival", var_1, 1, var_2, self.movetransitionrate );
    animscripts\shared::donotetracks( "coverArrival", ::swim_handlestartcoveraim );

    if ( !animhasnotetrack( var_1, "start_aim" ) )
        swim_startcoveraim();

    self.a.pose = "stand";
    self.a.movement = "stop";
    self.a.arrivaltype = self.approachtype;

    if ( animscripts\utility::isspaceai() )
    {
        self.turnrate = 0.16;
        self.prevturnrate = undefined;
    }

    self clearanim( %root, 0.3 );
    self.lastapproachaborttime = undefined;
    self.swim.arrivalanim = undefined;

    if ( animscripts\utility::isspaceai() && self.approachtype == "exposed" )
        self notify( "force_space_rotation_update", 0, 0, undefined, 1 );
}

space_arrival_turnrate_delay()
{
    self endon( "killanimscript" );
    self endon( "abort_approach" );
    wait 0.22;
    self.prevturnrate = 0.16;
    self.turnrate = 5.0;
}

swim_getanimstartpos( var_0, var_1, var_2, var_3, var_4 )
{
    if ( var_4 )
    {
        var_5 = calculatestartorientation( var_2, var_3, var_0, var_1 );
        return var_5[0];
    }

    var_6 = var_1 - var_3;
    var_7 = anglestoforward( var_6 );
    var_8 = anglestoright( var_6 );
    var_9 = anglestoup( var_6 );
    var_10 = var_7 * var_2[0];
    var_11 = var_8 * var_2[1];
    var_12 = var_9 * var_2[2];
    return var_0 - var_10 + var_11 - var_12;
}

swim_maymovefrompointtopoint( var_0, var_1, var_2, var_3, var_4 )
{
    if ( var_2 )
    {
        var_1 = rotatevector( var_1, var_4 ) + var_3;
        return self maymovefrompointtopoint( var_3, var_1, 0, 1 );
    }

    return self maymovefrompointtopoint( var_0, var_1, 0, 1 );
}

swim_determineapproachanim( var_0, var_1, var_2, var_3, var_4, var_5, var_6, var_7, var_8 )
{
    if ( lengthsquared( var_3 ) < 0.003 )
        return 0;

    var_9 = vectortoangles( var_3 );

    if ( var_1 == "exposed" )
    {
        var_10 = 4;
        var_11 = 4;
    }
    else
    {
        var_12 = angleclamp180( var_4[1] - var_9[1] );
        var_10 = swim_getangleindex( var_12 );
        var_11 = swim_getangleindex( var_12, 25 );
    }

    var_13 = angleclamp180( var_4[0] - var_9[0] );
    var_14 = swim_getangleindex( var_13 );
    var_15 = swim_getangleindex( var_13, 25 );
    var_16 = "arrival_" + var_1;

    if ( var_1 == "exposed" && !animscripts\utility::isincombat( 0 ) )
        var_16 = var_16 + "_noncombat";

    var_17 = getswimanim( var_16 );

    if ( !isdefined( var_17[var_10] ) || !isdefined( var_17[var_10][var_14] ) )
        return 0;

    var_18 = ( var_10 != var_11 || var_14 != var_15 ) && isdefined( var_17[var_11] ) && isdefined( var_17[var_11][var_15] );
    var_19 = 0;
    var_20 = 0;
    var_21 = undefined;
    var_22 = var_17[var_10][var_14];

    if ( var_18 )
        var_21 = var_17[var_11][var_15];

    var_23 = var_16 + "_delta";
    var_17 = getswimanim( var_23 );
    var_24 = var_17[var_10][var_14];

    if ( var_18 )
        var_19 = var_17[var_11][var_15];

    var_25 = var_16 + "_angleDelta";
    var_17 = getswimanim( var_25 );
    var_26 = var_17[var_10][var_14];

    if ( var_18 )
        var_20 = var_17[var_11][var_15];

    var_27 = swim_getanimstartpos( var_2, var_5, var_24, var_26, var_6 );

    if ( !swim_maymovefrompointtopoint( var_2, var_27, var_6, var_7, var_8 ) && var_18 && !animscripts\utility::isspaceai() )
    {
        var_22 = var_21;
        var_24 = var_19;
        var_26 = var_20;
        var_27 = swim_getanimstartpos( var_2, var_5, var_24, var_26, var_6 );

        if ( !swim_maymovefrompointtopoint( var_2, var_27, var_6, var_7, var_8 ) )
            return 0;
    }

    var_0.m_anim = var_22;
    var_0.m_delta = var_24;
    var_0.m_angledelta = var_26;
    var_0.m_worldstartpos = var_27;
    return 1;
}

swim_getangleindex( var_0, var_1 )
{
    if ( !isdefined( var_1 ) )
        var_1 = 10;

    if ( var_0 < 0 )
        return int( ceil( ( 180 + var_0 - var_1 ) / 45 ) );
    else
        return int( floor( ( 180 + var_0 + var_1 ) / 45 ) );
}

swim_getmaxanimdist( var_0 )
{
    var_1 = anim.archetypes["soldier"]["swim"][var_0]["maxDelta"];

    if ( isdefined( self.animarchetype ) && self.animarchetype != "soldier" )
    {
        if ( isdefined( anim.archetypes[self.animarchetype]["swim"] ) && isdefined( anim.archetypes[self.animarchetype]["swim"][var_0] ) )
        {
            var_2 = anim.archetypes[self.animarchetype]["swim"][var_0]["maxDelta"];

            if ( var_2 > var_1 )
                var_1 = var_2;
        }
    }

    return var_1;
}

swim_startcoveraim()
{
    animscripts\animset::set_animarray_standing();
    animscripts\combat::set_aim_and_turn_limits();
    self.previouspitchdelta = 0.0;
    animscripts\combat_utility::setupaim( 0 );
    thread animscripts\track::trackshootentorpos();
}

swim_handlestartcoveraim( var_0 )
{
    if ( var_0 != "start_aim" )
        return;

    swim_startcoveraim();
}

swim_getapproachtype( var_0 )
{
    if ( !isdefined( var_0 ) )
        return "exposed";

    var_1 = var_0.type;

    if ( !isdefined( var_1 ) )
        return "exposed";

    switch ( var_1 )
    {
        case "Cover Right 3D":
            return "cover_corner_r";
        case "Cover Left 3D":
            return "cover_corner_l";
        case "Cover Up 3D":
            return "cover_u";
        case "Path 3D":
        case "Exposed 3D":
            return "exposed";
        default:
    }
}

getnodeforwardangles( var_0 )
{
    if ( getdvarint( "player_spaceEnabled" ) == 1 )
    {
        var_1 = animscripts\utility::gettruenodeangles( var_0 );

        if ( animscripts\utility::isnodecoverleft( var_0 ) )
        {
            var_2 = getswimanim( "arrival_cover_corner_l_angleDelta" );
            var_3 = var_2[4][4][1];
        }
        else if ( animscripts\utility::isnodecoverright( var_0 ) )
        {
            var_2 = getswimanim( "arrival_cover_corner_r_angleDelta" );
            var_3 = var_2[4][4][1];
        }
        else
            var_3 = 0;

        var_1 = combineangles( var_1, ( 0, var_3, 0 ) );
        return var_1;
    }
    else
        var_1 = var_0.angles;

    var_4 = var_1[1];

    if ( animscripts\utility::isnodecoverleft( var_0 ) )
    {
        var_2 = getswimanim( "arrival_cover_corner_l_angleDelta" );
        var_4 = var_4 + var_2[4][4][1];
    }
    else if ( animscripts\utility::isnodecoverright( var_0 ) )
    {
        var_2 = getswimanim( "arrival_cover_corner_r_angleDelta" );
        var_4 = var_4 + var_2[4][4][1];
    }

    var_1 = ( var_1[0], var_4, var_1[2] );
    return var_1;
}

swim_dostrafe()
{
    if ( self.swim.movestate != "combat_strafe" )
        moveswim_combat_move_set( "combat_strafe" );

    var_0 = getswimanim( "forward_aim" );
    self setflaggedanimknoblimited( "swimanim", var_0, 1, 0.1, 1, 1 );
    thread swim_updatestrafeanim();
    animscripts\notetracks::donotetracksfortime( 0.2, "swimanim" );
    self notify( "end_swim_updatestrafeanim" );
}

swim_updatestrafeanim()
{
    self endon( "killanimscript" );
    self endon( "move_interrupt" );
    self endon( "move_mode" );
    self endon( "move_loop_restart" );
    self endon( "end_swim_updatestrafeanim" );
    var_0 = 0;

    for (;;)
    {
        if ( self.facemotion )
        {
            if ( !var_0 )
            {
                swim_setstrafeweights( 1.0, 0.0, 0.0, 0.0 );
                swim_setstrafeaimweights( 0, 0, 0, 0 );
            }
        }
        else
        {
            if ( self.relativedir == 1 )
            {
                var_1 = [];
                var_1["front"] = 1;
                var_1["back"] = 0;
                var_1["left"] = 0;
                var_1["right"] = 0;
            }
            else
                var_1 = animscripts\utility::quadrantanimweights( self getmotionangle() );

            if ( isdefined( self.update_move_front_bias ) )
            {
                var_1["back"] = 0.0;

                if ( var_1["front"] < 0.2 )
                    var_1["front"] = 0.2;
            }

            var_2 = swim_setstrafeweights( var_1["front"], var_1["back"], var_1["left"], var_1["right"] );
            swim_setstrafeaimset( var_2 );
            swim_updatestrafeaimanim();
        }

        var_0 = self.facemotion;
        wait 0.05;
        waittillframeend;
    }
}

swim_getstrafeblendtime()
{
    if ( animscripts\utility::isspaceai() )
        return 0.5;
    else
        return 0.5;
}

swim_setstrafeweights( var_0, var_1, var_2, var_3 )
{
    var_4 = swim_getstrafeblendtime();
    self setanim( %combatrun_forward, var_0, var_4, 1, 1 );
    self setanim( %combatrun_backward, var_1, var_4, 1, 1 );
    self setanim( %combatrun_left, var_2, var_4, 1, 1 );
    self setanim( %combatrun_right, var_3, var_4, 1, 1 );

    if ( var_0 > 0 )
        return "front";
    else if ( var_1 > 0 )
        return "back";
    else if ( var_2 > 0 )
        return "left";
    else if ( var_3 > 0 )
        return "right";
}

swim_setstrafeaimset( var_0 )
{
    switch ( var_0 )
    {
        case "front":
            self setanimknoblimited( getswimanim( "aim_move_U" ), 1, 0.1 );
            self setanimknoblimited( getswimanim( "aim_move_D" ), 1, 0.1 );
            self setanimknoblimited( getswimanim( "aim_move_L" ), 1, 0.1 );
            self setanimknoblimited( getswimanim( "aim_move_R" ), 1, 0.1 );
            break;
        case "back":
            self setanimknoblimited( getswimanim( "strafe_B_aim_U" ), 1, 0.1 );
            self setanimknoblimited( getswimanim( "strafe_B_aim_D" ), 1, 0.1 );
            self setanimknoblimited( getswimanim( "strafe_B_aim_L" ), 1, 0.1 );
            self setanimknoblimited( getswimanim( "strafe_B_aim_R" ), 1, 0.1 );
            break;
        case "left":
            self setanimknoblimited( getswimanim( "strafe_L_aim_U" ), 1, 0.1 );
            self setanimknoblimited( getswimanim( "strafe_L_aim_D" ), 1, 0.1 );
            self setanimknoblimited( getswimanim( "strafe_L_aim_L" ), 1, 0.1 );
            self setanimknoblimited( getswimanim( "strafe_L_aim_R" ), 1, 0.1 );
            break;
        case "right":
            self setanimknoblimited( getswimanim( "strafe_R_aim_U" ), 1, 0.1 );
            self setanimknoblimited( getswimanim( "strafe_R_aim_D" ), 1, 0.1 );
            self setanimknoblimited( getswimanim( "strafe_R_aim_L" ), 1, 0.1 );
            self setanimknoblimited( getswimanim( "strafe_R_aim_R" ), 1, 0.1 );
            break;
        default:
    }
}

swim_updatestrafeaimanim()
{
    var_0 = self.angles[1];
    var_1 = self.angles[0];
    var_2 = 0;
    var_3 = 0;
    var_4 = 0;
    var_5 = 0;
    var_6 = 45;
    var_7 = 60;

    if ( isdefined( self.enemy ) )
    {
        var_8 = self.enemy.origin - self.origin;
        var_9 = vectortoangles( var_8 );
        var_10 = angleclamp180( var_9[1] - var_0 );
        var_11 = angleclamp180( var_9[0] - var_1 );

        if ( var_10 > 0 )
            var_4 = clamp( 1 - ( var_6 - var_10 ) / var_6, 0, 1 );
        else
            var_5 = clamp( 1 - ( var_6 + var_10 ) / var_6, 0, 1 );

        if ( var_11 > 0 )
            var_3 = clamp( 1 - ( var_7 - var_11 ) / var_7, 0, 1 );
        else
            var_2 = clamp( 1 - ( var_7 + var_11 ) / var_7, 0, 1 );
    }

    swim_setstrafeaimweights( var_2, var_3, var_4, var_5 );
}

swim_setstrafeaimweights( var_0, var_1, var_2, var_3 )
{
    self setanim( %w_aim_4, var_2, 0.2, 1, 1 );
    self setanim( %w_aim_6, var_3, 0.2, 1, 1 );
    self setanim( %w_aim_8, var_0, 0.2, 1, 1 );
    self setanim( %w_aim_2, var_1, 0.2, 1, 1 );
}

swim_pathchange_getturnanim( var_0, var_1 )
{
    var_2 = undefined;
    var_3 = undefined;
    var_4 = getswimanim( "turn" );
    var_5 = swim_getangleindex( var_0 );
    var_6 = swim_getangleindex( var_1 );

    if ( isdefined( var_4[var_5] ) )
        var_2 = var_4[var_5][var_6];

    if ( var_5 == 4 )
    {
        if ( var_6 > 4 && isdefined( var_4[4][var_6 + 1] ) )
            var_2 = var_4[4][var_6 + 1];
        else if ( var_6 < 4 && var_6 > 0 && isdefined( var_4[4][var_6 - 1] ) )
            var_2 = var_4[4][var_6 - 1];
    }

    if ( !isdefined( var_2 ) )
        var_2 = var_4[var_5][4];

    if ( isdefined( var_2 ) )
    {
        if ( animscripts\move::pathchange_candoturnanim( var_2 ) )
            return var_2;
    }

    return undefined;
}

swim_cleanupturnanim()
{
    moveswim_set( "nostate" );
}

swim_updateleananim()
{
    var_0 = clamp( self.leanamount / 20.0, -1, 1 );

    if ( var_0 > 0 )
    {
        if ( self.prevleanfracyaw <= 0 && var_0 < 0.075 )
            var_0 = 0;

        self setanim( %add_turn_l, var_0, 0.2, 1, 1 );
        self setanim( %add_turn_r, 0.0, 0.2, 1, 1 );
    }
    else
    {
        if ( self.prevleanfracyaw >= 0 && var_0 > -0.075 )
            var_0 = 0;

        self setanim( %add_turn_l, 0, 0.2, 1, 1 );
        self setanim( %add_turn_r, 0 - var_0, 0.2, 1, 1 );
    }

    self.prevleanfracyaw = var_0;
    var_0 = clamp( self.pitchamount / 25.0, -1, 1 );

    if ( var_0 > 0 )
    {
        if ( self.prevleanfracpitch <= 0 && var_0 < 0.075 )
            var_0 = 0;

        self setanim( %add_turn_d, var_0, 0.2, 1, 1 );
        self setanim( %add_turn_u, 0.0, 0.2, 1, 1 );
    }
    else
    {
        if ( self.prevleanfracpitch >= 0 && var_0 > -0.075 )
            var_0 = 0;

        self setanim( %add_turn_d, 0, 0.2, 1, 1 );
        self setanim( %add_turn_u, 0 - var_0, 0.2, 1, 1 );
    }

    self.prevleanfracpitch = var_0;
}

swim_isapproachablenode( var_0 )
{
    switch ( var_0.type )
    {
        case "Exposed 3D":
        case "Cover Right 3D":
        case "Cover Left 3D":
        case "Cover Up 3D":
            return 1;
    }

    return 0;
}

space_getdefaultturnrate()
{
    return 0.16;
}

space_getorientturnrate()
{
    return 0.1;
}