ue05

.gitignore

@@ -5,6 +5,7 @@ __pycache__
 /EPR/ue02/7987847_epr-blatt02.zip
 /EPR/ue03/7987847_epr-blatt03.zip
 /EPR/ue04/7987847_epr-blatt04.zip
+/EPR/ue05/7987847_epr-blatt05.zip
 
 /GPR/ue03/gpr_blatt03_7987847_werner.zip
 /GPR/ue05/7987847_gpr-blatt05.zip

EPR/ue05/README.md.txt

@@ -0,0 +1,40 @@
+author: 7987847, Werner
+
+
+Zur Nutzung muss eine kompatible Python version installiert sein.
+Akzeptiert werden alle Python 3.x Versionen.
+
+Das Programm kann mit dem Befehl `python3 main.py` im Ordner gestartet werden.
+
+Das Programm ist ein Kartenspiel für 3-4 Spieler. Es werden 12 Karten (1-4 in Kreuz, herz, Karo) verwendet
+
+## Regeln wie auf dem Übungsblatt beschrieben:
+
+Gespielt wird mit 3 – 4 Spielern.
+Vorbereitung
+Es gibt drei verschiedene Farben (Karo, Herz, und Kreuz). Die jeweils höchste Karte einer Farbe ist die 4, die
+niedrigste eine 1. Zu Beginn des Spiels werden alle Karten vollständig an die Spieler verteilt.
+Ziel des Spiels und Spielablauf
+Spieler probieren Stiche zu vermeiden in denen Karten der Farbe ‚Kreuz‘ auftauchen. Jede Karte mit einem
+Kreuz gibt einen Strafpunkt. Am Ende des Spiels, d.h. nachdem alle Karten gespielt wurden, werden die
+EPR WiSe 2023/2024 2
+Strafpunkte notiert. Der Spieler mit den wenigsten Strafpunkten gewinnt. Es können auch mehrere Spieler
+gewinnen.
+Stiche
+Jeder Spieler spielt reihum genau eine Karte aus der Hand aus. Diese Karten bilden den Stich. In einem Spiel
+werden so viele Stiche gespielt, wie Spieler Handkarten besitzen. Der beginnende Spieler kann jede Karte aus
+der Hand abspielen. Die Farbe der ersten ausgespielten Karte in einem Stich ist Trumpf und muss ‚bedient‘
+werden. Das heißt, hat ein Spieler die Farbe der erstgelegten Karte auf der Hand, muss er diese spielen. Kann
+ein Spieler die Trumpffarbe nicht spielen, darf dieser Spieler eine andere Farbe spielen. Am Anfang jedes Stichs
+wird die Trumpffarbe neu bestimmt. Die Karte mit dem höchsten Wert der Trumpffarbe gewinnt und der
+Spieler, der diese Karte ausgespielt hat, bekommt alle Karten des Stichs. Karten, die eine andere Farbe als die
+Trumpffarbe haben, können einen Stich nie gewinnen. Nach jedem Stich werden die Stichkarten ausgewertet
+und die Strafpunkte der Spieler aufaddiert. Jede Kreuz-Karte ergibt einen Strafpunkt.
+
+## Durchführung des Programms
+
+Es wird zunächst nach der Anzahl an Spielern gefragt. Es können 3 oder 4 Spieler ausgewählt werden.
+
+Dann wird nach den Namen gefragt. Gibt der Benutzer bei einem der Spieler keinen Namen ein, wird dieser Spieler 'Spieler X' genannt, wobei X die Nummer des Spielers ist.
+
+Dann werden die Karten gemischt, an die Spieler verteilt und es geht los.

EPR/ue05/blatt04.py

