R/poker.R

Defines functions cgiPlayers tiebreaker dotStraightFlush dotStraightFlushRanker dotFourOfAKind dotFourOfAKindRanker dotFullHouse dotFullHouseRanker dotFlush dotFlushRanker dotStraight dotStraightRanker dotTrips dotTripRanker dotTwoPairs dotTwoPairRanker dotPair dotPairRanker dotHighcard dotHighcardCompare showdown dotScorer dotTransformToAbsolute transformToRelative dotTransformToNumber dotTransformToSuit dotTransformToRank hand assignToBoard assignToPlayers dotTestDealer deal testRoundOfPoker

Documented in assignToBoard assignToPlayers cgiPlayers deal dotFlush dotFlushRanker dotFourOfAKind dotFourOfAKindRanker dotFullHouse dotFullHouseRanker dotHighcard dotHighcardCompare dotPair dotPairRanker dotScorer dotStraight dotStraightFlush dotStraightFlushRanker dotStraightRanker dotTestDealer dotTransformToAbsolute dotTransformToNumber dotTransformToRank dotTransformToSuit dotTripRanker dotTrips dotTwoPairRanker dotTwoPairs hand showdown testRoundOfPoker tiebreaker transformToRelative

####################
#'testRoundOfPoker
#'
#'Run a test round of poker.
#'
#'@return Outputs a plot window showing the cards dealt as well as prints to the console the summary text, i.e., each hand's score and the winner.
#'@seealso \code{\link{deal}}, \code{\link{assignToPlayers}}, \code{\link{assignToBoard}}, \code{\link{hand}}, \code{\link{showdown}}, \code{\link{tiebreaker}}, and \code{\link{cgiPlayers}}
#'@examples 
#'testRoundOfPoker()
#'@export
testRoundOfPoker <- function() {
	alias <- c("Player 1", "Player 2","Player 3", "Player 4", "Player 5", "Player 6", "Player 7", "Player 8", "Player 9")
	nPlayers <- length(alias)
	position <- nPlayers

	y <- deal(nPlayers, position)
	players <- assignToPlayers(nPlayers, position, y)
	board <- assignToBoard(y)
	cards <- hand(players, board)
	score <- showdown(cards)
	winner <- tiebreaker(nPlayers,cards,score)

	round <- 1
	cgiPlayers(round, alias, position, cards)
	round <- 2
	cgiPlayers(round, alias, position, cards)
	round <- 3
	cgiPlayers(round, alias, position, cards)
	round <- 4
	cgiPlayers(round, alias, position, cards)

	cat("Please look at the graphics window to see the current hand.\n\nThe score of each player is one of the following:\n\t9 = Straight Flush\n\t8 = Four of a Kind\n\t7 = Full House\n\t6 = Flush\n\t5 = Straight\n\t4 = Three of a Kind\n\t3 = Two Pair\n\t2 = Pair\n\t1 = Highcard\nThe scores for this hand are:\n\tPlayer 1: ",score[1],"\n\tPlayer 2: ",score[2],"\n\tPlayer 3: ",score[3],"\n\tPlayer 4: ",score[4],"\n\tPlayer 5: ",score[5],"\n\tPlayer 6: ",score[6],"\n\tPlayer 7: ",score[7],"\n\tPlayer 8: ",score[8],"\n\tPlayer 9: ",score[9],".\nThe winners of this hand are Players",winner,".\n\nThank you for playing.")
}


#'deal
#'
#'Generate Player+Community cards = 2x(nPlayers)+5 cards.
#'
#'@param		nPlayers number of hands to deal as 
#'												integer in \{2, ... , 9\}
#'@param		position dealer position 		as integer in \{2, ..., nPlayers\}
#'@return		y : cards dealt in hole			as vector[nCards] in \{1, 2, ..., 52\}
#'@examples
#'deal(9,9)
#'deal(9,1)
#'@export
deal <- function(nPlayers, position) {
	nCards <- 2*nPlayers+5
	y <- numeric(nCards)
				#create a vector for the cards
	y <- sample(1:52, nCards, replace=FALSE, prob=rep(1/52,52))
				#deal numbers in \{1, 2, ... , 52\}
	y
}


#'dotTestDealer
#'
#'Assume player 1 already has cards.  For remaining players, generate Player+Community cards = 2x(nPlayers-1)+5 cards. \cr
#'
#'@param nPlayers number of hands to deal as 
#'												integer in \{2, ... , 9\}
#'@param position dealer position 	as integer in \{2, ..., nPlayers\}
#'@param holeCards the hand of player 1 as vector[2] in \{1, 2, ..., 52\}
#'@return y : cards dealt in hole as		vector[nCards] in \{1, 2, ..., 52\}
#'@examples
#'dotTestDealer(9,9,c(1,52))
#'dotTestDealer(9,5,c(1,52))
#'dotTestDealer(5,2,c(3,42))
#'@export
dotTestDealer <- function(nPlayers, position,holeCards) {
	nCards <- 2*nPlayers+5
	y <- numeric(nCards)
				#create a vector for the cards
	y[c(1,nPlayers+1)] <- holeCards
				#the cards for player 1
	y[-c(1,nPlayers+1)] <- sample(subset(1:52, 1:52 != holeCards), nCards-2)
				#deal numbers in \{1, 2, ... , 52\}
	y
}



#'assignToPlayers
#'
#'A standard deal situation beginnng the deal at the left of the dealer.
#'
#'@param nPlayers number of hands to deal as
#'												integer in \{2, ... , 9\}
#'@param position dealer position as	integer in \{2, ..., nPlayers\}
#'@param y cards dealt as					vector[2*nPlayers+5] in \{1, 2, ..., 52\}
#'@seealso \code{\link{dotTransformToAbsolute}}
#'@return \tabular{ll}{players :	the hole cards in absolute position \tab
#'												as matrix[nPlayers, 4] in \{1, 2, ..., 52\} \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2}
#'@examples
#'assignToPlayers(9,9,1:23)
#'assignToPlayers(9,1,1:23)
#'assignToPlayers(9,1,c(1:17,24,48:52))
#'@export
assignToPlayers <- function(nPlayers, position, y) {
	players <- matrix(0, nPlayers, 2) 
				#create a vector for the hole cards
	for (i in 1:2) {
		for (k in 1:nPlayers) {	
			players[dotTransformToAbsolute(nPlayers,position,k), i] <- y[(i-1)*nPlayers+k]
				#(i-1)*nPlayers+k : number of cards dealt at this time
												#integer in {1, 2, ..., 2*nPlayers}
			}
		}
	players
}



#'assignToBoard
#'
#'Deal 3 community cards.
#'
#'@param y cards dealt as					vector[2*nPlayers+3] in \{1, 2, ..., 52\}
#'@return board :	the board cards	as		vector[5] in \{1, 2, ..., 52\}
#'@examples
#'assignToBoard(1:23)
#'assignToBoard(c(1:17,24,48:52))
#'@export
assignToBoard <- function(y) {
	board <- numeric(5)
				#create a vector for the board cards
	board <- y[(length(y)-4):length(y)]
				#assign the board cards
	board
}


#'hand
#'
#'Assemble the 7 card hands.
#'
#'@param players : \tabular{ll}{the hole cards as			matrix[nPlayers, 4] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2}
#'@param board the board cards	as		vector[5] in \{1, 2, ..., 52\}
#'@return \tabular{ll}{cards : the 7 card hand as
#'												matrix[nPlayers, 14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab 
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@seealso \code{\link{dotTransformToRank}} and \code{\link{dotTransformToSuit}}
#'@examples
#'hand(matrix(1:18,9,2,byrow=TRUE),19:23)
#'hand(matrix(c(1:9,14:22),9,2),48:52)
#'@export
hand <- function(players, board) {
	nPlayers <- nrow(players)
				#create a variable for the number of players
	cards <- matrix(0, nrow=nPlayers, ncol = 14)
				#create a variable for the cards
	for (i in 1:nPlayers) {
		j <- 1:2
			cards[i, 2*j-1] <- dotTransformToRank(players[i,])
				#2*j-1 : column for rank	#integer in {1, 3}
			cards[i, 2*j] <- dotTransformToSuit(players[i,])
				#2*j : column for rank	#integer in {2, 4}
		j <- 1:5
			cards[i, 4+2*j-1] <- dotTransformToRank(board)
				#4+2*j-1 : column for rank	#integer in {5, 7, 9, 11, 13}
			cards[i, 4+2*j] <- dotTransformToSuit(board)
				#4+2*j :column for suit		#integer in {6, 8, 10, 12, 14}
		}
	cards
}


#'dotTransformToRank
#'
#'Determine the rank of a card.
#'
#'@param y number corresponding to card as
#'												integer in \{1, 2, ... , 52\} \cr
#'@return \tabular{ll}{rank: rank of card y as  
#'												integer in \{2, ... , 14\} \tab \cr \tab
#'												 2 = deuce \cr \tab
#'												 . \cr \tab
#'												 . \cr \tab
#'												 . \cr \tab
#'												 11 = jack \cr \tab
#'												 12 = queen \cr \tab
#'												 13 = king \cr \tab
#'												 14 = ace}
#'@examples
#'dotTransformToRank(1)
#'dotTransformToRank(13)
#'dotTransformToRank(14)
#'dotTransformToRank(26)
#'@export
dotTransformToRank <- function(y) {
	rank <- (y-1) %% 13+2
				#(y-1) %% 13+2: rank of this card
	rank
}


