# That's BS! (card game)

BS is a card game where the object of the game is to lose all of your cards.

A game consists of four players and a 52-card deck. Each player is randomly dealt 13 cards. Normally, cards are labeled 2 - 10, Ace, Jack, Queen, King, but for simplicity, the cards will be labeled with a number from 0 - 12 inclusive. Although the number of cards in a player's hand is public information, only the player knows what specific cards are in his hand.

The game goes as follows: the first player places as many cards labeled 0 as he wants to in the discard pile (note that he is not required to play all of his cards labeled 0, though usually it is in his best interest to do so). He must play at least one card. The second player plays as many cards as he wants to labeled 1, the third player plays 2, and so on. After 12, it resets to 0.

What happens if you don't have any of the cards that you are supposed to play? Remember, you must play at least one card -- in fact, you can play any cards you want! (Actually, even if you have the right card, you can lie and play a different card). However, someone can call you out and say, "BS!" If that someone is correct and you had lied, then you must take all the cards in the discard pile; as a reward, the player who called you out randomly places one of their cards in the discard pile. If the accuser is wrong, however, he must take all the cards in the discard pile. Note that you can't lie about the number of cards that you play.

More detailed info:

• At the beginning of the game, four random players are chosen to play. Since there will be at least 1000 games, each player will get a chance to play. The turn order is randomly decided at the beginning of the game
• If you return one correct card and one incorrect card, then it is considered lying (i.e. if you were supposed to give 2s, and you gave one 2 and one 1, then that's lying)
• If two or more players both say BS at the same time, then one is randomly chosen.
• Your score is the percent of games that you win.
• There is a maximum 1000 rounds, where one round is every player going once. Usually, someone wins before this. If no one wins, then it is counted towards the total number of games played, but no one wins.

Spec:

You should write a class which extends Player. It will look like:

package players;

import java.util.ArrayList;
import java.util.List;

import controller.*;

public class Player1 extends Player {

@Override
protected List<Card> requestCards(int card, Controller controller) {
Card[] hand = getHand();
List<Card> ret =  new ArrayList<Card>();
for (Card c : hand) {
if (c.getNumber() == card) {
}
}
return ret;
}

@Override
protected boolean bs(Player player, int card, int numberOfCards, Controller controller) {
return numberOfCards >= 3;
}

protected void update(Controller controller) {
// This method gets called once at the end of every round
}

protected void initialize(Controller controller) {
// This method gets called once at the beginning once all the cards are dealt
}

public String toString() {
return "Player 1";
}
}


The method requestCards is called when it is your turn. The argument card is the card number that you are supposed to provide. You return a list of cards that you want to put in the discard pile. The player above checks to see if he has any cards of the requested card type; if not, he simply plays his first card and hopes no one checks.

The method bs is called whenever someone else plays a card. The first argument is the player, the second - the card he was supposed to play, and the third - the number of that type of card that he claims that he has played. Return true if you want to call "BS." In the code above, the player only calls "BS" when the other player claims to have 3 or more cards of the requested type.

The last argument for both methods is controller, which is just the controller that controls the game. From the controller, you can get more public information, such as the number of cards in the discard pile or the list and turn order of the players.

The toString method is optional.

Conroller on GitHub: https://github.com/prakol16/bs

If you want to post a non-java solution, you can use the interface provided in https://github.com/LegionMammal978/bs (credits to LegionMammal978) and I'll try to integrate it.

Scoreboard so far:

class players.PlayerConMan: 2660/4446 = 59.82905982905983%
class players.CalculatingLiar: 2525/4426 = 57.049254405784005%
class players.PlayerTruthy: 1653/4497 = 36.75783855903936%
class players.Player4: 1446/4425 = 32.67796610169491%
class players.Player1: 536/4382 = 12.23185759926974%
class players.Player3: 493/4425 = 11.141242937853107%
class players.Player2: 370/4451 = 8.312738710402156%
class players.LiePlayer: 317/4432 = 7.152527075812275%
class players.Hoarder: 0/4516 = 0.0%


PlayerConMan is winning, but CalculatingLiar is in a close second. These scores seem consistent -- they are fairly the same every time.

• You have got to be kidding me. I have an almost finished controller for BS lying around for the sole purpose of creating this exact challenge. Well, I guess I have to find some other way to spend my time now. Apr 6, 2015 at 1:22
• It might be advisable not to expose Controller.toString() to public, as it returns the hands of all players and the discard pile. Apr 6, 2015 at 4:20
• @IchBinKeinBaum, if your controller can communicate with STDIN/STDOUT, you might consider publishing the challenge with your controller for all the non-Java people. Apr 6, 2015 at 5:28
• @CarpetPython: It does. It also uses slightly differen rules. If that doesn't count as a duplicate, I will. Apr 6, 2015 at 11:31
• I just finished creating a multi-language controller. The usage is in Program.cs. You can find it here. Apr 6, 2015 at 13:31

# ConMan

ConMan watches every card that goes through his hand, calling BS when a play isn't possible due to where the cards are.

Plays truth when able, but lies intelligently using the last card if a victory were to happen.

I spent a long time tuning a technique to call BS when the probability was high that the opponent was lying, or when calling BS was beneficial (such as getting useful cards from the discard pile), but in practice, not calling BS at all netted me the most points.

package players;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import controller.*;
import java.text.DecimalFormat;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;

public class PlayerConMan extends Player {

private enum Location {

PLAYER_0,
PLAYER_1,
PLAYER_2,
PLAYER_3,
UNKNOWN
};

private class MyCard {

private final int number;
private Location location;
private double confidence;
protected Card card;

public MyCard(int x) {
this.number = x;
location = Location.UNKNOWN;
confidence = 1.0;
}

@Override
public String toString() {
if (confidence > 0.75) {
return ""+number;
} else if (confidence > 0.25) {
return number+"*";
} else {
return number+"_";
}
}
}

private final ArrayList<ArrayList<MyCard>> theDeck = new ArrayList();
private Location myLocation;
private ArrayList<Player> players;
private final ArrayList<MyCard> myHand = new ArrayList();
private final HashMap<Location, Integer> sizes = new HashMap();
private ArrayList<Integer> lies = new ArrayList();
private ArrayList<Integer> truths = new ArrayList();

// Constructor
public PlayerConMan() {
for (int i = 0; i < 13; ++i) {
ArrayList<MyCard> set = new ArrayList();
for (int j = 0; j < 4; ++j) {
}
}
sizes.put(Location.PLAYER_0, 13);
sizes.put(Location.PLAYER_1, 13);
sizes.put(Location.PLAYER_2, 13);
sizes.put(Location.PLAYER_3, 13);
sizes.put(Location.UNKNOWN, 39);
}

//Gets the MyCard for this card, updating a MyCard with the lowest confidence if not already created
private MyCard getCard(Card c) {
ArrayList<MyCard> set = theDeck.get(c.getNumber());
MyCard unknown = null;
double confidence = 1.0;
for (MyCard m : set) {
if (m.card == c) {
return m;
}
if (m.card == null) {
if (m.location == Location.UNKNOWN) {
unknown = m;
confidence = 0.0;
} else if (m.confidence < confidence || unknown == null) {
unknown = m;
confidence = m.confidence;
}
}
}
unknown.card = c;
return unknown;
}

//Returns the Location of a player
private Location getLocation(Player p) {
return Location.values()[players.indexOf(p)];
}

@Override
protected void initialize(Controller controller) {
super.initialize(controller);
players = new ArrayList(controller.getPlayers());
for (Player p : players) {
if (p == this) {
myLocation = getLocation(p);
}
}
for (Location loc : Location.values()) {
sizes.put(loc, 0);
}
}

private ArrayList<Integer>[] getTruthesAndLies(Player player, int card, ArrayList<MyCard> myHand) {
//Determine our next plays
int offset = players.indexOf(player);
int myOffset = players.indexOf(this);
int nextCard = (card + (myOffset - offset + 4) % 4)%13;
ArrayList<Integer> truths = new ArrayList();
ArrayList<Integer> lies = new ArrayList();
ArrayList<MyCard> cardsLeft = new ArrayList(myHand);
while (!cardsLeft.isEmpty()) {
boolean isLie = true;
Iterator<MyCard> it = cardsLeft.iterator();
while (it.hasNext()) {
MyCard m = it.next();
if (m.number == nextCard) {
it.remove();
isLie = false;
}
}
if (isLie) {
} else {
}
nextCard = (nextCard + 4)%13;
}

return new ArrayList[]{truths, lies};
}

private void updateDeck(Player player, int card, int numberOfCards, Controller controller) {
Location loc = getLocation(player);

//Update from BS

//Move all cards from DISCARD to the losing player
//  Losing player defaults to player playing, in the rare case of a tie
Location losingPlayer = loc;
Location winningPlayer = null;
for (Player p : players) {
Location pLoc = getLocation(p);
int size = p.handSize();
if (pLoc == loc) size += numberOfCards;
if (p.handSize() > sizes.get(pLoc)) {
losingPlayer = pLoc;
} else if (size < sizes.get(pLoc)) {
winningPlayer = pLoc;
}
}

if (winningPlayer == null) {
debug(losingPlayer+" lost a BS");
} else {
debug(losingPlayer+" lied and "+winningPlayer+" lost a card");
}

//Move the cards from the discard to the player
ArrayList<MyCard> winnersHand = new ArrayList();
for (ArrayList<MyCard> set : theDeck) {
for (MyCard m : set) {
if (losingPlayer == myLocation) {
//If we lost, update the discard cards to unknown;
//  They'll be updated when we look at our hand
m.location = Location.UNKNOWN;
m.confidence = 1.0;
} else {
//Move to the losing player
m.location = losingPlayer;
}
} else if (m.location == myLocation && winningPlayer == myLocation) {
//Update our old cards to the discard pile, in case we won
m.confidence = 1.0;
} else if (m.location == winningPlayer) {
//Add the card to the winner's hand for later processing
}
}
}

//If someone else won, adjust the probabilities on their cards
if (winningPlayer != myLocation && winningPlayer != null) {
int winningSize = players.get(winningPlayer.ordinal()).handSize();
if (winningPlayer == loc) winningSize += numberOfCards;
for (MyCard m : winnersHand) {
m.confidence *= 1-(1/winningSize);
}
}

}
//Update player handSize
for (Player p : players) {
sizes.put(getLocation(p), p.handSize());
}

//Detect if my hand size has changed to speed processing
if (myHand.size() != handSize()) {
//Update values from my hand
myHand.clear();
for (Card c : getHand()) {
MyCard m = getCard(c);
m.location = myLocation;
m.confidence = 1.0;
}

//Determine our next plays
ArrayList<Integer> tl[] = getTruthesAndLies(player, card, myHand);
truths = tl;
lies = tl;
debug("Truthes: "+truths);
debug("Lies: "+lies);
}
}

