Saplings and Seeds

assets/cubyz/blocks/leaves/_defaults.zig.zon

@@ -4,11 +4,13 @@
 		.prevention = .{.log, .branch},
 		.drops = .{
 			.{.chance = 0.01, .items = .{"cubyz:apple"}},
+			.{.chance = 0.001, .items = .{"cubyz:sapling/oak"}},
 		},
 	},
 	.drops = .{
 		.{.items = .{.auto}, .allowedToolTags = .{.cuttable}},
 		.{.chance = 0.01, .items = .{"cubyz:apple"}, .forbiddenToolTags = .{.cuttable}},
+		.{.chance = 0.001, .items = .{"cubyz:sapling/oak"}, .forbiddenToolTags = .{.cuttable}},
 	},
 	.rotation = "cubyz:decayable",
 	.tags = .{.cuttable, .leaf},

assets/cubyz/blocks/sapling/cactus.zig.zon

@@ -0,0 +1,33 @@
+.{
+	.tags = .{.cuttable},
+	.blockHealth = 0.2,
+	.drops = .{
+		.{.items = .{.auto}},
+	},
+	.onTick = .{.type = .sapling, .sbb = .{
+		.structure = "cubyz:cactus/saguaro",
+		.placeMode = .degradable,
+		.chance = 0.01,
+	}},
+	.degradable = true,
+	.collide = false,
+	.alwaysViewThrough = true,
+	.absorbedLight = 0x121012,
+	.model = "cubyz:cactus_flower",
+	.rotation = "cubyz:direction",
+	.texture = "cubyz:cactus_flower",
+	.texture_top = "cubyz:cactus_flower_top",
+	.texture_bottom = "cubyz:cactus_flower_top",
+	.item = .{
+		.texture = "cactus_flower.png",
+	},
+	.lodReplacement = "cubyz:air",
+	.onTouch = .{
+		.type = .hurt,
+		.dps = 0.2,
+		.damageType = .spiky,
+	},
+	.onUpdate = .{
+		.type = .checkSupportBlocks,
+	},
+}

assets/cubyz/blocks/sapling/oak.zig.zon

@@ -0,0 +1,36 @@
+.{
+	.tags = .{.cuttable},
+	.blockHealth = 0.2,
+	.drops = .{
+		.{.items = .{.auto}},
+	},
+	.onTick = .{
+		.type = .sapling,
+		.sbb = .{
+			.structure = "cubyz:tree/oak/white",
+			.placeMode = .degradable,
+			.chance = 0.03,
+		},
+	},
+	.degradable = true,
+	.collide = false,
+	.alwaysViewThrough = true,
+	.absorbedLight = 0x121012,
+	.model = "cubyz:cactus_flower",
+	.rotation = "cubyz:direction",
+	.texture = "cubyz:cactus_flower",
+	.texture_top = "cubyz:cactus_flower_top",
+	.texture_bottom = "cubyz:cactus_flower_top",
+	.item = .{
+		.texture = "cactus_flower.png",
+	},
+	.lodReplacement = "cubyz:air",
+	.onTouch = .{
+		.type = .hurt,
+		.dps = 0.2,
+		.damageType = .spiky,
+	},
+	.onUpdate = .{
+		.type = .checkSupportBlocks,
+	},
+}

src/assets.zig

@@ -773,6 +773,8 @@ pub fn loadWorldAssets(assetFolder: []const u8, blockPalette: *Palette, itemPale
 		}
 	}
 
+	blocks.finishBlockCallbacks(worldAssets.blocks);
+
 	worldAssets.log(.world);
 }
 

src/blocks.zig

@@ -337,11 +337,16 @@ pub fn finishBlocks(zonElements: Assets.ZonHashMap) void {
 		registerBlockDrop(i, zonElements.get(_id[i]) orelse continue);
 		registerLodReplacement(i, zonElements.get(_id[i]) orelse continue);
 		registerOpaqueVariant(i, zonElements.get(_id[i]) orelse continue);
-		registerCallbacks(i, zonElements.get(_id[i]) orelse continue);
 	}
 	blueprint.registerVoidBlock(parseBlock("cubyz:void"));
 	meshes.finishTextureLoading();
 }
