IEnumerator MoveCamera(Vector2 coords, int zoom)
        {     
            float currentZoom = OnlineMaps.instance.zoom;

            double currentLon;
            double currentLat;
            OnlineMaps.instance.GetPosition(out currentLon, out currentLat);

            while (Mathf.Abs((float)currentLon - coords.y) > 0.01f || Mathf.Abs((float)currentLat - coords.x) > 0.01f)
            {
                currentLon = Mathf.Lerp((float)currentLon, coords.y, 0.45f);
                currentLat = Mathf.Lerp((float)currentLat, coords.x, 0.45f);
                currentZoom = Mathf.Lerp((float)currentZoom, zoom, 0.65f);

                OnlineMaps.instance.SetPositionAndZoom(currentLon, currentLat, currentZoom);

                yield return null;
            }

            UnlockCamera();
        }

using System.Collections;
using System.IO;
using UnityEngine;

public class RasterizeDrawingForOverlay : MonoBehaviour
{
    public int zoomFrom = 1;
    public int zoomTo = 10;

    private bool started = false;
    private IEnumerator routine;
    private Texture2D texture;
    private Color32[] colors;
    private OnlineMaps map;

    private void Finish()
    {
        Destroy(texture);
        texture = null;
        colors = null;
        map = null;

#if UNITY_EDITOR
        UnityEditor.AssetDatabase.Refresh();
#endif
    }

    private void GetBounds(out double lx, out double ty, out double rx, out double by)
    {
        lx = double.MaxValue;
        ty = double.MinValue;
        rx = double.MinValue;
        by = double.MaxValue;

        foreach (var el in OnlineMapsDrawingElementManager.instance)
        {
            if (el is OnlineMapsDrawingRect)
            {
                OnlineMapsDrawingRect rect = el as OnlineMapsDrawingRect;
                UpdateBounds(ref lx, ref ty, ref rx, ref by, rect.x, rect.y);
                UpdateBounds(ref lx, ref ty, ref rx, ref by, rect.x + rect.width, rect.y + rect.height);
                continue;
            }

            IEnumerable points;
            if (el is OnlineMapsDrawingLine) points = (el as OnlineMapsDrawingLine).points;
            else if (el is OnlineMapsDrawingPoly) points = (el as OnlineMapsDrawingPoly).points;
            else continue;

            int valueType = -1; // 0 - Vector2, 1 - float, 2 - double, 3 - OnlineMapsVector2d
            object v1 = null;
            int i = -1;
            double ppx = 0;

            foreach (object p in points)
            {
                i++;

                if (valueType == -1)
                {
                    if (p is Vector2) valueType = 0;
                    else if (p is float) valueType = 1;
                    else if (p is double) valueType = 2;
                    else if (p is OnlineMapsVector2d) valueType = 3;
                }

                object v2 = v1;
                v1 = p;

                double px = 0;
                double py = 0;

                if (valueType == 0)
                {
                    if (i == 0)
                    {
                        Vector2 p1 = (Vector2)v1;
                        ppx = p1.x;
                        UpdateBounds(ref lx, ref ty, ref rx, ref by, p1.x, p1.y);
                        continue;
                    }

                    Vector2 v = (Vector2) v1;
                    px = v.x;
                    py = v.y;
                }
                else if (valueType == 3)
                {
                    if (i == 0)
                    {
                        OnlineMapsVector2d p1 = (OnlineMapsVector2d)v1;
                        ppx = p1.x;
                        UpdateBounds(ref lx, ref ty, ref rx, ref by, p1.x, p1.y);
                        continue;
                    }

                    Vector2 v = (OnlineMapsVector2d)v1;
                    px = v.x;
                    py = v.y;
                }
                else if (i % 2 == 1)
                {
                    if (i == 1)
                    {
                        if (valueType == 1)
                        {
                            ppx = (float)v2;
                            UpdateBounds(ref lx, ref ty, ref rx, ref by, ppx, (float)v1);
                        }
                        else
                        {
                            ppx = (double)v2;
                            UpdateBounds(ref lx, ref ty, ref rx, ref by, ppx, (double)v1);
                        }
                        continue;
                    }

                    if (valueType == 1)
                    {
                        px = (float) v2;
                        py = (float) v1;
                    }
                    else
                    {
                        px = (double) v2;
                        py = (double) v1;
                    }
                }

                while (true)
                {
                    double ox = px - ppx;

                    if (ox > 180) px -= 360;
                    else if (ox < -180) px += 360;
                    else break;
                }

                UpdateBounds(ref lx, ref ty, ref rx, ref by, px, py);

                ppx = px;
            }
        }
    }

