ACES_HIGH = True

class card:
   suits = ["Clubs",
            "Diamonds",
            "Hearts",
            "Spades" ]
   ranks = ["Ace",
            "2",
            "3",
            "4",
            "5",
            "6",
            "7",
            "8",
            "9",
            "10",
            "Jack",
            "Queen",
            "King" ]

   def __init__(self, suit=0, rank=0):
       self.suit = suit
       self.rank = rank

   def __str__(self):
       return (self.ranks[self.rank] + " of " + self.suits[self.suit])

   def __cmp__(self, other):
       if self.suit > other.suit:
           return 1
       if self.suit < other.suit:
           return -1

       if ACES_HIGH == True:
           m = 13
           if m > other.rank:
               return 1
           if m < other.rank:
               return -1

       if ACES_HIGH == False:
           if self.rank > other.rank:
               return 1
           if self.rank < other.rank:
               return -1
       return 0

class deck:
   def __init__(self):
       self.cards = []
       for suit in range(4):
           for rank in range(12):
               self.cards.append(card(suit, rank))

   def __str__(self):
       s = ''
       for i in range(len(self.cards)):
           s = s + str(self.cards[i]) + '\n'
       return s
           

   def shuffle(self):
       import random
       cards_length = len(self.cards)
       for i in range(cards_length):
           j = random.randrange(i, cards_length)
           self.cards[i], self.cards[j] = self.cards[j], self.cards[i]

   def remove(self, card):
       if card in self.cards:
           self.cards.remove(card)
           return True
       else:
           return False

   def draw(self):
       return self.cards.pop()

   def is_empty(self):
       return (len(self.cards) == 0)

   def deal(self, hands, num_cards=999):
       for i in range(num_cards):
           if self.is_empty(): break
           card = self.pop()
           hand = hands[i % len(hands)]
           hand.add(card)

   def pop(self):
       return self.cards.pop()


class hand(deck):
   def __init__(self, player=''):
       self.cards = []
       self.player = player

   def add(self, card):
       self.cards.append(card)

   def __str__(self):
       s = "Hand " + self.player
       if self.is_empty():
           s = s + " is empty\n"
       else:
           s = s + " contains\n"
       for i in range(len(self.cards)):
           s = s + str(self.cards[i]) + '\n'
       return s

   


deck = deck()
deck.shuffle()

hand1 = hand("1")
deck.deal([hand1], 5)
print hand1

hand2 = hand("2")
deck.deal([hand2], 5)
print hand2

>>>
Hand 1 contains
2 of Spades
8 of Clubs
3 of Diamonds
8 of Spades
10 of Hearts

Hand 2 contains
3 of Clubs
2 of Clubs
10 of Clubs
4 of Diamonds
Jack of Spades

>>>

"""
To do:
- Check to see if player play is valid with top card.
- Allow player to draw cards from deck.
- Create an Ai which plays available cards, and draws if unavailable.
- Create rules for unique cards, like lose a turn, etc.
- Possibly add in rule to allow to play multiple cards at once, like pairs?

Created by: CecilSunkure
"""

import sys
import random

ACES_HIGH = True
GAME_RUNNING = True

class card:
   suits = ["Clubs",
            "Diamonds",
            "Hearts",
            "Spades" ]
   ranks = ["Ace",
            "2",
            "3",
            "4",
            "5",
            "6",
            "7",
            "8",
            "9",
            "10",
            "Jack",
            "Queen",
            "King" ]

   def __init__(self, suit=0, rank=0):
       self.suit = suit
       self.rank = rank

   def __str__(self):
       return (self.ranks[self.rank] + " of " + self.suits[self.suit])

   def __cmp__(self, other):
       if self.suit > other.suit:
           return 1
       if self.suit < other.suit:
           return -1

       if ACES_HIGH == True:
           m = 13
           if m > other.rank:
               return 1
           if m < other.rank:
               return -1

       if ACES_HIGH == False:
           if self.rank > other.rank:
               return 1
           if self.rank < other.rank:
               return -1
       return 0

class deck:
   def __init__(self):
       self.cards = []
       for suit in range(4):
           for rank in range(12):
               self.cards.append(card(suit, rank))

   def __str__(self):
       s = ''
       for i in range(len(self.cards)):
           s = s + str(self.cards[i]) + '\n'
       return s
           

   def shuffle(self):
       import random
       cards_length = len(self.cards)
       for i in range(cards_length):
           j = random.randrange(i, cards_length)
           self.cards[i], self.cards[j] = self.cards[j], self.cards[i]

   def remove(self, card):
       if card in self.cards:
           self.cards.remove(card)
           return True
       else:
           return False

   def draw(self):
       return self.cards.pop()

   def is_empty(self):
       return (len(self.cards) == 0)

   def deal(self, hands, num_cards=999):
       for i in range(num_cards):
           if self.is_empty(): break
           card = self.pop()
           hand = hands[i % len(hands)]
           hand.add(card)

   def pop(self):
       return self.cards.pop()


