lightning.cc

五行MMORPG引擎系统V1.0

//-----------------------------------------------------------------------------
// Torque Game Engine
// Copyright (C) GarageGames.com, Inc.
//-----------------------------------------------------------------------------

#include "game/fx/lightning.h"

#include "dgl/dgl.h"
#include "sceneGraph/sceneState.h"
#include "console/consoleTypes.h"
#include "math/mathIO.h"
#include "core/bitStream.h"
#include "game/gameConnection.h"
#include "game/shapeBase.h"
#include "math/mRandom.h"
#include "math/mathUtils.h"
#include "audio/audioDataBlock.h"
#include "platform/platformAudio.h"
#include "terrain/terrData.h"
#include "sceneGraph/sceneGraph.h"
#include "game/player.h"
#include "game/camera.h"

IMPLEMENT_CO_DATABLOCK_V1(LightningData);
IMPLEMENT_CO_NETOBJECT_V1(Lightning);

MRandomLCG sgLightningRand;

ConsoleMethod( Lightning, warningFlashes, void, 2, 2, "")
{
   if (object->isServerObject()) object->warningFlashes();
}

ConsoleMethod( Lightning, strikeRandomPoint, void, 2, 2, "")
{
   if (object->isServerObject()) object->strikeRandomPoint();
}

ConsoleMethod( Lightning, strikeObject, void, 3, 3, "(ShapeBase id)")
{
   S32 id = dAtoi(argv[2]);
   ShapeBase* pSB;

   if (object->isServerObject() && Sim::findObject(id, pSB))
      object->strikeObject(pSB);
}

S32 QSORT_CALLBACK cmpSounds(const void* p1, const void* p2)
{
   U32 i1 = *((const S32*)p1);
   U32 i2 = *((const S32*)p2);

   if (i1 < i2) {
      return 1;
   } else if (i1 > i2) {
      return -1;
   } else {
      return 0;
   }
}

//--------------------------------------------------------------------------
//--------------------------------------
//
class LightningStrikeEvent : public NetEvent
{
   typedef NetEvent Parent;

  public:
   enum EventType {
      WarningFlash   = 0,
      Strike         = 1,
      TargetedStrike = 2,

      TypeMin        = WarningFlash,
      TypeMax        = TargetedStrike
   };
   enum Constants {
      PositionalBits = 10
   };

   Point2F                   mStart;
   SimObjectPtr<SceneObject> mTarget;

   Lightning*                mLightning;

   // Set by unpack...
  public:
   S32                       mClientId;

  public:
   LightningStrikeEvent();
   ~LightningStrikeEvent();

   void pack(NetConnection*, BitStream*);
   void write(NetConnection*, BitStream*){}
   void unpack(NetConnection*, BitStream*);
   void process(NetConnection*);

   DECLARE_CONOBJECT(LightningStrikeEvent);
};
IMPLEMENT_CO_CLIENTEVENT_V1(LightningStrikeEvent);

LightningStrikeEvent::LightningStrikeEvent()
{
   mLightning = NULL;
   mTarget = NULL;
}

LightningStrikeEvent::~LightningStrikeEvent()
{

}

void LightningStrikeEvent::pack(NetConnection* con, BitStream* stream)
{
   if(!mLightning)
   {
      stream->writeFlag(false);
      return;
   }
   S32 id = con->getGhostIndex(mLightning);
   if(id == -1)
   {
      stream->writeFlag(false);
      return;
   }
   stream->writeFlag(true);
   stream->writeRangedU32(U32(id), 0, GhostConnection::MaxGhostCount);
   stream->writeFloat(mStart.x, PositionalBits);
   stream->writeFloat(mStart.y, PositionalBits);

   if( mTarget )
   {
      S32 ghostIndex = con->getGhostIndex(mTarget);
      if (ghostIndex == -1)
         stream->writeFlag(false);
      else
      {
         stream->writeFlag(true);
         stream->writeRangedU32(U32(ghostIndex), 0, GhostConnection::MaxGhostCount);
      }
   }
   else
      stream->writeFlag( false );
}

