Spirit Sling tabletop showcase

// Wait until MRUK loads the Scene API data
while (!MRUK.Instance.IsInitialized)
{
    yield return null;
}

var currentRoom = MRUK.Instance.GetCurrentRoom();
if (currentRoom.IsPositionInRoom(position) && !currentRoom.IsPositionInSceneVolume(position))
{

}

// Check that the line that connects the center of the board with the player board (grabbable handles) doesn't hit any scene anchor.
const float playerBoardOffset = 0.5f;
if (currentRoom.Raycast(new Ray(position, rotation * Vector3.back), playerBoardOffset, out RaycastHit hit))
{
    Log.Debug("GameVolumeSpawner can't spawn because the player board is not reachable by hand.");
    return false;
}

[SerializeField] private GameObject _objectToSpawn;

private IEnumerator Start()
{
    // Wait until MRUK loads the Scene API data
    while (!MRUK.Instance.IsInitialized)
    {
        yield return null;
    }

    while (true)
    {
        if (TryGetSpawnPosition(out Vector3 position, out Quaternion rotation))
        {
            // Spawn the board in front of the player if the spawn position was found
            var spawnedGameVolume = Instantiate(_objectToSpawn, position, rotation);
            SaveSpatialAnchorGuid(spawnedGameVolume.GetComponent<OVRSpatialAnchor>());
            SceneManager.MoveGameObjectToScene(spawnedGameVolume, gameObject.scene);
            GameVolumeSpawned?.Invoke(spawnedGameVolume);
            break;
        }

        // Wait until the board can be spawned in front of the player
        await Task.Yield();
    }
}

private static bool TryGetSpawnPosition(out Vector3 position, out Quaternion rotation)
{
    var cameraRig = OVRManager.instance.GetComponentInChildren<OVRCameraRig>();
    Transform centerEyeAnchor = cameraRig.centerEyeAnchor;
    bool isUserInsideRoom = MRUK.Instance.GetCurrentRoom().IsPositionInRoom(centerEyeAnchor.position);
    if (!isUserInsideRoom)
    {
        // The user is not inside the room. In this case it's recommended to show a UI
        // message asking the user to return to the room or rescan their environment.
        position = default;
        rotation = default;
        return false;
    }

    Vector3 lookDir = Vector3.ProjectOnPlane(centerEyeAnchor.forward, Vector3.up);

    // Calculate the position in front of the player and slightly lowered from the head position
    const float distanceToTheContent = 0.9f;
    const float downOffset = 0.4f;
    position = centerEyeAnchor.position + lookDir * distanceToTheContent + Vector3.down * downOffset;

    // Align the content's forward vector with the look direction of the player
    rotation = Quaternion.LookRotation(lookDir);

    return IsValidPlacementPose(position, rotation);
}

private static bool IsValidPlacementPose(Vector3 position, Quaternion rotation)
{
    // Check if the position is inside the room and isn't inside any volume
    var currentRoom = MRUK.Instance.GetCurrentRoom();
    if (!currentRoom.IsPositionInRoom(position) || currentRoom.IsPositionInSceneVolume(position))
    {
        Log.Debug("GameVolumeSpawner can't spawn because position is outside the current room or inside the anchor volume.");
        return false;
    }

    // Check that the line that connects the center of the board with the player board (grabbable handles) doesn't hit any scene anchor.
    const float playerBoardOffset = 0.5f;
    if (currentRoom.Raycast(new Ray(position, rotation * Vector3.back), playerBoardOffset, out RaycastHit hit))
    {
        Log.Debug("GameVolumeSpawner can't spawn because the player board is not reachable by hand.");
        return false;
    }

    return true;
}

