gameweapons.cpp

Blood 2全套源码

					pServerDE->WriteToMessageObject(hMessage, ii.m_hObject);
					pServerDE->WriteToMessageVector(hMessage, &offset);
					pServerDE->WriteToMessageFloat(hMessage, 0.0f);
					pServerDE->WriteToMessageDWord(hMessage, 0);
					pServerDE->WriteToMessageDWord(hMessage, OBJFX_VOODOO_6);
					pServerDE->WriteToMessageDWord(hMessage, 0);

					pServerDE->EndMessage2(hMessage, MESSAGE_GUARANTEED | MESSAGE_NAGGLEFAST);
					//******************************************************************

					if(pServerDE->IsKindOf(hObjClass, hPlayer))
					{
		    			CPlayerObj *pHit = (CPlayerObj*)pServerDE->HandleToObject(ii.m_hObject);

						HMESSAGEWRITE hMsg = pServerDE->StartMessage(pHit->GetClient(), SMSG_WONKYVISION);
						pServerDE->WriteToMessageFloat(hMsg, fWonkyTime);
						pServerDE->WriteToMessageByte(hMsg, 0);	// bNoMove = DFALSE
						pServerDE->EndMessage2(hMsg, MESSAGE_GUARANTEED | MESSAGE_NAGGLE);
					}
				}
			}
		}

		pLink = pLink->m_pNext;
	}

	return bHitSomething;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CShotgun::Fire()
//
//	PURPOSE:	Fires the shotgun
//
// ----------------------------------------------------------------------- //

DDWORD CShotgun::Fire()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE)
		return DFALSE;

	if (m_eState == WS_ALT_FIRING)
		m_bEjectShell = DTRUE;
	else
		m_bEjectShell = DFALSE;

	return CWeapon::Fire();
/*
	DVector vU, vR, vF;

	pServerDE->GetRotationVectors(&m_rRotation, &vU, &vR, &vF); 

	m_bPlayImpactSound = DFALSE;

	m_bEjectShell = DFALSE;

	// Fire two barrels
	if ((m_eState == WS_ALT_FIRING) && m_dwCurBarrel == BARREL_1)
	{
		DFLOAT newLastShotTime;
		DFLOAT oldLastShotTime = m_fLastShotTime;

		DDWORD dwRet = CWeapon::Fire();
		if (dwRet)
		{
			newLastShotTime = m_fLastShotTime;
			m_fLastShotTime = oldLastShotTime;

			m_bEjectShell = DTRUE;
			// Fire the 2nd barrel.
			dwRet = CWeapon::Fire();
			if (!dwRet)  // 2nd shot didn't go for some reason
			{
				m_fLastShotTime = newLastShotTime;
			}
			else
			{
				VEC_ADD(vR, vU, vR);
			}

			dwRet = 2;
			m_bLastFireAlt = DTRUE;
			m_dwCurBarrel = BARREL_1;
		}
		return dwRet;
	}
	else // Fire only one barrel
	{
		if (m_dwCurBarrel == BARREL_2)
			m_bEjectShell = DTRUE;

		DDWORD dwRet = CWeapon::Fire();
		if (dwRet)
		{
			if (m_dwCurBarrel == BARREL_2)
			{
				m_bLastFireAlt = DTRUE;
				m_dwCurBarrel = BARREL_1;

				VEC_ADD(vR, vU, vR);
			}
			else
			{
				m_bLastFireAlt = DFALSE;
				m_dwCurBarrel = BARREL_2;
			}
			return 1;
		}
		else
			return 0;
	}
*/
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CRGLauncher::FireProjectile()
//
//	PURPOSE:	Fires a projectile for the RGLauncher
//
// ----------------------------------------------------------------------- //

CProjectile* CNapalmCannon::FireProjectile(DVector *vFire, DFLOAT dist, DBOOL bAltFire)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	CProjectile *pProject = CWeapon::FireProjectile(vFire, dist, bAltFire);

	// Primary fire has rocket projectiles, so turn off gravity
	if (!bAltFire)
	{
		DDWORD dwFlags = pServerDE->GetObjectFlags(pProject->m_hObject);
		dwFlags &= ~FLAG_GRAVITY;
		pProject->SetFlags(dwFlags);
	}
	return pProject;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CDeathRay::CDeathRay()
//
//	PURPOSE:	Constructor
//
// ----------------------------------------------------------------------- //

