linearize betspace.cpp

#pragma once

#include <open_spiel/spiel.h>

namespace amirbot
{
	enum class ActionType : unsigned
	{
		FOLD = 0,
		CHECK = 1,
		CALL = 2,
		RAISE_FIXED = 3,
		RAISE_BB_RELATIVE = 4,
		RAISE_POT_RELATIVE = 5,
		RAISE_ALL_IN = 6,
		DEAL_FLOP = 7,
		DEAL_TURN = 8,
		DEAL_RIVER = 9
	};

	struct PokerAction {
		ActionType actionType;
		int64_t amount;
		unsigned flop;
		unsigned turn;
		unsigned river;
	};

	std::string ActionTypeToString(ActionType actionType) {
		switch(actionType) {
			case ActionType::FOLD: return "FOLD";
			case ActionType::CHECK: return "CHECK";
			case ActionType::CALL: return "CALL";
			case ActionType::RAISE_FIXED: return "RAISE_FIXED";
			case ActionType::RAISE_BB_RELATIVE: return "RAISE_BB_RELATIVE";
			case ActionType::RAISE_POT_RELATIVE: return "RAISE_POT_RELATIVE";
			case ActionType::RAISE_ALL_IN: return "RAISE_ALL_IN";
			case ActionType::DEAL_FLOP: return "DEAL_FLOP";
			case ActionType::DEAL_TURN: return "DEAL_TURN";
			case ActionType::DEAL_RIVER: return "DEAL_RIVER";
		}
	}

	namespace Lookups {


		constexpr int MAX_BETS = 6;
		constexpr int MAX_CARDS = 5; 

		int64_t LOOKUP_MAX = 
			/* UNINIT */ 0 +
			/* FOLD */ 1 +
			/* CHECK */ 1 +
			/* CALL */ MAX_BETS + 
			/* RAISE_FIXED */ MAX_BETS +
			/* RAISE_BB_RELATIVE */ MAX_BETS +
			/* RAISE_POT_RELATIVE */ MAX_BETS +
			/* RAISE_ALL_IN */ MAX_BETS +
			/* DEAL_FLOP */ (MAX_CARDS * MAX_CARDS * MAX_CARDS) +
			/* DEAL_TURN */ MAX_CARDS +
			/* DEAL_RIVER */ MAX_CARDS;

		ActionType getActionTypeFromKey(int64_t key) {
			if(key < 2) { // UNINIT - CALL
				return static_cast<ActionType>(key);
			}
			if(key < 2 + MAX_BETS) { // CALL
				return static_cast<ActionType>(ActionType::CALL);
			}
			if(key < 2 + (2 * MAX_BETS)) { // RAISE_FIXED
				return static_cast<ActionType>(ActionType::RAISE_FIXED);
			}
			if(key < 2 + (3 * MAX_BETS)) { // RAISE_BB_RELATIVE
				return static_cast<ActionType>(ActionType::RAISE_BB_RELATIVE);
			}
			if(key < 2 + (4 * MAX_BETS)) { // RAISE_POT_RELATIVE
				return static_cast<ActionType>(ActionType::RAISE_POT_RELATIVE);
			}
			if(key < 2 + (5 * MAX_BETS)) { // RAISE_ALL_IN
				return static_cast<ActionType>(ActionType::RAISE_ALL_IN);
			}
			if(key < 2 + (5 * MAX_BETS) + (MAX_CARDS*MAX_CARDS*MAX_CARDS)) { // DEAL_FLOP
				return static_cast<ActionType>(ActionType::DEAL_FLOP);
			}
			if(key < 2 + (5 * MAX_BETS) + (MAX_CARDS*MAX_CARDS*MAX_CARDS) + MAX_CARDS) { // DEAL_TURN
				return static_cast<ActionType>(ActionType::DEAL_TURN);
			}
			if(key < 2 + (5 * MAX_BETS) + (MAX_CARDS*MAX_CARDS*MAX_CARDS) + MAX_CARDS + MAX_CARDS) { // DEAL_RIVER
				return static_cast<ActionType>(ActionType::DEAL_RIVER);
			}
		}

