public GenericTile DataToTile(UniTileData data)
{
string name = mapping.ContainsKey(data.OriginalSpriteName)
? data.OriginalSpriteName
: data.Name.Split('(')[0].Trim();
if (!mapping.ContainsKey(name))
{
Debug.LogError("Missing tile for key: " + name);
return(null);
}
string assetPath = Path.Combine(tilePath, mapping[name] + ".asset");
if (!File.Exists(assetPath))
{
string altAssetPath = Path.Combine(tilePath, mapping[name] + "_0.asset");
if (File.Exists(altAssetPath))
{
assetPath = altAssetPath;
}
else
{
Debug.LogError("Missing tile at path: " + assetPath + " (key: " + name + " )");
return(null);
}
}
return(AssetDatabase.LoadAssetAtPath <GenericTile>(assetPath));
}
public GenericTile DataToTile(UniTileData data)
{
string name = mapping.ContainsKey(data.OriginalSpriteName)
? data.OriginalSpriteName
: data.Name.Split('(')[0].Trim();
if (!mapping.ContainsKey(name))
{
Logger.LogErrorFormat("Missing tile for key: {0}", Category.TileMaps, name);
return(null);
}
string assetPath = Path.Combine(tilePath, mapping[name] + ".asset");
if (!File.Exists(assetPath))
{
string altAssetPath = Path.Combine(tilePath, mapping[name] + "_0.asset");
if (File.Exists(altAssetPath))
{
assetPath = altAssetPath;
}
else
{
Logger.LogErrorFormat("Missing tile at path: {0} (key: {1} )", Category.TileMaps, assetPath, name);
return(null);
}
}
return(AssetDatabase.LoadAssetAtPath <GenericTile>(assetPath));
}
private static UniTile DataToTile(UniTileData data)
{
var tile = ScriptableObject.CreateInstance <UniTile>();
tile.name = data.Name;
var c = data.ChildTransform;
var p = data.Transform;
//upscaling TC tiles for eye candy, fixme: you will want to turn that off later when new tileconnect is ready
if (data.SpriteName.StartsWith(TC))
{
SetXyScale(ref p, 2);
}
tile.transform = CombineTransforms(p, c); //customMainTransform;//experimental
tile.ChildTransform = c; //not being interpreted by Tilemap
tile.colliderType = data.ColliderType;
//generate asset here?
tile.sprite = data.IsLegacy ? SpriteManager.Instance.dmi.getSpriteFromLegacyName(data.SpriteSheet, data.SpriteName)
: SpriteManager.Instance.dmi.getSprite(data.SpriteSheet, data.SpriteName);
return(tile);
}
private static bool looksLikeLegacy(string assetPath, UniTileData instance)
{
return(assetPath.Contains("textures") && !instance.SpriteName.StartsWith(TC));
}
public void Add(int x, int y, UniTileData tile)
{
tilePositions.Add(new XYCoord(x, y));
tiles.Add(tile);
}
static void Map2JSON()
{
AssetDatabase.Refresh();
var nodesMapped = MapToPNG.GetMappedNodes();
var tilemapLayers = new SortedDictionary <string, TilemapLayer>(Comparer <string> .Create(CompareSpriteLayer));
var tempGameObjects = new List <GameObject>();
for (int y = 0; y < nodesMapped.GetLength(0); y++)
{
for (int x = 0; x < nodesMapped.GetLength(1); x++)
{
var node = nodesMapped[y, x];
if (node == null)
{
continue;
}
var nodeRenderers = new List <SpriteRenderer>();
var objectsToExport = node.GetTiles();
node.GetItems().ForEach(behaviour => objectsToExport.Add(behaviour.gameObject));
foreach (var tile in objectsToExport)
{
var tileRenderers = tile.GetComponentsInChildren <SpriteRenderer>();
if (tileRenderers == null || tileRenderers.Length < 1)
{
continue;
}
var tileconnects = 0;
foreach (var renderer in tileRenderers)
{
if (thisRendererSucks(renderer) || renderer.sortingLayerID == 0)
{
continue;
}
TryMoveToSeparateLayer(renderer);
if (renderer.GetComponent <TileConnect>() || IsTileConnectWannabe(renderer))
{
tileconnects++;
if (tileconnects != 4)
{
continue;
}
if (tileconnects > 4)
{
Debug.LogWarningFormat("{0} — more than 4 tileconnects found!", renderer.name);
}
// grouping four tileconnect sprites into a single temporary thing
GameObject tcMergeGameObject = Instantiate(renderer.gameObject, tile.transform.position,
Quaternion.identity, tile.transform);
tempGameObjects.Add(tcMergeGameObject);
var childClone = tcMergeGameObject.GetComponent <SpriteRenderer>();
var spriteName = childClone.sprite.name;
if (spriteName.Contains("_"))
{
childClone.name = TC + spriteName.Substring(0,
spriteName.LastIndexOf("_", StringComparison.Ordinal));
}
nodeRenderers.Add(childClone);
}
else
{
renderer.name = renderer.sprite.name;
if (DuplicateFound(renderer, nodeRenderers))
{
Debug.LogFormat("Skipping {0}({1}) as duplicate", renderer.name, GetSortingLayerName(renderer));
continue;
}
var uniqueSortingOrder = GetUniqueSortingOrder(renderer, nodeRenderers);
if (!uniqueSortingOrder.Equals(renderer.sortingOrder))
{
renderer.sortingOrder = uniqueSortingOrder;
}
nodeRenderers.Add(renderer);
}
}
}
foreach (var renderer in nodeRenderers)
{
var currentLayerName = GetSortingLayerName(renderer);
TilemapLayer tilemapLayer;
if (tilemapLayers.ContainsKey(currentLayerName))
{
tilemapLayer = tilemapLayers[currentLayerName];
}
else
{
tilemapLayer = new TilemapLayer();
tilemapLayers[currentLayerName] = tilemapLayer;
}
if (tilemapLayer == null)
{
continue;
}
UniTileData tileDataInstance = CreateInstance <UniTileData>();
var parentObject = renderer.transform.parent.gameObject;
if (parentObject)
{
tileDataInstance.Name = parentObject.name;
}
var childtf = renderer.transform;
var parenttf = renderer.transform.parent.gameObject.transform;
//don't apply any rotation for tileconnects
var isTC = renderer.name.StartsWith(TC);
var zeroRot = Quaternion.Euler(0, 0, 0);
tileDataInstance.ChildTransform =
Matrix4x4.TRS(childtf.localPosition, isTC ? zeroRot : childtf.localRotation, childtf.localScale);
tileDataInstance.Transform =
Matrix4x4.TRS(parenttf.position, isTC ? zeroRot : parenttf.localRotation, parenttf.localScale);
tileDataInstance.OriginalSpriteName = renderer.sprite.name;
tileDataInstance.SpriteName = renderer.name;
var assetPath = AssetDatabase.GetAssetPath(renderer.sprite.GetInstanceID());
tileDataInstance.IsLegacy = looksLikeLegacy(assetPath, tileDataInstance) && !isExcluded(assetPath);
string sheet = assetPath
.Replace("Assets/Resources/", "")
.Replace("Assets/textures/", "")
.Replace("Resources/", "")
.Replace(".png", "");
string overrideSheet;
tileDataInstance.SpriteSheet = IsTileConnectWannabe(renderer, out overrideSheet) ? overrideSheet : sheet;
tilemapLayer.Add(x, y, tileDataInstance);
}
}
}
foreach (var layer in tilemapLayers)
{
Debug.LogFormat("{0}: {1}", layer.Key, layer.Value);
}
fsData data;
new fsSerializer().TrySerialize(tilemapLayers, out data);
File.WriteAllText(Application.dataPath + "/Resources/metadata/" + SceneManager.GetActiveScene().name + ".json",
fsJsonPrinter.PrettyJson(data));
//Cleanup
foreach (var o in tempGameObjects)
{
DestroyImmediate(o);
}
Debug.Log("Export kinda finished");
AssetDatabase.Refresh();
}
