(Feat) Add Network Body

Assets/GAME/Script/Network/NetworkSessionManager.cs

@@ -38,6 +38,10 @@ namespace Ashwild.Network
         [Tooltip("The networked player prefab (NetworkObject + PlayerNetworkController).")]
         [SerializeField] private NetworkObject playerPrefab;
 
+        [Tooltip("Hard cap on total players in a room (host included). The transport is set to accept " +
+                 "maxPlayers - 1 remote clients, and the Steam invite lobby mirrors this limit.")]
+        [SerializeField] private int maxPlayers = 6;
+
         [Header("Debug")]
         [Tooltip("Logs every host/join/connection/spawn step to the console.")]
         [SerializeField] private bool verboseLogging = true;
@@ -56,6 +60,12 @@ namespace Ashwild.Network
         /// </summary>
         public string GameSceneName => gameSceneName;
 
+        /// <summary>
+        /// Hard cap on total players per room (host included). Single source of truth for the
+        /// player limit — the Steam invite lobby reads this to mirror the cap.
+        /// </summary>
+        public int MaxPlayers => maxPlayers;
+
         /// <summary>
         /// Cached FishNet manager resolved from the active scene.
         /// </summary>
@@ -262,6 +272,8 @@ namespace Ashwild.Network
 
             if (args.ConnectionState == LocalConnectionState.Started)
             {
+                ApplyPlayerCap();
+
                 string code = GetLocalSteamCode();
                 PlayerEvents.RaiseSessionStarted(code);
                 Log($"✅ Session créée ! Code à partager = {code}");
@@ -430,6 +442,20 @@ namespace Ashwild.Network
             PlayerEvents.RaiseMenuReady();
         }
 
+        /// <summary>
+        /// Caps the transport at <see cref="maxPlayers"/> - 1 remote clients. Called once the server has
+        /// Started, not before: FishySteamworks re-applies its own serialized limit to the socket inside
+        /// StartConnection, so an earlier call would be clobbered. The host runs a local client that never
+        /// crosses the Steam socket, so the remote limit is one below the total headcount; the transport
+        /// then refuses the surplus connection outright.
+        /// </summary>
+        private void ApplyPlayerCap()
+        {
+            int remoteCap = Mathf.Max(0, maxPlayers - 1);
+            networkManager.TransportManager.Transport.SetMaximumClients(remoteCap);
+            Log($"Player cap set to {maxPlayers} (transport accepts {remoteCap} remote clients).");
+        }
+
         /// <summary>
         /// Loads the gameplay scene as a global networked scene, replacing the menu.
         /// </summary>

Assets/GAME/Script/Network/PlayerBodyVisibility.cs

@@ -0,0 +1,76 @@
+using FishNet.Object;
+using UnityEngine;
+
+namespace Ashwild.Network
+{
+    /// <summary>
+    /// Splits the player's visible body by viewpoint. The local owner's third-person body is
+    /// moved onto a dedicated "local body" layer that his own first-person camera excludes from
+    /// its culling mask, so he never sees his own torso/head clip through the view — while every
+    /// remote client still renders that same body normally. The layer change is purely local and
+    /// never travels over the network, so hiding your body from yourself does not hide it from
+    /// anyone else. The Animator/NetworkAnimator are left untouched, so the third-person animation
+    /// keeps replicating to other players even while the mesh is culled from the owner's own view.
+    /// </summary>
+    [DisallowMultipleComponent]
+    public class PlayerBodyVisibility : NetworkBehaviour
+    {
+        #region Serialized Fields
+
+        [Header("Body")]
+        [Tooltip("Root of the third-person body mesh hierarchy (skinned mesh + bones).")]
+        [SerializeField] private GameObject bodyRoot;
+
+        [Header("Local hiding")]
+        [Tooltip("Layer the owner's own body is moved to. The first-person camera must exclude this layer from its culling mask.")]
+        [SerializeField] private string localBodyLayer = "LocalBody";
+
+        #endregion
+
+        #region Network Lifecycle
+
+        /// <summary>
+        /// Once ownership is resolved, relayers the third-person body so the owning player's own
+        /// camera stops rendering it. Remote copies return early and keep the body on its authored
+        /// (visible) layer, which is why other players still see it.
+        /// </summary>
+        public override void OnStartClient()
+        {
+            base.OnStartClient();
+
+            if (!base.IsOwner) return;
+
+            if (bodyRoot == null)
+            {
+                Debug.LogError($"[PlayerBodyVisibility] '{name}' has no bodyRoot assigned — cannot hide the local body.", this);
+                return;
+            }
+
+            int layer = LayerMask.NameToLayer(localBodyLayer);
+            if (layer < 0)
+            {
+                Debug.LogError($"[PlayerBodyVisibility] '{name}' — layer '{localBodyLayer}' does not exist. Add it in Project Settings ▸ Tags and Layers, then exclude it from the first-person camera's culling mask.", this);
+                return;
+            }
+
+            SetLayerRecursively(bodyRoot, layer);
+        }
+
+        #endregion
+
+        #region Internal Helpers
+
+        /// <summary>
+        /// Applies a layer to a GameObject and every descendant, since a skinned body spans many
+        /// child renderers and bones that must all move together for the camera cull to hide it fully.
+        /// </summary>
+        private static void SetLayerRecursively(GameObject root, int layer)
+        {
+            root.layer = layer;
+            foreach (Transform child in root.transform)
+                SetLayerRecursively(child.gameObject, layer);
+        }
+
+        #endregion
+    }
+}

Assets/GAME/Script/Network/PlayerBodyVisibility.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 23848f2e7f7ecba4791aa89d5344b3d0

Assets/GAME/Script/Network/SessionPresenceEvents.cs

