/// <summary>
/// Draws a Rule Matrix for the given Rule for a RuleTile.
/// </summary>
/// <param name="tile">Tile to draw rule for.</param>
/// <param name="rect">GUI Rect to draw rule at.</param>
/// <param name="bounds">Cell bounds of the Rule.</param>
/// <param name="tilingRule">Rule to draw Rule Matrix for.</param>
public virtual void RuleMatrixOnGUI(RuleTile tile, Rect rect, BoundsInt bounds, RuleTile.TilingRule tilingRule)
{
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
float w = rect.width / bounds.size.x;
float h = rect.height / bounds.size.y;
for (int y = 0; y <= bounds.size.y; y++)
{
float top = rect.yMin + y * h;
Handles.DrawLine(new Vector3(rect.xMin, top), new Vector3(rect.xMax, top));
}
for (int x = 0; x <= bounds.size.x; x++)
{
float left = rect.xMin + x * w;
Handles.DrawLine(new Vector3(left, rect.yMin), new Vector3(left, rect.yMax));
}
Handles.color = Color.white;
var neighbors = tilingRule.GetNeighbors();
for (int y = bounds.yMin; y < bounds.yMax; y++)
{
for (int x = bounds.xMin; x < bounds.xMax; x++)
{
Vector3Int pos = new Vector3Int(x, y, 0);
Rect r = new Rect(rect.xMin + (x - bounds.xMin) * w, rect.yMin + (-y + bounds.yMax - 1) * h, w - 1, h - 1);
RuleMatrixIconOnGUI(tilingRule, neighbors, pos, r);
}
}
}
public override void OnInspectorGUI()
{
AutoTileLookup lookup = target as AutoTileLookup;
showBaseInspector = EditorGUILayout.Foldout(showBaseInspector, "Show Base Inspector");
if (showBaseInspector)
{
base.OnInspectorGUI();
}
overrideRulesFromTile = EditorGUILayout.Foldout(overrideRulesFromTile, "Override Rules List");
if (overrideRulesFromTile)
{
EditorGUILayout.BeginVertical(GUI.skin.box);
{
EditorGUILayout.LabelField(
"This will set the target rules for this lookup to match. " +
"You don't need to use this unless you are creating a new lookup.", GUI.skin.box);
RuleTile load = (RuleTile)EditorGUILayout.ObjectField("Load Ruleset", null, typeof(RuleTile), false);
if (load)
{
lookup.m_maskValues = load.m_TilingRules;
}
}
EditorGUILayout.EndVertical();
}
showSubTileMapping = EditorGUILayout.Foldout(showSubTileMapping, "Show Subtile Mapping");
if (showSubTileMapping)
{
EditorGUILayout.BeginVertical(GUI.skin.box);
{
EditorGUILayout.LabelField(
"This shows each Rule (set with the override tile rules parameter.) " +
"Alongside each rule is the lookup data for each quadrant of the tile.", GUI.skin.box);
}
EditorGUILayout.EndVertical();
SubTileMappingGUI(lookup);
}
EditorGUILayout.BeginVertical(GUI.skin.box);
{
EditorGUILayout.LabelField(
"This will take the texture and generate " +
"the appropriate assets + RuleTile data.", GUI.skin.box);
Texture2D texture = (Texture2D)EditorGUILayout.ObjectField(null, typeof(Texture2D), false);
if (texture != null)
{
ImportAutotile.ImportSubtile(texture, lookup);
}
}
EditorGUILayout.EndVertical();
}
private bool IsWalkable(Vector3Int node, float ArrowAvoidance)
{
if (!GameRule.get.GetBounds().Contains(node))
{
return(false);
}
RuleTile tile = TileMap.GetTile <RuleTile>(node);
if (tile == null)
{
return(false);
}
if (TileMap.GetColliderType(node) != Tile.ColliderType.None)
{
return(false);
}
if (GameRule.get.HasStatue(TileMap.GetBoundsLocal(node)))
{
return(false);
}
if (GameRule.get.NearBoomerang(node, ArrowAvoidance))
{
return(false);
}
return(true);
}
void ConverteToSimpleTile(Tilemap map)
{
var size = map.size;
for (int row = -size.y / 2; row < size.y; row++)
{
for (int col = -size.x / 2; col < size.x; col++)
{
var pos = new Vector3Int(col, row, 0);
RuleTile oldTile = map.GetTile(pos) as RuleTile;
if (oldTile != null)
{
MockRuleTile newTile;
if (!old_new_Tiles.ContainsKey(oldTile))
{
newTile = new MockRuleTile(oldTile);
old_new_Tiles.Add(oldTile, newTile);
}
else
{
newTile = old_new_Tiles[oldTile];
}
map.SetTile(pos, newTile);
}
}
}
}
public void OverrideRuleTile()
{
// Make a copy of the Rule Tile Template from a new asset.
RuleTile _new = CreateInstance<RuleTile>();
EditorUtility.CopySerialized(RuleTileTemplate, _new);
// Get all the sprites in the Texture2D file (TileMap)
string spriteSheet = AssetDatabase.GetAssetPath(TileMap);
Sprite[] sprites = AssetDatabase.LoadAllAssetsAtPath(spriteSheet)
.OfType<Sprite>().ToArray();
if (sprites.Length != RuleTileTemplate.m_TilingRules.Count)
{
Debug.LogWarning("The Tilemap doesn't have the same number of sprites than the Rule Tile template has rules.");
}
// Set all the sprites of the TileMap.
for (int i = 0; i < RuleTileTemplate.m_TilingRules.Count; i++)
{
_new.m_TilingRules[i].m_Sprites[0] = sprites[i];
_new.m_DefaultSprite = sprites[24];
}
// Replace this Asset with the new one.
AssetDatabase.CreateAsset(_new, AssetDatabase.GetAssetPath(this));
}
private static void AutogenerateTiles()
{
string[] actorSpriteGuids = AssetDatabase.FindAssets("t:sprite",
new[] { "Assets/Sprites/Actor" });
string[] itemSpriteGuids = AssetDatabase.FindAssets("t:sprite",
new[] { "Assets/Sprites/Item" });
foreach (string guid in actorSpriteGuids)
{
string path = AssetDatabase.GUIDToAssetPath(guid);
Sprite sprite = AssetDatabase.LoadAssetAtPath <Sprite>(path);
RuleTile tile = ScriptableObject.CreateInstance <RuleTile>();
tile.m_DefaultSprite = sprite;
string name = sprite.name.Split('_')[1];
AssetDatabase.CreateAsset(tile, $"Assets/Tiles/Actor/Tile_{name}.asset");
}
foreach (string guid in itemSpriteGuids)
{
string path = AssetDatabase.GUIDToAssetPath(guid);
Sprite sprite = AssetDatabase.LoadAssetAtPath <Sprite>(path);
Tile tile = ScriptableObject.CreateInstance <Tile>();
tile.sprite = sprite;
string name = sprite.name.Split('_')[1];
AssetDatabase.CreateAsset(tile, $"Assets/Tiles/Item/Tile_{name}.asset");
}
Debug.Log("Finished auto-generating tiles.");
}
protected void PutMissileToPool()
{
this.gameObject.SetActive(false);
this.gameObject.transform.parent = missilePool.transform;
missileContainer.PutToPool(this.gameObject);
explosionTile = Resources.Load <RuleTile>("ExplosionTile");
}
void OnTriggerExit2D(Collider2D other)
{
if (other.gameObject.tag == "Passenger" || other.gameObject.tag == "Guard" || other.gameObject.tag == "Builder" || other.gameObject.tag == "Captain")
{
// Incase the installed furniture has changed
if (tileOWW.GetInstalledFurniture()?.GetFurnitureType() == "Airlock Open")
{
// Enable collision
gameObject.GetComponent <NavMeshObstacle>().enabled = true;
// Close door texure
RuleTile t = Resources.Load <RuleTile>("TileSets/Furniture/Airlock");
FurnitureSpriteController.Instance.tilemap.SetTile(new Vector3Int((int)gameObject.transform.position.x, (int)gameObject.transform.position.y, 0), t);
// Block oxygen flow
tileOWW.GetInstalledFurniture().SetFurnitureType("Airlock");
}
else if (tileOWW.GetInstalledFurniture()?.GetFurnitureType() == "Airlock")
{
// Do nothing
}
else
{
Destroy(gameObject);
}
}
}
public MapSet(Tilemap a, RuleTile b, List <Vector3Int> c, string d)
{
map = a;
tile = b;
seeds = c;
name = d;
}
public void Caminho()
{
tmUso = controle;
rTUso = linha;
tileETexto = 0;
deletar = false;
delTexto = false;
}
public MockRuleTile(RuleTile baseTile)
{
this.m_DefaultSprite = baseTile.m_DefaultSprite;
this.m_DefaultColliderType = baseTile.m_DefaultColliderType;
this.m_TilingRules = baseTile.m_TilingRules;
RealTile = baseTile;
}
public override void OnInspectorGUI()
{
tile.m_DefaultSprite = EditorGUILayout.ObjectField("Default Sprite", tile.m_DefaultSprite, typeof(Sprite), false) as Sprite;
tile.m_DefaultGameObject = EditorGUILayout.ObjectField("Default Game Object", tile.m_DefaultGameObject, typeof(GameObject), false) as GameObject;
tile.m_DefaultColliderType = (Tile.ColliderType)EditorGUILayout.EnumPopup("Default Collider", tile.m_DefaultColliderType);
serializedObject.Update();
EditorGUI.BeginChangeCheck();
var baseFields = typeof(RuleTile).GetFields().Select(field => field.Name);
var fields = target.GetType().GetFields().Select(field => field.Name).Where(field => !baseFields.Contains(field));
foreach (var field in fields)
{
EditorGUILayout.PropertyField(serializedObject.FindProperty(field), true);
}
if (EditorGUI.EndChangeCheck())
{
serializedObject.ApplyModifiedProperties();
}
EditorGUILayout.Space();
if (m_ReorderableList != null && tile.m_TilingRules != null)
{
m_ReorderableList.DoLayoutList();
}
//Clones a ruleset and changes its base tiles.
if (tile.m_TilingRules.Count > 0)
{
tile.SpriteMapTOClone = EditorGUILayout.ObjectField("Sprite to Clone", tile.SpriteMapTOClone, typeof(Sprite), false) as Sprite;
if (GUILayout.Button("Clone Button") && tile.SpriteMapTOClone != null)
{
String path = AssetDatabase.GetAssetPath(tile.SpriteMapTOClone);
Object[] data = AssetDatabase.LoadAllAssetsAtPath(path);
Sprite[] spritelist;
spritelist = Array.ConvertAll(data, item => item as Sprite);
RuleTile ruletile = new RuleTile();
AssetDatabase.CreateAsset(ruletile, "Assets/" + tile.name + "_" + (++count) + ".asset");
for (int i = 0; i < tile.m_TilingRules.Count; i++)
{
RuleTile.TilingRule rule = new RuleTile.TilingRule();
rule.m_Output = tile.m_TilingRules[i].m_Output;
rule.m_Sprites[0] = spritelist[i + 1];
rule.m_GameObject = tile.m_DefaultGameObject;
rule.m_ColliderType = tile.m_DefaultColliderType;
for (int j = 0; j < tile.m_TilingRules[i].m_Neighbors.Length; j++)
{
rule.m_Neighbors[j] = tile.m_TilingRules[i].m_Neighbors[j];
}
ruletile.m_TilingRules.Add(rule);
}
}
}
}
/// <summary>
/// Updates all RuleOverrideTiles which override the given RUleTile
/// </summary>
/// <param name="target">RuleTile which has been updated</param>
public static void UpdateAffectedOverrideTiles(RuleTile target)
{
List<RuleOverrideTile> overrideTiles = FindAffectedOverrideTiles(target);
foreach (var overrideTile in overrideTiles)
{
overrideTile.Override();
UpdateAffectedOverrideTiles(overrideTile.m_InstanceTile);
}
}
private void Awake()
{
// Ff there is a default template, load it when the asset is created.
RuleTileTemplate_Default = Resources.Load("AutoRuleTile_default") as RuleTile;
if (RuleTileTemplate_Default != null)
{
RuleTileTemplate = RuleTileTemplate_Default;
}
}
public void Init()
{
string slug = "Sprites/RuleTiles/" + this.TileSlug;
BiomeTile = Resources.Load <RuleTile>(slug);
slug = "Prefabs/Trees/" + this.TileSlug;
Treefab = Resources.Load <GameObject>(slug);
}
public void Direcao()
{
tmUso = controle;
tUso = direcao0;
rTUso = null;
tileETexto = 0;
deletar = false;
delTexto = false;
}
private void DrawRuleMatrix(RuleTile tile, Rect rect, RuleTile.Rule rule)
{
var index = 0;
var w = rect.width / 3;
var h = rect.height / 3;
var color = new Color(0, 0, 0, 0.2f);
for (var y = 0; y <= 3; y++)
{
var top = rect.yMin + y * h;
HandleHelper.DrawLine(new Vector2(rect.xMin, top), new Vector2(rect.xMax, top), color);
}
for (var x = 0; x <= 3; x++)
{
var left = rect.xMin + x * w;
HandleHelper.DrawLine(new Vector3(left, rect.yMin), new Vector3(left, rect.yMax), color);
}
for (var y = 0; y <= 2; y++)
{
for (var x = 0; x <= 2; x++)
{
var r = new Rect(rect.xMin + x * w, rect.yMin + y * h, w - 1, h - 1);
if (x != 1 || y != 1)
{
var currentRule = rule.Neighbors[index];
DrawRule(tile, r, new Vector2Int(x, y), currentRule);
index++;
}
else
{
if (!rule.UseReference)
{
if (rule.Tile.FlipHorizontal)
{
GUI.DrawTexture(r, RuleTileEditor.Textures[10]);
}
if (rule.Tile.FlipVertical)
{
GUI.DrawTexture(r, RuleTileEditor.Textures[11]);
}
if (rule.Tile.Rotation != 0)
{
GUI.DrawTexture(r, RuleTileEditor.Textures[5]);
}
}
}
}
}
}
static private void ImportWangTile()
{
if (Selection.objects.Length != 1)
{
return;
}
Object file = Selection.objects[0];
string path = AssetDatabase.GetAssetPath(file);
Object[] spriteObjs = AssetDatabase.LoadAllAssetsAtPath(path);
List <Sprite> sprites = new List <Sprite>();
for (int i = 0; i < spriteObjs.Length; i++)
{
try
{
Sprite sprite = (Sprite)spriteObjs[i];
sprites.Add(sprite);
}
catch (System.Exception) { }
}
sprites.Sort((sprite1, sprite2) =>
{
int dashIndex1 = sprite1.name.LastIndexOf("_");
int dashIndex2 = sprite2.name.LastIndexOf("_");
int index1 = int.Parse(sprite1.name.Substring(dashIndex1 + 1));
int index2 = int.Parse(sprite2.name.Substring(dashIndex2 + 1));
// // return 0;
return(index1.CompareTo(index2));
});
RuleTile ruleTile = ScriptableObject.CreateInstance <RuleTile>();
ruleTile.m_DefaultSprite = sprites[0];
for (int i = 0; i < sprites.Count; i++)
{
RuleTile.TilingRule rule = FindWangTileRule(i);
if (rule != null)
{
rule.m_Sprites = new Sprite[] { sprites[i] };
ruleTile.m_TilingRules.Add(rule);
}
}
RuleTile.TilingRule first = ruleTile.m_TilingRules[0];
ruleTile.m_TilingRules.RemoveAt(0);
ruleTile.m_TilingRules.Add(first);
AssetDatabase.CreateAsset(ruleTile, "Assets/NewWangTile.asset");
AssetDatabase.SaveAssets();
}
public void LeftClick(Vector3 position)
{
Vector3Int positionInt = new Vector3Int((int)position.x, (int)position.y, (int)position.z);
RuleTile tile = (RuleTile)m_map.m_foregroundTilemap.GetTile(positionInt);
if (tile != null)
{
Debug.Log(string.Format("Tile is: {0}", tile.GetType()));
}
}
public RuleTileEditor GetSubTileEditor(int index, RuleTile tile)
{
if (m_SubTileEditors[index] == null)
{
m_SubTileEditors[index] = UnityEditor.Editor.CreateEditor(tile) as RuleTileEditor;
m_SubTileEditors[index].m_ReorderableList.onChangedCallback += list => OnSubListUpdate(index);
}
return(m_SubTileEditors[index]);
}
/// <summary>
/// 加载资源
/// </summary>
public void InitRes()
{
tile0 = Resources.Load(ResModule.Instance.GetPath(ResType.Tile, IdContract.TILE_BULE).assetPath) as RuleTile;
tile1 = Resources.Load(ResModule.Instance.GetPath(ResType.Tile, IdContract.TILE_CERULEAN).assetPath) as RuleTile;
tile2 = Resources.Load(ResModule.Instance.GetPath(ResType.Tile, IdContract.TILE_GREEN).assetPath) as RuleTile;
tile3 = Resources.Load(ResModule.Instance.GetPath(ResType.Tile, IdContract.TILE_ORANGE).assetPath) as RuleTile;
tile4 = Resources.Load(ResModule.Instance.GetPath(ResType.Tile, IdContract.TILE_PURPLE).assetPath) as RuleTile;
tile5 = Resources.Load(ResModule.Instance.GetPath(ResType.Tile, IdContract.TILE_RED).assetPath) as RuleTile;
tile6 = Resources.Load(ResModule.Instance.GetPath(ResType.Tile, IdContract.TILE_YELLOW).assetPath) as RuleTile;
}
protected override Sprite GetSprite(Vector3Int position, ITilemap tilemap)
{
int index = 0;
if (sprites.Length > 1)
{
index = Mathf.Clamp(Mathf.FloorToInt(RuleTile.GetPerlinValue(position, perlinScale, perlinOffset) * sprites.Length), 0, sprites.Length - 1);
}
return(sprites[index]);
}
public override void RuleMatrixOnGUI(RuleTile ruleTile, Rect rect, BoundsInt bounds,
RuleTile.TilingRule tilingRule)
{
Handles.color = EditorGUIUtility.isProSkin ? new Color(1f, 1f, 1f, 0.2f) : new Color(0f, 0f, 0f, 0.2f);
float w = rect.width / bounds.size.x;
float h = rect.height / bounds.size.y;
// Grid
float d = rect.width / (bounds.size.x + bounds.size.y);
for (int y = 0; y <= bounds.size.y; y++)
{
float left = rect.xMin + d * y;
float top = rect.yMin + d * y;
float right = rect.xMax - d * (bounds.size.y - y);
float bottom = rect.yMax - d * (bounds.size.y - y);
Handles.DrawLine(new Vector3(left, bottom), new Vector3(right, top));
}
for (int x = 0; x <= bounds.size.x; x++)
{
float left = rect.xMin + d * x;
float top = rect.yMax - d * x;
float right = rect.xMax - d * (bounds.size.x - x);
float bottom = rect.yMin + d * (bounds.size.x - x);
Handles.DrawLine(new Vector3(left, bottom), new Vector3(right, top));
}
Handles.color = Color.white;
var neighbors = tilingRule.GetNeighbors();
// Icons
float iconSize = (rect.width - d) / (bounds.size.x + bounds.size.y - 1);
float iconScale = Mathf.Pow(2, 0.5f);
for (int y = bounds.yMin; y < bounds.yMax; y++)
{
for (int x = bounds.xMin; x < bounds.xMax; x++)
{
Vector3Int pos = new Vector3Int(x, y, 0);
Vector3Int offset = new Vector3Int(pos.x - bounds.xMin, pos.y - bounds.yMin, 0);
Rect r = new Rect(
rect.xMin + rect.size.x - iconSize * (offset.y - offset.x + 0.5f + bounds.size.x),
rect.yMin + rect.size.y - iconSize * (offset.y + offset.x + 1.5f),
iconSize, iconSize
);
Vector2 center = r.center;
r.size *= iconScale;
r.center = center;
RuleMatrixIconOnGUI(tilingRule, neighbors, pos, r);
}
}
}
private void DrawRule(RuleTile tile, Rect rect, Vector2Int pos, RuleTile.NeighborType neighbor)
{
switch (neighbor)
{
case RuleTile.NeighborType.Any: break;
case RuleTile.NeighborType.This: GUI.DrawTexture(rect, RuleTileEditor.Textures[pos.y * 3 + pos.x]); break;
case RuleTile.NeighborType.NotThis: GUI.DrawTexture(rect, RuleTileEditor.Textures[9]); break;
}
}
static void ProcessFullsizeTexture(Texture2D selectedTexture, AutoTileLookup lookup)
{
string assetName = selectedTexture.name;
if (!AssetDatabase.IsValidFolder("Assets/Autotiles"))
{
string rootGuid = AssetDatabase.CreateFolder("Assets", "Autotiles");
}
string folderGuid = AssetDatabase.CreateFolder("Assets/Autotiles", assetName);
string folderName = AssetDatabase.GUIDToAssetPath(folderGuid);
Vector2Int TileResolution = new Vector2Int(
selectedTexture.width / 4,
selectedTexture.height / 6);
AssetDatabase.Refresh();
RuleTile m_tile = ScriptableObject.CreateInstance <RuleTile>();
m_tile.m_TilingRules = new List <RuleTile.TilingRule>();
int count = 0;
for (int i = 255; i >= 0; i--)
{
RuleTile.TilingRule rule = GetRule(i);
if (rule != null)
{
m_tile.m_TilingRules.Add(rule);
GenerateSprites(count, TileResolution.x, selectedTexture, lookup, folderName);
count++;
}
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
for (int i = 0; i < m_tile.m_TilingRules.Count; i++)
{
m_tile.m_TilingRules[i].m_Sprites = new Sprite[1];
m_tile.m_TilingRules[i].m_Sprites[0] = AssetDatabase.LoadAssetAtPath <Sprite>(folderName + "/" + selectedTexture.name + i + ".png");
}
AssetDatabase.CreateAsset(m_tile, folderName + "/" + assetName + "tile.asset");
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
public static void CopyAllRules(MenuCommand item)
{
RuleTile tile = item.context as RuleTile;
if (tile == null)
return;
RuleTileRuleWrapper rulesWrapper = new RuleTileRuleWrapper();
rulesWrapper.rules = tile.m_TilingRules;
var rulesJson = EditorJsonUtility.ToJson(rulesWrapper);
EditorGUIUtility.systemCopyBuffer = rulesJson;
}
internal virtual void RuleMatrixOnGUI(RuleTile tile, Rect rect, Rect sibRect, RuleTile.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));
if (tilingRule.m_CheckSiblings)
{
float top2 = sibRect.yMin + y * h;
Handles.DrawLine(new Vector3(sibRect.xMin, top2), new Vector3(sibRect.xMax, top2));
}
}
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));
if (tilingRule.m_CheckSiblings)
{
float left2 = sibRect.xMin + x * w;
Handles.DrawLine(new Vector3(left2, sibRect.yMin), new Vector3(left2, sibRect.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);
Rect r2 = new Rect(sibRect.xMin + x * w, sibRect.yMin + y * h, w - 1, h - 1);
if (x != 1 || y != 1)
{
RuleOnGUI(r, y * 3 + x, tilingRule.m_Neighbors[index]);
RuleOnGUI(r2, y * 3 + x, tilingRule.m_SiblingNeighbors[index]);
RuleNeighborUpdate(r, r2, tilingRule, index);
index++;
}
else
{
RuleTransformOnGUI(r, tilingRule.m_RuleTransform);
RuleTransformOnGUI(r2, tilingRule.m_RuleTransform);
RuleTransformUpdate(r, r2, tilingRule);
}
}
}
}
void CreateRooms()
{
roomsNumber = dungeon.roomsNumber;
roomSize = dungeon.roomSize;
bridgeTile = dungeon.bridgeTile;
groundTile = dungeon.groundTile;
barrelTile = dungeon.barrelTile;
chestTile = dungeon.chestTile;
barrelRate = dungeon.barrelsRate;
chestRate = dungeon.chestRate;
// svuota la tilemap
ClearTilemaps();
roomsCreated = 0;
Vector3Int roomPosition = Vector3Int.zero;
for (int i = 0; i < roomsNumber; i++)
{
counter = 0;
CreateRoom(roomPosition);
roomsPositions.Add(roomPosition);
int direction;
// non deve creare il passaggio nell'ultima stanza
if (i != roomsNumber - 1)
{
bool isEmpty;
do
{
direction = Random.Range(0, 4);
isEmpty = EmptySpot(roomPosition, direction);
counter++;
}while ((isEmpty == false) && (counter <= 20));
Debug.Log("Direction: " + direction + " , Empty: " + isEmpty);
if (counter == 20)
{
i = roomsNumber;
Debug.Log("Dead End");
}
else
{
CreatePassage(roomPosition, direction);
roomPosition = GetNewPosition(roomPosition, direction);
}
}
roomsCreated++;
}
Debug.Log("Rooms Created: " + roomsCreated);
}
private void Populate_World(int birth_amount, RuleTile place_tile)
{
List <Vector3Int> birth_list = new List <Vector3Int>();
// Birth or death the cells depending on neighbours
for (int i = 0; i < world_size.x * 10; i++)
{
for (int j = 0; j < world_size.y * 10; j++)
{
if ((i != 0) && (j != 0) && (i + 1 != world_size.x * 10) && (j + 1 != world_size.y * 10))
{
Vector3Int target_pos = new Vector3Int(i, j, 0);
List <Vector3Int> neighbours = new List <Vector3Int>();
neighbours.Add(target_pos + new Vector3Int(1, 0, 0));
neighbours.Add(target_pos + new Vector3Int(-1, 0, 0));
neighbours.Add(target_pos + new Vector3Int(0, 1, 0));
neighbours.Add(target_pos + new Vector3Int(0, -1, 0));
neighbours.Add(target_pos + new Vector3Int(1, 1, 0));
neighbours.Add(target_pos + new Vector3Int(-1, 1, 0));
neighbours.Add(target_pos + new Vector3Int(1, -1, 0));
neighbours.Add(target_pos + new Vector3Int(-1, -1, 0));
int neighbour_count = 0;
foreach (var neighbour_check in neighbours)
{
if (Get_Tile(neighbour_check) != null)
{
neighbour_count++;
}
}
if ((neighbour_count >= birth_amount) && (Get_Tile(target_pos) != null))
{
birth_list.Add(target_pos);
}
}
}
}
foreach (var birth_pos in birth_list)
{
Add_Tile(birth_pos, place_tile);
//dungeon_walls.SetTile(birth_pos, place_tile);
//yield return null;
}
}
internal override void RuleMatrixOnGUI(RuleTile ruleTile, Rect rect, RuleTile.TilingRule tilingRule)
{
var isoTile = (IsometricRuleTile)ruleTile;
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;
// Grid
for (int y = 0; y <= 3; y++)
{
float left = rect.xMin + (y * rect.width) / 6;
float right = left + rect.width / 2;
float bottom = rect.yMin + (y * rect.height) / 6;
float top = bottom + rect.height / 2;
Handles.DrawLine(new Vector3(left, top), new Vector3(right, bottom));
}
for (int x = 0; x <= 3; x++)
{
float left = rect.xMin + (x * rect.width) / 6;
float right = left + rect.width / 2;
float top = rect.yMax - (x * rect.height) / 6;
float bottom = top - rect.height / 2;
Handles.DrawLine(new Vector3(left, bottom), new Vector3(right, top));
}
Handles.color = Color.white;
// Icons
for (int y = 0; y <= 2; y++)
{
for (int x = 0; x <= 2; x++)
{
Rect r = new Rect(
rect.xMin + ((x + y) * rect.width) / 6,
rect.yMin + ((2 - x + y) * rect.height) / 6,
w - 1, h - 1);
if (x != 1 || y != 1)
{
RuleOnGUI(r, s_Arrows[y, x], tilingRule.m_Neighbors[index]);
RuleNeighborUpdate(r, tilingRule, index);
index++;
}
else
{
RuleTransformOnGUI(r, tilingRule.m_RuleTransform);
RuleTransformUpdate(r, tilingRule);
}
}
}
}
