private void DownloadWaterfall(Dictionary <Vector3d, ITileStorer> tileStorer, MapSceneDataControl mapScene, Vector3d[] tiles,
ITileMeta meta, int index, int endIndex, int tries, System.Action <MapSceneDataControl, int, ITilePromise, bool> finished)
{
if (index == endIndex || IsFinished(mapScene))
{
return;
}
if (tries < 5)
{
DownloadTile(tiles[index], meta, tp =>
{
if (tp.Data == null)
{
Debug.Log("Failed to download the tile" + tiles[index] + ", retrying... (" + tries + ")");
DownloadWaterfall(tileStorer, mapScene, tiles, meta, index, endIndex, tries + 1, finished);
}
else
{
finished(mapScene, index, tp, true);
DownloadWaterfall(tileStorer, mapScene, tiles, meta, index + 1, endIndex, 0, finished);
}
});
}
else
{
finished(mapScene, index, null, false);
}
}
public SimpleCachedOnlineTextureTileLoader(ITileMeta tileMeta, long cacheDuration)
{
this.tileMeta = tileMeta;
this.cacheDuration = cacheDuration;
TileProvider.Instance.PublishMeta(tileMeta);
}
private void DownloadTile(Vector2d tile, ITileMeta meta, System.Action <ITilePromise> result)
{
TileProvider.Instance.GetTile(new Vector3d(tile.x, tile.y, 19), meta, (tilePromise) =>
{
result(tilePromise);
});
}
public ITilePromise GetTile(Vector3d tile, ITileMeta tileMeta, Action <ITilePromise> callback)
{
if (!tileCache.ContainsKey(tileMeta))
{
tileCache[tileMeta] = new Dictionary <Vector3d, ITilePromise>();
}
if (tileCache[tileMeta].ContainsKey(tile))
{
callback(tileCache[tileMeta][tile]);
return(tileCache[tileMeta][tile]);
}
foreach (var tileLoader in tileLoaders)
{
if (tileLoader.CanLoadTile(tile, tileMeta))
{
var tilePromise = tileLoader.LoadTile(tile, tileMeta, (tp) =>
{
if (tp.Data == null)
{
tileCache[tp.Meta].Remove(tp.Tile);
}
callback(tp);
});
tileCache[tileMeta][tile] = tilePromise;
return(tilePromise);
}
}
Debug.LogWarning("Couldn't load tile " + tile + " with metatype " + tileMeta.GetType().ToString());
return(null);
}
public ITilePromise LoadTile(Vector3d tile, ITileMeta tileMeta, Action <ITilePromise> callback)
{
var urlTemplate = (string)tileMeta["url-template"];
var url = string.Format(urlTemplate, tile.z, tile.x, tile.y);
var cachePath = GetTilePath(url);
if (TextureExistsInCache(cachePath))
{
if (!HasExpired(cachePath, cacheDuration))
{
var cachePromise = new CachedTextureTilePromise(tile, tileMeta, cachePath, callback);
cachePromise.Load();
return(cachePromise);
}
// If has expired we delete the file
File.Delete(cachePath);
}
// Otherwise we load it from online
var onlinePromise = new OnlineTextureTilePromise(tile, tileMeta, url, (tilePromise) =>
{
var texture = tilePromise.Data as Texture2D;
if (tilePromise.Loaded && texture != null)
{
SavePNG(texture, GetTilePath(url));
}
callback(tilePromise);
});
onlinePromise.Load();
return(onlinePromise);
}
public ITilePromise LoadTile(Vector3d tile, ITileMeta tileMeta, Action <ITilePromise> callback)
{
var resourcesTilePromise =
new ResourcesTilePromise(tile, tileMeta, GetResourcesTilePath(tile, tileMeta), callback);
resourcesTilePromise.Load();
return(resourcesTilePromise);
}
private bool StoreTile(ITileStorer tileStorer, Vector3d tile, ITileMeta tileMeta, ITilePromise tilePromise)
{
if (!tileStorer.StoreTile(tile, tileMeta, tilePromise))
{
Debug.Log("Cannot store tile " + tile + " of " + tileMeta.Identifier);
return(false);
}
return(true);
}
private bool RemoveTile(ITileStorer tileStorer, Vector3d tile, ITileMeta tileMeta)
{
if (!tileStorer.DeleteTile(tile, tileMeta))
{
Debug.Log("Cannot delete tile " + tile + " of " + tileMeta.Identifier);
return(false);
}
return(true);
}
// ##################################
#endregion
#region Metas
// ##################################
public void PublishMeta(ITileMeta meta)
{
var newMetaType = meta.GetType();
if (publicMeta.All(m => m.GetType() != newMetaType))
{
publicMeta.Add(meta);
publicMetaArray = publicMeta.ToArray();
}
}
public bool StoreTile(Vector3d tile, ITileMeta meta, ITilePromise tilePromise)
{
if (tilePromise.Loaded && tilePromise.Data != null)
{
SimpleCachedOnlineTextureTileLoader.SavePNG(tilePromise.Data as Texture2D, OfflineTextureTileLoader.GetFullTilePath(tile, meta));
AssetDatabase.ImportAsset(OfflineTextureTileLoader.GetTilePath(tile, meta));
return(true);
}
return(false);
}
protected TextureTilePromise(Vector3d tile, ITileMeta meta, Action <ITilePromise> callback)
{
if (!loadingTexture)
{
loadingTexture = Resources.Load <Texture2D>("tile_loading");
}
this.Tile = tile;
this.Meta = meta;
this.callback = callback;
}
public bool CanLoadTile(Vector3d tile, ITileMeta tileMeta)
{
if (Application.isPlaying)
{
var mapScenes = Game.Instance.GameState.GetObjects <MapScene>();
var tileBounds = GM.TileBounds(tile.ToVector2d(), (int)tile.z)
.ToPoints()
.Select(p => GM.MetersToLatLon(p))
.ToArray()
.ToRectD();
var tileIsCached = mapScenes.Any(m =>
m.UsesGameplayArea &&
m.TileMetaIdentifier == tileMeta.Identifier &&
m.GameplayArea.Intersects(tileBounds));
return(tileIsCached && Resources.Load <Texture2D>(GetResourcesTilePath(tile, tileMeta)));
}
return(false);
}
public CachedTextureTilePromise(Vector3d tile, ITileMeta tileMeta, string path, Action <ITilePromise> callback) : base(tile,
tileMeta, callback)
{
this.path = path;
}
public static string GetFullTilePath(Vector3d tile, ITileMeta tileMeta)
{
return(string.Format(FullTilePath, tileMeta.Identifier, tile.z, tile.x, tile.y));
}
public OnlineTextureTilePromise(Vector3d tile, ITileMeta tileMeta, string url, Action <ITilePromise> callback) : base(tile, tileMeta, callback)
{
this.url = url;
}
public bool CanLoadTile(Vector3d tile, ITileMeta tileMeta)
{
return(tileMeta == this.tileMeta || tileMeta.Identifier == this.tileMeta.Identifier ||
tileMeta.GetType() == this.tileMeta.GetType());
}
private Dictionary <Vector3d, ITileStorer> GetNonCollidingStorableTiles(bool useArea, List <AreaMeta> allAreas, AreaMeta area, bool useExtraArea, AreaMeta extraArea, ITileMeta tileMeta)
{
var storableTiles = new Dictionary <Vector3d, ITileStorer>();
if (!useArea)
{
return(storableTiles);
}
var nonCollidingTiles = TileUtil.NonCollidingTiles(area, allAreas, extraArea, useExtraArea).ToList();
foreach (var tile in nonCollidingTiles)
{
var tile3d = new Vector3d(tile.x, tile.y, 19);
var tileStorer = tileStorers.Find(ts => ts.CanStoreTile(tile3d, tileMeta));
if (tileStorer == null)
{
Debug.LogError("Cannot find valid storer for tile " + tile3d);
return(null);
}
storableTiles.Add(tile3d, tileStorer);
}
return(storableTiles);
}
public bool DeleteTile(Vector3d tile, ITileMeta meta)
{
return(AssetDatabase.DeleteAsset(OfflineTextureTileLoader.GetTilePath(tile, meta)));
}
public ResourcesTilePromise(Vector3d tile, ITileMeta tileMeta, string path, Action <ITilePromise> callback) : base(tile,
tileMeta, callback)
{
this.path = path;
}
public bool CanStoreTile(Vector3d tile, ITileMeta meta)
{
return(meta.Attributes.Contains(ContentTypeAttr) && string.Equals(ContentTypeValue,
meta[ContentTypeAttr] as string, StringComparison.InvariantCultureIgnoreCase));
}
