Add terrain center bit

4 files changed, 726 insertions, 320 deletions

diff --git a/scene/2d/tile_map.cpp b/scene/2d/tile_map.cpp
index c4b923ff34..a7301c7f1f 100644
--- a/scene/2d/tile_map.cpp
+++ b/scene/2d/tile_map.cpp
@@ -36,27 +36,30 @@
 
 HashMap<Vector2i, TileSet::CellNeighbor> TileMap::TerrainConstraint::get_overlapping_coords_and_peering_bits() const {
 	HashMap<Vector2i, TileSet::CellNeighbor> output;
+
+	ERR_FAIL_COND_V(is_center_bit(), output);
+
 	Ref<TileSet> tile_set = tile_map->get_tileset();
 	ERR_FAIL_COND_V(!tile_set.is_valid(), output);
 
 	TileSet::TileShape shape = tile_set->get_tile_shape();
 	if (shape == TileSet::TILE_SHAPE_SQUARE) {
 		switch (bit) {
-			case 0:
+			case 1:
 				output[base_cell_coords] = TileSet::CELL_NEIGHBOR_RIGHT_SIDE;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_LEFT_SIDE;
 				break;
-			case 1:
+			case 2:
 				output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER)] = TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER;
 				break;
-			case 2:
+			case 3:
 				output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_SIDE;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_SIDE;
 				break;
-			case 3:
+			case 4:
 				output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER)] = TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER;
@@ -67,23 +70,23 @@ HashMap<Vector2i, TileSet::CellNeighbor> TileMap::TerrainConstraint::get_overlap
 		}
 	} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC) {
 		switch (bit) {
-			case 0:
+			case 1:
 				output[base_cell_coords] = TileSet::CELL_NEIGHBOR_RIGHT_CORNER;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_BOTTOM_CORNER;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_RIGHT_CORNER)] = TileSet::CELL_NEIGHBOR_LEFT_CORNER;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_CORNER;
 				break;
-			case 1:
+			case 2:
 				output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE;
 				break;
-			case 2:
+			case 3:
 				output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_CORNER;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_LEFT_CORNER;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_CORNER)] = TileSet::CELL_NEIGHBOR_TOP_CORNER;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE)] = TileSet::CELL_NEIGHBOR_RIGHT_CORNER;
 				break;
-			case 3:
+			case 4:
 				output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE;
 				output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE;
 				break;
@@ -95,25 +98,25 @@ HashMap<Vector2i, TileSet::CellNeighbor> TileMap::TerrainConstraint::get_overlap
 		TileSet::TileOffsetAxis offset_axis = tile_set->get_tile_offset_axis();
 		if (offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
 			switch (bit) {
-				case 0:
+				case 1:
 					output[base_cell_coords] = TileSet::CELL_NEIGHBOR_RIGHT_SIDE;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_LEFT_SIDE;
 					break;
-				case 1:
+				case 2:
 					output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_CORNER;
 					break;
-				case 2:
+				case 3:
 					output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE;
 					break;
-				case 3:
+				case 4:
 					output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_CORNER;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER;
 					break;
-				case 4:
+				case 5:
 					output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE;
 					break;
@@ -122,25 +125,25 @@ HashMap<Vector2i, TileSet::CellNeighbor> TileMap::TerrainConstraint::get_overlap
 			}
 		} else {
 			switch (bit) {
-				case 0:
+				case 1:
 					output[base_cell_coords] = TileSet::CELL_NEIGHBOR_RIGHT_CORNER;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER;
 					break;
-				case 1:
+				case 2:
 					output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE;
 					break;
-				case 2:
+				case 3:
 					output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE)] = TileSet::CELL_NEIGHBOR_LEFT_CORNER;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER;
 					break;
-				case 3:
+				case 4:
 					output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_SIDE;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_SIDE;
 					break;
-				case 4:
+				case 5:
 					output[base_cell_coords] = TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE;
 					output[tile_map->get_neighbor_cell(base_cell_coords, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE)] = TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE;
 					break;
@@ -152,6 +155,17 @@ HashMap<Vector2i, TileSet::CellNeighbor> TileMap::TerrainConstraint::get_overlap
 	return output;
 }
 
+TileMap::TerrainConstraint::TerrainConstraint(const TileMap *p_tile_map, const Vector2i &p_position, int p_terrain) {
+	tile_map = p_tile_map;
+
+	Ref<TileSet> tile_set = tile_map->get_tileset();
+	ERR_FAIL_COND(!tile_set.is_valid());
+
+	bit = 0;
+	base_cell_coords = p_position;
+	terrain = p_terrain;
+}
+
 TileMap::TerrainConstraint::TerrainConstraint(const TileMap *p_tile_map, const Vector2i &p_position, const TileSet::CellNeighbor &p_bit, int p_terrain) {
 	// The way we build the constraint make it easy to detect conflicting constraints.
 	tile_map = p_tile_map;
@@ -163,35 +177,35 @@ TileMap::TerrainConstraint::TerrainConstraint(const TileMap *p_tile_map, const V
 	if (shape == TileSet::TILE_SHAPE_SQUARE) {
 		switch (p_bit) {
 			case TileSet::CELL_NEIGHBOR_RIGHT_SIDE:
-				bit = 0;
+				bit = 1;
 				base_cell_coords = p_position;
 				break;
 			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
-				bit = 1;
+				bit = 2;
 				base_cell_coords = p_position;
 				break;
 			case TileSet::CELL_NEIGHBOR_BOTTOM_SIDE:
-				bit = 2;
+				bit = 3;
 				base_cell_coords = p_position;
 				break;
 			case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
-				bit = 1;
+				bit = 2;
 				base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_LEFT_SIDE);
 				break;
 			case TileSet::CELL_NEIGHBOR_LEFT_SIDE:
-				bit = 0;
+				bit = 1;
 				base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_LEFT_SIDE);
 				break;
 			case TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER:
-				bit = 1;
+				bit = 2;
 				base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER);
 				break;
 			case TileSet::CELL_NEIGHBOR_TOP_SIDE:
-				bit = 2;
+				bit = 3;
 				base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_SIDE);
 				break;
 			case TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER:
-				bit = 1;
+				bit = 2;
 				base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_SIDE);
 				break;
 			default:
@@ -201,35 +215,35 @@ TileMap::TerrainConstraint::TerrainConstraint(const TileMap *p_tile_map, const V
 	} else if (shape == TileSet::TILE_SHAPE_ISOMETRIC) {
 		switch (p_bit) {
 			case TileSet::CELL_NEIGHBOR_RIGHT_CORNER:
-				bit = 1;
+				bit = 2;
 				base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE);
 				break;
 			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
-				bit = 0;
+				bit = 1;
 				base_cell_coords = p_position;
 				break;
 			case TileSet::CELL_NEIGHBOR_BOTTOM_CORNER:
-				bit = 1;
+				bit = 2;
 				base_cell_coords = p_position;
 				break;
 			case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE:
-				bit = 2;
+				bit = 3;
 				base_cell_coords = p_position;
 				break;
 			case TileSet::CELL_NEIGHBOR_LEFT_CORNER:
-				bit = 1;
+				bit = 2;
 				base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE);
 				break;
 			case TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE:
-				bit = 0;
+				bit = 1;
 				base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE);
 				break;
 			case TileSet::CELL_NEIGHBOR_TOP_CORNER:
-				bit = 1;
+				bit = 2;
 				base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_CORNER);
 				break;
 			case TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE:
-				bit = 2;
+				bit = 3;
 				base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE);
 				break;
 			default:
@@ -242,51 +256,51 @@ TileMap::TerrainConstraint::TerrainConstraint(const TileMap *p_tile_map, const V
 		if (offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
 			switch (p_bit) {
 				case TileSet::CELL_NEIGHBOR_RIGHT_SIDE:
-					bit = 0;
+					bit = 1;
 					base_cell_coords = p_position;
 					break;
 				case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
-					bit = 1;
+					bit = 2;
 					base_cell_coords = p_position;
 					break;
 				case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
-					bit = 2;
+					bit = 3;
 					base_cell_coords = p_position;
 					break;
 				case TileSet::CELL_NEIGHBOR_BOTTOM_CORNER:
-					bit = 3;
+					bit = 4;
 					base_cell_coords = p_position;
 					break;
 				case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE:
-					bit = 4;
+					bit = 5;
 					base_cell_coords = p_position;
 					break;
 				case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
-					bit = 1;
+					bit = 2;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_LEFT_SIDE);
 					break;
 				case TileSet::CELL_NEIGHBOR_LEFT_SIDE:
-					bit = 0;
+					bit = 1;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_LEFT_SIDE);
 					break;
 				case TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER:
-					bit = 3;
+					bit = 4;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE);
 					break;
 				case TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE:
-					bit = 2;
+					bit = 3;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE);
 					break;
 				case TileSet::CELL_NEIGHBOR_TOP_CORNER:
-					bit = 1;
+					bit = 2;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE);
 					break;
 				case TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE:
-					bit = 4;
+					bit = 5;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE);
 					break;
 				case TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER:
-					bit = 3;
+					bit = 4;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE);
 					break;
 				default:
@@ -296,51 +310,51 @@ TileMap::TerrainConstraint::TerrainConstraint(const TileMap *p_tile_map, const V
 		} else {
 			switch (p_bit) {
 				case TileSet::CELL_NEIGHBOR_RIGHT_CORNER:
-					bit = 0;
+					bit = 1;
 					base_cell_coords = p_position;
 					break;
 				case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
-					bit = 1;
+					bit = 2;
 					base_cell_coords = p_position;
 					break;
 				case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
-					bit = 2;
+					bit = 3;
 					base_cell_coords = p_position;
 					break;
 				case TileSet::CELL_NEIGHBOR_BOTTOM_SIDE:
-					bit = 3;
+					bit = 4;
 					base_cell_coords = p_position;
 					break;
 				case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_CORNER:
-					bit = 0;
+					bit = 1;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE);
 					break;
 				case TileSet::CELL_NEIGHBOR_BOTTOM_LEFT_SIDE:
-					bit = 4;
+					bit = 5;
 					base_cell_coords = p_position;
 					break;
 				case TileSet::CELL_NEIGHBOR_LEFT_CORNER:
-					bit = 2;
+					bit = 3;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE);
 					break;
 				case TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE:
-					bit = 1;
+					bit = 2;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE);
 					break;
 				case TileSet::CELL_NEIGHBOR_TOP_LEFT_CORNER:
-					bit = 0;
+					bit = 1;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_LEFT_SIDE);
 					break;
 				case TileSet::CELL_NEIGHBOR_TOP_SIDE:
-					bit = 3;
+					bit = 4;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_SIDE);
 					break;
 				case TileSet::CELL_NEIGHBOR_TOP_RIGHT_CORNER:
-					bit = 2;
+					bit = 3;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_SIDE);
 					break;
 				case TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE:
-					bit = 4;
+					bit = 5;
 					base_cell_coords = p_tile_map->get_neighbor_cell(p_position, TileSet::CELL_NEIGHBOR_TOP_RIGHT_SIDE);
 					break;
 				default:
@@ -2149,37 +2163,75 @@ void TileMap::set_pattern(int p_layer, Vector2i p_position, const Ref<TileMapPat
 	}
 }
 
