Sprint Button

Download Code File

Adding a Player Sprint Key


by Daniel "Wizard_TPG" Neilsen
wizardsworld@bigpond.com


This is quite a simple thing to do but requires the editing of
several files in the torque engine. I have based this on the
latest HEAD version as at 13/5/02 but, I originally coded this
for the original release of torque so it should be compatible
with all torque versions to date.

Before we go too much further I should say this
DISCLAIMER - I am certainly not the best at C++ in the world but
this worked for me so it should work for you too.
- The line numbers are taken from my edit version of
the engine so should be considered approximate only.



STEP 1 - Adding a sprint toggle into the engine

Open MoveManager.h and add this line to line 29
bool sprint;

result should look like this
bool freeLook;
bool sprint;
bool trigger[MaxTriggerKeys];


Add this to line 50
static bool mSprint;

result should look like this
static bool mFreeLook;
static bool mSprint;
static F32 mPitch;
static F32 mYaw;
static F32 mRoll;


Open GameConnectionMoves.cc and add this line to line 29
bool MoveManager::mSprint = false;

result should look like this
bool MoveManager::mFreeLook = false;
bool MoveManager::mSprint = false;
F32 MoveManager::mPitch = 0;
F32 MoveManager::mYaw = 0;
F32 MoveManager::mRoll = 0;


Add this to line 64
Con::addVariable("mvSprint", TypeBool, &mSprint);

result should look like this
Con::addVariable("mvFreeLook", TypeBool, &mFreeLook);
Con::addVariable("mvSprint", TypeBool, &mSprint);
Con::addVariable("mvPitch", TypeF32, &mPitch);
Con::addVariable("mvYaw", TypeF32, &mYaw);
Con::addVariable("mvRoll", TypeF32, &mRoll);


Add this to line 148
stream->writeFlag(sprint);

result should look like this
stream->writeFlag(freeLook);
stream->writeFlag(sprint);


Add this to line 172
sprint = stream->readFlag();

result should look like this
freeLook = stream->readFlag();
sprint = stream->readFlag();


Add this to line 199
curMove.sprint = MoveManager::mSprint;

result should look like this
curMove.freeLook = MoveManager::mFreeLook;
curMove.sprint = MoveManager::mSprint;


Open default.bind.cs and add the following
function toggleSprint( %val )
{
if ( %val )
$mvSprint = true;
else
$mvSprint = false;
}
moveMap.bind( keyboard, q, toggleSprint );


ok, cool, we got a sprint button....but it dosnt do didly squat...doh!
hmmm better make it do something then eh?

Just a quick offside... For those that didnt notice, we literally copied the freelook
all the way. This method can be used for any toggle button you wish to add.



STEP 2 - THE SPRINT DATABLOCK SETTINGS

The next step is to add new properties into the playerdata datablock
for the sprint speed, force, energy drain and min energy


Open player.h and add the following at line 57
F32 SprintSpeedMult; // Player max speed increase when sprinting eg. 1.2 = 20% increase
F32 SprintForceMult; // Player run force increase when sprinting eg. 1.2 = 20% increase
F32 sprintEnergyDrain; // Energy drain/tick
F32 minSprintEnergy; // Energy required to sprint

Result should look like this:
F32 SprintSpeedMult;
F32 SprintForceMult;
F32 sprintEnergyDrain; // Energy drain/tick
F32 minSprintEnergy;
F32 maxStepHeight;
F32 runSurfaceAngle; // Angle from vertical in degrees



Open player.cc and add the following at line 170
SprintSpeedMult = 1.2;
SprintForceMult = 1.2;
sprintEnergyDrain = 2;
minSprintEnergy = 2;

Result should look like this:
SprintSpeedMult = 1.2;
SprintForceMult = 1.2;
sprintEnergyDrain = 2;
minSprintEnergy = 2;
maxStepHeight = 1;
runSurfaceAngle = 80;



add the following at line 450
addField("SprintSpeedMult", TypeF32, Offset(SprintSpeedMult, PlayerData));
addField("SprintForceMult", TypeF32, Offset(SprintForceMult, PlayerData));
addField("sprintEnergyDrain", TypeF32, Offset(sprintEnergyDrain, PlayerData));
addField("minSprintEnergy", TypeF32, Offset(minSprintEnergy, PlayerData));