class hand(deck):
   def __init__(self, player=''):
       self.cards = []
       self.player = player

   def add(self, card):
       self.cards.append(card)

   def __str__(self):
       s = self.player + "'s Hand"
       t = 0
       if self.is_empty():
           s = s + " is empty\n"
       else:
           s = s + " contains\n"
       for i in range(len(self.cards)):
           t += 1
           s = s + str(t) + '. ' + str(self.cards[i]) + '\n'
       return s

class MauMau:
   def __init__(self):
       self.deck = deck()
       self.deck.shuffle()
       self.players = []

   def getName(self):
       print('Welcome to Mau Mau!')
       player = raw_input()
       print('What is your name?')
       player = raw_input()
       print('')
       return player

   def startCard(self):
       return self.deck.pop()

def main():
   turn = random.randrange(2) + 1
   game = MauMau()
   name = game.getName()
   hand1 = hand(name)
   hand2 = hand("CPU")
   game.deck.deal([hand1], 5)
   game.deck.deal([hand2], 5)
   topCard = game.startCard()
   
   if turn == 1:
       print('The computer will go first, as decided at random.')
   else:
       print('You will move first, as decided at random.')
   
   while GAME_RUNNING:
       print ('///' + '\n' + '/// ' + str(topCard) + '\n' + '///' + '\n')
       print (hand1)

       if turn == 1:
           print ('The computer will now take its turn, hit enter to proceed.')
           a = raw_input()
       else:
           print ('Choose a card to play (1-5) or draw a card (6).')
           a = raw_input()


if __name__ == "__main__":
   main()

Welcome to Mau Mau!

What is your name?
Randy

You will move first, as decided at random.
///
/// Queen of Diamonds
///

Randy's Hand contains
1. Jack of Clubs
2. 9 of Diamonds
3. 9 of Clubs
4. 3 of Diamonds
5. Queen of Hearts

Choose a card to play (1-5) or draw a card (6).

"""
To do:
- Create the used stack pile.
- Allow players to make a move by playing a card onto the used stack pile.
- Create an Ai which plays available cards, and draws if unavailable.
- Create rules for unique cards, like lose a turn, etc.

Created by: CecilSunkure
"""

import sys
import random

ACES_HIGH = True
GAME_RUNNING = True

class card:
   suits = ["Clubs",
            "Diamonds",
            "Hearts",
            "Spades" ]
   ranks = ["Ace",
            "2",
            "3",
            "4",
            "5",
            "6",
            "7",
            "8",
            "9",
            "10",
            "Jack",
            "Queen",
            "King" ]

   def __init__(self, suit=0, rank=0):
       self.suit = suit
       self.rank = rank

   def __str__(self):
       return (self.ranks[self.rank] + " of " + self.suits[self.suit])

class deck:
   def __init__(self):
       self.cards = []
       for suit in range(4):
           for rank in range(12):
               self.cards.append(card(suit, rank))

   def __str__(self):
       s = ''
       for i in range(len(self.cards)):
           s = s + str(self.cards[i]) + '\n'
       return s
           

   def shuffle(self):
       import random
       cards_length = len(self.cards)
       for i in range(cards_length):
           j = random.randrange(i, cards_length)
           self.cards[i], self.cards[j] = self.cards[j], self.cards[i]

   def remove(self, card):
       if card in self.cards:
           self.cards.remove(card)
           return True
       else:
           return False

   def draw(self):
       return self.cards.pop()

   def is_empty(self):
       return (len(self.cards) == 0)

   def deal(self, hands, num_cards=999):
       for i in range(num_cards):
           if self.is_empty(): break
           card = self.pop()
           hand = hands[i % len(hands)]
           hand.add(card)

   def pop(self):
       return self.cards.pop()


class hand(deck):
   def __init__(self, player=''):
       self.cards = []
       self.player = player

   def add(self, card):
       self.cards.append(card)

   def __str__(self):
       s = self.player + "'s Hand"
       t = 0
       if self.is_empty():
           s = s + " is empty\n"
       else:
           s = s + " contains\n"
       for i in range(len(self.cards)):
           t += 1
           s = s + str(t) + '. ' + str(self.cards[i]) + '\n'
       return s

class MauMau:
   def __init__(self, stack=0, topCard=0):
       self.deck = deck()
       self.deck.shuffle()
       self.players = []
       self.stack = stack
       self.topCard = topCard

   def getName(self):
       print('Welcome to Mau Mau!')
       player = raw_input()
       print('What is your name?')
       player = raw_input()
       print('')
       return player

   def startCard(self):
       self.topCard = self.deck.pop()

   def cmp_topCard(self, other):
       if self.topCard.suit == other.suit:
           if self.topCard.rank == other.rank:
               return True

