C++ CServerDE::GetClass方法代码示例

void ObjectiveTrigger::ObjectTouch (HOBJECT hObj)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	// ignore everything but characters derived from BaseCharacter

	if (!IsBaseCharacter (hObj)) return;

	HCLASS hClassObj = pServerDE->GetObjectClass(hObj);
	
	// If we're AI, make sure we can activate this trigger...

	if (!m_bAITriggerable)
	{
		HCLASS hClassAI = pServerDE->GetClass("BaseAI");
		if ( pServerDE->IsKindOf(hClassObj, hClassAI) )
		{
			return;
		}
	}
	else if (m_hstrAIName) // See if only a specific AI can trigger it...
	{
		char* pAIName  = pServerDE->GetStringData(m_hstrAIName);
		char* pObjName = pServerDE->GetObjectName(hObj);

		if (pAIName && pObjName)
		{
			if ( stricmp(pAIName, pObjName) != 0)
			{
				return;
			}
		}
	}
	
	// If we're the player, make sure we can activate this trigger...

	if (!m_bPlayerTriggerable)
	{
		HCLASS hClassPlayer = pServerDE->GetClass("CPlayerObj");

		if ( pServerDE->IsKindOf(hClassObj, hClassPlayer) )
		{
			return;
		}
	}
	
	// send the mission objective message now

	Trigger();
}

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 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);
		}
	}
}

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;
}

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;
}

void Trigger::CreateBoundingBox()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	ObjectCreateStruct theStruct;
	INIT_OBJECTCREATESTRUCT(theStruct);

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

	SAFE_STRCPY(theStruct.m_Filename, "Models\\Props\\1x1_square.abc");
	// strcpy(theStruct.m_SkinName, "SpecialFX\\smoke.dtx");
	theStruct.m_Flags = FLAG_VISIBLE;

	HCLASS hClass = pServerDE->GetClass("Model");
	LPBASECLASS pModel = pServerDE->CreateObject(hClass, &theStruct);

	if (pModel)
	{
		m_hBoundingBox = pModel->m_hObject;

		DVector vDims;
		pServerDE->GetObjectDims(m_hObject, &vDims);

		DVector vScale;
		VEC_DIVSCALAR(vScale, vDims, 0.5f);
		pServerDE->ScaleObject(m_hBoundingBox, &vScale);
	}

	pServerDE->SetObjectColor(m_hBoundingBox, GetRandom(0.5f, 1.0f), 
							  GetRandom(0.5f, 1.0f), GetRandom(0.5f, 1.0f), 1.0f);
}

void CDestructableBrush::CreateWorldModelDebris()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE);

	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...

		ObjectList* pTempKeyList = pServerDE->FindNamedObjects(strKey);
		ObjectLink* pLink = pTempKeyList->m_pFirstLink;
		if (!pLink) return;
		
		while (pLink)
		{
			if (pServerDE->IsKindOf(pServerDE->GetObjectClass(pLink->m_hObject), hWMDebris))
			{
				WorldModelDebris* pDebris = (WorldModelDebris*)pServerDE->HandleToObject(pLink->m_hObject);
				if (!pDebris) break;

//				DVector vVel, vRotPeriods;
//				VEC_SET(vVel, pServerDE->Random(-200.0f, 200.0f), 
//							  pServerDE->Random(100.0f, 300.0f),
//							  pServerDE->Random(-200.0f, 200.0f) );

//				VEC_SET(vRotPeriods, pServerDE->Random(-1.0f, 1.0f),
//						pServerDE->Random(-1.0f, 1.0f), pServerDE->Random(-1.0f, 1.0f));

//				pDebris->Start(&vRotPeriods, &vVel);
				pDebris->Start();
			}

			pLink = pLink->m_pNext;
		}

		pServerDE->RelinquishList (pTempKeyList);
		
		// Increment the counter...

		nNum++;
	}
}