Result should look like this:
addField("SprintSpeedMult", TypeF32, Offset(SprintSpeedMult, PlayerData));
addField("SprintForceMult", TypeF32, Offset(SprintForceMult, PlayerData));
addField("sprintEnergyDrain", TypeF32, Offset(sprintEnergyDrain, PlayerData));
addField("minSprintEnergy", TypeF32, Offset(minSprintEnergy, PlayerData));
addField("runSurfaceAngle", TypeF32, Offset(runSurfaceAngle, PlayerData));
addField("recoverDelay", TypeS32, Offset(recoverDelay, PlayerData));
addField("recoverRunForceScale", TypeF32, Offset(recoverRunForceScale, PlayerData));



add the following at line 643
stream->write(SprintSpeedMult);
stream->write(SprintForceMult);
stream->write(sprintEnergyDrain);
stream->write(minSprintEnergy);

Result should look like this:
stream->write(SprintSpeedMult);
stream->write(SprintForceMult);
stream->write(sprintEnergyDrain);
stream->write(minSprintEnergy);
stream->write(recoverDelay);
stream->write(recoverRunForceScale);



add the following at line 761
stream->read(&SprintSpeedMult);
stream->read(&SprintForceMult);
stream->read(&sprintEnergyDrain);
stream->read(&minSprintEnergy);

Result should look like this:
stream->read(&runSurfaceAngle);
stream->read(&SprintSpeedMult);
stream->read(&SprintForceMult);
stream->read(&sprintEnergyDrain);
stream->read(&minSprintEnergy);
stream->read(&recoverDelay);
stream->read(&recoverRunForceScale);




STEP 3 - THE MOVEMENT

Now we have the button working, and we have the sprint settings in the engine
Time to make it all work. The basics of sprinting is we are "amplifying" the
players speed.


Before these three lines at approx line 1660

// Desired move direction & speed
VectorF moveVec;
F32 moveSpeed;

add the following:

//Check if sprinting
F32 tempSprintSpeedMult;
F32 tempSprintForceMult;
tempSprintSpeedMult = 1;
tempSprintForceMult = 1;

if (move->sprint)
{
tempSprintSpeedMult = mDataBlock->SprintSpeedMult;
tempSprintForceMult = mDataBlock->SprintForceMult;
if (mEnergy < mDataBlock->minSprintEnergy)
{
tempSprintSpeedMult = 1;
tempSprintForceMult = 1;
}
}



Change the following lines at approx line 1422 like so..

if (move->y > 0)
{
if( mWaterCoverage >= 0.9 )
moveSpeed = getMax(mDataBlock->maxUnderwaterForwardSpeed * tempSprintSpeedMult * move->y,
mDataBlock->maxUnderwaterSideSpeed * tempSprintSpeedMult * mFabs(move->x));
else
moveSpeed = getMax(mDataBlock->maxForwardSpeed * tempSprintSpeedMult * move->y,
mDataBlock->maxSideSpeed * tempSprintSpeedMult * mFabs(move->x));
}
else
{
if( mWaterCoverage >= 0.9 )
moveSpeed = getMax(mDataBlock->maxUnderwaterBackwardSpeed * tempSprintSpeedMult * mFabs(move->y),
mDataBlock->maxUnderwaterSideSpeed * tempSprintSpeedMult * mFabs(move->x));
else
moveSpeed = getMax(mDataBlock->maxBackwardSpeed * tempSprintSpeedMult * mFabs(move->y),
mDataBlock->maxSideSpeed * tempSprintSpeedMult * mFabs(move->x));
}




Change the following lines at approx line 1482 like so..

VectorF pv;
if(moveSpeed > 0)
{
if (move->sprint && mEnergy >= mDataBlock->minSprintEnergy)
{
mEnergy -= mDataBlock->sprintEnergyDrain;
}
else if (mEnergy >= mDataBlock->minRunEnergy)
{
mEnergy -= mDataBlock->runEnergyDrain;
pv = moveVec;
}
}
else
pv.set(0,0,0);



Change the following lines at approx line 1513 like so..

// Clamp acceleratin, player also accelerates faster when
// in his hard landing recover state.
F32 maxAcc = (mDataBlock->runForce / mMass) * TickSec;
if (move->sprint)
maxAcc *= mDataBlock->SprintForceMult;
if (mState == RecoverState)
maxAcc *= mDataBlock->recoverRunForceScale;
if (runSpeed > maxAcc)
runAcc *= maxAcc / runSpeed;
acc += runAcc;


And there you have it. A working sprint key.

Enjoy :)