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); }