player.cc

五行MMORPG引擎系统V1.0

   for (int i=0; i<NUM_SPLASH_EMITTERS; i++)
      if( !splashEmitterList[i] && splashEmitterIDList[i] != 0 )
         if( Sim::findObject( splashEmitterIDList[i], splashEmitterList[i] ) == false)
            Con::errorf(ConsoleLogEntry::General, "PlayerData::onAdd - Invalid packet, bad datablockId(particle emitter): 0x%x", splashEmitterIDList[i]);

   return true;
}

void PlayerData::getGroundInfo(TSShapeInstance* si, TSThread* thread,ActionAnimation *dp)
{
   dp->death = !dStrnicmp(dp->name, "death", 5);
   if (dp->death)
   {
      // Death animations use roll frame-to-frame changes in ground transform into position
      dp->speed = 0;
      dp->dir.set(0,0,0);
   }
   else
   {
      VectorF save = dp->dir;
      si->setSequence(thread,dp->sequence,0);
      si->animate();
      si->advanceTime(1);
      si->animateGround();
      si->getGroundTransform().getColumn(3,&dp->dir);
      if ((dp->speed = dp->dir.len()) < 0.01)
      {
         // No ground displacement... In this case we'll use the
         // default table entry, if there is one.
         if (save.len() > 0.01)
         {
            dp->dir = save;
            dp->speed = 1;
            dp->velocityScale = false;
         }
         else
            dp->speed = 0;
      }
      else
         dp->dir *= 1 / dp->speed*save;	/// TGE_PlayerAnim
         //dp->dir *= 1 / dp->speed;
   }
}

bool PlayerData::isTableSequence(S32 seq)
{
   // The sequences from the table must already have
   // been loaded for this to work.
   for (int i = 0; i < NumTableActionAnims; i++)
      if (actionList[i].sequence == seq)
         return true;
   return false;
}

bool PlayerData::isJumpAction(U32 action)
{
   return (action == JumpAnim || action == StandJumpAnim);
}

