Hopefully fix lingering games

.dir-locals.el

@@ -1 +1 @@
-((elixir-mode . ((lsp-elixir-project-dir . "web/"))))
+((elixir-ts-mode . ((lsp-elixir-project-dir . "web/"))))

web/.formatter.exs

@@ -24,5 +24,6 @@
     consumes: 1
   ],
   import_deps: [:phoenix, :typed_struct],
-  inputs: ["*.{ex,exs}", "{config,lib,test}/**/*.{ex,exs}"]
+  inputs: ["*.{ex,exs}", "{config,lib,test}/**/*.{ex,exs}"],
+  plugins: [Phoenix.LiveView.HTMLFormatter]
 ]

web/.gitignore

@@ -35,3 +35,5 @@ priv/static/
 priv/native/
 
 native/matrix/target/
+
+.direnv/

web/flake.nix

@@ -2,6 +2,7 @@
   description = "Dev deps for stuff";
 
   inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
     flake-utils.url = "github:numtide/flake-utils";
     fenix.url = "github:nix-community/fenix";
   };
@@ -18,10 +19,11 @@
             nodejs
             yarn
             rustComponents
-            beam.packages.erlangR25.elixir_1_14
             beam.packages.erlang.rebar3
-            beam.packages.erlangR25.hex
-            erlangR25
+            beam.packages.erlang.hex
+            beam.packages.erlang.erlang
+            beam.packages.erlang.elixir
+            elixir-ls
             git
           ];
       in

web/lib/infolab_light_games/application.ex

@@ -6,30 +6,39 @@ defmodule InfolabLightGames.Application do
   use Application
 
   def start(_type, _args) do
-    children = [
-      # Start the Telemetry supervisor
-      InfolabLightGamesWeb.Telemetry,
-      # Start the PubSub system
-      {Phoenix.PubSub, name: InfolabLightGames.PubSub},
-      # Start the Endpoint (http/https)
-      Presence,
-      InfolabLightGamesWeb.Endpoint,
-      # Start a worker by calling: InfolabLightGames.Worker.start_link(arg)
-      # {InfolabLightGames.Worker, arg}
-      GameSupervisor,
-      Screen,
-      Coordinator,
-      Bans,
-      MatrixPow,
-      Scheduler
-    ]
+    children =
+      [
+        # Start the Telemetry supervisor
+        InfolabLightGamesWeb.Telemetry,
+        # Start the PubSub system
+        {Phoenix.PubSub, name: InfolabLightGames.PubSub},
+        # Start the Endpoint (http/https)
+        Presence,
+        InfolabLightGamesWeb.Endpoint
+        # Start a worker by calling: InfolabLightGames.Worker.start_link(arg)
+        # {InfolabLightGames.Worker, arg}
+      ] ++
+        if in_phoenix?(),
+          do: [
+            GameSupervisor,
+            Screen,
+            Coordinator,
+            Bans,
+            MatrixPow,
+            Scheduler
+          ],
+          else: []
 
     # See https://hexdocs.pm/elixir/Supervisor.html
     # for other strategies and supported options
     opts = [strategy: :one_for_one, name: InfolabLightGames.Supervisor]
     Supervisor.start_link(children, opts)
   end
 
+  defp in_phoenix?() do
+    Application.get_env(:phoenix, :serve_endpoints)
+  end
+
   # Tell Phoenix to update the endpoint configuration
   # whenever the application is updated.
   def config_change(changed, _new, removed) do

web/lib/infolab_light_games/coordinator.ex

@@ -34,24 +34,33 @@ defmodule Coordinator do
   end
 
   @impl true
-  def handle_cast({:terminate, id}, state) do
-    GenServer.stop(via_tuple(id))
+  def handle_info({:force_kill_game, id}, %State{} = state) do
+    try_stop(via_tuple(id))
 
-    state = handle_terminated_game(id, state)
+    {:noreply, handle_terminated_game(id, state)}
+  end
+
+  @impl true
+  def handle_info({:force_kill_idle_animation, pid}, %State{} = state) do
+    try_stop(pid)
 
     {:noreply, state}
   end
 
   @impl true
-  def handle_cast(:terminate_idle_animation, %State{} = state) do
-    if !is_nil(state.current_idle_animation) and GenServer.whereis(state.current_idle_animation) do
-      GenServer.stop(state.current_idle_animation)
-    end
+  def handle_cast({:idle_animation_terminated, id}, %State{} = state) do
+    state =
+      if state.current_idle_animation == via_tuple(id) do
+        %State{state | current_idle_animation: nil}
+      else
+        state
+      end
 
-    {:noreply, state}
+    {:noreply, state, {:continue, :tick}}
   end
 
