Implement name generation for players and enhance UI feedback on player actions

client.py

@@ -51,6 +51,9 @@ class Game:
                 self.__player.new_verse(text)
             elif packet_id == 3:
                 self.__player.guess_incorrect()
+            elif packet_id == 7:
+                url = network_utilities.unpack_string(self.__server)
+                self.__player.guess_partial_correct(url)
             elif packet_id == 4:
                 self.__player.guess_correct()
             elif packet_id == 5:
@@ -125,6 +128,10 @@ class Player:
         if self.__game is not None:
             self.__ui.guess_incorrect()
 
+    def guess_partial_correct(self, url):
+        if self.__game is not None:
+            self.__ui.guess_partial_correct(url)
+
     def guess_correct(self):
         if self.__game is not None:
             self.__ui.guess_correct()

main.py

@@ -1,4 +1,46 @@
-import argparse
+
+import random
+
+def name_gen():
+    adjectives = [
+        "able", "active", "adaptable", "adventurous", "agreeable", "alert",
+        "amazing", "amiable", "ample", "artistic", "attractive", "balanced",
+        "beautiful", "blissful", "bold", "brave", "bright", "brilliant",
+        "bubbly", "calm", "capable", "careful", "charming", "cheerful", "clean",
+        "clear", "clever", "colorful", "comfortable", "compassionate",
+        "confident", "considerate", "cool", "cooperative", "courageous",
+        "creative", "cultured", "cute", "daring", "decent", "delightful",
+        "detailed", "determined", "dignified", "disciplined", "dynamic",
+        "eager", "easygoing", "elegant", "energetic", "engaging",
+        "enthusiastic", "excellent", "exciting", "expressive", "fair",
+        "faithful", "fancy", "fascinating", "flexible", "focused", "friendly",
+        "fun", "funny", "generous", "gentle", "genuine", "gifted", "glad",
+        "gleaming", "good", "graceful", "gracious", "great", "handsome",
+        "happy", "harmonious", "helpful", "honest", "hopeful", "humble",
+        "imaginative", "impressive", "independent", "innocent", "inspiring",
+        "intelligent", "interesting", "intuitive", "jolly", "jovial", "joyful",
+        "kind", "lively", "logical", "lovely", "loyal", "lucky", "mature",
+        "mindful", "modest",
+    ]
+    nouns = [
+        "Cello", "Badger", "Fish", "Apple", "Mountain", "River", "Teacher",
+        "Book", "Car", "Tree", "Dog", "House", "Chair", "Phone", "Computer",
+        "City", "Ocean", "Guitar", "Desk", "Flower", "Star", "Sky", "Window",
+        "Road", "Train", "Plane", "School", "Garden", "Table", "Bottle",
+        "Shirt", "Door", "Bridge", "Watch", "Camera", "Bag", "Pencil", "Cup",
+        "Hat", "Wall", "Cloud", "Island", "Forest", "Room", "Engine", "Shoe",
+        "Candle", "Bed", "Lamp", "Mirror", "Clock", "Keyboard", "Mouse",
+        "Blanket", "Pillow", "Soap", "Towel", "Toothbrush", "Backpack",
+        "Basket", "Fan", "Television", "Magazine", "Newspaper", "Statue",
+        "Painting", "Ladder", "Fence", "Rope", "Ball", "Drum", "Violin",
+        "Microphone", "Box", "Shelf", "Ring", "Necklace", "Coin", "Wallet",
+        "Purse", "Ticket", "Key", "Lock", "Brush", "Comb", "Notebook",
+        "Envelope", "Stamp", "Hammer", "Screwdriver", "Nail", "Saw", "Plank",
+        "Brick", "Tile", "Carpet", "Curtain", "Apron", "Oven", "Refrigerator",
+        "Blender", "Pot", "Pan",
+    ]
+
+    return random.choice(adjectives).capitalize() + random.choice(nouns)
 
 def server(host: str='', port: int=7788):
     from library import Library
@@ -11,7 +53,7 @@ def client(playername: str, host: str='localhost', port: int=7788):
     ui.loop()
 
 def main():
-    client("TestPlayer")
+    client(name_gen())
 
 if __name__ == "__main__":
     main()

