Refine wall base and ladder access

README.md

@@ -64,6 +64,7 @@ Useful options:
 - `--sea-level L`: sea level, default `70`.
 - `--snow-line H`: snow threshold, default `sea-level + 38`.
 - `--trails`: enable trail and cabin prepass.
+- `--wall`: build a brutalist border wall around the generated area.
 - `--format mca|bin`: write Minecraft region files or raw debug chunks.
 - `--out DIR`: output directory.
 

worldgen-c/include/worldgen.h

@@ -7,6 +7,7 @@
 
 #define CHUNK_SIZE 16
 #define CHUNK_HEIGHT 256
+#define WORLDGEN_HEIGHT_CACHE_SIZE 32768
 
 	enum BlockId {
 		BLOCK_BEDROCK = 0,
@@ -52,7 +53,15 @@
 		BLOCK_LADDER_N = 40,
 		BLOCK_LADDER_S = 41,
 		BLOCK_LADDER_W = 42,
-		BLOCK_LADDER_E = 43
+		BLOCK_LADDER_E = 43,
+		BLOCK_SMOOTH_STONE = 44,
+		BLOCK_STONE_BRICKS = 45,
+		BLOCK_BLACKSTONE = 46,
+		BLOCK_IRON_BARS = 47,
+		BLOCK_STONE_BRICK_STAIRS_E = 48,
+		BLOCK_STONE_BRICK_STAIRS_W = 49,
+		BLOCK_STONE_BRICK_STAIRS_N = 50,
+		BLOCK_STONE_BRICK_STAIRS_S = 51
 	};
 
 struct trail_segment;
@@ -64,17 +73,27 @@ typedef struct {
 	uint16_t blocks[CHUNK_HEIGHT][CHUNK_SIZE][CHUNK_SIZE];
 } chunk_data;
 
+typedef struct {
+	int x;
+	int z;
+	int value;
+	uint8_t valid;
+} worldgen_height_cache_entry;
+
 typedef struct {
 	simplex_noise noise;
 	int sea_level;
 	int world_seed;
 	int enable_trails;
+	int enable_wall;
+	int wall_min_x, wall_max_x, wall_min_z, wall_max_z;
 	int snow_line;
 	struct trail_segment *trail_segments;
 	size_t trail_segment_count;
 	size_t trail_segment_cap;
 	int prepass_done;
 	int prepass_min_x, prepass_max_x, prepass_min_z, prepass_max_z;
+	worldgen_height_cache_entry height_cache[WORLDGEN_HEIGHT_CACHE_SIZE];
 } worldgen_ctx;
 
 void worldgen_init(worldgen_ctx *ctx, int world_seed, int sea_level, int snow_line);

worldgen-c/src/main.c

