From 2dfa4588b3b5bba2a84dab239d62b1c285478870 Mon Sep 17 00:00:00 2001
From: miepzerino <o.skotnik@gmail.com>
Date: Wed, 02 Apr 2025 22:31:45 +0000
Subject: [PATCH] inventory scrollbar autohide
---
Assets/Scripts/GenerateTileMap.cs | 195 +++++++++++++++++++++++++++++++++++++++++++++---
1 files changed, 180 insertions(+), 15 deletions(-)
diff --git a/Assets/Scripts/GenerateTileMap.cs b/Assets/Scripts/GenerateTileMap.cs
index 136a14d..e704d1a 100644
--- a/Assets/Scripts/GenerateTileMap.cs
+++ b/Assets/Scripts/GenerateTileMap.cs
@@ -1,29 +1,55 @@
using System;
using System.Collections;
using System.Collections.Generic;
+using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.Tilemaps;
using UnityEngine.UIElements;
+using static UnityEditor.Progress;
+
+//[Serializable]
+//public class Ore
+//{
+// public string name;
+// /// <summary>
+// /// The lower the numer the higher the amount of ores that will spawn
+// /// Higher number means less ore
+// /// </summary>
+// [Tooltip("The lower the numer the higher the amount of ores that will spawn. Higher number means less ore.")]
+// [Range(1, 100000)]
+// public int weight;
+// /// <summary>
+// /// The lower the number the more dense the ore will spawn (big clusters
+// /// Higher number means little clusters (more spread)
+// /// </summary>
+// [Tooltip("The lower the number the more dense the ore will spawn (big clusters. Higher number means little clusters (more spread).")]
+// [Range(10, 100000)]
+// public int clusterWeight;
+// public CustomRuleTile tile;
+// public int maxSpawnHeight;
+// public int minSpawnHeight;
+//}
public class GenerateTileMap : MonoBehaviour
{
public int? seed;
- public int maxWidth = 256;
- public int maxHeight = 384;
- public int maxGroundHeight = 256;
+ public static int maxWidth = 256;
+ public static int maxDepth = 384;
+ public static int groundDepth = 256;
private float scale;
private float offsetX;
private float offsetY;
Tilemap tilemap;
- public RuleTile forestRuleTile;
+ public CustomRuleTile forestRuleTile;
public TileBase borderTile;
+ private List<Generateable> generateables;
//public List<TileBase> tiles;
private void Awake()
{
tilemap = GetComponent<Tilemap>();
#if DEBUG
- //seed = 0123456789;
+ seed = 0123456789;
#endif
if (seed == null)
{
@@ -31,6 +57,43 @@
}
SetSettingsFromSeed(seed.Value);
+
+ // Position adjusted to center horizontally, but align top at y=0
+ transform.position = new Vector3((maxWidth / 2) * -1, -1, transform.position.z);
+
+ LoadGenerateablesFromResources();
+ }
+ private void LoadGenerateablesFromResources()
+ {
+ // Clear existing siblings
+ forestRuleTile.siblings.Clear();
+
+ // Load all Item prefabs from the "Resources/Items" folder
+ GameObject[] generateablePrefabs = Resources.LoadAll<GameObject>("Generateable");
+ generateables = new List<Generateable>();
+ foreach (GameObject prefab in generateablePrefabs)
+ {
+ Generateable generateable = prefab.GetComponent<Generateable>();
+ if (generateable != null)
+ {
+ generateable.tile = ScriptableObject.CreateInstance<CustomRuleTile>();
+ generateable.tile.m_DefaultGameObject = prefab;
+ generateable.tile.m_DefaultSprite = generateable.sprite;
+ generateables.Add(generateable);
+ forestRuleTile.siblings.Add(generateable.tile);
+ }
+ else
+ {
+ Debug.LogWarning($"Prefab {prefab.name} does not have an Item component");
+ }
+ }
+
+ GenerateableDatabase.Instance.InitializeFromGenerateables(generateables);
+
+ if (generateables.Count == 0)
+ {
+ Debug.LogWarning("No items found in Resources/Items folder");
+ }
}
public void SetSettingsFromSeed(int seed)
@@ -60,19 +123,35 @@
public IEnumerator GenerateTiles(Action finishedCallback, List<Vector3Int> destroyedTiles)
{
+ // generate ground
+ yield return CreateGroundLayer(destroyedTiles);
+
+ if (generateables != null)
+ {
+ yield return GenerateOreClusters(destroyedTiles);
+ }
+
+ // generate borders
+ yield return GenerateBorders();
+ finishedCallback();
+ }
+
+ private IEnumerator CreateGroundLayer(List<Vector3Int> destroyedTiles)
+ {
for (int x = 1; x < maxWidth; x++)
{
- for (int y = 1; y < maxGroundHeight; y++)
+ for (int y = -1; y > -groundDepth; y--)
{
float xPerlin = ((float)x / maxWidth) * scale + offsetX;
- float yPerlin = ((float)y / maxHeight) * scale + offsetY;
+ float yPerlin = ((float)Mathf.Abs(y) / maxDepth) * scale + offsetY;
float perlinNoise = Mathf.PerlinNoise(xPerlin, yPerlin);
- if (perlinNoise >= 0.3f)
+ if (perlinNoise <= 0.7f)
{
- if (!destroyedTiles.Contains(new Vector3Int(x, y, 0)))
+ Vector3Int tileSpawnCoord = new Vector3Int(x, y);
+ if (!destroyedTiles.Contains(tileSpawnCoord))
{
- tilemap.SetTile(new Vector3Int(x, y), forestRuleTile);
+ tilemap.SetTile(tileSpawnCoord, forestRuleTile);
}
}
@@ -84,24 +163,110 @@
yield return null;
}
}
+ }
+
+ private IEnumerator GenerateOreClusters(List<Vector3Int> destroyedTiles)
+ {
+ foreach (Generateable generateable in generateables)
+ {
+ // Convert spawn heights to negative values if they aren't already
+ int maxY = -Mathf.Abs(generateable.maxSpawnHeight);
+ int minY = -Mathf.Abs(generateable.minSpawnHeight);
+ Debug.Log($"Generating {generateable.name} between Y: {minY} - {maxY}");
+ for (int x = 0; x < maxWidth; x++)
+ {
+ for (int y = maxY; y > minY; y--)
+ {
+ float xPerlin = ((float)x / maxWidth) * (float)generateable.clusterWeight + offsetX;
+ float yPerlin = ((float)Mathf.Abs(y) / maxDepth) * (float)generateable.clusterWeight + offsetY;
+ float perlinNoise = Mathf.PerlinNoise(xPerlin, yPerlin);
+
+ if (perlinNoise <= (1f / (float)generateable.weight))
+ {
+ Vector3Int tileSpawnCoord = new Vector3Int(x, y);
+ if (!destroyedTiles.Contains(tileSpawnCoord) && tilemap.HasTile(tileSpawnCoord))
+ {
+ // Check potential cluster size before placing
+ int clusterSize = CountPotentialClusterSize(x, y, generateable.weight, generateable.clusterWeight);
+ if (clusterSize >= generateable.minClusterSize)
+ {
+ tilemap.SetTile(tileSpawnCoord, generateable.tile);
+ }
+ //tilemap.SetTile(tileSpawnCoord, generateable.tile);
+ }
+ }
+
+ }
+
+ // Update UI every 8 lines
+ if ((x % 8) == 0)
+ {
+ yield return null;
+ }
+ }
+ }
+ }
+
+ private IEnumerator GenerateBorders()
+ {
+ // Vertical borders (going up from underground to sky)
for (int x = 0; x <= maxWidth; x += maxWidth)
{
- for (int y = 0; y <= maxHeight; y++)
+ for (int y = -groundDepth; y <= maxDepth - groundDepth; y++)
{
tilemap.SetTile(new Vector3Int(x, y), borderTile);
}
-
}
yield return null;
- for (int y = 0; y <= maxHeight; y += maxHeight)
+
+ // Horizontal borders (at bottom and sky level)
+ for (int y = -groundDepth; y <= maxDepth - groundDepth; y += maxDepth)
{
for (int x = 1; x <= maxWidth; x++)
{
tilemap.SetTile(new Vector3Int(x, y), borderTile);
}
-
}
yield return null;
- finishedCallback();
+ }
+
+ private int CountPotentialClusterSize(int startX, int startY, int weight, int clusterWeight)
+ {
+ int size = 0;
+ Queue<Vector2Int> toCheck = new Queue<Vector2Int>();
+ HashSet<Vector2Int> checked_positions = new HashSet<Vector2Int>();
+
+ toCheck.Enqueue(new Vector2Int(startX, startY));
+ checked_positions.Add(new Vector2Int(startX, startY));
+
+ while (toCheck.Count > 0)
+ {
+ Vector2Int current = toCheck.Dequeue();
+ size++;
+
+ // Check all 8 neighboring tiles
+ for (int dx = -1; dx <= 1; dx++)
+ {
+ for (int dy = -1; dy <= 1; dy++)
+ {
+ if (dx == 0 && dy == 0) continue;
+
+ Vector2Int neighbor = new Vector2Int(current.x + dx, current.y + dy);
+ if (checked_positions.Contains(neighbor)) continue;
+
+ float xPerlin = ((float)neighbor.x / maxWidth) * clusterWeight + offsetX;
+ float yPerlin = ((float)Mathf.Abs(neighbor.y) / maxDepth) * clusterWeight + offsetY;
+ float perlinNoise = Mathf.PerlinNoise(xPerlin, yPerlin);
+
+ if (perlinNoise <= (1f / (float)weight))
+ {
+ toCheck.Enqueue(neighbor);
+ checked_positions.Add(neighbor);
+ }
+ }
+ }
+ }
+
+ return size;
}
}
--
Gitblit v1.9.3