#35 reworked ore generation

miepzerino

2025-04-02 d4552adc9ec0998725e663c47114e6836061ad2c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
using System.Collections.Generic;
using UnityEngine;
 
public class GenerateableDatabase : MonoBehaviour
{
    public static GenerateableDatabase Instance { get; private set; }
    private Dictionary<int, List<(int minClusterSize, int maxHeight, int minHeight, Vector2 dropRange)>> generateableDict
        = new Dictionary<int, List<(int, int, int, Vector2 dropRange)>>();
 
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }
 
    public void InitializeFromGenerateables(List<Generateable> generateables)
    {
        generateableDict.Clear();
 
        foreach (Generateable generateable in generateables)
        {
            Dropable dropable = generateable.GetComponent<Dropable>();
 
            if (dropable != null && dropable.dropable != null)
            {
                int itemId = dropable.dropable.itemId;
 
                if (!generateableDict.ContainsKey(itemId))
                {
                    generateableDict[itemId] = new List<(int, int, int, Vector2 dropRange)>();
                }
 
                generateableDict[itemId].Add((
                    generateable.minClusterSize,
                    generateable.maxSpawnHeight,
                    generateable.minSpawnHeight,
                    dropable.dropRange
                ));
            }
        }
 
        if (generateableDict.Count == 0)
        {
            Debug.LogWarning("No valid generateables found with dropable items");
        }
    }
 
    public bool TryGetGenerateables(int itemId,
        out List<(int minClusterSize, int maxHeight, int minHeight, Vector2 dropRange)> generateables)
    {
        if (generateableDict.TryGetValue(itemId, out generateables))
        {
            return true;
        }
 
        generateables = null;
        return false;
    }
 
    // Optional: Helper method to get ranges across all variants
    public bool TryGetGenerateableRanges(int itemId,
        out int minClusterSize, out int maxHeight, out int minHeight)
    {
        if (generateableDict.TryGetValue(itemId, out var variants))
        {
            minClusterSize = int.MaxValue;
            maxHeight = int.MinValue;
            minHeight = int.MaxValue;
 
            foreach (var variant in variants)
            {
                minClusterSize = Mathf.Min(minClusterSize, variant.minClusterSize);
                maxHeight = Mathf.Max(maxHeight, variant.maxHeight);
                minHeight = Mathf.Min(minHeight, variant.minHeight);
            }
 
            return true;
        }
 
        minClusterSize = 0;
        maxHeight = 0;
        minHeight = 0;
        return false;
    }
 
    public IEnumerable<int> GetAllGenerateableIds()
    {
        return generateableDict.Keys;
    }
}