@@ -0,0 +1,42 @@
+using System;
+
+namespace Ashwild.Network
+{
+    /// <summary>
+    /// A tiny static hub for "another player joined / left my session" notifications, kept separate
+    /// from PlayerEvents on purpose: PlayerEvents represents the LOCAL owned player and §3 forbids a
+    /// remote player copy from driving it. These events are raised by SessionPresenceNotifier on the
+    /// networked player copies (a local-client view of the session roster) and consumed by the game
+    /// scene's presence feed UI. Names are already resolved display names, ready to show.
+    /// </summary>
+    public static class SessionPresenceEvents
+    {
+        #region Events
+
+        /// <summary>
+        /// A remote player just joined the session — carries their display name.
+        /// </summary>
+        public static event Action<string> PlayerJoined;
+
+        /// <summary>
+        /// A remote player just left the session — carries their display name.
+        /// </summary>
+        public static event Action<string> PlayerLeft;
+
+        #endregion
+
+        #region Raisers
+
+        /// <summary>
+        /// Announces that a remote player joined, to whoever is listening on this client.
+        /// </summary>
+        public static void RaisePlayerJoined(string playerName) => PlayerJoined?.Invoke(playerName);
+
+        /// <summary>
+        /// Announces that a remote player left, to whoever is listening on this client.
+        /// </summary>
+        public static void RaisePlayerLeft(string playerName) => PlayerLeft?.Invoke(playerName);
+
+        #endregion
+    }
+}

Assets/GAME/Script/Network/SessionPresenceEvents.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: db47bb9b3f6b5c747ae09b007c8aebf0

Assets/GAME/Script/Network/SessionPresenceNotifier.cs

@@ -0,0 +1,97 @@
+using FishNet.Object;
+using FishNet.Object.Synchronizing;
+using Steamworks;
+using UnityEngine;
+
+namespace Ashwild.Network
+{
+    /// <summary>
+    /// Announces this player's arrival and departure to every other client's presence feed. Lives on
+    /// the networked player prefab (like PlayerNameTag) and is NOT owner-gated — remote copies must run
+    /// it so they can report their own despawn as a "left".
+    ///
+    /// Join is server-driven: the owner submits its Steam name, the server stores it and fires a
+    /// one-shot ObserversRpc to whoever is watching right now. Because the RPC isn't buffered, a client
+    /// joining a busy room never replays the joins that happened before it arrived — no startup burst.
+    /// Leave is client-detected: when a player's copy despawns (disconnect), each remaining client reads
+    /// the replicated name and reports it. The feed UI itself suppresses the departure storm that fires
+    /// when the local player is the one leaving the session.
+    /// </summary>
+    [DisallowMultipleComponent]
+    public class SessionPresenceNotifier : NetworkBehaviour
+    {
+        #region Networked State
+
+        /// <summary>
+        /// The owner's display name, written by the server so every client can label this player's
+        /// "left" message once the copy despawns and the owner is already gone.
+        /// </summary>
+        private readonly SyncVar<string> displayName = new SyncVar<string>();
+
+        #endregion
+
+        #region Network Lifecycle
+
+        /// <summary>
+        /// On the owning client, publishes the local Steam persona name so the server can announce the join.
+        /// </summary>
+        public override void OnStartClient()
+        {
+            base.OnStartClient();
+
+            if (!base.IsOwner) return;
+
+            if (!SteamManager.Initialized)
+            {
+                Debug.LogError($"[SessionPresence] '{name}' — Steam not initialized, cannot announce join.", this);
+                return;
+            }
+
+            SubmitPresenceServerRpc(SteamFriends.GetPersonaName());
+        }
+
+        /// <summary>
+        /// A player's copy is despawning on this client. On non-owner copies that means a remote player
+        /// left the session, so report it; the owner never reports its own departure. Gated on the local
+        /// client still running so that OUR own disconnect — which despawns every copy at once — doesn't
+        /// announce the whole room leaving.
+        /// </summary>
+        public override void OnStopClient()
+        {
+            base.OnStopClient();
+
+            if (base.IsOwner || !base.IsClientStarted) return;
+
+            string playerName = displayName.Value;
+            if (!string.IsNullOrEmpty(playerName))
+                SessionPresenceEvents.RaisePlayerLeft(playerName);
+        }
+
+        #endregion
+
+        #region Replication
+
+        /// <summary>
+        /// Server-side: records the owner's name and announces the join once to the current observers.
+        /// </summary>
+        [ServerRpc]
+        private void SubmitPresenceServerRpc(string persona)
+        {
+            displayName.Value = persona;
+            AnnounceJoinObserversRpc(persona);
+        }
+
+        /// <summary>
+        /// Fires on every client observing this player at join time; each reports it to its feed,
+        /// except the owner who shouldn't be told they joined their own session.
+        /// </summary>
+        [ObserversRpc]
+        private void AnnounceJoinObserversRpc(string persona)
+        {
+            if (base.IsOwner) return;
+            SessionPresenceEvents.RaisePlayerJoined(persona);
+        }
+
+        #endregion
+    }
+}

Assets/GAME/Script/Network/SessionPresenceNotifier.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8809701d89694f5488cc03b300f8dc09

Assets/GAME/Script/Network/SteamInviteService.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using FishNet;
+using FishNet.Managing;
 using Steamworks;
 using UnityEngine;
 using Ashwild.Player;
