1. card2.py
2. card_byid.py
3. card.py
4. deck.py
5. war.py

# Card class and demonstration of use.
# This version of the code includes the getRummyValue method
# 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 rank."	
        return self._rank

    def getSuit(self):
        "Returns suit."
        return self._suit
        
    def getRummyValue(self):
        "Return the rummy value for the card."
        if self._rank < 10:
            return 5
        elif self._rank < 14:
            return 10
        else:
            return 15
            
    def getCardColor(self):
        "Return the color of the card, either the string 'red' or 'black'"
        if self._suit == "diamonds" or self._suit == "hearts":
            return "red"
        else:
            return "black"
        

# These are functions, not part of the class, because they are
# not indented under the class.

def testRummyValue():
    "Function to verify that Card's getRummyValue() method works correctly."
    
    # create the expected results for cards with ranks 2-14, inclusive
    expectedResults = [5]*9 + [10] * 4 + [15]
    for suit in ["hearts", "diamonds", "clubs", "spades"]:
        for x in range(2, 15):
            c = Card(x, suit)
            expected = expectedResults[x-1] # the indices are a bit off
            actual = c.getRummyValue()
            if expected != actual:
                print("ERROR! Expected", c, "'s Rummy value to be", expected)
                print("\t but was", actual)

def main():
    c1 = Card(14, "spades")
    print(c1)
    c2 = Card(13, "hearts")
    print(c2)
    c3 = Card(2, "diamonds")
    print(c3)
    
    print(c1, "'s rummy value is", c1.getRummyValue())
    print(c2, "'s rummy value is", c2.getRummyValue())
    print(c3, "'s rummy value is", c3.getRummyValue())
    
    test.testEqual( c1.getSuit(), "spades")
    test.testEqual( c2.getSuit(), "hearts")
    
    test.testEqual( c1.getRank(), 14)
    test.testEqual( c3.getRank(), 2)
    
    test.testEqual( str(c1), "Ace of spades")
    test.testEqual( str(c2), "King of hearts")
    test.testEqual( str(c3), "2 of diamonds")
    
    # test get rummy value
    test.testEqual( c1.getRummyValue(), 15 )
    test.testEqual( c2.getRummyValue(), 10 )
    test.testEqual( c3.getRummyValue(), 5 )
    
    # test the card color
    test.testEqual( c1.getCardColor(), "black" )
    test.testEqual( c2.getCardColor(), "red" )
    test.testEqual( c3.getCardColor(), "red" )
    
    # created code to automatically check the rummy code
    testRummyValue()
    
    #myString = c3.__str__()
    #myString2 = str(c3)
    
    #print(myString)
    #print(myString2)
    
# Since I am probably going to import this script into another script,
# I only want to call main() when it's *not* imported
if __name__ == '__main__':
    main()

# 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 rank."	
        return self._rank

    def getSuit(self):
        "Returns suit."
        return self._suit
        

def main():
    c1 = Card(14, "spades")
    print(c1)
    c2 = Card(13, "hearts")
    print(c2)
    c3 = Card(2, "diamonds")
    print(c3)
    
    test.testEqual( c1.getSuit(), "spades")
    test.testEqual( c2.getSuit(), "hearts")
    
    test.testEqual( c1.getRank(), 14)
    test.testEqual( c3.getRank(), 2)
    
    test.testEqual( str(c1), "Ace of spades")
    test.testEqual( str(c2), "King of hearts")
    test.testEqual( str(c3), "2 of diamonds")
    
    # 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 script into another script,
# I only want to call main() when it's *not* imported
if __name__ == '__main__':
    main()

# Implementation of a deck of cards.
# by CSCI 111

from card import *

class Deck:
    """ A class to represent a deck of playing cards."""
    
    def __init__(self):
        """Creates a new Deck object, filled with one of each
        unique card."""
        
        self.listOfCards = []
        for suit in ["clubs","hearts","diamonds","spades"]:
            for rank in range(2,15):
                self.listOfCards.append(Card(rank, suit))

  
        
def main():
    d = Deck()
    print(d)
    print("The number of cards remaining in the deck is", d.numRemaining())
    
# Since I am probably going to import this script into another script,
# I only want to call main() when it's *not* imported
if __name__ == "__main__":
    main()

# Simple implementation of the game of War
# There are some issues in simulation's accuracy.
# 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="")
    
    
    

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()