    private void OnGUI()
    {
        if (!started)
        {
            if (GUILayout.Button("Rasterize"))
            {
                routine = Rasterize();
                StartCoroutine(routine);
            }
        }
        else
        {
            if (GUILayout.Button("Cancel"))
            {
                StopCoroutine(routine);
                Finish();
            }
        }
    }

    public IEnumerator Rasterize()
    {
        if (OnlineMapsDrawingElementManager.CountItems == 0) yield break;

        double lx, ty, rx, by;
        GetBounds(out lx, out ty, out rx, out by);

        map = OnlineMaps.instance;
        texture = new Texture2D(256, 256, TextureFormat.ARGB32, false);
        colors = new Color32[256 * 256];

        for (int z = zoomFrom; z <= zoomTo; z++)
        {
            int max = 1 << z;

            double tlx, tty, trx, tby;
            map.projection.CoordinatesToTile(lx, ty, z, out tlx, out tty);
            map.projection.CoordinatesToTile(rx, by, z, out trx, out tby);

            int ilx = (int) tlx;
            int ity = (int) tty;
            int irx = (int) trx;
            int iby = (int) tby;

            if (ilx > irx) irx += max;

            for (int x = ilx; x <= irx; x++)
            {
                int cx = x;
                if (cx >= max) cx -= max;

                for (int y = ity; y <= iby; y++)
                {
                    yield return RasterizeTile(z, cx, y);
                }
            }
        }

        Finish();
    }

    private IEnumerator RasterizeTile(int zoom, int x, int y)
    {
        yield return null;

        Color32 empty = new Color32(255, 255, 255, 0);
        for (int i = 0; i < 256 * 256; i++) colors[i] = empty;

        Vector2 bufferPos = map.buffer.topLeftPosition;
        double sx, sy;
        map.projection.TileToCoordinates(bufferPos.x, bufferPos.y, map.buffer.lastState.zoom, out sx, out sy);

        Vector2 bufferPosition = new Vector2(x, y);

        foreach (OnlineMapsDrawingElement el in map.control.drawingElementManager)
        {
            el.Draw(colors, bufferPosition, 256, 256, zoom);
        }

        bool hasColor = false;
        for (int i = 0; i < 256 * 256; i++)
        {
            if (colors[i].a != 0)
            {
                hasColor = true;
                break;
            }
        }

        if (!hasColor)
        {
            Debug.Log("Ignore " + zoom + "/" + x + "/" + y);
            yield break;
        }

        texture.SetPixels32(colors);
        texture.Apply(false);

        byte[] bytes = texture.EncodeToPNG();

        string path = Application.dataPath + "/Resources/DrawingTiles/" + zoom + "/" + x + "/" + y + ".png";
        Debug.Log(path);
        FileInfo info = new FileInfo(path);
        if (!info.Directory.Exists) info.Directory.Create();

        File.WriteAllBytes(path, bytes);
    }

    private static void UpdateBounds(ref double lx, ref double ty, ref double rx, ref double by, double px, double py)
    {
        if (px < lx) lx = px;
        if (px > rx) rx = px;

        if (py > ty) ty = py;
        if (py < by) by = py;
    }
}

manager.map.projection.CoordinatesToTile(tlx, tly, izoom, out sx, out sy);

manager.map.projection.CoordinatesToTile(0, 0, izoom, out sx, out sy);

/*     INFINITY CODE 2013-2018      */
/*   http://www.infinity-code.com   */

using System.Collections.Generic;
using ExitGames.Client.Photon;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using Random = UnityEngine.Random;

namespace InfinityCode.OnlineMapsExamples
{
    /// <summary>
    /// Example of how to display the location of several users on the map at the same time usign Photon PUN2.
    /// Drag the player marker to move it synchronously for all clients.
    /// </summary>
    public class SyncDraggingUsingPhoton : MonoBehaviourPunCallbacks
    {
        /// <summary>
        /// Dictionary of other players
        /// </summary>
        public Dictionary<string, OnlineMapsMarker3D> otherPlayers;

        /// <summary>
        /// Array of marker prefabs
        /// </summary>
        public GameObject[] prefabs;

        /// <summary>
        /// Reference to the map
        /// </summary>
        private OnlineMaps map;

        /// <summary>
        /// Reference to the control
        /// </summary>
        private OnlineMapsTileSetControl control;

        /// <summary>
        /// Creates a marker for another player, and sets the position
        /// </summary>
        /// <param name="player"></param>
        private void CreateOtherPlayer(Player player)
        {
            // Get player properties
            Hashtable props = player.CustomProperties;
            double longitude = (double)props["longitude"];
            double latitude = (double)props["latitude"];
            int prefabIndex = (int)props["prefab_index"];
            string id = player.UserId;

            // Create a new marker
            OnlineMapsMarker3D marker = OnlineMapsMarker3DManager.CreateItem(longitude, latitude, prefabs[prefabIndex]);
            marker.label = player.NickName;
            otherPlayers.Add(id, marker);
        }