@@ -8,13 +10,18 @@ namespace Ashwild.Network
 {
     /// <summary>
     /// The one place that bridges Steam friend invites into the game. It does three things:
-    ///  • SEND — opens the Steam overlay friends list so the local player can invite a friend to
-    ///    their current session (the in-game pause menu "Invite" button calls OpenInviteOverlay).
+    ///  • SEND — while in a session, keeps a private "carrier" Steam lobby (one per local player, all
+    ///    advertising the same host connect code) so the pause-menu "Invite" button can open Steam's
+    ///    lobby invite overlay. Any session member — host or client — can invite their own friends,
+    ///    and every invite still points at the single host's room (see NetworkSessionManager.MaxPlayers).
     ///  • PRESENCE — publishes the session's connect code as Steam Rich Presence while online, so
-    ///    friends see "Join Game" and invites carry the code that JoinSession understands.
-    ///  • RECEIVE — listens for Steam's GameRichPresenceJoinRequested callback (fired when a friend
-    ///    accepts our invite or clicks "Join Game") and raises PlayerEvents.InviteReceived so the
-    ///    menu can pop the invitation card. Also resolves friend avatars (async via Steam).
+    ///    friends see "Join Game" in their friends list and that path carries the code JoinSession reads.
+    ///  • RECEIVE — routes Steam's join paths to match the player's intent:
+    ///      – LobbyInvite_t (invitation just ARRIVED) → raises PlayerEvents.InviteReceived so the menu
+    ///        pops the invitation card; the player joins with one in-game click, no Alt-Tab to Steam.
+    ///      – GameLobbyJoinRequested_t / GameRichPresenceJoinRequested_t (player explicitly clicked
+    ///        "Join" inside Steam) → joins the session directly, skipping the card.
+    ///    Also resolves friend avatars (async via Steam) for the invitation card.
     /// Place this on the persistent FishNet NetworkManager GameObject, beside NetworkSessionManager.
     /// </summary>
     [DisallowMultipleComponent]
@@ -23,10 +30,16 @@ namespace Ashwild.Network
         #region Constants
 
         /// <summary>
-        /// Steam Rich Presence key that makes the "Join Game" entry appear for friends.
+        /// Steam Rich Presence / lobby-data key that makes the "Join Game" entry appear for friends
+        /// and carries the connect code an incoming friend uses to reach our session.
         /// </summary>
         private const string ConnectKey = "connect";
 
+        /// <summary>
+        /// Fallback member cap for the carrier lobby when the session manager is unavailable.
+        /// </summary>
+        private const int FallbackMemberLimit = 6;
+
         #endregion
 
         #region State
@@ -37,15 +50,41 @@ namespace Ashwild.Network
         public static SteamInviteService Instance { get; private set; }
 
         /// <summary>
-        /// Steam callback fired when a friend accepts our invite or clicks "Join Game".
+        /// Steam callback fired when a friend clicks "Join Game" via our Rich Presence connect string.
         /// </summary>
         private Callback<GameRichPresenceJoinRequested_t> joinRequestedCallback;
 
+        /// <summary>
+        /// Steam callback fired when the local player clicks "Join" on a lobby invite inside Steam.
+        /// </summary>
+        private Callback<GameLobbyJoinRequested_t> lobbyJoinRequestedCallback;
+
+        /// <summary>
+        /// Steam callback fired the moment a friend's lobby invitation ARRIVES (before any accept).
+        /// </summary>
+        private Callback<LobbyInvite_t> lobbyInviteCallback;
+
         /// <summary>
         /// Steam callback fired when an avatar image finishes downloading from Steam's servers.
         /// </summary>
         private Callback<AvatarImageLoaded_t> avatarLoadedCallback;
 
+        /// <summary>
+        /// Async result of CreateLobby — writes the connect code into the new lobby once it exists.
+        /// </summary>
+        private CallResult<LobbyCreated_t> lobbyCreatedResult;
+
+        /// <summary>
+        /// The local player's carrier lobby while in a session (Nil when none). Exists only so the
+        /// Steam overlay has a lobby to invite friends to; nobody actually stays in it.
+        /// </summary>
+        private CSteamID currentLobby;
+
+        /// <summary>
+        /// Connect code to stamp onto the carrier lobby once CreateLobby completes.
+        /// </summary>
+        private string pendingLobbyCode;
+
         /// <summary>
         /// Avatar requests still waiting on Steam to finish downloading the image, by SteamID64.
         /// </summary>
@@ -86,7 +125,8 @@ namespace Ashwild.Network
         }
 
         /// <summary>
-        /// Unsubscribes from the bus and disposes the Steam callbacks — mirrors OnEnable.
+        /// Unsubscribes from the bus, tears down the carrier lobby, and disposes the Steam callbacks —
+        /// mirrors OnEnable.
         /// </summary>
         private void OnDisable()
         {
@@ -94,10 +134,18 @@ namespace Ashwild.Network
             PlayerEvents.SessionJoined -= HandleSessionJoined;
             PlayerEvents.SessionStopped -= HandleSessionStopped;
 
+            LeaveCarrierLobby();
+
             joinRequestedCallback?.Dispose();
+            lobbyJoinRequestedCallback?.Dispose();
+            lobbyInviteCallback?.Dispose();
             avatarLoadedCallback?.Dispose();
+            lobbyCreatedResult?.Dispose();
             joinRequestedCallback = null;
+            lobbyJoinRequestedCallback = null;
+            lobbyInviteCallback = null;
             avatarLoadedCallback = null;
+            lobbyCreatedResult = null;
             callbacksReady = false;
 
             pendingAvatars.Clear();
@@ -112,10 +160,11 @@ namespace Ashwild.Network
         }
 
         /// <summary>
-        /// Clears the singleton reference.
+        /// Clears the singleton reference and leaves any carrier lobby still open.
         /// </summary>
         private void OnDestroy()
         {
+            LeaveCarrierLobby();
             if (Instance == this) Instance = null;
         }
 
@@ -124,8 +173,10 @@ namespace Ashwild.Network
         #region Public API
 
         /// <summary>
-        /// Opens the Steam overlay friends list so the player can invite a friend to the current
-        /// session. Requires being in a session (host or client) so there is a code to share.
+        /// Opens the Steam overlay so the player can invite a friend to the current session. Prefers
+        /// the lobby invite dialog (so the friend gets an in-game invitation card via LobbyInvite_t);
+        /// falls back to the plain connect-string dialog if the carrier lobby isn't ready. Requires
+        /// being in a session (host or client) so there is a code to share.
         /// </summary>
         public void OpenInviteOverlay()
         {
@@ -142,7 +193,10 @@ namespace Ashwild.Network
                 return;
             }
 
-            SteamFriends.ActivateGameOverlayInviteDialogConnectString(code);
+            if (currentLobby.IsValid())
+                SteamFriends.ActivateGameOverlayInviteDialog(currentLobby);
+            else
+                SteamFriends.ActivateGameOverlayInviteDialogConnectString(code);
         }
 
         /// <summary>
@@ -181,7 +235,44 @@ namespace Ashwild.Network
         #region Steam Callbacks
 
         /// <summary>
