path: root/kpoker/player.cpp

/*
 *     This program is free software; you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation; either version 2 of the License, or
 *     (at your option) any later version.
 * 
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 * 
 *     You should have received a copy of the GNU General Public License
 *     along with this program; if not, write to the Free Software
 *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */


#include <stdio.h>
#include <assert.h>

#include "player.h"
#include "defines.h"


// ================================================================
//                         class Player


PokerPlayer::PokerPlayer()
  : m_hand()
{
  m_name = "Player";
  m_isHuman = false;

  m_money    = START_MONEY;
  currentBet = 0;

  isOut = false;
  // random.setSeed(0);
}


PokerPlayer::~PokerPlayer()
{
}


// ----------------------------------------------------------------


void PokerPlayer::giveCardsBack()
{
  m_hand.clear();
}


void PokerPlayer::giveCardBack(int cardNr)
{
  m_hand.clear(cardNr);
}


/* Set skip[i] to true if the corresponding card should *not* be
 * exchanged.
 */

void PokerPlayer::exchangeCards(bool skip[])
{ 
  //TODO: improve!
  // this is still a VERY simple method!

  m_hand.analyze();
  for (int i = 0; i < PokerHandSize; i++) {
    skip[i] = m_hand.getFoundCard(i);
  }
}


/* Prepare the player for a new round.
 */

void PokerPlayer::newRound()
{
  giveCardsBack();

  currentBet = 0;
  isOut      = false;
}


int PokerPlayer::bet(int origBet, bool mayRaise)
{
  // NOT useable for (status == continueBet) !!!
  // needs a rewrite for games with > 2 players
  int bet = origBet;

  // first bet minBet
  currentBet = minBet;
  m_money -= currentBet;
  bet -= currentBet;
  int newBet = bet; // bet at least the old bet

  if (bet > getCash())// we don't have the money :-(
    return 0;

  // calculate the chances and bet any value
  int chance = sortedResult();

  if (chance < 350) { // 3 of a kind or better!!
    newBet =  maxBet - (int)random.getLong(maxBet /2);//we subtract a 
    // random number to hide our cards (every player would
    // know we have good cards if we would bet maxBet) 
  }
  else if (chance < 400) { // 2 pairs
    newBet = bet + (int)random.getLong(maxBet /2 + origBet);
    if (newBet > maxBet)
      newBet = maxBet;
  }
  else if (chance < 500) { // one pair
    newBet = bet + (int)random.getLong(maxBet /4 + 1);
    if (newBet > getCash() - 2 * minBet)
      newBet = bet;
    if (bet >= getCash() /3)
      newBet = 0;
  }
  else if (chance < 506) { // best card is at least a ten
    newBet = bet;
    if (bet >= getCash() /3)
      newBet = 0;
  }
  else { // bad cards
    if (getCash() - bet >= bet) {// we would still have some money
      newBet = bet;
      if (bet >= getCash() /4)
	newBet = 0;
    }
    else
      newBet = 0;
  }

  // and now a final re-check
  if (newBet > bet) {
    if (random.getLong(20) == 0)
      newBet = bet;
    else if (random.getLong(30) <= 1)
      newBet = bet + (newBet - bet) /2;
  }

  if (newBet > getCash())
    newBet = bet; // maybe raise only a little bit but by now just do not raise

  if (!mayRaise && newBet > bet)
    newBet = bet;

  if (!changeBet(newBet))
    return 0; // BIG error

  return currentBet;
}


int PokerPlayer::raise(int origRaise)
{
  // NOT useable for (status == continueRaise) !!!
  // needs a rewrite for games with > 2 players
  int raise    = origRaise - getCurrentBet();
  int newRaise = raise;

  if (newRaise > getCash())// we don't have the money :-(
    return 0;

  // Calculate the chances and bet any value.
  int chance = sortedResult();

  if (chance < 350) { // 3 of a kind or better!!
    newRaise =  maxBet - (int)random.getLong(maxBet - maxBet /2);
    // we subtract a random number to hide our cards 
    // (every player would know we have good cards if 
    // we would bet maxBet) 
  }
  else if (chance < 400) { // 2 pairs
    newRaise = raise + (int)random.getLong(maxBet /2 + origRaise + 10);
    if (newRaise > maxBet)
      newRaise = maxBet;
  }
  else if (chance < 500) { // one pair
    newRaise = raise + (int)random.getLong(maxBet /4 + 1);
    if (newRaise > getCash() - 2 * minBet)
      newRaise = raise;
    if (raise >= getCash() /2)
      newRaise = 0;
  }
  else if (chance < 506) { // best card is at least a ten
    newRaise = raise;
    if (raise >= getCash() /2)
      newRaise = 0;
  }
  else { // bad cards
    if (getCash() - raise >= raise && raise <= minBet * 2) { // we would still have some money
      if (raise > getCash() /2)
	newRaise = 0;
      else
	newRaise = raise;
    }
    else
      newRaise = 0;
  }

  // And now a final re-check.
  if (newRaise > raise) {
    if (random.getLong(20) == 0)
      newRaise = raise;
    else if (random.getLong(30) <= 1)
      newRaise = raise + (newRaise - raise) /2;
  }

  if (newRaise > getCash())
    newRaise = raise; // maybe raise only a little bit but by now just do not raise

  if (!changeBet(newRaise))
    return 0; // BIG error

  return currentBet;
}


bool PokerPlayer::changeBet(int betChange)
{
  if (currentBet + betChange >= 0 && getCash() - betChange >= 0) {
    setCash(getCash() - betChange);
    currentBet += betChange;
    return true;
  }
  return false;
}


int PokerPlayer::sortedResult()
{
  PokerHandType result = m_hand.analyze();

  //Ok, the result produced by testHand() is a little bit... uncomfortable
  //so lets sort it for use in displayWinner_Computer()
  //additionally we extend the values e.g. by bestCard and so on

  int newResult = m_hand.getCardScore();

  // FIXME: Change this so that scores are higher for better hands.
  //        Don't forget to change m_hand.getCardScore() as well.
  switch (result) {
  case RoyalFlush:
    newResult += 0; // the royal flush is the best you can get
    break;
  case StraightFlush:
    newResult += 50; // straight flush
    break;
  case FourOfAKind:
    newResult += 100; // 4 of a kind
    break;
  case FullHouse:
    newResult += 150; // full house
    break;
  case Flush:
    newResult += 200; // flush
    break;
  case Straight:
    newResult += 250; // straight
    break;
  case ThreeOfAKind:
    newResult += 300; // 3 of a kind
    break;
  case TwoPairs:
    newResult += 350; // two pairs
    break;
  case Pair:
    newResult += 400; // one pair
    break;
  case HighCard:
    {
      CardValue  bestCard = m_hand.findNextBest(ROOF, false);
      newResult = 500 + ((int) H_ACE - (int) bestCard);
    }
    break;

  default:
    // Shouldn't get here.
    assert(0);
  }

  return newResult;
  // The lowest newResult is now the best.
}