LOCAL void Story_OnDestroy(HWND hWindow)
/***********************************************************************/
{
if ( bTrack )
{
ReleaseCapture();
bTrack = NO;
}
PSTORY pStory = GetStory(hWindow);
if (pStory)
{
delete pStory;
SetStory(hWindow, NULL);
}
}
LOCAL BOOL Story_OnSetCursor(HWND hWindow, HWND hWndCursor, UINT codeHitTest, UINT msg)
/***********************************************************************/
{
PSTORY pStory = GetStory(hWindow);
if (pStory)
{
POINT CursorPos;
GetCursorPos( &CursorPos );
ScreenToClient( hWindow, &CursorPos );
if (pStory->FindHotSpot(CursorPos.x, CursorPos.y) >= 0)
{
SetCursor(pStory->m_hHotSpotCursor);
return(TRUE);
}
}
return FORWARD_WM_SETCURSOR(hWindow, hWndCursor, codeHitTest, msg, DefWindowProc);
}
void
CConnectionManager::ProcessMessage(Json::Value& msg)
{
CString command = UnpackValue(msg["command"]);
if (command==_T("AboutMe"))
{
m_Connected = true;
m_Agent = UnpackValue(msg["agent"]);
m_Version = UnpackValue(msg["version"]);
CString log;
log.Format(_T("Connected to %s %s"), m_Agent, m_Version);
m_Parent->Log(log, ICON_CONNECTED);
RequestResetLastSentTitle();
RequestSendInfoAboutPage();
UpdateIcon();
}
if (command==_T("DoRefresh"))
{
CString name = UnpackValue(msg["name"]);
CString story = GetStory(msg);
CString log;
// test current url
CString url = GetURL(m_Parent->GetBrowser());
m_CS.Enter(); // m_SitesModel can be accessed by watchdog
bool answer = m_SitesModel.Test(url);
m_CS.Leave();
if (answer)
{
log.Format(_T("Refresh request from %s: %s"), name, story);
m_Parent->Log(log, ICON_REFRESH);
PerformRefresh();
}
else
{
log.Format(_T("Refresh request from %s (not allowed for this site - modify 'Allowed Sites' using XRefresh toolbar icon)"), name);
m_Parent->Log(log, ICON_CANCEL);
}
}
}
LOCAL void Story_OnLButtonUp(HWND hWindow, int x, int y, UINT keyFlags)
/***********************************************************************/
{
if ( !bTrack )
return;
ReleaseCapture(); bTrack = FALSE;
DWORD dwStyle = GetWindowLong(hWindow, GWL_STYLE);
PSTORY pStory = GetStory(hWindow);
if (pStory && pStory->m_iHighlight)
{
HDC hDC = GetDC(hWindow);
Story_OnDraw(hWindow, hDC, &pStory->m_lpWordData[pStory->m_iHighlight-1].rArea, FALSE);
ReleaseDC(hWindow, hDC);
pStory->m_iHighlight = 0;
FORWARD_WM_COMMAND(GetParent(hWindow), GET_WINDOW_ID(hWindow), hWindow, 3, SendMessage);
}
// if ( bInRect )
// {
// FORWARD_WM_COMMAND(GetParent(hWindow), GET_WINDOW_ID(hWindow), hWindow, 0, SendMessage);
// }
}
LOCAL BOOL ComputeDIBControlSize( HWND hControl, LPINT lpDX, LPINT lpDY )
/***********************************************************************/
{
// Make sure that the DIB is uncompressed
PSTORY pStory = GetStory(hControl);
if (pStory && pStory->m_pDib)
{
if ( lpDX )
*lpDX = (int)pStory->m_pDib->GetWidth();
if ( lpDY )
*lpDY = (int)abs(pStory->m_pDib->GetHeight());
}
else
{
if ( lpDX )
*lpDX = 1;
if ( lpDY )
*lpDY = 1;
}
return( YES );
}
LOCAL void Story_OnLButtonDown(HWND hWindow, BOOL fDoubleClick, int x, int y, UINT keyFlags)
/***********************************************************************/
{
if ( SHIFT )
return;
if ( bTrack )
return;
PSTORY pStory = GetStory(hWindow);
if (!pStory)
return;
if (pStory->m_fPlaying)
return;
if (pStory->m_fPlaying)
pStory->StopPlaying();
SetCapture( hWindow ); bTrack = TRUE;
if ( GetFocus() != hWindow )
SetFocus( hWindow );
bInRect = YES;
DWORD dwStyle = GetWindowLong(hWindow, GWL_STYLE);
int i;
if ((i = pStory->FindHotSpot(x, y)) >= 0)
{
HDC hDC = GetDC(hWindow);
pStory->m_iHighlight = i + 1;
Story_OnDraw(hWindow, hDC, &pStory->m_lpWordData[i].rArea, TRUE);
if (lstrlen(pStory->m_szStoryFile))
pStory->m_hMCIfile = MCIOpen( App.m_hDeviceWAV, pStory->m_szStoryFile, NULL/*lpAlias*/ );
if ( pStory->m_hMCIfile )
{
FORWARD_WM_COMMAND(GetParent(hWindow), GET_WINDOW_ID(hWindow), hWindow, 0, SendMessage);
MCIPlay( pStory->m_hMCIfile, NULL, pStory->m_lpWordData[i].dwFrom, pStory->m_lpWordData[i].dwTo );
MCIClose( pStory->m_hMCIfile );
pStory->m_hMCIfile = NULL;
}
ReleaseDC(hWindow, hDC);
}
}
LOCAL void Story_OnDraw(HWND hWindow, HDC hDC, LPRECT lpRect, BOOL fHighlight)
/***********************************************************************/
{
BOOL bHasFocus, bSelected, bDown;
DWORD dwStyle;
RECT rSrcArea, rDstArea;
PTOON pToon = NULL;
PDIB pdibSrc, pdibDst;
LPOFFSCREEN lpOffScreen = NULL;
if (IsRectEmpty(lpRect))
return;
PSTORY pStory = GetStory(hWindow);
if (!pStory)
return;
if (!pStory->m_pDib)
return;
// Draw the Bitmap
rSrcArea = *lpRect;
rDstArea = *lpRect;
LPSCENE lpScene = CScene::GetScene(GetParent(hWindow));
if (lpScene)
lpOffScreen = lpScene->GetOffScreen();
if (lpOffScreen)
{
if ( !(pdibSrc = lpOffScreen->GetReadOnlyDIB()) )
return;
MapWindowPoints( hWindow, GetParent(hWindow), (LPPOINT)&rDstArea, 2 );
}
else
{
// see if there is a toon control
HWND hToon = FindClassDescendent(GetParent(hWindow), "toon");
if (!hToon)
return;
pToon = GetToon(hToon);
if (!pToon)
return;
pdibSrc = pToon->GetStageDib();
MapWindowPoints( hWindow, GetParent(hToon), (LPPOINT)&rDstArea, 2 );
}
// create a dib to draw into
pdibDst = new CDib();
if (!pdibDst)
return;
if (!pdibDst->Create(pdibSrc->GetBitCount(),
lpRect->right-lpRect->left,
lpRect->bottom-lpRect->top))
{
delete pdibDst;
return;
}
pdibDst->CopyColorTable(pdibSrc);
// copy our color table into the dest dib
dwStyle = GetWindowLong( hWindow, GWL_STYLE );
bHasFocus = ( GetFocus() == hWindow );
bDown = ( bSelected || (bTrack && bInRect && bHasFocus) );
// draw in background
pdibSrc->DibBlt( pdibDst,
0, 0,
rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
rDstArea.left, rDstArea.top,
rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
NO /*bTransparent*/ );
// now draw in foreground
RGBTRIPLE rgb;
LPRGBTRIPLE lpRGB = NULL;
if (dwStyle & BS_MASK)
{
STRING szColor;
GetWindowText(hWindow, szColor, sizeof(szColor));
AsciiRGB( szColor, &rgb );
if (fHighlight)
{
// this relies on the fact that AsciiRGB replaces commas
// with NULL terminators
LPTSTR lp = szColor + lstrlen(szColor) + 1; // passed red
lp += lstrlen(lp) + 1; // passed green
lp += lstrlen(lp) + 1; // passed blue to higlight color
AsciiRGB(lp, &rgb);
rgb.rgbtRed = rgb.rgbtGreen = 0; rgb.rgbtBlue = 255;
}
else
rgb.rgbtRed = rgb.rgbtGreen = rgb.rgbtBlue = 0;
lpRGB = &rgb;
}
pStory->m_pDib->DibBlt( pdibDst,
0, 0,
rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
rSrcArea.left, rSrcArea.top,
rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top,
YES /*bTransparent*/, lpRGB, App.m_lpLut );
pdibDst->DCBlt( hDC,
rSrcArea.left, rSrcArea.top,
rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top,
0, 0,
rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top);
delete pdibDst;
}
LOCAL void Story_OnDraw(HWND hWindow, HDC hDC, LPRECT lpRect, BOOL fHighlight)
/***********************************************************************/
{
BOOL bHasFocus, bSelected, bDown;
DWORD dwStyle;
RECT rSrcArea, rDstArea;
POINT ptDst;
PDIB pdibSrc, pdibDst, pDib;
LPOFFSCREEN lpOffScreen;
PTOON pToon;
LPSCENE lpScene;
PSTORY pStory;
RGBQUAD rgbQuad[256];
BITMAPINFOHEADER bmi;
LPTR lp;
HDC hWinGDC;
HPALETTE hWinGPal = NULL, hDisplayPal = NULL, hOldPal;
if (IsRectEmpty(lpRect))
return;
pStory = GetStory(hWindow);
if (!pStory)
return;
if (!pStory->m_pDib)
return;
lpScene = CScene::GetScene(GetParent(hWindow));
if (!lpScene)
return;
rSrcArea = *lpRect;
rDstArea = *lpRect;
bSelected = GetWindowWord(hWindow, GWW_STATE );
dwStyle = GetWindowLong( hWindow, GWL_STYLE );
bHasFocus = ( GetFocus() == hWindow );
bDown = ( bSelected || (bTrack && bInRect && bHasFocus) );
lpOffScreen = lpScene->GetOffScreen();
if (lpOffScreen)
{
MapWindowPoints( hWindow, GetParent(hWindow), (LPPOINT)&rDstArea, 2 );
if ( !(pdibSrc = lpOffScreen->GetReadOnlyDIB()) )
return;
if ( !(pdibDst = lpOffScreen->GetWritableDIB()) )
return;
hWinGDC = lpOffScreen->GetDC();
hWinGPal = hDisplayPal = GetApp()->m_hPal;
}
else
{
// fix
HWND hToon = FindClassDescendent(GetParent(hWindow), "toon");
if (!hToon)
return;
pToon = GetToon(hToon);
if (!pToon)
return;
MapWindowPoints( hWindow, pToon->GetWindow(), (LPPOINT)&rDstArea, 2 );
pdibSrc = pToon->GetStageDib();
lp = ToonGetDIBPointer(pToon->GetToonHandle(), &bmi);
ToonGetColors(pToon->GetToonHandle(), 0, 256, rgbQuad);
bmi.biClrUsed = 256;
pdibDst = new CDib(&bmi, rgbQuad, lp);
if (!pdibDst)
return;
hWinGDC = ToonDC(pToon->GetToonHandle());
// to make sure we don't change the system palette
hDisplayPal = CopySystemPalette();
// to match WinG dib
hWinGPal = CreateCustomPalette(rgbQuad, 256);
}
if (!pStory->m_fMappedToPalette && ((dwStyle & BS_MASK) == 0))
{
pStory->m_pDib->MapToPalette(hWinGPal);
pStory->m_fMappedToPalette = TRUE;
}
// Copy source dib so we can twiddle its bits
pDib = new CDib();
if (!pDib)
{
if (!lpOffScreen && hDisplayPal)
DeleteObject(hDisplayPal);
if (!lpOffScreen && hWinGPal)
DeleteObject(hWinGPal);
return;
}
if (!pDib->Create(pStory->m_pDib->GetBitCount(),
lpRect->right-lpRect->left,
lpRect->bottom-lpRect->top))
{
delete pDib;
if (!lpOffScreen && hDisplayPal)
DeleteObject(hDisplayPal);
if (!lpOffScreen && hWinGPal)
DeleteObject(hWinGPal);
return;
}
pDib->CopyColorTable(pStory->m_pDib);
// draw in source bitmap
pStory->m_pDib->DibBlt( pDib,
0, 0,
rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top,
rSrcArea.left, rSrcArea.top,
rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top,
NO /*bTransparent*/ );
if ( pdibSrc->GetCompression() == BI_RLE8 ||
pdibDst->GetCompression() == BI_RLE8)
{ // compressed DIBs must use GDI copying (lose transparency ability)
pdibSrc->DCBlt( hWinGDC,
rDstArea.left, rDstArea.top,
rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
rDstArea.left, rDstArea.top,
rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top );
}
else
{
pdibSrc->DibBlt( pdibDst,
rDstArea.left, rDstArea.top,
rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
rDstArea.left, rDstArea.top,
rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
NO /*bTransparent*/ );
}
if ( pDib->GetCompression() == BI_RLE8 ||
pdibDst->GetCompression() == BI_RLE8 )
{ // compressed DIBs must use GDI copying (lose transparency ability)
pDib->DCBlt( hWinGDC,
rDstArea.left, rDstArea.top,
rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
rSrcArea.left, rSrcArea.top,
rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top );
}
else
{
RGBTRIPLE rgb;
LPRGBTRIPLE lpRGB = NULL;
if (dwStyle & BS_MASK)
{
STRING szColor;
GetWindowText(hWindow, szColor, sizeof(szColor));
AsciiRGB( szColor, &rgb );
if (fHighlight)
{
// this relies on the fact that AsciiRGB replaces commas
// with NULL terminators
LPTSTR lp = szColor + lstrlen(szColor) + 1; // passed red
lp += lstrlen(lp) + 1; // passed green
lp += lstrlen(lp) + 1; // passed blue to higlight color
AsciiRGB(lp, &rgb);
rgb.rgbtRed = rgb.rgbtGreen = 0; rgb.rgbtBlue = 255;
}
else
rgb.rgbtRed = rgb.rgbtGreen = rgb.rgbtBlue = 0;
lpRGB = &rgb;
}
else
{
BYTE bTrans = *pStory->m_pDib->GetXY(0, 0);
LPTR lpColor = pStory->m_pDib->GetXY(1, 0);
LPTR lpHighlight = pStory->m_pDib->GetXY(2, 0);
BYTE bColor = *lpColor;
BYTE bHighlight = *lpHighlight;
// if highlight color is the transparent color then
// we are hiding and showing highlighted area
// if not, then we are changing the color of highlighted area
if (bHighlight == bTrans)
{
// we need to strip off highlight info if we are not
// highlighted
if (!fHighlight && (bColor != bTrans))
{
HPTR hp = pDib->GetPtr();
DWORD dwSize = pDib->GetSizeImage();
while (dwSize)
{
if (*hp != bColor)
*hp = bTrans;
++hp;
--dwSize;
}
}
}
else
{
// we need to change the color if we are highlighted
if (fHighlight && (bColor != bHighlight) && (bColor != bTrans))
{
HPTR hp = pDib->GetPtr();
DWORD dwSize = pDib->GetSizeImage();
while (dwSize)
{
if (*hp == bColor)
*hp = bHighlight;
++hp;
--dwSize;
}
}
}
}
pDib->DibBlt( pdibDst,
rDstArea.left, rDstArea.top,
rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
0, 0,
rSrcArea.right - rSrcArea.left, rSrcArea.bottom - rSrcArea.top,
YES/*bTransparent*/, lpRGB, NULL, hWinGPal );
}
delete pDib;
ptDst.x = rSrcArea.left;
ptDst.y = rSrcArea.top;
if (lpOffScreen)
{
lpOffScreen->DrawRect( hDC, &rDstArea, &ptDst );
}
else
{
//if (hDisplayPal)
//{
// hOldPal = SelectPalette(hDC, hDisplayPal, FALSE);
// RealizePalette(hDC);
//}
//pdibDst->DCBlt( hDC,
// ptDst.x, ptDst.y,
// rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
// rDstArea.left, rDstArea.top,
// rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top );
WinGStretchBlt( hDC,
ptDst.x, ptDst.y,
rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top,
hWinGDC,
rDstArea.left, rDstArea.top,
rDstArea.right - rDstArea.left, rDstArea.bottom - rDstArea.top );
//if (hDisplayPal)
//{
// SelectPalette(hDC, hOldPal, TRUE);
// DeleteObject(hDisplayPal);
//}
if (hWinGPal)
DeleteObject(hWinGPal);
}
}
void
NetStory::CycleEnemy()
{
coord celOffX,celOffY;
BAM_Guy *pGuy,*pOutGuy;
uchar color;
bool found=FALSE;
uint32 calcGuy,x;
CelHeader *pEnemyTitle;
if(!enemyHasSelected)
{
// now lets check the storyline regions
for(x=0; x<NETMAXSTORYGUYS; x++)
{
pGuy = &storyGuy[x];
if (pGuy->scrim.rect.Contains(enemyCurX,enemyCurY))
{
celOffX = enemyCurX - pGuy->scrim.rect.x1;
celOffY = enemyCurY - pGuy->scrim.rect.y1;
color = GetPixel(celOffX, celOffY, pGuy->scrim.resType,
pGuy->scrim.resNum, pGuy->scrim.cel);
if (color != CI_SKIP) //we found it
{
found = TRUE;
calcGuy = x;
if (calcGuy != enemyCurrentGuy) //if new guy
{
if (pMono)
pMono->Out("\nRegion is %2d, StoryLine is %d",x,GetStory(x));
// cut old storyGuy only if there is one and un-enemy
// isn't using it
if (enemyCurrentGuy != -1 && enemyCurrentGuy != currentGuy)
{
pOutGuy = &storyGuy[enemyCurrentGuy];
pOutGuy->fIsActive = FALSE;
CutObject(pOutGuy->gSelf, CT_SERV | CT_ROST);
}
enemyCurrentGuy = calcGuy;
// add new region outline unless enemy has the region alread active
if(enemyCurrentGuy != currentGuy)
{
pOutGuy = &storyGuy[calcGuy];
pOutGuy->fIsActive = TRUE;
AddObject(pOutGuy->gSelf, CT_SERV | CT_ROST);
}
pEnemyTitle = (CelHeader *)AGetResData(gEnemyTitle);
// clear region name
memset(((uchar*)pEnemyTitle)+sizeof(CelHeader),SKIP_COLOR,L2R(pEnemyTitle->width) * pEnemyTitle->height);
pFontMgr->SetRes(9050);
SetFontColors(CI_SKIP,93,90,93,90,93,90);
//startup new region name
ASetString(0,0,storyNames[calcGuy], (uchar *)pEnemyTitle, pEnemyTitle->width, NULL, DG_JUST_CENTER);
enemyTitle.SetPos(titlePos[enemyCurrentGuy*2],titlePos[enemyCurrentGuy*2+1]);
break;
}
}//endif
}//endif
}//endfor
//cursor outside of all guys and not used by un-enemy -shutdown current guy
if(!found && enemyCurrentGuy != -1 && enemyCurrentGuy != currentGuy)
{
pOutGuy = &storyGuy[enemyCurrentGuy];
pOutGuy->fIsActive = FALSE;
CutObject(pOutGuy->gSelf, CT_SERV | CT_ROST);
enemyCurrentGuy = -1;
//shutdown last region name
pEnemyTitle = (CelHeader *)AGetResData(gEnemyTitle);
memset(((uchar*)pEnemyTitle)+sizeof(CelHeader),SKIP_COLOR,L2R(pEnemyTitle->width) * pEnemyTitle->height);
enemyTitle.SetState(S_CHANGED, TRUE);
}
}
}
void
NetStory::Cycle(void)
{
coord celOffX,celOffY;
BAM_Guy *pGuy,*pOutGuy;
BAM_ErrorPopup *pPop;
uchar color;
bool found=FALSE;
uint32 calcGuy,x;
CelHeader *ptitle;
clock_t newTime;
clock_t charTime=0;
theX = pMouse->GetX();
theY = pMouse->GetY();
newTime = clock();
if(!hasSelected)
{
// now lets check the storyline regions
for(x=0; x<NETMAXSTORYGUYS; x++)
{
pGuy = &storyGuy[x];
if (pGuy->scrim.rect.Contains(theX,theY))
{
celOffX = theX - pGuy->scrim.rect.x1;
celOffY = theY - pGuy->scrim.rect.y1;
color = GetPixel(celOffX, celOffY, pGuy->scrim.resType,
pGuy->scrim.resNum, pGuy->scrim.cel);
if (color != CI_SKIP) //we found it
{
found = TRUE;
calcGuy = x;
if (calcGuy != currentGuy) //if new guy
{
if (pMono)
pMono->Out("\nRegion is %2d, StoryLine is %d",x,GetStory(x));
// cut old storyGuy only if there is one and the enemy
// isn't using it
if (currentGuy != -1 && currentGuy != enemyCurrentGuy)
{
pOutGuy = &storyGuy[currentGuy];
pOutGuy->fIsActive = FALSE;
CutObject(pOutGuy->gSelf, CT_SERV | CT_ROST);
}
currentGuy = calcGuy;
// add new region outline unless enemy has the region alread active
if(currentGuy != enemyCurrentGuy)
{
pOutGuy = &storyGuy[calcGuy];
pOutGuy->fIsActive = TRUE;
AddObject(pOutGuy->gSelf, CT_SERV | CT_ROST);
}
ptitle = (CelHeader *)AGetResData(gtitle);
// clear region name
memset(((uchar*)ptitle)+sizeof(CelHeader),SKIP_COLOR,L2R(ptitle->width) * ptitle->height);
pFontMgr->SetRes(9050);
SetFontColors(CI_SKIP,93,90,93,90,93,90);
//startup new region name
ASetString(0,0,storyNames[calcGuy], (uchar *)ptitle, ptitle->width, NULL, DG_JUST_CENTER);
title.SetPos(titlePos[currentGuy*2],titlePos[currentGuy*2+1]);
break;
}
}//endif
}//endif
}//endfor
//cursor outside of all guys and not used by enemy -shutdown current guy
if(!found && currentGuy != -1 && currentGuy != enemyCurrentGuy)
{
pOutGuy = &storyGuy[currentGuy];
pOutGuy->fIsActive = FALSE;
CutObject(pOutGuy->gSelf, CT_SERV | CT_ROST);
currentGuy = -1;
//shutdown last region name
ptitle = (CelHeader *)AGetResData(gtitle);
memset(((uchar*)ptitle)+sizeof(CelHeader),SKIP_COLOR,L2R(ptitle->width) * ptitle->height);
title.SetState(S_CHANGED, TRUE);
}
}
else //no more selecting just show next region in path or wrap up.
{
if(newTime > flagFlashTimer)
{
if (flashToggle)
{
flashToggle=0;
flagGuy[currentGuy].Hide();
}
else
{
flashToggle++;
flagGuy[currentGuy].Show();
}
flagFlashTimer = newTime + FLASH_INTERVAL;
}
}
//===========================================================
// cycle anthing else
BAM_Room::Cycle();
//===========================================================
if(!SyncWithRemote())
{
if(!bGlobal.netDisconnect)
{
pMono->Out("NetStory::Cycle() - !SyncWithRemote()\n");
bGlobal.storyLine = STORY_NONE;
pCommMgr->Disconnect();
bGlobal.netDisconnect = TRUE;
bGlobal.roomMgr.newRoomMode = MM_MENU_DOUBLE;
TRACK_MEM("BAM_ErrorPopup"); pPop = new BAM_ErrorPopup;
pPop->SetMode(M_MODAL);
pPop->Setup(pal.gSelf,OPTION_SQB,errorSqbNum,BR_MENU);//"connection has failed"
}
return;
}
//===========================================================
//set enemy marker
CycleEnemy();
if(enemyHasSelected)
{
if(newTime > enemyFlagFlashTimer)
{
if (enemyFlashToggle)
{
enemyFlashToggle=0;
enemyFlagGuy[enemyCurrentGuy].Hide();
}
else
{
enemyFlashToggle++;
enemyFlagGuy[enemyCurrentGuy].Show();
}
enemyFlagFlashTimer = newTime + FLASH_INTERVAL;
}
}
//===========================================================
if(hasSelected && enemyHasSelected && (currentGuy == enemyCurrentGuy))
{
//if we've synced a new rand lets use it
if(syncedRand)
ASeedRandom(newRand);
else
ASeedRandom(curRand);
// wait a second for lingering packets to be ACKed (so no one has to
// timeout) - Van
ticks_t tWait = ATicks() + TICKS_PER_SEC / 2;
while(ATicks() < tWait)
{
// we wont send anything, but make it possible to ACK leftover
// packets sent to us
UpdateTicks();
pCommMgr->DataAvailable();
}
//lets sync tick counters
ASetTicks(1001);
int scenarioArr[15] = {
9112,9132,9152,
9172,9192,9212,
9232,9252,9272,
9292,9312,9332,
9352,9372,9392,
};
int tmpNum = scenarioArr[currentGuy];
sprintf(pBam->scenarioName,"%d",tmpNum);
bGlobal.roomMgr.NewRoom(BR_WORLD);
worldEnder = TRUE;
}
}
