funnygame/game/client/entitysystem.cpp

//================= Copyright kotofyt, All rights reserved ==================//
//
// Purpose:
//
//===========================================================================//

#include "entitysystem.h"
#include "baseentity.h"
#include "stddef.h"
#include "string.h"
#include "stdlib.h"

#include "netprotocol.h"


CEntitySystem *EntitySystem()
{
	static CEntitySystem s_entitySystem;
	return &s_entitySystem;
}

static struct EntityRegistry_t
{
	IEntityFactory *m_pFactory;
	const char *m_szClassName;
	struct EntityRegistry_t *m_pNext;
} *s_pEntitiesRegistry = NULL;

CEntitySystem::CEntitySystem()
{
	int i = 0;
	for ( i = 0; i < MAX_EDICTS; i++ )
	{
		m_pEntities[i] = NULL;
	}
	m_nEntityCount = 0;
}

void CEntitySystem::RegisterEntityClass( IEntityFactory *pEntityFactory, const char *szClassName )
{
	IEntityFactory *pFactory;
	EntityRegistry_t *pRegistry;

	pFactory = GetFactoryByClassname(szClassName);

	if ( pFactory != NULL )
	{
		// Already registered
		return;
	}
	
	pRegistry = new EntityRegistry_t;
	pRegistry->m_pFactory = pEntityFactory;
	pRegistry->m_pNext = s_pEntitiesRegistry;
	pRegistry->m_szClassName = szClassName;
	s_pEntitiesRegistry = pRegistry; 
}

C_BaseEntity *CEntitySystem::CreateByClassname( const char *szName )
{
	IEntityFactory *pFactory;
	C_BaseEntity *pEntity;
	int i;
	int iSelectedSlot;

	pFactory = GetFactoryByClassname(szName);
	if ( !pFactory )
		return NULL;

	// We do not want to have more than MAX_EDICT entities
	if ( m_nEntityCount >= MAX_EDICTS-1 )
		return NULL;

	// Search for space
	// Could be more efficient but nobody cares
	for ( i = 0; i < MAX_EDICTS; i++ )
	{
		if ( m_pEntities[i] == NULL )
		{
			iSelectedSlot = i;
			break;
		}
	}

	pEntity = pFactory->Create();
	pEntity->m_szClassName = szName;
	m_pEntities[iSelectedSlot] = pEntity;
	m_nEntityCount++;
	return pEntity;
}
C_BaseEntity *CEntitySystem::CreateByClassnameWithIndex( const char *szName, uint32_t uIndex  )
{
	IEntityFactory *pFactory;
	C_BaseEntity *pEntity;

	// Do not create such shit
	if (uIndex >= MAX_EDICTS)
		return NULL;

	pFactory = GetFactoryByClassname(szName);
	if ( !pFactory )
		return NULL;

	pEntity = pFactory->Create();
	pEntity->m_szClassName = szName;
	m_pEntities[uIndex] = pEntity;
	m_nEntityCount++;
	return pEntity;
}

IEntityFactory *CEntitySystem::GetFactoryByClassname( const char *szName )
{
	EntityRegistry_t *pEntity;

	for ( pEntity = s_pEntitiesRegistry; pEntity; pEntity = pEntity->m_pNext )
	{
		if (!strcmp(szName, pEntity->m_szClassName))
		{
			return pEntity->m_pFactory;
		}
	}
	return NULL;
}

void CEntitySystem::DestroyEntityByIndex( uint32_t uIndex )
{	
	if ( uIndex >= MAX_EDICTS )
		return;
	if (m_pEntities[uIndex])
	{
		V_printf("Deleting: %i\n", uIndex);
		delete m_pEntities[uIndex];
		m_pEntities[uIndex] = 0;
	}
}

void CEntitySystem::DestroyEntityByPtr( C_BaseEntity *pEntity )
{
}


void CEntitySystem::Think()
{
	C_BaseEntity *pEntity;
	int i;

	for ( i = 0; i < MAX_EDICTS; i++ )
	{
		pEntity = m_pEntities[i];
		if ( pEntity == NULL )
			continue;

		if ( !pEntity->m_pfnThink )
			continue;

		(pEntity->*pEntity->m_pfnThink)(0);
	}
}

static void *UTIL_GetNetMapData(C_BaseEntity *pEntity, netmap_t *pMap, uint32_t uIndex )
{
	netmap_t *pCurrentMap = pMap;
	uint32_t uCurrentIndex = uIndex;
searchIndex:
	if (uCurrentIndex >= pCurrentMap->m_uFieldCount || pCurrentMap->m_pBase )
	{
		uCurrentIndex -= pCurrentMap->m_uFieldCount;
		pCurrentMap = pCurrentMap->m_pBase;
		if (!pCurrentMap)
			return NULL;
		goto searchIndex;
	}
	
	return (char*)pEntity+pCurrentMap->m_pFields[uCurrentIndex].m_uOffset;
}


static C_BaseEntity *s_pLocalEntity;

void CEntitySystem::NetRecvPacket( NetPacket_t *pPacket )
{
	PlayerPacket_t *pPlayerPacket = (PlayerPacket_t*)pPacket->pData;
	C_BaseEntity *pEntity;
	switch (pPlayerPacket->m_eType)
	{
	case MESSAGE_ENTITY_CLASS_SYNC:

		V_printf("MESSAGE_ENTITY_CLASS_SYNC: %u = %s\n", 
				(uint32_t)pPlayerPacket->m_entityClass.m_uIndex, 
				pPlayerPacket->m_entityClass.m_szEntityName);
		pEntity = CreateByClassnameWithIndex(
				(char*)pPlayerPacket->m_entityClass.m_szEntityName, 
				pPlayerPacket->m_entityClass.m_uIndex
				);
		if (pEntity == NULL)
			break;
		pEntity->Spawn();
		break;
	case MESSAGE_ENTITY_DATA_SYNC:
		pEntity = m_pEntities[pPlayerPacket->m_entityData.m_uIndex];
		if (pEntity == NULL)
			break;
		union {
			void *pData;
			char *pcCurrentData;
			EntityDataSyncValue_t *pcSyncValue;
		};
		pData = pPlayerPacket;
		pcCurrentData += sizeof(EntityDataSync_t);

		// too bad
		// this shall be reworked
		for ( uint32_t u = 0; u < pPlayerPacket->m_entityData.m_uCount; u++ )
		{

			uint32_t uVariableSize = pcSyncValue->m_uVariableSize;
			void *pValueData = (float*)UTIL_GetNetMapData(
					pEntity, 
					pEntity->GetRecvMap(), 
					pcSyncValue->m_uVariableIndex);

			pcCurrentData += sizeof(EntityDataSyncValue_t);
			if (pValueData)
				V_memcpy(pValueData, pcCurrentData, uVariableSize);
			pcCurrentData += (uVariableSize+7) & ~7;
		}
		break;
	case k_EMessage_PlayerSetLocalEntity:
		V_printf("k_EMessage_PlayerSetLocalEntity: %u\n",(uint32_t)pPlayerPacket->m_setLocalEntity.m_uIndex); 
		if (pPlayerPacket->m_setLocalEntity.m_uIndex > MAX_EDICTS)
			break;
		s_pLocalEntity = m_pEntities[pPlayerPacket->m_setLocalEntity.m_uIndex];
	default:
		break;
	}
}

void CEntitySystem::NetSendThink()
{

}


C_BaseEntity **CEntitySystem::GetEntities()
{
	return m_pEntities;
};

C_BaseEntity *UTIL_GetLocalPlayer()
{
	return s_pLocalEntity;
}