void PlayerData::initPersistFields()
{
   Parent::initPersistFields();

   addField("renderFirstPerson", TypeBool, Offset(renderFirstPerson, PlayerData));
   addField("pickupRadius", TypeF32, Offset(pickupRadius, PlayerData));

   addField("minLookAngle", TypeF32, Offset(minLookAngle, PlayerData));
   addField("maxLookAngle", TypeF32, Offset(maxLookAngle, PlayerData));
   addField("maxFreelookAngle", TypeF32, Offset(maxFreelookAngle, PlayerData));

   addField("maxTimeScale", TypeF32, Offset(maxTimeScale, PlayerData));

   addField("maxStepHeight", TypeF32, Offset(maxStepHeight, PlayerData));
   addField("runForce", TypeF32, Offset(runForce, PlayerData));
   addField("runEnergyDrain", TypeF32, Offset(runEnergyDrain, PlayerData));
   addField("minRunEnergy", TypeF32, Offset(minRunEnergy, PlayerData));
   addField("maxForwardSpeed", TypeF32, Offset(maxForwardSpeed, PlayerData));
   addField("maxBackwardSpeed", TypeF32, Offset(maxBackwardSpeed, PlayerData));
   addField("maxSideSpeed", TypeF32, Offset(maxSideSpeed, PlayerData));
   addField("maxUnderwaterForwardSpeed", TypeF32, Offset(maxUnderwaterForwardSpeed, PlayerData));
   addField("maxUnderwaterBackwardSpeed", TypeF32, Offset(maxUnderwaterBackwardSpeed, PlayerData));
   addField("maxUnderwaterSideSpeed", TypeF32, Offset(maxUnderwaterSideSpeed, PlayerData));
   addField("runSurfaceAngle", TypeF32, Offset(runSurfaceAngle, PlayerData));
   addField("minImpactSpeed", TypeF32, Offset(minImpactSpeed, PlayerData));
#ifdef TGE_RPG
   addField("runRate", TypeF32, Offset(m_fRunRate, PlayerData));
#endif

   addField("recoverDelay", TypeS32, Offset(recoverDelay, PlayerData));
   addField("recoverRunForceScale", TypeF32, Offset(recoverRunForceScale, PlayerData));

   addField("jumpForce", TypeF32, Offset(jumpForce, PlayerData));
   addField("jumpEnergyDrain", TypeF32, Offset(jumpEnergyDrain, PlayerData));
   addField("minJumpEnergy", TypeF32, Offset(minJumpEnergy, PlayerData));
   addField("minJumpSpeed", TypeF32, Offset(minJumpSpeed, PlayerData));
   addField("maxJumpSpeed", TypeF32, Offset(maxJumpSpeed, PlayerData));
   addField("jumpSurfaceAngle", TypeF32, Offset(jumpSurfaceAngle, PlayerData));
   addField("jumpDelay", TypeS32, Offset(jumpDelay, PlayerData));

   addField("boundingBox", TypePoint3F, Offset(boxSize, PlayerData));
   addField("boxHeadPercentage", TypeF32, Offset(boxHeadPercentage, PlayerData));
   addField("boxTorsoPercentage", TypeF32, Offset(boxTorsoPercentage, PlayerData));
   addField("boxHeadLeftPercentage", TypeS32, Offset(boxHeadLeftPercentage, PlayerData));
   addField("boxHeadRightPercentage", TypeS32, Offset(boxHeadRightPercentage, PlayerData));
   addField("boxHeadBackPercentage", TypeS32, Offset(boxHeadBackPercentage, PlayerData));
   addField("boxHeadFrontPercentage", TypeS32, Offset(boxHeadFrontPercentage, PlayerData));

   addField("horizMaxSpeed", TypeF32, Offset(horizMaxSpeed, PlayerData));
   addField("horizResistSpeed", TypeF32, Offset(horizResistSpeed, PlayerData));
   addField("horizResistFactor", TypeF32, Offset(horizResistFactor, PlayerData));

   addField("upMaxSpeed", TypeF32, Offset(upMaxSpeed, PlayerData));
   addField("upResistSpeed", TypeF32, Offset(upResistSpeed, PlayerData));
   addField("upResistFactor", TypeF32, Offset(upResistFactor, PlayerData));

   addField("decalData",         TypeDecalDataPtr, Offset(decalData, PlayerData));
   addField("decalOffset",TypeF32, Offset(decalOffset, PlayerData));

   addField("footPuffEmitter",   TypeParticleEmitterDataPtr,   Offset(footPuffEmitter,    PlayerData));
   addField("footPuffNumParts",  TypeS32,                      Offset(footPuffNumParts,   PlayerData));
   addField("footPuffRadius",    TypeF32,                      Offset(footPuffRadius,     PlayerData));
   addField("dustEmitter",       TypeParticleEmitterDataPtr,   Offset(dustEmitter,        PlayerData));

   addField("FootSoftSound",       TypeAudioProfilePtr, Offset(sound[FootSoft],          PlayerData));
   addField("FootHardSound",       TypeAudioProfilePtr, Offset(sound[FootHard],          PlayerData));
   addField("FootMetalSound",      TypeAudioProfilePtr, Offset(sound[FootMetal],         PlayerData));
   addField("FootSnowSound",       TypeAudioProfilePtr, Offset(sound[FootSnow],          PlayerData));
   addField("FootShallowSound",    TypeAudioProfilePtr, Offset(sound[FootShallowSplash], PlayerData));
   addField("FootWadingSound",     TypeAudioProfilePtr, Offset(sound[FootWading],        PlayerData));
   addField("FootUnderwaterSound", TypeAudioProfilePtr, Offset(sound[FootUnderWater],    PlayerData));
   addField("FootBubblesSound",    TypeAudioProfilePtr, Offset(sound[FootBubbles],       PlayerData));
   addField("movingBubblesSound",   TypeAudioProfilePtr, Offset(sound[MoveBubbles],        PlayerData));
   addField("waterBreathSound",     TypeAudioProfilePtr, Offset(sound[WaterBreath],        PlayerData));

   addField("impactSoftSound",   TypeAudioProfilePtr, Offset(sound[ImpactSoft],  PlayerData));
   addField("impactHardSound",   TypeAudioProfilePtr, Offset(sound[ImpactHard],  PlayerData));
   addField("impactMetalSound",  TypeAudioProfilePtr, Offset(sound[ImpactMetal], PlayerData));
   addField("impactSnowSound",   TypeAudioProfilePtr, Offset(sound[ImpactSnow],  PlayerData));

   addField("mediumSplashSoundVelocity", TypeF32,     Offset(medSplashSoundVel,  PlayerData));
   addField("hardSplashSoundVelocity",   TypeF32,     Offset(hardSplashSoundVel,  PlayerData));
   addField("exitSplashSoundVelocity",   TypeF32,     Offset(exitSplashSoundVel,  PlayerData));

   addField("impactWaterEasy",   TypeAudioProfilePtr, Offset(sound[ImpactWaterEasy],   PlayerData));
   addField("impactWaterMedium", TypeAudioProfilePtr, Offset(sound[ImpactWaterMedium], PlayerData));
   addField("impactWaterHard",   TypeAudioProfilePtr, Offset(sound[ImpactWaterHard],   PlayerData));
   addField("exitingWater",      TypeAudioProfilePtr, Offset(sound[ExitWater],         PlayerData));

   addField("splash",         TypeSplashDataPtr,      Offset(splash,          PlayerData));
   addField("splashVelocity", TypeF32,                Offset(splashVelocity,  PlayerData));
   addField("splashAngle",    TypeF32,                Offset(splashAngle,     PlayerData));
   addField("splashFreqMod",  TypeF32,                Offset(splashFreqMod,   PlayerData));
   addField("splashVelEpsilon", TypeF32,              Offset(splashVelEpsilon, PlayerData));
   addField("bubbleEmitTime", TypeF32,                Offset(bubbleEmitTime,  PlayerData));
   addField("splashEmitter",  TypeParticleEmitterDataPtr,   Offset(splashEmitterList,   PlayerData), NUM_SPLASH_EMITTERS);
   addField("footstepSplashHeight",      TypeF32,     Offset(footSplashHeight,  PlayerData));

   addField("groundImpactMinSpeed",       TypeF32,       Offset(groundImpactMinSpeed,        PlayerData));
   addField("groundImpactShakeFreq",      TypePoint3F,   Offset(groundImpactShakeFreq,       PlayerData));
   addField("groundImpactShakeAmp",       TypePoint3F,   Offset(groundImpactShakeAmp,        PlayerData));
   addField("groundImpactShakeDuration",  TypeF32,       Offset(groundImpactShakeDuration,   PlayerData));
   addField("groundImpactShakeFalloff",   TypeF32,       Offset(groundImpactShakeFalloff,    PlayerData));
}

