Artificial Intelligence in Game Opponents

2 thoughts on “Artificial Intelligence in Game Opponents”

1. Hello,
   I might be a little late but, would you care sharing your AI script code? I’m planning doing one for the exact same use and I was wondering if I could do mine inspired by yours.
   Thank you!

   • I’m not sure how useful this code will be, as it is old and ripped right out of a project. It should at the very least give you a basic idea of how it works. I haven’t seen this code myself in ~5 years, so I was surprised that it actually has quite a lot of comments explaining how it works. The comments are probably more useful than the code:

     using System;
using System.Collections.Generic;
using System.Xml.Serialization;


namespace Match
{
public class AIOpponent
{
// this stores the logic for the AI opponent
public DataTypes.MatchPlayer AiPlayer;

     public AIOpponent()
     {
     }
     public AIOpponent(int skillLevel)
     {
     AiPlayer = new DataTypes.MatchPlayer(new DataTypes.Player());
     AiPlayer.IsAiOpponent = true;

     rememberedCards = new List();
     GameSettings.DifficultyLevel = skillLevel;
     switch (GameSettings.DifficultyLevel)
     {
     case 1:
     AiPlayer.Username = "Easy CPU";
     AiPlayer.AvatarImage = "ms-appx:///Images/Icons/player_1.png";
     break;
     case 5:
     AiPlayer.Username = "Medium CPU";
     AiPlayer.AvatarImage = "ms-appx:///Images/Icons/player_2.png";
     break;
     case 8:
     AiPlayer.Username = "Hard CPU";
     AiPlayer.AvatarImage = "ms-appx:///Images/Icons/player_3.png";
     break;
     case 10:
     AiPlayer.Username = "Impossible CPU";
     AiPlayer.AvatarImage = "ms-appx:///Images/Icons/player_4.png";
     break;
     default:
     AiPlayer.Username = "Error with AI";
     AiPlayer.AvatarImage = "ms-appx:///Images/Icons/player_1.png";
     break;

     }

     }

     [XmlIgnore]
     private DataTypes.Card firstCard { get; set; } // should not need to save this as the game should not be saved during a turn

     private bool RandomlyOverrideSkill()
     {
     // pick a number between 1 and the difficulty level
     // if number == difficulty level then play randomly instead of using skill
     // this makes the AI opponent play more randomly the lower the difficulty level is
     var rand = new Random();
     int s = rand.Next(1, GameSettings.DifficultyLevel + 1);

     if (s == GameSettings.DifficultyLevel)
     {
     // pick randomly
     return true;
     }
     else
     {
     // pick skillfully
     return false;
     }
     }

     public DataTypes.Card SelectedCard(List cardsList, bool isFirstCard)
     {
     if (isFirstCard)
     {
     firstCard = FindPairedOrRandomCard(cardsList);
     return firstCard;
     }
     else
     {
     return FindMatchingOrRandomCard(cardsList, firstCard);
     }
     }

     [XmlArrayItem(typeof(Clown)),
     XmlArrayItem(typeof(HoseClown)),
     XmlArrayItem(typeof(Cannon)),
     XmlArrayItem(typeof(LargeBall)),
     XmlArrayItem(typeof(MediumBall)),
     XmlArrayItem(typeof(ClownCar)),
     XmlArrayItem(typeof(ClownShoe)),
     XmlArrayItem(typeof(Balloon))]
     public List rememberedCards { get; set; }

     public void ResetAI()
     {
     rememberedCards = new List();
     }

     // holds a list of cards the AI has seen/remembered
     // the list sets the index value to true for all cards seen
     // the selection algorithms decide if the AI accurately acts on the information (e.g. making it forget some cards or picking an adjacent card by 'mistake')
     //static List rememberedCards;

     public void RememberCard(DataTypes.Card card, List cardsList)
     {

     // the AI remembers cards it has seen face up
     // based on difficulty level the AI will occasionally not remember cards it has seen
     // higher the difficulty the more chance of remembering the card
     var rand = new Random();

     // card is easier to remember if it is on a corner or edge
     CardPosition position = GetCardPos(cardsList.IndexOf(card));
     // temporarily increase the difficulty based on card position
     int modifiedDifficulty = GameSettings.DifficultyLevel + 1;

     // AI memory is improved when the card is at the corner or edge
     if(position == CardPosition.Corner)
     {
     modifiedDifficulty += 5;
     }
     else if(position == CardPosition.Edge)
     {
     modifiedDifficulty += 2;
     }

     int s = rand.Next(0, modifiedDifficulty);

     if (s != 1)
     {
     // rememberedCards[index] = true;
     if (!rememberedCards.Contains(card))
     {
     rememberedCards.Add(card);
     }
     }
     }

     private CardPosition GetCardPos(int p)
     {
     switch(p)
     {
     case 0:
     case 3:
     case 12:
     case 15:
     return CardPosition.Corner;
     case 1:
     case 2:
     case 4:
     case 7:
     case 8:
     case 11:
     case 13:
     case 14:
     return CardPosition.Edge;
     default:
     return CardPosition.Middle;

     }
     }

     enum CardPosition
     {
     Middle,
     Edge,
     Corner

     }

     private DataTypes.Card PickRandomCard(List cardsList)
     {
     // used to pick a card completely at random from the live and face-down cards

     Random rand = new Random();

     retry:

     int randNum = rand.Next(0, cardsList.Count);
     if (cardsList[randNum].IsLive && cardsList[randNum].IsFaceDown)
     {
     return cardsList[randNum];
     }
     else
     {
     goto retry;
     }
     }

     private DataTypes.Card FindPairedOrRandomCard(List cardsList)
     {
     //List foundPair = new List();

     //TODO: this needs to be more random/more varied. Currently will find a pair with the first card in the list that has a known pair.
     // should be weighted somehow
     if (RandomlyOverrideSkill())
     {
     return PickRandomCard(cardsList);
     }

     foreach (DataTypes.Card card in rememberedCards)
     {
     if (card.IsLive)
     {
     foreach (DataTypes.Card otherCard in rememberedCards)
     {
     if (otherCard != card) // don't compare card to itself
     {
     if (otherCard.CardType == card.CardType && otherCard.IsLive)
     {
     //foundPair.Add(card);
     //foundPair.Add(otherCard);
     //return foundPair;
     return card;
     }
     }
     }
     }
     }

     // if no pair found, return a random card
     return PickRandomCard(cardsList);
     }

     private DataTypes.Card FindMatchingOrRandomCard(List cardsList, DataTypes.Card card)
{
// tries to find a card matching the one given in the args
// otherwise returns random card
// used to find a second card matching an already selected card
// override with a random selection based on difficulty level
if (RandomlyOverrideSkill())
{
return PickRandomCard(cardsList);
}
foreach (DataTypes.Card otherCard in rememberedCards)
{
if (otherCard != card && otherCard.CardType == card.CardType && otherCard.IsLive)
{
//foundPair.Add(card);
//foundPair.Add(otherCard);
//return foundPair;
return otherCard;
}
}
return PickRandomCard(cardsList);
}
}
}