def isValidMove(move, hand, game, handlen):
   """Used to determine if a move by checking to see if the move is an integer, followed by and testing to see
   if the proposed move is within the length of the hand passed to this function. Finally, this function
   makes sure that the proposed card to be played is valid within the rules of the game (same rank)."""
   x = []
   for i in range(1, (handlen+2)):
       x.append(i)
   
   try:
       int(move)
   except:
       print('That is not a valid move (not int).\n')
       return False

   if int(move) not in x:
       print('That is not a valid move (not 1-' + str(handlen+1) + ').\n')
       return False

   if move != str(handlen+1):
       if game.topCard.rank == hand.cards[(int(move)-1)].rank:
           return True
       else:
           return False
   elif move == str(handlen+1):
       return True

def main():
   """This function is the main loop used for running the Class MauMau. The turns between Ai and human are
   represented by integers, and those integers are used in if statements to determine which player is currently
   taking their turn."""
   #turn = random.randrange(2) + 1 <-- A comment for now, so for testing the human always goes.
   turn = 0
   game = MauMau()
   name = game.getName()
   hand1 = hand(name)
   hand2 = hand("CPU")
   game.deck.deal([hand1], 5)
   game.deck.deal([hand2], 5)
   game.startCard()
   
   if turn == 1:
       print('The computer will go first, as decided at random.')
   else:
       print('You will move first, as decided at random.')
   
   while GAME_RUNNING:
       print ('///' + '\n' + '/// ' + str(game.topCard) + '\n' + '///' + '\n')
       print (hand1)

       if turn == 1:
           print ('The computer will now take its turn, hit enter to proceed.')
           Move = raw_input()
       else:
           print ('Choose a card to play (1-' + str(len(hand1.cards)) + ') or draw a card (' + str((len(hand1.cards)+1)) + ').')
           Move = raw_input()

           if isValidMove(Move, hand1, game, len(hand1.cards)):
               print('Valid move check passed.\n')

               if Move == str(len(hand1.cards)+1):
                   hand1.add(game.deck.draw())
           else:
               print('Valid move check failed.\n')
               

if __name__ == "__main__":
   main()

Welcome to Mau Mau!

What is your name?
Randy

You will move first, as decided at random.
///
/// 9 of Hearts
///

Randy's Hand contains
1. 5 of Diamonds
2. Jack of Diamonds
3. 2 of Clubs
4. Queen of Clubs
5. 6 of Clubs

Choose a card to play (1-5) or draw a card (6).
1
Valid move check failed.

///
/// 9 of Hearts
///

Randy's Hand contains
1. 5 of Diamonds
2. Jack of Diamonds
3. 2 of Clubs
4. Queen of Clubs
5. 6 of Clubs

Choose a card to play (1-5) or draw a card (6).
LOLOL
That is not a valid move (not int).

Valid move check failed.

///
/// 9 of Hearts
///

Randy's Hand contains
1. 5 of Diamonds
2. Jack of Diamonds
3. 2 of Clubs
4. Queen of Clubs
5. 6 of Clubs

Choose a card to play (1-5) or draw a card (6).
6
Valid move check passed.

///
/// 9 of Hearts
///

Randy's Hand contains
1. 5 of Diamonds
2. Jack of Diamonds
3. 2 of Clubs
4. Queen of Clubs
5. 6 of Clubs
6. 7 of Diamonds

Choose a card to play (1-6) or draw a card (7).

#A test module for creating a stack.

run = True
stack = []

while run:
   print('Stack, Pop, end, or continue? (1, 2, 3, enter)')
   yesno = raw_input()

   if yesno == '1':
       print('Enter a value to stack')
       a = raw_input()
       stack.append(a)

   if yesno == '2':
       try:
           stack.pop()
           b = stack.pop()
           print(b)
       except:
           print('Stack is empty.\n')

   if yesno == '3':
       run = False

/****************************
*Mau Mau, java card game.
*Auteur: Apos
*Version: Not yet set.
*ofscription: Card game based off of the Mau Mau game. Everything is text only.
*URL(s):     http://en.wikipedia.org/wiki/Mau_Mau_(card_game)
*             http://www.java-examples.com/check-string-contains-valid-number-example
*             http://leepoint.net/notes-java/data/strings/12stringcomparison.html
*   To do:
* - Allow players to play a card.
* - AI
* - The game itself.
****************************/

import java.util.*;
import java.io.*;

