//Might be able to handle this better...
void __MsgFunc_HapSetConst( bf_read &msg )
{
#ifdef WIN32
Vector constant;
constant.x = msg.ReadShort();
constant.y = msg.ReadShort();
constant.z = msg.ReadShort();
HapticsHandleMsg_HapSetConst( constant );
#endif // WIN32
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pszName -
// iSize -
// *pbuf -
// Output : static int
//-----------------------------------------------------------------------------
void __MsgFunc_Fade( bf_read &msg )
{
ScreenFade_t fade;
fade.duration = msg.ReadShort(); // fade lasts this long
fade.holdTime = msg.ReadShort(); // fade lasts this long
fade.fadeFlags = msg.ReadShort(); // fade type (in / out)
fade.r = msg.ReadByte(); // fade red
fade.g = msg.ReadByte(); // fade green
fade.b = msg.ReadByte(); // fade blue
fade.a = msg.ReadByte(); // fade blue
g_ViewEffects.Fade( fade );
}
//-----------------------------------------------------------------------------
// Purpose: ammo denied message
//-----------------------------------------------------------------------------
void CHudHistoryResource::MsgFunc_AmmoDenied( bf_read &msg )
{
int iAmmo = msg.ReadShort();
// see if there are any existing ammo items of that type
for ( int i = 0; i < m_PickupHistory.Count(); i++ )
{
if ( m_PickupHistory[i].type == HISTSLOT_AMMO && m_PickupHistory[i].iId == iAmmo )
{
// it's already in the list as a pickup, ignore
return;
}
}
// see if there are any denied ammo icons, if so refresh their timer
for ( int i = 0; i < m_PickupHistory.Count(); i++ )
{
if ( m_PickupHistory[i].type == HISTSLOT_AMMODENIED && m_PickupHistory[i].iId == iAmmo )
{
// it's already in the list, refresh
m_PickupHistory[i].DisplayTime = gpGlobals->curtime + (hud_drawhistory_time.GetFloat() / 2.0f);
m_bNeedsDraw = true;
return;
}
}
// add into the list
AddToHistory( HISTSLOT_AMMODENIED, iAmmo, 0 );
}
/**
*
* 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( );
}
//-----------------------------------------------------------------------------
// Purpose: Receive hud update message from server
// Input : *pszName -
// iSize -
// *pbuf -
// Output : int
//-----------------------------------------------------------------------------
int CTechnologyTreeDoc::MsgFunc_Technology(bf_read &msg)
{
int index;
int available;
int voters;
float resourcelevel;
bool preferred;
// Which tech
index = msg.ReadByte();
// Available to this team?
available = msg.ReadByte();
// # of players indicating this as their preferred tech for new spending
voters = msg.ReadByte();
preferred = ( voters & 0x80 ) ? true : false;
voters &= 0x7f;
resourcelevel = (float)msg.ReadShort();
// Look it up by index
CBaseTechnology *item = m_pTree->GetTechnology( index );
if ( item )
{
bool wasactive = item->GetActive();
bool justactivated = !wasactive && available;
// Set data elements
item->SetActive( available ? true : false );
item->SetVoters( voters );
item->SetResourceLevel( resourcelevel );
// If this is the tech I am voting for, clear my vote
if ( preferred )
{
// Sets the flag on the item, too
m_pTree->SetPreferredTechnology( item );
}
else
{
// Force deselection in case there is no active preference on the server any more
item->SetPreferred( false );
}
if ( justactivated && item->GetLevel() > 0 && !item->GetHintsGiven( TF_HINT_NEWTECHNOLOGY ) )
{
// So we only give this hint once this game, even if we respawn, etc.
item->SetHintsGiven( TF_HINT_NEWTECHNOLOGY, true );
// Note, only show a max of three or 4 newtechnology hints at a time
CreateGlobalHint( TF_HINT_NEWTECHNOLOGY, item->GetPrintName(), index, 3 );
}
// hogsy start - this might be temporary, just keep it here for now.
CCommanderStatusPanel::StatusPanel()->SetTechnology(item);
// hogsy end
}
return 1;
}
//--------------------------------------------------------------
// TGB: usermessage for updating the buildmenu
//--------------------------------------------------------------
void __MsgFunc_BuildMenuUpdate( bf_read &msg )
{
//DevMsg("Received BuildMenuUpdate on client\n");
if (gBuildMenu == NULL)
{
gBuildMenu = dynamic_cast<CBuildMenu *>(gViewPortInterface->FindPanelByName(PANEL_BUILD));
if(gBuildMenu == NULL)
return;
}
//read spawn entindex
int spawnidx = msg.ReadShort();
//read whether this is an opener msg or update msg
bool force_open = (msg.ReadOneBit() == 1);
//read queue from usermessage
int queue[BM_QUEUE_SIZE];
for (int i=0; i < BM_QUEUE_SIZE; i++)
{
//every type was increased by 1 so that type_invalid could be 0 (byte is unsigned)
queue[i] = (msg.ReadByte() - 1);
}
if (force_open)
{
//if we weren't visible, this is also an opening message
gViewPortInterface->ShowPanel(gBuildMenu, true);
}
gBuildMenu->SetCurrentSpawn(spawnidx);
gBuildMenu->UpdateQueue(queue);
}
void __MsgFunc_ReloadEffect( bf_read &msg )
{
int iPlayer = msg.ReadShort();
C_SDKPlayer *pPlayer = dynamic_cast< C_SDKPlayer* >( C_BaseEntity::Instance( iPlayer ) );
if ( pPlayer )
pPlayer->PlayReloadEffect();
}
void __MsgFunc_ASWSentryTracer( bf_read &msg )
{
int iSentry = msg.ReadShort();
C_ASW_Sentry_Top *pSentry = dynamic_cast<C_ASW_Sentry_Top*>( ClientEntityList().GetEnt( iSentry ) ); // turn iMarine ent index into the marine
Vector vecEnd;
vecEnd.x = msg.ReadFloat();
vecEnd.y = msg.ReadFloat();
vecEnd.z = msg.ReadFloat();
if ( pSentry )
{
pSentry->ASWSentryTracer( vecEnd );
}
}
void CASW_Hud_Squad_Hotbar::MsgFunc_ASWOrderStopItemFX( bf_read &msg )
{
int iMarine = msg.ReadShort();
C_ASW_Marine *pMarine = dynamic_cast<C_ASW_Marine*>(ClientEntityList().GetEnt(iMarine)); // turn iMarine ent index into the marine
if ( !pMarine )
return;
bool bShouldDelay = msg.ReadOneBit() ? true : false;
bool bFailed = msg.ReadOneBit() ? true : false;
// loops through to see if we already have an order effect for this marine
if ( bFailed )
StopItemFX( pMarine, gpGlobals->curtime + 2.0f, true );
else if ( bShouldDelay )
StopItemFX( pMarine, gpGlobals->curtime + 2.0f );
else
StopItemFX( pMarine );
}
//-----------------------------------------------------------------------------
// Purpose: Message handler for ASWOrderUseItemFX message
//-----------------------------------------------------------------------------
void CASW_Hud_Squad_Hotbar::MsgFunc_ASWOrderUseItemFX( bf_read &msg )
{
int iMarine = msg.ReadShort();
C_ASW_Marine *pMarine = dynamic_cast<C_ASW_Marine*>(ClientEntityList().GetEnt(iMarine)); // turn iMarine ent index into the marine
if ( !pMarine )
return;
int iOrderType = msg.ReadShort();
int iInventorySlot = msg.ReadShort();
Vector vecPosition;
vecPosition.x = msg.ReadFloat();
vecPosition.y = msg.ReadFloat();
vecPosition.z = msg.ReadFloat();
// loops through to see if we already have an order effect for this marine
StopItemFX( pMarine );
const char *pszClassName = NULL;
switch( iOrderType )
{
case ASW_USE_ORDER_WITH_ITEM:
{
// check we have an item in that slot
CASW_Weapon* pWeapon = pMarine->GetASWWeapon( iInventorySlot );
if ( !pWeapon || !pWeapon->GetWeaponInfo() || !pWeapon->GetWeaponInfo()->m_bOffhandActivate )
return;
pszClassName = pWeapon->GetClassname();
}
break;
case ASW_USE_ORDER_HACK:
{
pszClassName = "asw_weapon_t75"; // for now, we're using the t75 icon for hacking
}
break;
default:
{
Assert( false ); // unspecified order type
return;
}
break;
}
//CNewParticleEffect *pEffect = pMarine->ParticleProp()->Create( "order_use_item", PATTACH_CUSTOMORIGIN, -1, vecPosition - pMarine->GetAbsOrigin() );
CNewParticleEffect *pEffect = pMarine->ParticleProp()->Create( "order_use_item", PATTACH_ABSORIGIN );
if ( pEffect )
{
pMarine->ParticleProp()->AddControlPoint( pEffect, 1, pMarine, PATTACH_CUSTOMORIGIN );
pEffect->SetControlPoint( 1, vecPosition );//vecPosition - pMarine->GetAbsOrigin()
for ( int i = 0; i < NUM_USE_ITEM_ORDER_CLASSES; i++ )
{
if ( pszUseItemOrderClasses[i] && !Q_strcmp ( pszUseItemOrderClasses[i] , pszClassName ) )
{
pEffect->SetControlPoint( 2, Vector( i, 0, 0 ) );
break;
}
}
HotbarOrderEffectsList_t::IndexLocalType_t iIndex = m_hHotbarOrderEffects.AddToTail();
m_hHotbarOrderEffects[iIndex].iEffectID = iMarine;
m_hHotbarOrderEffects[iIndex].pEffect = pEffect;
}
}
//-----------------------------------------------------------------------------
// MsgFunc_Battery()
// Obtener la energía actual del traje.
//-----------------------------------------------------------------------------
void CHudBattery::MsgFunc_Battery(bf_read &msg)
{
m_iNewBat = msg.ReadShort();
}
void HandlePacket_LOOKING_FOR_WORKERS( bf_read &buf, const CIPAddr &ipFrom )
{
// If we're downloading files for a job request, don't process any more "looking for workers" packets.
if ( g_Waiting_hProcess )
return;
// This will be a nonzero-length string if patching.
char versionString[512];
buf.ReadString( versionString, sizeof( versionString ) );
int iPort = buf.ReadShort();
int iPriority = buf.ReadShort();
// Make sure we don't run the same job more than once.
if ( !CheckJobID( buf, g_CurJobID ) )
return;
CUtlVector<char*> newArgv;
GetArgsFromBuffer( buf, newArgv, &g_Waiting_bShowAppWindow );
bool bForcePatch = false;
if ( buf.GetNumBytesLeft() >= 1 )
bForcePatch = (buf.ReadByte() != 0);
int iDownloaderPort = iPort;
if ( buf.GetNumBytesLeft() >= 2 )
iDownloaderPort = buf.ReadShort();
// Add these arguments after the executable filename to tell the program
// that it's an MPI worker and who to connect to.
char strDownloaderIP[128], strMainIP[128];
V_snprintf( strDownloaderIP, sizeof( strDownloaderIP ), "%d.%d.%d.%d:%d", ipFrom.ip[0], ipFrom.ip[1], ipFrom.ip[2], ipFrom.ip[3], iDownloaderPort );
V_snprintf( strMainIP, sizeof( strMainIP ), "%d.%d.%d.%d:%d", ipFrom.ip[0], ipFrom.ip[1], ipFrom.ip[2], ipFrom.ip[3], iPort );
// (-mpi is already on the command line of whoever ran the app).
// AppendArg( commandLine, sizeof( commandLine ), "-mpi" );
newArgv.InsertAfter( 0, CopyString( "-mpi_worker" ) );
newArgv.InsertAfter( 1, CopyString( strDownloaderIP ) );
// If the version string is set, then this is a patch.
bool bPatching = false;
if ( versionString[0] != 0 )
{
bPatching = true;
// Check that we haven't applied this patch version yet. This case usually happens right after we've applied a patch
// and we're restarting. The vmpi_transfer master is still pinging us telling us to patch, but we don't want to
// reapply this patch.
if ( atof( versionString ) <= atof( g_VersionString ) && !bForcePatch )
{
newArgv.PurgeAndDeleteElements();
return;
}
// Ok, it's a new version. Get rid of whatever was running before.
KillRunningProcess( "Starting a patch..", true );
}
// If there's already a job running, only interrupt it if this new one has a higher priority.
if ( WaitForProcessToExit() )
{
if ( iPriority > g_CurJobPriority )
{
KillRunningProcess( "Interrupted by a higher priority process", true );
}
else
{
// This means we're already running a job with equal to or greater priority than
// the one that has been requested. We're going to ignore this request.
newArgv.PurgeAndDeleteElements();
return;
}
}
// Responses go here.
g_CurRespondAddr = ipFrom;
// Also look for -mpi_ShowAppWindow in the args to the service.
if ( !g_Waiting_bShowAppWindow && FindArg( __argc, __argv, "-mpi_ShowAppWindow" ) )
g_Waiting_bShowAppWindow = true;
// Copy all the files from the master and put them in our cache dir to run with.
char cacheDir[MAX_PATH];
if ( StartDownloadingAppFiles( newArgv, cacheDir, sizeof( cacheDir ), g_Waiting_bShowAppWindow, &g_Waiting_hProcess, bPatching ) )
{
// After it's downloaded, we want it to switch to the main connection port.
if ( newArgv.Count() >= 3 && V_stricmp( newArgv[2], strDownloaderIP ) == 0 )
{
delete newArgv[2];
newArgv[2] = CopyString( strMainIP );
}
g_Waiting_StartTime = Plat_FloatTime();
g_Waiting_Argv.PurgeAndDeleteElements();
g_Waiting_Argv = newArgv;
g_Waiting_Priority = iPriority;
g_Waiting_bPatching = bPatching;
newArgv.Purge();
}
else
{
newArgv.PurgeAndDeleteElements();
}
// Remember that we tried to run this job so we don't try to run it again.
AddJobMemory( g_CurJobID );
SendStateToServicesBrowsers();
}
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
senddata.WriteLong(1337);
static int shit = 20;
shit++;
printf("LOL: %i\n", shit);
senddata.WriteUBitLong(0, shit);
NET_SendDatagram(0);
senddata.WriteUBitLong(0, 6);
senddata.WriteUBitLong(6, 6);
senddata.WriteByte(state);
senddata.WriteLong(aservercount);
NET_SendDatagram(0);
return true;
}
if (bconnectstep)
{
if (state == 4 && false)
{
senddata.WriteUBitLong(12, 6);
for (int i = 0; i < 32; i++)
{
senddata.WriteUBitLong(1, 32);
}
}
senddata.WriteUBitLong(6, 6);
senddata.WriteByte(state);
senddata.WriteLong(aservercount);
NET_SendDatagram(false);
return true;
}
senddata.WriteUBitLong(6, 6);
senddata.WriteByte(state);
senddata.WriteLong(aservercount);
return true;
}
if (type == 7) // svc_Print
{
char print[2048];
msg.ReadString(print, sizeof(print));
// printf("svc_Print: %s", print);
printf("%s", print);
return true;
}
if (type == 8)//svc_ServerInfo
{
unsigned short protoversion = msg.ReadShort();
long servercount = msg.ReadLong();
bool srctv = (bool)(msg.ReadOneBit() == 1);
bool dedicated = (bool)(msg.ReadOneBit() == 1);
long crc = msg.ReadLong();
short maxclasses = msg.ReadWord();
char mapmd5[16];
msg.ReadBytes(mapmd5, 16);
char players = msg.ReadByte();
char maxplayers = msg.ReadByte();
float tickinterval = msg.ReadFloat();
char platform = msg.ReadChar();
char gamedir[255];
char levelname[255];
char skyname[255];
char hostname[255];
char loadingurl[255];
char gamemode[255];
msg.ReadString(gamedir, sizeof(gamedir));
msg.ReadString(levelname, sizeof(levelname));
msg.ReadString(skyname, sizeof(skyname));
msg.ReadString(hostname, sizeof(hostname));
msg.ReadString(loadingurl, sizeof(loadingurl));
msg.ReadString(gamemode, sizeof(gamemode));
printf("ServerInfo, players: %lu/%lu | map: %s | name: %s | gm: %s | count: %i | left: %i | step: %i\n", players, maxplayers, levelname, hostname, gamemode, servercount, msg.GetNumBitsLeft(), bconnectstep);
netchan->m_iServerCount = servercount;
bconnectstep = 4;
return true;
}
if (type == 10)//svc_ClassInfo
{
int classes = msg.ReadShort();
int useclientclasses = msg.ReadOneBit();
unsigned int size = (int)(log2(classes) + 1);
if (useclientclasses == 0)
{
printf("Received svc_ClassInfo | classes: %i: \n", classes);
for (int i = 0; i < classes; i++)
{
int classid = msg.ReadUBitLong(size);
char classname[255];
char dtname[255];
msg.ReadString(classname, sizeof(classname));
msg.ReadString(dtname, sizeof(dtname));
printf("Classname: %s | DTname: %s | ClassID: %i\n", classname, dtname, classid);
}
printf("svc_ClassInfo end\n");
}
else {
printf("Received svc_ClassInfo, classes: %i\n", classes);
}
return true;
}
if (type == 11)//svc_SetPause
{
int state = msg.ReadOneBit();
printf("Received svc_SetPause, state: %i\n", state);
return true;
}
if (type == 12)//svc_CreateStringTable
{
char name[500];
msg.ReadString(name, sizeof(name));
short maxentries = msg.ReadWord();
unsigned int size = (int)(log2(maxentries) + 1);
int entries = msg.ReadUBitLong(size);
int bits = msg.ReadVarInt32();
int userdata = msg.ReadOneBit();
//if (m_bUserDataFixedSize)
//{
// buffer.WriteUBitLong(m_nUserDataSize, 12);
// buffer.WriteUBitLong(m_nUserDataSizeBits, 4);
//}
if (userdata == 1)
{
int userdatasize = msg.ReadUBitLong(12);
int userdatabits = msg.ReadUBitLong(4);
}
int compressed = msg.ReadOneBit();
if (bits < 1) return true;
unsigned int sz = (bits / 8) + 2;
unsigned char* data = new unsigned char[sz*8]; //TODO: why is 8x the space required. (heap corruption otherwise)
msg.ReadBits(data, bits);
bool really_compressed = false;
unsigned int actual_size;
CLZSS s;
printf("\n");
{
unsigned int remaining = sz;
unsigned char* ptr = data;
ptr += + 8; // unknown data
remaining -= 8;
really_compressed = s.IsCompressed(ptr);
actual_size = really_compressed?s.GetActualSize(ptr):0;
if (really_compressed) {
unsigned char* data_dec = new unsigned char[actual_size];
s.Uncompress(ptr, data_dec);
// probably reuses the substring system used by old stringtable implementation. Shift the data by a bit or two to see the first entry of modelprecache for example.
hexdump(data_dec, actual_size);
delete[] data_dec;
printf("\n");
}
}
hexdump(data, bits / 8);
delete[] data;
printf("Received svc_CreateStringTable, name: %s | maxentries: %i | size: %d | entries: %i | compressed: %i,%s,%i | " "bits: %i (%i bytes)\n",
name, maxentries, size, entries, compressed, really_compressed?"y":"n", actual_size, bits,bits/8);
return true;
}
if (type == 13)//svc_UpdateStringTable
{
int tableid = msg.ReadUBitLong((int)MAX_TABLES_BITS);
int changed = 1;
if (msg.ReadOneBit() != 0)
{
changed = msg.ReadWord();
}
int bits = msg.ReadUBitLong(20);
if (bits < 1)
return true;
char *data = new char[bits];
msg.ReadBits(data, bits);
delete[] data;
printf("Received svc_UpdateStringTable, id: %i | changed: %i | bits: %i\n", tableid, changed, bits);
return true;
}
if (type == 14)//svc_VoiceInit
{
char codec[255];
msg.ReadString(codec, sizeof(codec));
int quality = msg.ReadByte();
printf("Received svc_VoiceInit, codec: %s | quality: %i\n", codec, quality);
return true;
}
if (type == 15)//svc_VoiceData
{
//FIX ME PLEASE
int client = msg.ReadByte();
int proximity = msg.ReadByte();
int bits = msg.ReadWord();
if (msg.GetNumBitsLeft() < bits)
bits = msg.GetNumBitsLeft();
//if (!bits)//its just us talking
// return true;
printf("Received svc_VoiceData, client: %i | proximity: %i | bits: %i\n", client, proximity, bits);
char* voicedata = new char[(bits+8)/8];
msg.ReadBits(voicedata, bits);
if(voicetoggle)
{
char*uncompressed = new char[0xFFFF];
unsigned int uncompressed_size = 0;
EVoiceResult worked = clientaudio->DecompressVoice(voicedata, bits / 8, uncompressed, 0xFFFF, &uncompressed_size, clientaudio->GetVoiceOptimalSampleRate());
if (worked == k_EVoiceResultOK)
{
HWAVEOUT hWaveOut = 0;
WAVEHDR header = { uncompressed, uncompressed_size, 0, 0, 0, 0, 0, 0 };
WAVEFORMATEX wfx = { WAVE_FORMAT_PCM, 1, clientaudio->GetVoiceOptimalSampleRate(), clientaudio->GetVoiceOptimalSampleRate()*2, 2, 16, sizeof(WAVEFORMATEX) };
waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
waveOutPrepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
waveOutWrite(hWaveOut, &header, sizeof(WAVEHDR));
waveOutUnprepareHeader(hWaveOut, &header, sizeof(WAVEHDR));
waveOutClose(hWaveOut);
}else{
printf("RIP AUDIO: %i\n", worked);
delete[] uncompressed;
}
delete[] voicedata;
}
if (voicemimic)
{
senddata.WriteUBitLong(10, 6);
senddata.WriteWord(bits);
senddata.WriteBits(voicedata, bits);
}
delete[] voicedata;
return true;
}
if (type == 17)//svc_Sounds
{
int reliable = msg.ReadOneBit();
int num = 1;
int bits = 0;
if (reliable == 0)
{
num = msg.ReadUBitLong(8);
bits = msg.ReadUBitLong(16);
}
else {
bits = msg.ReadUBitLong(8);
}
if (bits < 1)
return true;
char*data = new char[bits];
msg.ReadBits(data, bits);
delete[] data;
//printf("Received svc_Sounds, reliable: %i, bits: %i, num: %i\n", reliable, bits, num);
return true;
}
if (type == 18)//svc_SetView
{
int ent = msg.ReadUBitLong(MAX_EDICT_BITS);
printf("Received svc_SetView, ent: %i\n", ent);
return true;
}
if (type == 19)//svc_FixAngle
{
int relative = msg.ReadOneBit();
float x = msg.ReadBitAngle(16);
float y = msg.ReadBitAngle(16);
float z = msg.ReadBitAngle(16);
printf("Received svc_FixAngle, x:%f y: %f z: %f | relative: %i\n", x, y, z, relative);
return true;
}
if (type == 20)//svc_CrosshairAngle
{
int p = msg.ReadUBitLong(16);
int y = msg.ReadUBitLong(16);
int r = msg.ReadUBitLong(16);
printf("Received svc_CrosshairAngle p: %d y: %d r: %d\n", p, y, r);
}
if (type == 21)//svc_BSPDecal
{
Vector vec;
msg.ReadBitVec3Coord(vec);
int texture = msg.ReadUBitLong(9);
int useentity = msg.ReadOneBit();
int ent = 0;
int modulation = 0;
if (useentity == 1)
{
ent = msg.ReadUBitLong(MAX_EDICT_BITS);
modulation = msg.ReadUBitLong(12);//fix me
}
int lowpriority = msg.ReadOneBit();
printf("Received svc_BSPDecal: pos: %f:%f:%f | tex: %i | useent: %i\n", vec.x, vec.y, vec.z, texture, useentity);
return true;
}
if (type == 23)//svc_UserMessage
{
int msgtype = msg.ReadByte();
int bits = msg.ReadUBitLong(MAX_USERMESSAGE_BITS);
if (bits < 1)
return true;
char* data = new char[bits];
msg.ReadBits(data, bits);
bf_read userMsg(data, bits);
if (msgtype == 3)
{
int client = userMsg.ReadByte();
//int bWantsChat = userMsg.ReadByte();
char readstr[MAX_USER_MSG_DATA];
userMsg.ReadString(readstr, sizeof(readstr));
int something3 = userMsg.ReadByte(); //idk, sometimes 1, might be bchat
int something4 = userMsg.ReadByte(); //seems to be 1 when teamchatting
int something5 = userMsg.ReadByte(); //idk, sometimes 1
printf("Chat message: %i:%s __ %i\n", client, readstr, userMsg.GetNumBytesLeft());
delete[] data;
return true;
}
if (msgtype == 5)
{
userMsg.ReadByte();
char readstr[MAX_USER_MSG_DATA];
userMsg.ReadString(readstr, sizeof(readstr));
printf("umsg print: %s\n", readstr);
}
if (msgtype == 44)//nwvar
{
int c**k = userMsg.ReadUBitLong(32);
int cock2 = userMsg.ReadByte();
char str[255];
userMsg.ReadString(str, sizeof(str));
char str2[255];
userMsg.ReadString(str2, sizeof(str2));
//printf("cock1:%i cock2: %i name: %s str2: %s | left: %i\n", c**k, cock2, str, str2, userMsg.GetNumBytesLeft());
delete[] data;
return true;
}
delete[] data;
printf("Received svc_UserMessage, type: %i | bits: %i\n", msgtype, bits);
return true;
}
if (type == 24)//svc_EntityMessage
{
int ent = msg.ReadUBitLong(MAX_EDICT_BITS);
int entclass = msg.ReadUBitLong(MAX_SERVER_CLASS_BITS);
int bits = msg.ReadUBitLong(MAX_ENTITYMESSAGE_BITS);
if (bits < 1)
return true;
char *data = new char[bits];
msg.ReadBits(data, bits);
delete[] data;
printf("Received svc_EntityMessage, ent: %i | class: %i | bits: %i\n", ent, entclass, bits);
return true;
}
if (type == 25)//svc_GameEvent
{
int bits = msg.ReadUBitLong(11);
if (bits < 1)
return true;
char *data = new char[bits];
msg.ReadBits(data, bits);
delete[] data;
printf("Received svc_GameEvent, bits: %i\n", bits);
return true;
}
if (type == 26)//svc_PacketEntities
{
int max = msg.ReadUBitLong(MAX_EDICT_BITS);
int isdelta = msg.ReadOneBit();
int delta = -1;
if (isdelta)
{
delta = msg.ReadLong();
}
int baseline = msg.ReadUBitLong(1);
int changed = msg.ReadUBitLong(MAX_EDICT_BITS);
int bits = msg.ReadUBitLong(20);
int updatebaseline = msg.ReadOneBit();
int bytes = bits / 8;
if (bits < 1)
return true;
char *data = new char[bits];
msg.ReadBits(data, bits);
delete[] data;
//printf("Received svc_PacketEntities, max: %i | isdelta: %i | line: %i | changed: %i | bits: %i | update: %i\n", max, isdelta, baseline, changed, bits, updatebaseline);
return true;
}
if (type == 27)//svc_TempEntities
{
int num = msg.ReadUBitLong(8);
int bits = msg.ReadVarInt32();
if (bits < 1)
return true;
char *data = new char[bits];
msg.ReadBits(data, bits);
delete[] data;
printf("Received svc_TempEntities, num: %i | bits: %i\n", num, bits);
if (bconnectstep)
{
/*
leynet_tcp tcp;
printf("TCP TIME2\n");
tcp.OpenConnection(serverip, serverport);//is that really the tcp port
printf("CONNECTED: %s __ %i\n", serverip, serverport);
senddata.Reset();
memset(netsendbuffer, 0xFF, NETBUFFER_SIZE);
tcp.Send("\x09", 1);
Sleep(100);
senddata.WriteUBitLong(10, 6);
senddata.WriteWord(0xFFFF);
for (int i = 0; i < 1000; i++)
{
senddata.WriteOneBit(i%2==0);
}
tcp.Send((const char*)senddata.GetData(), senddata.GetNumBytesWritten());
*/
senddata.WriteUBitLong(6, 6);
senddata.WriteByte(6);
senddata.WriteLong(netchan->m_iServerCount);
senddata.WriteUBitLong(11, 6);
senddata.WriteLong(net_tick);
senddata.WriteUBitLong(1, 1);
Sleep(2000);
bconnectstep = 0;
}
return true;
}
if (type == 28)//svc_Prefetch
{
int index = msg.ReadUBitLong(4);
printf("Received svc_Prefetch, index: %i\n", index);
return true;
}
if (type == 30)//svc_GameEventList
{
int num = msg.ReadUBitLong(9);
int bits = msg.ReadUBitLong(20);
if (bits < 1)
return true;
char *data = new char[bits];
msg.ReadBits(data, bits);
printf("Received svc_GameEventList, num: %i | bits: %i\n", num, bits);
delete[] data;
return true;
}
if (type == 31)//svc_GetCvarValue
{
int cookie = msg.ReadUBitLong(32);
char cvarname[255];
msg.ReadString(cvarname, sizeof(cvarname));
printf("Received svc_GetCvarValue, cookie: %i | name: %s\n", cookie, cvarname);
return true;
}
if (type == 33)//svc_GMod_ServerToClient
{
int bits = msg.ReadUBitLong(20);
int type = msg.ReadByte(); // 4= probably server telling about files
if (bits < 1)
return true;
if (bits < 0)
{
printf("Received svc_Gmod_ServerToClient || Invalid!\n");
return true;
}
if (type == 4)
{
char* data = new char[bits];
int id = msg.ReadWord();
int toread = bits - 8 - 16;
if (toread > 0)
{
msg.ReadBits(data, toread);
}
printf("Received svc_GMod_ServerToClient, type: %i | bits: %i | id: %i \n", type, bits, id);
delete[] data;
return true;
}
if(type==3)
{
printf("Received svc_GMod_ServerToClient, type: %i | bits: %i\n", type, bits);
return true;
}
if (type == 0)
{
int id = msg.ReadWord();
char* data = new char[bits];
int toread = bits - 8 - 16;
if (toread > 0)
{
msg.ReadBits(data, toread);
}
delete[] data;
printf("Received svc_GMod_ServerToClient, type: %i | bits: %i\n", type, bits);
return true;
}
printf("Received svc_GMod_ServerToClient, type: %i | bits: %i\n", type, bits);
return true;
}
return false;
}
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)
{
bconnectstep = 3;
printf("Connected successfully\n");
netchan->Initialize();
senddata.WriteUBitLong(6, 6);
senddata.WriteByte(2);
senddata.WriteLong(-1);
senddata.WriteUBitLong(4, 6);
senddata.WriteString("VModEnable 1");
senddata.WriteUBitLong(4, 6);
senddata.WriteString("vban 0 0 0 0");
/*
senddata.WriteByte(31);
for (int i = 0; i < 31; i++)
{
senddata.WriteString("gm_snapangles");
senddata.WriteString("45");
}s
*/
NET_SendDatagram();
Sleep(3000);
}
return 0;
}
case 'I':
{
return 0;
}
default:
{
printf("Unknown message received from: %s, header: %i ( %c )\n", ip, header, header);
break;
}
}
return 0;
}