#'dotTransformToSuit
#'
#'Determine the suit of a card.
#'
#'@param y number corresponding to card as
#'												integer in \{1, 2, ... , 52\}
#'@return \tabular{ll}{suit: suit of card y as
#'												integer in \{1, 2, 3, 4\} \tab \cr \tab
#'												 1 = spade \cr \tab
#'												 2 = club \cr \tab
#'												 3 = heart \cr \tab
#'												 4 = diamond}
#'@examples
#'dotTransformToSuit(1)
#'dotTransformToSuit(13)
#'dotTransformToSuit(14)
#'dotTransformToSuit(26)
#'@export
dotTransformToSuit <- function(y) {
	suit <-  (y-1) %/% 13+1
				#(y-1) %/% 13+1: suit of this card
	suit
}


#'dotTransformToNumber
#'
#'Determine the card from a rank and suit.
#'
#'@param rank : \tabular{ll}{rank of card y as  
#'												integer in \{2, ... , 14\} \tab \cr \tab
#'												 2 = deuce \cr \tab
#'												 . \cr \tab
#'												 . \cr \tab
#'												 . \cr \tab
#'												 11 = jack \cr \tab
#'												 12 = queen \cr \tab
#'												 13 = king \cr \tab
#'												 14 = ace}
#'@param suit : \tabular{ll}{suit of card y as
#'												integer in \{1, 2, 3, 4\} \tab \cr \tab
#'												 1 = spade \cr \tab
#'												 2 = club \cr \tab
#'												 3 = heart \cr \tab
#'												 4 = diamond}
#'@return y: number corresponding to card as
#'												integer in \{1, 2, ... , 52\}
#'@examples
#'dotTransformToNumber(2,1)
#'dotTransformToNumber(14,1)
#'dotTransformToNumber(2,2)
#'dotTransformToNumber(14,2)
#'@export
dotTransformToNumber <- function(rank, suit) {
	y <- 13*(suit-1)+(rank-2)+1
				#the number of this card
	y
}


#'transformToRelative
#'
#'Transforms an absolute position (i.e., seat at the table) into a relative position (i.e., seats behind the dealer)
#'
#'@param nPlayers number of hands to deal as
#'												integer in \{2, ... , 9\}
#'@param position dealer position as		integer in \{2, ..., nPlayers\}
#'@param j absolute position of a player as
#'												integer in \{1, 2, ... , nPlayers\}
#'@return k : relative position of a player as
#'												integer in \{1, 2, ... , nPlayers\}
#'@examples
#'transformToRelative(9,9,9)
#'transformToRelative(9,9,8)
#'transformToRelative(9,1,9)
#'transformToRelative(9,5,2)
#'@export
transformToRelative <- function(nPlayers, position, j) {
	if (j-position == 0) k <- 0
	else if (j-position > 0) k <- j-position		
	else k <- j-position+nPlayers
	k
}
	

#'dotTransformToAbsolute
#'
#'Transform a relative position (i.e., seats behind the dealer) into an absolute position (i.e., seat at the table).
#'
#'@param nPlayers number of hands to deal as
#'												integer in \{2, ... , 9\}
#'@param position dealer position as		integer in \{2, ..., nPlayers\}
#'@param k relative position of a player as
#'												integer in \{1, 2, ... , nPlayers\}
#'@return j : absolute position of a player as
#'												integer in \{1, 2, ... , nPlayers\}
#'@examples
#'dotTransformToAbsolute(9,9,0)
#'dotTransformToAbsolute(9,9,8)
#'dotTransformToAbsolute(9,1,8)
#'dotTransformToAbsolute(9,5,6)

#'@export
dotTransformToAbsolute <- function(nPlayers, position, k) {
	j <- (k+position-1)%%nPlayers+1
	j
}


#'dotScorer
#'
#'Determine the ranking of one hand.
#'
#'@param cardsRow : \tabular{ll}{one 7 card hand as
#'												vector[14] \tab  \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@return \tabular{ll}{ranking : the rank of the hand as
#'												integer in \{2, ... , 9\} \tab \cr \tab
#'												 9 = Straight Flush \cr \tab
#'												 8 = Four of a Kind \cr \tab
#'												 7 = Full House \cr \tab
#'												 6 = Flush \cr \tab
#'												 5 = Straight \cr \tab
#'												 4 = Three of a Kind \cr \tab
#'												 3 = Two Pair \cr \tab
#'												 2 = One Pair \cr \tab
#'												 1 = High Card}
#'@seealso \code{\link{dotTransformToNumber}}, \code{\link{dotTransformToRank}}
#'@examples
#'dotScorer(c(2,1,3,2,5,3,6,4,7,1,13,2,14,2))
#'dotScorer(c(2,1,2,2,5,3,6,4,7,1,13,2,14,2))
#'dotScorer(c(2,1,2,2,5,3,5,4,7,1,13,2,14,2))
#'dotScorer(c(2,1,2,2,2,3,5,4,7,1,13,2,14,2))
#'dotScorer(c(2,1,3,2,4,3,5,4,6,1,13,2,14,2))
#'dotScorer(c(2,1,3,1,5,1,6,1,7,1,13,2,14,2))
#'dotScorer(c(2,1,2,2,2,8,13,8,7,1,13,2,14,2))
#'dotScorer(c(2,1,2,2,2,3,2,4,7,1,13,2,14,2))
#'dotScorer(c(2,1,3,1,4,1,5,1,6,1,7,1,14,2))
#'@export
dotScorer <- function(cardsRow) {
	ranks <- seq(from = 1, to = 13, by = 2)
				#the columns of rank
	suits <- seq(from = 2, to = 14, by = 2)
				#the columns of suit
	sortedSuits <- sort(cardsRow[suits])
				#sort the suits from low to high
	sortedRanks <- sort(cardsRow[ranks])
				#sort the ranks
	suitValues <- rle(sortedSuits)$values
				#the unique suits
	suitLengths <- rle(sortedSuits)$lengths
				#the length of the unique suits
	rankValues <- rle(sortedRanks)$values
				#the unique ranks
	rankLengths <- rle(sortedRanks)$lengths
				#the length of the unique ranks
	k <- length(rankValues)
				#create a variable for the length of the length of unique ranks
	kgt4 <- k - 4
				#create a variable for the number of sequences to check in a straight
	straight <- FALSE
				#create an indicator variable for the presence of a straight
	straightFlush <- FALSE
				#create an indicator variable for the presence of a straight flush
	#determine the ranking of the hand
	#high card
	if (sum(rankLengths > 1) == 0) ranking <- 1
	#one pair
	if (sum(rankLengths == 2) == 1) ranking <- 2
	#two pair 
	if (sum(rankLengths == 2) >= 2) ranking <- 3
				#there can be two or three pairs
	#three of a kind
	if (sum(rankLengths == 3) >= 1) ranking <- 4
				#there can be one or two sets
	#straight 
	if (k >= 5) {
				#if there are 5 unique ranks
		if (sum(rankValues[c(k,1,2,3,4)] == c(14,2,3,4,5)) == 5) straight <- TRUE
							#check for wrap around
							#aka a low straight or wheel
		for (i in 1:kgt4) {
							#check kgt4 number of sequences
			if (rankValues[i+4] == (rankValues[i]+4)) straight <- TRUE
							#if the (i+4)th rank is the ith rank plus four 
							#the high card is the (i+4)th rank
		}
		if (straight == TRUE) ranking <- 5
	}
	#flush
	if (sum(suitLengths >= 5) == 1 ) ranking <- 6
	#full house
	if (sum(rankLengths == 3) == 2 | (sum(rankLengths == 3) == 1 & sum(rankLengths == 2) >= 1)) {
				#if there are 
				#two sets
				#or
				#a set and one/two pairs
		ranking <- 7	
	}
	#four of a kind
	if (sum(rankLengths == 4) == 1) ranking <- 8
	#straight flush
	if (straight == TRUE & sum(suitLengths >= 5) == 1) {
				#if there is
				#a straight
				#and 
				#a flush
		yTemp <- dotTransformToNumber(cardsRow[ranks],cardsRow[suits])
				#transform cards to number
		yTemp <- sort(yTemp)
				#sort the numbers	
		for (i in 0:3){
						#check each suit for a flush and a wheel
					if (sum(yTemp %in% c(13+13*i,1+13*i,2+13*i,3+13*i,4+13*i)) == 5) straightFlush <- TRUE
						#check each suit for a flush and a straight
					if (sum(yTemp %in% c(1+13*i,2+13*i,3+13*i,4+13*i,5+13*i)) == 5) straightFlush <- TRUE
					if (sum(yTemp %in% c(2+13*i,3+13*i,4+13*i,5+13*i,6+13*i)) == 5) straightFlush <- TRUE
					if (sum(yTemp %in% c(3+13*i,4+13*i,5+13*i,6+13*i,7+13*i)) == 5) straightFlush <- TRUE
					if (sum(yTemp %in% c(4+13*i,5+13*i,6+13*i,7+13*i,8+13*i)) == 5) straightFlush <- TRUE
					if (sum(yTemp %in% c(5+13*i,6+13*i,7+13*i,8+13*i,9+13*i)) == 5) straightFlush <- TRUE
					if (sum(yTemp %in% c(6+13*i,7+13*i,8+13*i,9+13*i,10+13*i)) == 5) straightFlush <- TRUE
					if (sum(yTemp %in% c(7+13*i,8+13*i,9+13*i,10+13*i,11+13*i)) == 5) straightFlush <- TRUE
					if (sum(yTemp %in% c(8+13*i,9+13*i,10+13*i,11+13*i,12+13*i)) == 5) straightFlush <- TRUE
					if (sum(yTemp %in% c(9+13*i,10+13*i,11+13*i,12+13*i,13+13*i)) == 5) straightFlush <- TRUE
		}
		if (straightFlush == TRUE) ranking <- 9
	}
	ranking
}


