ref: 08304b6b5cbd60c92c1015068283738ac180d6cf
dir: /control.cpp/
// control.c
#include "stdafx.h"
#include "main.h"
#include "control.h"
#include "moving.h"
#include "players.h"
#include "random.h"
#include "grays.h"
#include "zap.h"
#include "gameticks.h"
#include "level.h"
#include "tutorial.h"
#include <stdlib.h>
int destinationX[2], destinationR[2];
signed char tempGrid[kGridAcross][kGridDown];
int timeAI[2], timeMove[2];
MBoolean moveQuick[2];
AutoPatternPtr autoPattern = NULL;
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 PlayerControl( int player )
{
int a = player, b = player;
MBoolean 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 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 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;
MBoolean 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 - 1) &&
(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];
}
int TestAIDestination( int player, int testX, int testR )
{
int x, y, height, chains, rensa = 50, result = 0;
for( x=0; x<kGridAcross; x++ )
{
for( y=0; y<kGridDown; y++ )
{
tempGrid[x][y] = grid[player][x][y];
}
}
height = GetRowHeight(player, testX);
switch( testR )
{
case upRotate:
tempGrid[testX][height--] = colorA[player];
if( height >= 0 ) tempGrid[testX][height] = colorB[player];
break;
case downRotate:
tempGrid[testX][height--] = colorB[player];
if( height >= 0 ) tempGrid[testX][height] = colorA[player];
break;
case leftRotate:
tempGrid[testX][height] = colorA[player];
tempGrid[testX-1][GetRowHeight(player,testX-1)] = colorB[player];
break;
case rightRotate:
tempGrid[testX][height] = colorA[player];
tempGrid[testX+1][GetRowHeight(player,testX+1)] = colorB[player];
break;
}
chains = TestTemporaryGrid( );
result = ScoreTemporaryGrid( );
if( (chains < 2) && (character[player].intellect > (24 * 2/3)) )
{
rensa = 0;
}
else
{
while( chains-- ) rensa *= 10;
}
result += rensa;
return result;
}
int ScoreTemporaryGrid( void )
{
int x, y, change, result = 0;
int deductions[kGridAcross][kGridDown] =
{ { 400, 350, 350, 200, 120, 60, 20, 5, 0, 0, 0, 0 },
{ 600, 500, 300, 150, 100, 50, 20, 0, 0, 0, 0, 0 },
{ 9999, 800, 200, 100, 50, 40, 20, 0, 0, 0, 0, 0 },
{ 9999, 800, 200, 100, 50, 40, 20, 0, 0, 0, 0, 0 },
{ 9999, 500, 300, 150, 100, 50, 20, 0, 0, 0, 0, 0 },
{ 400, 350, 350, 200, 120, 60, 20, 5, 0, 0, 0, 0 } };
for( x=0; x<kGridAcross; x++ )
{
for( y=0; y<kGridDown; y++ )
{
if( tempGrid[x][y] == kEmpty )
{
result += deductions[x][y];
}
else if( tempGrid[x][y] == kGray )
{
result -= deductions[x][y];
}
else
{
change = 0;
if( y < (kGridDown-1) && (tempGrid[x][y] == tempGrid[x][y+1]) ) change += 50;
if( y > 0 && (tempGrid[x][y] == tempGrid[x][y-1]) ) change += 50;
if( x < (kGridAcross-1) && (tempGrid[x][y] == tempGrid[x+1][y]) ) change += 40;
if( x > 0 && (tempGrid[x][y] == tempGrid[x-1][y]) ) change += 40;
if( x > 0 &&
y > 0 && (tempGrid[x][y] == tempGrid[x-1][y-1]) ) change += 20;
if( x < (kGridAcross-1) &&
y > 0 && (tempGrid[x][y] == tempGrid[x+1][y-1]) ) change += 20;
if( x > 0 &&
y < (kGridDown-1) && (tempGrid[x][y] == tempGrid[x-1][y+1]) ) change += 10;
if( x < (kGridAcross-1) &&
y < (kGridDown-1) && (tempGrid[x][y] == tempGrid[x+1][y+1]) ) change += 10;
if( y < (kGridDown-2) && (tempGrid[x][y] == tempGrid[x][y+2]) ) change += 10;
if( y > 1 && (tempGrid[x][y] == tempGrid[x][y-2]) ) change += 10;
if( (x > 0 && tempGrid[x-1][y] == kEmpty) ||
(x < (kGridAcross-1) && tempGrid[x+1][y] == kEmpty) ||
(y < 4 || tempGrid[x][y-4] == kEmpty) ) change *= 4;
result += change / 4;
}
}
}
return result;
}
int TestTemporaryGrid( void )
{
MBoolean busy;
int x, y, stackSize, chains = 0;
do
{
busy = false;
for( x=0; x<kGridAcross; x++ )
{
for( y=0; y<kGridDown; y++ )
{
if( tempGrid[x][y] >= kFirstBlob && tempGrid[x][y] <= kLastBlob )
{
if( SizeUp( tempGrid, x, y, tempGrid[x][y] ) >= kBlobClusterSize )
{
QuickRemove( tempGrid, x, y, tempGrid[x][y] );
busy = true;
}
}
}
}
if( busy )
{
chains++;
for( x=0; x<kGridAcross; x++ )
{
stackSize = kGridDown-1;
for( y=kGridDown-1; y>=0; y-- )
{
if( tempGrid[x][y] != kEmpty )
{
tempGrid[x][stackSize] = tempGrid[x][y];
if( y < stackSize ) tempGrid[x][y] = kEmpty;
stackSize--;
}
}
}
}
}
while( busy );
return chains;
}
void QuickRemove( signed char myGrid[kGridAcross][kGridDown], int x, int y, int color )
{
if( (x<0) || (x>=kGridAcross) || (y<0) || (y>=kGridDown) )
return;
if( myGrid[x][y] == kGray ) myGrid[x][y] = kEmpty;
if( myGrid[x][y] == color )
{
myGrid[x][y] = kEmpty;
QuickRemove( myGrid, x-1, y, color );
QuickRemove( myGrid, x+1, y, color );
QuickRemove( myGrid, x, y-1, color );
QuickRemove( myGrid, x, y+1, color );
}
}
int BestColor( int player, int blobX, int blobY )
{
int x, y, color, bestColor = kFirstBlob, bestResult = -9999999, rensa, chains, result;
// char C[] = {' ', '*', '@', '.', '=', '+', 'o', 'J'};
for( color = kFirstBlob; color <= kLastBlob; color++ )
{
for( y=0; y<kGridDown; y++ )
{
for( x=0; x<kGridAcross; x++ )
{
tempGrid[x][y] = grid[player][x][y];
}
}
tempGrid[blobX][blobY] = color;
chains = TestTemporaryGrid( );
result = ScoreTemporaryGrid( );
rensa = 1000;
while( chains-- ) rensa *= 10;
result += rensa;
if( result > bestResult )
{
bestColor = color;
bestResult = result;
}
}
return bestColor;
}
// Returns the first empty row.
int GetRowHeight( int player, int row )
{
int height;
for( height = (kGridDown-1); height > 0; height-- )
{
if( grid[player][row][height] == kEmpty ) break;
}
return height;
}
int DetermineEmotion( int player )
{
int us = 0, them = 0, aboveWater = 1;
int x,y;
if( role[player] == kLosing ) return kEmotionPanic;
if( role[player] == kWinning ) return kEmotionHappy;
for( x=0; x<kGridAcross; x++ )
{
for( y=0; y<kGridDown; y++ )
{
if( aboveWater && (y<3) && (grid[player][x][y] != kEmpty) ) aboveWater = 0;
if( grid[player][x][y] != kEmpty ) us++;
if( grid[1-player][x][y] != kEmpty ) them++;
}
}
if( us > 48 && !aboveWater ) return kEmotionPanic;
else if( abs(us-them) < 12 ) return kEmotionNeutral;
else if( us > them ) return kEmotionSad;
else return kEmotionHappy;
}