package com.sillysoft.lux;import java.util.List;import java.util.ArrayList;/** The Card class provides a data structure for representing cards, as well as some methods for checking sets.*/public class Card{// The country code of the country that is on this card:int countryCode;// The symbol on the card (we just assign the three different // pictures to be 0 for horses, 1 for cannons, 2 for men, and 3 // for wildcard (on which there will be a country code of -1):int symbol;public Card( int assocCode, int symbol )	{	this.symbol = symbol;	if ( symbol == 3 )		{		countryCode = -1;		}	else		{		countryCode = assocCode;		}	}/** Returns the country code associated with this card. It will return -1 if the card is wild. */public int getCode()	{	return countryCode;	}/** Returns the symbol on the card. Normal symbols are 0,1,2 while wildcards are 3.*/public int getSymbol()	{	return symbol;	}/** A test of whether these three cards are a cashable set. */public static boolean isASet( Card card1, Card card2, Card card3 )	{	if (card1 == null || card2 == null || card3 == null)		return false;	// Cycle through the cards and count the number of each symbol:	int symbolCount[] = new int[4];	symbolCount[ card1.getSymbol() ]++;	symbolCount[ card2.getSymbol() ]++;	symbolCount[ card3.getSymbol() ]++;	if ( symbolCount[0] + symbolCount[3] == 3 || symbolCount[1] + symbolCount[3] == 3 || symbolCount[2] + symbolCount[3] == 3 )		return true;	if ( ( Math.min( symbolCount[0], 1 ) + Math.min( symbolCount[1], 1 ) + Math.min( symbolCount[2], 1 ) + symbolCount[3] ) > 2 )		return true;	// Otherwise, they have no set:	return false;	}/** A test of whether the array of cards contains at least one cashable set. */public static boolean containsASet( Card[] cards )	{	if (cards == null || cards.length < 3)		return false;	// A player has a match if he has either three cards with the same symbol, or one of each symbol.	// Wildcard's symbol is 3, it can be anything.	// Cycle through the cards and count the number of each symbol:	int symbolCount[] = new int[4];	for (int i = 0; i < cards.length; i++)		{		symbolCount[ cards[i].getSymbol() ]++;		}	// See if they have three of a kind (3 counts for anything):	for (int i = 0; i < 3; i++)		{		if ( symbolCount[i] + symbolCount[3] > 2 )			{			return true;			}		}	// Now see if they have one of each (3 counts for anything):	if ( ( Math.min( symbolCount[0], 1 ) + Math.min( symbolCount[1], 1 ) + Math.min( symbolCount[2], 1 ) + symbolCount[3] ) > 2 )		{		return true;		}	// Otherwise, we have no set:	return false;	}/** This returns a size-3 Card array, containing a random set from amongst the given array.*The return value is undefined if there is no set. Use containsASet() to check first. */public static Card[] getRandomSet( Card[] cards )	{	Card[] toReturn = new Card[3];	// Cycle through the cards and count the number of each symbol:	int symbolCount[] = new int[4];	for (int i = 0; i < cards.length; i++)		{		symbolCount[ cards[i].getSymbol() ]++;		}	// See if they have three of a kind (3 counts for anything):	for (int i = 0; i < 3; i++)		{		if ( symbolCount[i] + symbolCount[3] > 2 )			{			int setCounter = 0;			// Then they have a set with symbol i, let's get it:			for (int j = 0; setCounter != 3 && j < cards.length; j++)				{				if ( cards[j].getSymbol() == i || cards[j].getSymbol() == 3 )					{					toReturn[ setCounter ] = cards[j];					setCounter++;					}				}			return toReturn;			}		}	// OK, so they don't have three symbols of a kind. that means that they must have one of each.	// Let's find them:	for (int j = 0; j < cards.length; j++)		{		if ( toReturn[0] == null && cards[j].getSymbol() == 0 )			{			toReturn[0] = cards[j];			}		else if ( toReturn[1] == null && cards[j].getSymbol() == 1 )			{			toReturn[1] = cards[j];			}		else if ( toReturn[2] == null && cards[j].getSymbol() == 2 )			{			toReturn[2] = cards[j];			}		else if ( cards[j].getSymbol() == 3 )			{			if ( symbolCount[0] == 0 && toReturn[0] == null )				{				toReturn[0] = cards[j];				}			else if ( symbolCount[1] == 0 && toReturn[1] == null )				{				toReturn[1] = cards[j];				}			else if ( symbolCount[2] == 0 && toReturn[2] == null )				{				toReturn[2] = cards[j];				}			}		}	return toReturn;	}/** This returns a size-3 Card array, containing a set from amongst the given array that uses as many cards owned by <i>player</i> as possible. Returns null if no sets are found.	*/public static Card[] getBestSet( Card[] cards, int player, Country[] countries )    {		// First look for a set using non wildcards:	List noWildList = new ArrayList();	List wildList = new ArrayList();	for (int i = 0; i < cards.length; i++)		{		if (cards[i].getSymbol() != 3)			noWildList.add(cards[i]);		else			wildList.add(cards[i]);		}	if (cards.length > noWildList.size())		{		// Then there were some wildcards. Look for a set amongst the non-wildcards:		Card[] noWildCards = new Card[noWildList.size()];		for (int i = 0; i < noWildList.size(); i++)			noWildCards[i] = (Card) noWildList.get(i);					Card[] bestNoWildSet = Card.getBestSet(noWildCards, player, countries);		if (bestNoWildSet != null)			{			// We found a set using no wildcards, return it:			return bestNoWildSet;			}					// No set was found using none of our wildcards. try with only one if we have multiple wildcards:		if (cards.length > noWildList.size() + 1)			{			Card[] oneWildCardList = new Card[noWildList.size() + 1];			for (int i = 0; i < noWildList.size(); i++)				oneWildCardList[i] = (Card) noWildList.get(i);			oneWildCardList[oneWildCardList.length-1] = (Card) wildList.get(0);						Card[] bestOneWildSet = Card.getBestSet(oneWildCardList, player, countries);			if (bestOneWildSet != null)				{				// We found a set using no wildcards, return it:				return bestOneWildSet;				}						}		}			// our attempts at finding a set with no wildcards have failed (or we have no wildcards).			    // populate an array with the ownercodes of the cards    int[] owners = new int[cards.length];    int owned = 0;    for (int i = 0; i < cards.length; i++)        {		if (cards[i].getCode() == -1)			owners[i] = -1;		else			{			owners[i] = countries[cards[i].getCode()].getOwner();			if (owners[i] == player)				owned++;			}        }    // start by getting an array with all the owned cards    Card[] ownedCards = new Card[owned];    int count = 0;        for (int i = 0; i < cards.length; i++)        {        if (owners[i] == player)            {            ownedCards[count] = cards[i];            count++;            }        }    if (owned > 2)        {        if (Card.containsASet( ownedCards ))            {            return Card.getRandomSet( ownedCards );            }        }    // OK, they have no sets made up of three of their cards.    // look for sets with two now    if (owned > 1)        {        Card[] ownedPlus = new Card[owned+1];        for (int i = 0; i < owned; i++)            ownedPlus[i] = ownedCards[i];         // now loop over all the non-owned cards looking for a set using only one of them        for (int c = 0; c < cards.length; c++)            {            if (owners[c] != player)                {                ownedPlus[owned] = cards[c];                if (Card.containsASet( ownedPlus ))                    {                    return Card.getRandomSet( ownedPlus );                    }                }            }        }    // ok, there is no set using two of the player's cards    if (owned > 0)        {        Card[] ownedPlusPlus = new Card[owned+2];        for (int i = 0; i < owned; i++)            ownedPlusPlus[i] = ownedCards[i];         for (int c = 0; c < cards.length; c++)        for (int d = 0; d < cards.length; d++)            {            if (owners[c] != player && owners[d] != player && c != d)                {                ownedPlusPlus[owned] = cards[c];                ownedPlusPlus[owned+1] = cards[d];                if (Card.containsASet( ownedPlusPlus ))                    {                    return Card.getRandomSet( ownedPlusPlus );                    }                }            }        }	// Check for any set at all	if (Card.containsASet(cards))		return Card.getRandomSet(cards);    return null;    }/** The way this method is implemented all wildcards are equal to each other!!! */public boolean equals(Object other)	{	if (other instanceof Card)		{		Card card = (Card) other;		return (card.countryCode == this.countryCode && card.symbol == this.symbol);		}	return false;	}/** Gives a String representation of the card.*/public String toString()	{	return "<Card symbol=\""+symbol+"\" country=\""+countryCode+"\">";	}}