-  def handle_cast({:terminated, id}, state) do
+  @impl true
+  def handle_cast({:game_terminated, id}, %State{} = state) do
     state = handle_terminated_game(id, state)
 
     Phoenix.PubSub.broadcast!(
@@ -66,17 +75,33 @@ defmodule Coordinator do
   end
 
   @impl true
-  def handle_cast({:terminated_idle_animation, id}, %State{} = state) do
-    Logger.info("Idle animation quit #{id}")
+  def handle_cast({:terminate, id}, state) do
+    try do
+      pid = via_tuple(id)
+      GenServer.cast(pid, :terminate)
 
-    state =
-      if state.current_idle_animation == via_tuple(id) do
-        %State{state | current_idle_animation: nil}
-      else
-        state
+      Process.send_after(self(), {:force_kill_game, id}, 5_000)
+    catch
+      _ -> :ok
+    end
+
+    {:noreply, state}
+  end
+
+  @impl true
+  def handle_cast(:terminate_idle_animation, %State{} = state) do
+    if !is_nil(state.current_idle_animation) do
+      try do
+        pid = state.current_idle_animation
+        GenServer.cast(pid, :terminate)
+
+        Process.send_after(self(), {:force_kill_idle_animation, pid}, 5_000)
+      catch
+        _ -> :ok
       end
+    end
 
-    {:noreply, state, {:continue, :tick}}
+    {:noreply, state}
   end
 
   @impl true
@@ -94,7 +119,16 @@ defmodule Coordinator do
 
     opts = meta ++ [game_id: id, name: via_tuple(id)]
 
-    {:ok, _pid} = DynamicSupervisor.start_child(GameManager, {game, opts})
+    {:ok, pid} = DynamicSupervisor.start_child(GameManager, {game, opts})
+
+    Task.start_link(fn ->
+      ref = Process.monitor(pid)
+
+      receive do
+        {:DOWN, ^ref, :process, ^pid, _reason} ->
+          GenServer.cast(__MODULE__, {:game_terminated, id})
+      end
+    end)
 
     :ok = GenServer.call(via_tuple(id), {:add_player, initial_player})
 
@@ -184,7 +218,7 @@ defmodule Coordinator do
       # stop, otherwise if there's no idle animation we can start the game
       if state.current_idle_animation do
         Logger.info("Requesting idle animation quits")
-        GenServer.cast(state.current_idle_animation, :terminate)
+        terminate_idle_animation()
       else
         GenServer.call(state.current_game, :start_if_ready)
       end
@@ -205,9 +239,9 @@ defmodule Coordinator do
   defp start_idle_animation(%State{} = state, module, mode) do
     Logger.info("Starting idle animation #{module}:#{inspect(mode)}")
     # stop the idle animation if it exists
-    if !is_nil(state.current_idle_animation) and GenServer.whereis(state.current_idle_animation) do
+    if !is_nil(state.current_idle_animation) do
       # we need the idle animation to stop immediately so it doesn't try to draw over us
-      GenServer.stop(state.current_idle_animation)
+      try_stop(state.current_idle_animation)
     end
 
     id = random_id()
@@ -218,6 +252,15 @@ defmodule Coordinator do
         {module, game_id: id, name: via_tuple(id), mode: mode}
       )
 
+    Task.start_link(fn ->
+      ref = Process.monitor(pid)
+
+      receive do
+        {:DOWN, ^ref, :process, ^pid, _reason} ->
+          GenServer.cast(__MODULE__, {:idle_animation_terminated, id})
+      end
+    end)
+
     {%State{state | current_idle_animation: via_tuple(id)}, pid}
   end
 
@@ -300,6 +343,12 @@ defmodule Coordinator do
     {:via, Registry, {GameRegistry, id}}
   end
 
+  defp try_stop(pid) do
+    if GenServer.whereis(pid) do
+      GenServer.stop(pid)
+    end
+  end
+
   def terminate_game(id) do
     Logger.info("terminating game #{id}")
     GenServer.cast(__MODULE__, {:terminate, id})
@@ -309,14 +358,6 @@ defmodule Coordinator do
     GenServer.cast(__MODULE__, :terminate_idle_animation)
   end
 
-  def notify_game_terminated(id) do
-    GenServer.cast(__MODULE__, {:terminated, id})
-  end
-
-  def notify_idle_animation_terminated(id) do
-    GenServer.cast(__MODULE__, {:terminated_idle_animation, id})
-  end
-
   def route_input(player, input) do
     GenServer.cast(__MODULE__, {:route_input, player, input})
   end

web/lib/infolab_light_games/games/pong.ex

@@ -182,11 +182,6 @@ defmodule Games.Pong do
     end
   end
 
-  @impl true
-  def terminate(_reason, state) do
-    Coordinator.notify_game_terminated(state.id)
-  end
-
   defp tick(state) do
     {dx, dy} = state.ball_vel
 

web/lib/infolab_light_games/games/snake.ex

@@ -168,11 +168,6 @@ defmodule Games.Snake do
     end
   end
 
-  @impl true
-  def terminate(_reason, state) do
-    Coordinator.notify_game_terminated(state.id)
-  end
-
   defp tick(%State{} = state) do
     state =
       state