828 lines
27 KiB
Text
828 lines
27 KiB
Text
// general movement code
|
|
extend Class Demolitionist
|
|
{
|
|
bool IsRunning()
|
|
{
|
|
// for analog move, check for full sprint speed
|
|
if ( isAnalogMoving )
|
|
return (NormalizedMove().length() >= (gameinfo.normforwardmove[1]*256.));
|
|
return !!(player.cmd.buttons&BT_RUN);
|
|
}
|
|
|
|
// directional movement without straferunning
|
|
Vector2 NormalizedMove()
|
|
{
|
|
if ( !(player.cmd.forwardmove|player.cmd.sidemove) )
|
|
return (0,0);
|
|
int idx = !!(player.cmd.buttons&BT_RUN);
|
|
// ratio between forwardmove and sidemove (depending on BT_RUN state)
|
|
double fs = gameinfo.normforwardmove[idx]/gameinfo.normsidemove[idx];
|
|
// raw axes scaled to 1:1 ratio
|
|
Vector2 mvec = (player.cmd.forwardmove,-player.cmd.sidemove*fs);
|
|
// should we use raw analog movement?
|
|
if ( isAnalogMoving )
|
|
{
|
|
// straferun cap (lol sorry)
|
|
if ( mvec.length() > gameinfo.normforwardmove[idx]*256. )
|
|
mvec = mvec.unit()*gameinfo.normforwardmove[idx]*256.;
|
|
return mvec; // passed as-is otherwise
|
|
}
|
|
// multiply unit vector back to "raw" running speed (as TweakSpeed handles the "true" scaling for us later)
|
|
return mvec.unit()*gameinfo.normforwardmove[1]*256.;
|
|
}
|
|
|
|
double TweakSpeed()
|
|
{
|
|
double fact;
|
|
// when analog moving, lerp between factors (should feel ok?)
|
|
if ( isAnalogMoving )
|
|
{
|
|
double mscale = NormalizedMove().length();
|
|
double rspeed = gameinfo.normforwardmove[0]*256.;
|
|
double sspeed = gameinfo.normforwardmove[1]*256.;
|
|
if ( mscale < rspeed ) // between walking/running
|
|
fact = SWWMUtility.MapRange(0,rspeed,.08,.4,mscale);
|
|
else if ( mscale < sspeed ) // between running/sprinting
|
|
fact = SWWMUtility.MapRange(rspeed,sspeed,.4,1.1,mscale);
|
|
else fact = 1.1; // sprinting
|
|
}
|
|
else fact = bWalking?.08:IsRunning()?1.1:.4;
|
|
for ( Inventory i=Inv; i; i=i.Inv ) fact *= i.GetSpeedFactor();
|
|
return fact;
|
|
}
|
|
|
|
void LeaveFootprint( double yofs, bool foot )
|
|
{
|
|
Vector3 checkpos = level.Vec3Offset((pos.xy,floorz),(RotateVector((0,yofs*.25*radius),angle),0));
|
|
let s = level.PointInSector(checkpos.xy);
|
|
// part 1: leave a footprint
|
|
if ( footblood[foot] > 0. )
|
|
{
|
|
double zatstep = s.floorplane.ZAtPoint(checkpos.xy);
|
|
for ( int i=0; i<s.Get3DFloorCount(); i++ )
|
|
{
|
|
if ( !(s.Get3DFloor(i).flags&F3DFloor.FF_SOLID) ) continue;
|
|
double ffz = s.Get3DFloor(i).top.ZAtPoint(checkpos.xy);
|
|
if ( ffz > checkpos.z ) continue;
|
|
else if ( ffz < zatstep ) continue;
|
|
zatstep = ffz;
|
|
break;
|
|
}
|
|
if ( abs(floorz-zatstep) <= 8. )
|
|
{
|
|
let bs = Spawn("mkBloodStep",(checkpos.xy,zatstep));
|
|
bs.angle = angle;
|
|
bs.frame = foot;
|
|
bs.A_ChangeModel("",0,"","",0,"models/extra",String.Format("BloodFoot%d.png",Random[Blood](1,4)));
|
|
bs.alpha = min(1.,footblood[foot]);
|
|
bs.SetShade(footbloodcol[foot]);
|
|
}
|
|
footblood[foot] = max(0.,footblood[foot]*.95-.05);
|
|
}
|
|
// part 2: check for stepping on a blood pool, make feet bloody
|
|
if ( !hnd ) hnd = SWWMHandler(EventHandler.Find("SWWMHandler"));
|
|
for ( mkBloodPool p=hnd.bloodpools; p; p=p.nextpool )
|
|
{
|
|
// vertical distance fast check
|
|
if ( abs(checkpos.z-p.pos.z) > 8. )
|
|
continue;
|
|
// horizontal distance slower check
|
|
double distsq = level.Vec2Diff(checkpos.xy,p.pos.xy).lengthsquared();
|
|
if ( distsq > (p.radius*p.radius+.25*radius*radius) )
|
|
continue;
|
|
// muck it up, with some color mixing too
|
|
double oldblood = footblood[foot];
|
|
footblood[foot] = 2.;
|
|
footbloodcol[foot] = SWWMUtility.LerpColor(p.stepcol,footbloodcol[foot],min(1.,oldblood)*.75);
|
|
}
|
|
}
|
|
|
|
void PlayFootstep( double yofs, int run = 0, double vol = .3, bool nosplash = false )
|
|
{
|
|
if ( run == 2 )
|
|
{
|
|
A_StartSound("demolitionist/run",CHAN_FOOTSTEP,CHANF_OVERLAP,vol);
|
|
if ( !nosplash )
|
|
{
|
|
let b = Spawn("InvisibleSplasher",level.Vec3Offset(pos,(RotateVector((0,yofs*.25*radius),angle),0)));
|
|
b.target = self;
|
|
b.A_CheckTerrain();
|
|
}
|
|
}
|
|
else if ( run == 1 )
|
|
{
|
|
A_StartSound("demolitionist/walk",CHAN_FOOTSTEP,CHANF_OVERLAP,vol*.5);
|
|
if ( !nosplash )
|
|
{
|
|
let b = Spawn("InvisibleSplasher",level.Vec3Offset(pos,(RotateVector((0,yofs*.25*radius),angle),0)));
|
|
b.target = self;
|
|
b.A_CheckTerrain();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
A_StartSound("demolitionist/walk",CHAN_FOOTSTEP,CHANF_OVERLAP,vol*.2);
|
|
if ( !nosplash )
|
|
{
|
|
let b = Spawn("SmolInvisibleSplasher",level.Vec3Offset(pos,(RotateVector((0,yofs*.25*radius),angle),0)));
|
|
b.target = self;
|
|
b.A_CheckTerrain();
|
|
}
|
|
}
|
|
LeaveFootprint(yofs,yofs>0);
|
|
}
|
|
|
|
override void CalcHeight()
|
|
{
|
|
double defviewh = viewheight+player.crouchviewdelta;
|
|
oldbob = player.bob;
|
|
if ( bFlyCheat || (player.cheats&CF_NOCLIP2) )
|
|
player.bob = 0.;
|
|
else
|
|
player.bob = min((player.vel dot player.vel)*player.GetMoveBob(),MAXBOB);
|
|
if ( player.cheats&CF_NOVELOCITY )
|
|
{
|
|
player.viewz = pos.z+defviewh;
|
|
if ( player.viewz > ceilingz-4 )
|
|
player.viewz = ceilingz-4;
|
|
SetViewPos((0.,0.,0.));
|
|
return;
|
|
}
|
|
// adjust viewheight
|
|
if ( player.playerstate == PST_LIVE )
|
|
{
|
|
player.viewheight += player.deltaviewheight;
|
|
if ( player.viewheight > defviewh )
|
|
{
|
|
player.viewheight = defviewh;
|
|
player.deltaviewheight = 0.;
|
|
}
|
|
else if ( player.viewheight < (defviewh/2.) )
|
|
{
|
|
player.viewheight = defviewh/2.;
|
|
if ( player.deltaviewheight <= 0. )
|
|
player.deltaviewheight = 1./65536.;
|
|
}
|
|
if ( player.deltaviewheight )
|
|
{
|
|
player.deltaviewheight += .25;
|
|
if ( !player.deltaviewheight )
|
|
player.deltaviewheight = 1./65536.;
|
|
}
|
|
}
|
|
// apply bobbing (formula adapted from Unreal)
|
|
oldbobtime = bobtime;
|
|
double vel2d = vel.xy dot vel.xy;
|
|
bobtime += (1.8+.4*min(vel2d/100.,3.))/GameTicRate;
|
|
Vector2 bob = (sin(bobtime*180.),.5*sin(bobtime*360.))*player.bob*.35;
|
|
if ( player.morphtics )
|
|
bob = (0.,0.);
|
|
else if ( player.bob && !multiplayer && !(player.cheats&CF_CHASECAM)
|
|
&& player.onground && !bNoGravity && (player.crouchdir != -1)
|
|
&& (player.cmd.forwardmove|player.cmd.sidemove) )
|
|
{
|
|
// bob-based footsteps in first person
|
|
int m = int(2.*M_PI+oldbobtime);
|
|
int n = int(2.*M_PI+bobtime);
|
|
if ( m != n )
|
|
{
|
|
int side = (sin(bobtime*180.)>0.)?1:-1;
|
|
int spd = bWalking?0:IsRunning()?2:1;
|
|
PlayFootstep(side,spd);
|
|
}
|
|
}
|
|
// set up viewz
|
|
player.viewz = pos.z+player.viewheight+(bob.y*clamp(viewbob,0.,1.5));
|
|
// handle smooth step down (hacky but looks ok)
|
|
player.viewz += ssup;
|
|
ssup = max(0,(ssup*.7)-.25);
|
|
if ( floorclip && (player.playerstate != PST_DEAD) && (pos.z <= floorz) )
|
|
player.viewz -= floorclip;
|
|
if ( player.viewz > ceilingz-4 )
|
|
player.viewz = ceilingz-4;
|
|
if ( player.viewz < floorz+4 )
|
|
player.viewz = floorz+4;
|
|
// add viewpos Y for side bob (currently breaks SCALEDNOLERP)
|
|
SetViewPos((0.,bob.x*clamp(viewbob,0.,1.5),0.));
|
|
}
|
|
|
|
override void CheckPitch()
|
|
{
|
|
if ( bFly && !bFlyCheat && !(player.cheats&CF_NOCLIP2) )
|
|
{
|
|
if ( player.cmd.pitch == -32768 ) player.centering = true;
|
|
return; // the rest is handled in moveplayer
|
|
}
|
|
// fun fact: we can't override freelook disabling
|
|
// so... just call super, I guess
|
|
Super.CheckPitch();
|
|
}
|
|
|
|
override void CheckMoveUpDown()
|
|
{
|
|
if ( InStateSequence(CurState,FindState("Dash")) )
|
|
player.cmd.upmove = 0;
|
|
if ( bFly && !bFlyCheat && !(player.cheats&CF_NOCLIP2) )
|
|
{
|
|
double fs = TweakSpeed();
|
|
let [x, y, z] = SWWMUtility.GetAxes(angle,pitch,roll);
|
|
Vector3 accel;
|
|
if ( (player.cmd.upmove == -32768) || sendtoground )
|
|
{
|
|
sendtoground = true;
|
|
player.centering = true;
|
|
accel = (0,0,-4096);
|
|
}
|
|
else accel = z*player.cmd.upmove*8.;
|
|
accel *= fs/128.;
|
|
vel = vel+accel/GameTicRate;
|
|
if ( sendtoground ) vel.xy *= .6;
|
|
if ( (pos.z <= floorz) || bOnMobj ) sendtoground = false;
|
|
if ( vel.length() > 50. )
|
|
vel = vel.unit()*50.;
|
|
return;
|
|
}
|
|
else sendtoground = false;
|
|
Super.CheckMoveUpDown();
|
|
}
|
|
|
|
private bool ShouldDecelerate( Sector s )
|
|
{
|
|
// check if we can apply fast decel while standing on this sector
|
|
// (important to not break certain intended vanilla effects)
|
|
if ( bNOFRICTION )
|
|
return false; // we don't have friction at all (e.g.: while dashing)
|
|
if ( bWINDTHRUST && (s.special >= 40) && (s.special <= 51) )
|
|
return false; // wind
|
|
if ( (s.special == 84) || (s.special == 118) || ((s.special >= 201) && (s.special <= 244)) )
|
|
return false; // current
|
|
// TODO check for scroller thinkers if that ever gets exposed to ZScript
|
|
return true;
|
|
}
|
|
|
|
private Vector3 GetGroundNormal()
|
|
{
|
|
// find closest 3d floor for its normal
|
|
F3DFloor ff;
|
|
for ( int i=0; i<floorsector.Get3DFloorCount(); i++ )
|
|
{
|
|
ff = floorsector.Get3DFloor(i);
|
|
if ( !(ff.flags&F3DFloor.FF_SOLID) ) continue;
|
|
if ( !(ff.top.ZAtPoint(pos.xy) ~== floorz) ) continue;
|
|
return -ff.top.Normal;
|
|
}
|
|
// fall back to floorsector's normal
|
|
return floorsector.floorplane.Normal;
|
|
}
|
|
|
|
override void MovePlayer()
|
|
{
|
|
if ( !player || (player.mo != self) || (player.cheats&(CF_FROZEN|CF_TOTALLYFROZEN)) )
|
|
{
|
|
dashboost = 0.;
|
|
player.vel *= 0.;
|
|
if ( IsActorPlayingSound(CHAN_JETPACK,"demolitionist/jet") )
|
|
A_StartSound("demolitionist/jetstop",CHAN_JETPACK);
|
|
Super.MovePlayer();
|
|
return;
|
|
}
|
|
bool isdashing = InStateSequence(CurState,FindState("Dash"));
|
|
if ( isdashing ) player.cmd.forwardmove = player.cmd.sidemove = 0;
|
|
if ( bFly && !bFlyCheat && !(player.cheats&CF_NOCLIP2) )
|
|
{
|
|
player.cheats &= ~CF_SCALEDNOLERP; // we cannot permit this flag here
|
|
player.onground = false;
|
|
if ( player.turnticks )
|
|
{
|
|
player.turnticks--;
|
|
A_SetAngle(angle+(180./TURN180_TICKS),SPF_INTERPOLATE);
|
|
}
|
|
else guideangle += .2*player.cmd.yaw*(360./65536.);
|
|
guidepitch -= .2*player.cmd.pitch*(360./65536.);
|
|
if ( player.centering ) guidepitch = clamp(deltaangle(pitch,0),-3.,3.);
|
|
guideroll = clamp(deltaangle(roll,0),-3.,3.);
|
|
A_SetAngle(angle+guideangle,SPF_INTERPOLATE);
|
|
A_SetPitch(clamp(pitch+guidepitch,player.MinPitch,player.MaxPitch),SPF_INTERPOLATE);
|
|
A_SetRoll(roll+guideroll,SPF_INTERPOLATE);
|
|
if ( (abs(roll) <= 1./65536.) && (abs(pitch) <= 1./65536.) )
|
|
{
|
|
guideroll = guidepitch = roll = pitch = 0.;
|
|
player.centering = false;
|
|
}
|
|
double fs = TweakSpeed();
|
|
double jcmove = 0.;
|
|
if ( player.cmd.buttons&BT_JUMP ) jcmove += 4096.;
|
|
if ( player.cmd.buttons&BT_CROUCH ) jcmove -= 4096.;
|
|
if ( CanCrouch() && (player.crouchfactor != -1) ) fs *= player.crouchfactor;
|
|
let [x, y, z] = SWWMUtility.GetAxes(angle,pitch,roll);
|
|
Vector2 nmove = NormalizedMove();
|
|
Vector3 accel = x*nmove.x-y*nmove.y+z*jcmove;
|
|
accel *= fs/320.;
|
|
double spd = vel.length();
|
|
if ( spd > 40. ) vel = (vel+accel/GameTicRate).unit()*spd;
|
|
else vel = vel+accel/GameTicRate;
|
|
vel *= .95;
|
|
player.vel += RotateVector(nmove,angle)*cos(pitch)*16.;
|
|
player.jumptics = -2;
|
|
if ( !(player.cheats & CF_PREDICTING) && (player.cmd.forwardmove|player.cmd.sidemove) )
|
|
PlayRunning();
|
|
if ( player.cheats&CF_REVERTPLEASE )
|
|
{
|
|
player.cheats &= ~CF_REVERTPLEASE;
|
|
player.camera = player.mo;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( player.turnticks )
|
|
{
|
|
player.turnticks--;
|
|
A_SetAngle(angle+(180./TURN180_TICKS),SPF_INTERPOLATE);
|
|
}
|
|
else angle += player.cmd.yaw*(360./65536.);
|
|
player.onground = (pos.z<=floorz)||bOnMobj||bMBFBouncer||(player.cheats&CF_NOCLIP2);
|
|
let [friction, movefactor] = GetFriction();
|
|
if ( player.cmd.forwardmove|player.cmd.sidemove )
|
|
{
|
|
double bobfactor;
|
|
bobfactor = (friction<ORIG_FRICTION)?movefactor:ORIG_FRICTION_FACTOR;
|
|
if ( !player.onground && !bNoGravity )
|
|
{
|
|
// no air control here, done afterwards
|
|
movefactor *= 0.;
|
|
bobfactor *= 0.;
|
|
}
|
|
// use normalized movement vector, no SR40 (not that we need it with how fast we can run)
|
|
Vector2 nmove = NormalizedMove();
|
|
nmove *= TweakSpeed();
|
|
nmove *= Speed/256.;
|
|
// When crouching, speed and bobbing have to be reduced
|
|
if ( CanCrouch() && (player.crouchfactor != 1) )
|
|
{
|
|
nmove *= player.crouchfactor;
|
|
// don't reduce bob as much, there needs to be SOME visible bobbing
|
|
bobfactor *= (1.+player.crouchfactor)/2.;
|
|
}
|
|
nmove *= movefactor;
|
|
if ( bNOGRAVITY && !player.GetClassicFlight() )
|
|
{
|
|
Vector3 accel;
|
|
accel.xy = RotateVector(nmove,angle)*cos(pitch);
|
|
accel.z += nmove.x*sin(-pitch);
|
|
double maxspd = 16.*TweakSpeed();
|
|
// account for special cases where max speed is zero
|
|
double spdup = 1.;
|
|
if ( maxspd <= 0. ) vel += accel;
|
|
else
|
|
{
|
|
if ( CanCrouch() && (player.crouchfactor != 1) ) maxspd *= player.crouchfactor;
|
|
double spd = vel.length();
|
|
// quicker speedup
|
|
spdup = clamp(maxspd/max(.01,spd),1.,2.);
|
|
vel += accel*spdup;
|
|
// additional steering + quicker slow down
|
|
spd = vel.length();
|
|
if ( spd > maxspd ) spd -= (spd-maxspd)*.1;
|
|
vel = (vel+accel).unit()*spd;
|
|
}
|
|
player.vel += RotateVector(nmove,angle)*bobfactor*cos(pitch)*16.*spdup;
|
|
}
|
|
else if ( player.onground )
|
|
{
|
|
Vector2 accel = RotateVector(nmove,angle);
|
|
double maxspd = 16.*TweakSpeed();
|
|
// account for special cases where max speed is zero
|
|
// also, slippery if waist-high or deeper
|
|
double spdup = 1.;
|
|
if ( (waterlevel > 1) || (maxspd <= 0.) ) vel.xy += accel;
|
|
else
|
|
{
|
|
// factors for slippery floors (make steering harder)
|
|
double fact1 = SWWMUtility.MapRange(.90625,.97265625,2.,1.,friction);
|
|
fact1 = clamp(fact1,1.,2.);
|
|
double fact2 = SWWMUtility.MapRange(.90625,.97265625,1.,4.,friction);
|
|
fact2 = clamp(fact2,1.,4.);
|
|
if ( CanCrouch() && (player.crouchfactor != 1) ) maxspd *= player.crouchfactor;
|
|
double spd = vel.xy.length();
|
|
// quicker speedup
|
|
spdup = clamp(maxspd/max(.01,spd),1.,fact1);
|
|
vel.xy += accel*spdup;
|
|
// additional steering + quicker slow down
|
|
spd = vel.xy.length();
|
|
if ( spd > maxspd ) spd -= (spd-maxspd)*.1;
|
|
vel.xy = (vel.xy*fact2+accel).unit()*spd;
|
|
}
|
|
player.vel += RotateVector(nmove,angle)*bobfactor*16.*spdup;
|
|
}
|
|
else player.vel *= .75;
|
|
// override air control because we REALLY need the extra mobility
|
|
if ( !player.onground && !bNOGRAVITY )
|
|
{
|
|
nmove = NormalizedMove();
|
|
double fs = TweakSpeed();
|
|
if ( CanCrouch() && (player.crouchfactor != -1) ) fs *= player.crouchfactor;
|
|
Vector2 accel = RotateVector(nmove,angle);
|
|
accel *= fs/320.;
|
|
double spd = vel.xy.length();
|
|
double maxspd = fs*12.;
|
|
if ( spd > maxspd ) vel.xy = (vel.xy+accel/GameTicRate).unit()*spd;
|
|
else vel.xy = vel.xy+accel/GameTicRate;
|
|
}
|
|
if ( !(player.cheats&CF_PREDICTING) && (nmove.length() > 0.) )
|
|
PlayRunning();
|
|
if ( player.cheats&CF_REVERTPLEASE )
|
|
{
|
|
player.cheats &= ~CF_REVERTPLEASE;
|
|
player.camera = player.mo;
|
|
}
|
|
}
|
|
else if ( player.onground && ShouldDecelerate(floorsector) )
|
|
{
|
|
// quickly decelerate if we're not holding movement keys
|
|
// the default friction is mapped to a 70% reduction,
|
|
// while slippery floors (above 95%) will have no reduction at all
|
|
double fact = SWWMUtility.MapRange(.90625,.97265625,.7,1.,friction);
|
|
fact = clamp(fact,.6,1.); // ensure this doesn't go too far out of range (especially, prevent endless acceleration)
|
|
vel *= fact;
|
|
player.vel *= fact;
|
|
}
|
|
if ( abs(roll) > 0. ) roll += clamp(deltaangle(roll,0),-3.,3.);
|
|
}
|
|
guideangle *= .9;
|
|
guidepitch *= .9;
|
|
guideroll *= .9;
|
|
// anchor to ground when going down steps
|
|
if ( !hnd ) hnd = SWWMHandler(EventHandler.Find("SWWMHandler"));
|
|
if ( lastground && !player.onground && !bFly && !bFlyCheat && (abs(pos.z-floorz) <= maxdropoffheight) && (player.jumptics == 0) && (vel.z <= 0) && !isdashing && !hnd.nogroundanchor )
|
|
{
|
|
// test for gap crossing (i.e: climbing up platforms with holes between them)
|
|
Vector3 storepos = pos;
|
|
double storefloorz = floorz;
|
|
bool crossgap = false;
|
|
for ( int i=1; i<=4; i++ ) // test up to 4 steps ahead, should be enough for most cases
|
|
{
|
|
SetOrigin(Vec3Offset(vel.x,vel.y,vel.z),true);
|
|
if ( floorz < storepos.z ) continue;
|
|
crossgap = true;
|
|
break;
|
|
}
|
|
SetOrigin(storepos,true);
|
|
floorz = storefloorz;
|
|
if ( !crossgap )
|
|
{
|
|
ssup = max(0,(pos.z-floorz));
|
|
SetZ(floorz);
|
|
lastground = player.onground = true;
|
|
}
|
|
}
|
|
if ( player.onground ) lastgroundtic = level.maptime;
|
|
else lastairtic = level.maptime;
|
|
if ( !(player.cheats & CF_PREDICTING) && !(player.cmd.forwardmove|player.cmd.sidemove) )
|
|
PlayIdle();
|
|
if ( !(player.cmd.buttons&BT_USER2) || (gamestate != GS_LEVEL) || (dashcooldown > 0) || (dashfuel < 20.) )
|
|
return;
|
|
Vector3 dodge = (0,0,0);
|
|
let [x, y, z] = SWWMUtility.GetAxes(angle,pitch,roll);
|
|
int fm = player.cmd.forwardmove;
|
|
int sm = player.cmd.sidemove;
|
|
if ( !(fm|sm) ) fm = 1;
|
|
if ( fm ) dodge += (fm>0)?X:-X;
|
|
if ( sm ) dodge += (sm>0)?Y:-Y;
|
|
if ( dodge == (0,0,0) ) dodge = X; // do we really need this?
|
|
if ( player.onground && !bNOGRAVITY && !(player.cheats&CF_NOCLIP2) )
|
|
{
|
|
Vector3 fnorm = GetGroundNormal();
|
|
if ( dodge dot fnorm <= 0. )
|
|
{
|
|
// recalc and project onto floor normal
|
|
dodge = (0,0,0);
|
|
Vector2 xdir = (cos(angle),sin(angle));
|
|
Vector2 ydir = (sin(angle),-cos(angle));
|
|
if ( fm ) dodge.xy += (fm>0)?xdir:-xdir;
|
|
if ( sm ) dodge.xy += (sm>0)?ydir:-ydir;
|
|
dodge = dodge-(dodge dot fnorm)*fnorm;
|
|
}
|
|
}
|
|
if ( dodge.length() <= 0. ) return; // not sure if this can happen, really
|
|
fullfuel = (dashfuel >= default.dashfuel);
|
|
dashdir = dodge.unit();
|
|
dashcooldown = 10;
|
|
dashboost = 20.;
|
|
bOnMobj = false;
|
|
if ( player.cheats & CF_REVERTPLEASE )
|
|
{
|
|
player.cheats &= ~CF_REVERTPLEASE;
|
|
player.camera = player.mo;
|
|
}
|
|
vel += dashdir*dashboost;
|
|
vel.z += clamp(-vel.z*.4,0.,30.);
|
|
player.jumptics = -1;
|
|
SetStateLabel("Dash");
|
|
A_StartSound("demolitionist/jet",CHAN_JETPACK,CHANF_LOOP);
|
|
lastbump *= .95;
|
|
mystats.dashcount++;
|
|
BumpView(5.,vel);
|
|
}
|
|
|
|
override void CheckJump()
|
|
{
|
|
if ( InStateSequence(CurState,FindState("Dash")) ) return; // do not
|
|
if ( !(player.cmd.buttons&BT_JUMP) || (gamestate != GS_LEVEL) ) return;
|
|
Vector2 walldir = AngleToVector(angle);
|
|
bool walljump = false, wallclimb = false;
|
|
double climbvelz = 0.;
|
|
FLineTraceData d;
|
|
Actor jumpactor = null;
|
|
for ( int i=-4; i<int(height*.8); i++ )
|
|
{
|
|
if ( !walljump )
|
|
{
|
|
for ( int k=0; k<60; k+=10 )
|
|
{
|
|
for ( int j=-1; j<=1; j+=2 )
|
|
{
|
|
double ang = (angle-180)+k*j;
|
|
walljump = LineTrace(ang,Radius+12,0,TRF_NOSKY|TRF_THRUHITSCAN|TRF_BLOCKSELF|TRF_SOLIDACTORS,i,data:d);
|
|
if ( walljump )
|
|
{
|
|
jumpactor = d.HitActor;
|
|
walldir = (walldir*.7+AngleToVector(ang+180)*.3);
|
|
break;
|
|
}
|
|
}
|
|
if ( walljump ) break;
|
|
}
|
|
if ( walljump ) break;
|
|
}
|
|
if ( walljump ) break;
|
|
if ( !wallclimb )
|
|
{
|
|
for ( int k=0; k<30; k+=10 )
|
|
{
|
|
for ( int j=-1; j<=1; j+=2 )
|
|
{
|
|
double ang = angle+k*j;
|
|
wallclimb = LineTrace(ang,Radius+12,0,TRF_NOSKY|TRF_THRUHITSCAN|TRF_BLOCKSELF|TRF_SOLIDACTORS,i,data:d);
|
|
if ( wallclimb )
|
|
{
|
|
// double-check that it's climbable
|
|
if ( d.HitType == TRACE_HitWall )
|
|
{
|
|
if ( !d.HitLine.sidedef[1] || !!(d.HitLine.flags&(Line.ML_BLOCKING|Line.ML_BLOCKEVERYTHING|Line.ML_BLOCK_PLAYERS)) ) // nope
|
|
{
|
|
wallclimb = false;
|
|
break;
|
|
}
|
|
Sector s = d.HitLine.sidedef[!d.LineSide].sector;
|
|
double backfloorz = s.floorplane.ZAtPoint(d.HitLocation.xy);
|
|
double backceilz = s.ceilingplane.ZAtPoint(d.HitLocation.xy);
|
|
// cling to 3D floor if hit
|
|
if ( d.Hit3DFloor ) backfloorz = d.Hit3DFloor.top.ZAtPoint(d.HitLocation.xy);
|
|
if ( ((backceilz-backfloorz) < Height) || ((pos.z+Height+32) < backfloorz) ) // nope
|
|
{
|
|
wallclimb = false;
|
|
break;
|
|
}
|
|
climbvelz = 1.5*sqrt(max(1.,backfloorz-pos.z));
|
|
}
|
|
else if ( d.HitType == TRACE_HitActor )
|
|
{
|
|
if ( ((d.HitActor.ceilingz-d.HitActor.pos.z+d.HitActor.Height) < Height) || ((pos.z+Height+32) < (d.HitActor.pos.z+d.HitActor.Height)) ) // nope
|
|
{
|
|
wallclimb = false;
|
|
break;
|
|
}
|
|
climbvelz = 1.5*sqrt(max(1.,(d.HitActor.pos.z+d.HitActor.Height)-pos.z));
|
|
}
|
|
jumpactor = d.HitActor;
|
|
walldir = (walldir*.7+AngleToVector(ang)*.3);
|
|
break;
|
|
}
|
|
}
|
|
if ( wallclimb ) break;
|
|
}
|
|
if ( wallclimb ) break;
|
|
}
|
|
if ( wallclimb ) break;
|
|
}
|
|
// cooldown before we can do these, avoids accidental walljumps off ledges we just fell off from
|
|
if ( level.maptime < (lastgroundtic+4) )
|
|
{
|
|
walljump = false;
|
|
wallclimb = false;
|
|
jumpactor = null;
|
|
}
|
|
if ( player.crouchoffset ) player.crouching = 1;
|
|
else if ( bFly && !bFlyCheat && !(player.cheats&CF_NOCLIP2) ) return;
|
|
else if ( bNoGravity ) vel.z = 3;
|
|
else if ( (player.onground && (player.jumptics == 0))
|
|
|| (!player.onground && (level.maptime > last_jump_held) && (((dashfuel > 10.) && (boostcooldown <= 0)) || walljump || wallclimb)) )
|
|
{
|
|
if ( !player.onground && (((walljump || wallclimb) && (level.maptime < last_kick+8)) || (!(walljump || wallclimb) && (level.maptime < last_boost+8))) )
|
|
return;
|
|
double jumpvelz = JumpZ*35./GameTicRate;
|
|
double jumpfac = 0;
|
|
for ( let p=Inv; p; p=p.Inv )
|
|
{
|
|
let pp = PowerHighJump(p);
|
|
if ( pp )
|
|
{
|
|
double f = pp.Strength;
|
|
if ( f > jumpfac ) jumpfac = f;
|
|
}
|
|
}
|
|
if ( jumpfac > 0 ) jumpvelz *= jumpfac;
|
|
bool raging = FindInventory("RagekitPower");
|
|
if ( raging ) jumpvelz *= 2.;
|
|
double pvelz = vel.z;
|
|
if ( !player.onground && !(player.cheats&CF_PREDICTING) )
|
|
{
|
|
// check for wall stuff
|
|
if ( walljump )
|
|
{
|
|
if ( vel.z < 10. )
|
|
vel.z += 2.*jumpvelz+clamp(-pvelz*.6,0.,30.);
|
|
vel.xy += walldir*20*Speed;
|
|
lastbump *= .95;
|
|
}
|
|
else if ( wallclimb )
|
|
{
|
|
if ( vel.z < 10. )
|
|
vel.z += climbvelz+clamp(-pvelz*.95,0.,30.);
|
|
vel.xy += walldir*10*Speed;
|
|
lastbump *= .97;
|
|
}
|
|
if ( walljump && jumpactor && jumpactor.bSHOOTABLE )
|
|
{
|
|
SWWMUtility.DoKnockback(jumpactor,(-walldir,0),12000);
|
|
int dmg = jumpactor.DamageMobj(self,self,10,'Jump');
|
|
if ( raging )
|
|
{
|
|
let ps = Spawn("BigPunchSplash",pos);
|
|
ps.damagetype = 'Jump';
|
|
ps.target = self;
|
|
ps.special1 = dmg;
|
|
}
|
|
}
|
|
if ( walljump || wallclimb )
|
|
{
|
|
last_kick = level.maptime+1;
|
|
SWWMUtility.AchievementProgressInc("jump",1,player);
|
|
}
|
|
}
|
|
bOnMobj = false;
|
|
player.jumpTics = -1;
|
|
if ( (dashfuel > 10.) && !player.onground && !walljump && !wallclimb )
|
|
{
|
|
dashboost = 3.;
|
|
boostcooldown = 20;
|
|
if ( vel.z < 10. )
|
|
vel.z += jumpvelz+clamp(-pvelz*.4,0.,30.);
|
|
A_StartSound("demolitionist/jet",CHAN_JETPACK,CHANF_LOOP);
|
|
lastbump *= .95;
|
|
mystats.boostcount++;
|
|
last_boost = level.maptime+1;
|
|
BumpView(3.,vel);
|
|
SetStateLabel("Boost");
|
|
}
|
|
else
|
|
{
|
|
A_StartSound(walljump?"demolitionist/kick":"demolitionist/runstart",CHAN_FOOTSTEP,CHANF_OVERLAP);
|
|
dashboost = 0.;
|
|
// bunnyhop time
|
|
if ( !walljump && !wallclimb )
|
|
{
|
|
if ( !bWalking && (level.maptime < (lastairtic+10)) )
|
|
{
|
|
SWWMUtility.AchievementProgressInc("bune",1,player);
|
|
// bhop, z vel relative to vel size
|
|
if ( vel.z < 25. ) // don't ramp up too hard
|
|
{
|
|
vel.z += jumpvelz*((IsRunning()?1.2:.65)+vel.length()*.01);
|
|
// add part of last landing z velocity too
|
|
vel.z += max(0,-landvelz*(raging?.45:.35));
|
|
}
|
|
// accelerate
|
|
vel.xy += (RotateVector(NormalizedMove(),angle)/2400.)*(1.+vel.length()*.025)*TweakSpeed();
|
|
}
|
|
else
|
|
{
|
|
// first jump
|
|
if ( vel.z < 10. ) // don't ramp up too hard
|
|
{
|
|
vel.z += jumpvelz*(bWalking?.75:IsRunning()?1.25:1.);
|
|
// add part of last landing z velocity too
|
|
vel.z += max(0,-landvelz*(raging?.35:.25));
|
|
}
|
|
// long jump if running/sprinting
|
|
if ( !walljump && !wallclimb && !bWalking )
|
|
vel.xy += (RotateVector(NormalizedMove(),angle)/1500.)*(raging?2.:1.)*TweakSpeed();
|
|
}
|
|
}
|
|
BumpView(clamp((vel.length()-10)/12.,1.,20.),vel);
|
|
if ( swwm_mutevoice < 4 )
|
|
{
|
|
String myvoice = CVar.GetCVar('swwm_voicetype',player).GetString();
|
|
int loudlv = swwm_voiceamp;
|
|
int maxjump = StringTable.Localize("$SWWM_"..myvoice.."_NJUMP").ToInt();
|
|
int idx = (maxjump<=1)?1:Random[DemoLines](1,maxjump);
|
|
A_StartSound(String.Format("voice/%s/jump%d",myvoice,idx),CHAN_DEMOVOICE,CHANF_OVERLAP);
|
|
if ( loudlv > 1 ) A_StartSound(String.Format("voice/%s/jump%d",myvoice,idx),CHAN_DEMOVOICEAUX,CHANF_OVERLAP);
|
|
if ( loudlv > 2 ) A_StartSound(String.Format("voice/%s/jump%d",myvoice,idx),CHAN_DEMOVOICEAUX2,CHANF_OVERLAP);
|
|
if ( loudlv > 3 ) A_StartSound(String.Format("voice/%s/jump%d",myvoice,idx),CHAN_DEMOVOICEAUX3,CHANF_OVERLAP);
|
|
}
|
|
SetStateLabel("Jump");
|
|
}
|
|
}
|
|
last_jump_held = level.maptime+1;
|
|
}
|
|
|
|
bool AllowCrouch()
|
|
{
|
|
if ( player.cmd.buttons&BT_JUMP ) return false;
|
|
if ( InStateSequence(CurState,FindState("Dash")) ) return false; // no crouch during dash
|
|
return true;
|
|
}
|
|
|
|
// Imagine having to duplicate two functions only to change a couple values in both
|
|
// I sure love constants
|
|
override void CrouchMove( int direction )
|
|
{
|
|
double defaultheight = FullHeight;
|
|
double savedheight = Height;
|
|
double crouchspeed = direction*CROUCHSPEED*((direction>0)?.65:.9); // match animation speed
|
|
double oldheight = player.viewheight;
|
|
player.crouchdir = direction;
|
|
player.crouchfactor += crouchspeed;
|
|
// check whether the move is ok
|
|
Height = defaultheight; // actually test the full height, or it'll look weird
|
|
if ( !TryMove(pos.xy,false) )
|
|
{
|
|
Height = savedheight;
|
|
if ( direction > 0 )
|
|
{
|
|
// doesn't fit
|
|
player.crouchfactor -= crouchspeed;
|
|
player.crouchdir = -1; // force crouch
|
|
return;
|
|
}
|
|
}
|
|
Height = savedheight;
|
|
player.crouchfactor = clamp(player.crouchfactor,.3,1.);
|
|
player.viewheight = ViewHeight*player.crouchfactor;
|
|
player.crouchviewdelta = player.viewheight-ViewHeight;
|
|
// Check for eyes going above/below fake floor due to crouching motion.
|
|
CheckFakeFloorTriggers(pos.z+oldheight,true);
|
|
}
|
|
|
|
override void CheckCrouch( bool totallyfrozen )
|
|
{
|
|
// crouch to swim/float down
|
|
if ( !totallyfrozen && (player.cmd.buttons&BT_CROUCH) && bNOGRAVITY )
|
|
vel.z = -3;
|
|
bool wascrouching = !!(player.cmd.buttons&BT_CROUCH);
|
|
if ( !AllowCrouch() ) player.cmd.buttons &= ~BT_CROUCH;
|
|
if ( CanCrouch() && (player.health > 0) )
|
|
{
|
|
if ( !totallyfrozen )
|
|
{
|
|
int crouchdir = player.crouching;
|
|
if ( !crouchdir ) crouchdir = (player.cmd.buttons&BT_CROUCH)?-1:1;
|
|
else if ( player.cmd.buttons&BT_CROUCH ) player.crouching = 0;
|
|
if ( (crouchdir == 1) && (player.crouchfactor < 1) && (pos.z+height < ceilingz) )
|
|
CrouchMove(1);
|
|
else if ( (crouchdir == -1) && (player.crouchfactor > .3) )
|
|
CrouchMove(-1);
|
|
}
|
|
}
|
|
else player.Uncrouch();
|
|
player.crouchoffset = -(ViewHeight)*(1-player.crouchfactor);
|
|
// we need the crouch button state to be preserved for other functions
|
|
if ( wascrouching ) player.cmd.buttons |= BT_CROUCH;
|
|
}
|
|
|
|
// let's customize our gravity
|
|
override void FallAndSink( double grav, double oldfloorz )
|
|
{
|
|
if ( !player || (player.mo != self) || (player.cheats&CF_TOTALLYFROZEN) )
|
|
{
|
|
Super.FallAndSink(grav,oldfloorz);
|
|
return;
|
|
}
|
|
// do nothing if standing on ground or "floating"
|
|
if ( player.onground || bNOGRAVITY ) return;
|
|
// ensure we don't pass terminal velocity just from falling
|
|
if ( vel.z < -50 ) return;
|
|
// we don't care about "the doom way" here, gravity is
|
|
// ALWAYS in effect when not standing on solid ground
|
|
if ( waterlevel > 1 )
|
|
{
|
|
// sink faster
|
|
grav *= .35;
|
|
}
|
|
// reduce gravity while we're boosting
|
|
else if ( InStateSequence(CurState,FindState("Dash")) || InStateSequence(CurState,FindState("Boost")) )
|
|
grav *= .25;
|
|
vel.z -= grav;
|
|
}
|
|
}
|