turns-00013.parquet:85427
7a8e3dc99f0c10c7dc5ecabedegenerate_repetitionAbsentFinal dense release
USER
so how do I remake this so it uses the tile sets instead?:
extends TileMap
# Initialize noise generators for different map features
# Values between -1 and 1
var moisture = FastNoiseLite.new()
var temperature = FastNoiseLite.new()
var altitude = FastNoiseLite.new()
# Dimensions of each generated chunk
var width = 64
var height = 64
# Reference to the player character
@onready var player = get_tree().current_scene.get_node("Player")
# List to keep track of loaded chunks
var loaded_chunks = []
func _ready():
# Set random seeds for noise variation
moisture.seed = randi()
temperature.seed = randi()
altitude.seed = randi()
# Adjust this value to change the 'smoothness' of the map; lower values mean more smooth noise
altitude.frequency = 0.01
func _process(delta):
# Convert the player's position to tile coordinates
var player_tile_pos = local_to_map(player.position)
# Generate the chunk at the player's position
generate_chunk(player_tile_pos)
# Unload chunks that are too far away.
# Note: Not needed for smaller projects but if you are loading a bigger tilemap it's good practice
unload_distant_chunks(player_tile_pos)
func generate_chunk(pos):
for x in range(width):
for y in range(height):
# Generate noise values for moisture, temperature, and altitude
var moist = moisture.get_noise_2d(pos.x - (width/2) + x, pos.y - (height/2) + y) * 10 # Values between -10 and 10
var temp = temperature.get_noise_2d(pos.x - (width/2) + x, pos.y - (height/2) + y) * 10
var alt = altitude.get_noise_2d(pos.x - (width/2) + x, pos.y - (height/2) + y) * 10
# Set the cell based on altitude; adjust for different tile types
# Need to evenly distribute -10 -> 10 to 0 -> 4.... This can be done by first adding 10
# Gets values from 0 -> 20... Then we will multiply by 3/20 in order to remap it to 0 -> 3
# vvv
if alt < 0: # Arbitrary sea level value (choosing 0 will mean roughly 1/2 the world is ocean)
set_cell(0, Vector2i(pos.x - (width/2) + x, pos.y - (height/2) + y), 0, Vector2(3, round(3 * (temp + 10) / 20))) # Change x value where I've wrote three to whatever the x-coord of your oceans are
else: # You can add other logic like making beaches by setting x-coord to whatever beach atlas x-coord is when the alt is between 0 and 0.5 or something
set_cell(0, Vector2i(pos.x - (width/2) + x, pos.y - (height/2) + y), 0, Vector2(round(3 * (moist + 10) / 20), round(3 * (temp + 10) / 20)))
if Vector2i(pos.x, pos.y) not in loaded_chunks:
loaded_chunks.append(Vector2i(pos.x, pos.y))
# Function to unload chunks that are too far away
func unload_distant_chunks(player_pos):
# Set the distance threshold to at least 2 times the width to limit visual glitches
# Higher values unload chunks further away
var unload_distance_threshold = (width * 2) + 1
for chunk in loaded_chunks:
var distance_to_player = get_dist(chunk, player_pos)
if distance_to_player > unload_distance_threshold:
clear_chunk(chunk)
loaded_chunks.erase(chunk)
# Function to clear a chunk
func clear_chunk(pos):
for x in range(width):
for y in range(height):
set_cell(0, Vector2i(pos.x - (width/2) + x, pos.y - (height/2) + y), -1, Vector2(-1, -1), -1)
# Function to calculate distance between two points
func get_dist(p1, p2):
var resultant = p1 - p2
return sqrt(resultant.x ** 2 + resultant.y ** 2)
ASSISTANT
It seems like you're trying to use the `set_cell` method incorrectly. To use autotiling with terrain sets in Godot, first, you need to configure an Autotile in your TileSet using the Godot editor. Once your Autotile is configured with the appropriate bitmask, connecting tiles, and collisions if needed, you can then reference it in your code using its tile index.
Here's how you modify the script to use a single autotile for both terrain types, water and land:
1. Configure your tileset with autotile. Create one autotile for water and one for land within the same TileSet resource. Let's assume the index for water is `0` and the index for land is `1`.
2. Update the `generate_chunk` function to use the correct autotile index and make sure you remove your `Vector2` coordinate from the `set_cell` call, as it requires individual integers for the x and y positions.
Here's what your updated `generate_chunk` function might look like:
```gdscript
func generate_chunk(pos):
var chunk_start = Vector2i(floor(pos.x / width) * width, floor(pos.y / height) * height)
if chunk_start in loaded_chunks:
return
for x in range(width):
for y in range(height):
# Get world position for the current tile.
var world_x = chunk_start.x + x
var world_y = chunk_start.y + y
# Generate noise values for moisture, temperature, and altitude.
var moist = moisture.get_noise_2d(world_x, world_y) * 10
var temp = temperature.get_noise_2d(world_x, world_y) * 10
var alt = altitude.get_noise_2d(world_x, world_y) * 10
# Choose the correct tile index based on altitude.
var tile_index = alt < 0 ? 0 : 1 # 0 for water, 1 for land.
# Set the cell using the determined tile index.
set_cell(world_x, world_y, tile_index)
# Add the current chunk to the list of loaded chunks.
loaded_chunks.append(chunk_start)
```
In this updated function:
- We define `chunk_start` to be the top-left tile position of the chunk the player is currently in.
- We check if the chunk is already loaded before generating it to avoid unnecessary work.
- When calling `set_cell`, we pass the world `x` and `y` positions as separate integers and the determined `tile_index` (0 for water, 1 for land).
Make sure your autotile is properly configured with all the required rules for tiling. Godot will apply your configured tile rules to the terrains and automatically choose the correct sub-tiles to represent different terrain types and transitions between them.
The script assumes that you have two autotile indices (0 for water, 1 for land). If you have more varied terrains, you'll need to refine the logic that assigns `tile_index` to choose the appropriate tile index based on your environment criteria.