void HandleCreditEyeBlinking()
{
HVOBJECT hPixHandle;
UINT8 ubCnt;
GetVideoObject(&hPixHandle, guiCreditFaces );
for( ubCnt=0; ubCnt<NUM_PEOPLE_IN_CREDITS; ubCnt++ )
{
if( ( GetJA2Clock() - gCreditFaces[ubCnt].uiLastBlinkTime ) > (UINT32)gCreditFaces[ubCnt].sBlinkFreq )
{
BltVideoObject( FRAME_BUFFER, hPixHandle, (UINT8)(ubCnt*3), gCreditFaces[ubCnt].sEyeX + xResOffset, gCreditFaces[ubCnt].sEyeY + yResOffset, VO_BLT_SRCTRANSPARENCY, NULL);
InvalidateRegion( gCreditFaces[ubCnt].sEyeX + xResOffset, gCreditFaces[ubCnt].sEyeY + yResOffset, gCreditFaces[ubCnt].sEyeX + CRDT_EYE_WIDTH + xResOffset, gCreditFaces[ubCnt].sEyeY + CRDT_EYE_HEIGHT + yResOffset );
gCreditFaces[ubCnt].uiLastBlinkTime = GetJA2Clock();
gCreditFaces[ubCnt].uiEyesClosedTime = GetJA2Clock() + CRDT_EYES_CLOSED_TIME + Random( CRDT_EYES_CLOSED_TIME );
}
else if( GetJA2Clock() > gCreditFaces[ubCnt].uiEyesClosedTime )
{
gCreditFaces[ubCnt].uiEyesClosedTime = 0;
RestoreExternBackgroundRect( gCreditFaces[ubCnt].sEyeX + xResOffset, gCreditFaces[ubCnt].sEyeY + yResOffset, CRDT_EYE_WIDTH, CRDT_EYE_HEIGHT );
}
}
}
void BtnIMPFinishPersonalityCallback(GUI_BUTTON *btn,INT32 reason)
{
// btn callback for Main Page Begin Profiling
static BOOLEAN fAnimateFlag = FALSE;
static UINT32 uiBaseTime = 0;
static BOOLEAN fState = 0;
INT32 iDifference = 0;
if (!(btn->uiFlags & BUTTON_ENABLED))
return;
if(reason & MSYS_CALLBACK_REASON_LBUTTON_DWN )
{
btn->uiFlags|=(BUTTON_CLICKED_ON);
uiBaseTime = GetJA2Clock();
SpecifyButtonText( giIMPFinishButton[2], pImpButtonText[ 23 ] );
fAnimateFlag = TRUE;
}
else if(reason & MSYS_CALLBACK_REASON_LBUTTON_UP )
{
if (btn->uiFlags & BUTTON_CLICKED_ON)
{
btn->uiFlags&=~(BUTTON_CLICKED_ON);
fButtonPendingFlag = TRUE;
uiBaseTime = 0;
fAnimateFlag = FALSE;
iCurrentImpPage = IMP_PERSONALITY_QUIZ;
SpecifyButtonText( giIMPFinishButton[2], pImpButtonText[ 2 ] );
}
}
// get amount of time between callbacks
iDifference = GetJA2Clock() - uiBaseTime;
if( fAnimateFlag )
{
if( iDifference > ANIMATE_MIN_TIME )
{
uiBaseTime = GetJA2Clock();
if( fState )
{
SpecifyButtonIcon( giIMPFinishButton[2] , guiANALYSE, 1, 33, 23, FALSE );
fState = FALSE;
}
else
{
SpecifyButtonIcon( giIMPFinishButton[2] , guiANALYSE, 0, 33, 23, FALSE );
fState = TRUE;
}
}
}
}
void DisplayNickNameStringCursor( void )
{
// this procdure will draw the activation string cursor on the screen at position cursorx cursory
UINT32 uiDestPitchBYTES;
static UINT32 uiBaseTime = 0;
UINT32 uiDeltaTime = 0;
UINT8 *pDestBuf;
static UINT32 iCurrentState = 0;
static BOOLEAN fIncrement = TRUE;
if(uiBaseTime == 0)
{
uiBaseTime = GetJA2Clock();
}
// get difference
uiDeltaTime = GetJA2Clock() - uiBaseTime;
// if difference is long enough, rotate colors
if(uiDeltaTime > MIN_GLOW_DELTA)
{
if( iCurrentState == 10)
{
// start rotating downward
fIncrement = FALSE;
}
if( iCurrentState == 0)
{
// rotate colors upward
fIncrement = TRUE;
}
// if increment upward, increment iCurrentState
if(fIncrement)
{
iCurrentState++;
}
else
{
// else downwards
iCurrentState--;
}
// reset basetime to current clock
uiBaseTime = GetJA2Clock( );
}
pDestBuf = LockVideoSurface( FRAME_BUFFER, &uiDestPitchBYTES );
SetClippingRegionAndImageWidth( uiDestPitchBYTES, 0, 0, SCREEN_BUFFER_WIDTH, SCREEN_BUFFER_HEIGHT );
// draw line in current state
LineDraw(TRUE, (UINT16) uiNickNameCursorPosition, NICK_NAME_CURSOR_Y, (UINT16)uiNickNameCursorPosition, NICK_NAME_CURSOR_Y + CURSOR_HEIGHT, Get16BPPColor( FROMRGB( GlowColorsList[ iCurrentState ][ 0 ], GlowColorsList[ iCurrentState ][ 1 ], GlowColorsList[ iCurrentState ][ 2 ] ) ),
pDestBuf );
InvalidateRegion((UINT16) uiNickNameCursorPosition, NICK_NAME_CURSOR_Y, (UINT16)uiNickNameCursorPosition + 1, NICK_NAME_CURSOR_Y + CURSOR_HEIGHT + 1);
// unlock frame buffer
UnLockVideoSurface( FRAME_BUFFER );
return;
}
void DisplayCompressMode( void )
{
INT16 sX, sY;
CHAR16 sString[ 128 ];
static UINT8 usColor = FONT_LTGREEN;
// get compress speed
if( giTimeCompressMode != NOT_USING_TIME_COMPRESSION )
{
if( IsTimeBeingCompressed() )
{
swprintf( sString, L"%s", sTimeStrings[ giTimeCompressMode ] );
}
else
{
swprintf( sString, L"%s", sTimeStrings[ 0 ] );
}
}
RestoreExternBackgroundRect( 489, 456, 522 - 489, 467 - 454 );
SetFontDestBuffer( FRAME_BUFFER, 0,0,640,480, FALSE );
SetFont( COMPFONT );
if( GetJA2Clock() - guiCompressionStringBaseTime >= PAUSE_GAME_TIMER )
{
if( usColor == FONT_LTGREEN )
{
usColor = FONT_WHITE;
}
else
{
usColor = FONT_LTGREEN;
}
guiCompressionStringBaseTime = GetJA2Clock();
}
if( ( giTimeCompressMode != 0 ) && ( GamePaused( ) == FALSE ) )
{
usColor = FONT_LTGREEN;
}
SetFontForeground( usColor );
SetFontBackground( FONT_BLACK );
FindFontCenterCoordinates( 489, 456, 522 - 489, 467 - 454, sString, COMPFONT, &sX, &sY );
mprintf( sX, sY, sString );
return;
}
void HideMessagesDuringNPCDialogue( void )
{
// will stop the scroll of messages in tactical and hide them during an NPC's dialogue
INT32 cnt;
VIDEO_OVERLAY_DESC VideoOverlayDesc;
memset( &VideoOverlayDesc, 0, sizeof( VideoOverlayDesc ) );
VideoOverlayDesc.fDisabled = TRUE;
VideoOverlayDesc.uiFlags = VOVERLAY_DESC_DISABLED;
fScrollMessagesHidden = TRUE;
uiStartOfPauseTime = GetJA2Clock();
for ( cnt = 0; cnt < MAX_LINE_COUNT; cnt++ )
{
if ( gpDisplayList[ cnt ] != NULL )
{
RestoreExternBackgroundRectGivenID( gVideoOverlays[ gpDisplayList[ cnt ] -> iVideoOverlay ].uiBackground );
UpdateVideoOverlay( &VideoOverlayDesc, gpDisplayList[ cnt ] -> iVideoOverlay, FALSE );
}
}
return;
}
void UnHideMessagesDuringNPCDialogue( void )
{
VIDEO_OVERLAY_DESC VideoOverlayDesc;
INT32 cnt = 0;
memset( &VideoOverlayDesc, 0, sizeof( VideoOverlayDesc ) );
VideoOverlayDesc.fDisabled = FALSE;
VideoOverlayDesc.uiFlags = VOVERLAY_DESC_DISABLED;
fScrollMessagesHidden = FALSE;
for ( cnt = 0; cnt < MAX_LINE_COUNT; cnt++ )
{
if ( gpDisplayList[ cnt ] != NULL )
{
gpDisplayList[ cnt ]->uiTimeOfLastUpdate+= GetJA2Clock() - uiStartOfPauseTime;
UpdateVideoOverlay( &VideoOverlayDesc, gpDisplayList[ cnt ] -> iVideoOverlay, FALSE );
}
}
return;
}
void HandleStrategicTurn( )
{
UINT32 uiTime;
UINT32 uiCheckTime;
// OK, DO THIS CHECK EVERY ONCE AND A WHILE...
if ( COUNTERDONE( STRATEGIC_OVERHEAD ) )
{
RESETCOUNTER( STRATEGIC_OVERHEAD );
// if the game is paused, or we're in mapscreen and time is not being compressed
if( ( GamePaused() == TRUE ) ||
( ( guiCurrentScreen == MAP_SCREEN ) && !IsTimeBeingCompressed() ) )
{
// don't do any of this
return;
}
//Kris -- What to do?
if( giTimeCompressMode == NOT_USING_TIME_COMPRESSION )
{
SetGameTimeCompressionLevel( TIME_COMPRESS_X1 );
}
uiTime = GetJA2Clock( );
// Do not handle turns update if in turnbased combat
if ( ( gTacticalStatus.uiFlags & TURNBASED ) && ( gTacticalStatus.uiFlags & INCOMBAT ) )
{
guiLastTacticalRealTime = uiTime;
}
else
{
// If none of these conditions are true, then don't do an end of turn
uiCheckTime = 0xffffffff;
if ( giTimeCompressMode == TIME_COMPRESS_X1 || giTimeCompressMode == 0 )
{
uiCheckTime = NUM_REAL_SEC_PER_TACTICAL_TURN;
}
else
{
// OK, if we have compressed time...., adjust our check value to be faster....
if( giTimeCompressSpeeds[ giTimeCompressMode ] > 0 )
{
uiCheckTime = NUM_REAL_SEC_PER_TACTICAL_TURN / ( giTimeCompressSpeeds[ giTimeCompressMode ] * RT_COMPRESSION_TACTICAL_TURN_MODIFIER );
}
}
if ( ( uiTime - guiLastTacticalRealTime ) > uiCheckTime )
{
HandleTacticalEndTurn( );
guiLastTacticalRealTime = uiTime;
}
}
}
}
void InitCreditEyeBlinking()
{
UINT8 ubCnt;
for( ubCnt=0; ubCnt<NUM_PEOPLE_IN_CREDITS; ubCnt++ )
{
gCreditFaces[ubCnt].uiLastBlinkTime = GetJA2Clock() + Random( gCreditFaces[ubCnt].sBlinkFreq * 2 );
}
}
//The callback calls this function passing the relative y position of where
//the user clicked on the hot spot.
void SelectFileDialogYPos( UINT16 usRelativeYPos )
{
INT16 sSelName;
INT32 x;
FDLG_LIST *FListNode;
sSelName = usRelativeYPos / 15;
//This is a field in the text editmode, but clicked via mouse.
SetActiveField( 1 );
// Skip to first filename
FListNode = FileList;
for(x=0;x<iTopFileShown && x<iTotalFiles && FListNode != NULL;x++)
{
FListNode = FListNode->pNext;
}
for(x=iTopFileShown;x<(iTopFileShown+8) && x<iTotalFiles && FListNode != NULL; x++)
{
if( (INT32)sSelName == (x-iTopFileShown) )
{
INT32 iCurrClickTime;
iCurrFileShown = x;
FListNode->FileInfo.zFileName[30] = 0;
swprintf( gzFilename, L"%S", FListNode->FileInfo.zFileName );
if( ValidFilename() )
{
SetInputFieldStringWith16BitString( 0, gzFilename );
}
else
{
SetInputFieldStringWith16BitString( 0, L"" );
wcscpy( gzFilename, L"" );
}
RenderInactiveTextField( 0 );
//Calculate and process any double clicking...
iCurrClickTime = GetJA2Clock();
if( iCurrClickTime - iLastClickTime < 400 && x == iLastFileClicked )
{ //Considered a double click, so activate load/save this filename.
gfDestroyFDlg = TRUE;
iFDlgState = iCurrentAction == ACTION_SAVE_MAP ? DIALOG_SAVE : DIALOG_LOAD;
}
iLastClickTime = iCurrClickTime;
iLastFileClicked = x;
}
FListNode = FListNode->pNext;
}
}
void HandleCreditNodes()
{
CRDT_NODE *pCurrent=NULL;
CRDT_NODE *pTemp=NULL;
if( gCrdtRootNode == NULL )
return;
//if the screen is paused, exit
if( gfPauseCreditScreen )
return;
pCurrent = gCrdtRootNode;
if( !( GetJA2Clock() - guiCrdtLastTimeUpdatingNode > guiCrdtNodeScrollSpeed ) )
return;
//loop through all the nodes
while( pCurrent != NULL )
{
pTemp = pCurrent;
pCurrent = pCurrent->pNext;
//Handle the current node
HandleCurrentCreditNode( pTemp );
//if the node is to be deleted
if( pTemp->fDelete )
{
//delete the node
DeleteNode( pTemp );
}
}
guiCrdtLastTimeUpdatingNode = GetJA2Clock();
}
BOOLEAN DrawWarningBox( BOOLEAN fInit, BOOLEAN fRedraw )
{
static UINT32 uiLastTime;
static UINT8 ubSubImage = 0;
UINT32 uiCurTime = GetJA2Clock();
if( fInit || fRedraw)
{
CHAR16 sText[400];
//UINT16 usLocY = AIM_WARNING_TEXT_Y + (GetFontHeight(AIM_WARNING_FONT) + 2) * 2;
HVOBJECT hWarningHandle;
//Warning
GetVideoObject(&hWarningHandle, guiWarning);
BltVideoObject(FRAME_BUFFER, hWarningHandle, 0,WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
if(!g_bUseXML_Strings)
{
UINT32 uiStartLoc = AIM_HISTORY_LINE_SIZE * AIM_WARNING_1;
LoadEncryptedDataFromFile(AIMHISTORYFILE, sText, uiStartLoc, AIM_HISTORY_LINE_SIZE);
}
else
{
Loc::GetString(Loc::AIM_HISTORY, L"Line", AIM_WARNING_1, sText, 400);
}
//Display Aim Warning Text
DisplayWrappedString(AIM_WARNING_TEXT_X, AIM_WARNING_TEXT_Y, AIM_WARNING_TEXT_WIDTH, 2, AIM_WARNING_FONT, FONT_RED, sText, FONT_MCOLOR_BLACK, FALSE, CENTER_JUSTIFIED);
InvalidateRegion(AIM_AD_TOP_LEFT_X,AIM_AD_TOP_LEFT_Y, AIM_AD_BOTTOM_RIGHT_X ,AIM_AD_BOTTOM_RIGHT_Y);
// redraw new mail warning, and create new mail button, if nessacary
fReDrawNewMailFlag = TRUE;
if( fInit )
uiLastTime = uiCurTime;
}
if( (uiCurTime - uiLastTime) > AIM_WARNING_TIME)
return(AIM_AD_DONE);
else
{
return(AIM_AD_NOT_DONE);
}
}
void HandleLastQuotePopUpTimer( void )
{
if( ( fTextBoxMouseRegionCreated == FALSE ) || ( fDialogueBoxDueToLastMessage == FALSE ) )
{
return;
}
// check if timed out
if( GetJA2Clock() - guiDialogueLastQuoteTime > guiDialogueLastQuoteDelay )
{
// done clear up
ShutDownLastQuoteTacticalTextBox( );
guiDialogueLastQuoteTime = 0;
guiDialogueLastQuoteDelay = 0;
}
}
void HandleNode_Default( CRDT_NODE *pCurrent )
{
//Display the Current Node
DisplayCreditNode( pCurrent );
//Save the old position
pCurrent->sOldPosX = pCurrent->sPosX;
pCurrent->sOldPosY = pCurrent->sPosY;
//Move the current node up
pCurrent->sPosY -= CRDT_SCROLL_PIXEL_AMOUNT;
//if the node is entirely off the screen
if( ( pCurrent->sPosY + pCurrent->sHeightOfString ) < CRDT_LINE_NODE_DISAPPEARS_AT )
{
//mark the node to be deleted this frame
pCurrent->fDelete = TRUE;
}
pCurrent->uiLastTime = GetJA2Clock();
}
BOOLEAN DisplayAd( BOOLEAN fInit, BOOLEAN fRedraw, UINT16 usDelay, UINT16 usNumberOfSubImages, UINT32 uiAdImageIdentifier )
{
static UINT32 uiLastTime;
static UINT8 ubSubImage=0;
static UINT8 ubCount=0;
UINT32 uiCurTime = GetJA2Clock();
UINT8 ubRetVal = 0;
if( fInit )
{
uiLastTime = 0;
ubSubImage = 0;
ubCount = 0;
}
if( ((uiCurTime - uiLastTime) > usDelay) || fRedraw)
{
HVOBJECT hAdHandle;
if( ubSubImage == 0 )
{
if(ubCount == 0 || fRedraw)
{
//Blit the ad
GetVideoObject(&hAdHandle, uiAdImageIdentifier);
BltVideoObject(FRAME_BUFFER, hAdHandle, 0,WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
// redraw new mail warning, and create new mail button, if nessacary
fReDrawNewMailFlag = TRUE;
InvalidateRegion(AIM_AD_TOP_LEFT_X,AIM_AD_TOP_LEFT_Y, AIM_AD_BOTTOM_RIGHT_X ,AIM_AD_BOTTOM_RIGHT_Y);
}
uiLastTime = GetJA2Clock();
//display first frame longer then rest
ubCount++;
if( ubCount > 12 )
{
ubCount=0;
ubSubImage++;
}
ubRetVal = AIM_AD_NOT_DONE;
}
else if( ubSubImage == usNumberOfSubImages-1 )
{
if(ubCount == 0 || fRedraw)
{
//Blit the ad
GetVideoObject(&hAdHandle, uiAdImageIdentifier);
BltVideoObject(FRAME_BUFFER, hAdHandle, ubSubImage,WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
// redraw new mail warning, and create new mail button, if nessacary
fReDrawNewMailFlag = TRUE;
InvalidateRegion(AIM_AD_TOP_LEFT_X,AIM_AD_TOP_LEFT_Y, AIM_AD_BOTTOM_RIGHT_X ,AIM_AD_BOTTOM_RIGHT_Y);
}
uiLastTime = GetJA2Clock();
//display first frame longer then rest
ubCount++;
if( ubCount > 12 )
{
ubRetVal = AIM_AD_DONE;
}
}
else
{
GetVideoObject(&hAdHandle, uiAdImageIdentifier);
BltVideoObject(FRAME_BUFFER, hAdHandle, ubSubImage,WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
// redraw new mail warning, and create new mail button, if nessacary
fReDrawNewMailFlag = TRUE;
ubSubImage++;
}
//if the add it to have text on it, then put the text on it.
HandleTextOnAimAdd( ubSubImage );
uiLastTime = GetJA2Clock();
InvalidateRegion(AIM_AD_TOP_LEFT_X,AIM_AD_TOP_LEFT_Y, AIM_AD_BOTTOM_RIGHT_X ,AIM_AD_BOTTOM_RIGHT_Y);
}
return( ubRetVal );
}
BOOLEAN DisplayFlowerAd( BOOLEAN fInit, BOOLEAN fRedraw )
{
static UINT32 uiLastTime;
static UINT8 ubSubImage=0;
static UINT8 ubCount=0;
UINT32 uiCurTime = GetJA2Clock();
if( fInit )
{
uiLastTime = 0;
ubSubImage = 0;
ubCount = 0;
MSYS_EnableRegion(&gSelectedBannerRegion);
}
if( ((uiCurTime - uiLastTime) > AIM_FLOWER_AD_DELAY) || fRedraw)
{
HVOBJECT hAdHandle;
if( ubSubImage == AIM_FLOWER_NUM_SUBIMAGES)
{
if(ubCount == 0 || fRedraw)
{
//Blit the blue sky frame with text on top
GetVideoObject(&hAdHandle, guiFlowerAdvertisement);
BltVideoObject(FRAME_BUFFER, hAdHandle, 0,WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
// redraw new mail warning, and create new mail button, if nessacary
fReDrawNewMailFlag = TRUE;
//Display Aim Warning Text
DisplayWrappedString(AIM_WARNING_TEXT_X, AIM_WARNING_TEXT_Y, AIM_WARNING_TEXT_WIDTH, 2, FONT14ARIAL, FONT_GREEN, AimScreenText[AIM_INFO_6], FONT_MCOLOR_BLACK, FALSE, CENTER_JUSTIFIED);
//Display Aim Warning Text
SetFontShadow( FONT_MCOLOR_WHITE );
DisplayWrappedString(AIM_WARNING_TEXT_X, AIM_FLOWER_LINK_TEXT_Y, AIM_WARNING_TEXT_WIDTH, 2, FONT12ARIAL, 2, AimScreenText[AIM_INFO_7], FONT_MCOLOR_BLACK, FALSE, CENTER_JUSTIFIED);
SetFontShadow( DEFAULT_SHADOW );
InvalidateRegion(AIM_AD_TOP_LEFT_X,AIM_AD_TOP_LEFT_Y, AIM_AD_BOTTOM_RIGHT_X ,AIM_AD_BOTTOM_RIGHT_Y);
}
uiLastTime = GetJA2Clock();
ubCount++;
if( ubCount > 40 )
{
return( AIM_AD_DONE );
}
else
return( AIM_AD_NOT_DONE );
}
else
{
GetVideoObject(&hAdHandle, guiFlowerAdvertisement);
BltVideoObject(FRAME_BUFFER, hAdHandle, ubSubImage,WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
// redraw new mail warning, and create new mail button, if nessacary
fReDrawNewMailFlag = TRUE;
ubSubImage++;
}
uiLastTime = GetJA2Clock();
InvalidateRegion(AIM_AD_TOP_LEFT_X,AIM_AD_TOP_LEFT_Y, AIM_AD_BOTTOM_RIGHT_X ,AIM_AD_BOTTOM_RIGHT_Y);
}
return( AIM_AD_NOT_DONE );
}
ANITILE *CreateAnimationTile( ANITILE_PARAMS *pAniParams )
{
ANITILE *pAniNode;
ANITILE *pNewAniNode;
LEVELNODE *pNode;
INT32 iCachedTile=-1;
INT16 sGridNo;
UINT8 ubLevel;
INT16 usTileType;
INT16 usTileIndex;
INT16 sDelay;
INT16 sStartFrame=-1;
UINT32 uiFlags;
LEVELNODE *pGivenNode;
INT16 sX, sY, sZ;
UINT8 ubTempDir;
// Get some parameters from structure sent in...
sGridNo = pAniParams->sGridNo;
ubLevel = pAniParams->ubLevelID;
usTileType = pAniParams->usTileType;
usTileIndex = pAniParams->usTileIndex;
sDelay = pAniParams->sDelay;
sStartFrame = pAniParams->sStartFrame;
uiFlags = pAniParams->uiFlags;
pGivenNode = pAniParams->pGivenLevelNode;
sX = pAniParams->sX;
sY = pAniParams->sY;
sZ = pAniParams->sZ;
pAniNode = pAniTileHead;
// Allocate head
pNewAniNode = MemAlloc( sizeof( ANITILE ) );
if ( (uiFlags & ANITILE_EXISTINGTILE ) )
{
pNewAniNode->pLevelNode = pGivenNode;
pNewAniNode->pLevelNode->pAniTile = pNewAniNode;
}
else
{
if ( ( uiFlags & ANITILE_CACHEDTILE ) )
{
iCachedTile = GetCachedTile( pAniParams->zCachedFile );
if ( iCachedTile == -1 )
{
return( NULL );
}
usTileIndex = iCachedTile + TILE_CACHE_START_INDEX;
}
// ALLOCATE NEW TILE
switch( ubLevel )
{
case ANI_STRUCT_LEVEL:
pNode = ForceStructToTail( sGridNo, usTileIndex );
break;
case ANI_SHADOW_LEVEL:
AddShadowToHead( sGridNo, usTileIndex );
pNode = gpWorldLevelData[ sGridNo ].pShadowHead;
break;
case ANI_OBJECT_LEVEL:
AddObjectToHead( sGridNo, usTileIndex );
pNode = gpWorldLevelData[ sGridNo ].pObjectHead;
break;
case ANI_ROOF_LEVEL:
AddRoofToHead( sGridNo, usTileIndex );
pNode = gpWorldLevelData[ sGridNo ].pRoofHead;
break;
case ANI_ONROOF_LEVEL:
AddOnRoofToHead( sGridNo, usTileIndex );
pNode = gpWorldLevelData[ sGridNo ].pOnRoofHead;
break;
case ANI_TOPMOST_LEVEL:
AddTopmostToHead( sGridNo, usTileIndex );
pNode = gpWorldLevelData[ sGridNo ].pTopmostHead;
break;
default:
return( NULL );
}
// SET NEW TILE VALUES
pNode->ubShadeLevel=DEFAULT_SHADE_LEVEL;
pNode->ubNaturalShadeLevel=DEFAULT_SHADE_LEVEL;
pNewAniNode->pLevelNode = pNode;
if ( ( uiFlags & ANITILE_CACHEDTILE ) )
{
pNewAniNode->pLevelNode->uiFlags |= ( LEVELNODE_CACHEDANITILE );
pNewAniNode->sCachedTileID = (INT16)iCachedTile;
pNewAniNode->usCachedTileSubIndex = usTileType;
pNewAniNode->pLevelNode->pAniTile = pNewAniNode;
pNewAniNode->sRelativeX = sX;
pNewAniNode->sRelativeY = sY;
pNewAniNode->pLevelNode->sRelativeZ = sZ;
}
// Can't set relative X,Y,Z IF FLAGS ANITILE_CACHEDTILE set!
else if ( (uiFlags & ANITILE_USEABSOLUTEPOS ) )
{
pNewAniNode->pLevelNode->sRelativeX = sX;
pNewAniNode->pLevelNode->sRelativeY = sY;
pNewAniNode->pLevelNode->sRelativeZ = sZ;
pNewAniNode->pLevelNode->uiFlags |= ( LEVELNODE_USEABSOLUTEPOS );
}
}
switch( ubLevel )
{
case ANI_STRUCT_LEVEL:
ResetSpecificLayerOptimizing( TILES_DYNAMIC_STRUCTURES );
break;
case ANI_SHADOW_LEVEL:
ResetSpecificLayerOptimizing( TILES_DYNAMIC_SHADOWS );
break;
case ANI_OBJECT_LEVEL:
ResetSpecificLayerOptimizing( TILES_DYNAMIC_OBJECTS );
break;
case ANI_ROOF_LEVEL:
ResetSpecificLayerOptimizing( TILES_DYNAMIC_ROOF );
break;
case ANI_ONROOF_LEVEL:
ResetSpecificLayerOptimizing( TILES_DYNAMIC_ONROOF );
break;
case ANI_TOPMOST_LEVEL:
ResetSpecificLayerOptimizing( TILES_DYNAMIC_TOPMOST );
break;
}
// SET FLAGS FOR LEVELNODE
pNewAniNode->pLevelNode->uiFlags |= ( LEVELNODE_ANIMATION | LEVELNODE_USEZ | LEVELNODE_DYNAMIC );
if ( ( uiFlags & ANITILE_NOZBLITTER ) )
{
pNewAniNode->pLevelNode->uiFlags |= LEVELNODE_NOZBLITTER;
}
if ( ( uiFlags & ANITILE_ALWAYS_TRANSLUCENT ) )
{
pNewAniNode->pLevelNode->uiFlags |= LEVELNODE_REVEAL;
}
if ( ( uiFlags & ANITILE_USEBEST_TRANSLUCENT ) )
{
pNewAniNode->pLevelNode->uiFlags |= LEVELNODE_USEBESTTRANSTYPE;
}
if ( ( uiFlags & ANITILE_ANIMATE_Z ) )
{
pNewAniNode->pLevelNode->uiFlags |= LEVELNODE_DYNAMICZ;
}
if ( ( uiFlags & ANITILE_PAUSED ) )
{
pNewAniNode->pLevelNode->uiFlags |= ( LEVELNODE_LASTDYNAMIC | LEVELNODE_UPDATESAVEBUFFERONCE );
pNewAniNode->pLevelNode->uiFlags &= (~LEVELNODE_DYNAMIC );
}
if ( ( uiFlags & ANITILE_OPTIMIZEFORSMOKEEFFECT ) )
{
pNewAniNode->pLevelNode->uiFlags |= LEVELNODE_NOWRITEZ;
}
// SET ANITILE VALUES
pNewAniNode->ubLevelID = ubLevel;
pNewAniNode->usTileIndex = usTileIndex;
if ( ( uiFlags & ANITILE_CACHEDTILE ) )
{
pNewAniNode->usNumFrames = gpTileCache[ iCachedTile ].ubNumFrames;
}
else
{
Assert( gTileDatabase[ usTileIndex ].pAnimData != NULL );
pNewAniNode->usNumFrames = gTileDatabase[ usTileIndex ].pAnimData->ubNumFrames;
}
if ( ( uiFlags & ANITILE_USE_DIRECTION_FOR_START_FRAME ) )
{
// Our start frame is actually a direction indicator
ubTempDir = gOneCDirection[ pAniParams->uiUserData3 ];
sStartFrame = (UINT16)sStartFrame + ( pNewAniNode->usNumFrames * ubTempDir );
}
if ( ( uiFlags & ANITILE_USE_4DIRECTION_FOR_START_FRAME ) )
{
// Our start frame is actually a direction indicator
ubTempDir = gb4DirectionsFrom8[ pAniParams->uiUserData3 ];
sStartFrame = (UINT16)sStartFrame + ( pNewAniNode->usNumFrames * ubTempDir );
}
pNewAniNode->usTileType = usTileType;
pNewAniNode->pNext = pAniNode;
pNewAniNode->uiFlags = uiFlags;
pNewAniNode->sDelay = sDelay;
pNewAniNode->sCurrentFrame = sStartFrame;
pNewAniNode->uiTimeLastUpdate = GetJA2Clock( );
pNewAniNode->sGridNo = sGridNo;
pNewAniNode->sStartFrame = sStartFrame;
pNewAniNode->ubKeyFrame1 = pAniParams->ubKeyFrame1;
pNewAniNode->uiKeyFrame1Code = pAniParams->uiKeyFrame1Code;
pNewAniNode->ubKeyFrame2 = pAniParams->ubKeyFrame2;
pNewAniNode->uiKeyFrame2Code = pAniParams->uiKeyFrame2Code;
pNewAniNode->uiUserData = pAniParams->uiUserData;
pNewAniNode->ubUserData2 = pAniParams->ubUserData2;
pNewAniNode->uiUserData3 = pAniParams->uiUserData3;
//Set head
pAniTileHead = pNewAniNode;
// Set some special stuff
return( pNewAniNode );
}
//Simply create videosurface, load image, and draw it to the screen.
void InitJA2SplashScreen()
{
#ifdef ENGLISH
ClearMainMenu();
#else
UINT32 uiLogoID = 0;
HVSURFACE hVSurface; // unused jonathanl // lalien reenabled for international versions
VSURFACE_DESC VSurfaceDesc; //unused jonathanl // lalien reenabled for international versions
# ifdef JA2TESTVERSION
INT32 i = 0;
memset( &VSurfaceDesc, 0, sizeof( VSURFACE_DESC ) );
VSurfaceDesc.fCreateFlags = VSURFACE_CREATE_FROMFILE | VSURFACE_SYSTEM_MEM_USAGE | VSURFACE_CREATE_FROMPNG_FALLBACK;
sprintf( VSurfaceDesc.ImageFile, "LOADSCREENS\\Notification.sti" );
if( !AddVideoSurface( &VSurfaceDesc, &uiLogoID ) )
{
//AssertMsg( 0, String( "Failed to load %s", VSurfaceDesc.ImageFile ) );
return;
}
GetVideoSurface(&hVSurface, uiLogoID );
//BltVideoSurfaceToVideoSurface( ghFrameBuffer, hVSurface, 0, 0, 0, 0, NULL );
BltVideoSurfaceToVideoSurface( ghFrameBuffer, hVSurface, 0, iScreenWidthOffset, iScreenHeightOffset, 0, NULL );
DeleteVideoSurfaceFromIndex( uiLogoID );
InvalidateScreen();
RefreshScreen( NULL );
guiSplashStartTime = GetJA2Clock();
while( i < 60 * 15 )//guiSplashStartTime + 15000 > GetJA2Clock() )
{
//Allow the user to pick his bum.
InvalidateScreen();
RefreshScreen( NULL );
i++;
}
# endif // JA2TESTVERSION
memset( &VSurfaceDesc, 0, sizeof( VSURFACE_DESC ) );
VSurfaceDesc.fCreateFlags = VSURFACE_CREATE_FROMFILE | VSURFACE_SYSTEM_MEM_USAGE | VSURFACE_CREATE_FROMPNG_FALLBACK;
GetMLGFilename( VSurfaceDesc.ImageFile, MLG_SPLASH );
try
{
if( !AddVideoSurface( &VSurfaceDesc, &uiLogoID ) )
{
AssertMsg( 0, String( "Failed to load %s", VSurfaceDesc.ImageFile ) );
return;
}
}
catch(std::exception &ex)
{
SGP_RETHROW(L"Failed loading splash screen", ex);
}
GetVideoSurface( &hVSurface, uiLogoID );
BltVideoSurfaceToVideoSurface( ghFrameBuffer, hVSurface, 0, iScreenWidthOffset, iScreenHeightOffset, 0, NULL );
DeleteVideoSurfaceFromIndex( uiLogoID );
#endif // ENGLISH
InvalidateScreen();
RefreshScreen( NULL );
guiSplashStartTime = GetJA2Clock();
}
void UpdateAniTiles( )
{
ANITILE *pAniNode = NULL;
ANITILE *pNode = NULL;
UINT32 uiClock = GetJA2Clock( );
UINT16 usMaxFrames, usMinFrames;
UINT8 ubTempDir;
// LOOP THROUGH EACH NODE
pAniNode = pAniTileHead;
while( pAniNode != NULL )
{
pNode = pAniNode;
pAniNode = pAniNode->pNext;
if ( (uiClock - pNode->uiTimeLastUpdate ) > (UINT32)pNode->sDelay && !( pNode->uiFlags & ANITILE_PAUSED ) )
{
pNode->uiTimeLastUpdate = GetJA2Clock( );
if ( pNode->uiFlags & ( ANITILE_OPTIMIZEFORSLOWMOVING ) )
{
pNode->pLevelNode->uiFlags |= (LEVELNODE_DYNAMIC );
pNode->pLevelNode->uiFlags &= (~LEVELNODE_LASTDYNAMIC);
}
else if ( pNode->uiFlags & ( ANITILE_OPTIMIZEFORSMOKEEFFECT ) )
{
// pNode->pLevelNode->uiFlags |= LEVELNODE_DYNAMICZ;
ResetSpecificLayerOptimizing( TILES_DYNAMIC_STRUCTURES );
pNode->pLevelNode->uiFlags &= (~LEVELNODE_LASTDYNAMIC);
pNode->pLevelNode->uiFlags |= (LEVELNODE_DYNAMIC );
}
if ( pNode->uiFlags & ANITILE_FORWARD )
{
usMaxFrames = pNode->usNumFrames;
if ( pNode->uiFlags & ANITILE_USE_DIRECTION_FOR_START_FRAME )
{
ubTempDir = gOneCDirection[ pNode->uiUserData3 ];
usMaxFrames = (UINT16)usMaxFrames + ( pNode->usNumFrames * ubTempDir );
}
if ( pNode->uiFlags & ANITILE_USE_4DIRECTION_FOR_START_FRAME )
{
ubTempDir = gb4DirectionsFrom8[ pNode->uiUserData3 ];
usMaxFrames = (UINT16)usMaxFrames + ( pNode->usNumFrames * ubTempDir );
}
if ( ( pNode->sCurrentFrame + 1 ) < usMaxFrames )
{
pNode->sCurrentFrame++;
pNode->pLevelNode->sCurrentFrame = pNode->sCurrentFrame;
if ( pNode->uiFlags & ANITILE_EXPLOSION )
{
// Talk to the explosion data...
UpdateExplosionFrame( pNode->uiUserData3, pNode->sCurrentFrame );
}
// CHECK IF WE SHOULD BE DISPLAYING TRANSLUCENTLY!
if ( pNode->sCurrentFrame == pNode->ubKeyFrame1 )
{
switch( pNode->uiKeyFrame1Code )
{
case ANI_KEYFRAME_BEGIN_TRANSLUCENCY:
pNode->pLevelNode->uiFlags |= LEVELNODE_REVEAL;
break;
case ANI_KEYFRAME_CHAIN_WATER_EXPLOSION:
IgniteExplosion( pNode->ubUserData2, pNode->pLevelNode->sRelativeX, pNode->pLevelNode->sRelativeY, 0, pNode->sGridNo, (UINT16)( pNode->uiUserData ), 0 );
break;
case ANI_KEYFRAME_DO_SOUND:
PlayJA2Sample( pNode->uiUserData, RATE_11025, SoundVolume( MIDVOLUME, (INT16)pNode->uiUserData3 ), 1, SoundDir( (INT16)pNode->uiUserData3 ) );
break;
}
}
// CHECK IF WE SHOULD BE DISPLAYING TRANSLUCENTLY!
if ( pNode->sCurrentFrame == pNode->ubKeyFrame2 )
{
UINT8 ubExpType;
switch( pNode->uiKeyFrame2Code )
{
case ANI_KEYFRAME_BEGIN_DAMAGE:
ubExpType = Explosive[ Item[ (UINT16)pNode->uiUserData ].ubClassIndex ].ubType;
if ( ubExpType == EXPLOSV_TEARGAS || ubExpType == EXPLOSV_MUSTGAS ||
ubExpType == EXPLOSV_SMOKE )
{
// Do sound....
// PlayJA2Sample( AIR_ESCAPING_1, RATE_11025, SoundVolume( HIGHVOLUME, pNode->sGridNo ), 1, SoundDir( pNode->sGridNo ) );
NewSmokeEffect( pNode->sGridNo, (UINT16)pNode->uiUserData, gExplosionData[ pNode->uiUserData3 ].Params.bLevel, (UINT8)pNode->ubUserData2 );
}
else
{
SpreadEffect( pNode->sGridNo, Explosive[ Item[ (UINT16)pNode->uiUserData ].ubClassIndex ].ubRadius, (UINT16)pNode->uiUserData, (UINT8)pNode->ubUserData2, FALSE, gExplosionData[ pNode->uiUserData3 ].Params.bLevel, -1 );
}
// Forfait any other animations this frame....
return;
}
}
}
else
{
// We are done!
if ( pNode->uiFlags & ANITILE_LOOPING )
{
pNode->sCurrentFrame = pNode->sStartFrame;
if ( ( pNode->uiFlags & ANITILE_USE_DIRECTION_FOR_START_FRAME ) )
{
// Our start frame is actually a direction indicator
ubTempDir = gOneCDirection[ pNode->uiUserData3 ];
pNode->sCurrentFrame = (UINT16)( pNode->usNumFrames * ubTempDir );
}
if ( ( pNode->uiFlags & ANITILE_USE_4DIRECTION_FOR_START_FRAME ) )
{
// Our start frame is actually a direction indicator
ubTempDir = gb4DirectionsFrom8[ pNode->uiUserData3 ];
pNode->sCurrentFrame = (UINT16)( pNode->usNumFrames * ubTempDir );
}
}
else if ( pNode->uiFlags & ANITILE_REVERSE_LOOPING )
{
// Turn off backwards flag
pNode->uiFlags &= (~ANITILE_FORWARD );
// Turn onn forwards flag
pNode->uiFlags |= ANITILE_BACKWARD;
}
else
{
// Delete from world!
DeleteAniTile( pNode );
// Turn back on redunency checks!
gTacticalStatus.uiFlags &= (~NOHIDE_REDUNDENCY);
return;
}
}
}
if ( pNode->uiFlags & ANITILE_BACKWARD )
{
if ( pNode->uiFlags & ANITILE_ERASEITEMFROMSAVEBUFFFER )
{
// ATE: Check if bounding box is on the screen...
if ( pNode->bFrameCountAfterStart == 0 )
{
pNode->bFrameCountAfterStart = 1;
pNode->pLevelNode->uiFlags |= (LEVELNODE_DYNAMIC );
// Dangerous here, since we may not even be on the screen...
SetRenderFlags( RENDER_FLAG_FULL );
continue;
}
}
usMinFrames = 0;
if ( pNode->uiFlags & ANITILE_USE_DIRECTION_FOR_START_FRAME )
{
ubTempDir = gOneCDirection[ pNode->uiUserData3 ];
usMinFrames = ( pNode->usNumFrames * ubTempDir );
}
if ( pNode->uiFlags & ANITILE_USE_4DIRECTION_FOR_START_FRAME )
{
ubTempDir = gb4DirectionsFrom8[ pNode->uiUserData3 ];
usMinFrames = ( pNode->usNumFrames * ubTempDir );
}
if ( ( pNode->sCurrentFrame - 1 ) >= usMinFrames )
{
pNode->sCurrentFrame--;
pNode->pLevelNode->sCurrentFrame = pNode->sCurrentFrame;
if ( pNode->uiFlags & ANITILE_EXPLOSION )
{
// Talk to the explosion data...
UpdateExplosionFrame( pNode->uiUserData3, pNode->sCurrentFrame );
}
}
else
{
// We are done!
if ( pNode->uiFlags & ANITILE_PAUSE_AFTER_LOOP )
{
// Turn off backwards flag
pNode->uiFlags &= (~ANITILE_BACKWARD );
// Pause
pNode->uiFlags |= ANITILE_PAUSED;
}
else if ( pNode->uiFlags & ANITILE_LOOPING )
{
pNode->sCurrentFrame = pNode->sStartFrame;
if ( ( pNode->uiFlags & ANITILE_USE_DIRECTION_FOR_START_FRAME ) )
{
// Our start frame is actually a direction indicator
ubTempDir = gOneCDirection[ pNode->uiUserData3 ];
pNode->sCurrentFrame = (UINT16)( pNode->usNumFrames * ubTempDir );
}
if ( ( pNode->uiFlags & ANITILE_USE_4DIRECTION_FOR_START_FRAME ) )
{
// Our start frame is actually a direction indicator
ubTempDir = gb4DirectionsFrom8[ pNode->uiUserData3 ];
pNode->sCurrentFrame = (UINT16)( pNode->usNumFrames * ubTempDir );
}
}
else if ( pNode->uiFlags & ANITILE_REVERSE_LOOPING )
{
// Turn off backwards flag
pNode->uiFlags &= (~ANITILE_BACKWARD );
// Turn onn forwards flag
pNode->uiFlags |= ANITILE_FORWARD;
}
else
{
// Delete from world!
DeleteAniTile( pNode );
return;
}
if ( pNode->uiFlags & ANITILE_ERASEITEMFROMSAVEBUFFFER )
{
// ATE: Check if bounding box is on the screen...
pNode->bFrameCountAfterStart = 0;
//pNode->pLevelNode->uiFlags |= LEVELNODE_UPDATESAVEBUFFERONCE;
// Dangerous here, since we may not even be on the screen...
SetRenderFlags( RENDER_FLAG_FULL );
}
}
}
}
else
{
if ( pNode->uiFlags & ( ANITILE_OPTIMIZEFORSLOWMOVING ) )
{
// ONLY TURN OFF IF PAUSED...
if ( ( pNode->uiFlags & ANITILE_ERASEITEMFROMSAVEBUFFFER ) )
{
if ( pNode->uiFlags & ANITILE_PAUSED )
{
if ( pNode->pLevelNode->uiFlags & LEVELNODE_DYNAMIC )
{
pNode->pLevelNode->uiFlags &= (~LEVELNODE_DYNAMIC );
pNode->pLevelNode->uiFlags |= (LEVELNODE_LASTDYNAMIC);
SetRenderFlags( RENDER_FLAG_FULL );
}
}
}
else
{
pNode->pLevelNode->uiFlags &= (~LEVELNODE_DYNAMIC );
pNode->pLevelNode->uiFlags |= (LEVELNODE_LASTDYNAMIC);
}
}
else if ( pNode->uiFlags & ( ANITILE_OPTIMIZEFORSMOKEEFFECT ) )
{
pNode->pLevelNode->uiFlags |= (LEVELNODE_LASTDYNAMIC);
pNode->pLevelNode->uiFlags &= (~LEVELNODE_DYNAMIC );
}
}
}
}
BOOLEAN DisplayBobbyRAd( BOOLEAN fInit, BOOLEAN fRedraw )
{
static UINT32 uiLastTime;
static UINT8 ubSubImage=0;
static UINT8 ubDuckCount=0;
static UINT8 ubCount=0;
UINT32 uiCurTime = GetJA2Clock();
UINT8 ubRetVal = 0;
UINT16 usDelay = AIM_AD_BOBBYR_AD_DELAY;
if( fInit )
{
ubDuckCount = 0;
uiLastTime = 0;
ubSubImage = 0;
ubCount = 0;
}
if( ((uiCurTime - uiLastTime) > usDelay) || fRedraw)
{
HVOBJECT hAdHandle;
//Loop through the first 6 images twice, then start into the later ones
GetVideoObject(&hAdHandle, guiBobbyRAdImages);
//if we are still looping through the first 6 animations
if( ubDuckCount < 2 )
{
BltVideoObject(FRAME_BUFFER, hAdHandle, ubSubImage, WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
ubSubImage ++;
InvalidateRegion(AIM_AD_TOP_LEFT_X,AIM_AD_TOP_LEFT_Y, AIM_AD_BOTTOM_RIGHT_X ,AIM_AD_BOTTOM_RIGHT_Y);
// if we do the first set of images
if( ubSubImage > AIM_AD_BOBBYR_AD_NUM_DUCK_SUBIMAGES )
{
ubDuckCount++;
if( ubDuckCount < 2 )
ubSubImage = 0;
else
ubSubImage = AIM_AD_BOBBYR_AD_NUM_DUCK_SUBIMAGES+1;
}
ubRetVal = AIM_AD_NOT_DONE;
}
else
{
//Blit the ad
BltVideoObject(FRAME_BUFFER, hAdHandle, ubSubImage,WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
ubSubImage ++;
if( ubSubImage >= AIM_AD_BOBBYR_AD__NUM_SUBIMAGES-1 )
{
//display last frame longer then rest
ubCount++;
if( ubCount > 12 )
{
ubRetVal = AIM_AD_DONE;
}
ubSubImage = AIM_AD_BOBBYR_AD__NUM_SUBIMAGES - 1;
}
// redraw new mail warning, and create new mail button, if nessacary
fReDrawNewMailFlag = TRUE;
InvalidateRegion(AIM_AD_TOP_LEFT_X,AIM_AD_TOP_LEFT_Y, AIM_AD_BOTTOM_RIGHT_X ,AIM_AD_BOTTOM_RIGHT_Y);
}
//if the add it to have text on it, then put the text on it.
HandleTextOnAimAdd( ubSubImage );
uiLastTime = GetJA2Clock();
InvalidateRegion(AIM_AD_TOP_LEFT_X,AIM_AD_TOP_LEFT_Y, AIM_AD_BOTTOM_RIGHT_X ,AIM_AD_BOTTOM_RIGHT_Y);
}
/*
if( ubDuckImage < AIM_AD_BOBBYR_AD_NUM_DUCK_SUBIMAGES )
{
ubDuckImage++;
}
GetVideoObject(&hAdHandle, guiBobbyRAdImages);
if( ubDuckImage < AIM_AD_BOBBYR_AD_NUM_DUCK_SUBIMAGES * 2 )
{
if( ubDuckImage >= AIM_AD_BOBBYR_AD_NUM_DUCK_SUBIMAGES )
BltVideoObject(FRAME_BUFFER, hAdHandle, (UINT16)(ubDuckImage-AIM_AD_BOBBYR_AD_NUM_DUCK_SUBIMAGES), WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
else
BltVideoObject(FRAME_BUFFER, hAdHandle, ubDuckImage,WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
ubDuckImage++;
}
else
ubSubImage = 5;
if( ubSubImage == 5 )
{
if(ubCount == 0 || fRedraw)
{
//Blit the ad
BltVideoObject(FRAME_BUFFER, hAdHandle, ubSubImage,WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
// redraw new mail warning, and create new mail button, if nessacary
fReDrawNewMailFlag = TRUE;
InvalidateRegion(AIM_AD_TOP_LEFT_X,AIM_AD_TOP_LEFT_Y, AIM_AD_BOTTOM_RIGHT_X ,AIM_AD_BOTTOM_RIGHT_Y);
}
uiLastTime = GetJA2Clock();
ubRetVal = AIM_AD_NOT_DONE;
}
else if( ubSubImage == AIM_AD_BOBBYR_AD__NUM_SUBIMAGES-1 )
{
if(ubCount == 0 || fRedraw)
{
//Blit the ad
GetVideoObject(&hAdHandle, guiBobbyRAdImages);
BltVideoObject(FRAME_BUFFER, hAdHandle, ubSubImage,WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
// redraw new mail warning, and create new mail button, if nessacary
fReDrawNewMailFlag = TRUE;
InvalidateRegion(AIM_AD_TOP_LEFT_X,AIM_AD_TOP_LEFT_Y, AIM_AD_BOTTOM_RIGHT_X ,AIM_AD_BOTTOM_RIGHT_Y);
}
uiLastTime = GetJA2Clock();
//display last frame longer then rest
ubCount++;
if( ubCount > 12 )
{
ubRetVal = AIM_AD_DONE;
}
}
else
{
GetVideoObject(&hAdHandle, guiBobbyRAdImages);
BltVideoObject(FRAME_BUFFER, hAdHandle, ubSubImage,WARNING_X, WARNING_Y, VO_BLT_SRCTRANSPARENCY,NULL);
// redraw new mail warning, and create new mail button, if nessacary
fReDrawNewMailFlag = TRUE;
ubSubImage++;
}
*/
return( ubRetVal );
}
void ScrollString( )
{
ScrollStringStPtr pStringSt = pStringS;
UINT32 suiTimer=0;
UINT32 cnt;
INT32 iNumberOfNewStrings = 0; // the count of new strings, so we can update position by WIDTH_BETWEEN_NEW_STRINGS pixels in the y
INT32 iNumberOfMessagesOnQueue = 0;
INT32 iMaxAge = 0;
BOOLEAN fDitchLastMessage = FALSE;
// UPDATE TIMER
suiTimer=GetJA2Clock();
// might have pop up text timer
HandleLastQuotePopUpTimer( );
if( guiCurrentScreen == MAP_SCREEN )
{
return;
}
// DONOT UPDATE IF WE ARE SCROLLING!
if ( gfScrollPending || gfScrollInertia )
{
return;
}
// messages hidden
if( fScrollMessagesHidden )
{
return;
}
iNumberOfMessagesOnQueue = GetMessageQueueSize( );
iMaxAge = MAX_AGE;
if( ( iNumberOfMessagesOnQueue > 0 )&&( gpDisplayList[ MAX_LINE_COUNT - 1 ] != NULL) )
{
fDitchLastMessage = TRUE;
}
else
{
fDitchLastMessage = FALSE;
}
if( ( iNumberOfMessagesOnQueue * 1000 ) >= iMaxAge )
{
iNumberOfMessagesOnQueue = ( iMaxAge / 1000 );
}
else if( iNumberOfMessagesOnQueue < 0 )
{
iNumberOfMessagesOnQueue = 0;
}
//AGE
for ( cnt = 0; cnt < MAX_LINE_COUNT; cnt++ )
{
if ( gpDisplayList[ cnt ] != NULL )
{
if( ( fDitchLastMessage ) && ( cnt == MAX_LINE_COUNT - 1 ) )
{
gpDisplayList[ cnt ]->uiTimeOfLastUpdate = iMaxAge;
}
// CHECK IF WE HAVE AGED
if ( ( suiTimer - gpDisplayList[ cnt ]->uiTimeOfLastUpdate ) > ( UINT32 )( iMaxAge - ( 1000 * iNumberOfMessagesOnQueue ) ) )
{
// Remove our sorry ass
RemoveStringVideoOverlay( gpDisplayList[ cnt ] );
MemFree( gpDisplayList[ cnt ]->pString16);
MemFree( gpDisplayList[ cnt ] );
// Free slot
gpDisplayList[ cnt ] = NULL;
}
}
}
// CHECK FOR FREE SPOTS AND ADD ANY STRINGS IF WE HAVE SOME TO ADD!
// FIRST CHECK IF WE HAVE ANY IN OUR QUEUE
if ( pStringS != NULL )
{
// CHECK IF WE HAVE A SLOT!
// CHECK OUR LAST SLOT!
if ( gpDisplayList[ MAX_LINE_COUNT - 1 ] == NULL )
{
// MOVE ALL UP!
// cpy, then move
for( cnt = MAX_LINE_COUNT - 1; cnt > 0; cnt-- )
{
gpDisplayList[ cnt ] = gpDisplayList[ cnt - 1 ];
}
// now add in the new string
cnt = 0;
gpDisplayList[ cnt ] = pStringS;
CreateStringVideoOverlay( pStringS, X_START, Y_START );
if( pStringS -> fBeginningOfNewString == TRUE )
{
iNumberOfNewStrings++;
}
// set up age
pStringS->uiTimeOfLastUpdate = GetJA2Clock();
// now move
for ( cnt = 0; cnt <= MAX_LINE_COUNT - 1; cnt++ )
{
// Adjust position!
if ( gpDisplayList[ cnt ] != NULL )
{
SetStringVideoOverlayPosition( gpDisplayList[ cnt ], X_START, (INT16)( ( Y_START - ( ( cnt ) * GetFontHeight( SMALLFONT1 ) ) ) - ( INT16)( WIDTH_BETWEEN_NEW_STRINGS * ( iNumberOfNewStrings ) ) ) );
// start of new string, increment count of new strings, for spacing purposes
if( gpDisplayList[ cnt ] -> fBeginningOfNewString == TRUE )
{
iNumberOfNewStrings++;
}
}
}
// WE NOW HAVE A FREE SPACE, INSERT!
// Adjust head!
pStringS = pStringS->pNext;
if( pStringS )
{
pStringS->pPrev = NULL;
}
//check if new meesage we have not seen since mapscreen..if so, beep
if( ( fOkToBeepNewMessage == TRUE ) && ( gpDisplayList[ MAX_LINE_COUNT - 2 ] == NULL ) && ( ( guiCurrentScreen == GAME_SCREEN ) || ( guiCurrentScreen == MAP_SCREEN ) ) && ( gfFacePanelActive == FALSE ) )
{
PlayNewMessageSound( );
}
}
}
}
//Simply create videosurface, load image, and draw it to the screen.
void InitJA2SplashScreen()
{
UINT32 uiLogoID = 0;
STRING512 CurrentDir;
STRING512 DataDir;
HVSURFACE hVSurface;
VSURFACE_DESC VSurfaceDesc;
INT32 i = 0;
InitializeJA2Clock();
//InitializeJA2TimerID();
// Get Executable Directory
GetExecutableDirectory( CurrentDir );
// Adjust Current Dir
sprintf( DataDir, "%s\\Data", CurrentDir );
if ( !SetFileManCurrentDirectory( DataDir ) )
{
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Could not find data directory, shutting down");
return;
}
//Initialize the file database
InitializeFileDatabase( gGameLibaries, NUMBER_OF_LIBRARIES );
#if !defined( ENGLISH ) && defined( JA2TESTVERSION )
memset( &VSurfaceDesc, 0, sizeof( VSURFACE_DESC ) );
VSurfaceDesc.fCreateFlags = VSURFACE_CREATE_FROMFILE | VSURFACE_SYSTEM_MEM_USAGE;
sprintf( VSurfaceDesc.ImageFile, "LOADSCREENS\\Notification.sti" );
if( !AddVideoSurface( &VSurfaceDesc, &uiLogoID ) )
{
AssertMsg( 0, String( "Failed to load %s", VSurfaceDesc.ImageFile ) );
return;
}
GetVideoSurface(&hVSurface, uiLogoID );
BltVideoSurfaceToVideoSurface( ghFrameBuffer, hVSurface, 0, 0, 0, 0, NULL );
DeleteVideoSurfaceFromIndex( uiLogoID );
InvalidateScreen();
RefreshScreen( NULL );
guiSplashStartTime = GetJA2Clock();
while( i < 60 * 15 )//guiSplashStartTime + 15000 > GetJA2Clock() )
{
//Allow the user to pick his bum.
InvalidateScreen();
RefreshScreen( NULL );
i++;
}
#endif
#ifdef ENGLISH
ClearMainMenu();
#else
{
memset( &VSurfaceDesc, 0, sizeof( VSURFACE_DESC ) );
VSurfaceDesc.fCreateFlags = VSURFACE_CREATE_FROMFILE | VSURFACE_SYSTEM_MEM_USAGE;
GetMLGFilename( VSurfaceDesc.ImageFile, MLG_SPLASH );
if( !AddVideoSurface( &VSurfaceDesc, &uiLogoID ) )
{
AssertMsg( 0, String( "Failed to load %s", VSurfaceDesc.ImageFile ) );
return;
}
GetVideoSurface( &hVSurface, uiLogoID );
BltVideoSurfaceToVideoSurface( ghFrameBuffer, hVSurface, 0, 0, 0, 0, NULL );
DeleteVideoSurfaceFromIndex( uiLogoID );
}
#endif
InvalidateScreen();
RefreshScreen( NULL );
guiSplashStartTime = GetJA2Clock();
}
void SyncStrategicTurnTimes( )
{
guiLastStrategicTime = GetWorldTotalSeconds( );
guiLastTacticalRealTime = GetJA2Clock( );
}
void RenderSelectedItemBlownUp()
{
UINT32 uiVideoObjectIndex;
HVOBJECT hVObject;
INT16 sScreenX, sScreenY, xp, yp;
ITEM_POOL *pItemPool;
UINT16 szItemName[ SIZE_ITEM_NAME ];
INT32 i;
INT16 sWidth, sHeight, sOffsetX, sOffsetY;
GetGridNoScreenPos( gsItemGridNo, 0, &sScreenX, &sScreenY );
if( sScreenY > 340 )
return;
//Display the enlarged item graphic
uiVideoObjectIndex = GetInterfaceGraphicForItem( &Item[ gpItem->usItem ] );
GetVideoObject( &hVObject, uiVideoObjectIndex );
sWidth = hVObject->pETRLEObject[ Item[ gpItem->usItem ].ubGraphicNum ].usWidth;
sOffsetX = hVObject->pETRLEObject[ Item[ gpItem->usItem ].ubGraphicNum ].sOffsetX;
xp = sScreenX + (40 - sWidth - sOffsetX*2) / 2;
sHeight = hVObject->pETRLEObject[ Item[ gpItem->usItem ].ubGraphicNum ].usHeight;
sOffsetY = hVObject->pETRLEObject[ Item[ gpItem->usItem ].ubGraphicNum ].sOffsetY;
yp = sScreenY + (20 - sHeight - sOffsetY*2) / 2;
BltVideoObjectOutlineFromIndex( FRAME_BUFFER, uiVideoObjectIndex, Item[ gpItem->usItem ].ubGraphicNum, xp, yp, Get16BPPColor(FROMRGB(0, 140, 170)), TRUE );
//Display the item name above it
SetFont( FONT10ARIAL );
SetFontForeground( FONT_YELLOW );
SetFontShadow( FONT_NEARBLACK );
if( gpItem->usItem == ACTION_ITEM || gpItem->usItem == SWITCH )
{
BuildTriggerName( gpItem, szItemName );
}
else if( Item[ gpItem->usItem ].usItemClass == IC_KEY )
{
swprintf( szItemName, L"%S", LockTable[ gpItem->ubKeyID ].ubEditorName );
}
else
{
LoadItemInfo( gpItem->usItem, szItemName, NULL );
}
xp = sScreenX - (StringPixLength( szItemName, FONT10ARIAL ) - 40) / 2;
yp -= 10;
mprintf( xp, yp, szItemName );
if( gpItem->usItem == ACTION_ITEM )
{
UINT16 *pStr;
pStr = GetActionItemName( gpItem );
xp = sScreenX - (StringPixLength( pStr, FONT10ARIALBOLD ) - 40) / 2;
yp += 10;
SetFont( FONT10ARIALBOLD );
SetFontForeground( FONT_LTKHAKI );
mprintf( xp, yp, pStr );
SetFontForeground( FONT_YELLOW );
}
//Count the number of items in the current pool, and display that.
i = 0;
GetItemPool( gsItemGridNo, &pItemPool, 0 );
Assert( pItemPool );
while( pItemPool )
{
i++;
pItemPool = pItemPool->pNext;
}
xp = sScreenX;
yp = sScreenY + 10;
mprintf( xp, yp, L"%d", i );
//If the item is hidden, render a blinking H (just like DG)
if( gWorldItems[ gpItemPool->iItemIndex ].bVisible == HIDDEN_ITEM ||
gWorldItems[ gpItemPool->iItemIndex ].bVisible == BURIED )
{
SetFont( FONT10ARIALBOLD );
if( GetJA2Clock() % 1000 > 500 )
{
SetFontForeground( 249 );
}
mprintf( sScreenX + 16, sScreenY + 7, L"H" );
InvalidateRegion( sScreenX + 16, sScreenY + 7, sScreenX + 24, sScreenY + 27 );
}
}
void RevealRoofsAndItems(SOLDIERTYPE *pSoldier, UINT32 itemsToo, BOOLEAN fShowLocators, UINT8 ubLevel, BOOLEAN fForce )
{
INT32 maincnt,markercnt,marker,tilesLeftToSee,prevmarker;
UINT8 cnt;
INT32 Inc[6],Dir[6];
INT8 itemVisible = FALSE;
INT8 Blocking,twoMoreTiles,markerDir;
INT8 nextDir=0;
UINT8 who; //,itemIndex; // for each square checked
UINT8 dir,range,Path2;
//DBrot: More Rooms
//UINT8 ubRoomNo;
UINT16 usRoomNo;
BOOLEAN fCheckForRooms = FALSE;
ITEM_POOL *pItemPool;
BOOLEAN fHiddenStructVisible;
UINT8 ubMovementCost;
BOOLEAN fTravelCostObs;
BOOLEAN fGoneThroughDoor = FALSE;
BOOLEAN fThroughWindow = FALSE;
BOOLEAN fItemsQuoteSaid = FALSE;
UINT16 usIndex;
BOOLEAN fRevealItems = TRUE;
BOOLEAN fStopRevealingItemsAfterThisTile = FALSE;
INT8 bTallestStructureHeight;
INT32 iDoorGridNo;
STRUCTURE *pStructure, *pDummy;
INT8 bStructHeight;
INT8 bThroughWindowDirection;
if ( pSoldier->flags.uiStatusFlags & SOLDIER_ENEMY )
{
//pSoldier->needToLookForItems = FALSE;
return;
}
if ( pSoldier->flags.uiStatusFlags & SOLDIER_VEHICLE )
{
return;
}
// Return if this guy has no gridno, has bad life, etc
if(TileIsOutOfBounds(pSoldier->sGridNo) || !pSoldier->bInSector || pSoldier->stats.bLife < OKLIFE )
{
return;
}
if (pSoldier->bBlindedCounter > 0)
{
return;
}
gubGridNoValue++;
if ( gubGridNoValue == 255 )
{
// Reset!
Assert(gubGridNoMarkers);
memset(gubGridNoMarkers, 0, sizeof(UINT8)*WORLD_MAX);
gubGridNoValue = 1;
}
// OK, look for doors
MercLooksForDoors( pSoldier, TRUE );
who = pSoldier->ubID;
dir = pSoldier->ubDirection;
//NumMessage("good old reveal",dir);
// a gassed merc can only see 1 tile away due to blurred vision
if ( pSoldier->flags.uiStatusFlags & SOLDIER_GASSED )
{
range = 1;
}
else
{
range = pSoldier->bViewRange;
// Flugente: adjust sightrange
range = (UINT8)( (range * (100 + pSoldier->GetSightRangeBonus()) ) / 100);
// balance item viewing range between normal and the limit set by opplist-type functions -- CJC
range = (AdjustMaxSightRangeForEnvEffects( pSoldier, LightTrueLevel( pSoldier->sGridNo, pSoldier->pathing.bLevel), range ) + range) / 2;
}
BuildSightDir(dir,(UINT32 *)&Dir[0],(UINT32 *)&Dir[1],(UINT32 *)&Dir[2],(UINT32 *)&Dir[3],(UINT32 *)&Dir[4]);
for (cnt = 0; cnt < 5; cnt++)
Inc[cnt] = DirectionInc( (UINT8) Dir[cnt]);
// create gridno increment for NOVIEW - in other words, no increment!
Inc[5] = 0;
Dir[5] = pSoldier->ubDirection;
if (dir % 2 == 1) /* even numbers use ViewPath2 */
Path2 = TRUE;
else
Path2 = FALSE;
// ATE: if in this special cercumstance... our guys are moving on their own...
// Stop sighting items
// IN the future, we may want to do something else here...
if ( gTacticalStatus.uiFlags & OUR_MERCS_AUTO_MOVE )
{
itemsToo = FALSE;
}
for (maincnt = 0; maincnt < MAXVIEWPATHS; maincnt++)
{
marker = pSoldier->sGridNo;
Blocking = FALSE;
twoMoreTiles = FALSE;
tilesLeftToSee = 99;
fRevealItems = TRUE;
fStopRevealingItemsAfterThisTile = FALSE;
#ifdef _DEBUG
if ( _KeyDown( NUM_LOCK ) )
{
memset( gubFOVDebugInfoInfo, 0, sizeof( gubFOVDebugInfoInfo ) );
SetRenderFlags( RENDER_FLAG_FULL );
RenderWorld( );
}
#endif
for (markercnt = 0; markercnt < range; markercnt++)
{
//fGoneThroughDoor = FALSE;
//fThroughWindow = FALSE;
prevmarker = marker;
nextDir = 99;
fCheckForRooms = FALSE;
fTravelCostObs = FALSE;
if ( fStopRevealingItemsAfterThisTile )
{
fRevealItems = FALSE;
fStopRevealingItemsAfterThisTile = FALSE;
}
if (Path2)
{
markerDir = ViewPath2[maincnt][markercnt];
if (markercnt < 12)
nextDir = ViewPath2[maincnt][markercnt+1];
}
else
{
markerDir = ViewPath[maincnt][markercnt];
if (markercnt < 12)
nextDir = ViewPath[maincnt][markercnt+1];
}
// OK, check flags for going through door/window last tile
if ( fThroughWindow == 1 )
{
// ATE: Make sure we are going through the same direction!
// THis is to solve the drassen SAM problem with seeing through walls
if ( Dir[markerDir] == bThroughWindowDirection)
{
fThroughWindow = 2;
}
else
{
fThroughWindow = 0;
}
}
else if ( fThroughWindow == 2 )
{
// We've overstayed our welcome - remove!
fThroughWindow = 0;
}
if ( fGoneThroughDoor == 1 )
{
fGoneThroughDoor = 2;
}
else if ( fGoneThroughDoor == 2 )
{
// We've overstayed our welcome - remove!
fGoneThroughDoor = 0;
}
//ATE CHECK FOR NOVIEW!
if ( nextDir == NOVIEW )
{
nextDir = 99;
}
marker = NewGridNo(marker,(INT16)Inc[markerDir]);
if ( marker == 12426 )
{
int i = 0;
}
// End if this is a no view...
if ( markerDir == NOVIEW && markercnt != 0 )
{
break;
}
#ifdef _DEBUG
if ( _KeyDown( NUM_LOCK ) )
{
int cnt = GetJA2Clock( );
gubFOVDebugInfoInfo[ marker ] = (UINT8)markercnt;
StartFrameBufferRender();
RenderFOVDebug( );
SetFont( LARGEFONT1 );
SetFontBackground( FONT_MCOLOR_BLACK );
SetFontForeground( FONT_MCOLOR_WHITE );
mprintf( 10, 10 , L"%d", maincnt );
//mprintf( 10, 20 , L"%d", marker );
//mprintf( 50, 20 , L"%d", pSoldier->sGridNo );
InvalidateScreen( );
EndFrameBufferRender();
RefreshScreen( NULL );
do
{
} while( ( GetJA2Clock( ) - cnt ) < 250 );
}
#endif
// Check if we can get to this gridno from our direction in
ubMovementCost = gubWorldMovementCosts[ marker ][ Dir[ markerDir ] ][ ubLevel ];
// ATE: Added: If our current sector is below ground, ignore any blocks!
if ( gfCaves && ubMovementCost != TRAVELCOST_CAVEWALL )
{
ubMovementCost = TRAVELCOST_FLAT;
}
if ( IS_TRAVELCOST_DOOR( ubMovementCost ) )
{
ubMovementCost = DoorTravelCost( pSoldier, marker, ubMovementCost, (BOOLEAN) (pSoldier->bTeam == gbPlayerNum), &iDoorGridNo );
pStructure = FindStructure( iDoorGridNo, STRUCTURE_ANYDOOR );
if ( pStructure != NULL && pStructure->fFlags & STRUCTURE_TRANSPARENT)
{
// cell door or somehow otherwise transparent; allow merc to see through
ubMovementCost = TRAVELCOST_FLAT;
}
}
// If we have hit an obstacle, STOP HERE
if ( ubMovementCost >= TRAVELCOST_BLOCKED )
{
// We have an obstacle here...
// If it is bigger than a breadbox... err... taller than a man...
// Then stop path altogether
// otherwise just stop revealing items
// CJC: only do this when the direction is horizontal; easier and faster to check
// and the effect should still be good enough
if ( ubMovementCost == TRAVELCOST_WALL || ubMovementCost == TRAVELCOST_DOOR || ubMovementCost == TRAVELCOST_EXITGRID )
{
fTravelCostObs = TRUE;
fRevealItems = FALSE;
}
else
{
// walls are handled above, so the blocking object is guaranteed not to be a wall
bTallestStructureHeight = GetTallestStructureHeight( marker, FALSE );
if (bTallestStructureHeight >= 3)
{
fTravelCostObs = TRUE;
fStopRevealingItemsAfterThisTile = TRUE;
}
else if ( bTallestStructureHeight != 0 )
{
// stop revealing items after this tile but keep going
fStopRevealingItemsAfterThisTile = TRUE;
}
}
if ( (Dir[markerDir] % 2) == 1 )
{
// diagonal
fTravelCostObs = TRUE;
// cheap hack... don't reveal items
fRevealItems = FALSE;
}
else
{
bTallestStructureHeight = GetTallestStructureHeight( marker, FALSE );
if (bTallestStructureHeight >= 3)
{
fTravelCostObs = TRUE;
fStopRevealingItemsAfterThisTile = TRUE;
}
else if ( bTallestStructureHeight != 0 )
{
// stop revealing items after this tile but keep going
fStopRevealingItemsAfterThisTile = TRUE;
}
}
}
// Check if it's been done already!
if ( gubGridNoMarkers[ marker ] != gubGridNoValue )
{
// Mark gridno
gubGridNoMarkers[ marker ] = gubGridNoValue;
// check and see if the gridno changed
// if the gridno is the same, avoid redundancy and break
if (marker==prevmarker && markercnt != 0 )
{
}
else // it changed
{
// Skip others if we have gone through a door but are too far away....
if ( fGoneThroughDoor )
{
if (markercnt > 5 ) // Are we near the door?
{
break;
}
}
// DO MINE FINDING STUFF
// GET INDEX FOR ITEM HERE
// if there IS a direction after this one, nextdir WILL NOT be 99
if (nextDir != 99)
{
Blocking = GetBlockingStructureInfo( marker, (INT8)Dir[ markerDir ], (INT8)Dir[ nextDir ], ubLevel, &bStructHeight, &pDummy, FALSE );
}
else // no "next" direction, so pass in a NOWHERE so that
// "SpecialViewObstruction" will know not to take it UINT32o consideration
{
Blocking = GetBlockingStructureInfo( marker, (INT8)Dir[markerDir], (INT8)30, ubLevel, &bStructHeight, &pDummy, FALSE );
}
if ( gfCaves )
{
Blocking = NOTHING_BLOCKING;
}
// CHECK FOR ROOMS
if ( Blocking == BLOCKING_TOPLEFT_WINDOW || Blocking == BLOCKING_TOPLEFT_OPEN_WINDOW )
{
// CHECK FACING DIRECTION!
if ( Dir[markerDir] == NORTH || Dir[markerDir] == SOUTH )
{
if (markercnt <= 1 ) // Are we right beside it?
{
fThroughWindow = TRUE;
bThroughWindowDirection = ( INT8 ) Dir[ markerDir ];
}
}
}
if ( Blocking == BLOCKING_TOPRIGHT_WINDOW || Blocking == BLOCKING_TOPRIGHT_OPEN_WINDOW )
{
// CHECK FACING DIRECTION!
if ( Dir[markerDir] == EAST || Dir[markerDir] == WEST )
{
if (markercnt <= 1 ) // Are we right beside it?
{
fThroughWindow = TRUE;
bThroughWindowDirection = ( INT8 ) Dir[ markerDir ];
}
}
}
if ( Blocking == BLOCKING_TOPLEFT_DOOR )
{
fGoneThroughDoor = TRUE;
}
if ( Blocking == BLOCKING_TOPRIGHT_DOOR )
{
fGoneThroughDoor = TRUE;
}
// ATE: If we hit this tile, find item always!
//if (Blocking < FULL_BLOCKING )
{
// Handle special things for our mercs, like uncovering roofs
// and revealing objects...
//gpSoldier->shad |= SEENBIT;
//itemVisible = ObjList[itemIndex].visible;
// NOTE: don't allow object viewing if gassed XXX
if (itemsToo && fRevealItems ) // && itemIndex < MAXOBJECTLIST)
{
// OK, look for corpses...
LookForAndMayCommentOnSeeingCorpse( pSoldier, marker, ubLevel );
if ( GetItemPool( marker, &pItemPool, ubLevel ) )
{
itemVisible = pItemPool->bVisible;
if ( SetItemPoolVisibilityOn( pItemPool, INVISIBLE, fShowLocators ) )
{
SetRenderFlags(RENDER_FLAG_FULL);
// WANNE: Should we pause when item was found in tactical?
bool enableItemSpottingAction = true;
if ( !is_networked && gGameExternalOptions.fItemSpottedNoTalk && gTacticalStatus.uiFlags & TURNBASED && gTacticalStatus.uiFlags & INCOMBAT)
enableItemSpottingAction = false;
if (enableItemSpottingAction)
{
if ( fShowLocators )
{
// Set makred render flags
//gpWorldLevelData[marker].uiFlags|=MAPELEMENT_REDRAW;
//gpWorldLevelData[gusCurMousePos].pTopmostHead->uiFlags |= LEVELNODE_DYNAMIC;
//SetRenderFlags(RENDER_FLAG_MARKED);
SetRenderFlags(RENDER_FLAG_FULL);
// Hault soldier
// ATE: Only if in combat...
if ( gTacticalStatus.uiFlags & INCOMBAT )
{
pSoldier->HaultSoldierFromSighting( FALSE );
}
else
{
// ATE: Make sure we show locators...
gTacticalStatus.fLockItemLocators = FALSE;
}
if ( !fItemsQuoteSaid && gTacticalStatus.fLockItemLocators == FALSE )
{
gTacticalStatus.fLockItemLocators = TRUE;
if ( gTacticalStatus.ubAttackBusyCount > 0 && ( gTacticalStatus.uiFlags & INCOMBAT ) )
{
gTacticalStatus.fItemsSeenOnAttack = TRUE;
gTacticalStatus.ubItemsSeenOnAttackSoldier = pSoldier->ubID;
gTacticalStatus.usItemsSeenOnAttackGridNo = marker;
}
else
{
// Display quote!
if ( !AM_AN_EPC( pSoldier ) )
{
TacticalCharacterDialogueWithSpecialEvent( pSoldier, (UINT16)( QUOTE_SPOTTED_SOMETHING_ONE + Random( 2 ) ), DIALOGUE_SPECIAL_EVENT_SIGNAL_ITEM_LOCATOR_START, marker, 0 );
}
else
{
// Turn off item lock for locators...
gTacticalStatus.fLockItemLocators = FALSE;
// Slide to location!
SlideToLocation( 0, marker );
}
}
fItemsQuoteSaid = TRUE;
}
}
}
}
}
}
// if blood here, let the user see it now...
//if (ExtGrid[marker].patrolInfo < MAXBLOOD)
// gpSoldier->blood = ExtGrid[marker].patrolInfo;
//DoRoofs(marker,gpSoldier);
tilesLeftToSee--;
}
// CHECK FOR HIDDEN STRUCTS
// IF we had a hidden struct here that is not visible ( which will still be true because
// we set it revealed below...
if ( DoesGridNoContainHiddenStruct( marker, &fHiddenStructVisible ) )
{
if ( !fHiddenStructVisible )
{
gpWorldLevelData[marker].uiFlags|=MAPELEMENT_REDRAW;
SetRenderFlags(RENDER_FLAG_MARKED);
RecompileLocalMovementCosts( marker );
}
}
if (tilesLeftToSee <= 0)
break;
if ( Blocking == FULL_BLOCKING || ( fTravelCostObs && !fThroughWindow ) )
{
break;
}
//if ( Blocking == NOTHING_BLOCKING || Blocking == BLOCKING_NEXT_TILE )
if ( Blocking == NOTHING_BLOCKING )
{
fCheckForRooms = TRUE;
}
if ( ubLevel != 0 )
{
fCheckForRooms = FALSE;
}
// CHECK FOR SLANT ROOF!
{
STRUCTURE *pStructure, *pBase;
pStructure = FindStructure( marker, STRUCTURE_SLANTED_ROOF );
if ( pStructure != NULL )
{
pBase = FindBaseStructure( pStructure );
// ADD TO SLANTED ROOF LIST!
AddSlantRoofFOVSlot( marker );
}
}
// Set gridno as revealed
if ( ubLevel == FIRST_LEVEL )
{
if ( gfBasement || gfCaves )
{
// OK, if we are underground, we don't want to reveal stuff if
// 1 ) there is a roof over us and
// 2 ) we are not in a room
if ( gusWorldRoomInfo[ marker ] == NO_ROOM && TypeRangeExistsInRoofLayer( marker, FIRSTROOF, FOURTHROOF, &usIndex ) )
{
int i = 0;
}
else
{
gpWorldLevelData[ marker ].uiFlags |= MAPELEMENT_REVEALED;
if( gfCaves )
{
RemoveFogFromGridNo( marker );
}
}
}
else
{
gpWorldLevelData[ marker ].uiFlags |= MAPELEMENT_REVEALED;
}
// CHECK FOR ROOMS
//if ( fCheckForRooms )
{
if ( InAHiddenRoom( marker, &usRoomNo ) )
{
RemoveRoomRoof( marker, usRoomNo, pSoldier );
if ( usRoomNo == ROOM_SURROUNDING_BOXING_RING && gWorldSectorX == BOXING_SECTOR_X && gWorldSectorY == BOXING_SECTOR_Y && gbWorldSectorZ == BOXING_SECTOR_Z )
{
// reveal boxing ring at same time
RemoveRoomRoof( marker, BOXING_RING, pSoldier );
}
}
}
}
else
{
gpWorldLevelData[ marker ].uiFlags |= MAPELEMENT_REVEALED_ROOF;
}
// Check for blood....
UpdateBloodGraphics( marker, ubLevel );
if ( Blocking != NOTHING_BLOCKING && Blocking != BLOCKING_TOPLEFT_DOOR && Blocking != BLOCKING_TOPRIGHT_DOOR && Blocking != BLOCKING_TOPLEFT_WINDOW && Blocking != BLOCKING_TOPRIGHT_WINDOW && Blocking != BLOCKING_TOPRIGHT_OPEN_WINDOW && Blocking != BLOCKING_TOPLEFT_OPEN_WINDOW)
{
break;
}
//gpWorldLevelData[ marker ].uiFlags |= MAPELEMENT_SHADELAND;
}
} // End of duplicate check
else
{
if ( fTravelCostObs )
{
break;
}
}
} // end of one path
} // end of path loop
// Loop through all availible slant roofs we collected and perform cool stuff on them
ExamineSlantRoofFOVSlots( );
//pSoldier->needToLookForItems = FALSE;
//LookForDoors(pSoldier,UNAWARE);
}
UINT32 FadeScreenHandle( )
{
UINT32 uiTime;
if ( !gfFadeInitialized )
{
SET_ERROR( "Fade Screen called but not intialized " );
return( ERROR_SCREEN );
}
// ATE: Remove cursor
SetCurrentCursorFromDatabase( VIDEO_NO_CURSOR );
if ( gfFirstTimeInFade )
{
gfFirstTimeInFade = FALSE;
// Calcuate delay
guiTime = GetJA2Clock( );
}
// Get time
uiTime = GetJA2Clock( );
MusicPoll( TRUE );
if ( ( uiTime - guiTime ) > guiFadeDelay )
{
// Fade!
if ( !gfFadeIn )
{
//gFadeFunction( );
}
InvalidateScreen();
if ( !gfFadeInVideo )
{
gFadeFunction( );
}
gsFadeCount++;
if ( gsFadeCount > gsFadeLimit )
{
switch( gbFadeType )
{
case FADE_OUT_REALFADE:
// Clear framebuffer
ColorFillVideoSurfaceArea( FRAME_BUFFER, 0, 0, 640, 480, Get16BPPColor( FROMRGB( 0, 0, 0 ) ) );
break;
}
//End!
gfFadeInitialized = FALSE;
gfFadeIn = FALSE;
return( guiExitScreen );
}
}
return( FADE_SCREEN );
}
void BtnMessageUpMapScreenCallback( GUI_BUTTON *btn,INT32 reason )
{
static INT32 iLastRepeatScrollTime = 0;
if(reason & MSYS_CALLBACK_REASON_LBUTTON_DWN )
{
if( IsMapScreenHelpTextUp() )
{
// stop mapscreen text
StopMapScreenHelpText( );
return;
}
btn->uiFlags|=(BUTTON_CLICKED_ON);
// redraw region
if( btn->Area.uiFlags & MSYS_HAS_BACKRECT )
{
fMapScreenBottomDirty = TRUE;
}
iLastRepeatScrollTime = 0;
}
else if(reason & MSYS_CALLBACK_REASON_LBUTTON_UP )
{
if (btn->uiFlags & BUTTON_CLICKED_ON)
{
btn->uiFlags&=~(BUTTON_CLICKED_ON);
// redraw region
if( btn ->uiFlags & MSYS_HAS_BACKRECT )
{
fMapScreenBottomDirty = TRUE;
}
// up a line
MapScreenMsgScrollUp( 1 );
}
}
else if( reason & MSYS_CALLBACK_REASON_LBUTTON_REPEAT )
{
if( GetJA2Clock() - iLastRepeatScrollTime >= MESSAGE_BTN_SCROLL_TIME )
{
// up a line
MapScreenMsgScrollUp( 1 );
iLastRepeatScrollTime = GetJA2Clock( );
}
}
else if( reason & MSYS_CALLBACK_REASON_RBUTTON_DWN )
{
if( IsMapScreenHelpTextUp() )
{
// stop mapscreen text
StopMapScreenHelpText( );
return;
}
// redraw region
if( btn ->uiFlags & MSYS_HAS_BACKRECT )
{
fMapScreenBottomDirty = TRUE;
}
btn->uiFlags|=(BUTTON_CLICKED_ON);
iLastRepeatScrollTime = 0;
}
else if(reason & MSYS_CALLBACK_REASON_RBUTTON_UP )
{
if (btn->uiFlags & BUTTON_CLICKED_ON)
{
btn->uiFlags&=~(BUTTON_CLICKED_ON);
// redraw region
if( btn ->uiFlags & MSYS_HAS_BACKRECT )
{
fMapScreenBottomDirty = TRUE;
}
// up a page
MapScreenMsgScrollUp( MAX_MESSAGES_ON_MAP_BOTTOM );
}
}
else if( reason & MSYS_CALLBACK_REASON_RBUTTON_REPEAT )
{
if( GetJA2Clock() - iLastRepeatScrollTime >= MESSAGE_BTN_SCROLL_TIME )
{
// up a page
MapScreenMsgScrollUp( MAX_MESSAGES_ON_MAP_BOTTOM );
iLastRepeatScrollTime = GetJA2Clock( );
}
}
}
void BtnMessageDownChatLogCallback( GUI_BUTTON *btn,INT32 reason )
{
static INT32 iLastRepeatScrollTime = 0;
if( reason & MSYS_CALLBACK_REASON_LBUTTON_DWN )
{
// redraw region
if( btn->uiFlags & MSYS_HAS_BACKRECT )
{
gChatBox.fRenderBox = TRUE;
}
btn->uiFlags|=(BUTTON_CLICKED_ON);
iLastRepeatScrollTime = 0;
}
else if(reason & MSYS_CALLBACK_REASON_LBUTTON_UP )
{
if (btn->uiFlags & BUTTON_CLICKED_ON)
{
btn->uiFlags&=~(BUTTON_CLICKED_ON);
// redraw region
if( btn->uiFlags & MSYS_HAS_BACKRECT )
{
gChatBox.fRenderBox = TRUE;
}
// down a line
ChatScreenMsgScrollDown( 1 );
}
}
else if( reason & MSYS_CALLBACK_REASON_LBUTTON_REPEAT )
{
if( GetJA2Clock() - iLastRepeatScrollTime >= CHATLOG_BTN_SCROLL_TIME )
{
// down a line
ChatScreenMsgScrollDown( 1 );
iLastRepeatScrollTime = GetJA2Clock( );
}
}
else if( reason & MSYS_CALLBACK_REASON_RBUTTON_DWN )
{
// redraw region
if( btn->uiFlags & MSYS_HAS_BACKRECT )
{
gChatBox.fRenderBox = TRUE;
}
btn->uiFlags|=(BUTTON_CLICKED_ON);
iLastRepeatScrollTime = 0;
}
else if(reason & MSYS_CALLBACK_REASON_RBUTTON_UP )
{
if (btn->uiFlags & BUTTON_CLICKED_ON)
{
btn->uiFlags&=~(BUTTON_CLICKED_ON);
// redraw region
if( btn->uiFlags & MSYS_HAS_BACKRECT )
{
gChatBox.fRenderBox = TRUE;
}
// down a page
ChatScreenMsgScrollDown( MAX_CHATLOG_MESSAGES );
}
}
else if( reason & MSYS_CALLBACK_REASON_RBUTTON_REPEAT )
{
if( GetJA2Clock() - iLastRepeatScrollTime >= CHATLOG_BTN_SCROLL_TIME )
{
// down a page
ChatScreenMsgScrollDown( MAX_CHATLOG_MESSAGES );
iLastRepeatScrollTime = GetJA2Clock( );
}
}
}
BOOLEAN EnterCreditsScreen()
{
UINT32 uiCnt;
VOBJECT_DESC VObjectDesc;
gfModCredits = TRUE;
ColorFillVideoSurfaceArea( FRAME_BUFFER, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0 );
VObjectDesc.fCreateFlags=VOBJECT_CREATE_FROMFILE;
if (iResolution >= _640x480 && iResolution < _800x600)
{
FilenameForBPP("INTERFACE\\Credits.sti", VObjectDesc.ImageFile);
}
else if (iResolution < _1024x768)
{
FilenameForBPP("INTERFACE\\Credits_800x600.sti", VObjectDesc.ImageFile);
}
else
{
FilenameForBPP("INTERFACE\\Credits_1024x768.sti", VObjectDesc.ImageFile);
}
CHECKF(AddVideoObject(&VObjectDesc, &guiCreditBackGroundImage ));
VObjectDesc.fCreateFlags=VOBJECT_CREATE_FROMFILE;
FilenameForBPP("INTERFACE\\Credit Faces.sti", VObjectDesc.ImageFile);
CHECKF(AddVideoObject(&VObjectDesc, &guiCreditFaces ));
//Initialize the root credit node
InitCreditNode( );
guiCreditsExitScreen = CREDIT_SCREEN;
gfCrdtHaveRenderedFirstFrameToSaveBuffer = FALSE;
guiCreditScreenActiveFont = FONT12ARIAL;
gubCreditScreenActiveColor = FONT_MCOLOR_DKWHITE;
guiCreditScreenTitleFont = FONT14ARIAL;
gubCreditScreenTitleColor = FONT_MCOLOR_RED;
guiCrdtNodeScrollSpeed = CRDT_NODE_DELAY_AMOUNT;
gubCrdtJustification = CENTER_JUSTIFIED;
guiCurrentCreditRecord = 0;
guiCrdtLastTimeUpdatingNode = GetJA2Clock();
guiGapBetweenCreditSections = CRDT_SPACE_BN_SECTIONS;
guiGapBetweenCreditNodes = CRDT_SPACE_BN_NODES;
guiGapTillReadNextCredit = CRDT_SPACE_BN_NODES;
for( uiCnt=0; uiCnt < NUM_PEOPLE_IN_CREDITS; uiCnt++)
{
// Make a mouse region
MSYS_DefineRegion( &gCrdtMouseRegions[uiCnt], gCreditFaces[uiCnt].sX + xResOffset, gCreditFaces[uiCnt].sY + yResOffset, (INT16)(gCreditFaces[uiCnt].sX + gCreditFaces[uiCnt].sWidth + xResOffset), (INT16)(gCreditFaces[uiCnt].sY + gCreditFaces[uiCnt].sHeight + yResOffset), MSYS_PRIORITY_NORMAL,
CURSOR_WWW, SelectCreditFaceMovementRegionCallBack, SelectCreditFaceRegionCallBack );
// Add region
MSYS_AddRegion( &gCrdtMouseRegions[uiCnt] );
MSYS_SetRegionUserData( &gCrdtMouseRegions[uiCnt], 0, uiCnt );
}
giCurrentlySelectedFace = -1;
gfPauseCreditScreen = FALSE;
InitCreditEyeBlinking();
return( TRUE );
}
UINT32 MainMenuScreenHandle( )
{
UINT32 cnt;
UINT32 uiTime;
if( guiSplashStartTime + 4000 > GetJA2Clock() )
{
SetCurrentCursorFromDatabase( VIDEO_NO_CURSOR );
SetMusicMode( MUSIC_NONE );
return MAINMENU_SCREEN; //The splash screen hasn't been up long enough yet.
}
if( guiSplashFrameFade )
{
uiTime = GetJA2Clock();
if( guiSplashFrameFade > 2 )
ShadowVideoSurfaceRectUsingLowPercentTable( FRAME_BUFFER, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT );
else if( guiSplashFrameFade > 1 )
ColorFillVideoSurfaceArea( FRAME_BUFFER, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0 );
else
{
uiTime = GetJA2Clock();
SetMusicMode( MUSIC_MAIN_MENU );
}
guiSplashFrameFade--;
InvalidateScreen();
EndFrameBufferRender();
SetCurrentCursorFromDatabase( VIDEO_NO_CURSOR );
return MAINMENU_SCREEN;
}
SetCurrentCursorFromDatabase( CURSOR_NORMAL );
if( gfMainMenuScreenEntry )
{
InitMainMenu( );
gfMainMenuScreenEntry = FALSE;
gfMainMenuScreenExit = FALSE;
guiMainMenuExitScreen = MAINMENU_SCREEN;
SetMusicMode( MUSIC_MAIN_MENU );
}
if ( fInitialRender )
{
ClearMainMenu();
RenderMainMenu();
fInitialRender = FALSE;
}
RestoreButtonBackGrounds();
// Render buttons
for ( cnt = 0; cnt < NUM_MENU_ITEMS; cnt++ )
{
MarkAButtonDirty( iMenuButtons[ cnt ] );
}
RenderButtons( );
EndFrameBufferRender( );
HandleMainMenuInput();
HandleMainMenuScreen();
if( gfMainMenuScreenExit )
{
ExitMainMenu( );
gfMainMenuScreenExit = FALSE;
gfMainMenuScreenEntry = TRUE;
}
if( guiMainMenuExitScreen != MAINMENU_SCREEN )
gfMainMenuScreenEntry = TRUE;
return( guiMainMenuExitScreen );
}
BOOLEAN DequeAllGameEvents( BOOLEAN fExecute )
{
EVENT *pEvent;
UINT32 uiQueueSize, cnt;
BOOLEAN fCompleteLoop = FALSE;
// First dequeue all primary events
while( EventQueueSize( PRIMARY_EVENT_QUEUE ) > 0 )
{
// Get Event
if ( RemoveEvent( &pEvent, 0, PRIMARY_EVENT_QUEUE) == FALSE )
{
return( FALSE );
}
if ( fExecute )
{
// Check if event has a delay and add to secondary queue if so
if ( pEvent->usDelay > 0 )
{
AddGameEventToQueue( pEvent->uiEvent, pEvent->usDelay, pEvent->pData, SECONDARY_EVENT_QUEUE );
}
else
{
ExecuteGameEvent( pEvent );
}
}
// Delete event
FreeEvent( pEvent );
};
// NOW CHECK SECONDARY QUEUE FOR ANY EXPRIED EVENTS
// Get size of queue
uiQueueSize = EventQueueSize( SECONDARY_EVENT_QUEUE );
for ( cnt = 0; cnt < uiQueueSize; cnt++ )
{
if ( PeekEvent( &pEvent, cnt, SECONDARY_EVENT_QUEUE) == FALSE )
{
return( FALSE );
}
// Check time
if ( ( GetJA2Clock() - pEvent->TimeStamp ) > pEvent->usDelay )
{
if ( fExecute )
{
ExecuteGameEvent( pEvent );
}
// FLag as expired
pEvent->uiFlags = EVENT_EXPIRED;
}
}
do
{
uiQueueSize = EventQueueSize( SECONDARY_EVENT_QUEUE );
for ( cnt = 0; cnt < uiQueueSize; cnt++ )
{
if ( PeekEvent( &pEvent, cnt, SECONDARY_EVENT_QUEUE) == FALSE )
{
return( FALSE );
}
// Check time
if ( pEvent->uiFlags & EVENT_EXPIRED )
{
RemoveEvent( &pEvent, cnt, SECONDARY_EVENT_QUEUE );
FreeEvent( pEvent );
// Restart loop
break;
}
}
if ( cnt == uiQueueSize )
{
fCompleteLoop = TRUE;
}
} while( fCompleteLoop == FALSE );
return( TRUE );
}