#'showdown
#'
#'Determine the ranking of the hands.
#'
#'@param cards : \tabular{ll}{the 7 card hand as 
#'												matrix[nPlayers, 14]  \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2}
#'@return \tabular{ll}{score : the score of the hand in absolute terms as
#'												vector[nPlayers] \tab \cr \tab
#'												 9 = Straight Flush \cr \tab
#'												 8 = Four of a Kind \cr \tab
#'												 7 = Full House \cr \tab
#'												 6 = Flush \cr \tab
#'												 5 = Straight \cr \tab
#'												 4 = Three of a Kind \cr \tab
#'												 3 = Two Pair \cr \tab
#'												 2 = One Pair \cr \tab
#'												 1 = High Card}
#'@seealso \code{\link{dotScorer}}
#'@examples
#'showdown(matrix( c( 2,1,3,2,5,3,6,4,7,1,13,2,14,2,2,3,2,4,5,1,6,2,7,3,13,4,14,4),2,14,byrow=TRUE))
#'@export
showdown <- function(cards) {
	score <- apply(cards,1,dotScorer)
	score
	}
	

#'dotHighcardCompare
#'
#'Determine the player(s) with the high card.
#'
#'@param rankMatrix : \tabular{ll}{the ranks from the 7 card hand as
#'												matrix[nPlayers, 7] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: rank of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col7: rank of card 7}
#'@return winner : absolute position of the winner as
#'												vector
#'@examples
#'dotHighcardCompare(matrix(c(2,4,5,6,7,13,14,2,3,5,6,7,13,14),2,7,byrow=TRUE))
#'dotHighcardCompare(matrix(c(2,3,5,6,7,13,14,2,3,5,6,7,13,14),2,7,byrow=TRUE))
#'@export
dotHighcardCompare <- function(rankMatrix) {
	#rankMatrix <- t(apply(rankMatrix,1,sort,decreasing=TRUE))
							#sort the ranks 
							#CANT APPLY IF RANKMATRIX IS A ROW
							#UNNECESSARY IF RANKMATRIX IS SORTED CORRECTLY
							
	for (step in 2:ncol(rankMatrix)) {
		Tie <- which(rankMatrix[,step-1]==max(rankMatrix[,step-1])) 
							#determine which rows are tied
		rankMatrix[-Tie,] <- 0		
							#zero out the others
		winner <- which(rankMatrix[,step]==max(rankMatrix[,step]))
							#which of the hands have the high card hand
	}
	winner
}


#'dotHighcard
#'
#'Determine the player(s) with a high card hand.
#'
#'@param cards : \tabular{ll}{ the 7 card hand as
#'												matrix[nPlayers, 14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@return winner : absolute position of the winner as
#'												vector 
#'@seealso \code{\link{dotHighcardCompare}}
#'@examples
#'dotHighcard(matrix(c(2,1,14,2,5,3,6,4,7,1,13,2,14,3,2,3,3,4,5,1,6,2,7,3,13,4,14,1),2,14,byrow=TRUE))
#'dotHighcard(matrix(c(2,1,3,2,5,3,6,4,7,1,13,2,14,3,2,3,3,4,5,1,6,2,7,3,13,4,14,1),2,14,byrow=TRUE))
#'@export
dotHighcard <- function(cards) {
	ranks <- seq(from = 1, to = 13, by = 2)	
							#the columns for rank
	temp <- cards[, ranks] 	#assume score = 1 for all players
							#create a copy of cards with ranks only
							#sorts the ranks
	temp <- t(apply(temp,1,sort,decreasing=TRUE))
							#systematic scan
	winner <- dotHighcardCompare(temp)
	winner
}	


#'dotPairRanker
#'
#'Determine the rank of the pair.  Notes: dotPairRanker requires a hand with a score of 2 (i.e., a pair). This functions works best when ranks are sorted in decreasing order.
#'
#'@param oneHand : \tabular{ll}{a sorted hand with ranks only as
#'												vector[7] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: rank of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col7: rank of card 7}
#'@return pairRank : the rank of the pair as
#'												vector
#'@examples
#'dotPairRanker(c(2,2,5,6,7,13,14))
#'@export
dotPairRanker <- function(oneHand) {
	rankValues <- rle(oneHand)$values
				#the unique ranks
	rankLengths <- rle(oneHand)$lengths
				#the length of the unique ranks
	pairRank <- rankValues[rankLengths == 2]
				#the rank of the pair
	pairRank
}


#'dotPair
#'
#'Determine the player(s) with the highest pair and kicker cards.
#'
#'@param nPlayers number of hands as		integer in \{2, ... , 9\}
#'@param cards : \tabular{ll}{the 7 card hands as
#'												matrix[nPlayers, 14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@param score : \tabular{ll}{the score of the hands in absolute terms as
#'												vector[nPlayers] \tab \cr \tab
#'												 9 = Straight Flush \cr \tab
#'												 8 = Four of a Kind \cr \tab
#'												 7 = Full House \cr \tab
#'												 6 = Flush \cr \tab
#'												 5 = Straight \cr \tab
#'												 4 = Three of a Kind \cr \tab
#'												 3 = Two Pair \cr \tab
#'												 2 = One Pair \cr \tab
#'												 1 = High Card}
#'@return winner : absolute position of the winner as
#'												vector
#'@seealso \code{\link{dotPairRanker}} and \code{\link{dotHighcardCompare}}
#'@examples
#'cards <- c(2,3,4,1,1,1,2,3,6,2,2,2,4,4,4,3,3,3,11,11,11,3,3,3,13,13,13)
#'cards <- c(cards,3,3,3,14,14,14,3,3,3,9,9,9,4,4,4)
#'cards <- matrix(cards,nrow=3,ncol=14)
#'dotPair(3,cards,c(2,2,2))
#'@export
dotPair <- function(nPlayers,cards,score) {
	ranks <- seq(from = 1, to = 13, by = 2)	
							#the columns for rank
	temp <- cards[,ranks]	#create a copy of cards with ranks only
	temp[which(score!=2),] <- 0 	
							#when there is not a pair,
							#set the copy to zero.
	temp <- t(apply(temp,1,sort,decreasing=TRUE))
							#sorts the ranks
	pairRanks <- rep(0, nrow(temp))
							#create a vector for pair rank
	pairRanks[which(score==2)] <- apply(temp[which(score==2),],1,dotPairRanker)
							#determine the pairRank
	winner <- which(pairRanks == max(pairRanks))
							#the absolute position of players with the highest pair
							#
							#systematic scan for kicker cards
	temp[-winner,] <- 0
							#if not the highest pair, set to zero
	kickers <- matrix(0, nrow=nrow(temp), ncol=3)
							#create a copy of cards with kickers only.
	for (i in 1:nPlayers){
			if (temp[i,1]==0) kickers[i,1:3] = 0
							#kickers are zero if not highest pair
			else kickers[i,] <- subset(temp[i,], temp[i,] != pairRanks[i])[1:3]
							#otherwise, kickers are 3 highest nonpair cards
	}
	winner <- dotHighcardCompare(kickers)
							#determine the player with the top kicker
	winner
}


#'dotTwoPairRanker
#'
#'Determine the ranks of the two pairs.  Notes: dotTwoPairRanker requires a hand with a score of 3 (i.e., two pairs). This functions works best when ranks are sorted in decreasing order.
#'
#'@param oneHand : \tabular{ll}{a sorted hand with ranks only as
#'												vector[7] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: rank of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col7: rank of card 7}
#'@return pairRank : the rank of the pair as
#'												vector
#'@examples
#'dotTwoPairRanker(c(9,7,5,3,3,2,2))
#'dotTwoPairRanker(c(9,5,5,3,3,2,2))
#'@export
dotTwoPairRanker <- function(oneHand) {
	rankValues <- rle(oneHand)$values
				#the unique ranks
	rankLengths <- rle(oneHand)$lengths
				#the length of the unique ranks
	pairRank <- rankValues[rankLengths == 2]
				#the ranks of the pairs
	pairRank[1:2]
				#the rank of the top two pairs
}


