Team Fortress 2 and Counterstrike source code leaked on the Internet.

class CNetworkClient : public IConnectionlessPacketHandler, public INetworkMessageHandler, public ILookupChannel
{
public:
	CNetworkClient();
	virtual ~CNetworkClient();
 
	bool	Init( int nListenPort );
	void	Shutdown();
 
	bool	Connect( const char *server, int port );
	void	Disconnect();
 
	// IConnectionlessPacketHandler
	virtual bool ProcessConnectionlessPacket( CNetPacket *packet );	// process a connectionless packet
 
	// INetworkMessageHandler
	virtual void	OnConnectionClosing( INetChannel *channel, char const *reason );
	virtual void	OnConnectionStarted( INetChannel *channel );
 
	virtual void	OnPacketStarted( int inseq, int outseq );
	virtual void	OnPacketFinished();
 
	// ILookupChannel
    virtual INetChannel *FindNetChannel( const netadr_t& from ) ;
 
	INetChannel *GetNetChannel()
	{
		return &m_NetChan;
	}
 
	void ReadPackets();
	void SendUpdate();
 
	CUDPSocket *m_pSocket;
 
	CNetChannel		m_NetChan;
	bool			m_bConnected;
};
 
#endif // CLIENT_H

bool CUDPSocket::Init( unsigned short nBindToPort )
{
	m_Port = nBindToPort;
	struct sockaddr_in	address;
 
	m_Socket = socket( PF_INET, SOCK_DGRAM, IPPROTO_UDP );
	if ( m_Socket == INVALID_SOCKET )
		return false;
 
	address = m_pImpl->m_SocketIP;
	address.sin_family = AF_INET;
	address.sin_port = htons( m_Port );
	address.sin_addr.S_un.S_addr = INADDR_ANY;
 
	if ( SOCKET_ERROR == bind( m_Socket, ( struct sockaddr * )&address, sizeof( address ) ) )
	{
		return false;
	}
 
	// Set to non-blocking i/o
	unsigned long value = 1;
	if ( SOCKET_ERROR == ioctlsocket( m_Socket, FIONBIO, &value ) )
	{
		return false;
	}
 
	return true;
}

void ReadCheatCommandsFromFile( char *pchFileName )
{
#if defined( _CERT )
	return;
#endif
	KeyValues *pCheatCodeKeys = new KeyValues( "cheat_codes" );
	if ( pCheatCodeKeys->LoadFromFile( g_pFullFileSystem, pchFileName, NULL ) )
	{
		KeyValues *pKey = NULL;
		for ( pKey = pCheatCodeKeys->GetFirstTrueSubKey(); pKey; pKey = pKey->GetNextTrueSubKey() )
		{
			int iCheat = s_CheatCodeCommands.AddToTail();
			CheatCodeData_t *pNewCheatCode = &(s_CheatCodeCommands[ iCheat ]);
 
			Q_strncpy( pNewCheatCode->szName, pKey->GetName(), CHEAT_NAME_MAX_LEN );	// Get the name
			pNewCheatCode->bDevOnly = ( pKey->GetInt( "dev", 0 ) != 0 );				// Get developer only flag
			pNewCheatCode->iCodeLength = 0;												// Start at zero code elements
			Q_strncpy( pNewCheatCode->szCommand, pKey->GetString( "command", "echo \"Cheat code has no command!\"" ), CHEAT_COMMAND_MAX_LEN );
 
			KeyValues *pSubKey = NULL;
			for ( pSubKey = pKey->GetFirstSubKey(); pSubKey; pSubKey = pSubKey->GetNextKey() )
			{
				const char *pchType = pSubKey->GetName();
				if ( Q_strcmp( pchType, "code" ) == 0 )
				{
					AssertMsg( ( pNewCheatCode->iCodeLength < CHEAT_NAME_MAX_LEN ), "Cheat code elements exceeded max!" );
 
					pNewCheatCode->pButtonCodes[ pNewCheatCode->iCodeLength ] = g_pInputSystem->StringToButtonCode( pSubKey->GetString() );
					++pNewCheatCode->iCodeLength;
				}
			}
 
			if ( pNewCheatCode->iCodeLength < CHEAT_NAME_MAX_LEN )
			{
				// If it's activation is a subsequence of another cheat, the longer cheat can't be activated!
				DevWarning( "Cheat code \"%s\" has less than %i code elements!", pKey->GetName(), CHEAT_NAME_MAX_LEN );
			}
		}
	}
 
	pCheatCodeKeys->deleteThis();
}

bool CBasePlayer::WantsLagCompensationOnEntity( const CBaseEntity *entity, const CUserCmd *pCmd, const CBitVec<MAX_EDICTS> *pEntityTransmitBits ) const
{
	// Team members shouldn't be adjusted unless friendly fire is on.
	if ( !mp_friendlyfire.GetInt() && !mp_teammates_are_enemies.GetBool() && entity->GetTeamNumber() == GetTeamNumber() )
		return false;
 
	// If this entity hasn't been transmitted to us and acked, then don't bother lag compensating it.
	if ( pEntityTransmitBits && !pEntityTransmitBits->Get( entity->entindex() ) )
		return false;
 
	const Vector &vMyOrigin = GetAbsOrigin();
	const Vector &vHisOrigin = entity->GetAbsOrigin();
 
	// get max distance player could have moved within max lag compensation time, 
	// multiply by 1.5 to to avoid "dead zones"  (sqrt(2) would be the exact value)
	float entityMaxSpeed = ToBasePlayer(entity) ? ToBasePlayer(entity)->MaxSpeed() : 300.0f;
	float maxDistance = 1.5 * entityMaxSpeed * sv_maxunlag.GetFloat();
 
	// If the player is within this distance, lag compensate them in case they're running past us.
	if ( vHisOrigin.DistTo( vMyOrigin ) < maxDistance )
		return true;
 
	// If their origin is not within a 45 degree cone in front of us, no need to lag compensate.
	Vector vForward;
	AngleVectors( pCmd->viewangles, &vForward );
 
	Vector vDiff = vHisOrigin - vMyOrigin;
	VectorNormalize( vDiff );
 
	float flCosAngle = 0.707107f;	// 45 degree angle
	if ( vForward.Dot( vDiff ) < flCosAngle )
		return false;
 
	return true;
}