Stop panic when blueprint doesn't exist for biome (#2195)

I just have it returning null if it can't find the blueprint and
printing an error in the log.
It should work the same as if the id was not found.
Fixes #1898
Fixes #1932

Author: BoySanic

src/server/terrain/biomes.zig

@@ -20,7 +20,7 @@ pub const SimpleStructureModel = struct { // MARK: SimpleStructureModel
 		water_surface,
 	};
 	const VTable = struct {
-		loadModel: *const fn(arena: NeverFailingAllocator, parameters: ZonElement) *anyopaque,
+		loadModel: *const fn(arena: NeverFailingAllocator, parameters: ZonElement) ?*anyopaque,
 		generate: *const fn(self: *anyopaque, generationMode: GenerationMode, x: i32, y: i32, z: i32, chunk: *ServerChunk, caveMap: terrain.CaveMap.CaveMapView, biomeMap: terrain.CaveBiomeMap.CaveBiomeMapView, seed: *u64, isCeiling: bool) void,
 		hashFunction: *const fn(self: *anyopaque) u64,
 		generationMode: GenerationMode,
@@ -38,9 +38,13 @@ pub const SimpleStructureModel = struct { // MARK: SimpleStructureModel
 			std.log.err("Couldn't find structure model with id {s}", .{id});
 			return null;
 		};
+		const vtableModel = vtable.loadModel(arenaAllocator.allocator(), parameters) orelse {
+			std.log.err("Error occurred while loading structure with id '{s}'. Dropping model from biome.", .{id});
+			return null;
+		};
 		return SimpleStructureModel{
 			.vtable = vtable,
-			.data = vtable.loadModel(arenaAllocator.allocator(), parameters),
+			.data = vtableModel,
 			.chance = parameters.get(f32, "chance", 0.1),
 			.priority = parameters.get(f32, "priority", 1),
 			.generationMode = std.meta.stringToEnum(GenerationMode, parameters.get([]const u8, "generationMode", "")) orelse vtable.generationMode,
@@ -60,7 +64,7 @@ pub const SimpleStructureModel = struct { // MARK: SimpleStructureModel
 
 	pub fn registerGenerator(comptime Generator: type) void {
 		var self: VTable = undefined;
-		self.loadModel = main.utils.castFunctionReturnToAnyopaque(Generator.loadModel);
+		self.loadModel = main.utils.castFunctionReturnToOptionalAnyopaque(Generator.loadModel);
 		self.generate = main.utils.castFunctionSelfToAnyopaque(Generator.generate);
 		self.hashFunction = main.utils.castFunctionSelfToAnyopaque(struct {
 			fn hash(ptr: *Generator) u64 {

src/server/terrain/simple_structures/Boulder.zig

@@ -23,7 +23,7 @@ block: main.blocks.Block,
 size: f32,
 sizeVariation: f32,
 
-pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) *Boulder {
+pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) ?*Boulder {
 	const self = arena.create(Boulder);
 	self.* = .{
 		.block = main.blocks.parseBlock(parameters.get([]const u8, "block", "cubyz:slate")),

src/server/terrain/simple_structures/FallenTree.zig

@@ -24,7 +24,7 @@ topWoodBlock: u16,
 height0: u32,
 deltaHeight: u31,
 
-pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) *FallenTree {
+pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) ?*FallenTree {
 	const self = arena.create(FallenTree);
 	self.* = .{
 		.woodBlock = main.blocks.getTypeById(parameters.get([]const u8, "log", "cubyz:oak_log")),

src/server/terrain/simple_structures/FlowerPatch.zig

@@ -24,7 +24,7 @@ width: f32,
 variation: f32,
 density: f32,
 
-pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) *FlowerPatch {
+pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) ?*FlowerPatch {
 	const self = arena.create(FlowerPatch);
 	self.* = .{
 		.block = main.blocks.parseBlock(parameters.get([]const u8, "block", "")),

src/server/terrain/simple_structures/GroundPatch.zig

@@ -25,7 +25,7 @@ variation: f32,
 depth: i32,
 smoothness: f32,
 
-pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) *GroundPatch {
+pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) ?*GroundPatch {
 	const self = arena.create(GroundPatch);
 	self.* = .{
 		.block = main.blocks.parseBlock(parameters.get([]const u8, "block", "")),

src/server/terrain/simple_structures/SbbGen.zig

@@ -26,12 +26,14 @@ pub fn getHash(self: SbbGen) u64 {
 	return std.hash.Wyhash.hash(@intFromEnum(self.placeMode), self.structureRef.id);
 }
 
-pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) *SbbGen {
+pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) ?*SbbGen {
 	const structureId = parameters.get(?[]const u8, "structure", null) orelse {
-		main.utils.panicWithMessage("Error loading generator 'cubyz:sbb' structure field is mandatory.", .{});
+		std.log.err("Error loading generator 'cubyz:sbb' structure field is mandatory.", .{});
+		return null;
 	};
 	const structureRef = sbb.getByStringId(structureId) orelse {
-		main.utils.panicWithMessage("Could not find structure building block with id '{s}'", .{structureId});
+		std.log.err("Could not find blueprint with id {s}. Structure will not be added.", .{structureId});
+		return null;
 	};
 	const rotationParam = parameters.getChild("rotation");
 	const rotation = sbb.Rotation.fromZon(rotationParam) catch |err| blk: {

src/server/terrain/simple_structures/SimpleTreeModel.zig

@@ -36,7 +36,7 @@ leafElongation: f32,
 deltaLeafElongation: f32,
 branched: bool,
 
-pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) *SimpleTreeModel {
+pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) ?*SimpleTreeModel {
 	const self = arena.create(SimpleTreeModel);
 	self.* = .{
 		.typ = std.meta.stringToEnum(Type, parameters.get([]const u8, "type", "")) orelse blk: {

src/server/terrain/simple_structures/SimpleVegetation.zig

@@ -23,7 +23,7 @@ block: main.blocks.Block,
 height0: u31,
 deltaHeight: u31,
 
-pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) *SimpleVegetation {
+pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) ?*SimpleVegetation {
 	const self = arena.create(SimpleVegetation);
 	self.* = .{
 		.block = main.blocks.parseBlock(parameters.get([]const u8, "block", "")),

src/server/terrain/simple_structures/Stalagmite.zig

@@ -23,7 +23,7 @@ block: main.blocks.Block,
 size: f32,
 sizeVariation: f32,
 
-pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) *Stalagmite {
+pub fn loadModel(arena: NeverFailingAllocator, parameters: ZonElement) ?*Stalagmite {
 	const self = arena.create(Stalagmite);
 	self.* = .{
 		.block = main.blocks.parseBlock(parameters.get([]const u8, "block", "cubyz:stalagmite")),

src/server/terrain/structure_building_blocks.zig

@@ -345,26 +345,25 @@ pub fn registerSBB(structures: *Assets.ZonHashMap) !void {
 	std.debug.assert(structureList.items.len == 0);
 	std.debug.assert(structureMap.capacity() == 0);
 
-	structureList.resize(arenaAllocator, structures.count());
+	structureList.ensureCapacity(arenaAllocator, structures.count());
 	structureMap.ensureTotalCapacity(arenaAllocator.allocator, structures.count()) catch unreachable;
 
 	childrenToResolve = .init(main.stackAllocator);
 	defer childrenToResolve.deinit();
 	{
 		var iterator = structures.iterator();
-		var index: u32 = 0;
+		var loadedCount: u32 = 0;
 		while(iterator.next()) |entry| {
-			defer index += 1;
-
-			structureList.items[index] = StructureBuildingBlock.initFromZon(entry.key_ptr.*, entry.value_ptr.*) catch |err| {
+			structureList.appendAssumeCapacity(StructureBuildingBlock.initFromZon(entry.key_ptr.*, entry.value_ptr.*) catch |err| {
 				std.log.err("Could not register structure building block '{s}' ({s})", .{entry.key_ptr.*, @errorName(err)});
 				continue;
-			};
+			});
 
 			const key = arenaAllocator.dupe(u8, entry.key_ptr.*);
-			structureMap.put(arenaAllocator.allocator, key, @enumFromInt(index)) catch unreachable;
+			structureMap.put(arenaAllocator.allocator, key, @enumFromInt(loadedCount)) catch unreachable;
 
 			std.log.debug("Registered structure building block: '{s}'", .{entry.key_ptr.*});
+			loadedCount += 1;
 		}
 	}
 	{