class maun
{
    public static void main(String[] args) throws IOException
    {
        String[][] ofck = {
        {"Hearts", "Spades", "Diamonds", "Clubs"},
        {"Ace of ", "2 of ", "3 of ", "4 of ", "5 of ", "6 of ", "7 of ", "8 of ", "9 of ", "10 of ", "Jack of ", "Queen of ", "King of "}};
        int a = 0;
        int b = 0;
        int c = 0;
        String[] paquet = new String[52];
        String[] jette = new String[52];
        String[] main1 = new String[52];
        String[] main2 = new String[52];
        BufferedReader stdin = new BufferedReader ( new InputStreamReader( System.in ) );
        String input1;
        int input2 = 0;
        int state = 0;
        int refaire1 = 0;
        int refaire2 = 0;
        int ajouter1 = 0;
        int ajouter2 = 0;
        int tourner = 0;
        String[] card;
        String[] cardjette;
        String oflimiter = " ";
        while (state != 5)
        {
            while (state ==0)
            {
                for (int i = 1; i <= 13; i++)
                {
                    for (int j = 0; j<=3; j++)
                    {
                        paquet[a] = (ofck[1][i-1] + ofck[0][j]);
                        a++;
                    }
                }
                a = 0;
                List<String> mix = Arrays.asList(paquet);
                Collections.shuffle(mix);
                Collections.shuffle(mix);
                state = 1;
            }
            while (state == 1)
            {
            ajouter1 = 5;
            ajouter2 = 5;
            refaire1 = 1;
            refaire2 = 1;
            tourner = 1;
            state = 2;
            }
            while (refaire1 == 1 && ajouter1 != 0)
            {
                for (int i = 0; i <= ajouter1 - 1; i++)
                {
                    if (main1[i + c] == null)
                    {
                        main1[i + c] = paquet[i];
                        for (int j = 0; j <= ajouter1 - 1 && i == ajouter1 - 1; j++)
                        {
                            for (int k = 0; k <= 50; k++)
                            {
                                paquet[k] = paquet[k + 1];
                            }
                        }
                        b = 0;
                        while (i == ajouter1 - 1 && 52 - ajouter1 != 52 && b + 51 - ajouter1 <= 50)
                        {
                            paquet[b + 52 - ajouter1] = null;
                            b++;
                        }
                    }
                    else
                    {
                        c++;
                        i--;
                    }
                }
                ajouter1 = 0;
                refaire1 = 0;
                b = 0;
                c = 0;
            }
            while (refaire2 == 1 && ajouter2 != 0)
            {
                for (int i = 0; i <= ajouter2 - 1; i++)
                {
                    main2[i] = paquet[i];
                    for (int j = 0; j <= ajouter2 - 1 && i == ajouter2 - 1; j++)
                    {
                        for (int k = 0; k <= 50; k++)
                        {
                            paquet[k] = paquet[k + 1];
                        }
                    }
                    b = 0;
                    while (i == ajouter2 - 1 && 52 - ajouter2 != 52 && b + 51 - ajouter2 <= 50)
                    {
                        paquet[b + 52 - ajouter2] = null;
                        b++;
                    }
                }
                ajouter2 = 0;
                refaire2 = 0;
                b = 0;
            }
            while (tourner == 1)
            {
                for (int i = 51; i >= 2; i--)
                {
                    jette[i] = jette[i-1];
                }
                jette[0] = paquet[0];
                for (int j = 0; j <= 0; j++)
                {
                    for (int k = 0; k <= 50; k++)
                    {
                        paquet[k] = paquet[k + 1];
                    }
                }
                b = 0;
                while (b + 50 <= 50)
                {
                    paquet[b + 51] = null;
                    b++;
                }
                tourner = 0;
                b = 0;
            }
            while (state == 2 && refaire1 != 1)
            {
                for (int i = 0; i == 0; i++)
                {
                    System.out.println("\n///\n///\t" + jette[0] + "\n///\n");

                    System.out.println("\nPlayer 1's Hand contains\n");

                    while (main1[b] != null)
                    {
                        System.out.println(b+1 + ". \t" + main1[b]);
                        b++;
                    }

                    System.out.println("\nChoose a card to play (1-" + b + ") or draw a card (" + (b+1) + ")\n");
                    input1 = stdin.readLine();

                    try
                    {
                        input2 = Integer.valueOf(input1);
                        if (input2 > 0 && input2 <= b || input2 - 1 == b)
                        {
                            if (input2 > 0 && input2 <= b && input2 - 1 != b)
                            {
                                card = main1[input2 - 1].split(oflimiter);
                                cardjette = jette[0].split(oflimiter);
                                if (card[0].equals(cardjette[0]))
                                {
                                    System.out.println("\nValid move check passed.");
                                    state = 3;
                                }
                                else if (card[2].equals(cardjette[2]))
                                {
                                    System.out.println("\nValid move check passed.");
                                    state = 3;
                                }
                                else
                                {
                                    System.out.println("\nValid move check failed.");
                                    input2 = 0;
                                    i = -1;
                                    b = 0;
                                }
                            }
                            else if (input2 - 1 == b)
                            {
                                System.out.println("\nValid move check passed.");
                                input2 = 0;
                                refaire1 = 1;
                                ajouter1 = 1;
                                b = 0;
                                i = 1;
                            }
                            else
                            {
                                System.out.println("That is not a valid move (not int) or number you entered was not in choices.");
                                input2 = 0;
                                i = -1;
                                b = 0;
                            }
                        }
                    }
                    catch (NumberFormatException nme)
                    {

                    }
                    if (input2 <= 0 && i != -1 && i != 1 || input2 > b + 1 && i != -1 && i != 1)
                    {
                        System.out.println("\nThat is not a valid move (not int) or number you entered was not in choices.");
                        i = -1;
                        b = 0;
                    }
                }
            }
        }
    }
}

