Make queries great again

lib/db/manager.ex

@@ -8,12 +8,12 @@ defmodule DuckTag.DB.Manager do
 
   - `:wait_connect` - Waiting for all nodes to connect.
   - `:init_players` - Initialising players.
-  - `:init_respawn` - Initialising respawns.
+  - `:init_respawns` - Initialising respawns.
   - `:game_on` - Game is running.
   - `:stopped` - Game was stopped or finished.
   """
   @type game_status ::
-          :wait_connect | :init_players | :init_respawn | :wait_start | :game_on | :stopped
+          :wait_connect | :init_players | :init_respawns | :wait_start | :game_on | :stopped
 
   @typedoc """
   Player's status in the game:

lib/duck_tag.ex

@@ -38,30 +38,20 @@ defmodule DuckTag do
     Logger.debug("Resetting players...")
 
     Amnesia.transaction do
-      case GameDB.Player.select(
-             fun do
-               p -> p
-             end
-           ) do
-        nil ->
-          nil
+      selection =
+        GameDB.Player.select(
+          fun do
+            p -> p
+          end
+        )
 
-        selection ->
-          selection
-          |> Amnesia.Selection.values()
-          |> Enum.each(fn {_, id, name, status, score, last_respawn} ->
-            player = %GameDB.Player{
-              id: id,
-              name: name,
-              status: status,
-              score: score,
-              last_respawn: last_respawn
-            }
-
-            GameDB.Player.set_status(player, :alive)
-            GameDB.Player.set_score(player, 0)
-          end)
-      end
+      selection
+      |> Amnesia.Selection.coerce(GameDB.Player)
+      |> Amnesia.Selection.values()
+      |> Enum.each(fn player ->
+        GameDB.Player.set_status(player, :alive)
+        GameDB.Player.set_score(player, 0)
+      end)
     end
 
     Amnesia.transaction do
@@ -75,29 +65,17 @@ defmodule DuckTag do
   """
   def stop_game() do
     Amnesia.transaction do
-      case GameDB.Player.select(
-             fun do
-               p -> p
-             end
-           ) do
-        nil ->
-          nil
+      selection =
+        GameDB.Player.select(
+          fun do
+            p -> p
+          end
+        )
 
-        selection ->
-          selection
-          |> Amnesia.Selection.values()
-          |> Enum.each(fn {_, id, name, status, score, last_respawn} ->
-            player = %GameDB.Player{
-              id: id,
-              name: name,
-              status: status,
-              score: score,
-              last_respawn: last_respawn
-            }
-
-            GameDB.Player.set_status(player, :out)
-          end)
-      end
+      selection
+      |> Amnesia.Selection.coerce(GameDB.Player)
+      |> Amnesia.Selection.values()
+      |> Enum.each(&GameDB.Player.set_status(&1, :out))
     end
 
     Amnesia.transaction do

lib/duck_tag/tag_handler.ex

@@ -94,34 +94,32 @@ defmodule DuckTag.TagHandler do
   end
 
   def get_player_id(player_name) do
-    case GameDB.Player.select(
-           fun do
-             {_, id, name, _, _, _} when name == ^player_name -> id
-           end
-         ) do
-      nil -> nil
-      selection -> selection |> Amnesia.Selection.values() |> Enum.at(0, nil)
-    end
+    GameDB.Player.select(
+      fun do
+        {_, id, name, _, _, _} when name == ^player_name -> id
+      end
+    )
+    |> Amnesia.Selection.values()
+    |> Enum.at(0, nil)
   end
 
   def get_our_device(tag_id) do
-    case GameDB.Device.select(
-           fun do
-             {_, node, rfid, player_id, type} when rfid == ^tag_id ->
-               {node, rfid, player_id, type}
-           end
-         ) do
+    selection =
+      GameDB.Device.select(
+        fun do
+          {mod, node, rfid, player_id, type} when rfid == ^tag_id ->
+            {mod, node, rfid, player_id, type}
+        end
+      )
+
+    case Amnesia.Selection.coerce(selection, GameDB.Device)
+         |> Amnesia.Selection.values()
+         |> Enum.at(0, nil) do
       nil ->
         nil
 
-      selection ->
-        case Amnesia.Selection.values(selection) |> Enum.at(0, nil) do
-          nil ->
-            nil
-
-          {node, rfid, player_id, type} ->
-            %GameDB.Device{node: node, rfid: rfid, player_id: player_id, type: type}
-        end
+      device ->
+        device
     end
   end
 end