C++ UserMessageBegin函数代码示例

	void SendHelp( CGEPlayer *pPlayer )
	{
		if ( !pPlayer || pPlayer->IsBotPlayer() )
			return;

		CSingleUserRecipientFilter filter( pPlayer );
		filter.MakeReliable();

		// Send overall scenario help information
		UserMessageBegin( filter, "ScenarioHelp" );
			WRITE_STRING( GEGameplay()->GetScenario()->GetIdent() );
			WRITE_STRING( m_szHelpTagLine );
			WRITE_STRING( m_szHelpWebsite );
			WRITE_BYTE( m_iDefaultPane );
		MessageEnd();

		// Output each help item from each pane
		FOR_EACH_MAP( m_vHelpPanes, idx )
		{
			sHelpPane *pPane = m_vHelpPanes[idx];

			if ( pPane->nHelpString == INVALID_STRING_INDEX )
			{
				bool save = engine->LockNetworkStringTables( false );
				pPane->nHelpString = g_pStringTableGameplay->AddString( true, pPane->szHelpString );
				engine->LockNetworkStringTables( save );
			}

			UserMessageBegin( filter, "ScenarioHelpPane" );
				WRITE_BYTE( m_vHelpPanes.Key(idx) );
				WRITE_STRING( pPane->szHelpId );
				WRITE_SHORT( pPane->nHelpString );
			MessageEnd();
		}

//-----------------------------------------------------------------------------
// Purpose: Input handler for showing the message and/or playing the sound.
//-----------------------------------------------------------------------------
void CEnvHudHint::InputShowHudHint( inputdata_t &inputdata )
{
	if ( AllPlayers() )
	{
		CReliableBroadcastRecipientFilter user;
		UserMessageBegin( user, "KeyHintText" );
		WRITE_BYTE( 1 );	// one message
		WRITE_STRING( STRING(m_iszMessage) );
		MessageEnd();
	}
	else
	{
		CBaseEntity *pPlayer = NULL;
		if ( inputdata.pActivator && inputdata.pActivator->IsPlayer() )
		{
			pPlayer = inputdata.pActivator;
		}
		else
		{
			pPlayer = UTIL_GetNearestPlayer(GetAbsOrigin());
		}

		if ( !pPlayer || !pPlayer->IsNetClient() )
			return;

		CSingleUserRecipientFilter user( (CBasePlayer *)pPlayer );
		user.MakeReliable();
		UserMessageBegin( user, "KeyHintText" );
			WRITE_BYTE( 1 );	// one message
			WRITE_STRING( STRING(m_iszMessage) );
		MessageEnd();
	}
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CEnvHudHint::InputHideHudHint( inputdata_t &inputdata )
{
	CBaseEntity *pPlayer = NULL;

	if ( inputdata.pActivator && inputdata.pActivator->IsPlayer() )
	{
		pPlayer = inputdata.pActivator;
	}
	else
	{
#ifdef HL2SB
		pPlayer = UTIL_GetNearestPlayer( GetAbsOrigin() );
#else
		pPlayer = UTIL_GetLocalPlayer();
#endif
	}

	if ( pPlayer )
	{
		if ( !pPlayer || !pPlayer->IsNetClient() )
			return;

		CSingleUserRecipientFilter user( (CBasePlayer *)pPlayer );
		user.MakeReliable();
		UserMessageBegin( user, "KeyHintText" );
		WRITE_BYTE( 1 );	// one message
		WRITE_STRING( STRING(NULL_STRING) );
		MessageEnd();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *player - 
//			effect - 
//			params - 
//-----------------------------------------------------------------------------
void CForceFeedback::StartEffect( CBasePlayer *player, FORCEFEEDBACK_t effect, const FFBaseParams_t& params )
{
	if ( !player )
	{
		return;
	}

	CSingleUserRecipientFilter user( player );

	UserMessageBegin( user, "ForceFeedback" );

		WRITE_BYTE( FFMSG_START ); // Reset effects
		WRITE_BYTE( effect );

		// encode direction as a byte
		int dir = (int)( ( params.m_flDirection / 360.0f ) * 255.0f );
		WRITE_BYTE( dir );

		// encode duration as a signed int
		int duration = (int)params.m_flDuration * 1000.0f;
		WRITE_LONG( duration );
		
		// encode gain as a byte
		byte gain = (byte)clamp( params.m_flGain * 255.0f, 0.0f, 255.0f );

		WRITE_BYTE( gain );
		WRITE_BYTE( params.m_nPriority );
		WRITE_BYTE( params.m_bSolo ? 1 : 0 );

	MessageEnd();
}

void HapticMsg_MeleeContact(CBasePlayer* pPlayer)
{
	CSingleUserRecipientFilter user(pPlayer);
	user.MakeReliable();
	UserMessageBegin(user,"HapMeleeContact");
	MessageEnd();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pPlayer - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CGrubNugget::MyTouch( CBasePlayer *pPlayer )
{
	//int nHealthToGive = sk_grubnugget_health.GetFloat() * m_nDenomination;
	int nHealthToGive;
	switch (m_nDenomination)
	{
	case NUGGET_SMALL:
		nHealthToGive = sk_grubnugget_health_small.GetInt();
		break;
	case NUGGET_LARGE:
		nHealthToGive = sk_grubnugget_health_large.GetInt();
		break;
	default:
		nHealthToGive = sk_grubnugget_health_medium.GetInt();
	}

	// Attempt to give the player health
	if ( pPlayer->TakeHealth( nHealthToGive, DMG_GENERIC ) == 0 )
		return false;

	CSingleUserRecipientFilter user( pPlayer );
	user.MakeReliable();

	UserMessageBegin( user, "ItemPickup" );
	WRITE_STRING( GetClassname() );
	MessageEnd();

	CPASAttenuationFilter filter( pPlayer, "GrubNugget.Touch" );
	EmitSound( filter, pPlayer->entindex(), "GrubNugget.Touch" );

	UTIL_Remove( this );	

	return true;
}

void CLoot::SendLoot(CIN_Player *pPlayer)
{
	// No es un jugador.
	if ( !pPlayer )
		return;

	CSingleUserRecipientFilter user(pPlayer);
	user.MakeReliable();

	// Loot!!
	for ( int i = 1; i < LootItems.Count(); i++ )
	{
		// Este slot no tiene ningún objeto.
		if ( LootItems[i] == 0 || !LootItems[i] )
			continue;

		// Le enviamos la lista de objetos en este Loot.
		UserMessageBegin(user, "Loot");
			WRITE_SHORT(entindex());	// Se lo enviamos en cada objeto y nos evitamos hacer otro UserMessage
			WRITE_SHORT(i);				// ID en el array.
			WRITE_SHORT(LootItems[i]);	// ID del objeto.
		MessageEnd();
	}

	// Actualizamos el panel de Loot.
	pPlayer->ExecCommand("cl_update_loot 1");
}

//-----------------------------------------------------------------------------
// Purpose: Touch function
//-----------------------------------------------------------------------------
bool CTFBaseDMPowerup::MyTouch( CBasePlayer *pPlayer )
{
	bool bSuccess = false;

	CTFPlayer *pTFPlayer = dynamic_cast<CTFPlayer*>( pPlayer );
	if ( pTFPlayer && ValidTouch( pPlayer ) )
	{
		// Add the condition and duration from derived classes
		pTFPlayer->m_Shared.AddCond( GetCondition(), GetEffectDuration() );

		// Give full health
		SetHealth( GetMaxHealth() );

		CSingleUserRecipientFilter user( pPlayer );
		user.MakeReliable();

		UserMessageBegin( user, "ItemPickup" );
			WRITE_STRING( GetClassname() );
		MessageEnd();

		pPlayer->EmitSound( STRING( m_strPickupSound ) );

		bSuccess = true;
	}

	return bSuccess;
}

void FullClientUpdatePyNetworkClsByFilter( IRecipientFilter &filter )
{
	if( !SrcPySystem()->IsPythonRunning() )
		return;

	Assert(g_SetupNetworkTablesOnHold == false);

	// Send messages about each server class
	PyServerClass *p = g_pPyServerClassHead;
	while( p )
	{
		if( p->m_bFree ) {
			p = p->m_pPyNext;
			continue;
		}

		// Send message
		UserMessageBegin(filter, "PyNetworkCls");
		WRITE_BYTE(p->m_iType);
		WRITE_STRING(p->m_pNetworkName);
		WRITE_STRING(p->m_pNetworkedClass->m_pNetworkName);
		MessageEnd();

		p = p->m_pPyNext;
	}
}

//=========================================================
// Deathnotice. 
//=========================================================
void CTeamplayRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
	if ( m_DisableDeathMessages )
		return;

	CBaseEntity *pKiller = info.GetAttacker();
	if ( pVictim && pKiller && pKiller->GetFlags() & FL_CLIENT )
	{
		CBasePlayer *pk = (CBasePlayer*)pKiller;

		if ( pk )
		{
			if ( (pk != pVictim) && (PlayerRelationship( pVictim, pk ) == GR_TEAMMATE) )
			{
				CRelieableBroadcastRecipientFilter filter;

				// TODO we are sending this message twice ?? in BaseClass::DeathNotice too.
				UserMessageBegin( filter, "DeathMsg" );	
					WRITE_BYTE( pKiller->entindex() );		// the killer
					WRITE_BYTE( pVictim->entindex() );	// the victim
					WRITE_STRING( "teammate" );		// flag this as a teammate kill
				MessageEnd();
				return;
			}
		}
	}

	BaseClass::DeathNotice( pVictim, info );
}

//-----------------------------------------------------------------------------
// Purpose: If we're picked up by another pla`yer, give resources to that team
//-----------------------------------------------------------------------------
void CResourceChunk::ChunkTouch( CBaseEntity *pOther )
{
	if ( pOther->IsPlayer() || pOther->GetServerVehicle() )
	{
		// Give the team the resources
		int iAmountPerPlayer = ((CTFTeam *)pOther->GetTeam())->AddTeamResources( GetResourceValue(), TF_PLAYER_STAT_RESOURCES_ACQUIRED_FROM_CHUNKS );
		TFStats()->IncrementTeamStat( pOther->GetTeamNumber(), TF_TEAM_STAT_RESOURCE_CHUNKS_COLLECTED, GetResourceValue() );

		pOther->EmitSound( "ResourceChunk.Pickup" );

		// Tell the player
		CSingleUserRecipientFilter user( (CBasePlayer*)pOther );
		UserMessageBegin( user, "PickupRes" );
			WRITE_BYTE( iAmountPerPlayer ); 
		MessageEnd();

		// Tell our zone to remove this chunk from it's list
		if ( m_hZone )
		{
			m_hZone->RemoveChunk( this, false );
			m_hZone = NULL;
		}

		// Remove this chunk
		SetTouch( NULL );
		UTIL_Remove( this );
		return;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CWarsWeapon::MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType )
{
#if 0
	const char* tracer = "ASWUTracer";
	//if (GetActiveASWWeapon())
	//	tracer = GetActiveASWWeapon()->GetUTracerType();
#ifdef CLIENT_DLL
	CEffectData data;
	data.m_vOrigin = tr.endpos;
	data.m_hEntity = this;
	//data.m_nMaterial = m_iDamageAttributeEffects;

	DispatchEffect( tracer, data );
#else
	CRecipientFilter filter;
	filter.AddAllPlayers();
	if (gpGlobals->maxClients > 1 && GetCommander())
	{ 
		filter.RemoveRecipient(GetCommander());
	}

	UserMessageBegin( filter, tracer );
		WRITE_SHORT( entindex() );
		WRITE_FLOAT( tr.endpos.x );
		WRITE_FLOAT( tr.endpos.y );
		WRITE_FLOAT( tr.endpos.z );
		//WRITE_SHORT( m_iDamageAttributeEffects );
	MessageEnd();
#endif
#else
#ifdef CLIENT_DLL
	ASWUTracer( GetOwner(), tr.endpos, m_vTracerColor );
#endif
#endif // 0
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameStats::SendStatsToPlayer( CTFPlayer *pPlayer, int iMsgType )
{
	PlayerStats_t &stats = m_aPlayerStats[pPlayer->entindex()];

	int iSendBits = stats.iStatsChangedBits;
	switch ( iMsgType )
	{
	case STATMSG_PLAYERDEATH:
	case STATMSG_PLAYERRESPAWN:
		break;
	case STATMSG_RESET:
		// this is a reset message, no need to send any stat values with it
		iSendBits = 0;
		break;
	case STATMSG_UPDATE:
		// if nothing changed, no need to send a message
		if ( iSendBits == 0 )
			return;
		break;
	case STATMSG_PLAYERSPAWN:
		// do a full update at player spawn
		for ( int i = TFSTAT_FIRST; i < TFSTAT_MAX; i++ )
		{
			iSendBits |= ( 1 << ( i - TFSTAT_FIRST ) );
		}
		break;
	default:
		Assert( false );
	}

	int iStat = TFSTAT_FIRST;
	CSingleUserRecipientFilter filter( pPlayer );
	UserMessageBegin( filter, "PlayerStatsUpdate" );
	WRITE_BYTE( pPlayer->GetPlayerClass()->GetClassIndex() );		// write the class
	WRITE_BYTE( iMsgType );											// type of message
	WRITE_LONG( iSendBits );										// write the bit mask of which stats follow in the message

	// write all the stats specified in the bit mask
	while ( iSendBits > 0 )
	{
		if ( iSendBits & 1 )
		{
			WRITE_LONG( stats.statsCurrentRound.m_iStat[iStat] );
		}
		iSendBits >>= 1;
		iStat ++;
	}
	MessageEnd();

	stats.iStatsChangedBits = 0;
	stats.m_flTimeLastSend = gpGlobals->curtime;

	if ( iMsgType == STATMSG_PLAYERDEATH )
	{
		// max sentry kills is different from other stats, it is a max value and can span player lives.  Reset it to zero so 
		// it doesn't get re-reported in the next life unless the sentry stays alive and gets more kills.
		pPlayer->SetMaxSentryKills( 0 );
		Event_MaxSentryKills( pPlayer, 0 );
	}
}

//=========================================================
// Se activa cuando el usuario toca el objeto.
//=========================================================
bool CSoda::MyTouch(CBasePlayer *pPlayer)
{
	// En modo Survival esto solo se puede usar desde el inventario.
	if ( g_pGameRules->IsMultiplayer() )
		return false;

	CIN_Player *pInPlayer = GetInPlayer(pPlayer);

	if ( !pPlayer )
		return false;

	if ( pInPlayer->TakeThirst(sk_soda.GetFloat()) != 0 )
	{
		CSingleUserRecipientFilter user(pInPlayer);
		user.MakeReliable();

		UserMessageBegin(user, "ItemPickup");
			WRITE_STRING(GetClassname());
		MessageEnd();

		CPASAttenuationFilter filter(pInPlayer, "Player.Drink");
		EmitSound(filter, entindex(), "Player.Drink");

		if ( g_pGameRules->ItemShouldRespawn(this) )
			Respawn();
		else
			Remove();

		return true;
	}

	return false;
}

void CTimer::DispatchResetMessage()
{
    CSingleUserRecipientFilter user(UTIL_GetLocalPlayer());
    user.MakeReliable();
    UserMessageBegin(user, "Timer_Reset");
    MessageEnd();
}