void Position::reverse(Square sq, int dir)
{
for (int cursq = sq + dir; isOppPiece(cursq); cursq += dir) {
place(cursq, currentPlayer());
++count[currentPlayer()];
--count[oppositePlayer()];
}
}
void Position::applyMove(Square sq)
{
place(sq, currentPlayer());
for (int d = 0; d < TOT_DIR; ++d) {
if (isValidMove(sq, DIR[d]))
reverse(sq, DIR[d]);
}
++count[currentPlayer()];
nullMoveCount = 0;
changePlayer();
}
void GameProfile::loadProfile()
{
loadXml();
// if no profile found, create default player
if (m_players.count() == 0)
setCurrentPlayer(tr("Player"));
if (m_current >= 0 && m_current < m_players.count()) {
sndEngine->setChannelVolume(currentPlayer()->soundVolume);
sndEngine->setMusicVolume(currentPlayer()->musicVolume);
sndEngine->enableMusic(currentPlayer()->musicEnabled);
}
// loadTopTen();
}
int FcpaActionAbstraction::get_actions( const Game *game,
const State &state,
Action actions
[ MAX_ABSTRACT_ACTIONS ] ) const
{
assert( MAX_ABSTRACT_ACTIONS >= 4 );
int num_actions = 0;
for( int a = 0; a < NUM_ACTION_TYPES; ++a ) {
Action action;
action.type = ( ActionType ) a;
action.size = 0;
if( action.type == a_raise ) {
int32_t min_raise_size;
int32_t max_raise_size;
if( raiseIsValid( game, &state, &min_raise_size, &max_raise_size ) ) {
/* Check for pot-size raise being valid. First, get the pot size. */
int32_t pot = 0;
for( int p = 0; p < game->numPlayers; ++p ) {
pot += state.spent[ p ];
}
/* Add amount needed to call. This gives the size of a pot-sized raise */
uint8_t player = currentPlayer( game, &state );
int amount_to_call = state.maxSpent - state.spent[ player ];
pot += amount_to_call;
/* Raise size is total amount of chips committed over all rounds
* after making the raise.
*/
int pot_raise_size = pot + ( state.spent[ player ] + amount_to_call );
if( pot_raise_size < max_raise_size ) {
actions[ num_actions ] = action;
actions[ num_actions ].size = pot_raise_size;
++num_actions;
}
/* Now add all-in */
actions[ num_actions ] = action;
actions[ num_actions ].size = max_raise_size;
++num_actions;
}
} else if( isValidAction( game, &state, 0, &action ) ) {
/* Fold and call */
actions[ num_actions ] = action;
++num_actions;
}
}
return num_actions;
}
GameContextData GameCycle::gameContextData() const
{
GameContextData res;
res.currentPlayerId = currentPlayer()->id();
res.requestedPlayerId = requestedPlayer()->id();
res.turnNumber = turnNumber();
res.gamePlayState = gamePlayState();
if (gamePlayState() == GAMEPLAYSTATE_RESPONSE) {
res.reactionType = reactionHandler()->reactionType();
Player* causedBy = reactionHandler()->causedBy();
res.causedBy = causedBy ? causedBy->id() : 0;
} else {
res.reactionType = REACTION_NONE;
res.causedBy = 0;
}
return res;
}
int main( int argc, char **argv )
{
int sock, len, r;
int32_t min, max;
uint16_t port;
Game *game;
MatchState state;
Action action;
struct sockaddr_in addr;
struct hostent *hostent;
FILE *file, *toServer, *fromServer;
char line[ MAX_LINE_LEN ];
if( argc < 4 ) {
fprintf( stderr, "usage: player game server port\n" );
exit( EXIT_FAILURE );
}
file = fopen( argv[ 1 ], "r" );
if( file == NULL ) {
fprintf( stderr, "ERROR: could not open game %s\n", argv[ 1 ] );
exit( EXIT_FAILURE );
}
game = readGame( file );
if( game == NULL ) {
fprintf( stderr, "ERROR: could not read game %s\n", argv[ 1 ] );
exit( EXIT_FAILURE );
}
fclose( file );
hostent = gethostbyname( argv[ 2 ] );
if( hostent == NULL ) {
fprintf( stderr, "ERROR: could not look up address for %s\n", argv[ 2 ] );
exit( EXIT_FAILURE );
}
if( sscanf( argv[ 3 ], "%"SCNu16, &port ) < 1 ) {
fprintf( stderr, "ERROR: invalid port %s\n", argv[ 3 ] );
exit( EXIT_FAILURE );
}
if( ( sock = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 ) {
fprintf( stderr, "ERROR: could not open socket\n" );
exit( EXIT_FAILURE );
}
addr.sin_family = AF_INET;
addr.sin_port = htons( port );
memcpy( &addr.sin_addr, hostent->h_addr_list[ 0 ], hostent->h_length );
if( connect( sock, (struct sockaddr *)&addr, sizeof( addr ) ) < 0 ) {
fprintf( stderr, "ERROR: could not open connect to %s:%"PRIu16"\n",
argv[ 2 ], port );
exit( EXIT_FAILURE );
}
toServer = fdopen( sock, "w" );
fromServer = fdopen( sock, "r" );
if( toServer == NULL || fromServer == NULL ) {
fprintf( stderr, "ERROR: could not get socket streams\n" );
exit( EXIT_FAILURE );
}
if( fprintf( toServer, "VERSION:%"PRIu32".%"PRIu32".%"PRIu32"\n",
VERSION_MAJOR, VERSION_MINOR, VERSION_REVISION ) != 14 ) {
fprintf( stderr, "ERROR: could not get send version to server\n" );
exit( EXIT_FAILURE );
}
fflush( toServer );
while( fgets( line, MAX_LINE_LEN, fromServer ) ) {
/* ignore comments */
if( line[ 0 ] == '#' || line[ 0 ] == ';' ) {
continue;
}
len = readMatchState( line, game, &state );
if( len < 0 ) {
fprintf( stderr, "ERROR: could not read state %s", line );
exit( EXIT_FAILURE );
}
if( stateFinished( &state.state ) ) {
/* ignore the game over message */
continue;
}
if( currentPlayer( game, &state.state ) != state.viewingPlayer ) {
/* we're not acting */
continue;
}
int bucket = computeHandValue(game,&state.state,state.viewingPlayer,min,max);
/* add a colon (guaranteed to fit because we read a new-line in fgets) */
line[ len ] = ':';
++len;
//if( ( random() % 2 ) && raiseIsValid( game, &state.state, &min, &max ) ) {
/* raise */
if ((bucket >= 3) && raiseIsValid(game, &state.state, &min, &max)) {
action.type = raise;
action.size = min + random() % ( max - min + 1 );
} else if (bucket >=2) {
/* call */
action.type = call;
action.size = 0;
}
else{
action.type = fold;
action.size = 0;
}
if( !isValidAction( game, &state.state, 0, &action ) ) {
fprintf( stderr, "ERROR: chose an invalid action\n" );
exit( EXIT_FAILURE );
}
r = printAction( game, &action, MAX_LINE_LEN - len - 1,
&line[ len ] );
if( r < 0 ) {
fprintf( stderr, "ERROR: line too long after printing action\n" );
exit( EXIT_FAILURE );
}
len += r;
line[ len ] = '\n';
++len;
if( fwrite( line, 1, len, toServer ) != len ) {
fprintf( stderr, "ERROR: could not get send response to server\n" );
exit( EXIT_FAILURE );
}
fflush( toServer );
}
return EXIT_SUCCESS;
}
/* run a match of numHands hands of the supplied game
cards are dealt using rng, error conditions like timeouts
are controlled and stored in errorInfo
actions are read/sent to seat p on seatFD[ p ]
if quiet is not zero, only print out errors, warnings, and final value
if logFile is not NULL, print out a single line for each completed
match with the final state and all player values. The values are
printed in player, not seat order.
if transactionFile is not NULL, a transaction log of actions made
is written to the file, and if there is any input left to read on
the stream when gameLoop is called, it will be processed to
initialise the state
returns >=0 if the match finished correctly, -1 on error */
static int gameLoop( const Game *game, char *seatName[ MAX_PLAYERS ],
const uint32_t numHands, const int quiet,
const int fixedSeats, rng_state_t *rng,
ErrorInfo *errorInfo, const int seatFD[ MAX_PLAYERS ],
ReadBuf *readBuf[ MAX_PLAYERS ],
FILE *logFile, FILE *transactionFile )
{
uint32_t handId;
uint8_t seat, p, player0Seat, currentP, currentSeat;
struct timeval t, sendTime, recvTime;
Action action;
MatchState state;
double value[ MAX_PLAYERS ], totalValue[ MAX_PLAYERS ];
/* check version string for each player */
for( seat = 0; seat < game->numPlayers; ++seat ) {
if( checkVersion( seat, readBuf[ seat ] ) < 0 ) {
/* error messages already handled in function */
return -1;
}
}
gettimeofday( &sendTime, NULL );
if( !quiet ) {
fprintf( stderr, "STARTED at %zu.%06zu\n",
sendTime.tv_sec, sendTime.tv_usec );
}
/* start at the first hand */
handId = 0;
if( checkErrorNewHand( game, errorInfo ) < 0 ) {
fprintf( stderr, "ERROR: unexpected game\n" );
return -1;
}
initState( game, handId, &state.state );
dealCards( game, rng, &state.state );
for( seat = 0; seat < game->numPlayers; ++seat ) {
totalValue[ seat ] = 0.0;
}
/* seat 0 is player 0 in first game */
player0Seat = 0;
/* process the transaction file */
if( transactionFile != NULL ) {
if( processTransactionFile( game, fixedSeats, &handId, &player0Seat,
rng, errorInfo, totalValue,
&state, transactionFile ) < 0 ) {
/* error messages already handled in function */
return -1;
}
}
if( handId >= numHands ) {
goto finishedGameLoop;
}
/* play all the (remaining) hands */
while( 1 ) {
/* play the hand */
while( !stateFinished( &state.state ) ) {
/* find the current player */
currentP = currentPlayer( game, &state.state );
/* send state to each player */
for( seat = 0; seat < game->numPlayers; ++seat ) {
state.viewingPlayer = seatToPlayer( game, player0Seat, seat );
if( sendPlayerMessage( game, &state, quiet, seat,
seatFD[ seat ], &t ) < 0 ) {
/* error messages already handled in function */
return -1;
}
/* remember the seat and send time if player is acting */
if( state.viewingPlayer == currentP ) {
sendTime = t;
}
}
/* get action from current player */
state.viewingPlayer = currentP;
currentSeat = playerToSeat( game, player0Seat, currentP );
if( readPlayerResponse( game, &state, quiet, currentSeat, &sendTime,
errorInfo, readBuf[ currentSeat ],
&action, &recvTime ) < 0 ) {
/* error messages already handled in function */
return -1;
}
/* log the transaction */
if( transactionFile != NULL ) {
if( logTransaction( game, &state.state, &action,
&sendTime, &recvTime, transactionFile ) < 0 ) {
/* error messages already handled in function */
return -1;
}
}
/* do the action */
doAction( game, &action, &state.state );
}
/* get values */
for( p = 0; p < game->numPlayers; ++p ) {
value[ p ] = valueOfState( game, &state.state, p );
totalValue[ playerToSeat( game, player0Seat, p ) ] += value[ p ];
}
/* add the game to the log */
if( logFile != NULL ) {
if( addToLogFile( game, &state.state, value, player0Seat,
seatName, logFile ) < 0 ) {
/* error messages already handled in function */
return -1;
}
}
/* send final state to each player */
for( seat = 0; seat < game->numPlayers; ++seat ) {
state.viewingPlayer = seatToPlayer( game, player0Seat, seat );
if( sendPlayerMessage( game, &state, quiet, seat,
seatFD[ seat ], &t ) < 0 ) {
/* error messages already handled in function */
return -1;
}
}
if ( !quiet ) {
if ( handId % 100 == 0) {
for( seat = 0; seat < game->numPlayers; ++seat ) {
fprintf(stderr, "Seconds cumulatively spent in match for seat %i: "
"%i\n", seat,
(int)(errorInfo->usedMatchMicros[ seat ] / 1000000));
}
}
}
/* start a new hand */
if( setUpNewHand( game, fixedSeats, &handId, &player0Seat,
rng, errorInfo, &state.state ) < 0 ) {
/* error messages already handled in function */
return -1;
}
if( handId >= numHands ) {
break;
}
}
finishedGameLoop:
/* print out the final values */
if( !quiet ) {
gettimeofday( &t, NULL );
fprintf( stderr, "FINISHED at %zu.%06zu\n",
sendTime.tv_sec, sendTime.tv_usec );
}
if( printFinalMessage( game, seatName, totalValue, logFile ) < 0 ) {
/* error messages already handled in function */
return -1;
}
return 0;
}
/* returns >= 0 if match should continue, -1 for failure */
static int processTransactionFile( const Game *game, const int fixedSeats,
uint32_t *handId, uint8_t *player0Seat,
rng_state_t *rng, ErrorInfo *errorInfo,
double totalValue[ MAX_PLAYERS ],
MatchState *state, FILE *file )
{
int c, r;
uint32_t h;
uint8_t s;
Action action;
struct timeval sendTime, recvTime;
char line[ MAX_LINE_LEN ];
while( fgets( line, MAX_LINE_LEN, file ) ) {
/* get the log entry */
/* ACTION */
c = readAction( line, game, &action );
if( c < 0 ) {
fprintf( stderr, "ERROR: could not parse transaction action %s", line );
return -1;
}
/* ACTION HANDID SEND RECV */
if( sscanf( &line[ c ], " %"SCNu32" %zu.%06zu %zu.%06zu%n", &h,
&sendTime.tv_sec, &sendTime.tv_usec,
&recvTime.tv_sec, &recvTime.tv_usec, &r ) < 4 ) {
fprintf( stderr, "ERROR: could not parse transaction stamp %s", line );
return -1;
}
c += r;
/* check that we're processing the expected handId */
if( h != *handId ) {
fprintf( stderr, "ERROR: handId mismatch in transaction log: %s", line );
return -1;
}
/* make sure the action is valid */
if( !isValidAction( game, &state->state, 0, &action ) ) {
fprintf( stderr, "ERROR: invalid action in transaction log: %s", line );
return -1;
}
/* check for any timeout issues */
s = playerToSeat( game, *player0Seat,
currentPlayer( game, &state->state ) );
if( checkErrorTimes( s, &sendTime, &recvTime, errorInfo ) < 0 ) {
fprintf( stderr,
"ERROR: seat %"PRIu8" ran out of time in transaction file\n",
s + 1 );
return -1;
}
doAction( game, &action, &state->state );
if( stateFinished( &state->state ) ) {
/* hand is finished */
/* update the total value for each player */
for( s = 0; s < game->numPlayers; ++s ) {
totalValue[ s ]
+= valueOfState( game, &state->state,
seatToPlayer( game, *player0Seat, s ) );
}
/* move on to next hand */
if( setUpNewHand( game, fixedSeats, handId, player0Seat,
rng, errorInfo, &state->state ) < 0 ) {
return -1;
}
}
}
return 0;
}
void Game::setCurrentPlayer(COLOR color) {
current = color == WHITE ? wp : bp;
current->setColor(color);
board.startMove(color);
emit currentPlayer(color);
}