"""
Version 0.00

Written in: Python 2.6.5

To do:
- Make a "check if won" method for MauMau.
- Create rules for unique cards, like lose a turn, etc.
- Improve Ai algorithm. For now it consists of simply playing available cards and drawing if none are playable.
   Possible improvements:
     -Change suit when able if hand contains many similar suits.
     -Remember cards that have been played to guess enemy's hand, and not play their enemy's hand's most
      common suit, if the option to not play that specific card is available.
     -Other possible options I may think of when unique card rules are created.
- Switch stack with deck when deck is empty.

Created by: CecilSunkure
URL: http://CecilSunkure.blogspot.com
    http://www.staredit.net/topic/10588/
"""

import sys
import random

ACES_HIGH = True
GAME_RUNNING = True

class card:
   suits = ["Clubs",
            "Diamonds",
            "Hearts",
            "Spades" ]
   ranks = ["Ace",
            "2",
            "3",
            "4",
            "5",
            "6",
            "7",
            "8",
            "9",
            "10",
            "Jack",
            "Queen",
            "King" ]

   def __init__(self, suit=0, rank=0):
       self.suit = suit
       self.rank = rank

   def __str__(self):
       return (self.ranks[self.rank] + " of " + self.suits[self.suit])

class deck:
   def __init__(self):
       self.cards = []
       for suit in range(4):
           for rank in range(12):
               self.cards.append(card(suit, rank))

   def __str__(self):
       s = ''
       for i in range(len(self.cards)):
           s = s + str(self.cards[i]) + '\n'
       return s
           

   def shuffle(self):
       import random
       cards_length = len(self.cards)
       for i in range(cards_length):
           j = random.randrange(i, cards_length)
           self.cards[i], self.cards[j] = self.cards[j], self.cards[i]

   def remove(self, card):
       if card in self.cards:
           self.cards.remove(card)
           return True
       else:
           return False

   def draw(self):
       return self.cards.pop()

   def is_empty(self):
       return (len(self.cards) == 0)

   def deal(self, hands, num_cards=999):
       for i in range(num_cards):
           if self.is_empty():
               break
           card = self.pop()
           hand = hands[i % len(hands)]
           hand.add(card)

   def pop(self):
       return self.cards.pop()


class hand(deck):
   def __init__(self, player=''):
       self.cards = []
       self.player = player

   def add(self, card):
       self.cards.append(card)

   def __str__(self):
       s = self.player + "'s Hand"
       t = 0
       if self.is_empty():
           s = s + " is empty\n"
       else:
           s = s + " contains\n"
       for i in range(len(self.cards)):
           t += 1
           s = s + str(t) + '. ' + str(self.cards[i]) + '\n'
       return s

class MauMau:
   def __init__(self, topCard=0):
       self.deck = deck()
       self.deck.shuffle()
       self.players = []
       self.stack = []
       self.topCard = topCard

   def getName(self):
       print('Welcome to Mau Mau!')
       player = raw_input()
       print('What is your name?')
       player = raw_input()
       print('')
       return player

   def startCard(self):
       self.topCard = self.deck.pop()
       self.stack.append(self.topCard)
       del self.stack[0]

   def cmp_topCard(self, other):
       if self.topCard.suit == other.suit:
           if self.topCard.rank == other.rank:
               return True

   def makeMove(self, move, hand, game):
       a = hand[int(move)-1]
       self.stack.append(a)
       self.topCard = a
       del hand[int(move)-1]

   def is_empty(self):
       return (len(self.stack) == 0)

   def __str__(self):
       s = ''
       t = 0
       if self.is_empty():
           s = s + "Stack is empty\n"
       else:
           s = s + "Stack contains\n"
       for i in range(len(self.stack)):
           t += 1
           s = s + str(t) + '. ' + str(self.stack[i]) + '\n'
       return s

