Initial Commit
This commit is contained in:
commit
ee5c2f922d
GPG key ID:
7611A451D2A5D37A
2255 changed files with 547750 additions and 0 deletions
|
|
@ -0,0 +1,8 @@
|
|||
fileFormatVersion: 2
|
||||
guid: 1e5614e4b96700843ba104987c4f190e
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
fileFormatVersion: 2
|
||||
guid: 1263d004036ee7f42aeed98348b5e8cf
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
|
|
@ -0,0 +1,350 @@
|
|||
using UnityEngine;
|
||||
using UnityEngine.Tilemaps;
|
||||
using UnityEditor;
|
||||
using UnityEditorInternal;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace UnityEditor
|
||||
{
|
||||
[CustomEditor(typeof(RuleOverrideTile))]
|
||||
internal class RuleOverrideTileEditor : Editor
|
||||
{
|
||||
|
||||
public RuleOverrideTile overrideTile { get { return (target as RuleOverrideTile); } }
|
||||
|
||||
private List<KeyValuePair<Sprite, Sprite>> m_Sprites;
|
||||
private List<KeyValuePair<RuleTile.TilingRule, RuleTile.TilingRule>> m_Rules;
|
||||
|
||||
ReorderableList m_SpriteList;
|
||||
ReorderableList m_RuleList;
|
||||
|
||||
private float k_DefaultElementHeight { get { return RuleTileEditor.k_DefaultElementHeight; } }
|
||||
private float k_PaddingBetweenRules { get { return RuleTileEditor.k_PaddingBetweenRules; } }
|
||||
private float k_SingleLineHeight { get { return RuleTileEditor.k_SingleLineHeight; } }
|
||||
private float k_LabelWidth { get { return RuleTileEditor.k_LabelWidth; } }
|
||||
|
||||
void OnEnable()
|
||||
{
|
||||
if (m_Sprites == null)
|
||||
m_Sprites = new List<KeyValuePair<Sprite, Sprite>>();
|
||||
|
||||
if (m_Rules == null)
|
||||
m_Rules = new List<KeyValuePair<RuleTile.TilingRule, RuleTile.TilingRule>>();
|
||||
|
||||
if (m_SpriteList == null)
|
||||
{
|
||||
overrideTile.GetOverrides(m_Sprites);
|
||||
|
||||
m_SpriteList = new ReorderableList(m_Sprites, typeof(KeyValuePair<Sprite, Sprite>), false, true, false, false);
|
||||
m_SpriteList.drawHeaderCallback = DrawSpriteHeader;
|
||||
m_SpriteList.drawElementCallback = DrawSpriteElement;
|
||||
m_SpriteList.elementHeight = k_DefaultElementHeight + k_PaddingBetweenRules;
|
||||
}
|
||||
if (m_RuleList == null)
|
||||
{
|
||||
overrideTile.GetOverrides(m_Rules);
|
||||
|
||||
m_RuleList = new ReorderableList(m_Rules, typeof(KeyValuePair<RuleTile.TilingRule, RuleTile.TilingRule>), false, true, false, false);
|
||||
m_RuleList.drawHeaderCallback = DrawRuleHeader;
|
||||
m_RuleList.drawElementCallback = DrawRuleElement;
|
||||
m_RuleList.elementHeightCallback = GetRuleElementHeight;
|
||||
}
|
||||
}
|
||||
|
||||
public override void OnInspectorGUI()
|
||||
{
|
||||
serializedObject.UpdateIfRequiredOrScript();
|
||||
|
||||
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_Tile"));
|
||||
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_Advanced"));
|
||||
serializedObject.ApplyModifiedProperties();
|
||||
|
||||
if (!overrideTile.m_Advanced)
|
||||
{
|
||||
using (new EditorGUI.DisabledScope(overrideTile.m_Tile == null))
|
||||
{
|
||||
EditorGUI.BeginChangeCheck();
|
||||
overrideTile.GetOverrides(m_Sprites);
|
||||
|
||||
m_SpriteList.list = m_Sprites;
|
||||
m_SpriteList.DoLayoutList();
|
||||
if (EditorGUI.EndChangeCheck())
|
||||
{
|
||||
for (int i = 0; i < targets.Length; i++)
|
||||
{
|
||||
RuleOverrideTile tile = targets[i] as RuleOverrideTile;
|
||||
tile.ApplyOverrides(m_Sprites);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
using (new EditorGUI.DisabledScope(overrideTile.m_Tile == null))
|
||||
{
|
||||
overrideTile.GetOverrides(m_Rules);
|
||||
|
||||
m_RuleList.list = m_Rules;
|
||||
m_RuleList.DoLayoutList();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void SaveTile()
|
||||
{
|
||||
EditorUtility.SetDirty(target);
|
||||
SceneView.RepaintAll();
|
||||
}
|
||||
|
||||
private void DrawSpriteElement(Rect rect, int index, bool selected, bool focused)
|
||||
{
|
||||
Sprite originalSprite = m_Sprites[index].Key;
|
||||
Sprite overrideSprite = m_Sprites[index].Value;
|
||||
|
||||
rect.y += 2;
|
||||
rect.height -= k_PaddingBetweenRules;
|
||||
|
||||
rect.xMax = rect.xMax / 2.0f;
|
||||
using (new EditorGUI.DisabledScope(true))
|
||||
EditorGUI.ObjectField(new Rect(rect.xMin, rect.yMin, rect.height, rect.height), originalSprite, typeof(Sprite), false);
|
||||
rect.xMin = rect.xMax;
|
||||
rect.xMax *= 2.0f;
|
||||
|
||||
EditorGUI.BeginChangeCheck();
|
||||
overrideSprite = EditorGUI.ObjectField(new Rect(rect.xMin, rect.yMin, rect.height, rect.height), overrideSprite, typeof(Sprite), false) as Sprite;
|
||||
if (EditorGUI.EndChangeCheck())
|
||||
{
|
||||
m_Sprites[index] = new KeyValuePair<Sprite, Sprite>(originalSprite, overrideSprite);
|
||||
SaveTile();
|
||||
}
|
||||
}
|
||||
private void DrawSpriteHeader(Rect rect)
|
||||
{
|
||||
float xMax = rect.xMax;
|
||||
rect.xMax = rect.xMax / 2.0f;
|
||||
GUI.Label(rect, "Original", EditorStyles.label);
|
||||
rect.xMin = rect.xMax;
|
||||
rect.xMax = xMax;
|
||||
GUI.Label(rect, "Override", EditorStyles.label);
|
||||
}
|
||||
|
||||
private void DrawRuleElement(Rect rect, int index, bool selected, bool focused)
|
||||
{
|
||||
RuleTile.TilingRule originalRule = m_Rules[index].Key;
|
||||
RuleTile.TilingRule overrideRule = m_Rules[index].Value;
|
||||
|
||||
float matrixWidth = k_DefaultElementHeight;
|
||||
|
||||
float xMax = rect.xMax;
|
||||
rect.xMax = rect.xMax / 2.0f + matrixWidth - 10f;
|
||||
|
||||
if (index != overrideTile.m_Tile.m_TilingRules.Count)
|
||||
DrawOriginalRuleElement(rect, originalRule);
|
||||
else
|
||||
DrawOriginalRuleElement(rect, originalRule, true);
|
||||
|
||||
rect.xMin = rect.xMax;
|
||||
rect.xMax = xMax;
|
||||
|
||||
EditorGUI.BeginChangeCheck();
|
||||
if (index != overrideTile.m_Tile.m_TilingRules.Count)
|
||||
DrawOverrideElement(rect, originalRule);
|
||||
else
|
||||
DrawOverrideDefaultElement(rect, overrideRule);
|
||||
if (EditorGUI.EndChangeCheck())
|
||||
SaveTile();
|
||||
}
|
||||
public void DrawOriginalRuleElement(Rect rect, RuleTile.TilingRule originalRule, bool isDefault = false)
|
||||
{
|
||||
using (new EditorGUI.DisabledScope(true))
|
||||
{
|
||||
float yPos = rect.yMin + 2f;
|
||||
float height = rect.height - k_PaddingBetweenRules;
|
||||
float matrixWidth = k_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, k_DefaultElementHeight);
|
||||
Rect spriteRect = new Rect(rect.xMax - matrixWidth - 5f, yPos, matrixWidth, k_DefaultElementHeight);
|
||||
|
||||
if (!isDefault)
|
||||
RuleTileEditor.RuleInspectorOnGUI(inspectorRect, originalRule);
|
||||
else
|
||||
RuleOriginalDefaultInspectorOnGUI(inspectorRect, originalRule);
|
||||
RuleTileEditor.RuleMatrixOnGUI(matrixRect, originalRule);
|
||||
RuleTileEditor.SpriteOnGUI(spriteRect, originalRule);
|
||||
}
|
||||
}
|
||||
private void DrawOverrideElement(Rect rect, RuleTile.TilingRule originalRule)
|
||||
{
|
||||
float yPos = rect.yMin + 2f;
|
||||
float height = rect.height - k_PaddingBetweenRules;
|
||||
float matrixWidth = k_DefaultElementHeight;
|
||||
|
||||
Rect inspectorRect = new Rect(rect.xMin, yPos, rect.width - matrixWidth - 10f, height);
|
||||
Rect spriteRect = new Rect(rect.xMax - matrixWidth - 5f, yPos, matrixWidth, k_DefaultElementHeight);
|
||||
|
||||
RuleOverrideInspectorOnGUI(inspectorRect, originalRule);
|
||||
RuleTile.TilingRule overrideRule = overrideTile[originalRule];
|
||||
if (overrideRule != null)
|
||||
RuleTileEditor.SpriteOnGUI(spriteRect, overrideRule);
|
||||
}
|
||||
private void RuleOriginalDefaultInspectorOnGUI(Rect rect, RuleTile.TilingRule originalRule)
|
||||
{
|
||||
float y = rect.yMin;
|
||||
|
||||
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Rule");
|
||||
EditorGUI.LabelField(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), "Default");
|
||||
y += k_SingleLineHeight;
|
||||
|
||||
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Collider");
|
||||
EditorGUI.EnumPopup(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), originalRule.m_ColliderType);
|
||||
y += k_SingleLineHeight;
|
||||
}
|
||||
private void RuleOverrideInspectorOnGUI(Rect rect, RuleTile.TilingRule originalRule)
|
||||
{
|
||||
RuleTile.TilingRule overrideRule = overrideTile[originalRule];
|
||||
|
||||
float y = rect.yMin;
|
||||
EditorGUI.BeginChangeCheck();
|
||||
|
||||
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Enabled");
|
||||
bool enabled = EditorGUI.Toggle(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule != null);
|
||||
y += k_SingleLineHeight;
|
||||
|
||||
if (EditorGUI.EndChangeCheck())
|
||||
{
|
||||
if (enabled)
|
||||
overrideTile[originalRule] = originalRule;
|
||||
else
|
||||
overrideTile[originalRule] = null;
|
||||
overrideRule = overrideTile[originalRule];
|
||||
}
|
||||
|
||||
if (overrideRule == null)
|
||||
return;
|
||||
|
||||
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Collider");
|
||||
overrideRule.m_ColliderType = (Tile.ColliderType)EditorGUI.EnumPopup(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_ColliderType);
|
||||
y += k_SingleLineHeight;
|
||||
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Output");
|
||||
overrideRule.m_Output = (RuleTile.TilingRule.OutputSprite)EditorGUI.EnumPopup(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_Output);
|
||||
y += k_SingleLineHeight;
|
||||
|
||||
if (overrideRule.m_Output == RuleTile.TilingRule.OutputSprite.Animation)
|
||||
{
|
||||
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Speed");
|
||||
overrideRule.m_AnimationSpeed = EditorGUI.FloatField(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_AnimationSpeed);
|
||||
y += k_SingleLineHeight;
|
||||
}
|
||||
if (overrideRule.m_Output == RuleTile.TilingRule.OutputSprite.Random)
|
||||
{
|
||||
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Noise");
|
||||
overrideRule.m_PerlinScale = EditorGUI.Slider(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_PerlinScale, 0.001f, 0.999f);
|
||||
y += k_SingleLineHeight;
|
||||
|
||||
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Shuffle");
|
||||
overrideRule.m_RandomTransform = (RuleTile.TilingRule.Transform)EditorGUI.EnumPopup(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_RandomTransform);
|
||||
y += k_SingleLineHeight;
|
||||
}
|
||||
|
||||
if (overrideRule.m_Output != RuleTile.TilingRule.OutputSprite.Single)
|
||||
{
|
||||
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Size");
|
||||
EditorGUI.BeginChangeCheck();
|
||||
int newLength = EditorGUI.DelayedIntField(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_Sprites.Length);
|
||||
if (EditorGUI.EndChangeCheck())
|
||||
Array.Resize(ref overrideRule.m_Sprites, Math.Max(newLength, 1));
|
||||
y += k_SingleLineHeight;
|
||||
|
||||
for (int i = 0; i < overrideRule.m_Sprites.Length; i++)
|
||||
{
|
||||
overrideRule.m_Sprites[i] = EditorGUI.ObjectField(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_Sprites[i], typeof(Sprite), false) as Sprite;
|
||||
y += k_SingleLineHeight;
|
||||
}
|
||||
}
|
||||
}
|
||||
private void DrawOverrideDefaultElement(Rect rect, RuleTile.TilingRule originalRule)
|
||||
{
|
||||
float yPos = rect.yMin + 2f;
|
||||
float height = rect.height - k_PaddingBetweenRules;
|
||||
float matrixWidth = k_DefaultElementHeight;
|
||||
|
||||
Rect inspectorRect = new Rect(rect.xMin, yPos, rect.width - matrixWidth - 10f, height);
|
||||
Rect spriteRect = new Rect(rect.xMax - matrixWidth - 5f, yPos, matrixWidth, k_DefaultElementHeight);
|
||||
|
||||
RuleOverrideDefaultInspectorOnGUI(inspectorRect, originalRule);
|
||||
if (overrideTile.m_OverrideDefault.m_Enabled)
|
||||
RuleTileEditor.SpriteOnGUI(spriteRect, overrideTile.m_OverrideDefault.m_TilingRule);
|
||||
}
|
||||
private void RuleOverrideDefaultInspectorOnGUI(Rect rect, RuleTile.TilingRule overrideRule)
|
||||
{
|
||||
float y = rect.yMin;
|
||||
EditorGUI.BeginChangeCheck();
|
||||
|
||||
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Enabled");
|
||||
bool enabled = EditorGUI.Toggle(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideTile.m_OverrideDefault.m_Enabled);
|
||||
y += k_SingleLineHeight;
|
||||
|
||||
if (EditorGUI.EndChangeCheck())
|
||||
{
|
||||
overrideTile.m_OverrideDefault.m_Enabled = enabled;
|
||||
overrideTile.m_OverrideDefault.m_TilingRule = overrideTile.m_OriginalDefault;
|
||||
}
|
||||
|
||||
if (!enabled)
|
||||
return;
|
||||
|
||||
GUI.Label(new Rect(rect.xMin, y, k_LabelWidth, k_SingleLineHeight), "Collider");
|
||||
overrideRule.m_ColliderType = (Tile.ColliderType)EditorGUI.EnumPopup(new Rect(rect.xMin + k_LabelWidth, y, rect.width - k_LabelWidth, k_SingleLineHeight), overrideRule.m_ColliderType);
|
||||
y += k_SingleLineHeight;
|
||||
}
|
||||
private void DrawRuleHeader(Rect rect)
|
||||
{
|
||||
overrideTile.Override();
|
||||
|
||||
float matrixWidth = k_DefaultElementHeight;
|
||||
|
||||
float xMax = rect.xMax;
|
||||
rect.xMax = rect.xMax / 2.0f + matrixWidth - 10f;
|
||||
GUI.Label(rect, "Original", EditorStyles.label);
|
||||
rect.xMin = rect.xMax;
|
||||
rect.xMax = xMax;
|
||||
GUI.Label(rect, "Override", EditorStyles.label);
|
||||
}
|
||||
private float GetRuleElementHeight(int index)
|
||||
{
|
||||
if (index != overrideTile.m_Tile.m_TilingRules.Count)
|
||||
{
|
||||
var overrideRule = overrideTile[overrideTile.m_Tile.m_TilingRules[index]];
|
||||
float overrideHeight = GetRuleElementHeight(overrideRule);
|
||||
float originalHeight = GetRuleElementHeight(overrideTile.m_Tile.m_TilingRules[index]);
|
||||
return Mathf.Max(overrideHeight, originalHeight);
|
||||
}
|
||||
else
|
||||
{
|
||||
var overrideRule = overrideTile.m_OverrideDefault.m_Enabled ? overrideTile.m_OverrideDefault.m_TilingRule : null;
|
||||
float overrideHeight = GetRuleElementHeight(overrideRule);
|
||||
float originalHeight = GetRuleElementHeight(new RuleTile.TilingRule());
|
||||
return Mathf.Max(overrideHeight, originalHeight);
|
||||
}
|
||||
}
|
||||
private float GetRuleElementHeight(RuleTile.TilingRule rule)
|
||||
{
|
||||
float height = k_DefaultElementHeight + k_PaddingBetweenRules;
|
||||
if (rule != null)
|
||||
{
|
||||
switch (rule.m_Output)
|
||||
{
|
||||
case RuleTile.TilingRule.OutputSprite.Random:
|
||||
height = k_DefaultElementHeight + k_SingleLineHeight * (rule.m_Sprites.Length + 3) + k_PaddingBetweenRules;
|
||||
break;
|
||||
case RuleTile.TilingRule.OutputSprite.Animation:
|
||||
height = k_DefaultElementHeight + k_SingleLineHeight * (rule.m_Sprites.Length + 2) + k_PaddingBetweenRules;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return height;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
fileFormatVersion: 2
|
||||
guid: dd977390416471341b10fd1278290da0
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
|
|
@ -0,0 +1,331 @@
|
|||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using UnityEngine.Tilemaps;
|
||||
|
||||
namespace UnityEngine
|
||||
{
|
||||
[Serializable, CreateAssetMenu]
|
||||
public class RuleOverrideTile : TileBase
|
||||
{
|
||||
public bool m_Advanced;
|
||||
public OverrideTilingRule m_OverrideDefault = new OverrideTilingRule();
|
||||
public List<OverrideTilingRule> m_OverrideTilingRules = new List<OverrideTilingRule>();
|
||||
public List<TileSpritePair> m_Sprites = new List<TileSpritePair>();
|
||||
|
||||
public RuleTile m_Tile;
|
||||
|
||||
private RuleTile m_RuntimeTile;
|
||||
|
||||
public Sprite this[Sprite originalSprite]
|
||||
{
|
||||
get
|
||||
{
|
||||
foreach (var spritePair in m_Sprites)
|
||||
{
|
||||
if (spritePair.m_OriginalSprite == originalSprite)
|
||||
{
|
||||
return spritePair.m_OverrideSprite;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
set
|
||||
{
|
||||
if (value == null)
|
||||
{
|
||||
m_Sprites = m_Sprites.Where(spritePair => spritePair.m_OriginalSprite != originalSprite).ToList();
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (var spritePair in m_Sprites)
|
||||
{
|
||||
if (spritePair.m_OriginalSprite == originalSprite)
|
||||
{
|
||||
spritePair.m_OverrideSprite = value;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
m_Sprites.Add(new TileSpritePair { m_OriginalSprite = originalSprite, m_OverrideSprite = value });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public RuleTile.TilingRule this[RuleTile.TilingRule originalRule]
|
||||
{
|
||||
get
|
||||
{
|
||||
if (!m_Tile)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var index = m_Tile.m_TilingRules.IndexOf(originalRule);
|
||||
if (index == -1)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
if (m_OverrideTilingRules.Count < index + 1)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
return m_OverrideTilingRules[index].m_Enabled ? m_OverrideTilingRules[index].m_TilingRule : null;
|
||||
}
|
||||
set
|
||||
{
|
||||
if (!m_Tile)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var index = m_Tile.m_TilingRules.IndexOf(originalRule);
|
||||
if (index == -1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (value == null)
|
||||
{
|
||||
if (m_OverrideTilingRules.Count < index + 1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
m_OverrideTilingRules[index].m_Enabled = false;
|
||||
while (m_OverrideTilingRules.Count > 0 && !m_OverrideTilingRules[m_OverrideTilingRules.Count - 1].m_Enabled)
|
||||
{
|
||||
m_OverrideTilingRules.RemoveAt(m_OverrideTilingRules.Count - 1);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (m_OverrideTilingRules.Count < index + 1)
|
||||
{
|
||||
m_OverrideTilingRules.Add(new OverrideTilingRule());
|
||||
}
|
||||
m_OverrideTilingRules[index].m_Enabled = true;
|
||||
m_OverrideTilingRules[index].m_TilingRule = CloneTilingRule(value);
|
||||
m_OverrideTilingRules[index].m_TilingRule.m_Neighbors = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public RuleTile.TilingRule m_OriginalDefault
|
||||
{
|
||||
get
|
||||
{
|
||||
return new RuleTile.TilingRule
|
||||
{
|
||||
m_Sprites = new[] { m_Tile != null ? m_Tile.m_DefaultSprite : null },
|
||||
m_ColliderType = m_Tile != null ? m_Tile.m_DefaultColliderType : Tile.ColliderType.None
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
public override bool GetTileAnimationData(Vector3Int position, ITilemap tilemap, ref TileAnimationData tileAnimationData)
|
||||
{
|
||||
if (!m_RuntimeTile)
|
||||
{
|
||||
Override();
|
||||
}
|
||||
return m_RuntimeTile.GetTileAnimationData(position, tilemap, ref tileAnimationData);
|
||||
}
|
||||
|
||||
public override void GetTileData(Vector3Int position, ITilemap tilemap, ref TileData tileData)
|
||||
{
|
||||
if (!m_RuntimeTile)
|
||||
{
|
||||
Override();
|
||||
}
|
||||
m_RuntimeTile.GetTileData(position, tilemap, ref tileData);
|
||||
}
|
||||
|
||||
public override void RefreshTile(Vector3Int position, ITilemap tilemap)
|
||||
{
|
||||
if (!m_RuntimeTile)
|
||||
{
|
||||
Override();
|
||||
}
|
||||
m_RuntimeTile.RefreshTile(position, tilemap);
|
||||
}
|
||||
|
||||
public override bool StartUp(Vector3Int position, ITilemap tilemap, GameObject go)
|
||||
{
|
||||
Override();
|
||||
return m_RuntimeTile.StartUp(position, tilemap, go);
|
||||
}
|
||||
|
||||
public void ApplyOverrides(IList<KeyValuePair<Sprite, Sprite>> overrides)
|
||||
{
|
||||
if (overrides == null)
|
||||
{
|
||||
throw new ArgumentNullException("overrides");
|
||||
}
|
||||
|
||||
for (var i = 0; i < overrides.Count; i++)
|
||||
{
|
||||
this[overrides[i].Key] = overrides[i].Value;
|
||||
}
|
||||
}
|
||||
|
||||
public void GetOverrides(List<KeyValuePair<Sprite, Sprite>> overrides)
|
||||
{
|
||||
if (overrides == null)
|
||||
{
|
||||
throw new ArgumentNullException("overrides");
|
||||
}
|
||||
|
||||
overrides.Clear();
|
||||
|
||||
if (!m_Tile)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var originalSprites = new List<Sprite>();
|
||||
|
||||
if (m_Tile.m_DefaultSprite)
|
||||
{
|
||||
originalSprites.Add(m_Tile.m_DefaultSprite);
|
||||
}
|
||||
|
||||
foreach (var rule in m_Tile.m_TilingRules)
|
||||
foreach (var sprite in rule.m_Sprites)
|
||||
{
|
||||
if (sprite && !originalSprites.Contains(sprite))
|
||||
{
|
||||
originalSprites.Add(sprite);
|
||||
}
|
||||
}
|
||||
|
||||
foreach (var sprite in originalSprites)
|
||||
{
|
||||
overrides.Add(new KeyValuePair<Sprite, Sprite>(sprite, this[sprite]));
|
||||
}
|
||||
}
|
||||
|
||||
public void ApplyOverrides(IList<KeyValuePair<RuleTile.TilingRule, RuleTile.TilingRule>> overrides)
|
||||
{
|
||||
if (overrides == null)
|
||||
{
|
||||
throw new ArgumentNullException("overrides");
|
||||
}
|
||||
|
||||
for (var i = 0; i < overrides.Count; i++)
|
||||
{
|
||||
this[overrides[i].Key] = overrides[i].Value;
|
||||
}
|
||||
}
|
||||
|
||||
public void GetOverrides(List<KeyValuePair<RuleTile.TilingRule, RuleTile.TilingRule>> overrides)
|
||||
{
|
||||
if (overrides == null)
|
||||
{
|
||||
throw new ArgumentNullException("overrides");
|
||||
}
|
||||
|
||||
overrides.Clear();
|
||||
|
||||
if (!m_Tile)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
foreach (var originalRule in m_Tile.m_TilingRules)
|
||||
{
|
||||
var overrideRule = this[originalRule];
|
||||
overrides.Add(new KeyValuePair<RuleTile.TilingRule, RuleTile.TilingRule>(originalRule, overrideRule));
|
||||
}
|
||||
|
||||
overrides.Add(new KeyValuePair<RuleTile.TilingRule, RuleTile.TilingRule>(m_OriginalDefault, m_OverrideDefault.m_TilingRule));
|
||||
}
|
||||
|
||||
public void Override()
|
||||
{
|
||||
m_RuntimeTile = m_Tile ? Instantiate(m_Tile) : new RuleTile();
|
||||
m_RuntimeTile.m_Self = this;
|
||||
if (!m_Advanced)
|
||||
{
|
||||
if (m_RuntimeTile.m_DefaultSprite)
|
||||
{
|
||||
m_RuntimeTile.m_DefaultSprite = this[m_RuntimeTile.m_DefaultSprite];
|
||||
}
|
||||
if (m_RuntimeTile.m_TilingRules != null)
|
||||
{
|
||||
foreach (var rule in m_RuntimeTile.m_TilingRules)
|
||||
{
|
||||
for (var 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_RuntimeTile.m_DefaultSprite = m_OverrideDefault.m_TilingRule.m_Sprites.Length > 0
|
||||
? m_OverrideDefault.m_TilingRule.m_Sprites[0]
|
||||
: null;
|
||||
m_RuntimeTile.m_DefaultColliderType = m_OverrideDefault.m_TilingRule.m_ColliderType;
|
||||
}
|
||||
|
||||
if (m_RuntimeTile.m_TilingRules != null)
|
||||
{
|
||||
for (var i = 0; i < m_RuntimeTile.m_TilingRules.Count; i++)
|
||||
{
|
||||
var originalRule = m_RuntimeTile.m_TilingRules[i];
|
||||
var overrideRule = this[m_Tile.m_TilingRules[i]];
|
||||
if (overrideRule == null)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
CopyTilingRule(overrideRule, originalRule, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public RuleTile.TilingRule CloneTilingRule(RuleTile.TilingRule from)
|
||||
{
|
||||
var clone = new RuleTile.TilingRule();
|
||||
CopyTilingRule(from, clone, true);
|
||||
return clone;
|
||||
}
|
||||
|
||||
public void CopyTilingRule(RuleTile.TilingRule from, RuleTile.TilingRule to, bool copyRule)
|
||||
{
|
||||
if (copyRule)
|
||||
{
|
||||
to.m_Neighbors = from.m_Neighbors;
|
||||
to.m_RuleTransform = from.m_RuleTransform;
|
||||
}
|
||||
|
||||
to.m_Sprites = from.m_Sprites.Clone() as Sprite[];
|
||||
to.m_AnimationSpeed = from.m_AnimationSpeed;
|
||||
to.m_PerlinScale = from.m_PerlinScale;
|
||||
to.m_Output = from.m_Output;
|
||||
to.m_ColliderType = from.m_ColliderType;
|
||||
to.m_RandomTransform = from.m_RandomTransform;
|
||||
}
|
||||
|
||||
[Serializable]
|
||||
public class TileSpritePair
|
||||
{
|
||||
public Sprite m_OriginalSprite;
|
||||
public Sprite m_OverrideSprite;
|
||||
}
|
||||
|
||||
[Serializable]
|
||||
public class OverrideTilingRule
|
||||
{
|
||||
public bool m_Enabled;
|
||||
public RuleTile.TilingRule m_TilingRule = new RuleTile.TilingRule();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
fileFormatVersion: 2
|
||||
guid: 4c779848d9dd029409ca676b49e10a18
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
Loading…
Add table
Add a link
Reference in a new issue