void WeaponPowerup::Save(HMESSAGEWRITE hWrite, DDWORD dwSaveFlags)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE || !hWrite) return;
pServerDE->WriteToMessageByte(hWrite, m_iWeaponType);
pServerDE->WriteToMessageByte(hWrite, m_eModelSize);
pServerDE->WriteToMessageDWord(hWrite, m_dwAmmo);
}
void SpellPickup::ObjectTouch(HOBJECT hObject)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return;
HMESSAGEWRITE hMessage = pServerDE->StartMessageToObject(this, hObject, MID_ADDAMMO);
pServerDE->WriteToMessageByte(hMessage, (DBYTE)m_nSpellType);
pServerDE->EndMessage(hMessage);
}
void PickupObject::SendEffectMessage()
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return;
HMESSAGEWRITE hMessage = pServerDE->StartSpecialEffectMessage(this);
pServerDE->WriteToMessageByte(hMessage, SFX_POWERUP_ID);
pServerDE->EndMessage(hMessage);
}
LTBOOL Key::InitialUpdate(LTVector* pMovement)
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE) return LTFALSE;
pServerDE->SetNextUpdate (m_hObject, 0.0f);
return LTTRUE;
}
DBOOL ParticleSystem::ReadProp(ObjectCreateStruct *)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return DFALSE;
GenericProp genProp;
if (g_pServerDE->GetPropGeneric("Static", &genProp) == DE_OK)
m_bStatic = genProp.m_Bool;
if (g_pServerDE->GetPropGeneric("ParticleFlags", &genProp) == DE_OK)
m_dwFlags = genProp.m_Long;
if (g_pServerDE->GetPropGeneric("BurstWait", &genProp) == DE_OK)
m_fBurstWait = genProp.m_Float;
if (g_pServerDE->GetPropGeneric("ParticlesPerSecond", &genProp) == DE_OK)
m_fParticlesPerSecond = genProp.m_Float;
if (g_pServerDE->GetPropGeneric("EmissionRadius", &genProp) == DE_OK)
m_fEmissionRadius = genProp.m_Float;
if (g_pServerDE->GetPropGeneric("MinimumVelocity", &genProp) == DE_OK)
m_fMinimumVelocity = genProp.m_Float;
if (g_pServerDE->GetPropGeneric("MaximumVelocity", &genProp) == DE_OK)
m_fMaximumVelocity = genProp.m_Float;
if (g_pServerDE->GetPropGeneric("VelocityOffset", &genProp) == DE_OK)
m_fVelocityOffset = genProp.m_Float;
if (g_pServerDE->GetPropGeneric("ParticleLifetime", &genProp) == DE_OK)
m_fParticleLifetime = genProp.m_Float;
if (g_pServerDE->GetPropGeneric("Color1", &genProp) == DE_OK)
VEC_COPY(m_vColor1, genProp.m_Color);
if (g_pServerDE->GetPropGeneric("Color2", &genProp) == DE_OK)
VEC_COPY(m_vColor2, genProp.m_Color);
if (g_pServerDE->GetPropGeneric("ParticleRadius", &genProp) == DE_OK)
m_fRadius = genProp.m_Float;
if (g_pServerDE->GetPropGeneric("Gravity", &genProp) == DE_OK)
m_fGravity = genProp.m_Float;
if (g_pServerDE->GetPropGeneric("RotationVelocity", &genProp) == DE_OK)
m_fRotationVelocity = genProp.m_Float;
if (g_pServerDE->GetPropGeneric("TextureName", &genProp) == DE_OK)
{
if (genProp.m_String[0]) m_hstrTextureName = pServerDE->CreateString(genProp.m_String);
}
return DTRUE;
}
void VolumeBrush::UpdateZeroGravity(ContainerPhysics* pCPStruct)
{
CServerDE* pServerDE = GetServerDE();
if (!pCPStruct || !pCPStruct->m_hObject) return;
if (pCPStruct->m_Flags & FLAG_GRAVITY)
{
pCPStruct->m_Flags &= ~FLAG_GRAVITY;
}
}
void ClientLightFX::Load(HMESSAGEREAD hRead, DDWORD dwLoadFlags)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE || !hRead) return;
m_bOn = (DBOOL) pServerDE->ReadFromMessageByte(hRead);
m_bDynamic = (DBOOL) pServerDE->ReadFromMessageByte(hRead);
m_fLifeTime = pServerDE->ReadFromMessageFloat(hRead);
m_fStartTime = pServerDE->ReadFromMessageFloat(hRead);
}
PolyGrid::~PolyGrid()
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return;
if (m_hstrSurfaceSprite)
{
pServerDE->FreeString(m_hstrSurfaceSprite);
}
}
void CClientParticleStreamSFX::Save(HMESSAGEWRITE hWrite, DDWORD dwSaveFlags)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE || !hWrite) return;
// Only need to save the data that changes (all the data in the
// special fx message is saved/loaded for us)...
pServerDE->WriteToMessageByte(hWrite, bOn);
}
void Rain::TriggerMsg(HOBJECT hSender, HSTRING hMsg)
{
CServerDE* pServerDE = GetServerDE();
HSTRING hstr;
hstr = pServerDE->CreateString(g_szTriggerOn);
if (pServerDE->CompareStringsUpper(hMsg, hstr))
SendEffectMessage();
pServerDE->FreeString(hstr);
}
void PowerupPickup::ObjectTouch(HOBJECT hObject)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return;
HMESSAGEWRITE hMessage = pServerDE->StartMessageToObject(this, hObject, MID_ADDPOWERUP);
pServerDE->WriteToMessageByte(hMessage, (DBYTE)m_nType);
pServerDE->WriteToMessageFloat(hMessage, m_fValue * m_fValueMult);
pServerDE->EndMessage(hMessage);
}
DDWORD Cat::ObjectMessageFn(HOBJECT hSender, DDWORD messageID, HMESSAGEREAD hRead)
{
switch(messageID)
{
case MID_DAMAGE:
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) break;
DVector vDir;
pServerDE->ReadFromMessageVector(hRead, &vDir);
DFLOAT fDamage = pServerDE->ReadFromMessageFloat(hRead);
DamageType eType = (DamageType)pServerDE->ReadFromMessageByte(hRead);
HOBJECT hHeHitMe = pServerDE->ReadFromMessageObject(hRead);
if (eType == DT_SQUEAKY)
{
if (m_hstrSqueakedAtSound)
{
char* pSound = pServerDE->GetStringData(m_hstrSqueakedAtSound);
if (pSound) PlaySoundFromObject(m_hObject, pSound, m_fSoundRadius, SOUNDPRIORITY_MISC_MEDIUM );
}
// If we're supposed to trigger something, trigger it here
if (m_hstrSqueakyTarget && m_hstrSqueakyMessage)
{
SendTriggerMsgToObjects(this, m_hstrSqueakyTarget, m_hstrSqueakyMessage);
}
}
else
{
if (m_hstrDeathSound)
{
DVector vPos;
pServerDE->GetObjectPos(m_hObject, &vPos);
char* pSound = pServerDE->GetStringData(m_hstrDeathSound);
if (pSound) PlaySoundFromPos(&vPos, pSound, m_fSoundRadius, SOUNDPRIORITY_MISC_MEDIUM );
}
if (m_hstrDeathTriggerTarget && m_hstrDeathTriggerMessage)
{
SendTriggerMsgToObjects(this, m_hstrDeathTriggerTarget, m_hstrDeathTriggerMessage);
}
pServerDE->RemoveObject(m_hObject);
}
break;
}
default : break;
}
return InventoryItem::ObjectMessageFn(hSender, messageID, hRead);
}
void Naga::PostPropRead(ObjectCreateStruct *pStruct)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE || !pStruct) return;
char* pFilename = "Models\\Enemies\\Naga.abc";
char* pSkin = "Skins\\Enemies\\Naga.dtx";
_mbscpy((unsigned char*)pStruct->m_Filename, (const unsigned char*)pFilename);
_mbscpy((unsigned char*)pStruct->m_SkinName, (const unsigned char*)pSkin);
}
CDestructableBrush::~CDestructableBrush()
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return;
if (m_hstrDebrisSkin)
{
pServerDE->FreeString(m_hstrDebrisSkin);
m_hstrDebrisSkin = NULL;
}
}
void KeyPickup::Save(HMESSAGEWRITE hWrite, DDWORD dwSaveFlags)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE || !hWrite) return;
pServerDE->WriteToMessageHString(hWrite, m_hstrFilename);
pServerDE->WriteToMessageHString(hWrite, m_hstrSkinName);
pServerDE->WriteToMessageHString(hWrite, m_hstrIconFile);
pServerDE->WriteToMessageHString(hWrite, m_hstrIconFileH);
pServerDE->WriteToMessageByte(hWrite, m_byUseCount);
}
void KeyPickup::Load(HMESSAGEREAD hRead, DDWORD dwSaveFlags)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE || !hRead) return;
m_hstrFilename = pServerDE->ReadFromMessageHString(hRead);
m_hstrSkinName = pServerDE->ReadFromMessageHString(hRead);
m_hstrIconFile = pServerDE->ReadFromMessageHString(hRead);
m_hstrIconFileH = pServerDE->ReadFromMessageHString(hRead);
m_byUseCount = pServerDE->ReadFromMessageByte(hRead);
}
void VolumeBrush::InitialUpdate(int nData)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return;
// For save game restores, just recreate the surface
if (nData == INITIALUPDATE_SAVEGAME)
return;
if (m_bShowSurface)
{
CreateSurface();
}
m_hPlayerClass = pServerDE->GetClass("CPlayerObj");
DDWORD dwUserFlags = m_bHidden ? 0 : USRFLG_VISIBLE;
dwUserFlags |= USRFLG_SAVEABLE;
pServerDE->SetObjectUserFlags(m_hObject, dwUserFlags);
if (m_hSurfaceObj)
{
pServerDE->SetObjectUserFlags(m_hSurfaceObj, dwUserFlags);
}
// Tell the client about any special fx (fog)...
HMESSAGEWRITE hMessage = pServerDE->StartSpecialEffectMessage(this);
pServerDE->WriteToMessageByte(hMessage, SFX_VOLUMEBRUSH_ID);
//pServerDE->WriteToMessageByte(hMessage, DTRUE);
pServerDE->WriteToMessageByte(hMessage, (DBYTE)m_bFogEnable);
pServerDE->WriteToMessageFloat(hMessage, m_fFogFarZ);
pServerDE->WriteToMessageFloat(hMessage, m_fFogNearZ);
pServerDE->WriteToMessageVector(hMessage, &m_vFogColor);
pServerDE->EndMessage(hMessage);
pServerDE->SetNextUpdate(m_hObject, 0.001f);
// Save volume brush's initial flags...
m_dwSaveFlags = pServerDE->GetObjectFlags(m_hObject);
// Normalize viscosity (1 = no movement, 0 = full movement)...
if (m_fViscosity < 0.0) m_fViscosity = 0.0f;
else if (m_fViscosity > 1.0) m_fViscosity = 1.0f;
// Okay, internally we really want it the opposite way (i.e., 1 = full
// movement, 0 = no movement)...
m_fViscosity = 1.0f - m_fViscosity;
}
DBOOL Trigger::Update()
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return DFALSE;
// Handle timed trigger...
if (m_bTimedTrigger)
{
DFLOAT fTime = pServerDE->GetTime();
if (fTime > m_fNextTriggerTime)
{
m_fNextTriggerTime = fTime + GetRandom(m_fMinTriggerTime, m_fMaxTriggerTime);
DoTrigger(DNULL, DFALSE);
}
}
// Attach the trigger to the object...
if (m_hstrAttachToObject && !m_bAttached)
{
AttachToObject();
m_bAttached = DTRUE;
}
if (m_bDelayingActivate)
{
UpdateDelayingActivate();
}
else
{
m_bActive = DTRUE;
// If not a timed trigger, my object touch notification will trigger
// new updates until then, I don't care.
if (m_bTimedTrigger)
{
pServerDE->SetNextUpdate(m_hObject, UPDATE_DELTA);
pServerDE->SetDeactivationTime(m_hObject, 0.0f);
}
else
{
pServerDE->SetNextUpdate(m_hObject, 0.0f);
pServerDE->SetDeactivationTime(m_hObject, TRIGGER_DEACTIVATION_TIME);
}
}
return DTRUE;
}
void Gabriel::StopShieldSound()
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE || !m_hShieldSound) return;
if (m_hShieldSound)
{
pServerDE->KillSound(m_hShieldSound);
m_hShieldSound = DNULL;
}
}
DBOOL CHandWeaponModel::Update()
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return 0;
if (m_bFirstUpdate)
{
m_bFirstUpdate = DFALSE;
DDWORD dwFlags = pServerDE->GetObjectFlags(m_hObject);
if (m_bVisible)
pServerDE->SetObjectFlags(m_hObject, dwFlags | FLAG_VISIBLE);
else
pServerDE->SetObjectFlags(m_hObject, dwFlags & ~FLAG_VISIBLE);
if( !m_bDropped )
{
pServerDE->SetNextUpdate(m_hObject, 0.0f);
return DTRUE;
}
}
// See if standing on anything
CollisionInfo collisionInfo;
pServerDE->GetStandingOn(m_hObject, &collisionInfo);
DBOOL bIsStandingOn = (collisionInfo.m_hObject != DNULL);
if (bIsStandingOn)
{
// Spawn a powerup
DVector vF, vPos, vU;
DRotation rRot;
// We want the rotation aligned.
pServerDE->GetObjectRotation(m_hObject, &rRot);
pServerDE->GetRotationVectors(&rRot, &vU, &vPos, &vF);
vF.y = 0.0f;
VEC_SET(vU, 0,1,0);
pServerDE->AlignRotation(&rRot, &vF, &vU);
pServerDE->GetObjectPos(m_hObject, &vPos);
vPos.y += 10;
SpawnWeaponPickup(m_dwType, m_hObject, &vPos, &rRot, !m_bOwnedByPlayer);
return DFALSE;
}
pServerDE->SetNextUpdate( m_hObject, 0.01f);
return DTRUE;
}
ObjectiveTrigger::~ObjectiveTrigger()
{
CServerDE* pServerDE = GetServerDE();
if (m_hstrAIName) pServerDE->FreeString (m_hstrAIName);
if (m_hAddObjectives) pServerDE->FreeString (m_hAddObjectives);
if (m_hRemoveObjectives) pServerDE->FreeString (m_hRemoveObjectives);
if (m_hCompletedObjectives) pServerDE->FreeString (m_hCompletedObjectives);
if (!pServerDE) return;
}
void PolyGrid:: Setup(DVector* pvDims, DVector* pvColor1, DVector* pvColor2,
HSTRING hstrSurfaceSprite, DFLOAT fXScaleMin, DFLOAT fXScaleMax,
DFLOAT fYScaleMin, DFLOAT fYScaleMax, DFLOAT fXScaleDuration,
DFLOAT fYScaleDuration, DFLOAT fXPan, DFLOAT fYPan,
DFLOAT fAlpha, DDWORD dwNumPolies)
{
D_WORD wColor1, wColor2;
CServerDE* pServerDE = GetServerDE();
if (!pServerDE || !pvDims || !pvColor1 || !pvColor2 || dwNumPolies < 4) return;
VEC_COPY(m_vDims, *pvDims);
pServerDE->SetObjectDims(m_hObject, pvDims);
VEC_COPY(m_vColor1, *pvColor1);
VEC_COPY(m_vColor2, *pvColor2);
wColor1 = Color255VectorToWord( pvColor1 );
wColor2 = Color255VectorToWord( pvColor2 );
// Limit the number of polies to 32k...
if ( dwNumPolies > 0x7FFF )
dwNumPolies = 0x7FFF;
HSTRING hstrSprite = hstrSurfaceSprite ? hstrSurfaceSprite : pServerDE->CreateString("");
// Tell the clients about the polygrid...
HMESSAGEWRITE hMessage = pServerDE->StartSpecialEffectMessage(this);
pServerDE->WriteToMessageByte(hMessage, SFX_POLYGRID_ID);
pServerDE->WriteToMessageVector(hMessage, &m_vDims);
pServerDE->WriteToMessageWord(hMessage, wColor1);
pServerDE->WriteToMessageWord(hMessage, wColor2);
pServerDE->WriteToMessageFloat(hMessage, fXScaleMin);
pServerDE->WriteToMessageFloat(hMessage, fXScaleMax);
pServerDE->WriteToMessageFloat(hMessage, fYScaleMin);
pServerDE->WriteToMessageFloat(hMessage, fYScaleMax);
pServerDE->WriteToMessageFloat(hMessage, fXScaleDuration);
pServerDE->WriteToMessageFloat(hMessage, fYScaleDuration);
pServerDE->WriteToMessageFloat(hMessage, fXPan);
pServerDE->WriteToMessageFloat(hMessage, fYPan);
pServerDE->WriteToMessageFloat(hMessage, fAlpha);
pServerDE->WriteToMessageHString(hMessage, hstrSprite);
pServerDE->WriteToMessageWord(hMessage, (D_WORD)dwNumPolies);
pServerDE->WriteToMessageByte(hMessage, m_nPlasmaType);
pServerDE->WriteToMessageByte(hMessage, m_nRingRate[0]);
pServerDE->WriteToMessageByte(hMessage, m_nRingRate[1]);
pServerDE->WriteToMessageByte(hMessage, m_nRingRate[2]);
pServerDE->WriteToMessageByte(hMessage, m_nRingRate[3]);
pServerDE->EndMessage(hMessage);
if (!hstrSurfaceSprite)
{
pServerDE->FreeString(hstrSprite);
}
}
DDWORD ObjectiveTrigger::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return DFALSE;
switch (messageID)
{
case MID_INITIALUPDATE:
{
if (fData != INITIALUPDATE_SAVEGAME)
{
pServerDE->SetObjectDims(m_hObject, &m_vDims);
pServerDE->SetObjectFlags(m_hObject, FLAG_TOUCH_NOTIFY);
pServerDE->SetObjectUserFlags(m_hObject, USRFLG_IGNORE_PROJECTILES);
pServerDE->SetNextUpdate(m_hObject, 0.0f);
}
}
break;
case MID_TOUCHNOTIFY:
{
if (!m_bTriggered) ObjectTouch((HOBJECT)pData);
}
break;
case MID_PRECREATE:
{
ObjectCreateStruct* pStruct = (ObjectCreateStruct*)pData;
if (!pStruct) return 0;
if (fData == PRECREATE_WORLDFILE)
{
ReadProp(pStruct);
}
}
break;
case MID_SAVEOBJECT:
{
Save((HMESSAGEWRITE)pData, (DDWORD)fData);
}
break;
case MID_LOADOBJECT:
{
Load((HMESSAGEREAD)pData, (DDWORD)fData);
}
break;
default : break;
}
return BaseClass::EngineMessageFn(messageID, pData, fData);
}
Key::~Key()
{
CServerDE* pServerDE = GetServerDE();
if (pServerDE)
{
if (m_hstrSoundName) pServerDE->FreeString (m_hstrSoundName);
if (m_hstrMessageTarget) pServerDE->FreeString (m_hstrMessageTarget);
if (m_hstrMessageName) pServerDE->FreeString (m_hstrMessageName);
if (m_hstrBPrintMessage) pServerDE->FreeString (m_hstrBPrintMessage);
}
}
void ScreenShake::Save(HMESSAGEWRITE hWrite, uint32 dwSaveFlags)
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE || !hWrite) return;
pServerDE->WriteToMessageVector(hWrite, &m_vAmount);
pServerDE->WriteToMessageFloat(hWrite, (LTFLOAT) m_nNumShakes);
pServerDE->WriteToMessageFloat(hWrite, m_fAreaOfEffect);
pServerDE->WriteToMessageFloat(hWrite, m_fFrequency);
pServerDE->WriteToMessageFloat(hWrite, m_fSoundRadius);
pServerDE->WriteToMessageHString(hWrite, m_hstrSound);
}
DBOOL LightFX::Init()
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return DFALSE;
// Normalize colors (0-1)
if (m_nNumColorCycles != 0)
{
m_vColor1.x = m_vColor1.x/255.0f;
m_vColor1.y = m_vColor1.y/255.0f;
m_vColor1.z = m_vColor1.z/255.0f;
m_vColor2.x = m_vColor2.x/255.0f;
m_vColor2.y = m_vColor2.y/255.0f;
m_vColor2.z = m_vColor2.z/255.0f;
m_vColor3.x = m_vColor3.x/255.0f;
m_vColor3.y = m_vColor3.y/255.0f;
m_vColor3.z = m_vColor3.z/255.0f;
m_fRedValue = m_vColor1.x;
m_fGreenValue = m_vColor1.y;
m_fBlueValue = m_vColor1.z;
}
else
{
m_fRedValue = m_vColor1.x;
m_fGreenValue = m_vColor1.y;
m_fBlueValue = m_vColor1.z;
m_fRedValue = m_fRedValue/255.0f;
m_fGreenValue = m_fGreenValue/255.0f;
m_fBlueValue = m_fBlueValue/255.0f;
}
m_vCurrentColor.x = m_fRedValue;
m_vCurrentColor.y = m_fGreenValue;
m_vCurrentColor.z = m_fBlueValue;
m_fCurrentRadius = m_fRadius = m_fRadiusMin;
m_nCurIntensityState = LFX_INTENSITY_INIT;
m_nCurRadiusState = LFX_RADIUS_INIT;
m_nCurColorUsed = 0;
m_fStartTime = pServerDE->GetTime();
SetRadius(m_fRadius, DTRUE);
SetColor(m_fRedValue, m_fGreenValue, m_fBlueValue);
return DTRUE;
}
void WeaponPickup::ObjectTouch(HOBJECT hObject)
{
HMESSAGEWRITE hMessage;
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return;
hMessage = pServerDE->StartMessageToObject(this, hObject, MID_ADDWEAPON);
pServerDE->WriteToMessageByte(hMessage, m_nType);
pServerDE->WriteToMessageFloat(hMessage, m_fValue * m_fValueMult );
pServerDE->EndMessage(hMessage);
}
void UpgradeItem::Save(HMESSAGEWRITE hWrite, DDWORD dwSaveFlags)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE || !hWrite) return;
pServerDE->WriteToLoadSaveMessageObject(hWrite, m_hDroppedBy);
pServerDE->WriteToMessageDWord(hWrite, m_nModelName);
pServerDE->WriteToMessageDWord(hWrite, m_nModelSkin);
pServerDE->WriteToMessageDWord(hWrite, m_nSoundName);
pServerDE->WriteToMessageDWord(hWrite, m_nUpgradeSubType);
pServerDE->WriteToMessageFloat(hWrite, m_fCreationTime);
}
void UpgradeItem::Load(HMESSAGEREAD hRead, DDWORD dwLoadFlags)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE || !hRead) return;
pServerDE->ReadFromLoadSaveMessageObject(hRead, &m_hDroppedBy);
m_nModelName = pServerDE->ReadFromMessageDWord(hRead);
m_nModelSkin = pServerDE->ReadFromMessageDWord(hRead);
m_nSoundName = pServerDE->ReadFromMessageDWord(hRead);
m_nUpgradeSubType = pServerDE->ReadFromMessageDWord(hRead);
m_fCreationTime = pServerDE->ReadFromMessageFloat(hRead);
}
void ScreenShake::Load(HMESSAGEREAD hRead, uint32 dwLoadFlags)
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE || !hRead) return;
pServerDE->ReadFromMessageVector(hRead, &m_vAmount);
m_nNumShakes = (int) pServerDE->ReadFromMessageFloat(hRead);
m_fAreaOfEffect = pServerDE->ReadFromMessageFloat(hRead);
m_fFrequency = pServerDE->ReadFromMessageFloat(hRead);
m_fSoundRadius = pServerDE->ReadFromMessageFloat(hRead);
m_hstrSound = pServerDE->ReadFromMessageHString(hRead);
}
