acpc_dealer 0.0.1

data/vendor/project_acpc_server/game.h

@@ -0,0 +1,253 @@
+/*
+Copyright (C) 2011 by the Computer Poker Research Group, University of Alberta
+*/
+
+#ifndef _GAME_H
+#define _GAME_H
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+#include "rng.h"
+#include "net.h"
+
+
+#define VERSION_MAJOR 2
+#define VERSION_MINOR 0
+#define VERSION_REVISION 0
+
+
+#define MAX_ROUNDS 4
+#define MAX_PLAYERS 10
+#define MAX_BOARD_CARDS 7
+#define MAX_HOLE_CARDS 3
+#define MAX_NUM_ACTIONS 64
+#define MAX_SUITS 4
+#define MAX_RANKS 13
+#define MAX_LINE_LEN READBUF_LEN
+
+#define NUM_ACTION_TYPES 3
+
+
+enum BettingType { limitBetting, noLimitBetting };
+enum ActionType { a_fold = 0, a_call = 1, a_raise = 2,
+		  a_invalid = NUM_ACTION_TYPES };
+
+typedef struct {
+  enum ActionType type; /* is action a fold, call, or raise? */
+  int32_t size; /* for no-limit raises, we need a size
+		   MUST BE 0 IN ALL CASES WHERE IT IS NOT USED */
+} Action;
+
+typedef struct {
+
+  /* stack sizes for each player */
+  int32_t stack[ MAX_PLAYERS ];
+
+  /* entry fee for game, per player */
+  int32_t blind[ MAX_PLAYERS ];
+
+  /* size of fixed raises for limitBetting games */
+  int32_t raiseSize[ MAX_ROUNDS ];
+
+  /* general class of game */
+  enum BettingType bettingType;
+
+  /* number of players in the game */
+  uint8_t numPlayers;
+
+  /* number of betting rounds */
+  uint8_t numRounds;
+
+  /* first player to act in a round */
+  uint8_t firstPlayer[ MAX_ROUNDS ];
+
+  /* number of bets/raises that may be made in each round */
+  uint8_t maxRaises[ MAX_ROUNDS ];
+
+  /* number of suits and ranks in the deck of cards */
+  uint8_t numSuits;
+  uint8_t numRanks;
+
+  /* number of private player cards */
+  uint8_t numHoleCards;
+
+  /* number of shared public cards each round */
+  uint8_t numBoardCards[ MAX_ROUNDS ];
+} Game;
+
+typedef struct {
+  uint32_t handId;
+
+  /* largest bet so far, including all previous rounds */
+  int32_t maxSpent;
+
+  /* minimum number of chips a player must have spend in total to raise
+     only used for noLimitBetting games */
+  int32_t minNoLimitRaiseTo;
+
+  /* spent[ p ] gives the total amount put into the pot by player p */
+  int32_t spent[ MAX_PLAYERS ];
+
+  /* action[ r ][ i ] gives the i'th action in round r */
+  Action action[ MAX_ROUNDS ][ MAX_NUM_ACTIONS ];
+
+  /* actingPlayer[ r ][ i ] gives the player who made action i in round r
+     we can always figure this out from the actions taken, but it's
+     easier to just remember this in multiplayer (because of folds) */
+  uint8_t actingPlayer[ MAX_ROUNDS ][ MAX_NUM_ACTIONS ];
+
+  /* numActions[ r ] gives the number of actions made in round r */
+  uint8_t numActions[ MAX_ROUNDS ];
+
+  /* current round: a value between 0 and game.numRounds-1
+     a showdown is still in numRounds-1, not a separate round */
+  uint8_t round;
+
+  /* finished is non-zero if and only if the game is over */
+  uint8_t finished;
+
+  /* playerFolded[ p ] is non-zero if and only player p has folded */
+  uint8_t playerFolded[ MAX_PLAYERS ];
+
+  /* public cards (including cards which may not yet be visible to players) */
+  uint8_t boardCards[ MAX_BOARD_CARDS ];
+
+  /* private cards */
+  uint8_t holeCards[ MAX_PLAYERS ][ MAX_HOLE_CARDS ];
+} State;
+
+typedef struct {
+  State state;
+  uint8_t viewingPlayer;
+} MatchState;
+
+
+/* returns a game structure, or NULL on failure */
+Game *readGame( FILE *file );
+
+void printGame( FILE *file, const Game *game );
+
+/* initialise a state so that it is at the beginning of a hand
+   DOES NOT DEAL OUT CARDS */
+void initState( const Game *game, const uint32_t handId, State *state );
+
+/* shuffle a deck of cards and deal them out, writing the results to state */
+void dealCards( const Game *game, rng_state_t *rng, State *state );
+
+int statesEqual( const Game *game, const State *a, const State *b );
+
+int matchStatesEqual( const Game *game, const MatchState *a,
+		      const MatchState *b );
+
+/* check if a raise is possible, and the range of valid sizes
+   returns non-zero if raise is a valid action and sets *minSize
+   and maxSize, or zero if raise is not valid */
+int raiseIsValid( const Game *game, const State *curState,
+		  int32_t *minSize, int32_t *maxSize );
+
+/* check if an action is valid
+
+   if tryFixing is non-zero, try modifying the given action to produce
+   a valid action, as in the AAAI rules.  Currently this only means
+   that a no-limit raise will be modified to the nearest valid raise size
+
+   returns non-zero if final action/size is valid for state, 0 otherwise */
+int isValidAction( const Game *game, const State *curState,
+		   const int tryFixing, Action *action );
+
+/* record the given action in state
+    does not check that action is valid */
+void doAction( const Game *game, const Action *action, State *state );
+
+/* returns non-zero if hand is finished, zero otherwise */
+#define stateFinished( constStatePtr ) ((constStatePtr)->finished)
+
+/* get the current player to act in the state */
+uint8_t currentPlayer( const Game *game, const State *state );
+
+/* number of raises in the current round */
+uint8_t numRaises( const State *state );
+
+/* number of players who have folded */
+uint8_t numFolded( const Game *game, const State *state );
+
+/* number of players who have called the current bet (or initiated it)
+   doesn't count non-acting players who are all-in */
+uint8_t numCalled( const Game *game, const State *state );
+
+/* number of players who are all-in */
+uint8_t numAllIn( const Game *game, const State *state );
+
+/* number of players who can still act (ie not all-in or folded) */
+uint8_t numActingPlayers( const Game *game, const State *state );
+
+/* get the index into array state.boardCards[] for the first board
+   card in round (where the first round is round 0) */
+uint8_t bcStart( const Game *game, const uint8_t round );
+
+/* get the total number of board cards dealt out after (zero based) round */
+uint8_t sumBoardCards( const Game *game, const uint8_t round );
+
+/* return the value of a finished hand for a player
+   returns a double because pots may be split when players tie
+   WILL HAVE UNDEFINED BEHAVIOUR IF HAND ISN'T FINISHED
+   (stateFinished(state)==0) */
+double valueOfState( const Game *game, const State *state,
+		      const uint8_t player );
+
+/* returns number of characters consumed on success, -1 on failure
+   state will be modified even on a failure to read */
+int readState( const char *string, const Game *game, State *state );
+
+/* returns number of characters consumed on success, -1 on failure
+   state will be modified even on a failure to read */
+int readMatchState( const char *string, const Game *game, MatchState *state );
+
+/* print a state to a string, as viewed by viewingPlayer
+   returns the number of characters in string, or -1 on error
+   DOES NOT COUNT FINAL 0 TERMINATOR IN THIS COUNT!!! */
+int printState( const Game *game, const State *state,
+		const int maxLen, char *string );
+
+/* print a state to a string, as viewed by viewingPlayer
+   returns the number of characters in string, or -1 on error
+   DOES NOT COUNT FINAL 0 TERMINATOR IN THIS COUNT!!! */
+int printMatchState( const Game *game, const MatchState *state,
+		     const int maxLen, char *string );
+
+/* read an action, returning the action in the passed pointer
+   action and size will be modified even on a failure to read
+   returns number of characters consumed on succes, -1 on failure */
+int readAction( const char *string, const Game *game, Action *action );
+
+/* print an action to a string
+   returns the number of characters in string, or -1 on error
+   DOES NOT COUNT FINAL 0 TERMINATOR IN THIS COUNT!!! */
+int printAction( const Game *game, const Action *action,
+		 const int maxLen, char *string );
+
+/* returns number of characters consumed, or -1 on error
+   on success, returns the card in *card */
+int readCard( const char *string, uint8_t *card );
+
+/* read up to maxCards cards
+   returns number of cards successfully read
+   returns number of characters consumed in charsConsumed */
+int readCards( const char *string, const int maxCards,
+	       uint8_t *cards, int *charsConsumed );
+
+/* print a card to a string
+   returns the number of characters in string, or -1 on error
+   DOES NOT COUNT FINAL 0 TERMINATOR IN THIS COUNT!!! */
+int printCard( const uint8_t card, const int maxLen, char *string );
+
+/* print out numCards cards to a string
+   returns the number of characters in string
+   DOES NOT COUNT FINAL 0 TERMINATOR IN THIS COUNT!!! */
+int printCards( const int numCards, const uint8_t *cards,
+		const int maxLen, char *string );
+
+#define rankOfCard( card ) ((card)/MAX_SUITS)
+#define suitOfCard( card ) ((card)%MAX_SUITS)
+#define makeCard( rank, suit ) ((rank)*MAX_SUITS+(suit))
+
+#endif

