chore: release version v1.2.9

Persist the signature sort between sessions and header improvements

CHANGELOG.md

@@ -2,6 +2,57 @@
 
 <!-- changelog -->
 
+## [v1.2.9](https://github.com/wanderer-industries/wanderer/compare/v1.2.8...v1.2.9) (2024-10-07)
+
+
+
+
+## [v1.2.8](https://github.com/wanderer-industries/wanderer/compare/v1.2.7...v1.2.8) (2024-10-06)
+
+
+
+
+## [v1.2.7](https://github.com/wanderer-industries/wanderer/compare/v1.2.6...v1.2.7) (2024-10-05)
+
+
+
+
+## [v1.2.6](https://github.com/wanderer-industries/wanderer/compare/v1.2.5...v1.2.6) (2024-10-05)
+
+
+
+
+### Bug Fixes:
+
+* Core: Stability & performance improvements
+
+## [v1.2.5](https://github.com/wanderer-industries/wanderer/compare/v1.2.4...v1.2.5) (2024-10-04)
+
+
+
+
+### Bug Fixes:
+
+* Core: Add system "true security" correction
+
+## [v1.2.4](https://github.com/wanderer-industries/wanderer/compare/v1.2.3...v1.2.4) (2024-10-03)
+
+
+
+
+### Bug Fixes:
+
+* Map: Remove duplicate connections
+
+## [v1.2.3](https://github.com/wanderer-industries/wanderer/compare/v1.2.2...v1.2.3) (2024-10-02)
+
+
+
+
+### Bug Fixes:
+
+* Map: Fix map loading after select a different map.
+
 ## [v1.2.2](https://github.com/wanderer-industries/wanderer/compare/v1.2.1...v1.2.2) (2024-10-02)
 
 

assets/js/hooks/Mapper/common-styles/fixes.scss

@@ -67,3 +67,8 @@
   }
 }
 
+.p-sortable-column {
+  font-size: 12px;
+  font-weight: bold;
+  padding: 0.25rem 0.5rem;
+}

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/SystemSignaturesContent/SystemSignaturesContent.tsx

@@ -4,7 +4,7 @@ import { parseSignatures } from '@/hooks/Mapper/helpers';
 import { OutCommand } from '@/hooks/Mapper/types/mapHandlers.ts';
 import { WdTooltip, WdTooltipHandlers } from '@/hooks/Mapper/components/ui-kit';
 
-import { DataTable, DataTableRowMouseEvent } from 'primereact/datatable';
+import { DataTable, DataTableRowMouseEvent, SortOrder } from 'primereact/datatable';
 import { Column } from 'primereact/column';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import useRefState from 'react-usestateref';
@@ -25,6 +25,17 @@ import {
   renderName,
   renderTimeLeft,
 } from '@/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/renders';
