G* Memory<G>::Require( std::size_t size )
{
if( size > size_ )
{
delete[] buffer_;
#ifndef ELEM_RELEASE
try {
#endif
buffer_ = new G[size];
#ifndef ELEM_RELEASE
}
catch( std::bad_alloc& e )
{
std::ostringstream os;
os << "Failed to allocate " << size*sizeof(G)
<< " bytes on process " << mpi::WorldRank() << std::endl;
std::cerr << os.str();
throw e;
}
#endif
size_ = size;
#ifdef ELEM_ZERO_INIT
MemZero( buffer_, size_ );
#elif defined(ELEM_HAVE_VALGRIND)
if( ELEM_RUNNING_ON_VALGRIND )
MemZero( buffer_, size_ );
#endif
}
return buffer_;
}
inline void
MakeTriangular( UpperOrLower uplo, DistMatrix<T,U,V>& A )
{
#ifndef RELEASE
PushCallStack("MakeTriangular");
#endif
const int height = A.Height();
const int localHeight = A.LocalHeight();
const int localWidth = A.LocalWidth();
const int colShift = A.ColShift();
const int rowShift = A.RowShift();
const int colStride = A.ColStride();
const int rowStride = A.RowStride();
T* localBuffer = A.LocalBuffer();
const int ldim = A.LocalLDim();
if( uplo == LOWER )
{
#ifdef HAVE_OPENMP
#pragma omp parallel for
#endif
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*rowStride;
const int lastZeroRow = j-1;
if( lastZeroRow >= 0 )
{
const int boundary = std::min( lastZeroRow+1, height );
const int numZeroRows =
RawLocalLength( boundary, colShift, colStride );
MemZero( &localBuffer[jLocal*ldim], numZeroRows );
}
}
}
else
{
#ifdef HAVE_OPENMP
#pragma omp parallel for
#endif
for( int jLocal=0; jLocal<localWidth; ++jLocal )
{
const int j = rowShift + jLocal*rowStride;
const int firstZeroRow = j+1;
const int numNonzeroRows =
RawLocalLength(firstZeroRow,colShift,colStride);
if( numNonzeroRows < localHeight )
{
T* col = &localBuffer[numNonzeroRows+jLocal*ldim];
MemZero( col, localHeight-numNonzeroRows );
}
}
}
#ifndef RELEASE
PopCallStack();
#endif
}
RegionImpl::RegionImpl(int id)
: self( &data )
{
// Set client data
MemZero(this->data);
// Assuming this is called via GameInternals, so no checks are made
BW::region *r = &BW::BWDATA_SAIPathing->regions[id];
// Assign common region properties
self->islandID = r->groupIndex;
self->center_x = r->getCenter().x;
self->center_y = r->getCenter().y;
self->isWalkable = r->accessabilityFlags != 0x1FFD;
self->isHigherGround = r->accessabilityFlags == 0x1FF9;
self->priority = r->properties & 0x7F;
self->leftMost = r->rgnBox.left;
self->rightMost = r->rgnBox.right;
self->topMost = r->rgnBox.top;
self->bottomMost = r->rgnBox.bottom;
// Connect the BWAPI Region and BW Region two ways
self->id = id;
r->unk_28 = (u32)this;
this->closestAccessibleRgn = NULL;
this->closestInaccessibleRgn = NULL;
}
void InitializeWModeBitmap(int width, int height)
{
if ( hdcMem )
DeleteDC(hdcMem);
hdcMem = NULL;
// Create Bitmap HDC
MemZero(wmodebmp);
wmodebmp.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
wmodebmp.bmiHeader.biWidth = width;
wmodebmp.bmiHeader.biHeight = -(height);
wmodebmp.bmiHeader.biPlanes = 1;
wmodebmp.bmiHeader.biBitCount = 8;
wmodebmp.bmiHeader.biCompression = BI_RGB;
wmodebmp.bmiHeader.biSizeImage = width * height;
#ifndef SHADOW_BROODWAR
if ( isCorrectVersion )
{
for ( int i = 0; i < 256; ++i )
{
wmodebmp.bmiColors[i].rgbRed = BW::BWDATA::GamePalette[i].peRed;
wmodebmp.bmiColors[i].rgbGreen = BW::BWDATA::GamePalette[i].peGreen;
wmodebmp.bmiColors[i].rgbBlue = BW::BWDATA::GamePalette[i].peBlue;
}
}
#endif
HDC hdc = GetDC(ghMainWnd);
hwmodeBmp = CreateDIBSection(hdc, (BITMAPINFO*)&wmodebmp, DIB_RGB_COLORS, &pBits, NULL, 0);
hdcMem = CreateCompatibleDC(hdc);
ReleaseDC(ghMainWnd, hdc);
SelectObject(hdcMem, hwmodeBmp);
}
//--------------------------------------------- CONSTRUCTOR ------------------------------------------------
UnitImpl::UnitImpl(BW::CUnit* originalUnit,
u16 index)
: getOriginalRawData(originalUnit)
, self(&data)
, index(index)
, userSelected(false)
, isAlive(false)
, wasAlive(false)
, wasCompleted(false)
, wasAccessible(false)
, wasVisible(false)
, staticInformation(false)
, lastType(UnitTypes::Unknown)
, lastPlayer(nullptr)
, nukeDetected(false)
, lastGroundWeaponCooldown(0)
, lastAirWeaponCooldown(0)
, startingAttack(false)
, lastCommandFrame(0)
, lastImmediateCommandFrame(0)
, lastCommand()
, lastImmediateCommand()
, id(-1)
{
MemZero(data);
clear();
}
IS_FRAME *LoadIS_FRAME( COAL *path )
{
DWORD dErr = ERROR_FRAMSERV( 0x10 );
IS_FRAME *f = 0, *o;
DWORD oRes = (DWORD) path <= IDX_LAST;
CHECK_ERROR( o = (IS_FRAME *) MemAlloc( sizeof( IS_FRAME ) / 4 ) );
MemZero( sizeof( IS_FRAME ) / 4, o );
CHECK_ERROR( o->hBM = LoadImage( oRes ? gs_hInst : 0, path, IMAGE_BITMAP, 0, 0, oRes ? 0 : LR_LOADFROMFILE ) );
CHECK_ERROR( GetObject( o->hBM, sizeof( BITMAP ), &o->bih ) );
CHECK_ERROR( o->hDC = CreateCompatibleDC( 0 ) );
CHECK_ERROR( o->hGO = SelectObject( o->hDC, o->hBM ) );
CHECK_ERROR( f = MakeIS_FRAME( o->_x, o->_y ) );
CHECK_ERROR( BitBlt( f->hDC, 0, 0, o->_x, o->_y, o->hDC, 0, 0, SRCCOPY ) );
dErr = ERROR_SUCCESS;
CatchError:
KillIS_FRAME( o );
if ( dErr )
{
KillIS_FRAME( f );
f = 0;
}
return f;
}
int mbbs_memalloc(MemType **buf, unsigned int *bufsz, unsigned int nobj, size_t objsz) {
if (buf == (MemType **)0)
return MEM_BADARG;
if (bufsz == (unsigned int *)0)
return MEM_BADARG;
/* sufficient memory already allocated? */
if (*bufsz >= nobj) {
if ((*buf != (MemType *)0) && (nobj != 0) && (objsz != 0))
MemZero(*buf, nobj * objsz);
return MEM_SUCCESS;
}
if ((mem_maxallocsz != 0) && (mem_maxallocsz < (unsigned long)(nobj * objsz)))
return MEM_OOB;
/* free any existing memory */
if (*buf != (MemType *)0)
CFree((MemType *)*buf);
*bufsz = 0;
/* allocate new memory */
if ((*buf = (MemType *)calloc((MemSizeType)nobj, (MemSizeType)objsz)) == (MemType *)0)
return MEM_CALLOC;
*bufsz = nobj;
return MEM_SUCCESS;
}
/////////////////////////////////////////////////////////////////////////////////
// ConsoleEnvironment implementation
ConsoleEnvironment::ConsoleEnvironment():
m_mapVariables(), m_itEnumerate()
{
// Resource state data
m_pActiveDB = NULL;
m_bOpenedResource = false;
MemZero( &m_hOpenedResource, sizeof(RDB_ResourceHandle) );
m_strOpenedResourceName[0] = NULLBYTE;
}
//---------------------------------------------- CONSTRUCTOR -----------------------------------------------
BulletImpl::BulletImpl(BW::CBullet* originalBullet, u16 _index)
: self( &data )
, bwOriginalBullet(originalBullet)
, index(_index)
, id(-1)
, __exists(false)
, lastExists(false)
{
MemZero(data);
}
//------------------------------------------------------------------
void INetworkedObject::AddField( EFieldType type, uint bits, uint size, const void* data )
{
_fields.resize( _fields.size() + 1 );
SField& field( *_fields.rbegin() );
field.type = type;
field.bits = bits;
field.data = data;
field.size = size;
MemZero( field.prevValue, size );
}
static
bool F_Parse_INI_and_Load_Packages( PCHARS szProjFilePath )
{
AssertPtr( szProjFilePath );
// Parse .INI file and load resource packages.
ANSICHAR iniFilePath[ FS_MAX_PATH ];
VRET_FALSE_IF_NOT( F_Compose_File_Path( szProjFilePath, iniFilePath, NUMBER_OF(iniFilePath) ) );
FileReader iniFileReader( iniFilePath, FileRead_NoErrors );
if( !iniFileReader.IsOpen() ) {
mxWarnf("Failed to load config file '%s'\n",iniFilePath);
return false;
}
// 1 KiB
enum { MAX_INI_SIZE = 1*mxKIBIBYTE};
const UINT fileSize = iniFileReader.GetSize();
if( fileSize > MAX_INI_SIZE )
{
mxWarnf("Config file '%s' is too big\n",iniFilePath);
return false;
}
ANSICHAR buffer[ MAX_INI_SIZE ];
MemZero( buffer, sizeof buffer );
iniFileReader.Read( buffer, fileSize );
idLexer lexer( buffer, fileSize, iniFilePath, LEXFL_ALLOWPATHNAMES|LEXFL_NOSTRINGCONCAT );
idToken token;
while( lexer.ReadToken( &token ) )
{
if( token == "[" ) {
lexer.ExpectAnyToken( &token );
lexer.ExpectTokenString("]");
continue;
}
if( token.type == TT_STRING ) {
UNDONE;
//F_MountExistingPackage( token.ToChars() );
continue;
} else {
lexer.Error("Expected a string, but got '%s'\n",token.ToChars());
}
return false;
}//while (ReadToken)
return true;
}
inline void
MakeTriangular( UpperOrLower uplo, Matrix<T>& A )
{
#ifndef RELEASE
PushCallStack("MakeTriangular");
#endif
const int height = A.Height();
const int width = A.Width();
const int ldim = A.LDim();
T* buffer = A.Buffer();
if( uplo == LOWER )
{
#ifdef HAVE_OPENMP
#pragma omp parallel for
#endif
for( int j=1; j<width; ++j )
{
const int numZeroRows = std::min( j, height );
MemZero( &buffer[j*ldim], numZeroRows );
}
}
else
{
#ifdef HAVE_OPENMP
#pragma omp parallel for
#endif
for( int j=0; j<std::min(width,height); ++j )
{
const int firstZeroRow = j+1;
MemZero( &buffer[firstZeroRow+j*ldim], height-firstZeroRow );
}
}
#ifndef RELEASE
PopCallStack();
#endif
}
int
mbbs_memallocsh(MemType **buf, int *shmid, unsigned int *bufsz, unsigned int nobj, size_t objsz)
{
if (buf == (MemType **) 0)
return MEM_BADARG;
if (shmid == (int *) 0)
return MEM_BADARG;
if (bufsz == (unsigned int *) 0)
return MEM_BADARG;
/* sufficient memory already allocated? */
if (*bufsz >= nobj) {
if ((*buf != (MemType *) 0) && (nobj != 0) && (objsz != 0))
MemZero(*buf, nobj*objsz);
return MEM_SUCCESS;
}
if ((mem_maxallocsz != 0) && (mem_maxallocsz < (unsigned long) (nobj*objsz)))
return MEM_OOB;
/* free any existing memory */
if ((*buf != (MemType *) 0) && (*shmid != MEM_SHMNULLID)) {
if (shmdt((MemType *) *buf) < 0)
return MEM_SHMDET;
*buf= (MemType *) 0;
*bufsz= 0;
if (shmctl(*shmid, IPC_RMID, (struct shmid_ds *) 0) < 0) {
*shmid= MEM_SHMNULLID;
return MEM_SHMRM;
}
}
*buf= (MemType *) 0;
*bufsz= 0;
*shmid= MEM_SHMNULLID;
/* allocate new memory */
if ((*shmid= shmget(mem_key, (MemSizeType) (nobj*objsz), mem_shmflag)) < 0) {
*shmid= MEM_SHMNULLID;
return MEM_SHMGET;
}
if ((*buf= (MemType *) shmat(*shmid, (MemType *) 0, (int) 0)) == (MemType *) -1) {
(void) shmctl(*shmid, IPC_RMID, (struct shmid_ds *) 0);
*shmid= MEM_SHMNULLID;
return MEM_SHMATT;
}
*bufsz= nobj;
return MEM_SUCCESS;
}
Void InputManager::Initialize()
{
// default state
m_AsyncKeyboard.NumLock = true;
m_AsyncKeyboard.CapsLock = false;
m_AsyncKeyboard.ScrollLock = false;
m_AsyncKeyboard.LastKey = KEYCODE_NULL;
MemZero( m_AsyncKeyboard.Keys, KEYBOARD_KEYS );
m_AsyncMouse.X = 0;
m_AsyncMouse.Y = 0;
m_AsyncMouse.DX = 0;
m_AsyncMouse.DY = 0;
m_AsyncMouse.DWheel = 0;
m_AsyncMouse.LastButton = KEYCODE_NULL;
MemZero( m_AsyncMouse.Buttons, MOUSE_BUTTONS );
// Action Mapping
for( UInt i = 0; i < INPUT_MAX_MAPS; ++i )
m_arrActionMaps[i] = NULL;
m_iMapCount = 0;
m_iActiveMap = INVALID_OFFSET;
// Build a default map ?
}
G* Memory<G>::Require( size_t size )
{
if( size > size_ )
{
Delete( rawBuffer_ );
#ifndef EL_RELEASE
try {
#endif
// TODO: Optionally overallocate to force alignment of buffer_
rawBuffer_ = New<G>( size );
buffer_ = rawBuffer_;
size_ = size;
#ifndef EL_RELEASE
}
catch( std::bad_alloc& e )
{
size_ = 0;
ostringstream os;
os << "Failed to allocate " << size*sizeof(G)
<< " bytes on process " << mpi::WorldRank() << endl;
cerr << os.str();
throw e;
}
#endif
#ifdef EL_ZERO_INIT
MemZero( buffer_, size_ );
#elif defined(EL_HAVE_VALGRIND)
if( EL_RUNNING_ON_VALGRIND )
MemZero( buffer_, size_ );
#endif
}
return buffer_;
}
/////////////////////////////////////////////////////////////////////////////////
// HProcess implementation
HProcess::HProcess( ProcessCreationFlags iFlags, GChar * strCmdLine, Void * pEnvironment,
HThread * outMainThread, ProcessID * outProcessID, ThreadID * outMainThreadID ):
HThreadingObject()
{
STARTUPINFO startupInfos;
MemZero( &startupInfos, sizeof(STARTUPINFO) );
startupInfos.cb = sizeof(STARTUPINFO);
if ( iFlags & PROCESS_FULLSCREEN )
startupInfos.dwFlags |= STARTF_RUNFULLSCREEN;
DWord dwFlags = 0;
if ( iFlags & PROCESS_SUSPENDED ) // main thread is suspended upon creation
dwFlags |= CREATE_SUSPENDED;
if ( iFlags & PROCESS_NO_WINDOW ) // no console window
dwFlags |= CREATE_NO_WINDOW;
else {
if ( iFlags & PROCESS_DETACHED ) // new console instead of parent's
dwFlags |= DETACHED_PROCESS;
else if ( iFlags & PROCESS_NEW_CONSOLE ) // don't inherit parent's console, create manually later (or not)
dwFlags |= CREATE_NEW_CONSOLE;
}
PROCESS_INFORMATION processInfos;
MemZero( &processInfos, sizeof(PROCESS_INFORMATION) );
BOOL bRes = CreateProcess( NULL, strCmdLine, NULL, NULL, FALSE, dwFlags, pEnvironment, NULL, &startupInfos, &processInfos );
DebugAssert( bRes );
m_hThreadingObject = processInfos.hProcess;
if ( outMainThread != NULL )
outMainThread->m_hThreadingObject = processInfos.hThread;
if ( outProcessID != NULL )
*outProcessID = processInfos.dwProcessId;
if ( outMainThreadID != NULL )
*outMainThreadID = processInfos.dwThreadId;
}
bool Image::Create(uint width, uint height, uint bpp)
{
if (!m_pImageData && IMAGE_BPP_8 == bpp &&
width > IMAGE_MIN_WIDTH && height > IMAGE_MIN_HEIGHT)
{
//create image only if not already created
ulong size = width * height * IMAGE_NUM_COMPONENTS;
m_pImageData = new ubyte [size];
MemZero(m_pImageData, size);
m_width = width;
m_height = height;
m_bpp = bpp;
return true;
}
return false;
}
NetworkError System::ResolveHostName( const GChar * strServiceName, const GChar * strHostName,
SocketProtocol protocolHint, AddressResolveFlags iFlags )
{
ADDRINFOT hints;
MemZero( &hints, sizeof(ADDRINFOT) );
switch( protocolHint ) {
case SOCKET_UNSPECIFIED: hints.ai_family = AF_UNSPEC; hints.ai_socktype = 0; hints.ai_protocol = 0; break;
case SOCKET_ICMPv4: hints.ai_family = AF_INET; hints.ai_socktype = SOCK_RAW; hints.ai_protocol = IPPROTO_ICMP; break;
case SOCKET_IGMPv4: hints.ai_family = AF_INET; hints.ai_socktype = SOCK_RAW; hints.ai_protocol = IPPROTO_IGMP; break;
case SOCKET_UDPIPv4: hints.ai_family = AF_INET; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; break;
case SOCKET_TCPIPv4: hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; break;
case SOCKET_ICMPv6: hints.ai_family = AF_INET6; hints.ai_socktype = SOCK_RAW; hints.ai_protocol = IPPROTO_ICMPV6; break;
case SOCKET_IGMPv6: hints.ai_family = AF_INET6; hints.ai_socktype = SOCK_RAW; hints.ai_protocol = IPPROTO_IGMP; break;
case SOCKET_UDPIPv6: hints.ai_family = AF_INET6; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; break;
case SOCKET_TCPIPv6: hints.ai_family = AF_INET6; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; break;
default: return NETWORK_ERROR;
}
if ( iFlags & ADDRRESOLVE_FLAG_SERVER_USAGE )
hints.ai_flags |= AI_PASSIVE;
if ( iFlags & ADDRRESOLVE_FLAG_NUMERIC_HOST )
hints.ai_flags |= AI_NUMERICHOST;
if ( iFlags & ADDRRESOLVE_FLAG_CANONICAL_NAME )
hints.ai_flags |= AI_CANONNAME;
// Many more flags supported with Vista/Seven ...
Int iResult = GetAddrInfo( strHostName, strServiceName, &hints, &m_pCurAddrInfo );
if ( iResult == 0 )
return NETWORK_OK;
m_pCurAddrInfo = NULL;
iResult = WSAGetLastError();
switch(iResult) {
case WSAHOST_NOT_FOUND: return NETWORK_HOST_NOT_FOUND;
case WSANO_DATA: return NETWORK_NO_DATA;
case WSATRY_AGAIN: return NETWORK_RETRY;
case WSANOTINITIALISED:
case WSAEAFNOSUPPORT:
case WSAESOCKTNOSUPPORT:
case WSAEINVAL:
case WSATYPE_NOT_FOUND:
case WSA_NOT_ENOUGH_MEMORY:
case WSANO_RECOVERY:
default: break;
}
return NETWORK_ERROR;
}
DWORD TrayAction( DWORD m_dAction )
{
NOTIFYICONDATA xNID;
MemZero( sizeof( NOTIFYICONDATA ) / 4, &xNID );
xNID.cbSize = sizeof( NOTIFYICONDATA );
xNID.hWnd = gm_hWnd;
xNID.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
xNID.uCallbackMessage = WM_TRAYIDOL;
xNID.hIcon = LoadIcon( gs_hInst, MAKEINTRESOURCE( gm_hAC ? IDI_POINTER : IDI_DENIED ) );
wsprintf( xNID.szTip, TEXT( "%s - %s" ), &gs_sSH, gm_hAC ? TEXT( "Active" ) : TEXT( "Disabled" ) );
if ( !Shell_NotifyIcon( m_dAction, &xNID ) ) return ERROR_TRAYIDOL( 0x00 );
return ERROR_SUCCESS;
}
inline void
Zero( Matrix<T>& A )
{
#ifndef RELEASE
PushCallStack("Zero");
#endif
const int height = A.Height();
const int width = A.Width();
#ifdef HAVE_OPENMP
#pragma omp parallel for
#endif
for( int j=0; j<width; ++j )
MemZero( A.Buffer(0,j), height );
#ifndef RELEASE
PopCallStack();
#endif
}
void MakeTrapezoidal( UpperOrLower uplo, Matrix<T>& A, Int offset )
{
EL_DEBUG_CSE
const Int height = A.Height();
const Int width = A.Width();
const Int ldim = A.LDim();
T* buffer = A.Buffer();
if( uplo == LOWER )
{
EL_PARALLEL_FOR
for( Int j=Max(0,offset+1); j<width; ++j )
{
const Int lastZeroRow = j-offset-1;
const Int numZeroRows = Min( lastZeroRow+1, height );
MemZero( &buffer[j*ldim], numZeroRows );
}
}
void Zero( AutoMatrix<Int>& A )
{
#ifndef RELEASE
PushCallStack("Zero");
#endif
const size_t dsize = A.DataSize();
const size_t height = A.Height() * dsize;
const size_t ldim = A.LDim() * dsize;
const int width = A.Width();
byte* buffer = static_cast<byte*>( A.Buffer() );
#ifdef HAVE_OPENMP
#pragma omp parallel for
#endif
for( int j=0; j<width; ++j )
MemZero( buffer + j * ldim, height );
#ifndef RELEASE
PopCallStack();
#endif
}
NAMESPACE_BEGIN
ParticleSystem::ParticleSystem()
: m_reduceSize (false),
m_reduceAlpha (false),
m_maxSize (0.0f),
m_spread (0.0f),
m_minFade (0.0f),
m_maxFade (0.0f),
m_maxLife (0.0f),
m_count (0),
m_frame (0)
{
#ifdef _DEBUG
SetName("psystem");
#endif
ColorZero(m_color);
VectorZero(m_velocity);
VectorZero(m_accel);
MemZero(m_aParticles, sizeof(m_aParticles));
}
IS_FRAME *MakeIS_FRAME( int f_iX, int f_iY )
{
DWORD dErr = ERROR_FRAMSERV( 0x00 );
IS_FRAME *f = 0;
CHECK_ERROR( ( f_iX > 0 ) && ( f_iY > 0 ) );
CHECK_ERROR( f = (IS_FRAME *) MemAlloc( sizeof( IS_FRAME ) / 4 ) );
MemZero( sizeof( IS_FRAME ) / 4, f );
f->bih.biSize = sizeof( BITMAPINFOHEADER );
f->bih.biPlanes = 1;
f->bih.biBitCount = 32;
f->bih.biSizeImage = f_iX * f_iY << 2;
f->_x = ( f->_rl = f_iX );
f->_y = - ( f->_rt = f_iY );
CHECK_ERROR( f->hBM = CreateDIBSection( 0, (BITMAPINFO *) &f->bih, 0, &f->dPx, 0, 0 ) );
f->_y = f_iY;
CHECK_ERROR( f->hDC = CreateCompatibleDC( 0 ) );
CHECK_ERROR( f->hGO = SelectObject( f->hDC, f->hBM ) );
dErr = ERROR_SUCCESS;
CatchError:
if ( dErr )
{
KillIS_FRAME( f );
f = 0;
MsgErr( dErr, MB_ICONWARNING );
}
return f;
}
//=============================================================================
CManager::CManager ()
{
MemZero(m_keys);
MemZero(m_mouse);
}
void UnitImpl::updateInternalData()
{
BW::CUnit *o = getOriginalRawData;
if ( !o )
return;
int selfPlayerID = BroodwarImpl.server.getPlayerID(Broodwar->self());
self->replayID = BWAPI::BroodwarImpl.isFlagEnabled(Flag::CompleteMapInformation) ? BW::UnitTarget(o).getTarget() : 0;
if (isAlive)
{
_getPlayer = BroodwarImpl._getPlayer(getOriginalRawData->playerID); //_getPlayer
//------------------------------------------------------------------------------------------------------
//isVisible
for ( int i = 0; i < 9; ++i )
{
if ( i == selfPlayerID )
continue;
PlayerImpl* player = static_cast<PlayerImpl*>(Broodwar->getPlayer(i));
if ( !o->sprite || !player )
self->isVisible[i] = false;
else if (!BroodwarImpl.isReplay() && !BWAPI::BroodwarImpl.isFlagEnabled(Flag::CompleteMapInformation))
self->isVisible[i] = false;
else if ( _getPlayer == player )
self->isVisible[i] = true;
else if ( player->isNeutral() )
self->isVisible[i] = o->sprite->visibilityFlags > 0;
else
self->isVisible[i] = (o->sprite->visibilityFlags & (1 << player->getIndex())) != 0;
}
if (selfPlayerID >= 0)
{
if ( !o->sprite )
{
self->isVisible[selfPlayerID] = false;
self->isDetected = false;
}
else if (_getPlayer == BWAPI::BroodwarImpl.self())
{
self->isVisible[selfPlayerID] = true;
self->isDetected = true;
}
else if (o->unitType == UnitTypes::Spell_Scanner_Sweep)
{
self->isVisible[selfPlayerID] = isScannerVisible(o->position);
self->isDetected = true;
}
else
{
self->isVisible[selfPlayerID] = (o->sprite->visibilityFlags & (1 << BroodwarImpl.BWAPIPlayer->getIndex())) != 0;
if (o->statusFlag(BW::StatusFlags::RequiresDetection))
{
self->isVisible[selfPlayerID] &= ((o->visibilityStatus == -1) ||
((o->visibilityStatus & (1 << BroodwarImpl.BWAPIPlayer->getIndex())) != 0) ||
o->movementFlag(BW::MovementFlags::Moving | BW::MovementFlags::Accelerating) ||
o->orderID == Orders::Move ||
o->groundWeaponCooldown > 0 ||
o->airWeaponCooldown > 0 ||
!o->statusFlag(BW::StatusFlags::Burrowed) );
}
bool canDetect = !o->statusFlag(BW::StatusFlags::RequiresDetection) ||
o->visibilityStatus == -1 ||
((o->visibilityStatus & (1 << BroodwarImpl.BWAPIPlayer->getIndex())) != 0);
self->isDetected = self->isVisible[selfPlayerID] & canDetect;
}
}
else
{
self->isDetected = false;
for(unsigned int i = 0; i < 9; ++i)
{
if (self->isVisible[i])
{
self->isDetected = true;
break;
}
}
}
//------------------------------------------------------------------------------------------------------
//_getType
_getType = UnitType(o->unitType);
if ( _getType.isMineralField() )
_getType = UnitTypes::Resource_Mineral_Field;
getBuildQueueSlot = o->buildQueueSlot; //getBuildQueueSlot
for ( unsigned int i = 0; i < 5; ++i )
getBuildQueue[i] = BWAPI::UnitType(o->buildQueue[i]); //getBuildQueue
if (_getType.isBuilding())
{
if (o->orderID == Orders::ZergBirth ||
o->orderID == Orders::ZergBuildingMorph ||
o->orderID == Orders::ZergUnitMorph ||
o->orderID == Orders::Enum::IncompleteMorphing )
{
//if we have a morphing building, set unit type to the build type (what it is morphing to)
if ( getBuildQueue[(getBuildQueueSlot % 5)] != UnitTypes::None )
_getType = getBuildQueue[(getBuildQueueSlot % 5)];
}
}
//------------------------------------------------------------------------------------------------------
//_getTransport
_getTransport = nullptr;
if (_getType == UnitTypes::Protoss_Interceptor ||
_getType == UnitTypes::Protoss_Scarab ||
_getType == UnitTypes::Terran_Vulture_Spider_Mine)
{
if (o->fighter.inHanger == false ||
o->statusFlag(BW::StatusFlags::InTransport | BW::StatusFlags::InBuilding) )
_getTransport = UnitImpl::BWUnitToBWAPIUnit(o->fighter.parent);
}
else if (o->statusFlag(BW::StatusFlags::InTransport | BW::StatusFlags::InBuilding) )
_getTransport = UnitImpl::BWUnitToBWAPIUnit(o->connectedUnit);
//------------------------------------------------------------------------------------------------------
//_getPosition
_getPosition = BWAPI::Position(_getTransport ? static_cast<UnitImpl*>(_getTransport)->getOriginalRawData->position : o->position);
_getHitPoints = (int)std::ceil(o->hitPoints / 256.0); //_getHitPoints
//------------------------------------------------------------------------------------------------------
//_getResources
_getResources = 0;
if ( _getType.isResourceContainer() )
_getResources = o->resource.resourceCount;
hasEmptyBuildQueue = getBuildQueueSlot < 5 ? (getBuildQueue[getBuildQueueSlot] == UnitTypes::None) : false; //hasEmptyBuildQueue
_isCompleted = o->statusFlag(BW::StatusFlags::Completed); //_isCompleted
}
else // not alive
{
//------------------------------------------------------------------------------------------------------
//isVisible
MemZero(self->isVisible);
self->isDetected = false;
_getPlayer = nullptr; //_getPlayer
_getType = UnitTypes::Unknown; //_getType
_getTransport = nullptr; //_getTransport
_getPosition = Positions::Unknown; //_getPosition
_getHitPoints = 0; //_getHitPoints
_getResources = 0; //_getResources
getBuildQueueSlot = 0; //getBuildQueueSlot
for ( unsigned int i = 0; i < 5; ++i )
getBuildQueue[i] = UnitTypes::None; //getBuildQueue
hasEmptyBuildQueue = true; //hasEmptyBuildQueue
_isCompleted = false; //_isCompleted
}
}
//=============================================================================
void CManager::Update ()
{
//byte newKeyState[256];
//::GetKeyboardState(newKeyState);
//for (uint i = 8; i < array_size(newKeyState); ++i)
//{
// const bool newState = newKeyState[i] != 0;
// const bool oldState = m_keys[i] != 0;
// if (newState == oldState)
// continue;
// const EKey key = (EKey)i;
// m_keys[i] = newState;
// if (newState)
// m_notifier.Call(&CInputNotify::OnInputKeyDown, key);
// else
// m_notifier.Call(&CInputNotify::OnInputKeyUp, key);
//}
{
XINPUT_STATE state;
MemZero(state);
const DWORD result = ::XInputGetState(0, &state);
if (result == ERROR_SUCCESS)
{
m_gamepad.isAvailable = true;
m_gamepad.axis[int(EGameAxis::LeftStickX)] = MapStick(state.Gamepad.sThumbLX);
m_gamepad.axis[int(EGameAxis::LeftStickY)] = MapStick(state.Gamepad.sThumbLY);
m_gamepad.axis[int(EGameAxis::LeftTrigger)] = MapTrigger(state.Gamepad.bLeftTrigger);
m_gamepad.axis[int(EGameAxis::RightStickX)] = MapStick(state.Gamepad.sThumbRX);
m_gamepad.axis[int(EGameAxis::RightStickY)] = MapStick(state.Gamepad.sThumbRY);
m_gamepad.axis[int(EGameAxis::RightTrigger)] = MapTrigger(state.Gamepad.bRightTrigger);
Update(EButton::LeftDpadUp, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_DPAD_UP));
Update(EButton::LeftDpadUp, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_DPAD_UP));
Update(EButton::LeftDpadRight, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_DPAD_RIGHT));
Update(EButton::LeftDpadDown, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_DPAD_DOWN));
Update(EButton::LeftDpadLeft, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_DPAD_LEFT));
Update(EButton::LeftStick, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_LEFT_THUMB));
Update(EButton::LeftShoulder, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_LEFT_SHOULDER));
Update(EButton::LeftTrigger, (state.Gamepad.bLeftTrigger > XINPUT_GAMEPAD_TRIGGER_THRESHOLD));
Update(EButton::RightDpadUp, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_Y));
Update(EButton::RightDpadRight, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_X));
Update(EButton::RightDpadDown, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_A));
Update(EButton::RightDpadLeft, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_B));
Update(EButton::RightStick, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_RIGHT_THUMB));
Update(EButton::RightShoulder, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_RIGHT_SHOULDER));
Update(EButton::RightTrigger, (state.Gamepad.bRightTrigger > XINPUT_GAMEPAD_TRIGGER_THRESHOLD));
Update(EButton::CenterLeft, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_BACK));
Update(EButton::CenterMiddle, false);
Update(EButton::CenterRight, MapButton(state.Gamepad.wButtons, XINPUT_GAMEPAD_START));
}
else
{
MemZero(m_gamepad);
}
}
}
void BulletImpl::updateData()
{
bool _exists = __exists && bwOriginalBullet;
if ( _exists )
{
for(int i = 0; i < 9; ++i)
{
PlayerImpl* player = static_cast<PlayerImpl*>(Broodwar->getPlayer(i));
if ( !bwOriginalBullet->sprite || !player )
self->isVisible[i] = false;
else if ( BWAPI::BroodwarImpl.isFlagEnabled(Flag::CompleteMapInformation) )
self->isVisible[i] = true;
else
self->isVisible[i] = Broodwar->isVisible( TilePosition(bwOriginalBullet->sprite->position) );
}
}
else
{
MemZero(self->isVisible);
}
if ( _exists &&
(BWAPI::BroodwarImpl.isFlagEnabled(Flag::CompleteMapInformation) ||
BroodwarImpl.isReplay() ||
isVisible()) )
{
UnitImpl *_getSource = UnitImpl::BWUnitToBWAPIUnit(bwOriginalBullet->sourceUnit);
UnitImpl *_getTarget = UnitImpl::BWUnitToBWAPIUnit(bwOriginalBullet->attackTarget.pUnit);
Player _getPlayer = _getSource ? _getSource->_getPlayer : nullptr;
// id, player, type, source
self->id = id;
self->player = (_getSource && _getSource->isAlive && _getPlayer) ? _getPlayer->getID() : -1;
self->type = bwOriginalBullet->type;
self->source = (_getSource && _getSource->exists()) ? _getSource->getID() : -1;
// position
self->positionX = bwOriginalBullet->position.x;
self->positionY = bwOriginalBullet->position.y;
// angle, velocity
int d = (int)bwOriginalBullet->currentDirection - 64;
if ( d < 0 )
d += 256;
self->angle = (double)d * 3.14159265358979323846 / 128.0;
self->velocityX = (double)(bwOriginalBullet->current_speed.x / 256.0);
self->velocityY = (double)(bwOriginalBullet->current_speed.y / 256.0);
// target, targetPosition
self->target = (_getTarget && _getTarget->exists()) ? _getTarget->getID() : -1;
self->targetPositionX = bwOriginalBullet->targetPosition.x;
self->targetPositionY = bwOriginalBullet->targetPosition.y;
// removeTimer
self->removeTimer = bwOriginalBullet->time_remaining;
// exists
self->exists = true;
}
else
{
self->id = -1;
self->player = -1;
self->type = BulletTypes::Unknown;
self->source = -1;
self->positionX = Positions::Unknown.x;
self->positionY = Positions::Unknown.y;
self->angle = 0;
self->velocityX = 0;
self->velocityY = 0;
self->target = -1;
self->targetPositionX = Positions::Unknown.x;
self->targetPositionY = Positions::Unknown.y;
self->removeTimer = 0;
self->exists = false;
}
}
//--------------------------------------------- UPDATE -----------------------------------------------------
void PlayerImpl::updateData()
{
self->color = index < BW::PLAYER_COUNT ? BW::BWDATA::PlayerColors[index] : Colors::Black;
// Get upgrades, tech, resources
if ( this->isNeutral() ||
index >= BW::PLAYER_COUNT ||
(!BroodwarImpl.isReplay() &&
BroodwarImpl.self()->isEnemy(this) &&
!BroodwarImpl.isFlagEnabled(Flag::CompleteMapInformation)) )
{
self->minerals = 0;
self->gas = 0;
self->gatheredMinerals = 0;
self->gatheredGas = 0;
self->repairedMinerals = 0;
self->repairedGas = 0;
self->refundedMinerals = 0;
self->refundedGas = 0;
// Reset values
MemZero(self->upgradeLevel);
MemZero(self->hasResearched);
MemZero(self->isUpgrading);
MemZero(self->isResearching);
MemZero(self->maxUpgradeLevel);
MemZero(self->isResearchAvailable);
MemZero(self->isUnitAvailable);
if (!this->isNeutral() && index < BW::PLAYER_COUNT)
{
// set upgrade level for visible enemy units
for(int i = 0; i < 46; ++i)
{
for(UnitType t : UpgradeType(i).whatUses())
{
if ( self->completedUnitCount[t] > 0 )
self->upgradeLevel[i] = BW::BWDATA::UpgradeLevelSC[index][i];
}
}
for (int i = 46; i < BW::UPGRADE_TYPE_COUNT; ++i)
{
for(UnitType t : UpgradeType(i).whatUses())
{
if ( self->completedUnitCount[t] > 0 )
self->upgradeLevel[i] = BW::BWDATA::UpgradeLevelBW[index][i - 46];
}
}
}
}
else
{
this->wasSeenByBWAPIPlayer = true;
// set resources
self->minerals = BW::BWDATA::PlayerResources.minerals[index];
self->gas = BW::BWDATA::PlayerResources.gas[index];
self->gatheredMinerals = BW::BWDATA::PlayerResources.cumulativeMinerals[index];
self->gatheredGas = BW::BWDATA::PlayerResources.cumulativeGas[index];
self->repairedMinerals = this->_repairedMinerals;
self->repairedGas = this->_repairedGas;
self->refundedMinerals = this->_refundedMinerals;
self->refundedGas = this->_refundedGas;
// set upgrade level
for(int i = 0; i < 46; ++i)
{
self->upgradeLevel[i] = BW::BWDATA::UpgradeLevelSC[index][i];
self->maxUpgradeLevel[i] = BW::BWDATA::UpgradeMaxSC[index][i];
}
for (int i = 46; i < BW::UPGRADE_TYPE_COUNT; ++i)
{
self->upgradeLevel[i] = BW::BWDATA::UpgradeLevelBW[index][i - 46];
self->maxUpgradeLevel[i] = BW::BWDATA::UpgradeMaxBW[index][i - 46];
}
// set abilities researched
for(int i = 0; i < 24; ++i)
{
self->hasResearched[i] = (TechType(i).whatResearches() == UnitTypes::None ? true : !!BW::BWDATA::TechResearchSC[index][i]);
self->isResearchAvailable[i] = !!BW::BWDATA::TechAvailableSC[index][i];
}
for (int i = 24; i < BW::TECH_TYPE_COUNT; ++i)
{
self->hasResearched[i] = (TechType(i).whatResearches() == UnitTypes::None ? true : !!BW::BWDATA::TechResearchBW[index][i - 24]);
self->isResearchAvailable[i] = !!BW::BWDATA::TechAvailableBW[index][i - 24];
}
// set upgrades in progress
for (int i = 0; i < BW::UPGRADE_TYPE_COUNT; ++i)
self->isUpgrading[i] = (BW::BWDATA::UpgradeProgress[index * 8 + i/8] & (1 << i%8)) != 0;
// set research in progress
for (int i = 0; i < BW::TECH_TYPE_COUNT; ++i)
self->isResearching[i] = (BW::BWDATA::ResearchProgress[index * 6 + i/8] & (1 << i%8)) != 0;
for (int i = 0; i < BW::UNIT_TYPE_COUNT; ++i)
self->isUnitAvailable[i] = !!BW::BWDATA::UnitAvailability[index][i];
self->hasResearched[TechTypes::Enum::Nuclear_Strike] = self->isUnitAvailable[UnitTypes::Enum::Terran_Nuclear_Missile];
}
// Get Scores, supply
if ( (!BroodwarImpl.isReplay() &&
BroodwarImpl.self()->isEnemy(this) &&
!BroodwarImpl.isFlagEnabled(Flag::CompleteMapInformation)) ||
index >= BW::PLAYER_COUNT)
{
MemZero(self->supplyTotal);
MemZero(self->supplyUsed);
MemZero(self->deadUnitCount);
MemZero(self->killedUnitCount);
self->totalUnitScore = 0;
self->totalKillScore = 0;
self->totalBuildingScore = 0;
self->totalRazingScore = 0;
self->customScore = 0;
}
else
{
// set supply
for (u8 i = 0; i < BW::RACE_COUNT; ++i)
{
self->supplyTotal[i] = BW::BWDATA::AllScores.supplies[i].available[index];
if (self->supplyTotal[i] > BW::BWDATA::AllScores.supplies[i].max[index])
self->supplyTotal[i] = BW::BWDATA::AllScores.supplies[i].max[index];
self->supplyUsed[i] = BW::BWDATA::AllScores.supplies[i].used[index];
}
// set total unit counts
for (int i = 0; i < BW::UNIT_TYPE_COUNT; ++i)
{
self->deadUnitCount[i] = BW::BWDATA::AllScores.unitCounts.dead[i][index];
self->killedUnitCount[i] = BW::BWDATA::AllScores.unitCounts.killed[i][index];
}
// set macro dead unit counts
self->deadUnitCount[UnitTypes::AllUnits] = BW::BWDATA::AllScores.allUnitsLost[index] + BW::BWDATA::AllScores.allBuildingsLost[index];
self->deadUnitCount[UnitTypes::Men] = BW::BWDATA::AllScores.allUnitsLost[index];
self->deadUnitCount[UnitTypes::Buildings] = BW::BWDATA::AllScores.allBuildingsLost[index];
self->deadUnitCount[UnitTypes::Factories] = BW::BWDATA::AllScores.allFactoriesLost[index];
// set macro kill unit counts
self->killedUnitCount[UnitTypes::AllUnits] = BW::BWDATA::AllScores.allUnitsKilled[index] + BW::BWDATA::AllScores.allBuildingsRazed[index];
self->killedUnitCount[UnitTypes::Men] = BW::BWDATA::AllScores.allUnitsKilled[index];
self->killedUnitCount[UnitTypes::Buildings] = BW::BWDATA::AllScores.allBuildingsRazed[index];
self->killedUnitCount[UnitTypes::Factories] = BW::BWDATA::AllScores.allFactoriesRazed[index];
// set score counts
self->totalUnitScore = BW::BWDATA::AllScores.allUnitScore[index];
self->totalKillScore = BW::BWDATA::AllScores.allKillScore[index];
self->totalBuildingScore = BW::BWDATA::AllScores.allBuildingScore[index];
self->totalRazingScore = BW::BWDATA::AllScores.allRazingScore[index];
self->customScore = BW::BWDATA::AllScores.customScore[index];
}
if (index < BW::PLAYER_COUNT && (BW::BWDATA::Players[index].nType == PlayerTypes::PlayerLeft ||
BW::BWDATA::Players[index].nType == PlayerTypes::ComputerLeft ||
(BW::BWDATA::Players[index].nType == PlayerTypes::Neutral && !isNeutral())))
{
self->leftGame = true;
}
}
NetworkError System::ResolveNetAddress( GChar * outServiceName, GChar * outHostName, const NetAddress * pAddress,
AddressResolveFlags iFlags ) const
{
Int iNameInfoFlags = 0;
if ( iFlags & ADDRRESOLVE_FLAG_NUMERIC_SERVICE )
iNameInfoFlags |= NI_NUMERICSERV;
if ( iFlags & ADDRRESOLVE_FLAG_NUMERIC_HOST )
iNameInfoFlags |= NI_NUMERICHOST;
if ( iFlags & ADDRRESOLVE_FLAG_RELATIVE_NAME )
iNameInfoFlags |= NI_NOFQDN;
if ( iFlags & ADDRRESOLVE_FLAG_REQUIRED_NAME )
iNameInfoFlags |= NI_NAMEREQD;
if ( iFlags & ADDRRESOLVE_FLAG_DATAGRAM )
iNameInfoFlags |= NI_DGRAM;
Int iResult;
switch( pAddress->iType ) {
case NETADDRESS_IPv4: {
const NetAddressIPv4 * pAddr = (const NetAddressIPv4 *)pAddress;
SOCKADDR_IN sockIPv4;
MemZero( &sockIPv4, sizeof(SOCKADDR_IN) );
sockIPv4.sin_family = AF_INET;
sockIPv4.sin_addr.s_addr = pAddr->Addr.Value;
sockIPv4.sin_port = pAddr->wPort;
iResult = GetNameInfo( (const SOCKADDR*)( &sockIPv4 ), sizeof(SOCKADDR_IN),
outHostName, NI_MAXHOST, outServiceName, NI_MAXSERV, iNameInfoFlags );
} break;
case NETADDRESS_IPv6: {
const NetAddressIPv6 * pAddr = (const NetAddressIPv6 *)pAddress;
SOCKADDR_IN6 sockIPv6;
MemZero( &sockIPv6, sizeof(SOCKADDR_IN6) );
sockIPv6.sin6_family = AF_INET6;
sockIPv6.sin6_flowinfo = pAddr->dwFlowInfo;
sockIPv6.sin6_scope_id = pAddr->dwScopeID;
MemCopy( sockIPv6.sin6_addr.s6_addr, pAddr->Addr.Bytes, 16 );
sockIPv6.sin6_port = pAddr->wPort;
iResult = GetNameInfo( (const SOCKADDR*)( &sockIPv6 ), sizeof(SOCKADDR_IN6),
outHostName, NI_MAXHOST, outServiceName, NI_MAXSERV, iNameInfoFlags );
} break;
default: return NETWORK_ERROR;
}
if ( iResult == 0 )
return NETWORK_OK;
iResult = WSAGetLastError();
switch(iResult) {
case WSAHOST_NOT_FOUND: return NETWORK_HOST_NOT_FOUND;
case WSATRY_AGAIN: return NETWORK_RETRY;
case WSANOTINITIALISED:
case WSAEAFNOSUPPORT:
case WSAEINVAL:
case WSAEFAULT:
case WSANO_RECOVERY:
default: break;
}
return NETWORK_ERROR;
}
