renamed the namespace

Renamed the namespace
added a popup for when the user forgets to input their project settings

Assets/Scripts/GameLobby/Auth/Identity.cs

 using System;
 using System.Collections.Generic;
 
-namespace LobbyRelaySample.Auth
+namespace GamelobbySample.Auth
 {
     /// <summary>
     /// Represents some provider of credentials.

Assets/Scripts/GameLobby/Auth/NameGenerator.cs

 using System;
 using System.Text;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Just for fun, give a cute default player name if no name is provided, based on a hash of their anonymous ID.

Assets/Scripts/GameLobby/Auth/SubIdentity_Authentication.cs

 using Unity.Services.Authentication;
 using Unity.Services.Core;
 
-namespace LobbyRelaySample.Auth
+namespace GamelobbySample.Auth
 {
     /// <summary>
     /// The Authentication package will sign in asynchronously and anonymously. When complete, we will need to store the generated ID.
 
         private async void DoSignIn(Action onSigninComplete)
         {
-            await UnityServices.InitializeAsync();
-            AuthenticationService.Instance.SignedIn += OnSignInChange;
-            AuthenticationService.Instance.SignedOut += OnSignInChange;
+            try
+            {
+                await UnityServices.InitializeAsync();
+                AuthenticationService.Instance.SignedIn += OnSignInChange;
+                AuthenticationService.Instance.SignedOut += OnSignInChange;
-            try
-            {   if (!AuthenticationService.Instance.IsSignedIn)
+                if (!AuthenticationService.Instance.IsSignedIn)
-            {   UnityEngine.Debug.LogError("Failed to login. Did you remember to set your Project ID under Services > General Settings?");
+            {
+                Locator.Get.Messenger.OnReceiveMessage(MessageType.DisplayErrorPopup, "Authentication Failed: Project ID not set in Project Settings >  Services > General Settings?");
+                UnityEngine.Debug.LogError("Authentication Failed: Project ID not set in Project Settings >  Services > General Settings?");
                 throw;
             }
 

Assets/Scripts/GameLobby/Game/Countdown.cs

 using System;
 using UnityEngine;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Runs the countdown to the in-game state. While the start of the countdown is synced via Relay, the countdown itself is handled locally,

Assets/Scripts/GameLobby/Game/EmoteType.cs

-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     public enum EmoteType { None = 0, Smile, Frown, Unamused, Tongue }
 

Assets/Scripts/GameLobby/Game/GameManager.cs

-using LobbyRelaySample.relay;
+using GamelobbySample.relay;
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Sets up and runs the entire sample.

Assets/Scripts/GameLobby/Game/LobbyServiceData.cs

 using System.Collections.Generic;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Used when displaying the lobby list, to indicate when we are awaiting an updated lobby query.

Assets/Scripts/GameLobby/Game/LobbyServiceDataObserver.cs

-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Holds a LobbyServiceData value and notifies all subscribers when it has been changed.

Assets/Scripts/GameLobby/Game/LobbyUser.cs

 using System;
 using UnityEngine;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Current state of the user in the lobby.

Assets/Scripts/GameLobby/Game/LobbyUserAudio.cs

 using UnityEngine;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     [SerializeField]
     public class LobbyUserAudio

Assets/Scripts/GameLobby/Game/LobbyUserObserver.cs

-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Holds a LobbyUser value and notifies all subscribers when it has been changed.

Assets/Scripts/GameLobby/Game/LocalLobby.cs

 using System.Collections.Generic;
 using UnityEngine;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     [Flags] // Some UI elements will want to specify multiple states in which to be active, so this is Flags.
     public enum LobbyState

Assets/Scripts/GameLobby/Game/LocalLobbyObserver.cs

-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Holds a LocalLobby value and notifies all subscribers when it has been changed.

Assets/Scripts/GameLobby/Game/LocalMenuState.cs

 using System;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Current state of the local game.

Assets/Scripts/GameLobby/Game/LocalMenuStateObserver.cs

-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Holds a LocalMenuState value and notifies all subscribers when it has been changed.

Assets/Scripts/GameLobby/Game/ServerAddress.cs

-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Just for displaying the anonymous Relay IP.

Assets/Scripts/GameLobby/Infrastructure/AsyncRequest.cs

 using System;
 using System.Threading.Tasks;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Both Lobby and Relay have need for asynchronous requests with some basic safety wrappers. This is a shared place for that.

Assets/Scripts/GameLobby/Infrastructure/Locator.cs

-using LobbyRelaySample.Auth;
+using GamelobbySample.Auth;
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Anything which provides itself to a Locator can then be globally accessed. This should be a single access point for things that *want* to be singleton (that is,

Assets/Scripts/GameLobby/Infrastructure/LogHandler.cs

 using UnityEngine;
 using Object = UnityEngine.Object;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     public enum LogMode
     {

Assets/Scripts/GameLobby/Infrastructure/LogHandlerSettings.cs

 using UnityEngine;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Acts as a buffer between receiving requests to display error messages to the player and running the pop-up UI to do so.

Assets/Scripts/GameLobby/Infrastructure/Messenger.cs

 using UnityEngine;
 using Stopwatch = System.Diagnostics.Stopwatch;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Core mechanism for routing messages to arbitrary listeners.

Assets/Scripts/GameLobby/Infrastructure/Observed.cs

 using System;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Something that exposes some data that, when changed, an observer would want to be notified about automatically.

Assets/Scripts/GameLobby/Infrastructure/ObserverBehaviour.cs

 using UnityEngine;
 using UnityEngine.Events;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// MonoBehaviour that will automatically handle setting up to observe something. It also exposes an event so some other component can effectively observe it as well.

Assets/Scripts/GameLobby/Infrastructure/UpdateSlow.cs

 using UnityEngine;
 using Stopwatch = System.Diagnostics.Stopwatch;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     public delegate void UpdateMethod(float dt);
 

Assets/Scripts/GameLobby/Lobby/AsyncRequestLobby.cs

 using System;
 using Unity.Services.Lobbies;
 
-namespace LobbyRelaySample.lobby
+namespace GamelobbySample.lobby
 {
     public class AsyncRequestLobby : AsyncRequest
     {

Assets/Scripts/GameLobby/Lobby/LobbyAPIInterface.cs

 using Unity.Services.Lobbies;
 using Unity.Services.Lobbies.Models;
 
-namespace LobbyRelaySample.lobby
+namespace GamelobbySample.lobby
 {
     /// <summary>
     /// Wrapper for all the interactions with the Lobby API.

Assets/Scripts/GameLobby/Lobby/LobbyAsyncRequests.cs

-using LobbyRelaySample.lobby;
-using System;
+using System;
+using GamelobbySample.lobby;
-namespace LobbyRelaySample
+namespace GamelobbySample
-    /// An abstraction layer between the direct calls into the Lobby API and the outcomes you actually want. E.g. you can request to get a readable list of 
+    /// An abstraction layer between the direct calls into the Lobby API and the outcomes you actually want. E.g. you can request to get a readable list of
     /// current lobbies and not need to make the query call directly.
     /// </summary>
     public class LobbyAsyncRequests
                     dataCurr[dataNew.Key] = dataObj;
                 else
                     dataCurr.Add(dataNew.Key, dataObj);
-                
+
                 //Special Use: Get the state of the Local lobby so we can lock it from appearing in queries if it's not in the "Lobby" State
                 if (dataNew.Key == "State")
                 {
-            }         
+            }
 
             LobbyAPIInterface.UpdateLobbyAsync(lobby.Id, dataCurr, shouldLock, (result) =>
             {

Assets/Scripts/GameLobby/Lobby/LobbyContentHeartbeat.cs

 using System.Collections.Generic;
 using LobbyRemote = Unity.Services.Lobbies.Models.Lobby;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Keep updated on changes to a joined lobby, at a speed compliant with Lobby's rate limiting.

Assets/Scripts/GameLobby/Lobby/ToLocalLobby.cs

 using System.Collections.Generic;
 using Unity.Services.Lobbies.Models;
 
-namespace LobbyRelaySample.lobby
+namespace GamelobbySample.lobby
 {
     /// <summary>
     /// Convert the lobby resulting from a request into a LocalLobby for use in the game logic.

Assets/Scripts/GameLobby/NGO/IInGameInputHandler.cs

-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// Something that will handle player input while in the game.

Assets/Scripts/GameLobby/NGO/InGameRunner.cs

 using Unity.Netcode;
 using UnityEngine;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// Once the NetworkManager has been spawned, we need something to manage the game state and setup other in-game objects

Assets/Scripts/GameLobby/NGO/IntroOutroRunner.cs

 using System;
 using UnityEngine;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// Handles any visual tasks for running the NGO minigame's intro and outro.

Assets/Scripts/GameLobby/NGO/NetworkedDataStore.cs

 using Unity.Netcode;
 using UnityEngine.Events;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// A place to store data needed by networked behaviors. Each client has an instance so they can retrieve data, but the server's instance stores the actual data.

Assets/Scripts/GameLobby/NGO/PlayerCursor.cs

 using Unity.Netcode;
 using UnityEngine;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// This cursor object will follow the owning player's mouse cursor and be visible to the other players.

Assets/Scripts/GameLobby/NGO/PlayerData.cs

 using Unity.Netcode;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// An example of a custom type serialized for use in RPC calls. This represents the state of a player as far as NGO is concerned,

Assets/Scripts/GameLobby/NGO/RelayNGOUtpSetup.cs

 using System;
+using GamelobbySample.relay;
-using LobbyRelaySample.relay;
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /*
      * To use Netcode for GameObjects (NGO), we use the Relay adapter for UTP, attached to a NetworkManager. This needs to be provided the Allocation info before we bind to it.

Assets/Scripts/GameLobby/NGO/ResultsUserUI.cs

 using UnityEngine;
 using Unity.Netcode;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// Displays the results for all players after the NGO minigame.

Assets/Scripts/GameLobby/NGO/Scorer.cs

 using UnityEngine;
 using UnityEngine.Events;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// Used by the host to actually track scores for all players, and by each client to monitor for updates to their own score.

Assets/Scripts/GameLobby/NGO/SequenceSelector.cs

 using UnityEngine.UI;
 using Random = UnityEngine.Random;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// Handles selecting the randomized sequence of symbols to spawn, choosing a subset to be the ordered target sequence that each player needs to select.

Assets/Scripts/GameLobby/NGO/SetupInGame.cs

 using Unity.Netcode;
 using UnityEngine;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// Once the local player is in a lobby and that lobby has entered the In-Game state, this will load in whatever is necessary to actually run the game part.

Assets/Scripts/GameLobby/NGO/SymbolContainer.cs

 using UnityEngine;
 using Unity.Netcode.Components;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// Rather than track movement data for every symbol object, the symbols will all be parented under one container that will move.

Assets/Scripts/GameLobby/NGO/SymbolData.cs

 using System.Collections.Generic;
 using UnityEngine;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// Associates a symbol index with the sprite to display for symbol objects matching the index.

Assets/Scripts/GameLobby/NGO/SymbolKillVolume.cs

 using System;
 using UnityEngine;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// Used by the host to deactivate symbol objects once they're off-screen.

Assets/Scripts/GameLobby/NGO/SymbolObject.cs

 using UnityEngine;
 using VivoxUnity;
 
-namespace LobbyRelaySample.ngo
+namespace GamelobbySample.ngo
 {
     /// <summary>
     /// This holds the logic and data for an individual symbol, which can be "clicked" if the server detects the collision with a player who sends a click input.

Assets/Scripts/GameLobby/Relay/AsyncRequestRelay.cs

 using System;
 using Unity.Services.Relay;
 
-namespace LobbyRelaySample.relay
+namespace GamelobbySample.relay
 {
     public class AsyncRequestRelay : AsyncRequest
     {

Assets/Scripts/GameLobby/Relay/RelayAPIInterface.cs

 using UnityEngine;
 using RelayService = Unity.Services.Relay.Relay;
 
-namespace LobbyRelaySample.relay
+namespace GamelobbySample.relay
 {
     /// <summary>
     /// Wrapper for all the interaction with the Relay API.

Assets/Scripts/GameLobby/Relay/RelayPendingApproval.cs

 using System;
 using Unity.Networking.Transport;
 
-namespace LobbyRelaySample.relay
+namespace GamelobbySample.relay
 {
     /// <summary>
     /// The Relay host doesn't need to know what might approve or disapprove of a pending connection, so this will

Assets/Scripts/GameLobby/Relay/RelayUtpClient.cs

 using Unity.Networking.Transport;
 using UnityEngine;
 
-namespace LobbyRelaySample.relay
+namespace GamelobbySample.relay
 {
     public enum Approval { OK = 0, GameAlreadyStarted }
 

Assets/Scripts/GameLobby/Relay/RelayUtpHost.cs

 using System.Collections.Generic;
 using Unity.Networking.Transport;
 
-namespace LobbyRelaySample.relay
+namespace GamelobbySample.relay
 {
     /// <summary>
     /// In addition to maintaining a heartbeat with the Relay server to keep it from timing out, the host player must pass network events

Assets/Scripts/GameLobby/Relay/RelayUtpSetup.cs

 using Unity.Services.Relay.Models;
 using UnityEngine;
 
-namespace LobbyRelaySample.relay
+namespace GamelobbySample.relay
 {
     /// <summary>
     /// Responsible for setting up a connection with Relay using Unity Transport (UTP). A Relay Allocation is created by the host, and then all players

Assets/Scripts/GameLobby/Tests/Editor/AuthTests.cs

-using LobbyRelaySample.Auth;
+using GamelobbySample.Auth;
 using NUnit.Framework;
 
 namespace Test

Assets/Scripts/GameLobby/Tests/Editor/LoggerTests.cs

-using LobbyRelaySample;
+using GamelobbySample;
 using System;
 using NUnit.Framework;
 using UnityEngine;

Assets/Scripts/GameLobby/Tests/Editor/MessengerTests.cs

-using LobbyRelaySample;
+using GamelobbySample;
 using NUnit.Framework;
 using System;
 using System.Text.RegularExpressions;

Assets/Scripts/GameLobby/Tests/Editor/ObserverTests.cs

-using LobbyRelaySample;
+using GamelobbySample;
 using System.Collections;
 using UnityEngine;
 using UnityEngine.TestTools;

Assets/Scripts/GameLobby/Tests/Editor/Tests.Editor.asmdef

     "references": [
         "UnityEngine.TestRunner",
         "UnityEditor.TestRunner",
-        "LobbyRelaySample"
+        "GamelobbySample"
     ],
     "includePlatforms": [
         "Editor"

Assets/Scripts/GameLobby/Tests/PlayMode/LobbyRoundtripTests.cs

 using Unity.Services.Lobbies.Models;
 using UnityEngine;
 using UnityEngine.TestTools;
-using LobbyAPIInterface = LobbyRelaySample.lobby.LobbyAPIInterface;
+using LobbyAPIInterface = GamelobbySample.lobby.LobbyAPIInterface;
 
 namespace Test
 {
     public class LobbyRoundtripTests
     {
         private string m_workingLobbyId;
-        private LobbyRelaySample.Auth.SubIdentity_Authentication m_auth;
+        private GamelobbySample.Auth.SubIdentity_Authentication m_auth;
         private bool m_didSigninComplete = false;
         private Dictionary<string, PlayerDataObject> m_mockUserData; // This is handled in the LobbyAsyncRequest calls normally, but we need to supply this for the direct Lobby API calls.
 
-            m_auth = new LobbyRelaySample.Auth.SubIdentity_Authentication(() => { m_didSigninComplete = true; });
+            m_auth = new GamelobbySample.Auth.SubIdentity_Authentication(() => { m_didSigninComplete = true; });
             m_mockUserData = new Dictionary<string, PlayerDataObject>();
             m_mockUserData.Add("DisplayName", new PlayerDataObject(PlayerDataObject.VisibilityOptions.Member, "TestUser123"));
         }

Assets/Scripts/GameLobby/Tests/PlayMode/RelayRoundTripTests.cs

 using System;
 using System.Collections;
-using LobbyRelaySample.relay;
+using GamelobbySample.relay;
 using NUnit.Framework;
 using Unity.Services.Relay.Models;
 using UnityEngine;
     /// </summary>
     public class RelayRoundTripTests
     {
-        private LobbyRelaySample.Auth.SubIdentity_Authentication m_auth;
+        private GamelobbySample.Auth.SubIdentity_Authentication m_auth;
-            m_auth = new LobbyRelaySample.Auth.SubIdentity_Authentication(() => { m_didSigninComplete = true; });
+            m_auth = new GamelobbySample.Auth.SubIdentity_Authentication(() => { m_didSigninComplete = true; });
         }
 
         [OneTimeTearDown]

Assets/Scripts/GameLobby/Tests/PlayMode/Tests.Play.asmdef

     "references": [
         "UnityEngine.TestRunner",
         "UnityEditor.TestRunner",
-        "LobbyRelaySample",
-        "Unity.Networking.Transport"
+        "Unity.Networking.Transport",
+        "GamelobbySample"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

Assets/Scripts/GameLobby/Tests/PlayMode/UpdateSlowTests.cs

-using LobbyRelaySample;
+using GamelobbySample;
 using NUnit.Framework;
 using System;
 using System.Collections;

Assets/Scripts/GameLobby/Tests/PlayMode/UtpTests.cs

 using System;
 using System.Collections;
-using LobbyRelaySample.relay;
+using GamelobbySample.relay;
 using NUnit.Framework;
 using Unity.Networking.Transport;
 using Unity.Services.Relay.Models;
             }
         }
 
-        private LobbyRelaySample.Auth.SubIdentity_Authentication m_auth;
+        private GamelobbySample.Auth.SubIdentity_Authentication m_auth;
         GameObject m_dummy;
         //Only used when testing DTLS
         #pragma warning disable CS0414 // This is the "assigned but its value is never used" warning, which will otherwise appear when DTLS is unavailable.
         public void Setup()
         {
             m_dummy = new GameObject();
-            m_auth = new LobbyRelaySample.Auth.SubIdentity_Authentication(() => { m_didSigninComplete = true; });
+            m_auth = new GamelobbySample.Auth.SubIdentity_Authentication(() => { m_didSigninComplete = true; });
         }
 
         [OneTimeTearDown]

Assets/Scripts/GameLobby/UI/BackButtonUI.cs

 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// For navigating the main menu.

Assets/Scripts/GameLobby/UI/CountdownUI.cs

 using TMPro;
 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// After all players ready up for the game, this will show the countdown that occurs.

Assets/Scripts/GameLobby/UI/CreateMenuUI.cs

 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Handles the menu for a player creating a new lobby.

Assets/Scripts/GameLobby/UI/DisplayCodeUI.cs

 using TMPro;
 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Watches a lobby or relay code for updates, displaying the current code to lobby members.

Assets/Scripts/GameLobby/UI/EmoteButtonUI.cs

 using TMPro;
 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Controls a button which will set the local player's emote state when pressed. This demonstrates a player updating their data within the room.

Assets/Scripts/GameLobby/UI/EndGameButtonUI.cs

 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// After connecting to Relay, the host can use this to end the game, returning to the regular lobby state.

Assets/Scripts/GameLobby/UI/ExitButtonUI.cs

 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// When the main menu's Exit button is selected, send a quit signal.

Assets/Scripts/GameLobby/UI/GameStateVisibilityUI.cs

 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Show or hide a UI element based on the current GameState (e.g. in a lobby).

Assets/Scripts/GameLobby/UI/InLobbyUserList.cs

 using System.Collections.Generic;
 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Contains the InLobbyUserUI instances while showing the UI for a lobby.

Assets/Scripts/GameLobby/UI/InLobbyUserUI.cs

 using UnityEngine;
 using UnityEngine.UI;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// When inside a lobby, this will show information about a player, whether local or remote.

Assets/Scripts/GameLobby/UI/JoinCreateLobbyUI.cs

 using UnityEngine;
 using UnityEngine.Events;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     public enum JoinCreateTabs
     {

Assets/Scripts/GameLobby/UI/JoinMenuUI.cs

 using TMPro;
 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Handles the list of LobbyButtons and ensures it stays synchronized with the lobby list from the service.

Assets/Scripts/GameLobby/UI/LobbyButtonUI.cs

 using UnityEngine;
 using UnityEngine.Events;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Controls an entry in the join menu's list of lobbies, acting as a clickable button as well as displaying info about the lobby.

Assets/Scripts/GameLobby/UI/LobbyNameUI.cs

 using TMPro;
 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Displays the name of the lobby.

Assets/Scripts/GameLobby/UI/LobbyUserVolumeUI.cs

 using UnityEngine;
 using UnityEngine.UI;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     public class LobbyUserVolumeUI : MonoBehaviour
     {

Assets/Scripts/GameLobby/UI/MainMenuUI.cs

 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Watches for changes in the game state to/from the main menu.

Assets/Scripts/GameLobby/UI/NameChangeUI.cs

-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// When the player changes their name with the UI, this triggers the actual rename.

Assets/Scripts/GameLobby/UI/ObserverPanel.cs

-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Observer UI panel base class. This allows UI elements to be shown or hidden based on an Observed element.

Assets/Scripts/GameLobby/UI/PopUpUI.cs

 using TMPro;
 using UnityEngine;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Controls a pop-up message that lays over the rest of the UI, with a button to dismiss. Used for displaying player-facing error messages.

Assets/Scripts/GameLobby/UI/RateLimitVisibility.cs

 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Observes the Lobby request rate limits and changes the visibility of a UIPanelBase to suit.

Assets/Scripts/GameLobby/UI/ReadyCheckUI.cs

 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Button callbacks for the "Ready"/"Not Ready" buttons used to indicate the local player is ready/not ready.

Assets/Scripts/GameLobby/UI/RecolorForLobbyType.cs

 using UnityEngine;
 using UnityEngine.UI;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// We want to illustrate filtering the lobby list by some arbitrary variable. This will allow the lobby host to choose a color for the lobby, and will display a lobby's current color.

Assets/Scripts/GameLobby/UI/RelayAddressUI.cs

 using TMPro;
 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Displays the IP when connected to Relay.

Assets/Scripts/GameLobby/UI/ShowWhenLobbyStateUI.cs

 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
-    /// <summary>
-    /// UI element that is displayed when the lobby is in a particular state (e.g. counting down, in-game).
+    /// <summary>
+    /// UI element that is displayed when the lobby is in a particular state (e.g. counting down, in-game).
     /// </summary>
     public class ShowWhenLobbyStateUI : ObserverPanel<LocalLobby>
     {

Assets/Scripts/GameLobby/UI/SpinnerUI.cs

 using TMPro;
 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Controls a simple throbber that is displayed when the lobby list is being refreshed.

Assets/Scripts/GameLobby/UI/StartLobbyButtonUI.cs

 using UnityEngine;
 
-namespace LobbyRelaySample
+namespace GamelobbySample
 {
     /// <summary>
     /// Main menu start button.

Assets/Scripts/GameLobby/UI/UIPanelBase.cs

 using UnityEngine;
 using UnityEngine.Events;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Basic UI element that can be shown or hidden.

Assets/Scripts/GameLobby/UI/UserNameUI.cs

 using TMPro;
 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// Displays the player's name.

Assets/Scripts/GameLobby/UI/UserStateVisibilityUI.cs

 using System;
 using UnityEngine;
 
-namespace LobbyRelaySample.UI
+namespace GamelobbySample.UI
 {
     /// <summary>
     /// User permission type. It's a flag enum to allow for the Inspector to select multiples for various UI features.

Assets/Scripts/GameLobby/Vivox/VivoxSetup.cs

 using Unity.Services.Vivox;
 using VivoxUnity;
 
-namespace LobbyRelaySample.vivox
+namespace GamelobbySample.vivox
 {
     /// <summary>
     /// Handles setting up a voice channel once inside a lobby.

Assets/Scripts/GameLobby/Vivox/VivoxUserHandler.cs

 using Unity.Services.Vivox;
 using VivoxUnity;
 
-namespace LobbyRelaySample.vivox
+namespace GamelobbySample.vivox
 {
     /// <summary>
     /// Listens for changes to Vivox state for one user in the lobby.

Assets/Scripts/GameLobby/GamelobbySample.asmdef

 {
-    "name": "LobbyRelaySample",
+    "name": "GamelobbySample",
     "rootNamespace": "",
     "references": [
         "GUID:6055be8ebefd69e48b49212b09b47b2f",

LICENSE.md

-com.unity.services.samples.lobby-rooms © 2021 Unity Technologies
+com.unity.services.samples.game-lobby © 2021 Unity Technologies
 Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license).
 Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.