acpc_dealer 2.0.6 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3096d955fa2a03dd769ddd096e776f540e434219
-  data.tar.gz: 2f3af5943346c1c7f27a693bf4e9ff7a3c9bff8f
+  metadata.gz: 84b73326801489cffe4fff1438b8afc890e36d7f
+  data.tar.gz: bfd427d17ccbc771a118140a6535d1d7604bca7f
 SHA512:
-  metadata.gz: fcb431724d0dcca127e152c42f0f4293b0291435d5e3a4ab46e442fb8839dc15ce656ba4f52e3a89256355efbdb48c33b7707f6cb5bb20fcb4cffb3987c2788f
-  data.tar.gz: d435b6137168a2e7fb6b01ee7afee56285cca85d7a3e386cccde549d35f76a438f6eb7979a72c87f2237228cdb82bfe9a90b7f775b20f9c94a286ed8fd9e59e9
+  metadata.gz: e2f156daf439f1cb7d0993f81ddd173582ab56ef26e34290522f4f148f5028150937a26be240ce91eff5089bc035c2feb4e76b6c3b5df31ea4c51e77633b1bfb
+  data.tar.gz: 38133b40d10f1c3613dba9a705a27ab805bbb492694bbaf32ac0fda20a60e5d379ffe52117bde395da4fc0680e2fb7d205168d7045355d0fa028a9d3fd1852e9

data/Rakefile

@@ -9,11 +9,13 @@ require 'rubygems/package_task'
 require File.expand_path('../lib/acpc_dealer/version', __FILE__)
 
 desc 'Build gem'
-task :default => [:build, :test]
+task :default => [:test]
 
 task :compile => ['dealer:clean', 'dealer:compile']
 
-task :build => [:clean, :compile]
+task :test => :compile
+
+task :build => :clean
 
 Rake::TestTask.new do |t|
   t.libs << "lib" << 'spec/support'

data/lib/acpc_dealer.rb

@@ -14,7 +14,8 @@ module AcpcDealer
     3 =>
     {
       limit: "#{DEALER_DIRECTORY}/holdem.limit.3p.game",
-      nolimit: "#{DEALER_DIRECTORY}/holdem.nolimit.3p.game"
+      nolimit: "#{DEALER_DIRECTORY}/holdem.nolimit.3p.game",
+      kuhn: "#{DEALER_DIRECTORY}/kuhn.limit.3p.game"
     }
   }
   DEALER_PATH = "#{DEALER_DIRECTORY}/dealer"
@@ -28,7 +29,10 @@ module AcpcDealer
     3 =>
     {
       limit: "#{DEALER_DIRECTORY}/example_player.limit.3p.sh",
-      nolimit: "#{DEALER_DIRECTORY}/example_player.nolimit.3p.sh"
+      nolimit: "#{DEALER_DIRECTORY}/example_player.nolimit.3p.sh",
+      kuhn_sf1: "#{DEALER_DIRECTORY}/kuhn_3p_equilibrium_player.sf1.sh",
+      kuhn_sf2: "#{DEALER_DIRECTORY}/kuhn_3p_equilibrium_player.sf2.sh",
+      kuhn_sf3: "#{DEALER_DIRECTORY}/kuhn_3p_equilibrium_player.sf3.sh"
     }
   }
 

data/lib/acpc_dealer/version.rb

@@ -1,3 +1,3 @@
 module AcpcDealer
-  VERSION = "2.0.6"
+  VERSION = "2.1.0"
 end

data/vendor/project_acpc_server/Makefile

@@ -1,12 +1,19 @@
+
+THIS_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
+
 CC = gcc
 CFLAGS = -O3 -Wall
 
+KUHN_3P_E_BASE = kuhn_3p_equilibrium_player
+KUHN_3P_E_PLAYER := $(KUHN_3P_E_BASE)
+KUHN_3P_E_DIR := $(KUHN_3P_E_BASE)
+
 PROGRAMS = bm_server bm_widget dealer example_player
 
-all: $(PROGRAMS)
+all: $(PROGRAMS) $(KUHN_3P_E_DIR)/$(KUHN_3P_E_PLAYER)
 
 clean:
-	rm -f $(PROGRAMS)
+	rm -f $(PROGRAMS) && cd $(KUHN_3P_E_DIR) && make clean
 
 
 bm_server: bm_server.c game.c game.h rng.c rng.h net.c net.h
@@ -20,3 +27,6 @@ dealer: game.c game.h evalHandTables rng.c rng.h dealer.c net.c net.h
 
 example_player: game.c game.h evalHandTables rng.c rng.h example_player.c net.c net.h
 	$(CC) $(CFLAGS) -o $@ game.c rng.c example_player.c net.c