-RBSet<TileSet::TerrainsPattern> TileMap::_get_valid_terrains_patterns_for_constraints(int p_terrain_set, const Vector2i &p_position, RBSet<TerrainConstraint> p_constraints) {
+TileSet::TerrainsPattern TileMap::_get_best_terrain_pattern_for_constraints(int p_terrain_set, const Vector2i &p_position, RBSet<TerrainConstraint> p_constraints) {
 	if (!tile_set.is_valid()) {
-		return RBSet<TileSet::TerrainsPattern>();
+		return TileSet::TerrainsPattern();
 	}
 
 	// Returns all tiles compatible with the given constraints.
-	RBSet<TileSet::TerrainsPattern> compatible_terrain_tile_patterns;
-	for (TileSet::TerrainsPattern &terrain_pattern : tile_set->get_terrains_pattern_set(p_terrain_set)) {
-		int valid = true;
+	RBMap<TileSet::TerrainsPattern, int> terrain_pattern_score;
+	RBSet<TileSet::TerrainsPattern> pattern_set = tile_set->get_terrains_pattern_set(p_terrain_set);
+	ERR_FAIL_COND_V(pattern_set.is_empty(), TileSet::TerrainsPattern());
+	for (TileSet::TerrainsPattern &terrain_pattern : pattern_set) {
+		int score = 0;
+
+		// Check the center bit constraint
+		TerrainConstraint terrain_constraint = TerrainConstraint(this, p_position, terrain_pattern.get_terrain());
+		RBSet<TerrainConstraint>::Element *in_set_constraint_element = p_constraints.find(terrain_constraint);
+		if (in_set_constraint_element && in_set_constraint_element->get().get_terrain() != terrain_constraint.get_terrain()) {
+			score += in_set_constraint_element->get().get_priority();
+		}
+
+		// Check the surrounding bits
 		for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
 			TileSet::CellNeighbor bit = TileSet::CellNeighbor(i);
-			if (tile_set->is_valid_peering_bit_terrain(p_terrain_set, bit)) {
+			if (tile_set->is_valid_terrain_peering_bit(p_terrain_set, bit)) {
 				// Check if the bit is compatible with the constraints.
-				TerrainConstraint terrain_bit_constraint = TerrainConstraint(this, p_position, bit, terrain_pattern.get_terrain(bit));
-				RBSet<TerrainConstraint>::Element *in_set_constraint_element = p_constraints.find(terrain_bit_constraint);
+				TerrainConstraint terrain_bit_constraint = TerrainConstraint(this, p_position, bit, terrain_pattern.get_terrain_peering_bit(bit));
+				in_set_constraint_element = p_constraints.find(terrain_bit_constraint);
 				if (in_set_constraint_element && in_set_constraint_element->get().get_terrain() != terrain_bit_constraint.get_terrain()) {
-					valid = false;
-					break;
+					score += in_set_constraint_element->get().get_priority();
 				}
 			}
 		}
 
-		if (valid) {
-			compatible_terrain_tile_patterns.insert(terrain_pattern);
+		terrain_pattern_score[terrain_pattern] = score;
+	}
+
+	// Compute the minimum score
+	TileSet::TerrainsPattern min_score_pattern;
+	int min_score = INT32_MAX;
+	for (KeyValue<TileSet::TerrainsPattern, int> E : terrain_pattern_score) {
+		if (E.value < min_score) {
+			min_score_pattern = E.key;
+			min_score = E.value;
 		}
 	}
 
-	return compatible_terrain_tile_patterns;
+	return min_score_pattern;
 }
 
-RBSet<TileMap::TerrainConstraint> TileMap::get_terrain_constraints_from_removed_cells_list(int p_layer, const RBSet<Vector2i> &p_to_replace, int p_terrain_set, bool p_ignore_empty_terrains) const {
+RBSet<TileMap::TerrainConstraint> TileMap::_get_terrain_constraints_from_added_pattern(Vector2i p_position, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern) const {
+	if (!tile_set.is_valid()) {
+		return RBSet<TerrainConstraint>();
+	}
+
+	// Compute the constraints needed from the surrounding tiles.
+	RBSet<TerrainConstraint> output;
+	output.insert(TerrainConstraint(this, p_position, p_terrains_pattern.get_terrain()));
+
+	for (uint32_t i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
+		TileSet::CellNeighbor side = TileSet::CellNeighbor(i);
+		if (tile_set->is_valid_terrain_peering_bit(p_terrain_set, side)) {
+			TerrainConstraint c = TerrainConstraint(this, p_position, side, p_terrains_pattern.get_terrain_peering_bit(side));
+			output.insert(c);
+		}
+	}
+
+	return output;
+}
+
+RBSet<TileMap::TerrainConstraint> TileMap::_get_terrain_constraints_from_cells_list(int p_layer, const RBSet<Vector2i> &p_cell_list, int p_terrain_set, bool p_ignore_empty_terrains) const {
 	if (!tile_set.is_valid()) {
 		return RBSet<TerrainConstraint>();
 	}
@@ -2187,12 +2239,12 @@ RBSet<TileMap::TerrainConstraint> TileMap::get_terrain_constraints_from_removed_
 	ERR_FAIL_INDEX_V(p_terrain_set, tile_set->get_terrain_sets_count(), RBSet<TerrainConstraint>());
 	ERR_FAIL_INDEX_V(p_layer, (int)layers.size(), RBSet<TerrainConstraint>());
 
-	// Build a set of dummy constraints get the constrained points.
+	// Build a set of dummy constraints to get the constrained points.
 	RBSet<TerrainConstraint> dummy_constraints;
-	for (const Vector2i &E : p_to_replace) {
+	for (const Vector2i &E : p_cell_list) {
 		for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) { // Iterates over sides.
 			TileSet::CellNeighbor bit = TileSet::CellNeighbor(i);
-			if (tile_set->is_valid_peering_bit_terrain(p_terrain_set, bit)) {
+			if (tile_set->is_valid_terrain_peering_bit(p_terrain_set, bit)) {
 				dummy_constraints.insert(TerrainConstraint(this, E, bit, -1));
 			}
 		}
@@ -2200,35 +2252,31 @@ RBSet<TileMap::TerrainConstraint> TileMap::get_terrain_constraints_from_removed_
 
 	// For each constrained point, we get all overlapping tiles, and select the most adequate terrain for it.
 	RBSet<TerrainConstraint> constraints;
-	for (const TerrainConstraint &E : dummy_constraints) {
-		TerrainConstraint c = E;
-
+	for (const TerrainConstraint &E_constraint : dummy_constraints) {
 		HashMap<int, int> terrain_count;
 
 		// Count the number of occurrences per terrain.
-		HashMap<Vector2i, TileSet::CellNeighbor> overlapping_terrain_bits = c.get_overlapping_coords_and_peering_bits();
+		HashMap<Vector2i, TileSet::CellNeighbor> overlapping_terrain_bits = E_constraint.get_overlapping_coords_and_peering_bits();
 		for (const KeyValue<Vector2i, TileSet::CellNeighbor> &E_overlapping : overlapping_terrain_bits) {
-			if (!p_to_replace.has(E_overlapping.key)) {
-				TileData *neighbor_tile_data = nullptr;
-				TileMapCell neighbor_cell = get_cell(p_layer, E_overlapping.key);
-				if (neighbor_cell.source_id != TileSet::INVALID_SOURCE) {
-					Ref<TileSetSource> source = tile_set->get_source(neighbor_cell.source_id);
-					Ref<TileSetAtlasSource> atlas_source = source;
-					if (atlas_source.is_valid()) {
-						TileData *tile_data = atlas_source->get_tile_data(neighbor_cell.get_atlas_coords(), neighbor_cell.alternative_tile);
-						if (tile_data && tile_data->get_terrain_set() == p_terrain_set) {
-							neighbor_tile_data = tile_data;
-						}
+			TileData *neighbor_tile_data = nullptr;
+			TileMapCell neighbor_cell = get_cell(p_layer, E_overlapping.key);
+			if (neighbor_cell.source_id != TileSet::INVALID_SOURCE) {
+				Ref<TileSetSource> source = tile_set->get_source(neighbor_cell.source_id);
+				Ref<TileSetAtlasSource> atlas_source = source;
+				if (atlas_source.is_valid()) {
+					TileData *tile_data = atlas_source->get_tile_data(neighbor_cell.get_atlas_coords(), neighbor_cell.alternative_tile);
+					if (tile_data && tile_data->get_terrain_set() == p_terrain_set) {
+						neighbor_tile_data = tile_data;
 					}
 				}
+			}
 
-				int terrain = neighbor_tile_data ? neighbor_tile_data->get_peering_bit_terrain(TileSet::CellNeighbor(E_overlapping.value)) : -1;
-				if (!p_ignore_empty_terrains || terrain >= 0) {
-					if (!terrain_count.has(terrain)) {
-						terrain_count[terrain] = 0;
-					}
-					terrain_count[terrain] += 1;
+			int terrain = neighbor_tile_data ? neighbor_tile_data->get_terrain_peering_bit(TileSet::CellNeighbor(E_overlapping.value)) : -1;
+			if (!p_ignore_empty_terrains || terrain >= 0) {
+				if (!terrain_count.has(terrain)) {
+					terrain_count[terrain] = 0;
 				}
+				terrain_count[terrain] += 1;
 			}
 		}
 
@@ -2244,33 +2292,34 @@ RBSet<TileMap::TerrainConstraint> TileMap::get_terrain_constraints_from_removed_
 
 		// Set the adequate terrain.
 		if (max > 0) {
+			TerrainConstraint c = E_constraint;
 			c.set_terrain(max_terrain);
 			constraints.insert(c);
 		}
 	}
 
-	return constraints;
-}
-
-RBSet<TileMap::TerrainConstraint> TileMap::get_terrain_constraints_from_added_tile(Vector2i p_position, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern) const {
-	if (!tile_set.is_valid()) {
-		return RBSet<TerrainConstraint>();
-	}
+	// Add the centers as constraints
+	for (Vector2i E_coords : p_cell_list) {
+		TileData *tile_data = nullptr;
+		TileMapCell cell = get_cell(p_layer, E_coords);
+		if (cell.source_id != TileSet::INVALID_SOURCE) {
+			Ref<TileSetSource> source = tile_set->get_source(cell.source_id);
+			Ref<TileSetAtlasSource> atlas_source = source;
+			if (atlas_source.is_valid()) {
+				tile_data = atlas_source->get_tile_data(cell.get_atlas_coords(), cell.alternative_tile);
+			}
+		}
 
-	// Compute the constraints needed from the surrounding tiles.
-	RBSet<TerrainConstraint> output;
-	for (uint32_t i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
-		TileSet::CellNeighbor side = TileSet::CellNeighbor(i);
-		if (tile_set->is_valid_peering_bit_terrain(p_terrain_set, side)) {
-			TerrainConstraint c = TerrainConstraint(this, p_position, side, p_terrains_pattern.get_terrain(side));
-			output.insert(c);
+		int terrain = (tile_data && tile_data->get_terrain_set() == p_terrain_set) ? tile_data->get_terrain() : -1;
+		if (!p_ignore_empty_terrains || terrain >= 0) {
+			constraints.insert(TerrainConstraint(this, E_coords, terrain));
 		}
 	}
 
-	return output;
+	return constraints;
 }
 
-HashMap<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_wave_function_collapse(const RBSet<Vector2i> &p_to_replace, int p_terrain_set, const RBSet<TerrainConstraint> p_constraints) {
+HashMap<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_fill_constraints(const Vector<Vector2i> &p_to_replace, int p_terrain_set, const RBSet<TerrainConstraint> p_constraints) {
 	if (!tile_set.is_valid()) {
 		return HashMap<Vector2i, TileSet::TerrainsPattern>();
 	}
@@ -2278,110 +2327,287 @@ HashMap<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_wave_function_colla
 	// Copy the constraints set.
 	RBSet<TerrainConstraint> constraints = p_constraints;
 
-	// Compute all acceptable patterns for each cell.
-	HashMap<Vector2i, RBSet<TileSet::TerrainsPattern>> per_cell_acceptable_tiles;
-	for (Vector2i cell : p_to_replace) {
-		per_cell_acceptable_tiles[cell] = _get_valid_terrains_patterns_for_constraints(p_terrain_set, cell, constraints);
-	}
-
 	// Output map.
 	HashMap<Vector2i, TileSet::TerrainsPattern> output;
 
 	// Add all positions to a set.
-	RBSet<Vector2i> to_replace = RBSet<Vector2i>(p_to_replace);
-	while (!to_replace.is_empty()) {
-		// Compute the minimum number of tile possibilities for each cell.
-		int min_nb_possibilities = 100000000;
-		for (const KeyValue<Vector2i, RBSet<TileSet::TerrainsPattern>> &E : per_cell_acceptable_tiles) {
-			min_nb_possibilities = MIN(min_nb_possibilities, E.value.size());
-		}
-
-		// Get the set of possible cells to fill, out of the most constrained ones.
-		LocalVector<Vector2i> to_choose_from;
-		for (const KeyValue<Vector2i, RBSet<TileSet::TerrainsPattern>> &E : per_cell_acceptable_tiles) {
-			if (E.value.size() == min_nb_possibilities) {
-				to_choose_from.push_back(E.key);
-			}
-		}
-
-		// Randomly a cell to fill out of the most constrained.
-		Vector2i selected_cell_to_replace = to_choose_from[Math::random(0, to_choose_from.size() - 1)];
-
-		// Get the list of acceptable patterns for the given cell.
-		RBSet<TileSet::TerrainsPattern> valid_tiles = per_cell_acceptable_tiles[selected_cell_to_replace];
-		if (valid_tiles.is_empty()) {
-			break; // No possibilities :/
-		}
-
-		// Out of the possible patterns, prioritize the one which have the least amount of different terrains.
-		LocalVector<TileSet::TerrainsPattern> valid_tiles_with_least_amount_of_terrains;
-		int min_terrain_count = 10000;
-		LocalVector<int> terrains_counts;
-		int pattern_index = 0;
-		for (const TileSet::TerrainsPattern &pattern : valid_tiles) {
-			RBSet<int> terrains;
-			for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
-				TileSet::CellNeighbor side = TileSet::CellNeighbor(i);
-				if (tile_set->is_valid_peering_bit_terrain(p_terrain_set, side)) {
-					terrains.insert(pattern.get_terrain(side));
+	for (int i = 0; i < p_to_replace.size(); i++) {
+		const Vector2i &coords = p_to_replace[i];
+
+		// Select the best pattern for the given constraints
+		TileSet::TerrainsPattern pattern = _get_best_terrain_pattern_for_constraints(p_terrain_set, coords, constraints);
+
+		// Update the constraint set with the new ones
+		RBSet<TerrainConstraint> new_constraints = _get_terrain_constraints_from_added_pattern(coords, p_terrain_set, pattern);
+		for (const TerrainConstraint &E_constraint : new_constraints) {
+			if (constraints.has(E_constraint)) {
+				constraints.erase(E_constraint);
+			}
+			TerrainConstraint c = E_constraint;
+			c.set_priority(5);
+			constraints.insert(c);
+		}
+
+		output[coords] = pattern;
+	}
+	return output;
+}
+
+HashMap<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_fill_connect(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) {
+	HashMap<Vector2i, TileSet::TerrainsPattern> output;
+	ERR_FAIL_COND_V(!tile_set.is_valid(), output);
+	ERR_FAIL_INDEX_V(p_terrain_set, tile_set->get_terrain_sets_count(), output);
+
+	// Build list and set of tiles that can be modified (painted and their surroundings)
+	Vector<Vector2i> can_modify_list;
+	RBSet<Vector2i> can_modify_set;
+	RBSet<Vector2i> painted_set;
+	for (int i = p_coords_array.size() - 1; i >= 0; i--) {
+		const Vector2i &coords = p_coords_array[i];
+		can_modify_list.push_back(coords);
+		can_modify_set.insert(coords);
+		painted_set.insert(coords);
+	}
+	for (Vector2i coords : p_coords_array) {
+		// Find the adequate neighbor
+		for (int j = 0; j < TileSet::CELL_NEIGHBOR_MAX; j++) {
+			TileSet::CellNeighbor bit = TileSet::CellNeighbor(j);
+			if (tile_set->is_valid_terrain_peering_bit(p_terrain_set, bit)) {
+				Vector2i neighbor = get_neighbor_cell(coords, bit);
+				if (!can_modify_set.has(neighbor)) {
+					can_modify_list.push_back(neighbor);
+					can_modify_set.insert(neighbor);
 				}
 			}
-			min_terrain_count = MIN(min_terrain_count, terrains.size());
-			terrains_counts.push_back(terrains.size());
-			pattern_index++;
 		}
-		pattern_index = 0;
-		for (const TileSet::TerrainsPattern &pattern : valid_tiles) {
-			if (terrains_counts[pattern_index] == min_terrain_count) {
-				valid_tiles_with_least_amount_of_terrains.push_back(pattern);
+	}
+
+	// Build a set, out of the possibly modified tiles, of the one with a center bit that is set (or will be) to the painted terrain
+	RBSet<Vector2i> cells_with_terrain_center_bit;
+	for (Vector2i coords : can_modify_set) {
+		bool connect = false;
+		if (painted_set.has(coords)) {
+			connect = true;
+		} else {
+			// Get the center bit of the cell
+			TileData *tile_data = nullptr;
+			TileMapCell cell = get_cell(p_layer, coords);
+			if (cell.source_id != TileSet::INVALID_SOURCE) {
+				Ref<TileSetSource> source = tile_set->get_source(cell.source_id);
+				Ref<TileSetAtlasSource> atlas_source = source;
+				if (atlas_source.is_valid()) {
+					tile_data = atlas_source->get_tile_data(cell.get_atlas_coords(), cell.alternative_tile);
+				}
+			}
+
+			if (tile_data && tile_data->get_terrain_set() == p_terrain_set && tile_data->get_terrain() == p_terrain) {
+				connect = true;
+			}
+		}
+		if (connect) {
+			cells_with_terrain_center_bit.insert(coords);
+		}
+	}
+
+	RBSet<TerrainConstraint> constraints;
+
+	// Add new constraints from the path drawn.
+	for (Vector2i coords : p_coords_array) {
+		// Constraints on the center bit.
+		TerrainConstraint c = TerrainConstraint(this, coords, p_terrain);
+		c.set_priority(10);
+		constraints.insert(c);
+
+		// Constraints on the connecting bits.
+		for (int j = 0; j < TileSet::CELL_NEIGHBOR_MAX; j++) {
+			TileSet::CellNeighbor bit = TileSet::CellNeighbor(j);
+			if (tile_set->is_valid_terrain_peering_bit(p_terrain_set, bit)) {
+				c = TerrainConstraint(this, coords, bit, p_terrain);
+				c.set_priority(10);
+				if ((int(bit) % 2) == 0) {
+					// Side peering bits: add the constraint if the center is of the same terrain
+					Vector2i neighbor = get_neighbor_cell(coords, bit);
+					if (cells_with_terrain_center_bit.has(neighbor)) {
+						constraints.insert(c);
+					}
+				} else {
+					// Corner peering bits: add the constraint if all tiles on the constraint has the same center bit
+					HashMap<Vector2i, TileSet::CellNeighbor> overlapping_terrain_bits = c.get_overlapping_coords_and_peering_bits();
+					bool valid = true;
+					for (KeyValue<Vector2i, TileSet::CellNeighbor> kv : overlapping_terrain_bits) {
+						if (!cells_with_terrain_center_bit.has(kv.key)) {
+							valid = false;
+							break;
+						}
+					}
+					if (valid) {
+						constraints.insert(c);
+					}
+				}
 			}
-			pattern_index++;
 		}
+	}
 
-		// Randomly select a pattern out of the remaining ones.
-		TileSet::TerrainsPattern selected_terrain_tile_pattern = valid_tiles_with_least_amount_of_terrains[Math::random(0, valid_tiles_with_least_amount_of_terrains.size() - 1)];
+	// Fills in the constraint list from existing tiles.
+	for (TerrainConstraint c : _get_terrain_constraints_from_cells_list(p_layer, can_modify_set, p_terrain_set, p_ignore_empty_terrains)) {
+		constraints.insert(c);
+	}
 
-		// Set the selected cell into the output.
-		output[selected_cell_to_replace] = selected_terrain_tile_pattern;
-		to_replace.erase(selected_cell_to_replace);
-		per_cell_acceptable_tiles.erase(selected_cell_to_replace);
+	// Fill the terrains.
+	output = terrain_fill_constraints(can_modify_list, p_terrain_set, constraints);
+	return output;
+}
 
-		// Add the new constraints from the added tiles.
-		RBSet<TerrainConstraint> new_constraints = get_terrain_constraints_from_added_tile(selected_cell_to_replace, p_terrain_set, selected_terrain_tile_pattern);
-		for (const TerrainConstraint &E_constraint : new_constraints) {
-			constraints.insert(E_constraint);
+HashMap<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_fill_path(int p_layer, const Vector<Vector2i> &p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) {
+	HashMap<Vector2i, TileSet::TerrainsPattern> output;
+	ERR_FAIL_COND_V(!tile_set.is_valid(), output);
+	ERR_FAIL_INDEX_V(p_terrain_set, tile_set->get_terrain_sets_count(), output);
+
+	// Make sure the path is correct and build the peering bit list while doing it.
+	Vector<TileSet::CellNeighbor> neighbor_list;
+	for (int i = 0; i < p_path.size() - 1; i++) {
+		// Find the adequate neighbor
+		TileSet::CellNeighbor found_bit = TileSet::CELL_NEIGHBOR_MAX;
+		for (int j = 0; j < TileSet::CELL_NEIGHBOR_MAX; j++) {
+			TileSet::CellNeighbor bit = TileSet::CellNeighbor(j);
+			if (tile_set->is_valid_terrain_peering_bit(p_terrain_set, bit)) {
+				if (get_neighbor_cell(p_path[i], bit) == p_path[i + 1]) {
+					found_bit = bit;
+					break;
+				}
+			}
 		}
+		ERR_FAIL_COND_V_MSG(found_bit == TileSet::CELL_NEIGHBOR_MAX, output, vformat("Invalid terrain path, %s is not a neighbouring tile of %s", p_path[i + 1], p_path[i]));
+		neighbor_list.push_back(found_bit);
+	}
 
-		// Compute valid tiles again for neighbors.
-		for (uint32_t i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
-			TileSet::CellNeighbor side = TileSet::CellNeighbor(i);
-			if (is_existing_neighbor(side)) {
-				Vector2i neighbor = get_neighbor_cell(selected_cell_to_replace, side);
-				if (to_replace.has(neighbor)) {
-					per_cell_acceptable_tiles[neighbor] = _get_valid_terrains_patterns_for_constraints(p_terrain_set, neighbor, constraints);
+	// Build list and set of tiles that can be modified (painted and their surroundings)
+	Vector<Vector2i> can_modify_list;
+	RBSet<Vector2i> can_modify_set;
+	for (int i = p_path.size() - 1; i >= 0; i--) {
+		const Vector2i &coords = p_path[i];
+		can_modify_list.push_back(coords);
+		can_modify_set.insert(coords);
+	}
+	for (Vector2i coords : p_path) {
+		// Find the adequate neighbor
+		for (int j = 0; j < TileSet::CELL_NEIGHBOR_MAX; j++) {
+			TileSet::CellNeighbor bit = TileSet::CellNeighbor(j);
+			if (tile_set->is_valid_terrain_peering_bit(p_terrain_set, bit)) {
+				Vector2i neighbor = get_neighbor_cell(coords, bit);
+				if (!can_modify_set.has(neighbor)) {
+					can_modify_list.push_back(neighbor);
+					can_modify_set.insert(neighbor);
 				}
 			}
 		}
 	}
+
+	RBSet<TerrainConstraint> constraints;
+
+	// Add new constraints from the path drawn.
+	for (Vector2i coords : p_path) {
+		// Constraints on the center bit
+		TerrainConstraint c = TerrainConstraint(this, coords, p_terrain);
+		c.set_priority(10);
+		constraints.insert(c);
+	}
+	for (int i = 0; i < p_path.size() - 1; i++) {
+		// Constraints on the peering bits.
+		TerrainConstraint c = TerrainConstraint(this, p_path[i], neighbor_list[i], p_terrain);
+		c.set_priority(10);
+		constraints.insert(c);
+	}
+
+	// Fills in the constraint list from existing tiles.
+	for (TerrainConstraint c : _get_terrain_constraints_from_cells_list(p_layer, can_modify_set, p_terrain_set, p_ignore_empty_terrains)) {
+		constraints.insert(c);
+	}
+
+	// Fill the terrains.
+	output = terrain_fill_constraints(can_modify_list, p_terrain_set, constraints);
 	return output;
 }
 
-void TileMap::set_cells_from_surrounding_terrains(int p_layer, TypedArray<Vector2i> p_coords_array, int p_terrain_set, bool p_ignore_empty_terrains) {
+HashMap<Vector2i, TileSet::TerrainsPattern> TileMap::terrain_fill_pattern(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern, bool p_ignore_empty_terrains) {
+	HashMap<Vector2i, TileSet::TerrainsPattern> output;
+	ERR_FAIL_COND_V(!tile_set.is_valid(), output);
+	ERR_FAIL_INDEX_V(p_terrain_set, tile_set->get_terrain_sets_count(), output);
+
+	// Build list and set of tiles that can be modified (painted and their surroundings).
+	Vector<Vector2i> can_modify_list;
+	RBSet<Vector2i> can_modify_set;
+	for (int i = p_coords_array.size() - 1; i >= 0; i--) {
+		const Vector2i &coords = p_coords_array[i];
+		can_modify_list.push_back(coords);
+		can_modify_set.insert(coords);
+	}
+	for (Vector2i coords : p_coords_array) {
+		// Find the adequate neighbor
+		for (int j = 0; j < TileSet::CELL_NEIGHBOR_MAX; j++) {
+			TileSet::CellNeighbor bit = TileSet::CellNeighbor(j);
+			if (tile_set->is_valid_terrain_peering_bit(p_terrain_set, bit)) {
+				Vector2i neighbor = get_neighbor_cell(coords, bit);
+				if (!can_modify_set.has(neighbor)) {
+					can_modify_list.push_back(neighbor);
+					can_modify_set.insert(neighbor);
+				}
+			}
+		}
+	}
+
+	// Add constraint by the new ones.
+	RBSet<TerrainConstraint> constraints;
+
+	// Add new constraints from the path drawn.
+	for (Vector2i coords : p_coords_array) {
+		// Constraints on the center bit
+		RBSet<TerrainConstraint> added_constraints = _get_terrain_constraints_from_added_pattern(coords, p_terrain_set, p_terrains_pattern);
+		for (TerrainConstraint c : added_constraints) {
+			c.set_priority(10);
+			constraints.insert(c);
+		}
+	}
+
+	// Fills in the constraint list from modified tiles border.
+	for (TerrainConstraint c : _get_terrain_constraints_from_cells_list(p_layer, can_modify_set, p_terrain_set, p_ignore_empty_terrains)) {
+		constraints.insert(c);
+	}
+
+	// Fill the terrains.
+	output = terrain_fill_constraints(can_modify_list, p_terrain_set, constraints);
+	return output;
+}
+
+void TileMap::set_cells_terrain_connect(int p_layer, TypedArray<Vector2i> p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) {
 	ERR_FAIL_COND(!tile_set.is_valid());
 	ERR_FAIL_INDEX(p_layer, (int)layers.size());
 	ERR_FAIL_INDEX(p_terrain_set, tile_set->get_terrain_sets_count());
 
-	RBSet<Vector2i> coords_set;
-	for (int i = 0; i < p_coords_array.size(); i++) {
-		coords_set.insert(p_coords_array[i]);
+	Vector<Vector2i> vector_cells;
+	for (int i = 0; i < p_cells.size(); i++) {
+		vector_cells.push_back(p_cells[i]);
 	}
+	HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_output = terrain_fill_connect(p_layer, vector_cells, p_terrain_set, p_terrain, p_ignore_empty_terrains);
+	for (const KeyValue<Vector2i, TileSet::TerrainsPattern> &E : terrain_fill_output) {
+		TileMapCell c = tile_set->get_random_tile_from_terrains_pattern(p_terrain_set, E.value);
+		set_cell(p_layer, E.key, c.source_id, c.get_atlas_coords(), c.alternative_tile);
+	}
+}
 
-	RBSet<TileMap::TerrainConstraint> constraints = get_terrain_constraints_from_removed_cells_list(p_layer, coords_set, p_terrain_set, p_ignore_empty_terrains);
+void TileMap::set_cells_terrain_path(int p_layer, TypedArray<Vector2i> p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains) {
+	ERR_FAIL_COND(!tile_set.is_valid());
+	ERR_FAIL_INDEX(p_layer, (int)layers.size());
+	ERR_FAIL_INDEX(p_terrain_set, tile_set->get_terrain_sets_count());
 
-	HashMap<Vector2i, TileSet::TerrainsPattern> wfc_output = terrain_wave_function_collapse(coords_set, p_terrain_set, constraints);
-	for (const KeyValue<Vector2i, TileSet::TerrainsPattern> &kv : wfc_output) {
-		TileMapCell cell = tile_set->get_random_tile_from_terrains_pattern(p_terrain_set, kv.value);
-		set_cell(p_layer, kv.key, cell.source_id, cell.get_atlas_coords(), cell.alternative_tile);
+	Vector<Vector2i> vector_path;
+	for (int i = 0; i < p_path.size(); i++) {
+		vector_path.push_back(p_path[i]);
+	}
+	HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_output = terrain_fill_path(p_layer, vector_path, p_terrain_set, p_terrain, p_ignore_empty_terrains);
+	for (const KeyValue<Vector2i, TileSet::TerrainsPattern> &E : terrain_fill_output) {
+		TileMapCell c = tile_set->get_random_tile_from_terrains_pattern(p_terrain_set, E.value);
+		set_cell(p_layer, E.key, c.source_id, c.get_atlas_coords(), c.alternative_tile);
 	}
 }
 
@@ -3640,7 +3866,8 @@ void TileMap::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("map_pattern", "position_in_tilemap", "coords_in_pattern", "pattern"), &TileMap::map_pattern);
 	ClassDB::bind_method(D_METHOD("set_pattern", "layer", "position", "pattern"), &TileMap::set_pattern);
 
-	ClassDB::bind_method(D_METHOD("set_cells_from_surrounding_terrains", "layer", "cells", "terrain_set", "ignore_empty_terrains"), &TileMap::set_cells_from_surrounding_terrains, DEFVAL(true));
+	ClassDB::bind_method(D_METHOD("set_cells_terrain_connect", "layer", "cells", "terrain_set", "terrain", "ignore_empty_terrains"), &TileMap::set_cells_terrain_connect, DEFVAL(true));
+	ClassDB::bind_method(D_METHOD("set_cells_terrain_path", "layer", "path", "terrain_set", "terrain", "ignore_empty_terrains"), &TileMap::set_cells_terrain_path, DEFVAL(true));
 
 	ClassDB::bind_method(D_METHOD("fix_invalid_tiles"), &TileMap::fix_invalid_tiles);
 	ClassDB::bind_method(D_METHOD("clear_layer", "layer"), &TileMap::clear_layer);
diff --git a/scene/2d/tile_map.h b/scene/2d/tile_map.h
index 02a2b3a1c6..0ac94b9d45 100644
--- a/scene/2d/tile_map.h
+++ b/scene/2d/tile_map.h
@@ -119,6 +119,8 @@ public:
 		int bit = -1;
 		int terrain = -1;
 
+		int priority = 1;
+
 	public:
 		bool operator<(const TerrainConstraint &p_other) const {
 			if (base_cell_coords == p_other.base_cell_coords) {
@@ -128,13 +130,17 @@ public:
 		}
 
 		String to_string() const {
-			return vformat("Constraint {pos:%s, bit:%d, terrain:%d}", base_cell_coords, bit, terrain);
+			return vformat("Constraint {pos:%s, bit:%d, terrain:%d, priotity:%d}", base_cell_coords, bit, terrain, priority);
 		}
 
 		Vector2i get_base_cell_coords() const {
 			return base_cell_coords;
 		}
 
+		bool is_center_bit() const {
+			return bit == 0;
+		}
+
 		HashMap<Vector2i, TileSet::CellNeighbor> get_overlapping_coords_and_peering_bits() const;
 
 		void set_terrain(int p_terrain) {
@@ -145,8 +151,17 @@ public:
 			return terrain;
 		}
 
-		TerrainConstraint(const TileMap *p_tile_map, const Vector2i &p_position, const TileSet::CellNeighbor &p_bit, int p_terrain);
-		TerrainConstraint() {}
+		void set_priority(int p_priority) {
+			priority = p_priority;
+		}
+
+		int get_priority() {
+			return priority;
+		}
+
+		TerrainConstraint(const TileMap *p_tile_map, const Vector2i &p_position, int p_terrain); // For the center terrain bit
+		TerrainConstraint(const TileMap *p_tile_map, const Vector2i &p_position, const TileSet::CellNeighbor &p_bit, int p_terrain); // For peering bits
+		TerrainConstraint(){};
 	};
 
 	enum VisibilityMode {
@@ -251,7 +266,9 @@ private:
 	void _scenes_draw_quadrant_debug(TileMapQuadrant *p_quadrant);
 
 	// Terrains.
-	RBSet<TileSet::TerrainsPattern> _get_valid_terrains_patterns_for_constraints(int p_terrain_set, const Vector2i &p_position, RBSet<TerrainConstraint> p_constraints);
+	TileSet::TerrainsPattern _get_best_terrain_pattern_for_constraints(int p_terrain_set, const Vector2i &p_position, RBSet<TerrainConstraint> p_constraints);
+	RBSet<TerrainConstraint> _get_terrain_constraints_from_added_pattern(Vector2i p_position, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern) const;
+	RBSet<TerrainConstraint> _get_terrain_constraints_from_cells_list(int p_layer, const RBSet<Vector2i> &p_on_map, int p_terrain_set, bool p_ignore_empty_terrains) const;
 
 	// Set and get tiles from data arrays.
 	void _set_tile_data(int p_layer, const Vector<int> &p_data);
@@ -333,10 +350,13 @@ public:
 	void set_pattern(int p_layer, Vector2i p_position, const Ref<TileMapPattern> p_pattern);
 
 	// Terrains.
-	RBSet<TerrainConstraint> get_terrain_constraints_from_removed_cells_list(int p_layer, const RBSet<Vector2i> &p_to_replace, int p_terrain_set, bool p_ignore_empty_terrains = true) const; // Not exposed.
-	RBSet<TerrainConstraint> get_terrain_constraints_from_added_tile(Vector2i p_position, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern) const; // Not exposed.
-	HashMap<Vector2i, TileSet::TerrainsPattern> terrain_wave_function_collapse(const RBSet<Vector2i> &p_to_replace, int p_terrain_set, const RBSet<TerrainConstraint> p_constraints); // Not exposed.
-	void set_cells_from_surrounding_terrains(int p_layer, TypedArray<Vector2i> p_coords_array, int p_terrain_set, bool p_ignore_empty_terrains = true);
+	HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_constraints(const Vector<Vector2i> &p_to_replace, int p_terrain_set, const RBSet<TerrainConstraint> p_constraints); // Not exposed.
+	HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_connect(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true); // Not exposed.
+	HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_path(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true); // Not exposed.
+	HashMap<Vector2i, TileSet::TerrainsPattern> terrain_fill_pattern(int p_layer, const Vector<Vector2i> &p_coords_array, int p_terrain_set, TileSet::TerrainsPattern p_terrains_pattern, bool p_ignore_empty_terrains = true); // Not exposed.
+
+	void set_cells_terrain_connect(int p_layer, TypedArray<Vector2i> p_cells, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
+	void set_cells_terrain_path(int p_layer, TypedArray<Vector2i> p_path, int p_terrain_set, int p_terrain, bool p_ignore_empty_terrains = true);
 
 	// Not exposed to users
 	TileMapCell get_cell(int p_layer, const Vector2i &p_coords, bool p_use_proxies = false) const;
@@ -365,7 +385,7 @@ public:
 	// For finding tiles from collision.
 	Vector2i get_coords_for_body_rid(RID p_physics_body);
 
-	// Fixing a nclearing methods.
+	// Fixing and clearing methods.
 	void fix_invalid_tiles();
 
 	// Clears tiles from a given layer
diff --git a/scene/resources/tile_set.cpp b/scene/resources/tile_set.cpp
index 9d2d4cdb20..8976aa17d2 100644
--- a/scene/resources/tile_set.cpp
+++ b/scene/resources/tile_set.cpp
@@ -236,6 +236,9 @@ bool TileSet::TerrainsPattern::operator<(const TerrainsPattern &p_terrains_patte
 			return is_valid_bit[i] < p_terrains_pattern.is_valid_bit[i];
 		}
 	}
+	if (terrain != p_terrains_pattern.terrain) {
+		return terrain < p_terrains_pattern.terrain;
+	}
 	for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
 		if (is_valid_bit[i] && bits[i] != p_terrains_pattern.bits[i]) {
 			return bits[i] < p_terrains_pattern.bits[i];
@@ -253,10 +256,23 @@ bool TileSet::TerrainsPattern::operator==(const TerrainsPattern &p_terrains_patt
 			return false;
 		}
 	}
+	if (terrain != p_terrains_pattern.terrain) {
+		return false;
+	}
 	return true;
 }
 
-void TileSet::TerrainsPattern::set_terrain(TileSet::CellNeighbor p_peering_bit, int p_terrain) {
+void TileSet::TerrainsPattern::set_terrain(int p_terrain) {
+	ERR_FAIL_COND(p_terrain < -1);
+
+	terrain = p_terrain;
+}
+
+int TileSet::TerrainsPattern::get_terrain() const {
+	return terrain;
+}
+
+void TileSet::TerrainsPattern::set_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit, int p_terrain) {
 	ERR_FAIL_COND(p_peering_bit == TileSet::CELL_NEIGHBOR_MAX);
 	ERR_FAIL_COND(!is_valid_bit[p_peering_bit]);
 	ERR_FAIL_COND(p_terrain < -1);
@@ -271,25 +287,27 @@ void TileSet::TerrainsPattern::set_terrain(TileSet::CellNeighbor p_peering_bit,
 	bits[p_peering_bit] = p_terrain;
 }
 
-int TileSet::TerrainsPattern::get_terrain(TileSet::CellNeighbor p_peering_bit) const {
+int TileSet::TerrainsPattern::get_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit) const {
 	ERR_FAIL_COND_V(p_peering_bit == TileSet::CELL_NEIGHBOR_MAX, -1);
 	ERR_FAIL_COND_V(!is_valid_bit[p_peering_bit], -1);
 	return bits[p_peering_bit];
 }
 
-void TileSet::TerrainsPattern::set_terrains_from_array(Array p_terrains) {
-	int in_array_index = 0;
+void TileSet::TerrainsPattern::from_array(Array p_terrains) {
+	set_terrain(p_terrains[0]);
+	int in_array_index = 1;
 	for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
 		if (is_valid_bit[i]) {
 			ERR_FAIL_INDEX(in_array_index, p_terrains.size());
-			set_terrain(TileSet::CellNeighbor(i), p_terrains[in_array_index]);
+			set_terrain_peering_bit(TileSet::CellNeighbor(i), p_terrains[in_array_index]);
 			in_array_index++;
 		}
 	}
 }
 
-Array TileSet::TerrainsPattern::get_terrains_as_array() const {
+Array TileSet::TerrainsPattern::as_array() const {
 	Array output;
+	output.push_back(get_terrain());
 	for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
 		if (is_valid_bit[i]) {
 			output.push_back(bits[i]);
@@ -297,10 +315,11 @@ Array TileSet::TerrainsPattern::get_terrains_as_array() const {
 	}
 	return output;
 }
+
 TileSet::TerrainsPattern::TerrainsPattern(const TileSet *p_tile_set, int p_terrain_set) {
 	ERR_FAIL_COND(p_terrain_set < 0);
 	for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
-		is_valid_bit[i] = (p_tile_set->is_valid_peering_bit_terrain(p_terrain_set, TileSet::CellNeighbor(i)));
+		is_valid_bit[i] = (p_tile_set->is_valid_terrain_peering_bit(p_terrain_set, TileSet::CellNeighbor(i)));
 		bits[i] = -1;
 	}
 	valid = true;
@@ -410,11 +429,16 @@ void TileSet::_update_terrains_cache() {
 
 							TileSet::TerrainsPattern terrains_pattern = tile_data->get_terrains_pattern();
 
+							// Main terrain.
+							if (terrains_pattern.get_terrain() >= 0) {
+								per_terrain_pattern_tiles[terrain_set][terrains_pattern].insert(cell);
+							}
+
 							// Terrain bits.
 							for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
 								CellNeighbor bit = CellNeighbor(i);
-								if (is_valid_peering_bit_terrain(terrain_set, bit)) {
-									int terrain = terrains_pattern.get_terrain(bit);
+								if (is_valid_terrain_peering_bit(terrain_set, bit)) {
+									int terrain = terrains_pattern.get_terrain_peering_bit(bit);
 									if (terrain >= 0) {
 										per_terrain_pattern_tiles[terrain_set][terrains_pattern].insert(cell);
 									}
@@ -822,7 +846,7 @@ Color TileSet::get_terrain_color(int p_terrain_set, int p_terrain_index) const {
 	return terrain_sets[p_terrain_set].terrains[p_terrain_index].color;
 }
 
-bool TileSet::is_valid_peering_bit_for_mode(TileSet::TerrainMode p_terrain_mode, TileSet::CellNeighbor p_peering_bit) const {
+bool TileSet::is_valid_terrain_peering_bit_for_mode(TileSet::TerrainMode p_terrain_mode, TileSet::CellNeighbor p_peering_bit) const {
 	if (tile_shape == TileSet::TILE_SHAPE_SQUARE) {
 		if (p_terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES || p_terrain_mode == TileSet::TERRAIN_MODE_MATCH_SIDES) {
 			if (p_peering_bit == TileSet::CELL_NEIGHBOR_RIGHT_SIDE ||
@@ -905,13 +929,13 @@ bool TileSet::is_valid_peering_bit_for_mode(TileSet::TerrainMode p_terrain_mode,
 	return false;
 }
 
-bool TileSet::is_valid_peering_bit_terrain(int p_terrain_set, TileSet::CellNeighbor p_peering_bit) const {
+bool TileSet::is_valid_terrain_peering_bit(int p_terrain_set, TileSet::CellNeighbor p_peering_bit) const {
 	if (p_terrain_set < 0 || p_terrain_set >= get_terrain_sets_count()) {
 		return false;
 	}
 
 	TileSet::TerrainMode terrain_mode = get_terrain_set_mode(p_terrain_set);
-	return is_valid_peering_bit_for_mode(terrain_mode, p_peering_bit);
+	return is_valid_terrain_peering_bit_for_mode(terrain_mode, p_peering_bit);
 }
 
 // Navigation
@@ -1494,26 +1518,48 @@ void TileSet::draw_tile_shape(CanvasItem *p_canvas_item, Transform2D p_transform
 	}
 }
 
-Vector<Point2> TileSet::get_terrain_bit_polygon(int p_terrain_set, TileSet::CellNeighbor p_bit) {
+Vector<Point2> TileSet::get_terrain_polygon(int p_terrain_set) {
+	if (tile_shape == TileSet::TILE_SHAPE_SQUARE) {
+		return _get_square_terrain_polygon(tile_size);
+	} else if (tile_shape == TileSet::TILE_SHAPE_ISOMETRIC) {
+		return _get_isometric_terrain_polygon(tile_size);
+	} else {
+		float overlap = 0.0;
+		switch (tile_shape) {
+			case TileSet::TILE_SHAPE_HEXAGON:
+				overlap = 0.25;
+				break;
+			case TileSet::TILE_SHAPE_HALF_OFFSET_SQUARE:
+				overlap = 0.0;
+				break;
+			default:
+				break;
+		}
+		return _get_half_offset_terrain_polygon(tile_size, overlap, tile_offset_axis);
+	}
+	return Vector<Point2>();
+}
+
+Vector<Point2> TileSet::get_terrain_peering_bit_polygon(int p_terrain_set, TileSet::CellNeighbor p_bit) {
 	ERR_FAIL_COND_V(p_terrain_set < 0 || p_terrain_set >= get_terrain_sets_count(), Vector<Point2>());
 
 	TileSet::TerrainMode terrain_mode = get_terrain_set_mode(p_terrain_set);
 
 	if (tile_shape == TileSet::TILE_SHAPE_SQUARE) {
 		if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES) {
-			return _get_square_corner_or_side_terrain_bit_polygon(tile_size, p_bit);
+			return _get_square_corner_or_side_terrain_peering_bit_polygon(tile_size, p_bit);
 		} else if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
-			return _get_square_corner_terrain_bit_polygon(tile_size, p_bit);
+			return _get_square_corner_terrain_peering_bit_polygon(tile_size, p_bit);
 		} else { // TileData::TERRAIN_MODE_MATCH_SIDES
-			return _get_square_side_terrain_bit_polygon(tile_size, p_bit);
+			return _get_square_side_terrain_peering_bit_polygon(tile_size, p_bit);
 		}
 	} else if (tile_shape == TileSet::TILE_SHAPE_ISOMETRIC) {
 		if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES) {
-			return _get_isometric_corner_or_side_terrain_bit_polygon(tile_size, p_bit);
+			return _get_isometric_corner_or_side_terrain_peering_bit_polygon(tile_size, p_bit);
 		} else if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
-			return _get_isometric_corner_terrain_bit_polygon(tile_size, p_bit);
+			return _get_isometric_corner_terrain_peering_bit_polygon(tile_size, p_bit);
 		} else { // TileData::TERRAIN_MODE_MATCH_SIDES
-			return _get_isometric_side_terrain_bit_polygon(tile_size, p_bit);
+			return _get_isometric_side_terrain_peering_bit_polygon(tile_size, p_bit);
 		}
 	} else {
 		float overlap = 0.0;
@@ -1528,11 +1574,11 @@ Vector<Point2> TileSet::get_terrain_bit_polygon(int p_terrain_set, TileSet::Cell
 				break;
 		}
 		if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES) {
-			return _get_half_offset_corner_or_side_terrain_bit_polygon(tile_size, p_bit, overlap, tile_offset_axis);
+			return _get_half_offset_corner_or_side_terrain_peering_bit_polygon(tile_size, overlap, tile_offset_axis, p_bit);
 		} else if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
-			return _get_half_offset_corner_terrain_bit_polygon(tile_size, p_bit, overlap, tile_offset_axis);
+			return _get_half_offset_corner_terrain_peering_bit_polygon(tile_size, overlap, tile_offset_axis, p_bit);
 		} else { // TileData::TERRAIN_MODE_MATCH_SIDES
-			return _get_half_offset_side_terrain_bit_polygon(tile_size, p_bit, overlap, tile_offset_axis);
+			return _get_half_offset_side_terrain_peering_bit_polygon(tile_size, overlap, tile_offset_axis, p_bit);
 		}
 	}
 }
@@ -1544,30 +1590,68 @@ void TileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_transform,
 
 	if (terrain_bits_meshes_dirty) {
 		// Recompute the meshes.
-		terrain_bits_meshes.clear();
+		terrain_peering_bits_meshes.clear();
 
 		for (int terrain_mode_index = 0; terrain_mode_index < 3; terrain_mode_index++) {
 			TerrainMode terrain_mode = TerrainMode(terrain_mode_index);
+
+			// Center terrain
+			Vector<Vector2> polygon;
+			if (tile_shape == TileSet::TILE_SHAPE_SQUARE) {
+				polygon = _get_square_terrain_polygon(tile_size);
+			} else if (tile_shape == TileSet::TILE_SHAPE_ISOMETRIC) {
+				polygon = _get_isometric_terrain_polygon(tile_size);
+			} else {
+				float overlap = 0.0;
+				switch (tile_shape) {
+					case TileSet::TILE_SHAPE_HEXAGON:
+						overlap = 0.25;
+						break;
+					case TileSet::TILE_SHAPE_HALF_OFFSET_SQUARE:
+						overlap = 0.0;
+						break;
+					default:
+						break;
+				}
+				polygon = _get_half_offset_terrain_polygon(tile_size, overlap, tile_offset_axis);
+			}
+			{
+				Ref<ArrayMesh> mesh;
+				mesh.instantiate();
+				Vector<Vector2> uvs;
+				uvs.resize(polygon.size());
+				Vector<Color> colors;
+				colors.resize(polygon.size());
+				colors.fill(Color(1.0, 1.0, 1.0, 1.0));
+				Array a;
+				a.resize(Mesh::ARRAY_MAX);
+				a[Mesh::ARRAY_VERTEX] = polygon;
+				a[Mesh::ARRAY_TEX_UV] = uvs;
+				a[Mesh::ARRAY_COLOR] = colors;
+				a[Mesh::ARRAY_INDEX] = Geometry2D::triangulate_polygon(polygon);
+				mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, a, Array(), Dictionary(), Mesh::ARRAY_FLAG_USE_2D_VERTICES);
+				terrain_meshes[terrain_mode] = mesh;
+			}
+			// Peering bits
 			for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
 				CellNeighbor bit = CellNeighbor(i);
 
-				if (is_valid_peering_bit_for_mode(terrain_mode, bit)) {
-					Vector<Vector2> polygon;
+				if (is_valid_terrain_peering_bit_for_mode(terrain_mode, bit)) {
 					if (tile_shape == TileSet::TILE_SHAPE_SQUARE) {
 						if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES) {
-							polygon = _get_square_corner_or_side_terrain_bit_polygon(tile_size, bit);
+							polygon = _get_square_corner_or_side_terrain_peering_bit_polygon(tile_size, bit);
 						} else if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
-							polygon = _get_square_corner_terrain_bit_polygon(tile_size, bit);
+							polygon = _get_square_corner_terrain_peering_bit_polygon(tile_size, bit);
 						} else { // TileData::TERRAIN_MODE_MATCH_SIDES
-							polygon = _get_square_side_terrain_bit_polygon(tile_size, bit);
+							polygon = _get_square_side_terrain_peering_bit_polygon(tile_size, bit);
 						}
 					} else if (tile_shape == TileSet::TILE_SHAPE_ISOMETRIC) {
 						if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES) {
-							polygon = _get_isometric_corner_or_side_terrain_bit_polygon(tile_size, bit);
+							polygon = _get_isometric_corner_or_side_terrain_peering_bit_polygon(tile_size, bit);
 						} else if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
-							polygon = _get_isometric_corner_terrain_bit_polygon(tile_size, bit);
+							polygon = _get_isometric_corner_terrain_peering_bit_polygon(tile_size, bit);
 						} else { // TileData::TERRAIN_MODE_MATCH_SIDES
-							polygon = _get_isometric_side_terrain_bit_polygon(tile_size, bit);
+							polygon = _get_isometric_side_terrain_peering_bit_polygon(tile_size, bit);
 						}
 					} else {
 						float overlap = 0.0;
@@ -1582,29 +1666,30 @@ void TileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_transform,
 								break;
 						}
 						if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS_AND_SIDES) {
-							polygon = _get_half_offset_corner_or_side_terrain_bit_polygon(tile_size, bit, overlap, tile_offset_axis);
+							polygon = _get_half_offset_corner_or_side_terrain_peering_bit_polygon(tile_size, overlap, tile_offset_axis, bit);
 						} else if (terrain_mode == TileSet::TERRAIN_MODE_MATCH_CORNERS) {
-							polygon = _get_half_offset_corner_terrain_bit_polygon(tile_size, bit, overlap, tile_offset_axis);
+							polygon = _get_half_offset_corner_terrain_peering_bit_polygon(tile_size, overlap, tile_offset_axis, bit);
 						} else { // TileData::TERRAIN_MODE_MATCH_SIDES
-							polygon = _get_half_offset_side_terrain_bit_polygon(tile_size, bit, overlap, tile_offset_axis);
+							polygon = _get_half_offset_side_terrain_peering_bit_polygon(tile_size, overlap, tile_offset_axis, bit);
 						}
 					}
-
-					Ref<ArrayMesh> mesh;
-					mesh.instantiate();
-					Vector<Vector2> uvs;
-					uvs.resize(polygon.size());
-					Vector<Color> colors;
-					colors.resize(polygon.size());
-					colors.fill(Color(1.0, 1.0, 1.0, 1.0));
-					Array a;
-					a.resize(Mesh::ARRAY_MAX);
-					a[Mesh::ARRAY_VERTEX] = polygon;
-					a[Mesh::ARRAY_TEX_UV] = uvs;
-					a[Mesh::ARRAY_COLOR] = colors;
-					a[Mesh::ARRAY_INDEX] = Geometry2D::triangulate_polygon(polygon);
-					mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, a, Array(), Dictionary(), Mesh::ARRAY_FLAG_USE_2D_VERTICES);
-					terrain_bits_meshes[terrain_mode][bit] = mesh;
+					{
+						Ref<ArrayMesh> mesh;
+						mesh.instantiate();
+						Vector<Vector2> uvs;
+						uvs.resize(polygon.size());
+						Vector<Color> colors;
+						colors.resize(polygon.size());
+						colors.fill(Color(1.0, 1.0, 1.0, 1.0));
+						Array a;
+						a.resize(Mesh::ARRAY_MAX);
+						a[Mesh::ARRAY_VERTEX] = polygon;
+						a[Mesh::ARRAY_TEX_UV] = uvs;
+						a[Mesh::ARRAY_COLOR] = colors;
+						a[Mesh::ARRAY_INDEX] = Geometry2D::triangulate_polygon(polygon);
+						mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, a, Array(), Dictionary(), Mesh::ARRAY_FLAG_USE_2D_VERTICES);
+						terrain_peering_bits_meshes[terrain_mode][bit] = mesh;
+					}
 				}
 			}
 		}
@@ -1618,14 +1703,21 @@ void TileSet::draw_terrains(CanvasItem *p_canvas_item, Transform2D p_transform,
 	TileSet::TerrainMode terrain_mode = get_terrain_set_mode(terrain_set);
 
 	RenderingServer::get_singleton()->canvas_item_add_set_transform(p_canvas_item->get_canvas_item(), p_transform);
+	int terrain_id = p_tile_data->get_terrain();
+	if (terrain_id >= 0) {
+		Color color = get_terrain_color(terrain_set, terrain_id);
+		color.a = TERRAIN_ALPHA;
+		p_canvas_item->draw_mesh(terrain_meshes[terrain_mode], Ref<Texture2D>(), Transform2D(), color);
+	}
+
 	for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
 		CellNeighbor bit = CellNeighbor(i);
-		if (is_valid_peering_bit_terrain(terrain_set, bit)) {
-			int terrain_id = p_tile_data->get_peering_bit_terrain(bit);
+		if (is_valid_terrain_peering_bit(terrain_set, bit)) {
+			terrain_id = p_tile_data->get_terrain_peering_bit(bit);
 			if (terrain_id >= 0) {
 				Color color = get_terrain_color(terrain_set, terrain_id);
 				color.a = TERRAIN_ALPHA;
-				p_canvas_item->draw_mesh(terrain_bits_meshes[terrain_mode][bit], Ref<Texture2D>(), Transform2D(), color);
+				p_canvas_item->draw_mesh(terrain_peering_bits_meshes[terrain_mode][bit], Ref<Texture2D>(), Transform2D(), color);
 			}
 		}
 	}
@@ -1670,13 +1762,16 @@ Vector<Vector<Ref<Texture2D>>> TileSet::generate_terrains_icons(Size2i p_size) {
 						for (int terrain = 0; terrain < get_terrains_count(terrain_set); terrain++) {
 							bit_counts[terrain] = 0;
 						}
+						if (tile_data->get_terrain() >= 0) {
+							bit_counts[tile_data->get_terrain()] += 10;
+						}
 						for (int terrain_bit = 0; terrain_bit < TileSet::CELL_NEIGHBOR_MAX; terrain_bit++) {
 							TileSet::CellNeighbor cell_neighbor = TileSet::CellNeighbor(terrain_bit);
-							if (is_valid_peering_bit_terrain(terrain_set, cell_neighbor)) {
-								int terrain = tile_data->get_peering_bit_terrain(cell_neighbor);
+							if (is_valid_terrain_peering_bit(terrain_set, cell_neighbor)) {
+								int terrain = tile_data->get_terrain_peering_bit(cell_neighbor);
 								if (terrain >= 0) {
 									if (terrain >= (int)bit_counts.size()) {
-										WARN_PRINT(vformat("Invalid peering bit terrain: %d", terrain));
+										WARN_PRINT(vformat("Invalid terrain peering bit: %d", terrain));
 									} else {
 										bit_counts[terrain] += 1;
 									}
@@ -1730,7 +1825,17 @@ void TileSet::_source_changed() {
 	emit_changed();
 }
 
-Vector<Point2> TileSet::_get_square_corner_or_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) {
+Vector<Point2> TileSet::_get_square_terrain_polygon(Vector2i p_size) {
+	Rect2 rect(-Vector2(p_size) / 6.0, Vector2(p_size) / 3.0);
+	return {
+		rect.position,
+		Vector2(rect.get_end().x, rect.position.y),
+		rect.get_end(),
+		Vector2(rect.position.x, rect.get_end().y)
+	};
+}
+
+Vector<Point2> TileSet::_get_square_corner_or_side_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) {
 	Rect2 bit_rect;
 	bit_rect.size = Vector2(p_size) / 3;
 	switch (p_bit) {
@@ -1773,7 +1878,7 @@ Vector<Point2> TileSet::_get_square_corner_or_side_terrain_bit_polygon(Vector2i
 	return polygon;
 }
 
-Vector<Point2> TileSet::_get_square_corner_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) {
+Vector<Point2> TileSet::_get_square_corner_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) {
 	Vector2 unit = Vector2(p_size) / 6.0;
 	Vector<Vector2> polygon;
 	switch (p_bit) {
@@ -1815,7 +1920,7 @@ Vector<Point2> TileSet::_get_square_corner_terrain_bit_polygon(Vector2i p_size,
 	return polygon;
 }
 
-Vector<Point2> TileSet::_get_square_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) {
+Vector<Point2> TileSet::_get_square_side_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) {
 	Vector2 unit = Vector2(p_size) / 6.0;
 	Vector<Vector2> polygon;
 	switch (p_bit) {
@@ -1849,7 +1954,17 @@ Vector<Point2> TileSet::_get_square_side_terrain_bit_polygon(Vector2i p_size, Ti
 	return polygon;
 }
 
-Vector<Point2> TileSet::_get_isometric_corner_or_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) {
+Vector<Point2> TileSet::_get_isometric_terrain_polygon(Vector2i p_size) {
+	Vector2 unit = Vector2(p_size) / 6.0;
+	return {
+		Vector2(1, 0) * unit,
+		Vector2(0, 1) * unit,
+		Vector2(-1, 0) * unit,
+		Vector2(0, -1) * unit,
+	};
+}
+
+Vector<Point2> TileSet::_get_isometric_corner_or_side_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) {
 	Vector2 unit = Vector2(p_size) / 6.0;
 	Vector<Vector2> polygon;
 	switch (p_bit) {
@@ -1907,7 +2022,7 @@ Vector<Point2> TileSet::_get_isometric_corner_or_side_terrain_bit_polygon(Vector
 	return polygon;
 }
 
-Vector<Point2> TileSet::_get_isometric_corner_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) {
+Vector<Point2> TileSet::_get_isometric_corner_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) {
 	Vector2 unit = Vector2(p_size) / 6.0;
 	Vector<Vector2> polygon;
 	switch (p_bit) {
@@ -1949,7 +2064,7 @@ Vector<Point2> TileSet::_get_isometric_corner_terrain_bit_polygon(Vector2i p_siz
 	return polygon;
 }
 
-Vector<Point2> TileSet::_get_isometric_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) {
+Vector<Point2> TileSet::_get_isometric_side_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit) {
 	Vector2 unit = Vector2(p_size) / 6.0;
 	Vector<Vector2> polygon;
 	switch (p_bit) {
@@ -1983,7 +2098,30 @@ Vector<Point2> TileSet::_get_isometric_side_terrain_bit_polygon(Vector2i p_size,
 	return polygon;
 }
 
-Vector<Point2> TileSet::_get_half_offset_corner_or_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit, float p_overlap, TileSet::TileOffsetAxis p_offset_axis) {
+Vector<Point2> TileSet::_get_half_offset_terrain_polygon(Vector2i p_size, float p_overlap, TileSet::TileOffsetAxis p_offset_axis) {
+	Vector2 unit = Vector2(p_size) / 6.0;
+	if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+		return {
+			Vector2(1, 1.0 - p_overlap * 2.0) * unit,
+			Vector2(0, 1) * unit,
+			Vector2(-1, 1.0 - p_overlap * 2.0) * unit,
+			Vector2(-1, -1.0 + p_overlap * 2.0) * unit,
+			Vector2(0, -1) * unit,
+			Vector2(1, -1.0 + p_overlap * 2.0) * unit,
+		};
+	} else {
+		return {
+			Vector2(1, 0) * unit,
+			Vector2(1.0 - p_overlap * 2.0, -1) * unit,
+			Vector2(-1.0 + p_overlap * 2.0, -1) * unit,
+			Vector2(-1, 0) * unit,
+			Vector2(-1.0 + p_overlap * 2.0, 1) * unit,
+			Vector2(1.0 - p_overlap * 2.0, 1) * unit,
+		};
+	}
+}
+
+Vector<Point2> TileSet::_get_half_offset_corner_or_side_terrain_peering_bit_polygon(Vector2i p_size, float p_overlap, TileSet::TileOffsetAxis p_offset_axis, TileSet::CellNeighbor p_bit) {
 	Vector<Vector2> point_list = {
 		Vector2(3, (3.0 * (1.0 - p_overlap * 2.0)) / 2.0),
 		Vector2(3, 3.0 * (1.0 - p_overlap * 2.0)),
@@ -2006,12 +2144,11 @@ Vector<Point2> TileSet::_get_half_offset_corner_or_side_terrain_bit_polygon(Vect
 	};
 
 	Vector2 unit = Vector2(p_size) / 6.0;
-	for (int i = 0; i < point_list.size(); i++) {
-		point_list.write[i] = point_list[i] * unit;
-	}
-
 	Vector<Vector2> polygon;
 	if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+		for (int i = 0; i < point_list.size(); i++) {
+			point_list.write[i] = point_list[i] * unit;
+		}
 		switch (p_bit) {
 			case TileSet::CELL_NEIGHBOR_RIGHT_SIDE:
 				polygon.push_back(point_list[17]);
@@ -2071,10 +2208,8 @@ Vector<Point2> TileSet::_get_half_offset_corner_or_side_terrain_bit_polygon(Vect
 				break;
 		}
 	} else {
-		if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_VERTICAL) {
-			for (int i = 0; i < point_list.size(); i++) {
-				point_list.write[i] = Vector2(point_list[i].y, point_list[i].x);
-			}
+		for (int i = 0; i < point_list.size(); i++) {
+			point_list.write[i] = Vector2(point_list[i].y, point_list[i].x) * unit;
 		}
 		switch (p_bit) {
 			case TileSet::CELL_NEIGHBOR_RIGHT_CORNER:
@@ -2144,7 +2279,7 @@ Vector<Point2> TileSet::_get_half_offset_corner_or_side_terrain_bit_polygon(Vect
 	return polygon;
 }
 
-Vector<Point2> TileSet::_get_half_offset_corner_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit, float p_overlap, TileSet::TileOffsetAxis p_offset_axis) {
+Vector<Point2> TileSet::_get_half_offset_corner_terrain_peering_bit_polygon(Vector2i p_size, float p_overlap, TileSet::TileOffsetAxis p_offset_axis, TileSet::CellNeighbor p_bit) {
 	Vector<Vector2> point_list = {
 		Vector2(3, 0),
 		Vector2(3, 3.0 * (1.0 - p_overlap * 2.0)),
@@ -2161,12 +2296,11 @@ Vector<Point2> TileSet::_get_half_offset_corner_terrain_bit_polygon(Vector2i p_s
 	};
 
 	Vector2 unit = Vector2(p_size) / 6.0;
-	for (int i = 0; i < point_list.size(); i++) {
-		point_list.write[i] = point_list[i] * unit;
-	}
-
 	Vector<Vector2> polygon;
 	if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+		for (int i = 0; i < point_list.size(); i++) {
+			point_list.write[i] = point_list[i] * unit;
+		}
 		switch (p_bit) {
 			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_CORNER:
 				polygon.push_back(point_list[0]);
@@ -2202,10 +2336,8 @@ Vector<Point2> TileSet::_get_half_offset_corner_terrain_bit_polygon(Vector2i p_s
 				break;
 		}
 	} else {
-		if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_VERTICAL) {
-			for (int i = 0; i < point_list.size(); i++) {
-				point_list.write[i] = Vector2(point_list[i].y, point_list[i].x);
-			}
+		for (int i = 0; i < point_list.size(); i++) {
+			point_list.write[i] = Vector2(point_list[i].y, point_list[i].x) * unit;
 		}
 		switch (p_bit) {
 			case TileSet::CELL_NEIGHBOR_RIGHT_CORNER:
@@ -2251,7 +2383,7 @@ Vector<Point2> TileSet::_get_half_offset_corner_terrain_bit_polygon(Vector2i p_s
 	return polygon;
 }
 
-Vector<Point2> TileSet::_get_half_offset_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit, float p_overlap, TileSet::TileOffsetAxis p_offset_axis) {
+Vector<Point2> TileSet::_get_half_offset_side_terrain_peering_bit_polygon(Vector2i p_size, float p_overlap, TileSet::TileOffsetAxis p_offset_axis, TileSet::CellNeighbor p_bit) {
 	Vector<Vector2> point_list = {
 		Vector2(3, 3.0 * (1.0 - p_overlap * 2.0)),
 		Vector2(0, 3),
@@ -2262,12 +2394,11 @@ Vector<Point2> TileSet::_get_half_offset_side_terrain_bit_polygon(Vector2i p_siz
 	};
 
 	Vector2 unit = Vector2(p_size) / 6.0;
-	for (int i = 0; i < point_list.size(); i++) {
-		point_list.write[i] = point_list[i] * unit;
-	}
-
 	Vector<Vector2> polygon;
 	if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_HORIZONTAL) {
+		for (int i = 0; i < point_list.size(); i++) {
+			point_list.write[i] = point_list[i] * unit;
+		}
 		switch (p_bit) {
 			case TileSet::CELL_NEIGHBOR_RIGHT_SIDE:
 				polygon.push_back(point_list[5]);
@@ -2297,10 +2428,8 @@ Vector<Point2> TileSet::_get_half_offset_side_terrain_bit_polygon(Vector2i p_siz
 				break;
 		}
 	} else {
-		if (p_offset_axis == TileSet::TILE_OFFSET_AXIS_VERTICAL) {
-			for (int i = 0; i < point_list.size(); i++) {
-				point_list.write[i] = Vector2(point_list[i].y, point_list[i].x);
-			}
+		for (int i = 0; i < point_list.size(); i++) {
+			point_list.write[i] = Vector2(point_list[i].y, point_list[i].x) * unit;
 		}
 		switch (p_bit) {
 			case TileSet::CELL_NEIGHBOR_BOTTOM_RIGHT_SIDE:
@@ -5114,36 +5243,51 @@ int TileData::get_terrain_set() const {
 	return terrain_set;
 }
 
-void TileData::set_peering_bit_terrain(TileSet::CellNeighbor p_peering_bit, int p_terrain_index) {
+void TileData::set_terrain(int p_terrain) {
+	ERR_FAIL_COND(terrain_set < 0);
+	ERR_FAIL_COND(p_terrain < -1);
+	if (tile_set) {
+		ERR_FAIL_COND(p_terrain >= tile_set->get_terrains_count(terrain_set));
+	}
+	terrain = p_terrain;
+	emit_signal(SNAME("changed"));
+}
+
+int TileData::get_terrain() const {
+	return terrain;
+}
+
+void TileData::set_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit, int p_terrain_index) {
 	ERR_FAIL_INDEX(p_peering_bit, TileSet::CellNeighbor::CELL_NEIGHBOR_MAX);
 	ERR_FAIL_COND(terrain_set < 0);
 	ERR_FAIL_COND(p_terrain_index < -1);
 	if (tile_set) {
 		ERR_FAIL_COND(p_terrain_index >= tile_set->get_terrains_count(terrain_set));
-		ERR_FAIL_COND(!is_valid_peering_bit_terrain(p_peering_bit));
+		ERR_FAIL_COND(!is_valid_terrain_peering_bit(p_peering_bit));
 	}
 	terrain_peering_bits[p_peering_bit] = p_terrain_index;
 	emit_signal(SNAME("changed"));
 }
 
-int TileData::get_peering_bit_terrain(TileSet::CellNeighbor p_peering_bit) const {
-	ERR_FAIL_COND_V(!is_valid_peering_bit_terrain(p_peering_bit), -1);
+int TileData::get_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit) const {
+	ERR_FAIL_COND_V(!is_valid_terrain_peering_bit(p_peering_bit), -1);
 	return terrain_peering_bits[p_peering_bit];
 }
 
-bool TileData::is_valid_peering_bit_terrain(TileSet::CellNeighbor p_peering_bit) const {
+bool TileData::is_valid_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit) const {
 	ERR_FAIL_COND_V(!tile_set, false);
 
-	return tile_set->is_valid_peering_bit_terrain(terrain_set, p_peering_bit);
+	return tile_set->is_valid_terrain_peering_bit(terrain_set, p_peering_bit);
 }
 
 TileSet::TerrainsPattern TileData::get_terrains_pattern() const {
 	ERR_FAIL_COND_V(!tile_set, TileSet::TerrainsPattern());
 
 	TileSet::TerrainsPattern output(tile_set, terrain_set);
+	output.set_terrain(terrain);
 	for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
-		if (tile_set->is_valid_peering_bit_terrain(terrain_set, TileSet::CellNeighbor(i))) {
-			output.set_terrain(TileSet::CellNeighbor(i), get_peering_bit_terrain(TileSet::CellNeighbor(i)));
+		if (tile_set->is_valid_terrain_peering_bit(terrain_set, TileSet::CellNeighbor(i))) {
+			output.set_terrain_peering_bit(TileSet::CellNeighbor(i), get_terrain_peering_bit(TileSet::CellNeighbor(i)));
 		}
 	}
 	return output;
@@ -5293,7 +5437,7 @@ bool TileData::_set(const StringName &p_name, const Variant &p_value) {
 		for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
 			TileSet::CellNeighbor bit = TileSet::CellNeighbor(i);
 			if (components[1] == TileSet::CELL_NEIGHBOR_ENUM_TO_TEXT[i]) {
-				set_peering_bit_terrain(bit, p_value);
+				set_terrain_peering_bit(bit, p_value);
 				return true;
 			}
 		}
@@ -5455,9 +5599,9 @@ void TileData::_get_property_list(List<PropertyInfo> *p_list) const {
 			p_list->push_back(PropertyInfo(Variant::NIL, "Terrains", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
 			for (int i = 0; i < TileSet::CELL_NEIGHBOR_MAX; i++) {
 				TileSet::CellNeighbor bit = TileSet::CellNeighbor(i);
-				if (is_valid_peering_bit_terrain(bit)) {
+				if (is_valid_terrain_peering_bit(bit)) {
 					property_info = PropertyInfo(Variant::INT, "terrains_peering_bit/" + String(TileSet::CELL_NEIGHBOR_ENUM_TO_TEXT[i]));
-					if (get_peering_bit_terrain(bit) == -1) {
+					if (get_terrain_peering_bit(bit) == -1) {
 						property_info.usage ^= PROPERTY_USAGE_STORAGE;
 					}
 					p_list->push_back(property_info);
@@ -5531,8 +5675,10 @@ void TileData::_bind_methods() {
 	// Terrain
 	ClassDB::bind_method(D_METHOD("set_terrain_set", "terrain_set"), &TileData::set_terrain_set);
 	ClassDB::bind_method(D_METHOD("get_terrain_set"), &TileData::get_terrain_set);
-	ClassDB::bind_method(D_METHOD("set_peering_bit_terrain", "peering_bit", "terrain"), &TileData::set_peering_bit_terrain);
-	ClassDB::bind_method(D_METHOD("get_peering_bit_terrain", "peering_bit"), &TileData::get_peering_bit_terrain);
+	ClassDB::bind_method(D_METHOD("set_terrain", "terrain"), &TileData::set_terrain);
+	ClassDB::bind_method(D_METHOD("get_terrain"), &TileData::get_terrain);
+	ClassDB::bind_method(D_METHOD("set_terrain_peering_bit", "peering_bit", "terrain"), &TileData::set_terrain_peering_bit);
+	ClassDB::bind_method(D_METHOD("get_terrain_peering_bit", "peering_bit"), &TileData::get_terrain_peering_bit);
 
 	// Navigation
 	ClassDB::bind_method(D_METHOD("set_navigation_polygon", "layer_id", "navigation_polygon"), &TileData::set_navigation_polygon);
@@ -5560,6 +5706,7 @@ void TileData::_bind_methods() {
 
 	ADD_GROUP("Terrains", "");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "terrain_set"), "set_terrain_set", "get_terrain_set");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "terrain"), "set_terrain", "get_terrain");
 
 	ADD_GROUP("Miscellaneous", "");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "probability"), "set_probability", "get_probability");
diff --git a/scene/resources/tile_set.h b/scene/resources/tile_set.h
index 615ab35615..181782e5af 100644
--- a/scene/resources/tile_set.h
+++ b/scene/resources/tile_set.h
@@ -265,6 +265,7 @@ public:
 
 	class TerrainsPattern {
 		bool valid = false;
+		int terrain = -1;
 		int bits[TileSet::CELL_NEIGHBOR_MAX];
 		bool is_valid_bit[TileSet::CELL_NEIGHBOR_MAX];
 
@@ -277,11 +278,14 @@ public:
 		bool operator<(const TerrainsPattern &p_terrains_pattern) const;
 		bool operator==(const TerrainsPattern &p_terrains_pattern) const;
 
-		void set_terrain(TileSet::CellNeighbor p_peering_bit, int p_terrain);
-		int get_terrain(TileSet::CellNeighbor p_peering_bit) const;
+		void set_terrain(int p_terrain);
+		int get_terrain() const;
 
-		void set_terrains_from_array(Array p_terrains);
-		Array get_terrains_as_array() const;
+		void set_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit, int p_terrain);
+		int get_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit) const;
+
+		void from_array(Array p_terrains);
+		Array as_array() const;
 
 		TerrainsPattern(const TileSet *p_tile_set, int p_terrain_set);
 		TerrainsPattern() {}
@@ -333,7 +337,8 @@ private:
 	};
 	Vector<TerrainSet> terrain_sets;
 
-	HashMap<TerrainMode, HashMap<CellNeighbor, Ref<ArrayMesh>>> terrain_bits_meshes;
+	HashMap<TerrainMode, Ref<ArrayMesh>> terrain_meshes;
+	HashMap<TerrainMode, HashMap<CellNeighbor, Ref<ArrayMesh>>> terrain_peering_bits_meshes;
 	bool terrain_bits_meshes_dirty = true;
 
 	LocalVector<RBMap<TileSet::TerrainsPattern, RBSet<TileMapCell>>> per_terrain_pattern_tiles; // Cached data.
@@ -371,17 +376,20 @@ private:
 	RBMap<Array, Array> alternative_level_proxies;
 
 	// Helpers
-	Vector<Point2> _get_square_corner_or_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
-	Vector<Point2> _get_square_corner_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
-	Vector<Point2> _get_square_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
+	Vector<Point2> _get_square_terrain_polygon(Vector2i p_size);
+	Vector<Point2> _get_square_corner_or_side_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
+	Vector<Point2> _get_square_corner_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
+	Vector<Point2> _get_square_side_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
 
-	Vector<Point2> _get_isometric_corner_or_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
-	Vector<Point2> _get_isometric_corner_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
-	Vector<Point2> _get_isometric_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
+	Vector<Point2> _get_isometric_terrain_polygon(Vector2i p_size);
+	Vector<Point2> _get_isometric_corner_or_side_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
+	Vector<Point2> _get_isometric_corner_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
+	Vector<Point2> _get_isometric_side_terrain_peering_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit);
 
-	Vector<Point2> _get_half_offset_corner_or_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit, float p_overlap, TileSet::TileOffsetAxis p_offset_axis);
-	Vector<Point2> _get_half_offset_corner_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit, float p_overlap, TileSet::TileOffsetAxis p_offset_axis);
-	Vector<Point2> _get_half_offset_side_terrain_bit_polygon(Vector2i p_size, TileSet::CellNeighbor p_bit, float p_overlap, TileSet::TileOffsetAxis p_offset_axis);
+	Vector<Point2> _get_half_offset_terrain_polygon(Vector2i p_size, float p_overlap, TileSet::TileOffsetAxis p_offset_axis);
+	Vector<Point2> _get_half_offset_corner_or_side_terrain_peering_bit_polygon(Vector2i p_size, float p_overlap, TileSet::TileOffsetAxis p_offset_axis, TileSet::CellNeighbor p_bit);
+	Vector<Point2> _get_half_offset_corner_terrain_peering_bit_polygon(Vector2i p_size, float p_overlap, TileSet::TileOffsetAxis p_offset_axis, TileSet::CellNeighbor p_bit);
+	Vector<Point2> _get_half_offset_side_terrain_peering_bit_polygon(Vector2i p_size, float p_overlap, TileSet::TileOffsetAxis p_offset_axis, TileSet::CellNeighbor p_bit);
 
 protected:
 	static void _bind_methods();
@@ -454,8 +462,8 @@ public:
 	String get_terrain_name(int p_terrain_set, int p_terrain_index) const;
 	void set_terrain_color(int p_terrain_set, int p_terrain_index, Color p_color);
 	Color get_terrain_color(int p_terrain_set, int p_terrain_index) const;
-	bool is_valid_peering_bit_for_mode(TileSet::TerrainMode p_terrain_mode, TileSet::CellNeighbor p_peering_bit) const;
-	bool is_valid_peering_bit_terrain(int p_terrain_set, TileSet::CellNeighbor p_peering_bit) const;
+	bool is_valid_terrain_peering_bit_for_mode(TileSet::TerrainMode p_terrain_mode, TileSet::CellNeighbor p_peering_bit) const;
+	bool is_valid_terrain_peering_bit(int p_terrain_set, TileSet::CellNeighbor p_peering_bit) const;
 
 	// Navigation
 	int get_navigation_layers_count() const;
@@ -516,7 +524,8 @@ public:
 	Vector<Vector2> get_tile_shape_polygon();
 	void draw_tile_shape(CanvasItem *p_canvas_item, Transform2D p_transform, Color p_color, bool p_filled = false, Ref<Texture2D> p_texture = Ref<Texture2D>());
 
-	Vector<Point2> get_terrain_bit_polygon(int p_terrain_set, TileSet::CellNeighbor p_bit);
+	Vector<Point2> get_terrain_polygon(int p_terrain_set);
+	Vector<Point2> get_terrain_peering_bit_polygon(int p_terrain_set, TileSet::CellNeighbor p_bit);
 	void draw_terrains(CanvasItem *p_canvas_item, Transform2D p_transform, const TileData *p_tile_data);
 	Vector<Vector<Ref<Texture2D>>> generate_terrains_icons(Size2i p_size);
 
@@ -798,6 +807,7 @@ private:
 
 	// Terrain
 	int terrain_set = -1;
+	int terrain = -1;
 	int terrain_peering_bits[16] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
 
 	// Navigation
@@ -887,9 +897,11 @@ public:
 	// Terrain
 	void set_terrain_set(int p_terrain_id);
 	int get_terrain_set() const;
-	void set_peering_bit_terrain(TileSet::CellNeighbor p_peering_bit, int p_terrain_id);
-	int get_peering_bit_terrain(TileSet::CellNeighbor p_peering_bit) const;
-	bool is_valid_peering_bit_terrain(TileSet::CellNeighbor p_peering_bit) const;
+	void set_terrain(int p_terrain_id);
+	int get_terrain() const;
+	void set_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit, int p_terrain_id);
+	int get_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit) const;
+	bool is_valid_terrain_peering_bit(TileSet::CellNeighbor p_peering_bit) const;
 
 	TileSet::TerrainsPattern get_terrains_pattern() const; // Not exposed.