#42 still bugged

miepzerino

2025-04-03 4f1ed3919b0ee3f89dbcbacf49990888a7d9274a

 Assets/Scripts/GenerateTileMap.cs

@@ -1,6 +1,9 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Unity.Collections;
using Unity.Jobs;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.Tilemaps;
@@ -52,6 +55,11 @@
    private Transform playerTransform; // Reference to player/camera
    private Vector2Int lastLoadedChunk;
    private GameManager gameManager;
    private Dictionary<Vector2Int, HashSet<Vector3Int>> activeChunkTiles = new Dictionary<Vector2Int, HashSet<Vector3Int>>();
    public TilePool tilePool; // Reference to the TilePool script
    private bool isGenerating = false; 
    private Dictionary<Vector2Int, List<(Vector3Int position, CustomRuleTile tile)>> chunkTileData = new Dictionary<Vector2Int, List<(Vector3Int position, CustomRuleTile tile)>>();


    private void Awake()
    {
@@ -70,20 +78,40 @@

        // Position adjusted to center horizontally, but align top at y=0
        transform.position = new Vector3((maxWidth / 2) * -1, -1, transform.position.z);
        tilePool.InitializePool(forestRuleTile);

        LoadGenerateablesFromResources();
    }
    private void Update()
    {
        if (playerTransform == null) return;
        Debug.Log($"Player Position: {playerTransform.position}");
        if (playerTransform == null || isGenerating) return;

        Vector2Int currentChunk = GetChunkPosition(playerTransform.position);
        Debug.Log($"Current Chunk: {currentChunk}");
        if (currentChunk != lastLoadedChunk)
        {
            StartCoroutine(UpdateLoadedChunks(currentChunk));
            Debug.Log($"Player moved to new chunk: {currentChunk}");
            isGenerating = true;
            StopAllCoroutines();

            var chunksToUnload = loadedChunks.Keys
                .Where(chunk => Mathf.Abs(chunk.x - currentChunk.x) > LOAD_DISTANCE ||
                               Mathf.Abs(chunk.y - currentChunk.y) > LOAD_DISTANCE)
                .ToList();

            foreach (var chunk in chunksToUnload)
            {
                Debug.Log($"Unloading chunk: {chunk}");
                UnloadChunk(chunk);
            }

            StartCoroutine(UpdateLoadedChunksWithCompletion(currentChunk));
            lastLoadedChunk = currentChunk;
        }
    }
    private IEnumerator UpdateLoadedChunksWithCompletion(Vector2Int currentChunk)
    {
        yield return UpdateLoadedChunks(currentChunk);
        isGenerating = false;
    }
    // When a tile is destroyed in a chunk, update GameManager's list
    private void AddDestroyedTile(Vector3Int tilePos)
@@ -92,6 +120,45 @@
        {
            gameManager.destroyedTiles.Add(tilePos);
        }
    }
    private void SetTileWithPool(Vector3Int position, CustomRuleTile tileType)
    {
        var chunk = new Vector2Int(
            Mathf.FloorToInt(position.x / (float)CHUNK_SIZE),
            Mathf.FloorToInt(position.y / (float)CHUNK_SIZE)
        );

        if (!activeChunkTiles.ContainsKey(chunk))
        {
            activeChunkTiles[chunk] = new HashSet<Vector3Int>();
        }

        var tileData = tilePool.GetTileData(position, tileType);
        if (tileData != null)
        {
            tilemap.SetTile(position, tileData.tileType);
            activeChunkTiles[chunk].Add(position);

            // Refresh neighboring tiles to maintain proper rule tile connections
            for (int nx = -1; nx <= 1; nx++)
            {
                for (int ny = -1; ny <= 1; ny++)
                {
                    if (nx == 0 && ny == 0) continue;
                    Vector3Int neighbor = new Vector3Int(position.x + nx, position.y + ny, position.z);
                    if (tilemap.HasTile(neighbor))
                    {
                        tilemap.RefreshTile(neighbor);
                    }
                }
            }
        }
    }

    private void RemoveTileWithPool(Vector3Int position)
    {
        tilemap.SetTile(position, null);
        tilePool.ReturnTileData(position);
    }

    // When checking if a tile is destroyed, use GameManager's list
@@ -109,11 +176,11 @@
                Mathf.Abs(chunk.y - currentChunk.y) > LOAD_DISTANCE)
            {
                chunksToUnload.Add(chunk);
                UnloadChunk(chunk);
            }
        }
        foreach (var chunk in chunksToUnload)
        {
            UnloadChunk(chunk);
            loadedChunks.Remove(chunk);
        }