#'dotTwoPairs
#'
#'Determine the player(s) with the highest two pairs and kicker card.
#'
#'@param nPlayers number of hands as		integer in \{2, ... , 9\}
#'@param cards : \tabular{ll}{the 7 card hand as
#'												matrix[nPlayers, 14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@param score : \tabular{ll}{the score of the hand in absolute terms as
#'												vector[nPlayers] \tab \cr \tab
#'												 9 = Straight Flush \cr \tab
#'												 8 = Four of a Kind \cr \tab
#'												 7 = Full House \cr \tab
#'												 6 = Flush \cr \tab
#'												 5 = Straight \cr \tab
#'												 4 = Three of a Kind \cr \tab
#'												 3 = Two Pair \cr \tab
#'												 2 = One Pair \cr \tab
#'												 1 = High Card}
#'@return winner : absolute position of the winner as
#'												vector
#'@seealso \code{\link{dotTwoPairRanker}} and \code{\link{dotHighcardCompare}}
#'@examples
#'cards <- c(2,3,4,5,1,1,1,1,2,3,6,7,2,2,2,2,4,4,4,4,3,3,3,3,11,11,11,11,3,3,3,3)
#'cards <- c(cards,13,13,13,13,3,3,3,3,14,14,14,14,3,3,3,3,14,14,14,14,4,4,4,4)
#'cards <- matrix(cards,nrow=4,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'dotTwoPairs(nPlayers,cards,score)
#'@export
dotTwoPairs <- function(nPlayers,cards,score) {
	ranks <- seq(from = 1, to = 13, by = 2)	
							#the columns for rank
	temp <- cards[,ranks]	#create a copy of cards with ranks only
	temp[which(score!=3),] <- 0 	
							#when there is not a set,
							#set the copy to zero.
	temp <- t(apply(temp,1,sort,decreasing=TRUE))
							#sorts the ranks
	pairRanks <- matrix(0, nPlayers,2)
							#create a vector for pair ranks
	pairRanks[which(score==3),] <- t(apply(temp[which(score==3),],1,dotTwoPairRanker))
							#determine the ranks of the pairs
	winner <- dotHighcardCompare(pairRanks)
							#determine which players have the highest two pair
	temp[-winner,] <- 0
							#if not the highest two pairs, set to zero
	kickers <- matrix(0, nrow=nrow(temp), ncol=1)
							#create a copy of cards with kickers only.
	for (i in 1:nPlayers){
			if (temp[i,1]==0) kickers[i,1] = 0
							#kickers are zero if not highest two pair
			else kickers[i,] <- subset(temp[i,],temp[i,] != pairRanks[i,1] & temp[i,] != pairRanks[i,2])[1]
							#otherwise, kicker is highest card not in the top and bottom pair
	}
	winner <- which(kickers == max(kickers))
							#determine which hand with top and bottom pair has the highest kicker
	winner
}


#'dotTripRanker
#'
#'Determine the rank of the three of a kind.  Note: dotTripRanker requires a hand with a score of 4 (i.e., three of a kind).
#'
#'@param oneHand : \tabular{ll}{a sorted hand with ranks only as
#'												vector[7] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: rank of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col7: rank of card 7}
#'@return tripRank : the rank of the pair as
#'												vector
#'@examples
#'dotTripRanker(c(9,7,5,3,3,3,2))
#'@export
dotTripRanker <- function(oneHand) {
	rankValues <- rle(oneHand)$values
				#the unique ranks
	rankLengths <- rle(oneHand)$lengths
				#the length of the unique ranks
	tripRank <- rankValues[rankLengths == 3]
				#the ranks of the sets
	tripRank[1]
				#the rank of the top set
}


#'dotTrips
#'
#'Determine the player(s) with the highest three of a kind and kicker cards.
#'
#'@param nPlayers number of hands as		integer in \{2, ... , 9\}
#'@param cards : \tabular{ll}{the 7 card hand as
#'												matrix[nPlayers, 14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@param score : \tabular{ll}{the score of the hand in absolute terms as
#'												vector[nPlayers] \tab \cr \tab
#'												 9 = Straight Flush \cr \tab
#'												 8 = Four of a Kind \cr \tab
#'												 7 = Full House \cr \tab
#'												 6 = Flush \cr \tab
#'												 5 = Straight \cr \tab
#'												 4 = Three of a Kind \cr \tab
#'												 3 = Two Pair \cr \tab
#'												 2 = One Pair \cr \tab
#'												 1 = High Card}
#'@return winner : absolute position of the winner as
#'												vector
#'@seealso \code{\link{dotTripRanker}} and \code{\link{dotHighcardCompare}}
#'@examples
#'cards <- c(14,14,4,5,1,2,1,1,10,9,6,7,2,2,2,2,4,4,4,4,3,3,3,3,8,8,8,8,3,3,3,3)
#'cards <- c(cards,13,13,13,13,3,3,3,3,14,14,14,14,3,3,3,3,14,14,14,14,4,4,4,4)
#'cards <- matrix(cards,nrow=4,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'dotTrips(nPlayers,cards,score)
#'
#'cards <- c(14,14,4,5,1,2,1,1,2,3,6,7,2,2,2,2,4,4,4,4,3,3,3,3,11,11,11,11,3,3,3,3)
#'cards <- c(cards,13,13,13,13,3,3,3,3,14,14,14,14,3,3,3,3,14,14,14,14,4,4,4,4)
#'cards <- matrix(cards,nrow=4,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'dotTrips(nPlayers,cards,score)
#'@export
dotTrips <- function(nPlayers,cards,score) {
	ranks <- seq(from = 1, to = 13, by = 2)	
							#the columns for rank
	temp <- cards[,ranks]	#create a copy of cards with ranks only
	temp[which(score!=4),] <- 0 	
							#when there is not a set,
							#set the copy to zero.
	temp <- t(apply(temp,1,sort,decreasing=TRUE))
							#sorts the ranks
	tripRanks <- matrix(0, nPlayers,1)
							#create a vector for trip rank
	tripRanks[which(score==4),] <- apply(temp[which(score==4),],1,dotTripRanker)
							#determine the rank of the set
	winner <- which(tripRanks == max(tripRanks))
							#the absolute position of players with the biggest set
	temp[-winner,] <- 0
							#if not the highest pair, set to zero
	kickers <- matrix(0, nrow=nrow(temp), ncol=2)
							#create a copy of cards with kickers only.
	for (i in 1:nPlayers){
			if (temp[i,1]==0) kickers[i,1:2] = 0
							#kickers are zero if not highest set
			else kickers[i,] <- subset(temp[i,], temp[i,] != tripRanks[i])[1:2]
							#otherwise, kickers are 2 highest unmatched cards
	}
	winner <- dotHighcardCompare(kickers)
							#determine the player with the top kicker
	winner
}


#'dotStraightRanker
#'
#'Returns the rank of the highest card in the straight.
#'
#'@param oneHand : \tabular{ll}{a sorted hand with ranks only as
#'												vector[7] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: rank of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col7: rank of card 7}
#'@return straightRank : the rank of top card in the straight as
#'												integer
#'@examples
#'dotStraightRanker(c(2,3,4,5,6,9,10))
#'dotStraightRanker(c(2,3,3,4,5,6,10))
#'dotStraightRanker(c(2,3,4,5,6,7,10))
#'@export
dotStraightRanker <- function(oneHand) {
	oneHand <- sort(oneHand)
							#sort the values from low to high
	rankValues <- rle(oneHand)$values
							#the unique ranks		
	k <- length(rankValues)
							#the number of unique cards
	kgt4 <- k - 4
							#create a variable for the number of sequences to check
	if (sum(rankValues[c(k,1,2,3,4)] == c(14,2,3,4,5)) == 5) straightRank <- 5
							#check for wrap around
							#aka a low straight or wheel
	for (i in 1:kgt4) {
							#check kgt4 number of sequences
		if (rankValues[i+4] == (rankValues[i]+4)) straightRank <- rankValues[i+4]
							#if the (i+4)th rank is the ith rank plus four 
							#the high card is the (i+4)th rank
	}
	straightRank
}


#'dotStraight
#'
#'Determine the player with the highest straight.
#'
#'@param cards : \tabular{ll}{the 7 card hand as
#'												matrix[nPlayers, 14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@param score : \tabular{ll}{the score of the hand in absolute terms as
#'												vector[nPlayers] \tab \cr \tab
#'												 9 = Straight Flush \cr \tab
#'												 8 = Four of a Kind \cr \tab
#'												 7 = Full House \cr \tab
#'												 6 = Flush \cr \tab
#'												 5 = Straight \cr \tab
#'												 4 = Three of a Kind \cr \tab
#'												 3 = Two Pair \cr \tab
#'												 2 = One Pair \cr \tab
#'												 1 = High Card}
#'@return winner : absolute position of the winner as
#'												vector
#'@seealso \code{\link{dotStraightRanker}}
#'@examples
#'cards <- c(7,1,4,2,4,1,4,3,10,1,11,2,2,2,2,3,3,3,3,3,3,1,1,1,5,5,5)
#'cards <- c(cards,4,4,4,6,6,6,2,2,2,14,14,14,2,2,2)
#'cards <- matrix(cards,nrow=3,ncol=14); cards
#'score <- showdown(cards); score
#'dotStraight(cards, score)
#'
#'cards <- c(2,1,4,2,4,1,4,3,10,1,11,2,2,2,2,3,3,3,3,3,3,1,1,1,5,5,5)
#'cards <- c(cards,4,4,4,6,6,6,2,2,2,14,14,14,2,2,2)
#'cards <- matrix(cards,nrow=3,ncol=14); cards
#'score <- showdown(cards); score
#'dotStraight(cards, score)
#'@export
dotStraight <- function(cards,score) {
	ranks <- seq(from = 1, to = 13, by = 2)	
							#the columns for rank
	temp <- cards[, ranks] 	#assume score = 1 for all players
							#create a copy of cards with ranks only
	temp <- t(apply(temp,1,sort,decreasing=FALSE))
							#sorts the ranks
	temp[-which(score==5),] <- 0
							#if not a straight, set temp to zero. SLIGHTLY UNNECESSARY, BUT GOOD TO KEEP IN

	straightRanks <- matrix(0, nrow=nrow(temp), ncol=1)
							#create a variable for the high card in the straight
	straightRanks[which(score==5),] <- apply(temp[which(score==5),],1,dotStraightRanker)
							#determine the high card in each straight
	winner <- which(straightRanks == max(straightRanks))
							#determine the player with the top straight
	winner
}	