@Override
protected List<Card> requestCards(int card, Controller controller) {
updateDeck(this, card, 0, controller);

ArrayList<Card> ret = new ArrayList();
int pick = card;
boolean all = true;
if (truths.get(0) != card) {
pick = truths.get(truths.size()-1);
all = false;
}

for (MyCard m : myHand) {
if (m.number == pick) {
if (!all) break;
}
}

sizes.put(myLocation, myHand.size() - ret.size());
printTheDeck();

return ret;
}

@Override
protected boolean bs(Player player, int card, int numberOfCards, Controller controller) {
updateDeck(player, card, numberOfCards, controller);
Location loc = getLocation(player);

//Get total number of unknown cards and total number of cards the player must have
int handSize = player.handSize() + numberOfCards;
ArrayList<MyCard> playerHand = new ArrayList();
double totalUnknown = 0;
double playerUnknown = handSize;
double cardsHeld = 0;
double cardsNotHeld = 0;
for (ArrayList<MyCard> set : theDeck) {
for (MyCard m : set) {
if (m.location == Location.UNKNOWN) {
totalUnknown++;
} else if (m.location == loc) {
playerUnknown -= m.confidence;
totalUnknown += 1.0 - m.confidence;
if (m.number == card) {
cardsHeld += m.confidence;
}
} else {
}
totalUnknown += 1.0 - m.confidence;
if (m.number == card) {
cardsNotHeld += m.confidence;
}
}
}
}