-        /// A friend accepted our invite / clicked "Join Game" — surface it to the menu popup.
+        /// A friend's lobby invitation just ARRIVED — surface it to the menu popup so the player can
+        /// join with one in-game click. The connect code is read from the inviter's Rich Presence,
+        /// which every session member publishes; an empty read means we can't build a joinable card.
+        /// </summary>
+        private void OnLobbyInvite(LobbyInvite_t cb)
+        {
+            CSteamID inviter = new CSteamID(cb.m_ulSteamIDUser);
+            string connect = ResolveConnectFromFriend(inviter);
+            if (string.IsNullOrEmpty(connect))
+            {
+                Debug.LogWarning($"[SteamInvite] Lobby invite from {cb.m_ulSteamIDUser} had no readable connect code — ignoring.", this);
+                return;
+            }
+
+            string inviterName = inviter.IsValid() ? SteamFriends.GetFriendPersonaName(inviter) : "Un ami";
+            Debug.Log($"[SteamInvite] Invitation reçue de {inviterName} (connect={connect}).", this);
+            PlayerEvents.RaiseInviteReceived(cb.m_ulSteamIDUser, inviterName, connect);
+        }
+
+        /// <summary>
+        /// The player clicked "Join" on a lobby invite inside Steam — an explicit intent, so we join
+        /// the session directly and skip the invitation card.
+        /// </summary>
+        private void OnLobbyJoinRequested(GameLobbyJoinRequested_t cb)
+        {
+            string connect = ResolveConnectFromFriend(cb.m_steamIDFriend);
+            if (string.IsNullOrEmpty(connect))
+            {
+                Debug.LogWarning("[SteamInvite] Lobby join request had no readable connect code — ignoring.", this);
+                return;
+            }
+
+            JoinDirect(connect);
+        }
+
+        /// <summary>
+        /// A friend clicked "Join Game" via our Rich Presence connect string — an explicit intent, so
+        /// we join directly rather than popping the invitation card.
         /// </summary>
         private void OnJoinRequested(GameRichPresenceJoinRequested_t cb)
         {
@@ -192,13 +283,24 @@ namespace Ashwild.Network
                 return;
             }
 
-            ulong inviterId = cb.m_steamIDFriend.m_SteamID;
-            string inviterName = cb.m_steamIDFriend.IsValid()
-                ? SteamFriends.GetFriendPersonaName(cb.m_steamIDFriend)
-                : "Un ami";
+            JoinDirect(connect);
+        }
 
-            Debug.Log($"[SteamInvite] Invitation reçue de {inviterName} (connect={connect}).", this);
-            PlayerEvents.RaiseInviteReceived(inviterId, inviterName, connect);
+        /// <summary>
+        /// The carrier lobby finished creating — record it and stamp the connect code onto it so a
+        /// joining friend could also recover the code from lobby data if needed.
+        /// </summary>
+        private void OnLobbyCreated(LobbyCreated_t cb, bool ioFailure)
+        {
+            if (ioFailure || cb.m_eResult != EResult.k_EResultOK)
+            {
+                Debug.LogWarning($"[SteamInvite] Failed to create the invite lobby (result={cb.m_eResult}, ioFailure={ioFailure}). Invites fall back to the connect string.", this);
+                return;
+            }
+
+            currentLobby = new CSteamID(cb.m_ulSteamIDLobby);
+            if (!string.IsNullOrEmpty(pendingLobbyCode))
+                SteamMatchmaking.SetLobbyData(currentLobby, ConnectKey, pendingLobbyCode);
         }
 
         /// <summary>
@@ -218,22 +320,34 @@ namespace Ashwild.Network
         #region Event Handlers
 
         /// <summary>
-        /// Host came online — advertise the session code so friends can join/invite.
+        /// Host came online — advertise the session code and open a carrier lobby friends can be invited to.
         /// </summary>
-        private void HandleSessionOnline(string code) => PublishConnect(code);
+        private void HandleSessionOnline(string code)
+        {
+            PublishConnect(code);
+            CreateCarrierLobby(code);
+        }
 
         /// <summary>
-        /// Joined a host — advertise the same code so this client can also invite friends.
+        /// Joined a host — advertise the same code and open a carrier lobby so this client can also
+        /// invite its own friends into the host's room.
         /// </summary>
-        private void HandleSessionJoined() => PublishConnect(PlayerEvents.SessionCode);
+        private void HandleSessionJoined()
+        {
+            string code = PlayerEvents.SessionCode;
+            PublishConnect(code);
+            CreateCarrierLobby(code);
+        }
 
         /// <summary>
-        /// Session ended — remove the Rich Presence so we stop advertising as joinable.
+        /// Session ended — stop advertising as joinable and tear down the carrier lobby.
         /// </summary>
         private void HandleSessionStopped()
         {
             if (SteamManager.Initialized)
                 SteamFriends.SetRichPresence(ConnectKey, null);
+
+            LeaveCarrierLobby();
         }
 
         #endregion
@@ -248,7 +362,10 @@ namespace Ashwild.Network
             if (callbacksReady || !SteamManager.Initialized) return;
 
             joinRequestedCallback = Callback<GameRichPresenceJoinRequested_t>.Create(OnJoinRequested);
+            lobbyJoinRequestedCallback = Callback<GameLobbyJoinRequested_t>.Create(OnLobbyJoinRequested);
+            lobbyInviteCallback = Callback<LobbyInvite_t>.Create(OnLobbyInvite);
             avatarLoadedCallback = Callback<AvatarImageLoaded_t>.Create(OnAvatarLoaded);
+            lobbyCreatedResult = CallResult<LobbyCreated_t>.Create(OnLobbyCreated);
             callbacksReady = true;
         }
 
@@ -261,6 +378,88 @@ namespace Ashwild.Network
             SteamFriends.SetRichPresence(ConnectKey, code);
         }
 