void VolumeBrush::InitialUpdate(int nData)
{
    CServerDE* pServerDE = GetServerDE();
    if (!pServerDE) return;

    // For save game restores, just recreate the surface
    if (nData == INITIALUPDATE_SAVEGAME)
        return;

    if (m_bShowSurface)
    {
        CreateSurface();
    }

    m_hPlayerClass = pServerDE->GetClass("CPlayerObj");

    DDWORD dwUserFlags = m_bHidden ? 0 : USRFLG_VISIBLE;
    dwUserFlags |= USRFLG_SAVEABLE;

    pServerDE->SetObjectUserFlags(m_hObject, dwUserFlags);

    if (m_hSurfaceObj)
    {
        pServerDE->SetObjectUserFlags(m_hSurfaceObj, dwUserFlags);
    }

    // Tell the client about any special fx (fog)...
    HMESSAGEWRITE hMessage = pServerDE->StartSpecialEffectMessage(this);
    pServerDE->WriteToMessageByte(hMessage, SFX_VOLUMEBRUSH_ID);
//pServerDE->WriteToMessageByte(hMessage, DTRUE);
    pServerDE->WriteToMessageByte(hMessage, (DBYTE)m_bFogEnable);
    pServerDE->WriteToMessageFloat(hMessage, m_fFogFarZ);
    pServerDE->WriteToMessageFloat(hMessage, m_fFogNearZ);
    pServerDE->WriteToMessageVector(hMessage, &m_vFogColor);
    pServerDE->EndMessage(hMessage);

    pServerDE->SetNextUpdate(m_hObject, 0.001f);


    // Save volume brush's initial flags...

    m_dwSaveFlags = pServerDE->GetObjectFlags(m_hObject);


    // Normalize viscosity (1 = no movement, 0 = full movement)...

    if (m_fViscosity < 0.0) m_fViscosity = 0.0f;
    else if (m_fViscosity > 1.0) m_fViscosity = 1.0f;

    // Okay, internally we really want it the opposite way (i.e., 1 = full
    // movement, 0 = no movement)...

    m_fViscosity = 1.0f - m_fViscosity;
}

void CProjectile::AddSparks(DVector vPos, DVector vNormal, DFLOAT fDamage, HOBJECT hObject)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE) return;

	ObjectCreateStruct ocStruct;
	INIT_OBJECTCREATESTRUCT(ocStruct);

	VEC_COPY(ocStruct.m_Pos, vPos);

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

	CClientSparksSFX *pSpark = DNULL;

	if (hClass)
	{
		pSpark = (CClientSparksSFX *)pServerDE->CreateObject(hClass, &ocStruct);
	}

	if (pSpark)
	{
		DVector vColor1, vColor2;
		char* pFile;
		DBYTE nSparks = (DBYTE)fDamage;

		SurfaceType eType = GetSurfaceType(hObject, DNULL);

		switch(eType)
		{
			case SURFTYPE_FLESH:
			{
				VEC_SET(vColor1, 200.0f, 0.0f, 0.0f);
				VEC_SET(vColor2, 255.0f, 0.0f, 0.0f);

				pFile = "spritetextures\\particle1.dtx";

				pSpark->Setup(&vNormal, &vColor1, &vColor2, pFile, nSparks, 0.6f, 2.0f, 500.0f);
				break;
			}
			default:
			{
				VEC_SET(vColor1, 200.0f, 200.0, 200.0f);
				VEC_SET(vColor2, 200.0f, 200.0f, 0.0f);

				pFile = "spritetextures\\particle1.dtx";

				pSpark->Setup(&vNormal, &vColor1, &vColor2, pFile, nSparks, 0.4f, 2.0f, 500.0f);
				break;
			}
		}
	}

	return;
}

void VolumeBrush::CreateSurface()
{
    CServerDE* pServerDE = GetServerDE();
    if (!pServerDE) return;

    ObjectCreateStruct theStruct;
    INIT_OBJECTCREATESTRUCT(theStruct);

    DVector vPos, vDims, vScale;
    VEC_INIT(vScale);

    pServerDE->GetObjectDims(m_hObject, &vDims);
    pServerDE->GetObjectPos(m_hObject, &vPos);

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

    VEC_COPY(m_vLastPos, vPos);

    vPos.y += vDims.y - (m_fSurfaceHeight/2.0f);
    VEC_COPY(theStruct.m_Pos, vPos);
    ROT_COPY(theStruct.m_Rotation, rRot);

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

    PolyGrid* pSurface = DNULL;

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

    if (pSurface)
    {
        m_hSurfaceObj = pSurface->m_hObject;
        vDims.y		  = m_fSurfaceHeight;

        DFLOAT fXPan = 1.0f + (m_vCurrent.x * 0.01f);
        DFLOAT fYPan = 1.0f + (m_vCurrent.y * 0.01f);

        pSurface->Setup(&vDims, &m_vSurfaceColor1, &m_vSurfaceColor2,
                        m_hstrSurfaceSprite, m_fXScaleMin, m_fXScaleMax,
                        m_fYScaleMin, m_fYScaleMax, m_fXScaleDuration,
                        m_fYScaleDuration, fXPan, fYPan, m_fSurfaceAlpha,
                        m_dwNumSurfacePolies);

//		pServerDE->SetObjectColor(m_hSurfaceObj,1.0f,0,0,0.1f);
    }
}