boolean callBS = false;
double prob;
int possible = (int)Math.round(4-cardsNotHeld);
int needed = (int)Math.round(numberOfCards - cardsHeld);
if (needed > possible) {
//Player can't possibly have the cards
prob = 0.0;
debug("impossible");
callBS = true;
} else if (needed <= 0) {
//Player guaranteed to have the cards
prob = 1.0;
debug("guaranteed");
} else {
//The probability that player has needed or more of the possible cards
double successes = 0;
for (int i = (int)needed; i <= (int)possible; i++) {
successes += choose(possible, i) * choose(totalUnknown-possible, playerUnknown-i);
}
double outcomes = choose(totalUnknown, playerUnknown);
prob = successes / outcomes;
if (Double.isNaN(prob)) {
prob = 0;
callBS = true;
}
debug("prob = "+new DecimalFormat("0.000").format(prob));
}

//Update which cards they may have put down
//  Assume they put down as many as they could truthfully
int cardsMoved = 0;
Iterator<MyCard> it = playerHand.iterator();
while (it.hasNext()) {
MyCard m = it.next();
if (m.number == card) {
it.remove();
cardsMoved++;
if (cardsMoved >= numberOfCards) {
break;
}
}
}

//We can't account for all the cards they put down
//  Adjust existing probabilities and move our lowest confidence cards to the discard
if (cardsMoved < numberOfCards) {
//  Reduce the confidence of all remaining cards, in case they lied
//  Assumes they lie at random
double cardsLeft = handSize-cardsMoved;
double cardsNeeded = numberOfCards-cardsMoved;
double probChosen = 1 * choose(cardsLeft-1, cardsNeeded-1) / choose(cardsLeft, cardsNeeded);
if (Double.compare(cardsLeft, cardsNeeded) == 0) {
//They're gonna win, call their bluff
callBS = true;
for (MyCard m : playerHand) {
}
} else {
for (MyCard m : playerHand) {
m.confidence *= (1-probChosen) * (1-prob) + prob;
}
}

//  Move any UNKNOWN cards they could have played, assuming they told the truth
Collections.sort(theDeck.get(card), new Comparator<MyCard>() {
@Override
public int compare(MyCard o1, MyCard o2) {
double p1 = o1.confidence - (o1.location == Location.UNKNOWN ? 10 : 0);
double p2 = o2.confidence - (o2.location == Location.UNKNOWN ? 10 : 0);
return (int)Math.signum(p1-p2);
}
});
for (MyCard m : theDeck.get(card)) {
if (m.location == Location.UNKNOWN || m.confidence < prob) {
m.confidence = prob;
cardsMoved++;
if (cardsMoved >= numberOfCards) break;
}
}
}

