C++ CServerDE类代码示例

DDWORD ParticleSystem::EngineMessageFn(DDWORD messageID, void *pData, DFLOAT fData)
{
	switch(messageID)
	{
		case MID_PRECREATE:
		{
			if (fData == 1.0f || fData == 2.0f)
			{
				ReadProp((ObjectCreateStruct *)pData);
			}
			break;
		}

		case MID_INITIALUPDATE:
		{
			InitialUpdate((DVector *)pData);
			break;
		}

		case MID_UPDATE:
		{
			CServerDE* pServerDE = GetServerDE();
			if (pServerDE)
			{
				pServerDE->RemoveObject(m_hObject);
			}
			break;
		}

		default : break;
	}

	return CClientSFX::EngineMessageFn(messageID, pData, fData);
}

DBOOL ClientLightFX::InitialUpdate(DVector *pMovement)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return DFALSE;

	m_damage.Init(m_hObject);
	m_damage.SetMaxHitPoints(m_fHitPts);
	m_damage.SetHitPoints(m_fHitPts);

    // Set Next update (randomize it if this object was loaded from the
	// level - so we don't have all the lights updating on the same frame)...
	
	DFLOAT fOffset = 0.0f;
	if (!m_bDynamic) fOffset = pServerDE->Random(0.01f, 0.5f);

	if (m_bOn)
	{
		pServerDE->SetNextUpdate(m_hObject, UPDATE_DELTA + fOffset);
	}

	Init();

	SendEffectMessage();

	return DTRUE;
}

void CMovement::DebugDrawPath()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	HCLASS hClass = pServerDE->GetClass( "CClientDebugLine" );
	if( !hClass )	return;

	ObjectCreateStruct ocStruct;
	INIT_OBJECTCREATESTRUCT(ocStruct);

	VEC_COPY(ocStruct.m_Pos, m_vPos);
	ROT_COPY(ocStruct.m_Rotation, m_rRot);

	DLink* pLink1 = m_PathList.m_Head.m_pNext;
	DLink* pLink2 = pLink1->m_pNext;

	while(pLink1->m_pData && pLink2->m_pData)
	{
		CClientDebugLine* pDebugline = (CClientDebugLine*)pServerDE->CreateObject(hClass, &ocStruct);

		pDebugline->Setup((DVector*)pLink1->m_pData, (DVector*)pLink2->m_pData);

		pLink1 = pLink1->m_pNext;
		pLink2 = pLink2->m_pNext;
	}

	return;
}

void VolumeBrush::UpdateLiquidPhysics(ContainerPhysics* pCPStruct, DBOOL bCharacter)
{
    CServerDE* pServerDE = GetServerDE();
    if (!pServerDE || !pCPStruct || !pCPStruct->m_hObject) return;


    // If we are affecting a BaseCharacter object, let it do its own update...

    if (bCharacter)
    {
        CBaseCharacter* pCharacter = (CBaseCharacter*)pServerDE->HandleToObject(pCPStruct->m_hObject);
        if (pCharacter)
        {
            pCharacter->UpdateInLiquid(this, pCPStruct);
        }
    }
    else  // Apply liquid gravity to object...
    {
        if (pCPStruct->m_Flags & FLAG_GRAVITY)
        {
            pCPStruct->m_Flags &= ~FLAG_GRAVITY;
            pCPStruct->m_Acceleration.y += m_fGravity;
        }
    }
}

void CProjectile::AddLight(DFLOAT fRadius, DFLOAT fRed, DFLOAT fGreen, DFLOAT fBlue)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	m_vLightColor.x = fRed;
	m_vLightColor.y = fGreen;
	m_vLightColor.z = fBlue;

	if (fRadius)
	{
		ObjectCreateStruct ocStruct;
		INIT_OBJECTCREATESTRUCT(ocStruct);

		ocStruct.m_Flags = FLAG_VISIBLE;
		ocStruct.m_ObjectType = OT_LIGHT; 

		HCLASS hClass = pServerDE->GetClass("BaseClass");
		LPBASECLASS	pFlash = pServerDE->CreateObject(hClass, &ocStruct);

		if (pFlash)
		{
			m_hLight = pFlash->m_hObject;
			pServerDE->SetLightRadius(m_hLight, fRadius);
			pServerDE->SetLightColor(m_hLight, m_vLightColor.x, m_vLightColor.y, m_vLightColor.z);
		}
	}
}

