bool CommonScheduleThread::run()
{
Log.Success("CommonScheduleThread", "Started.");
m_busy = false;
if(sWorld.BCSystemEnable && sWorld.BCOrderMode == 1)
itOrderMSGEntry = objmgr.GetBCTotalItemBegin();
// cebernic nothing in storage
if(objmgr.IsBCEntryStorageEmpty()) sWorld.BCSystemEnable = 0;
BCTimerCount = getMSTime() + ((uint32)sWorld.BCInterval * 1000);
while(GetThreadState() != THREADSTATE_TERMINATE)
{
m_busy = true;
// do job -------------------
BroadCastExec();
// -----------------------
m_busy = false;
if(GetThreadState() == THREADSTATE_TERMINATE)
break;
cond.Wait(THREAD_LOOP_INTERVAL * 1000);
if(!m_running)
break;
}
return true;
}
void CBSPLightingThread::Interrupt()
{
if( GetThreadState() == STATE_LIGHTING )
{
m_pVRadDLL->Interrupt();
while( GetThreadState() == STATE_LIGHTING )
Sleep( 10 );
}
}
void Database::thread_proc_query()
{
QueryBuffer* q;
DatabaseConnection* con = GetFreeConnection();
q = query_buffer.pop();
while(1)
{
if(q != NULL)
{
PerformQueryBuffer(q, con);
delete q;
}
if(GetThreadState() == THREADSTATE_TERMINATE)
break;
q = query_buffer.pop();
if(q == NULL)
arcpro::Sleep(10);
}
con->Busy.Release();
// kill any queries
q = query_buffer.pop();
while(q != NULL)
{
PerformQueryBuffer(q, NULL);
delete q;
q = query_buffer.pop();
}
}
bool Thread::Start(ThreadState initialState)
{
if (initialState == NotRunning)
return 0;
if (GetThreadState() != NotRunning)
{
OVR_DEBUG_LOG(("Thread::Start failed - thread %p already running", this));
return 0;
}
// Free old thread handle before creating the new one
CleanupSystemThread();
ExitCode = NULL;
ThreadFlags = (initialState == Running) ? OVR_THREAD_STARTED : OVR_THREAD_START_SUSPENDED;
ThreadHandle = (HANDLE) _beginthreadex(0, (unsigned)StackSize,
Thread_Win32StartFn, this, 0, (unsigned*)&IdValue);
// Failed? Fail the function
if (ThreadHandle == 0)
{
ThreadFlags = 0;
return 0;
}
return 1;
}
int OCThreadBase::WaitUntilThreadDestroy()
{
//float fBeginTime = time();
//DWORD dwElapsedTime;
while(true)
{
int iThreadState = GetThreadState();
if(iThreadState == THREAD_STATE_END)
{
return iThreadState;
}
else
{
// wait
//dwElapsedTime = time() - dwBeginTime;
//if(dwElapsedTime > 10000)
//{
// assert(0);
// return iThreadState;
//}
}
}
return THREAD_STATE_PROBLEM;
}
//+---------------------------------------------------------------------------
//
// Function: InitScrollbarTiming
//
// Synopsis: Get scrollbar's timing info into a thread local storage
// scrollTimeInfo structure
//
//----------------------------------------------------------------------------
void InitScrollbarTiming()
{
THREADSTATE* pts = GetThreadState();
Assert(pts);
Assert(pts->pSBC);
pts->scrollTimeInfo.lRepeatDelay = pts->pSBC->GetRepeatDelay();
pts->scrollTimeInfo.lRepeatRate = pts->pSBC->GetRepeatRate();
pts->scrollTimeInfo.lFocusRate = pts->pSBC->GetFocusRate();
}
bool GameEventMgr::GameEventMgrThread::run()
{
Log.Success("GameEventMgr", "Started.");
// Do NOT uncomment this unless you know what you're doing, debug code
//CleanupEntities();
SpawnActiveEvents();
THREAD_TRY_EXECUTION
while (GetThreadState() != THREADSTATE_TERMINATE)
{
while (GetThreadState() == THREADSTATE_PAUSED)
{
m_IsActive = false;
Arcemu::Sleep(200);
}
m_IsActive = true;
if (GetThreadState() == THREADSTATE_TERMINATE)
break;
ThreadState.SetVal(THREADSTATE_BUSY);
Update();
if (GetThreadState() == THREADSTATE_TERMINATE)
break;
ThreadState.SetVal(THREADSTATE_SLEEPING);
Arcemu::Sleep(1 * 1000); // 1 second
}
THREAD_HANDLE_CRASH
return true;
}
bool DayWatcherThread::run()
{
Log.Success("DayWatcherThread", "Started.");
currenttime = UNIXTIME;
dupe_tm_pointer(localtime(¤ttime), &local_currenttime);
load_settings();
set_tm_pointers();
m_busy = false;
while (GetThreadState() != THREADSTATE_TERMINATE)
{
m_busy = true;
currenttime = UNIXTIME;
dupe_tm_pointer(localtime(¤ttime), &local_currenttime);
if (has_timeout_expired(&local_currenttime, &local_last_arena_time, arena_period))
update_arena();
if (has_timeout_expired(&local_currenttime, &local_last_daily_time, daily_period))
update_daily();
if (m_dirty)
update_settings();
m_busy = false;
if (GetThreadState() == THREADSTATE_TERMINATE)
break;
cond.Wait(THREAD_LOOP_INTERVAL * 1000);
if (!m_running)
break;
}
return true;
}
bool Database::run()
{
SetThreadName("Database Execute Thread");
SetThreadState(THREADSTATE_BUSY);
ThreadRunning = true;
char* query = queries_queue.pop();
DatabaseConnection* con = GetFreeConnection();
while(1)
{
if(query != NULL)
{
if(con == NULL)
con = GetFreeConnection();
_SendQuery(con, query, false);
delete[] query;
}
if(GetThreadState() == THREADSTATE_TERMINATE)
break;
query = queries_queue.pop();
if(query == NULL)
{
if(con != NULL)
con->Busy.Release();
con = NULL;
arcpro::Sleep(10);
}
}
if(con != NULL)
con->Busy.Release();
// execute all the remaining queries
query = queries_queue.pop();
while(query)
{
con = GetFreeConnection();
_SendQuery(con, query, false);
con->Busy.Release();
delete[] query;
query = queries_queue.pop();
}
ThreadRunning = false;
return false;
}
bool Lacrimi::run()
{
Delay(400);
if(GetConfigBool("Features", "LuaEngine", true))
{
L_LuaEngineMgr = new LuaEngineMgr();
L_LuaEngineMgr->Startup();
Delay(100);
while(LuaEngineIsStarting)
Delay(100);
}
uint32 curTime = getMSTime();
uint32 m_StatDumpTimer = curTime+15000, m_CleanupDelay = curTime+10000;
while(GetThreadState() != THREADSTATE_SELF_TERMINATE)
{
curTime = getMSTime();
if(!SetThreadState(THREADSTATE_BUSY))
break;
if(dumpstats)
{
if(curTime > m_StatDumpTimer)
{
DumpStats();
m_StatDumpTimer = curTime+60000;
}
}
if(curTime > m_CleanupDelay)
Cleanup();
if(!SetThreadState(THREADSTATE_SLEEPING))
break;
Delay(5);
}
sLog.Notice("Lacrimi", "Terminating...");
FinalCleanup();
if(database)
_StopDB();
OnShutdown();
return true;
}
HRESULT CTxtSlave::ComputeFormats(CFormatInfo* pCFI, CTreeNode* pNodeTarget)
{
HRESULT hr = S_OK;
CTreeNode* pNodeMaster = NULL;
CElement* pElemMaster = MarkupMaster();
CDocument* pDoc = Doc();
THREADSTATE* pts = GetThreadState();
BOOL fComputeFFOnly = pNodeTarget->_iCF != -1;
COMPUTEFORMATSTYPE eExtraValues = pCFI->_eExtraValues;
Assert(pCFI);
Assert(SameScope(this, pNodeTarget));
Assert(eExtraValues!=ComputeFormatsType_Normal || ((pNodeTarget->_iCF==-1 && pNodeTarget->_iPF==-1) || pNodeTarget->_iFF==-1));
if(pElemMaster)
{
pNodeMaster = pElemMaster->GetFirstBranch();
// Get the format of our master before applying our own format.
if(pNodeMaster)
{
// If the master node has not computed formats yet, recursively compute them
if(pNodeMaster->_iCF==-1 || pNodeMaster->_iFF==-1
|| eExtraValues==ComputeFormatsType_GetInheritedValue)
{
hr = pElemMaster->ComputeFormats(pCFI, pNodeMaster);
if(hr)
{
goto Cleanup;
}
}
Assert(pNodeMaster->_iCF >= 0);
Assert(pNodeMaster->_iPF >= 0);
Assert(pNodeMaster->_iFF >= 0);
}
}
// NOTE: From this point forward any errors must goto Error instead of Cleanup!
pCFI->Reset();
pCFI->_pNodeContext = pNodeTarget;
if(pNodeMaster)
{
// Inherit para format directly from the master node.
pCFI->_iffSrc = pNodeMaster->_iFF;
pCFI->_pffSrc = pCFI->_pff = &(*pts->_pFancyFormatCache)[pCFI->_iffSrc];
pCFI->_fHasExpandos = (pCFI->_pff->_iExpandos >= 0);
if(!fComputeFFOnly)
{
// Inherit the Char and Para formats from the master node
pCFI->_icfSrc = pNodeMaster->_iCF;
pCFI->_pcfSrc = pCFI->_pcf = &(*pts->_pCharFormatCache)[pCFI->_icfSrc];
pCFI->_ipfSrc = pNodeMaster->_iPF;
pCFI->_ppfSrc = pCFI->_ppf = &(*pts->_pParaFormatCache)[pCFI->_ipfSrc];
// If the parent had layoutness, clear the inner formats
if(pCFI->_pcf->_fHasDirtyInnerFormats)
{
pCFI->PrepareCharFormat();
pCFI->_cf().ClearInnerFormats();
pCFI->UnprepareForDebug();
}
if(pCFI->_ppf->_fHasDirtyInnerFormats)
{
pCFI->PrepareParaFormat();
pCFI->_pf().ClearInnerFormats();
pCFI->UnprepareForDebug();
}
if(pCFI->_ppf->_fPre != pCFI->_ppf->_fPreInner
|| pCFI->_ppf->_fInclEOLWhite != pCFI->_ppf->_fInclEOLWhiteInner
|| pCFI->_ppf->_bBlockAlign != pCFI->_ppf->_bBlockAlignInner)
{
pCFI->PrepareParaFormat();
pCFI->_pf()._fPre = pCFI->_pf()._fPreInner;
pCFI->_pf()._fInclEOLWhite = pCFI->_pf()._fInclEOLWhiteInner;
pCFI->_pf()._bBlockAlign = pCFI->_pf()._bBlockAlignInner;
pCFI->UnprepareForDebug();
}
if(pCFI->_pcf->_fNoBreak != pCFI->_pcf->_fNoBreakInner)
{
pCFI->PrepareCharFormat();
pCFI->_cf()._fNoBreak = pCFI->_cf()._fNoBreakInner;
pCFI->UnprepareForDebug();
}
}
else
{
pCFI->_icfSrc = pDoc->_icfDefault;
pCFI->_pcfSrc = pCFI->_pcf = pDoc->_pcfDefault;
pCFI->_ipfSrc = pts->_ipfDefault;
pCFI->_ppfSrc = pCFI->_ppf = pts->_ppfDefault;
}
}
else
{
pCFI->_iffSrc = pts->_iffDefault;
pCFI->_pffSrc = pCFI->_pff = pts->_pffDefault;
pCFI->_icfSrc = pDoc->_icfDefault;
pCFI->_pcfSrc = pCFI->_pcf = pDoc->_pcfDefault;
pCFI->_ipfSrc = pts->_ipfDefault;
pCFI->_ppfSrc = pCFI->_ppf = pts->_ppfDefault;
Assert(pCFI->_pffSrc->_pszFilters == NULL);
}
if(pCFI->_pff->_fHasLayout || !pCFI->_pff->_fBlockNess)
{
pCFI->PrepareFancyFormat();
pCFI->_ff()._fHasLayout = FALSE;
pCFI->_ff()._fBlockNess = TRUE;
pCFI->UnprepareForDebug();
}
if(eExtraValues == ComputeFormatsType_Normal)
{
hr = pNodeTarget->CacheNewFormats(pCFI);
if(hr)
{
goto Error;
}
// Cache whether an element is a block element or not for fast retrieval.
pNodeTarget->_fBlockNess = TRUE;
pNodeTarget->_fHasLayout = FALSE;
}
Cleanup:
RRETURN(hr);
Error:
pCFI->Cleanup();
goto Cleanup;
}
// Draw the src rect of the specified image into the dest rect of the hdc
void CImgBitsDIB::StretchBlt(HDC hdc, RECT* prcDst, RECT* prcSrc, DWORD dwRop, DWORD dwFlags)
{
HDC hdcDib = NULL;
HBITMAP hbmSav = NULL;
int xDst = prcDst->left;
int yDst = prcDst->top;
int xDstWid = prcDst->right - xDst;
int yDstHei = prcDst->bottom - yDst;
int xSrc = prcSrc->left;
int ySrc = prcSrc->top;
int xSrcWid = prcSrc->right - xSrc;
int ySrcHei = prcSrc->bottom - ySrc;
int yUseHei = _yHeight;
// Cases in which there is nothing to draw
if((!_pvImgBits && !_pvMaskBits && !_fSolid) || _yHeightValid==0)
{
return;
}
if(xDstWid<=0 || xSrcWid<=0 || _xWidth<=0 || yDstHei<=0 || ySrcHei<=0 || _yHeight<=0)
{
return;
}
if(dwRop!=SRCCOPY && (_pvMaskBits || _iTrans>=0))
{
return;
}
// Step 1: Limit the source and dest rectangles to the visible area only.
if(_yHeightValid>0 && _yHeightValid<_yHeight)
{
yUseHei = _yHeightValid;
}
if(xSrc < 0)
{
xDst += MulDivQuick(-xSrc, xDstWid, xSrcWid);
xDstWid = prcDst->right - xDst;
xSrcWid += xSrc;
xSrc = 0;
if(xDstWid<=0 || xSrcWid<=0)
{
return;
}
}
if(ySrc < 0)
{
yDst += MulDivQuick(-ySrc, yDstHei, ySrcHei);
yDstHei = prcDst->bottom - yDst;
ySrcHei += ySrc;
ySrc = 0;
if(yDstHei<=0 || ySrcHei<=0)
{
return;
}
}
if(xSrc+xSrcWid > _xWidth)
{
xDstWid = MulDivQuick(xDstWid, _xWidth-xSrc, xSrcWid);
xSrcWid = _xWidth - xSrc;
if(xDstWid<=0 || xSrcWid<=0)
{
return;
}
}
if(ySrc+ySrcHei > yUseHei)
{
yDstHei = MulDivQuick(yDstHei, yUseHei-ySrc, ySrcHei);
ySrcHei = yUseHei - ySrc;
if(yDstHei<=0 || ySrcHei<=0)
{
return;
}
}
// For the mirrored case, we need flip then offset.
if(_fNeedMirroring)
{
// We need to handle clipping correctly and give a right-to-left tiling effect.
// Let's take the "opposite" slice of the source.
// The maximum will be the whole image.
xSrc = - xSrc +_xWidth - xSrcWid;
xDst += xDstWid - 1;
xDstWid = - xDstWid;
}
// Optimization: if solid, just patblt the color
if(_fSolid)
{
// Turn on the palette relative bit for palettized devices in order to ensure that dithering
// doesn't happen here. The main reason is that is looks ugly, but more importantly we aren't
// prepared to seam multiple copies of the image so that the dithering looks smooth.
PatBltBrush(hdc, xDst, yDst, xDstWid, yDstHei, PATCOPY, _crSolid|g_crPaletteRelative);
return;
}
SetStretchBltMode(hdc, COLORONCOLOR);
// Step 2: For tranparent images, use mask to whiten drawing area
if(_pvMaskBits || _iTrans>=0)
{
if(dwFlags & DRAWIMAGE_NOTRANS)
{
goto NoTransparency;
}
if(GetDeviceCaps(hdc, TECHNOLOGY) == DT_RASPRINTER)
{
// No transparency for printers that we know lie about their support for transparency.
int iEscapeFunction = POSTSCRIPT_PASSTHROUGH;
THREADSTATE* pts = GetThreadState();
if(Escape(hdc, QUERYESCSUPPORT, sizeof(int), (LPCSTR)&iEscapeFunction, NULL))
{
// Skip transparency unless we are a mask-only image
if(_pvImgBits || !_pvMaskBits)
{
goto NoTransparency;
}
}
}
if(_pvMaskBits)
{
// 1-bit mask case
if(_hbmMask)
{
// We have an HBITMAP, not just bits
Assert(!hdcDib && !hbmSav);
hdcDib = GetMemoryDC();
if(!hdcDib)
{
goto Cleanup;
}
// Special case: use MaskBlt for the whole thing on NT
if(xSrcWid==xDstWid && ySrcHei==yDstHei && _hbmImg)
{
hbmSav = (HBITMAP)SelectObject(hdcDib, _hbmImg);
MaskBlt(hdc, xDst, yDst, xDstWid, yDstHei,
hdcDib, xSrc, ySrc, _hbmMask, xSrc, ySrc, 0xAACC0020);
goto Cleanup;
}
hbmSav = (HBITMAP)SelectObject(hdcDib, _hbmMask);
if(!_pvImgBits)
{
// a mask-only one-bit image: just draw the "1" bits as black
::StretchBlt(hdc, xDst, yDst, xDstWid, yDstHei,
hdcDib, xSrc, ySrc, xSrcWid, ySrcHei, MERGEPAINT);
}
else
{
// transparent mask: draw the "1" bits as white
::StretchBlt(hdc, xDst, yDst, xDstWid, yDstHei,
hdcDib, xSrc, ySrc, xSrcWid, ySrcHei, SRCPAINT);
}
}
else
{
// We have just bits, not an HBITMAP
struct
{
BITMAPINFOHEADER bmih;
union
{
RGBQUAD rgb[2];
WORD windex[2];
};
} bmiMask;
// construct mask header
memset(&bmiMask, 0, sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*2);
bmiMask.bmih.biSize = sizeof(BITMAPINFOHEADER);
bmiMask.bmih.biWidth = _xWidth;
bmiMask.bmih.biHeight = _yHeight;
bmiMask.bmih.biPlanes = 1;
bmiMask.bmih.biBitCount = 1;
if(!_pvImgBits)
{
// a mask-only one-bit image: just draw the "1" bits as black
bmiMask.rgb[0] = g_rgbWhite;
StretchDIBits(hdc, xDst, yDst, xDstWid, yDstHei,
xSrc, _yHeight-ySrc-ySrcHei, xSrcWid, ySrcHei, _pvMaskBits, (BITMAPINFO*)&bmiMask, DIB_RGB_COLORS, SRCAND);
}
else if(_iBitCount<=8 && _fPalColors && !(dwFlags&DRAWIMAGE_NHPALETTE))
{
// this setup only occurs on an 8-bit palettized display; we can use DIB_PAL_COLORS
bmiMask.windex[1] = 255;
StretchDIBits(hdc, xDst, yDst, xDstWid, yDstHei,
xSrc, _yHeight-ySrc-ySrcHei, xSrcWid, ySrcHei, _pvMaskBits, (BITMAPINFO*)&bmiMask, DIB_PAL_COLORS, SRCPAINT);
}
else
{
bmiMask.rgb[1] = g_rgbWhite;
StretchDIBits(hdc, xDst, yDst, xDstWid, yDstHei,
xSrc, _yHeight-ySrc-ySrcHei, xSrcWid, ySrcHei, _pvMaskBits, (BITMAPINFO *)&bmiMask, DIB_RGB_COLORS, SRCPAINT);
}
}
}
else
{
// 1- 4- or 8-bit mask case (with _iTrans)
long cTable = 1 << _iBitCount;
Assert(_iTrans >= 0);
Assert(_iTrans < cTable);
Assert(_iBitCount <= 8);
if(_hbmImg)
{
// We have an HBITMAP, not just bits
RGBQUAD argbOld[256];
RGBQUAD argbNew[256];
memset(argbNew, 0, sizeof(RGBQUAD)*cTable);
argbNew[_iTrans] = g_rgbWhite;
Assert(!hdcDib && !hbmSav);
hdcDib = GetMemoryDC();
if(!hdcDib)
{
goto Cleanup;
}
hbmSav = (HBITMAP)SelectObject(hdcDib, _hbmImg);
// HBM case: we need to change the color table, which can only be done one-at-a time
g_csImgTransBlt.Enter();
Verify(GetDIBColorTable(hdcDib, 0, cTable, argbOld) > 0);
Verify(SetDIBColorTable(hdcDib, 0, cTable, argbNew) == (unsigned)cTable);
::StretchBlt(hdc, xDst, yDst, xDstWid, yDstHei,
hdcDib, xSrc, ySrc, xSrcWid, ySrcHei, MERGEPAINT);
Verify(SetDIBColorTable(hdcDib, 0, cTable, argbOld) == (unsigned)cTable);
g_csImgTransBlt.Leave();
}
else
{
// We have just bits, not an HBITMAP
struct
{
BITMAPINFOHEADER bmih;
RGBQUAD rgb[256];
} bmiMask;
// construct mask header
memset(&bmiMask, 0, sizeof(BITMAPINFOHEADER)+(sizeof(RGBQUAD)*cTable));
bmiMask.bmih.biSize = sizeof(BITMAPINFOHEADER);
bmiMask.bmih.biWidth = _xWidth;
bmiMask.bmih.biHeight = _yHeight;
bmiMask.bmih.biPlanes = 1;
bmiMask.bmih.biBitCount = _iBitCount;
bmiMask.rgb[_iTrans] = g_rgbWhite;
StretchDIBits(hdc, xDst, yDst, xDstWid, yDstHei,
xSrc, _yHeight-ySrc-ySrcHei, xSrcWid, ySrcHei, _pvImgBits, (BITMAPINFO*)&bmiMask, DIB_RGB_COLORS, MERGEPAINT);
}
}
// prepare for transparent blt: area to be painted is now whitened, so AND-blt on top of it
dwRop = SRCAND;
}
NoTransparency:
// Step 3: Draw the image bits
if(_pvImgBits)
{
if(dwFlags & DRAWIMAGE_MASKONLY)
{
goto Cleanup;
}
if(_hbmImg)
{
// The normal case (not to a Win95 printer): call StretchBlt
if(!hdcDib)
{
hdcDib = GetMemoryDC();
if(!hdcDib)
{
goto Cleanup;
}
}
HBITMAP hbmOld;
hbmOld = (HBITMAP)SelectObject(hdcDib, _hbmImg);
if(!hbmSav)
{
hbmSav = hbmOld;
}
::StretchBlt(hdc, xDst, yDst, xDstWid, yDstHei, hdcDib, xSrc, ySrc, xSrcWid, ySrcHei, dwRop);
}
else
{
// We have just bits, not an HBITMAP
if(!_pbmih)
{
// No color table header: cobble up a standard header [perhaps these should just be globally cached?]
struct
{
BITMAPINFOHEADER bmih;
union
{
WORD windex[256];
RGBQUAD rgb[256];
DWORD bfmask[3];
};
} bmi;
DWORD dwDibMode = DIB_RGB_COLORS;
// construct mask header
memset(&bmi, 0, sizeof(BITMAPINFOHEADER)+(_iBitCount>8?sizeof(DWORD)*3:sizeof(WORD)*(_iBitCount<<1)));
bmi.bmih.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmih.biWidth = _xWidth;
bmi.bmih.biHeight = _yHeight;
bmi.bmih.biPlanes = 1;
bmi.bmih.biBitCount = _iBitCount + (_iBitCount==15);
if(_iBitCount == 4)
{
// Thanks to Steve Palmer: fix VGA color rendering
bmi.bmih.biClrUsed = 16;
bmi.bmih.biClrImportant = 16;
CopyColorsFromPaletteEntries(bmi.rgb, g_peVga, 16);
}
else if(_iBitCount <= 8)
{
if(dwFlags & DRAWIMAGE_NHPALETTE)
{
// If being drawn on an <= 8-bit surface from a filter, we can make no assumptions about
// the selected palette, so use RGB_COLORS
LONG c;
c = (1 << (_iBitCount-1));
memcpy(bmi.rgb, g_rgbHalftone, c*sizeof(RGBQUAD));
memcpy(bmi.rgb+c, g_rgbHalftone+256-c, c*sizeof(RGBQUAD));
}
else
{
// internal draw, no color table with _iBitCount <= 8 means that the palette selected into hdc
// is our standard 8-bit halftone palette and we can use DIB_PAL_COLORS
LONG c;
LONG d;
WORD* pwi;
dwDibMode = DIB_PAL_COLORS;
for(c=(1<<(_iBitCount-1)),pwi=bmi.windex+c; c; *(--pwi)=(--c));
for(c=(1<<(_iBitCount-1)),pwi=bmi.windex+c*2,d=256; c; --c,*(--pwi)=(--d));
}
}
else if(_iBitCount == 16)
{
// sixteen-bit case: fill in the bitfields mask for 565
bmi.bmih.biCompression = BI_BITFIELDS;
bmi.bfmask[0] = MASK565_0;
bmi.bfmask[1] = MASK565_1;
bmi.bfmask[2] = MASK565_2;
}
StretchDIBits(hdc, xDst, yDst, xDstWid, yDstHei,
xSrc, _yHeight-ySrc-ySrcHei, xSrcWid, ySrcHei, _pvImgBits, (BITMAPINFO*)&bmi, dwDibMode, dwRop);
}
else
{
StretchDIBits(hdc, xDst, yDst, xDstWid, yDstHei,
xSrc, _yHeight-ySrc-ySrcHei, xSrcWid, ySrcHei, _pvImgBits, (BITMAPINFO*)_pbmih, DIB_RGB_COLORS, dwRop);
}
}
}
Cleanup:
if(hbmSav)
{
SelectObject(hdcDib, hbmSav);
}
if(hdcDib)
{
ReleaseMemoryDC(hdcDib);
}
}
int CBSPLightingThread::GetCurrentState()
{
return GetThreadState();
}
void fastPoll( void )
{
RANDOM_STATE randomState;
BYTE buffer[ RANDOM_BUFSIZE + 8 ];
/* BatteryTimeRec batteryTimeInfo; */
SMStatus soundStatus;
ThreadID threadID;
ThreadState threadState;
EventRecord eventRecord;
Point point;
WindowPtr windowPtr;
PScrapStuff scrapInfo;
UnsignedWide usSinceStartup;
BYTE dataBuffer[ 2 + 8 ];
/* short driverRefNum; */
UInt32 dateTime;
/* int count, dummy; */
NumVersion version;
initRandomData( randomState, buffer, RANDOM_BUFSIZE );
/* Get the status of the last alert, how much battery time is remaining
and the voltage from all batteries, the internal battery status, the
current date and time and time since system startup in ticks, the
application heap limit and current and heap zone, free memory in the
current and system heap, microseconds since system startup, whether
QuickDraw has finished drawing, modem status, SCSI status
information, maximum block allocatable without compacting, available
stack space, the last QuickDraw error code */
/* addRandomValue( randomState, GetAlertStage() );
count = BatteryCount();
while( count-- > 0 )
{
addRandomValue( randomState,
GetBatteryVoltage( count ) );
GetBatteryTimes( count, &batteryTimeInfo );
addRandomData( randomState, &batteryTimeInfo,
sizeof( BatteryTimeRec ) );
}
if( !BatteryStatus( buffer, dataBuffer + 1 ) )
addRandomValue( randomState, dataBuffer );
*/ GetDateTime( &dateTime );
addRandomValue( randomState, dateTime );
addRandomValue( randomState, TickCount() );
#if !defined CALL_NOT_IN_CARBON || CALL_NOT_IN_CARBON
addRandomValue( randomState, GetApplLimit() );
addRandomValue( randomState, GetZone() );
addRandomValue( randomState, SystemZone() );
addRandomValue( randomState, FreeMem() );
addRandomValue( randomState, FreeMemSys() );
#endif
/* MicroSeconds( &usSinceStartup );
addRandomData( randomState, &usSinceStartup, sizeof( UnsignedWide ) ); */
addRandomValue( randomState, QDDone( NULL ) );
/* ModemStatus( dataBuffer );
addRandomValue( randomState, dataBuffer[ 0 ] ); */
#if !defined CALL_NOT_IN_CARBON || CALL_NOT_IN_CARBON
addRandomValue( randomState, SCSIStat() );
#endif
addRandomValue( randomState, MaxBlock() );
addRandomValue( randomState, StackSpace() );
addRandomValue( randomState, QDError() );
/* Get the event code and message, time, and mouse location for the next
event in the event queue and the OS event queue */
if( EventAvail( everyEvent, &eventRecord ) )
addRandomData( randomState, &eventRecord, sizeof( EventRecord ) );
#if !defined CALL_NOT_IN_CARBON || CALL_NOT_IN_CARBON
if( OSEventAvail( everyEvent, &eventRecord ) )
addRandomData( randomState, &eventRecord, sizeof( EventRecord ) );
#endif
/* Get all sorts of information such as device-specific info, grafport
information, visible and clipping region, pattern, pen, text, and
colour information, and other details, on the topmost window. Also
get the window variant. If there's a colour table record, add the
colour table as well */
if( ( windowPtr = FrontWindow() ) != NULL )
{
/* CTabHandle colourHandle; */
#if !defined OPAQUE_TOOLBOX_STRUCTS || !OPAQUE_TOOLBOX_STRUCTS
addRandomData( randomState, windowPtr, sizeof( GrafPort ) );
#endif
addRandomValue( randomState, GetWVariant( windowPtr ) );
/* if( GetAuxWin( windowPtr, colourHandle ) )
{
CTabPtr colourPtr;
HLock( colourHandle );
colourPtr = *colourHandle;
addRandomData( randomState, colourPtr, sizeof( ColorTable ) );
HUnlock( colourHandle );
} */
}
/* Get mouse-related such as the mouse button status and mouse position,
information on the window underneath the mouse */
addRandomValue( randomState, Button() );
GetMouse( &point );
addRandomData( randomState, &point, sizeof( Point ) );
FindWindow( point, &windowPtr );
#if !defined OPAQUE_TOOLBOX_STRUCTS || !OPAQUE_TOOLBOX_STRUCTS
if( windowPtr != NULL )
addRandomData( randomState, windowPtr, sizeof( GrafPort ) );
#endif
/* Get the size, handle, and location of the desk scrap/clipboard */
#if !defined CALL_NOT_IN_CARBON || CALL_NOT_IN_CARBON
scrapInfo = InfoScrap();
addRandomData( randomState, scrapInfo, sizeof( ScrapStuff ) );
#endif
/* Get information on the current thread */
threadID = kCurrentThreadID; /*GetThreadID( &threadID ); */
GetThreadState( threadID, &threadState );
addRandomData( randomState, &threadState, sizeof( ThreadState ) );
/* Get the sound mananger status. This gets the number of allocated
sound channels and the current CPU load from these channels */
SndManagerStatus( sizeof( SMStatus ), &soundStatus );
addRandomData( randomState, &soundStatus, sizeof( SMStatus ) );
/* Get the speech manager version and status */
/* version = SpeechManagerVersion();
addRandomData( randomState, &version, sizeof( NumVersion ) );
addRandomValue( randomState, SpeechBusy() );
*/
/* Get the status of the serial port. This gets information on recent
errors, read and write pending status, and flow control values */
/* if( !OpenDriver( "\p.AIn", &driverRefNum ) )
{
SerStaRec serialStatus;
SetStatus( driverRefNum, &serialStatus );
addRandomData( randomState, &serialStatus, sizeof( SerStaRec ) );
}
if( !OpenDriver( "\p.AOut", &driverRefNum ) )
{
SerStaRec serialStatus;
SetStatus( driverRefNum, &serialStatus );
addRandomData( randomState, &serialStatus, sizeof( SerStaRec ) );
} */
/* Flush any remaining data through */
endRandomData( randomState, 10 );
}
bool WorldRunnable::run()
{
SetThreadName("WorldRunnable (non-instance/logon)");
uint32 LastWorldUpdate = getMSTime();
uint32 LastSessionsUpdate = getMSTime();
THREAD_TRY_EXECUTION
while (GetThreadState() != THREADSTATE_TERMINATE)
{
// Provision for pausing this thread.
if (GetThreadState() == THREADSTATE_PAUSED)
{
while (GetThreadState() == THREADSTATE_PAUSED)
{
Arcemu::Sleep(200);
}
}
if (GetThreadState() == THREADSTATE_TERMINATE)
break;
ThreadState.SetVal(THREADSTATE_BUSY);
uint32 diff;
//calc time passed
uint32 now, execution_start;
now = getMSTime();
execution_start = now;
if (now < LastWorldUpdate) //overrun
diff = WORLD_UPDATE_DELAY;
else
diff = now - LastWorldUpdate;
LastWorldUpdate = now;
sWorld.Update(diff);
now = getMSTime();
if (now < LastSessionsUpdate) //overrun
diff = WORLD_UPDATE_DELAY;
else
diff = now - LastSessionsUpdate;
LastSessionsUpdate = now;
sWorld.UpdateSessions(diff);
now = getMSTime();
//we have to wait now
if (execution_start > now)//overrun
diff = WORLD_UPDATE_DELAY - now;
else
diff = now - execution_start; //time used for updating
if (GetThreadState() == THREADSTATE_TERMINATE)
break;
ThreadState.SetVal(THREADSTATE_SLEEPING);
/*This is execution time compensating system
if execution took more than default delay
no need to make this sleep*/
if (diff < WORLD_UPDATE_DELAY)
Arcemu::Sleep(WORLD_UPDATE_DELAY - diff);
}
THREAD_HANDLE_CRASH
return true;
}
bool MapMgr::Do()
{
#ifdef WIN32
threadid = GetCurrentThreadId();
#endif
t_currentMapContext.set(this);
thread_running = true;
ThreadState.SetVal(THREADSTATE_BUSY);
SetThreadName("Map mgr - M%u|I%u", this->_mapId , this->m_instanceID);
ObjectSet::iterator i;
uint32 last_exec = getMSTime();
// Create Instance script
LoadInstanceScript();
/* create static objects */
for(GOSpawnList::iterator itr = _map->staticSpawns.GOSpawns.begin(); itr != _map->staticSpawns.GOSpawns.end(); ++itr)
{
GameObject* obj = CreateGameObject((*itr)->entry);
obj->Load((*itr));
PushStaticObject(obj);
}
// Call script OnLoad virtual procedure
CALL_INSTANCE_SCRIPT_EVENT(this, OnLoad)();
for(CreatureSpawnList::iterator itr = _map->staticSpawns.CreatureSpawns.begin(); itr != _map->staticSpawns.CreatureSpawns.end(); ++itr)
{
Creature* obj = CreateCreature((*itr)->entry);
obj->Load(*itr, 0, pMapInfo);
PushStaticObject(obj);
}
/* load corpses */
objmgr.LoadCorpses(this);
worldstateshandler.InitWorldStates( objmgr.GetWorldStatesForMap( _mapId ) );
worldstateshandler.setObserver( this );
// always declare local variables outside of the loop!
// otherwise there's a lot of sub esp; going on.
uint32 exec_time, exec_start;
while((GetThreadState() != THREADSTATE_TERMINATE) && !_shutdown)
{
exec_start = getMSTime();
///////////////////////////////////////////// first push to world new objects ////////////////////////////////////////////
m_objectinsertlock.Acquire();
if(m_objectinsertpool.size())
{
for(i = m_objectinsertpool.begin(); i != m_objectinsertpool.end(); ++i)
{
Object* o = *i;
o->PushToWorld(this);
}
m_objectinsertpool.clear();
}
m_objectinsertlock.Release();
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Now update sessions of this map + objects
_PerformObjectDuties();
last_exec = getMSTime();
exec_time = last_exec - exec_start;
if(exec_time < MAP_MGR_UPDATE_PERIOD)
{
Arcemu::Sleep(MAP_MGR_UPDATE_PERIOD - exec_time);
}
//////////////////////////////////////////////////////////////////////////
// Check if we have to die :P
//////////////////////////////////////////////////////////////////////////
if(InactiveMoveTime && UNIXTIME >= InactiveMoveTime)
break;
}
// Teleport any left-over players out.
TeleportPlayers();
// Clear the instance's reference to us.
if(m_battleground)
{
BattlegroundManager.DeleteBattleground(m_battleground);
sInstanceMgr.DeleteBattlegroundInstance(GetMapId(), GetInstanceID());
}
if(pInstance)
{
// check for a non-raid instance, these expire after 10 minutes.
if(GetMapInfo()->type == INSTANCE_NONRAID || pInstance->m_isBattleground)
{
pInstance->m_mapMgr = NULL;
sInstanceMgr._DeleteInstance(pInstance, true);
pInstance = NULL;
}
else
{
// just null out the pointer
pInstance->m_mapMgr = NULL;
}
}
else if(GetMapInfo()->type == INSTANCE_NULL)
sInstanceMgr.m_singleMaps[GetMapId()] = NULL;
thread_running = false;
if(thread_kill_only)
return false;
// delete ourselves
delete this;
// already deleted, so the threadpool doesn't have to.
return false;
}