#'dotFlushRanker
#'
#'Return the ranks of the 5 highest cards in the flush.
#'
#'@param cardsRow : \tabular{ll}{one 7 card hand as
#'												vector[14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@return \tabular{ll}{flushRank : the rank of 5 high cards in flush as
#'												vector[5] \tab \cr \tab
#'												col1: suit of card 1 in \{2, ... , 14\} \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col5: suit of card n in \{2, ... , 14\}}
#'@examples
#'dotFlushRanker(c(2,1,2,2,5,2,7,2,8,2,9,2,11,1))
#'dotFlushRanker(c(2,1,2,2,5,2,7,2,8,2,9,2,11,2))
#'@export								
dotFlushRanker <- function(cardsRow){
	suits <- seq(from = 2, to = 14, by = 2)
				#the columns of suit
	sortedSuits <- sort(cardsRow[suits])
				#sort the suits from low to high
	suitValues <- rle(sortedSuits)$values
				#the unique suits
	suitLengths <- rle(sortedSuits)$lengths
				#the length of the unique suits
	flushSuit <- suitValues[suitLengths >= 5]
				#the flush suit
	flushIndex <- which(cardsRow[suits] == flushSuit)
				#the index of cards in flush
	flushRank <- cardsRow[2*flushIndex - 1]
				#rank of each card in flush
	flushRank <- sort(flushRank,decreasing=TRUE)[1:5]
				#5 high cards in flush
	flushRank
}


#'dotFlush
#'
#'Determine the player with the highest flush.
#'
#'@param cards : \tabular{ll}{the 7 card hand as
#'												matrix[nPlayers, 14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@param score : \tabular{ll}{the score of the hand in absolute terms as
#'												vector[nPlayers] \tab \cr \tab
#'												 9 = Straight Flush \cr \tab
#'												 8 = Four of a Kind \cr \tab
#'												 7 = Full House \cr \tab
#'												 6 = Flush \cr \tab
#'												 5 = Straight \cr \tab
#'												 4 = Three of a Kind \cr \tab
#'												 3 = Two Pair \cr \tab
#'												 2 = One Pair \cr \tab
#'												 1 = High Card}
#'@return winner : absolute position of the winner as
#'												vector
#'@seealso \code{\link{dotFlushRanker}} and \code{\link{dotHighcardCompare}}
#'@examples
#'cards <- c(2,1,3,3,5,2,6,3,7,3,13,3,14,3,2,3,3,4,5,1,6,3,7,3,13,3,14,3)
#'cards <- matrix(cards,2,14,byrow=TRUE); cards
#'score <- showdown(cards); score
#'dotFlush(cards,score)
#'
#'cards <- c(2,1,3,3,5,3,6,3,7,3,13,3,14,3,2,3,3,4,5,3,6,3,7,3,13,3,14,3)
#'cards <- matrix(cards,2,14,byrow=TRUE);cards
#'score <- showdown(cards); score 
#'dotFlush(cards,score)
#'@export
dotFlush <- function(cards,score) {
	flushRanks <- matrix(0, nrow=nrow(cards), ncol=5)
				#create a vector for each rank in flush
	flushRanks[which(score==6),] <- t(apply(cards[which(score==6),],1,dotFlushRanker))
				#if there is a flush,
				#fill in top 5 ranks of the same suit
	winner <- dotHighcardCompare(flushRanks)
				#determine the player with the top flush
	winner
}


#'dotFullHouseRanker
#'
#'Determine the rank of the top set and the top pair.
#'
#'@param oneHand : \tabular{ll}{the ranks of one 7 card hand as
#'												vector[7] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: rank of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col7: rank of card 7}
#'@return \tabular{ll}{fullHouseRank : the ranks of the high set and the high pair as
#'												vector \tab \cr \tab
#'												col1: the rank of the top set \cr \tab
#'												col2: the rank of the top pair}
#'@examples
#'dotFullHouseRanker(c(2,2,2,5,5,8,9))
#'dotFullHouseRanker(c(2,2,5,5,5,8,9))
#'dotFullHouseRanker(c(2,2,5,5,5,8,8))
#'@export
dotFullHouseRanker <- function(oneHand) {
							#rle is the equivalent of the Unix uniq -c command.
	values <- rle(oneHand)$values
							#compute the values of equal ranks
	lengths <- rle(oneHand)$length
							#compute the lengths of equal ranks 
							#A full Boat could have 2 sets, 1 set and 2 pairs, or 
							#1 set and 1 pair.
	fullHouseRank <- rep(0,2)
							#create a vector for pair ranks
	if (sum(lengths == 3) == 2) {
							#if there are two sets
							#choose the top set as the set
							#choose the bottom set as the pair
		fullHouseRank[1] <- max(values[lengths == 3])
		fullHouseRank[2] <- min(values[lengths == 3])
		}
	else if (sum(lengths == 2) == 2) {
							#if there are two pairs
							#choose the set as the set
							#choose the top pair as the pair
		fullHouseRank[1] <- values[lengths == 3]
		fullHouseRank[2] <- max(values[lengths == 2])
		}
	else if (sum(lengths == 2) == 1) {
							#if there is one pair
							#choose the set as the set
							#choose the pair as the pair
		fullHouseRank[1] <- values[lengths == 3]
		fullHouseRank[2] <- values[lengths == 2]
		}
	fullHouseRank
}


#'dotFullHouse
#'
#'Determine the player with the highest boat.
#'
#'@param cards : \tabular{ll}{the 7 card hand as
#'												matrix[nPlayers, 14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@param score : \tabular{ll}{the score of the hand in absolute terms as
#'												vector[nPlayers] \tab \cr \tab
#'												 9 = Straight Flush \cr \tab
#'												 8 = Four of a Kind \cr \tab
#'												 7 = Full House \cr \tab
#'												 6 = Flush \cr \tab
#'												 5 = Straight \cr \tab
#'												 4 = Three of a Kind \cr \tab
#'												 3 = Two Pair \cr \tab
#'												 2 = One Pair \cr \tab
#'												 1 = High Card}
#'@return winner : absolute position of the winner as
#'												vector
#'@seealso \code{\link{dotFullHouseRanker}}
#'@examples
#'cards <- c(5,10,4,8,1,2,1,1,10,9,6,7,3,2,2,2,5,5,5,5,3,3,3,3,8,8,8,8,3,3,3,3)
#'cards <- c(cards,14,14,14,14,2,2,2,2,14,14,14,14,3,3,3,3,14,14,14,14,4,4,4,4)
#'cards <- matrix(cards,nrow=4,ncol=14); cards
#'score <- showdown(cards); score
#'dotFullHouse(cards,score)
#'
#'cards <- c(5,10,4,8,1,2,1,1,10,9,6,7,3,2,2,2,12,12,12,12,1,1,1,1,12,12,12,12,3,3,3,3)
#'cards <- c(cards,14,14,14,14,2,2,2,2,14,14,14,14,3,3,3,3,14,14,14,14,4,4,4,4)
#'cards <- matrix(cards,nrow=4,ncol=14); cards
#'score <- showdown(cards); score
#'dotFullHouse(cards,score)
#'@export
dotFullHouse <- function(cards,score) {
	ranks <- seq(from = 1, to = 13, by = 2)	
							#the columns for rank
	temp <- cards[,ranks]	#create a copy of cards with ranks only
	temp[-which(score==7),] <- 0
							#when there is not a boat,
							#set the copy to zero.
							#SLIGHTLY UNNECESSARY
	temp <- t(apply(temp,1,sort,decreasing=TRUE))
							#sorts the ranks
	fullHouseRanks <- matrix(0,nrow=nrow(cards),ncol=2)
							#create a variable for the rank of the high set and the high pair
	fullHouseRanks[-which(score==7),] <- 0
							#if there is not a full house, then set to zero
	fullHouseRanks[which(score==7),] <- t(apply(temp[which(score==7),],1,dotFullHouseRanker))
							#determine the rank of the high set and the high pair
	winner <- which(fullHouseRanks[,1] == max(fullHouseRanks[,1]))
							#determine the players with the high set
	fullHouseRanks[-winner,] <- 0
							#if player does not have the high set, zero out their full house
	winner <- which(fullHouseRanks[,2] == max(fullHouseRanks[,2]))
							#determine which player with the high set has the high pair
	winner					
}


