Configurable bounce object types for projectiles

In the default engine, projectiles can be set to either explode immediately on impact, or bounce for a set duration (the 'armingDelay') then explode on the very next collision.

Bouncing is currently all-or-nothing; if the projectile's current life time is less than the arming delay, the projectile will bounce off everything including players/vehicles.

The following minor code changes to the engine add a variable to the ProjectileData datablock called 'noBounceObjTypes' against which a projectile will *always* explode. This opens up several possibilities, such as richochet-fire or grenades that bounce along the ground but will explode when they hit a player.


All changes are contained to projectile.cc and projectile.h.


First, in projectile.h find the following (~line 62):

bool isBallistic;

Just below this, add the following line:

U32 noBounceObjTypes;

The remaining changes are in projectile.cc. at around line 69 find:

isBallistic = false;

Below this add the following line:

noBounceObjTypes =  0;

The above change dictates the default behavior when no variable is specified in a datablock. The value of '0' means projectiles will bounce off of all object types (current behavior).


Next up, adding the new datablock variable and its read/write support. Around line 132 find:

addNamedField(isBallistic, TypeBool, ProjectileData);

and add the following line below it:

addNamedField(noBounceObjTypes, TypeS32, ProjectileData);

Next find around line 287:

if(stream->writeFlag(isBallistic))
   {
      stream->write(gravityMod);
      stream->write(bounceElasticity);
      stream->write(bounceFriction);
   }

and add the following below the last stream->write line (but within the if() ):

stream->write(noBounceObjTypes);

Finally, around line 353 find:

if(isBallistic)
   {
      stream->read(&gravityMod);
      stream->read(&bounceElasticity);
      stream->read(&bounceFriction);
   }

and add the following below the last stream->read line (but within the if() ):

stream->read(&noBounceObjTypes);

The utility code to read and write the new 'noBounceObjTypes' variable is now in place. Next, to enable selective bouncing, find (around line 791):

// make sure the client knows to bounce
      if(isServerObject() && (rInfo.object->getType() & csmStaticCollisionMask) == 0)
         setMaskBits(BounceMask);

And replace the conditional line with:

if(isServerObject() && ((rInfo.object->getType() & mDataBlock->noBounceObjTypes) == 0))

Also around line 796, find:

if(mCurrTick > mDataBlock->armingDelay)

and replace it with the following line:

if (mCurrTick > mDataBlock->armingDelay || ((rInfo.object->getType() & mDataBlock->noBounceObjTypes) != 0) )

That's it! Compile the source, and crack open your favorite weapon .cs file. Within the ProjectileData definition, you need to have certain other variables set properly to enable bouncing in general. Add (or change) the following variables:

armingDelay         = 5000;
bounceElasticity    = 0.5;
bounceFriction      = 0;
isBallistic         = true;

The above values are reasonable (read: they work for me) to start with.

Finally, add the following variable to the above set:

noBounceObjTypes   = $TypeMasks::PlayerObjectType;

Multiple TypeMasks can be OR'd together (e.g. $TypeMasks::PlayerObjectType | $TypeMasks::VehicleObjectType) if so desired.


Run the above example, get into a good firefight in a small room and voila! The RUBBER BALL OF DEATH!

Enjoy! I look forward to any comments/corrections.