+import useLocalStorageState from 'use-local-storage-state';
+
+type SystemSignaturesSortSettings = {
+  sortField: string;
+  sortOrder: SortOrder;
+}
+
+const SORT_DEFAULT_VALUES: SystemSignaturesSortSettings = {
+  sortField: 'eve_id',
+  sortOrder: 1
+};
 
 interface SystemSignaturesContentProps {
   systemId: string;
@@ -39,6 +50,10 @@ export const SystemSignaturesContent = ({ systemId, settings }: SystemSignatures
 
   const [hoveredSig, setHoveredSig] = useState<SystemSignature | null>(null);
 
+  const [sortSettings, setSortSettings] = useLocalStorageState<SystemSignaturesSortSettings>('window:signatures:sort', {
+    defaultValue: SORT_DEFAULT_VALUES,
+  });
+
   const tableRef = useRef<HTMLDivElement>(null);
   const compact = useMaxWidth(tableRef, 260);
   const medium = useMaxWidth(tableRef, 380);
@@ -178,7 +193,9 @@ export const SystemSignaturesContent = ({ systemId, settings }: SystemSignatures
             resizableColumns
             rowHover
             selectAll
-            showHeaders={false}
+            sortField={sortSettings.sortField}
+            sortOrder={sortSettings.sortOrder}
+            onSort={(event) => setSortSettings(() => ({ sortField: event.sortField, sortOrder: event.sortOrder }))}
             onRowMouseEnter={handleEnterRow}
             onRowMouseLeave={handleLeaveRow}
             rowClassName={row => {
@@ -206,12 +223,14 @@ export const SystemSignaturesContent = ({ systemId, settings }: SystemSignatures
               header="Id"
               bodyClassName="text-ellipsis overflow-hidden whitespace-nowrap"
               style={{ maxWidth: 72, minWidth: 72, width: 72 }}
+              sortable
             ></Column>
             <Column
               field="group"
               header="Group"
               bodyClassName="text-ellipsis overflow-hidden whitespace-nowrap"
               hidden={compact}
+              sortable
             ></Column>
             <Column
               field="name"
@@ -220,6 +239,7 @@ export const SystemSignaturesContent = ({ systemId, settings }: SystemSignatures
               body={renderName}
               style={{ maxWidth: nameColumnWidth }}
               hidden={compact || medium}
+              sortable
             ></Column>
             <Column
               field="updated_at"
@@ -227,6 +247,7 @@ export const SystemSignaturesContent = ({ systemId, settings }: SystemSignatures
               dataType="date"
               bodyClassName="w-[80px] text-ellipsis overflow-hidden whitespace-nowrap"
               body={renderTimeLeft}
+              sortable
             ></Column>
           </DataTable>
         </>

assets/js/hooks/Mapper/index.tsx

@@ -23,7 +23,7 @@ export default {
       onError: handleError,
     });
 
-    this.pushEvent('loaded');
+    this.pushEvent('ui_loaded');
   },
 
   handleEventWrapper(event: string, handler: (payload: any) => void) {

lib/wanderer_app/api/map_connection.ex

@@ -18,10 +18,7 @@ defmodule WandererApp.Api.MapConnection do
       action: :read
     )
 
-    define(:by_locations,
-      get_by: [:map_id, :solar_system_source, :solar_system_target],
-      action: :read
-    )
+    define(:by_locations, action: :read_by_locations)
 
     define(:read_by_map, action: :read_by_map)
     define(:get_link_pairs_advanced, action: :get_link_pairs_advanced)
@@ -47,6 +44,13 @@ defmodule WandererApp.Api.MapConnection do
       filter(expr(map_id == ^arg(:map_id)))
     end
 
+    read :read_by_locations do
+      argument(:map_id, :string, allow_nil?: false)
+      argument(:solar_system_source, :integer, allow_nil?: false)
+      argument(:solar_system_target, :integer, allow_nil?: false)
+      filter(expr(map_id == ^arg(:map_id) and solar_system_source == ^arg(:solar_system_source) and solar_system_target == ^arg(:solar_system_target)))
+    end
+
     read :get_link_pairs_advanced do
       argument(:map_id, :string, allow_nil?: false)
       argument(:include_mass_crit, :boolean, allow_nil?: false)

lib/wanderer_app/character/tracker_manager_impl.ex

@@ -68,13 +68,16 @@ defmodule WandererApp.Character.TrackerManager.Impl do
         state
 
       false ->
-        WandererApp.Character.update_character_state(character_id, %{opts: opts})
-        :telemetry.execute([:wanderer_app, :character, :tracker, :started], %{count: 1})
-
         Logger.debug(fn -> "Start character tracker: #{inspect(character_id)}" end)
 
-        tracked_characters = [character_id | state.characters] |> Enum.uniq()
+        Task.start_link(fn ->
+          WandererApp.Character.update_character_state(character_id, %{opts: opts})
+          :telemetry.execute([:wanderer_app, :character, :tracker, :started], %{count: 1})
 
+          :ok
+        end)
+
+        tracked_characters = [character_id | state.characters] |> Enum.uniq()
         WandererApp.Cache.insert("tracked_characters", tracked_characters)
 
         %{state | characters: tracked_characters}

lib/wanderer_app/eve_data_service.ex

@@ -229,7 +229,7 @@ defmodule WandererApp.EveDataService do
         constellation_id = row["constellationID"] |> Integer.parse() |> elem(0)
 
         {:ok, wormhole_class_id} =
-          _get_wormhole_class_id(
+          get_wormhole_class_id(
             map_location_wormhole_classes,
             region_id,
             constellation_id,
@@ -237,16 +237,16 @@ defmodule WandererApp.EveDataService do
           )
 
         {:ok, constellation_name} =
-          _get_constellation_name(map_constellations, constellation_id)
+          get_constellation_name(map_constellations, constellation_id)
 
-        {:ok, region_name} = _get_region_name(map_regions, region_id)
+        {:ok, region_name} = get_region_name(map_regions, region_id)
 
-        {:ok, wormhole_class} = _get_wormhole_class(wormhole_classes, wormhole_class_id)
+        {:ok, wormhole_class} = get_wormhole_class(wormhole_classes, wormhole_class_id)
 
-        {:ok, security} = _get_security(row["security"])
+        {:ok, security} = get_security(row["security"])
 
         {:ok, class_title} =
-          _get_class_title(
+          get_class_title(
             wormhole_classes_info,
             wormhole_class_id,
             security,
@@ -270,7 +270,7 @@ defmodule WandererApp.EveDataService do
           solar_system_id: solar_system_id,
           solar_system_name: row["solarSystemName"],
           solar_system_name_lc: row["solarSystemName"] |> String.downcase(),
-          sun_type_id: _get_sun_type_id(row["sunTypeID"]),
+          sun_type_id: get_sun_type_id(row["sunTypeID"]),
           constellation_name: constellation_name,
           region_name: region_name,
           security: security,
@@ -279,8 +279,8 @@ defmodule WandererApp.EveDataService do
           type_description: wormhole_class.title,
           is_shattered: is_shattered
         }
-        |> _get_wormhole_data(wormhole_systems, solar_system_id, wormhole_class)
-        |> _get_triglavian_data(triglavian_systems, solar_system_id)
+        |> get_wormhole_data(wormhole_systems, solar_system_id, wormhole_class)
+        |> get_triglavian_data(triglavian_systems, solar_system_id)
       end
     )
   end
@@ -332,14 +332,14 @@ defmodule WandererApp.EveDataService do
     )
   end
 
-  defp _get_sun_type_id(sun_type_id) do
+  defp get_sun_type_id(sun_type_id) do
     case sun_type_id do
       "None" -> 0
       _ -> sun_type_id |> Integer.parse() |> elem(0)
     end
   end
 
-  defp _get_wormhole_data(default_data, wormhole_systems, solar_system_id, wormhole_class) do
+  defp get_wormhole_data(default_data, wormhole_systems, solar_system_id, wormhole_class) do
     case Enum.find(wormhole_systems, fn system -> system.solar_system_id == solar_system_id end) do
       nil ->
         default_data
@@ -355,7 +355,7 @@ defmodule WandererApp.EveDataService do
     end
   end
 
-  defp _get_triglavian_data(default_data, triglavian_systems, solar_system_id) do
+  defp get_triglavian_data(default_data, triglavian_systems, solar_system_id) do
     case Enum.find(triglavian_systems, fn system -> system.solar_system_id == solar_system_id end) do
       nil ->
         default_data
@@ -370,14 +370,18 @@ defmodule WandererApp.EveDataService do
     end
   end
 
-  defp _get_security(security) do
+  defp get_security(security) do
     case security do
       nil -> {:ok, ""}
-      _ -> {:ok, Decimal.parse(security) |> elem(0) |> Decimal.round(1) |> Decimal.to_string()}
+      _ -> {:ok, String.to_float(security) |> get_true_security() |> Float.to_string(decimals: 1)}
     end
   end
 
-  defp _get_class_title(wormhole_classes_info, wormhole_class_id, security, wormhole_class) do
+  defp get_true_security(security) when is_float(security) and security > 0.0 and security < 0.05, do: security |> Float.ceil(1)
+
+  defp get_true_security(security) when is_float(security), do: security |> Float.floor(1)
+
+  defp get_class_title(wormhole_classes_info, wormhole_class_id, security, wormhole_class) do
     case wormhole_class_id in [
            wormhole_classes_info.names["hs"],
            wormhole_classes_info.names["ls"],
@@ -391,7 +395,7 @@ defmodule WandererApp.EveDataService do
     end
   end
 
-  defp _get_constellation_name(constellations, constellation_id) do
+  defp get_constellation_name(constellations, constellation_id) do
     case Enum.find(constellations, fn constellation ->
            constellation.constellation_id == constellation_id
          end) do
@@ -400,24 +404,24 @@ defmodule WandererApp.EveDataService do
     end
   end
 
-  defp _get_region_name(regions, region_id) do
+  defp get_region_name(regions, region_id) do
     case Enum.find(regions, fn region -> region.region_id == region_id end) do
       nil -> {:ok, ""}
       region -> {:ok, region.region_name}
     end
   end
 
-  defp _get_wormhole_class(wormhole_classes, wormhole_class_id) do
+  defp get_wormhole_class(wormhole_classes, wormhole_class_id) do
     {:ok,
      Enum.find(wormhole_classes, fn wormhole_class ->
        wormhole_class.wormhole_class_id == wormhole_class_id
      end)}
   end
 
-  defp _get_wormhole_class_id(_systems, _region_id, _constellation_id, 30_100_000),
+  defp get_wormhole_class_id(_systems, _region_id, _constellation_id, 30_100_000),
     do: {:ok, 10_100}
 
-  defp _get_wormhole_class_id(systems, region_id, constellation_id, solar_system_id) do
+  defp get_wormhole_class_id(systems, region_id, constellation_id, solar_system_id) do
     with region <-
            Enum.find(systems, fn system ->
              system.location_id |> Integer.parse() |> elem(0) == region_id
@@ -430,23 +434,23 @@ defmodule WandererApp.EveDataService do
            Enum.find(systems, fn system ->
              system.location_id |> Integer.parse() |> elem(0) == solar_system_id
            end),
-         wormhole_class_id <- _get_wormhole_class_id(region, constellation, solar_system) do
+         wormhole_class_id <- get_wormhole_class_id(region, constellation, solar_system) do
       {:ok, wormhole_class_id}
     else
       _ -> {:ok, -1}
     end
   end
 
-  defp _get_wormhole_class_id(_region, _constellation, solar_system)
+  defp get_wormhole_class_id(_region, _constellation, solar_system)
        when not is_nil(solar_system),
        do: solar_system.wormhole_class_id |> Integer.parse() |> elem(0)
 
-  defp _get_wormhole_class_id(_region, constellation, _solar_system)
+  defp get_wormhole_class_id(_region, constellation, _solar_system)
        when not is_nil(constellation),
        do: constellation.wormhole_class_id |> Integer.parse() |> elem(0)
 
-  defp _get_wormhole_class_id(region, _constellation, _solar_system) when not is_nil(region),
+  defp get_wormhole_class_id(region, _constellation, _solar_system) when not is_nil(region),
     do: region.wormhole_class_id |> Integer.parse() |> elem(0)
 
-  defp _get_wormhole_class_id(_region, _constellation, _solar_system), do: -1
+  defp get_wormhole_class_id(_region, _constellation, _solar_system), do: -1
 end

lib/wanderer_app/map/map_manager.ex

@@ -10,8 +10,8 @@ defmodule WandererApp.Map.Manager do
   alias WandererApp.Map.Server
   alias WandererApp.Map.ServerSupervisor
 
-  @maps_start_per_second 100
-  @maps_start_interval 1500
+  @maps_start_per_second 5
+  @maps_start_interval 1000
   @maps_queue :maps_queue
   @garbage_collection_interval :timer.hours(1)
   @check_maps_queue_interval :timer.seconds(1)

lib/wanderer_app/map/map_server_impl.ex

@@ -177,37 +177,45 @@ defmodule WandererApp.Map.Server.Impl do
     do: {:ok, map_id |> WandererApp.Map.list_characters()}
 
   def add_character(%{map_id: map_id} = state, %{id: character_id} = character, track_character) do
-    with :ok <- map_id |> WandererApp.Map.add_character(character),
-         {:ok, _} <-
-           WandererApp.MapCharacterSettingsRepo.create(%{
-             character_id: character_id,
-             map_id: map_id,
-             tracked: track_character
-           }),
-         {:ok, character} <- WandererApp.Character.get_character(character_id) do
-      broadcast!(map_id, :character_added, character)
+    Task.start_link(fn ->
+      with :ok <- map_id |> WandererApp.Map.add_character(character),
+           {:ok, _} <-
+             WandererApp.MapCharacterSettingsRepo.create(%{
+               character_id: character_id,
+               map_id: map_id,
+               tracked: track_character
+             }),
+           {:ok, character} <- WandererApp.Character.get_character(character_id) do
+        broadcast!(map_id, :character_added, character)
 
-      :telemetry.execute([:wanderer_app, :map, :character, :added], %{count: 1})
+        :telemetry.execute([:wanderer_app, :map, :character, :added], %{count: 1})
 
-      state
-    else
-      {:error, _error} ->
-        state
-    end
+        :ok
+      else
+        {:error, _error} ->
+          :ok
+      end
+    end)
+
+    state
   end
 
   def remove_character(%{map_id: map_id} = state, character_id) do
-    with :ok <- WandererApp.Map.remove_character(map_id, character_id),
-         {:ok, character} <- WandererApp.Character.get_character(character_id) do
-      broadcast!(map_id, :character_removed, character)
+    Task.start_link(fn ->
+      with :ok <- WandererApp.Map.remove_character(map_id, character_id),
+           {:ok, character} <- WandererApp.Character.get_character(character_id) do
+        broadcast!(map_id, :character_removed, character)
 
-      :telemetry.execute([:wanderer_app, :map, :character, :removed], %{count: 1})
+        :telemetry.execute([:wanderer_app, :map, :character, :removed], %{count: 1})
 
-      state
-    else
-      {:error, _error} ->
-        state
-    end
+        :ok
+      else
+        {:error, _error} ->
+          :ok
+      end
+    end)
+
+    state
   end
 
   def untrack_characters(%{map_id: map_id} = state, characters_ids) do
@@ -357,17 +365,7 @@ defmodule WandererApp.Map.Server.Impl do
     connections_to_remove
     |> Enum.each(fn connection ->
       @logger.debug(fn -> "Removing connection from map: #{inspect(connection)}" end)
-
-      connection
-      |> WandererApp.MapConnectionRepo.destroy!()
-      |> case do
-        :ok ->
-          :ok
-
-        {:error, error} ->
-          @logger.error("Failed to remove connection from map: #{inspect(error, pretty: true)}")
-          :ok
-      end
+      WandererApp.MapConnectionRepo.destroy(map_id, connection)
     end)
 
     @ddrt.delete(removed_ids, rtree_name)
@@ -1567,8 +1565,7 @@ defmodule WandererApp.Map.Server.Impl do
            old_location.solar_system_id
          ) do
       {:ok, connection} ->
-        connection
-        |> WandererApp.MapConnectionRepo.destroy!()
+        :ok = WandererApp.MapConnectionRepo.destroy(map_id, connection)
 
         broadcast!(map_id, :remove_connections, [connection])
         map_id |> WandererApp.Map.remove_connection(connection)

lib/wanderer_app/repositories/map_connection_repo.ex

@@ -1,12 +1,60 @@
 defmodule WandererApp.MapConnectionRepo do
   use WandererApp, :repository
 
+  require Logger
+
+  @logger Application.compile_env(:wanderer_app, :logger)
+
   def get_by_map(map_id),
     do: WandererApp.Api.MapConnection.read_by_map(%{map_id: map_id})
 
+  def get_by_locations(map_id, solar_system_source, solar_system_target) do
+    WandererApp.Api.MapConnection.by_locations(%{map_id: map_id, solar_system_source: solar_system_source, solar_system_target: solar_system_target})
+    |> case do
+      {:ok, connections} ->
+        {:ok, connections}
+
+      {:error, %Ash.Error.Query.NotFound{}} ->
+        {:ok, []}
+
+      {:error, error} ->
+        @logger.error("Failed to get connections: #{inspect(error, pretty: true)}")
+        {:error, error}
+    end
+  end
+
   def create!(connection), do: connection |> WandererApp.Api.MapConnection.create!()
 
-  def destroy!(connection), do: connection |> WandererApp.Api.MapConnection.destroy!()
+  def destroy(map_id, connection) do
+    {:ok, from_connections} = get_by_locations(map_id, connection.solar_system_source, connection.solar_system_target)
+    {:ok, to_connections} = get_by_locations(map_id, connection.solar_system_target, connection.solar_system_source)
+
+    [from_connections ++ to_connections]
+    |> List.flatten()
+    |> bulk_destroy!()
+    |> case do
+      :ok ->
+        :ok
+
+      error ->
+        @logger.error("Failed to remove connections from map: #{inspect(error, pretty: true)}")
+        :ok
+    end
+  end
+
+  def destroy!(connection), do:
+    connection |> WandererApp.Api.MapConnection.destroy!()
+
+  def bulk_destroy!(connections) do
+    connections
+    |> WandererApp.Api.MapConnection.destroy!()
+    |> case do
+      %Ash.BulkResult{status: :success} ->
+        :ok
+      error ->
+        error
+    end
+  end
 
   def update_time_status(connection, update),
     do:

lib/wanderer_app_web/live/maps/map_live.ex

@@ -45,7 +45,7 @@ defmodule WandererAppWeb.MapLive do
          deleted: false
        } = map} ->
 
-        Process.send_after(self(), {:init_map, map}, 100)
+        Process.send_after(self(), {:init_map, map}, 10)
 
         socket
         |> assign(
@@ -114,7 +114,7 @@ defmodule WandererAppWeb.MapLive do
           }
         } = socket
       ) do
-    Task.async(fn -> _on_map_started(map_id, current_user, user_permissions) end)
+    _on_map_started(map_id, current_user, user_permissions)
 
     {:noreply, socket}
   end
@@ -386,17 +386,17 @@ defmodule WandererAppWeb.MapLive do
               page_title: map_name,
               user_permissions: user_permissions,
               tracked_character_ids: tracked_character_ids
-            }}, 100)
+            }}, 10)
 
         only_tracked_characters and can_track? and not all_character_tracked? ->