#'dotFourOfAKindRanker
#'
#'Determine the rank of the four of a kind and the kicker. This functions assumes ranks are sorted in decreasing order.
#'
#'@param oneHand : \tabular{ll}{the ranks of one 7 card hand as
#'												vector[7] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: rank of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col7: rank of card 7}
#'@return \tabular{ll}{fourOfAKindRank : the ranks of the quads and the high kicker as
#'												vector \tab \cr \tab
#'												col1: the rank of the quads \cr \tab
#'												col2: the rank of the kicker}
#'@examples
#'dotFourOfAKindRanker(c(14,14,14,14,10,7,6))
#'dotFourOfAKindRanker(sort(c(10,14,6,14,7,14,14),decreasing=TRUE))
#'@export
dotFourOfAKindRanker <- function(oneHand) {
							#rle is the equivalent of the Unix uniq -c command.
	values <- rle(oneHand)$values
							#compute the values of equal ranks
	lengths <- rle(oneHand)$length
							#compute the lengths of equal ranks 
							#A full Boat could have 2 sets, 1 set and 2 pairs, or 
							#1 set and 1 pair.
	fourOfAKindRank <- rep(0,2)
							#create a vector for pair ranks
							#choose the four of a kind as the quad
							#choose the high "other" as the kicker
	fourOfAKindRank[1] <- values[lengths == 4]
	fourOfAKindRank[2] <- max(values[lengths != 4])
	fourOfAKindRank
}


#'dotFourOfAKind
#'
#'Determine the player with the highest hand (i.e., four of a kind and kicker) with score of 8.
#'
#'@param nPlayers : number of hands to deal as 
#'												integer in \{2, ... , 9\}
#'@param cards : \tabular{ll}{the 7 card hand as
#'												matrix[nPlayers, 14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@param score : \tabular{ll}{the score of the hand in absolute terms as
#'												vector[nPlayers] \tab \cr \tab
#'												 9 = Straight Flush \cr \tab
#'												 8 = Four of a Kind \cr \tab
#'												 7 = Full House \cr \tab
#'												 6 = Flush \cr \tab
#'												 5 = Straight \cr \tab
#'												 4 = Three of a Kind \cr \tab
#'												 3 = Two Pair \cr \tab
#'												 2 = One Pair \cr \tab
#'												 1 = High Card}
#'@return winner : absolute position of the winner as
#'												vector
#'@seealso \code{\link{dotFourOfAKindRanker}}
#'@examples
#'cards <- c(14,10,5,1,2,1,14,9,7,2,2,2,4,4,4,3,3,3,8,8,8,3,3,3,13,13,13)
#'cards <- c(cards,3,3,3,14,14,14,3,3,3,14,14,14,4,4,4)
#'cards <- matrix(cards,nrow=3,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'dotFourOfAKind(nPlayers,cards,score)
#'
#'cards <- c(3,4,5,1,1,1,8,9,10,1,1,1,14,14,14,1,1,1,14,14,14,2,2,2,7,7,7)
#'cards <- c(cards,3,3,3,14,14,14,3,3,3,14,14,14,4,4,4)
#'cards <- matrix(cards,nrow=3,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'dotFourOfAKind(nPlayers,cards,score)
#'
#'cards <- c(3,4,5,1,1,1,8,9,10,1,1,1,14,14,14,1,1,1,14,14,14,2,2,2,11,11,11)
#'cards <- c(cards,3,3,3,14,14,14,3,3,3,14,14,14,4,4,4)
#'cards <- matrix(cards,nrow=3,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'dotFourOfAKind(nPlayers,cards,score)
#'@export
dotFourOfAKind <- function(nPlayers,cards,score) {
	ranks <- seq(from = 1, to = 13, by = 2)	
							#the columns for rank
	temp <- cards[,ranks]	#create a copy of cards with ranks only
	temp <- t(apply(temp,1,sort,decreasing=TRUE))
							#sorts the ranks
	temp[-which(score==8),] <- 0
							#when there is not a boat,
							#set the copy to zero.
	fourOfAKindRanks <- matrix(0,nrow=nPlayers,ncol=2)
							#create a variable for the rank of the quads and the kicker
	if (sum(which(score==8))==1) {
		fourOfAKindRanks[which(score==8),] <- dotFourOfAKindRanker(temp[which(score==8),])
							#determine the rank of the four of a kind and the kicker
	} else {
		fourOfAKindRanks[which(score==8),] <- t(apply(temp[which(score==8),],1,dotFourOfAKindRanker))
							#determine the rank of the four of a kind and the kicker
	}
	winner <- which(fourOfAKindRanks[,1] == max(fourOfAKindRanks[,1]))
							#determine the players with the high four of a kind
	fourOfAKindRanks[-winner,] <- 0
							#if player does not have the high four of a kind, zero out their quads
	winner <- which(fourOfAKindRanks[,2] == max(fourOfAKindRanks[,2]))
							#determine which player with the high four of a kind has the high kicker
	winner					
}


#'dotStraightFlushRanker
#'
#'Determine the rank of the highest card in a straight flush. This function assumes cards are sorted in ascending order.
#'
#'@param yTempRow : \tabular{ll}{a sorted 7 card hand of numbers as
#'												vector[7] \tab \cr \tab
#'												col1: number of card 1 in \{1, 2, ... , 52\} \cr \tab
#'												col2: number of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col7: number of card 7}
#'@return straightFlushRank : the top card in the straight flush as
#'												integer
#'@examples
#'dotStraightFlushRanker(c(1,2,3,4,5,15,19))
#'dotStraightFlushRanker(c(9,10,11,12,13,35,42))
#'dotStraightFlushRanker(c(9,10,11,12,13,14,35))
#'dotStraightFlushRanker(c(1,2,3,4,13,20,35))
#'dotStraightFlushRanker(c(9,26,14,15,16,17,35))
#'@export
dotStraightFlushRanker <- function(yTempRow) {
				#there is a straight flush
	for (i in 0:3){
					#check each suit for a flush and a wheel
				if (sum(yTempRow %in% c(13+13*i,1+13*i,2+13*i,3+13*i,4+13*i)) == 5) straightFlushRank <- 5
					#check each suit for a flush and a straight
				if (sum(yTempRow %in% c(1+13*i,2+13*i,3+13*i,4+13*i,5+13*i)) == 5) straightFlushRank <- 6
				if (sum(yTempRow %in% c(2+13*i,3+13*i,4+13*i,5+13*i,6+13*i)) == 5) straightFlushRank <- 7
				if (sum(yTempRow %in% c(3+13*i,4+13*i,5+13*i,6+13*i,7+13*i)) == 5) straightFlushRank <- 8
				if (sum(yTempRow %in% c(4+13*i,5+13*i,6+13*i,7+13*i,8+13*i)) == 5) straightFlushRank <- 9
				if (sum(yTempRow %in% c(5+13*i,6+13*i,7+13*i,8+13*i,9+13*i)) == 5) straightFlushRank <- 10
				if (sum(yTempRow %in% c(6+13*i,7+13*i,8+13*i,9+13*i,10+13*i)) == 5) straightFlushRank <- 11
				if (sum(yTempRow %in% c(7+13*i,8+13*i,9+13*i,10+13*i,11+13*i)) == 5) straightFlushRank <- 12
				if (sum(yTempRow %in% c(8+13*i,9+13*i,10+13*i,11+13*i,12+13*i)) == 5) straightFlushRank <- 13
				if (sum(yTempRow %in% c(9+13*i,10+13*i,11+13*i,12+13*i,13+13*i)) == 5) straightFlushRank <- 14
	}
	straightFlushRank
}


#'dotStraightFlush
#'
#'Determine the player with the highest straight flush.
#'
#'@param nPlayers number of hands as			integer in \{2, ... , 9\}
#'@param cards : \tabular{ll}{the 7 card hand as
#'												matrix[nPlayers, 14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@param score : \tabular{ll}{the score of the hand in absolute terms as
#'												vector[nPlayers] \tab \cr \tab
#'												 9 = Straight Flush \cr \tab
#'												 8 = Four of a Kind \cr \tab
#'												 7 = Full House \cr \tab
#'												 6 = Flush \cr \tab
#'												 5 = Straight \cr \tab
#'												 4 = Three of a Kind \cr \tab
#'												 3 = Two Pair \cr \tab
#'												 2 = One Pair \cr \tab
#'												 1 = High Card}
#'@return winner : absolute position of the winner as
#'												vector
#'@seealso \code{\link{dotTransformToNumber}} and \code{\link{dotStraightFlushRanker}}
#'@examples
#'cards <- c(8,13,5,1,1,4,6,2,2,2,3,4,14,14,14,2,2,2,9,9,9,1,1,1,10,10,10)
#'cards <- c(cards,1,1,1,11,11,11,1,1,1,12,12,12,1,1,1)
#'cards <- matrix(cards,nrow=3,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'dotStraightFlush(nPlayers,cards,score)
#'
#'cards <- c(1,1,3,4,2,2,3,4,8,8,1,1,9,9,1,1,10,10,1,1,11,11,1,1,12,12,1,1)
#'cards <- matrix(cards,nrow=2,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'dotStraightFlush(nPlayers,cards,score)
#'@export
dotStraightFlush <- function(nPlayers, cards, score) {
	ranks <- seq(from = 1, to = 13, by = 2)
				#the columns of rank
	suits <- seq(from = 2, to = 14, by = 2)
				#the columns of suit
	yTemp <- matrix(0,nrow=nPlayers,ncol=7)
				#create a copy of the 7 card hand transformed to number
	for (i in 1:nPlayers) {
		yTemp[i,] <- dotTransformToNumber(cards[i,ranks],cards[i,suits])
				#transform cards to number
	}
	yTemp[-which(score==9),] <- 0
				#if not a straight flush, set to zero
	yTemp <- t(apply(yTemp,1,sort))	
				#sort the numbers
	straightFlushRanks <- matrix(0, nrow=nPlayers, ncol=1)
				#create a variable for the top card in the straight flush
	straightFlushRanks[which(score==9),] <- t(apply(yTemp[which(score==9),],1,dotStraightFlushRanker))
				#determine the top card in each straight flush
	winner <- which(straightFlushRanks == max(straightFlushRanks))
				#determine the player with the top straight flush
	winner
}