data/vendor/project_acpc_server/holdem.limit.2p.reverse_blinds.game

@@ -0,0 +1,13 @@
+GAMEDEF
+limit
+numPlayers = 2
+numRounds = 4
+blind = 10 5
+raiseSize = 10 10 20 20
+firstPlayer = 2 1 1 1
+maxRaises = 3 4 4 4
+numSuits = 4
+numRanks = 13
+numHoleCards = 2
+numBoardCards = 0 3 1 1
+END GAMEDEF

data/vendor/project_acpc_server/holdem.limit.3p.game

@@ -0,0 +1,13 @@
+GAMEDEF
+limit
+numPlayers = 3
+numRounds = 4
+blind = 5 10 0
+raiseSize = 10 10 20 20
+firstPlayer = 3 1 1 1
+maxRaises = 3 4 4 4
+numSuits = 4
+numRanks = 13
+numHoleCards = 2
+numBoardCards = 0 3 1 1
+END GAMEDEF

data/vendor/project_acpc_server/holdem.nolimit.2p.reverse_blinds.game

@@ -0,0 +1,12 @@
+GAMEDEF
+nolimit
+numPlayers = 2
+numRounds = 4
+stack = 20000 20000
+blind = 100 50
+firstPlayer = 2 1 1 1
+numSuits = 4
+numRanks = 13
+numHoleCards = 2
+numBoardCards = 0 3 1 1
+END GAMEDEF

