1. ./card2.py
2. ./card_byid.py
3. ./card.py
4. ./test.py
5. ./war.py

# Card class and demonstration of use
# by CSCI111

import test

class Card:
    """
    A class to represent a standard playing card. The ranks are ints:
    2-10 for numbered cards, 11=Jack, 12=Queen, 13=King, 14=Ace.
    The suits are strings: 'clubs', 'spades', 'hearts', 'diamonds'.
    """
    
    def __init__(self, rank, suit):
        "Constructs a new Card object with the given rank (an int) and suit (a string)."
        self._rank = rank
        self._suit = suit
        
    def __str__(self):
        "Returns a string describing the card as 'rank of suit'."
        result = ""
        if self._rank == 11:
            result += "Jack"
        elif self._rank == 12:
            result += "Queen"
        elif self._rank == 13:
            result += "King"
        elif self._rank == 14:
            result += "Ace"
        else:
            result += str(self._rank)
        result += " of " + self._suit
        return result
        
    def getRank(self):
        "Returns this card's rank."	
        return self._rank

    def getSuit(self):
        "Returns this card's suit."
        return self._suit
        
    def getCardColor(self):
        """
        Returns the color of the card's suit.  
        This will be "red" for hearts and diamonds and
        "black" for spades and clubs
        """
        if self._suit == "diamonds":
            result = "red"
            #return "red"
        elif self._suit == "hearts":
            result = "red"
        else:
            result = "black"
        return result
        
        
    def getRummyValue(self):
        """
        Returns the value of the card in a game 
        of Rummy.  (Apparently, Sprenkle modified rules)
        """
        if self._rank == 14:
            return 15
        elif self._rank < 11:
            return 5
        else:
            return 10
   
def testCardClass():
    """
    Exercises many methods of the Card class.  
    Note that this test function was built up over time, testing one method
    at a time and then adding tests for the next method, repeat.
    """
    
    c1 = Card(14, "spades")
    c2 = Card(13, "hearts")
    c3 = Card(2, "diamonds")
    
    # test the getSuit() method and constructor
    test.testEqual(c1.getSuit(), "spades")
    test.testEqual(c2.getSuit(), "hearts")
    test.testEqual(c3.getSuit(), "diamonds")
        
    # test the getRank() method and constructor
    test.testEqual(c1.getRank(), 14)
    test.testEqual(c2.getRank(), 13)
    test.testEqual(c3.getRank(), 2)
    
    # test the __str__ method
    test.testEqual( str(c1), "Ace of spades")
    test.testEqual( str(c2), "King of hearts")
    test.testEqual( str(c3), "2 of diamonds")
    
    # test the getCardColor method
    test.testEqual( c1.getCardColor(), "black")
    test.testEqual( c2.getCardColor(), "red")
    
    # We can test a method with a bunch of objects all at once.
    # You set up your objects and expected results in a list.  
    # It's easy to add new test cases to the list. 
    myCards = [c1, c2, c3]
    expectedSuitResults = ["spades", "hearts", "diamonds"]
    
    for index in range(len(myCards)):
        test.testEqual( myCards[index].getSuit(), expectedSuitResults[index])
        
    expectedRankResults = [14, 13, 2]
    expectedStrResults = ["Ace of spades", "King of hearts", "2 of diamonds"]
    expectedColorResults = ["black", "red", "red"]
    # should add a test for clubs 
   
    # tests a bunch of methods at once
    for index in range(len(myCards)):
        test.testEqual( myCards[index].getSuit(), expectedSuitResults[index])
        test.testEqual( myCards[index].getRank(), expectedRankResults[index])
        test.testEqual( str(myCards[index]), expectedStrResults[index])
        test.testEqual( myCards[index].getCardColor(), expectedColorResults[index])