server.py

@@ -17,6 +17,7 @@ class Game:
 
     __library: Library
     __current_url: str
+    __current_url_parts: list[str]
     __clients: list[Player]
     __round_points: list[int]
     __total_scores: list[int]
@@ -27,6 +28,7 @@ class Game:
     def __init__(self, library: Library):
         self.__library = library
         self.__current_url = ""
+        self.__current_url_parts = []
         self.__clients = []
         self.__round_points = []
         self.__total_scores = []
@@ -42,7 +44,10 @@ class Game:
 
     def add_player(self, name: str, conn: socket):
         if not self.__active:
-            self.__clients.append(Player(name, self, conn))
+            new_player = Player(name, self, conn)
+            for player in self.__clients:
+                new_player.player_joined(player.name)
+            self.__clients.append(new_player)
             self.__total_scores.append(0)
             for player in self.__clients:
                 player.player_joined(name)
@@ -58,18 +63,28 @@ class Game:
     def new_verse(self, url: str, text: str):
         for player in self.__clients:
             self.__current_url = url
+            self.__current_url_parts = url.strip('/').split('/')
             player.new_verse(text)
 
     def guess_reference(self, url: str, player: Player):
         if self.__active and not self.__finished:
             if url == self.__current_url:
                 player.guess_correct()
+                self.__round_points[self.__clients.index(player)] = 4
                 for i, points in enumerate(self.__round_points):
                     self.__total_scores[i] += points
                     self.__clients[i].verse_guessed(
                         points, self.__current_url, player.name)
+                self.end_game()
             else:
-                player.guess_incorrect()
+                partially_correct = []
+                for player_url, current_url in zip(url.strip('/').split('/'), self.__current_url_parts):
+                    if player_url == current_url:
+                        partially_correct.append(current_url)
+                if partially_correct:
+                    player.guess_partial_correct(f"/{'/'.join(partially_correct)}")
+                    self.__round_points[self.__clients.index(player)] = len(partially_correct)
+                else: player.guess_incorrect()
 
     def end_game(self):
         self.__finished = True
@@ -95,39 +110,47 @@ class Player:
     __name: str
     __game: Game
     __client: socket
+    __connected: bool
 
     def __init__(self, name: str, game: Game, conn: socket):
         self.__name = name
         self.__game = game
         self.__client = conn
+        self.__connected = True
 
     @property
     def name(self) -> str: return self.__name
 
     def player_joined(self, name: str):
-        print(f">> (1) player_joined({name})")
+        print(f">> (1, {self.name}) player_joined({name})")
         data = network_utilities.pack_varint(1)
         data += network_utilities.pack_string(name)
         self.__client.send(data)
 
     def new_verse(self, text: str):
-        print(f">> (2) new_verse({text})")
+        print(f">> (2, {self.name}) new_verse({text})")
         data = network_utilities.pack_varint(2)
         data += network_utilities.pack_string(text)
         self.__client.send(data)
 
     def guess_incorrect(self):
-        print(">> (3) guess_incorrect()")
+        print(f">> (3, {self.name}) guess_incorrect()")
         data = network_utilities.pack_varint(3)
         self.__client.send(data)
 
+    def guess_partial_correct(self, url):
+        print(f">> (7, {self.name}) guess_partial_correct({url})")
+        data = network_utilities.pack_varint(7)
+        data += network_utilities.pack_string(url)
+        self.__client.send(data)
+
     def guess_correct(self):
-        print(">> (4) guess_correct()")
+        print(">> (4, {self.name}) guess_correct()")
         data = network_utilities.pack_varint(4)
         self.__client.send(data)
 
     def verse_guessed(self, points: int, url: str, player: str):
-        print(f">> (5) verse_guessed({points}, {url})")
+        print(f">> (5, {self.name}) verse_guessed({points}, {url})")
         data = network_utilities.pack_varint(5)
         data += network_utilities.pack_varint(points)
         data += network_utilities.pack_string(url)
@@ -135,29 +158,31 @@ class Player:
         self.__client.send(data)
 
     def game_over(self, players: list[str], scores: list[int]):
