public bool CanMergeBoxColliderWith(UniTileTile b, int aX, int aY, int bX, int bY, bool aFlippedH, bool aFlippedV, TileInstance.Rotation aRotation, bool bFlippedH, bool bFlippedV, TileInstance.Rotation bRotation, Vector2 tileSize)
{
if(b == null) return false;
Rect aRect = TileLayerUtil.TransformRect(boxDimensions, tileSize / 2f, aFlippedH, aFlippedV, aRotation);
Rect bRect = TileLayerUtil.TransformRect(b.boxDimensions, tileSize / 2f, bFlippedH, bFlippedV, bRotation);
return b != null
&& b.boxCollider
&& boxDepth == b.boxDepth
&& boxLayer == b.boxLayer
&& boxMaterial == b.boxMaterial
&& boxTag == b.boxTag
&& boxPrefab == b.boxPrefab
&& (
(
!customBoxDimensions
&& !b.customBoxDimensions
) || (
customBoxDimensions && b.customBoxDimensions && aRect == bRect
&& (
(
aY == bY &&
aRect.x == 0 && aRect.xMax == tileSize.x
) || (
aX == bX &&
aRect.y == 0 && aRect.yMax == tileSize.y
)
)
)
);
}
public float GetBoxDepth(int x, int y)
{
UniTileTile tile = GetTile(x, y);
if (tile == null)
{
return(0);
}
return(tile.boxDepth);
}
public int GetBoxLayer(int x, int y)
{
UniTileTile tile = GetTile(x, y);
if (tile == null)
{
return(0);
}
return(tile.boxLayer);
}
public string GetBoxTag(int x, int y)
{
UniTileTile tile = GetTile(x, y);
if (tile == null)
{
return(null);
}
return(tile.boxTag);
}
public bool HasBox(int x, int y)
{
UniTileTile tile = GetTile(x, y);
if (tile == null)
{
return(false);
}
return(tile.boxCollider);
}
public float GetValue(int x, int y)
{
UniTileTile tile = GetTile(x, y);
if (tile == null)
{
return(0);
}
return(tile.value);
}
public string GetName(int x, int y)
{
UniTileTile tile = GetTile(x, y);
if (tile == null)
{
return(null);
}
return(tile.name);
}
public GameObject GetPrefab(int x, int y)
{
UniTileTile tile = GetTile(x, y);
if (tile == null)
{
return(null);
}
return(tile.prefab);
}
public void Save()
{
GameObject g = null;
UniTileTileset tileset;
g = (GameObject)Instantiate(layer.tileset.gameObject);
tileset = g.GetComponent <UniTileTileset>();
this.ResizeArray();
foreach (TileInstance selectedTile in this.selectedTiles)
{
if (tileset.tiles[selectedTile.id] == null)
{
tileset.tiles[selectedTile.id] = new UniTileTile();
}
UniTileTile tile = tileset.tiles[selectedTile.id];
tile.properties = new UniTileProperty[propertiesLength];
for (int i = 0; i < this.propertiesLength; i++)
{
tile.properties[i] = new UniTileProperty();
tile.properties[i].key = this.properties[i].key;
tile.properties[i].value = this.properties[i].value;
}
tile.prefab = this.prefab;
tile.name = this.name;
tile.value = this.value;
tile.boxCollider = this.boxCollider;
tile.resizable = this.resizable;
tile.boxLayer = this.boxLayer;
tile.boxMaterial = this.boxMaterial;
tile.boxTag = this.boxTag;
tile.boxDepth = this.boxDepth;
tile.boxPrefab = this.boxPrefab;
tile.prefabOffset = this.prefabOffset;
tile.customBoxDimensions = this.customBoxDimensions;
tile.boxDimensions = this.boxDimensions;
}
#if (UNITY_3_5 || UNITY_3_6 || UNITY_3_7 || UNITY_3_8 || UNITY_3_9)
PrefabUtility.ReplacePrefab(g, layer.tileset.gameObject);
#else
PrefabUtility.ReplacePrefab(g, layer.tileset.gameObject);
#endif
DestroyImmediate(g);
}
public bool CanMergeBoxColliders(int aX, int aY, int bX, int bY)
{
TileInstance tileInstanceA = GetTileData(aX, aY);
TileInstance tileInstanceB = GetTileData(bX, bY);
if (tileInstanceA == null || tileInstanceB == null)
{
return(false);
}
else
{
UniTileTile tileA = GetTile(aX, aY);
return(tileA.CanMergeBoxColliderWith(GetTile(bX, bY), aX, aY, bX, bY, tileInstanceA.flippedHorizontally, tileInstanceA.flippedVertically, tileInstanceA.rotation, tileInstanceB.flippedHorizontally, tileInstanceB.flippedVertically, tileInstanceB.rotation, this.tileSpacing));
}
}
public string GetProperty(int x, int y, string key)
{
UniTileTile tile = GetTile(x, y);
if (tile == null)
{
return(null);
}
for (int i = 0; i < tile.properties.Length; i++)
{
if (tile.properties[i].key == key)
{
return(tile.properties[i].value);
}
}
return(null);
}
public bool CanMergeBoxColliderWith(UniTileTile b, int aX, int aY, int bX, int bY, bool aFlippedH, bool aFlippedV, TileInstance.Rotation aRotation, bool bFlippedH, bool bFlippedV, TileInstance.Rotation bRotation, Vector2 tileSize)
{
if (b == null)
{
return(false);
}
Rect aRect = TileLayerUtil.TransformRect(boxDimensions, tileSize / 2f, aFlippedH, aFlippedV, aRotation);
Rect bRect = TileLayerUtil.TransformRect(b.boxDimensions, tileSize / 2f, bFlippedH, bFlippedV, bRotation);
return(b != null &&
b.boxCollider &&
boxDepth == b.boxDepth &&
boxLayer == b.boxLayer &&
boxMaterial == b.boxMaterial &&
boxTag == b.boxTag &&
boxPrefab == b.boxPrefab &&
(
(
!customBoxDimensions &&
!b.customBoxDimensions
) || (
customBoxDimensions && b.customBoxDimensions && aRect == bRect &&
(
(
aY == bY &&
aRect.x == 0 && aRect.xMax == tileSize.x
) || (
aX == bX &&
aRect.y == 0 && aRect.yMax == tileSize.y
)
)
)
));
}
public void Setup(TileLayerEditor editor, TileInstance[] selectedTiles)
{
if (selectedTiles.Length == 0)
{
Debug.LogError("No tiles selected! Only use TileEditorWindow if tiles have been selected");
this.Close();
return;
}
int selectedTile = selectedTiles[0].id;
this.editor = editor;
this.selectedTiles = selectedTiles;
this.layer = editor.target as TileLayer;
this.boxDepth = 64;
this.boxTag = "Untagged";
if (layer.tileset != null)
{
this.ResizeArray();
UniTileTile tile = layer.tileset.tiles[selectedTile];
if (tile != null)
{
this.prefab = tile.prefab;
this.name = tile.name;
this.value = tile.value;
this.boxCollider = tile.boxCollider;
this.resizable = tile.resizable;
this.boxLayer = tile.boxLayer;
this.boxMaterial = tile.boxMaterial;
this.boxTag = tile.boxTag;
this.boxDepth = tile.boxDepth;
this.boxPrefab = tile.boxPrefab;
this.prefabOffset = tile.prefabOffset;
if (this.prefab == null)
{
this.prefabOffset = new Vector2(this.layer.tileSpacing.x / 2f, this.layer.tileSpacing.y / 2f);
}
this.customBoxDimensions = tile.customBoxDimensions;
if (!this.customBoxDimensions)
{
this.boxDimensions = new Rect(0, 0, this.layer.tileSpacing.x, this.layer.tileSpacing.y);
}
else
{
this.boxDimensions = tile.boxDimensions;
}
if (tile.properties != null)
{
this.properties = new UniTileProperty[tile.properties.Length];
for (int i = 0; i < this.properties.Length; i++)
{
this.properties[i] = new UniTileProperty();
this.properties[i].key = tile.properties[i].key;
this.properties[i].value = tile.properties[i].value;
}
}
else
{
this.properties = new UniTileProperty[0];
}
}
}
if (this.properties == null)
{
this.properties = new UniTileProperty[0];
}
this.propertiesLength = this.properties.Length;
if (this.name == null)
{
this.name = "";
}
}
/*
* public static void RedrawGroupForTiles(TileLayer layer, TilePos[] tiles)
* {
* List<GroupPos> groups = new List<GroupPos>();
* foreach(TilePos tile in tiles)
* {
* GroupPos group = TileToGroup(layer, tile);
* if(!groups.Contains(group))
* groups.Add(group);
* }
*
* foreach(GroupPos group in groups)
* {
* RedrawGroup(layer, group.x, group.y);
* }
* }
*/
public static void RedrawGroup(TileLayer layer, int groupX, int groupY)
{
if (layer == null)
{
return;
}
if (layer.parent != null)
{
layer = layer.parent;
}
GameObject g;
Transform t = layer.GroupRoot.FindChild("group_" + groupX + "_" + groupY);
Mesh m;
if (t == null)
{
g = new GameObject("group_" + groupX + "_" + groupY);
t = g.transform;
t.transform.parent = layer.GroupRoot;
t.localPosition = new Vector3(groupX * layer.tileSpacing.x * layer.groupSize.x, groupY * layer.tileSpacing.y * layer.groupSize.y);
t.localScale = new Vector3(1, 1, 1);
Quaternion quaternion = t.localRotation;
quaternion.eulerAngles = new Vector3(0, 0, 0);
t.localRotation = quaternion;
MeshRenderer r = g.AddComponent <MeshRenderer>();
MeshFilter f = g.AddComponent <MeshFilter>();
m = f.sharedMesh = new Mesh();
r.material = layer.material;
}
else
{
g = t.gameObject;
MeshFilter f = t.GetComponent <MeshFilter>();
GameObject.DestroyImmediate(f.sharedMesh);;
m = f.sharedMesh = new Mesh();
}
//ArrayList temp = new ArrayList();
List <Hashtable> temp = new List <Hashtable>();
List <TileLayer> layers = new List <TileLayer>();
layers.Add(layer);
for (int i = 0; i < layer.transform.childCount; i++)
{
TileLayer child = layer.transform.GetChild(i).GetComponent <TileLayer>();
if (child != null)
{
layers.Add(child);
}
}
layers.Sort(delegate(TileLayer l1, TileLayer l2)
{ return((l2 == layer?0f:l2.transform.localPosition.z).CompareTo(l1 == layer?0f:l1.transform.localPosition.z)); });
for (int c = 0; c < layers.Count; c++)
{
TileLayer lyr = layers[c];
Hashtable skip = new Hashtable();
for (int i = groupX * (int)lyr.groupSize.x; i < Mathf.Min(lyr.layerSize.x, groupX * (int)lyr.groupSize.x + lyr.groupSize.x); i++)
{
for (int j = groupY * (int)lyr.groupSize.y; j < Mathf.Min(lyr.layerSize.y, groupY * (int)lyr.groupSize.y + lyr.groupSize.y); j++)
{
UniTileTile tile = lyr.GetTile(i, j);
TileInstance data = lyr.GetTileData(i, j);
if (data != null && data.id != -1)
{
if (skip[new Vector2(i, j)] == null)
{
Hashtable h = new Hashtable();
h["x"] = i;
h["y"] = j;
h["z"] = (lyr == layer?0:lyr.transform.localPosition.z);
h["tile"] = data;
h["resizable"] = tile.resizable;
int sizeX = 1;
int sizeY = 1;
if (tile != null && tile.resizable)
{
while (skip[new Vector2(i, j + sizeY)] == null && lyr.GetTileId(i, j + sizeY) == data.id && j + sizeY < (groupY + 1) * lyr.groupSize.y)
{
skip[new Vector2(i, j + sizeY)] = true;
sizeY++;
}
if (sizeY == 1)
{
while (skip[new Vector2(i + sizeX, j)] == null && lyr.GetTileId(i + sizeX, j) == data.id && i + sizeX < (groupX + 1) * lyr.groupSize.x)
{
skip[new Vector2(i + sizeX, j)] = true;
sizeX++;
}
}
else
{
sizeX = 1;
bool columnOk = true;
int column = 1;
while (columnOk && i + column < (groupX + 1) * lyr.groupSize.x)
{
columnOk = true;
for (int k = 0; k < sizeY; k++)
{
if (skip[new Vector2(i + column, j + k)] != null || lyr.GetTileId(i + column, j + k) != data.id)
{
columnOk = false;
break;
}
}
if (columnOk)
{
column++;
}
}
sizeX = column;
for (int k = 0; k < sizeX; k++)
{
for (int l = 0; l < sizeY; l++)
{
skip[new Vector2(i + k, j + l)] = true;
}
}
}
}
h["sizeX"] = sizeX;
h["sizeY"] = sizeY;
temp.Add(h);
}
}
}
}
}
if (temp.Count == 0)
{
GameObject.DestroyImmediate(m);
GameObject.DestroyImmediate(g);
}
else
{
Vector3 [] vertices = new Vector3[4 * temp.Count];
int [] triangles = new int[6 * temp.Count];
Vector2 [] uv = new Vector2[4 * temp.Count];
for (int i = 0; i < temp.Count; i++)
{
Hashtable h = temp[i] as Hashtable;
int x = (int)((int)h["x"] * layer.tileSpacing.x) - (int)(groupX * layer.tileSpacing.x * layer.groupSize.x);
int y = (int)((int)h["y"] * layer.tileSpacing.y) - (int)(groupY * layer.tileSpacing.y * layer.groupSize.y);
int sizeX = (int)h["sizeX"];
int sizeY = (int)h["sizeY"];
TileInstance data = (TileInstance)h["tile"];
Rect vRect = new Rect();
Rect uvRect = new Rect();
int columns = (int)((layer.material.mainTexture.width) / (layer.tileSize.x + layer.borderSize.x * 2));
if (sizeX == 1 && sizeY == 1)
{
vRect.x = (int)x - layer.overlap.x;
vRect.y = (int)y - layer.overlap.y;
vRect.xMax = layer.tileSpacing.x + (int)x + layer.overlap.x;
vRect.yMax = layer.tileSpacing.y + (int)y + layer.overlap.y;
uvRect.x = Mathf.Floor(data.id % columns) * (layer.tileSize.x + layer.borderSize.x * 2f) + layer.borderSize.x - layer.overlap.x;
uvRect.y = layer.material.mainTexture.height - (Mathf.Floor(data.id / columns) * (layer.tileSize.x + layer.borderSize.y * 2f) + layer.borderSize.y + layer.overlap.y + layer.tileSize.y);
uvRect.width = layer.tileSize.x + layer.overlap.x;
uvRect.height = layer.tileSize.y + layer.overlap.y;
Texture2D texture = (Texture2D)layer.material.mainTexture;
if (layer.readableTexture && !Application.isPlaying)
{
try {
// Find empty columns left
int start = Mathf.Max(0, (int)Mathf.Round(uvRect.x));
int end = Mathf.Min(texture.width, (int)Mathf.Round(uvRect.xMax));
for (int j = start; j < end; j++)
{
int min = Mathf.Max(0, (int)Mathf.Round(uvRect.y));
int max = Mathf.Min(texture.height - min, (int)Mathf.Round(uvRect.height));
Color[] pixels = texture.GetPixels(j, min, 1, max);
bool allTrans = true;
for (int k = 0; k < pixels.Length; k++)
{
if (pixels[k].a != 0)
{
allTrans = false;
break;
}
}
if (!allTrans)
{
break;
}
uvRect.xMin++;
vRect.xMin += layer.tileSpacing.x / layer.tileSize.x;
}
// Find empty columns right
start = Mathf.Min(texture.width, (int)Mathf.Round(uvRect.xMax)) - 1;
end = Mathf.Max(0, (int)Mathf.Round(uvRect.x));
for (int j = start; j >= end; j--)
{
int min = Mathf.Max(0, (int)Mathf.Round(uvRect.y));
int max = Mathf.Min(texture.height - min, (int)Mathf.Round(uvRect.height));
Color[] pixels = texture.GetPixels(j, min, 1, max);
bool allTrans = true;
for (int k = 0; k < pixels.Length; k++)
{
if (pixels[k].a != 0)
{
allTrans = false;
break;
}
}
if (!allTrans)
{
break;
}
else
{
uvRect.xMax--;
vRect.xMax -= layer.tileSpacing.x / layer.tileSize.x;
}
}
// Find empty rows down
start = Mathf.Max(0, (int)Mathf.Round(uvRect.y));
end = Mathf.Min(texture.height, (int)Mathf.Round(uvRect.yMax));
for (int j = start; j < end; j++)
{
int min = Mathf.Max(0, (int)Mathf.Round(uvRect.x));
int max = Mathf.Min(texture.width - min, (int)Mathf.Round(uvRect.width));
Color[] pixels = texture.GetPixels(min, j, max, 1);
bool allTrans = true;
for (int k = 0; k < pixels.Length; k++)
{
if (pixels[k].a != 0)
{
allTrans = false;
break;
}
}
if (!allTrans)
{
break;
}
uvRect.yMin++;
vRect.yMin += layer.tileSpacing.y / layer.tileSize.y;
}
// Find empty rows up
start = Mathf.Min(texture.height, (int)Mathf.Round(uvRect.yMax)) - 1;
end = Mathf.Max(0, (int)Mathf.Round(uvRect.y));
for (int j = start; j >= end; j--)
{
int min = Mathf.Max(0, (int)Mathf.Round(uvRect.x));
int max = Mathf.Min(texture.width - min, (int)Mathf.Round(uvRect.width));
Color[] pixels = texture.GetPixels(min, j, max, 1);
bool allTrans = true;
for (int k = 0; k < pixels.Length; k++)
{
if (pixels[k].a != 0)
{
allTrans = false;
break;
}
}
if (!allTrans)
{
break;
}
uvRect.yMax--;
vRect.yMax -= layer.tileSpacing.y / layer.tileSize.y;
}
} catch {
layer.readableTexture = false;
}
}
}
else
{
vRect.x = (int)x - layer.overlap.x;
vRect.y = (int)y - layer.overlap.y;
vRect.xMax = layer.tileSpacing.x * (float)sizeX + (int)x + layer.overlap.x;
vRect.yMax = layer.tileSpacing.y * (float)sizeY + (int)y + layer.overlap.y;
//vRect.xMax = layer.tileSize.x * 1 + (int)x + layer.overlap.x;
//vRect.yMax = layer.tileSize.y * 1 + (int)y + layer.overlap.y;
uvRect.x = Mathf.Floor(data.id % columns) * (layer.tileSize.x + layer.borderSize.x * 2f) + (layer.borderSize.x - layer.overlap.x) / sizeX + 1;
uvRect.y = layer.material.mainTexture.height - (Mathf.Floor(data.id / columns) * (layer.tileSize.x + layer.borderSize.y * 2f) + (layer.borderSize.y + layer.overlap.y) / sizeY + layer.tileSize.y) + 1;
uvRect.width = layer.tileSize.x + layer.overlap.x - 2;
uvRect.height = layer.tileSize.y + layer.overlap.y - 2;
}
Vector2 center = new Vector2(x, y) + layer.tileSpacing / 2f;
//Vecrtices
vertices[(i * 4) + 0] = new Vector3(vRect.x, vRect.yMax, (float)h["z"]);
vertices[(i * 4) + 1] = new Vector3(vRect.xMax, vRect.yMax, (float)h["z"]);
vertices[(i * 4) + 2] = new Vector3(vRect.x, vRect.y, (float)h["z"]);
vertices[(i * 4) + 3] = new Vector3(vRect.xMax, vRect.y, (float)h["z"]);
bool reversed = false;
if (!(bool)h["resizable"])
{
for (int j = 0; j < (uint)data.rotation; j++)
{
vertices[(i * 4) + 0] = RotatePoint(vertices[(i * 4) + 0], center);
vertices[(i * 4) + 1] = RotatePoint(vertices[(i * 4) + 1], center);
vertices[(i * 4) + 2] = RotatePoint(vertices[(i * 4) + 2], center);
vertices[(i * 4) + 3] = RotatePoint(vertices[(i * 4) + 3], center);
}
if (data.flippedHorizontally)
{
reversed = !reversed;
vertices[(i * 4) + 0].x = (center.x - vertices[(i * 4) + 0].x) + center.x;
vertices[(i * 4) + 1].x = (center.x - vertices[(i * 4) + 1].x) + center.x;
vertices[(i * 4) + 2].x = (center.x - vertices[(i * 4) + 2].x) + center.x;
vertices[(i * 4) + 3].x = (center.x - vertices[(i * 4) + 3].x) + center.x;
}
if (data.flippedVertically)
{
reversed = !reversed;
vertices[(i * 4) + 0].y = (center.y - vertices[(i * 4) + 0].y) + center.y;
vertices[(i * 4) + 1].y = (center.y - vertices[(i * 4) + 1].y) + center.y;
vertices[(i * 4) + 2].y = (center.y - vertices[(i * 4) + 2].y) + center.y;
vertices[(i * 4) + 3].y = (center.y - vertices[(i * 4) + 3].y) + center.y;
}
}
// Triangles
if (!reversed)
{
triangles[(i * 6) + 0] = (i * 4) + 0;
triangles[(i * 6) + 1] = (i * 4) + 1;
triangles[(i * 6) + 2] = (i * 4) + 2;
triangles[(i * 6) + 3] = (i * 4) + 1;
triangles[(i * 6) + 4] = (i * 4) + 3;
triangles[(i * 6) + 5] = (i * 4) + 2;
}
else
{
triangles[(i * 6) + 0] = (i * 4) + 2;
triangles[(i * 6) + 1] = (i * 4) + 1;
triangles[(i * 6) + 2] = (i * 4) + 0;
triangles[(i * 6) + 3] = (i * 4) + 2;
triangles[(i * 6) + 4] = (i * 4) + 3;
triangles[(i * 6) + 5] = (i * 4) + 1;
}
// UVS
uv[(i * 4) + 0] = new Vector2(uvRect.x / (float)layer.material.mainTexture.width, uvRect.yMax / (float)layer.material.mainTexture.height);
uv[(i * 4) + 1] = new Vector2(uvRect.xMax / (float)layer.material.mainTexture.width, uvRect.yMax / (float)layer.material.mainTexture.height);
uv[(i * 4) + 2] = new Vector2(uvRect.x / (float)layer.material.mainTexture.width, uvRect.y / (float)layer.material.mainTexture.height);
uv[(i * 4) + 3] = new Vector2(uvRect.xMax / (float)layer.material.mainTexture.width, uvRect.y / (float)layer.material.mainTexture.height);
}
m.vertices = vertices;
m.triangles = triangles;
m.uv = uv;
m.RecalculateNormals();
}
}
public static void InstantiatePrefabs(TileLayer layer)
{
if (layer.tileset == null)
{
return;
}
if (layer.tileset.tiles == null)
{
return;
}
Transform t = layer.transform.FindChild("TileInstances");
if (t != null)
{
DestroyImmediate(t.gameObject);
}
t = layer.transform.FindChild("BoxColliders");
if (t != null)
{
DestroyImmediate(t.gameObject);
}
GameObject instances = new GameObject("TileInstances");
Transform instancesTransform = instances.transform;
instancesTransform.parent = layer.transform;
instancesTransform.localPosition = new Vector3(0, 0, 0);
instancesTransform.localScale = new Vector3(1, 1, 1);
instancesTransform.localRotation = new Quaternion(0, 0, 0, 0);
GameObject boxes = new GameObject("BoxColliders");
Transform boxesTransform = boxes.transform;
boxesTransform.parent = layer.transform;
boxesTransform.localPosition = new Vector3(0, 0, 0);
boxesTransform.localScale = new Vector3(1, 1, 1);
boxesTransform.localRotation = new Quaternion(0, 0, 0, 0);
GameObject prefab;
GameObject instance;
GameObject box;
BoxCollider2D collider;
Hashtable skip = new Hashtable();
if (layer.tileSpacing == new Vector2(-1, -1) || layer.tileSpacing == new Vector2(0, 0))
{
layer.tileSpacing = layer.tileSize;
}
for (int i = 0; i < layer.layerSize.x; i++)
{
for (int j = 0; j < layer.layerSize.y; j++)
{
UniTileTile tile = layer.GetTile(i, j);
if (tile != null)
{
TileInstance inst = layer.GetTileData(i, j);
prefab = tile.prefab;
if (prefab != null)
{
#if (UNITY_3_5 || UNITY_3_6 || UNITY_3_7 || UNITY_3_8 || UNITY_3_9)
instance = (GameObject)PrefabUtility.InstantiatePrefab(prefab);
#else
instance = (GameObject)PrefabUtility.InstantiatePrefab(prefab);
#endif
Vector3 scale = instance.transform.localScale;
instance.transform.parent = instancesTransform;
instance.transform.localScale = scale;
Quaternion q = new Quaternion(0, 0, 0, 0);
q.eulerAngles = new Vector3(0, 0, (int)inst.rotation * 90);
instance.transform.localRotation = q;
instance.transform.localPosition = (Vector3)TileLayerUtil.TransformPoint(new Vector2(i * layer.tileSpacing.x + tile.prefabOffset.x, j * layer.tileSpacing.y + tile.prefabOffset.y), new Vector2(i * layer.tileSpacing.x + layer.tileSpacing.x / 2f, j * layer.tileSpacing.y + +layer.tileSpacing.y / 2f), inst.flippedHorizontally, inst.flippedVertically, inst.rotation);
if (inst.flippedHorizontally)
{
instance.transform.localScale = new Vector3(-instance.transform.localScale.x, instance.transform.localScale.y, instance.transform.localScale.z);
}
if (inst.flippedVertically)
{
instance.transform.localScale = new Vector3(instance.transform.localScale.x, -instance.transform.localScale.y, instance.transform.localScale.z);
}
}
if (layer.collidable && tile.boxCollider)
{
if (skip[new Vector2(i, j)] == null)
{
if (tile.boxPrefab != null)
#if (UNITY_3_5 || UNITY_3_6 || UNITY_3_7 || UNITY_3_8 || UNITY_3_9)
{ box = (GameObject)PrefabUtility.InstantiatePrefab(tile.boxPrefab); }
#else
{ box = (GameObject)PrefabUtility.InstantiatePrefab(tile.boxPrefab); }
#endif
else
{
box = new GameObject("BoxCollider");
}
box.layer = tile.boxLayer;
box.tag = tile.boxTag;
collider = box.GetComponent <BoxCollider2D>();
if (!collider)
{
collider = box.AddComponent <BoxCollider2D>();
}
collider.sharedMaterial = tile.boxMaterial;
box.transform.parent = boxesTransform;
box.transform.localScale = new Vector3(1, 1, 1);
box.transform.localRotation = new Quaternion(0, 0, 0, 0);
box.transform.localPosition = new Vector3(i * layer.tileSpacing.x, j * layer.tileSpacing.y, 0);
int sizeX = 1;
int sizeY = 1;
while (skip[new Vector2(i, j + sizeY)] == null && layer.CanMergeBoxColliders(i, j, i, j + sizeY))
{
skip[new Vector2(i, j + sizeY)] = true;
sizeY++;
}
if (sizeY == 1)
{
while (skip[new Vector2(i + sizeX, j)] == null && layer.CanMergeBoxColliders(i, j, i + sizeX, j))
{
skip[new Vector2(i + sizeX, j)] = true;
sizeX++;
}
}
else
{
sizeX = 1;
bool columnOk = true;
int column = 1;
while (columnOk)
{
columnOk = true;
for (int k = 0; k < sizeY; k++)
{
if (skip[new Vector2(i + column, j + k)] != null || !layer.CanMergeBoxColliders(i, j, i + column, j + k))
{
columnOk = false;
break;
}
}
if (columnOk)
{
column++;
}
}
sizeX = column;
for (int k = 0; k < sizeX; k++)
{
for (int l = 0; l < sizeY; l++)
{
skip[new Vector2(i + k, j + l)] = true;
}
}
}
if (tile.customBoxDimensions)
{
Rect rect = TileLayerUtil.TransformRect(tile.boxDimensions, layer.tileSize / 2f, inst.flippedHorizontally, inst.flippedVertically, inst.rotation);
float x = rect.width;
float y = rect.height;
if (rect.x == 0 && rect.xMax == layer.tileSpacing.x)
{
x = layer.tileSpacing.x * sizeX;
}
if (rect.y == 0 && rect.yMax == layer.tileSpacing.y)
{
y = layer.tileSpacing.y * sizeY;
}
collider.size = new Vector3(x, y, tile.boxDepth);
collider.offset = new Vector3(collider.size.x / 2f + rect.x, collider.size.y / 2f + rect.y);
}
else
{
collider.size = new Vector3(layer.tileSpacing.x * sizeX, layer.tileSpacing.y * sizeY, tile.boxDepth);
collider.offset = new Vector3(collider.size.x / 2f, collider.size.y / 2f);
//collider.center = new Vector3(layer.tileSpacing.x * sizeX / 2f, layer.tileSpacing.y * sizeY / 2f);
}
}
}
}
}
}