void PlayerData::packData(BitStream* stream)
{
   Parent::packData(stream);

   stream->writeFlag(renderFirstPerson);

   stream->write(minLookAngle);
   stream->write(maxLookAngle);
   stream->write(maxFreelookAngle);
   stream->write(maxTimeScale);

   stream->write(maxStepHeight);

   stream->write(runForce);
   stream->write(runEnergyDrain);
   stream->write(minRunEnergy);
   stream->write(maxForwardSpeed);
   stream->write(maxBackwardSpeed);
   stream->write(maxSideSpeed);
   stream->write(maxUnderwaterForwardSpeed);
   stream->write(maxUnderwaterBackwardSpeed);
   stream->write(maxUnderwaterSideSpeed);
   stream->write(runSurfaceAngle);
#ifdef TGE_RPG
   stream->write(m_fRunRate);
#endif

   stream->write(recoverDelay);
   stream->write(recoverRunForceScale);

   stream->write(jumpForce);
   stream->write(jumpEnergyDrain);
   stream->write(minJumpEnergy);
   stream->write(minJumpSpeed);
   stream->write(maxJumpSpeed);
   stream->write(jumpSurfaceAngle);
   stream->writeInt(jumpDelay,JumpDelayBits);

   stream->write(horizMaxSpeed);
   stream->write(horizResistSpeed);
   stream->write(horizResistFactor);

   stream->write(upMaxSpeed);
   stream->write(upResistSpeed);
   stream->write(upResistFactor);

   stream->write(splashVelocity);
   stream->write(splashAngle);
   stream->write(splashFreqMod);
   stream->write(splashVelEpsilon);
   stream->write(bubbleEmitTime);

   stream->write(medSplashSoundVel);
   stream->write(hardSplashSoundVel);
   stream->write(exitSplashSoundVel);
   stream->write(footSplashHeight);
   // Don't need damage scale on the client
   stream->write(minImpactSpeed);

   S32 i;
   for ( i = 0; i < MaxSounds; i++)
      if (stream->writeFlag(sound[i]))
         stream->writeRangedU32(packed? SimObjectId(sound[i]):
                                sound[i]->getId(),DataBlockObjectIdFirst,DataBlockObjectIdLast);

   stream->write(boxSize.x);
   stream->write(boxSize.y);
   stream->write(boxSize.z);

   if( stream->writeFlag( footPuffEmitter ) )
   {
      stream->writeRangedU32( footPuffEmitter->getId(), DataBlockObjectIdFirst,  DataBlockObjectIdLast );
   }

   stream->write( footPuffNumParts );
   stream->write( footPuffRadius );

   if( stream->writeFlag( decalData ) )
   {
      stream->writeRangedU32( decalData->getId(), DataBlockObjectIdFirst,  DataBlockObjectIdLast );
   }
   stream->write(decalOffset);

   if( stream->writeFlag( dustEmitter ) )
   {
      stream->writeRangedU32( dustEmitter->getId(), DataBlockObjectIdFirst,  DataBlockObjectIdLast );
   }

   if (stream->writeFlag( splash ))
   {
      stream->writeRangedU32(splash->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast);
   }

   for( i=0; i<NUM_SPLASH_EMITTERS; i++ )
   {
      if( stream->writeFlag( splashEmitterList[i] != NULL ) )
      {
         stream->writeRangedU32( splashEmitterList[i]->getId(), DataBlockObjectIdFirst,  DataBlockObjectIdLast );
      }
   }

   stream->write(groundImpactMinSpeed);
   stream->write(groundImpactShakeFreq.x);
   stream->write(groundImpactShakeFreq.y);
   stream->write(groundImpactShakeFreq.z);
   stream->write(groundImpactShakeAmp.x);
   stream->write(groundImpactShakeAmp.y);
   stream->write(groundImpactShakeAmp.z);
   stream->write(groundImpactShakeDuration);
   stream->write(groundImpactShakeFalloff);
}

