Got first part of UI working.

.gitignore

@@ -0,0 +1 @@
+__pycache__/

client.py

@@ -3,10 +3,14 @@
 # Apr 2025
 
 from __future__ import annotations
+from typing import TYPE_CHECKING
 import socket
 import select
 import network_utilities
 
+if TYPE_CHECKING:
+    from ui import UI
+
 
 class Game:
 
@@ -66,12 +70,14 @@ class Player:
     __verse: str
     __score: int
     __game: Game | None
+    __ui: UI
 
-    def __init__(self, name: str):
+    def __init__(self, name: str, ui: UI):
         self.__name = name
         self.__verse = ""
         self.__score = 0
         self.__game = None
+        self.__ui = ui
 
     @property
     def name(self) -> str: return self.__name
@@ -108,27 +114,29 @@ class Player:
 
     def player_joined(self, name: str):
         if self.__game is not None:
-            pass
+            self.__ui.player_joined(name)
 
     def new_verse(self, text: str):
         if self.__game is not None:
-            pass
+            self.__verse = text
+            self.__ui.new_verse(text)
 
     def guess_incorrect(self):
         if self.__game is not None:
-            pass
+            self.__ui.guess_incorrect()
 
     def guess_correct(self):
         if self.__game is not None:
-            pass
+            self.__ui.guess_correct()
 
     def verse_guessed(self, points: int, url: str, player: str):
         if self.__game is not None:
-            pass
+            self.__score += points
+            self.__ui.verse_guessed(points, url, player)
 
     def game_over(self, players: list[str], scores: list[int]):
         if self.__game is not None:
-            pass
+            self.__ui.game_over(players, scores)
 
     def update(self):
         if self.__game is not None:

library.py

@@ -9,6 +9,7 @@ import socket
 import select
 import network_utilities
 from server import Game
+from time import sleep
 
 
 class Library:
@@ -41,11 +42,13 @@ class Library:
                         if not game.finished: game.update()
                         else: self.__games.remove(game)
                     if ready_to_read:
-                        conn, _ = s.accept()
+                        conn, addr = s.accept()
                         conn.setblocking(False)
                         if network_utilities.unpack_varint(conn) == 1:
                             name = network_utilities.unpack_string(conn)
+                            print(f"<< (1) join_game({name}, {addr})")
                             self.join_game(name, conn)
+                    sleep(0.1)
         except KeyboardInterrupt:
             print("KeyboardInterrupt\nExiting...")
             return
@@ -110,3 +113,7 @@ class Library:
 
         return difficulty_verses
 
+
+if __name__ == '__main__':
+    lib = Library()
+    lib.serve_forever()

main.py

@@ -6,10 +6,12 @@ def server(host: str='', port: int=7788):
     lib.serve_forever()
 
 def client(playername: str, host: str='localhost', port: int=7788):
-    pass
+    from ui import UI
+    ui = UI(playername, host, port)
+    ui.loop()
 
 def main():
-    pass
+    client("TestPlayer")
 
 if __name__ == "__main__":
     main()

server.py

@@ -105,24 +105,29 @@ class Player:
     def name(self) -> str: return self.__name
 
     def player_joined(self, name: str):
+        print(f">> (1) 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})")
         data = network_utilities.pack_varint(2)
         data += network_utilities.pack_string(text)
         self.__client.send(data)
 
     def guess_incorrect(self):
+        print(">> (3) guess_incorrect()")
         data = network_utilities.pack_varint(3)
         self.__client.send(data)
 
     def guess_correct(self):
+        print(">> (4) 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})")
         data = network_utilities.pack_varint(5)
         data += network_utilities.pack_varint(points)
         data += network_utilities.pack_string(url)
@@ -130,6 +135,7 @@ 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)})")
         data = network_utilities.pack_varint(6)
         data += network_utilities.pack_string_array(players)
         data += network_utilities.pack_varint_array(scores)
@@ -141,13 +147,17 @@ class Player:
         if ready_to_read:
             packet_id = network_utilities.unpack_varint(self.__client)
             if packet_id == 2:
+                print("<< (2) start_game()")
                 self.__game.start_game()
             elif packet_id == 3:
                 difficulty = network_utilities.unpack_varint(self.__client)
+                print(f"<< (3) start_round({difficulty})")
                 self.__game.start_round(difficulty)
             elif packet_id == 4:
                 url = network_utilities.unpack_string(self.__client)
+                print(f"<< (4) guess_reference({url}, {self.name})")
                 self.__game.guess_reference(url, self)
             elif packet_id == 5:
+                print("<< (5) end_game()")
                 self.__game.end_game()
 

ui.py

@@ -1,10 +1,81 @@
 
 from client import Player
+from time import sleep
+from blessed import Terminal
+
 
 class UI:
 
     __player: Player
+    __verse: str
+    __in_game: bool
+    __game_over: bool
+    __term: Terminal
+    __buffer: str
 
     def __init__(self, playername: str, host: str='localhost', port: int=7788):
-        self.__player = Player(playername)
+        self.__player = Player(playername, self)
-        self.__player.join_game()
+        self.__player.join_game(host, port)
+        self.__verse = ""
+        self.__in_game = False
+        self.__game_over = False
+        self.__term = Terminal()
+        self.__buffer = ""
+
+    def get_line(self):
+        with self.__term.cbreak():
+            val = self.__term.inkey(timeout=0)
+            if not val:
+                return None
+            if val.is_sequence:
+                if val.name == 'KEY_ENTER':
+                    line = self.__buffer
+                    self.__buffer = ""
+                    print()
+                    return line
+                elif val.name == 'KEY_BACKSPACE':
+                    self.__buffer = self.__buffer[:-1]
+                    print(f'\r{self.__term.clear_eol}{self.__buffer}', end='', flush=True)
+            else:
+                self.__buffer += val
+                print(val, end='', flush=True)
+        return None
+
+    def loop(self):
+        while not self.__game_over:
+            self.__player.update()
+            if text := self.get_line():
+                if self.__in_game:
+                    self.__player.guess_reference(text)
+                elif text == 'Start Game':
+                    self.__player.start_game()
+                    self.__player.new_round(1)
+            sleep(0.1)
+
+    def player_joined(self, name: str):
+        print(f"{name} Joined the Game")
+
+    def new_verse(self, text: str):
+        self.__in_game = True
+        self.__verse = text
+        print(self.__verse)
+
+    def guess_incorrect(self):
+        print("That guess was incorrect.")
+        print(self.__verse)
+
+    def guess_correct(self):
+        print("That guess was correct!")
+
+    def verse_guessed(self, points: int, url: str, player: str):
+        print(f"The verse has been guessed. It is {url}.")
+        print(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! ---")
+        for player, score in players, scores:
+            if player == self.__player.name:
+                print(f"  * {player}: {score} *")
+            else:
+                print(f"    {player}: {score}")