void Spawner::Load(HMESSAGEREAD hRead, uint32 dwLoadFlags)
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE || !hRead) return;
m_fSoundRadius = pServerDE->ReadFromMessageFloat(hRead);
m_hstrSpawnSound = pServerDE->ReadFromMessageHString(hRead);
m_hstrDefaultSpawn = pServerDE->ReadFromMessageHString(hRead);
}
LTBOOL Key::InitialUpdate(LTVector* pMovement)
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE) return LTFALSE;
pServerDE->SetNextUpdate (m_hObject, 0.0f);
return LTTRUE;
}
void Spawner::Save(HMESSAGEWRITE hWrite, uint32 dwSaveFlags)
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE || !hWrite) return;
pServerDE->WriteToMessageFloat(hWrite, m_fSoundRadius);
pServerDE->WriteToMessageHString(hWrite, m_hstrSpawnSound);
pServerDE->WriteToMessageHString(hWrite, m_hstrDefaultSpawn);
}
Key::~Key()
{
ILTServer* 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 Ladder::UpdatePhysics(ContainerPhysics* pCPStruct)
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE) return;
if (IsCharacter(pCPStruct->m_hObject))
{
CCharacter* pCharacter = (CCharacter*)pServerDE->HandleToObject(pCPStruct->m_hObject);
if (pCharacter)
{
pCharacter->UpdateOnLadder(this, pCPStruct);
}
}
}
void Spawner::CacheFiles()
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE) return;
char* pFile = LTNULL;
if (m_hstrSpawnSound)
{
pFile = pServerDE->GetStringData(m_hstrSpawnSound);
if (pFile)
{
pServerDE->CacheFile(FT_SOUND, pFile);
}
}
}
void CDestructibleModel::CreateWorldModelDebris()
{
ILTServer* pServerDE = BaseClass::GetServerDE();
if (!pServerDE) return;
char* pName = pServerDE->GetObjectName(m_hObject);
if (!pName || !pName[0]) return;
// Find all the debris objects...
int nNum = 0;
char strKey[128]; memset(strKey, 0, 128);
char strNum[18]; memset(strNum, 0, 18);
HCLASS hWMDebris = pServerDE->GetClass("WorldModelDebris");
while (1)
{
// Create the keyname string...
sprintf(strKey, "%sDebris%d", pName, nNum);
// Find any debris with that name...
ObjArray <HOBJECT, MAX_OBJECT_ARRAY_SIZE> objArray;
pServerDE->FindNamedObjects(strKey, objArray);
int numObjects = objArray.NumObjects();
if (!numObjects) return;
for (int i = 0; i < numObjects; i++)
{
HOBJECT hObject = objArray.GetObject(i);
if (pServerDE->IsKindOf(pServerDE->GetObjectClass(hObject), hWMDebris))
{
WorldModelDebris* pDebris = (WorldModelDebris*)pServerDE->HandleToObject(hObject);
if (!pDebris) break;
LTVector vVel, vRotPeriods;
vVel.Init(GetRandom(-200.0f, 200.0f),
GetRandom(100.0f, 300.0f), GetRandom(-200.0f, 200.0f));
vRotPeriods.Init(GetRandom(-1.0f, 1.0f),
GetRandom(-1.0f, 1.0f), GetRandom(-1.0f, 1.0f));
pDebris->Start(&vRotPeriods, &vVel);
}
}
// Increment the counter...
nNum++;
}
}
void WorldModelDebris::Save(HMESSAGEWRITE hWrite, uint32 dwSaveFlags)
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE || !hWrite) return;
pServerDE->WriteToMessageByte(hWrite, m_bRotate);
pServerDE->WriteToMessageFloat(hWrite, m_fXRotVel);
pServerDE->WriteToMessageFloat(hWrite, m_fYRotVel);
pServerDE->WriteToMessageFloat(hWrite, m_fZRotVel);
pServerDE->WriteToMessageFloat(hWrite, m_fPitch);
pServerDE->WriteToMessageFloat(hWrite, m_fYaw);
pServerDE->WriteToMessageFloat(hWrite, m_fRoll);
pServerDE->WriteToMessageFloat(hWrite, m_fLastTime);
}
void WorldModelDebris::Load(HMESSAGEREAD hRead, uint32 dwLoadFlags)
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE || !hRead) return;
m_bRotate = pServerDE->ReadFromMessageByte(hRead);
m_fXRotVel = pServerDE->ReadFromMessageFloat(hRead);
m_fYRotVel = pServerDE->ReadFromMessageFloat(hRead);
m_fZRotVel = pServerDE->ReadFromMessageFloat(hRead);
m_fPitch = pServerDE->ReadFromMessageFloat(hRead);
m_fYaw = pServerDE->ReadFromMessageFloat(hRead);
m_fRoll = pServerDE->ReadFromMessageFloat(hRead);
m_fLastTime = 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);
}
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);
}
void SecurityCamera::CacheFiles()
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE) return;
// Cache sounds...
pServerDE->CacheFile(FT_SOUND, DETECT_SOUND);
pServerDE->CacheFile(FT_SOUND, LOOP_SOUND);
pServerDE->CacheFile(FT_SOUND, FOCUSING_SOUND);
// Cache the light sprites...
char buf[128];
buf[0] = '\0';
g_pServerButeMgr->GetSecurityCameraString("GreenLight", buf,
ARRAY_LEN(buf));
if (buf[0])
{
pServerDE->CacheFile(FT_SPRITE, buf);
}
buf[0] = '\0';
g_pServerButeMgr->GetSecurityCameraString("YellowLight", buf,
ARRAY_LEN(buf));
if (buf[0])
{
pServerDE->CacheFile(FT_SPRITE, buf);
}
buf[0] = '\0';
g_pServerButeMgr->GetSecurityCameraString("RedLight", buf,
ARRAY_LEN(buf));
if (buf[0])
{
pServerDE->CacheFile(FT_SPRITE, buf);
}
}
void CinematicTrigger::Load(HMESSAGEREAD hRead, uint32 dwLoadFlags)
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE || !hRead) return;
pServerDE->ReadFromLoadSaveMessageObject(hRead, &m_hCurSpeaker);
pServerDE->ReadFromLoadSaveMessageObject(hRead, &m_hLastSpeaker);
pServerDE->ReadFromLoadSaveMessageObject(hRead, &m_hCamera);
pServerDE->ReadFromLoadSaveMessageObject(hRead, &m_hKeyFramer);
m_nCurMessage = pServerDE->ReadFromMessageByte(hRead);
m_bOn = (LTBOOL) pServerDE->ReadFromMessageByte(hRead);
m_bNotified = (LTBOOL) pServerDE->ReadFromMessageByte(hRead);
m_bCreateCamera = (LTBOOL) pServerDE->ReadFromMessageByte(hRead);
m_bCreateKeyFramer = (LTBOOL) pServerDE->ReadFromMessageByte(hRead);
m_bStartOn = (LTBOOL) pServerDE->ReadFromMessageByte(hRead);
m_bRemoveBadAI = (LTBOOL) pServerDE->ReadFromMessageByte(hRead);
m_bOneTimeOnly = (LTBOOL) pServerDE->ReadFromMessageByte(hRead);
m_bCanSkip = (LTBOOL) pServerDE->ReadFromMessageByte(hRead);
m_bAllWindows = (LTBOOL) pServerDE->ReadFromMessageByte(hRead);
m_bDialogueDone = (LTBOOL) pServerDE->ReadFromMessageByte(hRead);
m_bLeaveCameraOn = (LTBOOL) pServerDE->ReadFromMessageByte(hRead);
m_fNextDialogueStart = pServerDE->ReadFromMessageFloat(hRead);
for (int i=0; i < MAX_CT_MESSAGES; i++)
{
m_fDelay[i] = pServerDE->ReadFromMessageFloat(hRead);
m_hstrDialogue[i] = pServerDE->ReadFromMessageHString(hRead);
m_hstrWhoPlaysDialogue[i] = pServerDE->ReadFromMessageHString(hRead);
m_hstrTargetName[i] = pServerDE->ReadFromMessageHString(hRead);
m_hstrMessageName[i] = pServerDE->ReadFromMessageHString(hRead);
m_hstrWhoPlaysDecisions[i] = pServerDE->ReadFromMessageHString(hRead);
m_hstrDecisions[i] = pServerDE->ReadFromMessageHString(hRead);
m_hstrReplies[i] = pServerDE->ReadFromMessageHString(hRead);
m_hstrRepliesTarget[i] = pServerDE->ReadFromMessageHString(hRead);
m_hstrRepliesMsg[i] = pServerDE->ReadFromMessageHString(hRead);
m_bWindow[i] = pServerDE->ReadFromMessageByte(hRead);
}
m_hstrCleanUpTriggerTarget = pServerDE->ReadFromMessageHString(hRead);
m_hstrCleanUpTriggerMsg = pServerDE->ReadFromMessageHString(hRead);
m_hstrDialogueDoneTarget = pServerDE->ReadFromMessageHString(hRead);
m_hstrDialogueDoneMsg = pServerDE->ReadFromMessageHString(hRead);
m_hstrDialogueStartTarget = pServerDE->ReadFromMessageHString(hRead);
m_hstrDialogueStartMsg = pServerDE->ReadFromMessageHString(hRead);
}
void CinematicTrigger::Save(HMESSAGEWRITE hWrite, uint32 dwSaveFlags)
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE || !hWrite) return;
pServerDE->WriteToLoadSaveMessageObject(hWrite, m_hCurSpeaker);
pServerDE->WriteToLoadSaveMessageObject(hWrite, m_hLastSpeaker);
pServerDE->WriteToLoadSaveMessageObject(hWrite, m_hCamera);
pServerDE->WriteToLoadSaveMessageObject(hWrite, m_hKeyFramer);
pServerDE->WriteToMessageByte(hWrite, m_nCurMessage);
pServerDE->WriteToMessageByte(hWrite, m_bOn);
pServerDE->WriteToMessageByte(hWrite, m_bNotified);
pServerDE->WriteToMessageByte(hWrite, m_bCreateCamera);
pServerDE->WriteToMessageByte(hWrite, m_bCreateKeyFramer);
pServerDE->WriteToMessageByte(hWrite, m_bStartOn);
pServerDE->WriteToMessageByte(hWrite, m_bRemoveBadAI);
pServerDE->WriteToMessageByte(hWrite, m_bOneTimeOnly);
pServerDE->WriteToMessageByte(hWrite, m_bCanSkip);
pServerDE->WriteToMessageByte(hWrite, m_bAllWindows);
pServerDE->WriteToMessageByte(hWrite, m_bDialogueDone);
pServerDE->WriteToMessageByte(hWrite, m_bLeaveCameraOn);
pServerDE->WriteToMessageFloat(hWrite, m_fNextDialogueStart);
for (int i=0; i < MAX_CT_MESSAGES; i++)
{
pServerDE->WriteToMessageFloat(hWrite, m_fDelay[i]);
pServerDE->WriteToMessageHString(hWrite, m_hstrDialogue[i]);
pServerDE->WriteToMessageHString(hWrite, m_hstrWhoPlaysDialogue[i]);
pServerDE->WriteToMessageHString(hWrite, m_hstrTargetName[i]);
pServerDE->WriteToMessageHString(hWrite, m_hstrMessageName[i]);
pServerDE->WriteToMessageHString(hWrite, m_hstrWhoPlaysDecisions[i]);
pServerDE->WriteToMessageHString(hWrite, m_hstrDecisions[i]);
pServerDE->WriteToMessageHString(hWrite, m_hstrReplies[i]);
pServerDE->WriteToMessageHString(hWrite, m_hstrRepliesTarget[i]);
pServerDE->WriteToMessageHString(hWrite, m_hstrRepliesMsg[i]);
pServerDE->WriteToMessageByte(hWrite, m_bWindow[i]);
}
pServerDE->WriteToMessageHString(hWrite, m_hstrCleanUpTriggerTarget);
pServerDE->WriteToMessageHString(hWrite, m_hstrCleanUpTriggerMsg);
pServerDE->WriteToMessageHString(hWrite, m_hstrDialogueDoneTarget);
pServerDE->WriteToMessageHString(hWrite, m_hstrDialogueDoneMsg);
pServerDE->WriteToMessageHString(hWrite, m_hstrDialogueStartTarget);
pServerDE->WriteToMessageHString(hWrite, m_hstrDialogueStartMsg);
}
uint32 CDestructibleModel::ObjectMessageFn(LPBASECLASS pObject, HOBJECT hSender, uint32 messageID, HMESSAGEREAD hRead)
{
uint32 dwRet = CDestructible::ObjectMessageFn(pObject, hSender, messageID, hRead);
switch(messageID)
{
case MID_DAMAGE:
{
if (IsDead() && !m_bCreatedDebris)
{
ILTServer* pServerDE = BaseClass::GetServerDE();
if (!pServerDE) break;
SpawnItem();
CreateDebris();
CreateWorldModelDebris();
if (m_bCreateExplosion)
{
DoExplosion();
}
m_bCreatedDebris = LTTRUE;
if (m_bRemoveOnDeath)
{
pServerDE->RemoveObject(m_hObject);
}
}
}
break;
case MID_TRIGGER:
{
const char* szMsg = (const char*)g_pLTServer->ReadFromMessageDWord(hRead);
// ConParse does not destroy szMsg, so this is safe
ConParse parse;
parse.Init((char*)szMsg);
while (g_pLTServer->Common()->Parse(&parse) == LT_OK)
{
if (parse.m_nArgs > 0 && parse.m_Args[0])
{
if (!IsDead())
{
if (_stricmp(parse.m_Args[0], "FIRE") == 0)
{
char* pTargetName = parse.m_nArgs > 1 ? parse.m_Args[1] : LTNULL;
DoExplosion(pTargetName);
}
else if (_stricmp(parse.m_Args[0], "HIDDEN") == 0)
{
uint32 dwFlags = g_pLTServer->GetObjectFlags(m_hObject);
if (parse.m_nArgs > 1 && parse.m_Args[1])
{
if ((_stricmp(parse.m_Args[1], "1") == 0) ||
(_stricmp(parse.m_Args[1], "TRUE") == 0))
{
dwFlags = 0;
m_bSaveCanDamage = GetCanDamage();
m_bSaveNeverDestroy = GetNeverDestroy();
SetCanDamage(LTFALSE);
SetNeverDestroy(LTTRUE);
}
else
{
if ((_stricmp(parse.m_Args[1], "0") == 0) ||
(_stricmp(parse.m_Args[1], "FALSE") == 0))
{
dwFlags = m_dwOriginalFlags;
dwFlags |= FLAG_VISIBLE;
SetCanDamage(m_bSaveCanDamage);
SetNeverDestroy(m_bSaveNeverDestroy);
}
}
g_pLTServer->SetObjectFlags(m_hObject, dwFlags);
}
}
}
}
}
}
break;
default : break;
}
return dwRet;
}
uint32 CDestructibleModel::ObjectMessageFn(LPBASECLASS pObject, HOBJECT hSender, ILTMessage_Read *pMsg)
{
uint32 dwRet = CDestructible::ObjectMessageFn(pObject, hSender, pMsg);
pMsg->SeekTo(0);
uint32 messageID = pMsg->Readuint32();
switch(messageID)
{
case MID_DAMAGE:
{
if (IsDead() && !m_bCreatedDebris)
{
ILTServer* pServerDE = BaseClass::GetServerDE();
if (!pServerDE) break;
SpawnItem();
CreateDebris();
CreateWorldModelDebris();
if (m_bCreateExplosion)
{
DoExplosion();
}
RegisterDestroyedStimulus();
m_bCreatedDebris = LTTRUE;
if (m_bRemoveOnDeath)
{
pServerDE->RemoveObject(m_hObject);
}
}
}
break;
case MID_TRIGGER:
{
const char* szMsg = (const char*)pMsg->Readuint32();
// ConParse does not destroy szMsg, so this is safe
ConParse parse;
parse.Init((char*)szMsg);
while (g_pCommonLT->Parse(&parse) == LT_OK)
{
if (parse.m_nArgs > 0 && parse.m_Args[0])
{
if (!IsDead())
{
if (_stricmp(parse.m_Args[0], "FIRE") == 0)
{
char* pTargetName = parse.m_nArgs > 1 ? parse.m_Args[1] : LTNULL;
DoExplosion(pTargetName);
}
else if (_stricmp(parse.m_Args[0], "HIDDEN") == 0)
{
// Game Base will take care of the solid and visible flags for us...
if (parse.m_nArgs > 1 && parse.m_Args[1])
{
if ((_stricmp(parse.m_Args[1], "1") == 0) ||
(_stricmp(parse.m_Args[1], "TRUE") == 0))
{
m_bSaveCanDamage = GetCanDamage();
m_bSaveNeverDestroy = GetNeverDestroy();
SetCanDamage(LTFALSE);
SetNeverDestroy(LTTRUE);
}
else
{
if ((_stricmp(parse.m_Args[1], "0") == 0) ||
(_stricmp(parse.m_Args[1], "FALSE") == 0))
{
SetCanDamage(m_bSaveCanDamage);
SetNeverDestroy(m_bSaveNeverDestroy);
}
}
}
}
}
}
}
}
break;
default : break;
}
return dwRet;
}
LTBOOL Key::ReadProp(ObjectCreateStruct *)
{
ILTServer* pServerDE = GetServerDE();
if (!pServerDE) return LTFALSE;
GenericProp genProp;
pServerDE->GetPropReal("TimeStamp", &m_fTimeStamp);
pServerDE->GetPropReal("SoundRadius", &m_fSoundRadius);
if (pServerDE->GetPropGeneric("SoundName", &genProp) == LT_OK)
{
if (genProp.m_String[0])
{
m_hstrSoundName = pServerDE->CreateString(genProp.m_String);
}
}
if (pServerDE->GetPropGeneric("MessageTarget", &genProp) == LT_OK)
{
if (genProp.m_String[0])
{
m_hstrMessageTarget = pServerDE->CreateString(genProp.m_String);
}
}
if (pServerDE->GetPropGeneric("MessageName", &genProp) == LT_OK)
{
if (genProp.m_String[0])
{
m_hstrMessageName = pServerDE->CreateString(genProp.m_String);
}
}
if (pServerDE->GetPropGeneric("BPrintMessage", &genProp) == LT_OK)
{
if (genProp.m_String[0])
{
m_hstrBPrintMessage = pServerDE->CreateString(genProp.m_String);
}
}
pServerDE->GetPropRotationEuler("Rotation", &m_vPitchYawRoll);
// {MD}
// Read the bezier tangent vectors.
if (pServerDE->GetPropGeneric("BezierPrev", &genProp) == LT_OK)
{
m_BezierPrevTangent = genProp.m_Vec;
}
if (pServerDE->GetPropGeneric("BezierNext", &genProp) == LT_OK)
{
m_BezierNextTangent = genProp.m_Vec;
}
if (pServerDE->GetPropGeneric("LightFrames", &genProp) == LT_OK)
{
m_LightFrames = genProp.m_Long;
}
return LTTRUE;
}