#'tiebreaker
#'
#'Determine the winner in the presence of any ties.
#'
#'@param nPlayers number of hands as			integer in \{2, ... , 9\}
#'@param cards : \tabular{ll}{the 7 card hand as
#'												matrix[nPlayers, 14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@param score : \tabular{ll}{the score of the hand in absolute terms as
#'												vector[nPlayers] \tab \cr \tab
#'												 9 = Straight Flush \cr \tab
#'												 8 = Four of a Kind \cr \tab
#'												 7 = Full House \cr \tab
#'												 6 = Flush \cr \tab
#'												 5 = Straight \cr \tab
#'												 4 = Three of a Kind \cr \tab
#'												 3 = Two Pair \cr \tab
#'												 2 = One Pair \cr \tab
#'												 1 = High Card}
#'@return winner : the absolute position of the winner(s) as
#'												vector
#'@seealso \code{\link{dotHighcard}}, \code{\link{dotPair}}, \code{\link{dotTwoPairs}}, \code{\link{dotTrips}}, \code{\link{dotStraight}}, \code{\link{dotFlush}}, \code{\link{dotFullHouse}}, \code{\link{dotFourOfAKind}} and \code{\link{dotStraightFlush}}
#'@examples
#'cards <- c(2,1,4,2,5,3,6,4,7,1,13,2,14,3,2,3,3,4,5,1,6,2,7,3,13,4,14,1)
#'cards <- matrix(cards,2,14,byrow=TRUE); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(2,1,3,2,5,3,6,4,7,1,13,2,14,3,2,3,3,4,5,1,6,2,7,3,13,4,14,1)
#'cards <- matrix(cards,2,14,byrow=TRUE); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(2,3,4,5,1,1,1,1,2,3,6,7,2,2,2,2,4,4,4,4,3,3,3,3,11,11,11,11,3,3,3,3)
#'cards <- c(cards,13,13,13,13,3,3,3,3,14,14,14,14,3,3,3,3,9,9,9,9,4,4,4,4)
#'cards <- matrix(cards,nrow=4,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(2,3,4,5,1,1,1,1,2,3,6,7,2,2,2,2,4,4,4,4,3,3,3,3,11,11,11,11,3,3,3,3)
#'cards <- c(cards,13,13,13,13,3,3,3,3,14,14,14,14,3,3,3,3,14,14,14,14,4,4,4,4)
#'cards <- matrix(cards,nrow=4,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(14,14,4,5,1,2,1,1,10,9,6,7,2,2,2,2,4,4,4,4,3,3,3,3,8,8,8,8,3,3,3,3)
#'cards <-c(cards,13,13,13,13,3,3,3,3,14,14,14,14,3,3,3,3,14,14,14,14,4,4,4,4)
#'cards <- matrix(cards,nrow=4,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(14,14,4,5,1,2,1,1,2,3,6,7,2,2,2,2,4,4,4,4,3,3,3,3,11,11,11,11,3,3,3,3)
#'cards <-c(cards,13,13,13,13,3,3,3,3,14,14,14,14,3,3,3,3,14,14,14,14,4,4,4,4)
#'cards <- matrix(cards,nrow=4,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(7,1,4,2,4,1,4,3,10,1,11,2,2,2,2,3,3,3,3,3,3,1,1,1,5,5,5,4,4,4,6,6,6)
#'cards <-c(cards,2,2,2,14,14,14,2,2,2)
#'cards <- matrix(cards,nrow=3,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(2,1,4,2,4,1,4,3,10,1,11,2,2,2,2,3,3,3,3,3,3,1,1,1,5,5,5,4,4,4,6,6,6)
#'cards <-c(cards,2,2,2,14,14,14,2,2,2)
#'cards <- matrix(cards,nrow=3,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(2,1,3,3,5,2,6,3,7,3,13,3,14,3,2,3,3,4,5,1,6,3,7,3,13,3,14,3)
#'cards <- matrix(cards,2,14,byrow=TRUE); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(2,1,3,3,5,3,6,3,7,3,13,3,14,3,2,3,3,4,5,3,6,3,7,3,13,3,14,3)
#'cards <- matrix(cards,2,14,byrow=TRUE); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(5,10,4,8,1,2,1,1,10,9,6,7,3,2,2,2,5,5,5,5,3,3,3,3,8,8,8,8,3,3,3,3)
#'cards <-c(cards,14,14,14,14,2,2,2,2,14,14,14,14,3,3,3,3,14,14,14,14,4,4,4,4)
#'cards <- matrix(cards,nrow=4,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(5,10,4,8,1,2,1,1,10,9,6,7,3,2,2,2,12,12,12,12,1,1,1,1,12,12,12,12)
#'cards <-c(cards,3,3,3,3,14,14,14,14,2,2,2,2,14,14,14,14,3,3,3,3,14,14,14,14,4,4,4,4)
#'cards <- matrix(cards,nrow=4,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(14,10,5,1,2,1,14,9,7,2,2,2,4,4,4,3,3,3,8,8,8,3,3,3,13,13,13)
#'cards <-c(cards,3,3,3,14,14,14,3,3,3,14,14,14,4,4,4)
#'cards <- matrix(cards,nrow=3,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(3,4,5,1,1,1,8,9,10,1,1,1,14,14,14,1,1,1,14,14,14,2,2,2,11,11,11)
#'cards <-c(cards,3,3,3,14,14,14,3,3,3,14,14,14,4,4,4)
#'cards <- matrix(cards,nrow=3,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(8,13,5,1,1,4,6,2,2,2,3,4,14,14,14,2,2,2,9,9,9,1,1,1,10,10,10)
#'cards <-c(cards,1,1,1,11,11,11,1,1,1,12,12,12,1,1,1)
#'cards <- matrix(cards,nrow=3,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'
#'cards <- c(1,1,3,4,2,2,3,4,8,8,1,1,9,9,1,1,10,10,1,1,11,11,1,1,12,12,1,1)
#'cards <- matrix(cards,nrow=2,ncol=14); cards
#'score <- showdown(cards); score
#'nPlayers <- nrow(cards); nPlayers
#'tiebreaker(nPlayers,cards,score)
#'@export
tiebreaker <- function(nPlayers,cards,score) {
	winner <- which(score==max(score))
	if (length(winner) > 1) {
			#if length(max(scores)) >= 2
			#there is a tie
			if (max(score)==1) winner <- dotHighcard(cards)
			if (max(score)==2) winner <- dotPair(nPlayers,cards,score)
			if (max(score)==3) winner <- dotTwoPairs(nPlayers,cards,score)
			if (max(score)==4) winner <- dotTrips(nPlayers,cards,score)
			if (max(score)==5) winner <- dotStraight(cards,score)
			if (max(score)==6) winner <- dotFlush(cards,score)
			if (max(score)==7) winner <- dotFullHouse(cards,score)
			if (max(score)==8) winner <- dotFourOfAKind(nPlayers,cards,score)
			if (max(score)==9) winner <- dotStraightFlush(nPlayers,cards,score)
	}
	winner
}