def main():
    # exercise the class
    c1 = Card(14, "spades")
    # display the card to see how the __str__ method output looks
    print("Card 1:", c1)
    c2 = Card(13, "hearts")
    print("Card 2:", c2)
    c3 = Card(2, "diamonds")
    print("Card 3:", c3)
    print("Card 3's suit:", c3.getSuit())
    print("Card 3's rank:", c3.getRank())
    
    # showing other ways to call the str method 
    myString = c3.__str__()
    myString2 = str(c3)
    
    print(myString)
    print(myString2)
    
    # exercise the getCardColor method
    cardColor = c1.getCardColor()
    print("Card 1's card color:", cardColor)
    
    myHand = [ c1, c2, c3 ]
    
    print()
    print("My Hand:")
    # Problem: determine the rummy value of this hand
    rummyValue = 0
    for card in myHand:
        print(card)
        rummyValue += card.getRummyValue()
    
    print("My hand's value in Rummy is", rummyValue)
    
    
# Since I am probably going to import this class into another script,
# I only want to call main() when it's *not* imported
if __name__ == '__main__':
    main()
    testCardClass()

# Demonstrates abstraction: has same interface as card.py
# but different implementation, e.g., defining state using an id.

class Card:
    """
    A class to represent a standard playing card. The ranks are ints:
    2-10 for numbered cards, 11=Jack, 12=Queen, 13=King, 14=Ace.
    The suits are strings: 'clubs', 'spades', 'hearts', 'diamonds'.
    """
        
    def __init__(self, rank, suit):
        "Constructor for class Card takes int rank and string suit."
        # card ids go from 2 to 55
        self._cardid = rank
        if suit == "clubs":
            self._cardid += 13
        elif suit == "hearts":
            self._cardid += 26
        elif suit == "diamonds":
            self._cardid += 39

    def __str__(self):
        "Returns a string describing the card as 'rank of suit'."
        result = ""
        rank = self.getRank()
        if rank == 11:
            result += "Jack"
        elif rank == 12:
            result += "Queen"
        elif rank == 13:
            result += "King"
        elif rank == 14:
            result += "Ace"
        else:
            result += str(rank)
        result += " of " + self.getSuit()
        return result

    def getRank(self):
        "Returns rank."
        return (self._cardid-2) % 13 + 2

    def getSuit(self):
        "Returns suit."
        suits = ["spades", "clubs", "hearts", "diamonds"]
        whichsuit = (self._cardid-2)//13
        return suits[whichsuit]

    def blackJackValue(self):
        "Returns the value of the card in Black Jack"
        if self.getRank() == 14:
            # alternatively, this could be 11
            return 1
        elif self.getRank() > 10:
            return 10
        else:
            return self.getRank()

    def getRummyValue(self):
        "Returns the value of the card in Rummy"
        

def main():
    c1 = Card(14, "spades")
    print( c1 )
    print( c1.getRank() )
    #print( "Black Jack Value", c1.blackJackValue())
    print( "Rummy Value", c1.getRummyValue())
    c2 = Card(13, "hearts")
    print(c2)
    print(c2.getRank())
    print("Black Jack Value", c2.blackJackValue())
    #print("Rummy Value", c2.getRummyValue())
    
if __name__ == '__main__':
    main()

# Card class and demonstration of use
# by CSCI111

import test

class Card:
    """
    A class to represent a standard playing card. The ranks are ints:
    2-10 for numbered cards, 11=Jack, 12=Queen, 13=King, 14=Ace.
    The suits are strings: 'clubs', 'spades', 'hearts', 'diamonds'.
    """
    
    def __init__(self, rank, suit):
        "Constructs a new Card object with the given rank (an int) and suit (a string)."
        self._rank = rank
        self._suit = suit
        
    def __str__(self):
        "Returns a string describing the card as 'rank of suit'."
        result = ""
        if self._rank == 11:
            result += "Jack"
        elif self._rank == 12:
            result += "Queen"
        elif self._rank == 13:
            result += "King"
        elif self._rank == 14:
            result += "Ace"
        else:
            result += str(self._rank)
        result += " of " + self._suit
        return result
        
    def getRank(self):
        "Returns this card's rank."	
        return self._rank

    def getSuit(self):
        "Returns this card's suit."
        return self._suit
        
