void PlayerControl( int player )
{
int a = player, b = player;
bool moved = false;
if( players == 1 )
{
a = 0;
b = 1;
}
if( hitKey[a].left || hitKey[b].left )
{
if( GameTickCount() >= timeMove[player] )
{
timeMove[player] += 12;
if( CanGoLeft( player ) )
GoLeft( player );
}
moved = true;
}
if( hitKey[a].right || hitKey[b].right )
{
if( GameTickCount() >= timeMove[player] )
{
timeMove[player] += 12;
if( CanGoRight( player ) )
GoRight( player );
}
moved = true;
}
if( !moved ) timeMove[player] = GameTickCount( );
if( hitKey[a].rotate == 1 || hitKey[b].rotate == 1 )
{
if( CanRotate( player ) )
DoRotate( player );
}
if( hitKey[a].drop == 1 || hitKey[b].drop == 1 )
{
DoDrop( player );
}
if( hitKey[a].drop == 0 && hitKey[b].drop == 0 )
{
StopDrop( player );
}
}
void OpponentChatter( MBoolean on )
{
switch( on )
{
case true:
opponentMood = 5;
opponentTime = GameTickCount();
break;
case false:
opponentMood = 0;
opponentTime = GameTickCount();
break;
}
}
void DoDrop( int player )
{
dropping[player] = true;
if( role[player] != kJiggleBlobs &&
role[player] != kFastJiggleBlobs &&
role[player] != kLockdownBlobs )
blobTime[player] = GameTickCount( );
}
void UpdateTweak( int player, int animation )
{
MBoolean isXTweaked, isYTweaked, isRTweaked, isAnimTweaked = false;
if( GameTickCount( ) >= animTime[player] )
{
isAnimTweaked = true;
animTime[player] += 2;
anim[player]++;
HandleMagic( player );
}
isXTweaked = ( (GameTickCount() >= xTweakTime[player]) && (xTweak[player] > 0) );
isYTweaked = ( (GameTickCount() >= yTweakTime[player]) && (yTweak[player] > 0) );
isRTweaked = ( (GameTickCount() >= rTweakTime[player]) && (rTweak[player] > 0) );
if( isXTweaked || isRTweaked || isYTweaked ||
isAnimTweaked || (shadowDepth[player] != lastShadow[player]) )
{
EraseSpriteBlobs( player );
if( isXTweaked )
{
xTweak[player]--;
xTweakTime[player] += kTweakDelay;
}
if( isYTweaked )
{
yTweak[player]--;
yTweakTime[player] += kTweakDelay;
}
if( isRTweaked )
{
rTweak[player]--;
rTweakTime[player] += kTweakDelay;
}
DrawSpriteBlobs( player, animation );
}
}
void StartTweak( int player, int direction, int rotate, int fall )
{
if( fall != 0 )
{
yTweak[player] = 3;
yTweakTime[player] = GameTickCount() + kTweakDelay;
}
if( direction != 0 )
{
xDirection[player] = direction;
xTweak[player] = 5;
xTweakTime[player] = GameTickCount() + kTweakDelay;
}
if( rotate != 0 )
{
rTweak[player] = rotate * 5;
rDirection[player] = rotate;
rTweakTime[player] = GameTickCount() + kTweakDelay;
}
}
void UpdateBalloon( void )
{
SDL_Rect balloonSDLRect;
if( control[0] != kAutoControl ) return;
if( GameTickCount() < balloonTime ) return;
if( balloonChar )
{
char in = *balloonChar++;
switch( in )
{
case 0:
OpponentChatter( false );
balloonChar = NULL;
balloonTime += 120;
break;
case '\n':
balloonPt.h = balloonRect.left + 10;
balloonPt.v += 20;
break;
default:
if( balloonFont->width[in] > 0 )
{
SDLU_AcquireSurface( balloonSurface );
SurfaceBlitCharacter( balloonFont, in, &balloonPt, 0, 0, 0, 0 );
SDLU_ReleaseSurface( balloonSurface );
SDLU_MRectToSDLRect( &balloonRect, &balloonSDLRect );
SDLU_BlitFrontSurface( balloonSurface, &balloonSDLRect, &balloonSDLRect );
balloonTime += 2;
}
break;
}
}
else
{
SDLU_MRectToSDLRect( &balloonRect, &balloonSDLRect );
SDLU_BlitFrontSurface( backdropSurface, &balloonSDLRect, &balloonSDLRect );
StopBalloon();
}
}
void BeginOpponent( int which )
{
int count;
DrawPICTInSurface( opponentSurface, 5000 + which );
DrawPICTInSurface( opponentMaskSurface, 5100 + which );
opponentTime = panicTime = GameTickCount( );
for( count=0; count<kGlows; count++ )
{
glowTime[count] = panicTime;
glowFrame[count] = 0;
}
opponentMood = 0;
emotions[0] = emotions[1] = kEmotionNeutral;
}
void AIControl( int player )
{
if( timeAI[player] > GameTickCount() )
return;
timeAI[player] += moveQuick[player]? character[player].speedRush:
character[player].speedNormal;
switch( RandomBefore( 2 ) )
{
case 0:
if( destinationR[player] != blobR[player] )
{
if( CanRotate(player) )
{
DoRotate( player );
}
}
break;
case 1:
if( destinationX[player] != blobX[player] )
{
if( destinationX[player] > blobX[player] )
{
if( CanGoRight( player ) )
GoRight( player );
}
else
{
if( CanGoLeft( player ) )
GoLeft( player );
}
}
break;
}
if( destinationX[player] == blobX[player] &&
destinationR[player] == blobR[player] &&
RandomBefore( 100 ) < character[player].intellect )
{
DoDrop( player );
}
}
void StartBalloon( const char *message )
{
MPoint balloonTip, balloonFill;
int replace;
const char* match[] = { "~~", "||", "``", "{{" };
char* search;
SDL_Rect balloonSDLRect, balloonContentsSDLRect;
MRect balloonContentsRect;
strcpy( balloonMsg, message );
for( replace=0; replace<4; replace++ )
{
search = strstr( balloonMsg, match[replace] );
if( search )
{
char temp[256];
search[0] = '%';
search[1] = 's';
sprintf( temp, balloonMsg, SDL_GetKeyName( playerKeys[1][replace] ) );
strcpy( balloonMsg, temp );
}
}
// Erase previous balloons
SDLU_MRectToSDLRect( &balloonRect, &balloonSDLRect );
SDLU_BlitFrontSurface( backdropSurface, &balloonSDLRect, &balloonSDLRect );
// Draw empty balloon outline
SDLU_AcquireSurface( balloonSurface );
balloonRect.left = balloonRect.right - 25 - CalculateBalloonWidth ( balloonMsg );
balloonRect.top = balloonRect.bottom - 25 - CalculateBalloonHeight( balloonMsg );
SDLU_MRectToSDLRect( &balloonRect, &balloonSDLRect );
SDLU_BlitSurface( backdropSurface, &balloonSDLRect,
balloonSurface, &balloonSDLRect );
balloonContentsRect = balloonRect;
balloonContentsRect.bottom -= 25;
SurfaceGetEdges( balloonSurface, &balloonContentsRect );
SDL_FillRect( balloonSurface,
SDLU_MRectToSDLRect( &balloonContentsRect, &balloonContentsSDLRect ),
SDL_MapRGB( balloonSurface->format, 0xFF, 0xFF, 0xFF ) );
SurfaceCurveEdges( balloonSurface, &balloonContentsRect );
balloonTip.v = balloonContentsRect.bottom - 2;
balloonTip.h = balloonContentsRect.right - 40;
balloonFill = balloonTip;
SurfaceBlitCharacter( balloonFont, '\x01', &balloonFill, 0, 0, 0, 0 );
SurfaceBlitCharacter( balloonFont, '\x02', &balloonTip, 31, 31, 31, 0 );
SDLU_ReleaseSurface( balloonSurface );
// Blit empty balloon to screen
SDLU_MRectToSDLRect( &balloonRect, &balloonSDLRect );
SDLU_BlitFrontSurface( balloonSurface, &balloonSDLRect, &balloonSDLRect );
balloonPt.h = balloonRect.left + 10;
balloonPt.v = balloonRect.top + 10;
balloonChar = balloonMsg;
balloonTime = GameTickCount( );
OpponentChatter( true );
}
void ChooseAIDestination( int player )
{
int testX, testR, testX2, testR2, value, bestValue = -9999999;
int x, y;
int bestX[kGridAcross*4], bestR[kGridAcross*4], currentBest = -1;
int rowDifference, totalTries, temp;
bool shouldTry[kGridAcross][4];
timeAI[player] = GameTickCount( ) + 1;
moveQuick[player] = true;
if( grenade[player] )
{
bestValue = 0;
currentBest = 2;
for( testX = 0; testX < kGridAcross; testX++ )
{
rowDifference = GetRowHeight( player, testX );
if( (rowDifference < kGridDown) &&
(grid[player][testX][rowDifference+1] >= kFirstBlob) &&
(grid[player][testX][rowDifference+1] <= kLastBlob) )
{
value = 0;
for( x=0; x<kGridAcross; x++ )
{
for( y=0; y<kGridDown; y++ )
{
if( grid[player][x][y] == grid[player][testX][rowDifference+1] ) value++;
}
}
if( value > bestValue )
{
bestValue = value;
currentBest = testX;
}
}
}
destinationR[player] = upRotate;
destinationX[player] = currentBest;
return;
}
if( (GameTickCount() - startTime) <= 3600 )
{
for( testX = 0; testX < kGridAcross; testX++ )
{
rowDifference = GetRowHeight( player, testX ) - character[player].autoSetup[testX];
if( rowDifference >= 2 )
{
destinationR[player] = downRotate;
destinationX[player] = testX;
return;
}
if( rowDifference == 1 )
{
destinationX[player] = testX;
if( testX > 0 )
{
if( GetRowHeight( player, testX-1 ) > character[player].autoSetup[testX-1] )
{
destinationR[player] = leftRotate;
return;
}
}
if( testX < (kGridAcross-1) )
{
if( GetRowHeight( player, testX+1 ) > character[player].autoSetup[testX+1] )
{
destinationR[player] = rightRotate;
return;
}
}
destinationR[player] = upRotate;
return;
}
}
}
moveQuick[player] = (emotions[player] == kEmotionSad) || (emotions[player] == kEmotionPanic);
totalTries = character[player].intellect;
for( testX = 0; testX < kGridAcross; testX++ )
{
for( testR = 0; testR < 4; testR++ )
{
shouldTry[testX][testR] = --totalTries >= 0;
}
}
for( testX = 0; testX < kGridAcross; testX++ )
{
for( testR = 0; testR < 4; testR++ )
{
testX2 = RandomBefore( kGridAcross );
testR2 = RandomBefore( 4 );
temp = shouldTry[testX][testR];
shouldTry[testX][testR] = shouldTry[testX2][testR2];
shouldTry[testX2][testR2] = temp;
}
}
shouldTry[0][leftRotate] = false;
shouldTry[kGridAcross-1][rightRotate] = false;
for( testX = 0; testX < kGridAcross; testX++ )
{
for( testR = 0; testR<=3; testR++ )
{
if( shouldTry[testX][testR] )
{
value = TestAIDestination( player, testX, testR );
if( value > bestValue )
{
bestValue = value;
currentBest = -1;
}
if( value == bestValue )
{
currentBest++;
bestX[currentBest] = testX;
bestR[currentBest] = testR;
}
}
}
}
currentBest = RandomBefore( currentBest + 1 );
destinationX[player] = bestX[currentBest];
destinationR[player] = bestR[currentBest];
}
void AutoControl( int player )
{
if( autoPattern )
{
switch( autoPattern->command )
{
case kMessage:
StartBalloon( autoPattern->message );
autoPattern++;
break;
case kIdleTicks:
if( !tutorialTime )
{
tutorialTime = GameTickCount() + autoPattern->d1;
}
else
{
if( GameTickCount() >= tutorialTime )
{
tutorialTime = 0;
autoPattern++;
}
}
break;
case kRetrieve:
if( role[player] == kWaitForRetrieval )
{
nextA[player] = abs( autoPattern->d1 );
nextB[player] = abs( autoPattern->d2 );
nextM[player] = (autoPattern->d1 < 0);
nextG[player] = (autoPattern->d1 == kBombBottom) && (autoPattern->d2 == kBombTop);
if( !nextG[player] )
{
nextA[player] = pieceMap[ nextA[player] ];
nextB[player] = pieceMap[ nextB[player] ];
}
role[player] = kRetrieveBlobs;
autoPattern++;
}
break;
case kPosition:
if( (role[player] != kFalling) || (blobX[player] == autoPattern->d1) )
{
autoPattern++;
}
else if( GameTickCount() >= timeMove[player] )
{
timeMove[player] = GameTickCount() + 12;
if( blobX[player] > autoPattern->d1 )
{
if( CanGoLeft( player ) )
GoLeft( player );
}
else
{
if( CanGoRight( player ) )
GoRight( player );
}
}
break;
case kSpin:
if( role[player] != kFalling )
{
autoPattern++;
}
else if( CanRotate( player ) )
{
DoRotate( player );
autoPattern++;
}
break;
case kBlockUntilLand:
if( role[player] != kFalling )
{
autoPattern++;
}
break;
case kBlockUntilDrop:
if( !dropping[player] ) DoDrop( player );
if( role[player] != kFalling )
{
autoPattern++;
}
break;
case kPunish:
if( role[player] == kWaitForRetrieval )
{
lockGrays[player] = autoPattern->d1;
SetupGrays( player );
blobTime[player] = GameTickCount( );
role[player] = kDropGrays;
autoPattern++;
}
break;
case kComplete:
EndTutorial( );
break;
case kBlockUntilComplete:
if( role[player] == kWaitForRetrieval )
{
autoPattern++;
}
break;
}
}
}
void DoRotate( int player )
{
MBoolean possible;
EraseSpriteBlobs( player );
blobR[player] = ( blobR[player] + 1 ) % 4;
possible = CanMoveDirection( player, 0, halfway[player]? 1: 0 );
StartTweak( player, 0, 1, 0 ); // only rotates clockwise
if( !possible )
{
if( blobR[player] == downRotate )
{
if( halfway[player] )
halfway[player] = false;
else
blobY[player]--;
if( ++blobSpin[player] >= 4 )
{
blobTime[player] = animTime[player] = GameTickCount( );
role[player] = kLockdownBlobs;
anim[player] = 0;
PlayStereoFrequency( player, kPlace, player );
}
}
if( blobR[player] == leftRotate )
{
if( CanGoRight(player) )
GoRight( player );
else
{
blobR[player]++;
StartTweak( player, 0, 2, 0 );
}
}
if( blobR[player] == rightRotate )
{
if( CanGoLeft(player) )
GoLeft( player );
else
{
blobR[player]++;
StartTweak( player, 0, 2, 0 );
if( !CanMoveDirection( player, 0, halfway[player]? 1: 0 ) )
{
if( halfway[player] )
halfway[player] = false;
else
blobY[player]--;
if( ++blobSpin[player] >= 4 )
{
blobTime[player] = animTime[player] = GameTickCount( );
role[player] = kLockdownBlobs;
anim[player] = 0;
PlayStereoFrequency( player, kPlace, player );
}
}
}
}
}
DrawSpriteBlobs( player, kNoSuction );
PlayStereo( player, kRotate );
}
void ZapBlobs( int player )
{
int x, y, cluster, clusterCount = 0, multiplier, amount = 0;
int zapFocusX = -1, zapFocusY = -1, zapFocusC = 0;
zapScorePt[player].y = 0;
zapScoreFrame[player] = 0;
switch( chain[player] )
{
case 1: multiplier = 1; break;
default: multiplier = 2 << chain[player]; break;
}
for( y=kGridDown-1; y>=0; y-- )
{
for( x=kGridAcross-1; x>=0; x-- )
{
if( grid[player][x][y] >= kFirstBlob &&
grid[player][x][y] <= kLastBlob &&
suction[player][x][y] != kInDeath )
{
cluster = SizeUp( grid[player], x, y, grid[player][x][y] );
if( cluster >= kBlobClusterSize )
{
clusterCount++;
zapFocusX = x;
zapFocusY = y;
zapFocusC = grid[player][x][y];
amount += cluster * 10;
multiplier += cluster - kBlobClusterSize;
RemoveBlobs( player, x, y, grid[player][x][y], 0 );
}
}
}
}
if( clusterCount > 0 )
{
switch( clusterCount )
{
case 1: break;
case 2: multiplier += 3; break;
case 3: multiplier += 6; break;
case 4: multiplier += 12; break;
default: multiplier += 24; break;
}
if( multiplier > 999 ) multiplier = 999;
CalculateGrays( 1-player, amount * multiplier / difficulty[player] );
potentialCombo[player].value += amount * multiplier;
if( players == 1 ) amount *= ((level <= kLevels)? level: 1);
score[player] += amount * multiplier;
ZapScoreDisplay( player, amount, multiplier, zapFocusX, zapFocusY, zapFocusC );
}
blobTime[player] = GameTickCount( );
if( clusterCount > 0 )
{
chain[player]++;
role[player] = kKillBlobs;
PlayStereoFrequency( player, kSquishy, zapIteration[player]++ );
}
else
{
if( control[player] == kPlayerControl )
{
SubmitCombo( &potentialCombo[player] );
}
SetupGrays( player );
role[player] = kDropGrays;
if( BusyDroppingGrays( player ) )
{
PlayStereoFrequency( player, kWhistle, player );
}
}
}
void KillBlobs( int player )
{
int x,y;
const int position[] = { 0, 15, 27, 39, 51, 63, 72, 81, 90, 99,105,
111,117,123,126,129,131,132,133,134,135,135,
136,136,137,137,138,138,138,139,139,139,139,
140,140,140 },
shading [] = {20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,
31, 30, 29, 28, 26, 24, 21, 18, 15, 12, 9,
6, 3, 0 },
blobGraphic[kZapFrames] = { kDying, kDying, kDying, kDying, kSquish1,
kSquish1, kSquish1, kSquish1, kSquish2, kSquish2,
kSquish2, kSquish2, kSquish3, kSquish3, kSquish3,
kSquish3, kSquish4, kSquish4, kSquish4, kSquish4 },
grayGraphic[kZapFrames] = { kGrayBlink1, kGrayBlink1, kGrayBlink1,
kGrayBlink1, kGrayBlink1, kGrayBlink1,
kGrayBlink2, kGrayBlink2, kGrayBlink2,
kGrayBlink2, kGrayBlink2, kGrayBlink2,
kGrayBlink3, kGrayBlink3, kGrayBlink3,
kGrayBlink3, kGrayBlink3, kGrayBlink3,
kGrayBlink3, kGrayBlink3 };
SDL_Rect myRect;
bool busy = false;
SDLU_Point dPoint, oPoint;
char *scan;
if( blobTime[player] > GameTickCount( ) )
return;
blobTime[player]++;
SDLU_AcquireSurface( playerSurface[player] );
// clear grenade sprite
if( grenadeFrame[player] <= kBlastFrames )
{
CleanSpriteArea( player, &grenadeRect[player] );
if( grenadeFrame[player] == kBlastFrames ) grenadeFrame[player]++;
}
for( x=0; x<kGridAcross; x++ )
{
for( y=0; y<kGridDown; y++ )
{
if( grid[player][x][y] >= kFirstBlob && // if a blob is dying
grid[player][x][y] <= kLastBlob &&
suction[player][x][y] == kInDeath )
{
death[player][x][y]++;
busy = true;
CalcBlobRect( x, y, &myRect );
if( death[player][x][y] >= 0 && death[player][x][y] <= kZapFrames ) // draw its death
{
if( death[player][x][y] == kZapFrames )
{
grid[player][x][y] = kEmpty;
suction[player][x][y] = kNoSuction;
charred[player][x][y] = kNoCharring;
SurfaceDrawBlob( player, &myRect, kEmpty, kNoSuction, kNoCharring );
CleanSpriteArea( player, &myRect );
}
else
{
SurfaceDrawBlob( player, &myRect,
grid[player][x][y],
blobGraphic[ death[player][x][y] ],
kNoCharring );
CleanSpriteArea( player, &myRect );
}
CleanChunks( player, x, y, death[player][x][y], character[player].zapStyle );
}
else
{
SurfaceDrawBlob( player, &myRect, grid[player][x][y],
(blobTime[player] & 2)? kFlashDarkBlob: kNoSuction, kNoCharring );
CleanSpriteArea( player, &myRect );
}
}
else
{
if( grid[player][x][y] == kGray && // gray dying
suction[player][x][y] == kGrayBlink1 )
{
CalcBlobRect( x, y, &myRect );
if( death[player][x][y] >= 0 && death[player][x][y] <= kZapFrames )
{
if( death[player][x][y] == kZapFrames )
{
grid[player][x][y] = kEmpty;
suction[player][x][y] = kNoSuction;
SurfaceDrawBlob( player, &myRect, kEmpty, kNoSuction, kNoCharring );
}
else
{
SurfaceDrawBoard( player, &myRect );
SurfaceDrawAlpha( &myRect, kGray, kLight, grayGraphic[ death[player][x][y] ] );
busy = true;
}
CleanSpriteArea( player, &myRect );
}
death[player][x][y]++;
}
}
}
}
// draw score info above blobs but below chunks and explosions
if( zapScoreFrame[player] < arrsize(position) )
{
myRect.y = zapScorePt[player].y - (position[zapScoreFrame[player] ]);
myRect.x = zapScorePt[player].x;
myRect.h = 15 - (position[zapScoreFrame[player] - 1]);
myRect.w = zapScoreWidth[player];
CleanSpriteArea( player, &myRect );
if( zapScoreFrame[player] < arrsize(position)-1 )
{
SDLU_AcquireSurface( playerSpriteSurface[player] );
dPoint.y = oPoint.y = myRect.y;
dPoint.x = oPoint.x = myRect.x;
scan = zapScore[player];
while( *scan )
{
SurfaceBlitWeightedCharacter( zapFont, *scan, &dPoint, zapScoreR[player], zapScoreG[player], zapScoreB[player], shading[zapScoreFrame[player]] );
SurfaceBlitWeightedCharacter( zapOutline, *scan, &oPoint, 0, 0, 0, shading[zapScoreFrame[player]] );
scan++;
}
SDLU_ReleaseSurface( playerSpriteSurface[player] );
zapScoreFrame[player]++;
busy = true;
}
}
///////////////////////////////////////////////////////////////
for( x=0; x<kGridAcross; x++ )
{
for( y=0; y<kGridDown; y++ )
{
if( grid[player][x][y] >= kFirstBlob && // if a blob is dying
grid[player][x][y] <= kLastBlob &&
suction[player][x][y] == kInDeath &&
death[player][x][y] >= 0 && death[player][x][y] < kZapFrames ) // draw chunks (after all that stuff)
{
DrawChunks( player, x, y, death[player][x][y], character[player].zapStyle );
}
}
}
SDLU_ReleaseSurface( playerSurface[player] );
if( grenadeFrame[player] < kBlastFrames )
{
busy = true;
SDLU_AcquireSurface( playerSpriteSurface[player] );
myRect.y = grenadeFrame[player] * kBlastHeight;
myRect.x = 0;
myRect.h = kBlastHeight;
myRect.w = kBlastWidth;
SurfaceBlitAlpha( playerSpriteSurface[player], blastSurface, blastMaskSurface, playerSpriteSurface[player],
&grenadeRect[player], &myRect, &myRect, &grenadeRect[player] );
grenadeFrame[player]++;
SDLU_ReleaseSurface( playerSpriteSurface[player] );
}
if( !busy && role[player] == kKillBlobs )
{
blobTime[player] = GameTickCount( );
halfway[player] = false;
role[player] = kDropBlobs;
}
}
void OpponentPissed( void )
{
opponentMood = 7;
opponentTime = GameTickCount();
}
void UpdateOpponent( void )
{
MRect myRect = {0,0,64,64}, dstRect = {0,0,64,64}, maskRect;
int emotiMap[] = {0, 1, 2, 1}, draw = false, count;
SDL_Rect srcSDLRect, dstSDLRect;
if( GameTickCount( ) > opponentTime )
{
switch( opponentMood )
{
case 0: // Idle
opponentTime += 60 + RandomBefore(180);
opponentMood = RandomBefore(2) + 1;
opponentFrame = (emotiMap[emotions[1]] * kOppFrames);
break;
case 1: // Shifty Eyes
opponentTime += 40 + RandomBefore(60);
opponentMood = 0;
opponentFrame = (emotiMap[emotions[1]] * kOppFrames) + RandomBefore(2) + 1;
break;
case 2: // Blinks
opponentTime += 3;
opponentMood = 3;
opponentFrame = (emotiMap[emotions[1]] * kOppFrames) + 3;
break;
case 3: // Blinks (more)
opponentTime += 3;
opponentMood = 4;
opponentFrame = (emotiMap[emotions[1]] * kOppFrames) + 4;
break;
case 4: // Blinks (more)
opponentTime += 3;
opponentMood = 0;
opponentFrame = (emotiMap[emotions[1]] * kOppFrames) + 3;
break;
case 5: // Chatter (only good for tutorial)
opponentTime += 8;
opponentMood = 6;
opponentFrame = 5;
break;
case 6: // Chatter 2 (only good for tutorial)
opponentTime += 8;
opponentMood = 5;
opponentFrame = 6;
break;
case 7: // Pissed (when hit with punishments)
opponentTime += 60;
opponentFrame = 7;
opponentMood = 0;
break;
}
draw = true;
}
if( GameTickCount( ) > panicTime )
{
panicTime += 2;
if( emotions[1] == kEmotionPanic )
{
if( ++panicFrame >= kGlowArraySize ) panicFrame = 0;
draw = true;
}
else
{
panicFrame = 0;
}
}
for( count=0; count<kGlows; count++ )
{
if( GameTickCount( ) > glowTime[count] )
{
glowTime[count] += character[1].glow[count].time;
if( character[1].glow[count].color )
{
if( ++glowFrame[count] >= kGlowArraySize ) glowFrame[count] = 0;
draw = true;
}
else
{
glowFrame[count] = 0;
}
}
}
if( draw )
{
OffsetMRect( &myRect, 64*opponentFrame, 0 );
SDLU_AcquireSurface( opponentDrawSurface );
SDLU_BlitSurface( opponentSurface, SDLU_MRectToSDLRect( &myRect, &srcSDLRect ),
opponentDrawSurface, SDLU_MRectToSDLRect( &dstRect, &dstSDLRect ) );
maskRect = myRect;
for( count=0; count<kGlows; count++ )
{
OffsetMRect( &maskRect, 0, 64 );
if( glowFrame[count] )
{
if( character[1].glow[count].color & 0x8000 )
{
SurfaceBlitColor( opponentMaskSurface, opponentDrawSurface,
&maskRect, &dstRect,
(character[1].glow[count].color & 0x7C00) >> 10,
(character[1].glow[count].color & 0x03E0) >> 5,
(character[1].glow[count].color & 0x001F),
heavyGlowArray[glowFrame[count]] );
}
else
{
SurfaceBlitColor( opponentMaskSurface, opponentDrawSurface,
&maskRect, &dstRect,
(character[1].glow[count].color & 0x7C00) >> 10,
(character[1].glow[count].color & 0x03E0) >> 5,
(character[1].glow[count].color & 0x001F),
lightGlowArray[glowFrame[count]] );
}
}
}
