Q: Setting tile programmatically

[hieutkt]

Hi. This is a neat package. Thank you for sharing it.

Could you give any pointer on how to use this package programmatically to create infinite worlds (using Perlin noise or Wave Function Collapse)? Something similar to set_cells_terrain_connect() in TileMapLayer?

[DanTrz]

Hey @hieutkt I never really got to design a nice API for Runtime or Procedural generation of terrain yet. That is in the plans for the future.

Right now, you would need to do it yourself.

I had some play with it in an old version, but never tested it in the latest one. You would need to build some custom, similar to something like below:

runtime_world_generator.gd

class_name RuntimeWorldGenerator
extends Node

@export var tile_map: TileMapLayer3D
@export var noise: FastNoiseLite

const CHUNK_SIZE: int = 16
const FLOOR_ORIENTATION: int = 0  # GlobalConstants.Orientations.FLOOR

func procedural_generate_chunk(chunk_pos: Vector2i) -> void:
    var base_x: float = chunk_pos.x * CHUNK_SIZE
    var base_z: float = chunk_pos.y * CHUNK_SIZE
    
    for x in range(CHUNK_SIZE):
        for z in range(CHUNK_SIZE):
            var world_x: float = base_x + x
            var world_z: float = base_z + z
            
            # Sample noise for height
            var height: float = noise.get_noise_2d(world_x, world_z)
            var grid_pos: Vector3 = Vector3(world_x, floorf(height * 5), world_z)
            
            # Get UV based on height (simple biome selection)
            var uv_rect: Rect2 = _get_tile_uv_for_height(height)
            
            # Place directly - NO undo/redo needed at runtime
            tile_map.save_tile_data_direct(
                grid_pos,
                uv_rect,
                FLOOR_ORIENTATION,
                0,      # mesh_rotation
                0,      # mesh_mode (FLAT_SQUARE)
                false,  # is_flipped
                -1,     # terrain_id (-1 = manual)
                0.0, 0.0, 0.0, 0.0,  # transform params
                1.0,    # depth_scale
                0       # texture_repeat_mode
            )
    
    # This is critical, you have to rebuild all (not optimal, but current solution would be that) 
    tile_map._rebuild_chunks_from_saved_data(false)

func _get_tile_uv_for_height(height: float) -> Rect2:
    # Map height to tile UV (example: 16x16 tileset)
    var tile_size: Vector2 = Vector2(16, 16)
    var atlas_size: Vector2 = tile_map.settings.tileset_texture.get_size()
    
    var tile_index: int = 0
    if height < -0.3:
        tile_index = 0  # Water
    elif height < 0.0:
        tile_index = 1  # Sand
    elif height < 0.5:
        tile_index = 2  # Grass
    else:
        tile_index = 3  # Stone
    
    var tile_x: int = tile_index % int(atlas_size.x / tile_size.x)
    var tile_y: int = tile_index / int(atlas_size.x / tile_size.x)
    
    return Rect2(tile_x * tile_size.x, tile_y * tile_size.y, tile_size.x, tile_size.y)

Potential issues: Calling _rebuild_chunks_from_saved_data() rebuilds ALL chunks. For infinite worlds, you need incremental chunk updates. So this solution is not really perfect for that, without changing the underlying way we are handling MultiMesh, LOD, Chunk Management, etc.