data/vendor/project_acpc_server/holdem.nolimit.3p.game

@@ -0,0 +1,12 @@
+GAMEDEF
+nolimit
+numPlayers = 3
+numRounds = 4
+stack = 20000 20000 20000
+blind = 50 100 0
+firstPlayer = 3 1 1 1
+numSuits = 4
+numRanks = 13
+numHoleCards = 2
+numBoardCards = 0 3 1 1
+END GAMEDEF

data/vendor/project_acpc_server/net.c

@@ -0,0 +1,218 @@
+/*
+Copyright (C) 2011 by the Computer Poker Research Group, University of Alberta
+*/
+
+#include <unistd.h>
+#include <netdb.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include "net.h"
+
+
+ReadBuf *createReadBuf( int fd )
+{
+  ReadBuf *readBuf = (ReadBuf*)malloc( sizeof( ReadBuf ) );
+  if( readBuf == 0 ) {
+
+    return readBuf;
+  }
+
+  readBuf->fd = fd;
+  readBuf->bufStart = 0;
+  readBuf->bufEnd = 0;
+
+  return readBuf;
+}
+
+void destroyReadBuf( ReadBuf *readBuf )
+{
+  close( readBuf->fd );
+  free( readBuf );
+}
+
+/* get a newline terminated line and place it as a string in 'line'
+   terminates the string with a 0 character
+   if timeoutMicros is non-negative, do not spend more than
+   that number of microseconds waiting to read data
+   return number of characters read (including newline, excluding 0)
+   0 on end of file, or -1 on error or timeout */
+ssize_t getLine( ReadBuf *readBuf,
+		 size_t maxLen,
+		 char *line,
+		 int64_t timeoutMicros )
+{
+  int haveStartTime, c;
+  ssize_t len;
+  fd_set fds;
+  struct timeval start, tv;
+
+  /* reserve space for string terminator */
+  --maxLen;
+  if( maxLen < 0 ) {
+    return -1;
+  }
+
+  /* read the line */
+  haveStartTime = 0;
+  len = 0;
+  while( len < maxLen ) {
+
+    if( readBuf->bufStart >= readBuf->bufEnd ) {
+      /* buffer is empty */
+
+      if( timeoutMicros >= 0 ) {
+	/* figure out how much time is left for reading */
+	uint64_t timeLeft;
+
+	timeLeft = timeoutMicros;
+	if( haveStartTime ) {
+
+	  gettimeofday( &tv, NULL );
+	  timeLeft -= (uint64_t)( tv.tv_sec - start.tv_sec ) * 1000000
+	    + ( tv.tv_usec - start.tv_usec );
+	  if( timeLeft < 0 ) {
+
+	    timeLeft = 0;
+	  }
+	} else {
+
+	  haveStartTime = 1;
+	  gettimeofday( &start, NULL );
+	}
+	tv.tv_sec = timeLeft / 1000000;
+	tv.tv_usec = timeLeft % 1000000;
+
+	/* wait for file descriptor to be ready */
+	FD_ZERO( &fds );
+	FD_SET( readBuf->fd, &fds );
+	if( select( readBuf->fd + 1, &fds, NULL, NULL, &tv ) < 1 ) {
+	  /* no input ready within time, or an actual error */
+	
+	  return -1;
+	}
+      }
+
+      /* try reading a buffer full of data */
+      readBuf->bufStart = 0;
+      readBuf->bufEnd = read( readBuf->fd, readBuf->buf, READBUF_LEN );
+      if( readBuf->bufEnd == 0 ) {
+	/* end of input */
+
+	break;
+      } else if( readBuf->bufEnd < 0 ) {
+	/* error condition */
+
+	readBuf->bufEnd = 0;
+	return -1;
+      }
+    }
+
+    /* keep adding to the string until we see a newline */
+    c = readBuf->buf[ readBuf->bufStart ];
+    ++readBuf->bufStart;
+    line[ len ] = c;
+    ++len;
+    if( c == '\n' ) {
+
+      break;
+    }
+  }
+
+  /* terminate the string */
+  line[ len ] = 0;
+  return len;
+}
+
+
+int connectTo( char *hostname, uint16_t port )
+{
+  int sock;
+  struct hostent *hostent;
+  struct sockaddr_in addr;
+
+  hostent = gethostbyname( hostname );
+  if( hostent == NULL ) {
+
+    fprintf( stderr, "ERROR: could not look up address for %s\n", hostname );
+    return -1;
+  }
+
+  if( ( sock = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 ) {
+
+    fprintf( stderr, "ERROR: could not open socket\n" );
+    return -1;
+  }
+
+  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 connect to %s:%"PRIu16"\n",
+	     hostname, port );
+    return -1;
+  }
+
+  return sock;
+}
+
+int getListenSocket( uint16_t *desiredPort )
+{
+  int sock, t;
+  struct sockaddr_in addr;
+
+  if( ( sock = socket( AF_INET, SOCK_STREAM, 0 ) ) < 0 ) {
+
+    return -1;
+  }
+
+  /* allow fast socket reuse - ignore failure */
+  t = 1;
+  setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, &t, sizeof( int ) );
+
+  /* bind the socket to the port */
+  if( *desiredPort != 0 ) {
+
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons( *desiredPort );
+    addr.sin_addr.s_addr = htonl( INADDR_ANY );
+    if( bind( sock, (struct sockaddr *)&addr, sizeof( addr ) ) < 0 ) {
+
+      return -1;
+    }
+  } else {
+
+    t = 0;
+    while( 1 ) {
+      addr.sin_family = AF_INET;
+      *desiredPort = ( random() % 64512 ) + 1024;
+      addr.sin_port = htons( *desiredPort );
+      addr.sin_addr.s_addr = htonl( INADDR_ANY );
+      if( bind( sock, (struct sockaddr *)&addr, sizeof( addr ) ) < 0 ) {
+
+	if( t < NUM_PORT_CREATION_ATTEMPTS ) {
+
+	  ++t;
+	  continue;
+	} else {
+
+	  return -1;
+	}
+      }
+
+      break;
+    }
+  }
+
+  /* listen on the socket */
+  if( listen( sock, 8 ) < 0 ) {
+
+    return -1;
+  }
+
+  return sock;
+}