DVector CMovement::FindPosAroundObj(DVector vStart, DVector vDir)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return vStart;

	DVector vDims, vPoint, vColor;

	m_nWidthPoints = 10;

	//get the parent's dims
	pServerDE->GetObjectDims(m_hObject,&vDims);
	DFLOAT fDim = (DFLOAT)sqrt((vDims.x * vDims.x) + (vDims.z * vDims.z)) + 0.1f;

	VEC_ADDSCALED(vPoint, vStart, vDir, fDim);

	while(m_nWidthPoints)
	{
		if(pServerDE->GetPointShade(&vPoint,&vColor))
		{
			return vPoint;	
		}
		else
		{
			VEC_ADDSCALED(vPoint, vPoint, vDir, fDim);
		}

		m_nWidthPoints--;
	}

	return vStart;
}

void CProjectile::AddSmokeTrail(DVector vVel)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	ObjectCreateStruct theStruct;
	INIT_OBJECTCREATESTRUCT(theStruct);

	DVector vPos;
	pServerDE->GetObjectPos(m_hObject, &vPos);
	VEC_COPY(theStruct.m_Pos, vPos);

	HCLASS hClass = pServerDE->GetClass("CClientSmokeTrail");

	CClientSmokeTrail* pTrail = DNULL;

	if (hClass)
	{
		pTrail = (CClientSmokeTrail*)pServerDE->CreateObject(hClass, &theStruct);
	}

	if (pTrail)
	{
		pTrail->Setup(vVel, DTRUE);
		m_hSmokeTrail = pTrail->m_hObject;
	}
}

void Rotating::HandleTrigger(HOBJECT hSender, HSTRING hMsg)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	char* pMsg = pServerDE->GetStringData(hMsg);
	if (!pMsg || !pMsg[0]) return;

	if (m_eState == RWM_OFF && _mbsicmp((const unsigned char*)pMsg, (const unsigned char*)TRIGGER_MSG_ON) == 0)
	{
		SetSpinUp();
		pServerDE->SetNextUpdate(m_hObject, RWM_UPDATE_DELTA);
	}
	else if (m_eState != RWM_OFF && _mbsicmp((const unsigned char*)pMsg, (const unsigned char*)TRIGGER_MSG_OFF) == 0)
	{
		SetSpinDown();
		pServerDE->SetNextUpdate(m_hObject, RWM_UPDATE_DELTA);
	}
	else if (_mbsicmp((const unsigned char*)pMsg, (const unsigned char*)TRIGGER_MSG_TOGGLE) == 0)
	{
		if (m_eState == RWM_OFF)
			SetSpinUp();
		else
			SetSpinDown();
		pServerDE->SetNextUpdate(m_hObject, RWM_UPDATE_DELTA);
	}
}

void Rotating::UpdateNormalRotation()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	DRotation rRot;
	pServerDE->GetObjectRotation(m_hObject, &rRot);

	DFLOAT fTime = pServerDE->GetTime();
	DFLOAT fDeltaTime = fTime - m_fLastTime;

	if (m_vVelocity.x > 0.0f)
	{
		m_fPitch += (m_vSign.x * (m_vVelocity.x * fDeltaTime));
	}

	if (m_vVelocity.y > 0.0f)
	{
		m_fYaw += (m_vSign.y * (m_vVelocity.y * fDeltaTime));
	}

	if (m_vVelocity.z > 0.0f)
	{
		m_fRoll += (m_vSign.z * (m_vVelocity.z * fDeltaTime));
	}

	pServerDE->SetupEuler(&rRot, m_fPitch, m_fYaw, m_fRoll);
	pServerDE->RotateObject(m_hObject, &rRot);	

	m_fLastTime = fTime;
}

void Gabriel::UpdateSenses()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	CCharacterMgr* pCharMgr = CCharacterMgr::GetMgr();
	if (!pCharMgr) return;

	// Until we've spotted a player, keep looking for one...

	if (!m_bSpottedPlayer)
	{
		HOBJECT hObj = pCharMgr->FindVisiblePlayer(this);
		if (hObj)
		{
			if (CheckAlignment(HATE, hObj))
			{
				SetNewTarget(hObj);
				TargetObject(hObj);
			}
			
			SpotPlayer(hObj);
		}
	}

	if (m_hTarget)
	{
		UpdateTargetPos();
		TargetObject(m_hTarget);
	}

	pServerDE->SetNextUpdate(m_hObject, 0.001f);
}