+pub fn finishBlockCallbacks(zonElements: Assets.ZonHashMap) void {
+	var i: u16 = 0;
+	while (i < size) : (i += 1) {
+		registerCallbacks(i, zonElements.get(_id[i]) orelse continue);
+	}
+}
 
 pub fn reset() void {
 	size = 0;

src/blueprint.zig

@@ -166,6 +166,7 @@ pub const Blueprint = struct {
 
 	pub const PasteFlags = struct {
 		preserveVoid: bool = false,
+		replaceUndegradable: bool = true,
 	};
 
 	pub fn paste(self: Blueprint, pos: Vec3i, flags: PasteFlags) void {
@@ -183,8 +184,15 @@ pub const Blueprint = struct {
 					const worldZ = startZ +% @as(i32, @intCast(z));
 
 					const block = self.blocks.get(x, y, z);
-					if (block.typ != voidType or flags.preserveVoid) {
-						_ = main.server.world.?.updateBlock(worldX, worldY, worldZ, block);
+					if (block.typ == voidType and !flags.preserveVoid) continue;
+
+					while (true) {
+						const oldBlock = main.server.world.?.getBlock(@intCast(worldX), @intCast(worldY), @intCast(worldZ));
+						if (oldBlock) |_oldBlock| {
+							if (!_oldBlock.degradable() and !flags.replaceUndegradable) break;
+						}
+						if (main.server.world.?.cmpxchgBlock(worldX, worldY, worldZ, oldBlock, block, true) == null)
+							break;
 					}
 				}
 			}

src/callbacks/block/server/_list.zig

@@ -2,3 +2,4 @@ pub const check_support_blocks = @import("check_support_blocks.zig");
 pub const decay = @import("decay.zig");
 pub const vine_decay = @import("vine_decay.zig");
 pub const replace_block = @import("replace_block.zig");
+pub const sapling = @import("sapling.zig");

src/callbacks/block/server/check_support_blocks.zig

@@ -42,7 +42,7 @@ pub fn run(_: *@This(), params: main.callbacks.ServerBlockCallback.Params) main.
 
 	if (newBlock == params.block) return .ignored;
 
-	if (main.server.world.?.cmpxchgBlock(wx, wy, wz, params.block, newBlock) == null) {
+	if (main.server.world.?.cmpxchgBlock(wx, wy, wz, params.block, newBlock, false) == null) {
 		const dropAmount = params.block.mode().itemDropsOnChange(params.block, newBlock);
 		const drops = params.block.blockDrops();
 		for (0..dropAmount) |_| {

src/callbacks/block/server/decay.zig

@@ -133,7 +133,7 @@ pub fn run(self: *@This(), params: main.callbacks.ServerBlockCallback.Params) ma
 			if (self.foundWayToLog(world, leaf, wx, wy, wz)) return .ignored;
 
 			// no, there is no log in proximity
-			if (world.cmpxchgBlock(wx, wy, wz, leaf, self.decayReplacement) == null) {
+			if (world.cmpxchgBlock(wx, wy, wz, leaf, self.decayReplacement, false) == null) {
 				for (self.blockDrops) |drop| {
 					if (drop.chance == 1 or main.random.nextFloat(&main.seed) < drop.chance) {
 						for (drop.items) |stack| {

src/callbacks/block/server/replace_block.zig

@@ -20,6 +20,6 @@ pub fn run(self: *@This(), params: main.callbacks.ServerBlockCallback.Params) ma
 	const wy = params.chunk.super.pos.wy + params.blockPos.y;
 	const wz = params.chunk.super.pos.wz + params.blockPos.z;
 
-	_ = main.server.world.?.cmpxchgBlock(wx, wy, wz, params.block, self.block);
+	_ = main.server.world.?.cmpxchgBlock(wx, wy, wz, params.block, self.block, false);
 	return .handled;
 }

src/callbacks/block/server/sapling.zig

@@ -0,0 +1,32 @@
+const std = @import("std");
+
+const main = @import("main");
+const Vec3i = main.vec.Vec3i;
+const sbbGen = main.server.terrain.structures.simple_structures.SbbGen;
+const SimpleStructureModel = main.server.terrain.biomes.SimpleStructureModel;
+
+sbb: *sbbGen.SbbGen,
+chance: f32,
+
+pub fn init(zon: main.ZonElement, _: main.callbacks.Creator) ?*@This() {
+	const result = main.worldArena.create(@This());
+
+	const vtableModel = sbbGen.loadModel(zon.getChild("sbb")) orelse {
+		std.log.err("Error occurred while loading structure for saplings", .{});
+		return null;
+	};
+	result.sbb = vtableModel;
+	result.chance = zon.get(f32, "chance", 0.1);
+	return result;
+}
+
+pub fn run(self: *@This(), params: main.callbacks.ServerBlockCallback.Params) main.callbacks.Result {
+
+	// copied from SimpleStructureGen.generate.
+	const randomValue = main.random.nextFloat(&main.seed);
+	if (randomValue < self.chance) {
+		self.sbb.placeSbb(self.sbb.structureRef, Vec3i{params.blockPos.x, params.blockPos.y, params.blockPos.z}, null, self.sbb.rotation.getInitialRotation(&main.seed), params.chunk, &main.seed, false);
+	}
+
+	return .handled;
+}

src/callbacks/block/server/vine_decay.zig

@@ -35,6 +35,6 @@ pub fn run(_: *@This(), params: main.callbacks.ServerBlockCallback.Params) main.
 }
 
 fn decay(x: i32, y: i32, z: i32, current: Block) main.callbacks.Result {
-	if (server.world.?.cmpxchgBlock(x, y, z, current, blocks.Block.air) == null) return .handled;
+	if (server.world.?.cmpxchgBlock(x, y, z, current, blocks.Block.air, false) == null) return .handled;
 	return .ignored;
 }

src/server/terrain/simple_structures/SbbGen.zig

@@ -16,7 +16,7 @@ const NeverFailingAllocator = main.heap.NeverFailingAllocator;
 pub const id = "cubyz:sbb";
 pub const generationMode = .floor;
 
-const SbbGen = @This();
+pub const SbbGen = @This();
 
 structureRef: *const sbb.StructureBuildingBlock,
 placeMode: Blueprint.PasteMode,
@@ -53,10 +53,10 @@ pub fn loadModel(parameters: ZonElement) ?*SbbGen {
 }
 
 pub fn generate(self: *SbbGen, _: GenerationMode, x: i32, y: i32, z: i32, chunk: *ServerChunk, _: CaveMapView, _: CaveBiomeMapView, seed: *u64, _: bool) void {
-	placeSbb(self, self.structureRef, Vec3i{x, y, z}, null, self.rotation.getInitialRotation(seed), chunk, seed);
+	placeSbb(self, self.structureRef, Vec3i{x, y, z}, null, self.rotation.getInitialRotation(seed), chunk, seed, true);
 }
 
-fn placeSbb(self: *SbbGen, structure: *const sbb.StructureBuildingBlock, placementPosition: Vec3i, placementDirection: ?Neighbor, rotation: sbb.Rotation, chunk: *ServerChunk, seed: *u64) void {
+pub fn placeSbb(self: *SbbGen, structure: *const sbb.StructureBuildingBlock, placementPosition: Vec3i, placementDirection: ?Neighbor, rotation: sbb.Rotation, chunk: *ServerChunk, seed: *u64, comptime duringWorldGeneration: bool) void {
 	const blueprints = &(structure.getBlueprints(seed).* orelse return);
 
 	const origin = blueprints[0].originBlock;
@@ -68,12 +68,20 @@ fn placeSbb(self: *SbbGen, structure: *const sbb.StructureBuildingBlock, placeme
 	const rotatedOrigin = rotated.originBlock.pos();
 	const pastePosition = placementPosition - rotatedOrigin - (placementDirection orelse origin.direction()).relPos();
 
-	rotated.blueprint.pasteInGeneration(pastePosition, chunk, self.placeMode);
+	if (duringWorldGeneration) {
+		rotated.blueprint.pasteInGeneration(pastePosition, chunk, self.placeMode);
+	} else {
+		var pos = Vec3i{0, 0, 0};
+		pos[0] = chunk.super.pos.wx + pastePosition[0];
+		pos[1] = chunk.super.pos.wy + pastePosition[1];
+		pos[2] = chunk.super.pos.wz + pastePosition[2];
 
+		rotated.blueprint.paste(pos, .{.replaceUndegradable = false});
+	}
 	for (rotated.childBlocks) |childBlock| {
 		const child = structure.getChildStructure(childBlock) orelse continue;
 		const childRotation = blueprintRotation.getChildRotation(seed, child.rotation, childBlock.direction());
-		placeSbb(self, child, pastePosition + childBlock.pos(), childBlock.direction(), childRotation, chunk, seed);
+		placeSbb(self, child, pastePosition + childBlock.pos(), childBlock.direction(), childRotation, chunk, seed, duringWorldGeneration);
 	}
 }
 

src/server/world.zig

@@ -1231,7 +1231,7 @@ pub const ServerWorld = struct { // MARK: ServerWorld
 	}
 
 	/// Returns the actual block on failure
-	pub fn cmpxchgBlock(self: *ServerWorld, wx: i32, wy: i32, wz: i32, oldBlock: ?Block, _newBlock: Block) ?Block {
+	pub fn cmpxchgBlock(self: *ServerWorld, wx: i32, wy: i32, wz: i32, oldBlock: ?Block, _newBlock: Block, comptime noUpdate: bool) ?Block {
 		main.sync.threadContext.assertCorrectContext(.server);
 		const baseChunk = ChunkManager.getOrGenerateChunkAndIncreaseRefCount(.{.wx = wx & ~@as(i32, chunk.chunkMask), .wy = wy & ~@as(i32, chunk.chunkMask), .wz = wz & ~@as(i32, chunk.chunkMask), .voxelSize = 1});
 		defer baseChunk.decreaseRefCount();
@@ -1291,6 +1291,7 @@ pub const ServerWorld = struct { // MARK: ServerWorld
 		for (userList) |user| {
 			main.network.protocols.blockUpdate.send(user.conn, &.{.{.pos = .{wx, wy, wz}, .newBlock = newBlock, .blockEntityData = &.{}}});
 		}
+
 		// onBreak event
 		if (oldBlock) |block| {
 			if (block.typ != newBlock.typ) {
@@ -1301,7 +1302,9 @@ pub const ServerWorld = struct { // MARK: ServerWorld
 				});
 			}
 		}
-		self.triggerNeighborBlockUpdates(wx, wy, wz);
+		if (!noUpdate) {
+			self.triggerNeighborBlockUpdates(wx, wy, wz);
+		}
 
 		return null;
 	}
@@ -1324,8 +1327,8 @@ pub const ServerWorld = struct { // MARK: ServerWorld
 		}
 	}
 
-	pub fn updateBlock(self: *ServerWorld, wx: i32, wy: i32, wz: i32, newBlock: Block) void {
-		_ = self.cmpxchgBlock(wx, wy, wz, null, newBlock);
+	pub fn updateBlock(self: *ServerWorld, wx: i32, wy: i32, wz: i32, newBlock: Block, comptime noUpdate: bool) void {
+		_ = self.cmpxchgBlock(wx, wy, wz, null, newBlock, noUpdate);
 	}
 
 	pub fn queueChunkUpdateAndDecreaseRefCount(self: *ServerWorld, ch: *ServerChunk) void {

src/sync.zig

@@ -1612,7 +1612,7 @@ pub const Command = struct { // MARK: Command
 			}
 
 			if (ctx.side == .server) {
-				if (main.server.world.?.cmpxchgBlock(self.pos[0], self.pos[1], self.pos[2], self.oldBlock, self.newBlock) != null) {
+				if (main.server.world.?.cmpxchgBlock(self.pos[0], self.pos[1], self.pos[2], self.oldBlock, self.newBlock, false) != null) {
 					// Inform the client of the actual block:
 					var writer = BinaryWriter.init(main.stackAllocator);
 					defer writer.deinit();