mirror of
https://github.com/InfinityLoader/IL-GSC.git
synced 2025-06-07 17:17:50 -05:00
1639 lines
34 KiB
Plaintext
1639 lines
34 KiB
Plaintext
/*******************************************************************
|
|
* Decompiled By: Bog
|
|
* Decompiled File: swim.gsc
|
|
* Game: Call of Duty: Advanced Warfare
|
|
* Platform: PC
|
|
* Function Count: 63
|
|
* Decompile Time: 920 ms
|
|
* Timestamp: 4/22/2024 2:01:03 AM
|
|
*******************************************************************/
|
|
|
|
//Function Number: 1
|
|
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();
|
|
return;
|
|
}
|
|
|
|
moveswim_noncombat();
|
|
}
|
|
|
|
//Function Number: 2
|
|
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;
|
|
}
|
|
|
|
//Function Number: 3
|
|
swim_end()
|
|
{
|
|
self.swim = undefined;
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
self.turnrate = 0.16;
|
|
return;
|
|
}
|
|
|
|
self.turnrate = 0.3;
|
|
}
|
|
|
|
//Function Number: 4
|
|
swim_null()
|
|
{
|
|
}
|
|
|
|
//Function Number: 5
|
|
swim_moveend()
|
|
{
|
|
moveswim_set("nostate");
|
|
swim_clearleananims();
|
|
if(isdefined(self.prevturnrate))
|
|
{
|
|
self.turnrate = self.prevturnrate;
|
|
self.prevturnrate = undefined;
|
|
}
|
|
}
|
|
|
|
//Function Number: 6
|
|
moveswim_noncombat()
|
|
{
|
|
if(self.swim.combatstate != "noncombat")
|
|
{
|
|
moveswim_set("noncombat");
|
|
}
|
|
|
|
var_00 = self.swim.move_noncombat_anim;
|
|
var_01 = 0.4;
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_01 = 0.2;
|
|
}
|
|
|
|
self setflaggedanimknob("swimanim",var_00,1,var_01,self.moveplaybackrate);
|
|
swim_updateleananim();
|
|
animscripts\notetracks::donotetracksfortime(0.2,"swimanim");
|
|
}
|
|
|
|
//Function Number: 7
|
|
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_00 = vectortoangles(self.velocity);
|
|
if(abs(angleclamp180(var_00[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_01 = getswimanim("forward_aim");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(self.swim.movestate != "combat_forward")
|
|
{
|
|
moveswim_combat_move_set("combat_forward");
|
|
}
|
|
|
|
animscripts\run::setshootwhilemoving(0);
|
|
var_01 = getswimanim("forward_aim");
|
|
}
|
|
|
|
var_02 = 0.4;
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_02 = 0.2;
|
|
}
|
|
|
|
swim_updateleananim();
|
|
self setflaggedanimknob("swimanim",var_01,1,var_02,self.moveplaybackrate);
|
|
animscripts\notetracks::donotetracksfortime(0.2,"swimanim");
|
|
}
|
|
|
|
//Function Number: 8
|
|
moveswim_set(param_00)
|
|
{
|
|
if(param_00 == self.swim.combatstate)
|
|
{
|
|
return;
|
|
}
|
|
|
|
[[ self.swim.statefns[self.swim.combatstate][1] ]]();
|
|
[[ self.swim.statefns[param_00][0] ]]();
|
|
self.swim.combatstate = param_00;
|
|
}
|
|
|
|
//Function Number: 9
|
|
moveswim_noncombat_enter()
|
|
{
|
|
if(self.swim.trackstate != "track_none")
|
|
{
|
|
swim_track_set("track_none");
|
|
}
|
|
|
|
swim_setleananims();
|
|
thread moveswim_noncombat_twitchupdate();
|
|
}
|
|
|
|
//Function Number: 10
|
|
moveswim_noncombat_exit()
|
|
{
|
|
self notify("end_MoveSwim_NonCombat_TwitchUpdate");
|
|
}
|
|
|
|
//Function Number: 11
|
|
moveswim_combat_enter()
|
|
{
|
|
self setanimknob(%combatrun,1,0.5,self.moveplaybackrate);
|
|
if(self.swim.movestate != "combat_forward")
|
|
{
|
|
moveswim_combat_move_set("combat_forward");
|
|
}
|
|
}
|
|
|
|
//Function Number: 12
|
|
moveswim_combat_exit()
|
|
{
|
|
moveswim_combat_move_set("combat_stationary");
|
|
}
|
|
|
|
//Function Number: 13
|
|
moveswim_combat_move_set(param_00)
|
|
{
|
|
if(param_00 == self.swim.movestate)
|
|
{
|
|
return;
|
|
}
|
|
|
|
[[ self.swim.statefns[self.swim.movestate][1] ]]();
|
|
[[ self.swim.statefns[param_00][0] ]]();
|
|
self.swim.movestate = param_00;
|
|
}
|
|
|
|
//Function Number: 14
|
|
moveswim_combat_forward_enter()
|
|
{
|
|
if(self.swim.trackstate != "track_forward")
|
|
{
|
|
swim_track_set("track_forward");
|
|
}
|
|
|
|
swim_setleananims();
|
|
}
|
|
|
|
//Function Number: 15
|
|
moveswim_combat_forward_exit()
|
|
{
|
|
}
|
|
|
|
//Function Number: 16
|
|
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;
|
|
return;
|
|
}
|
|
|
|
self.turnrate = 0.18;
|
|
self.jumping = 1;
|
|
}
|
|
|
|
//Function Number: 17
|
|
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;
|
|
}
|
|
|
|
//Function Number: 18
|
|
swim_track_set(param_00)
|
|
{
|
|
if(self.swim.trackstate == param_00)
|
|
{
|
|
return;
|
|
}
|
|
|
|
[[ self.swim.statefns[self.swim.trackstate][1] ]]();
|
|
[[ self.swim.statefns[param_00][0] ]]();
|
|
self.swim.trackstate = param_00;
|
|
}
|
|
|
|
//Function Number: 19
|
|
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();
|
|
}
|
|
|
|
//Function Number: 20
|
|
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);
|
|
}
|
|
|
|
//Function Number: 21
|
|
swim_track_strafe_enter()
|
|
{
|
|
}
|
|
|
|
//Function Number: 22
|
|
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);
|
|
}
|
|
|
|
//Function Number: 23
|
|
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);
|
|
}
|
|
}
|
|
|
|
//Function Number: 24
|
|
getswimanim(param_00,param_01)
|
|
{
|
|
var_02 = animscripts\utility::lookupanim("swim",param_00);
|
|
if(isdefined(param_01))
|
|
{
|
|
return var_02[param_01];
|
|
}
|
|
|
|
return var_02;
|
|
}
|
|
|
|
//Function Number: 25
|
|
moveswim_noncombat_twitchupdate()
|
|
{
|
|
var_00 = getswimanim("forward");
|
|
self.swim.move_noncombat_anim = var_00;
|
|
}
|
|
|
|
//Function Number: 26
|
|
swim_shoulddonodeexit()
|
|
{
|
|
if(isdefined(self.disableexits))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if(!isdefined(self.pathgoalpos))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
var_00 = self.maxfaceenemydist;
|
|
self.maxfaceenemydist = 128;
|
|
if(!self shouldfacemotion())
|
|
{
|
|
self.maxfaceenemydist = var_00;
|
|
return 0;
|
|
}
|
|
|
|
self.maxfaceenemydist = var_00;
|
|
var_01 = 10000;
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_01 = 32400;
|
|
}
|
|
|
|
if(distancesquared(self.origin,self.pathgoalpos) < var_01)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if(self.a.movement != "stop")
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if(lengthsquared(self.prevanimdelta) > 1)
|
|
{
|
|
var_02 = vectortoangles(self.prevanimdelta);
|
|
if(abs(angleclamp180(var_02[1] - self.angles[1])) < 90)
|
|
{
|
|
var_03 = vectortoangles(self.lookaheaddir);
|
|
if(abs(angleclamp180(var_03[1] - self.angles[1])) < 90)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
//Function Number: 27
|
|
swim_movebegin()
|
|
{
|
|
self.a.pose = "stand";
|
|
if(!swim_shoulddonodeexit())
|
|
{
|
|
return;
|
|
}
|
|
|
|
var_00 = swim_choosestart();
|
|
if(!isdefined(var_00))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var_01 = var_00.m_turnanim;
|
|
var_02 = var_00.m_anim;
|
|
var_03 = var_00.m_angledelta;
|
|
var_04 = vectortoangles(self.lookaheaddir);
|
|
var_05 = var_04 - var_03;
|
|
var_06 = anglestoforward(var_05);
|
|
var_07 = animscripts\exit_node::getexitnode();
|
|
if(animscripts\utility::isspaceai() && isdefined(var_07))
|
|
{
|
|
var_08 = swim_getapproachtype(var_07);
|
|
if(var_08 != "exposed")
|
|
{
|
|
var_09 = getnodeforwardangles(var_07);
|
|
var_06 = anglestoforward(var_09);
|
|
}
|
|
else
|
|
{
|
|
var_06 = anglestoforward(self.angles);
|
|
}
|
|
}
|
|
|
|
self animmode("nogravity",0);
|
|
var_0A = randomfloatrange(0.9,1.1);
|
|
var_0B = 0.3;
|
|
self orientmode("face angle 3d",self.angles);
|
|
if(isdefined(var_01) && !animscripts\utility::isspaceai())
|
|
{
|
|
self setflaggedanimknoballrestart("startturn",var_01,%body,1,0.3,var_0A * self.moveplaybackrate);
|
|
animscripts\shared::donotetracks("startturn");
|
|
var_0B = 0.5;
|
|
}
|
|
else if(isdefined(var_01) && animscripts\utility::isspaceai())
|
|
{
|
|
if(isdefined(var_07))
|
|
{
|
|
self orientmode("face direction",var_06);
|
|
}
|
|
|
|
self.prevturnrate = 0.16;
|
|
self.turnrate = 5;
|
|
var_0B = 0.1;
|
|
self setflaggedanimknoballrestart("startturn",var_01,%body,1,var_0B,var_0A * self.moveplaybackrate);
|
|
animscripts\shared::donotetracks("startturn");
|
|
var_0B = 0.5;
|
|
self.turnrate = 0.16;
|
|
self.prevturnrate = undefined;
|
|
var_0C = getangledelta(var_01);
|
|
var_07 = animscripts\exit_node::getexitnode();
|
|
var_06 = anglestoforward(self.angles);
|
|
if(isdefined(var_07))
|
|
{
|
|
var_08 = swim_getapproachtype(var_07);
|
|
if(var_08 != "exposed")
|
|
{
|
|
var_09 = getnodeforwardangles(var_07);
|
|
var_09 = (var_09[0],var_09[1] - var_0C,var_09[2]);
|
|
var_06 = anglestoforward(var_09);
|
|
}
|
|
}
|
|
}
|
|
|
|
var_0D = var_04 - self.angles;
|
|
var_0E = getanimlength(var_02);
|
|
var_0F = 0.001 * abs(angleclamp180(var_0D[1] - var_03[1])) / var_0E;
|
|
var_10 = 0.001 * abs(angleclamp180(var_0D[0] - var_03[0])) / var_0E;
|
|
var_11 = max(var_0F,var_10);
|
|
if(var_11 < 0.01)
|
|
{
|
|
var_11 = 0.01;
|
|
}
|
|
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_0B = 0.05;
|
|
self.turnrate = 0.16;
|
|
var_11 = 5;
|
|
}
|
|
|
|
self.prevturnrate = self.turnrate;
|
|
self.turnrate = var_11;
|
|
self orientmode("face direction",var_06);
|
|
self setflaggedanimknoballrestart("startmove",var_02,%body,1,var_0B,var_0A * 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_02,"finish"))
|
|
{
|
|
animscripts\shared::donotetracks("startmove");
|
|
}
|
|
|
|
var_12 = 65536;
|
|
var_13 = self.goalpos;
|
|
if(isdefined(self.node))
|
|
{
|
|
var_13 = self.node.origin;
|
|
}
|
|
|
|
if(distance2dsquared(self.origin,var_13) > var_12)
|
|
{
|
|
self notify("force_space_rotation_update",0,0,undefined,1);
|
|
}
|
|
}
|
|
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
return 0.2;
|
|
}
|
|
|
|
return 0.4;
|
|
}
|
|
|
|
//Function Number: 28
|
|
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;
|
|
}
|
|
|
|
//Function Number: 29
|
|
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;
|
|
}
|
|
|
|
//Function Number: 30
|
|
swim_choosestart()
|
|
{
|
|
var_00 = animscripts\utility::isincombat();
|
|
var_01 = animscripts\exit_node::getexitnode();
|
|
var_02 = self.angles;
|
|
var_03 = 0;
|
|
var_04 = 0;
|
|
var_05 = 0;
|
|
var_06 = vectortoangles(self.lookaheaddir);
|
|
var_07 = animscripts\utility::gettruenodeangles(var_01);
|
|
if(animscripts\utility::isspaceai() && var_07[2])
|
|
{
|
|
if(var_07[2] != 0)
|
|
{
|
|
var_08 = anglestoforward(var_07);
|
|
var_09 = self.goalpos;
|
|
if(isdefined(self.node))
|
|
{
|
|
var_09 = self.node.origin;
|
|
}
|
|
|
|
var_0A = rotatepointaroundvector(var_08,var_09 - self.origin,var_07[2] * -1);
|
|
var_0B = var_0A + self.origin;
|
|
var_0C = var_0B - self.origin;
|
|
var_0C = vectornormalize(var_0C);
|
|
var_06 = vectortoangles(var_0C);
|
|
var_05 = 1;
|
|
}
|
|
}
|
|
|
|
var_0D = undefined;
|
|
var_0E = undefined;
|
|
if(isdefined(var_01) && isdefined(var_01.type))
|
|
{
|
|
var_0E = swim_getapproachtype(var_01);
|
|
if(var_0E != "exposed")
|
|
{
|
|
var_0D = "exit_" + var_0E;
|
|
var_02 = var_01.angles;
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_02 = animscripts\utility::gettruenodeangles(var_01);
|
|
if(var_05 == 1)
|
|
{
|
|
var_02 = (var_02[0],var_02[1],0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var_02 = var_01.angles;
|
|
}
|
|
|
|
var_03 = 1;
|
|
}
|
|
}
|
|
|
|
if(!isdefined(var_0D))
|
|
{
|
|
if(var_00)
|
|
{
|
|
var_0D = "idle_ready_to_forward";
|
|
}
|
|
else
|
|
{
|
|
var_0D = "idle_to_forward";
|
|
var_04 = 1;
|
|
var_03 = 1;
|
|
}
|
|
}
|
|
|
|
var_0F = getswimanim(var_0D);
|
|
var_10 = angleclamp180(var_06[1] - var_02[1]);
|
|
var_11 = angleclamp180(var_06[0] - var_02[0]);
|
|
var_12 = undefined;
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_12 = 3;
|
|
}
|
|
|
|
var_13 = swim_getangleindex(var_10,var_12);
|
|
var_14 = swim_getangleindex(var_11,var_12);
|
|
var_15 = var_0E;
|
|
if(!isdefined(var_15) && isdefined(self.prevnode) && distance2dsquared(self.prevnode.origin,self.origin) < 36)
|
|
{
|
|
var_15 = swim_getapproachtype(self.prevnode);
|
|
}
|
|
|
|
if(var_13 == 4 && isdefined(var_15))
|
|
{
|
|
var_16 = isdefined(var_0E);
|
|
if(var_15 == "cover_corner_l" && var_10 < -10 && !var_16 || isdefined(var_0F[2]))
|
|
{
|
|
var_13 = 2;
|
|
}
|
|
else if(var_15 == "cover_corner_r" && var_10 > 10 && !var_16 || isdefined(var_0F[6]))
|
|
{
|
|
var_13 = 6;
|
|
}
|
|
}
|
|
|
|
if(!isdefined(var_0F[var_13]))
|
|
{
|
|
var_0D = "idle_to_forward";
|
|
var_0F = getswimanim(var_0D);
|
|
var_04 = 1;
|
|
}
|
|
|
|
var_17 = spawnstruct();
|
|
if(var_04)
|
|
{
|
|
var_18 = getswimanim("idle_turn");
|
|
if(!isdefined(var_18[var_13]))
|
|
{
|
|
var_19 = 0;
|
|
var_1A = 8;
|
|
while(!isdefined(var_0F[var_19]) && var_19 < 8)
|
|
{
|
|
var_19++;
|
|
}
|
|
|
|
while(!isdefined(var_0F[var_1A]) && var_1A > 0)
|
|
{
|
|
var_1A--;
|
|
}
|
|
|
|
if(var_13 < var_19)
|
|
{
|
|
var_13 = var_19;
|
|
}
|
|
else if(var_13 > var_1A)
|
|
{
|
|
var_13 = var_1A;
|
|
}
|
|
}
|
|
|
|
var_17.m_turnanim = var_18[var_13];
|
|
var_13 = 4;
|
|
}
|
|
|
|
if(isdefined(var_0F[var_13]) && isdefined(var_0F[var_13][var_14]))
|
|
{
|
|
var_17.m_anim = var_0F[var_13][var_14];
|
|
if(var_03)
|
|
{
|
|
var_0F = getswimanim(var_0D + "_angleDelta");
|
|
var_17.m_angledelta = var_0F[var_13][var_14];
|
|
}
|
|
else
|
|
{
|
|
var_17.m_angledelta = (0,0,0);
|
|
}
|
|
|
|
return var_17;
|
|
}
|
|
|
|
var_17 = undefined;
|
|
return undefined;
|
|
}
|
|
|
|
//Function Number: 31
|
|
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_00 = animscripts\cover_arrival::getapproachent();
|
|
if(isdefined(var_00) && swim_isapproachablenode(var_00))
|
|
{
|
|
thread swim_approachnode();
|
|
return;
|
|
}
|
|
|
|
thread swim_approachpos();
|
|
}
|
|
|
|
//Function Number: 32
|
|
swim_restartapproachlistener()
|
|
{
|
|
self endon("killanimscript");
|
|
self endon("swim_killrestartlistener");
|
|
self waittill("path_set");
|
|
var_00 = isdefined(self.pathgoalpos) && isdefined(self.swim.arrivalpathgoalpos) && distancesquared(self.pathgoalpos,self.swim.arrivalpathgoalpos) < 4;
|
|
if(var_00)
|
|
{
|
|
thread swim_restartapproachlistener();
|
|
return;
|
|
}
|
|
|
|
swim_cancelcurrentapproach();
|
|
swim_setupapproach();
|
|
}
|
|
|
|
//Function Number: 33
|
|
swim_cancelcurrentapproach()
|
|
{
|
|
self notify("swim_cancelapproach");
|
|
self.stopanimdistsq = 0;
|
|
}
|
|
|
|
//Function Number: 34
|
|
swim_waitforapproachpos(param_00,param_01)
|
|
{
|
|
self endon("swim_cancelwaitforapproachpos");
|
|
var_02 = param_01 + 60 * param_01 + 60;
|
|
var_03 = distancesquared(param_00,self.origin);
|
|
if(var_03 <= var_02)
|
|
{
|
|
return;
|
|
}
|
|
|
|
self.stopanimdistsq = var_02;
|
|
self waittill("stop_soon");
|
|
self.stopanimdistsq = 0;
|
|
}
|
|
|
|
//Function Number: 35
|
|
swim_approachpos()
|
|
{
|
|
self endon("killanimscript");
|
|
self endon("swim_cancelapproach");
|
|
self endon("move_interrupt");
|
|
self endon("swim_killrestartlistener");
|
|
if(!isdefined(self.pathgoalpos))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var_00 = swim_getmaxanimdist("arrival_exposed");
|
|
swim_waitforapproachpos(self.pathgoalpos,var_00);
|
|
swim_doposarrival();
|
|
}
|
|
|
|
//Function Number: 36
|
|
swim_approachnode()
|
|
{
|
|
self endon("killanimscript");
|
|
self endon("swim_cancelapproach");
|
|
self endon("swim_killrestartlistener");
|
|
var_00 = animscripts\cover_arrival::getapproachent();
|
|
self.approachtype = swim_getapproachtype(var_00);
|
|
self.requestarrivalnotify = 1;
|
|
self waittill("cover_approach",var_01);
|
|
var_00 = animscripts\cover_arrival::getapproachent();
|
|
var_02 = swim_getapproachtype(var_00);
|
|
if(var_02 == "exposed")
|
|
{
|
|
if(isdefined(var_00))
|
|
{
|
|
var_03 = var_00.origin;
|
|
}
|
|
else
|
|
{
|
|
var_03 = self.pathgoalpos;
|
|
}
|
|
|
|
var_04 = var_03 - self.origin;
|
|
var_05 = vectortoangles(var_04);
|
|
var_06 = (0,var_05[1],0);
|
|
var_07 = (0,var_05[1],0);
|
|
}
|
|
else
|
|
{
|
|
var_03 = var_03.origin;
|
|
var_06 = getnodeforwardangles(var_02);
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_07 = animscripts\utility::gettruenodeangles(var_01);
|
|
}
|
|
else
|
|
{
|
|
var_07 = var_01.angles;
|
|
}
|
|
}
|
|
|
|
thread swim_dofinalarrival(var_02,var_03,var_01,var_07,var_06);
|
|
}
|
|
|
|
//Function Number: 37
|
|
swim_doposarrival()
|
|
{
|
|
var_00 = animscripts\cover_arrival::getapproachent();
|
|
var_01 = self.pathgoalpos;
|
|
var_02 = (0,self.angles[1],self.angles[2]);
|
|
if(isdefined(var_00) && var_00.type != "Path" && var_00.type != "Path 3D")
|
|
{
|
|
var_02 = getnodeforwardangles(var_00);
|
|
}
|
|
else if(animscripts\cover_arrival::faceenemyatendofapproach())
|
|
{
|
|
var_02 = vectortoangles(self.enemy.origin - var_01);
|
|
}
|
|
|
|
var_03 = vectornormalize(var_01 - self.origin);
|
|
if(isdefined(var_00) && swim_isapproachablenode(var_00))
|
|
{
|
|
var_04 = swim_getapproachtype(var_00);
|
|
var_05 = getnodeforwardangles(var_00);
|
|
var_02 = var_00.angles;
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_02 = animscripts\utility::gettruenodeangles(var_00);
|
|
}
|
|
|
|
thread swim_dofinalarrival(var_04,var_00.origin,var_03,var_02,var_05);
|
|
return;
|
|
}
|
|
|
|
thread swim_dofinalarrival("exposed",var_03,var_05,var_04,var_04);
|
|
}
|
|
|
|
//Function Number: 38
|
|
swim_determineapproachanim3d(param_00,param_01,param_02,param_03,param_04,param_05)
|
|
{
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_06 = (0,0,0);
|
|
var_07 = (0,0,0);
|
|
var_08 = combineangles(invertangles(param_04),param_05);
|
|
var_09 = rotatevectorinverted(vectornormalize(self.origin - param_02),param_04) * -1;
|
|
var_0A = swim_determineapproachanim(param_00,param_01,var_06,var_09,var_07,var_08,1,param_02,param_04);
|
|
if(var_0A)
|
|
{
|
|
param_00.m_worldstartpos = rotatevector(param_00.m_worldstartpos,param_04) + param_02;
|
|
}
|
|
|
|
return var_0A;
|
|
}
|
|
|
|
return swim_determineapproachanim(param_05,var_06,var_07,var_08,var_09,var_0A,0);
|
|
}
|
|
|
|
//Function Number: 39
|
|
swim_dofinalarrival(param_00,param_01,param_02,param_03,param_04)
|
|
{
|
|
self endon("killanimscript");
|
|
self endon("swim_cancelapproach");
|
|
self.approachtype = param_00;
|
|
var_05 = spawnstruct();
|
|
if(!swim_determineapproachanim3d(var_05,param_00,param_01,param_02,param_03,param_04))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var_06 = anglestoforward(self.angles);
|
|
var_07 = var_05.m_worldstartpos - self.origin;
|
|
var_08 = length(var_07);
|
|
var_07 = var_07 / var_08;
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_09 = param_01 - var_05.m_worldstartpos;
|
|
var_0A = length(var_09);
|
|
var_0B = vectordot(var_07,var_06);
|
|
if(var_08 > var_0A * 0.4 && vectordot(var_07,var_06) < 0.5)
|
|
{
|
|
self notify("force_space_rotation_update",0,0);
|
|
return;
|
|
}
|
|
}
|
|
else if(var_08 < 100 && vectordot(var_07,var_06) < 0.5)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(var_08 > 4)
|
|
{
|
|
if(var_08 < 12 || self.fixednode || !isdefined(self.node) || !animscripts\cover_arrival::isthreatenedbyenemy())
|
|
{
|
|
self.swim.arrivalpathgoalpos = var_05.m_worldstartpos;
|
|
self setruntopos(var_05.m_worldstartpos);
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_0C = 16384;
|
|
for(;;)
|
|
{
|
|
if(distancesquared(self.origin,var_05.m_worldstartpos) < var_0C)
|
|
{
|
|
self.prevturnrate = self.turnrate;
|
|
self.turnrate = 0.1;
|
|
var_0D = calculatestartorientation(var_05.m_delta,var_05.m_angledelta,param_01,param_04);
|
|
self notify("force_space_rotation_update",0,0,var_0D[1]);
|
|
break;
|
|
}
|
|
|
|
wait(0.1);
|
|
}
|
|
}
|
|
|
|
self waittill("runto_arrived");
|
|
}
|
|
}
|
|
|
|
self notify("swim_killrestartlistener");
|
|
var_0E = vectornormalize(param_01 - self.origin);
|
|
if(!swim_determineapproachanim3d(var_05,param_00,param_01,var_0E,param_03,param_04))
|
|
{
|
|
return;
|
|
}
|
|
|
|
self.swim.arrivalanim = var_05.m_anim;
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_0F = self startcoverarrival(var_05.m_worldstartpos,param_04[1] - var_05.m_angledelta[1],param_04[0] - var_05.m_angledelta[0],param_04,var_05.m_angledelta);
|
|
return;
|
|
}
|
|
|
|
self startcoverarrival(var_05.m_worldstartpos,param_04[1] - var_05.m_angledelta[1],param_04[0] - var_05.m_angledelta[0]);
|
|
}
|
|
|
|
//Function Number: 40
|
|
swim_coverarrival_main()
|
|
{
|
|
self endon("killanimscript");
|
|
self endon("abort_approach");
|
|
var_00 = "arrival_" + self.approachtype;
|
|
var_01 = self.swim.arrivalanim;
|
|
if(!self.fixednode)
|
|
{
|
|
thread animscripts\cover_arrival::abortapproachifthreatened();
|
|
}
|
|
|
|
var_02 = 0.4;
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
var_02 = 0.2;
|
|
thread space_arrival_turnrate_delay();
|
|
}
|
|
|
|
self clearanim(%body,0.2);
|
|
self setflaggedanimrestart("coverArrival",var_01,1,var_02,self.movetransitionrate);
|
|
animscripts\shared::donotetracks("coverArrival",::swim_handlestartcoveraim);
|
|
if(!animhasnotetrack(var_01,"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(%animscript_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);
|
|
}
|
|
}
|
|
|
|
//Function Number: 41
|
|
space_arrival_turnrate_delay()
|
|
{
|
|
self endon("killanimscript");
|
|
self endon("abort_approach");
|
|
wait(0.22);
|
|
self.prevturnrate = 0.16;
|
|
self.turnrate = 5;
|
|
}
|
|
|
|
//Function Number: 42
|
|
swim_getanimstartpos(param_00,param_01,param_02,param_03,param_04)
|
|
{
|
|
if(param_04)
|
|
{
|
|
var_05 = calculatestartorientation(param_02,param_03,param_00,param_01);
|
|
return var_05[0];
|
|
}
|
|
|
|
var_06 = param_02 - param_04;
|
|
var_07 = anglestoforward(var_06);
|
|
var_08 = anglestoright(var_06);
|
|
var_09 = anglestoup(var_06);
|
|
var_0A = var_07 * param_03[0];
|
|
var_0B = var_08 * param_03[1];
|
|
var_0C = var_09 * param_03[2];
|
|
return param_01 - var_0A + var_0B - var_0C;
|
|
}
|
|
|
|
//Function Number: 43
|
|
swim_maymovefrompointtopoint(param_00,param_01,param_02,param_03,param_04)
|
|
{
|
|
if(param_02)
|
|
{
|
|
param_01 = rotatevector(param_01,param_04) + param_03;
|
|
return self maymovefrompointtopoint(param_03,param_01,0,1);
|
|
}
|
|
|
|
return self maymovefrompointtopoint(param_00,param_01,0,1);
|
|
}
|
|
|
|
//Function Number: 44
|
|
swim_determineapproachanim(param_00,param_01,param_02,param_03,param_04,param_05,param_06,param_07,param_08)
|
|
{
|
|
if(lengthsquared(param_03) < 0.003)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
var_09 = vectortoangles(param_03);
|
|
if(param_01 == "exposed")
|
|
{
|
|
var_0A = 4;
|
|
var_0B = 4;
|
|
}
|
|
else
|
|
{
|
|
var_0C = angleclamp180(param_06[1] - var_0B[1]);
|
|
var_0A = swim_getangleindex(var_0C);
|
|
var_0B = swim_getangleindex(var_0C,25);
|
|
}
|
|
|
|
var_0D = angleclamp180(param_04[0] - var_09[0]);
|
|
var_0E = swim_getangleindex(var_0D);
|
|
var_0F = swim_getangleindex(var_0D,25);
|
|
var_10 = "arrival_" + param_01;
|
|
if(param_01 == "exposed" && !animscripts\utility::isincombat(0))
|
|
{
|
|
var_10 = var_10 + "_noncombat";
|
|
}
|
|
|
|
var_11 = getswimanim(var_10);
|
|
if(!isdefined(var_11[var_0A]) || !isdefined(var_11[var_0A][var_0E]))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
var_12 = (var_0A != var_0B || var_0E != var_0F) && isdefined(var_11[var_0B]) && isdefined(var_11[var_0B][var_0F]);
|
|
var_13 = 0;
|
|
var_14 = 0;
|
|
var_15 = undefined;
|
|
var_16 = var_11[var_0A][var_0E];
|
|
if(var_12)
|
|
{
|
|
var_15 = var_11[var_0B][var_0F];
|
|
}
|
|
|
|
var_17 = var_10 + "_delta";
|
|
var_11 = getswimanim(var_17);
|
|
var_18 = var_11[var_0A][var_0E];
|
|
if(var_12)
|
|
{
|
|
var_13 = var_11[var_0B][var_0F];
|
|
}
|
|
|
|
var_19 = var_10 + "_angleDelta";
|
|
var_11 = getswimanim(var_19);
|
|
var_1A = var_11[var_0A][var_0E];
|
|
if(var_12)
|
|
{
|
|
var_14 = var_11[var_0B][var_0F];
|
|
}
|
|
|
|
var_1B = swim_getanimstartpos(param_02,param_05,var_18,var_1A,param_06);
|
|
if(!swim_maymovefrompointtopoint(param_02,var_1B,param_06,param_07,param_08) && var_12 && !animscripts\utility::isspaceai())
|
|
{
|
|
var_16 = var_15;
|
|
var_18 = var_13;
|
|
var_1A = var_14;
|
|
var_1B = swim_getanimstartpos(param_02,param_05,var_18,var_1A,param_06);
|
|
if(!swim_maymovefrompointtopoint(param_02,var_1B,param_06,param_07,param_08))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
param_00.m_anim = var_16;
|
|
param_00.m_delta = var_18;
|
|
param_00.m_angledelta = var_1A;
|
|
param_00.m_worldstartpos = var_1B;
|
|
return 1;
|
|
}
|
|
|
|
//Function Number: 45
|
|
swim_getangleindex(param_00,param_01)
|
|
{
|
|
if(!isdefined(param_01))
|
|
{
|
|
param_01 = 10;
|
|
}
|
|
|
|
if(param_00 < 0)
|
|
{
|
|
return int(ceil(180 + param_00 - param_01 / 45));
|
|
}
|
|
|
|
return int(floor(180 + param_00 + param_01 / 45));
|
|
}
|
|
|
|
//Function Number: 46
|
|
swim_getmaxanimdist(param_00)
|
|
{
|
|
var_01 = level.archetypes["soldier"]["swim"][param_00]["maxDelta"];
|
|
if(isdefined(self.animarchetype) && self.animarchetype != "soldier")
|
|
{
|
|
if(isdefined(level.archetypes[self.animarchetype]["swim"]) && isdefined(level.archetypes[self.animarchetype]["swim"][param_00]))
|
|
{
|
|
var_02 = level.archetypes[self.animarchetype]["swim"][param_00]["maxDelta"];
|
|
if(var_02 > var_01)
|
|
{
|
|
var_01 = var_02;
|
|
}
|
|
}
|
|
}
|
|
|
|
return var_01;
|
|
}
|
|
|
|
//Function Number: 47
|
|
swim_startcoveraim()
|
|
{
|
|
animscripts\animset::set_animarray_standing();
|
|
animscripts\combat::set_aim_and_turn_limits();
|
|
self.previouspitchdelta = 0;
|
|
animscripts\combat_utility::setupaim(0);
|
|
thread animscripts\track::trackshootentorpos();
|
|
}
|
|
|
|
//Function Number: 48
|
|
swim_handlestartcoveraim(param_00)
|
|
{
|
|
if(param_00 != "start_aim")
|
|
{
|
|
return;
|
|
}
|
|
|
|
swim_startcoveraim();
|
|
}
|
|
|
|
//Function Number: 49
|
|
swim_getapproachtype(param_00)
|
|
{
|
|
if(!isdefined(param_00))
|
|
{
|
|
return "exposed";
|
|
}
|
|
|
|
var_01 = param_00.type;
|
|
if(!isdefined(var_01))
|
|
{
|
|
return "exposed";
|
|
}
|
|
|
|
switch(var_01)
|
|
{
|
|
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:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Function Number: 50
|
|
getnodeforwardangles(param_00)
|
|
{
|
|
if(getdvarint("player_spaceEnabled") == 1)
|
|
{
|
|
var_01 = animscripts\utility::gettruenodeangles(param_00);
|
|
if(animscripts\utility::isnodecoverleft(param_00))
|
|
{
|
|
var_02 = getswimanim("arrival_cover_corner_l_angleDelta");
|
|
var_03 = var_02[4][4][1];
|
|
}
|
|
else if(animscripts\utility::isnodecoverright(var_01))
|
|
{
|
|
var_02 = getswimanim("arrival_cover_corner_r_angleDelta");
|
|
var_03 = var_02[4][4][1];
|
|
}
|
|
else
|
|
{
|
|
var_03 = 0;
|
|
}
|
|
|
|
var_01 = combineangles(var_01,(0,var_03,0));
|
|
return var_01;
|
|
}
|
|
else
|
|
{
|
|
var_01 = var_03.angles;
|
|
}
|
|
|
|
var_04 = var_03[1];
|
|
if(animscripts\utility::isnodecoverleft(var_01))
|
|
{
|
|
var_02 = getswimanim("arrival_cover_corner_l_angleDelta");
|
|
var_04 = var_04 + var_02[4][4][1];
|
|
}
|
|
else if(animscripts\utility::isnodecoverright(var_01))
|
|
{
|
|
var_02 = getswimanim("arrival_cover_corner_r_angleDelta");
|
|
var_04 = var_04 + var_02[4][4][1];
|
|
}
|
|
|
|
var_03 = (var_03[0],var_04,var_03[2]);
|
|
return var_03;
|
|
}
|
|
|
|
//Function Number: 51
|
|
swim_dostrafe()
|
|
{
|
|
if(self.swim.movestate != "combat_strafe")
|
|
{
|
|
moveswim_combat_move_set("combat_strafe");
|
|
}
|
|
|
|
var_00 = getswimanim("forward_aim");
|
|
self setflaggedanimknoblimited("swimanim",var_00,1,0.1,1,1);
|
|
thread swim_updatestrafeanim();
|
|
animscripts\notetracks::donotetracksfortime(0.2,"swimanim");
|
|
self notify("end_swim_updatestrafeanim");
|
|
}
|
|
|
|
//Function Number: 52
|
|
swim_updatestrafeanim()
|
|
{
|
|
self endon("killanimscript");
|
|
self endon("move_interrupt");
|
|
self endon("move_mode");
|
|
self endon("move_loop_restart");
|
|
self endon("end_swim_updatestrafeanim");
|
|
var_00 = 0;
|
|
for(;;)
|
|
{
|
|
if(self.facemotion)
|
|
{
|
|
if(!var_00)
|
|
{
|
|
swim_setstrafeweights(1,0,0,0);
|
|
swim_setstrafeaimweights(0,0,0,0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(self.relativedir == 1)
|
|
{
|
|
var_01 = [];
|
|
var_01["front"] = 1;
|
|
var_01["back"] = 0;
|
|
var_01["left"] = 0;
|
|
var_01["right"] = 0;
|
|
}
|
|
else
|
|
{
|
|
var_01 = animscripts\utility::quadrantanimweights(self getmotionangle());
|
|
}
|
|
|
|
if(isdefined(self.update_move_front_bias))
|
|
{
|
|
var_01["back"] = 0;
|
|
if(var_01["front"] < 0.2)
|
|
{
|
|
var_01["front"] = 0.2;
|
|
}
|
|
}
|
|
|
|
var_02 = swim_setstrafeweights(var_01["front"],var_01["back"],var_01["left"],var_01["right"]);
|
|
swim_setstrafeaimset(var_02);
|
|
swim_updatestrafeaimanim();
|
|
}
|
|
|
|
var_00 = self.facemotion;
|
|
wait(0.05);
|
|
waittillframeend;
|
|
}
|
|
}
|
|
|
|
//Function Number: 53
|
|
swim_getstrafeblendtime()
|
|
{
|
|
if(animscripts\utility::isspaceai())
|
|
{
|
|
return 0.5;
|
|
}
|
|
|
|
return 0.5;
|
|
}
|
|
|
|
//Function Number: 54
|
|
swim_setstrafeweights(param_00,param_01,param_02,param_03)
|
|
{
|
|
var_04 = swim_getstrafeblendtime();
|
|
self setanim(%combatrun_forward,param_00,var_04,1,1);
|
|
self setanim(%combatrun_backward,param_01,var_04,1,1);
|
|
self setanim(%combatrun_left,param_02,var_04,1,1);
|
|
self setanim(%combatrun_right,param_03,var_04,1,1);
|
|
if(param_00 > 0)
|
|
{
|
|
return "front";
|
|
}
|
|
|
|
if(param_01 > 0)
|
|
{
|
|
return "back";
|
|
}
|
|
|
|
if(param_02 > 0)
|
|
{
|
|
return "left";
|
|
}
|
|
|
|
if(param_03 > 0)
|
|
{
|
|
return "right";
|
|
}
|
|
}
|
|
|
|
//Function Number: 55
|
|
swim_setstrafeaimset(param_00)
|
|
{
|
|
switch(param_00)
|
|
{
|
|
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:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Function Number: 56
|
|
swim_updatestrafeaimanim()
|
|
{
|
|
var_00 = self.angles[1];
|
|
var_01 = self.angles[0];
|
|
var_02 = 0;
|
|
var_03 = 0;
|
|
var_04 = 0;
|
|
var_05 = 0;
|
|
var_06 = 45;
|
|
var_07 = 60;
|
|
if(isdefined(self.enemy))
|
|
{
|
|
var_08 = self.enemy.origin - self.origin;
|
|
var_09 = vectortoangles(var_08);
|
|
var_0A = angleclamp180(var_09[1] - var_00);
|
|
var_0B = angleclamp180(var_09[0] - var_01);
|
|
if(var_0A > 0)
|
|
{
|
|
var_04 = clamp(1 - var_06 - var_0A / var_06,0,1);
|
|
}
|
|
else
|
|
{
|
|
var_05 = clamp(1 - var_06 + var_0A / var_06,0,1);
|
|
}
|
|
|
|
if(var_0B > 0)
|
|
{
|
|
var_03 = clamp(1 - var_07 - var_0B / var_07,0,1);
|
|
}
|
|
else
|
|
{
|
|
var_02 = clamp(1 - var_07 + var_0B / var_07,0,1);
|
|
}
|
|
}
|
|
|
|
swim_setstrafeaimweights(var_02,var_03,var_04,var_05);
|
|
}
|
|
|
|
//Function Number: 57
|
|
swim_setstrafeaimweights(param_00,param_01,param_02,param_03)
|
|
{
|
|
self setanim(%w_aim_4,param_02,0.2,1,1);
|
|
self setanim(%w_aim_6,param_03,0.2,1,1);
|
|
self setanim(%w_aim_8,param_00,0.2,1,1);
|
|
self setanim(%w_aim_2,param_01,0.2,1,1);
|
|
}
|
|
|
|
//Function Number: 58
|
|
swim_pathchange_getturnanim(param_00,param_01)
|
|
{
|
|
var_02 = undefined;
|
|
var_03 = undefined;
|
|
var_04 = getswimanim("turn");
|
|
var_05 = swim_getangleindex(param_00);
|
|
var_06 = swim_getangleindex(param_01);
|
|
if(isdefined(var_04[var_05]))
|
|
{
|
|
var_02 = var_04[var_05][var_06];
|
|
}
|
|
|
|
if(var_05 == 4)
|
|
{
|
|
if(var_06 > 4 && isdefined(var_04[4][var_06 + 1]))
|
|
{
|
|
var_02 = var_04[4][var_06 + 1];
|
|
}
|
|
else if(var_06 < 4 && var_06 > 0 && isdefined(var_04[4][var_06 - 1]))
|
|
{
|
|
var_02 = var_04[4][var_06 - 1];
|
|
}
|
|
}
|
|
|
|
if(!isdefined(var_02))
|
|
{
|
|
var_02 = var_04[var_05][4];
|
|
}
|
|
|
|
if(isdefined(var_02))
|
|
{
|
|
if(animscripts\move::pathchange_candoturnanim(var_02))
|
|
{
|
|
return var_02;
|
|
}
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
//Function Number: 59
|
|
swim_cleanupturnanim()
|
|
{
|
|
moveswim_set("nostate");
|
|
}
|
|
|
|
//Function Number: 60
|
|
swim_updateleananim()
|
|
{
|
|
var_00 = clamp(self.leanamount / 20,-1,1);
|
|
if(var_00 > 0)
|
|
{
|
|
if(self.prevleanfracyaw <= 0 && var_00 < 0.075)
|
|
{
|
|
var_00 = 0;
|
|
}
|
|
|
|
self setanim(%add_turn_l,var_00,0.2,1,1);
|
|
self setanim(%add_turn_r,0,0.2,1,1);
|
|
}
|
|
else
|
|
{
|
|
if(self.prevleanfracyaw >= 0 && var_00 > -0.075)
|
|
{
|
|
var_00 = 0;
|
|
}
|
|
|
|
self setanim(%add_turn_l,0,0.2,1,1);
|
|
self setanim(%add_turn_r,0 - var_00,0.2,1,1);
|
|
}
|
|
|
|
self.prevleanfracyaw = var_00;
|
|
var_00 = clamp(self.pitchamount / 25,-1,1);
|
|
if(var_00 > 0)
|
|
{
|
|
if(self.prevleanfracpitch <= 0 && var_00 < 0.075)
|
|
{
|
|
var_00 = 0;
|
|
}
|
|
|
|
self setanim(%add_turn_d,var_00,0.2,1,1);
|
|
self setanim(%add_turn_u,0,0.2,1,1);
|
|
}
|
|
else
|
|
{
|
|
if(self.prevleanfracpitch >= 0 && var_00 > -0.075)
|
|
{
|
|
var_00 = 0;
|
|
}
|
|
|
|
self setanim(%add_turn_d,0,0.2,1,1);
|
|
self setanim(%add_turn_u,0 - var_00,0.2,1,1);
|
|
}
|
|
|
|
self.prevleanfracpitch = var_00;
|
|
}
|
|
|
|
//Function Number: 61
|
|
swim_isapproachablenode(param_00)
|
|
{
|
|
switch(param_00.type)
|
|
{
|
|
case "Exposed 3D":
|
|
case "Cover Right 3D":
|
|
case "Cover Left 3D":
|
|
case "Cover Up 3D":
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//Function Number: 62
|
|
space_getdefaultturnrate()
|
|
{
|
|
return 0.16;
|
|
}
|
|
|
|
//Function Number: 63
|
|
space_getorientturnrate()
|
|
{
|
|
return 0.1;
|
|
} |