DDWORD UpgradeItem::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
DDWORD dwRet;
if( g_pServerDE )
{
switch(messageID)
{
case MID_PRECREATE:
{
dwRet = InventoryItem::EngineMessageFn(messageID, pData, fData);
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
break;
}
case MID_SAVEOBJECT:
{
Save((HMESSAGEWRITE)pData, (DDWORD)fData);
}
break;
case MID_LOADOBJECT:
{
Load((HMESSAGEREAD)pData, (DDWORD)fData);
}
break;
default : break;
}
}
return InventoryItem::EngineMessageFn(messageID, pData, fData);
}
DDWORD MadScientistAI::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
// Need to call base class to have the object name read in before
// we call PostPropRead()
DDWORD dwRet = AI_Mgr::EngineMessageFn(messageID, pData, fData);
if(fData != PRECREATE_SAVEGAME)
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
InitialUpdate((DVector *)pData);
CacheFiles();
break;
}
default : break;
}
return AI_Mgr::EngineMessageFn(messageID, pData, fData);
}
uint32 ExitTrigger::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
if (fData == PRECREATE_WORLDFILE)
{
ReadProp((ObjectCreateStruct*)pData);
}
uint32 dwRet = Trigger::EngineMessageFn(messageID, pData, fData);
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
case MID_SAVEOBJECT:
{
Save((ILTMessage_Write*)pData, (uint32)fData);
}
break;
case MID_LOADOBJECT:
{
Load((ILTMessage_Read*)pData, (uint32)fData);
}
break;
default : break;
}
return Trigger::EngineMessageFn(messageID, pData, fData);
}
uint32 VolumeBrush::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
uint32 dwRet;
switch(messageID)
{
case MID_UPDATE:
{
Update();
break;
}
case MID_AFFECTPHYSICS:
{
UpdatePhysics((ContainerPhysics*)pData);
break;
}
case MID_PRECREATE:
{
dwRet = GameBase::EngineMessageFn(messageID, pData, fData);
if (fData == PRECREATE_WORLDFILE)
{
ReadProp((ObjectCreateStruct*)pData);
}
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
break;
}
case MID_INITIALUPDATE:
{
if (fData != INITIALUPDATE_SAVEGAME)
{
InitialUpdate();
}
CacheFiles();
break;
}
case MID_SAVEOBJECT:
{
Save((HMESSAGEWRITE)pData, (uint32)fData);
}
break;
case MID_LOADOBJECT:
{
Load((HMESSAGEREAD)pData, (uint32)fData);
}
break;
default : break;
}
return GameBase::EngineMessageFn(messageID, pData, fData);
}
uint32 WeaponItem::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
switch(messageID)
{
case MID_UPDATE:
{
uint32 dwRet = PickupItem::EngineMessageFn(messageID, pData, fData);
g_pLTServer->SetNextUpdate(m_hObject, 0.0f);
return dwRet;
}
break;
case MID_PRECREATE:
{
uint32 dwRet = PickupItem::EngineMessageFn(messageID, pData, fData);
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
ReadProp((ObjectCreateStruct*)pData);
}
if (fData != PRECREATE_SAVEGAME)
{
PostPropRead((ObjectCreateStruct*)pData);
}
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
uint32 dwRet = PickupItem::EngineMessageFn(messageID, pData, fData);
if (fData != INITIALUPDATE_SAVEGAME)
{
InitialUpdate();
}
return dwRet;
}
case MID_SAVEOBJECT:
{
Save((HMESSAGEWRITE)pData, (uint32)fData);
}
break;
case MID_LOADOBJECT:
{
Load((HMESSAGEREAD)pData, (uint32)fData);
}
break;
default : break;
}
return PickupItem::EngineMessageFn(messageID, pData, fData);
}
DDWORD ClientLightFX::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
DDWORD dwRet = B2BaseClass::EngineMessageFn(messageID, pData, fData);
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
m_bDynamic = DFALSE;
ReadProp((ObjectCreateStruct*)pData);
}
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
if (fData != INITIALUPDATE_SAVEGAME)
{
InitialUpdate((DVector *)pData);
}
CacheFiles();
break;
}
case MID_UPDATE:
{
if (!Update())
{
CServerDE* pServerDE = BaseClass::GetServerDE();
if (pServerDE) pServerDE->RemoveObject(m_hObject);
}
}
break;
case MID_SAVEOBJECT:
{
Save((HMESSAGEWRITE)pData, (DDWORD)fData);
}
break;
case MID_LOADOBJECT:
{
Load((HMESSAGEREAD)pData, (DDWORD)fData);
}
break;
default : break;
}
return B2BaseClass::EngineMessageFn(messageID, pData, fData);
}
uint32 SoundFX::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
uint32 dwRet = BaseClass::EngineMessageFn(messageID, pData, fData);
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
ReadProp((ObjectCreateStruct*)pData);
}
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
if (fData != INITIALUPDATE_SAVEGAME)
{
InitialUpdate();
}
CacheFiles();
}
break;
case MID_UPDATE:
{
if (m_hsndSound)
{
g_pLTServer->KillSound(m_hsndSound);
m_hsndSound = NULL;
}
}
break;
case MID_SAVEOBJECT:
{
Save((HMESSAGEWRITE)pData, (uint32)fData);
}
break;
case MID_LOADOBJECT:
{
Load((HMESSAGEREAD)pData, (uint32)fData);
}
break;
default : break;
}
return BaseClass::EngineMessageFn(messageID, pData, fData);
}
uint32 SecurityCamera::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
switch(messageID)
{
case MID_UPDATE:
{
Update();
}
break;
case MID_PRECREATE:
{
uint32 dwRet = CScanner::EngineMessageFn(messageID, pData, fData);
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
ReadProp((ObjectCreateStruct*)pData);
}
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
uint32 dwRet = CScanner::EngineMessageFn(messageID, pData, fData);
if (fData != INITIALUPDATE_SAVEGAME)
{
InitialUpdate();
}
CacheFiles();
return dwRet;
}
break;
case MID_SAVEOBJECT:
{
Save((HMESSAGEWRITE)pData);
}
break;
case MID_LOADOBJECT:
{
Load((HMESSAGEREAD)pData);
}
break;
default : break;
}
return CScanner::EngineMessageFn(messageID, pData, fData);
}
DDWORD SoccerBall::EngineMessageFn( DDWORD messageID, void *pData, DFLOAT fData )
{
// Handle the engine messages we're interested in...
switch( messageID )
{
case MID_PRECREATE:
{
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
ReadProp((ObjectCreateStruct*)pData);
}
PostPropRead((ObjectCreateStruct*)pData);
break;
}
case MID_INITIALUPDATE:
{
OnInitialUpdate(pData, fData);
break;
}
case MID_TOUCHNOTIFY:
{
OnTouchNotify(( HOBJECT )pData, fData );
break;
}
case MID_UPDATE:
{
Update( );
break;
}
case MID_LINKBROKEN:
{
if( m_hLastPlayer == ( HOBJECT )pData )
{
m_hLastPlayer = DNULL;
}
/* else if( m_hLight == ( HOBJECT )pData )
{
g_pServerDE->RemoveAttachment( m_hLightAttachment );
m_hLightAttachment = DNULL;
m_hLight = DNULL;
}
*/
break;
}
}
return B2BaseClass::EngineMessageFn(messageID, pData, fData);
}
uint32 ClientLightFX::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
uint32 dwRet = GameBase::EngineMessageFn(messageID, pData, fData);
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
m_bDynamic = LTFALSE;
ReadProp((ObjectCreateStruct*)pData);
PostPropRead((ObjectCreateStruct*)pData);
}
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
if (fData != INITIALUPDATE_SAVEGAME)
{
InitialUpdate((LTVector *)pData);
}
CacheFiles();
break;
}
case MID_UPDATE:
{
if (!Update())
{
g_pLTServer->RemoveObject(m_hObject);
}
}
break;
case MID_SAVEOBJECT:
{
Save((HMESSAGEWRITE)pData, (uint32)fData);
}
break;
case MID_LOADOBJECT:
{
Load((HMESSAGEREAD)pData, (uint32)fData);
}
break;
default : break;
}
return GameBase::EngineMessageFn(messageID, pData, fData);
}
uint32 PlayerVehicle::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
switch(messageID)
{
case MID_UPDATE:
{
Update();
}
break;
case MID_PRECREATE:
{
uint32 dwRet = Prop::EngineMessageFn(messageID, pData, fData);
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
ReadProp((ObjectCreateStruct*)pData);
PostPropRead((ObjectCreateStruct*)pData);
}
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
uint32 dwRet = Prop::EngineMessageFn(messageID, pData, fData);
if (fData != INITIALUPDATE_SAVEGAME)
{
InitialUpdate();
}
return dwRet;
}
break;
case MID_SAVEOBJECT:
{
Save((ILTMessage_Write*)pData);
}
break;
case MID_LOADOBJECT:
{
Load((ILTMessage_Read*)pData);
}
break;
default : break;
}
return Prop::EngineMessageFn(messageID, pData, fData);
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: SkeletonObject::EngineMessageFn
//
// PURPOSE: Handle engine messages
//
// ----------------------------------------------------------------------- //
uint32 SkeletonObject::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
// First we call down to the base class.
// This isn't currently done in all objects, but
// it really is good practice to do it this way.
LTRESULT ret = GameBase::EngineMessageFn(messageID, pData, fData);
if((fData == PRECREATE_WORLDFILE) || (fData == PRECREATE_STRINGPROP))
{
ReadProp((ObjectCreateStruct*)pData);
}
// Passing this message to the base class first insures that all the props
// will be read in when we get here
PostPropRead((ObjectCreateStruct*)pData);
return ret;
}
case MID_INITIALUPDATE:
{
// Initial update
InitialUpdate();
break;
}
case MID_UPDATE:
{
// Main update function
Update();
break;
}
case MID_SAVEOBJECT:
{
Save((ILTMessage_Write*)pData, (uint32)fData);
break;
}
case MID_LOADOBJECT:
{
Load((ILTMessage_Read*)pData, (uint32)fData);
break;
}
default: break;
}
return(GameBase::EngineMessageFn(messageID, pData, fData));
}
uint32 Alarm::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
ReadProp((ObjectCreateStruct*)pData);
}
PostPropRead((ObjectCreateStruct*)pData);
break;
}
case MID_INITIALUPDATE:
{
if (fData != INITIALUPDATE_SAVEGAME)
{
InitialUpdate();
}
break;
}
case MID_ALLOBJECTSCREATED:
{
CreateRegionLists();
break;
}
case MID_SAVEOBJECT:
{
Save((ILTMessage_Write*)pData);
}
break;
case MID_LOADOBJECT:
{
Load((ILTMessage_Read*)pData);
}
break;
default : break;
}
return Prop::EngineMessageFn(messageID, pData, fData);
}
DDWORD DefenseGlobeLegs::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
switch(messageID)
{
case MID_UPDATE:
{
if (!Update((DVector *)pData) )
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) break;
pServerDE->RemoveObject(m_hObject);
}
}
break;
case MID_TOUCHNOTIFY:
{
ObjectTouch((HOBJECT)pData);
}
break;
case MID_PRECREATE:
{
// Need to call base class to have the object name read in before
// we call PostPropRead()
DDWORD dwRet = B2BaseClass::EngineMessageFn(messageID, pData, fData);
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
case MID_INITIALUPDATE:
{
InitialUpdate((DVector *)pData);
}
break;
default : break;
}
return B2BaseClass::EngineMessageFn(messageID, pData, fData);
}
DDWORD CivilianAI::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
// Need to call base class to have the object name read in before
// we call PostPropRead()
DDWORD dwRet = AI_Mgr::EngineMessageFn(messageID, pData, fData);
if (fData == 1.0)
{
GetServerDE()->GetPropBool("Male", &m_bMale);
GetServerDE()->GetPropBool("LabTech", &m_bLabTech);
GetServerDE()->GetPropBool("Scared", &m_bScared);
GetServerDE()->GetPropBool("SororitySkin", &m_bSororitySkin);
}
if(fData != PRECREATE_SAVEGAME)
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
InitialUpdate((DVector *)pData);
CacheFiles();
break;
}
case MID_SAVEOBJECT:
Save((HMESSAGEWRITE)pData, (DDWORD)fData);
break;
case MID_LOADOBJECT:
Load((HMESSAGEREAD)pData, (DDWORD)fData);
break;
default : break;
}
return AI_Mgr::EngineMessageFn(messageID, pData, fData);
}
DDWORD FlagObject::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
// Handle the engine messages we're interested in...
switch(messageID)
{
case MID_PRECREATE:
{
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
ReadProp((ObjectCreateStruct*)pData);
}
PostPropRead((ObjectCreateStruct*)pData);
break;
}
case MID_INITIALUPDATE:
{
OnInitialUpdate(pData, fData);
break;
}
case MID_TOUCHNOTIFY:
{
if (!IsWithPlayer())
{
OnTouchNotify((HOBJECT)pData);
}
break;
}
case MID_UPDATE:
{
if (IsOnGround())
{
ReturnToFlagStand();
}
break;
}
}
return B2BaseClass::EngineMessageFn(messageID, pData, fData);
}
void WeaponPowerup::Load(HMESSAGEREAD hRead, DDWORD dwLoadFlags)
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE || !hRead) return;
m_iWeaponType = pServerDE->ReadFromMessageByte(hRead);
m_eModelSize = (ModelSize) pServerDE->ReadFromMessageByte(hRead);
m_dwAmmo = pServerDE->ReadFromMessageDWord(hRead);
// Set our object to the correct filenames...
ObjectCreateStruct theStruct;
INIT_OBJECTCREATESTRUCT(theStruct)
PostPropRead(&theStruct);
pServerDE->SetModelFilenames(m_hObject, theStruct.m_Filename,
theStruct.m_SkinName);
}
DDWORD SoccerGoal::EngineMessageFn( DDWORD messageID, void *pData, DFLOAT fData )
{
DDWORD dwRet;
// Handle the engine messages we're interested in...
switch( messageID )
{
case MID_PRECREATE:
{
dwRet = B2BaseClass::EngineMessageFn( messageID, pData, fData );
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
ReadProp((ObjectCreateStruct*)pData);
}
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
break;
}
case MID_INITIALUPDATE:
{
OnInitialUpdate(pData, fData);
break;
}
case MID_UPDATE:
{
Update( );
break;
}
case MID_TOUCHNOTIFY:
{
OnTouchNotify((HOBJECT)pData);
break;
}
}
return B2BaseClass::EngineMessageFn(messageID, pData, fData);
}
uint32 ModItem::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
uint32 dwRet = PickupItem::EngineMessageFn(messageID, pData, fData);
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
if( !ReadProp((ObjectCreateStruct*)pData))
return 0;
}
if( fData != PRECREATE_SAVEGAME )
{
if( !PostPropRead((ObjectCreateStruct*)pData))
return 0;
}
return dwRet;
}
break;
case MID_SAVEOBJECT:
{
Save((ILTMessage_Write*)pData, (uint32)fData);
}
break;
case MID_LOADOBJECT:
{
Load((ILTMessage_Read*)pData, (uint32)fData);
}
break;
default :
break;
}
return PickupItem::EngineMessageFn(messageID, pData, fData);
}
DDWORD LightFX::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
DDWORD dwRet = BaseClass::EngineMessageFn(messageID, pData, fData);
if (fData == 1.0f || fData == 2.0f)
{
m_bDynamic = DFALSE;
ReadProp((ObjectCreateStruct*)pData);
}
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
InitialUpdate((DVector *)pData);
break;
}
case MID_UPDATE:
{
if (!Update())
{
CServerDE* pServerDE = BaseClass::GetServerDE();
if (pServerDE) pServerDE->RemoveObject(m_hObject);
}
}
break;
default : break;
}
return BaseClass::EngineMessageFn(messageID, pData, fData);
}
DDWORD DeathShroud::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
// Need to call base class to have the object name read in before
// we call PostPropRead()
DDWORD dwRet = AI_Mgr::EngineMessageFn(messageID, pData, fData);
if(fData != PRECREATE_SAVEGAME)
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
InitialUpdate((DVector *)pData);
AI_Mgr::EngineMessageFn(messageID, pData, fData);
VEC_SET(m_vScale, 1.5f, 1.5f, 1.5f);
DDWORD dwFlags = m_pServerDE->GetObjectFlags(m_hObject);
dwFlags &= ~FLAG_SHADOW;
m_pServerDE->SetObjectFlags(m_hObject, dwFlags);
CacheFiles();
return 0;
}
default : break;
}
return AI_Mgr::EngineMessageFn(messageID, pData, fData);
}
uint32 Spawner::EngineMessageFn(uint32 messageID, void *pData, float fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
if (fData == PRECREATE_WORLDFILE)
{
ReadProp(&((ObjectCreateStruct*)pData)->m_cProperties);
}
PostPropRead((ObjectCreateStruct*)pData);
break;
}
case MID_INITIALUPDATE:
{
InitialUpdate();
break;
}
case MID_SAVEOBJECT:
{
Save((ILTMessage_Write*)pData, (uint32)fData);
}
break;
case MID_LOADOBJECT:
{
Load((ILTMessage_Read*)pData, (uint32)fData);
}
break;
default :
break;
}
return GameBase::EngineMessageFn(messageID, pData, fData);
}
uint32 Spawner::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
if (fData == PRECREATE_WORLDFILE)
{
ReadProp((ObjectCreateStruct*)pData);
}
PostPropRead((ObjectCreateStruct*)pData);
break;
}
case MID_INITIALUPDATE:
{
InitialUpdate();
CacheFiles();
break;
}
case MID_SAVEOBJECT:
{
Save((HMESSAGEWRITE)pData, (uint32)fData);
}
break;
case MID_LOADOBJECT:
{
Load((HMESSAGEREAD)pData, (uint32)fData);
}
break;
default : break;
}
return BaseClass::EngineMessageFn(messageID, pData, fData);
}
uint32 GearItem::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
uint32 dwRet = PickupItem::EngineMessageFn(messageID, pData, fData);
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
ReadProp((ObjectCreateStruct*)pData);
}
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_SAVEOBJECT:
{
Save((HMESSAGEWRITE)pData, (uint32)fData);
}
break;
case MID_LOADOBJECT:
{
Load((HMESSAGEREAD)pData, (uint32)fData);
}
break;
default : break;
}
return PickupItem::EngineMessageFn(messageID, pData, fData);
}
DDWORD BugAI::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
// Need to call base class to have the object name read in before
// we call PostPropRead()
DDWORD dwRet = AI_Mgr::EngineMessageFn(messageID, pData, fData);
if (fData == 1.0)
AI_Mgr::ReadProp((ObjectCreateStruct*)pData); // inside BaseCharacter
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
InitialUpdate((DVector *)pData);
break;
}
case MID_UPDATE:
{
CServerDE* pServerDE = GetServerDE();
if (!pServerDE) return 0;
//gotta keep the bug stuck to whatever surface it is on
DRotation rRot;
DVector vU,vR,vF,vVel,vPos;
pServerDE->GetObjectPos(m_hObject,&vPos);
pServerDE->GetObjectRotation(m_hObject,&rRot);
pServerDE->GetRotationVectors(&rRot,&vU,&vR,&vF);
VEC_MULSCALAR(vVel,vU,-15.0f);
Move(vVel, MATH_EPSILON);
//check if there is something below, if not rotate
IntersectQuery IQuery;
IntersectInfo ii;
IQuery.m_Flags = INTERSECT_OBJECTS;
IQuery.m_FilterFn = DNULL;
DVector vTemp;
VEC_MULSCALAR(vTemp,vU,-2.0f);
VEC_COPY(IQuery.m_From,vPos);
VEC_ADD(IQuery.m_To,IQuery.m_From,vTemp);
if(pServerDE->IntersectSegment(&IQuery, &ii))
{
DRotation rRot;
DVector vDown;
VEC_MULSCALAR(vDown,vU,-1.0f);
pServerDE->AlignRotation(&rRot,&vDown,&vF);
pServerDE->SetObjectRotation(m_hObject,&rRot);
}
}
break;
default : break;
}
return AI_Mgr::EngineMessageFn(messageID, pData, fData);
}
uint32 PickupItem::EngineMessageFn(uint32 messageID, void *pData, LTFLOAT fData)
{
switch(messageID)
{
case MID_UPDATE:
{
Update();
}
break;
case MID_TOUCHNOTIFY:
{
if( !m_bTouchPickup ) break;
HOBJECT hObj = (HOBJECT)pData;
// If this is a character hit box, use its object...
CCharacterHitBox* pHitBox = LTNULL;
if (IsCharacterHitBox(hObj))
{
pHitBox = (CCharacterHitBox*)g_pLTServer->HandleToObject(hObj);
if (pHitBox)
{
hObj = pHitBox->GetModelObject();
}
}
// If the object is dead, it can't pick up stuff...
if (IsPlayer(hObj))
{
CPlayerObj* pPlayer = (CPlayerObj*)g_pLTServer->HandleToObject(hObj);
if (!pPlayer || pPlayer->IsDead()) break;
SetPlayerObj(hObj);
}
else
{
SetPlayerObj(LTNULL);
break;
}
ObjectTouch(hObj);
}
break;
case MID_PRECREATE:
{
ObjectCreateStruct* pInfo = (ObjectCreateStruct*)pData;
if (fData == PRECREATE_WORLDFILE)
{
ReadProp(pInfo);
}
else if (fData == PRECREATE_STRINGPROP)
{
ReadProp(pInfo);
// Show ourself...
pInfo->m_Flags |= FLAG_VISIBLE;
}
PostPropRead(pInfo);
}
break;
case MID_INITIALUPDATE:
{
if (fData != INITIALUPDATE_SAVEGAME)
{
InitialUpdate();
}
}
break;
case MID_SAVEOBJECT:
{
Save((ILTMessage_Write*)pData, (uint32)fData);
}
break;
case MID_LOADOBJECT:
{
Load((ILTMessage_Read*)pData, (uint32)fData);
uint32 dwRet = GameBase::EngineMessageFn(messageID, pData, fData);
// We need to reset our sfx message since values
// could have changed across save versions.
CreateSpecialFX( );
return dwRet;
}
break;
default : break;
}
return GameBase::EngineMessageFn(messageID, pData, fData);
}
DDWORD Naga::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
// Need to call base class to have the object name read in before
// we call PostPropRead()
DDWORD dwRet = AI_Mgr::EngineMessageFn(messageID, pData, fData);
if(fData != PRECREATE_SAVEGAME)
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
InitialUpdate((DVector *)pData);
DDWORD dwRet = AI_Mgr::EngineMessageFn(messageID, pData, fData);
if (fData != INITIALUPDATE_SAVEGAME)
{
// Remove shadow for 'dramatic purposes' at Bill V's request.
DDWORD dwFlags;
dwFlags = m_pServerDE->GetObjectFlags(m_hObject);
dwFlags &= ~FLAG_SHADOW;
dwFlags &= ~FLAG_SOLID;
m_pServerDE->SetObjectFlags(m_hObject,dwFlags);
}
CacheFiles();
return dwRet;
break;
}
case MID_UPDATE:
{
if (m_bCreateHealth)
{
if (!m_fFullHealth)
{
HMESSAGEWRITE hWrite = m_pServerDE->StartMessage(NULL, SMSG_BOSSHEALTH);
m_pServerDE->WriteToMessageFloat(hWrite,1.0f);
m_pServerDE->EndMessage(hWrite);
m_bCreateHealth = DFALSE;
m_fFullHealth = m_damage.GetHitPoints();
}
else
{
DFLOAT fTemp = m_damage.GetHitPoints() / m_fFullHealth;
HMESSAGEWRITE hWrite = m_pServerDE->StartMessage(NULL, SMSG_BOSSHEALTH);
m_pServerDE->WriteToMessageFloat(hWrite,fTemp);
m_pServerDE->EndMessage(hWrite);
}
}
}
break;
case MID_SAVEOBJECT:
Save((HMESSAGEWRITE)pData, (DDWORD)fData);
break;
case MID_LOADOBJECT:
Load((HMESSAGEREAD)pData, (DDWORD)fData);
break;
default : break;
}
return AI_Mgr::EngineMessageFn(messageID, pData, fData);
}
DDWORD CameraObj::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
if (!g_pServerDE) return 0;
switch(messageID)
{
case MID_UPDATE:
{
if (!Update())
{
g_pServerDE->RemoveObject(m_hObject);
}
}
break;
case MID_LINKBROKEN:
{
HOBJECT hObj = (HOBJECT)pData;
if (m_hLinkObject == hObj)
{
m_hLinkObject = DNULL;
}
}
break;
case MID_PRECREATE:
{
DDWORD dwRet = B2BaseClass::EngineMessageFn(messageID, pData, fData);
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
ReadProp((ObjectCreateStruct*)pData);
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
if (fData != INITIALUPDATE_SAVEGAME)
InitialUpdate();
// insert it into the list
if (!m_Link.m_pData)
{
dl_Insert( &m_CameraHead, &m_Link );
m_Link.m_pData = ( void * )this;
m_dwNumCameras++;
}
}
break;
case MID_SAVEOBJECT:
{
Save((HMESSAGEWRITE)pData, (DDWORD)fData);
}
break;
case MID_LOADOBJECT:
{
Load((HMESSAGEREAD)pData, (DDWORD)fData);
}
break;
default : break;
}
return B2BaseClass::EngineMessageFn(messageID, pData, fData);
}
DDWORD UndeadGideon::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
// Need to call base class to have the object name read in before
// we call PostPropRead()
DDWORD dwRet = AI_Mgr::EngineMessageFn(messageID, pData, fData);
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
InitialUpdate((DVector *)pData);
CacheFiles();
break;
}
case MID_UPDATE:
{
if (m_bCreateHealth)
{
if (!m_fFullHealth)
{
m_fFullHealth = m_damage.GetHitPoints();
HMESSAGEWRITE hWrite = m_pServerDE->StartMessage(NULL, SMSG_BOSSHEALTH);
m_pServerDE->WriteToMessageFloat(hWrite,1.0f);
m_pServerDE->EndMessage(hWrite);
m_bCreateHealth = DFALSE;
}
else
{
DFLOAT fTemp = m_damage.GetHitPoints() / m_fFullHealth;
HMESSAGEWRITE hWrite = m_pServerDE->StartMessage(NULL, SMSG_BOSSHEALTH);
m_pServerDE->WriteToMessageFloat(hWrite,fTemp);
m_pServerDE->EndMessage(hWrite);
}
}
}
break;
case MID_SAVEOBJECT:
Save((HMESSAGEWRITE)pData, (DDWORD)fData);
break;
case MID_LOADOBJECT:
Load((HMESSAGEREAD)pData, (DDWORD)fData);
break;
default : break;
}
return AI_Mgr::EngineMessageFn(messageID, pData, fData);
}
uint32 SoundNonPoint::EngineMessageFn(uint32 messageID, void *pData, float fData)
{
switch(messageID)
{
case MID_PRECREATE:
{
uint32 dwRet = GameBase::EngineMessageFn(messageID, pData, fData);
if (fData == PRECREATE_WORLDFILE || fData == PRECREATE_STRINGPROP)
{
ReadProp(&((ObjectCreateStruct*)pData)->m_cProperties);
}
PostPropRead((ObjectCreateStruct*)pData);
return dwRet;
}
break;
case MID_INITIALUPDATE:
{
if (fData != INITIALUPDATE_SAVEGAME)
{
InitialUpdate();
m_bLoadFromSave = false;
}
else
{
m_bLoadFromSave = true;
}
}
break;
case MID_ALLOBJECTSCREATED:
// if not a savegame, call this to resolve object links
// (otherwise, all this info has already been saved)
{
if (!m_bLoadFromSave)
{
AllObjectsCreated();
CreateSpecialFX();
}
}
break;
case MID_UPDATE:
{
SetNextUpdate(UPDATE_NEVER); // UPDATE_NEXT_FRAME
}
break;
case MID_SAVEOBJECT:
{
Save((ILTMessage_Write*)pData, (uint32)fData);
}
break;
case MID_LOADOBJECT:
{
Load((ILTMessage_Read*)pData, (uint32)fData);
}
break;
default : break;
}
return GameBase::EngineMessageFn(messageID, pData, fData);
}