//Get the confidence of the discardPile
for (MyCard m : discardPile) {
}

//Call BS if the cards in the discard pile consists only of cards we need / will play
double truthCount = 0;
double lieCount = 0;
double unknownCount = 0;
for (MyCard m : discardPile) {
if (truths.contains(m.number)) {
truthCount += m.confidence;
unknownCount += 1-m.confidence;
} else if (lies.contains(m.number)) {
lieCount += m.confidence;
unknownCount += 1-m.confidence;
} else {
unknownCount += 1;
break;
}
}
if (lieCount > 0 && unknownCount < 1) {
debug("Strategic BS");
//callBS = true;
}
}

//What's the worst that could happen?
//Test the decks'
ArrayList<MyCard> worstHand = new ArrayList<MyCard>(myHand);
ArrayList<Integer> loseCase[] = getTruthesAndLies(player, card, worstHand);
int winPlaysLeft = truths.size() + lies.size();
int losePlaysLeft = loseCase.size() + loseCase.size();
double randomPlaysLeft = Math.max(losePlaysLeft,7);
double threshold = 0.0 - (expectedPlaysLeft - winPlaysLeft)/13.0;
debug("winPlaysLeft = "+winPlaysLeft);
debug("expectedPlaysLeft   = "+expectedPlaysLeft);
debug("Threshold    = "+threshold);