CDeathRay::CDeathRay() : CWeapon(WEAP_DEATHRAY)
{
	m_nFlags = FLAG_ENVIRONMENTMAP;
	m_fChromeValue = 0.05f;
	m_fLastDamageTime = 0.0f;
	m_pRotModel = DNULL;

	ObjectCreateStruct ocStruct;
	INIT_OBJECTCREATESTRUCT(ocStruct);

	ocStruct.m_ObjectType = OT_NORMAL; 
	ocStruct.m_Flags = FLAG_FORCECLIENTUPDATE;

	HCLASS hClass = g_pServerDE->GetClass("BaseClass");
	m_pRotModel = (BaseClass*)g_pServerDE->CreateObject(hClass, &ocStruct);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CDeathRay::~CDeathRay()
//
//	PURPOSE:	Destructor
//
// ----------------------------------------------------------------------- //

CDeathRay::~CDeathRay()
{
	if(m_pRotModel)
	{
		delete m_pRotModel;
		m_pRotModel = DNULL;
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CDeathRay::Fire()
//
//	PURPOSE:	Fires the rings o' death
//
// ----------------------------------------------------------------------- //

DDWORD CDeathRay::Fire()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if(!pServerDE)	return 0;

	if(m_eState == WS_ALT_FIRING)
	{
		DVector		vPos;
		DRotation	rRot;

		pServerDE->GetObjectPos(m_hOwner, &vPos);

		if(IsOwnerAPlayer())
		{
   			CPlayerObj	*pObj = (CPlayerObj*)pServerDE->HandleToObject(m_hOwner);
			DFLOAT		fEyeLevel = pObj->GetEyeLevel();
			vPos.y += fEyeLevel;
			pObj->GetPlayerRotation(&rRot);
		}
		else
			pServerDE->GetObjectRotation(m_hOwner, &rRot);

		pServerDE->SetObjectPos(m_pRotModel->m_hObject, &vPos);
		pServerDE->SetObjectRotation(m_pRotModel->m_hObject, &rRot);

		// Create a client side effect around the projectile
		DVector		offset;
		VEC_SET(offset, m_vFlash.y, m_vFlash.x, m_vFlash.z);

		HMESSAGEWRITE hMessage = pServerDE->StartInstantSpecialEffectMessage(&offset);
		pServerDE->WriteToMessageByte(hMessage, SFX_OBJECTFX_ID);

		pServerDE->WriteToMessageObject(hMessage, m_pRotModel->m_hObject);
		pServerDE->WriteToMessageVector(hMessage, &offset);
		pServerDE->WriteToMessageFloat(hMessage, 0.0f);
		pServerDE->WriteToMessageDWord(hMessage, 0);
		pServerDE->WriteToMessageDWord(hMessage, OBJFX_DEATHRAY_RING_1);
		pServerDE->WriteToMessageDWord(hMessage, 0);

		pServerDE->EndMessage2(hMessage, MESSAGE_GUARANTEED | MESSAGE_NAGGLEFAST);

		hMessage = pServerDE->StartInstantSpecialEffectMessage(&offset);
		pServerDE->WriteToMessageByte(hMessage, SFX_OBJECTFX_ID);

		pServerDE->WriteToMessageObject(hMessage, m_pRotModel->m_hObject);
		pServerDE->WriteToMessageVector(hMessage, &offset);
		pServerDE->WriteToMessageFloat(hMessage, 0.0f);
		pServerDE->WriteToMessageDWord(hMessage, 0);
		pServerDE->WriteToMessageDWord(hMessage, OBJFX_DEATHRAY_RING_2);
		pServerDE->WriteToMessageDWord(hMessage, 0);

		pServerDE->EndMessage2(hMessage, MESSAGE_GUARANTEED | MESSAGE_NAGGLEFAST);

		DamageObjectsInFOV(DEATHRAY_BEAM_DIST, DEATHRAY_BEAM_FOV);
	}

	return CWeapon::Fire();
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CDeathRay::DamageObjectsInFOV()
//
//	PURPOSE:	Damages every destructable object in the FOV at a short range
//
// ----------------------------------------------------------------------- //

void CDeathRay::DamageObjectsInFOV(DFLOAT fRange, DFLOAT fFOV)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE)	return;

	// Get the head of the list of destructable objects
	DLink*	pLink = CDestructable::m_DestructableHead.m_pNext;
	if(!pLink || (pLink == &CDestructable::m_DestructableHead))	return;

	HOBJECT		hObj;

	// Get a forward vector and position of the player who shot the death ray
   	CPlayerObj	*pObj = (CPlayerObj*)pServerDE->HandleToObject(m_hOwner);
	DVector		vOwnerF, vOwnerPos;
	pObj->GetPlayerForward(&vOwnerF);
	pServerDE->GetObjectPos(m_hOwner, &vOwnerPos);
	VEC_NORM(vOwnerF);

	// Go through the list of destructable objects and look for people within your FOV
	while(pLink != &CDestructable::m_DestructableHead)
	{
		hObj = ((CDestructable*)pLink->m_pData)->GetObject();
		if(!hObj)	break;

		DVector		vObjPos, vDir;
		DFLOAT		fDist, fAngle;

		// If it's us... skip to the next in the list
		if(hObj == m_hOwner)
			{ pLink = pLink->m_pNext; continue; }

		// Test the angle between this object and us
		pServerDE->GetObjectPos(hObj, &vObjPos);
		VEC_SUB(vDir, vObjPos, vOwnerPos);
		fDist = VEC_MAG(vDir);

		// If the target is too far away... skip it
		if(fDist > fRange)
			{ pLink = pLink->m_pNext; continue; }

		VEC_NORM(vDir);
		fAngle = VEC_DOT(vDir, vOwnerF);

		// If the target isn't within our square FOV, then skip it
		if(fAngle < fFOV)
			{ pLink = pLink->m_pNext; continue; }

		// Make sure there's nothing blocking our view of the character
		IntersectQuery iq;
		IntersectInfo  ii;

		VEC_COPY(iq.m_From, vOwnerPos);
		VEC_COPY(iq.m_To, vObjPos);
		VEC_MULSCALAR(vDir, vDir, 15.0f);
		VEC_ADD(iq.m_To, iq.m_To, vDir);

		iq.m_Flags = INTERSECT_OBJECTS | IGNORE_NONSOLID;
		iq.m_FilterFn = LiquidFilterFn;
		iq.m_pUserData = NULL;	

		if(pServerDE->IntersectSegment(&iq, &ii))
		{
			if(ii.m_hObject == hObj)
			{
				VEC_NORM(vDir);

				m_nDamageType = DAMAGE_TYPE_ELECTRIC;
				SendDamageMsg(ii.m_hObject, ii.m_Point, &vDir, m_fDamage);

				//******************************************************************
				// Create a particle effect around the hit character
				DVector		offset;
				VEC_SET(offset, 0.0f, 0.0f, 0.0f);

				HMESSAGEWRITE hMessage = pServerDE->StartInstantSpecialEffectMessage(&offset);
				pServerDE->WriteToMessageByte(hMessage, SFX_OBJECTFX_ID);

				pServerDE->WriteToMessageObject(hMessage, ii.m_hObject);
				pServerDE->WriteToMessageVector(hMessage, &offset);
				pServerDE->WriteToMessageFloat(hMessage, 0.0f);
				pServerDE->WriteToMessageDWord(hMessage, 0);
				pServerDE->WriteToMessageDWord(hMessage, OBJFX_ELECTRIC_1);
				pServerDE->WriteToMessageDWord(hMessage, 0);

				pServerDE->EndMessage2(hMessage, MESSAGE_GUARANTEED | MESSAGE_NAGGLEFAST);
				//******************************************************************
			}
		}

		pLink = pLink->m_pNext;
	}
}

#ifdef _ADD_ON

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CFlayer::FireProjectile()
//
//	PURPOSE:	Fires the weapon
//
// ----------------------------------------------------------------------- //

CProjectile* CFlayer::FireProjectile(DVector *vFire, DFLOAT dist, DBOOL bAltFire)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE)		return 0;