class Ai:
   def __init__(self, hand=0):
       self.memory = []
       self.hand = hand

   def scanMoves(self, game):
       moves = []
       
       for i in range(len(self.hand.cards)):
           #Create a list of playable cards from the current hand.
           if game.topCard.rank == self.hand.cards[i].rank:
               moves.append(i)
               continue
           elif game.topCard.suit == self.hand.cards[i].suit:
               moves.append(i)
               
       try:
           #The random.randrange will fail if the parameters are 0, 0, 0 (if no plays are available).
           move = random.randrange(0, len(moves))
           return moves[move]+1
       except:
           return 'no'

def isValidMove(move, hand, game, handlen):
   """Used to determine if a move by checking to see if the move is an integer, followed by and testing to see
   if the proposed move is within the length of the hand passed to this function. Finally, this function
   makes sure that the proposed card to be played is valid within the rules of the game (same rank)."""
   x = []
   for i in range(1, (handlen+2)):
       x.append(i)
   
   try:
       int(move)
   except:
       print('That is not a valid move (not int).\n')
       return False

   if int(move) not in x:
       print('That is not a valid move (not 1-' + str(handlen+1) + ').\n')
       return False

   if move != str(handlen+1):
       if game.topCard.rank == hand.cards[(int(move)-1)].rank:
           return True
       elif game.topCard.suit == hand.cards[(int(move)-1)].suit:
           return True
       else:
           return False
   elif move == str(handlen+1):
       return True

def main():
   """This function is the main loop used for running the Class MauMau. The turns between Ai and human are
   represented by integers, and those integers are used in if statements to determine which player is currently
   taking their turn."""
   turn = random.randrange(2) + 1
   game = MauMau()
   name = game.getName()
   hand1 = hand(name)
   Ai1 = Ai()
   Ai1.hand = hand("CPU #1")
   game.deck.deal([hand1], 5)
   game.deck.deal([Ai1.hand], 5)
   game.startCard()
   game.players.append(name)
   game.players.append("CPU #1")
   enter = 0 #This variable is used to pause the game until the player hits enter.
   
   if turn == 1:
       print('The computer will go first, as decided at random.\n')
   else:
       print('You will move first, as decided at random.\n')
   
   while GAME_RUNNING:
       #This is the loop that oscillates between the players currently playing, to set which one
       #is currenty playing.
       
       if turn == 1:
           #Ai's turn
           
           print (Ai1.hand.player +' will now take its turn, hit enter to proceed.')
           enter = raw_input()
           Move = Ai1.scanMoves(game)
           try:
               int(Move)
               game.makeMove(Move, Ai1.hand.cards, game)
               print (Ai1.hand.player + ' played a card, hit enter to proceed.')
               enter = raw_input()
           except:
               Ai1.hand.add(game.deck.draw())
               print (Ai1.hand.player + ' has drawn a card, hit enter to proceed.')
               enter = raw_input()
           turn = 0
       else:
           #Player's turn

           print ('It is now ' + str(name) + "'s turn.\n")
           print ('///' + '\n' + '/// ' + str(game.topCard) + '\n' + '///' + '\n')
           print (hand1)
           print ('Choose a card to play (1-' + str(len(hand1.cards)) + ') or draw a card (' + str((len(hand1.cards)+1)) + ').\n')
           Move = raw_input()

           if isValidMove(Move, hand1, game, len(hand1.cards)):
               print('Valid move check passed.\n')

               if Move == str(len(hand1.cards)+1):
                   hand1.add(game.deck.draw())
               else:
                   game.makeMove(Move, hand1.cards, game)
               turn = 1
           else:
               print('Valid move check failed.\n')
           
               
if __name__ == "__main__":
   main()

Welcome to Mau Mau!

What is your name?
Randy

You will move first, as decided at random.

It is now Randy's turn.

///
/// 7 of Hearts
///

Randy's Hand contains
1. 7 of Clubs
2. Ace of Clubs
3. 2 of Spades
4. Ace of Spades
5. 6 of Spades

Choose a card to play (1-5) or draw a card (6).

1
Valid move check passed.

CPU #1 will now take its turn, hit enter to proceed.

CPU #1 played a card, hit enter to proceed.

It is now Randy's turn.

///
/// 10 of Clubs
///

Randy's Hand contains
1. Ace of Clubs
2. 2 of Spades
3. Ace of Spades
4. 6 of Spades

Choose a card to play (1-4) or draw a card (5).

5
Valid move check passed.

CPU #1 will now take its turn, hit enter to proceed.

CPU #1 played a card, hit enter to proceed.

It is now Randy's turn.

///
/// 6 of Clubs
///

Randy's Hand contains
1. Ace of Clubs
2. 2 of Spades
3. Ace of Spades
4. 6 of Spades
5. Queen of Hearts

Choose a card to play (1-5) or draw a card (6).

4
Valid move check passed.

CPU #1 will now take its turn, hit enter to proceed.