void LightningStrikeEvent::unpack(NetConnection* con, BitStream* stream)
{
   if(!stream->readFlag())
      return;
   S32 mClientId = stream->readRangedU32(0, GhostConnection::MaxGhostCount);
   mLightning = NULL;
   NetObject* pObject = con->resolveGhost(mClientId);
   if (pObject)
      mLightning = dynamic_cast<Lightning*>(pObject);

   mStart.x = stream->readFloat(PositionalBits);
   mStart.y = stream->readFloat(PositionalBits);

   if( stream->readFlag() )
   {
      // target id
      S32 mTargetID    = stream->readRangedU32(0, GhostConnection::MaxGhostCount);

      NetObject* pObject = con->resolveGhost(mTargetID);
      if( pObject != NULL )
      {
         mTarget = dynamic_cast<SceneObject*>(pObject);
      }
      if( bool(mTarget) == false )
      {
         Con::errorf(ConsoleLogEntry::General, "LightningStrikeEvent::unpack: could not resolve target ghost properly");
      }

   }

}

void LightningStrikeEvent::process(NetConnection*)
{
   if (mLightning)
      mLightning->processEvent(this);
}


//--------------------------------------------------------------------------
//--------------------------------------
//
LightningData::LightningData()
{
   strikeSound = NULL;
   strikeSoundID = -1;

   dMemset( strikeTextureNames, 0, sizeof( strikeTextureNames ) );
   dMemset( strikeTextures, 0, sizeof( strikeTextures ) );

   U32 i;
   for (i = 0; i < MaxThunders; i++) {
      thunderSounds[i]   = NULL;
      thunderSoundIds[i] = -1;
   }
}

LightningData::~LightningData()
{

}


//--------------------------------------------------------------------------
void LightningData::initPersistFields()
{
   Parent::initPersistFields();

   addField("strikeSound",     TypeAudioProfilePtr, Offset(strikeSound,        LightningData));
   addField("thunderSounds",   TypeAudioProfilePtr, Offset(thunderSounds,      LightningData), MaxThunders);
   addField("strikeTextures",  TypeString,          Offset(strikeTextureNames, LightningData), MaxTextures);
}


//--------------------------------------------------------------------------
bool LightningData::onAdd()
{
   if(!Parent::onAdd())
      return false;

   for (U32 i = 0; i < MaxThunders; i++) {
      if (!thunderSounds[i] && thunderSoundIds[i] != -1) {
         if (Sim::findObject(thunderSoundIds[i], thunderSounds[i]) == false)
            Con::errorf(ConsoleLogEntry::General, "LightningData::onAdd: Invalid packet, bad datablockId(sound: %d", thunderSounds[i]);
      }
   }

   if( !strikeSound && strikeSoundID != -1 )
   {
      if( Sim::findObject( strikeSoundID, strikeSound ) == false)
         Con::errorf(ConsoleLogEntry::General, "LightningData::onAdd: Invalid packet, bad datablockId(sound: %d", strikeSound);
   }

   return true;
}


bool LightningData::preload(bool server, char errorBuffer[256])
{
   if (Parent::preload(server, errorBuffer) == false)
      return false;


   dQsort(thunderSounds, MaxThunders, sizeof(AudioProfile*), cmpSounds);
   for (numThunders = 0; numThunders < MaxThunders && thunderSounds[numThunders] != NULL; numThunders++) 
   {
      //
   }

   if (server == false) 
   {
      for (U32 i = 0; i < MaxTextures; i++) 
      {
         strikeTextures[i] = TextureHandle(strikeTextureNames[i], MeshTexture);
         strikeTextures[i].setClamp(false);
      }
   }


   return true;
}


