自学教程：C++ GetClassPtr函数代码示例

CGrenade *CGrenade::ShootSmokeGrenade(entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time, unsigned short usEvent){	CGrenade *pGrenade = GetClassPtr((CGrenade *)NULL);	pGrenade->Spawn();	UTIL_SetOrigin(pGrenade->pev, vecStart);	pGrenade->pev->velocity = vecVelocity;	pGrenade->pev->angles = pevOwner->angles;	pGrenade->pev->owner = ENT(pevOwner);	pGrenade->m_usEvent = usEvent;	pGrenade->m_bLightSmoke = false;	pGrenade->m_bDetonated = false;	pGrenade->SetTouch(&CGrenade::BounceTouch);	pGrenade->pev->dmgtime = gpGlobals->time + time;	pGrenade->SetThink(&CGrenade::SG_TumbleThink);	pGrenade->pev->nextthink = gpGlobals->time + 0.1;	if (time < 0.1)	{		pGrenade->pev->nextthink = gpGlobals->time;		pGrenade->pev->velocity = Vector(0, 0, 0);	}	pGrenade->pev->sequence = RANDOM_LONG(3, 6);	pGrenade->pev->framerate = 1;	pGrenade->m_bJustBlew = true;	pGrenade->pev->gravity = 0.5;	pGrenade->pev->friction = 0.8;	pGrenade->m_SGSmoke = 0;	SET_MODEL(ENT(pGrenade->pev), "models/w_smokegrenade.mdl");	pGrenade->pev->dmg = 35;	return pGrenade;}