@@ -10,9 +10,9 @@ def create_card_list(number_of_cards:int) -> [(int, str)]:
     number_of_cards: Anzahl der Karten
     '''
     card_list = []
-    for i in range(1, int((number_of_cards+1)/4)+1):
+    for i in range(1, int((number_of_cards+1)/3)+1):
         card_list.append((i, "Kreuz"))
-        card_list.append((i, "Pik"))
+        #card_list.append((i, "Pik"))
         card_list.append((i, "Herz"))
         card_list.append((i, "Karo"))
     return card_list
@@ -71,6 +71,20 @@ int) -> [[(int, str)]]:
     return list_players
 
 
+def hand_out_cards_modified(list_cards: [(int, str)], players: {str: list}, number_of_cards:
+int) -> [[(int, str)]]:
+    '''Teilt die Karten an die Spieler aus
+    list_cards: Liste mit Karten
+    players: Anzahl der Spieler
+    number_of_cards: Anzahl der Karten pro Spieler
+    '''
+    for player in players:
+        for _ in range(number_of_cards):
+            players[player].append(list_cards.pop(0))
+
+    return players
+
+
 def main():
     '''Hauptprogramm'''
     # Testfälle

EPR/ue05/main.py

@@ -1,9 +1,175 @@
 '''EPR Übungsblatt 05'''
 __author__="7987847, Werner"
 
+import random
 import blatt04
 
 
+def load_players() -> [str]:
+    '''Erstellt die Spieler des Spiels'''
+    while True:
+        try:
+            player_count = int(input("Anzahl der Spieler (3-4): "))
+            if player_count in [3, 4]:
+                break
+        except ValueError:
+            pass
+
+    player_names = []
+
+    for i in range(player_count):
+        print("Spieler", i+1, "Name: ", end='')
+        name = input()
+        if name == "":
+            name = "Spieler " + str(i+1)
+        player_names.append(name)
+
+    return player_names
+
+
+def initialize_variables(players:[str]) -> ({str: int}, {str: list}):
+    '''Initialisiert die Variablen für das Spiel'''
+
+    score_dict = {}
+    hand_dict = {}
+
+    # Erstelle und mische das Kratenblatt
+    deck = blatt04.create_card_list(12)
+    deck = blatt04.shuffle_card_list(deck)
+
+    for i in players:
+        score_dict[i] = 0
+        hand_dict[i] = []
+
+    hand_dict = blatt04.hand_out_cards_modified(deck, hand_dict, 3)
+
+    return score_dict, hand_dict
+
+
+def play_game(players: list, scores: {str: int}, all_hands: {str: list}) -> {str: int}:
+    '''Spielt das Spiel'''
+
+    game_over = False
+
+    while not game_over:
+        # Ermittlung einer zufälligen Reihenfolge der Spieler
+        random.shuffle(players)
+
+        trumpf = "any"
+        played_cards = []
+        for player in players:
+            # Karte spielen
+            # player hand von dict all_hands holen
+            player_hand = all_hands.get(player)
+
+            print("-------------------")
+            print("Spieler", player, "ist an der Reihe")
+            played_card, player_cards = play_card(player_hand, trumpf)
+            all_hands[player] = player_cards
+
+            # Wenn der Spieler an der Reihe ist
+            if player == players[0]:
+                trumpf = played_card[1]
+                print("~~~~~~~~~~~~~~~~~~~")
+                print("Trumpf ist", trumpf)
+                print("~~~~~~~~~~~~~~~~~~~")
+            played_cards.append(played_card)
+
+        # Ermittlung des Gewinners
+        winner = get_winner(played_cards, trumpf)
+
+        # Punktevergabe
+        if winner != -1:
+            scores[players[winner]] += 1
+
+            # Gewinner bekommt die Karten
+            for card in played_cards:
+                all_hands[players[winner]].append(card)
+
+        print("Punktestand: ", scores)
+
+        # Überprüfung ob das Spiel zu Ende ist
+        for player in players:
+            if len(all_hands[player]) == 0:
+                game_over = True
+
+    print("Das Spiel ist zu Ende.")
+    # sortiere die spieler scores nach der höhe
+    sorted_scores = sorted(scores.items(), key=lambda x: x[1])
+
+    players_won = []
+    players_won.append(sorted_scores[0][0])
+
+    for i in range(len(sorted_scores)):
+        if i == len(sorted_scores) - 1:
+            break
+        if sorted_scores[i][1] == sorted_scores[i+1][1]:
+            players_won.append(sorted_scores[i+1][0])
+
+    print("Die Spieler", players_won, "haben gewonnen.")
+
+
+
+
+
+def check_card(card: (int, str), player_hand: list, trump: str) -> bool:
+    '''Überprüft ob eine Karte gespielt werden darf'''
+
+    if card[1] == trump:
+        return True
+
+    for i in player_hand:
+        if i[1] == trump:
+            return False
+
+    return True
+
+
+def play_card(player_hand: list, trump: str) -> ((int, str), list):
+    '''Spielt eine Karte aus der Hand'''
+    for i in player_hand:
+        print(i + 1, player_hand[i])
+
+    card_valid = False
+
+    while not card_valid:
+        played_card_index = input(
+            "Karte wählen. Bei illegalem Zug wird dies wiederholt.\
+(Nummer von 1 - " +
+              str(len(player_hand)) + "): ")
+
+        try:
+            played_card_index = int(played_card_index)
+            player_hand[played_card_index - 1]
+        except ValueError:
+            print("Keine gültige Zahl")
+            continue
+
+        card_valid = check_card(player_hand[played_card_index - 1], player_hand, trump)
+
+    print("Karte gespielt: ", player_hand[i-1])
+
+    return player_hand.pop(i-1), player_hand
+
+
+def get_winner(current_trick: list, trump: str) -> int:
+    '''Ermittelt den Gewinner eines Stiches'''
+
+    # Ermittelt die Trumpfkarten der liste current_trick.
+    trump_cards = list(filter(lambda x: x[1] == trump, current_trick))
+
+    if len(trump_cards) > 0:
+        # Ermittelt die höchste Trumpfkarte
+        highest_trump = max(trump_cards, key=lambda x: x[0])
+        return current_trick.index(highest_trump)
+
+    # Wenn es keine Trumpkarten gibt, gewinnt niemand
+    return -1
+
+
+
+
+
 
 
 
@@ -14,4 +180,111 @@ import blatt04
 
 
 if __name__ == '__main__':
-    pass
+    players = load_players()
+    scores, hands = initialize_variables(players)
+    play_game(players, scores, hands)
+
+    # Testfälle
+
+    # a)
+    # load_players()
+    # Ausgabe: Anzahl der Spieler (3-4): 3
+    # Spieler 1 Name: Spieler 1
+    # Spieler 2 Name: Spieler 2
+    # Spieler 3 Name: Spieler 3
+    # Rückgabe: ['Spieler 1', 'Spieler 2', 'Spieler 3']
+
+    # load_players()
+    # Ausgabe: Anzahl der Spieler (3-4): 4
+    # Spieler 1 Name: Spieler 1
+    # Spieler 2 Name: Spieler 2
+    # Spieler 3 Name: Spieler 3
+    # Spieler 4 Name: Spieler 4
+    # Rückgabe: ['Spieler 1', 'Spieler 2', 'Spieler 3', 'Spieler 4']
+
+    # load_players()
+    # Ausgabe: Anzahl der Spieler (3-4): 2
+    # Anzahl der Spieler (3-4): 5
+    # Anzahl der Spieler (3-4): 3
+    # Spieler 1 Name: Spieler 1
+    # Spieler 2 Name: Spieler 2
+    # Spieler 3 Name: Spieler 3
+    # Rückgabe: ['Spieler 1', 'Spieler 2', 'Spieler 3']
+
+    # b)
+    # initialize_variables(['Spieler 1', 'Spieler 2', 'Spieler 3'])
+    # Rückgabe: ({'Spieler 1': 0, 'Spieler 2': 0, 'Spieler 3': 0},
+    # {'Spieler 1': [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Spieler 2':
+    # [(1, 'Karo'), (2, 'Kreuz'), (2, 'Pik')], 'Spieler 3': [(2, 'Herz'),
+    # (2, 'Karo'), (3, 'Kreuz')]})
+
+    # initialize_variables(['Spieler 1', 'Spieler 2', 'Spieler 3', 'Spieler 4'])
+    # Rückgabe: ({'Spieler 1': 0, 'Spieler 2': 0, 'Spieler 3': 0,
+    # 'Spieler 4': 0}, {'Spieler 1': [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')],
+    # 'Spieler 2': [(1, 'Karo'), (2, 'Kreuz'), (2, 'Pik')], 'Spieler 3':
+    # [(2, 'Herz'), (2, 'Karo'), (3, 'Kreuz')], 'Spieler 4': [(3, 'Pik'),
+    # (3, 'Herz'), (3, 'Karo')]})
+
+    # initialize_variables(['Spieler 1', 'Spieler 2'])
+    # Rückgabe: ({'Spieler 1': 0, 'Spieler 2': 0}, {'Spieler 1': [(1, 'Kreuz'),
+    # (1, 'Pik'), (1, 'Herz')], 'Spieler 2': [(1, 'Karo'), (2, 'Kreuz'),
+    # (2, 'Pik')]})
+
+    # c)
+    # play_game(['Spieler 1', 'Spieler 2', 'Spieler 3'], {'Spieler 1': 0,
+    # 'Spieler 2': 0, 'Spieler 3': 0}, {'Spieler 1': [(1, 'Kreuz'), (1, 'Pik'),
+    # (1, 'Herz')], 'Spieler 2': [(1, 'Karo'), (2, 'Kreuz'), (2, 'Pik')],
+    # 'Spieler 3': [(2, 'Herz'), (2, 'Karo'), (3, 'Kreuz')]})
+    # Spiel wird gespielt
+
+    # play_game(['Spieler 1', 'Spieler 2', 'Spieler 3', 'Spieler 4'],
+    # {'Spieler 1': 0, 'Spieler 2': 0, 'Spieler 3': 0, 'Spieler 4': 0},
+    # {'Spieler 1': [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Spieler 2':
+    # [(1, 'Karo'), (2, 'Kreuz'), (2, 'Pik')], 'Spieler 3': [(2, 'Herz'),
+    # (2, 'Karo'), (3, 'Kreuz')], 'Spieler 4': [(3, 'Pik'), (3, 'Herz'),
+    # (3, 'Karo')]})
+    # Spiel wird gespielt
+
+    # play_game(['Spieler 1', 'Spieler 2'], {'Spieler 1': 0, 'Spieler 2': 0},
+    # {'Spieler 1': [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Spieler 2':
+    # [(1, 'Karo'), (2, 'Kreuz'), (2, 'Pik')]})
+    # Spiel wird gespielt
+
+    # d)
+    # check_card((1, 'Kreuz'), [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Karo')
+    # Rückgabe: True
+
+    # check_card((1, 'Kreuz'), [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Pik')
+    # Rückgabe: False
+
+    # check_card((1, 'Kreuz'), [(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Herz')
+    # Rückgabe: True
+
+    # e)
+    # play_card([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Karo')
+    # Ausgabe: 1 (Karte wählen. Bei illegalem Zug wird dies wiederholt. (Nummer von 1 - 3): 1
+    # Karte gespielt: (1, 'Kreuz')
+    # Rückgabe: ((1, 'Kreuz'), [(1, 'Pik'), (1, 'Herz')])
+    # (Kann auch anders aussehen)
+
+    # play_card([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Pik')
+    # Ausgabe: 1 (Karte wählen. Bei illegalem Zug wird dies wiederholt. (Nummer von 1 - 3): 1
+    # Karte gespielt: (1, 'Kreuz')
+    # Rückgabe: ((1, 'Kreuz'), [(1, 'Pik'), (1, 'Herz')])
+    # (Kann auch anders aussehen)
+
+    # play_card([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Herz')
+    # Ausgabe: 1 (Karte wählen. Bei illegalem Zug wird dies wiederholt. (Nummer von 1 - 3): 1
+    # Karte gespielt: (1, 'Kreuz')
+    # Rückgabe: ((1, 'Kreuz'), [(1, 'Pik'), (1, 'Herz')])
+    # (Kann auch anders aussehen)
+
+    # f)
+    # get_winner([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Karo')
+    # Rückgabe: 0
+
+    # get_winner([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Pik')
+    # Rückgabe: 0
+
+    # get_winner([(1, 'Kreuz'), (1, 'Pik'), (1, 'Herz')], 'Herz')
+    # Rückgabe: 0