CPU #1 played a card, hit enter to proceed.

It is now Randy's turn.

///
/// 4 of Spades
///

Randy's Hand contains
1. Ace of Clubs
2. 2 of Spades
3. Ace of Spades
4. Queen of Hearts

Choose a card to play (1-4) or draw a card (5).

2
Valid move check passed.

CPU #1 will now take its turn, hit enter to proceed.

CPU #1 has drawn a card, hit enter to proceed.

It is now Randy's turn.

///
/// 2 of Spades
///

Randy's Hand contains
1. Ace of Clubs
2. Ace of Spades
3. Queen of Hearts

Choose a card to play (1-3) or draw a card (4).

"""
Version 0.00

Written in Python 2.6.5

Created by: CecilSunkure
URL: http://CecilSunkure.blogspot.com
    http://www.staredit.net/topic/10588/

Rules:
-Playing an Ace makes the next player lose a turn.
-Playing a 7 makes the next player draw a card.
"""

import sys
import random

GAME_RUNNING = True

class card:
   suits = ["Clubs",
            "Diamonds",
            "Hearts",
            "Spades" ]
   ranks = ["Ace",
            "2",
            "3",
            "4",
            "5",
            "6",
            "7",
            "8",
            "9",
            "10",
            "Jack",
            "Queen",
            "King" ]

   def __init__(self, suit=0, rank=0):
       self.suit = suit
       self.rank = rank

   def __str__(self):
       return (self.ranks[self.rank] + " of " + self.suits[self.suit])

class deck:
   def __init__(self):
       self.cards = []
       for suit in range(4):
           for rank in range(12):
               self.cards.append(card(suit, rank))

   def __str__(self):
       s = ''
       for i in range(len(self.cards)):
           s = s + str(self.cards[i]) + '\n'
       return s
           

   def shuffle(self):
       import random
       cards_length = len(self.cards)
       for i in range(cards_length):
           j = random.randrange(i, cards_length)
           self.cards[i], self.cards[j] = self.cards[j], self.cards[i]

   def remove(self, card):
       if card in self.cards:
           self.cards.remove(card)
           return True
       else:
           return False

   def draw(self):
       return self.cards.pop()

   def is_empty(self):
       return (len(self.cards) == 0)

   def deal(self, hands, num_cards=999):
       for i in range(num_cards):
           if self.is_empty():
               break
           card = self.pop()
           hand = hands[i % len(hands)]
           hand.add(card)

   def pop(self):
       return self.cards.pop()


class hand(deck):
   def __init__(self, player=''):
       self.cards = []
       self.player = player

   def add(self, card):
       self.cards.append(card)

   def __str__(self):
       s = self.player + "'s Hand"
       t = 0
       if self.is_empty():
           s = s + " is empty\n"
       else:
           s = s + " contains\n"
       for i in range(len(self.cards)):
           t += 1
           s = s + str(t) + '. ' + str(self.cards[i]) + '\n'
       return s

class MauMau:
   def __init__(self, topCard=0):
       self.deck = deck()
       self.deck.shuffle()
       self.players = []
       self.stack = []
       self.topCard = topCard

   def getName(self):
       print('Welcome to Mau Mau!')
       player = raw_input()
       print('What is your name?')
       player = raw_input()
       print('')
       return player

   def startCard(self):
       self.topCard = self.deck.pop()
       self.stack.append(self.topCard)
       del self.stack[0]

   def cmp_topCard(self, other):
       if self.topCard.suit == other.suit:
           if self.topCard.rank == other.rank:
               return True

   def makeMove(self, move, hand, game):
       """Return values represent card rules.
       1 = Next player skips their turn
       2 = Next player draws a card"""
       
       a = hand[int(move)-1]
       self.stack.append(a)
       self.topCard = a
       del hand[int(move)-1]

       #Check and see if the played card was one with special rules.
       if self.topCard.ranks[self.topCard.rank] == 'Ace':
           return 1
       elif self.topCard.ranks[self.topCard.rank] == '7':
           return 2
       else:
           return 0

   def is_empty(self):
       return (len(self.stack) == 0)

   def __str__(self):
       s = ''
       t = 0
       if self.is_empty():
           s = s + "Stack is empty\n"
       else:
           s = s + "Stack contains\n"
       for i in range(len(self.stack)):
           t += 1
           s = s + str(t) + '. ' + str(self.stack[i]) + '\n'
       return s

   def reuse_Stack(self):
       for i in range(len(self.stack)):
           self.deck.cards.append(self.stack[i])
       self.deck.shuffle()
       self.startCard()