+
+$(KUHN_3P_E_DIR)/$(KUHN_3P_E_PLAYER):
+	cd $(KUHN_3P_E_DIR) && make

data/vendor/project_acpc_server/README

@@ -111,3 +111,4 @@ If you are creating your own game definitions, please note that game.h defines
 some constants for maximums in games (e.g., number of rounds).  These may need
 to be changed for games outside of the what is being run for the Annual
 Computer Poker Competition.
+

data/vendor/project_acpc_server/example_player.limit.2p.sh

@@ -1,2 +1,3 @@
 #!/bin/bash
-./example_player holdem.limit.2p.reverse_blinds.game $1 $2
+THIS_DIR=$( cd "$( dirname "$0" )" && pwd )
+cd $THIS_DIR && ./example_player holdem.limit.2p.reverse_blinds.game $1 $2

data/vendor/project_acpc_server/example_player.limit.3p.sh

@@ -1,2 +1,3 @@
 #!/bin/bash
-./example_player holdem.limit.3p.game $1 $2
+THIS_DIR=$( cd "$( dirname "$0" )" && pwd )
+cd $THIS_DIR && ./example_player holdem.limit.3p.game $1 $2

data/vendor/project_acpc_server/example_player.nolimit.2p.sh

@@ -1,2 +1,3 @@
 #!/bin/bash
-./example_player holdem.nolimit.2p.reverse_blinds.game $1 $2
+THIS_DIR=$( cd "$( dirname "$0" )" && pwd )
+cd $THIS_DIR && ./example_player holdem.nolimit.2p.reverse_blinds.game $1 $2

data/vendor/project_acpc_server/example_player.nolimit.3p.sh

@@ -1,2 +1,3 @@
 #!/bin/bash
-./example_player holdem.nolimit.3p.game $1 $2
+THIS_DIR=$( cd "$( dirname "$0" )" && pwd )
+cd $THIS_DIR && ./example_player holdem.nolimit.3p.game $1 $2

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

@@ -0,0 +1,14 @@
+GAMEDEF
+limit
+numPlayers = 3
+numRounds = 1
+blind = 1 1 1
+raiseSize = 1
+firstPlayer = 1
+maxRaises = 1
+numSuits = 1
+numRanks = 4
+numHoleCards = 1
+numBoardCards = 0
+stack = 2 2 2
+END GAMEDEF

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player.sf1.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+THIS_DIR=$( cd "$( dirname "$0" )" && pwd )
+cd $THIS_DIR && ./kuhn_3p_equilibrium_player/kuhn_3p_equilibrium_player -n $1 -p $2 --c11 0.0 --b11 0.25 --b21 0.25 --b32 0.9375 --c33 0.0 --c34 1.0 -g kuhn.limit.3p.game

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player.sf2.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+THIS_DIR=$( cd "$( dirname "$0" )" && pwd )
+cd $THIS_DIR && ./kuhn_3p_equilibrium_player/kuhn_3p_equilibrium_player -n $1 -p $2 --c11 0.5 --b11 0.25 --b21 0.0 --b23 0.125 --b32 0.75 --c33 0.0 --c34 0.75 -g kuhn.limit.3p.game

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player.sf3.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+THIS_DIR=$( cd "$( dirname "$0" )" && pwd )
+cd $THIS_DIR && ./kuhn_3p_equilibrium_player/kuhn_3p_equilibrium_player -n $1 -p $2 --c11 0.33 --b11 0.166667 --b32 0.791667 --c33 0.0 --c34 0.75 -g kuhn.limit.3p.game

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/LICENCE

@@ -0,0 +1,23 @@
+Copyright (C) 2013 by the Computer Poker Research Group, University of Alberta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicence, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+Except as contained in this notice, the name(s) of the above copyright holders
+shall not be used in advertising or otherwise to promote the sale, use or other
+dealings in this Software without prior written authorization.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/Makefile

