Particles not following particle node.

Hi, I've been playing with this problem for quite a while now, and quite honestly I have no idea what might be causing it. I've created a class that extends ShapeBase to use as a collision object that has a Particle Emitter Node mounted to it. The ShapeBase class moves downwards by 0.05 every tick.

Here's the first problem, when I go into the editor in game, I can select and watch the objects move downwards in perfect harmony. However, the actual visual particle effect remains where the object was spawned.

Now another interesting part. I created a class extending a particle emitter node that moves itself up 0.5 every tick. When I add that to the game, it moves along with the visual particle effects. When I mount the extended particle emitter node, and watch it in the editor the ShapeBase and extended particle emitter both move down. However, the visual particle effect moves up into the sky.

Is there something extra special happening when I call the position update from inside the class? Is this some sort of problem that is well known? I've searched the forums repeatedly to try and find something but I haven't had any luck. Does any one have any suggestions or advice?

Extended ShapeBase Class:

//IMPLEMENT_CONOBJECT(EffectType);
IMPLEMENT_CO_NETOBJECT_V1(EffectType);
IMPLEMENT_CO_DATABLOCK_V1(EffectTypeData);
static const U32 sgAllowedDynamicTypes = 0xffffff;

EffectTypeData::EffectTypeData()
{
   dynamicTypeField     = 0;

   shadowEnable = true;

   noIndividualDamage = false;
}

void EffectTypeData::initPersistFields()
{
   addField("noIndividualDamage",   TypeBool, Offset(noIndividualDamage,   StaticShapeData), "Deprecatednn @internal");
   addField("dynamicType",          TypeS32,  Offset(dynamicTypeField,     StaticShapeData), 
      "@brief An integer value which, if speficied, is added to the value retured by getType().nn"
      "This allows you to extend the type mask for a StaticShape that uses this datablock.  Type masks "
      "are used for container queries, etc.");

   Parent::initPersistFields();
}

void EffectTypeData::packData(BitStream* stream)
{
   Parent::packData(stream);
   stream->writeFlag(noIndividualDamage);
   stream->write(dynamicTypeField);
}

void EffectTypeData::unpackData(BitStream* stream)
{
   Parent::unpackData(stream);
   noIndividualDamage = stream->readFlag();
   stream->read(&dynamicTypeField);
}
//----EffectType begin----
void EffectType::initPersistFields()
{
   Parent::initPersistFields();
}

bool EffectType::onAdd()
{
   if(!Parent::onAdd() || !mDataBlock)
      return false;

   // We need to modify our type mask based on what our datablock says...
   mTypeMask |= (mDataBlock->dynamicTypeField & sgAllowedDynamicTypes);

   addToScene();
 
   if (isServerObject())
      scriptOnAdd();

   nodeData->addToScene();
   nodeData->setPosition(this->getPosition());
   


   return true;
}

bool EffectType::onNewDataBlock(GameBaseData* dptr, bool reload)
{
   mDataBlock = dynamic_cast<EffectTypeData*>(dptr);
   if (!mDataBlock || !Parent::onNewDataBlock(dptr, reload))
      return false;

   scriptOnNewDataBlock();
   return true;
}

void EffectType::onRemove()
{
   scriptOnRemove();
   removeFromScene();
   Parent::onRemove();
}


//----------------------------------------------------------------------------

void EffectType::onCollision(SceneObject *object, const VectorF &vec){
	Con::warnf("hit");
}

void EffectType::processTick(const Move* move)
{
   Parent::processTick(move);
   // Image Triggers
   if (move && mDamageState == Enabled) {
      setImageTriggerState(0,move->trigger[0]);
      setImageTriggerState(1,move->trigger[1]);
   }

   this->setPosition(Point3F(this->getPosition().x, this->getPosition().y, this->getPosition().z - .05));

   if (isMounted()) {
      MatrixF mat;
      mMount.object->getMountTransform( mMount.node, mMount.xfm, &mat );
      Parent::setTransform(mat);
      Parent::setRenderTransform(mat);
   }
}

void EffectType::interpolateTick(F32 delta)
{
   if (isMounted()) {
      MatrixF mat;
      mMount.object->getRenderMountTransform( delta, mMount.node, mMount.xfm, &mat );
      Parent::setRenderTransform(mat);
   }
}

void EffectType::setTransform(const MatrixF& mat)
{
   Parent::setTransform(mat);
   setMaskBits(PositionMask);
}

void EffectType::onUnmount(ShapeBase*,S32)
{
   // Make sure the client get's the final server pos.
   setMaskBits(PositionMask);
}


//----------------------------------------------------------------------------

U32 EffectType::packUpdate(NetConnection *connection, U32 mask, BitStream *bstream)
{
   U32 retMask = Parent::packUpdate(connection,mask,bstream);
   if (bstream->writeFlag(mask & PositionMask | ExtendedInfoMask))
   {

      // Write the transform (do _not_ use writeAffineTransform.  Since this is a static
      //  object, the transform must be RIGHT THE *&)*$&^ ON or it will goof up the
      //  synchronization between the client and the server.
      mathWrite(*bstream,mObjToWorld);
      mathWrite(*bstream, mObjScale);
   }

   // powered?
   bstream->writeFlag(mPowered);

   if (mLightPlugin) 
   {
      retMask |= mLightPlugin->packUpdate(this, ExtendedInfoMask, connection, mask, bstream);
   }

   return retMask;
}

void EffectType::unpackUpdate(NetConnection *connection, BitStream *bstream)
{
   Parent::unpackUpdate(connection,bstream);
   if (bstream->readFlag())
   {
      MatrixF mat;
      mathRead(*bstream,&mat);
      Parent::setTransform(mat);
      Parent::setRenderTransform(mat);

      VectorF scale;
      mathRead(*bstream, &scale);
      setScale(scale);
   }

   // powered?
   mPowered = bstream->readFlag();

   if (mLightPlugin)
   {
      mLightPlugin->unpackUpdate(this, connection, bstream);
   }
}

EffectType::EffectType() : ShapeBase(){
	mTypeMask |= StaticShapeObjectType | StaticObjectType;
	mDataBlock = 0;
	nodeData = dynamic_cast<ParticleEmitterNode*>(Sim::findObject("FireEffectNode"));
	this->mountObject(nodeData, 0);
}

EffectType::~EffectType(){
	
}

Extended ParticleEmitterNode class:

IMPLEMENT_CO_NETOBJECT_V1(SpellEffect);

void SpellEffect::processTick(const Move *move){
	processMove();
	Parent::processTick(move);
}

void SpellEffect::processMove(){
	this->setPosition(Point3F(this->getPosition().x, this->getPosition().y, this->getPosition().z + 0.5));
}

void SpellEffect::cast(Point3F castPoint){
	initializing = true;
}

SpellEffect::SpellEffect() : ParticleEmitterNode(){
	initializing = false;
}

SpellEffect::~SpellEffect(){
}