private void Awake()
{
    // Initialize Platform SDK.
    // Set the App ID  in the 'Meta / Platform / Edit Settings' menu before calling Core.AsyncInitialize().
    Core.AsyncInitialize().OnComplete(initMsg =>
    {
        if (initMsg.IsError)
        {
            Debug.LogError("Failed to initialize Platform SDK");
            return;
        }

        // Check app entitlement
        Entitlements.IsUserEntitledToApplication().OnComplete(entitlementMsg =>
        {
            if (entitlementMsg.IsError)
            {
                Debug.LogError("The user has no entitlement to use this app.");
                Application.Quit();
            }
            else
            {
                OnUserEntitlementChecked();
            }
        });
    });
}

[SerializeField] private Fusion.NetworkRunner _networkRunner;

public async void CreateRoom(bool isPublic)
{
    while (!_networkRunner.IsCloudReady)
    {
        await Task.Yield();
    }

    StartGameResult result = await _networkRunner.StartGame(new StartGameArgs
    {
        GameMode = GameMode.Shared,
        PlayerCount = 4,
        SessionName = $"{Application.version}-{Guid.NewGuid()}",
        CustomLobbyName = "Spirit Sling",
        IsVisible = isPublic,
        SceneManager = gameObject.GetComponent<NetworkSceneManagerDefault>()
    });

    if (!result.Ok)
    {
        Debug.LogError($"CreateRoom failed: {result.ErrorMessage}");
        return;
    }

    if (!isPublic)
    {
        string roomName = _networkRunner.SessionInfo.Name;
        var options = new GroupPresenceOptions();
        options.SetDestinationApiName("Spirit Sling Private Room");
        options.SetMatchSessionId(roomName);
        options.SetLobbySessionId(roomName);
        options.SetIsJoinable(true);
        GroupPresence.Set(options).OnComplete(msg =>
        {
            Debug.Log($"Private room created successfully: {!msg.IsError}");
        });
    }
}

[SerializeField] private NetworkEvents _networkEvents;
private readonly List<SessionInfo> m_cachedSessionList = new List<SessionInfo>();

private void OnEnable() => _networkEvents.OnSessionListUpdate.AddListener(OnSessionListUpdate);
private void OnDisable() => _networkEvents.OnSessionListUpdate.RemoveListener(OnSessionListUpdate);

private void OnSessionListUpdate(NetworkRunner _, List<SessionInfo> updatedSessions)
{
    // Save the list of all available sessions
    m_cachedSessionList.Clear();
    m_cachedSessionList.AddRange(updatedSessions);
}

public async Task JoinPublicRoom()
{
    while (!_networkRunner.IsCloudReady)
    {
        await Task.Yield();
    }

    if (_networkRunner.LobbyInfo == null)
    {
        // Join the session lobby
        StartGameResult joinSessionResult = await _networkRunner.JoinSessionLobby(SessionLobby.Custom, "Spirit Sling");
        if (!joinSessionResult.Ok)
        {
            Debug.LogError($"JoinSessionLobby failed: {joinSessionResult.ErrorMessage}");
            return;
        }
    }

    // Find the first non-full room
    var session = m_cachedSessionList.Find(static s =>
    {
        return s.IsOpen && s.PlayerCount < 4 && s.Name.StartsWith(Application.version, StringComparison.Ordinal);
    });
    if (session == null)
    {
        Debug.LogError("Public session not found.");
        return;
    }

    // Join the session
    var startGameResult = await _networkRunner.StartGame(new StartGameArgs
    {
        GameMode = GameMode.Shared,
        SessionName = session.Name,
        SceneManager = gameObject.GetComponent<NetworkSceneManagerDefault>()
    });

    if (startGameResult.Ok)
    {
        // Open the main menu and start the game
        MenuStateMachine.ChangeState(MenuStateMachine.mainMenuState);
    }
    else
    {
        Debug.LogError($"Failed to join room: {startGameResult.ErrorMessage}, {startGameResult.ShutdownReason}");
    }
}