def testCardClass():
    """
    Exercises many methods of the Card class.  
    Note that this test function was built up over time, testing one method
    at a time and then adding tests for the next method, repeat.
    """
    
    c1 = Card(14, "spades")
    c2 = Card(13, "hearts")
    c3 = Card(2, "diamonds")
    
    # test the getSuit() method and constructor
    test.testEqual(c1.getSuit(), "spades")
    test.testEqual(c2.getSuit(), "hearts")
    test.testEqual(c3.getSuit(), "diamonds")
        
    # test the getRank() method and constructor
    test.testEqual(c1.getRank(), 14)
    test.testEqual(c2.getRank(), 13)
    test.testEqual(c3.getRank(), 2)
    
    # test the __str__ method
    test.testEqual( str(c1), "Ace of spades")
    test.testEqual( str(c2), "King of hearts")
    test.testEqual( str(c3), "2 of diamonds")
    
    
    # We can test a method with a bunch of objects all at once.
    # You set up your objects and expected results in a list.  
    # It's easy to add new test cases to the list. 
    myCards = [c1, c2, c3]
    expectedSuitResults = ["spades", "hearts", "diamonds"]
    
    for index in range(len(myCards)):
        test.testEqual( myCards[index].getSuit(), expectedSuitResults[index])
        
    expectedRankResults = [14, 13, 2]
    expectedStrResults = ["Ace of spades", "King of hearts", "2 of diamonds"]

    # tests a bunch of methods at once
    for index in range(len(myCards)):
        test.testEqual( myCards[index].getSuit(), expectedSuitResults[index])
        test.testEqual( myCards[index].getRank(), expectedRankResults[index])
        test.testEqual( str(myCards[index]), expectedStrResults[index])

    
        
def main():
    
    # exercise the class
    c1 = Card(14, "spades")
    # display the card to see how the __str__ method output looks
    print("Card 1:", c1)
    c2 = Card(13, "hearts")
    print("Card 2:", c2)
    c3 = Card(2, "diamonds")
    print("Card 3:", c3)
    print("Card 3's suit:", c3.getSuit())
    print("Card 3's rank:", c3.getRank())
    
    print(c3)
    
    # showing other ways to call the str method 
    myString = c3.__str__()
    myString2 = str(c3)
    
    print(myString)
    print(myString2)
    
    
# Since I am probably going to import this class into another script,
# I only want to call main() when it's *not* imported
if __name__ == '__main__':
    main()
    testCardClass() # once testing is complete, we can remove this call

# From How to Think Like a Computer Scientist textbook

def testEqual(actual,expected,places=5):
    '''
    Does the actual value equal the expected value?
    For floats, places indicates how many places, right of the decimal, must be correct
    '''
    if isinstance(expected,float):
        if abs(actual-expected) < 10**(-places):
            print('\tPass')
            return True
    else:
        if actual == expected:
            print('\tPass')
            return True
    print('\tTest Failed: expected {} but got {}'.format(expected,actual))
    return False

# Simple implementation of the game of War
# There are some issues in simulation's accuracy.
# Pedagogical goal: practice calling object's methods to solve a problem.
# Sara Sprenkle

from card import *
from random import *

def main():
    player1Card = genRandomCard()
    player2Card = genRandomCard()

    print("Player 1 draws a", player1Card)
    print("Player 2 draws a", player2Card)
    print()
    print(" --> ", end="")
    
    # determine who wins this round of War
    

def genRandomCard():
    """ Returns a randomly generated Card object.
    Assumes an infinite number of decks of cards available."""
    
    suits = ["hearts", "diamonds", "clubs", "spades"]
    
    randRank = randint(2, 14) # generate a random rank
    randSuit = suits[randint(0, 3)]  # generate a random suit
    
    # create a new Card object from randomly generated rank and suit
    randomCard = Card( randRank, randSuit )
    
    return randomCard
    
main()