void AvHUmbraGun::FireProjectiles(void){	#ifdef AVH_SERVER		// Make sure we have enough points to shoot this thing	AvHPlayer* thePlayer = dynamic_cast<AvHPlayer*>(this->m_pPlayer);	ASSERT(thePlayer);	// Create umbra projectile	AvHUmbraProjectile* theUmbra = GetClassPtr((AvHUmbraProjectile*)NULL );	theUmbra->Spawn();		UTIL_MakeVectors(this->m_pPlayer->pev->v_angle);		Vector vecAiming = gpGlobals->v_forward;	Vector vecSrc = this->m_pPlayer->GetGunPosition( ) + vecAiming;		UTIL_SetOrigin(theUmbra->pev, vecSrc);		VectorScale(vecAiming, kShootCloudVelocity, theUmbra->pev->velocity);		// Set projectile team and owner	theUmbra->pev->owner = ENT(this->m_pPlayer->pev);		// Set Umbra's team :)	theUmbra->pev->team = this->m_pPlayer->pev->team;		#endif	}

void CTankBSP :: Spawn( void ){	Precache();	pev->solid			= SOLID_BSP;	pev->movetype		= MOVETYPE_PUSH;	SET_MODEL( ENT(pev), STRING(pev->model) );		UTIL_SetSize( pev, pev->mins, pev->maxs );	UTIL_SetOrigin( pev, pev->origin );	pev->flags			|= FL_MONSTER;	pev->takedamage		= DAMAGE_YES;	pev->rendermode		= kRenderTransTexture;	pev->renderamt		= 0;	pev->view_ofs		= Vector ( 0,0,100 );	pev->health			= TANK_LIFE;	m_pTankModel = GetClassPtr( (CTank*)NULL );	UTIL_SetOrigin( m_pTankModel->pev, pev->origin );	m_pTankModel->pev->angles = pev->angles;	m_pTankModel->m_pTankBSP = this;	m_pTankModel->Spawn();	SetThink ( TankThink );	SetTouch ( TouchPlayer );	pev->nextthink = pev->ltime + 0xFF;}

CDisc *CDisc::CreateDisc( Vector vecOrigin, Vector vecAngles, CBaseEntity *pOwner, CDiscWeapon *pLauncher, bool bDecapitator, int iPowerupFlags ){	CDisc *pDisc = GetClassPtr( (CDisc *)NULL );	UTIL_SetOrigin( pDisc->pev, vecOrigin );	pDisc->m_iPowerupFlags = iPowerupFlags;	// Hard shots always decapitate	if ( pDisc->m_iPowerupFlags & POW_HARD )		pDisc->m_bDecapitate = TRUE;	else		pDisc->m_bDecapitate = bDecapitator;	pDisc->pev->angles = vecAngles;	pDisc->pev->owner = pOwner->edict();	pDisc->pev->team = pOwner->pev->team;	pDisc->pev->iuser4 = pOwner->pev->iuser4;	// Set the Group Info	pDisc->pev->groupinfo = pOwner->pev->groupinfo;	pDisc->m_pLauncher = pLauncher; 	pDisc->Spawn();	return pDisc;}

//=========================================================CQuakeRocket *CQuakeRocket::CreateRocket( Vector vecOrigin, Vector vecAngles, CBaseEntity *pOwner ){	CQuakeRocket *pRocket = GetClassPtr( (CQuakeRocket *)NULL );		UTIL_SetOrigin( pRocket->pev, vecOrigin );	SET_MODEL(ENT(pRocket->pev), "models/rocket.mdl");	pRocket->Spawn();	pRocket->pev->classname = MAKE_STRING("missile");	pRocket->pev->owner = pOwner->edict();	// Setup	pRocket->pev->movetype = MOVETYPE_FLYMISSILE;	pRocket->pev->solid = SOLID_BBOX;			// Velocity	pRocket->pev->velocity = vecAngles * 1000;	pRocket->pev->angles = UTIL_VecToAngles( vecAngles );		// Touch	pRocket->SetTouch( CQuakeRocket::RocketTouch );	// Safety Remove	pRocket->pev->nextthink = gpGlobals->time + 5;	pRocket->SetThink( SUB_Remove );	// Effects//	pRocket->pev->effects |= EF_LIGHT;	PLAYBACK_EVENT_FULL (FEV_GLOBAL, pRocket->edict(), g_sTrail, 0.0, 	(float *)&pRocket->pev->origin, (float *)&pRocket->pev->angles, 0.7, 0.0, pRocket->entindex(), ROCKET_TRAIL, 0, 0);	return pRocket;} 

/*========================ClientUserInfoChangedcalled after the player changesuserinfo - gives dll a chance to modify it beforeit gets sent into the rest of the engine.========================*/void ClientUserInfoChanged( edict_t *pEntity, char *infobuffer ){	// Is the client spawned yet?	if ( !pEntity->pvPrivateData )		return;	// msg everyone if someone changes their name,  and it isn't the first time (changing no name to current name)	if ( pEntity->v.netname && STRING(pEntity->v.netname)[0] != 0 && !FStrEq( STRING(pEntity->v.netname), g_engfuncs.pfnInfoKeyValue( infobuffer, "name" )) )	{		char sName[256];		char *pName = g_engfuncs.pfnInfoKeyValue( infobuffer, "name" );		strncpy( sName, pName, sizeof(sName) - 1 );		sName[ sizeof(sName) - 1 ] = '/0';		// First parse the name and remove any %'s		for ( char *pApersand = sName; pApersand != NULL && *pApersand != 0; pApersand++ )		{			// Replace it with a space			if ( *pApersand == '%' )				*pApersand = ' ';		}		// Set the name		g_engfuncs.pfnSetClientKeyValue( ENTINDEX(pEntity), infobuffer, "name", sName );		char text[256];		sprintf( text, "* %s changed name to %s/n", STRING(pEntity->v.netname), g_engfuncs.pfnInfoKeyValue( infobuffer, "name" ) );		MESSAGE_BEGIN( MSG_ALL, gmsgSayText, NULL );		WRITE_BYTE( ENTINDEX(pEntity) );		WRITE_STRING( text );		MESSAGE_END();	}	g_pGameRules->ClientUserInfoChanged( GetClassPtr((CBasePlayer *)&pEntity->v), infobuffer );}

CInOutRegister *CInOutRegister::Add( CBaseEntity *pValue ){	if (m_hValue == pValue)	{		// it's already in the list, don't need to do anything		return this;	}	else if (m_pNext)	{		// keep looking		m_pNext = m_pNext->Add( pValue );		return this;	}	else	{		// reached the end of the list; add the new entry, and trigger		CInOutRegister *pResult = GetClassPtr( (CInOutRegister*)NULL );		pResult->m_hValue = pValue;		pResult->m_pNext = this;		pResult->m_pField = m_pField;		pResult->pev->classname = MAKE_STRING("zoneent");		m_pField->FireOnEntry( pValue );		return pResult;	}}

void CHostage::SendHostageEventMsg(void){	CBaseEntity *pEntity = NULL;	while ((pEntity = UTIL_FindEntityByClassname(pEntity, "player")) != NULL)	{		if (FNullEnt(pEntity->edict()))			break;		if (!pEntity->IsPlayer())			continue;		if (pEntity->pev->flags == FL_DORMANT)			continue;		CBasePlayer *pPlayer = GetClassPtr((CBasePlayer *)pEntity->pev);		if (pPlayer->pev->deadflag == DEAD_NO && pPlayer->m_iTeam == TEAM_CT)		{			MESSAGE_BEGIN(MSG_ONE, gmsgHostageK, NULL, pPlayer->pev);			WRITE_BYTE(m_iHostageIndex);			MESSAGE_END();		}		if (pPlayer->pev->deadflag == DEAD_NO)			pPlayer->SendHostageIcons();	}}

//=========================================================// Tracking Hornet hit something//=========================================================void CMHornet :: TrackTouch ( edict_t *pOther ){	if ( (pOther == pev->owner) || pOther->v.modelindex == pev->modelindex )	{// bumped into the guy that shot it.		pev->solid = SOLID_NOT;		return;	}   // is this NOT a player and IS a monster?   if (!UTIL_IsPlayer(pOther) && (pOther->v.euser4 != NULL))   {		CMBaseMonster *pMonster = GetClassPtr((CMBaseMonster *)VARS(pOther));		if ( IRelationship( pMonster ) <= R_NO )		{			// hit something we don't want to hurt, so turn around.			pev->velocity = pev->velocity.Normalize();			pev->velocity.x *= -1;			pev->velocity.y *= -1;			pev->origin = pev->origin + pev->velocity * 4; // bounce the hornet off a bit.			pev->velocity = pev->velocity * m_flFlySpeed;			return;		}	}	DieTouch( pOther );}

// Overridden for Gargantua because his swing starts lower as// a percentage of his height (otherwise he swings over the// players head)//=========================================================edict_t* CMGargantua::GargantuaCheckTraceHullAttack(float flDist, int iDamage, int iDmgType){	TraceResult tr;	UTIL_MakeVectors( pev->angles );	Vector vecStart = pev->origin;	vecStart.z += 64;	Vector vecEnd = vecStart + (gpGlobals->v_forward * flDist) - (gpGlobals->v_up * flDist * 0.3);	UTIL_TraceHull( vecStart, vecEnd, dont_ignore_monsters, head_hull, ENT(pev), &tr );		if ( tr.pHit)	{		if ( iDamage > 0 )		{			if (UTIL_IsPlayer(tr.pHit))			{				UTIL_TakeDamage( tr.pHit,pev, pev, iDamage, iDmgType );			}			else if (tr.pHit->v.euser4 != NULL)			{				CMBaseMonster *pMonster = GetClassPtr((CMBaseMonster *)VARS(tr.pHit));				pMonster->TakeDamage(pev, pev,iDamage, iDmgType);			}		}		return tr.pHit;	}	return NULL;}

void CLocalNav::RequestNav(CHostage *pOwner){	if (nodeval > 17 || tot_inqueue)	{		if (tot_inqueue >= MAX_HOSTAGES)		{			CONSOLE_ECHO("queue full/n");			return;		}		int i = qptr;		for (int j = 0; j < tot_inqueue; j++)		{			CHostage *pHostage = GetClassPtr((CHostage *)queue[i]->pev);			if (pHostage == pOwner)				return;			if (++i == MAX_HOSTAGES)				i = 0;		}		queue[i] = pOwner;		tot_inqueue++;	}	else		pOwner->NavReady();}

CGrenade * CGrenade :: ShootSatchelCharge( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity ){	CGrenade *pGrenade = GetClassPtr( (CGrenade *)NULL );	pGrenade->pev->movetype = MOVETYPE_BOUNCE;	pGrenade->pev->classname = MAKE_STRING( "grenade" );		pGrenade->pev->solid = SOLID_BBOX;	SET_MODEL(ENT(pGrenade->pev), "models/grenade.mdl");	// Change this to satchel charge model	UTIL_SetSize(pGrenade->pev, Vector( 0, 0, 0), Vector(0, 0, 0));	pGrenade->pev->dmg = 200;	UTIL_SetOrigin( pGrenade->pev, vecStart );	pGrenade->pev->velocity = vecVelocity;	pGrenade->pev->angles = g_vecZero;	pGrenade->pev->owner = ENT(pevOwner);		// Detonate in "time" seconds	pGrenade->SetThink( &CGrenade::SUB_DoNothing );	pGrenade->SetUse( &CGrenade::DetonateUse );	pGrenade->SetTouch( &CGrenade::SlideTouch );	pGrenade->pev->spawnflags = SF_DETONATE;	pGrenade->pev->friction = 0.9;	return pGrenade;}

bool FEnvSoundInRange( entvars_t *pev, entvars_t *pevTarget, float *pflRange ){	CEnvSound *pSound = GetClassPtr( ( CEnvSound * ) pev );	Vector vecSpot1 = pev->origin + pev->view_ofs;	Vector vecSpot2 = pevTarget->origin + pevTarget->view_ofs;	Vector vecRange;	float flRange;	TraceResult tr;	UTIL_TraceLine( vecSpot1, vecSpot2, ignore_monsters, ENT( pev ), &tr );	// check if line of sight crosses water boundary, or is blocked	if( ( tr.fInOpen && tr.fInWater ) || tr.flFraction != 1 )		return false;	// calc range from sound entity to player	vecRange = tr.vecEndPos - vecSpot1;	flRange = vecRange.Length();	if( pSound->m_flRadius < flRange )		return false;	if( pflRange )		*pflRange = flRange;	return true;}

void CMHornet::DieTouch ( edict_t *pOther ){	if ( pOther && pOther->v.takedamage )	{// do the damage		switch (RANDOM_LONG(0,2))		{// buzz when you plug someone			case 0:	EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_hornethit1.wav", 1, ATTN_NORM);	break;			case 1:	EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_hornethit2.wav", 1, ATTN_NORM);	break;			case 2:	EMIT_SOUND( ENT(pev), CHAN_VOICE, "hornet/ag_hornethit3.wav", 1, ATTN_NORM);	break;		}		if (UTIL_IsPlayer(pOther))			UTIL_TakeDamage( pOther, pev, VARS( pev->owner ), pev->dmg, DMG_BULLET );		else if (pOther->v.euser4 != NULL)		{			CMBaseMonster *pMonster = GetClassPtr((CMBaseMonster *)VARS(pOther));			pMonster->TakeDamage( pev, VARS( pev->owner ), pev->dmg, DMG_BULLET );		}	}	pev->modelindex = 0;// so will disappear for the 0.1 secs we wait until NEXTTHINK gets rid	pev->solid = SOLID_NOT;	SetThink ( SUB_Remove );	pev->nextthink = gpGlobals->time + 1;// stick around long enough for the sound to finish!}

CGrenade *CGrenade::ShootContact( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity ){	CGrenade *pGrenade = GetClassPtr( (CGrenade *)NULL );	pGrenade->Spawn();	// contact grenades arc lower	pGrenade->pev->gravity = 0.5;// lower gravity since grenade is aerodynamic and engine doesn't know it.	UTIL_SetOrigin( pGrenade->pev, vecStart );	pGrenade->pev->velocity = vecVelocity;	pGrenade->pev->angles = UTIL_VecToAngles (pGrenade->pev->velocity);	pGrenade->pev->owner = ENT(pevOwner);		// make monsters afaid of it while in the air	pGrenade->SetThink( &CGrenade::DangerSoundThink );	pGrenade->pev->nextthink = gpGlobals->time;		// Tumble in air	pGrenade->pev->avelocity.x = RANDOM_FLOAT ( -100, -500 );		// Explode on contact	pGrenade->SetTouch( &CGrenade::ExplodeTouch );	pGrenade->pev->dmg = gSkillData.plrDmgM203Grenade;	return pGrenade;}

CGrenade* CGrenade::ShootTimed2( entvars_t *pevOwner, Vector vecStart, Vector vecVelocity, float time, int team, unsigned short usEvent ){    CGrenade *pGrenade = GetClassPtr( (CGrenade *)NULL );    pGrenade->Spawn();    UTIL_SetOrigin( pGrenade->pev, vecStart );    pGrenade->pev->velocity	= vecVelocity;    pGrenade->pev->angles	= pevOwner->angles;    pGrenade->pev->owner	= ENT( pevOwner );    pGrenade->m_usEvent	= usEvent;    pGrenade->SetTouch( &CGrenade::BounceTouch );    pGrenade->SetThink( &CGrenade::TumbleThink );    pGrenade->pev->dmgtime	= gpGlobals->time + time;    pGrenade->pev->nextthink= gpGlobals->time + 0.1;    pGrenade->pev->sequence	= RANDOM_LONG( 3, 6 );    pGrenade->pev->framerate= 1.0;    pGrenade->m_fJustBlew	= TRUE;    pGrenade->m_iTeam		= team;    pGrenade->pev->gravity	= 0.55;    pGrenade->pev->friction = 0.70;    pGrenade->pev->dmg		= 100;    SET_MODEL( ENT( pGrenade->pev ), "models/w_hegrenade.mdl" );    return pGrenade;}

void CTriggerHurt :: Think( void ){	edict_t *pentPlayer;	CBasePlayer *pPlayer = NULL;	float flRange;	entvars_t *pevTarget;	Vector vecSpot1;	Vector vecSpot2;	Vector vecRange;	Vector origin;	Vector view_ofs;	origin = pev->origin;	view_ofs = pev->view_ofs;	pev->origin = (pev->absmin + pev->absmax) * 0.5;	pev->view_ofs = pev->view_ofs * 0.0;	pentPlayer = FIND_CLIENT_IN_PVS(edict());	pev->origin = origin;	pev->view_ofs = view_ofs;	if (!FNullEnt(pentPlayer))	{		pPlayer = GetClassPtr( (CBasePlayer *)VARS(pentPlayer));		pevTarget = VARS(pentPlayer);		vecSpot1 = (pev->absmin + pev->absmax) * 0.5;		vecSpot2 = (pevTarget->absmin + pevTarget->absmax) * 0.5;		vecRange = vecSpot1 - vecSpot2;		flRange = vecRange.Length();		if (pPlayer->m_flgeigerRange >= flRange) pPlayer->m_flgeigerRange = flRange;	}	SetNextThink( 0.25 );}

CGrenade *CGrenade::ShootSatchelCharge(entvars_t *pevOwner, Vector vecStart, Vector vecVelocity)	// Last check: 2013, May 28{	CGrenade *pGrenade = GetClassPtr((CGrenade*)NULL);	pGrenade->pev->movetype	= MOVETYPE_TOSS;	pGrenade->pev->solid	= SOLID_BBOX;	if (pGrenade->pev->classname)		RemoveEntityHashValue(pGrenade->pev, STRING(pGrenade->pev->classname), CLASSNAME);	pGrenade->pev->classname = MAKE_STRING("grenade");	AddEntityHashValue(pGrenade->pev, STRING(pGrenade->pev->classname), CLASSNAME);	SET_MODEL(ENT(pGrenade->pev), "models/w_c4.mdl");	UTIL_SetSize(pGrenade->pev, Vector(3, 6, 8), Vector(-3, -6, 0));	UTIL_SetOrigin(pGrenade->pev, vecStart);	pGrenade->pev->dmg		= 100;	pGrenade->pev->angles	= vecVelocity;	pGrenade->pev->velocity = g_vecZero;	pGrenade->pev->owner	= ENT(pevOwner);	pGrenade->SetThink(&CGrenade::C4Think);	pGrenade->SetTouch(&CGrenade::C4Touch);	pGrenade->pev->spawnflags = SF_DETONATE;	pGrenade->pev->nextthink  = gpGlobals->time + 0.1;	pGrenade->m_flC4Blow			= gpGlobals->time + g_pGameRules->m_iC4Timer;	pGrenade->m_flNextFreqInterval	= g_pGameRules->m_iC4Timer / 4;	pGrenade->m_flNextFreq			= gpGlobals->time;	pGrenade->m_flNextBeep			= gpGlobals->time + 0.5;	pGrenade->m_flNextBlink			= gpGlobals->time + 2.0;	pGrenade->m_iCurWave	= 0;	pGrenade->m_fAttenu		= 0;	pGrenade->m_sBeepName	= NULL;	pGrenade->m_fNextDefuse = 0;	pGrenade->m_bIsC4		= true;	pGrenade->m_bStartDefuse= false;	pGrenade->m_bJustBlew	= false;	pGrenade->pev->friction = 0.9;	if (!FNullEnt(pevOwner))	{		CBasePlayer *pPlayer = (CBasePlayer*)Instance(pevOwner);		if (pPlayer->IsPlayer())			pGrenade->m_pentCurBombTarget = pPlayer->m_pentCurBombTarget;	}	else		pGrenade->m_pentCurBombTarget = NULL;	return pGrenade;}

void CLocusVariable::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ){	Vector vecPos = g_vecZero;	Vector vecDir = g_vecZero;	float fRatio = 0;	if (m_iszPosition)		vecPos = CalcLocus_Position(this, pActivator, STRING(m_iszPosition));	if (m_iszVelocity)		vecDir = CalcLocus_Velocity(this, pActivator, STRING(m_iszVelocity));	if (m_iszRatio)		fRatio = CalcLocus_Ratio(pActivator, STRING(m_iszRatio));	if (m_iszTargetName)	{		CMark *pMark = GetClassPtr( (CMark*)NULL );		pMark->pev->classname = MAKE_STRING("mark");		pMark->pev->origin = vecPos;		pMark->pev->movedir = vecDir;		pMark->pev->frags = fRatio;		pMark->pev->targetname = m_iszTargetName;		pMark->SetNextThink(m_fDuration);		FireTargets(STRING(m_iszFireOnSpawn), pMark, this, USE_TOGGLE, 0);	}	else	{		pev->origin = vecPos;		pev->movedir = vecDir;		pev->frags = fRatio;		FireTargets(STRING(m_iszFireOnSpawn), this, this, USE_TOGGLE, 0);	}}

void ScriptEntityCancel(edict_t *pentCine){	// make sure they are a scripted_sequence	if(FClassnameIs(pentCine, CLASSNAME))	{		CCineMonster *pCineTarget = GetClassPtr((CCineMonster *)VARS(pentCine));		// make sure they have a monster in mind for the script		CBaseEntity * pEntity = pCineTarget->m_hTargetEnt;		CBaseMonster *pTarget = NULL;		if(pEntity)			pTarget = pEntity->MyMonsterPointer();		if(pTarget)		{			// make sure their monster is actually playing a script			if(pTarget->m_MonsterState == MONSTERSTATE_SCRIPT)			{				// tell them do die				pTarget->m_scriptState = CCineMonster::SCRIPT_CLEANUP;				// do it now				pTarget->CineCleanup();			}		}	}}

void CLocalNav::RequestNav(CHostage *pCaller){	int curr = qptr;	int found = 0;	if (nodeval <= 17 && !tot_inqueue)	{		pCaller->NavReady();		return;	}	if (tot_inqueue >= MAX_HOSTAGES_NAV)	{		return;	}	for (int i = 0; i < tot_inqueue; ++i)	{		CHostage *pQueueItem = GetClassPtr((CHostage *)_queue[curr]->pev);		if (pQueueItem == pCaller)			return;		if (++curr == MAX_HOSTAGES_NAV)			curr = 0;	}	_queue[curr] = pCaller;	++tot_inqueue;}

void CLocalNav::HostagePrethink(void){	for (int i = 0; i < tot_hostages; i++)	{		if (hostages[i] != NULL)			GetClassPtr((CHostage *)hostages[i]->pev)->PreThink();	}}

void CGib :: SpawnHeadGib( entvars_t *pevVictim ){	CGib *pGib = GetClassPtr( (CGib *)NULL );	if ( g_Language == LANGUAGE_GERMAN )	{		pGib->Spawn( "models/germangibs.mdl" );// throw one head		pGib->pev->body = 0;	}	else	{		pGib->Spawn( "models/hgibs.mdl" );// throw one head		pGib->pev->body = 0;	}	if ( pevVictim )	{		pGib->pev->origin = pevVictim->origin + pevVictim->view_ofs;				edict_t		*pentPlayer = FIND_CLIENT_IN_PVS( pGib->edict() );				if ( RANDOM_LONG ( 0, 100 ) <= 5 && pentPlayer )		{			// 5% chance head will be thrown at player's face.			entvars_t	*pevPlayer;			pevPlayer = VARS( pentPlayer );			pGib->pev->velocity = ( ( pevPlayer->origin + pevPlayer->view_ofs ) - pGib->pev->origin ).Normalize() * 300;			pGib->pev->velocity.z += 100;		}		else		{			pGib->pev->velocity = Vector (RANDOM_FLOAT(-100,100), RANDOM_FLOAT(-100,100), RANDOM_FLOAT(200,300));		}		pGib->pev->avelocity.x = RANDOM_FLOAT ( 100, 200 );		pGib->pev->avelocity.y = RANDOM_FLOAT ( 100, 300 );		// copy owner's blood color		pGib->m_bloodColor = (CBaseEntity::Instance(pevVictim))->BloodColor();			if ( pevVictim->health > -50)		{			pGib->pev->velocity = pGib->pev->velocity * 0.7;		}		else if ( pevVictim->health > -200)		{			pGib->pev->velocity = pGib->pev->velocity * 2;		}		else		{			pGib->pev->velocity = pGib->pev->velocity * 4;		}	}	pGib->LimitVelocity();}

//=========================================================//=========================================================CLaserSpot *CLaserSpot::CreateSpot( void ){	CLaserSpot *pSpot = GetClassPtr( (CLaserSpot *)NULL );	pSpot->Spawn();	pSpot->pev->classname = MAKE_STRING("laser_spot");	return pSpot;}

CCrossbowBolt *CCrossbowBolt::BoltCreate( void ){	// Create a new entity with CCrossbowBolt private data	CCrossbowBolt *pBolt = GetClassPtr( (CCrossbowBolt *)NULL );	pBolt->pev->classname = MAKE_STRING("bolt");	pBolt->Spawn();	return pBolt;}

CLaserSpotTEST *CLaserSpotTEST::CreateSpotTEST( void ){CLaserSpotTEST *pSpot = GetClassPtr( (CLaserSpotTEST *)NULL );pSpot->Spawn();pSpot->pev->classname = MAKE_STRING("laser_spot_TEST");return pSpot;}

//=========================================================//=========================================================CEagleLaser *CEagleLaser::CreateSpotDeagle( void ){	CEagleLaser *pEagleLaser = GetClassPtr( (CEagleLaser *)NULL );	pEagleLaser->Spawn();	pEagleLaser->pev->classname = MAKE_STRING("eagle_laser");	return pEagleLaser;}

void CBaseDelay :: SUB_UseTargets( CBaseEntity *pActivator, USE_TYPE useType, float value ){	//	// exit immediatly if we don't have a target or kill target	//	if (FStringNull(pev->target) && !m_iszKillTarget)		return;	//	// check for a delay	//	if (m_flDelay != 0)	{		// create a temp object to fire at a later time		CBaseDelay *pTemp = GetClassPtr( (CBaseDelay *)NULL);		pTemp->pev->classname = MAKE_STRING("DelayedUse");		pTemp->SetNextThink( m_flDelay );		pTemp->SetThink(&CBaseDelay:: DelayThink );				// Save the useType		pTemp->pev->button = (int)useType;		pTemp->m_iszKillTarget = m_iszKillTarget;		pTemp->m_flDelay = 0; // prevent "recursion"		pTemp->pev->target = pev->target;		//LRC - Valve had a hacked thing here to avoid breaking		// save/restore. In Spirit that's not a problem.		// I've moved m_hActivator into this class, for the "elegant" fix.		pTemp->m_hActivator = pActivator;		return;	}	//	// kill the killtargets	//	if ( m_iszKillTarget )	{		edict_t *pentKillTarget = NULL;		ALERT( at_aiconsole, "KillTarget: %s/n", STRING(m_iszKillTarget) );		//LRC- now just USE_KILLs its killtarget, for consistency.		FireTargets( STRING(m_iszKillTarget), pActivator, this, USE_KILL, 0);	}		//	// fire targets	//	if (!FStringNull(pev->target))	{		FireTargets( STRING(pev->target), pActivator, this, useType, value );	}}

CBeam *CBeam::BeamCreate( const char *pSpriteName, int width ){	// Create a new entity with CBeam private data	CBeam *pBeam = GetClassPtr( ( CBeam * ) NULL );	pBeam->pev->classname = MAKE_STRING( "beam" );	pBeam->BeamInit( pSpriteName, width );	return pBeam;}