		int64_t getAmountFromKey(int64_t key) {
			ActionType actionType = getActionTypeFromKey(key);
			switch(actionType) {
				case ActionType::FOLD:
				case ActionType::CHECK:
					return 0;
				case ActionType::CALL:
					return key - 2;
				case ActionType::RAISE_FIXED:
					return key - 2 - MAX_BETS;
				case ActionType::RAISE_BB_RELATIVE:
					return key - 2 - (2 * MAX_BETS);
				case ActionType::RAISE_POT_RELATIVE:
					return key - 2 - (3 * MAX_BETS);
				case ActionType::RAISE_ALL_IN:
					return key - 2 - (4 * MAX_BETS);
				case ActionType::DEAL_FLOP:
					return key - 2 - (5 * MAX_BETS);
				case ActionType::DEAL_TURN:
					return key - 2 - (5 * MAX_BETS) - (MAX_CARDS * MAX_CARDS * MAX_CARDS);
				case ActionType::DEAL_RIVER:
					return key - 2 - (5 * MAX_BETS) - (MAX_CARDS * MAX_CARDS * MAX_CARDS) - MAX_CARDS;
			}
		}
		unsigned encodeCall(unsigned amount) {
			return amount + 2;
		}
		unsigned encodeRaiseFixed(unsigned amount) {
			return amount + MAX_BETS + 2;
		}
		unsigned encodeRaiseBbRelative(unsigned amount) {
			return amount + (2 * MAX_BETS) + 2;
		}
		unsigned encodeRaisePotRelative(unsigned amount) {
			return amount + (3 * MAX_BETS) + 2;
		}
		unsigned encodeRaiseAllIn(unsigned amount) {
			return amount + (4 * MAX_BETS) + 2;
		}

		unsigned encodeDealFlop(unsigned x, unsigned y, unsigned z) {
			auto base = 2 + (5 * MAX_BETS) ;

			auto offset = (z * MAX_CARDS * MAX_CARDS) + (y * MAX_CARDS) + x;
			return base + offset;
			//  + (card1 * (MAX_CARDS * MAX_CARDS) + (card2 * MAX_CARDS) + card3);
			// Worst case (card 16)
		}
		unsigned encodeDealTurn(unsigned card) {
			return 2 + (5 * MAX_BETS) + (MAX_CARDS * MAX_CARDS * MAX_CARDS) + card;
		}
		unsigned encodeDealRiver(unsigned card) {
			return 2 + (5 * MAX_BETS) + (MAX_CARDS * MAX_CARDS * MAX_CARDS) + MAX_CARDS + card;
		}


		unsigned getFlopFromKey(int64_t key) {
			return key - 2 - (5 * MAX_BETS);
		}
		unsigned getTurnCardFromKey(int64_t key) {
			return key - 2 - (5 * MAX_BETS) - (MAX_CARDS * MAX_CARDS * MAX_CARDS);
		}
		unsigned getRiverCardFromKey(int64_t key) {
			return key - 2 - (5 * MAX_BETS) - (MAX_CARDS * MAX_CARDS * MAX_CARDS) - MAX_CARDS;
		}

		unsigned getFlopCard1(unsigned flop) {
			return flop / (MAX_CARDS * MAX_CARDS);
		}

		unsigned getFlopCard2(unsigned flop) {
			return (flop % (MAX_CARDS * MAX_CARDS)) / MAX_CARDS;
		}
		unsigned getFlopCard3(unsigned flop) {
			return flop % MAX_CARDS;
		}


		unsigned encode(ActionType actionType, unsigned am1 = 0, unsigned am2 = 0, unsigned am3 = 0) {
			switch(actionType) {
				case ActionType::FOLD:
					return static_cast<unsigned>(actionType);
				case ActionType::CHECK:
					return static_cast<unsigned>(actionType);
				case ActionType::CALL:
					return encodeCall(am1);
				case ActionType::RAISE_FIXED:
					return encodeRaiseFixed(am1);
				case ActionType::RAISE_BB_RELATIVE:
					return encodeRaiseBbRelative(am1);
				case ActionType::RAISE_POT_RELATIVE:
					return encodeRaisePotRelative(am1);
				case ActionType::RAISE_ALL_IN:
					return encodeRaiseAllIn(am1);
				case ActionType::DEAL_FLOP:
					return encodeDealFlop(am1, am2, am3);
				case ActionType::DEAL_TURN:
					return encodeDealTurn(am1);
				case ActionType::DEAL_RIVER:
					return encodeDealRiver(am1);
				default:
					return 0;
			}
		}
	}
}