change game storage to save it into a nice folder structure

server/GameStorage.py

@@ -1,57 +1,91 @@
 from server.Files import save_file
+from datetime import datetime
 import os
 
 class GameStorage:
+  save_folder_dict = {
+    "standart": "Standart",
+    "duel": "Duels",
+    "constrictor": "Constrictor",
+  }
+
   def __init__(self, snake:str, path:str):
     self.snake_type = snake
     self.folder = path
     self.winner_snake_names = None
+    self.turns = {}
 
-  def start_new_game(self, game_type:dict, game_board:dict, snake:dict):
-    self.game_type = game_type
-    self.start_position = snake
-    self.game_board = [game_board]
+  def start_new_game(self, game_info:dict, game_board:dict, snake:dict):
+    self.init_game_board = game_board
+    self.game_info = game_info
+    self.my_snake_id = snake['id']
     self.moves = []
+    self.now_date = datetime.now()
 
-  def add_moves(self, game_board:dict, my_move:str):
-    self.game_board.append(game_board)
-    self.moves.append(my_move)
+  def add_moves(self, turn:int, game_board:dict, my_move:str):
+    self.turns[turn] = {
+      "move": my_move,
+      "game_board": game_board
+    }
 
   def add_end_state(self, game_board:dict, snake_history_state:list[dict], final_turns:int):
-    self.game_board.append(game_board)
+    self.final_turns = final_turns
     self.snake_history = snake_history_state
     self._set_winner_snake_name(game_board['snakes'])
-    self.final_turns = final_turns
 
   def _set_winner_snake_name(self, snakes:list[dict]):
-    if self.start_position["id"] in [ x["id"] for x in snakes]:
+    if self.my_snake_id in [ x["id"] for x in snakes]:
       self.winner_snake_names = "me"
     else:
       self.winner_snake_names = [ x["name"] for x in snakes]
+      if len(self.winner_snake_names) == 0:
+        self.winner_snake_names = None
 
   def _get_type_of_gameboard(self):
-    if len(self.game_board[0]["snakes"]) == 2:
-      return "duel"
-    
-    return "standart"
+    if len(self.init_game_board["snakes"]) == 2:
+      return {"name": "duel", "is_ladder": True if self.game_info["source"] == "ladder" else False}
+    elif self.game_info["ruleset"]["name"] == "constrictor":
+      return {"name": "constrictor", "is_ladder": True if self.game_info["source"] == "ladder" else False}
 
-  def save(self, path:str, callback=None, **kwargs):
+    return {"name": "standart", "is_ladder": True if self.game_info["source"] == "ladder" else False}
+
+  def _get_correct_folder_for_save_file(self, file_name:str, game_type:str, leader_board:bool, winner:bool):
+    storage_folder = self.folder
+    if leader_board:
+      storage_folder = os.path.join(storage_folder, "Leaderboards")
+
+    storage_folder = os.path.join(storage_folder, self.save_folder_dict[game_type])
+    storage_folder = os.path.join(storage_folder, self.now_date.strftime('%Y'), self.now_date.strftime('%m_%B'), self.now_date.strftime('%d'))
+
+    if winner:
+      storage_folder = os.path.join(storage_folder, "Winner")
+    else:
+      storage_folder = os.path.join(storage_folder, "Lost")
+
+    print(file_name, game_type, leader_board, winner)
+    return os.path.join(storage_folder, file_name)
+
+  def save(self, file_name:str, callback=None, **kwargs):
     if self.winner_snake_names == "me" and self.final_turns <= 10:
       return None
 
-    save_file(os.path.join(self.folder, path), {
+    game_type = self._get_type_of_gameboard()
+    save_file_path = self._get_correct_folder_for_save_file(file_name, game_type["name"], game_type["is_ladder"], True if self.winner_snake_names == "me" else False)
+
+    save_file(save_file_path, {
+      "winner": self.winner_snake_names,
+      "game": {
+        "id": self.game_info["id"],
+        "final_turns": self.final_turns,
+        "map": self.game_info["map"],
+        "type": game_type,
+        "ruleset": self.game_info["ruleset"],
+      },
+      "moves": self.turns,
       "snake": {
         "type": self.snake_type,
         "calculations": self.snake_history,
       },
-      "game": {
-        "type": self._get_type_of_gameboard(),
-        "infos": self.game_type,
-        "final_turns": self.final_turns,
-        "gameboard": self.game_board,
-        "my_moves": self.moves,
-      },
-      "winner": self.winner_snake_names,
     }, callback=callback, **kwargs)
 
   def __str__(self):

server/Server.py

@@ -90,7 +90,7 @@ class Server:
     next_move = self.running_snake[game_state["game"]["id"]].choose_move(game_state)
 
     if self.store_game_state:
-      self.running_games[game_state["game"]["id"]].add_moves(game_state["board"], next_move)
+      self.running_games[game_state["game"]["id"]].add_moves(game_state["turn"], game_state["board"], next_move)
       if self.debug:
         print(self.running_games[game_state["game"]["id"]])
 
@@ -104,7 +104,7 @@ class Server:
 
       self.running_games[game_state["game"]["id"]].add_end_state(game_state["board"], snake.get_history(), game_state["turn"])
       self.running_games[game_state["game"]["id"]].save(
-        f"{snake.__class__.__name__}_{datetime.now().strftime('%d.%m.%Y_%H%M%S')}_{game_state['game']['id']}.json",
+        f"{snake.__class__.__name__}_{datetime.now().strftime('%H-%M-%S')}_{game_state['game']['id']}.json",
         callback=json.dump, indent=2, ensure_ascii=False
       )
       del self.running_games[game_state["game"]["id"]]