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

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 == 14:
            return 15
        elif self._rank >= 10:
            return 10
        else:
            return 5

# 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())
    
    # 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 rummyValue(self):
        "Returns the value of the card in Rummy"
        if self.getRank() <= 9:
            return 5
        elif self.getRank() < 14:
            return 10
        else:
            return 15

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

# Card class and demonstration of use
# by CSCI111

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)
    
    # 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 __str__(self):
        """Returns a string representing the cards that are
        in the deck."""
        
        deckRep= ""
        for c in self.listOfCards:
            deckRep += str(c) + "\n"
        return deckRep

    def numRemaining(self):
        """Returns the number of cards left in the deck."""
        return len(self.listOfCards)
        
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()