        /// <summary>
        /// Called when the client is connected to the Master Server and ready for matchmaking and other tasks
        /// </summary>
        public override void OnConnectedToMaster()
        {
            // Create a new room or connect to an existing one
            RoomOptions roomOptions = new RoomOptions();
            roomOptions.IsVisible = false;
            roomOptions.MaxPlayers = 4;
            roomOptions.PublishUserId = true;
            PhotonNetwork.JoinOrCreateRoom("Test Room", roomOptions, TypedLobby.Default);

            double tlx, tly, brx, bry;
            map.GetCorners(out tlx, out tly, out brx, out bry);

            // Create current player marker
            int prefabIndex = Random.Range(0, prefabs.Length);
            double longitude = Random.Range((float)tlx, (float)brx);
            double latitude = Random.Range((float)bry, (float)tly);
            OnlineMapsMarker3D marker = OnlineMapsMarker3DManager.CreateItem(longitude, latitude, prefabs[prefabIndex]);
            marker.label = "My Player";

            // Make a marker draggable, and subscribe to the drag event
            marker.SetDraggable();
            marker.OnDrag += OnDrag;

            // Center the map on the marker
            map.position = marker.position;

            // Create initial properties
            Hashtable hashtable = new Hashtable
            {
                {"prefab_index", prefabIndex},
                {"longitude", longitude},
                {"latitude", latitude}
            };
            PhotonNetwork.SetPlayerCustomProperties(hashtable);
        }

        /// <summary>
        /// Called when dragging a player marker
        /// </summary>
        /// <param name="marker">Player marker</param>
        private void OnDrag(OnlineMapsMarkerBase marker)
        {
            // Update location in player properties
            double longitude, latitude;
            marker.GetPosition(out longitude, out latitude);
            Hashtable hashtable = new Hashtable
            {
                {"longitude", longitude},
                { "latitude", latitude}
            };

            PhotonNetwork.SetPlayerCustomProperties(hashtable);
        }

        /// <summary>
        /// Called when the LoadBalancingClient entered a room, no matter if this client created it or simply joined
        /// </summary>
        public override void OnJoinedRoom()
        {
            // Create markers for other players.
            foreach (KeyValuePair<int, Player> pair in PhotonNetwork.CurrentRoom.Players)
            {
                Player player = pair.Value;
                if (player.IsLocal) continue;
                CreateOtherPlayer(player);
            }
        }

        /// <summary>
        /// Called when a remote player entered the room. This Player is already added to the playerlist
        /// </summary>
        /// <param name="otherPlayer">The player who entered the room</param>
        public override void OnPlayerEnteredRoom(Player otherPlayer)
        {
            CreateOtherPlayer(otherPlayer);
        }

        /// <summary>
        /// Called when a remote player left the room or became inactive
        /// </summary>
        /// <param name="otherPlayer">The player who left the room</param>
        public override void OnPlayerLeftRoom(Player otherPlayer)
        {
            OnlineMapsMarker3D marker;
            if (otherPlayers.TryGetValue(otherPlayer.UserId, out marker))
            {
                otherPlayers.Remove(otherPlayer.UserId);
                OnlineMapsMarker3DManager.RemoveItem(marker);
            }
        }

        /// <summary>
        /// Called when custom player-properties are changed
        /// </summary>
        /// <param name="targetPlayer">Player that changed</param>
        /// <param name="changedProps">Properties that changed</param>
        public override void OnPlayerPropertiesUpdate(Player targetPlayer, Hashtable changedProps)
        {
            if (targetPlayer.IsLocal) return;

            // Update player marker location
            double longitude = (double)changedProps["longitude"];
            double latitude = (double)changedProps["latitude"];

            string id = targetPlayer.UserId;
            OnlineMapsMarker3D marker;

            if (otherPlayers.TryGetValue(id, out marker))
            {
                marker.SetPosition(longitude, latitude);
                map.Redraw();
            }
        }

        private void Start()
        {
            map = OnlineMaps.instance;
            control = OnlineMapsTileSetControl.instance;
            otherPlayers = new Dictionary<string, OnlineMapsMarker3D>();

            // Connect to Photon as configured in the PhotonServerSettings file
            PhotonNetwork.LocalPlayer.NickName = "Player " + Random.Range(0, 100000);
            PhotonNetwork.ConnectUsingSettings();
        }
    }
}