override public bool decideOnPlayer(CardDecision decision, RpsAgent otherPlayer)
{
Card opponentsCard = decisionToCard(decision);
//Only accept requests we know we can win
return(parentAI.IndexOfCardInHand(counterCard(opponentsCard)) != -1);
}
override public Card decideOnCard(CardDecision decision, RpsAgent otherPlayer)
{
Card opponentsCard = decisionToCard(decision);
Dictionary <Card, int> cardCounts = parentAI.getCardCounts();
//The AI will counter the player or match the player depending on which is more out of balance
if (parentAI.IndexOfCardInHand(counterCard(opponentsCard)) != -1 && (cardCounts.Values.Aggregate(0, Mathf.Max) - cardCounts.Values.Aggregate(cardCounts.Count, Mathf.Max)) > 1)
{
return(counterCard(opponentsCard));
}
else if (cardCounts[opponentsCard] == cardCounts.Values.Aggregate(0, Mathf.Max))
{
return(opponentsCard);
}
else if (isProbable(decision) && (cardCounts.Values.Aggregate(0, Mathf.Max) - cardCounts.Values.Aggregate(cardCounts.Count, Mathf.Max)) > 1)
{
//return the card we have the most of
return(cardCounts.First(entry => entry.Value == cardCounts.Values.Aggregate(0, Mathf.Max)).Key);
}
else
{
//Shouldn't happen, but if it does, return a random card
return((Card)Random.Range(0, 2));
}
}
override public Card decideOnCard(CardDecision decision, RpsAgent otherPlayer)
{
//If we don't know what the opponent will play, assume they are playing the card with the highest number in play
if (decision == CardDecision.Random)
{
Dictionary <Card, int> totalCardCounts = GameObject.FindObjectOfType <ChallengeLobbyManager>().getTotalCardCounts();
Card highestCardInPlay = totalCardCounts.Keys.Aggregate(Card.Rock, (x, y) => totalCardCounts[x] > totalCardCounts[y] ? x : y);
if (parentAI.IndexOfCardInHand(counterCard(highestCardInPlay)) != -1)
{
return(counterCard(highestCardInPlay));
}
else
{
return(highestCardInPlay);
}
}
Card opponentsCard = decisionToCard(decision);
//The AI will do their best to counter the opponent
if (parentAI.IndexOfCardInHand(counterCard(opponentsCard)) != -1)
{
return(counterCard(opponentsCard));
}
else
{
return(opponentsCard);
}
}
override public bool decideOnPlayer(CardDecision decision, RpsAgent otherPlayer)
{
Card opponentsCard = decisionToCard(decision);
Dictionary <Card, int> totalCardCounts = GameObject.FindObjectOfType <ChallengeLobbyManager>().getTotalCardCounts();
Card highestCardInPlay = totalCardCounts.Keys.Aggregate(Card.Rock, (x, y) => totalCardCounts[x] > totalCardCounts[y] ? x : y);
if (parentAI.IndexOfCardInHand(counterCard(opponentsCard)) != -1)
{
return(highestCardInPlay == opponentsCard);
}
return(highestCardInPlay != opponentsCard);
}
override public Card decideOnCard(CardDecision decision, RpsAgent otherPlayer)
{
Card opponentsCard = decisionToCard(decision);
//The AI blindly decides to counter the player decision or match it if possible
if (parentAI.IndexOfCardInHand(counterCard(opponentsCard)) != -1)
{
return(counterCard(opponentsCard));
}
else
{
return(opponentsCard);
}
}
public override int getSelectedCard(RpsAgent otherPlayer)
{
CardDecision opponentsDecision = getCardDecision(otherPlayer);
Card bestCard = this.currentStrategyState.decideOnCard(opponentsDecision, otherPlayer);
int index = IndexOfCardInHand(bestCard);
if (index > -1)
{
selectedCard = index;
}
selectedCard = returnRandomCardFromHand();
return(selectedCard);
}
//Returns the card that this decision would have you play
public Card decisionToCard(CardDecision decision)
{
if (decision == CardDecision.ProbableRock || decision == CardDecision.DefiniteRock)
{
return(Card.Rock);
}
else if (decision == CardDecision.ProbablePaper || decision == CardDecision.DefinitePaper)
{
return(Card.Paper);
}
else if (decision == CardDecision.ProbableScissors || decision == CardDecision.DefiniteScissors)
{
return(Card.Scissors);
}
else
{
return((Card)Random.Range(0, 2));
}
}
override public bool decideOnPlayer(CardDecision decision, RpsAgent otherPlayer)
{
Card opponentsCard = decisionToCard(decision);
//Only accept requests which can leave our hand balanced
Dictionary <Card, int> cardCounts = parentAI.getCardCounts();
if (parentAI.IndexOfCardInHand(counterCard(opponentsCard)) != -1)
{
return(cardCounts.Values.Aggregate(0, Mathf.Max) - cardCounts[counterCard(opponentsCard)] <= 1);
}
else if (parentAI.IndexOfCardInHand(opponentsCard) != -1)
{
return(cardCounts.Values.Aggregate(0, Mathf.Max) - cardCounts[opponentsCard] <= 1);
}
else
{
//If we can't beat the card, we'll challenge if our hand is sufficiently out of whack in terms of balance
return(isProbable(decision) && (cardCounts.Values.Aggregate(0, Mathf.Max) - cardCounts.Values.Aggregate(cardCounts.Count, Mathf.Max)) > 1);
}
}
public void AddSuggestion(CardDecision card)
{
_stackCard.Push(card);
}
//Returns which card we should play based on what we think the other player is going to play and our own hand public abstract Card decideOnCard(CardDecision card, RpsAgent otherPlayer);
//Returns whether or not we should play this player based on what we think the other player is going to play and our own hand public abstract bool decideOnPlayer(CardDecision card, RpsAgent otherPlayer);
//Basic used to see if a decision is probable
public bool isProbable(CardDecision decision)
{
return(decision == CardDecision.ProbableRock || decision == CardDecision.ProbablePaper || decision == CardDecision.ProbableScissors);
}
override public bool decideOnPlayer(CardDecision decision, RpsAgent otherPlayer)
{
//Accept any match
return(true);
}
private bool makeRequestDecision(RpsAgent otherPlayer)
{
CardDecision opponentsDecision = getCardDecision(otherPlayer);
return(currentStrategyState.decideOnPlayer(opponentsDecision, otherPlayer));
}
