/*
================
idTarget_FadeEntity::Event_Activate
================
*/
void idTarget_FadeEntity::Event_Activate( idEntity *activator ) {
idEntity *ent;
int i;
if ( !targets.Num() ) {
return;
}
// always allow during cinematics
cinematic = true;
BecomeActive( TH_THINK );
ent = this;
for( i = 0; i < targets.Num(); i++ ) {
ent = targets[ i ].GetEntity();
if ( ent ) {
ent->GetColor( fadeFrom );
break;
}
}
fadeStart = gameLocal.time;
fadeEnd = gameLocal.time + SEC2MS( spawnArgs.GetFloat( "fadetime" ) );
}
/*
================
idTrigger_Hurt::Event_Touch
================
*/
void idTrigger_Hurt::Event_Touch( idEntity *other, trace_t *trace )
{
const char *damage;
if( on && other && gameLocal.time >= nextTime )
{
#ifdef _D3XP
bool playerOnly = spawnArgs.GetBool( "playerOnly" );
if( playerOnly )
{
if( !other->IsType( idPlayer::Type ) )
{
return;
}
}
#endif
damage = spawnArgs.GetString( "def_damage", "damage_painTrigger" );
#ifdef _D3XP
idVec3 dir = vec3_origin;
if( spawnArgs.GetBool( "kick_from_center", "0" ) )
{
dir = other->GetPhysics()->GetOrigin() - GetPhysics()->GetOrigin();
dir.Normalize();
}
other->Damage( NULL, NULL, dir, damage, 1.0f, INVALID_JOINT );
#else
other->Damage( NULL, NULL, vec3_origin, damage, 1.0f, INVALID_JOINT );
#endif
ActivateTargets( other );
CallScript();
nextTime = gameLocal.time + SEC2MS( delay );
}
}
bool CClientList::IsKadFirewallCheckIP(uint32 dwIP) const{
for (POSITION pos = listFirewallCheckRequests.GetHeadPosition(); pos != NULL; listFirewallCheckRequests.GetNext(pos)){
if (listFirewallCheckRequests.GetAt(pos).dwIP == dwIP && ::GetTickCount() - listFirewallCheckRequests.GetAt(pos).dwInserted < SEC2MS(180))
return true;
}
return false;
}
/**
* The thread method that handles calling send for the individual sockets.
*
* Control packets will always be tried to be sent first. If there is any bandwidth leftover
* after that, send() for the upload slot sockets will be called in priority order until we have run
* out of available bandwidth for this loop. Upload slots will not be allowed to go without having sent
* called for more than a defined amount of time (i.e. two seconds).
*
* @return always returns 0.
*/
UINT UploadBandwidthThrottler::RunInternal() {
DWORD lastLoopTick = timeGetTime();
sint64 realBytesToSpend = 0;
uint32 allowedDataRate = 0;
uint32 rememberedSlotCounter = 0;
DWORD lastTickReachedBandwidth = timeGetTime();
uint32 nEstiminatedLimit = 0;
int nSlotsBusyLevel = 0;
DWORD nUploadStartTime = 0;
uint32 numberOfConsecutiveUpChanges = 0;
uint32 numberOfConsecutiveDownChanges = 0;
uint32 changesCount = 0;
uint32 loopsCount = 0;
bool estimateChangedLog = false;
bool lotsOfLog = false;
while(doRun) {
pauseEvent->Lock();
DWORD timeSinceLastLoop = timeGetTime() - lastLoopTick;
// Get current speed from UploadSpeedSense
allowedDataRate = theApp.lastCommonRouteFinder->GetUpload();
// check busy level for all the slots (WSAEWOULDBLOCK status)
uint32 cBusy = 0;
uint32 nCanSend = 0;
sendLocker.Lock();
for (int i = 0; i < m_StandardOrder_list.GetSize() && (i < 3 || (UINT)i < GetSlotLimit(theApp.uploadqueue->GetDatarate())); i++) {
if (m_StandardOrder_list[i] != NULL && m_StandardOrder_list[i]->HasQueues()) {
nCanSend++;
if(m_StandardOrder_list[i]->IsBusy())
cBusy++;
}
}
sendLocker.Unlock();
// if this is kept, the loop above can be a little optimized (don't count nCanSend, just use nCanSend = GetSlotLimit(theApp.uploadqueue->GetDatarate())
if(theApp.uploadqueue)
nCanSend = max(nCanSend, GetSlotLimit(theApp.uploadqueue->GetDatarate()));
// When no upload limit has been set in options, try to guess a good upload limit.
bool bUploadUnlimited = (thePrefs.GetMaxUpload() == UNLIMITED);
if (bUploadUnlimited) {
loopsCount++;
//if(lotsOfLog) theApp.QueueDebugLogLine(false,_T("Throttler: busy: %i/%i nSlotsBusyLevel: %i Guessed limit: %0.5f changesCount: %i loopsCount: %i"), cBusy, nCanSend, nSlotsBusyLevel, (float)nEstiminatedLimit/1024.00f, changesCount, loopsCount);
if(nCanSend > 0) {
float fBusyPercent = ((float)cBusy/(float)nCanSend) * 100;
if (cBusy > 2 && fBusyPercent > 75.00f && nSlotsBusyLevel < 255) {
nSlotsBusyLevel++;
changesCount++;
if(thePrefs.GetVerbose() && lotsOfLog && nSlotsBusyLevel%25==0) theApp.QueueDebugLogLine(false,_T("Throttler: nSlotsBusyLevel: %i Guessed limit: %0.5f changesCount: %i loopsCount: %i"), nSlotsBusyLevel, (float)nEstiminatedLimit/1024.00f, changesCount, loopsCount);
}
else if ( (cBusy <= 2 || fBusyPercent < 25.00f) && nSlotsBusyLevel > (-255)) {
nSlotsBusyLevel--;
changesCount++;
if(thePrefs.GetVerbose() && lotsOfLog && nSlotsBusyLevel%25==0) theApp.QueueDebugLogLine(false,_T("Throttler: nSlotsBusyLevel: %i Guessed limit: %0.5f changesCount %i loopsCount: %i"), nSlotsBusyLevel, (float)nEstiminatedLimit/1024.00f, changesCount, loopsCount);
}
}
if(nUploadStartTime == 0) {
if (m_StandardOrder_list.GetSize() >= 3)
nUploadStartTime = timeGetTime();
} else if(timeGetTime()- nUploadStartTime > SEC2MS(60)) {
if (theApp.uploadqueue) {
if (nEstiminatedLimit == 0) { // no autolimit was set yet
if (nSlotsBusyLevel >= 250) { // sockets indicated that the BW limit has been reached
nEstiminatedLimit = theApp.uploadqueue->GetDatarate();
allowedDataRate = min(nEstiminatedLimit, allowedDataRate);
nSlotsBusyLevel = -200;
if(thePrefs.GetVerbose() && estimateChangedLog) theApp.QueueDebugLogLine(false,_T("Throttler: Set inital estimated limit to %0.5f changesCount: %i loopsCount: %i"), (float)nEstiminatedLimit/1024.00f, changesCount, loopsCount);
changesCount = 0;
loopsCount = 0;
}
}
else {
if (nSlotsBusyLevel > 250) {
if(changesCount > 500 || changesCount > 300 && loopsCount > 1000 || loopsCount > 2000) {
numberOfConsecutiveDownChanges = 0;
}
numberOfConsecutiveDownChanges++;
uint32 changeDelta = CalculateChangeDelta(numberOfConsecutiveDownChanges);
// Don't lower speed below 1 KBytes/s
if(nEstiminatedLimit < changeDelta + 1024) {
if(nEstiminatedLimit > 1024) {
changeDelta = nEstiminatedLimit - 1024;
} else {
changeDelta = 0;
}
}
ASSERT(nEstiminatedLimit >= changeDelta + 1024);
nEstiminatedLimit -= changeDelta;
if(thePrefs.GetVerbose() && estimateChangedLog) theApp.QueueDebugLogLine(false,_T("Throttler: REDUCED limit #%i with %i bytes to: %0.5f changesCount: %i loopsCount: %i"), numberOfConsecutiveDownChanges, changeDelta, (float)nEstiminatedLimit/1024.00f, changesCount, loopsCount);
numberOfConsecutiveUpChanges = 0;
nSlotsBusyLevel = 0;
changesCount = 0;
loopsCount = 0;
}
else if (nSlotsBusyLevel < (-250)) {
if(changesCount > 500 || changesCount > 300 && loopsCount > 1000 || loopsCount > 2000) {
numberOfConsecutiveUpChanges = 0;
}
numberOfConsecutiveUpChanges++;
uint32 changeDelta = CalculateChangeDelta(numberOfConsecutiveUpChanges);
// Don't raise speed unless we are under current allowedDataRate
if(nEstiminatedLimit+changeDelta > allowedDataRate) {
if(nEstiminatedLimit < allowedDataRate) {
changeDelta = allowedDataRate - nEstiminatedLimit;
} else {
changeDelta = 0;
}
}
ASSERT(nEstiminatedLimit < allowedDataRate && nEstiminatedLimit+changeDelta <= allowedDataRate || nEstiminatedLimit >= allowedDataRate && changeDelta == 0);
nEstiminatedLimit += changeDelta;
if(thePrefs.GetVerbose() && estimateChangedLog) theApp.QueueDebugLogLine(false,_T("Throttler: INCREASED limit #%i with %i bytes to: %0.5f changesCount: %i loopsCount: %i"), numberOfConsecutiveUpChanges, changeDelta, (float)nEstiminatedLimit/1024.00f, changesCount, loopsCount);
numberOfConsecutiveDownChanges = 0;
nSlotsBusyLevel = 0;
changesCount = 0;
loopsCount = 0;
}
allowedDataRate = min(nEstiminatedLimit, allowedDataRate);
}
}
}
}
if(cBusy == nCanSend && m_StandardOrder_list.GetSize() > 0) {
allowedDataRate = 0;
if(nSlotsBusyLevel < 125 && bUploadUnlimited) {
nSlotsBusyLevel = 125;
if(thePrefs.GetVerbose() && lotsOfLog) theApp.QueueDebugLogLine(false,_T("Throttler: nSlotsBusyLevel: %i Guessed limit: %0.5f changesCount %i loopsCount: %i (set due to all slots busy)"), nSlotsBusyLevel, (float)nEstiminatedLimit/1024.00f, changesCount, loopsCount);
}
}
uint32 minFragSize = 1300;
uint32 doubleSendSize = minFragSize*2; // send two packages at a time so they can share an ACK
if(allowedDataRate < 6*1024) {
minFragSize = 536;
doubleSendSize = minFragSize; // don't send two packages at a time at very low speeds to give them a smoother load
}
#define TIME_BETWEEN_UPLOAD_LOOPS 1
uint32 sleepTime;
if(allowedDataRate == _UI32_MAX || realBytesToSpend >= 1000 || allowedDataRate == 0 && nEstiminatedLimit == 0) {
// we could send at once, but sleep a while to not suck up all cpu
sleepTime = TIME_BETWEEN_UPLOAD_LOOPS;
} else if(allowedDataRate == 0) {
sleepTime = max((uint32)ceil(((double)doubleSendSize*1000)/nEstiminatedLimit), TIME_BETWEEN_UPLOAD_LOOPS);
} else {
// sleep for just as long as we need to get back to having one byte to send
sleepTime = max((uint32)ceil((double)(-realBytesToSpend + 1000)/allowedDataRate), TIME_BETWEEN_UPLOAD_LOOPS);
}
if(timeSinceLastLoop < sleepTime) {
Sleep(sleepTime-timeSinceLastLoop);
}
const DWORD thisLoopTick = timeGetTime();
timeSinceLastLoop = thisLoopTick - lastLoopTick;
// Calculate how many bytes we can spend
sint64 bytesToSpend = 0;
if(allowedDataRate != _UI32_MAX) {
// prevent overflow
if(timeSinceLastLoop == 0) {
// no time has passed, so don't add any bytes. Shouldn't happen.
bytesToSpend = 0; //realBytesToSpend/1000;
} else if(_I64_MAX/timeSinceLastLoop > allowedDataRate && _I64_MAX-allowedDataRate*timeSinceLastLoop > realBytesToSpend) {
if(timeSinceLastLoop > sleepTime + 2000) {
theApp.QueueDebugLogLine(false,_T("UploadBandwidthThrottler: Time since last loop too long. time: %ims wanted: %ims Max: %ims"), timeSinceLastLoop, sleepTime, sleepTime + 2000);
timeSinceLastLoop = sleepTime + 2000;
lastLoopTick = thisLoopTick - timeSinceLastLoop;
}
realBytesToSpend += allowedDataRate*timeSinceLastLoop;
bytesToSpend = realBytesToSpend/1000;
} else {
realBytesToSpend = _I64_MAX;
bytesToSpend = _I32_MAX;
}
} else {
realBytesToSpend = 0; //_I64_MAX;
bytesToSpend = _I32_MAX;
}
lastLoopTick = thisLoopTick;
if(bytesToSpend >= 1 || allowedDataRate == 0) {
uint64 spentBytes = 0;
uint64 spentOverhead = 0;
sendLocker.Lock();
tempQueueLocker.Lock();
// are there any sockets in m_TempControlQueue_list? Move them to normal m_ControlQueue_list;
while(!m_TempControlQueueFirst_list.IsEmpty()) {
ThrottledControlSocket* moveSocket = m_TempControlQueueFirst_list.RemoveHead();
m_ControlQueueFirst_list.AddTail(moveSocket);
}
while(!m_TempControlQueue_list.IsEmpty()) {
ThrottledControlSocket* moveSocket = m_TempControlQueue_list.RemoveHead();
m_ControlQueue_list.AddTail(moveSocket);
}
tempQueueLocker.Unlock();
// Send any queued up control packets first
while((bytesToSpend > 0 && spentBytes < (uint64)bytesToSpend || allowedDataRate == 0 && spentBytes < 500) && (!m_ControlQueueFirst_list.IsEmpty() || !m_ControlQueue_list.IsEmpty())) {
ThrottledControlSocket* socket = NULL;
if(!m_ControlQueueFirst_list.IsEmpty()) {
socket = m_ControlQueueFirst_list.RemoveHead();
} else if(!m_ControlQueue_list.IsEmpty()) {
socket = m_ControlQueue_list.RemoveHead();
}
if(socket != NULL) {
SocketSentBytes socketSentBytes = socket->SendControlData(allowedDataRate > 0?(UINT)(bytesToSpend - spentBytes):1, minFragSize);
uint32 lastSpentBytes = socketSentBytes.sentBytesControlPackets + socketSentBytes.sentBytesStandardPackets;
spentBytes += lastSpentBytes;
spentOverhead += socketSentBytes.sentBytesControlPackets;
}
}
// Check if any sockets haven't gotten data for a long time. Then trickle them a package.
for(uint32 slotCounter = 0; slotCounter < (uint32)m_StandardOrder_list.GetSize(); slotCounter++) {
ThrottledFileSocket* socket = m_StandardOrder_list.GetAt(slotCounter);
if(socket != NULL) {
if(thisLoopTick-socket->GetLastCalledSend() > SEC2MS(1)) {
// trickle
uint32 neededBytes = socket->GetNeededBytes();
if(neededBytes > 0) {
SocketSentBytes socketSentBytes = socket->SendFileAndControlData(neededBytes, minFragSize);
uint32 lastSpentBytes = socketSentBytes.sentBytesControlPackets + socketSentBytes.sentBytesStandardPackets;
spentBytes += lastSpentBytes;
spentOverhead += socketSentBytes.sentBytesControlPackets;
if(lastSpentBytes > 0 && slotCounter < m_highestNumberOfFullyActivatedSlots) {
m_highestNumberOfFullyActivatedSlots = slotCounter;
}
}
}
} else {
theApp.QueueDebugLogLine(false,_T("There was a NULL socket in the UploadBandwidthThrottler Standard list (trickle)! Prevented usage. Index: %i Size: %i"), slotCounter, m_StandardOrder_list.GetSize());
}
}
// Equal bandwidth for all slots
uint32 maxSlot = (uint32)m_StandardOrder_list.GetSize();
if(maxSlot > 0 && allowedDataRate/maxSlot < UPLOAD_CLIENT_DATARATE) {
maxSlot = allowedDataRate/UPLOAD_CLIENT_DATARATE;
}
if(maxSlot > m_highestNumberOfFullyActivatedSlots) {
m_highestNumberOfFullyActivatedSlots = maxSlot;
}
for(uint32 maxCounter = 0; maxCounter < min(maxSlot, (uint32)m_StandardOrder_list.GetSize()) && bytesToSpend > 0 && spentBytes < (uint64)bytesToSpend; maxCounter++) {
if(rememberedSlotCounter >= (uint32)m_StandardOrder_list.GetSize() ||
rememberedSlotCounter >= maxSlot) {
rememberedSlotCounter = 0;
}
ThrottledFileSocket* socket = m_StandardOrder_list.GetAt(rememberedSlotCounter);
if(socket != NULL) {
SocketSentBytes socketSentBytes = socket->SendFileAndControlData((UINT)min(doubleSendSize, bytesToSpend-spentBytes), doubleSendSize);
uint32 lastSpentBytes = socketSentBytes.sentBytesControlPackets + socketSentBytes.sentBytesStandardPackets;
spentBytes += lastSpentBytes;
spentOverhead += socketSentBytes.sentBytesControlPackets;
} else {
theApp.QueueDebugLogLine(false,_T("There was a NULL socket in the UploadBandwidthThrottler Standard list (equal-for-all)! Prevented usage. Index: %i Size: %i"), rememberedSlotCounter, m_StandardOrder_list.GetSize());
}
rememberedSlotCounter++;
}
// Any bandwidth that hasn't been used yet are used first to last.
for(uint32 slotCounter = 0; slotCounter < (uint32)m_StandardOrder_list.GetSize() && bytesToSpend > 0 && spentBytes < (uint64)bytesToSpend; slotCounter++) {
ThrottledFileSocket* socket = m_StandardOrder_list.GetAt(slotCounter);
if(socket != NULL) {
uint32 bytesToSpendTemp = (UINT)(bytesToSpend-spentBytes);
SocketSentBytes socketSentBytes = socket->SendFileAndControlData(bytesToSpendTemp, doubleSendSize);
uint32 lastSpentBytes = socketSentBytes.sentBytesControlPackets + socketSentBytes.sentBytesStandardPackets;
spentBytes += lastSpentBytes;
spentOverhead += socketSentBytes.sentBytesControlPackets;
if(slotCounter+1 > m_highestNumberOfFullyActivatedSlots && (lastSpentBytes < bytesToSpendTemp || lastSpentBytes >= doubleSendSize)) { // || lastSpentBytes > 0 && spentBytes == bytesToSpend /*|| slotCounter+1 == (uint32)m_StandardOrder_list.GetSize())*/)) {
m_highestNumberOfFullyActivatedSlots = slotCounter+1;
}
} else {
theApp.QueueDebugLogLine(false,_T("There was a NULL socket in the UploadBandwidthThrottler Standard list (fully activated)! Prevented usage. Index: %i Size: %i"), slotCounter, m_StandardOrder_list.GetSize());
}
}
realBytesToSpend -= spentBytes*1000;
// If we couldn't spend all allocated bandwidth this loop, some of it is allowed to be saved
// and used the next loop
if(realBytesToSpend < -(((sint64)m_StandardOrder_list.GetSize()+1)*minFragSize)*1000) {
sint64 newRealBytesToSpend = -(((sint64)m_StandardOrder_list.GetSize()+1)*minFragSize)*1000;
realBytesToSpend = newRealBytesToSpend;
lastTickReachedBandwidth = thisLoopTick;
} else {
uint64 bandwidthSavedTolerance = 0;
if(realBytesToSpend > 0 && (uint64)realBytesToSpend > 999+bandwidthSavedTolerance) {
sint64 newRealBytesToSpend = 999+bandwidthSavedTolerance;
//theApp.QueueDebugLogLine(false,_T("UploadBandwidthThrottler::RunInternal(): Too high saved bytesToSpend. Limiting value. Old value: %I64i New value: %I64i"), realBytesToSpend, newRealBytesToSpend);
realBytesToSpend = newRealBytesToSpend;
if(thisLoopTick-lastTickReachedBandwidth > max(1000, timeSinceLastLoop*2)) {
m_highestNumberOfFullyActivatedSlots = m_StandardOrder_list.GetSize()+1;
lastTickReachedBandwidth = thisLoopTick;
//theApp.QueueDebugLogLine(false, _T("UploadBandwidthThrottler: Throttler requests new slot due to bw not reached. m_highestNumberOfFullyActivatedSlots: %i m_StandardOrder_list.GetSize(): %i tick: %i"), m_highestNumberOfFullyActivatedSlots, m_StandardOrder_list.GetSize(), thisLoopTick);
}
} else {
lastTickReachedBandwidth = thisLoopTick;
}
}
// save info about how much bandwidth we've managed to use since the last time someone polled us about used bandwidth
m_SentBytesSinceLastCall += spentBytes;
m_SentBytesSinceLastCallOverhead += spentOverhead;
sendLocker.Unlock();
}
}
threadEndedEvent->SetEvent();
tempQueueLocker.Lock();
m_TempControlQueue_list.RemoveAll();
m_TempControlQueueFirst_list.RemoveAll();
tempQueueLocker.Unlock();
sendLocker.Lock();
m_ControlQueue_list.RemoveAll();
m_StandardOrder_list.RemoveAll();
sendLocker.Unlock();
return 0;
}
/*
================
idClass::PostEventSec
================
*/
bool idClass::PostEventSec( const idEventDef *ev, float time, idEventArg arg1, idEventArg arg2, idEventArg arg3, idEventArg arg4 ) {
return PostEventArgs( ev, SEC2MS( time ), 4, &arg1, &arg2, &arg3, &arg4 );
}
/*
====================
idRenderModelLiquid::InitFromFile
====================
*/
void idRenderModelLiquid::InitFromFile( const char* fileName )
{
int i, x, y;
idToken token;
idParser parser( LEXFL_ALLOWPATHNAMES | LEXFL_NOSTRINGESCAPECHARS );
idList<int> tris;
float size_x, size_y;
float rate;
name = fileName;
if( !parser.LoadFile( fileName ) )
{
MakeDefaultModel();
return;
}
size_x = scale_x * verts_x;
size_y = scale_y * verts_y;
while( parser.ReadToken( &token ) )
{
if( !token.Icmp( "seed" ) )
{
seed = parser.ParseInt();
}
else if( !token.Icmp( "size_x" ) )
{
size_x = parser.ParseFloat();
}
else if( !token.Icmp( "size_y" ) )
{
size_y = parser.ParseFloat();
}
else if( !token.Icmp( "verts_x" ) )
{
verts_x = parser.ParseFloat();
if( verts_x < 2 )
{
parser.Warning( "Invalid # of verts. Using default model." );
MakeDefaultModel();
return;
}
}
else if( !token.Icmp( "verts_y" ) )
{
verts_y = parser.ParseFloat();
if( verts_y < 2 )
{
parser.Warning( "Invalid # of verts. Using default model." );
MakeDefaultModel();
return;
}
}
else if( !token.Icmp( "liquid_type" ) )
{
liquid_type = parser.ParseInt() - 1;
if( ( liquid_type < 0 ) || ( liquid_type >= LIQUID_MAX_TYPES ) )
{
parser.Warning( "Invalid liquid_type. Using default model." );
MakeDefaultModel();
return;
}
}
else if( !token.Icmp( "density" ) )
{
density = parser.ParseFloat();
}
else if( !token.Icmp( "drop_height" ) )
{
drop_height = parser.ParseFloat();
}
else if( !token.Icmp( "drop_radius" ) )
{
drop_radius = parser.ParseInt();
}
else if( !token.Icmp( "drop_delay" ) )
{
drop_delay = SEC2MS( parser.ParseFloat() );
}
else if( !token.Icmp( "shader" ) )
{
parser.ReadToken( &token );
shader = declManager->FindMaterial( token );
}
else if( !token.Icmp( "update_rate" ) )
{
rate = parser.ParseFloat();
if( ( rate <= 0.0f ) || ( rate > 60.0f ) )
{
parser.Warning( "Invalid update_rate. Must be between 0 and 60. Using default model." );
MakeDefaultModel();
return;
}
update_tics = 1000 / rate;
}
else
{
parser.Warning( "Unknown parameter '%s'. Using default model.", token.c_str() );
MakeDefaultModel();
return;
}
}
scale_x = size_x / ( verts_x - 1 );
scale_y = size_y / ( verts_y - 1 );
pages.SetNum( 2 * verts_x * verts_y );
page1 = pages.Ptr();
page2 = page1 + verts_x * verts_y;
verts.SetNum( verts_x * verts_y );
for( i = 0, y = 0; y < verts_y; y++ )
{
for( x = 0; x < verts_x; x++, i++ )
{
page1[ i ] = 0.0f;
page2[ i ] = 0.0f;
verts[ i ].Clear();
verts[ i ].xyz.Set( x * scale_x, y * scale_y, 0.0f );
verts[ i ].SetTexCoord( ( float ) x / ( float )( verts_x - 1 ), ( float ) - y / ( float )( verts_y - 1 ) );
}
}
tris.SetNum( ( verts_x - 1 ) * ( verts_y - 1 ) * 6 );
for( i = 0, y = 0; y < verts_y - 1; y++ )
{
for( x = 1; x < verts_x; x++, i += 6 )
{
tris[ i + 0 ] = y * verts_x + x;
tris[ i + 1 ] = y * verts_x + x - 1;
tris[ i + 2 ] = ( y + 1 ) * verts_x + x - 1;
tris[ i + 3 ] = ( y + 1 ) * verts_x + x - 1;
tris[ i + 4 ] = ( y + 1 ) * verts_x + x;
tris[ i + 5 ] = y * verts_x + x;
}
}
// build the information that will be common to all animations of this mesh:
// sil edge connectivity and normal / tangent generation information
deformInfo = R_BuildDeformInfo( verts.Num(), verts.Ptr(), tris.Num(), tris.Ptr(), true );
bounds.Clear();
bounds.AddPoint( idVec3( 0.0f, 0.0f, drop_height * -10.0f ) );
bounds.AddPoint( idVec3( ( verts_x - 1 ) * scale_x, ( verts_y - 1 ) * scale_y, drop_height * 10.0f ) );
// set the timestamp for reloadmodels
fileSystem->ReadFile( name, NULL, &timeStamp );
Reset();
}
void rvMonsterStreamProtector::InitSpawnArgsVariables ( void ) {
jointPlasmaMuzzle = animator.GetJointHandle ( spawnArgs.GetString ( "joint_plasmaMuzzle", "NM_muzzle" ) );
plasmaAttackRate = SEC2MS ( spawnArgs.GetFloat ( "attack_plasma_rate", ".15" ) );
}
/*
================
idTarget_SetInfluence::Event_Activate
================
*/
void idTarget_SetInfluence::Event_Activate( idEntity *activator )
{
int i, j;
idEntity *ent;
idLight *light;
idSound *sound;
idStaticEntity *generic;
const char *parm;
const char *skin;
bool update;
idVec3 color;
idVec4 colorTo;
idPlayer *player;
player = gameLocal.GetLocalPlayer();
if( spawnArgs.GetBool( "triggerActivate" ) )
{
if( restoreOnTrigger )
{
ProcessEvent( &EV_RestoreInfluence );
restoreOnTrigger = false;
return;
}
restoreOnTrigger = true;
}
float fadeTime = spawnArgs.GetFloat( "fadeWorldSounds" );
if( delay > 0.0f )
{
PostEventSec( &EV_Activate, delay, activator );
delay = 0.0f;
// start any sound fading now
if( fadeTime )
{
gameSoundWorld->FadeSoundClasses( 0, -40.0f, fadeTime );
soundFaded = true;
}
return;
}
else if( fadeTime && !soundFaded )
{
gameSoundWorld->FadeSoundClasses( 0, -40.0f, fadeTime );
soundFaded = true;
}
if( spawnArgs.GetBool( "triggerTargets" ) )
{
ActivateTargets( activator );
}
if( flashIn )
{
PostEventSec( &EV_Flash, 0.0f, flashIn, 0 );
}
parm = spawnArgs.GetString( "snd_influence" );
if( parm && *parm )
{
PostEventSec( &EV_StartSoundShader, flashIn, parm, SND_CHANNEL_ANY );
}
if( switchToCamera )
{
switchToCamera->PostEventSec( &EV_Activate, flashIn + 0.05f, this );
}
int fov = spawnArgs.GetInt( "fov" );
if( fov )
{
fovSetting.Init( gameLocal.time, SEC2MS( spawnArgs.GetFloat( "fovTime" ) ), player->DefaultFov(), fov );
BecomeActive( TH_THINK );
}
for( i = 0; i < genericList.Num(); i++ )
{
ent = gameLocal.entities[genericList[i]];
if( ent == NULL )
{
continue;
}
generic = static_cast<idStaticEntity *>( ent );
color = generic->spawnArgs.GetVector( "color_demonic" );
colorTo.Set( color.x, color.y, color.z, 1.0f );
generic->Fade( colorTo, spawnArgs.GetFloat( "fade_time", "0.25" ) );
}
for( i = 0; i < lightList.Num(); i++ )
{
ent = gameLocal.entities[lightList[i]];
if( ent == NULL || !ent->IsType( idLight::Type ) )
{
continue;
}
light = static_cast<idLight *>( ent );
parm = light->spawnArgs.GetString( "mat_demonic" );
if( parm && *parm )
{
light->SetShader( parm );
}
color = light->spawnArgs.GetVector( "_color" );
color = light->spawnArgs.GetVector( "color_demonic", color.ToString() );
colorTo.Set( color.x, color.y, color.z, 1.0f );
light->Fade( colorTo, spawnArgs.GetFloat( "fade_time", "0.25" ) );
}
for( i = 0; i < soundList.Num(); i++ )
{
ent = gameLocal.entities[soundList[i]];
if( ent == NULL || !ent->IsType( idSound::Type ) )
{
continue;
}
sound = static_cast<idSound *>( ent );
parm = sound->spawnArgs.GetString( "snd_demonic" );
if( parm && *parm )
{
if( sound->spawnArgs.GetBool( "overlayDemonic" ) )
{
sound->StartSound( "snd_demonic", SND_CHANNEL_DEMONIC, 0, false, NULL );
}
else
{
sound->StopSound( SND_CHANNEL_ANY, false );
sound->SetSound( parm );
}
}
}
for( i = 0; i < guiList.Num(); i++ )
{
ent = gameLocal.entities[guiList[i]];
if( ent == NULL || ent->GetRenderEntity() == NULL )
{
continue;
}
update = false;
for( j = 0; j < MAX_RENDERENTITY_GUI; j++ )
{
if( ent->GetRenderEntity()->gui[ j ] && ent->spawnArgs.FindKey( j == 0 ? "gui_demonic" : va( "gui_demonic%d", j + 1 ) ) )
{
#ifdef _D3XP
//Backup the old one
savedGuiList[i].gui[j] = ent->GetRenderEntity()->gui[ j ];
#endif
ent->GetRenderEntity()->gui[ j ] = uiManager->FindGui( ent->spawnArgs.GetString( j == 0 ? "gui_demonic" : va( "gui_demonic%d", j + 1 ) ), true );
update = true;
}
}
if( update )
{
ent->UpdateVisuals();
ent->Present();
}
}
player->SetInfluenceLevel( spawnArgs.GetInt( "influenceLevel" ) );
int snapAngle = spawnArgs.GetInt( "snapAngle" );
if( snapAngle )
{
idAngles ang( 0, snapAngle, 0 );
player->SetViewAngles( ang );
player->SetAngles( ang );
}
if( spawnArgs.GetBool( "effect_vision" ) )
{
parm = spawnArgs.GetString( "mtrVision" );
skin = spawnArgs.GetString( "skinVision" );
player->SetInfluenceView( parm, skin, spawnArgs.GetInt( "visionRadius" ), this );
}
parm = spawnArgs.GetString( "mtrWorld" );
if( parm && *parm )
{
gameLocal.SetGlobalMaterial( declManager->FindMaterial( parm ) );
}
if( !restoreOnTrigger )
{
PostEventMS( &EV_RestoreInfluence, SEC2MS( spawnArgs.GetFloat( "time" ) ) );
}
}
bool
kad_session_init(
uint16_t tcp_port,
uint16_t udp_port,
char* nodes_file_path,
KAD_SESSION** ks_out
)
{
bool result = false;
KAD_SESSION* ks = NULL;
char host_name[HOST_NAME_MAX + 1];
struct hostent* he = NULL;
UINT128 zone_idx;
uint32_t now = 0;
do {
LOG_PREFIX("[libkad] ");
LOG_LEVEL_DEBUG;
LOG_FILE_NAME("libkad.log");
LOG_OUTPUT_CONSOLE_AND_FILE;
if (!ks_out) break;
ks = (KAD_SESSION*)mem_alloc(sizeof(KAD_SESSION));
if (!ks){
LOG_ERROR("Failed to allocate memory for kad session.");
break;
}
ks->version = KADEMLIA_VERSION;
random_init(ticks_now_ms());
gethostname(host_name, HOST_NAME_MAX);
LOG_DEBUG("Host name: %s", host_name);
he = gethostbyname(host_name);
ks->loc_ip4_no = *(uint32_t*)he->h_addr;
kad_fw_set_status(&ks->fw, true);
kad_fw_set_status_udp(&ks->fw, true);
uint128_generate(&ks->kad_id);
LOG_DEBUG_UINT128("kad_id: ", ((UINT128*)&ks->kad_id));
for (uint32_t i = 0; i < sizeof(ks->user_hash); i++){
ks->user_hash[i] = random_uint8();
}
ks->user_hash[5] = 14;
ks->user_hash[14] = 111;
kadhlp_gen_udp_key(&ks->udp_key);
LOG_DEBUG("udp_key: %.8x", ks->udp_key);
ks->udp_port = udp_port;
ks->tcp_port = tcp_port;
LOG_DEBUG("udp_port = %d", udp_port);
LOG_DEBUG("tcp_port = %d", tcp_port);
uint128_init(&zone_idx, 0);
routing_create_zone(NULL, 0, &zone_idx, &ks->root_zone);
list_add_entry(&ks->active_zones, ks->root_zone);
now = ticks_now_ms();
ks->timers.self_lookup = now + MIN2MS(3);
ks->timers.udp_port_lookup = now;
ks->timers.nodes_count_check = now + SEC2MS(10);
ks->opts.use_extrn_udp_port = true;
queue_create(CONTROL_PACKET_QUEUE_LENGTH, &ks->queue_in_udp);
queue_create(CONTROL_PACKET_QUEUE_LENGTH, &ks->queue_out_udp);
if (nodes_file_path) kadhlp_add_nodes_from_file(ks, nodes_file_path);
kadusr_init(ks);
*ks_out = ks;
result = true;
} while (false);
return result;
}
/**
* The thread method that handles calling send for the individual sockets.
*
* Control packets will always be tried to be sent first. If there is any bandwidth leftover
* after that, send() for the upload slot sockets will be called in priority order until we have run
* out of available bandwidth for this loop. Upload slots will not be allowed to go without having sent
* called for more than a defined amount of time (i.e. two seconds).
*
* @return always returns 0.
*/
void* UploadBandwidthThrottler::Entry()
{
const uint32 TIME_BETWEEN_UPLOAD_LOOPS = 1;
uint32 lastLoopTick = GetTickCountFullRes();
// Bytes to spend in current cycle. If we spend more this becomes negative and causes a wait next time.
sint32 bytesToSpend = 0;
uint32 allowedDataRate = 0;
uint32 rememberedSlotCounter = 0;
uint32 extraSleepTime = TIME_BETWEEN_UPLOAD_LOOPS;
while (m_doRun && !TestDestroy()) {
uint32 timeSinceLastLoop = GetTickCountFullRes() - lastLoopTick;
// Calculate data rate
if (thePrefs::GetMaxUpload() == UNLIMITED) {
// Try to increase the upload rate from UploadSpeedSense
allowedDataRate = (uint32)theStats::GetUploadRate() + 5 * 1024;
} else {
allowedDataRate = thePrefs::GetMaxUpload() * 1024;
}
uint32 minFragSize = 1300;
uint32 doubleSendSize = minFragSize*2; // send two packages at a time so they can share an ACK
if (allowedDataRate < 6*1024) {
minFragSize = 536;
doubleSendSize = minFragSize; // don't send two packages at a time at very low speeds to give them a smoother load
}
uint32 sleepTime;
if (bytesToSpend < 1) {
// We have sent more than allowed in last cycle so we have to wait now
// until we can send at least 1 byte.
sleepTime = std::max((-bytesToSpend + 1) * 1000 / allowedDataRate + 2, // add 2 ms to allow for rounding inaccuracies
extraSleepTime);
} else {
// We could send at once, but sleep a while to not suck up all cpu
sleepTime = extraSleepTime;
}
if (timeSinceLastLoop < sleepTime) {
Sleep(sleepTime-timeSinceLastLoop);
}
// Check after sleep in case the thread has been signaled to end
if (!m_doRun || TestDestroy()) {
break;
}
const uint32 thisLoopTick = GetTickCountFullRes();
timeSinceLastLoop = thisLoopTick - lastLoopTick;
lastLoopTick = thisLoopTick;
if (timeSinceLastLoop > sleepTime + 2000) {
AddDebugLogLineN(logGeneral, CFormat(wxT("UploadBandwidthThrottler: Time since last loop too long. time: %ims wanted: %ims Max: %ims"))
% timeSinceLastLoop % sleepTime % (sleepTime + 2000));
timeSinceLastLoop = sleepTime + 2000;
}
// Calculate how many bytes we can spend
bytesToSpend += (sint32) (allowedDataRate / 1000.0 * timeSinceLastLoop);
if (bytesToSpend >= 1) {
sint32 spentBytes = 0;
sint32 spentOverhead = 0;
wxMutexLocker sendLock(m_sendLocker);
{
wxMutexLocker queueLock(m_tempQueueLocker);
// are there any sockets in m_TempControlQueue_list? Move them to normal m_ControlQueue_list;
m_ControlQueueFirst_list.insert( m_ControlQueueFirst_list.end(),
m_TempControlQueueFirst_list.begin(),
m_TempControlQueueFirst_list.end() );
m_ControlQueue_list.insert( m_ControlQueue_list.end(),
m_TempControlQueue_list.begin(),
m_TempControlQueue_list.end() );
m_TempControlQueue_list.clear();
m_TempControlQueueFirst_list.clear();
}
// Send any queued up control packets first
while (spentBytes < bytesToSpend && (!m_ControlQueueFirst_list.empty() || !m_ControlQueue_list.empty())) {
ThrottledControlSocket* socket = NULL;
if (!m_ControlQueueFirst_list.empty()) {
socket = m_ControlQueueFirst_list.front();
m_ControlQueueFirst_list.pop_front();
} else if (!m_ControlQueue_list.empty()) {
socket = m_ControlQueue_list.front();
m_ControlQueue_list.pop_front();
}
if (socket != NULL) {
SocketSentBytes socketSentBytes = socket->SendControlData(bytesToSpend-spentBytes, minFragSize);
spentBytes += socketSentBytes.sentBytesControlPackets + socketSentBytes.sentBytesStandardPackets;
spentOverhead += socketSentBytes.sentBytesControlPackets;
}
}
// Check if any sockets haven't gotten data for a long time. Then trickle them a package.
uint32 slots = m_StandardOrder_list.size();
for (uint32 slotCounter = 0; slotCounter < slots; slotCounter++) {
ThrottledFileSocket* socket = m_StandardOrder_list[ slotCounter ];
if (socket != NULL) {
if (thisLoopTick-socket->GetLastCalledSend() > SEC2MS(1)) {
// trickle
uint32 neededBytes = socket->GetNeededBytes();
if (neededBytes > 0) {
SocketSentBytes socketSentBytes = socket->SendFileAndControlData(neededBytes, minFragSize);
spentBytes += socketSentBytes.sentBytesControlPackets + socketSentBytes.sentBytesStandardPackets;
spentOverhead += socketSentBytes.sentBytesControlPackets;
}
}
} else {
AddDebugLogLineN(logGeneral, CFormat( wxT("There was a NULL socket in the UploadBandwidthThrottler Standard list (trickle)! Prevented usage. Index: %i Size: %i"))
% slotCounter % m_StandardOrder_list.size());
}
}
// Give available bandwidth to slots, starting with the one we ended with last time.
// There are two passes. First pass gives packets of doubleSendSize, second pass
// gives as much as possible.
// Second pass starts with the last slot of the first pass actually.
for (uint32 slotCounter = 0; (slotCounter < slots * 2) && spentBytes < bytesToSpend; slotCounter++) {
if (rememberedSlotCounter >= slots) { // wrap around pointer
rememberedSlotCounter = 0;
}
uint32 data = (slotCounter < slots - 1) ? doubleSendSize // pass 1
: (bytesToSpend - spentBytes); // pass 2
ThrottledFileSocket* socket = m_StandardOrder_list[ rememberedSlotCounter ];
if (socket != NULL) {
SocketSentBytes socketSentBytes = socket->SendFileAndControlData(data, doubleSendSize);
spentBytes += socketSentBytes.sentBytesControlPackets + socketSentBytes.sentBytesStandardPackets;
spentOverhead += socketSentBytes.sentBytesControlPackets;
} else {
AddDebugLogLineN(logGeneral, CFormat(wxT("There was a NULL socket in the UploadBandwidthThrottler Standard list (equal-for-all)! Prevented usage. Index: %i Size: %i"))
% rememberedSlotCounter % m_StandardOrder_list.size());
}
rememberedSlotCounter++;
}
// Do some limiting of what we keep for the next loop.
bytesToSpend -= spentBytes;
sint32 minBytesToSpend = (slots + 1) * minFragSize;
if (bytesToSpend < - minBytesToSpend) {
bytesToSpend = - minBytesToSpend;
} else {
sint32 bandwidthSavedTolerance = slots * 512 + 1;
if (bytesToSpend > bandwidthSavedTolerance) {
bytesToSpend = bandwidthSavedTolerance;
}
}
m_SentBytesSinceLastCall += spentBytes;
m_SentBytesSinceLastCallOverhead += spentOverhead;
if (spentBytes == 0) { // spentBytes includes the overhead
extraSleepTime = std::min<uint32>(extraSleepTime * 5, 1000); // 1s at most
} else {
extraSleepTime = TIME_BETWEEN_UPLOAD_LOOPS;
}
}
}
{
wxMutexLocker queueLock(m_tempQueueLocker);
m_TempControlQueue_list.clear();
m_TempControlQueueFirst_list.clear();
}
wxMutexLocker sendLock(m_sendLocker);
m_ControlQueue_list.clear();
m_StandardOrder_list.clear();
return 0;
}
// RAVEN BEGIN
// jnewquist: Controller rumble
void idPlayerView::DamageImpulse( idVec3 localKickDir, const idDict *damageDef, int damage ) {
//
// double vision effect
//
float tvTime = damageDef->GetFloat( "tv_time" );
if ( tvTime ) {
tvStartTime = gameLocal.time;
tvFinishTime = gameLocal.time + tvTime;
damageDef->GetFloat ( "tv_scale", "1", tvScale );
}
if ( lastDamageTime > 0.0f && SEC2MS( lastDamageTime ) + IMPULSE_DELAY > gameLocal.time ) {
// keep shotgun from obliterating the view
return;
}
//
// double vision effect
//
float dvTime = damageDef->GetFloat( "dv_time" );
if ( dvTime ) {
dvFinishTime = gameLocal.time + (g_dvTime.GetFloat() * dvTime);
damageDef->GetFloat ( "dv_scale", "1", dvScale );
}
//
// head angle kick
//
const float modifierScale = 0.25f;
const float inverseModifier = ( 1.0f - modifierScale );
float modifier = idMath::ClampFloat( 0.0f, inverseModifier, damage / 100.0f * inverseModifier ) + modifierScale;
float kickTime = damageDef->GetFloat( "kick_time" );
if ( kickTime ) {
kickFinishTime = gameLocal.time + g_kickTime.GetFloat() * kickTime;
// forward / back kick will pitch view
kickAngles[0] = localKickDir[0];
// side kick will yaw view
kickAngles[1] = localKickDir[1]*0.5f;
// up / down kick will pitch view
kickAngles[0] += localKickDir[2];
// roll will come from side
kickAngles[2] = localKickDir[1];
float kickAmplitude = damageDef->GetFloat( "kick_amplitude" );
if ( kickAmplitude ) {
kickAngles *= kickAmplitude;
}
if ( modifier < kickAmplitude ) {
modifier = kickAmplitude;
}
}
else {
kickTime = 500;
}
//
// screen blob
//
float blobTime = damageDef->GetFloat( "blob_time" );
if ( blobTime ) {
screenBlob_t *blob = GetScreenBlob();
blob->startFadeTime = gameLocal.time;
blob->finishTime = gameLocal.time + blobTime * g_blobTime.GetFloat();
const char *materialName = damageDef->GetString( "mtr_blob" );
blob->material = declManager->FindMaterial( materialName );
blob->x = damageDef->GetFloat( "blob_x" );
blob->x += ( gameLocal.random.RandomInt()&63 ) - 32;
blob->y = damageDef->GetFloat( "blob_y" );
blob->y += ( gameLocal.random.RandomInt()&63 ) - 32;
float scale = ( 256 + ( ( gameLocal.random.RandomInt()&63 ) - 32 ) ) / 256.0f;
blob->w = damageDef->GetFloat( "blob_width" ) * g_blobSize.GetFloat() * scale;
blob->h = damageDef->GetFloat( "blob_height" ) * g_blobSize.GetFloat() * scale;
blob->s1 = 0;
blob->t1 = 0;
blob->s2 = 1;
blob->t2 = 1;
}
//
// save lastDamageTime for tunnel vision accentuation
//
lastDamageTime = MS2SEC( gameLocal.time );
}
UINT GetPeerCacheSocketDownloadTimeout()
{
return DOWNLOADTIMEOUT + SEC2MS(20); // must be lower than Upload timeout
}
UINT GetPeerCacheSocketUploadTimeout()
{
return DOWNLOADTIMEOUT + SEC2MS(20 + 30);
}
/*
================
idTrigger_Multi::Event_Touch
================
*/
void idTrigger_Multi::Event_Touch( idEntity* other, trace_t* trace )
{
if( common->IsClient() )
{
return;
}
if( triggerFirst )
{
return;
}
bool player = other->IsType( idPlayer::Type );
if( player )
{
if( !touchClient )
{
return;
}
if( static_cast< idPlayer* >( other )->spectating )
{
return;
}
}
else if( !touchOther )
{
return;
}
if( nextTriggerTime > gameLocal.time )
{
// can't retrigger until the wait is over
return;
}
// see if this trigger requires an item
if( !gameLocal.RequirementMet( other, requires, removeItem ) )
{
return;
}
if( !CheckFacing( other ) )
{
return;
}
if( spawnArgs.GetBool( "toggleTriggerFirst" ) )
{
triggerFirst = true;
}
nextTriggerTime = gameLocal.time + 1;
if( delay > 0 )
{
// don't allow it to trigger again until our delay has passed
nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
PostEventSec( &EV_TriggerAction, delay, other );
}
else
{
TriggerAction( other );
}
}
void CDownloadQueue::ProcessLocalRequests()
{
wxMutexLocker lock( m_mutex );
bool bServerSupportsLargeFiles = theApp->serverconnect
&& theApp->serverconnect->GetCurrentServer()
&& theApp->serverconnect->GetCurrentServer()->SupportsLargeFilesTCP();
if ( (!m_localServerReqQueue.empty()) && (m_dwNextTCPSrcReq < ::GetTickCount()) ) {
CMemFile dataTcpFrame(22);
const int iMaxFilesPerTcpFrame = 15;
int iFiles = 0;
while (!m_localServerReqQueue.empty() && iFiles < iMaxFilesPerTcpFrame) {
// find the file with the longest waitingtime
uint32 dwBestWaitTime = 0xFFFFFFFF;
std::list<CPartFile*>::iterator posNextRequest = m_localServerReqQueue.end();
std::list<CPartFile*>::iterator it = m_localServerReqQueue.begin();
while( it != m_localServerReqQueue.end() ) {
CPartFile* cur_file = (*it);
if (cur_file->GetStatus() == PS_READY || cur_file->GetStatus() == PS_EMPTY) {
uint8 nPriority = cur_file->GetDownPriority();
if (nPriority > PR_HIGH) {
wxFAIL;
nPriority = PR_HIGH;
}
if (cur_file->GetLastSearchTime() + (PR_HIGH-nPriority) < dwBestWaitTime ){
dwBestWaitTime = cur_file->GetLastSearchTime() + (PR_HIGH - nPriority);
posNextRequest = it;
}
it++;
} else {
it = m_localServerReqQueue.erase(it);
cur_file->SetLocalSrcRequestQueued(false);
AddDebugLogLineN(logDownloadQueue,
CFormat(wxT("Local server source request for file '%s' not sent because of status '%s'"))
% cur_file->GetFileName() % cur_file->getPartfileStatus());
}
}
if (posNextRequest != m_localServerReqQueue.end()) {
CPartFile* cur_file = (*posNextRequest);
cur_file->SetLocalSrcRequestQueued(false);
cur_file->SetLastSearchTime(::GetTickCount());
m_localServerReqQueue.erase(posNextRequest);
iFiles++;
if (!bServerSupportsLargeFiles && cur_file->IsLargeFile()) {
AddDebugLogLineN(logDownloadQueue, wxT("TCP Request for sources on a large file ignored: server doesn't support it"));
} else {
AddDebugLogLineN(logDownloadQueue,
CFormat(wxT("Creating local sources request packet for '%s'")) % cur_file->GetFileName());
// create request packet
CMemFile data(16 + (cur_file->IsLargeFile() ? 8 : 4));
data.WriteHash(cur_file->GetFileHash());
// Kry - lugdunum extended protocol on 17.3 to handle filesize properly.
// There is no need to check anything, old server ignore the extra 4 bytes.
// As of 17.9, servers accept a 0 32-bits size and then a 64bits size
if (cur_file->IsLargeFile()) {
wxASSERT(bServerSupportsLargeFiles);
data.WriteUInt32(0);
data.WriteUInt64(cur_file->GetFileSize());
} else {
data.WriteUInt32(cur_file->GetFileSize());
}
uint8 byOpcode = 0;
if (thePrefs::IsClientCryptLayerSupported() && theApp->serverconnect->GetCurrentServer() != NULL && theApp->serverconnect->GetCurrentServer()->SupportsGetSourcesObfuscation()) {
byOpcode = OP_GETSOURCES_OBFU;
} else {
byOpcode = OP_GETSOURCES;
}
CPacket packet(data, OP_EDONKEYPROT, byOpcode);
dataTcpFrame.Write(packet.GetPacket(), packet.GetRealPacketSize());
}
}
}
int iSize = dataTcpFrame.GetLength();
if (iSize > 0) {
// create one 'packet' which contains all buffered OP_GETSOURCES ED2K packets to be sent with one TCP frame
// server credits: (16+4)*regularfiles + (16+4+8)*largefiles +1
CScopedPtr<CPacket> packet(new CPacket(new byte[iSize], dataTcpFrame.GetLength(), true, false));
dataTcpFrame.Seek(0, wxFromStart);
dataTcpFrame.Read(packet->GetPacket(), iSize);
uint32 size = packet->GetPacketSize();
theApp->serverconnect->SendPacket(packet.release(), true); // Deletes `packet'.
AddDebugLogLineN(logDownloadQueue, wxT("Sent local sources request packet."));
theStats::AddUpOverheadServer(size);
}
// next TCP frame with up to 15 source requests is allowed to be sent in..
m_dwNextTCPSrcReq = ::GetTickCount() + SEC2MS(iMaxFilesPerTcpFrame*(16+4));
}
}
uint8_t
node_create(
UINT128* id,
uint32_t self_ip4_no,
uint32_t ip4_no,
uint16_t tcp_port_no,
uint16_t udp_port_no,
uint8_t version,
uint32_t udp_key,
bool ip_verified,
UINT128* dist,
KAD_NODE** kn_out
)
{
uint8_t result = 0;
KAD_NODE* kn;
#ifdef CONFIG_VERBOSE
struct in_addr ia = {0};
#endif
uint32_t now;
do {
if (!id || !dist || !kn_out) break;
LOG_DEBUG("+++node_create+++");
LOG_DEBUG_UINT128("id:", id);
#ifdef CONFIG_VERBOSE
ia.s_addr = ip4_no;
#endif
LOG_DEBUG("ip %s, tcp_port %.4d, udp_port %.4d, version %.2d", inet_ntoa(ia), ntohs(tcp_port_no), ntohs(udp_port_no), version);
LOG_DEBUG_UINT128("distance", dist);
kn = (KAD_NODE*)mem_alloc(sizeof(KAD_NODE));
if (!kn) {
LOG_ERROR("Failed to allocate memory for node.");
break;
}
memcpy(&kn->id, id, sizeof(UINT128));
uint128_copy(id, &kn->id);
kn->ip4_no = ip4_no;
kn->tcp_port_no = tcp_port_no;
kn->udp_port_no = udp_port_no;
uint128_copy(dist, &kn->dist);
kn->status = NODE_STATUS_NEW;
now = ticks_now_ms();
kn->created = now;
kn->next_check_time = now + SEC2MS(5);
kn->packet_timeout = 0;
kn->version = version;
kn->check_kad2 = true;
kn->ip_verified = ip_verified;
kn->hello_received = false;
node_set_udp_key_with_ip(kn, udp_key, self_ip4_no);
#ifdef CONFIG_VERBOSE
strcpy(kn->ip4_str, inet_ntoa(ia));
#endif
// Here should be node lock initializer
*kn_out = kn;
result = 1;
} while (false);
if (!result && kn) mem_free(kn);
return result;
}
void SearchingState::Init( idAI *owner ) {
// Init base class first
State::Init( owner );
DM_LOG( LC_AI, LT_INFO )LOGSTRING( "SearchingState initialised.\r" );
assert( owner );
// Ensure we are in the correct alert level
if( !CheckAlertLevel( owner ) ) {
return;
}
if( owner->GetMoveType() == MOVETYPE_SIT || owner->GetMoveType() == MOVETYPE_SLEEP ) {
owner->GetUp();
}
// Shortcut reference
Memory &memory = owner->GetMemory();
float alertTime = owner->atime3 + owner->atime3_fuzzyness * ( gameLocal.random.RandomFloat() - 0.5 );
_alertLevelDecreaseRate = ( owner->thresh_4 - owner->thresh_3 ) / alertTime;
if( owner->AlertIndexIncreased() || memory.mandatory ) { // grayman #3331
// Setup a new hiding spot search
StartNewHidingSpotSearch( owner );
}
if( owner->AlertIndexIncreased() ) {
// grayman #3423 - when the alert level is ascending, kill the repeated bark task
owner->commSubsystem->ClearTasks();
// Play bark if alert level is ascending
// grayman #3496 - enough time passed since last alert bark?
if( gameLocal.time >= memory.lastTimeAlertBark + MIN_TIME_BETWEEN_ALERT_BARKS ) {
idStr bark;
if( ( memory.alertedDueToCommunication == false ) && ( ( memory.alertType == EAlertTypeSuspicious ) || ( memory.alertType == EAlertTypeEnemy ) ) ) {
bool friendsNear = ( ( MS2SEC( gameLocal.time - memory.lastTimeFriendlyAISeen ) ) <= MAX_FRIEND_SIGHTING_SECONDS_FOR_ACCOMPANIED_ALERT_BARK );
if( ( memory.alertClass == EAlertVisual_1 ) ||
( memory.alertClass == EAlertVisual_2 ) || // grayman #2603, #3424
// (memory.alertClass == EAlertVisual_3) ) || // grayman #3472 - no longer needed
( memory.alertClass == EAlertVisual_4 ) ) { // grayman #3498
if( friendsNear ) {
bark = "snd_alert3sc";
} else {
bark = "snd_alert3s";
}
} else if( memory.alertClass == EAlertAudio ) {
if( friendsNear ) {
bark = "snd_alert3hc";
} else {
bark = "snd_alert3h";
}
} else if( friendsNear ) {
bark = "snd_alert3c";
} else {
bark = "snd_alert3";
}
// Allocate a SingleBarkTask, set the sound and enqueue it
owner->commSubsystem->AddCommTask( CommunicationTaskPtr( new SingleBarkTask( bark ) ) );
memory.lastTimeAlertBark = gameLocal.time; // grayman #3496
if( cv_ai_debug_transition_barks.GetBool() ) {
gameLocal.Printf( "%d: %s rises to Searching state, barks '%s'\n", gameLocal.time, owner->GetName(), bark.c_str() );
}
}
} else {
if( cv_ai_debug_transition_barks.GetBool() ) {
gameLocal.Printf( "%d: %s rises to Searching state, can't bark 'snd_alert3{s/sc/h/hc/c}' yet\n", gameLocal.time, owner->GetName() );
}
}
} else if( memory.alertType == EAlertTypeEnemy ) {
// reduce the alert type, so we can react to other alert types (such as a dead person)
memory.alertType = EAlertTypeSuspicious;
}
// grayman #3472 - When ascending, set up a repeated bark
if( owner->AlertIndexIncreased() ) {
owner->commSubsystem->AddSilence( 5000 + gameLocal.random.RandomInt( 3000 ) ); // grayman #3424
// This will hold the message to be delivered with the bark
CommMessagePtr message( new CommMessage(
CommMessage::DetectedEnemy_CommType,
owner, NULL,// from this AI to anyone
NULL,
idVec3( idMath::INFINITY, idMath::INFINITY, idMath::INFINITY ),
0
) );
int minTime = SEC2MS( owner->spawnArgs.GetFloat( "searchbark_delay_min", "10" ) );
int maxTime = SEC2MS( owner->spawnArgs.GetFloat( "searchbark_delay_max", "15" ) );
owner->commSubsystem->AddCommTask( CommunicationTaskPtr( new RepeatedBarkTask( "snd_state3", minTime, maxTime, message ) ) );
} else { // descending
// Allow repeated barks from Agitated Searching to continue.
}
if( !owner->HasSeenEvidence() ) {
owner->SheathWeapon();
owner->UpdateAttachmentContents( false );
} else {
// Let the AI update their weapons (make them solid)
owner->UpdateAttachmentContents( true );
}
}
bool
kad_session_update(
KAD_SESSION* ks,
uint32_t now
)
{
bool result = false;
ROUTING_ZONE* rz;
LIST* active_zones = NULL;
bool zones_locked = false;
uint32_t kn_cnt = 0;
do {
if (ks->timers.self_lookup <= now){
LOG_DEBUG("Self-lookup.");
kad_search_find_node(ks, ks->root_zone, &ks->kad_id, &ks->kad_id, true, &ks->searches);
ks->timers.self_lookup = now + HR2MS(4);
}
if (ks->timers.udp_port_lookup <= now && kad_fw_udp_check_running(&ks->fw) && !kad_fw_extrn_port_valid(&ks->fw)){
LOG_DEBUG("Ping packet to random node.");
kadhlp_send_ping_pkt_to_rand_node(ks);
ks->timers.udp_port_lookup = now + SEC2MS(15);
}
if (ks->timers.update_user_data <= now){
kad_session_update_user_data(ks);
ks->timers.update_user_data = now + SEC2MS(1);
}
if (
!kad_fw_udp_check_started(&ks->fw) &&
kad_fw_udp_check_running(&ks->fw) &&
kad_fw_need_more_udp_checks(&ks->fw)
){
ks->fw.udp_check_running = true;
LOG_DEBUG("Starting search for nodes for udp firewall check.");
kad_search_find_node_for_fw_check(
ks,
ks->root_zone,
&ks->kad_id,
&ks->searches
);
}
if (kad_fw_extrn_port_valid(&ks->fw) && kad_fw_need_more_udp_checks(&ks->fw)){
LOG_DEBUG("Sending udp firewall check request.");
kad_fw_udp_check_request(ks);
}
ACTIVE_ZONES_LOCK(ks);
zones_locked = true;
LIST_EACH_ENTRY_WITH_DATA_BEGIN(ks->active_zones, e, rz);
if (now >= rz->next_bucket_timer){
kad_zone_update_bucket(ks, rz);
rz->next_bucket_timer = now + MIN2MS(1);
}
if (now >= rz->next_lookup_timer){
LOG_DEBUG("Random lookup.");
kad_zone_random_lookup(ks, rz, &ks->kad_id);
rz->next_lookup_timer = now + HR2MS(1);
}
LIST_EACH_ENTRY_WITH_DATA_END(e);
// [IMPLEMENT] Empty zones consolidation.
if (now >= ks->timers.nodes_count_check){
if (routing_get_nodes_count(ks->root_zone, &kn_cnt, true) && kn_cnt < 200){
// LOG_DEBUG("Bootstrap packet.");
// kadhlp_send_bs_req_pkt_to_rand_node(ks);
}
LOG_DEBUG("Nodes count: %d", kn_cnt);
ks->timers.nodes_count_check = now + SEC2MS(10);
}
ACTIVE_ZONES_UNLOCK(ks);
zones_locked = false;
// Jumpstart stalled searches.
if (now >= ks->timers.search_jumpstart){
// LOG_DEBUG("Jump-start searches.");
kad_search_jumpstart_all(ks, &ks->searches);
ks->timers.search_jumpstart = now + SEC2MS(1);
}
} while (false);
return result;
}
/*
================
rvMonsterStreamProtector::State_Torso_PlasmaAttack
================
*/
stateResult_t rvMonsterStreamProtector::State_Torso_PlasmaAttack ( const stateParms_t& parms ) {
enum {
STAGE_START,
STAGE_START_WAIT,
STAGE_FIRE,
STAGE_INITIALFIRE_WAIT,
STAGE_FIRE_WAIT,
STAGE_END,
STAGE_END_WAIT,
};
switch ( parms.stage ) {
case STAGE_START:
DisableAnimState ( ANIMCHANNEL_LEGS );
// Loop the flame animation
PlayAnim( ANIMCHANNEL_TORSO, "range_plasma_start", parms.blendFrames );
// Make sure we clean up some things when this state is finished (effects for one)
PostAnimState ( ANIMCHANNEL_TORSO, "Torso_FinishPlasmaAttack", 0, 0, SFLAG_ONCLEAR );
return SRESULT_STAGE ( STAGE_START_WAIT );
case STAGE_START_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
return SRESULT_STAGE ( STAGE_FIRE );
}
return SRESULT_WAIT;
case STAGE_FIRE:
attackEndTime = gameLocal.time + 500;
attackNextTime = gameLocal.time;
// Flame effect
PlayEffect ( "fx_plasma_muzzle", jointPlasmaMuzzle, true );
PlayCycle ( ANIMCHANNEL_TORSO, "range_plasma_fire", 0 );
return SRESULT_STAGE ( STAGE_INITIALFIRE_WAIT );
case STAGE_INITIALFIRE_WAIT:
if ( gameLocal.time > attackEndTime ) {
attackEndTime = gameLocal.time + SEC2MS ( 1.0f + gameLocal.random.RandomFloat ( ) * 4.0f );
return SRESULT_STAGE ( STAGE_FIRE_WAIT );
}
// Launch another attack?
if ( gameLocal.time >= attackNextTime ) {
Attack ( "plasma", jointPlasmaMuzzle, enemy.ent );
attackNextTime = gameLocal.time + plasmaAttackRate;
}
return SRESULT_WAIT;
case STAGE_FIRE_WAIT:
// If we have been using plasma too long or havent seen our enemy for at least half a second then
// stop now.
if ( gameLocal.time > attackEndTime || gameLocal.time - enemy.lastVisibleTime > 500 || (IsEnemyVisible() && !enemy.fl.inFov) ) {
StopEffect ( "fx_plasma_muzzle" );
return SRESULT_STAGE ( STAGE_END );
}
// Launch another attack?
if ( gameLocal.time >= attackNextTime ) {
Attack ( "plasma", jointPlasmaMuzzle, enemy.ent );
attackNextTime = gameLocal.time + plasmaAttackRate;
}
return SRESULT_WAIT;
case STAGE_END:
// End animations
PlayAnim( ANIMCHANNEL_TORSO, "range_plasma_end", parms.blendFrames );
return SRESULT_STAGE ( STAGE_END_WAIT );
case STAGE_END_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
bool
kad_zone_update_bucket(
KAD_SESSION* ks,
ROUTING_ZONE* rz
)
{
bool result = false;
KBUCKET* kb = NULL;
uint32_t now = ticks_now_ms();
uint32_t kn_cnt = 0;
KAD_NODE* rmvd_kn = NULL;
KAD_NODE* kn = NULL;
void* pkt = NULL;
uint32_t pkt_len = 0;
struct in_addr ia;
do {
if (!ks || !rz || !rz->kb) break;
kb = rz->kb;
kn_cnt = kb->nodes_count;
// Check all nodes for expiration,
// if node expire time is not set -
// set it to now. If node expiration time
// is lesser than now remove node from bucket
// and destroy it.
for (uint32_t i = 0; i < kn_cnt; i++){
kn = kb->nodes[i];
if (kn->status == NODE_STATUS_TO_REMOVE || ((kn->status & NODE_STATUS_WAIT_MASK) && kn->packet_timeout < now)){
LOG_DEBUG("Removing node: %s:%d with status %s, packet timeout.", kn->ip4_str, ntohs(kn->udp_port_no), node_status_str(kn));
if (!kbucket_remove_node_by_idx(kb, i, &rmvd_kn)){
LOG_ERROR("Failed to delete expired node.");
break;
}
kn_cnt--;
node_destroy(rmvd_kn);
}
}
if (!kbucket_get_oldest_node(kb, &kn)) break;
if (!kn) break;
if (kn->next_check_time >= now){
kbucket_push_node_up(kb, kn);
} else {
switch (kn->status){
case NODE_STATUS_NEW:
if (kadhlp_send_hello_req_pkt_to_node(ks, kn)){
kn->packet_timeout = now + SEC2MS(15);
kn->status = NODE_STATUS_HELLO_REQ_SENT;
LOG_DEBUG("NODE_STATUS_HELLO_REQ_SENT for %s:%d", kn->ip4_str, ntohs(kn->udp_port_no));
} else {
// Something happened and hello request was not sent.
if (kn->version < 2) kn->status = NODE_STATUS_TO_REMOVE;
}
break;
case NODE_STATUS_HELLO_RES_RECEIVED:
case NODE_STATUS_PONG_RECEIVED:
kadhlp_send_ping_pkt_to_node(ks, kn);
kn->packet_timeout = now + SEC2MS(10);
kn->status = NODE_STATUS_PING_SENT;
LOG_DEBUG("NODE_STATUS_PING_SENT for %s:%d", kn->ip4_str, ntohs(kn->udp_port_no));
break;
}
}
result = true;
} while (false);
return result;
}
void CMuleKad::Process(UINT Tick)
{
if(m_MyBuddy && IsFirewalled() && m_NextBuddyPing < GetCurTick())
{
m_NextBuddyPing = GetCurTick() + MIN2MS(10);
m_MyBuddy->SendBuddyPing();
}
QVariantMap Request;
Request["Firewalled"] = theCore->m_MuleManager->IsFirewalled(CAddress::IPv4, false, true);
Request["PublicIP"] = theCore->m_MuleManager->GetAddress(CAddress::IPv4, true).ToQString();
if(theCore->m_MuleManager->IsFirewalled(CAddress::IPv4))
{
if(m_MyBuddy)
{
Request["BuddyIP"] = m_MyBuddy->GetMule().IPv4.ToQString();
Request["BuddyPort"] = m_MyBuddy->GetKadPort();
}
}
// Note: we always advertize IPv6 addresses
CAddress IPv6 = theCore->m_MuleManager->GetAddress(CAddress::IPv6, true);
if(!IPv6.IsNull())
Request["IPv6"] = IPv6.ToQString();
if(Tick & EPerSec)
{
if(theCore->Cfg()->GetBool("Log/Merge"))
SyncLog();
}
QVariantMap Response = theCore->m_Interfaces->RemoteProcedureCall("MuleKad", "SyncState", Request).toMap();
m_KadID = Response["KadID"].toByteArray();
if(Response["Result"] == "Connected")
{
if(m_KadStatus != eConnected)
{
LogLine(LOG_SUCCESS, tr("MuleKad Connected, ID: %1").arg(QString(m_KadID.toHex()).toUpper()));
m_KadStatus = eConnected;
}
}
else if(Response["Result"] == "Connecting")
m_KadStatus = eConnecting;
else //if(Response["Result"] == "Disconnected")
m_KadStatus = eDisconnected;
if(m_KadStatus == eDisconnected)
{
if(GetCurTick() > m_NextConnectionAttempt)
{
LogLine(LOG_INFO, tr("Connecting emule kademlia"));
m_NextConnectionAttempt = GetCurTick() + SEC2MS(theCore->Cfg()->GetInt("Ed2kMule/IdleTimeout"));
StartKad();
}
return;
}
m_Address = CAddress(Response["PublicIP"].toString());
m_KadPort = Response["KadPort"].toUInt(); // external kad port
//m_UDPPort = Response["UDPPort"].toUInt(); // socket port
m_Firewalled = Response["Firewalled"].toBool();
m_KadFirewalled = Response["KadFirewalled"].toBool();
if (m_KadFirewalled && m_uNextKadFirewallRecheck <= GetCurTick())
{
m_uNextKadFirewallRecheck = GetCurTick() + SEC2MS(theCore->Cfg()->GetInt("Ed2kMule/CheckFWInterval"));
CheckFWState();
}
foreach(const QVariant& vQueuedFWCheck, Response["QueuedFWChecks"].toList())
{
QVariantMap QueuedFWCheck = vQueuedFWCheck.toMap();
SMuleSource Mule;
Mule.SetIP(CAddress(QueuedFWCheck["Address"].toString()));
Mule.TCPPort = QueuedFWCheck["TCPPort"].toUInt();
Mule.ConOpts.Bits = QueuedFWCheck["ConOpts"].toUInt();
if(Mule.ConOpts.Fields.RequestsCryptLayer) // some cleints seam to mess this up
Mule.ConOpts.Fields.SupportsCryptLayer = true;
QByteArray UserHash = QueuedFWCheck["UserHash"].toByteArray();
if(!Mule.SelectIP() || !theCore->m_PeerWatch->CheckPeer(Mule.GetIP(), Mule.TCPPort))
continue;
bool bAdded = false;
CMuleClient* pClient = theCore->m_MuleManager->GetClient(Mule, &bAdded);
if(!bAdded)
{
if(QueuedFWCheck["TestUDP"].toBool() == true)
SetUDPFWCheckResult(pClient, true);
continue;
}
if(QueuedFWCheck["TestUDP"].toBool() == true)
{
uint32 UDPKey;
if(QueuedFWCheck.contains("UDPKey"))
UDPKey = QueuedFWCheck["UDPKey"].toUInt();
else
UDPKey = theCore->m_MuleManager->GetServer()->GetUDPKey(Mule.GetIP());
m_QueuedFWChecks.insert(pClient, SFWCheck(QueuedFWCheck["IntPort"].toUInt(), QueuedFWCheck["ExtPort"].toUInt(), UDPKey));
}
else
m_QueuedFWChecks.insert(pClient, SFWCheck());
connect(pClient, SIGNAL(HelloRecived()), this, SLOT(OnHelloRecived()));
connect(pClient, SIGNAL(SocketClosed()), this, SLOT(OnSocketClosed()));
pClient->SetUserHash(UserHash);
pClient->Connect();
}
QList<CAddress> PendingFWChecks;
foreach(const QVariant& vPendingFWCheck, Response["PendingFWChecks"].toList())
{
QVariantMap PendingFWCheck = vPendingFWCheck.toMap();
PendingFWChecks.append(CAddress(PendingFWCheck["Address"].toString()));
}
theCore->m_MuleManager->GetServer()->SetExpected(PendingFWChecks);
foreach(const QVariant& vBufferedCallback, Response["BufferedCallbacks"].toList())
{
QVariantMap BufferedCallback = vBufferedCallback.toMap();
CAddress Address = CAddress(BufferedCallback["Address"].toString());
uint16 uPort = BufferedCallback["TCPPort"].toUInt();
QByteArray BuddyID = BufferedCallback["BuddyID"].toByteArray();
QByteArray FileID = BufferedCallback["FileID"].toByteArray();
if(m_MyBuddy && m_MyBuddy->IsFirewalled(CAddress::IPv4))
{
if(m_MyBuddy->GetBuddyID() == BuddyID)
m_MyBuddy->RelayKadCallback(Address, uPort, BuddyID, FileID);
}
}
// Note: This comes in on the normal UDP Socket, as we provide thesocket now we dont haveto pull it
/*foreach(const QVariant& vBufferedPackets, Response["BufferedPackets"].toList())
{
QVariantMap BufferedPackets = vBufferedPackets.toMap();
CAddress Address = CAddress(BufferedPackets["Address"].toString());
uint16 uPort = BufferedPackets["UDPPort"].toUInt();
QByteArray Data = BufferedPackets["Data"].toByteArray();
CBuffer Packet((byte*)Data.data(), Data.size(), true);
RelayUDPPacket(Address, uPort, Packet);
}
foreach(const QVariant& vPendingCallback, Response["PendingCallbacks"].toList())
{
QVariantMap PendingCallback = vPendingCallback.toMap();
SMuleSource Mule;
Mule.SetIP(CAddress(PendingCallback["Address"].toString()));
Mule.TCPPort = PendingCallback["TCPPort"].toUInt();
Mule.UserHash = PendingCallback["UserHash"].toByteArray();
Mule.ConOpts.Bits = PendingCallback["ConOpts"].toUInt();
if(Mule.ConOpts.Fields.RequestsCryptLayer) // some cleints seam to mess this up
Mule.ConOpts.Fields.SupportsCryptLayer = true;
theCore->m_MuleManager->CallbackRequested(Mule);
}*/
foreach(const QVariant& vPendingBuddys, Response["PendingBuddys"].toList())
{
if(m_MyBuddy) // if we have a buddy we are not interested in new ones
break;
QVariantMap PendingBuddy = vPendingBuddys.toMap();
SMuleSource Mule;
Mule.SetIP(CAddress(PendingBuddy["Address"].toString()));
Mule.TCPPort = PendingBuddy["TCPPort"].toUInt();
Mule.KadPort = PendingBuddy["KadPort"].toUInt();
Mule.ConOpts.Bits = PendingBuddy["ConOpts"].toUInt();
if(Mule.ConOpts.Fields.RequestsCryptLayer) // some cleints seam to mess this up
Mule.ConOpts.Fields.SupportsCryptLayer = true;
Mule.UserHash = PendingBuddy["UserHash"].toByteArray();
Mule.BuddyID = PendingBuddy["BuddyID"].toByteArray();
if(!theCore->m_PeerWatch->CheckPeer(Mule.GetIP(), Mule.TCPPort))
continue;
bool bAdded = false;
CMuleClient* pClient = theCore->m_MuleManager->GetClient(Mule, &bAdded);
if(!bAdded)
continue; // already known clients are not viable budies
connect(pClient, SIGNAL(HelloRecived()), this, SLOT(OnHelloRecived()));
connect(pClient, SIGNAL(SocketClosed()), this, SLOT(OnSocketClosed()));
if(m_PendingBuddys.contains(pClient))
continue; // already listes
m_PendingBuddys.append(pClient);
if(PendingBuddy["Incoming"].toBool()) // is this a lowID client that wants us to become his buddy ans will soon connect us?
pClient->ExpectConnection();
else //this is a high ID client that agreed to become our buddy
pClient->Connect();
}
m_KadStats = Response["Stats"].toMap();
if(Tick & EPerSec)
{
if(IsConnected())
{
SyncFiles();
SyncNotes();
foreach(CAbstractSearch* pSearch, m_RunningSearches)
SyncSearch(pSearch);
}
}
}
/*
================
idThread::Event_DebugArrow
================
*/
void idThread::Event_DebugArrow( const idVec3 &color, const idVec3 &start, const idVec3 &end, const int size, const float lifetime ) {
gameRenderWorld->DebugArrow( idVec4( color.x, color.y, color.z, 0.0f ), start, end, size, SEC2MS( lifetime ) );
}
/*
================
idClass::PostEventSec
================
*/
bool idClass::PostEventSec( const idEventDef *ev, float time, idEventArg arg1 ) {
return PostEventArgs( ev, SEC2MS( time ), 1, &arg1 );
}
/*
================
idThread::Event_DebugCircle
================
*/
void idThread::Event_DebugCircle( const idVec3 &color, const idVec3 &origin, const idVec3 &dir, const float radius, const int numSteps, const float lifetime ) {
gameRenderWorld->DebugCircle( idVec4( color.x, color.y, color.z, 0.0f ), origin, dir, radius, numSteps, SEC2MS( lifetime ) );
}
/*
================
idClass::PostEventSec
================
*/
bool idClass::PostEventSec( const idEventDef *ev, float time, idEventArg arg1, idEventArg arg2, idEventArg arg3, idEventArg arg4, idEventArg arg5, idEventArg arg6, idEventArg arg7, idEventArg arg8 ) {
return PostEventArgs( ev, SEC2MS( time ), 8, &arg1, &arg2, &arg3, &arg4, &arg5, &arg6, &arg7, &arg8 );
}
/*
================
idThread::Event_DebugBounds
================
*/
void idThread::Event_DebugBounds( const idVec3 &color, const idVec3 &mins, const idVec3 &maxs, const float lifetime ) {
gameRenderWorld->DebugBounds( idVec4( color.x, color.y, color.z, 0.0f ), idBounds( mins, maxs ), vec3_origin, SEC2MS( lifetime ) );
}
/*
================
idTrigger_Multi::Event_Touch
================
*/
void idTrigger_Multi::Event_Touch( idEntity *other, trace_t *trace ) {
if( triggerFirst ) {
return;
}
// RAVEN BEGIN
// jdischler: vehicle only trigger
if ( touchVehicle ) {
if ( !other->IsType(rvVehicle::GetClassType()) ) {
return;
}
} else {
// RAVEN BEGIN
// jnewquist: Use accessor for static class type
bool player = other->IsType( idPlayer::GetClassType() );
// RAVEN END
if ( player ) {
if ( !touchClient ) {
return;
}
if ( static_cast< idPlayer * >( other )->spectating ) {
return;
}
// Buy zone handling
if ( buyZoneTrigger /*&& gameLocal.mpGame.mpGameState.gameState.currentState != 1*/ ) {
idPlayer *p = static_cast< idPlayer * >( other );
if ( buyZoneTrigger-1 == p->team || buyZoneTrigger == 3)
{
p->inBuyZone = true;
p->inBuyZonePrev = true;
}
}
// Control zone handling
if ( controlZoneTrigger > 0 ) {
idPlayer *p = static_cast< idPlayer * >( other );
if ( p->PowerUpActive(POWERUP_DEADZONE) || !spawnArgs.GetBool("requiresDeadZonePowerup", "1") )
playersInTrigger.Append(p);
}
} else if ( !touchOther ) {
return;
}
}
if ( nextTriggerTime > gameLocal.time ) {
// can't retrigger until the wait is over
return;
}
// see if this trigger requires an item
if ( !gameLocal.RequirementMet( other, requires, removeItem ) ) {
return;
}
if ( !CheckFacing( other ) ) {
return;
}
if ( spawnArgs.GetBool( "toggleTriggerFirst" ) ) {
triggerFirst = true;
}
// RAVEN BEGIN
// rjohnson: added block
if ( developer.GetBool() && *spawnArgs.GetString ( "message" ) ) {
gameLocal.DPrintf ( "Trigger: %s\n", spawnArgs.GetString ( "message" ) );
}
// RAVEN END
nextTriggerTime = gameLocal.time + 1;
if ( delay > 0 ) {
// don't allow it to trigger again until our delay has passed
nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
PostEventSec( &EV_TriggerAction, delay, other );
} else {
TriggerAction( other );
}
}
/*
================
idThread::Event_DrawText
================
*/
void idThread::Event_DrawText( const char *text, const idVec3 &origin, float scale, const idVec3 &color, const int align, const float lifetime ) {
gameRenderWorld->DrawText( text, origin, scale, idVec4( color.x, color.y, color.z, 0.0f ), gameLocal.GetLocalPlayer()->viewAngles.ToMat3(), align, SEC2MS( lifetime ) );
}
/*
==============
idPlayerView::DamageImpulse
LocalKickDir is the direction of force in the player's coordinate system,
which will determine the head kick direction
==============
*/
void idPlayerView::DamageImpulse( idVec3 localKickDir, const idDict *damageDef ) {
//
// double vision effect
//
if ( lastDamageTime > 0.0f && SEC2MS( lastDamageTime ) + IMPULSE_DELAY > gameLocal.time ) {
// keep shotgun from obliterating the view
return;
}
float dvTime = damageDef->GetFloat( "dv_time" );
if ( dvTime ) {
if ( dvFinishTime < gameLocal.time ) {
dvFinishTime = gameLocal.time;
}
dvFinishTime += g_dvTime.GetFloat() * dvTime;
// don't let it add up too much in god mode
if ( dvFinishTime > gameLocal.time + 5000 ) {
dvFinishTime = gameLocal.time + 5000;
}
}
//
// head angle kick
//
float kickTime = damageDef->GetFloat( "kick_time" );
if ( kickTime ) {
kickFinishTime = gameLocal.time + g_kickTime.GetFloat() * kickTime;
// forward / back kick will pitch view
kickAngles[0] = localKickDir[0];
// side kick will yaw view
kickAngles[1] = localKickDir[1]*0.5f;
// up / down kick will pitch view
kickAngles[0] += localKickDir[2];
// roll will come from side
kickAngles[2] = localKickDir[1];
float kickAmplitude = damageDef->GetFloat( "kick_amplitude" );
if ( kickAmplitude ) {
kickAngles *= kickAmplitude;
}
}
//
// screen blob
//
float blobTime = damageDef->GetFloat( "blob_time" );
if ( blobTime ) {
screenBlob_t *blob = GetScreenBlob();
blob->startFadeTime = gameLocal.time;
blob->finishTime = gameLocal.time + blobTime * g_blobTime.GetFloat();
const char *materialName = damageDef->GetString( "mtr_blob" );
blob->material = declManager->FindMaterial( materialName );
blob->x = damageDef->GetFloat( "blob_x" );
blob->x += ( gameLocal.random.RandomInt()&63 ) - 32;
blob->y = damageDef->GetFloat( "blob_y" );
blob->y += ( gameLocal.random.RandomInt()&63 ) - 32;
float scale = ( 256 + ( ( gameLocal.random.RandomInt()&63 ) - 32 ) ) / 256.0f;
blob->w = damageDef->GetFloat( "blob_width" ) * g_blobSize.GetFloat() * scale;
blob->h = damageDef->GetFloat( "blob_height" ) * g_blobSize.GetFloat() * scale;
blob->s1 = 0;
blob->t1 = 0;
blob->s2 = 1;
blob->t2 = 1;
}
//
// save lastDamageTime for tunnel vision accentuation
//
lastDamageTime = MS2SEC( gameLocal.time );
}
/*
================
idThread::WaitSec
================
*/
void idThread::WaitSec( float time ) {
WaitMS( SEC2MS( time ) );
}