-          Process.send_after(self(), :not_all_characters_tracked, 100)
+          Process.send_after(self(), :not_all_characters_tracked, 10)
 
         true ->
-          Process.send_after(self(), :no_permissions, 100)
+          Process.send_after(self(), :no_permissions, 10)
       end
     else
       _ ->
-        Process.send_after(self(), :no_access, 100)
+        Process.send_after(self(), :no_access, 10)
     end
 
     {:noreply, socket}
@@ -404,13 +404,6 @@ defmodule WandererAppWeb.MapLive do
 
   def handle_info({:map_init, %{map_id: map_id} = initial_data}, socket) do
     Phoenix.PubSub.subscribe(WandererApp.PubSub, map_id)
-    WandererApp.Map.Manager.start_map(map_id)
-
-    {:ok, map_started} = WandererApp.Cache.lookup("map_#{map_id}:started", false)
-
-    if map_started do
-      Process.send_after(self(), %{event: :map_started}, 100)
-    end
 
     {:noreply,
       socket
@@ -464,7 +457,7 @@ defmodule WandererAppWeb.MapLive do
         map_id: map_id,
         user_characters: user_character_eve_ids,
         initial_data: initial_data
-      }}, 100)
+      }}, 10)
 
     {:noreply, socket}
   end
@@ -567,7 +560,15 @@ defmodule WandererAppWeb.MapLive do
   def handle_info(_event, socket), do: {:noreply, socket}
 
   @impl true
