↑

Laboration 6

Introduktion

I denna laboration är er uppgift att utgå från ett färdigt klassdiagram och med detta skapa ett Blackjack-spel. Information som finns i klassdiagramet är bland annat:

Syftet med laborationen är att ni ska få förståelse för hur ni kan använda er av UML (klassdiagram i detta fallet) för att underlätta utvecklandet av mjukvara. Ni ska här skapa spelet blackjack, tänk även på hur ni själva möjligen valt att modellera upp detta spelet själva - jämfört med att bli tilldelade ett färdigt klassdiagram. Förhoppningsvis visar detta fördelarna med att separera modellering och programmering, vilket även öppnar upp nya dörrar vad gäller samarbete mellan olika yrkesområden.

Uppgift

Som tidigare nämnt är er uppgift att implementera spelet Blackjack, nedan visas det klassdiagram ni kan utgå ifrån:

Klassdiagram över Blackjack Klassdiagram över Blackjack.

I ovanstående klassdiagram består vår version av spelat av 7st klasser, som alla hänger ihop på ett eller annat sätt. Börja med att skapa stubbar i Python, baserat på klasserna och respektive metoder. Försök att bilda er en uppfattning för hur allting sedan hänger ihop innan ni börjar implementera någonting. Glöm inte att dokumentera er kod. För att ni ska få en flygande start får ni hela klassen “Card” presenterad nedan - så har ni en utgångspunkt i alla fall!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

class Card():
    """A card, belongs to a Deck or a Hand

    Args:
        card_number (int) : Index of a card (0 - 51)

    Example:
        # Generate a full deck of cards:
        deck = []
        for i in range(52):
            deck.append(Card(i))

        # Shuffle the cards (don't forget to include the random module):
        random.shuffle(deck)
    """

    def __init__(self, card_number):
        """Creates a card with folloing attributes

        Attributes:
            + color (str) : The color of the card
            + number (str) : The number of a card (2-10, knight, queen, king, ace)
            + value (int) : The value of a card (2-11)

        Args:
            card_number (int) : Index of a card (0 - 51)
        """
        self.color = self.set_color(card_number)
        self.number = self.set_number(card_number)
        self.value = self.set_value(card_number)

    def set_color(self, card_number):
        """Sets the color of a card

        Args:
            card_number (int) : The index of the card (0-51)

        Returns:
            str : The color of the card
        """
        if card_number < 13:
            return "Hjärter"
        elif card_number < 26:
            return "Ruter"
        elif card_number < 39:
            return "Spader"
        else:
            return "Klöver"

    def get_color(self):
        """Gets the color of a card

        Returns:
            str : The color of the card
        """
        return self.color

    def set_number(self, card_number):
        """Sets the number of a card

        Args:
            card_number (int) : The index of the card (0-51)

        Returns:
            str : The number of the card
        """
        card_value = card_number % 13

        if card_value < 9:
            return  str(card_value + 2)
        elif card_value == 9:
            return "Knekt"
        elif card_value == 10:
            return "Dam"
        elif card_value == 11:
            return "Kung"
        else:
            return "Ess"

    def get_number(self):
        """Gets the number of a card

        Returns:
            str : The number of the card
        """
        return self.number

    def set_value(self, card_number):
        """Sets the value of a card

        Args:
            card_number (int) : The index of the card (0-51)

        Returns:
            int : The value of the card
        """
        card_value = card_number % 13

        if card_value < 9:
            return card_value + 2
        elif card_value == 12:
            return 11
        else:
            return 10

    def get_value(self, soft):
        """Gets the value of a card

        Args:
            card_number (int) : The index of the card (0-51)
            soft (bool) : If the hand (holder of the n cards) is soft, aces gets the value of 1

        Returns:
            int : The value of the card
        """
        if self.value != 11:
            return self.value
        else:
            if soft:
                return 1
            else:
                return 11

    def __str__(self):
        """Generates a readable presentation of the card

        Returns:
            str : The readable string, including the cards color and number
        """
        return "{} {}".format(self.color, self.number)

Nu är det upp till er att fortsätta översätta klassdiagramet till körbar kod - alltså att slutföra programmet så att ni kan möta datorn i Blackjack, och förhoppningsvis vinna!

Lycka till!

Exempelkörningar

Exempel 1 Exempelkörning 1.

Exempel 2 Exempelkörning 2.

Exempellösning

Exempellölsning till labben hittar ni här