void CClientParticleStreamSFX::Load(HMESSAGEREAD hRead, DDWORD dwLoadFlags)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE || !hRead) return;

	bOn = (DBOOL) pServerDE->ReadFromMessageByte(hRead);
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::PlayRampSound(int nDirection)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;
    
	char *sound = DNULL;
    
    // Set the char pointer    
	if (nDirection == 1 && m_hstrRampUpSound)
	{
		sound = pServerDE->GetStringData(m_hstrRampUpSound);
	}
	else if (m_hstrRampDownSound)
	{
		sound = pServerDE->GetStringData(m_hstrRampDownSound);
	}

    // Play the sound if valid pointer
	if (sound && _mbstrlen(sound) > 0)
	{
		DFLOAT Radius = 1000.0f;
		PlaySoundFromObject(m_hObject, sound, Radius, SOUNDPRIORITY_MISC_HIGH);
	}

}

DBOOL PathMgr::BuildPathList()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return DFALSE;
	
	ClearPathList();

	// Iterate through the world building our list of keys, and removing 
	// all the PathPoints found...

	HCLASS  hPathPoint = pServerDE->GetClass("PathPoint");
	HOBJECT	hCurObject = DNULL;
	while (hCurObject = pServerDE->GetNextObject(hCurObject))
	{
		if (pServerDE->IsKindOf(pServerDE->GetObjectClass(hCurObject), hPathPoint))
		{
            // Make sure its not a SMELL pathpoint!
			PathListData* pKeyData = new PathListData;
			if (!pKeyData) return DFALSE;

			pKeyData->Copy(hCurObject);

			m_pathList.Add(pKeyData);

            // Check for Debug console var, if found do not REMOVE from world!
//			pServerDE->RemoveObject(hCurObject);
		}
	}

	return DTRUE;
}

DBOOL BugAI::InitialUpdate(DVector *pMovement)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return DFALSE;

	//Load up animation indexes if first model instance
    if(m_bLoadAnims)
	{
	    m_Anim_Sound.SetAnimationIndexes(m_hObject);
		m_Anim_Sound.GenerateHitSpheres(m_hObject);
	    m_Anim_Sound.SetSoundRoot("sounds\\enemies\\bug");
		m_bLoadAnims = DFALSE;
	}

	//randomize the size/weight
	DFLOAT fScale = pServerDE->Random(-0.05f, 0.1f);
	VEC_SET(m_vScale,1.0f + fScale, 1.0f, 1.0f + fScale);

    // Init the objects
	m_InventoryMgr.Init(m_hObject);
    
	//Set hit points
	m_damage.Init(m_hObject);
	m_damage.SetHitPoints(m_fAIHitPoints + pServerDE->Random(1,m_fAIRandomHP));
	m_damage.SetMaxHitPoints(m_damage.GetHitPoints());

	//Set armor point
	m_damage.SetArmorPoints(m_fAIArmorPoints);
	m_damage.SetMaxArmorPoints(200.0f);
	m_damage.SetMass(m_fAIMass);

	AI_Mgr::InitStatics(&m_Anim_Sound);
	
	return DTRUE;
}

void PathMgr::AddToSortedList(DList* pSortList, PathListData* pCurData)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !pSortList || !pCurData) return;

	DLink* pLink = new DLink;
	if (!pLink) return;

	pLink->m_pNext = pLink->m_pPrev = DNULL;
	pLink->m_pData = DNULL;

	// Find where in the list we belong...

	DLink* pCurPos    = &pSortList->m_Head;
	DLink* pInsertPos = pCurPos;

	while (pCurPos)
	{
		PathListData* pData = (PathListData*)pCurPos->m_pData;
		if (!pData) break;

		if (pServerDE->CompareStringsUpper(pCurData->m_hstrName, pData->m_hstrName) < 0)
		{
			break;
		}

		pInsertPos = pCurPos;
		pCurPos	   = pCurPos->m_pNext;
	}

	dl_AddAfter(pSortList, pInsertPos, pLink, (void*)pCurData);
}