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

bool CPropVehicleManhack::CanEnterVehicle( CBaseEntity *pEntity ){	// Prevent entering if the vehicle's being driven by an NPC	if ( GetDriver() && GetDriver() != pEntity )		return false;	return true; }

//-----------------------------------------------------------------------------// Purpose: Return true of the player's allowed to enter / exit the vehicle//-----------------------------------------------------------------------------bool CPropCrane::CanEnterVehicle( CBaseEntity *pEntity ){	// Prevent entering if the vehicle's being driven by an NPC	if ( GetDriver() && GetDriver() != pEntity )		return false;		// Prevent entering if the vehicle's locked	return ( !m_bLocked );}

//-----------------------------------------------------------------------------// Purpose: Return true of the player's allowed to enter / exit the vehicle//-----------------------------------------------------------------------------bool CPropVehicleChoreoGeneric::CanEnterVehicle( CBaseEntity *pEntity ){	// Prevent entering if the vehicle's being driven by an NPC	if ( GetDriver() && GetDriver() != pEntity )		return false;	// Prevent entering if the vehicle's locked	return !m_bLocked;}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CPropVehicleManhack::Think(void){	if ( GetDriver() )	{		if (GlobalEntity_GetState("manhacks_not_controllable") == GLOBAL_ON)			ForcePlayerOut();		BaseClass::Think();		SetNextThink( gpGlobals->curtime );		StudioFrameAdvance();		if (m_hManhack == NULL || m_iManhackHealth <= 0 || m_iManhackDistance >= 100)		{			if (m_iManhackDistance >= 100)			{				CNPC_Manhack *pManhack = m_hManhack;				if (pManhack)				{					pManhack->ComeBackToPlayer(m_hPlayer, 8.0f);				}			}			/*if (!FindNextManhack())			{				SetLocator( NULL );				ForcePlayerOut();				DestroyAllManhacks();				UTIL_Remove(this);			}*/			if (!FindNextManhack(true))			{				ForcePlayerOut();			}		} 		else if ( m_hPlayer.Get() != NULL )		{			UpdateManhackView( m_hPlayer.Get() );				UpdateManhackDistance(this);		}		if (!GetDriver() && m_bHadDriver)		{			DevMsg("We have no driver, lets disappear");			m_bHadDriver = false;			//SetRenderMode(kRenderTransColor );			//SetRenderColorA(0);			AddEffects( EF_NODRAW );			SetSolid(SOLID_NONE);			AddSolidFlags( FSOLID_NOT_SOLID );		}	}}

//TERO: We want to take damage normally since this is not really a vehicle but a fake body//		We exit the vehicle so that it wouldn't look silly stiff man from the manhack point of viewint CPropVehicleManhack::OnTakeDamage( const CTakeDamageInfo &inputInfo ){	//Check to do damage to driver	if ( GetDriver() )	{		GetDriver()->TakeDamage( inputInfo );		ForcePlayerOut();	}	return 0;}

//-----------------------------------------------------------------------------// Purpose: Return true of the player's allowed to enter the vehicle//-----------------------------------------------------------------------------bool CPropVehicleDriveable::CanEnterVehicle( CBaseEntity *pEntity ){	// Prevent entering if the vehicle's being driven by an NPC	if ( GetDriver() && GetDriver() != pEntity )		return false;	if ( IsOverturned() )		return false;	// Prevent entering if the vehicle's locked, or if it's moving too fast.	return ( !m_bLocked && (m_nSpeed <= m_flMinimumSpeedToEnterExit) );}

CClientPlayer * CClientVehicle::GetOccupant(BYTE byteSeatId){	if(byteSeatId == 0)		return GetDriver();	return GetPassenger(byteSeatId - 1);}

void GaussianBlurRender::Render(Engine& engine, IDirect3DSurface9* backBuffer, IDirect3DSurface9* dsSurface){	if (!_shader || !GetRT() || !GetRT()->IsInit() || !_colorTex)		throw int();	_shader->Apply(engine);	IDirect3DSurface9* targetSurf;	GetRT()->GetTex()->GetSurfaceLevel(0, &targetSurf);	GetDriver().GetDevice()->SetRenderTarget(0, targetSurf);	engine.SetTexture(0, _colorTex->GetTex());	//Horizontal	_shader->curTechnique = GaussianBlurShader::ttHorizontal;	engine.BeginDraw();	DrawScreenQuad(engine);	engine.EndDraw();	//Vertical	_shader->curTechnique = GaussianBlurShader::ttVertical;	engine.BeginDraw();	DrawScreenQuad(engine);	engine.EndDraw();	_shader->UnApply(engine);	engine.SetTexture(0, 0);	}

CPlayerEntity * CVehicleEntity::GetOccupant(BYTE byteSeatId){	if(byteSeatId == 0)		return GetDriver();	return new CPlayerEntity(); //GetPassenger(byteSeatId - 1);}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CPropVehicleDriveable::Think(){	BaseClass::Think();	// Always think if we have any driver in us	if ( GetDriver() )	{		SetNextThink( gpGlobals->curtime );	}	// If we have an NPC Driver, tell him to drive	if ( m_hNPCDriver )	{		GetServerVehicle()->NPC_DriveVehicle();	}	// Keep thinking while we're waiting to turn off the keep upright	if ( m_flTurnOffKeepUpright )	{		SetNextThink( gpGlobals->curtime );		// Time up?		if ( m_hKeepUpright && m_flTurnOffKeepUpright < gpGlobals->curtime && m_hKeepUpright )		{			variant_t emptyVariant;			m_hKeepUpright->AcceptInput( "TurnOff", this, this, emptyVariant, USE_TOGGLE );			m_flTurnOffKeepUpright = 0;			UTIL_Remove( m_hKeepUpright );		}	}}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CPropVehicleViewController::InputForcePlayerOut( inputdata_t &inputdata ){	if ( !GetDriver() )		return;	GetServerVehicle()->HandlePassengerExit( m_hPlayer );}

void CVehicleEntity::Interpolate(){	// Do we have a driver?	if(GetDriver())	{		// Update our target position		UpdateTargetPosition();		// Update our target rotation		UpdateTargetRotation();		// Update our interior		UpdateInterior(true);	}	else	{		// Update our interior		UpdateInterior(false);		// Remove our target position		RemoveTargetPosition();		// Remove our target rotation		RemoveTargetRotation();	}}

void UUnitTestNetConnection::HandleClientPlayer(class APlayerController* PC, class UNetConnection* NetConnection){	// Implement only essential parts of the original function, as we want to block most of it (triggers level change code)	PC->Role = ROLE_AutonomousProxy;	PC->NetConnection = NetConnection;	PlayerController = PC;	OwningActor = PC;	// @todo #JohnBReview: This might cause undesirable behaviour, if - for example - HandleDisconnect gets called by	//				RPC's, so may want to create a fake localplayer instead	PC->Player = GEngine->GetFirstGamePlayer(NUTUtil::GetPrimaryWorld());	// Sometimes, e.g. when executing in a commandlet, there is no available player, and one has to be created	if (PC->Player == NULL)	{		// Do nothing, other than just create the raw object		PC->Player = NewObject<ULocalPlayer>(GEngine, GEngine->LocalPlayerClass);	}	// Pass on notification	UNetDriver* CurDriver = GetDriver();	FNetworkNotifyHook* NotifyHook = (Driver != NULL ? (FNetworkNotifyHook*)CurDriver->Notify : NULL);	if (NotifyHook != NULL)	{		NotifyHook->NotifyHandleClientPlayer(PC, NetConnection);	}}

bool UDemoNetConnection::ClientHasInitializedLevelFor(const UObject* TestObject) const{	// We save all currently streamed levels into the demo stream so we can force the demo playback client	// to stay in sync with the recording server	// This may need to be tweaked or re-evaluated when we start recording demos on the client	return ( GetDriver()->DemoFrameNum > 2 || Super::ClientHasInitializedLevelFor( TestObject ) );}

void unregister_cdrom(int drive){	int device = GetDriver(drive);	if (device >= 4)		return;	cd_drives[drive] = -1;	numDrives--;}

//-----------------------------------------------------------------------------//-----------------------------------------------------------------------------bool CPropAPC::ShouldAttractAutoAim( CBaseEntity *pAimingEnt ){	if( IsXbox() && pAimingEnt->IsPlayer() && GetDriver() )	{		return true;	}	return BaseClass::ShouldAttractAutoAim( pAimingEnt );}

//-----------------------------------------------------------------------------// Purpose: // The player takes damage if he hits something going fast enough//-----------------------------------------------------------------------------void CPropVehicleDriveable::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent ){	// Don't care if we don't have a driver	if ( !GetDriver() )		return;	// Make sure we don't keep hitting the same entity	int otherIndex = !index;	CBaseEntity *pHitEntity = pEvent->pEntities[otherIndex];	if ( pEvent->deltaCollisionTime < 0.5 && (pHitEntity == this) )		return;	BaseClass::VPhysicsCollision( index, pEvent );	// If we hit hard enough, damage the player	// Don't take damage from ramming bad guys	if ( pHitEntity->MyNPCPointer() )		return;	// Don't take damage from ramming ragdolls	if ( pEvent->pObjects[otherIndex]->GetGameFlags() & FVPHYSICS_PART_OF_RAGDOLL )		return;	// Ignore func_breakables	CBreakable *pBreakable = dynamic_cast<CBreakable *>(pHitEntity);	if ( pBreakable )	{		// ROBIN: Do we want to only do this on func_breakables that are about to die?		//if ( pBreakable->HasSpawnFlags( SF_PHYSICS_BREAK_IMMEDIATELY ) )		return;	}	// Over our skill's minimum crash level?	int damageType = 0;	float flDamage = CalculatePhysicsImpactDamage( index, pEvent, gDefaultPlayerVehicleImpactDamageTable, 1.0, true, damageType );	if ( flDamage > 0 )	{		Vector damagePos;		pEvent->pInternalData->GetContactPoint( damagePos );		Vector damageForce = pEvent->postVelocity[index] * pEvent->pObjects[index]->GetMass();		CTakeDamageInfo info( this, GetDriver(), damageForce, damagePos, flDamage, damageType );		GetDriver()->TakeDamage( info );	}}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------int CASW_PropJeep::OnTakeDamage( const CTakeDamageInfo &inputInfo ){	//Do scaled up physics damage to the car	CTakeDamageInfo info = inputInfo;	info.ScaleDamage( 25 );		// HACKHACK: Scale up grenades until we get a better explosion/pressure damage system	if ( inputInfo.GetDamageType() & DMG_BLAST )	{		info.SetDamageForce( inputInfo.GetDamageForce() * 10 );	}	VPhysicsTakeDamage( info );	// reset the damage	info.SetDamage( inputInfo.GetDamage() );	// small amounts of shock damage disrupt the car, but aren't transferred to the player	if ( info.GetDamageType() == DMG_SHOCK )	{		if ( info.GetDamage() <= 10 )		{			// take 10% damage and make the engine stall			info.ScaleDamage( 0.1 );			m_throttleDisableTime = gpGlobals->curtime + 2;		}	}	//Check to do damage to driver	if ( GetDriver() )	{		//Take no damage from physics damages		if ( info.GetDamageType() & DMG_CRUSH )			return 0;		// Take the damage (strip out the DMG_BLAST)		info.SetDamageType( info.GetDamageType() & (~DMG_BLAST) );		GetDriver()->TakeDamage( info );	}	return 0;}

void UDemoNetConnection::LowLevelSend( void* Data, int32 Count ){	if ( Count == 0 )	{		UE_LOG( LogDemo, Warning, TEXT( "UDemoNetConnection::LowLevelSend: Ignoring empty packet." ) );		return;	}	if ( Count > MAX_DEMO_READ_WRITE_BUFFER )	{		UE_LOG( LogDemo, Fatal, TEXT( "UDemoNetConnection::LowLevelSend: Count > MAX_DEMO_READ_WRITE_BUFFER." ) );	}	if ( !GetDriver()->ServerConnection && GetDriver()->FileAr )	{		// If we're outside of an official demo frame, we need to queue this up or it will throw off the stream		if ( !GetDriver()->bIsRecordingDemoFrame )		{			FQueuedDemoPacket & B = *( new( QueuedDemoPackets )FQueuedDemoPacket );			B.Data.AddUninitialized( Count );			FMemory::Memcpy( B.Data.GetData(), Data, Count );			return;		}		*GetDriver()->FileAr << Count;		GetDriver()->FileAr->Serialize( Data, Count );		#if DEMO_CHECKSUMS == 1		uint32 Checksum = FCrc::MemCrc32( Data, Count, 0 );		*GetDriver()->FileAr << Checksum;#endif	}}

void UDemoNetConnection::FlushNet( bool bIgnoreSimulation ){	// in playback, there is no data to send except	// channel closing if an error occurs.	if ( GetDriver()->ServerConnection != NULL )	{		InitSendBuffer();	}	else	{		Super::FlushNet( bIgnoreSimulation );	}}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CASW_PropJeep::CheckWaterLevel( void ){	CBaseEntity *pEntity = GetDriver();	if ( pEntity && pEntity->IsPlayer() )	{		CBasePlayer *pPlayer = static_cast<CBasePlayer*>( pEntity );				Vector vecAttachPoint;		QAngle vecAttachAngles;				// Check eyes. (vehicle_driver_eyes point)		int iAttachment = LookupAttachment( "vehicle_driver_eyes" );		GetAttachment( iAttachment, vecAttachPoint, vecAttachAngles );		// Add the jeep's Z view offset		Vector vecUp;		AngleVectors( vecAttachAngles, NULL, NULL, &vecUp );		vecUp.z = clamp( vecUp.z, 0.0f, vecUp.z );		vecAttachPoint.z += r_JeepViewZHeight.GetFloat() * vecUp.z;		bool bEyes = ( UTIL_PointContents( vecAttachPoint, MASK_WATER ) & MASK_WATER ) ? true : false;		if ( bEyes )		{			pPlayer->SetWaterLevel( WL_Eyes );			return;		}		// Check waist.  (vehicle_engine point -- see parent function).		if ( m_WaterData.m_bBodyInWater )		{			pPlayer->SetWaterLevel( WL_Waist );			return;		}		// Check feet. (vehicle_feet_passenger0 point)		iAttachment = LookupAttachment( "vehicle_feet_passenger0" );		GetAttachment( iAttachment, vecAttachPoint, vecAttachAngles );		bool bFeet = ( UTIL_PointContents( vecAttachPoint, MASK_WATER ) & MASK_WATER ) ? true : false;		if ( bFeet )		{			pPlayer->SetWaterLevel( WL_Feet );			return;		}		// Not in water.		pPlayer->SetWaterLevel( WL_NotInWater );	}}

static int ReadSectors(int drive, Bit32u sector, Bit16u num, unsigned char *buf){	unsigned char req_buf[24];	unsigned save_ax = _AX;	int error;	Bit8u driver = GetDriver(drive);	if (driver >= 4)		return MSCDEX_ERROR_UNKNOWN_DRIVE;	*CALC_PTR(req_buf, MSCD_READ_STARTSECTOR, u_long) = sector;	*CALC_PTR(req_buf, MSCD_READ_ADRESSING, u_char) = 0;	*CALC_PTR(req_buf, MSCD_READ_NUMSECTORS, u_short) = num;	_AH = 2 | (driver << 6);	cdrom_helper(req_buf, buf);	error = _AL == 0 ? 0 : MSCDEX_ERROR_DRIVE_NOT_READY;	_AX = save_ax;	return error;}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CPropVehicleChoreoGeneric::Think(void){	SetNextThink( gpGlobals->curtime + 0.1 );	if ( GetDriver() )	{		BaseClass::Think();				// If the enter or exit animation has finished, tell the server vehicle		if ( IsSequenceFinished() && (m_bExitAnimOn || m_bEnterAnimOn) )		{			GetServerVehicle()->HandleEntryExitFinish( m_bExitAnimOn, true );		}	}	StudioFrameAdvance();	DispatchAnimEvents( this );}

//-----------------------------------------------------------------------------// Purpose: // Input  : pPlayer - //-----------------------------------------------------------------------------void CChoreoGenericServerVehicle::ItemPostFrame( CBasePlayer *player ){	Assert( player == GetDriver() );	GetDrivableVehicle()->ItemPostFrame( player );	if (( player->m_afButtonPressed & IN_USE ) || GetVehicle()->ShouldForceExit() )	{		GetVehicle()->ClearForcedExit();		if ( GetDrivableVehicle()->CanExitVehicle(player) )		{			// Let the vehicle try to play the exit animation			if ( !HandlePassengerExit( player ) && ( player != NULL ) )			{				player->PlayUseDenySound();			}		}	}}

void UDemoNetConnection::HandleClientPlayer( APlayerController* PC, UNetConnection* NetConnection ){	Super::HandleClientPlayer( PC, NetConnection );	// Assume this is our special spectator controller	GetDriver()->SpectatorController = PC;	for ( FActorIterator It( Driver->World ); It; ++It)	{		if ( It->IsA( APlayerStart::StaticClass() ) )		{			PC->SetInitialLocationAndRotation( It->GetActorLocation(), It->GetActorRotation() );			if ( PC->GetPawn() )			{				PC->GetPawn()->TeleportTo( It->GetActorLocation(), It->GetActorRotation(), false, true );			}			break;		}	}}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CASW_PropJeep::HandleWater( void ){	// Only check the wheels and engine in water if we have a driver (player).	if ( !GetDriver() )		return;	// Check to see if we are in water.	if ( CheckWater() )	{		for ( int iWheel = 0; iWheel < ASW_JEEP_WHEEL_COUNT; ++iWheel )		{			// Create an entry/exit splash!			if ( m_WaterData.m_bWheelInWater[iWheel] != m_WaterData.m_bWheelWasInWater[iWheel] )			{				CreateSplash( m_WaterData.m_vecWheelContactPoints[iWheel] );				CreateRipple( m_WaterData.m_vecWheelContactPoints[iWheel] );			}						// Create ripples.			if ( m_WaterData.m_bWheelInWater[iWheel] && m_WaterData.m_bWheelWasInWater[iWheel] )			{				if ( m_WaterData.m_flNextRippleTime[iWheel] < gpGlobals->curtime )				{					// Stagger ripple times					m_WaterData.m_flNextRippleTime[iWheel] = gpGlobals->curtime + RandomFloat( 0.1, 0.3 );					CreateRipple( m_WaterData.m_vecWheelContactPoints[iWheel] );				}			}		}	}	// Save of data from last think.	for ( int iWheel = 0; iWheel < ASW_JEEP_WHEEL_COUNT; ++iWheel )	{		m_WaterData.m_bWheelWasInWater[iWheel] = m_WaterData.m_bWheelInWater[iWheel];	}}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CPropCrane::Think(void){	SetNextThink( gpGlobals->curtime + 0.1 );	if ( GetDriver() )	{		BaseClass::Think();				if ( m_hNPCDriver )		{			GetServerVehicle()->NPC_DriveVehicle();		}		// play enter animation		StudioFrameAdvance();		// If the enter or exit animation has finished, tell the server vehicle		if ( IsSequenceFinished() && (m_bExitAnimOn || m_bEnterAnimOn) )		{			if ( m_bEnterAnimOn )			{				// Finished entering, display the hint for using the crane				UTIL_HudHintText( m_hPlayer, "#Valve_Hint_CraneKeys" );			}						GetServerVehicle()->HandleEntryExitFinish( m_bExitAnimOn, true );		}	}	else	{		// Run the crane's movement		RunCraneMovement( 0.1 );	}	// Update follower bones	m_BoneFollowerManager.UpdateBoneFollowers(this);}