OldMaid

# Dal capitolo 15 di Pensare da Informatico.

class Carta:
    ListaSemi = ["Fiori", "Quadri", "Cuori", "Picche"]
    ListaRanghi = ["impossibile", "Asso", "2", "3", "4", "5", "6",\
                    "7", "8", "9", "10", "Jack", "Regina", "Re"]
    def __init__(self, Seme=0, Rango=0):
        self.Seme = Seme
        self.Rango = Rango
    def __cmp__(self, Altro):
        # controlla il seme
        if self.Seme > Altro.Seme: return 1
        if self.Seme < Altro.Seme: return -1
        # se i semi sono uguali controlla il rango
        if self.Rango > Altro.Rango: return 1
        if self.Rango < Altro.Rango: return -1
        # se anche i ranghi sono uguali le carte sono uguali!
        return 0
    def __str__(self):
        return (self.ListaRanghi[self.Rango] + " di " +
               self.ListaSemi[self.Seme])
#Ora l'oggetto carta e' creato.

# Ora il Mazzo.

class Mazzo:
    def __init__(self):
        self.Carte = []
        for Seme in range(4):
            for Rango in range (1,14):
                self.Carte.append(Carta(Seme, Rango))
    def __str__(self):
        s = ""
        for i in range(len(self.Carte)):
            s = s + " "*i + str(self.Carte[i]) + "\n"
        return s
    def Mescola(self):
        import random
        NumCarte = len(self.Carte)
        for i in range(NumCarte):
            j = random.randrange(i,NumCarte)
            self.Carte[i], self.Carte[j] = self.Carte[j], self.Carte[i]
    def RimuoviCarta(self, Carta):
        if Carta in self.Carte:
            self.Carte.remove(Carta)
            return 1
        else:
            return 0
    def PrimaCarta(self):
        return self.Carte.pop()
    def EVuoto(self):
        return (len(self.Carte) == 0)
    def Distribuisci(self, ListaMani, NumCarte=999):
        NumMani=len(ListaMani)
        for i in range(NumCarte):
            if self.EVuoto:
                break
            Carta = self.PrimaCarta()
            Mano = ListaMani(i % NumMani)
            Mano.AggiungiCarta(Carta)

class Mano(Mazzo):
    def __init__(self, Nome=""):
        self.Carte = []
        self.Nome = Nome
    def AggiungiCarta(self, Carta):
        self.Carte.append(Carta)
    def __str__(self):
        s = "La mano di "+self.Nome
        if self.EVuoto():
            s += " E' vuota\n"
        else:
            s += " Contiene queste carte:\n"
            return s + Mazzo.__str__(self)
class GiocoDiCarte:
    def __init__(self):
        self.Mazzo = Mazzo()
        self.Mazzo.Mescola()
class ManoOldMaid(Mano):
    def RimuoviCoppie(self):
        Conteggio = 0
        CarteOriginali = self.Carte[:]
        for CartaOrig in CarteOriginali:
            CartaDaCercare = (3-CartaOrig.Seme, CartaOrig.Rango)
            if CartaDaCercare in self.Carte:
                self.Carte.remove(CartaOrig)
                self.Carte.remove(CartaDaCercare)
                print "Mano di %s : %s elimina %s" %\
                self.Nome, CartaOrig, CartaDaCercare
                Conteggio += 1
                return Conteggio
class GiocoOldMaid(GiocoDiCarte):
    def Partita(self, Nomi):
        # Tolgo la donna di fiori
        self.Mazzo.RimuoviCarta(Carta(0,12))
        # Creazione di una mano per ogni giocatore
        self.Mani = []
        for Nome in Nomi:
            self.Mani.append(ManoOldMaid(Nome))
            # Distribuzione mani
            self.Mazzo.Distribuisci(self.Mani)
            print " ---------- Le carte sono state distribuite."
            #self.StampaMani()
            print self.Mani
            # Toglie le coppie iniziali.
            NumCoppie = self.RimuoviTutteLeCoppie()
            print " --- Coppie scartate. Inizia la partita.\n"
            #self.StampaMani()
            print self.Mani
            # Gioca finche' non sono state fatte 25 coppie
            Turno = 0
            NumMani = len(self.Mani())
            while NumCoppie < 25:
                NumCoppie += self.GiocaUnTurno(Turno)
                Turno = (Turno + 1) % NumMani
            print "----------La partita e' finita! \n"
            #self.StampaMani()
            print self.Mani
    def RimuoviTutteLeCoppie(self):
        Conteggio = 0
        for Mano in self.Mani:
            Conteggio += Mano.RimuoviCoppie()
            return Conteggio
    def GiocaUnTurno(self, Giocatore):
        if self.Mani[Giocatore].EVuoto():
            return 0
        Vicino = self.TrovaVicino(Giocatore)
        CartaScelta = self.Mani[Vicino].PrimaCarta()
        self.Mani[Giocatore].AggiungiCarta(CartaScelta)
        print "Mano di ",self.Mani[Giocatore].Nome,\
        ": scelta", CartaScelta
        Conteggio = self.Mani[Giocatore].RimuoveCoppie()
        self.Mani[Giocatore].Mescola()
        return Conteggio
    def TrovaVicino(self, Giocatore):
        NumMani=len(self.Mani)
        for Prossimo in range(1, NumMani):
            Vicino = (Prossimo + Giocatore) % NumMani
            if not self.Mani[Vicino].EVuoto():
                return Vicino
# Codice che gestisce il gioco.
Gioco = GiocoOldMaid()
Quanti = input("Quanti giocatori?")
if Quanti > 8: Quanti = 8
if Quanti < 2: Quanti = 2
ListaG = []
for i in range(Quanti):
    print "Giocatore: ", i+1,
    ListaG.append(raw_input("nome: "))
Gioco.Partita(ListaG)