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]] ); } } }