+        /// <summary>
+        /// Opens (or refreshes) the private carrier lobby that the invite overlay hangs its friend
+        /// invites off. Friends-only and capped at the room's player limit; the connect code is stamped
+        /// on once LobbyCreated returns. No-op without Steam or a code; refreshes data if one already exists.
+        /// </summary>
+        private void CreateCarrierLobby(string code)
+        {
+            if (!SteamManager.Initialized || string.IsNullOrEmpty(code)) return;
+
+            pendingLobbyCode = code;
+
+            if (currentLobby.IsValid())
+            {
+                SteamMatchmaking.SetLobbyData(currentLobby, ConnectKey, code);
+                return;
+            }
+
+            int memberLimit = NetworkSessionManager.Instance != null
+                ? NetworkSessionManager.Instance.MaxPlayers
+                : FallbackMemberLimit;
+
+            SteamAPICall_t call = SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypeFriendsOnly, memberLimit);
+            lobbyCreatedResult?.Set(call);
+        }
+
+        /// <summary>
+        /// Leaves and forgets the carrier lobby, if one is open.
+        /// </summary>
+        private void LeaveCarrierLobby()
+        {
+            pendingLobbyCode = null;
+            if (!currentLobby.IsValid()) return;
+
+            if (SteamManager.Initialized)
+                SteamMatchmaking.LeaveLobby(currentLobby);
+            currentLobby = CSteamID.Nil;
+        }
+
+        /// <summary>
+        /// Reads the connect code a session member publishes via Rich Presence. Returns empty when the
+        /// friend is invalid, offline, or hasn't published one (they may not be in a session).
+        /// </summary>
+        private string ResolveConnectFromFriend(CSteamID friend)
+        {
+            if (!SteamManager.Initialized || !friend.IsValid()) return string.Empty;
+            return SteamFriends.GetFriendRichPresence(friend, ConnectKey);
+        }
+
+        /// <summary>
+        /// Connects straight to a session by its code — used when the player expressed an explicit
+        /// "Join" intent inside Steam. Ignored (with a log) when already in a session so a stray Steam
+        /// click can't tear down a running game.
+        /// </summary>
+        private void JoinDirect(string code)
+        {
+            if (IsAlreadyInSession())
+            {
+                Debug.LogWarning("[SteamInvite] Ignoring a Steam join request — already in a session.", this);
+                return;
+            }
+
+            if (NetworkSessionManager.Instance == null)
+            {
+                Debug.LogError("[SteamInvite] Cannot join — NetworkSessionManager missing.", this);
+                return;
+            }
+
+            GameSession.Mode = GameSession.LaunchMode.Join;
+            GameSession.JoinCode = code;
+            NetworkSessionManager.Instance.JoinSession(code);
+        }
+
+        /// <summary>
+        /// True when a client or server connection is already up, so we shouldn't start a fresh join.
+        /// </summary>
+        private bool IsAlreadyInSession()
+        {
+            NetworkManager nm = InstanceFinder.NetworkManager;
+            if (nm == null) return false;
+            return nm.ClientManager.Started || nm.ServerManager.Started;
+        }
+
         #endregion
     }
 }

Assets/GAME/Script/Player/Animation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7bcd5cb7e1311614a8607e68424e119f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GAME/Script/Player/Animation/PlayerAnimatorDriver.cs

@@ -0,0 +1,185 @@
+using UnityEngine;
+
+namespace Ashwild.Player
+{
+    /// <summary>
+    /// Drives a humanoid Animator from the local player's PlayerEvents bus so a visible rig
+    /// reflects what the player is doing. It is a pure consumer of the bus — it never simulates
+    /// anything itself — which lets the exact same component drive two independent rigs from one
+    /// shared source of truth: the owner's first-person arms (seen only by the owner, never
+    /// networked) and his third-person body (replicated to other players by a sibling FishNet
+    /// NetworkAnimator). Because both rigs read the same events at the same frame, the arms the
+    /// owner sees and the body everyone else sees stay in lockstep by construction.
+    /// This is owner-only local simulation: add every instance to
+    /// PlayerNetworkController.ownerOnlyBehaviours so remote puppets never run it — a remote body
+    /// is animated by its replicated NetworkAnimator instead. Every parameter name is optional;
+    /// leave a field blank to skip that parameter, so a minimal arms rig can ignore the full
+    /// locomotion blend that the third-person body uses.
+    /// </summary>
+    [DisallowMultipleComponent]
+    public class PlayerAnimatorDriver : MonoBehaviour
+    {
+        #region Serialized Fields
+
+        [Header("Target")]
+        [SerializeField] private Animator animator;
+        [Tooltip("Transform whose facing defines local move direction. Defaults to the Animator's transform when left empty.")]
+        [SerializeField] private Transform orientation;
+
+        [Header("Float parameters (leave blank to skip)")]
+        [SerializeField] private string speedParam = "Speed";
+        [SerializeField] private string moveXParam = "MoveX";
+        [SerializeField] private string moveYParam = "MoveY";
+        [Tooltip("Planar speed (m/s) that maps to 1 in the blend tree. 0 feeds raw speed unscaled.")]
+        [SerializeField] private float normalizeSpeed = 6f;
+        [Tooltip("Damping applied to float parameters for smooth blends.")]
+        [SerializeField] private float floatDampTime = 0.1f;
+
+        [Header("Bool parameters (leave blank to skip)")]
+        [SerializeField] private string groundedParam = "Grounded";
+        [SerializeField] private string crouchingParam = "Crouching";
+        [SerializeField] private string sprintingParam = "Sprinting";
+
+        [Header("Trigger parameters (leave blank to skip)")]
+        [SerializeField] private string jumpParam = "Jump";
+        [SerializeField] private string attackParam = "Attack";
+        [SerializeField] private string landParam = "Land";
+
+        #endregion
+
+        #region State
+
+        private Vector3 planarVelocity;
+
+        private int speedId, moveXId, moveYId;
+        private int groundedId, crouchingId, sprintingId;
+        private int jumpId, attackId, landId;
+
+        #endregion
+
+        #region Unity Lifecycle
+
+        /// <summary>
+        /// Caches parameter hashes (0 for blank names, which are then skipped) and defaults the
+        /// orientation reference so local move direction works without extra wiring.
+        /// </summary>
+        private void Awake()
+        {
+            speedId = Hash(speedParam);
+            moveXId = Hash(moveXParam);
+            moveYId = Hash(moveYParam);
+            groundedId = Hash(groundedParam);
+            crouchingId = Hash(crouchingParam);
+            sprintingId = Hash(sprintingParam);
+            jumpId = Hash(jumpParam);
+            attackId = Hash(attackParam);
+            landId = Hash(landParam);
+
+            if (orientation == null && animator != null)
+                orientation = animator.transform;
+        }
+
+        /// <summary>
+        /// Subscribes to the locomotion/tool events that map onto animation, and seeds the bool
+        /// parameters from the bus's current state so a freshly enabled rig starts in the right pose.
+        /// </summary>
+        private void OnEnable()
+        {
+            PlayerEvents.VelocityChanged += HandleVelocityChanged;
+            PlayerEvents.GroundedChanged += HandleGroundedChanged;
+            PlayerEvents.CrouchChanged += HandleCrouchChanged;
+            PlayerEvents.SprintChanged += HandleSprintChanged;
+            PlayerEvents.Jumped += HandleJumped;
+            PlayerEvents.AttackSwung += HandleAttackSwung;
+            PlayerEvents.LandingStunStarted += HandleLandingStunStarted;
+
+            SetBool(groundedId, PlayerEvents.IsGrounded);
+            SetBool(crouchingId, PlayerEvents.IsCrouching);
+            SetBool(sprintingId, PlayerEvents.IsSprinting);
+        }
+
+        /// <summary>
+        /// Unsubscribes — mirrors OnEnable exactly.
+        /// </summary>
+        private void OnDisable()
+        {
+            PlayerEvents.VelocityChanged -= HandleVelocityChanged;
+            PlayerEvents.GroundedChanged -= HandleGroundedChanged;
+            PlayerEvents.CrouchChanged -= HandleCrouchChanged;
+            PlayerEvents.SprintChanged -= HandleSprintChanged;
+            PlayerEvents.Jumped -= HandleJumped;
+            PlayerEvents.AttackSwung -= HandleAttackSwung;
+            PlayerEvents.LandingStunStarted -= HandleLandingStunStarted;
+        }
+
+        /// <summary>
+        /// Pushes the smoothed movement floats every frame so blend trees ease between poses
+        /// instead of snapping when velocity changes.
+        /// </summary>
+        private void Update()
+        {
+            if (animator == null) return;
+
+            float scale = normalizeSpeed > 0f ? 1f / normalizeSpeed : 1f;
+            SetFloat(speedId, planarVelocity.magnitude * scale);
+
+            if (moveXId != 0 || moveYId != 0)
+            {
+                Vector3 local = orientation != null
+                    ? orientation.InverseTransformDirection(planarVelocity)
+                    : planarVelocity;
+                SetFloat(moveXId, local.x * scale);
+                SetFloat(moveYId, local.z * scale);
+            }
+        }
+
+        #endregion
+
+        #region Event Handlers
+
+        /// <summary>
+        /// Caches the planar (horizontal) velocity that Update turns into blend-tree floats.
+        /// </summary>
+        private void HandleVelocityChanged(Vector3 velocity)
+        {
+            planarVelocity = new Vector3(velocity.x, 0f, velocity.z);
+        }
+
+        private void HandleGroundedChanged(bool grounded, float impactSpeed) => SetBool(groundedId, grounded);
+        private void HandleCrouchChanged(bool crouching) => SetBool(crouchingId, crouching);
+        private void HandleSprintChanged(bool sprinting) => SetBool(sprintingId, sprinting);
+        private void HandleJumped() => SetTrigger(jumpId);
+        private void HandleAttackSwung() => SetTrigger(attackId);
+
+        /// <summary>
+        /// A landing stun begins on a hard touchdown — the cue for a landing animation.
+        /// </summary>
+        private void HandleLandingStunStarted(float duration) => SetTrigger(landId);
+
+        #endregion
+
+        #region Internal Helpers
+
+        /// <summary>
+        /// Hashes a parameter name, returning 0 for a blank name so the setters can skip it.
+        /// </summary>
+        private int Hash(string paramName) => string.IsNullOrEmpty(paramName) ? 0 : Animator.StringToHash(paramName);
+
+        private void SetFloat(int id, float value)
+        {
+            if (id != 0) animator.SetFloat(id, value, floatDampTime, Time.deltaTime);
+        }
+
+        private void SetBool(int id, bool value)
+        {
+            if (id != 0 && animator != null) animator.SetBool(id, value);
+        }
+
+        private void SetTrigger(int id)
+        {
+            if (id != 0 && animator != null) animator.SetTrigger(id);
+        }
+
+        #endregion
+    }
+}