void Gabriel::CreateShield()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE || m_hShield) return;

	ObjectCreateStruct theStruct;
	INIT_OBJECTCREATESTRUCT(theStruct);

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

	SAFE_STRCPY(theStruct.m_Filename, "Models\\PV_Weapons\\SpiderExplosionCore.abc");
	SAFE_STRCPY(theStruct.m_SkinName, "SpecialFX\\Explosions\\SpiderCore.dtx");

	theStruct.m_ObjectType  = OT_MODEL;
	theStruct.m_Flags		= FLAG_VISIBLE | FLAG_GOTHRUWORLD;

	HCLASS hClass = pServerDE->GetClass("BaseClass");
	LPBASECLASS pModel = pServerDE->CreateObject(hClass, &theStruct);
	if (!pModel) return;

	m_hShield = pModel->m_hObject;

	DVector vScale;
	VEC_SET(vScale, 150.0f, 300.0f, 150.0f);
	pServerDE->ScaleObject(m_hShield, &vScale);

	pServerDE->SetObjectColor(m_hShield, 1.0f, 0.5f, 0.0f, 0.5f);

	// Attach the sheild model to Gabriel...

	DVector vOffset;
	VEC_INIT(vOffset);

	DRotation rOffset;
	ROT_INIT(rOffset);

	HATTACHMENT hAttachment;
	DRESULT dRes = pServerDE->CreateAttachment(m_hObject, m_hShield, DNULL, 
											   &vOffset, &rOffset, &hAttachment);
	if (dRes != DE_OK)
	{
		pServerDE->RemoveObject(m_hShield);
		m_hShield = DNULL;
	}
}

DBOOL CMovement::Init(HOBJECT hObject)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!hObject || !pServerDE) return DFALSE;

	m_hObject = hObject;

	VEC_INIT(m_vLastPos);

    // See if it's a player object
	if(pServerDE->IsKindOf(pServerDE->GetObjectClass(hObject), pServerDE->GetClass("CBaseCharacter"))) 
	{
		m_pOwner = (CBaseCharacter*)pServerDE->HandleToObject(hObject);
	}

	return DTRUE;
}

void WeaponPowerup::ObjectTouch(HOBJECT hObject)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE || !hObject) return;

	// If we hit non-character objects, just ignore them...

	HCLASS hCharClass = pServerDE->GetClass("CBaseCharacter");
	HCLASS hObjClass  = pServerDE->GetObjectClass(hObject);

	if (pServerDE->IsKindOf(hObjClass, hCharClass))
	{
		CBaseCharacter* pCharObj = (CBaseCharacter*)pServerDE->HandleToObject(hObject);

		if (pCharObj && !pCharObj->IsDead() && pCharObj->CanCarryWeapon(m_iWeaponType))
		{
			HMESSAGEWRITE hMessage = pServerDE->StartMessageToObject(this, hObject, MID_ADDWEAPON);
			pServerDE->WriteToMessageByte( hMessage, m_iWeaponType );
			pServerDE->WriteToMessageFloat( hMessage, ( float )m_dwAmmo );
			pServerDE->EndMessage(hMessage);
		}
	}
}