-  def handle_event("loaded", _body, socket) do
+  def handle_event("ui_loaded", _body, %{assigns: %{map_id: map_id}} = socket) do
+    {:ok, map_started} = WandererApp.Cache.lookup("map_#{map_id}:started", false)
+
+    if map_started do
+      Process.send_after(self(), %{event: :map_started}, 10)
+    else
+      WandererApp.Map.Manager.start_map(map_id)
+    end
+
     {:noreply, socket}
   end
 
@@ -577,7 +578,8 @@ defmodule WandererAppWeb.MapLive do
   end
 
   @impl true
-  def handle_event("change_map", %{"map_slug" => map_slug} = _event, socket) do
+  def handle_event("change_map", %{"map_slug" => map_slug} = _event, %{assigns: %{map_id: map_id}} = socket) do
+    Phoenix.PubSub.unsubscribe(WandererApp.PubSub, map_id)
     {:noreply, push_navigate(socket, to: ~p"/#{map_slug}")}
   end
 
@@ -1564,16 +1566,23 @@ defmodule WandererAppWeb.MapLive do
           )
           |> Map.put(:reset, true)
 
-        {:map_started_data,
-         %{
-           map_id: map_id,
-           user_characters: user_character_eve_ids,
-           initial_data: initial_data,
-           events: events
-         }}
+        Process.send_after(self(), {:map_start, %{
+          map_id: map_id,
+          user_characters: user_character_eve_ids,
+          initial_data: initial_data,
+          events: events
+        }}, 10)
+        # {:map_started_data,
+        #  %{
+        #    map_id: map_id,
+        #    user_characters: user_character_eve_ids,
+        #    initial_data: initial_data,
+        #    events: events
+        #  }}
 
       _ ->