-        print(f">> (6) game_over({len(players)}, {len(scores)})")
+        print(f">> (6, {self.name}) game_over({len(players)}, {len(scores)})")
         data = network_utilities.pack_varint(6)
         data += network_utilities.pack_string_array(players)
         data += network_utilities.pack_varint_array(scores)
         self.__client.send(data)
         self.__client.close()
+        self.__connected = False
 
     def update(self):
-        ready_to_read, _, _ = select.select([self.__client], [], [], 0)
+        if self.__connected:
-        if ready_to_read:
+            ready_to_read, _, _ = select.select([self.__client], [], [], 0)
-            packet_id = network_utilities.unpack_varint(self.__client)
+            if ready_to_read:
-            if packet_id == 2:
+                packet_id = network_utilities.unpack_varint(self.__client)
-                print("<< (2) start_game()")
+                if packet_id == 2:
-                self.__game.start_game()
+                    print(f"<< (2, {self.name}) start_game()")
-            elif packet_id == 3:
+                    self.__game.start_game()
-                difficulty = network_utilities.unpack_varint(self.__client)
+                elif packet_id == 3:
-                print(f"<< (3) start_round({difficulty})")
+                    difficulty = network_utilities.unpack_varint(self.__client)
-                self.__game.start_round(difficulty)
+                    print(f"<< (3, {self.name}) start_round({difficulty})")
-            elif packet_id == 4:
+                    self.__game.start_round(difficulty)
-                url = network_utilities.unpack_string(self.__client)
+                elif packet_id == 4:
-                print(f"<< (4) guess_reference({url}, {self.name})")
+                    url = network_utilities.unpack_string(self.__client)
-                self.__game.guess_reference(url, self)
+                    print(f"<< (4, {self.name}) guess_reference({url}, {self.name})")
-            elif packet_id == 5:
+                    self.__game.guess_reference(url, self)
-                print("<< (5) end_game()")
+                elif packet_id == 5:
-                self.__game.end_game()
+                    print(f"<< (5, {self.name}) end_game()")
+                    self.__game.end_game()
 

ui.py

@@ -42,6 +42,10 @@ class UI:
                 print(val, end='', flush=True)
         return None
 
+    def __reset(self):
+        self.__buffer = ""
+        print()
+
     def loop(self):
         while not self.__game_over:
             self.__player.update()
@@ -60,6 +64,9 @@ class UI:
             )
         else:
             if url:
+                try: ref = convert_url(url)
+                except Exception: ref = url.upper().replace('/','.').strip('.')
+                print(f"Your input was interpreted as: {ref}")
                 self.__player.guess_reference(url)
                 return
             elif possible:
@@ -81,9 +88,11 @@ class UI:
         self.__player.new_round(difficulty)
 
     def player_joined(self, name: str):
-        print(f"{name} Joined the Game")
+        if name == self.__player.name: print(f"* {name} Joined the Game *")
+        else: print(f"{name} Joined the Game")
 
     def new_verse(self, text: str):
+        self.__reset()
         self.__in_game = True
         self.__verse = text
         print(self.__verse)
@@ -92,6 +101,12 @@ class UI:
         print("That guess was incorrect.")
         print(self.__verse)
 
+    def guess_partial_correct(self, url):
+        try: ref = convert_url(url)
+        except Exception: ref = url.upper().replace('/','.').strip('.')
+        print(f"That guess was partially correct: {ref}")
+        print(self.__verse)
+
     def guess_correct(self):
         print("That guess was correct!")
 
@@ -99,15 +114,15 @@ class UI:
         try: ref = convert_url(url)
         except Exception: ref = url.upper().replace('/','.').strip('.')
         print(
-            f"The verse has been guessed by {player}.\n"
+            f"\nThe verse has been guessed by {player}.\n"
             f"The reference is {ref}.\n"
             f"You have been awarded {points} points for your guess."
         )
 
     def game_over(self, players: list[str], scores: list[int]):
         self.__game_over = True
-        print("--- THANKS FOR PLAYING! ---")
+        print("\n--- THANKS FOR PLAYING! ---")
-        for player, score in players, scores:
+        for player, score in zip(players, scores):
             if player == self.__player.name:
                 print(f"  * {player}: {score} *")
             else: