# PlayResolver

The PlayResolver encapsulates all the internals to fetch and join both rooms and worlds. 

```
using Coherence.Runtime;

// ensure connection to the play services backend
async Task<bool> PlayResolver.EnsurePlayConnection();
```

### Rooms API

Detailed usage can be found in [Rooms](/0.7.4/api-reference/network-sdk/rooms.md#rooms-api).

```
// Returns "local" as the region if local server is running.
async Task<string> FetchLocalRegions()

// Returns all the regions where rooms are enabled in the portal.
async Task<IReadOnlyList<string>> FetchRegions()

// Fetch a list of rooms currently active in the given region.
// Optionally, filter by tags provided when creating the room.
async Task<IReadOnlyList<RoomData>> FetchRooms(string region, string[] tags = null)

// Create a new room in the region. 
// Sample UI uses key value to set/get room names.
async Task<RoomData> CreateRoom(string region,
                                int maxClients = 10,
                                string[] tags = null, 
                                Dictionary<string, string> keyValues = null)

// Start connecting to the room. 
// IClient can be accessed through 
// MonoBridgeStore.GetBrige(gameObject.scene).Client
// connection success and can be monitored using IClient.OnConnected, etc events.
void JoinRoom(IClient client, RoomData room)

// Convert RoomData to EndpointData, to call IClient.Connect(endpoint) directly.
// The second return value is false if the room data is invalid. 
(EndpointData, bool) GetRoomEndpointData(RoomData room)
```

Example usage for Rooms API

```
using Coherence.Runtime;
using UnityEngine;

public class CreatorAndJoiner : MonoBehaviour
{
    private async void Start()
    {
        var client = MonoBridgeStore.GetBridge(gameObject.scene).Client;
        // XXX: try-catch everything
        var regions = await PlayResolver.FetchRegions();
        var rooms = await PlayResolver.FetchRooms(regions[0]);
        if (rooms.Count == 0)
        {
            var room = await PlayResolver.CreateRoom(regions[0]);
            PlayResolver.JoinRoom(client, room);
        }
        else
        {
            PlayResolver.JoinRoom(rooms[0]);
        }
    }
}
```

### Worlds API

Detailed usage can be found in [Worlds](/0.7.4/api-reference/network-sdk/worlds.md#worlds-api).

```
// Returns true if a local worlds replication server is running.
async Task<bool> EnsureLocalServer()

// Fetches the connection data for local replication server.
async Task<WorldData> FetchLocalWorld()

// Fetches a list of worlds from the portal.
async Task<IReadOnlyList<WorldData>> FetchWorlds()

// Start connecting to the world. 
// IClient can be accessed through 
// MonoBridgeStore.GetBrige(gameObject.scene).Client
// connection success and can be monitored using IClient.OnConnected, etc events.
// Can also join as a simulator.
void JoinWorld(IClient client, WorldData data, bool isSimulator = false)

// Convert WorldData into EndpointData, to call IClient.Connect(endpoint) directly.
// The second return value is false if the world data is invalid. 
(EndpointData, bool) GetWorldEndpoint(WorldData world)
```

Example usage for Worlds API

```
using Coherence.Runtime;
using UnityEngine;

public class WorldJoiner : MonoBehaviour
{
    private async void Start()
    {
        var client = MonoBridgeStore.GetBridge(gameObject.scene).Client;
        // XXX: try-catch everything
        var worlds = await PlayResolver.FetchWorlds();
        if (worlds.Count > 0)
        {
            PlayResolver.JoinWorld(client, worlds[0]);
        }
    }
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.coherence.io/0.7.4/api-reference/network-sdk/playresolver.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.