Turret & AITurret classes, Version 1.20

void AITurret::throwCallback( const char *name )
{
   Con::executef(getDataBlock(), 2, name, scriptThis());
}

void AITurret::throwCallback( const char *name )
{
   Con::executef(getDataBlock(),name, scriptThis()); /// <--- no 2
}

// draw all the objects
   Vector<SceneObject*> objects;
   // phdana turrets ->
   U32 mask = InteriorObjectType | PlayerObjectType | VehicleObjectType | StaticShapeObjectType | WaterObjectType | TriggerObjectType | TurretObjectType;
   // <- phdana turrets
   gServerContainer.findObjects(mask, findObjectsCallback, &objects);

void	writePacketData(GameConnection *, BitStream *stream);

void AITurret::writePacketData(GameConnection *con, BitStream *stream)
{
  Parent::writePacketData(con, stream);

  return;
}

enum SimObjectTypes
{
....
   StaticRenderedObjectType =    BIT(26),
   // phdana turrets ->
   TurretObjectType =            BIT(27),
   // <- phdana turrets

#include "../trigger.h"

#include "aiTurret.h"                          // <---- here
#include "console/consoleInternal.h"
#include "math/mMatrix.h"
#include "math/mathUtils.h"
#include "console/console.h"
#include "console/consoleTypes.h"
#include "console/consoleInternal.h"
#include "../gameConnection.h"                 // <-----here  
#include "../../core/stream/bitStream.h"       // <-----here
#include "math/mMathFn.h" 
#include "../moveManager.h"                    // <-----here

#include "Turret.h"                             //<-- here
#include "console/console.h"
#include "console/consoleTypes.h"
#include "console/consoleInternal.h"
#include "../gameConnection.h"                  //<-- here
#include "../../core/stream/bitStream.h"        //<-- here
#include "ts/tsShapeInstance.h"
#include "../moveManager.h"                     //<-- here
#include "../../core/resourceManager.h"         //<-- here

bool mountImage(ShapeBaseImageData* imageData,U32 imageSlot,bool loaded,NetStringHandle &skinNameHandle);

void	writePacketData(GameConnection *, BitStream *stream);

void Turret::writePacketData(GameConnection *con, BitStream *stream)
{
  Parent::writePacketData(con, stream);

  stream->write(mRot.x); 
  stream->write(mRot.z);
  stream->writeFlag(isActive);
    
  return;
}

bool Turret::mountImage(ShapeBaseImageData* imageData,U32 imageSlot,bool loaded,NetStringHandle &skinNameHandle)
{
...

bool TurretData::preload(bool server, String &errorBuffer)
{
   if (!Parent::preload(server, errorBuffer))
      return false;
   if (shapeName && shapeName[0])
   {
      // Resolve shapename
      shapeResource = ResourceManager::get().load(shapeName);
      if (!bool(shapeResource))
      {
		 //dSprintf(buffer, sizeOf(buffer), "TankData: Couldn't load shape "%s"",shapeName);
		 errorBuffer = String::ToString("TankData: Couldn't load shape "%s"",shapeName);
         return false;
      }
      if(!server && !shapeResource->preloadMaterialList(shapeResource.getPath()) && NetConnection::filesWereDownloaded())
         return false;
   }
...

static U32 sDirtySetMask = PlayerObjectType     |
                           // phdana turrets ->
                           TurretObjectType |
                           // <- phdana turrets
                           VehicleObjectType;

const static U32 sCollisionMoveMask = (TerrainObjectType        | InteriorObjectType   |
                                       WaterObjectType          | PlayerObjectType     |
									   // phdana turrets ->
										TurretObjectType         |
										// <- phdana turrets
                                       StaticShapeObjectType    | VehicleObjectType    |
                                       VehicleBlockerObjectType | StaticTSObjectType   |
                                       AtlasObjectType);

const U32 sCollisionMoveMask = (TerrainObjectType        | InteriorObjectType   |
                                PlayerObjectType         | StaticTSObjectType   |
								// phdana turrets ->
                                TurretObjectType         |
                                // <- phdana turrets
                                StaticShapeObjectType    | VehicleObjectType    |
                                VehicleBlockerObjectType | AtlasObjectType);

static U32 sClientCollisionMask =
      TerrainObjectType    | InteriorObjectType       |
      PlayerObjectType     | StaticShapeObjectType    |
	  // phdana turrets
      TurretObjectType     |
      // <- phdana turrets
      VehicleObjectType    | VehicleBlockerObjectType |
      StaticTSObjectType   | AtlasObjectType;

// phdana turrets ->
void GameBase::potentialEnterObject(GameBase*)
{
   // do nothing...derived classes do something with this
}
// <- phdana turrets

// phdana turrets ->
   virtual void potentialEnterObject(GameBase*);
   // <- phdana turrets

const U32 sClientCollisionMask = (AtlasObjectType       |  TerrainObjectType     |
                                  InteriorObjectType    |  StaticShapeObjectType |
								  // phdana turrets ->
                                  TurretObjectType      |
                                  // <- phdana turrets
                                  VehicleObjectType     |  PlayerObjectType      | 
                                  StaticTSObjectType);

// phdana turrets ->
   Con::setIntVariable("$TypeMasks::TurretObjectType",         TurretObjectType);
// <- phdana turrets

// Air control
   airControl = 0.0f;

   jumpTowardsNormal = true;

   // phdana aiobject ->
   activatesTriggers = true;
   // <- phdana aiobject

   dMemset( actionList, 0, sizeof(actionList) );
}

//
static U32 sCollisionMoveMask = (AtlasObjectType        | TerrainObjectType    |
                                 InteriorObjectType     |
                                 WaterObjectType        | PlayerObjectType     |
								 // phdana turrets ->
                                 TurretObjectType       | 
                                 // <- phdana turrets
                                 StaticShapeObjectType  | VehicleObjectType    |
                                 PhysicalZoneObjectType | StaticTSObjectType);

static U32 sServerCollisionContactMask = (sCollisionMoveMask |
                                          (ItemObjectType    |
                                           TriggerObjectType |
                                           CorpseObjectType));

static U32 sClientCollisionContactMask = sCollisionMoveMask | PhysicalZoneObjectType;

// phdana turrets ->
static U32 sDirtySetMask = (PlayerObjectType | TurretObjectType | VehicleObjectType);
// <- phdana turrets

bool renderFirstPerson;    ///< Render the player shape in first person

   // phdana aiobject ->
   bool activatesTriggers;
   // <- phdana aiobject

const U32 Projectile::csmDynamicCollisionMask = PlayerObjectType        |
                                                VehicleObjectType       |
												// phdana turrets ->
                                                TurretObjectType        |
                                                // <- phdana turrets
                                                DamagableItemObjectType;

// phdana turrets ->
   mOwner = NULL;
   // <- phdana turrets

void Trigger::potentialEnterObject(GameBase* enter)
{
   AssertFatal(isServerObject(), "Error, should never be called on the client!");

   // phdana turrets ->
   // if we have an owner then we just call their potential enter
   // instead and let them do the rest of the processing
   if (mOwner != NULL)
   {
      mOwner->potentialEnterObject(enter);
      return;
   }
   // <- phdana turrets

// phdana turrets ->
void Trigger::setOwner(GameBase *owner)
{
  mOwner = owner;
}
// <- phdana turrets

// phdana turrets ->
void cTriggerSetOwner(SimObject* obj, S32 argc, const char** argv )
{
   AssertFatal(dynamic_cast<Trigger*>(obj) != NULL, "Error, how did a non-trigger get here?");
   Trigger* trigger = static_cast<Trigger*>(obj);

   if (argc > 2)
   {
      GameBase* owner = NULL;
      if (Sim::findObject(argv[2], owner) == false)
         return;

      trigger->setOwner(owner);
   }

}
// <- phdana turrets

void Trigger::consoleInit()
{
   // phdana aiobject ->
   Con::addCommand("Trigger", "setOwner",      cTriggerSetOwner,     "[TriggerObject].setOwner(obj)", 3, 3);
   // <- phdana aiobject
}

TriggerData*      mDataBlock;

   U32               mLastThink;
   U32               mCurrTick;

   // phdana turrets ->
   GameBase         *mOwner;
   // <- phdana turrets

public:
   void setTransform(const MatrixF &mat);

   // phdana aiobject ->
   void setOwner(GameBase *owner);
   // <- phdana aiobject

... more code...

   static void initPersistFields();
   // phdana aiobject ->
   static void consoleInit();
   // <- phdana aiobject

// phdana turrets ->
   exec("./turret.cs");
   exec("./aiTurret.cs");
   exec("./genericTurret.cs");
   exec("./genericAITurret.cs");
   // <- phdana turrets

   // Keep track of when the game started
   $Game::StartTime = $Sim::Time;

for (%i = 0; %i < %numAttempts; %i++) {
      %pos = VectorAdd(%oldPos, VectorScale(%vec[%i], 3));
      if (%obj.checkDismountPoint(%oldPos, %pos)) {
         %success = %i;
         %impulseVec = %vec[%i];
         break;
      }
   }
   if (%forced && %success == -1)
      %pos = %oldPos;

   // phdana turrets ->
      if(%obj.mVehicle)
      {
         %data = %obj.mVehicle.getDataBlock();
         if (%data.className $= TurretData)
            %data.playerDismounted(%obj.mVehicle, %obj);

         %obj.mVehicle.mountable = true;
        %client = %obj.client;
        if(%obj.mVehicle.mountedTurret.currentDriver == %client)
         %obj.mVehicle.mountedTurret.currentDriver = "";
      }

      %obj.mountVehicle = false;
      %obj.schedule(4000, "setMountVehicle", true);
      %obj.schedule(4000, "mountVehicles", true);

      // Mount last weapon used, unmount from node, and give player control.
      %obj.unMount();
      %this.onUnMount(%obj);
      %obj.setControlObject(%obj);

   // <- phdana turrets

// Mount vehicles
   %this = %col.getDataBlock();
   if ((%this.className $= WheeledVehicleData) && %obj.mountVehicle &&
         %obj.getState() $= "Move" && %col.mountable) {

      // Only mount drivers for now.
      %node = 0;
      %col.mountObject(%obj,%node);
      %obj.mVehicle = %col;
   }

// phdana turrets ->
   %obj.mountedTurret = "";

   // Mount vehicles or turrets
   %this = %col.getDataBlock();
   if ((%this.className $= WheeledVehicleData ||
       %this.className $= TurretData) && %obj.mountVehicle &&
         %obj.getState() $= "Move" && %col.mountable) {

         %node = findEmptySeat(%col, %this);
         if(%col.mountedTurret.currentDriver $= "" && %node > 0)
         {
            error("FOUND MOUNTED TURRET ON vehicle! %node =" SPC %node);
            %col.mountedTurret.mountObject(%obj, 0);
            %col.mountedTurret.currentDriver = %client;
            %turretMounted = true;
         }

         %col.mountable=true;// Set Vehicle mountable for other passengers

         if(!%turretMounted)
         {
            %col.mountObject(%obj,%node);
 		 	%player = %client.player;
 		 	%col.currentDriver = %client;
 		 	%client.currentMountedVehicle = %col;
 		 }
 		 %obj.mVehicle = %col;

        if(%this.className $= TurretData)
        {
          echo("Mounted a Turret, not a vehicle");
          %this.playerMounted(%col,%obj, %node);
        }
   }
   // <- phdana turrets

// phdana turrets ->
// if you dont already have this for vehicles
// you need it for turrets
function findEmptySeat(%vehicle, %vehicleblock)
{
  for (%i = 0; %i <  %vehicleblock.numMountPoints; %i++)
  {
    %node = %vehicle.getMountNodeObject(%i);
    if (%node == 0)
    {
         return %i;
    }
  }
  return -1;
}
// <- phdana turrets

// phdana turrets ->

//-----------------------------------------------------------------------------
// ShapeBaseImage datablock
//-----------------------------------------------------------------------------

// any shape base image does this on fire
function ShapeBaseImageData::onFire(%data, %obj, %slot)
{
   echo("ShapeBaseImageData::onFire()");

	%projectile = %data.projectile;

	%muzzleVector = %obj.getMuzzleVector(%slot);
   %objectVelocity = %obj.getVelocity();

   %muzzleVelocity = VectorAdd(
      VectorScale(%muzzleVector, %projectile.muzzleVelocity),
      VectorScale(%objectVelocity, %projectile.velInheritFactor));

       %p = new (%data.projectileType)() {
         dataBlock        = %data.projectile;
         initialVelocity  = %muzzleVelocity;
         initialDirection = %obj.getMuzzleVector(%slot);
         initialPosition  = %obj.getMuzzlePoint(%slot);
         sourceObject     = %obj;
         sourceSlot       = %slot;
      };

   if (isObject(%obj.lastProjectile) && %obj.deleteLastProjectile)
      %obj.lastProjectile.delete();

   %obj.lastProjectile = %p;
   %obj.deleteLastProjectile = %data.deleteLastProjectile;

   MissionCleanup.add(%p);

   return %p;
}

// <- phdana turrets

scriptsAndAssets/server/scripts/player.cs (761): Unable to find function findEmptySeat
FOUND MOUNTED TURRET ON vehicle! %node = 2276
scriptsAndAssets/server/scripts/player.cs (765): Unable to find object: '' attempting to call function 'mountObject'
Mounted a Turret, not a vehicle
TurretData::playerMounted()

projectile = RifleProjectile;