private void OnUserEntitlementChecked()
{
    // Try to accept the invitation once the Platform SDK is initialized
    TryAcceptInvitationFromDeepLink();

    // Subscribe to the launch intent changes and accept the invitation in the callback
    ApplicationLifecycle.SetLaunchIntentChangedNotificationCallback(intentChangeMsg =>
    {
        if (!intentChangeMsg.IsError)
        {
            TryAcceptInvitationFromDeepLink();
        }
    });

    async void TryAcceptInvitationFromDeepLink()
    {
        while (!_networkRunner.IsCloudReady)
        {
            await Task.Yield();
        }

        LaunchDetails launchDetails = ApplicationLifecycle.GetLaunchDetails();
        if (string.IsNullOrEmpty(launchDetails.TrackingID))
        {
            return;
        }

        StartGameResult startGameResult = await _networkRunner.StartGame(new StartGameArgs
        {
            GameMode = GameMode.Shared,
            SessionName = launchDetails.MatchSessionID,
            SceneManager = gameObject.GetComponent<NetworkSceneManagerDefault>()
        });

        if (startGameResult.Ok)
        {
            // Open the main menu and start the game
            MenuStateMachine.ChangeState(MenuStateMachine.mainMenuState);
        }
        else
        {
            Debug.LogError($"Failed to join room: {startGameResult.ErrorMessage}, {startGameResult.ShutdownReason}");
        }
    }
}

public class SlingBallShootController : MonoBehaviour
{
    [SerializeField] private Grabbable _grabbable;

    /// Initial position when the ball is pulled back.
    /// HasValue only when the player is performing the drag gesture.
    private Vector3? _pullInitialPosition;

    private void OnEnable() => _grabbable.WhenPointerEventRaised += GrabbableOnWhenPointerEventRaised;
    private void OnDisable() => _grabbable.WhenPointerEventRaised -= GrabbableOnWhenPointerEventRaised;

    private void GrabbableOnWhenPointerEventRaised(PointerEvent pointerEvent)
    {
        switch (pointerEvent.Type)
        {
            case PointerEventType.Select:
                // Record the initial position of the ball
                _pullInitialPosition = transform.parent.position;
                break;
            case PointerEventType.Cancel:
                // Reset the ball when the grab gesture is cancelled
                _pullInitialPosition = null;
                ResetBall();
                break;
            case PointerEventType.Unselect:
                if (_pullInitialPosition.HasValue)
                {
                    float pullDistance = Vector3.Distance(_pullInitialPosition.Value, transform.position);
                    const float minPullDistance = 0.03f;
                    // Launch the ball only when the current pull distance is big enough
                    if (pullDistance < minPullDistance)
                    {
                        CancelDrag();
                    }
                    else
                    {
                        LaunchBall();
                    }
                }
                break;
        }
    }

    private void Update()
    {
        if (_pullInitialPosition.HasValue)
        {
            // Update the ball while the player is performing the drag gesture
            UpdateBallVisual();
            UpdateAimRotation();
            UpdateTrajectory();
        }
    }
}

public class TwoGrabGameVolumeTransformer : MonoBehaviour, ITransformer
{
    void ITransformer.UpdateTransform()
    {
        var grabbable = GetComponent<Grabbable>();
        var grabA = grabbable.GrabPoints[0];
        var grabB = grabbable.GrabPoints[1];
        // Calculate new board pose from two grab points...
        Vector3 position = ...;
        Quaternion rotation = ...;
        transform.SetPositionAndRotation(position, rotation);
        if (IsValidPlacementPose(position, rotation))
        {
            // Hide the invalid placement hint
            HideGhost();
        }
        else
        {
            // Display the hint to the user that the current position is invalid
            DisplayGhost(position, inVolume: true);
        }
    }

public class SpiritSlingButton : MonoBehaviour
{
    [SerializeField] private PokeInteractable _poke;

    private void OnEnable() => _poke.WhenPointerEventRaised += WhenPointerEventRaised;
    private void OnDisable() => _poke.WhenPointerEventRaised -= WhenPointerEventRaised;

    private void WhenPointerEventRaised(PointerEvent pointerEvent)
    {
        switch (pointerEvent.Type)
        {
            case PointerEventType.Select:
                Debug.Log("Button pressed.");
                break;
        }
    }
}