Das deutsche Python-Forum

Code: Alles auswählen

#!/usr/bin/env python
# coding: utf8
from random import shuffle


class Deck(object):
    def __init__(self, cards=()):
        self.cards = list(cards)

    def __len__(self):
        return len(self.cards)

    def __getitem__(self, index):
        return self.cards[index]

    def __delitem__(self, index):
        del self.cards[index]

    def add_many(self, cards):
        self.cards.extend(cards)

    def shuffle(self):
        shuffle(self.cards)

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

    def deal_cards(self, players):
        count = len(self) // len(players)
        if not count:
            raise ValueError('more players than cards')
        for player in players:
            player.add_many(self[-count:])
            del self[-count:]


class Card(object):
    
    RANK_NAMES = map(str, xrange(1, 11)) + ['Jack', 'Queen', 'King', 'Ace']
    SUITE_NAMES = ['diamonds', 'hearts', 'spades', 'clubs']

    def __init__(self, rank, suite):
        if not (
            0 <= rank < len(self.RANK_NAMES)
            and 0 <= suite < len(self.SUITE_NAMES)
        ):
            raise ValueError('suite or rank out of bounds')
        self.rank = rank
        self.suite = suite

    def __str__(self):
        return '{0} of {1}'.format(
            self.RANK_NAMES[self.rank], self.SUITE_NAMES[self.suite]
        )

    def __cmp__(self, other):
        return cmp(self.rank, other.rank)

    def __hash__(self):
        raise TypeError('unhashable type: {0}'.format(type(self)))

    @classmethod
    def create_deck(cls):
        return Deck(
            cls(r, s)
            for r in xrange(len(cls.RANK_NAMES))
            for s in xrange(len(cls.SUITE_NAMES))
        )


class Player(object):
    def __init__(self, name):
        self.name = name
        self.hand = Deck()
        self.received = Deck()

    def __str__(self):
        return '{0} ({1} cards)'.format(self.name, len(self))

    def __len__(self):
        return len(self.hand) + len(self.received)

    def has_cards(self):
        return bool(self)

    def add_many(self, cards):
        self.received.add_many(cards)

    def get_card(self):
        if not self.hand:
            self.received.shuffle()
            self.hand, self.received = self.received, Deck()
        return self.hand.draw_card()


def main():
    players = map(Player, ['Mary', 'Paul'])

    deck = Card.create_deck()
    deck.shuffle()
    deck.deal_cards(players)

    cards_on_table = list()
    while len(players) > 1:
        print
        ranking = sorted(
            ((player.get_card(), player) for player in players), reverse=True
        )
        for card, player in ranking:
            print '{0} is playing {1}.'.format(player, card)
        cards_on_table.extend(card for card, _ in ranking)
        best_card, best_player = ranking[0]
        second_best_card, _ = ranking[1]
        if best_card != second_best_card:
            print '{0} is winning.'.format(best_player)
            best_player.add_many(cards_on_table)
            cards_on_table = list()
        else:
            print 'No one is winning.'
        players = [player for player in players if player.has_cards()]

    print '-' * 30
    print 'Winner:', players[0]


if __name__ == '__main__':
    main()

Code: Alles auswählen

def Spielfeld():
            
        spielfeld = []
        karteSpieler1 = spieler1.aktuellerKartenWert()
        karteSpieler2 = spieler2.aktuellerKartenWert()

        if karteSpieler1 > karteSpieler2:
            spieler1.gewinneKarte(spieler2.verliereKarte())
        elif karteSpieler1 < karteSpieler2:
            spieler2.gewinneKarte(spieler1.verliereKarte())
        else:
            spielfeld.append(spieler1.verliereKarte())
            spielfeld.append(spieler2.verliereKarte())

        
        if len(spieler1.hand) == 0:
            try:
                spieler1.hand.extend(spieler1.nachziehstapel)
                random.shuffle(spieler1.hand)
                del spieler1.nachziehstapel[0:-1]
            except:
                print("Keine Karten mehr - ",spieler2," gewinnt")

        if len(spieler2.hand) == 0:
            try:
                spieler2.hand.extend(spieler2.nachziehstapel)
                random.shuffle(spieler2.hand)
                del spieler2.nachziehstapel[0:-1]
            except:
                print("Keine Karten mehr - ",spieler1," gewinnt")

Code: Alles auswählen

while len(spieler1.hand) != 0 or len(spieler2.hand) != 0:

Code: Alles auswählen

Eichel-7  gegen  Eichel-7
Eichel-7  gegen  Eichel-7
Schellen-Ober  gegen  Eichel-7
Schellen-Ober von Heinz  gewinnt

Schellen-10  gegen  Eichel-7
Schellen-10 von Heinz  gewinnt

Eichel-7  gegen  Eichel-7
Eichel-7  gegen  Eichel-7
Eichel-7  gegen  Eichel-7
Eichel-7  gegen  Eichel-7
Blatt-Unter  gegen  Eichel-7
Blatt-Unter von Heinz  gewinnt

Eichel-7  gegen  Eichel-7
Eichel-7  gegen  Eichel-7
Eichel-7  gegen  Eichel-7
Schellen-9  gegen  Eichel-7
Schellen-9 von Heinz  gewinnt

Code: Alles auswählen

 karteSpieler1 = spieler1.aktuellerKartenWert()
 karteSpieler2 = spieler2.aktuellerKartenWert()

Code: Alles auswählen

In [19]: xs = range(10)

In [20]: del xs[0:-1]

In [21]: xs
Out[21]: [9]

Code: Alles auswählen

        if len(spieler1.hand) == 0:
            spieler1.hand = spieler1.nachziehstapel
            random.shuffle(spieler1.hand)
            spieler1.nachziehstapel = list()

Code: Alles auswählen

def make_move(cards_on_table, player_a, player_b):
    card_a = player_a.get_card()
    card_b = player_b.get_card()
    cards_on_table.extend([card_a, card_b])
    if card_a > card_b:
        winner = player_a
    elif card_a < card_b:
        winner = player_b
    else:
        winner = None
    if winner is not None:
        winner.add_many(cards_on_table)
        cards_on_table = list()
    return cards_on_table