Assets/GAME/Script/Player/Animation/PlayerAnimatorDriver.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8c1abd96334ddec4f8abf1ccdde057f9

Assets/GAME/Script/Player/Events/PlayerEvents.cs

@@ -47,6 +47,7 @@ namespace Ashwild.Player
         public static event Action<bool> SprintHeld;
         public static event Action CrouchPressed;
         public static event Action AttackPressed;
+        public static event Action SecondaryUsePressed;         // right-click / secondary use (build menu, aim, block, ...)
         public static event Action InteractPressed;
         public static event Action DropPressed;
         public static event Action InventoryTogglePressed;
@@ -115,6 +116,12 @@ namespace Ashwild.Player
         public static event Action EquipAnimComplete;
         public static event Action UnequipAnimComplete;
 
+        // ============================================================
+        // Building events
+        // ============================================================
+
+        public static event Action BuildMenuToggleRequested;    // the build hammer asks to open/close the construction menu
+
         // ============================================================
         // Cooking events
         // ============================================================
@@ -166,6 +173,7 @@ namespace Ashwild.Player
         public static void RaiseSprintHeld(bool b) { Log(nameof(SprintHeld)); SprintHeld?.Invoke(b); }
         public static void RaiseCrouchPressed() { Log(nameof(CrouchPressed)); CrouchPressed?.Invoke(); }
         public static void RaiseAttackPressed() { Log(nameof(AttackPressed)); AttackPressed?.Invoke(); }
+        public static void RaiseSecondaryUsePressed() { Log(nameof(SecondaryUsePressed)); SecondaryUsePressed?.Invoke(); }
         public static void RaiseInteractPressed() { Log(nameof(InteractPressed)); InteractPressed?.Invoke(); }
         public static void RaiseDropPressed() { Log(nameof(DropPressed)); DropPressed?.Invoke(); }
         public static void RaiseInventoryTogglePressed() { Log(nameof(InventoryTogglePressed)); InventoryTogglePressed?.Invoke(); }
@@ -258,6 +266,8 @@ namespace Ashwild.Player
         public static void RaiseEquipAnimComplete() { EquipAnimComplete?.Invoke(); }
         public static void RaiseUnequipAnimComplete() { UnequipAnimComplete?.Invoke(); }
 
+        public static void RaiseBuildMenuToggleRequested() { Log(nameof(BuildMenuToggleRequested)); BuildMenuToggleRequested?.Invoke(); }
+
         public static void RaiseFoodPlacedToCook(ItemData raw) { Log(nameof(FoodPlacedToCook)); FoodPlacedToCook?.Invoke(raw); }
         public static void RaiseFoodCookedReady(ItemData cooked) { Log(nameof(FoodCookedReady)); FoodCookedReady?.Invoke(cooked); }
         public static void RaiseFuelAdded(ItemData fuel) { Log(nameof(FuelAdded)); FuelAdded?.Invoke(fuel); }

