Projectiles: Server vs. Client

This is kind of a break off from my thread from last week, however, this topic is more relevant for the needs of that thread and suits what I'm actually looking for answer wise better.

So, I've been tackling the job of adding new projectile types as of recently, and one of my stumbling blocks I've come across is in C++, where calculations need to be handled on either the server or the client side of the application.

So, first things first, let's get a list of functions that are relevant:

void advanceTime(F32 dt)

This one appears to be called at every frame update in the game, and it can be used to provide the highest precision in movements. However, I can't seem to figure out if this is called on the client or the server side of things, but my hunch is telling me that it's taking place on both.

void processTick(const Move *move)

Now, I have no idea what's going on here. I state this because of the following in projectile.cpp:

void Projectile::processTick( const Move *move )
{
   Parent::processTick( move );
   mCurrTick++;

   simulate( TickSec );
}

void Projectile::simulate( F32 dt )
{         
   if ( isServerObject() && mCurrTick >= mDataBlock->lifetime )
   {
      deleteObject();
      return;
   }
   .
   .
   .
   if ( isClientObject() )
   {
      emitParticles( mCurrPosition, newPosition, mCurrVelocity, U32( dt * 1000.0f ) );
      updateSound();
   }
}

So, what I see going on here is absolutely "silly". So, if we're on the server the object is just deleted right away, which is confusing to me because you would think the server should have the authority on how and when projectiles function the way they are, so that led me to believe this is "client-only", until I hit the little if block near the bottom, which implies that calls on the server can still be made. Either this is redundant code, or I have no idea what's going on here.

void interpolateTick( F32 delta )

This one just drives me nuts beyond all reason, because it seems to share functioning from all of the prior calls. Again, server versus client, no idea here.

I would honestly love for you guys to tell me what's going on with these three calls. But what I'm really after here is a little more important. I want to do projectile specific stuff, positional related and functioning related, so what kind of functioning belongs in which functions, and how do I ensure I'm doing the right operation in what function. Lastly, I need something about this:

SimObjectPtr<ShapeBase> mSourceObject; ///< Actual pointer to the source object, times out after SourceIdTimeoutTicks

This is defined in projectile.h, now, I need this object to be "server-side" so I can use object specific functions on the server that relate to whether or not the player firing the gun is holding down a trigger (see prior thread), but when I'm calling this, I get stuck with a client object, which is bad. But here's where things get really "good".

Check out how that is defined:

bool Projectile::onAdd() {
   .
   .
   if (isServerObject()) {
      ShapeBase* ptr;
      if (Sim::findObject(mSourceObjectId, ptr)) {
         mSourceObject = ptr;

         // Since we later do processAfter( mSourceObject ) we must clearProcessAfter
         // if it is deleted. SceneObject already handles this in onDeleteNotify so
         // all we need to do is register for the notification.
         deleteNotify( ptr );
      }
      else {
         if (mSourceObjectId != -1)
            Con::errorf(ConsoleLogEntry::General, "Projectile::onAdd: mSourceObjectId is invalid");
         mSourceObject = NULL;
      }

      // If we're on the server, we need to inherit some of our parent's velocity
      //
      mCurrTick = 0;
   }
   .
   .
}

Which implies that this should be a server-side source object. So why exactly, would I be getting my client-side player object as the source of my projectile, which bases from this same code? You tell me.

So, what it all comes down to here, is a matter of the naming convention of these functions versus where they're actually used server versus client, and how I can go about getting the server version of mSourceObject without needing to dabble in the volatile and untrustable ghosting system for projectiles.