Changed the courts to dictionaries

1 files changed, 45 insertions, 51 deletions

diff --git a/model.py b/model.py
index c83bcfd..bfaa9d5 100644
--- a/model.py
+++ b/model.py
@@ -4,36 +4,28 @@ from pathlib import Path
 from random import sample
 from operator import attrgetter
 from dataclasses import dataclass
-
-
-@dataclass
-class Court:
-    number: int
-    status: bool
+from typing import Tuple
 
 
 @dataclass
 class CourtList:
     total: int
 
-    def __post_init__(self):
-        self.courts = [Court(i + 1, True) for i in range(self.total)]
+    def __post_init__(self) -> None:
+        self.courts = {i + 1: True for i in range(self.total)}
 
-    def get_court(self, court_number: int):
-        return [court for court in self.courts if court.number == court_number]
+    def get_court_status(self, court_number: int) -> bool:
+        return self.courts[court_number]
 
-    def toggle_court(self, court_number: int):
-        self.courts = [
-            (
-                Court(
-                    number=court_number,
-                    status=not court.status,
-                )
-                if court_number == court.number
-                else court
-            )
-            for court in self.courts
-        ]
+    def toggle_court_status(self, court_number: int) -> None:
+        current_status = self.courts[court_number]
+        self.courts[court_number] = not current_status
+        return not current_status
+
+    def separate_courts(self) -> Tuple[dict, dict]:
+        active_courts = {k: v for k, v in self.courts.items() if v}
+        inactive_courts = {k: v for k, v in self.courts.items() if not v}
+        return active_courts, inactive_courts
 
 
 @dataclass
@@ -96,7 +88,7 @@ class Team:
 
 @dataclass
 class Game:
-    court: Court
+    court: int
     team1: Team
     team2: Team
 
@@ -105,36 +97,33 @@ DUMMY_PLAYER = Player(name="-")
 DUMMY_TEAM = Team(player1=DUMMY_PLAYER, player2=DUMMY_PLAYER)
 
 
-def create_dummy_games(courts: list[Court]):
-    return [Game(court, DUMMY_TEAM, DUMMY_TEAM) for court in courts]
+def create_dummy_games(courts: dict):
+    return [Game(court, DUMMY_TEAM, DUMMY_TEAM) for court, _ in courts.items()]
 
 
 RESERVED_PLAYER = Player(name="Reserved")
 RESERVED_TEAM = Team(player1=RESERVED_PLAYER, player2=RESERVED_PLAYER)
 
 
-def create_reserved_games(courts: list[Court]):
-    return [Game(court, RESERVED_TEAM, RESERVED_TEAM) for court in courts]
+def create_reserved_games(courts: dict):
+    return [Game(court, RESERVED_TEAM, RESERVED_TEAM) for court, _ in courts.items()]
 
 
 PLAYER_PER_COURT = 4
 
 
-def create_single_game(court: Court, players: list[Player]):
+def create_game(court: int, players: list[Player]):
     team1 = Team(player1=players[0], player2=players[3])
     team2 = Team(player1=players[1], player2=players[2])
     return Game(court, team1, team2)
 
 
-def create_possible_games(court_list: list[Court], players: list[Player]):
+def create_possible_games(courts: dict, players: list[Player]):
+    count = len(players)
     clumped_players = [
-        players[i : i + PLAYER_PER_COURT]
-        for i in range(0, len(players), PLAYER_PER_COURT)
-    ]
-    games = [
-        create_single_game(court, clump)
-        for court, clump in zip(court_list, clumped_players)
+        players[i : i + PLAYER_PER_COURT] for i in range(0, count, PLAYER_PER_COURT)
     ]
+    games = [create_game(court, clump) for court, clump in zip(courts, clumped_players)]
     return games
 
 
@@ -142,42 +131,47 @@ def create_possible_games(court_list: list[Court], players: list[Player]):
 class GameList:
 
     def clear(self, court_list: CourtList):
-        courts = court_list.courts
-        active_courts = [court for court in courts if court.status]
-        inactive_courts = [court for court in courts if not court.status]
+        active_courts, inactive_courts = court_list.separate_courts()
         dummy_games = create_dummy_games(active_courts)
         reserved_games = create_reserved_games(inactive_courts)
         games = dummy_games + reserved_games
-        games.sort(key=attrgetter("court.number"))
+        games.sort(key=attrgetter("court"))
         self.games = games
 
-    def create_random_games(self, court_list: CourtList, player_list: PlayerList):
+    def create_random_games(self, courts: CourtList, player_list: PlayerList):
         active_players = player_list.get_active_players()
-        active_courts = [court for court in court_list.courts if court.status]
-        inactive_courts = [court for court in court_list.courts if not court.status]
+        active_courts, inactive_courts = courts.separate_courts()
         possible_games = floor(len(active_players) / PLAYER_PER_COURT)
+        if possible_games > len(active_courts):
+            possible_games = len(active_courts)
         current_players = sample(active_players, possible_games * PLAYER_PER_COURT)
         active_games = create_possible_games(
-            active_courts[:possible_games], current_players
+            dict(list(active_courts.items())[:possible_games]), current_players
+        )
+        dummy_games = create_dummy_games(
+            dict(list(active_courts.items())[possible_games:])
         )
-        dummy_games = create_dummy_games(active_courts[possible_games:])
         reserved_games = create_reserved_games(inactive_courts)
         games = active_games + dummy_games + reserved_games
-        games.sort(key=attrgetter("court.number"))
+        games.sort(key=attrgetter("court"))
         self.games = games
 
-    def create_skilled_games(self, court_list: CourtList, player_list: PlayerList):
+    def create_skilled_games(self, courts: CourtList, player_list: PlayerList):
         active_players = player_list.get_active_players()
-        active_courts = [court for court in court_list.courts if court.status]
-        inactive_courts = [court for court in court_list.courts if not court.status]
+        active_courts, inactive_courts = courts.separate_courts()
         possible_games = floor(len(active_players) / PLAYER_PER_COURT)
+        if possible_games > len(active_courts):
+            possible_games = len(active_courts)
         current_players = sample(active_players, possible_games * PLAYER_PER_COURT)
         current_players.sort(key=attrgetter("skill"))
+
         active_games = create_possible_games(
-            active_courts[:possible_games], current_players
+            dict(list(active_courts.items())[:possible_games]), current_players
+        )
+        dummy_games = create_dummy_games(
+            dict(list(active_courts.items())[possible_games:])
         )
-        dummy_games = create_dummy_games(active_courts[possible_games:])
         reserved_games = create_reserved_games(inactive_courts)
         games = active_games + dummy_games + reserved_games
-        games.sort(key=attrgetter("court.number"))
+        games.sort(key=attrgetter("court"))
         self.games = games