int fts_AddFile(FTServ *pServ, char *pFilename, uint32 fileSize, uint32 fileID, uint16 flags)
{
FTFile *pFile;
if(!pServ)
return 0;
LT_MEM_TRACK_ALLOC(pFile = pServ->m_FTFileBank.Allocate(), LT_MEM_TYPE_MISC);
pFile->m_Link.m_pData = pFile;
pFile->m_Flags = flags;
pFile->m_FileID = fileID;
pFile->m_FileSize = fileSize;
pFile->m_Filename = pFilename;
if(pFile->m_Flags & FFLAG_NEEDED)
{
// Needed files go first in the list.
dl_Insert(&pServ->m_Files, &pFile->m_Link);
++pServ->m_nNeededFiles;
}
else
{
dl_Insert(pServ->m_Files.m_pPrev, &pFile->m_Link);
}
// Tell the client about this file.
if(!(flags & FFLAG_SENDWAIT))
{
fts_SendFileDesc(pServ, pFile);
}
++pServ->m_nTotalFiles;
return 1;
}
DDWORD AmmoPickup::EngineMessageFn(DDWORD messageID, void *pData, float fData)
{
switch(messageID)
{
case MID_INITIALUPDATE:
{
// insert it into the list
dl_Insert( &m_PUHead, &m_Link );
m_Link.m_pData = ( void * )this;
m_dwNumPU++;
if( g_pBloodServerShell->IsMultiplayerGame( ))
{
m_fRespawnTime = ( DFLOAT )g_pBloodServerShell->GetNetGameInfo( )->m_nAmmoRespawn;
if( g_pBloodServerShell->GetNetGameInfo( )->m_nAmmoLevel == LEVEL_NONE )
g_pServerDE->RemoveObject( m_hObject );
else
m_fValueMult = ConvertNetItemMultiplier( g_pBloodServerShell->GetNetGameInfo( )->m_nAmmoLevel );
}
break;
}
}
return PickupObject::EngineMessageFn(messageID, pData, fData);
}
void CDestructable::Load(HMESSAGEREAD hRead, DDWORD dwLoadFlags)
{
CServerDE* pServerDE = BaseClass::GetServerDE();
if (!pServerDE || !hRead) return;
DDWORD dwTest = pServerDE->ReadFromMessageDWord(hRead);
// Gross hack because PlayerObj hObject deoesn't seem to be loaded.
// Don't reload m_hObject if it is already set to something.
HOBJECT hObjectTmp;
if (!m_hObject)
pServerDE->ReadFromLoadSaveMessageObject(hRead, &m_hObject);
else
pServerDE->ReadFromLoadSaveMessageObject(hRead, &hObjectTmp);
m_bApplyDamagePhysics = (DBOOL)pServerDE->ReadFromMessageByte(hRead);
m_fMass = pServerDE->ReadFromMessageFloat(hRead);
m_fMaxHitPoints = pServerDE->ReadFromMessageFloat(hRead);
m_fMaxMegaHitPoints = pServerDE->ReadFromMessageFloat(hRead);
m_fHitPoints = pServerDE->ReadFromMessageFloat(hRead);
m_fDeathHitPoints = pServerDE->ReadFromMessageFloat(hRead);
m_fMaxArmorPoints = pServerDE->ReadFromMessageFloat(hRead);
m_fMaxNecroArmorPoints = pServerDE->ReadFromMessageFloat(hRead);
m_fArmorPoints = pServerDE->ReadFromMessageFloat(hRead);
m_fResistance = pServerDE->ReadFromMessageFloat(hRead);
m_bDead = (DBOOL)pServerDE->ReadFromMessageByte(hRead);
m_bNighInvulnerable = (DBOOL)pServerDE->ReadFromMessageByte(hRead);
m_nLastDamageType = pServerDE->ReadFromMessageByte(hRead);
m_nLastDamageLocation = pServerDE->ReadFromMessageByte(hRead);
pServerDE->ReadFromMessageVector(hRead, &m_vLastDamageDirection);
m_fLastDamageAmount = pServerDE->ReadFromMessageFloat(hRead);
m_fLastDamagePercent = pServerDE->ReadFromMessageFloat(hRead);
m_hstrDamageTriggerTarget = pServerDE->ReadFromMessageHString(hRead);
m_hstrDamageTriggerMessage = pServerDE->ReadFromMessageHString(hRead);
m_hstrDeathTriggerTarget = pServerDE->ReadFromMessageHString(hRead);
m_hstrDeathTriggerMessage = pServerDE->ReadFromMessageHString(hRead);
m_hstrSpawnObject = pServerDE->ReadFromMessageHString(hRead);
pServerDE->ReadFromMessageVector(hRead, &m_vSpawnObjectVel);
m_bGodMode = pServerDE->ReadFromMessageByte(hRead);
m_bTriggerOnly = pServerDE->ReadFromMessageByte(hRead);
m_fDeathDelay = pServerDE->ReadFromMessageFloat(hRead);
m_bDestructable = ( m_fHitPoints >= 1.0e6f ) ? DFALSE : DTRUE;
dwTest = pServerDE->ReadFromMessageDWord(hRead);
if (!m_Link.m_pData)
{
dl_Insert( &m_DestructableHead, &m_Link );
m_Link.m_pData = ( void * )this;
m_dwNumDestructables++;
}
}
bool BaseObjectSet::Init(VisibleSet *pVisibleSet, const char *pSetName)
{
if(pVisibleSet)
{
dl_Insert(pVisibleSet->m_Sets.m_pPrev, &m_Link);
}
m_pSetName = pSetName;
return true;
}
LTRESULT CreateInterLink(LTObject *pOwner, void *pOther, uint32 linkType)
{
// Don't link them if they already are.
if( DoesLinkExist( pOwner, pOther, linkType ))
return LT_OK;
if (pOwner == pOther)
return LT_ERROR;
InterLink* pLink;
LT_MEM_TRACK_ALLOC(pLink = (InterLink*)sb_Allocate(&g_pServerMgr->m_InterLinkBank), LT_MEM_TYPE_MISC);
pLink->m_Type = linkType;
pLink->m_pOwner = pOwner;
pLink->m_pOther = pOther;
LTLink* pOwnerLink;
LT_MEM_TRACK_ALLOC(pOwnerLink = g_DLinkBank.Allocate(), LT_MEM_TYPE_MISC);
pOwnerLink->m_pData = pLink;
pLink->m_pOwnerLink = pOwnerLink;
dl_Insert(&pOwner->sd->m_Links, pOwnerLink);
if (linkType == LINKTYPE_SOUND)
{
((CSoundTrack *)pOther)->m_pInterLink = pLink;
}
else
{
LTLink* pOtherLink;
LT_MEM_TRACK_ALLOC(pOtherLink = g_DLinkBank.Allocate(), LT_MEM_TYPE_MISC);
pOtherLink->m_pData = pLink;
pLink->m_pOtherLink = pOtherLink;
dl_Insert(&((LTObject *)pOther)->sd->m_Links, pOtherLink);
}
return LT_OK;
}
// Attaches the object to another one (standing on it).
void SetObjectStanding(LTObject *pObj, LTObject *pStandingOn, const Node *pNode)
{
// ASSERT(!!pObj->sd == !!pStandingOn->sd);
DetachObjectStanding(pObj);
if(pStandingOn)
{
dl_Insert(&pStandingOn->m_ObjectsStandingOn, &pObj->m_StandingOnLink);
}
pObj->m_pStandingOn = pStandingOn;
pObj->m_pNodeStandingOn = pNode;
}
LTExtraCommandStruct* cc_AddCommand(ConsoleState *pState,
const char *pCmdName, LTCommandFn fn, uint32 flags)
{
LTExtraCommandStruct *pCommand;
LT_MEM_TRACK_ALLOC(pCommand = (LTExtraCommandStruct*)pState->Alloc(sizeof(LTExtraCommandStruct)), LT_MEM_TYPE_CONSOLE);
if(!pCommand)
return 0;
pCommand->link.m_pData = pCommand;
pCommand->fn = fn;
pCommand->pCmdName = pCmdName;
pCommand->flags = flags;
dl_Insert(&pState->m_ExtraCommands, &pCommand->link);
return pCommand;
}
DDWORD ExitHint::EngineMessageFn(DDWORD messageID, void *pData, float fData)
{
switch(messageID)
{
case MID_INITIALUPDATE:
{
// insert it into the list
dl_Insert( &m_ExitHead, &m_Link );
m_Link.m_pData = ( void * )this;
m_dwNumExits++;
GetServerDE()->SetNextUpdate(m_hObject, 0.0f);
break;
}
}
return B2BaseClass::EngineMessageFn(messageID, pData, fData);
}
DBOOL CDestructable::Init(HOBJECT hObject, CInventoryMgr* pInv, CAnim_Sound* pAnimSound)
{
CServerDE* pServerDE = BaseClass::GetServerDE();
if (!hObject || !pServerDE) return DFALSE;
m_hObject = hObject;
// insert it into the list
if (!m_Link.m_pData)
{
dl_Insert( &m_DestructableHead, &m_Link );
m_Link.m_pData = ( void * )this;
m_dwNumDestructables++;
}
m_pInventoryMgr = pInv;
m_pAnim_Sound = pAnimSound;
return DTRUE;
}
HHASHELEMENT hs_AddElement(HHASHTABLE hTable, const void *pKey, uint32 keyLen)
{
HashTable *pTable;
uint32 mapEl;
HashElement *pElement;
MapEntry *pMapEntry;
if(!hTable)
return 0;
pTable = (HashTable*)hTable;
mapEl = hs_GetMapEntryIndex(pTable, pKey, keyLen);
pMapEntry = &pTable->m_Map[mapEl];
if( pTable->m_HashType == HASH_2BYTENUMBER )
{
pElement = g_HashElementBank.Allocate( );
}
else
{
pElement = (HashElement*)dalloc(sizeof(HashElement) + (((int)keyLen)-2));
}
pElement->m_KeySize = (unsigned short)keyLen;
memcpy(pElement->m_Key, pKey, keyLen);
pElement->m_pUser = 0;
pElement->m_pMapEntry = pMapEntry;
pElement->m_Link.m_pData = pElement;
dl_Insert(&pMapEntry->m_Elements, &pElement->m_Link);
++pMapEntry->m_nElements;
if(pMapEntry->m_nElements > 1)
{
++pTable->m_nCollisions;
}
return (HHASHELEMENT)pElement;
}
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);
}