-        {:map_error, :no_access}
+        Process.send_after(self(), {:map_error, :no_access}, 10)
+
     end
   end
 
@@ -2079,13 +2088,14 @@ defmodule WandererAppWeb.MapLive do
     :ok = WandererApp.Character.TrackerManager.start_tracking(character_id)
   end
 
-  defp _push_map_event(socket, type, event_body),
-    do:
+  defp _push_map_event(socket, type, event_body)
+    do
       socket
       |> push_event("map_event", %{
         type: type,
         body: event_body |> WandererApp.Utils.JSONUtil.compress()
       })
+    end
 
   defp map_id(%{assigns: %{map_id: map_id}} = _socket), do: map_id
 end

lib/wanderer_app_web/live/maps/map_live.html.heex

@@ -2,9 +2,10 @@
   id="map-loader"
   data-loading={show_loader("map-loader")}
   data-loaded={hide_loader("map-loader")}
-  class="!z-100 absolute w-screen h-screen bg-transparent hidden"
+  class="!z-100 w-screen h-screen hidden relative"
 >
-  <div class="flex w-full h-full items-center justify-center">
+  <div class="hs-overlay-backdrop transition duration absolute inset-0 blur" />
+  <div class="flex !z-[150] w-full h-full items-center justify-center">
     <div class="Loader" data-text="Wanderer">
       <span class="Loader__Circle"></span>
       <span class="Loader__Circle"></span>
@@ -12,6 +13,8 @@
       <span class="Loader__Circle"></span>
     </div>
   </div>
+
+
 </div>
 
 <div class="w-full h-full" id="mapper" phx-hook="Mapper" phx-update="ignore"></div>

mix.exs

@@ -2,7 +2,7 @@ defmodule WandererApp.MixProject do
   use Mix.Project
 
   @source_url "https://github.com/wanderer-industries/wanderer"
-  @version "1.2.2"
+  @version "1.2.9"
 
   def project do
     [