class Ai:
   def __init__(self, hand=0):
       self.memory = []
       self.hand = hand

   def scanMoves(self, game):
       moves = []
       
       for i in range(len(self.hand.cards)):
           #Create a list of playable cards from the current hand.
           if game.topCard.rank == self.hand.cards[i].rank:
               moves.append(i)
               continue
           elif game.topCard.suit == self.hand.cards[i].suit:
               moves.append(i)
               
       try:
           #The random.randrange will fail if the parameters are 0, 0, 0 (if no plays are available).
           move = random.randrange(0, len(moves))
           return moves[move]+1
       except:
           return 'no'

def isValidMove(move, hand, game, handlen):
   """Used to determine if a move by checking to see if the move is an integer, followed by and testing to see
   if the proposed move is within the length of the hand passed to this function. Finally, this function
   makes sure that the proposed card to be played is valid within the rules of the game (same rank)."""
   x = []
   for i in range(1, (handlen+2)):
       x.append(i)
   
   try:
       int(move)
   except:
       print('That is not a valid move (not int).\n')
       return False

   if int(move) not in x:
       print('That is not a valid move (not 1-' + str(handlen+1) + ').\n')
       return False

   if move != str(handlen+1):
       if game.topCard.rank == hand.cards[(int(move)-1)].rank:
           return True
       elif game.topCard.suit == hand.cards[(int(move)-1)].suit:
           return True
       else:
           return False
   elif move == str(handlen+1):
       return True

def main():
   """This function is the main loop used for running the Class MauMau. The turns between Ai and human are
   represented by integers, and those integers are used in if statements to determine which player is currently
   taking their turn."""
   turn = random.randrange(2)
   game = MauMau()
   name = game.getName()
   hand1 = hand(name)
   Ai1 = Ai()
   Ai1.hand = hand("CPU #1")
   game.deck.deal([hand1], 5)
   game.deck.deal([Ai1.hand], 5)
   game.startCard()
   game.players.append(name)
   game.players.append("CPU #1")
   enter = 0 #This variable is used to pause the game until the player hits enter.
   affects = 0
   
   if turn == 1:
       print('The computer will go first, as decided at random.\n')
   else:
       print('You will move first, as decided at random.\n')
   
   while GAME_RUNNING == True:
       #This is the loop that oscillates between the players currently playing, to set which one
       #is currenty playing.

       if game.deck.is_empty():
           #When the deck is empty, set the stack equal to deck and shuffle.
           game.reuse_Stack()
       
       if turn == 1:
           #Ai's turn
           
           print (Ai1.hand.player +' will now take its turn, hit enter to proceed.')
           enter = raw_input()
           Move = Ai1.scanMoves(game)
           try:
               int(Move)
               affects = game.makeMove(Move, Ai1.hand.cards, game)
               print (Ai1.hand.player + ' played a card, hit enter to proceed.')
               enter = raw_input()
           except:
               Ai1.hand.add(game.deck.draw())
               print (Ai1.hand.player + ' has drawn a card, hit enter to proceed.')
               enter = raw_input()

           if Ai1.hand.is_empty():
               print(Ai1.hand.player + ' has emptied their hand and won! Hit enter to exit.')
               enter = raw_input()
               sys.exit()

           if affects == 1:
               print(Ai1.hand.player + ' has made the next player skip a turn! Hit enter to continue.')
               turn = 1
               enter = raw_input()
           if affects == 0:
               turn = 0
           if affects == 2:
               turn = 1
               hand1.add(game.deck.draw())
               print(Ai1.hand.player + ' has made the next player draw a card by playing a seven! Hit enter to continue.\n')
               enter = raw_input()

           affects = 0
       if turn == 0:
           #Player's turn

           print ('It is now ' + str(name) + "'s turn.\n")
           print ('///' + '\n' + '/// ' + str(game.topCard) + '\n' + '///' + '\n')
           print (hand1)
           print ('Choose a card to play (1-' + str(len(hand1.cards)) + ') or draw a card (' + str((len(hand1.cards)+1)) + ').\n')
           Move = raw_input()

           if isValidMove(Move, hand1, game, len(hand1.cards)):
               print('Valid move check passed.\n')

               if Move == str(len(hand1.cards)+1):
                   hand1.add(game.deck.draw())
               else:
                   affects = game.makeMove(Move, hand1.cards, game)

               if hand1.is_empty():
                   print(hand1.player + ' has emptied their hand and won! Hit enter to exit.')
                   enter = raw_input()
                   sys.exit()

               if affects == 1:
                   print(hand1.player + ' has made the next player skip a turn! Hit enter to continue.')
                   turn = 0
                   enter = raw_input()
               if affects == 0:
                   turn = 1
               if affects == 2:
                   turn = 0
                   Ai1.hand.add(game.deck.draw())
                   print(Ai1.hand.player + ' has made the next player draw a card by playing a seven! Hit enter to continue.\n')
                   enter = raw_input()

               affects = 0
           else:
               print('Valid move check failed.\n')
           
               
if __name__ == "__main__":
   main()