data/vendor/project_acpc_server/net.h

@@ -0,0 +1,61 @@
+/*
+Copyright (C) 2011 by the Computer Poker Research Group, University of Alberta
+*/
+
+#ifndef _NET_H
+#define _NET_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+
+
+#define READBUF_LEN 1024
+#define NUM_PORT_CREATION_ATTEMPTS 10
+
+
+/* buffered I/O on file descriptors
+
+   Yes... this is basically re-implementing bits of a standard FILE.
+   Unfortunately, trying to mix timeouts and FILE streams either
+   a) doesn't work, or b) is fairly system specific */
+typedef struct {
+  int fd;
+  int bufStart;
+  int bufEnd;
+  char buf[ READBUF_LEN ];
+} ReadBuf;
+
+
+/* open a socket to hostname/port
+   returns file descriptor on success, <0 on failure */
+int connectTo( char *hostname, uint16_t port );
+
+/* try opening a socket suitable for connecting to
+   if *desiredPort>0, uses specified port, otherwise use a random port
+   returns actual port in *desiredPort
+   returns file descriptor for socket, or -1 on failure */
+int getListenSocket( uint16_t *desiredPort );
+
+
+/* create a read buffer structure
+   returns 0 on failure */
+ReadBuf *createReadBuf( int fd );
+
+/* destroy a read buffer - like fdopen, it will close the file descriptor */
+void destroyReadBuf( ReadBuf *readBuf );
+
+/* get a newline terminated line and place it as a string in 'line'
+   terminates the string with a 0 character
+   if timeoutMicros is non-negative, do not spend more than
+   that number of microseconds waiting to read data
+   return number of characters read (including newline, excluding 0)
+   0 on end of file, or -1 on error or timeout */
+ssize_t getLine( ReadBuf *readBuf,
+		 size_t maxLen,
+		 char *line,
+		 int64_t timeoutMicros );
+
+
+#endif