@@ -123,16 +190,25 @@

    private void UnloadChunk(Vector2Int chunk)
    {
        if (!loadedChunks.ContainsKey(chunk)) return;

        int startX = chunk.x * CHUNK_SIZE;
        int startY = chunk.y * CHUNK_SIZE;

        for (int x = startX; x < startX + CHUNK_SIZE; x++)
        // Clear rule cache for this chunk
        forestRuleTile.ClearRuleCache();

        // Remove all tiles in the chunk
        if (activeChunkTiles.TryGetValue(chunk, out var tiles))
        {
            for (int y = startY; y > startY - CHUNK_SIZE; y--)
            foreach (var pos in tiles)
            {
                tilemap.SetTile(new Vector3Int(x, y), null);
                RemoveTileWithPool(pos);
            }
            activeChunkTiles.Remove(chunk);
        }

        loadedChunks.Remove(chunk);
    }
    private void LoadGenerateablesFromResources()
    {
@@ -209,10 +285,14 @@
        float adjustedX = worldPosition.x - transform.position.x;
        float adjustedY = worldPosition.y - transform.position.y;

        return new Vector2Int(
        // Calculate chunk position based on chunk boundaries
        // We don't add the CHUNK_SIZE/2 offset here anymore since we want to detect based on boundaries
        Vector2Int chunkPosition = new Vector2Int(
            Mathf.FloorToInt(adjustedX / CHUNK_SIZE),
            Mathf.FloorToInt(adjustedY / CHUNK_SIZE)
        );

        return chunkPosition;
    }
    private IEnumerator LoadChunksAroundPosition(Vector2Int centerChunk, List<Vector3Int> destroyedTiles)
    {
@@ -223,7 +303,29 @@
                Vector2Int chunkPos = new Vector2Int(centerChunk.x + x, centerChunk.y + y);
                if (!loadedChunks.ContainsKey(chunkPos))
                {
                    yield return GenerateChunk(chunkPos, destroyedTiles);
                    if (chunkTileData.ContainsKey(chunkPos))
                    {
                        Debug.Log($"Reloading chunk from saved data: {chunkPos}");
                        // Reload chunk from saved data
                        var tilesToUpdate = chunkTileData[chunkPos];
                        const int BATCH_SIZE = 32;
                        for (int i = 0; i < tilesToUpdate.Count; i += BATCH_SIZE)
                        {
                            int batchCount = Math.Min(BATCH_SIZE, tilesToUpdate.Count - i);
                            for (int j = 0; j < batchCount; j++)
                            {
                                var (pos, tile) = tilesToUpdate[i + j];
                                SetTileWithPool(pos, tile);
                            }
                            yield return null;
                        }
                    }
                    else
                    {
                        Debug.Log($"Generating new chunk: {chunkPos}");
                        // Generate new chunk
                        yield return GenerateChunk(chunkPos, destroyedTiles);
                    }
                    loadedChunks[chunkPos] = true;
                }
            }
@@ -232,42 +334,94 @@
    private IEnumerator GenerateChunk(Vector2Int chunk, List<Vector3Int> destroyedTiles)
    {
        int startX = chunk.x * CHUNK_SIZE;
        int startY = (chunk.y * CHUNK_SIZE);
        int startY = chunk.y * CHUNK_SIZE;

        // Generate ground in chunk
        for (int x = startX; x < startX + CHUNK_SIZE; x++)
        // Clear rule cache for this chunk's area
        forestRuleTile.ClearRuleCache();

        NativeArray<bool> terrainMap = default;
        NativeArray<float> noiseMap = default;

        try
        {
            if (x < 1 || x >= maxWidth) continue;
            terrainMap = new NativeArray<bool>(CHUNK_SIZE * CHUNK_SIZE, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
            noiseMap = new NativeArray<float>(CHUNK_SIZE * CHUNK_SIZE, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);

            for (int y = startY; y > startY - CHUNK_SIZE; y--)
            var job = new TerrainGenerationJob
            {
                if (y < -groundDepth || y >= 0) continue;
                Vector3Int tilePos = new Vector3Int(x, y);
                if (IsTileDestroyed(tilePos))
                    continue;
                ChunkStartX = startX,
                ChunkStartY = startY,
                ChunkSize = CHUNK_SIZE,
                Scale = scale,
                OffsetX = offsetX,
                OffsetY = offsetY,
                MaxWidth = maxWidth,
                MaxDepth = maxDepth,
                TerrainMap = terrainMap,
                NoiseMap = noiseMap
            };

                float xPerlin = ((float)x / maxWidth) * scale + offsetX;
                float yPerlin = ((float)Mathf.Abs(y) / maxDepth) * scale + offsetY;
                float perlinNoise = Mathf.PerlinNoise(xPerlin, yPerlin);
            // Schedule and complete job immediately to prevent frame lifetime issues
            job.Schedule(CHUNK_SIZE * CHUNK_SIZE, 32).Complete();

                if (perlinNoise <= 0.7f)
            // Copy data from job before yielding
            var tilesToUpdate = new List<(Vector3Int pos, CustomRuleTile tile)>();

            for (int i = 0; i < terrainMap.Length; i++)
            {
                if (terrainMap[i])
                {
                    tilemap.SetTile(tilePos, forestRuleTile);
                    int x = startX + (i % CHUNK_SIZE);
                    int y = startY + (i / CHUNK_SIZE);
                    Vector3Int tilePos = new Vector3Int(x, y);

                    if (!IsTileDestroyed(tilePos))
                    {
                        tilesToUpdate.Add((tilePos, forestRuleTile));
                    }
                }
            }
        }

        // Generate ores in chunk
        if (generateables != null)
        {
            yield return GenerateOresInChunk(chunk, destroyedTiles);
            // Save tile data to dictionary
            chunkTileData[chunk] = tilesToUpdate;

            // Dispose native arrays before yielding
            terrainMap.Dispose();
            noiseMap.Dispose();
            terrainMap = default;
            noiseMap = default;

            // Now we can safely yield and process tiles
            const int BATCH_SIZE = 32;
            for (int i = 0; i < tilesToUpdate.Count; i += BATCH_SIZE)
            {
                int batchCount = Math.Min(BATCH_SIZE, tilesToUpdate.Count - i);
                for (int j = 0; j < batchCount; j++)
                {
                    var (pos, tile) = tilesToUpdate[i + j];
                    SetTileWithPool(pos, tile);
                }
                yield return null;
            }

            // Generate ores
            if (generateables != null)
            {
                yield return GenerateOresInChunk(chunk, destroyedTiles);
            }

            // Generate borders if needed
            if (startX == 0 || startX + CHUNK_SIZE >= maxWidth ||
                startY == 0 || startY - CHUNK_SIZE <= -groundDepth)
            {
                yield return GenerateBorders();
            }
        }
        // Don't generate borders for each chunk
        // Only generate borders when at world edges
        if (startX == 0 || startX + CHUNK_SIZE >= maxWidth ||
            startY == 0 || startY - CHUNK_SIZE <= -groundDepth)
        finally
        {
            yield return GenerateBorders();
            // Ensure arrays are always disposed
            if (terrainMap.IsCreated) terrainMap.Dispose();
            if (noiseMap.IsCreated) noiseMap.Dispose();
        }
    }

@@ -462,6 +616,11 @@
            Vector2Int currentChunk = GetChunkPosition(playerTransform.position);
            Gizmos.color = Color.yellow;

            // Draw player position for debugging
            Gizmos.color = Color.red;
            Gizmos.DrawSphere(playerTransform.position, 0.5f);
            Gizmos.color = Color.yellow;

            for (int x = -LOAD_DISTANCE; x <= LOAD_DISTANCE; x++)
            {
                for (int y = -LOAD_DISTANCE; y <= LOAD_DISTANCE; y++)
@@ -473,10 +632,19 @@
                        0
                    );

                    // Draw chunk boundary
                    Gizmos.DrawWireCube(
                        worldPos + new Vector3(CHUNK_SIZE / 2f, -CHUNK_SIZE / 2f, 0),
                        new Vector3(CHUNK_SIZE, CHUNK_SIZE, 0)
                    );

                    // Draw chunk coordinates and boundaries
                    UnityEditor.Handles.Label(
                        worldPos + new Vector3(CHUNK_SIZE / 2f, -CHUNK_SIZE / 2f, 0),
                        $"({chunk.x}, {chunk.y})\n" +
                        $"X: {worldPos.x} to {worldPos.x + CHUNK_SIZE}\n" +
                        $"Y: {worldPos.y} to {worldPos.y - CHUNK_SIZE}"
                    );
                }
            }
        }