C++ bf_read::ReadLong方法代码示例

bool CheckJobID( bf_read &buf, int jobID[4] )
{
	TimeoutJobIDs();
	
	jobID[0] = buf.ReadLong();
	jobID[1] = buf.ReadLong();
	jobID[2] = buf.ReadLong();
	jobID[3] = buf.ReadLong();
	if ( FindJobMemory( jobID ) || buf.IsOverflowed() )
	{
		return false;
	}
	
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudHealth::MsgFunc_Damage( bf_read &msg )
{

	int armor = msg.ReadByte();	// armor
	int damageTaken = msg.ReadByte();	// health
	long bitsDamage = msg.ReadLong(); // damage bits
	bitsDamage; // variable still sent but not used

	Vector vecFrom;

	vecFrom.x = msg.ReadBitCoord();
	vecFrom.y = msg.ReadBitCoord();
	vecFrom.z = msg.ReadBitCoord();

	// Actually took damage?
	if ( damageTaken > 0 || armor > 0 )
	{
		if ( damageTaken > 0 )
		{
			// start the animation
			if( m_flHealthSize > 20 )
			{
				g_pClientMode->GetViewportAnimationController()->StartAnimationSequence("C17HealthDamageTaken");
			}
		}
	}
}

/**
 *
 * short - 
 * long - Duration in seconds to display (-1 means forever)
 */
void CHudNotification::MsgFunc_NotificationIcon( bf_read& data )
{
	short icon = data.ReadShort();
	int duration = data.ReadLong();

	m_IconList.AddToTail( );
}

void CHudStyleBar::MsgFunc_StyleAnnouncement( bf_read &msg )
{
	announcement_t eAnnouncement = (announcement_t)msg.ReadLong();
	style_point_t ePointStyle = (style_point_t)msg.ReadByte();
	float flBar = msg.ReadFloat();
	float flPoints = msg.ReadFloat();

	CAnnouncement oAnnouncement;
	oAnnouncement.m_flStartTime = gpGlobals->curtime;
	oAnnouncement.m_eAnnouncement = eAnnouncement;
	oAnnouncement.m_ePointStyle = ePointStyle;
	oAnnouncement.m_flBarPosition = flBar;

	if (m_aAnnouncements.Count())
	{
		// If a few at a time come in off the wire don't throw them all up at once. Subsequent ones should come in with a delay.

		float flDelay = 0.02f;
		if (gpGlobals->curtime < m_aAnnouncements[m_aAnnouncements.Tail()].m_flStartTime + flDelay)
			oAnnouncement.m_flStartTime = m_aAnnouncements[m_aAnnouncements.Tail()].m_flStartTime + flDelay;
	}

	oAnnouncement.m_flStylePoints = flPoints;

	m_aAnnouncements.AddToTail(oAnnouncement);
}

// Server to client message received
void C_NPC_Advisor::ReceiveMessage( int classID, bf_read &msg )
{
	if ( classID != GetClientClass()->m_ClassID )
	{
		// message is for subclass
		BaseClass::ReceiveMessage( classID, msg );
		return;
	}

	int messageType = msg.ReadByte();
	switch( messageType )
	{
	case ADVISOR_MSG_START_BEAM:
		{
			int eindex = msg.ReadLong();
			StartBeamFX(IndexToEntity(eindex));
		}
		break;

	case ADVISOR_MSG_STOP_BEAM:
		{
			int eindex = msg.ReadLong();
			StopBeamFX(IndexToEntity(eindex));

		}
		break;

	case ADVISOR_MSG_STOP_ALL_BEAMS:
		{
			ParticleProp()->StopEmission();
		}
		break;
	case ADVISOR_MSG_START_ELIGHT:
		{
			StartElight();
		}
		break;
	case ADVISOR_MSG_STOP_ELIGHT:
		{
			StopElight();
		}
		break;

	default:
		AssertMsg1( false, "Received unknown message %d", messageType);
	}
}

//-----------------------------------------------------------------------------
// Purpose: Message handler for Damage message
//-----------------------------------------------------------------------------
void CHudDamageTiles::MsgFunc_Damage( bf_read &msg )
{
						msg.ReadByte();	// armor
						msg.ReadByte();	// health
	long bitsDamage	=	msg.ReadLong();	// damage bits, ignore

	UpdateTiles( bitsDamage );
}

void __MsgFunc_SPHapWeapEvent( bf_read &msg )
{
#ifdef WIN32
	int iActivity = msg.ReadLong();

	HapticsHandleMsg_SPHapWeapEvent( iActivity );
#endif // WIN32
}

void CVoiceStatus::HandleVoiceMaskMsg(bf_read &msg)
{
	unsigned long dw;
	for(dw=0; dw < VOICE_MAX_PLAYERS_DW; dw++)
	{
		m_AudiblePlayers.SetDWord(dw, (unsigned long)msg.ReadLong());
		m_ServerBannedPlayers.SetDWord(dw, (unsigned long)msg.ReadLong());

		if( voice_clientdebug.GetInt())
		{
			Msg("CVoiceStatus::HandleVoiceMaskMsg\n");
			Msg("    - m_AudiblePlayers[%d] = %lu\n", dw, m_AudiblePlayers.GetDWord(dw));
			Msg("    - m_ServerBannedPlayers[%d] = %lu\n", dw, m_ServerBannedPlayers.GetDWord(dw));
		}
	}

	m_bServerModEnable = msg.ReadByte();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pszName - 
//			iSize - 
//			*pbuf - 
//-----------------------------------------------------------------------------
void CForceFeedback::MsgFunc_ForceFeedback( bf_read &msg )
{
	byte msgType = msg.ReadByte();

	switch ( msgType )
	{
	default:
		{
			Warning( "Bad parse in MsgFunc_ForceFeedback!\n" );
		}
		break;
	case FFMSG_STOPALL:
		{
			Internal_StopAllEffects();
		}
		break;
	case FFMSG_START:
		{
			FORCEFEEDBACK_t effectType = (FORCEFEEDBACK_t)msg.ReadByte();

			FFBaseParams_t params;
			params.m_flDirection = 360.0f * ( (byte)msg.ReadByte() / 255.0f );
			params.m_flDuration = (float)msg.ReadLong() / 1000.0f;
			params.m_flGain = ( (byte)msg.ReadByte() / 255.0f );
			params.m_nPriority = msg.ReadByte();
			params.m_bSolo = msg.ReadByte() == 0 ? false : true;

			if ( effectType >= 0 && effectType < NUM_FORCE_FEEDBACK_PRESETS )
			{
				Internal_StartEffect( effectType, params );
			}
			else
			{
				Warning( "Bad parse in MsgFunc_ForceFeedback, FFMSG_START (%i)!\n", effectType );
			}
		}
		break;
	case FFMSG_STOP:
		{
			FORCEFEEDBACK_t effectType = (FORCEFEEDBACK_t)msg.ReadByte();

			Internal_StopEffect( effectType );
		}
		break;
	case FFMSG_PAUSE:
		{
			Internal_PauseAll();
		}
		break;
	case FFMSG_RESUME:
		{
			Internal_ResumeAll();
		}
		break;
	}
}

void __MsgFunc_HapDmg( bf_read &msg )
{
#ifdef WIN32
	float pitch = msg.ReadFloat();
	float yaw = msg.ReadFloat();
	float damage = msg.ReadFloat();
	int damageType = msg.ReadLong();

	HapticsHandleMsg_HapDmg( pitch, yaw, damage, damageType );
#endif // WIN32
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CHudHealth::MsgFunc_Damage(bf_read &msg)
{
	msg.ReadByte();	// armor
	msg.ReadByte();	// health
	msg.ReadLong();	// damage bits

	Vector vecFrom;

	vecFrom.x = msg.ReadBitCoord();
	vecFrom.y = msg.ReadBitCoord();
	vecFrom.z = msg.ReadBitCoord();
}

/*=======================================================
	Protocol:
		EventType	[long]
		teamid		[long]
		userid		[long]
=======================================================*/
void CHudFlagCarrier::MsgFunc_UpdateFlagCarrier( bf_read& data )
{
	int event = data.ReadLong();
	int teamid = data.ReadLong();
	int flagteamid = data.ReadLong();
	int userid = data.ReadLong();

	if ( event == HFLG_PICKUP )
	{
		int teamIndex = flagteamid;
		m_FlagState[ teamIndex ] = HFLG_PICKUP;
		UpdateFlagState( teamIndex );

		m_iTakenByPlayer[ teamIndex ] = userid;
		UpdateTakenAvatar( teamIndex );
	}
	else if ( event == HFLG_DROPPED || event == HFLG_DROPPED_TIMER )
	{
		m_DroppedMaxTime = data.ReadFloat();

		int teamIndex = flagteamid;
		m_FlagState[ teamIndex ] = HFLG_DROPPED_TIMER;
		m_DroppedTimer[ teamIndex ].Reset();
		m_DroppedTimer[ teamIndex ].Start( 0.0f );
		UpdateFlagState( teamIndex );

		m_iTakenByPlayer[ teamIndex ] = TAKEN_INVALID_PLAYER;
	}
	else if ( event == HFLG_RETURNED )
	{
		int teamIndex = flagteamid;
		m_FlagState[ teamIndex ] = HFLG_BASE;
		m_DroppedTimer[ teamIndex ].Reset();
		UpdateFlagState( teamIndex );

		m_iTakenByPlayer[ teamIndex ] = TAKEN_INVALID_PLAYER;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Called when we get a stat update for the local player
//-----------------------------------------------------------------------------
void CTFStatPanel::MsgFunc_PlayerStatsUpdate( bf_read &msg )
{
	// get the fixed-size information
	int iClass = msg.ReadByte();
	int iMsgType = msg.ReadByte();
	int iSendBits = msg.ReadLong();

	bool bAlive = true;
	bool bSpawned = false;

	switch ( iMsgType )
	{
	case STATMSG_RESET:
		m_RoundStatsCurrentGame.Reset();
		m_RoundStatsLifeStart.Reset();
		return;
	case STATMSG_PLAYERSPAWN:
	case STATMSG_PLAYERRESPAWN:
		bSpawned = true;
		break;
	case STATMSG_PLAYERDEATH:
		bAlive = false;
		break;
	case STATMSG_UPDATE:
		break;
	default:
		Assert( false );
	}

	Assert( iClass >= TF_FIRST_NORMAL_CLASS && iClass <= TF_LAST_NORMAL_CLASS );
	if ( iClass < TF_FIRST_NORMAL_CLASS || iClass > TF_LAST_NORMAL_CLASS )
		return;
	
	m_iClassCurrentLife = iClass;
	C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( pPlayer )
	{
		m_iTeamCurrentLife = pPlayer->GetTeamNumber();
	}

//	Msg( "Stat update: (msg %d) ", iMsgType );
	// the bitfield indicates which stats are contained in the message.  Set the stats appropriately.
	int iStat = TFSTAT_FIRST;
	while ( iSendBits > 0 )
	{
		if ( iSendBits & 1 )
		{	
			int iVal = msg.ReadLong();
//			Msg( "#%d=%d ", iStat, iVal );
			m_RoundStatsCurrentGame.m_iStat[iStat] = iVal;
		}
		iSendBits >>= 1;
		iStat++;
	}
//	Msg( "\n" );
	// Calculate stat values for current life.  Take current game stats and subtract what the values were at the start of this life
	for ( iStat = TFSTAT_FIRST; iStat < TFSTAT_MAX; iStat++ )
	{
		if ( iStat == TFSTAT_MAXSENTRYKILLS )
		{
			// max sentry kills is special, it is a max value.  Always use absolute value, do not use delta from earlier value.
			m_RoundStatsCurrentLife.m_iStat[TFSTAT_MAXSENTRYKILLS] = m_RoundStatsCurrentGame.m_iStat[TFSTAT_MAXSENTRYKILLS];
			continue;
		}
		int iDelta = m_RoundStatsCurrentGame.m_iStat[iStat] - m_RoundStatsLifeStart.m_iStat[iStat];
		Assert( iDelta >= 0 );
		m_RoundStatsCurrentLife.m_iStat[iStat] = iDelta;
	}

	if ( iMsgType == STATMSG_PLAYERDEATH || iMsgType == STATMSG_PLAYERRESPAWN )
	{
		m_RoundStatsCurrentLife.m_iStat[TFSTAT_PLAYTIME] = gpGlobals->curtime - m_flTimeCurrentLifeStart;
	}

	if ( bSpawned )
	{
		// if the player just spawned, use current stats as baseline to calculate stats for next life
		m_RoundStatsLifeStart = m_RoundStatsCurrentGame;
		m_flTimeCurrentLifeStart = gpGlobals->curtime;
	}

	// sanity check: the message should contain exactly the # of bytes we expect based on the bit field
	Assert( !msg.IsOverflowed() );
	Assert( 0 == msg.GetNumBytesLeft() );
	// if byte count isn't correct, bail out and don't use this data, rather than risk polluting player stats with garbage
	if ( msg.IsOverflowed() || ( 0 != msg.GetNumBytesLeft() ) )
		return;

	UpdateStats( iMsgType );
}

bool HandleMessage(bf_read &msg, int type)
{

	if (type == 0) // nop
	{
		//	printf("NOP\n");
		return true;
	}

	if (type == 1) // disconnect
	{
		char dcreason[1024];
		msg.ReadString(dcreason, sizeof(dcreason));
		printf("Disconnected: %s\n", dcreason);
		printf("Reconnecting in 5000 ms ...");

		_sleep(5000);
		NET_Reconnect();
		return true;
	}

	if (type == 2)//net_File
	{
		long transferid = msg.ReadUBitLong(32);
		char filename[255];
		msg.ReadString(filename, sizeof(filename));
		bool requested = (bool)(msg.ReadOneBit()==1);

		if (requested)
			printf("net_File: Server requested file: %s::%i\n", filename, transferid);
		else
			printf("net_File: Server is not sending file: %s::%i\n", filename, transferid);

		return true;
	}
	if (type == 3)//net_Tick
	{
		net_tick = msg.ReadLong();
		net_hostframetime = msg.ReadUBitLong(16);
		net_hostframedeviation = msg.ReadUBitLong(16);
		//printf("Tick: %i - hostframetime: %i ( deviation: %i )\n", net_tick, net_hostframedeviation, net_hostframedeviation);

		return true;
	}

	if (type == 4)//net_StringCmd
	{
		char cmd[1024];
		msg.ReadString(cmd, sizeof(cmd));

		printf("net_StringCmd: %s\n", cmd);
		return true;
	}

	if (type == 5)//net_SetConVar
	{

		int count = msg.ReadByte();

		char cmdname[255];
		char cmdval[255];

		printf("net_SetConVar: %i\n", count);
		for (int i = 0; i < count; i++)
		{
			msg.ReadString(cmdname, sizeof(cmdname));
			msg.ReadString(cmdval, sizeof(cmdval));
			printf("%s to: %s\n", cmdname, cmdval);

		}
		printf("net_SetConVar_end, left: %i\n", msg.GetNumBytesLeft());
		return true;

	}

	if (type == 6)// net_SignonState
	{
		int state = msg.ReadByte();
		long aservercount = msg.ReadLong();


		printf("Received net_SignOnState: %i, count: %i\n", state, bconnectstep);

		if (netchan->m_iSignOnState == state)
		{
			printf("Ignored signonstate!\n");
			return true;
		}

		netchan->m_iServerCount = aservercount;
		netchan->m_iSignOnState = state;

		printf("KK __ %i\n", state);
		if (state == 3)
		{

			senddata.WriteUBitLong(8, 6);
			senddata.WriteLong(netchan->m_iServerCount);
			senddata.WriteLong(518790445);//clc_ClientInfo crc
			senddata.WriteOneBit(1);//ishltv
//.........这里部分代码省略.........

int HandleConnectionLessPacket(char*ip, short port, int connection_less, bf_read& recvdata)
{
	recvdata.ReadLong();

	int header = 0;
	int id = 0;
	int total = 0;
	int number = 0;
	short splitsize = 0;

	if (connection_less == 1)
	{
		header = recvdata.ReadByte();
	}
	else {
		id = recvdata.ReadLong();
		total = recvdata.ReadByte();
		number = recvdata.ReadByte();
		splitsize = recvdata.ReadByte();
	}

	switch (header)
	{

	case '9':
	{
		recvdata.ReadLong();

		char error[1024];
		recvdata.ReadString(error, 1024);
		printf("Connection refused! [%s]\n", error);

		NET_Reconnect();

		return 0;
	}
	case 'A': // A2A_GETCHALLENGE
	{
		bconnectstep = 2;
		long magicnumber = recvdata.ReadLong();

		serverchallenge = recvdata.ReadLong();
		ourchallenge = recvdata.ReadLong();
		authprotocol = recvdata.ReadLong();

		steamkey_encryptionsize = recvdata.ReadShort(); // gotta be 0

		recvdata.ReadBytes(steamkey_encryptionkey, steamkey_encryptionsize);
		recvdata.ReadBytes(serversteamid, sizeof(serversteamid));
		vacsecured = recvdata.ReadByte();

		printf("Challenge: %lu__%lu|Auth: %x|SKey: %lu|VAC: %x\n", serverchallenge, ourchallenge, authprotocol, steamkey_encryptionsize, vacsecured);

		char connectpkg[700];
		memset(connectpkg, 0, sizeof(connectpkg));

		bf_write writeconnect(connectpkg, sizeof(connectpkg));
		bf_read readsteamid(connectpkg, sizeof(connectpkg));

		writeconnect.WriteLong(-1);
		writeconnect.WriteByte('k');//C2S_CONNECT

		writeconnect.WriteLong(0x18);//protocol ver

		writeconnect.WriteLong(0x03);//auth protocol 0x03 = PROTOCOL_STEAM, 0x02 = PROTOCOL_HASHEDCDKEY, 0x01=PROTOCOL_AUTHCERTIFICATE
		writeconnect.WriteLong(serverchallenge);
		writeconnect.WriteLong(ourchallenge);

		writeconnect.WriteUBitLong(2729496039, 32);

		writeconnect.WriteString(nickname); //nick
		writeconnect.WriteString(password); // pass
		writeconnect.WriteString("2000"); // game version


		unsigned char steamkey[STEAM_KEYSIZE];
		unsigned int keysize = 0;

		steamuser->GetAuthSessionTicket(steamkey, STEAM_KEYSIZE, &keysize);

		CSteamID localsid = steamuser->GetSteamID();

		writeconnect.WriteShort(242);
		unsigned long long steamid64 = localsid.ConvertToUint64();
		writeconnect.WriteLongLong(steamid64);

		if (keysize)
			writeconnect.WriteBytes(steamkey, keysize);

		net.SendTo(ip, port, connectpkg, writeconnect.GetNumBytesWritten());


		return 0;

	}
	case 'B': // S2C_CONNECTION
	{

		if (bconnectstep == 2)
		{
//.........这里部分代码省略.........