@@ -0,0 +1,128 @@
+THIS_DIR := $(CURDIR)/$(dir $(lastword $(MAKEFILE_LIST)))
+PROJECT_DIR := $(THIS_DIR)/../
+
+CC = gcc -std=gnu99
+CFLAGS = -O0 -g
+LIBS = -lm
+TARGET_SYMBOLS = -DCEXCEPTION_USE_CONFIG_FILE
+
+VENDOR_DIR := $(THIS_DIR)/vendor/
+COMMANDER_DIR := $(VENDOR_DIR)/commander.c
+TARGET_INCLUDES = -I$(PROJECT_DIR) -I$(THIS_DIR)/src -I$(CEXCEPTION_LIB) -I$(COMMANDER_DIR)/src
+
+CEXCEPTION_DIR := $(VENDOR_DIR)/cexception/
+CEXCEPTION_LIB := $(CEXCEPTION_DIR)/lib
+CEXCEPTION_SRC := $(CEXCEPTION_LIB)/CException.c
+
+TARGET_BASE = kuhn_3p_equilibrium_player
+TARGET_SRC_DIR := $(THIS_DIR)/src
+TARGET_SRC := $(TARGET_SRC_DIR)/$(TARGET_BASE).c $(CEXCEPTION_SRC) 
+
+PROJECT_SRC := $(PROJECT_DIR)/game.c $(PROJECT_DIR)/rng.c $(PROJECT_DIR)/net.c
+
+BUILD_PREFIX := $(CC) $(CFLAGS) $(TARGET_SYMBOLS)
+
+TARGET := $(THIS_DIR)/$(TARGET_BASE)
+
+default: $(TARGET) 
+
+# Build target
+#==============
+$(TARGET): $(TARGET_SRC) $(PROJECT_DIR)/evalHandTables $(PROJECT_DIR)/game.h $(PROJECT_DIR)/net.h $(PROJECT_DIR)/rng.h
+	$(BUILD_PREFIX) -Wall $(TARGET_INCLUDES) $(TARGET_SRC) $(TARGET_SRC_DIR)/main.c $(TARGET_SRC_DIR)/player_config.c $(TARGET_SRC_DIR)/dealer_connection.c $(COMMANDER_DIR)/src/commander.c $(LIBS) -o $@ $(PROJECT_SRC)
+	chmod 755 $@
+
+# Testing
+#===========
+UNITY_DIR := $(VENDOR_DIR)/unity
+CMOCK_DIR := $(VENDOR_DIR)/cmock
+TEST_DIR := $(THIS_DIR)/test
+TEST_SUPPORT_DIR := $(TEST_DIR)/support
+INC_DIRS := -I$(UNITY_DIR)/src -I$(TEST_SUPPORT_DIR) -I$(THIS_DIR)/src $(TARGET_INCLUDES)
+SYMBOLS = -DTEST -DUNITY_FLOAT_TYPE=double -DUNITY_FLOAT_VERBOSE
+TEST_BASE := $(TEST_DIR)/test_$(TARGET_BASE)
+ifeq ($(OS),Windows_NT)
+	TEST_EXTENSION=.exe
+else
+	TEST_EXTENSION=.out
+endif
+
+# Test 1
+#-------------
+TEST1_BASE := $(TEST_BASE)
+TEST1_SRC := $(TEST1_BASE).c
+TEST1 := $(TEST1_BASE)$(TEST_EXTENSION)
+TEST1_RUNNER := $(TEST1_BASE)_Runner.c
+
+$(TEST1_RUNNER):
+	ruby $(UNITY_DIR)/auto/generate_test_runner.rb $(TEST1_SRC) $(TEST1_RUNNER)
+
+$(TEST1): $(TARGET) $(TEST1_RUNNER)
+	$(BUILD_PREFIX) $(SYMBOLS) $(INC_DIRS) $(TARGET_SRC) $(PROJECT_SRC) $(TEST_SUPPORT_DIR)/test_helper.c $(UNITY_DIR)/src/unity.c $(TEST1_SRC) $(TEST1_RUNNER) $(LIBS) -o $(TEST1)
+
+# Test 2
+#-------------
+TEST2_BASE := $(TEST_BASE)_sub_family_1
+TEST2_SRC := $(TEST2_BASE).c
+TEST2 := $(TEST2_BASE)$(TEST_EXTENSION)
+TEST2_RUNNER := $(TEST2_BASE)_Runner.c
+
+$(TEST2_RUNNER):
+	ruby $(UNITY_DIR)/auto/generate_test_runner.rb $(TEST2_SRC) $(TEST2_RUNNER)
+
+$(TEST2): $(TARGET) $(TEST2_RUNNER)
+	$(BUILD_PREFIX) $(SYMBOLS) $(INC_DIRS) $(TARGET_SRC) $(PROJECT_SRC) $(TEST_SUPPORT_DIR)/test_helper.c $(UNITY_DIR)/src/unity.c $(TEST2_SRC) $(TEST2_RUNNER) $(LIBS) -o $(TEST2)
+
+# Test 3
+#-------------
+TEST3_BASE := $(TEST_BASE)_sub_family_2
+TEST3_SRC := $(TEST3_BASE).c
+TEST3 := $(TEST3_BASE)$(TEST_EXTENSION)
+TEST3_RUNNER := $(TEST3_BASE)_Runner.c
+
+$(TEST3_RUNNER):
+	ruby $(UNITY_DIR)/auto/generate_test_runner.rb $(TEST3_SRC) $(TEST3_RUNNER)
+
+$(TEST3): $(TARGET) $(TEST3_RUNNER)
+	$(BUILD_PREFIX) $(SYMBOLS) $(INC_DIRS) $(TARGET_SRC) $(PROJECT_SRC) $(TEST_SUPPORT_DIR)/test_helper.c $(UNITY_DIR)/src/unity.c $(TEST3_SRC) $(TEST3_RUNNER) $(LIBS) -o $(TEST3)
+
+# Test 4
+#-------------
+TEST4_BASE := $(TEST_BASE)_sub_family_3
+TEST4_SRC := $(TEST4_BASE).c
+TEST4 := $(TEST4_BASE)$(TEST_EXTENSION)
+TEST4_RUNNER := $(TEST4_BASE)_Runner.c
+
+$(TEST4_RUNNER):
+	ruby $(UNITY_DIR)/auto/generate_test_runner.rb $(TEST4_SRC) $(TEST4_RUNNER)
+
+$(TEST4): $(TARGET) $(TEST4_RUNNER)
+	$(BUILD_PREFIX) $(SYMBOLS) $(INC_DIRS) $(TARGET_SRC) $(PROJECT_SRC) $(TEST_SUPPORT_DIR)/test_helper.c $(UNITY_DIR)/src/unity.c $(TEST4_SRC) $(TEST4_RUNNER) $(LIBS) -o $(TEST4)
+
+# Basic functionality exercise with the dealer
+#-------------------------------
+$(PROJECT_DIR)/dealer:
+	cd $(PROJECT_DIR) && make
+
+dealer_test: clean $(TARGET) $(PROJECT_DIR)/dealer
+	cd $(PROJECT_DIR) && ./dealer m kuhn.limit.3p.game 100 1 p1 p2 p3 &
+	sleep 0.1 # Ensure the dealer has started and is ready to accept connections
+	./kuhn_3p_equilibrium_player -0 0.0 -1 0.25 -2 0.25 -4 0.9375 --c33 0.0 --c34 1.0 -p 18791 -g ../kuhn.limit.3p.game & # Sub-family 1
+	./kuhn_3p_equilibrium_player --c11 0.5 --b11 0.25 --b21 0.0 --b23 0.125 --b32 0.75 --c33 0.0 --c34 0.75 -p 18374 -g ../kuhn.limit.3p.game & # Sub-family 2
+	./kuhn_3p_equilibrium_player --c11 0.33 --b11 0.166667 --b32 0.791667 --c33 0.0 --c34 0.75 -p 59497 -g ../kuhn.limit.3p.game & # Sub-family 3
+
+# Automatic tests (require Ruby)
+#--------------------------------
+test: clean $(TEST1) $(TEST2) $(TEST3) $(TEST4)
+	$(TEST1)
+	$(TEST2)
+	$(TEST3)
+	$(TEST4)
+
+# Clean
+#============
+clean:
+	rm -f $(TARGET) *.o *.il *.out $(TEST1) $(TEST2) $(TEST3) $(TEST4) $(TEST1_RUNNER) $(TEST2_RUNNER) $(TEST3_RUNNER) $(TEST4_RUNNER) $(THIS_DIR)/test/*.out
+
+dist_clean: clean
+	rm -f *~ core

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/README.md

@@ -0,0 +1,35 @@
+Kuhn 3-Player Equilibrium Player
+=================================
+`kuhn_3p_equilibrium_player` is an ACPC compatible player that connects to the
+ACPC dealer and plays 3-player Kuhn poker with an equilibrium component 
+strategy specified by its arguments from one of those specified by 
+[*A Parameterized Family of Equilibrium Profiles for Three-Player Kuhn 
+Poker*](http://poker.cs.ualberta.ca/publications/2013-techreport-nl-size.pdf), 
+written by Duane Szafron, Richard Gibson, and Nathan Sturtevant, found in 
+*Proceedings of the Twelfth International Conference on Autonomous Agents and 
+Multiagent Systems (AAMAS-13)* in May 2013.
+ 
+Equilibrium sub-families
+--------------------------
+There are three sub-families of equilibria identified by Szafron, Gibson, and 
+Sturtevant, each defined by a different value of parameter `c11`. Depending on
+the sub-family, different parameters must necessarily be provided, except for
+`c11`, `b11`, `b32`, `c33`, and `c34`, which are always necessary. Please
+see 
+[the paper](http://poker.cs.ualberta.ca/publications/2013-techreport-nl-size.pdf)
+for the domain of each paramter. 
+
+- `c11 = 0.0` sub-family: `b21` must also be provided.
+- `c11 = 1/2.0` sub-family: `b21` and `b23` must also be provided.
+- `0.0 < c11 < 1/2.0` sub-family: No futher parameters are necessary. 
+
+License
+-------
+MIT license (see `LICENCE`).
+
+Acknowledgements
+----------------
+This project includes software developed for 
+the CException Project, by Mark VanderVoord and other 
+contributors, as well as the CMock and Unity Projects, by Mike Karlesky,
+Mark VanderVoord, and Greg Williams and other contributors.

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/src/CExceptionConfig.h

@@ -0,0 +1,12 @@
+/*
+Copyright (C) 2013 by the Computer Poker Research Group, University of Alberta
+*/
+
+#ifndef __CEXCEPTION_CONFIG_H__
+#define __CEXCEPTION_CONFIG_H__
+
+#include <stdlib.h>
+
+#define CEXCEPTION_NO_CATCH_HANDLER(id) exit(id)
+
+#endif

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/src/dealer_connection.c