/*	DVector		vNormal;
	DDWORD		dwExpType = EXP_FLAYER_PRIMARY;

	VEC_SET(vNormal, 0.0f, 1.0f, 0.0f);

	if(bAltFire)
		dwExpType = EXP_FLAYER_ALT;

	// Create a little explosion effect at the source
	HMESSAGEWRITE hMessage = pServerDE->StartInstantSpecialEffectMessage(&m_vPosition);
	pServerDE->WriteToMessageByte(hMessage, SFX_EXPLOSIONFX_ID);

	pServerDE->WriteToMessageVector(hMessage, &m_vPosition);
	pServerDE->WriteToMessageVector(hMessage, &vNormal);
	pServerDE->WriteToMessageDWord(hMessage, dwExpType);

	pServerDE->EndMessage2(hMessage, MESSAGE_GUARANTEED | MESSAGE_NAGGLEFAST);
*/
	return CWeapon::FireProjectile(vFire, dist, bAltFire);
}


#endif

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeslaCannon::Fire()
//
//	PURPOSE:	Fires the weapon
//
// ----------------------------------------------------------------------- //

DDWORD CTeslaCannon::Fire()
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE)		return 0;

	if(m_eState == WS_ALT_FIRING)
	{
		numAltFires++;

		if(numAltFires == 2)
			m_szAltProjectileClass = "CTeslaBallProjectile";
		else
			m_szAltProjectileClass = "CTeslaBoltProjectile";
	}

	return CWeapon::Fire();
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CTeslaCannon::FireProjectile()
//
//	PURPOSE:	Fires the weapon
//
// ----------------------------------------------------------------------- //

CProjectile* CTeslaCannon::FireProjectile(DVector *vFire, DFLOAT dist, DBOOL bAltFire)
{
	CServerDE* pServerDE = BaseClass::GetServerDE();
	if (!pServerDE)		return 0;

	if(bAltFire)
	{
		IntersectQuery	iq;
		IntersectInfo	ii;
		DVector			vDist, vDest;

		iq.m_Flags = INTERSECT_OBJECTS | IGNORE_NONSOLID;
		iq.m_FilterFn = DNULL;
		iq.m_pUserData = DNULL;

		VEC_COPY(iq.m_From, m_vPosition);
		VEC_COPY(iq.m_To, m_vPosition);
		VEC_MULSCALAR(vDist, *vFire, dist)
		VEC_ADD(iq.m_To, iq.m_To, vDist);

		if(pServerDE->IntersectSegment(&iq, &ii))
			{ VEC_COPY(vDest, ii.m_Point); }
		else
			{ VEC_COPY(vDest, iq.m_To); }