Swimming in one step -- standard FPS swimming physics

*Updated 5/22/09: This code is already included and improved upon in stock T3D Beta1+

*Updated 1/26/07 to fix typo in code: missing ')'*
*Updated 11/6/07 to clarify a confusing element and add explaination.*
*Updated 11/12/07 to upgrade vector calculations, add moveUp/moveDown support.*

While there is one swimming resource available (Swim/Crawl/Crouch resource, it includes extra code for move states (crouch, etc.) and uses a slightly awkward (as admitted by the author) swim vector calculation routine.

This resource is intended to provide FPS-style swimming physics in a simple patch which can be done in about 30 seconds. If you also want crouching and crawling, check out the link above.

What it does: Swim in any direction you can look, using existing runForce calculations. One file change.

What it does not: Animations not included; there are many existing tutorials on adding new animations to your player object.

With that said, open player.cpp (or .cc for older versions) and go to the function:

void Player::updateMove(const Move* move)

Find the following if-else in updateMove:

if (runSurface) {
...<All the code for running (Don't delete this stuff!)>...
}
else
   mContactTimer++;

..and make it look like this (new code in bold):

if (runSurface) {
...<All the code for running (Don't delete this stuff!)>...
}
[b]
else if (inLiquid)
{
   // get the head pitch and add it to the moveVec
   // This more accurate swim vector calc comes from Matt Fairfax
   MatrixF xRot, zRot;
   xRot.set(EulerF(mHead.x, 0, 0));
   zRot.set(EulerF(0, 0, mRot.z));
   MatrixF rot;
   rot.mul(zRot, xRot);
   rot.getColumn(0,&moveVec);

   moveVec *= move->x;
   VectorF tv;
   rot.getColumn(1,&tv);
   moveVec += tv * move->y;
   rot.getColumn(2,&tv);
   moveVec += tv * move->z;

   // Force a 0 move if there is no energy, and only drain
   // move energy if we're moving.
   VectorF pv;
   if (mEnergy >= mDataBlock->minRunEnergy) {
      if (moveSpeed)
         mEnergy -= mDataBlock->runEnergyDrain;
      pv = moveVec;
   }
   else
      pv.set(0,0,0);

  F32 pvl = pv.len();

   // Convert to acceleration
   if (pvl)
      pv *= moveSpeed / pvl;
   VectorF runAcc = pv - mVelocity;
   F32 runSpeed = runAcc.len();

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

   mContactTimer++;
}
[/b]
else
   mContactTimer++;

Compile and jump in some water. You should be able to swim, assuming your player is not too heavy or dense. You may notice that you can still walk on the bottom of the ocean if you make contact with it.

Density: If your player has a higher density than the water, he will sink and swim very slowly. A lower density will cause the player to rise and accelerate more quickly. Equal density will make swimming feel like flying. I recommend the player's density be just slightly higher than the water's, for the sake of realism.

Waves: The waves in TGE's waterblock don't exist on the server, so they won't be part of the swimming physics.

For those interested in what this actually does, you're changing the if-else chain that usually does:
"If we're on the ground, use the running code. Else, don't do anything except count, because we're in the air."
Into:
"If we're on the ground, use the running code. Else, if we're underwater, use the swimming code. Else, we're in the air, just count."

Upgraded on 11/12/07 to use a more accurate, slightly more math-intensive swim vector. The old method worked fine, but this version is "correct" in comparison to other FPS swimming models. It also now supports move up and move down (move->z).