@@ -0,0 +1,49 @@
+/*
+Copyright (C) 2013 by the Computer Poker Research Group, University of Alberta
+*/
+
+#include <stdlib.h>
+#include <assert.h>
+#include "dealer_connection.h"
+#include "game.h"
+
+DealerConnection new_dealer_connection()
+{
+  DealerConnection this = {
+      .host = "localhost",
+      .port = 0,
+      .toServer = NULL,
+      .fromServer = NULL
+  };
+
+  return this;
+}
+
+void connect_to_dealer(DealerConnection* this)
+{
+  assert(this);
+
+  int sock = connectTo(this->host, this->port);
+  if( sock < 0 ) {
+    exit( EXIT_FAILURE );
+  }
+  this->toServer = fdopen( sock, "w" );
+  this->fromServer = fdopen( sock, "r" );
+  if(!(this->toServer && this->fromServer)) {
+    fprintf( stderr, "ERROR: could not get socket streams\n" );
+    exit( EXIT_FAILURE );
+  }
+
+  /* send version string to dealer */
+  if(
+      fprintf(
+          this->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(this->toServer);
+}

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/src/dealer_connection.h

@@ -0,0 +1,22 @@
+/*
+Copyright (C) 2013 by the Computer Poker Research Group, University of Alberta
+*/
+
+#ifndef __DEALER_CONNECTION_H__
+#define __DEALER_CONNECTION_H__
+
+#include <limits.h>
+#include <stdint.h>
+#include <stdio.h>
+
+typedef struct {
+  char host[HOST_NAME_MAX];
+  uint16_t port;
+  FILE *toServer;
+  FILE *fromServer;
+} DealerConnection;
+
+DealerConnection new_dealer_connection();
+void connect_to_dealer(DealerConnection* this);
+
+#endif

data/vendor/project_acpc_server/kuhn_3p_equilibrium_player/src/kuhn_3p_equilibrium_player.c

@@ -0,0 +1,483 @@
+/*
+Copyright (C) 2013 by the Computer Poker Research Group, University of Alberta
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <math.h>
+#include <assert.h>
+
+#include "CException.h"
+void print_and_throw_error(const char const *message)
+{
+  fprintf(stderr, "ERROR: %s", message);
+  Throw(1);
+}
+
+#include "kuhn_3p_equilibrium_player.h"
+
+double beta(const Kuhn3pEquilibriumPlayer* kuhn_3p_e_player)
+{
+  assert(kuhn_3p_e_player);
+
+  return fmax(
+      kuhn_3p_e_player->params[B11_INDEX], kuhn_3p_e_player->params[B21_INDEX]
+  );
+}
+
+/* Based on Unity's UnityAssertDoublesWithin function */
+static bool doublesAboutEqual(double d1, double d2) {
+    static const double DOUBLE_PRECISION = 1e-12f;
+
+    double diff = fabs(d2 - d1);
+    double delta = fabs(d2 * DOUBLE_PRECISION);
+
+    //This first part of this condition will catch any NaN or Infinite values
+    return !((diff * 0.0 != 0.0) || (delta < diff));
+}
+
+static bool is_3p_kuhn_poker_game(const Game const *game_def)
+{
+  assert(game_def);
+  return (
+      game_def->bettingType == limitBetting &&
+      game_def->numRounds == 1 && game_def->maxRaises[0] == 1 &&
+      game_def->numSuits == 1 && game_def->numRanks == 4 &&
+      game_def->numHoleCards == 1 &&
+      game_def->numBoardCards[0] == 0 &&
+      game_def->numPlayers == 3
+ );
+}
+
+static void check_c11_b11_and_b21(Kuhn3pEquilibriumPlayer* kuhn_3p_e_player) {
+  assert(kuhn_3p_e_player);
+
+  if (kuhn_3p_e_player->params[C11_INDEX] > (1/2.0)) {
+    print_and_throw_error(
+        "kuhn_3p_equilibrium_player: c11 greater than 1/2\n"
+    );
+    return;
+  }
+  if (doublesAboutEqual(0.0, kuhn_3p_e_player->params[C11_INDEX])) {
+    if (kuhn_3p_e_player->params[B21_INDEX] > (1/4.0)) {
+      print_and_throw_error(
+          "kuhn_3p_equilibrium_player: b21 greater than 1/4\n"
+      );
+    }
+    if (
+        kuhn_3p_e_player->params[B11_INDEX] >
+        kuhn_3p_e_player->params[B21_INDEX]
+    ) {
+      print_and_throw_error(
+          "kuhn_3p_equilibrium_player: b11 greater than b21\n"
+      );
+    }
+  } else {
+    if (kuhn_3p_e_player->params[B11_INDEX] > (1/4.0)) {
+      print_and_throw_error(
+          "kuhn_3p_equilibrium_player: b11 greater than 1/4\n"
+      );
+    }
+    if (kuhn_3p_e_player->params[C11_INDEX] < (1/2.0)) {
+      if (
+          kuhn_3p_e_player->params[B11_INDEX] > (1/6.0) && (
+            kuhn_3p_e_player->params[C11_INDEX] > (
+                  (2 - kuhn_3p_e_player->params[B11_INDEX]) /
+                  (3 + 4 * kuhn_3p_e_player->params[B11_INDEX])
+            )
+          )
+      ) {
+        print_and_throw_error(
+            "kuhn_3p_equilibrium_player: c11 too large\n"
+        );
+      }
+
+      kuhn_3p_e_player->params[B21_INDEX] =
+          kuhn_3p_e_player->params[B11_INDEX];
+    } else if (
+        kuhn_3p_e_player->params[B21_INDEX] > fmin(
+            kuhn_3p_e_player->params[B11_INDEX],
+            (1/2.0) - 2 * kuhn_3p_e_player->params[B11_INDEX]
+        )
+    ) {
+      print_and_throw_error(
+          "kuhn_3p_equilibrium_player: b21 too large\n"
+      );
+    }
+  }
+}
+
+static void check_b32(Kuhn3pEquilibriumPlayer* kuhn_3p_e_player) {
+  assert(kuhn_3p_e_player);
+
+  if (
+      kuhn_3p_e_player->params[B32_INDEX] > (
+          (1 / 2.0) + (3 / 4.0) * (
+              kuhn_3p_e_player->params[B11_INDEX] +
+              kuhn_3p_e_player->params[B21_INDEX]
+          ) + (beta(kuhn_3p_e_player) / 4.0)
+      )
+  ) {
+    print_and_throw_error(
+        "kuhn_3p_equilibrium_player: b32 too large\n");
+  }
+}
+
+static void check_c33(Kuhn3pEquilibriumPlayer* kuhn_3p_e_player) {
+  assert(kuhn_3p_e_player);
+
+  if (
+      kuhn_3p_e_player->params[C33_INDEX] < (
+          (1 / 2.0) - kuhn_3p_e_player->params[B32_INDEX])
+  ) {
+    print_and_throw_error(
+        "kuhn_3p_equilibrium_player: c33 too small\n");
+  }
+  if (
+      kuhn_3p_e_player->params[C33_INDEX] > (
+          (1 / 2.0) - kuhn_3p_e_player->params[B32_INDEX] + (3 / 4.0) * (
+              kuhn_3p_e_player->params[B11_INDEX] +
+              kuhn_3p_e_player->params[B21_INDEX]
+          ) + (beta(kuhn_3p_e_player) / 4.0)
+      )
+  ) {
+    print_and_throw_error(
+        "kuhn_3p_equilibrium_player: c33 too large\n"
+    );
+  }
+}
+
+static void check_b23(Kuhn3pEquilibriumPlayer* kuhn_3p_e_player) {
+  if (
+      kuhn_3p_e_player->params[B23_INDEX] > fmax(
+          0.0,
+          (
+              kuhn_3p_e_player->params[B11_INDEX] -
+              kuhn_3p_e_player->params[B21_INDEX]
+          ) /
+          (2 * (1.0 - kuhn_3p_e_player->params[B21_INDEX]))
+      )
+  ) {
+    print_and_throw_error("kuhn_3p_equilibrium_player: b23 too large\n");
+  }
+}
+
+static void check_params(Kuhn3pEquilibriumPlayer* kuhn_3p_e_player)
+{
+  assert(kuhn_3p_e_player);
+
+  check_c11_b11_and_b21(kuhn_3p_e_player);
+
+  check_b23(kuhn_3p_e_player);
+  kuhn_3p_e_player->params[B33_INDEX] = (
+      (1 / 2.0) + (1 / 2.0)*(
+          kuhn_3p_e_player->params[B11_INDEX] +
+          kuhn_3p_e_player->params[B21_INDEX]
+      ) +
+      (beta(kuhn_3p_e_player) / 2.0) - kuhn_3p_e_player->params[B23_INDEX] * (
+          1 - kuhn_3p_e_player->params[B21_INDEX]
+      )
+  );
+  kuhn_3p_e_player->params[B41_INDEX] = (
+      2 * kuhn_3p_e_player->params[B11_INDEX] +
+      2 * kuhn_3p_e_player->params[B21_INDEX]
+  );
+
+  check_b32(kuhn_3p_e_player);
+  check_c33(kuhn_3p_e_player);
+
+  kuhn_3p_e_player->params[B41_INDEX] = (
+      2 * kuhn_3p_e_player->params[B11_INDEX] +
+      2 * kuhn_3p_e_player->params[B21_INDEX]
+  );
+  kuhn_3p_e_player->params[C21_INDEX] = (
+      (1 / 2.0) - kuhn_3p_e_player->params[C11_INDEX]
+  );
+
+  for (size_t i = 0; i < NUM_PARAMS; ++i) {
+    if (
+        kuhn_3p_e_player->params[i] < 0.0 ||
+        kuhn_3p_e_player->params[i] > 1.0
+    ) {
+      print_and_throw_error(
+         "kuhn_3p_equilibrium_player: strategy parameters must be in [0,1]\n"
+      );
+    }
+  }
+  return;
+}
+
+static void action_probs_p0(
+    uint8_t card_rank,
+    const State const* state,
+    double* probs
+) {
+  assert(probs);
+  assert(state);
+
+  size_t situation_index = 0;
+
+  if (0 == state->numActions[0]) { // Situation 1
+    probs[a_fold] = 0.0;
+    probs[a_call] = 1.0 - A[card_rank - JACK_RANK][0];
+    probs[a_raise] = A[card_rank - JACK_RANK][0];
+    return;
+  } else if (a_call == state->action[0][1].type) { // Situation 2
+    situation_index = 1;
+  } else if (a_fold == state->action[0][2].type) { // Situation 3
+    situation_index = 2;
+  } else { // Situation 4
+    situation_index = 3;
+  }
+  probs[a_fold] = 1.0 - A[card_rank - JACK_RANK][situation_index];
+  probs[a_call] = A[card_rank - JACK_RANK][situation_index];
+  probs[a_raise] = 0.0;
+
+  return;
+}
+
+static void action_probs_p1(
+    const double const* params,
+    uint8_t card_rank,
+    const State const* state,
+    double* probs
+) {
+  assert(params);
+  assert(probs);
+  assert(state);
+
+  double param;
+
+  // Situation 1 or 2
+  if (1 == state->numActions[0]) {
+    if (a_call == state->action[0][0].type) { // Situation 1
+      if (JACK_RANK == card_rank) {
+        param = params[B11_INDEX];
+      } else if (QUEEN_RANK == card_rank) {
+        param = params[B21_INDEX];
+      } else if (KING_RANK == card_rank) {
+        param = B31;
+      } else {
+        param = params[B41_INDEX];
+      }
+      probs[a_fold] = 0.0;
+      probs[a_call] = 1.0 - param;
+      probs[a_raise] = param;
+      return;
+    } else { // Situation 2
+      if (JACK_RANK == card_rank) {
+        param = B12;
+      } else if (QUEEN_RANK == card_rank) {
+        param = B22;
+      } else if (KING_RANK == card_rank) {
+        param = params[B32_INDEX];
+      } else {
+        param = B42;
+      }
+    }
+  } else { // Situation 3 or 4
+    if (a_fold == state->action[0][3].type) { // Situation 3
+      if (JACK_RANK == card_rank) {
+        param = B13;
+      } else if (QUEEN_RANK == card_rank) {
+        param = params[B23_INDEX];
+      } else if (KING_RANK == card_rank) {
+        param = params[B33_INDEX];
+      } else {
+        param = B43;
+      }
+    } else { // Situation 4
+      if (JACK_RANK == card_rank) {
+        param = B14;
+      } else if (QUEEN_RANK == card_rank) {
+        param = B24;
+      } else if (KING_RANK == card_rank) {
+        param = B34;
+      } else {
+        param = B44;
+      }
+    }
+  }
+
+  probs[a_fold] = 1.0 - param;
+  probs[a_call] = param;
+  probs[a_raise] = 0.0;
+
+  return;
+}
+
+static void action_probs_p2(
+    const double const* params,
+    uint8_t card_rank,
+    const State const* state,
+    double* probs
+)
+{
+  assert(params);
+  assert(probs);
+  assert(state);
+
+  double param;
+
+  // Situation 1
+  if (a_call == state->action[0][0].type) {
+    if (a_call == state->action[0][1].type) { // Situation 1
+      if (JACK_RANK == card_rank) {
+        param = params[C11_INDEX];
+      } else if (QUEEN_RANK == card_rank) {
+        param = params[C21_INDEX];
+      } else if (KING_RANK == card_rank) {
+        param = C31;
+      } else {
+        param = C4[0];
+      }
+      probs[a_fold] = 0.0;
+      probs[a_call] = 1.0 - param;
+      probs[a_raise] = param;
+      return;
+    } else { // Situation 2
+      if (JACK_RANK == card_rank) {
+        param = C12;
+      } else if (QUEEN_RANK == card_rank) {
+        param = C22;
+      } else if (KING_RANK == card_rank) {
+        param = C32;
+      } else {
+        param = C4[1];
+      }
+    }
+  } else { // Situation 3 or 4
+    if (a_fold == state->action[0][1].type) { // Situation 3
+      if (JACK_RANK == card_rank) {
+        param = C13;
+      } else if (QUEEN_RANK == card_rank) {
+        param = C23;
+      } else if (KING_RANK == card_rank) {
+        param = params[C33_INDEX];
+      } else {
+        param = C4[2];
+      }
+    } else { // Situation 4
+      if (JACK_RANK == card_rank) {
+        param = C14;
+      } else if (QUEEN_RANK == card_rank) {
+        param = C24;
+      } else if (KING_RANK == card_rank) {
+        param = params[C34_INDEX];
+      } else {
+        param = C4[3];
+      }
+    }
+  }
+
+  probs[a_fold] = 1.0 - param;
+  probs[a_call] = param;
+  probs[a_raise] = 0.0;
+
+  return;
+}
+
+/*********************************/
+/****** Player Interface *********/
+/*********************************/
+
+/* create any private space needed for future calls
+   game_def is a private copy allocated by the dealer for the player's use */
+Kuhn3pEquilibriumPlayer new_kuhn_3p_equilibrium_player(
+    const Game const* game_def,
+    const double const* params,
+    uint32_t seed
+)
+{
+  assert(game_def);
+  assert(params);
+
+  Kuhn3pEquilibriumPlayer kuhn_3p_e_player;
+
+  /* This player cannot be used outside of Kuhn poker */
+  if(!is_3p_kuhn_poker_game(game_def)) {
+    print_and_throw_error(
+        "kuhn_3p_equilibrium_player used in non-Kuhn game\n"
+    );
+    return kuhn_3p_e_player;
+  }
+
+  kuhn_3p_e_player.game_def = game_def;
+
+  memset(
+      kuhn_3p_e_player.params,
+      0,
+      NUM_PARAMS * sizeof(*kuhn_3p_e_player.params)
+  );
+  for (size_t i = 0; i < NUM_PARAMS; ++i) {
+    kuhn_3p_e_player.params[i] = params[i];
+  }
+
+  kuhn_3p_e_player.seed = seed;
+
+  CEXCEPTION_T e = 0;
+  Try {
+    check_params(&kuhn_3p_e_player);
+  } Catch(e) {
+    Throw(e);
+  }
+
+  /* Create our random number generators */
+  init_genrand(&kuhn_3p_e_player.get_action_rng, kuhn_3p_e_player.seed);
+
+  return kuhn_3p_e_player;
+}
+
+/* return a (valid!) action at the information state described by view */
+Action action(
+    Kuhn3pEquilibriumPlayer* player,
+    MatchState view
+)
+{
+  assert(player);
+
+  double probs[NUM_ACTION_TYPES];
+  memset(probs, 0, NUM_ACTION_TYPES * sizeof(*probs));
+  action_probs(player, view, probs);
+
+  double r = genrand_real2(&player->get_action_rng);
+
+  enum ActionType i = a_fold;
+  for (; i < NUM_ACTION_TYPES - 1; ++i) {
+    if (r <= probs[i]) {
+      break;
+    }
+    r -= probs[i];
+  }
+
+  Action a = {a.type = i, a.size = 0};
+
+  return a;
+}
+
+/* Returns a distribution of actions in action_triple
+   This is an extra function, and does _NOT_ need to be implemented
+   to be considered a valid player.h interface. */
+void action_probs(
+    const Kuhn3pEquilibriumPlayer const* player,
+    MatchState view,
+    double* probs
+)
+{
+  assert(player);
+  assert(probs);
+
+  uint8_t card_rank = rankOfCard(view.state.holeCards[view.viewingPlayer][0]);
+
+  if (0 == view.viewingPlayer) {
+    action_probs_p0(card_rank, &view.state, probs);
+  } else if (1 == view.viewingPlayer) {
+    action_probs_p1(player->params, card_rank, &view.state, probs);
+  } else {
+    action_probs_p2(player->params, card_rank, &view.state, probs);
+  }
+
+  return;
+}