@@ -51,6 +51,8 @@ typedef struct {
 	int snow_line;
 	pthread_mutex_t *log_mu;
 	int enable_trails;
+	int enable_wall;
+	int wall_min_x, wall_max_x, wall_min_z, wall_max_z;
 	results_buffer *results;
 	struct trail_segment *trail_segments;
 	size_t trail_segment_count;
@@ -84,6 +86,8 @@ static const kv_pair PROPS_WATER[] = {{"level", "0"}};
 static const kv_pair PROPS_LEAVES[] = {{"distance", "1"}, {"persistent", "false"}};
 static const kv_pair PROPS_STAIRS_E[] = {{"facing", "east"}, {"half", "bottom"}, {"shape", "straight"}, {"waterlogged", "false"}};
 static const kv_pair PROPS_STAIRS_W[] = {{"facing", "west"}, {"half", "bottom"}, {"shape", "straight"}, {"waterlogged", "false"}};
+static const kv_pair PROPS_STAIRS_N[] = {{"facing", "north"}, {"half", "bottom"}, {"shape", "straight"}, {"waterlogged", "false"}};
+static const kv_pair PROPS_STAIRS_S[] = {{"facing", "south"}, {"half", "bottom"}, {"shape", "straight"}, {"waterlogged", "false"}};
 static const kv_pair PROPS_DOOR_S_LOWER[] = {{"facing", "south"}, {"half", "lower"}, {"hinge", "left"}, {"open", "false"}, {"powered", "false"}};
 static const kv_pair PROPS_DOOR_S_UPPER[] = {{"facing", "south"}, {"half", "upper"}, {"hinge", "left"}, {"open", "false"}, {"powered", "false"}};
 static const kv_pair PROPS_DOOR_N_LOWER[] = {{"facing", "north"}, {"half", "lower"}, {"hinge", "left"}, {"open", "false"}, {"powered", "false"}};
@@ -142,7 +146,15 @@ static const block_state BLOCK_STATE_TABLE[] = {
 	[BLOCK_LADDER_N] = {"minecraft:ladder", PROPS_LADDER_N, 2},
 	[BLOCK_LADDER_S] = {"minecraft:ladder", PROPS_LADDER_S, 2},
 	[BLOCK_LADDER_W] = {"minecraft:ladder", PROPS_LADDER_W, 2},
-	[BLOCK_LADDER_E] = {"minecraft:ladder", PROPS_LADDER_E, 2}
+	[BLOCK_LADDER_E] = {"minecraft:ladder", PROPS_LADDER_E, 2},
+	[BLOCK_SMOOTH_STONE] = {"minecraft:smooth_stone", NULL, 0},
+	[BLOCK_STONE_BRICKS] = {"minecraft:stone_bricks", NULL, 0},
+	[BLOCK_BLACKSTONE] = {"minecraft:blackstone", NULL, 0},
+	[BLOCK_IRON_BARS] = {"minecraft:iron_bars", NULL, 0},
+	[BLOCK_STONE_BRICK_STAIRS_E] = {"minecraft:stone_brick_stairs", PROPS_STAIRS_E, 4},
+	[BLOCK_STONE_BRICK_STAIRS_W] = {"minecraft:stone_brick_stairs", PROPS_STAIRS_W, 4},
+	[BLOCK_STONE_BRICK_STAIRS_N] = {"minecraft:stone_brick_stairs", PROPS_STAIRS_N, 4},
+	[BLOCK_STONE_BRICK_STAIRS_S] = {"minecraft:stone_brick_stairs", PROPS_STAIRS_S, 4}
 };
 
 static const block_state *get_block_state(uint16_t id) {
@@ -593,7 +605,7 @@ static void write_regions(const char *out_dir, region_accum *regions, size_t reg
 static void usage(const char *prog) {
 	fprintf(stderr,
 	        "Usage: %s [--radius R] [--center-x X --center-z Z] [--min-x MX --max-x MX --min-z MZ --max-z MZ]\n"
-	        "          [--threads N] [--seed S] [--sea-level L] [--snow-line H] [--format mca|bin] [--trails] [--out DIR]\n",
+	        "          [--threads N] [--seed S] [--sea-level L] [--snow-line H] [--format mca|bin] [--trails] [--wall] [--out DIR]\n",
 	        prog);
 }
 
@@ -665,6 +677,11 @@ static void *worker_fn(void *ptr) {
 	worldgen_ctx ctx;
 	worldgen_init(&ctx, args->world_seed, args->sea_level, args->snow_line);
 	ctx.enable_trails = args->enable_trails;
+	ctx.enable_wall = args->enable_wall;
+	ctx.wall_min_x = args->wall_min_x;
+	ctx.wall_max_x = args->wall_max_x;
+	ctx.wall_min_z = args->wall_min_z;
+	ctx.wall_max_z = args->wall_max_z;
 	if (args->trail_segments && args->trail_segment_count > 0) {
 		ctx.trail_segments = args->trail_segments;
 		ctx.trail_segment_count = args->trail_segment_count;
@@ -682,14 +699,12 @@ static void *worker_fn(void *ptr) {
 		chunk_data chunk;
 		worldgen_generate_chunk(&ctx, job.x, job.z, &chunk);
 		if (args->results) {
-			pthread_mutex_lock(&args->results->mutex);
 			size_t result_idx = atomic_fetch_add(&args->results->count, 1);
 			if (result_idx < args->results->capacity) {
 				args->results->chunks[result_idx].chunk_x = chunk.chunk_x;
 				args->results->chunks[result_idx].chunk_z = chunk.chunk_z;
 				memcpy(&args->results->chunks[result_idx].data, &chunk, sizeof(chunk_data));
 			}
-			pthread_mutex_unlock(&args->results->mutex);
 		} else {
 			write_chunk_file(args->out_dir, &chunk);
 		}
@@ -716,6 +731,7 @@ int main(int argc, char **argv) {
 	int sea_level = 70;
 	int snow_line = INT_MIN;
 	int enable_trails = 0;
+	int enable_wall = 0;
 	const char *out_dir = "output";
 	output_format format = FORMAT_MCA;
 
@@ -761,6 +777,8 @@ int main(int argc, char **argv) {
 			}
 		} else if (strcmp(argv[i], "--trails") == 0) {
 			enable_trails = 1;
+		} else if (strcmp(argv[i], "--wall") == 0) {
+			enable_wall = 1;
 		} else if ((strcmp(argv[i], "--out") == 0 || strcmp(argv[i], "--output") == 0) && i + 1 < argc) {
 			out_dir = argv[++i];
 		} else if (strcmp(argv[i], "--help") == 0) {
@@ -791,6 +809,11 @@ int main(int argc, char **argv) {
 	int world_max_x = max_x * CHUNK_SIZE + (CHUNK_SIZE - 1);
 	int world_min_z = min_z * CHUNK_SIZE;
 	int world_max_z = max_z * CHUNK_SIZE + (CHUNK_SIZE - 1);
+	pre_ctx.enable_wall = enable_wall;
+	pre_ctx.wall_min_x = world_min_x;
+	pre_ctx.wall_max_x = world_max_x;
+	pre_ctx.wall_min_z = world_min_z;
+	pre_ctx.wall_max_z = world_max_z;
 	if (enable_trails) {
 		worldgen_prepass(&pre_ctx, world_min_x, world_max_x, world_min_z, world_max_z);
 		prepass_ready = 1;
@@ -836,6 +859,11 @@ int main(int argc, char **argv) {
 		.snow_line = snow_line,
 		.log_mu = &log_mu,
 		.enable_trails = enable_trails,
+		.enable_wall = enable_wall,
+		.wall_min_x = world_min_x,
+		.wall_max_x = world_max_x,
+		.wall_min_z = world_min_z,
+		.wall_max_z = world_max_z,
 		.results = &results,
 		.trail_segments = prepass_ready ? pre_ctx.trail_segments : NULL,
 		.trail_segment_count = prepass_ready ? pre_ctx.trail_segment_count : 0,

worldgen-c/src/worldgen.c

@@ -125,6 +125,11 @@ static inline int clamp_int(int v, int min_v, int max_v) {
 	return v;
 }
 
+static inline double smoothstep01(double v) {
+	v = clamp01(v);
+	return v * v * (3.0 - 2.0 * v);
+}
+
 static int ground_slope(worldgen_ctx *ctx, int x, int z);
 static uint16_t select_surface_block(worldgen_ctx *ctx, const column_data *data, int world_x, int world_z);
 static void generate_chunk_trails(worldgen_ctx *ctx, int chunk_x, int chunk_z, column_data columns[CHUNK_SIZE][CHUNK_SIZE], chunk_data *out);
@@ -133,6 +138,7 @@ static void generate_chunk_redwood_floor(worldgen_ctx *ctx, int chunk_x, int chu
 static void generate_chunk_grass(worldgen_ctx *ctx, int chunk_x, int chunk_z, column_data columns[CHUNK_SIZE][CHUNK_SIZE], chunk_data *out);
 static void generate_chunk_flowers(worldgen_ctx *ctx, int chunk_x, int chunk_z, column_data columns[CHUNK_SIZE][CHUNK_SIZE], chunk_data *out);
 static void generate_chunk_cabins(worldgen_ctx *ctx, int chunk_x, int chunk_z, column_data columns[CHUNK_SIZE][CHUNK_SIZE], chunk_data *out);
+static void generate_chunk_border_wall(worldgen_ctx *ctx, int chunk_x, int chunk_z, chunk_data *out);
 static void ensure_trail_prepass(worldgen_ctx *ctx, int chunk_x, int chunk_z);
 static void append_trail_segment(worldgen_ctx *ctx, int ax, int az, int bx, int bz, int *points, int count);
 static int *smooth_trail_polyline(worldgen_ctx *ctx, int *points, int count, int *out_count);
@@ -519,6 +525,15 @@ static double redwood_tree_presence(worldgen_ctx *ctx, int x, int z) {
 	return clamp01(presence);
 }
 
+static double buildable_flatland_mask(worldgen_ctx *ctx, int x, int z, double mountain_factor) {
+	double cell = worley_distance(x + 71000, z - 71000, 0.00082, 0xB17D4B11u);
+	double broad_patch = smoothstep01((0.66 - cell) / 0.28);
+	double gate = simplex_noise2(&ctx->noise, (x - 91000) * 0.00022, (z + 91000) * 0.00022) * 0.5 + 0.5;
+	double campus_patch = broad_patch * smoothstep01((gate - 0.32) / 0.36);
+	double mountain_guard = 1.0 - smoothstep01((mountain_factor - 0.42) / 0.34) * 0.82;
+	return clamp01(campus_patch * mountain_guard);
+}
+
 
 static double region_blend(worldgen_ctx *ctx, int x, int z) {
 	(void)ctx;
@@ -605,7 +620,7 @@ static void block_list_push(block_list *list, int x, int y, int z, uint16_t id)
 // ---------------------------------------------------------------------------
 // Core worldgen functions
 // ---------------------------------------------------------------------------
-static int column_height(worldgen_ctx *ctx, int x, int z) {
+static int raw_column_height(worldgen_ctx *ctx, int x, int z) {
 	double region = region_blend(ctx, x, z);
 	double old_growth = old_growth_plains_mask(ctx, x, z);
 	double warp1_x = x + simplex_noise2(&ctx->noise, x * 0.001, z * 0.001) * 50.0;
@@ -634,6 +649,7 @@ static int column_height(worldgen_ctx *ctx, int x, int z) {
 	double mix_base = region * 0.35 + base_mountain * 0.55;
 	double mix = clamp01(mix_base * 0.65 + 0.15);
 	double height = lowland * (1.0 - mix) + highland * mix;
+	double build_flats = buildable_flatland_mask(ctx, x, z, mountain_factor);
 
 	double flat_noise = simplex_noise2(&ctx->noise, warp2_x * 0.0015, warp2_z * 0.0015) * 0.5 + 0.5;
 	double flat_bias = (mix < 0.45 ? (0.45 - mix) * 1.6 : 0.0) * flat_noise;
@@ -648,20 +664,44 @@ static int column_height(worldgen_ctx *ctx, int x, int z) {
 	double region_bias = 0.7 + 0.3 * clamp01(region);
 	double plains_detail_quiet = clamp01(1.0 - mix * 1.2);
 	double adjusted_weight = detail_weight * region_bias * (1.0 - plains_detail_quiet * 0.8);
+	adjusted_weight *= 1.0 - build_flats * 0.92;
 	height += simplex_noise2(&ctx->noise, warp2_x * 0.02, warp2_z * 0.02) * 5.0 * adjusted_weight;
 	height += simplex_noise2(&ctx->noise, warp2_x * 0.05, warp2_z * 0.05) * 2.0 * adjusted_weight;
 	height += simplex_noise2(&ctx->noise, warp2_x * 0.1, warp2_z * 0.1) * 1.0 * adjusted_weight;
-	height += simplex_noise3(&ctx->noise, warp2_x * 0.015, warp2_z * 0.015, region * 7.0) * 1.5;
+	height += simplex_noise3(&ctx->noise, warp2_x * 0.015, warp2_z * 0.015, region * 7.0) * 1.5 * (1.0 - build_flats * 0.85);
+	if (build_flats > 0.0) {
+		double campus_target = ctx->sea_level + 4;
+		campus_target += simplex_noise2(&ctx->noise, (x + 51000) * 0.00055, (z - 51000) * 0.00055) * 2.0;
+		campus_target += simplex_noise2(&ctx->noise, (x - 62000) * 0.0014, (z + 62000) * 0.0014) * 0.8;
+		double campus_blend = build_flats * 0.88;
+		height = height * (1.0 - campus_blend) + campus_target * campus_blend;
+	}
 	double flats = clamp01((old_growth - 0.25) / 0.75);
 	if (flats > 0.0) {
 		double plains_target = ctx->sea_level - 2 + simplex_noise2(&ctx->noise, (x - 22000) * 0.002, (z + 22000) * 0.002) * 5.0;
 		plains_target += simplex_noise2(&ctx->noise, (x + 33000) * 0.01, (z - 33000) * 0.01) * 1.5;
-		height = height * (1.0 - flats) + plains_target * flats;
+		double plains_blend = flats * (1.0 - build_flats * 0.55);
+		height = height * (1.0 - plains_blend) + plains_target * plains_blend;
 	}
 
 	return (int)height;
 }
 
+static int column_height(worldgen_ctx *ctx, int x, int z) {
+	uint32_t h = hash_coords(x, z, (uint32_t)ctx->world_seed ^ 0xA53C9E21u);
+	size_t idx = (size_t)(h & (WORLDGEN_HEIGHT_CACHE_SIZE - 1));
+	worldgen_height_cache_entry *entry = &ctx->height_cache[idx];
+	if (entry->valid && entry->x == x && entry->z == z) {
+		return entry->value;
+	}
+	int value = raw_column_height(ctx, x, z);
+	entry->x = x;
+	entry->z = z;
+	entry->value = value;
+	entry->valid = 1;
+	return value;
+}
+
 static column_data get_column_data(worldgen_ctx *ctx, int x, int z) {
 	column_data data;
 	data.height = column_height(ctx, x, z);
@@ -967,14 +1007,19 @@ static int can_place_tree(worldgen_ctx *ctx, int x, int y, int z, int trunk_heig
 	if (ground_block != BLOCK_GRASS && ground_block != BLOCK_SNOW && ground_block != BLOCK_DIRT) return 0;
 	int top = y + trunk_height + crown_extra;
 	if (top >= CHUNK_HEIGHT) return 0;
-	for (int cy = y; cy <= top; ++cy) {
-		for (int dx = -radius; dx <= radius; ++dx) {
-			for (int dz = -radius; dz <= radius; ++dz) {
-				if (cy < y && (dx != 0 || dz != 0)) continue;
-				int block = sample_block(ctx, x + dx, cy, z + dz);
-				if (block != BLOCK_AIR && block != BLOCK_SNOW) {
-					return 0;
+	for (int dx = -radius; dx <= radius; ++dx) {
+		for (int dz = -radius; dz <= radius; ++dz) {
+			column_data data = get_column_data(ctx, x + dx, z + dz);
+			int natural_top = data.height;
+			if (data.has_water && data.water_surface > natural_top) {
+				natural_top = data.water_surface;
+			}
+			if (natural_top >= y && natural_top <= top) {
+				if (natural_top == y && natural_top == data.height &&
+				    select_surface_block(ctx, &data, x + dx, z + dz) == BLOCK_SNOW) {
+					continue;
 				}
+				return 0;
 			}
 		}
 	}
@@ -1039,6 +1084,87 @@ static void place_branch_span(int x, int y, int z, int dx, int dz, int length, i
 	}
 }
 
+static int redwood_axis_log(int log_block, int dx, int dz) {
+	if (log_block == BLOCK_OAK_LOG) {
+		return (abs(dz) > abs(dx)) ? BLOCK_OAK_LOG_Z : BLOCK_OAK_LOG_X;
+	}
+	return log_block;
+}
+
+static void place_redwood_leaf_disc(int cx, int cy, int cz, int radius, int trunk_x, int trunk_z,
+				    int trunk_radius, int leaf_block, rng_state *rng, double hole_prob,
+				    double edge_hole, block_list *out) {
+	if (radius < 1) return;
+	int r2 = radius * radius;
+	for (int dx = -radius; dx <= radius; ++dx) {
+		for (int dz = -radius; dz <= radius; ++dz) {
+			int d2 = dx * dx + dz * dz;
+			if (d2 > r2) continue;
+			int wx = cx + dx;
+			int wz = cz + dz;
+			if (trunk_radius >= 0 && abs(wx - trunk_x) <= trunk_radius && abs(wz - trunk_z) <= trunk_radius) continue;
+			double edge = radius > 0 ? sqrt((double)d2) / (double)radius : 0.0;
+			double skip = hole_prob + edge * edge_hole;
+			if (skip > 0.0 && rng_next_f64(rng) < skip) continue;
+			block_list_push(out, wx, cy, wz, (uint16_t)leaf_block);
+		}
+	}
+}
+
+static void place_redwood_leaf_cluster(int cx, int cy, int cz, int trunk_x, int trunk_z,
+				       int radius, int leaf_block, rng_state *rng, block_list *out) {
+	if (radius < 2) radius = 2;
+	place_redwood_leaf_disc(cx, cy, cz, radius, trunk_x, trunk_z, 1, leaf_block, rng, 0.04, 0.12, out);
+	place_redwood_leaf_disc(cx, cy - 1, cz, radius - 1, trunk_x, trunk_z, 1, leaf_block, rng, 0.08, 0.16, out);
+	place_redwood_leaf_disc(cx, cy + 1, cz, radius - 1, trunk_x, trunk_z, 1, leaf_block, rng, 0.10, 0.18, out);
+	if (radius > 2 && rng_next_f64(rng) < 0.55) {
+		place_redwood_leaf_disc(cx, cy - 2, cz, 1, trunk_x, trunk_z, 1, leaf_block, rng, 0.0, 0.0, out);
+	}
+}
+
+static void place_redwood_branch(int x, int y, int z, int dx, int dz, int length,
+				 int log_block, int leaf_block, rng_state *rng, block_list *out) {
+	if (length < 2) length = 2;
+	int branch_log = redwood_axis_log(log_block, dx, dz);
+	for (int step = 0; step < length; ++step) {
+		int reach = 2 + step;
+		int px = x + dx * reach;
+		int pz = z + dz * reach;
+		int py = y + ((step >= length - 2 && length > 3) ? 1 : 0);
+		if (step >= length - 3) {
+			place_redwood_leaf_cluster(px, py, pz, x, z, step == length - 1 ? 3 : 2, leaf_block, rng, out);
+		} else if ((step & 1) == 1) {
+			place_redwood_leaf_disc(px, py - 1, pz, 2, x, z, 1, leaf_block, rng, 0.18, 0.20, out);
+		}
+	}
+	for (int step = 0; step < length; ++step) {
+		int reach = 2 + step;
+		int px = x + dx * reach;
+		int pz = z + dz * reach;
+		int py = y + ((step >= length - 2 && length > 3) ? 1 : 0);
+		block_list_push(out, px, py, pz, (uint16_t)branch_log);
+	}
+}
+
+static void place_redwood_root(worldgen_ctx *ctx, int x, int y, int z, int dx, int dz,
+			       int length, int log_block, rng_state *rng, block_list *out) {
+	int root_log = redwood_axis_log(log_block, dx, dz);
+	for (int step = 2; step <= length; ++step) {
+		int px = x + dx * step;
+		int pz = z + dz * step;
+		int ground = column_height(ctx, px, pz);
+		if (ground <= 0 || ground >= CHUNK_HEIGHT - 2) continue;
+		if (abs(ground - y) > 3) continue;
+		int py = ground + 1;
+		block_list_push(out, px, py, pz, (uint16_t)root_log);
+		int stack = 4 - step + rng_range_inclusive(rng, 0, 1);
+		if (stack < 0) stack = 0;
+		for (int s = 1; s <= stack; ++s) {
+			block_list_push(out, px, py + s, pz, (uint16_t)log_block);
+		}
+	}
+}
+
 static void clear_snow_block(worldgen_ctx *ctx, int x, int y, int z, block_list *out) {
 	int block = sample_block(ctx, x, y, z);
 	if (block == BLOCK_SNOW) {
@@ -1441,53 +1567,90 @@ static void build_maple_ancient(worldgen_ctx *ctx, int x, int y, int z, int heig
 }
 
 static void build_redwood_titan(worldgen_ctx *ctx, int x, int y, int z, int height, rng_state *rng, block_list *out, const tree_archetype *arch) {
-	(void)ctx;
-	int core_height = height + rng_range_inclusive(rng, 2, 7);
-	if (core_height < 30) core_height = 30;
-	if (core_height > 44) core_height = 44;
-	if (y + core_height + 10 >= CHUNK_HEIGHT) {
-		core_height = CHUNK_HEIGHT - y - 10;
-		if (core_height < 24) core_height = 24;
+	int core_height = height + rng_range_inclusive(rng, 3, 8);
+	if (core_height < 32) core_height = 32;
+	if (core_height > 46) core_height = 46;
+	if (y + core_height + 9 >= CHUNK_HEIGHT) {
+		core_height = CHUNK_HEIGHT - y - 9;
+		if (core_height < 26) core_height = 26;
 	}
-	int taper_start = core_height - 6;
+
+	const int dirs8[8][2] = {
+		{1, 0}, {-1, 0}, {0, 1}, {0, -1},
+		{1, 1}, {1, -1}, {-1, 1}, {-1, -1}
+	};
+	int spire = 3 + rng_range_inclusive(rng, 0, 2);
+	int crown_start = y + core_height / 2 + rng_range_inclusive(rng, 0, 2);
+
+	for (int cy = crown_start; cy <= y + core_height + 2; cy += 2) {
+		int below_top = y + core_height + 2 - cy;
+		int radius = 2 + below_top / 9;
+		if (radius > 4) radius = 4;
+		if (cy > y + core_height - 4) radius = 2;
+		place_redwood_leaf_disc(x, cy, z, radius, x, z, 1, arch->leaf_block, rng, 0.08, 0.16, out);
+		if (radius > 2) {
+			place_redwood_leaf_disc(x, cy - 1, z, radius - 1, x, z, 1, arch->leaf_block, rng, 0.12, 0.20, out);
+		}
+	}
+
+	int whorls = 7 + rng_range_inclusive(rng, 0, 2);
+	for (int w = 0; w < whorls; ++w) {
+		int wy = crown_start + w * 3 + rng_range_inclusive(rng, -1, 1);
+		if (wy > y + core_height - 2) break;
+		int branch_count = 3 + rng_range_inclusive(rng, 0, 2);
+		if (w >= whorls - 2) branch_count += 1;
+		int base_len = 6 - w / 2 + rng_range_inclusive(rng, 0, 1);
+		if (base_len < 3) base_len = 3;
+		if (base_len > 6) base_len = 6;
+		int start_dir = rng_range_inclusive(rng, 0, 7);
+		for (int b = 0; b < branch_count; ++b) {
+			int idx = (start_dir + b * 2 + rng_range_inclusive(rng, 0, 1)) & 7;
+			int branch_len = base_len - rng_range_inclusive(rng, 0, 1);
+			place_redwood_branch(x, wy, z, dirs8[idx][0], dirs8[idx][1], branch_len,
+					     arch->log_block, arch->leaf_block, rng, out);
+		}
+	}
+
+	for (int t = 0; t < 4; ++t) {
+		int py = y + core_height - 2 + t * 2;
+		int radius = (t < 2) ? 2 : 1;
+		place_redwood_leaf_disc(x, py, z, radius, x, z, 0, arch->leaf_block, rng, 0.04, 0.10, out);
+	}
+
+	int dead_nubs = 5 + rng_range_inclusive(rng, 0, 3);
+	for (int n = 0; n < dead_nubs; ++n) {
+		int idx = rng_range_inclusive(rng, 0, 7);
+		int nub_y = y + core_height / 4 + rng_range_inclusive(rng, 0, core_height / 3);
+		int nub_len = 2 + rng_range_inclusive(rng, 0, 1);
+		int branch_log = redwood_axis_log(arch->log_block, dirs8[idx][0], dirs8[idx][1]);
+		for (int step = 2; step <= nub_len + 1; ++step) {
+			block_list_push(out, x + dirs8[idx][0] * step, nub_y, z + dirs8[idx][1] * step, (uint16_t)branch_log);
+		}
+	}
+
+	int taper_start = core_height - 7;
 	for (int dy = 0; dy < core_height; ++dy) {
 		int radius = (dy >= taper_start) ? 0 : 1;
 		for (int dx = -radius; dx <= radius; ++dx) {
 			for (int dz = -radius; dz <= radius; ++dz) {
+				if (radius == 1 && abs(dx) == 1 && abs(dz) == 1 && dy > 12 && dy < taper_start - 2) {
+					int corner_seed = (dy + (dx > 0 ? 2 : 0) + (dz > 0 ? 5 : 0)) % 7;
+					if (corner_seed == 0 || corner_seed == 3) continue;
+				}
 				block_list_push(out, x + dx, y + dy, z + dz, (uint16_t)arch->log_block);
 			}
 		}
-	}
-	int spire = 3 + rng_range_inclusive(rng, 0, 2);
-	place_log_column(x, y + core_height, z, spire, arch->log_block, out);
-	int canopy_base = y + core_height - 6;
-	for (int ring = 0; ring < 4; ++ring) {
-		int radius = 4 - ring;
-		if (radius < 2) radius = 2;
-		place_leaf_circle(x, canopy_base + ring, z, radius, arch->leaf_block, rng, 0.1, out);
-		place_leaf_circle(x, canopy_base + ring + 1, z, radius - 1, arch->leaf_block, rng, 0.18, out);
-	}
-	place_leaf_circle(x, canopy_base + 5, z, 2, arch->leaf_block, rng, 0.0, out);
-	place_leaf_circle(x, canopy_base + 6, z, 1, arch->leaf_block, rng, 0.0, out);
-	const int dirs[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
-	for (int i = 0; i < 4; ++i) {
-		int buttress_height = 3 + rng_range_inclusive(rng, 0, 2);
-		for (int step = 0; step < 2; ++step) {
-			int px = x + dirs[i][0] * (2 + step);
-			int pz = z + dirs[i][1] * (2 + step);
-			int stack = buttress_height - step;
-			if (stack < 1) stack = 1;
-			for (int s = 0; s < stack; ++s) {
-				block_list_push(out, px, y + s, pz, (uint16_t)arch->log_block);
-			}
+		if (dy < taper_start - 4 && dy > 2 && (dy % 5) == 0) {
+			int rib = (dy / 5 + rng_range_inclusive(rng, 0, 3)) & 3;
+			block_list_push(out, x + dirs8[rib][0] * 2, y + dy, z + dirs8[rib][1] * 2, (uint16_t)arch->log_block);
 		}
 	}
-	for (int i = 0; i < 4; ++i) {
-		int branch_y = canopy_base - 3 - rng_range_inclusive(rng, 0, 3);
-		int branch_len = 3 + rng_range_inclusive(rng, 0, 2);
-		place_branch_span(x, branch_y, z, dirs[i][0], dirs[i][1], branch_len, 2, arch->log_block, arch->leaf_block, rng, out);
+	place_log_column(x, y + core_height, z, spire, arch->log_block, out);
+
+	for (int i = 0; i < 8; ++i) {
+		int root_len = 3 + rng_range_inclusive(rng, 0, (i < 4) ? 2 : 1);
+		place_redwood_root(ctx, x, y, z, dirs8[i][0], dirs8[i][1], root_len, arch->log_block, rng, out);
 	}
-	place_leaf_blob(x, canopy_base - 2, z, 4, 3, arch->leaf_block, rng, out);
 }
 
 	typedef enum {
@@ -1536,7 +1699,7 @@ static void build_redwood_titan(worldgen_ctx *ctx, int x, int y, int z, int heig
 	[TREE_OAK_ANCIENT] = {"oak_ancient", TREE_SPECIES_OAK, BLOCK_OAK_LOG, BLOCK_OAK_LEAVES, 12, 16, 6, 7, build_oak_ancient},
 	[TREE_SPRUCE_ANCIENT] = {"spruce_ancient", TREE_SPECIES_SPRUCE, BLOCK_OAK_LOG, BLOCK_OAK_LEAVES, 12, 16, 5, 7, build_spruce_ancient},
 	[TREE_MAPLE_ANCIENT] = {"maple_ancient", TREE_SPECIES_MAPLE, BLOCK_OAK_LOG, BLOCK_OAK_LEAVES, 11, 15, 6, 6, build_maple_ancient},
-	[TREE_REDWOOD_TITAN] = {"redwood_titan", TREE_SPECIES_PINE, BLOCK_OAK_LOG, BLOCK_OAK_LEAVES, 28, 38, 4, 10, build_redwood_titan},
+	[TREE_REDWOOD_TITAN] = {"redwood_titan", TREE_SPECIES_PINE, BLOCK_OAK_LOG, BLOCK_OAK_LEAVES, 28, 38, 5, 11, build_redwood_titan},
 	};
 
 static const int TREE_VARIANTS_OAK[] = {TREE_OAK_ROUND, TREE_OAK_SPRAWL, TREE_OAK_COLUMNAR, TREE_OAK_ANCIENT};
@@ -3391,6 +3554,190 @@ static void generate_chunk_trails(worldgen_ctx *ctx, int chunk_x, int chunk_z, c
 	}
 }
 
+static void generate_chunk_border_wall(worldgen_ctx *ctx, int chunk_x, int chunk_z, chunk_data *out) {
+	if (!ctx->enable_wall) return;
+	if (ctx->wall_min_x > ctx->wall_max_x || ctx->wall_min_z > ctx->wall_max_z) return;
+
+	const int exterior_apron = 5;
+	const int wall_depth = 7;
+	const int wall_start = exterior_apron;
+	const int wall_end = wall_start + wall_depth - 1;
+	const int wall_center = wall_start + wall_depth / 2;
+	const int wall_height = 18;
+	const int tower_outer = 1;
+	const int tower_inner = wall_end + 5;
+	const int tower_depth = 9;
+	const int tower_height = 28;
+	const int tower_spacing = 32;
+	const int tower_half_width = 4;
+	const int ladder_spacing = 96;
+	for (int dx = 0; dx < CHUNK_SIZE; ++dx) {
+		for (int dz = 0; dz < CHUNK_SIZE; ++dz) {
+			int world_x = chunk_x * CHUNK_SIZE + dx;
+			int world_z = chunk_z * CHUNK_SIZE + dz;
+			if (world_x < ctx->wall_min_x || world_x > ctx->wall_max_x) continue;
+			if (world_z < ctx->wall_min_z || world_z > ctx->wall_max_z) continue;
+
+			int dist_min_x = world_x - ctx->wall_min_x;
+			int dist_max_x = ctx->wall_max_x - world_x;
+			int dist_min_z = world_z - ctx->wall_min_z;
+			int dist_max_z = ctx->wall_max_z - world_z;
+			int side_dist = dist_min_x;
+			int along = world_z;
+			int side = 0;
+			if (dist_max_x < side_dist) {
+				side_dist = dist_max_x;
+				along = world_z;
+				side = 1;
+			}
+			if (dist_min_z < side_dist) {
+				side_dist = dist_min_z;
+				along = world_x;
+				side = 2;
+			}
+			if (dist_max_z < side_dist) {
+				side_dist = dist_max_z;
+				along = world_x;
+				side = 3;
+			}
+
+			int phase = along % tower_spacing;
+			if (phase < 0) phase += tower_spacing;
+			int tower_offset = phase;
+			if (tower_offset > tower_spacing / 2) tower_offset = tower_spacing - tower_offset;
+			int ladder_phase = along % ladder_spacing;
+			if (ladder_phase < 0) ladder_phase += ladder_spacing;
+			int ladder_offset = ladder_phase - ladder_spacing / 2;
+			if (ladder_offset < 0) ladder_offset = -ladder_offset;
+			int near_corner = (dist_min_x < tower_depth || dist_max_x < tower_depth) &&
+			                  (dist_min_z < tower_depth || dist_max_z < tower_depth);
+			int ladder_module = !near_corner && ladder_offset <= 1;
+			int ladder_face = !near_corner && ladder_offset == 0 && side_dist == wall_end + 1;
+			int ladder_trim = ladder_module && side_dist == wall_end + 1 && ladder_offset == 1;
+			int in_tower = side_dist >= tower_outer && side_dist <= tower_inner &&
+			               (tower_offset <= tower_half_width || near_corner);
+			int in_wall = (side_dist >= wall_start && side_dist <= wall_end) || in_tower || ladder_face || ladder_trim;
+			int in_exterior_apron = side_dist < wall_start && !in_wall;
+			if (!in_wall && !in_exterior_apron) continue;
+
+			column_data data = get_column_data(ctx, world_x, world_z);
+			int visible_base = data.height;
+			if (data.has_water && data.water_surface > visible_base) {
+				visible_base = data.water_surface;
+			}
+			if (visible_base >= CHUNK_HEIGHT - 1) continue;
+
+			if (in_exterior_apron) {
+				for (int y = data.height + 1; y < CHUNK_HEIGHT; ++y) {
+					out->blocks[y][dx][dz] = BLOCK_AIR;
+				}
+				out->heightmap[dx][dz] = (uint16_t)data.height;
+				uint32_t rubble_hash = hash_coords(world_x, world_z, (uint32_t)(ctx->world_seed ^ 0x4A7C9B2Du));
+				if (side_dist >= wall_start - 3 && (rubble_hash % 5) != 0) {
+					uint16_t rubble = (rubble_hash % 3 == 0) ? BLOCK_GRAVEL : ((rubble_hash % 3 == 1) ? BLOCK_STONE : BLOCK_STONE_BRICKS);
+					set_block_with_height(out, dx, dz, visible_base + 1, rubble);
+					if (side_dist == wall_start - 1 && rubble_hash % 7 == 0) {
+						set_block_with_height(out, dx, dz, visible_base + 2, BLOCK_STONE);
+					}
+				}
+				continue;
+			}
+
+			int center_x = world_x;
+			int center_z = world_z;
+			switch (side) {
+				case 0: center_x = ctx->wall_min_x + wall_center; break;
+				case 1: center_x = ctx->wall_max_x - wall_center; break;
+				case 2: center_z = ctx->wall_min_z + wall_center; break;
+				case 3: center_z = ctx->wall_max_z - wall_center; break;
+			}
+			int smoothed_base = 0;
+			int weight_sum = 0;
+			const int sample_offsets[5] = {-32, -16, 0, 16, 32};
+			const int sample_weights[5] = {1, 2, 4, 2, 1};
+			for (int i = 0; i < 5; ++i) {
+				int sx = center_x;
+				int sz = center_z;
+				if (side < 2) {
+					sz += sample_offsets[i];
+				} else {
+					sx += sample_offsets[i];
+				}
+				if (sx < ctx->wall_min_x) sx = ctx->wall_min_x;
+				if (sx > ctx->wall_max_x) sx = ctx->wall_max_x;
+				if (sz < ctx->wall_min_z) sz = ctx->wall_min_z;
+				if (sz > ctx->wall_max_z) sz = ctx->wall_max_z;
+				column_data sample = get_column_data(ctx, sx, sz);
+				int sample_base = sample.height;
+				if (sample.has_water && sample.water_surface > sample_base) sample_base = sample.water_surface;
+				smoothed_base += sample_base * sample_weights[i];
+				weight_sum += sample_weights[i];
+			}
+			smoothed_base /= weight_sum;
+			if (visible_base > smoothed_base + 8) {
+				smoothed_base += (visible_base - smoothed_base - 8 + 3) / 4;
+			} else if (visible_base < smoothed_base - 16) {
+				smoothed_base -= (smoothed_base - visible_base - 16 + 4) / 5;
+			}
+			if (smoothed_base < 1) smoothed_base = 1;
+			if (smoothed_base > CHUNK_HEIGHT - 2) smoothed_base = CHUNK_HEIGHT - 2;
+
+			int height = in_tower ? tower_height : wall_height;
+			int top = smoothed_base + height;
+			if (top >= CHUNK_HEIGHT) top = CHUNK_HEIGHT - 1;
+			uint16_t ladder_block = BLOCK_LADDER_E;
+			if (side == 1) ladder_block = BLOCK_LADDER_W;
+			if (side == 2) ladder_block = BLOCK_LADDER_S;
+			if (side == 3) ladder_block = BLOCK_LADDER_N;
+
+			for (int y = data.height + 1; y < CHUNK_HEIGHT; ++y) {
+				out->blocks[y][dx][dz] = BLOCK_AIR;
+			}
+			out->heightmap[dx][dz] = (uint16_t)data.height;
+
+			int start = data.height - 4;
+			if (smoothed_base - 4 < start) start = smoothed_base - 4;
+			if (start < 1) start = 1;
+			for (int y = start; y <= top; ++y) {
+				int rel_y = y - smoothed_base;
+				uint16_t block = BLOCK_SMOOTH_STONE;
+				int in_center_corridor = side_dist >= wall_center - 1 && side_dist <= wall_center + 1 &&
+				                         rel_y >= 2 && rel_y <= 4;
+				if (in_center_corridor) {
+					continue;
+				}
+				if (rel_y < 0) {
+					block = (rel_y == -1 || rel_y == -4) ? BLOCK_STONE_BRICKS : BLOCK_STONE;
+				}
+				if (rel_y <= 2 || rel_y % 6 == 0 || rel_y == height - 1) {
+					block = BLOCK_STONE_BRICKS;
+				}
+				if (side_dist >= wall_center - 1 && side_dist <= wall_center + 1 && rel_y == height) {
+					block = BLOCK_STONE_BRICKS;
+				}
+				if (ladder_face && rel_y >= 2 && rel_y <= height - 1) {
+					block = ladder_block;
+				} else if (ladder_trim && rel_y >= 2 && rel_y <= height - 1 && rel_y % 3 != 1) {
+					block = (rel_y % 6 == 0) ? BLOCK_BLACKSTONE : BLOCK_STONE_BRICKS;
+				}
+				if (in_tower && side_dist == tower_outer && rel_y >= 9 && rel_y <= 17 &&
+				    (tower_offset == 0 || (rel_y == 13 && tower_offset <= 3))) {
+					block = BLOCK_BLACKSTONE;
+				} else if (in_tower && side_dist == tower_outer + 1 && tower_offset == 0 && rel_y >= 4 && rel_y <= 7) {
+					block = BLOCK_IRON_BARS;
+				} else if (!in_tower && side_dist == wall_start && rel_y >= 7 && rel_y <= 10 && phase % 16 == 8) {
+					block = BLOCK_IRON_BARS;
+				}
+				set_block_with_height(out, dx, dz, y, block);
+			}
+			if (top + 1 < CHUNK_HEIGHT && (side_dist == wall_start || side_dist == wall_end || in_tower) &&
+			    phase % 4 < 2) {
+				set_block_with_height(out, dx, dz, top + 1, BLOCK_STONE_BRICKS);
+			}
+		}
+	}
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -3399,12 +3746,16 @@ void worldgen_init(worldgen_ctx *ctx, int world_seed, int sea_level, int snow_li
 	ctx->sea_level = sea_level;
 	ctx->snow_line = snow_line;
 	ctx->enable_trails = 0;
+	ctx->enable_wall = 0;
+	ctx->wall_min_x = ctx->wall_max_x = 0;
+	ctx->wall_min_z = ctx->wall_max_z = 0;
 	ctx->trail_segments = NULL;
 	ctx->trail_segment_count = 0;
 	ctx->trail_segment_cap = 0;
 	ctx->prepass_done = 0;
 	ctx->prepass_min_x = ctx->prepass_max_x = 0;
 	ctx->prepass_min_z = ctx->prepass_max_z = 0;
+	memset(ctx->height_cache, 0, sizeof(ctx->height_cache));
 	simplex_init(&ctx->noise, (uint32_t)world_seed);
 }
 
@@ -3412,6 +3763,13 @@ void worldgen_generate_chunk(worldgen_ctx *ctx, int chunk_x, int chunk_z, chunk_
 	memset(out, 0, sizeof(*out));
 	out->chunk_x = chunk_x;
 	out->chunk_z = chunk_z;
+	for (int y = 0; y < CHUNK_HEIGHT; ++y) {
+		for (int dx = 0; dx < CHUNK_SIZE; ++dx) {
+			for (int dz = 0; dz < CHUNK_SIZE; ++dz) {
+				out->blocks[y][dx][dz] = BLOCK_AIR;
+			}
+		}
+	}
 
 	ensure_trail_prepass(ctx, chunk_x, chunk_z);
 
@@ -3430,28 +3788,31 @@ void worldgen_generate_chunk(worldgen_ctx *ctx, int chunk_x, int chunk_z, chunk_
 	for (int dx = 0; dx < CHUNK_SIZE; ++dx) {
 		for (int dz = 0; dz < CHUNK_SIZE; ++dz) {
 			column_data cd = columns[dx][dz];
-            int world_x = chunk_x * CHUNK_SIZE + dx;
-            int world_z = chunk_z * CHUNK_SIZE + dz;
-            for (int y = 0; y < CHUNK_HEIGHT; ++y) {
-				int id;
-				if (y == 0) {
-					id = BLOCK_BEDROCK;
-				} else if (y < cd.height - 3) {
-					if (generate_coal(ctx, world_x, y, world_z, cd.height, cd.biome)) {
-						id = BLOCK_COAL;
-					} else {
-						id = (int)generate_normal_ores(ctx, world_x, y, world_z, &cd);
-					}
-				} else if (y < cd.height) {
-					id = BLOCK_DIRT;
-				} else if (y == cd.height) {
-					id = select_surface_block(ctx, &cd, world_x, world_z);
-				} else if (cd.has_water && y <= cd.water_surface && y > cd.height) {
-					id = BLOCK_WATER;
+			int world_x = chunk_x * CHUNK_SIZE + dx;
+			int world_z = chunk_z * CHUNK_SIZE + dz;
+			out->blocks[0][dx][dz] = BLOCK_BEDROCK;
+			int stone_top = cd.height - 3;
+			if (stone_top > CHUNK_HEIGHT) stone_top = CHUNK_HEIGHT;
+			for (int y = 1; y < stone_top; ++y) {
+				if (generate_coal(ctx, world_x, y, world_z, cd.height, cd.biome)) {
+					out->blocks[y][dx][dz] = BLOCK_COAL;
 				} else {
-					id = BLOCK_AIR;
+					out->blocks[y][dx][dz] = generate_normal_ores(ctx, world_x, y, world_z, &cd);
+				}
+			}
+			int dirt_start = stone_top > 1 ? stone_top : 1;
+			for (int y = dirt_start; y < cd.height && y < CHUNK_HEIGHT; ++y) {
+				out->blocks[y][dx][dz] = BLOCK_DIRT;
+			}
+			if (cd.height >= 0 && cd.height < CHUNK_HEIGHT) {
+				out->blocks[cd.height][dx][dz] = select_surface_block(ctx, &cd, world_x, world_z);
+			}
+			if (cd.has_water) {
+				int water_top = cd.water_surface;
+				if (water_top >= CHUNK_HEIGHT) water_top = CHUNK_HEIGHT - 1;
+				for (int y = cd.height + 1; y <= water_top; ++y) {
+					if (y > 0) out->blocks[y][dx][dz] = BLOCK_WATER;
 				}
-				out->blocks[y][dx][dz] = (uint16_t)id;
 			}
 		}
 	}
@@ -3477,4 +3838,6 @@ void worldgen_generate_chunk(worldgen_ctx *ctx, int chunk_x, int chunk_z, chunk_
 		}
 	}
 	block_list_free(&trees);
+
+	generate_chunk_border_wall(ctx, chunk_x, chunk_z, out);
 }