//--------------------------------------------------------------------------
void LightningData::packData(BitStream* stream)
{
   Parent::packData(stream);

   U32 i;
   for (i = 0; i < MaxThunders; i++) 
   {
      if (stream->writeFlag(thunderSounds[i] != NULL)) 
      {
         stream->writeRangedU32(thunderSounds[i]->getId(), DataBlockObjectIdFirst,
                                                           DataBlockObjectIdLast);
      }
   }
   for (i = 0; i < MaxTextures; i++) 
   {
      stream->writeString(strikeTextureNames[i]);
   }

   if( stream->writeFlag( strikeSound != NULL) )
   {
      stream->writeRangedU32( strikeSound->getId(), DataBlockObjectIdFirst,
                                                    DataBlockObjectIdLast);
   }
}

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

   U32 i;
   for (i = 0; i < MaxThunders; i++) 
   {
      if (stream->readFlag())
         thunderSoundIds[i] = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
      else
         thunderSoundIds[i] = -1;
   }
   
   for (i = 0; i < MaxTextures; i++) 
   {
      strikeTextureNames[i] = stream->readSTString();
   }

   if (stream->readFlag())
      strikeSoundID = stream->readRangedU32(DataBlockObjectIdFirst, DataBlockObjectIdLast);
   else
      strikeSoundID = -1;
}


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

Lightning::Lightning()
{
   mNetFlags.set(Ghostable|ScopeAlways);
   mTypeMask |= StaticObjectType|EnvironmentObjectType;

   mLastThink = 0;

   mStrikeListHead  = NULL;
   mThunderListHead = NULL;

   strikesPerMinute = 12;
   strikeWidth = 2.5;
   chanceToHitTarget = 0.5;
   strikeRadius = 20.0;
   boltStartRadius = 20.0;
   color.set( 1.0, 1.0, 1.0, 1.0 );
   fadeColor.set( 0.1, 0.1, 1.0, 1.0 );
   useFog = true;

   setScale( VectorF( 512, 512, 300 ) );
}

Lightning::~Lightning()
{
   //
}

//--------------------------------------------------------------------------
void Lightning::initPersistFields()
{
   Parent::initPersistFields();

   addGroup("Strikes");	
   addField("strikesPerMinute",TypeS32,             Offset(strikesPerMinute,   Lightning));
   addField("strikeWidth",     TypeF32,             Offset(strikeWidth,        Lightning));
   addField("strikeRadius",    TypeF32,             Offset(strikeRadius,       Lightning));
   endGroup("Strikes");	

   addGroup("Colors");	
   addField("color",           TypeColorF,          Offset(color,              Lightning));
   addField("fadeColor",       TypeColorF,          Offset(fadeColor,          Lightning));
   endGroup("Colors");	

   addGroup("Bolts");	
   addField("chanceToHitTarget", TypeF32,           Offset(chanceToHitTarget,  Lightning));
   addField("boltStartRadius", TypeF32,             Offset(boltStartRadius,    Lightning));
   addField("useFog",          TypeBool,            Offset(useFog,             Lightning));
   endGroup("Bolts");	
}

//--------------------------------------------------------------------------
bool Lightning::onAdd()
{
   if(!Parent::onAdd())
      return false;

   mObjBox.min.set( -0.5, -0.5, -0.5 );
   mObjBox.max.set(  0.5,  0.5,  0.5 );

   resetWorldBox();
   addToScene();

   return true;
}


void Lightning::onRemove()
{
   removeFromScene();

   Parent::onRemove();
}


bool Lightning::onNewDataBlock(GameBaseData* dptr)
{
   mDataBlock = dynamic_cast<LightningData*>(dptr);
   if (!mDataBlock || !Parent::onNewDataBlock(dptr))
      return false;

   scriptOnNewDataBlock();
   return true;
}


//--------------------------------------------------------------------------
bool Lightning::prepRenderImage(SceneState* state, const U32 stateKey,
                                const U32 /*startZone*/, const bool /*modifyBaseState*/)