Testing cheats and time/move graphs

app.py

@@ -143,18 +143,19 @@ def main():
         game_state, game_ongoing = make_move(white, game_state)
         onetime_logger.add_legal_move(game_state)
         if not game_ongoing:
-            #print_game(game_state)
+            print_game(game_state)
             break
         game_state, game_ongoing = make_move(black, game_state)
         onetime_logger.add_legal_move(game_state)
         if not game_ongoing:
-            #print_game(game_state)
+            print_game(game_state)
             break
     """
+    onetime_logger.add_checkmate(player_1) #here for testing purposes
     finished_game = onetime_logger.return_formatted_game()
     onetime_db = GameDatabase()
     onetime_db.add_game(finished_game)
 
-    onetime_db.display_tournament()
+    onetime_db.display_game(0)
 if __name__ == "__main__":
    main()

game_database.py

@@ -4,6 +4,8 @@ import pandas as pd
 import streamlit as st
 from typing import Dict
 from logger import Logger
+import time
+import numpy as np
 
 class GameDatabase:
     def __init__(self):
@@ -14,7 +16,39 @@ class GameDatabase:
         self.db.append(game)
 
     def display_game(self, game_num: int): #Displays analytics for a specific game
+        game = self.db[game_num]
+
+        fig, axs = plt.subplots(2,2)
+        width = 0.4
+
+        def list_sets_graph(data_list: [], axs_pos: [], title, width = 0.4):
+            white_data = data_list[::2]
+            black_data = data_list[1::2]
+            x = np.arange(len(white_data))
+
+            axs[axs_pos[0], axs_pos[1]].set_xticks(x, [x for x in range(len(white_data))])
+            axs[axs_pos[0], axs_pos[1]].bar(x - (width/2), white_data, width, color = "navajowhite")
+            axs[axs_pos[0], axs_pos[1]].bar(x + (width/2), black_data, width, color = "saddlebrown")
+            axs[axs_pos[0], axs_pos[1]].legend(["White", "Black"]) 
+
+
+
+        #plot time per move, with data for each model
+        time_title = "Seconds Per Move"
+        list_sets_graph(game[time_title], axs_pos=[0,0], title=time_title)
+
+        #plot cheating per model
+        cheat_title = "Cheat Attempts Per Move"
+        list_sets_graph(game["Cheat Attempts"], axs_pos=[1,0], title = cheat_title)
+
+        #stockfish analysis of each player over time
+
+
+        #plt.show()
+        st.pyplot(fig)
         pass
+
+
     def display_tournament(self): #Displays analytics for the entire tournament
 
         df = pd.DataFrame(self.db)
@@ -29,8 +63,9 @@ class GameDatabase:
         nums = [1,2,3]
 
         fig, axs = plt.subplots(2,1)
-        axs[0].plot(names, nums)
+        axs[0].plot(win_results)
         axs[1].bar(names, nums)
+
         st.pyplot(fig)
         
         
@@ -38,7 +73,12 @@ class GameDatabase:
 if __name__ == "__main__":
     test_logger = Logger("ChessGPT", "ChatGPT")
     test_logger.add_cheat("ChessGPT")
+    time.sleep(1)
     test_logger.add_legal_move("e4")
+    time.sleep(1)
+    test_logger.add_legal_move("e4 e6")
+    time.sleep(2)
+    test_logger.add_legal_move("e4 e6 Nf3")
     test_logger.add_checkmate("ChessGPT")
     #test_logger.add_legal_move("e4 e5")
     formatted = test_logger.return_formatted_game()
@@ -56,4 +96,4 @@ if __name__ == "__main__":
     db.add_game(formatted_2)
     db.add_game(formatted_3)
 
-    db.display_tournament()
+    db.display_game(0)

logger.py

@@ -1,15 +1,23 @@
 import requests
 import re
+import time
 
 class Logger:
     def __init__(self, model_1: str, model_2: str): #Model 1 should be white
         self.model_1 = model_1
         self.model_2 = model_2
         self.current_moves = ""
+
         self.cheat_attempts = [0]
+
         self.winner = ""
         self.checkmate = False
 
+        self.seconds_per_move = []
+        self.prev_end_time = time.time()
+
+        self.stockfish_results = []
+
     #Interface with the Model Interface
     def add_legal_move(self, current_moves: str): #current_moves should be all moves so far, in UCI notation
         if self.checkmate:
@@ -17,6 +25,10 @@ class Logger:
         else: 
             self.current_moves = current_moves
             self.cheat_attempts.append(0)
+
+            current_time = time.time()
+            self.seconds_per_move.append(current_time - self.prev_end_time)
+            self.prev_end_time = current_time
             
     def add_cheat(self, cheater_name: str):
         if self.checkmate:
@@ -69,7 +81,9 @@ class Logger:
                     "Model 2": self.model_2, 
                     "Winner": self.winner, 
                     "UCI": self.current_moves, 
-                    "Cheat Attempts": self.cheat_attempts}
+                    "Cheat Attempts": self.cheat_attempts,
+                    "Seconds Per Move": self.seconds_per_move,
+                    "Stockfish Results": self.stockfish_results}
             return game
     
 #Testing section