static void RuleInspectorOnGUI(Rect rect, TilingRule tilingRule)
{
float y = rect.yMin;
EditorGUI.BeginChangeCheck();
GUI.Label(new Rect(rect.xMin, y, labelWidth, singleLineHeight), "Rule");
tilingRule.AutoTransform = (TilingRule.AutoTransformEnum)EditorGUI.EnumPopup(new Rect(rect.xMin + labelWidth, y, rect.width - labelWidth, singleLineHeight), tilingRule.AutoTransform);
y += singleLineHeight;
GUI.Label(new Rect(rect.xMin, y, labelWidth, singleLineHeight), "Collider");
tilingRule.ColliderType = (Tile.ColliderType)EditorGUI.EnumPopup(new Rect(rect.xMin + labelWidth, y, rect.width - labelWidth, singleLineHeight), tilingRule.ColliderType);
y += singleLineHeight;
GUI.Label(new Rect(rect.xMin, y, labelWidth, singleLineHeight), "Output");
tilingRule.Output = (TilingRule.OutputSpriteEnum)EditorGUI.EnumPopup(new Rect(rect.xMin + labelWidth, y, rect.width - labelWidth, singleLineHeight), tilingRule.Output);
y += singleLineHeight;
if (tilingRule.Output == TilingRule.OutputSpriteEnum.Animation)
{
GUI.Label(new Rect(rect.xMin, y, labelWidth, singleLineHeight), "Speed");
tilingRule.AnimationSpeed = EditorGUI.FloatField(new Rect(rect.xMin + labelWidth, y, rect.width - labelWidth, singleLineHeight), tilingRule.AnimationSpeed);
y += singleLineHeight;
}
if (tilingRule.Output == TilingRule.OutputSpriteEnum.Random)
{
GUI.Label(new Rect(rect.xMin, y, labelWidth, singleLineHeight), "Noise");
tilingRule.PerlinScale = EditorGUI.Slider(new Rect(rect.xMin + labelWidth, y, rect.width - labelWidth, singleLineHeight), tilingRule.PerlinScale, 0.001f, 0.999f);
y += singleLineHeight;
}
if (tilingRule.Output != TilingRule.OutputSpriteEnum.Single)
{
GUI.Label(new Rect(rect.xMin, y, labelWidth, singleLineHeight), "Size");
EditorGUI.BeginChangeCheck();
int newLength = EditorGUI.IntField(new Rect(rect.xMin + labelWidth, y, rect.width - labelWidth, singleLineHeight), tilingRule.Sprites.Length);
if (EditorGUI.EndChangeCheck())
{
Array.Resize(ref tilingRule.Sprites, Math.Max(newLength, 1));
}
y += singleLineHeight;
for (int i = 0; i < tilingRule.Sprites.Length; i++)
{
tilingRule.Sprites[i] = EditorGUI.ObjectField(new Rect(rect.xMin + labelWidth, y, rect.width - labelWidth, singleLineHeight), tilingRule.Sprites[i], typeof(Sprite), false) as Sprite;
y += singleLineHeight;
}
}
}
public TilingRule Clone()
{
TilingRule rule = new TilingRule();
rule.m_Neighbors = new List <int>(m_Neighbors);
rule.m_NeighborPositions = new List <Vector3Int>(m_NeighborPositions);
rule.m_RuleTransform = m_RuleTransform;
rule.m_Sprites = new Sprite[m_Sprites.Length];
Array.Copy(m_Sprites, rule.m_Sprites, m_Sprites.Length);
rule.m_GameObject = m_GameObject;
rule.m_MinAnimationSpeed = m_MinAnimationSpeed;
rule.m_MaxAnimationSpeed = m_MaxAnimationSpeed;
rule.m_PerlinScale = m_PerlinScale;
rule.m_Output = m_Output;
rule.m_ColliderType = m_ColliderType;
rule.m_RandomTransform = m_RandomTransform;
return(rule);
}
public void Override()
{
if (m_Tile)
{
m_DefaultSprite = m_Tile.m_DefaultSprite;
m_DefaultColliderType = m_Tile.m_DefaultColliderType;
m_TilingRules = m_Tile.m_TilingRules.Select(rule => CloneTilingRule(rule)).ToList();
}
if (!m_Advanced)
{
if (m_DefaultSprite)
{
m_DefaultSprite = this[m_DefaultSprite];
}
foreach (RuleTile.TilingRule rule in m_TilingRules)
{
for (int i = 0; i < rule.m_Sprites.Length; i++)
{
if (rule.m_Sprites[i])
{
rule.m_Sprites[i] = this[rule.m_Sprites[i]];
}
}
}
}
else
{
if (m_OverrideDefault.m_Enabled)
{
m_DefaultSprite = m_OverrideDefault.m_TilingRule.m_Sprites.Length > 0 ? m_OverrideDefault.m_TilingRule.m_Sprites[0] : null;
m_DefaultColliderType = m_OverrideDefault.m_TilingRule.m_ColliderType;
}
for (int i = 0; i < m_TilingRules.Count; i++)
{
var originalRule = m_TilingRules[i];
TilingRule overrideRule = this[m_Tile.m_TilingRules[i]];
if (overrideRule == null)
{
continue;
}
CopyTilingRule(overrideRule, originalRule, false);
}
}
}
public bool RuleMatches(TilingRule rule, Vector3Int position, ITilemap tilemap, bool mirrorX, bool mirrorY)
{
for (int y = -1; y <= 1; y++)
{
for (int x = -1; x <= 1; x++)
{
if (x != 0 || y != 0)
{
Vector3Int offset = new Vector3Int(x, y, 0);
Vector3Int mirrored = GetMirroredPos(offset, mirrorX, mirrorY);
int index = GetIndexOfOffset(mirrored);
int targetX = (position + offset).x;
int targetY = (position + offset).y;
if (targetX < 0)
{
targetX = tilemap.size.x + targetX;
}
if (targetY < 0)
{
targetY = tilemap.size.y + targetY;
}
if (tilemap.size.x <= targetX)
{
targetX = targetX - tilemap.size.x;
}
if (tilemap.size.y <= targetY)
{
targetY = targetY - tilemap.size.y;
}
TileBase tile = tilemap.GetTile(new Vector3Int(targetX, targetY, 0));
if (rule.m_Neighbors[index] == TilingRule.Neighbor.This && tile != this || rule.m_Neighbors[index] == TilingRule.Neighbor.NotThis && tile == this)
{
return(false);
}
}
}
}
return(true);
}
public bool RuleMatches(TilingRule rule, Vector3Int position, ITilemap tilemap, int angle)
{
for (int y = -1; y <= 1; y++)
{
for (int x = -1; x <= 1; x++)
{
if (x != 0 || y != 0)
{
Vector3Int offset = new Vector3Int(x, y, 0);
Vector3Int rotated = GetRotatedPos(offset, angle);
int index = GetIndexOfOffset(rotated);
TileBase tile = tilemap.GetTile(position + offset);
if (rule.m_Neighbors[index] == TilingRule.Neighbor.This && tile != this || rule.m_Neighbors[index] == TilingRule.Neighbor.NotThis && tile == this)
{
return(false);
}
}
}
}
return(true);
}
public bool RuleMatches(TilingRule rule, Vector3Int position, ITilemap tilemap, int angle)
{
for (int y = -1; y <= 1; y++)
{
for (int x = -1; x <= 1; x++)
{
if (x != 0 || y != 0)
{
Vector3Int offset = new Vector3Int(x, y, 0);
Vector3Int rotated = GetRotatedPos(offset, angle);
int index = GetIndexOfOffset(rotated);
TileBase tile = tilemap.GetTile(position + offset);
if (RuleBroken(rule, index, tile))
{
return(false);
}
}
}
}
return(true);
}
void OnDrawElement(Rect rect, int index, bool isactive, bool isfocused)
{
TilingRule rule = tile.TilingRules[index];
float yPos = rect.yMin + 2f;
float height = rect.height - paddingBetweenRules;
float matrixWidth = defaultElementHeight;
Rect inspectorRect = new Rect(rect.xMin, yPos, rect.width - matrixWidth * 2f - 20f, height);
Rect matrixRect = new Rect(rect.xMax - matrixWidth * 2f - 10f, yPos, matrixWidth, defaultElementHeight);
Rect spriteRect = new Rect(rect.xMax - matrixWidth - 5f, yPos, matrixWidth, defaultElementHeight);
EditorGUI.BeginChangeCheck();
RuleInspectorOnGUI(inspectorRect, rule);
RuleMatrixOnGUI(matrixRect, rule);
SpriteOnGUI(spriteRect, rule);
if (EditorGUI.EndChangeCheck())
{
SaveTile();
}
}
public void GetOverrides(List <KeyValuePair <TilingRule, TilingRule> > overrides)
{
if (overrides == null)
{
throw new System.ArgumentNullException("overrides");
}
overrides.Clear();
if (!m_Tile)
{
return;
}
foreach (var originalRule in m_Tile.m_TilingRules)
{
TilingRule overrideRule = this[originalRule];
overrides.Add(new KeyValuePair <TilingRule, TilingRule>(originalRule, overrideRule));
}
overrides.Add(new KeyValuePair <TilingRule, TilingRule>(m_OriginalDefault, m_OverrideDefault.m_TilingRule));
}
public bool RuleMatches(TilingRule rule, Vector3Int position, ITilemap tilemap, bool mirrorX, bool mirrorY)
{
for (var y = -1; y <= 1; y++)
{
for (var x = -1; x <= 1; x++)
{
if (x != 0 || y != 0)
{
var offset = new Vector3Int(x, y, 0);
var mirrored = GetMirroredPos(offset, mirrorX, mirrorY);
var index = GetIndexOfOffset(mirrored);
var tile = tilemap.GetTile(position + offset);
if (rule.m_Neighbors[index] == TilingRule.Neighbor.This && tile != this || rule.m_Neighbors[index] == TilingRule.Neighbor.NotThis && tile == this)
{
return(false);
}
}
}
}
return(true);
}
public override bool RuleMatches(TilingRule rule, Vector3Int position, ITilemap tilemap, ref Matrix4x4 transform)
{
if (RuleMatches(rule, position, tilemap, 0))
{
transform = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, 0f, 0f), Vector3.one);
return(true);
}
if (rule.m_RuleTransform == TilingRule.Transform.Rotated)
{
for (int angle = m_RotationAngle; angle < 360; angle += m_RotationAngle)
{
if (RuleMatches(rule, position, tilemap, angle))
{
transform = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, 0f, -angle), Vector3.one);
return(true);
}
}
}
return(false);
}
public bool RuleMatches(TilingRule rule, Vector3Int position, ITilemap tilemap, bool mirrorX, bool mirrorY)
{
for (int y = -1; y <= 1; y++)
{
for (int x = -1; x <= 1; x++)
{
if (x != 0 || y != 0)
{
Vector3Int offset = new Vector3Int(x, y, 0);
Vector3Int mirrored = GetMirroredPos(offset, mirrorX, mirrorY);
int index = GetIndexOfOffset(mirrored);
TileBase tile = tilemap.GetTile(position + offset);
if (!NeighborMatchesRule(rule.m_Neighbors[index], tile))
{
return(false);
}
}
}
}
return(true);
}
public bool RuleMatches(TilingRule rule, Vector3Int position, ITilemap tilemap, ref Matrix4x4 transform)
{
for (int angle = 0; angle <= (rule.m_RuleTransform == TilingRule.Transform.Rotated ? 270 : 0); angle += 90)
{
if (RuleMatches(rule, position, tilemap, angle))
{
transform = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, 0f, -angle), Vector3.one);
return(true);
}
}
if ((rule.m_RuleTransform == TilingRule.Transform.MirrorX) && RuleMatches(rule, position, tilemap, true, false))
{
transform = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(-1f, 1f, 1f));
return(true);
}
if ((rule.m_RuleTransform == TilingRule.Transform.MirrorY) && RuleMatches(rule, position, tilemap, false, true))
{
transform = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(1f, -1f, 1f));
return(true);
}
return(false);
}
private bool OldRuleCheck(TilingRule rule, int index, TileBase tile)
{
return(rule.m_Neighbors[index] == TilingRule.Neighbor.This && tile != this || rule.m_Neighbors[index] == TilingRule.Neighbor.NotThis && tile == this);
}
void SpriteOnGUI(Rect rect, TilingRule tilingRule)
{
tilingRule.Sprites[0] = EditorGUI.ObjectField(new Rect(rect.xMax - rect.height, rect.yMin, rect.height, rect.height), tilingRule.Sprites[0], typeof(Sprite), false) as Sprite;
}
static void RuleMatrixOnGUI(Rect rect, TilingRule tilingRule)
{
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
int index = 0;
float w = rect.width / 3f;
float h = rect.height / 3f;
for (int y = 0; y <= 3; y++)
{
float top = rect.yMin + y * h;
Handles.DrawLine(new Vector3(rect.xMin, top), new Vector3(rect.xMax, top));
}
for (int x = 0; x <= 3; x++)
{
float left = rect.xMin + x * w;
Handles.DrawLine(new Vector3(left, rect.yMin), new Vector3(left, rect.yMax));
}
Handles.color = Color.white;
for (int y = 0; y <= 2; y++)
{
for (int x = 0; x <= 2; x++)
{
Rect r = new Rect(rect.xMin + x * w, rect.yMin + y * h, w - 1, h - 1);
if (x != 1 || y != 1)
{
switch (tilingRule.Neighbors[index])
{
case TilingRule.NeighborEnum.This:
GUI.DrawTexture(r, Arrows[y * 3 + x]);
break;
case TilingRule.NeighborEnum.NotThis:
GUI.DrawTexture(r, Arrows[9]);
break;
}
if (Event.current.type == EventType.MouseDown && r.Contains(Event.current.mousePosition))
{
tilingRule.Neighbors[index] = (TilingRule.NeighborEnum)(((int)tilingRule.Neighbors[index] + 1) % 3);
GUI.changed = true;
Event.current.Use();
}
index++;
}
else
{
switch (tilingRule.AutoTransform)
{
case TilingRule.AutoTransformEnum.Rotated:
GUI.DrawTexture(r, AutoTransforms[0]);
break;
case TilingRule.AutoTransformEnum.MirrorX:
GUI.DrawTexture(r, AutoTransforms[1]);
break;
case TilingRule.AutoTransformEnum.MirrorY:
GUI.DrawTexture(r, AutoTransforms[2]);
break;
}
if (Event.current.type == EventType.MouseDown && r.Contains(Event.current.mousePosition))
{
tilingRule.AutoTransform = (TilingRule.AutoTransformEnum)(((int)tilingRule.AutoTransform + 1) % 4);
GUI.changed = true;
Event.current.Use();
}
}
}
}
}
public MenuItemData(TilingRule rule, TilingRule.AutoTransformEnum newValue)
{
Rule = rule;
NewValue = newValue;
}
private bool ReturnFalseIf(TilingRule rule, TileBase tile, TilingRule.Neighbor RULE)
{
TileBase[] Q;
#region this is bad
switch ((int)RULE)
{
case 3:
Q = t1;
break;
case 4:
Q = t2;
break;
case 5:
Q = t3;
break;
case 6:
Q = t4;
break;
case 7:
Q = t5;
break;
case 8:
Q = t6;
break;
case 9:
Q = t7;
break;
case 10:
Q = n1;
break;
case 11:
Q = n2;
break;
case 12:
Q = n3;
break;
case 13:
Q = n4;
break;
case 14:
Q = n5;
break;
case 15:
Q = n6;
break;
default:
Q = t1;
break;
}
#endregion
if (RULE == TilingRule.Neighbor.This && tile == m_Self || RULE == TilingRule.Neighbor.NotThis && tile != m_Self)
{
return(false);
}
if ((int)RULE > 2 && (int)RULE < 10)
{
foreach (TileBase q in Q) //No, .Contains() does not exist for TileBase[]
{
if (q == tile)
{
return(false);
}
}
return(true);
}
if ((int)RULE > 9)
{
foreach (TileBase q in Q)
{
if (q == tile)
{
return(true);
}
}
return(false);
}
if (RULE == TilingRule.Neighbor.DontCare)
{
return(false);
}
return(true);
}