#'cgiPlayers
#'
#'A primitive method (i.e., does not support classes) for graphics using the plot() function. Built-in support for 2-9 players.  This function was written on a Mac and may not be PC-compatible (yet). You must have already called cgiPlayers(time=1, ...) before calling cgiPlayers(time=2, ...), you must have already called cgiPlayers(time=1, ...) and cgiPlayers(time=2, ...) before calling cgiPlayers(time=3, ...), etc. 
#'
#'@param time : \tabular{ll}{the current round as	integer in \{1, 2, 3, 4\} \tab \cr \tab
#'												1 = pre-flop \cr \tab
#'												2 = flop \cr \tab
#'												3 = turn \cr \tab
#'												4 = river}
#'@param alias names of players	as				vector[nPlayers]
#'@param position dealer position as 			integer in \{2, ..., nPlayers\}
#'@param cards : \tabular{ll}{the 7 card hand as
#'												matrix[nPlayers, 14] \tab \cr \tab
#'												col1: rank of card 1 in \{2, ... , 14\} \cr \tab
#'												col2: suit of card 1 in \{1, 2, 3, 4\} \cr \tab
#'												col3: rank of card 2 \cr \tab
#'												col4: suit of card 2 \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												. \cr \tab
#'												col13: rank of card 7 \cr \tab
#'												col14: suit of card 7}
#'@return In lieu of a return value, cgiPlayers calls the plot() function.
#'@examples
#'alias <- c("Player1","Player2","Player3","Player4","Player5")
#'alias <- c(alias,"Player6","Player7","Player8","Player9")
#'cols1thru5 <- c(2,8,12,14,10,6,14,8,4,2,3,2,4,1,4,3,1,1,13,4,4,5,3,9,8,12,7)
#'cols1thru5 <- c(cols1thru5,3,4,3,2,2,4,2,1,1,3,3,3,3,3,3,3,3,3)
#'cols6thru10 <- c(1,1,1,1,1,1,1,1,1,10,10,10,10,10,10,10,10,10,4,4,4,4,4,4,4,4,4)
#'cols6thru10 <- c(cols6thru10,12,12,12,12,12,12,12,12,12,4,4,4,4,4,4,4,4,4)
#'cols11thru14 <- c(11,11,11,11,11,11,11,11,11,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2)
#'cols11thru14 <- c(cols11thru14,3,3,3,3,3,3,3,3,3)
#'cards <- matrix(c(cols1thru5,cols6thru10,cols11thru14),nrow=9,ncol=14); cards
#'cgiPlayers(1,alias,9,cards)
#'cgiPlayers(2,alias,9,cards)
#'cgiPlayers(3,alias,9,cards)
#'cgiPlayers(4,alias,9,cards)
#'@export
cgiPlayers <- function(time, alias, position, cards) {
	nPlayers <- nrow(cards)
	width <- 30
	height <- 20
	X1 <- numeric(nPlayers)
	Y1 <- numeric(nPlayers)
	X2 <- numeric(nPlayers)
	Y2 <- numeric(nPlayers)
	X3 <- numeric(5)
	Y3 <- height-5.5
	#PRE-FLOP
	if (time == 1) {
		plot(0,0, xlim=c(0,width), ylim=c(0,height), axes=FALSE, xlab="", ylab="", cex= 0, main="Poker Simulator")
		text(width/2,Y3+.7, "Community")
		X4 <- c(width/2-7.5,width/2+1.5,width/2+1.5,width/2-7.5,width/2-7.5,width/2+1.5,width/2+4.5,width/2+4.5,
			width/2+1.5,width/2+1.5,width/2+4.5,width/2+7.5,width/2+7.5,width/2+4.5)
		Y4 <- c(Y3+.35,Y3+.35,Y3-.35,Y3-.35,Y3+.35,Y3+.35,Y3+.35,Y3-.35,Y3-.35,Y3+.35,Y3+.35,Y3+.35,Y3-.35,Y3-.35)
		points(X4,Y4,"l", col="green")
		if (nPlayers==2) {
			X1 <- seq(from = 10,to = width-10, length = 2)
			Y1 <- rep(3.5,2)
			}
		if (nPlayers==3) {
			X1 <- seq(from = 5,to = width-5, length = 3)
			Y1 <- rep(3.5,3)
			}
		if (nPlayers==4) {
			X1 <- c(5,seq(from = 10,to = width-10, length = 2),width-5)
			Y1 <- c(6,rep(3.5,2),6)
			}
		if (nPlayers==5) {
			X1 <- c(5,seq(from = 5,to = width-5, length = 3),width-5)
			Y1 <- c(6,rep(3.5,3),6)
			}
		if (nPlayers==6) {
			X1 <- c(rep(5,2),seq(from = 10,to = width-10, length = 2),rep(width-5,2))
			Y1 <- c(8.5,6,rep(3.5,2),6,8.5)
			}
		if (nPlayers==7) {
			X1 <- c(rep(5,2),seq(from = 5,to = width-5, length = 3),rep(width-5,2))
			Y1 <- c(8.5,6,rep(3.5,3),6,8.5)
			}
		if (nPlayers==8) {
			X1 <- c(rep(5,3),seq(from = 10,to = width-10, length = 2),rep(width-5,3))
			Y1 <- c(11,8.5,6,rep(3.5,2),6,8.5,11)
			}
		if (nPlayers==9) {
			X1 <- c(rep(5,3),seq(from = 5,to = width-5, length = 3),rep(width-5,3))
			Y1 <- c(11,8.5,6,rep(3.5,3),6,8.5,11)
			}
		for (i in 1:nPlayers) 
		{
				text(X1[i], Y1[i], alias[i])
				for (j in 1:2) {			
					#RANK
					X2 <- X1[i]-2+3*(j-1)
					Y2[i] <- Y1[i] - .5
					if(cards[i,2*j-1]<=10) {
						text(X2,Y2[i], cards[i,2*j-1])
						}
					if(cards[i,2*j-1]==11) {
						text(X2,Y2[i], "J")
						}
					if(cards[i,2*j-1]==12) {
						text(X2,Y2[i], "Q")
						}
					if(cards[i,2*j-1]==13) {
						text(X2,Y2[i], "K")
						}
					if(cards[i,2*j-1]==14) {
						text(X2,Y2[i], "A")
						}			
					#SUIT
					if(cards[i,2*j]==1) {
						text(X2+1,Y2[i], "\u2660") #spades
						}
					if(cards[i,2*j]==2) {
						text(X2+1,Y2[i],"\u2663") #clubs
						}
					if(cards[i,2*j]==3) {
						text(X2+1,Y2[i], "\u2665") #hearts
						}
					if(cards[i,2*j]==4) {
						text(X2+1,Y2[i], "\u2666") #diamonds
						}	
				}
		}
	}		
	#FLOP
	if (time == 2 ) {
		X3 <- seq(from = width/2-6.5, by = 3, length = 3)
		for (i in 1:3) {
			if(cards[1,3+2*i]<=10) {
				text(X3[i],Y3, cards[1,3+2*i])
				}
			if(cards[1,3+2*i]==11) {
				text(X3[i],Y3, "J")
				}
			if(cards[1,3+2*i]==12) {
				text(X3[i],Y3, "Q")
				}
			if(cards[1,3+2*i]==13) {
				text(X3[i],Y3, "K")
				}
			if(cards[1,3+2*i]==14) {
				text(X3[i],Y3, "A")
				}			
			#SUIT
			if(cards[1,4+2*i]==1) {
				text(X3[i]+1,Y3,"\u2660") #spades
				}
			if(cards[1,4+2*i]==2) {
				text(X3[i]+1,Y3,"\u2663") #clubs
				}
			if(cards[1,4+2*i]==3) {
				text(X3[i]+1,Y3, "\u2665") #hearts
				}
			if(cards[1,4+2*i]==4) {
				text(X3[i]+1,Y3, "\u2666") #diamonds
				}
		}
	}
	#TURN
	if (time == 3 ) {
		X3 <- seq(from = width/2-6.5, by = 3, length = 5)
		i <- 4	
		if(cards[1,3+2*i]<=10) {
			text(X3[i],Y3, cards[1,3+2*i])
			}
		if(cards[1,3+2*i]==11) {
			text(X3[i],Y3, "J")
			}
		if(cards[1,3+2*i]==12) {
			text(X3[i],Y3, "Q")
			}
		if(cards[1,3+2*i]==13) {
			text(X3[i],Y3, "K")
			}
		if(cards[1,3+2*i]==14) {
			text(X3[i],Y3, "A")
			}			
		#SUIT
		if(cards[1,4+2*i]==1) {
			text(X3[i]+1,Y3,"\u2660") #spades
			}
		if(cards[1,4+2*i]==2) {
			text(X3[i]+1,Y3,"\u2663") #clubs
			}
		if(cards[1,4+2*i]==3) {
			text(X3[i]+1,Y3, "\u2665") #hearts
			}
		if(cards[1,4+2*i]==4) {
			text(X3[i]+1,Y3, "\u2666") #diamonds
			}
	}
	#RIVER	
	if (time == 4 ) {
	X3 <- seq(from = width/2-6.5, by = 3, length = 5)
		i <- 5	
		if(cards[1,3+2*i]<=10) {
			text(X3[i],Y3, cards[1,3+2*i])
			}
		if(cards[1,3+2*i]==11) {
			text(X3[i],Y3, "J")
			}
		if(cards[1,3+2*i]==12) {
			text(X3[i],Y3, "Q")
			}
		if(cards[1,3+2*i]==13) {
			text(X3[i],Y3, "K")
			}
		if(cards[1,3+2*i]==14) {
			text(X3[i],Y3, "A")
			}			
		#SUIT
		if(cards[1,4+2*i]==1) {
			text(X3[i]+1,Y3,"\u2660") #spades
			}
		if(cards[1,4+2*i]==2) {
			text(X3[i]+1,Y3,"\u2663") #clubs
			}
		if(cards[1,4+2*i]==3) {
			text(X3[i]+1,Y3, "\u2665") #hearts
			}
		if(cards[1,4+2*i]==4) {
			text(X3[i]+1,Y3, "\u2666") #diamonds
			}
	}
}

Try the poker package in your browser

Any scripts or data that you put into this service are public.

poker documentation built on Aug. 9, 2017, 9:03 a.m.