DBOOL FireFX::Update(DVector* pMovement)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE || !m_hObject) return DFALSE;

	pServerDE->SetNextUpdate(m_hObject, (DFLOAT)0.01);

    // Increase the Fire Index
    m_nFireIndex++;
    if (m_nFireIndex >= MAXFIRES)        m_nFireIndex = 0;
    
    // If First Update then look for the object to attach to...
    // and Add Light...
    //
	if (m_bFirstUpdate == DTRUE)
	{
		FirstUpdate();
	}
    else
    {
        if (m_hLinkObject)
        {
        
        	DFLOAT fTime = pServerDE->GetTime();
            
            //
            // Send Damage to LinkObject!!!
            //                  
            
            // Check for Object Dead
            if (m_bDead == DTRUE)
            {
                // Move the Smoke Up
            	if (m_hSmokeTrail[m_nFireIndex])
            	{
		            DVector vPos;
                    pServerDE->GetObjectPos(m_hSmokeTrail[m_nFireIndex], &vPos);
                    
                	vPos.y = vPos.y + 2;
		            pServerDE->SetObjectPos(m_hSmokeTrail[m_nFireIndex], &vPos);
            	}
                
                // Keep Smoke around longer 
            	if (fTime > m_fLastTime + 5.0f)
                {
                    for (int x=0; x<MAXFIRES; x++)
                    {
                       	if (m_hSmokeTrail[x])
						{
							pServerDE->RemoveObject(m_hSmokeTrail[x]);
							m_hSmokeTrail[x] = DNULL;
						}
                    }
                                
                    if (m_hLight)   pServerDE->RemoveObject( m_hLight );
                    pServerDE->RemoveObject( m_hObject );
                }
                return DTRUE;
                
            }
            else
            {
                if (m_hLinkObject)
                {
    	            if(pServerDE->IsKindOf(pServerDE->GetObjectClass(m_hLinkObject), pServerDE->GetClass("CBaseCharacter"))) 
                    {
                        CBaseCharacter *pLinkObject = (CBaseCharacter*)pServerDE->HandleToObject(m_hLinkObject);
                        // Check to see if the Linked object is dead
                	    if(pLinkObject->IsDead() )
    	                {
                            for (int x=0; x<MAXFIRES; x++)
                            {
                            	if (m_hSprite[x])
								{
									pServerDE->RemoveObject(m_hSprite[x]);
									m_hSprite[x] = DNULL;
								}
                            }           
                            
                            m_bDead = DTRUE;
        	                m_fLastTime = pServerDE->GetTime();
                        
                            return DTRUE;
                        }
                    }        
                }
            }
            
            
            DRotation rRot;
            DVector m_vUp, m_vRight, m_vForward;
            DVector vPos, vTemp, vDir, vDims;

// Need to build a table of Sprites and There Positions...
// Then Update Each position???
//
            int x = m_nFireIndex;
            
            {
            	// Remove everything if we're done.
//.........这里部分代码省略.........

void VolumeBrush::UpdatePhysics(ContainerPhysics* pCPStruct)
{
    CServerDE* pServerDE = GetServerDE();
    if (m_bHidden || !pServerDE || !pCPStruct || !pCPStruct->m_hObject) return;

    DFLOAT fUpdateDelta = pServerDE->GetFrameTime();

    // Check to see if this object is the player object...

    if (!pServerDE->IsKindOf(pServerDE->GetObjectClass(pCPStruct->m_hObject), m_hPlayerClass))
    {
        // Check to see if this object is a character object...

        DBOOL bCharacter = DFALSE;
        HCLASS hBaseCharClass = pServerDE->GetClass("CBaseCharacter");

        if (pServerDE->IsKindOf(pServerDE->GetObjectClass(pCPStruct->m_hObject), hBaseCharClass))
        {
            bCharacter = DTRUE;

            if (m_bLocked)
            {
                // See if they have the key we need to unlock
                HMESSAGEWRITE hMessage = pServerDE->StartMessageToObject((LPBASECLASS)this, pCPStruct->m_hObject, MID_KEYQUERY);
                pServerDE->WriteToMessageHString(hMessage, m_hstrKeyName);
                pServerDE->EndMessage(hMessage);
            }
        }


        // Update velocity...

        // Dampen velocity and acceleration based on the viscosity of the container...

        if (m_fViscosity > 0.0f)
        {
            VEC_MULSCALAR(pCPStruct->m_Velocity, pCPStruct->m_Velocity, m_fViscosity);
            VEC_MULSCALAR(pCPStruct->m_Acceleration, pCPStruct->m_Acceleration, m_fViscosity);
        }


        // Do special liquid / zero gravity handling...

        if (IsLiquid(m_eContainerCode))
        {
            UpdateLiquidPhysics(pCPStruct, bCharacter);
        }


        // Add any current...

        // Make current relative to update delta (actually change the REAL velocity)...

        DVector vCurrent;
        VEC_MULSCALAR(vCurrent, m_vCurrent, fUpdateDelta);

        VEC_ADD(pCPStruct->m_Velocity, pCPStruct->m_Velocity, vCurrent);
    }

    // Update damage...

    // Make damage relative to update delta...

    if (m_fDamage)
    {
        DFLOAT fTime = pServerDE->GetTime();
        DFLOAT fDamageDeltaTime = fTime - m_fLastDamageTime;

        if (fDamageDeltaTime >= DAMAGE_UPDATE_DELTA || fTime == m_fLastDamageTime)
        {
            m_fLastDamageTime = fTime;

            DVector vDir;
            VEC_INIT(vDir);

            DamageObject(m_hObject, this, pCPStruct->m_hObject, m_fDamage * DAMAGE_UPDATE_DELTA, vDir, vDir, m_nDamageType);
        }
    }

}