Assets/GAME/Script/Player/HeldItems/BuildHammerBehaviour.cs

@@ -0,0 +1,85 @@
+using UnityEngine;
+using Ashwild.Inventory;
+
+namespace Ashwild.Player
+{
+    /// <summary>
+    /// Held-item logic for the build hammer, placed on its hand prefab. While equipped it
+    /// listens to the secondary-use input (right-click) and asks the construction UI to
+    /// open/close through the bus — it never reaches for the menu itself, so the hammer
+    /// stays a pure input source and the UI owns its own state. Left-click placement will
+    /// be added on top of this once the build menu exists.
+    /// </summary>
+    [DisallowMultipleComponent]
+    public class BuildHammerBehaviour : MonoBehaviour, IHeldItemBehaviour
+    {
+        #region Serialized Fields
+
+        [Header("Cooldown")]
+        /// <summary>
+        /// Minimum time, in seconds, between two menu toggles so a held right-click
+        /// does not flicker the menu open and shut.
+        /// </summary>
+        [SerializeField] private float toggleCooldown = 0.25f;
+
+        #endregion
+
+        #region State
+
+        /// <summary>
+        /// Earliest time, in seconds, the next menu toggle is allowed.
+        /// </summary>
+        private float nextToggleTime;
+
+        #endregion
+
+        #region Unity Lifecycle
+
+        /// <summary>
+        /// Subscribes to the secondary-use input for as long as the hammer is held.
+        /// </summary>
+        private void OnEnable()
+        {
+            PlayerEvents.SecondaryUsePressed += HandleSecondaryUse;
+        }
+
+        /// <summary>
+        /// Unsubscribes when the hammer is put away (the prefab is destroyed).
+        /// </summary>
+        private void OnDisable()
+        {
+            PlayerEvents.SecondaryUsePressed -= HandleSecondaryUse;
+        }
+
+        #endregion
+
+        #region IHeldItemBehaviour
+
+        /// <summary>
+        /// Nothing to link yet: toggling the menu needs no player refs. Present to satisfy
+        /// the held-item contract; placement logic added later will use the context.
+        /// </summary>
+        public void Setup(HeldItemContext context, ItemData item)
+        {
+        }
+
+        #endregion
+
+        #region Event Handlers
+
+        /// <summary>
+        /// Requests the construction menu to open/close on right-click, gated by lock and
+        /// cooldown. The UI decides whether that opens or closes it.
+        /// </summary>
+        private void HandleSecondaryUse()
+        {
+            if (PlayerEvents.InputLocked) return;
+            if (Time.time < nextToggleTime) return;
+
+            nextToggleTime = Time.time + toggleCooldown;
+            PlayerEvents.RaiseBuildMenuToggleRequested();
+        }
+
+        #endregion
+    }
+}

Assets/GAME/Script/Player/HeldItems/BuildHammerBehaviour.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 59ffa82caa5b57841a87a6f1e5d8839d

Assets/GAME/Script/Player/Input/InputManager.cs

@@ -199,6 +199,7 @@ namespace Ashwild.Player
             WireHold(playerMap, "Sprint", PlayerEvents.RaiseSprintHeld);
             WireButton(playerMap, "Crouch", PlayerEvents.RaiseCrouchPressed);
             WireButton(playerMap, "Attack", PlayerEvents.RaiseAttackPressed);
+            WireButton(playerMap, "SecondaryUse", PlayerEvents.RaiseSecondaryUsePressed);
             WireButton(playerMap, "Interact", PlayerEvents.RaiseInteractPressed);
             WireButton(playerMap, "Drop", PlayerEvents.RaiseDropPressed);
             WireButton(playerMap, "Inventory", PlayerEvents.RaiseInventoryTogglePressed);

Assets/GAME/Script/UI/PlayerPresenceFeedUI.cs