if(lies.isEmpty()) {
threshold /= 2;
}
//callBS = callBS || prob < threshold;

printTheDeck();
return callBS;
}

static double logGamma(double x) {
double tmp = (x - 0.5) * Math.log(x + 4.5) - (x + 4.5);
double ser = 1.0 + 76.18009173 / (x + 0) - 86.50532033 / (x + 1)
+ 24.01409822 / (x + 2) - 1.231739516 / (x + 3)
+ 0.00120858003 / (x + 4) - 0.00000536382 / (x + 5);
return tmp + Math.log(ser * Math.sqrt(2 * Math.PI));
}

static double gamma(double x) {
return Math.exp(logGamma(x));
}

static double factorial(double x) {
return x * gamma(x);
}

static double choose(double n, double k) {
if (Double.compare(n, k) == 0 || Double.compare(k, 0) == 0) return 1.0;
if (k < 0 || k > n) {
return 0.0;
}
return factorial(n) / (factorial(n-k) * factorial(k));
}

public String toString() {
return "ConMan";
}

public void printTheDeck() {
HashMap<Location, ArrayList<MyCard>> map = new HashMap();
for (Location loc : Location.values()) {
map.put(loc, new ArrayList());
}
for (ArrayList<MyCard> set : theDeck) {
for (MyCard m : set) {
}
}
String ret = "";
for (Player p : players) {
ret += p.toString()+": "+map.get(getLocation(p))+"\n";
}
ret += "Unknown: ("+map.get(Location.UNKNOWN).size()+" cards)\n";
debug(ret);
}

public void debug(Object s) {

}
}

• Nice job. This bot easily wins most games so far. Apr 10, 2015 at 12:58
• Thank you! Looking through the code, I realized I forgot to callBS when the cards said it was outright impossible. I've updated the code above. Apr 10, 2015 at 14:24

# Player 3131961357_10

Picks a random player each game, and always calls BS on that player.

package players;

import java.util.ArrayList;
import java.util.List;

import controller.*;

public class Player3131961357_10 extends Player{
private int[] ducks = new int;
private Player target = null;
private int cake = 0;

@Override
protected List<Card> requestCards(int bacon, Controller controller){
Card[] hand = getHand();
List<Card> ret = new ArrayList<Card>();
List<Card> others = new ArrayList<Card>();
for(Card c:hand){
if(c.getNumber() == bacon){
}else{
}
}
if(ret.size() == 0){
ImperfectPlayer.moveRandom(others, ret);
}
if(others.size() > 0 && ret.size() < 3 && handSize() > ret.size() + 1){
ImperfectPlayer.moveRandom(others, ret);
}
return ret;
}

private final int someoneLied = 0;
@Override
protected boolean bs(Player player, int bacon, int howMuchBacon, Controller controller){
if(target == null){
// Could not find my cake.
// Someone must have taken it.
// They are my target.
List<Player> players = controller.getPlayers();
do target = players.get((int)Math.floor(Math.random() * players.size()));
while(target != this);
}

int count = 0;
Card[] hand = getHand();
for(Card c:hand){
if(c.getNumber() == bacon)
++count;
}
ducks = new int;
cake = someoneLied;
}
ducks[bacon] += howMuchBacon;
cake += howMuchBacon;

if(player.handSize() == 0) return true;
return player.handSize() == 0
|| howMuchBacon + count > 4
|| ducks[bacon] > 5
|| player == target
|| Math.random() < 0.025; // why not?
}

public String toString(){
return "Player 3131961357_10";
}

public static <T> void moveRandom(List<T> from, List<T> to){
T a = from.remove((int)Math.floor(Math.random() * from.size()));
}
}


