Game loading completed

src/Go.cr

@@ -8,70 +8,94 @@ require "sqlite3"
 URL = "localhost"
 PORT = "3000"
 GAME_CACHE = {} of String => Go::Game
-
+GAME_SAVE  = "./game_saves.db"
 
 def save_game(db, gameid, game)
-    puts "Saving"
-    puts game.encode
+    # Function: save_game
+    # Parameters: db(String)[Unused] gameid(String) game(Go::Game)
     turn, size, white_pass, black_pass, board = game.encode
-    DB.open "sqlite3:./game_saves.db" do |db|
-        # TODO: Table creation function
-        # Creates table
-        db.exec "create table game_saves (gameid integer, turn integer, size integer, white_pass string, black_pass string, board string )"
-        db.exec "insert into game_saves values (?, ?, ?, ?, ?, ?)", gameid, turn.value, size, white_pass, black_pass, board
+    DB.open "sqlite3:./#{GAME_SAVE}" do |db|
+        # Create table if one does not exist, gameid is UNIQUE => No duplicates
+        db.exec "create table if not exists game_saves (gameid string, turn integer, size integer, white_pass string, black_pass string, board string, UNIQUE(gameid) )"
+        # If duplicate => replace values, else => make new row for gameid
+        db.exec "insert or replace into game_saves values (?, ?, ?, ?, ?, ?)", gameid, turn.value, size, white_pass, black_pass, board
     end
 end
 
 def query_game(db, gameid) : Go::Game?
+    # Function: query_game
+    # Parameters: db(String)[Unused] gameid(String)
+    turn       = 0
     size       = Go::Size::Small 
     white_pass = ""
     black_pass = ""
     board      = ""
-    turn       = ""
-
-    DB.open "sqlite3:./game_saves.db" do |db|
-        puts "Saves:"
-        db.query "select gameid, turn, size, white_pass, black_pass, board from game_saves where gameid = #{gameid}" do |rs|
+    begin 
+    DB.open "sqlite3:./#{GAME_SAVE}" do |db|
+        # Query whole row where the gameid is found
+        db.query "SELECT * FROM game_saves WHERE gameid = ?", gameid do |rs|
             rs.each do
-                id         = rs.read(Int32)
-
+                id         = rs.read(String) # Reduntant
                 turn       = rs.read(Int32)
                 size       = rs.read(Int32)
                 white_pass = rs.read(String)
                 black_pass = rs.read(String)
                 board      = rs.read(String)
-                puts turn
             end
         end
       end
-
-    game            = Go::Game.new()
-    game.size       = Go::Size.from_value(size)
-    game.white_pass = white_pass
-    game.black_pass = black_pass
-    # Todo: Parse game board string
-    # game.board      = 
-    game.turn       = Go::Color.from_value(turn)
-    # Todo: Fix return type mismatch
-    # return game
-    return nil
+        # New Go::Game object
+        game            = Go::Game.new()
+        game.size       = Go::Size.from_value(size)
+        game.white_pass = white_pass
+        game.black_pass = black_pass
+        game.turn       = Go::Color.from_value(turn)
+        # Parses game board string
+        counter = 0
+        # For each character in the board String
+        board.each_char do |char|
+            x = counter % 9
+            y = counter / 9
+            coord = {x.to_i8, y.to_i8}
+            if(char == 'B')
+                game.board[coord] = Go::Color::Black
+            elsif(char == 'W')
+                game.board[coord] = Go::Color::White
+            end
+            counter += 1
+        end
+    rescue
+        # Catch bad query
+        puts "DB query Failed"
+        return nil
+    end
+    # Finished Go::Game object to return
+    return game
 end
 
 def lookup_game(db, cache, id) : Go::Game?
+    # Function: lookup_game
+    # Parameters: db(String)[Unused] cache({(String), (Go::Game)}) id(String)
     if game = cache[id]?
         return game
     else
         loaded_game = query_game(db, id)
-        cache[id] = loaded_game if loaded_game
+        # Need to convert id to string for some reason
+        cache[id.to_s] = loaded_game if loaded_game
         return loaded_game
     end
 end
 
 def create_game(db, cache, game, id)
+    # Function: create_game
+    # Parameters: db(String)[Unused] cache({(String), (Go::Game)}) game(Go::Game) id(String)
     cache[id] = game
 end
 
 def handle_message(id, game, socket, message)
+    # Function: handle_message
+    # Parameters: id(String) game(Go::Game) socket() message()
+    
     split_command = message.split(" ")
     command = split_command[0]
     if command == "place"
@@ -89,10 +113,13 @@ get "/" do |env|
 end
 
 get "/save" do |env|
-    #game = Go::Game.new(Go::Size::Small, "asdf", "sadfasdf")
-    #save_game(db, 0, game)
+    GAME_CACHE.each do |game_hash|
+        gameid, game = game_hash
+        save_game("none", gameid, game) 
+    end
 end
 
+
 post "/game" do |env|
     game_id = env.params.body["id"]?
     game_password = env.params.body["password"]?
@@ -169,14 +196,4 @@ ws "/game/:id" do |socket, env|
     end
 end
 
-def test_save()
-    puts "test"
-    game = Go::Game.new(Go::Size::Small, "asdf", "sadfasdf")
-    
-    save_game("none", 1, game)
-    query_game("none", 1)
-end
-
-
-test_save()
 Kemal.run