void PlayerData::unpackData(BitStream* stream)
{
   Parent::unpackData(stream);

   renderFirstPerson = stream->readFlag();

   stream->read(&minLookAngle);
   stream->read(&maxLookAngle);
   stream->read(&maxFreelookAngle);
   stream->read(&maxTimeScale);

   stream->read(&maxStepHeight);

   stream->read(&runForce);
   stream->read(&runEnergyDrain);
   stream->read(&minRunEnergy);
   stream->read(&maxForwardSpeed);
   stream->read(&maxBackwardSpeed);
   stream->read(&maxSideSpeed);
   stream->read(&maxUnderwaterForwardSpeed);
   stream->read(&maxUnderwaterBackwardSpeed);
   stream->read(&maxUnderwaterSideSpeed);
   stream->read(&runSurfaceAngle);

#ifdef TGE_RPG
   stream->read(&m_fRunRate);
#endif

   stream->read(&recoverDelay);
   stream->read(&recoverRunForceScale);

   stream->read(&jumpForce);
   stream->read(&jumpEnergyDrain);
   stream->read(&minJumpEnergy);
   stream->read(&minJumpSpeed);
   stream->read(&maxJumpSpeed);
   stream->read(&jumpSurfaceAngle);
   jumpDelay = stream->readInt(JumpDelayBits);

   stream->read(&horizMaxSpeed);
   stream->read(&horizResistSpeed);
   stream->read(&horizResistFactor);

   stream->read(&upMaxSpeed);
   stream->read(&upResistSpeed);
   stream->read(&upResistFactor);

   stream->read(&splashVelocity);
   stream->read(&splashAngle);
   stream->read(&splashFreqMod);
   stream->read(&splashVelEpsilon);
   stream->read(&bubbleEmitTime);

   stream->read(&medSplashSoundVel);
   stream->read(&hardSplashSoundVel);
   stream->read(&exitSplashSoundVel);
   stream->read(&footSplashHeight);

   stream->read(&minImpactSpeed);

   S32 i;
   for (i = 0; i < MaxSounds; i++) {
      sound[i] = NULL;
      if (stream->readFlag())
         sound[i] = (AudioProfile*)stream->readRangedU32(DataBlockObjectIdFirst,
                                                         DataBlockObjectIdLast);
   }

   stream->read(&boxSize.x);
   stream->read(&boxSize.y);
   stream->read(&boxSize.z);

   if( stream->readFlag() )
   {
      footPuffID = (S32) stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
   }

   stream->read(&footPuffNumParts);
   stream->read(&footPuffRadius);

   if( stream->readFlag() )
   {
      decalID = (S32) stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
   }
   stream->read(&decalOffset);

   if( stream->readFlag() )
   {
      dustID = (S32) stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
   }

   if (stream->readFlag())
   {
      splashId = stream->readRangedU32( DataBlockObjectIdFirst, DataBlockObjectIdLast );
   }

   for( i=0; i<NUM_SPLASH_EMITTERS; i++ )
   {
      if( stream->readFlag() )
      {
         splashEmitterIDList[i] = stream->readRangedU32( DataBlockObjectIdFirst, DataBlockObjectIdLast );
      }
   }

   stream->read(&groundImpactMinSpeed);
   stream->read(&groundImpactShakeFreq.x);
   stream->read(&groundImpactShakeFreq.y);
   stream->read(&groundImpactShakeFreq.z);
   stream->read(&groundImpactShakeAmp.x);
   stream->read(&groundImpactShakeAmp.y);
   stream->read(&groundImpactShakeAmp.z);
   stream->read(&groundImpactShakeDuration);
   stream->read(&groundImpactShakeFalloff);
}


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

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

IMPLEMENT_CO_NETOBJECT_V1(Player);
F32 Player::mGravity = -20;


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