# Truthy

Not quite finished, since I don't know how to tell the result of calling BS (if they took the pile, or someone else in case of tie, or I did).

At the moment, only call BS if I can prove it. Don't lie unless I have to. I need to improve the lying algorithm. I'm trying to make it as close as possible to how I play BS against other players (minus randomly putting extra cards underneath to play 5 or 6 without them knowing.)

package players;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import controller.*;

public class PlayerTruthy extends Player {

private List<Card> played;
private HashMap<String,Integer> handSizes;
private boolean initialized;

// Constructor
public PlayerTruthy() {
played = new ArrayList<Card>();
handSizes = new HashMap<String,Integer>();
initialized = false;
}

// Initialize (do once)
private void init(Controller controller) {
for (Player p : controller.getPlayers()) {
handSizes.put(p, 0);
}
initialized = true;
}

@Override
protected List<Card> requestCards(int card, Controller controller) {
if (!initialized) {
init(controller);
}
List<Card> cards = getCards(card);
if (cards.size() == 0) {
cards = lieCards(card);
}
return cards;
}

@Override
protected boolean bs(Player player, int card, int numberOfCards, Controller controller) {
if (!initialized) {
init(controller);
}
List<Card> hand = Arrays.asList(getHand());
int count = countCards(hand, card);
return numberOfCards > 4-count;
}

public String toString() {
return "Truthy";
}

private int countCards(List<Card> list, int card) {
int count = 0;
for (Card c : list) {
if (c.getNumber() == card) {
count++;
}
}
return count;
}

private List<Card> getCards(int card) {
List<Card> cards = new ArrayList<Card>();
Card[] hand = getHand();
for (Card c : hand) {
if (c.getNumber() == card) {
}
}
return cards;
}

private List<Card> lieCards(int card) {
List<Card> hand = Arrays.asList(getHand());
List<Card> cards = new ArrayList<Card>();
int limit = 1;
int count = 0;
int index = (card+9) % 13;
while (cards.size() == 0) {
count = countCards(hand, index);
if (count <= limit) {
cards = getCards(index);
}
if (limit >= 3) {
cards.removeRange(1, cards.size());
}
if (index == card) {
limit++;
}
index = (index+9) % 13;
}
return cards;
}
}

• You could also keep track of the played cards. Apr 6, 2015 at 20:11
• I'm not sure what you're trying to do with cards = cards.get(0). cards is a list so you can't assign a Card to a List<Card>. Are you trying to remove everything except the first element? Apr 7, 2015 at 12:07
• Yeah, fixed it. Apr 8, 2015 at 0:14
• I found the results of BS by memorizing the hand sizes of each player, and then comparing my memory to what the controller has. An increase means that player lost; a decrease means that player won. (The current player's hand size must be offset by the numberOfCards because they are already discarded when bs is called) Apr 10, 2015 at 15:11
• I don't know if I'll ever have time to implement what I wanted to. The more I thought about how I'd optimally play BS, the harder the programming would be. I pretty much wanted to do what ConMan has to some extent, but the complexity is a little much for me. Apr 10, 2015 at 15:47

# CalculatingLiar

This one tries to play truth. If he lies, he uses a card that he won't use in the near future. It also tries to win trough calling BS on other players, since the last card almost never fits.

package players;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import controller.Card;
import controller.Controller;
import controller.Player;

public class CalculatingLiar extends Player {
private final List<Integer> knownCardsOnDeck = new ArrayList<>();
private int lastDeckSize = 0;

@Override
protected List<Card> requestCards(int card, Controller controller) {
Card[] hand = getHand();
List<Card> ret =  new ArrayList<Card>();
for (Card c : hand) {
if (c.getNumber() == card) {
}
}
if (ret.size() == 0) {
}

update(controller);

for (Card c : ret) {
}
return ret;
}

@Override
protected boolean bs(Player player, int card, int numberOfCards,
Controller controller) {
Card[] hand = getHand();
int myCards = 0;
for (Card c : hand) {
if (c.getNumber() == card)
myCards++;
}
update(controller);
for (Integer number : knownCardsOnDeck) {
if (number == card) {
myCards++;
}
}

return player.handSize() == 0
|| numberOfCards > 4
|| myCards + numberOfCards > 4
|| (player.handSize() < 5 && handSize() == 1);
}

@Override
protected void initialize(Controller controller) {
knownCardsOnDeck.clear();
lastDeckSize = 0;
}

@Override
protected void update(Controller controller) {
knownCardsOnDeck.clear();
} else {
}
}

private Card calculateWorstCard(int currentCard) {
List<Integer> cardOrder = new ArrayList<>();

int nextCard = currentCard;
do {
nextCard = (nextCard + 4) % 13;
} while (nextCard != currentCard);
Collections.reverse(cardOrder);

Card[] hand = getHand();
for (Integer number : cardOrder) {
for (Card card : hand) {
if (card.getNumber() == number) {
return card;
}
}
}
//never happens
return null;
}

@Override
public String toString() {
return "(-";
}
}