data/vendor/project_acpc_server/play_match.pl

@@ -0,0 +1,99 @@
+#!/usr/bin/perl
+
+# Copyright (C) 2011 by the Computer Poker Research Group, University of Alberta
+
+use Socket;
+
+$hostname = `hostname` or die "could not get hostname";
+chomp $hostname;
+@hostent = gethostbyname( $hostname );
+$#hostent >= 4 or die "could not look up $hostname";
+$hostip = inet_ntoa( $hostent[ 4 ] );
+
+$#ARGV >= 3 or die "usage: play_match.pl matchName gameDefFile #Hands rngSeed player1name player1exe player2name player2exe ... [options]";
+
+$numPlayers = -1;
+open FILE, '<', $ARGV[ 1 ] or die "couldn't open game definition $ARGV[ 1 ]";
+while( $_ = <FILE> ) {
+
+    @_ = split;
+
+    if( uc( $_[ 0 ] ) eq 'NUMPLAYERS' ) {
+	$numPlayers = $_[ $#_ ];
+    }
+}
+close FILE;
+
+$numPlayers > 1 or die "couldn't get number of players from $ARGV[ 1 ]";
+
+
+$#ARGV >= 3 + $numPlayers * 2 or die "too few players on command line";
+
+pipe STDINREADPIPE, STDINWRITEPIPE or die "couldn't create stdin pipe";
+pipe STDOUTREADPIPE, STDOUTWRITEPIPE or die "couldn't create stdout pipe";
+
+$dealerPID = fork();
+if( $dealerPID == 0 ) {
+    # we're the child
+
+    # replace standard in and standard out with pipe
+    close STDINWRITEPIPE;
+    close STDOUTREADPIPE;
+    open STDIN, '<&STDINREADPIPE' or die "can't dup STDIN";
+    open STDOUT, '>&STDOUTWRITEPIPE' or die "can't dup STDOUT";
+    open STDERR, ">>$ARGV[ 0 ].err" or die "can't open log file $ARGV[ 0 ].err";
+
+    @args = ( "dealer", $ARGV[ 0 ], $ARGV[ 1 ],
+	      $ARGV[ 2 ], $ARGV[ 3 ] );
+
+    # add names to the arguments
+    for( $p = 0; $p < $numPlayers; ++$p ) {
+	push @args, $ARGV[ 4 + $p * 2 ];
+    }
+
+    # add any extra arguments (options?) to the arguments
+    for( $i = 4 + $numPlayers * 2; $i <= $#ARGV; ++$i ) {
+	push @args, $ARGV[ $i ];
+    }
+    exec { "./dealer" } @args or die "Couldn't run dealer";
+}
+
+close STDINREADPIPE;
+close STDOUTWRITEPIPE;
+
+$_ = <STDOUTREADPIPE> or die "couldn't read port description from dealer";
+@_ = split;
+$#_ + 1 >= $numPlayers or die "couldn't get enough ports from $_";
+
+for( $p = 0; $p < $numPlayers; ++$p ) {
+
+    $playerPID[ $p ] = fork();
+
+    if( $playerPID[ $p ] == 0 ) {
+	# we're the child
+
+	# log standard out and standard error
+	open STDOUT, ">$ARGV[ 0 ].player$p.std"
+	    or die "can't dup player $p STDOUT";
+	open STDERR, ">$ARGV[ 0 ].player$p.err"
+	    or die "can't dup player $p STDERR";
+
+	exec { $ARGV[ 4 + $p * 2 + 1 ] } ( $ARGV[ 4 + $p * 2 + 1 ],
+					   $hostip, $_[ $p ] )
+	    or die "couldn't run $ARGV[ 4 + $p * 2 + 1 ] for player $p";
+    }
+}
+
+$_ = <STDOUTREADPIPE>;
+
+for( $p = 0; $p < $numPlayers; ++$p ) {
+    waitpid( $playerPID[ $p ], 0 );
+}
+
+waitpid( $dealerPID, 0 );
+
+$_ or die "couldn't get values from dealer";
+
+print $_;
+
+exit( 0 );