@@ -0,0 +1,144 @@
+using System.Collections.Generic;
+using UnityEngine;
+using Ashwild.Network;
+using Ashwild.Player;
+
+namespace Ashwild.UI
+{
+    /// <summary>
+    /// The in-game feed that spawns a "X a rejoint / a quitté la partie" line whenever a remote player
+    /// joins or leaves the session. Listens to the network layer's SessionPresenceEvents (raised on
+    /// every client, host or not) and instantiates a PresenceFeedEntry under a holder whose layout group
+    /// stacks the lines. Drop this on the holder (or any object referencing it) in the game scene.
+    ///
+    /// While the local player is tearing the session down (returning to the menu, or the host stopping)
+    /// every remote copy despawns at once, which would spam "left" lines; this feed goes quiet on those
+    /// bus events so that storm never reaches the screen.
+    /// </summary>
+    [DisallowMultipleComponent]
+    public class PlayerPresenceFeedUI : MonoBehaviour
+    {
+        #region Serialized Fields
+
+        [Header("References")]
+        [Tooltip("Holder the entries are parented to — give it a VerticalLayoutGroup so lines stack.")]
+        [SerializeField] private RectTransform holder;
+
+        [Tooltip("Prefab with a PresenceFeedEntry (CanvasGroup + label) instantiated per notification.")]
+        [SerializeField] private PresenceFeedEntry entryPrefab;
+
+        [Header("Messages")]
+        [Tooltip("Join line format — {0} is the player name.")]
+        [SerializeField] private string joinFormat = "{0} a rejoint la partie";
+
+        [Tooltip("Leave line format — {0} is the player name.")]
+        [SerializeField] private string leaveFormat = "{0} a quitté la partie";
+
+        [Header("Colours")]
+        [SerializeField] private Color joinColor = new Color(0.45f, 1f, 0.45f);
+        [SerializeField] private Color leaveColor = new Color(1f, 0.55f, 0.45f);
+
+        [Header("Timing")]
+        [Tooltip("Seconds a line stays fully visible before fading out.")]
+        [SerializeField] private float holdDuration = 4f;
+        [SerializeField] private float fadeInDuration = 0.3f;
+        [SerializeField] private float fadeOutDuration = 0.5f;
+
+        [Header("Limits")]
+        [Tooltip("Oldest lines are removed once this many are on screen at once.")]
+        [SerializeField] private int maxEntries = 5;
+
+        #endregion
+
+        #region State
+
+        /// <summary>
+        /// Currently displayed lines, oldest first — trimmed from the front when over the cap.
+        /// </summary>
+        private readonly List<PresenceFeedEntry> activeEntries = new List<PresenceFeedEntry>();
+
+        /// <summary>
+        /// True once the session is tearing down, so the despawn-driven "left" storm is ignored.
+        /// </summary>
+        private bool suppressed;
+
+        #endregion
+
+        #region Unity Lifecycle
+
+        /// <summary>
+        /// Subscribes to presence notifications and the teardown signals that mute the feed.
+        /// </summary>
+        private void OnEnable()
+        {
+            SessionPresenceEvents.PlayerJoined += HandlePlayerJoined;
+            SessionPresenceEvents.PlayerLeft += HandlePlayerLeft;
+            PlayerEvents.ReturningToMenu += HandleTeardown;
+            PlayerEvents.SessionStopped += HandleTeardown;
+        }
+
+        /// <summary>
+        /// Unsubscribes — mirrors OnEnable exactly.
+        /// </summary>
+        private void OnDisable()
+        {
+            SessionPresenceEvents.PlayerJoined -= HandlePlayerJoined;
+            SessionPresenceEvents.PlayerLeft -= HandlePlayerLeft;
+            PlayerEvents.ReturningToMenu -= HandleTeardown;
+            PlayerEvents.SessionStopped -= HandleTeardown;
+        }
+
+        #endregion
+
+        #region Event Handlers
+
+        /// <summary>
+        /// Shows a green arrival line for the named player.
+        /// </summary>
+        private void HandlePlayerJoined(string playerName) => Push(string.Format(joinFormat, playerName), joinColor);
+
+        /// <summary>
+        /// Shows an orange departure line for the named player.
+        /// </summary>
+        private void HandlePlayerLeft(string playerName) => Push(string.Format(leaveFormat, playerName), leaveColor);
+
+        /// <summary>
+        /// Mutes the feed for the rest of its lifetime once the session is being torn down.
+        /// </summary>
+        private void HandleTeardown() => suppressed = true;
+
+        #endregion
+
+        #region Internal Helpers
+
+        /// <summary>
+        /// Instantiates a feed line, trimming the oldest ones past the cap. Ignored while muted or when
+        /// a reference is missing (logged once so a mis-wired holder/prefab is obvious).
+        /// </summary>
+        private void Push(string message, Color color)
+        {
+            if (suppressed) return;
+
+            if (holder == null || entryPrefab == null)
+            {
+                Debug.LogError("[PresenceFeed] Holder or entry prefab not assigned — cannot show notifications.", this);
+                return;
+            }
+
+            activeEntries.RemoveAll(e => e == null);
+
+            while (activeEntries.Count >= maxEntries)
+            {
+                PresenceFeedEntry oldest = activeEntries[0];
+                activeEntries.RemoveAt(0);
+                if (oldest != null) Destroy(oldest.gameObject);
+            }
+
+            PresenceFeedEntry entry = Instantiate(entryPrefab, holder);
+            entry.Play(message, color, holdDuration, fadeInDuration, fadeOutDuration);
+            activeEntries.Add(entry);
+        }
+
+        #endregion
+    }
+}

Assets/GAME/Script/UI/PlayerPresenceFeedUI.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: e34a77305857ab84a87431aca9903af0

Assets/GAME/Script/UI/PresenceFeedEntry.cs

@@ -0,0 +1,81 @@
+using UnityEngine;
+using TMPro;
+using DG.Tweening;
+
+namespace Ashwild.UI
+{
+    /// <summary>
+    /// A single line in the player presence feed (e.g. "Alex a rejoint la partie"). Fades itself in,
+    /// holds, fades out, then self-destructs — the parent holder's layout group handles stacking, so
+    /// this only ever animates its own alpha and never fights the layout for position.
+    /// </summary>
+    [DisallowMultipleComponent]
+    [RequireComponent(typeof(CanvasGroup))]
+    public class PresenceFeedEntry : MonoBehaviour
+    {
+        #region Serialized Fields
+
+        [Header("References")]
+        [Tooltip("The label that shows the join/leave message.")]
+        [SerializeField] private TMP_Text label;
+
+        [Tooltip("Faded in and out over the entry's lifetime. Auto-fetched from this object if left empty.")]
+        [SerializeField] private CanvasGroup canvasGroup;
+
+        #endregion
+
+        #region State
+
+        /// <summary>
+        /// The full lifecycle tween (fade in → hold → fade out → destroy), killed on teardown.
+        /// </summary>
+        private Sequence lifecycle;
+
+        #endregion
+
+        #region Unity Lifecycle
+
+        /// <summary>
+        /// Caches the CanvasGroup when it wasn't wired in the inspector.
+        /// </summary>
+        private void Awake()
+        {
+            if (canvasGroup == null) canvasGroup = GetComponent<CanvasGroup>();
+        }
+
+        /// <summary>
+        /// Kills the lifecycle tween so it never targets a destroyed object.
+        /// </summary>
+        private void OnDestroy()
+        {
+            lifecycle?.Kill();
+        }
+
+        #endregion
+
+        #region Public API
+
+        /// <summary>
+        /// Fills in the message and colour, then runs the fade-in → hold → fade-out → destroy sequence.
+        /// Safe to call once right after instantiation.
+        /// </summary>
+        public void Play(string message, Color color, float holdDuration, float fadeInDuration, float fadeOutDuration)
+        {
+            if (label != null)
+            {
+                label.text = message;
+                label.color = color;
+            }
+
+            canvasGroup.alpha = 0f;
+
+            lifecycle = DOTween.Sequence();
+            lifecycle.Append(canvasGroup.DOFade(1f, fadeInDuration).SetEase(Ease.OutQuad));
+            lifecycle.AppendInterval(holdDuration);
+            lifecycle.Append(canvasGroup.DOFade(0f, fadeOutDuration).SetEase(Ease.InQuad));
+            lifecycle.OnComplete(() => Destroy(gameObject));
+        }
+
+        #endregion
+    }
+}

Assets/GAME/Script/UI/PresenceFeedEntry.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4c87382f506a62e489d4ea7a432accac