# Hoarder

package players;

import java.util.ArrayList;
import java.util.List;

import controller.*;

public class Hoarder extends Player{
@Override
protected List<Card> requestCards(int card, Controller controller) {
Card[] hand = getHand();
List<Card> ret =  new ArrayList<Card>();
if( canWinHonestly(card) ) { //Hoarded enough cards that I won't have to bs ever again, time to win.
for (Card c : hand) {
if (c.getNumber() == card) {
}
}
}
else { // Don't have the cards I'll need in the future. Play my entire hand. Either get more cards or instantly win.
for (Card c : hand) {
}
}
return ret;
}

@Override
protected boolean bs(Player player, int card, int numberOfCards, Controller controller) {
//Don't call unless I have to, don't want to lose a random card
return (player.handSize() <= numberOfCards);
}

@Override
public String toString() {
return "Hoarder";
}

private boolean canWinHonestly(int card) {
Card[] hand = getHand();
List<Integer> remainingCards = new ArrayList<Integer>();
for (Card c : hand) {
}
while( remainingCards.size() > 0 ) {
if(remainingCards.contains(card)) {
remainingCards.remove((Integer) card);
card = (card + 4) % 13;
}
else {
return false;
}
}
return true;
}

}


Very simple strategy, collects cards until it can go on an honesty streak and win. Wasn't able to test it, hopefully my Java isn't too rusty.

• remainingCards.remove(card) should have a cast to Integer, otherwise Java thinks you are calling .remove(int), which is remove by index. Apr 7, 2015 at 0:41

# LiePlayer

Lays down at least 2 cards, even if that means stretching the truth.

package players;

import java.util.ArrayList;
import java.util.List;

import controller.*;

public class LiePlayer extends Player {

@Override
protected List<Card> requestCards(int card, Controller controller) {
Card[] hand = getHand();
List<Card> ret =  new ArrayList<Card>();
for (Card c : hand) {
if (c.getNumber() == card) {
}
}
int i=0;
while(ret.size()<2 && i<cards.length){
if(c.getNumber() != card){
}
i++;
}
return ret;
}

@Override
protected boolean bs(Player player, int card, int numberOfCards, Controller controller) {
Card[] hand = getHand();
int myCards = 0;//How meny of that card do I have.
for (Card c : hand) {
if (c.getNumber() == card) {
myCards += 1;
}
}
return numberOfCards+myCards >= 4;
//for that to work, he would have to have all the other cards of that number.
}

public String toString() {
//Why would we admit to lying?
return "Truthful Player";
}
}

• Card[] hand = getHand(); is needed at the top of bs(..) (Player.hand is private). Also, this crashes if you have fewer than 2 cards in your hand. Apr 7, 2015 at 0:35
• Unfortunately, your code has some errors: cards is not defined at i<cards.length; hand is not defined at Card c : hand. And sometimes it goes into an infinite loop because you don't do ++i in the loop. I would add these but I'm not sure that's how you want them exactly. Apr 14, 2015 at 0:25