Merge testing into compatibility

A user claimed that this texture was a texture from Minecraft 1.8.9 –
see <MineClone2/MineClone2#2099> for
further details. I have not verified that but I noticed that in commit
152e55245804bd2b4790ee31454986948237d2a8 the file was replaced with a
file containing the exact same pixels.

A visual inspection confirms that the file contains noise, so it is not
clear if it is even copyrightable. However, to ensure that it could not
be identical to a file from Minecraft, To get noise of the same quality,
I have shuffled all its pixels with the following POSIX sh shell script:

LANG=C
PREFIX=mcl_end_crystal_beam
convert $PREFIX.png $PREFIX.pnm
<$PREFIX.pnm  >$PREFIX.plainpnm pnmtoplainpnm
<$PREFIX.plainpnm >$PREFIX.seed tr '1234567890 ' ' 1356902468'
(
 <$PREFIX.plainpnm head -n+3
 <$PREFIX.plainpnm tail -n+4 \
  |tr ' ' '\n' \
  |shuf --random-source $PREFIX.seed
) >$PREFIX.shuffled.plainpnm

I then opened mcl_end_crystal_beam.shuffled.plainpnm using GIMP,
converted the color black to tranparency and saved the image as a
paletted PNG (which yields a smaller filesize than a grayscale PNG).

mods/CORE/mcl_compatibility/init.lua

@@ -0,0 +1,100 @@
+mcl_compatibility = mcl_compatibility or {}
+mcl_vars = mcl_vars or {}
+
+local modname = minetest.get_current_modname()
+local modpath = minetest.get_modpath(modname)
+
+if not bit then
+	bit = {}
+	function bit.bxor(a, b)
+		-- fake! mock! speedify for now! TODO: make proper xor bitwise
+		return math.ceil(math.abs(math.floor(a/0.14) * b * 1.001 + b))
+	end
+end
+
+function math.round(x)
+	if x >= 0 then
+		return math.floor(x + 0.5)
+	end
+	return math.ceil(x - 0.5)
+end
+
+dofile(modpath .. "/vector.lua")
+
+local minetest_get_node = minetest.get_node
+
+mcl_compatibility.sort_nodes = function(nodes)
+	if not nodes then return {} end
+	for _, pos in pairs(nodes) do
+		if not pos.x or not pos.y or not pos.z then
+			return nodes
+		end
+	end
+	local new_nodes = {}
+	for _, pos in pairs(nodes) do
+		local node = minetest_get_node(pos)
+		local name = node.name
+		if not new_nodes[name] then
+			new_nodes[name] = { pos }
+		else
+			table.insert(new_nodes[name], pos)
+		end
+	end
+	return new_nodes
+end
+
+local minetest_find_nodes_in_area = minetest.find_nodes_in_area
+minetest.find_nodes_in_area = function(pos1, pos2, nodenames, grouped)
+	local nodes, num = minetest_find_nodes_in_area(pos1, pos2, nodenames, grouped)
+	if not grouped or not nodes or next(nodes) == nil then
+		return nodes, num
+	end
+	return mcl_compatibility.sort_nodes(nodes)
+end
+
+function mcl_vars.pos_to_block(pos)
+	return mcl_mapgen and mcl_mapgen.pos_to_block(pos)
+end
+
+function mcl_vars.pos_to_chunk(pos)
+	return mcl_mapgen and mcl_mapgen.pos_to_chunk(pos)
+end
+
+function mcl_vars.get_chunk_number(pos)
+	return mcl_mapgen and get_chunk_number(pos)
+end
+
+function mcl_vars.is_generated(pos)
+	local node = minetest.get_node(pos)
+	if not node then return false end
+	if node.name == "ignore" then return false end
+	return true
+end
+
+function mcl_vars.get_node(p, force, us_timeout)
+	if not p or not p.x or not p.y or not p.z then return {name="error"} end
+	local node = minetest.get_node(p)
+	if node.name ~= "ignore" then return node end
+	minetest.get_voxel_manip():read_from_map(p, p)
+	return minetest.get_node(pos)
+end
+
+mcl_vars.mg_overworld_min = -62
+mcl_vars.mg_overworld_max_official = 198
+mcl_vars.mg_bedrock_overworld_min = -62
+mcl_vars.mg_bedrock_overworld_max = -58
+mcl_vars.mg_lava_overworld_max = -52
+mcl_vars.mg_lava = true
+mcl_vars.mg_bedrock_is_rough = true
+mcl_vars.mg_overworld_max = 30927
+mcl_vars.mg_nether_min = -29067
+mcl_vars.mg_nether_max = -28939
+mcl_vars.mg_bedrock_nether_bottom_min = -29067
+mcl_vars.mg_bedrock_nether_top_max = -29063
+mcl_vars.mg_end_min = -27073
+mcl_vars.mg_end_max_official = -26817
+mcl_vars.mg_end_max = -2062
+mcl_vars.mg_end_platform_pos = { x = 100, y = -26999, z = 0 }
+mcl_vars.mg_realm_barrier_overworld_end_max = -2062
+mcl_vars.mg_realm_barrier_overworld_end_min = -2073
+mcl_vars.mg_dungeons = true

mods/CORE/mcl_compatibility/mod.conf

@@ -0,0 +1,3 @@
+name = mcl_compatibility
+author = kay27, minetest devs
+description = Makes MineClone 5 run in old versions of Minetest and be compatible with mods using old MineClone APIs

mods/CORE/mcl_compatibility/vector.lua

@@ -0,0 +1,362 @@
+--[[
+Vector helpers
+Note: The vector.*-functions must be able to accept old vectors that had no metatables
+]]
+
+-- localize functions
+local setmetatable = setmetatable
+
+vector = {}
+
+local metatable = {}
+vector.metatable = metatable
+
+local xyz = {"x", "y", "z"}
+
+-- only called when rawget(v, key) returns nil
+function metatable.__index(v, key)
+	return rawget(v, xyz[key]) or vector[key]
+end
+
+-- only called when rawget(v, key) returns nil
+function metatable.__newindex(v, key, value)
+	rawset(v, xyz[key] or key, value)
+end
+
+-- constructors
+
+local function fast_new(x, y, z)
+	return setmetatable({x = x, y = y, z = z}, metatable)
+end
+
+function vector.new(a, b, c)
+	if a and b and c then
+		return fast_new(a, b, c)
+	end
+
+	-- deprecated, use vector.copy and vector.zero directly
+	if type(a) == "table" then
+		return vector.copy(a)
+	else
+		assert(not a, "Invalid arguments for vector.new()")
+		return vector.zero()
+	end
+end
+
+function vector.zero()
+	return fast_new(0, 0, 0)
+end
+
+function vector.copy(v)
+	assert(v.x and v.y and v.z, "Invalid vector passed to vector.copy()")
+	return fast_new(v.x, v.y, v.z)
+end
+
+function vector.from_string(s, init)
+	local x, y, z, np = string.match(s, "^%s*%(%s*([^%s,]+)%s*[,%s]%s*([^%s,]+)%s*[,%s]" ..
+			"%s*([^%s,]+)%s*[,%s]?%s*%)()", init)
+	x = tonumber(x)
+	y = tonumber(y)
+	z = tonumber(z)
+	if not (x and y and z) then
+		return nil
+	end
+	return fast_new(x, y, z), np
+end
+
+function vector.to_string(v)
+	return string.format("(%g, %g, %g)", v.x, v.y, v.z)
+end
+metatable.__tostring = vector.to_string
+
+function vector.equals(a, b)
+	return a.x == b.x and
+	       a.y == b.y and
+	       a.z == b.z
+end
+metatable.__eq = vector.equals
+
+-- unary operations
+
+function vector.length(v)
+	return math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z)
+end
+-- Note: we can not use __len because it is already used for primitive table length
+
+function vector.normalize(v)
+	local len = vector.length(v)
+	if len == 0 then
+		return fast_new(0, 0, 0)
+	else
+		return vector.divide(v, len)
+	end
+end
+
+function vector.floor(v)
+	return vector.apply(v, math.floor)
+end
+
+function vector.round(v)
+	return fast_new(
+		math.round(v.x),
+		math.round(v.y),
+		math.round(v.z)
+	)
+end
+
+function vector.apply(v, func)
+	return fast_new(
+		func(v.x),
+		func(v.y),
+		func(v.z)
+	)
+end
+
+function vector.distance(a, b)
+	local x = a.x - b.x
+	local y = a.y - b.y
+	local z = a.z - b.z
+	return math.sqrt(x * x + y * y + z * z)
+end
+
+function vector.direction(pos1, pos2)
+	return vector.subtract(pos2, pos1):normalize()
+end
+
+function vector.angle(a, b)
+	local dotp = vector.dot(a, b)
+	local cp = vector.cross(a, b)
+	local crossplen = vector.length(cp)
+	return math.atan2(crossplen, dotp)
+end
+
+function vector.dot(a, b)
+	return a.x * b.x + a.y * b.y + a.z * b.z
+end
+
+function vector.cross(a, b)
+	return fast_new(
+		a.y * b.z - a.z * b.y,
+		a.z * b.x - a.x * b.z,
+		a.x * b.y - a.y * b.x
+	)
+end
+
+function metatable.__unm(v)
+	return fast_new(-v.x, -v.y, -v.z)
+end
+
+-- add, sub, mul, div operations
+
+function vector.add(a, b)
+	if type(b) == "table" then
+		return fast_new(
+			a.x + b.x,
+			a.y + b.y,
+			a.z + b.z
+		)
+	else
+		return fast_new(
+			a.x + b,
+			a.y + b,
+			a.z + b
+		)
+	end
+end
+function metatable.__add(a, b)
+	return fast_new(
+		a.x + b.x,
+		a.y + b.y,
+		a.z + b.z
+	)
+end
+
+function vector.subtract(a, b)
+	if type(b) == "table" then
+		return fast_new(
+			a.x - b.x,
+			a.y - b.y,
+			a.z - b.z
+		)
+	else
+		return fast_new(
+			a.x - b,
+			a.y - b,
+			a.z - b
+		)
+	end
+end
+function metatable.__sub(a, b)
+	return fast_new(
+		a.x - b.x,
+		a.y - b.y,
+		a.z - b.z
+	)
+end
+
+function vector.multiply(a, b)
+	if type(b) == "table" then
+		return fast_new(
+			a.x * b.x,
+			a.y * b.y,
+			a.z * b.z
+		)
+	else
+		return fast_new(
+			a.x * b,
+			a.y * b,
+			a.z * b
+		)
+	end
+end
+function metatable.__mul(a, b)
+	if type(a) == "table" then
+		return fast_new(
+			a.x * b,
+			a.y * b,
+			a.z * b
+		)
+	else
+		return fast_new(
+			a * b.x,
+			a * b.y,
+			a * b.z
+		)
+	end
+end
+
+function vector.divide(a, b)
+	if type(b) == "table" then
+		return fast_new(
+			a.x / b.x,
+			a.y / b.y,
+			a.z / b.z
+		)
+	else
+		return fast_new(
+			a.x / b,
+			a.y / b,
+			a.z / b
+		)
+	end
+end
+function metatable.__div(a, b)
+	-- scalar/vector makes no sense
+	return fast_new(
+		a.x / b,
+		a.y / b,
+		a.z / b
+	)
+end
+
+-- misc stuff
+
+function vector.offset(v, x, y, z)
+	return fast_new(
+		v.x + x,
+		v.y + y,
+		v.z + z
+	)
+end
+
+function vector.sort(a, b)
+	return fast_new(math.min(a.x, b.x), math.min(a.y, b.y), math.min(a.z, b.z)),
+		fast_new(math.max(a.x, b.x), math.max(a.y, b.y), math.max(a.z, b.z))
+end
+
+function vector.check(v)
+	return getmetatable(v) == metatable
+end
+
+local function sin(x)
+	if x % math.pi == 0 then
+		return 0
+	else
+		return math.sin(x)
+	end
+end
+
+local function cos(x)
+	if x % math.pi == math.pi / 2 then
+		return 0
+	else
+		return math.cos(x)
+	end
+end
+
+function vector.rotate_around_axis(v, axis, angle)
+	local cosangle = cos(angle)
+	local sinangle = sin(angle)
+	axis = vector.normalize(axis)
+	-- https://en.wikipedia.org/wiki/Rodrigues%27_rotation_formula
+	local dot_axis = vector.multiply(axis, vector.dot(axis, v))
+	local cross = vector.cross(v, axis)
+	return vector.new(
+		cross.x * sinangle + (v.x - dot_axis.x) * cosangle + dot_axis.x,
+		cross.y * sinangle + (v.y - dot_axis.y) * cosangle + dot_axis.y,
+		cross.z * sinangle + (v.z - dot_axis.z) * cosangle + dot_axis.z
+	)
+end
+
+function vector.rotate(v, rot)
+	local sinpitch = sin(-rot.x)
+	local sinyaw = sin(-rot.y)
+	local sinroll = sin(-rot.z)
+	local cospitch = cos(rot.x)
+	local cosyaw = cos(rot.y)
+	local cosroll = math.cos(rot.z)
+	-- Rotation matrix that applies yaw, pitch and roll
+	local matrix = {
+		{
+			sinyaw * sinpitch * sinroll + cosyaw * cosroll,
+			sinyaw * sinpitch * cosroll - cosyaw * sinroll,
+			sinyaw * cospitch,
+		},
+		{
+			cospitch * sinroll,
+			cospitch * cosroll,
+			-sinpitch,
+		},
+		{
+			cosyaw * sinpitch * sinroll - sinyaw * cosroll,
+			cosyaw * sinpitch * cosroll + sinyaw * sinroll,
+			cosyaw * cospitch,
+		},
+	}
+	-- Compute matrix multiplication: `matrix` * `v`
+	return vector.new(
+		matrix[1][1] * v.x + matrix[1][2] * v.y + matrix[1][3] * v.z,
+		matrix[2][1] * v.x + matrix[2][2] * v.y + matrix[2][3] * v.z,
+		matrix[3][1] * v.x + matrix[3][2] * v.y + matrix[3][3] * v.z
+	)
+end
+
+function vector.dir_to_rotation(forward, up)
+	forward = vector.normalize(forward)
+	local rot = vector.new(math.asin(forward.y), -math.atan2(forward.x, forward.z), 0)
+	if not up then
+		return rot
+	end
+	assert(vector.dot(forward, up) < 0.000001,
+			"Invalid vectors passed to vector.dir_to_rotation().")
+	up = vector.normalize(up)
+	-- Calculate vector pointing up with roll = 0, just based on forward vector.
+	local forwup = vector.rotate(vector.new(0, 1, 0), rot)
+	-- 'forwup' and 'up' are now in a plane with 'forward' as normal.
+	-- The angle between them is the absolute of the roll value we're looking for.
+	rot.z = vector.angle(forwup, up)
+
+	-- Since vector.angle never returns a negative value or a value greater
+	-- than math.pi, rot.z has to be inverted sometimes.
+	-- To determine wether this is the case, we rotate the up vector back around
+	-- the forward vector and check if it worked out.
+	local back = vector.rotate_around_axis(up, forward, -rot.z)
+
+	-- We don't use vector.equals for this because of floating point imprecision.
+	if (back.x - forwup.x) * (back.x - forwup.x) +
+			(back.y - forwup.y) * (back.y - forwup.y) +
+			(back.z - forwup.z) * (back.z - forwup.z) > 0.0000001 then
+		rot.z = -rot.z
+	end
+	return rot
+end

mods/CORE/mcl_init/compatibility.lua

@@ -0,0 +1 @@
+-- moved to mcl_compatibility

mods/CORE/mcl_init/init.lua

@@ -1,5 +1,5 @@
 -- Some global variables (don't overwrite them!)
-mcl_vars = {}
+mcl_vars = mcl_vars or {}
 
 mcl_vars.redstone_tick = 0.1
 

mods/CORE/mcl_init/mod.conf

@@ -1,3 +1,4 @@
 name = mcl_init
+depends = mcl_compatibility
 author = Wuzzy
 description = Initialization mod of MineClone 2. Defines some common shared variables and sets up initial default settings which have to be set at the beginning.

mods/CORE/mcl_mapgen/init.lua

@@ -325,7 +325,7 @@ minetest.register_on_generated(function(minp, maxp, chunkseed)
 		--  mcl_mapgen.register_mapgen_lvm(function(vm_context), order_number)    --
 		--                                                                        --
 		for _, v in pairs(queue_chunks_lvm) do
-			vm_context = v.f(vm_context)
+			v.f(vm_context)
 		end
 		--                                                                                         --
 		--  mcl_mapgen.register_mapgen(function(minp, maxp, chunkseed, vm_context), order_number)  --

mods/CORE/mcl_time/init.lua

@@ -148,6 +148,7 @@ function mcl_time.get_irl_seconds_passed_at_pos_or_nil(pos)
 	if last_time <= 0 then return end
 	local delta_time = seconds_irl_public - last_time
 	if delta_time <= 0 then return end
+	meta:set_int(meta_name, seconds_irl_public)
 	return delta_time
 end
 

mods/CORE/mcl_worlds/init.lua

@@ -152,3 +152,23 @@ minetest.register_globalstep(function(dtime)
 		dimtimer = 0
 	end
 end)
+
+function mcl_worlds.get_cloud_parameters()
+	if mcl_mapgen.name == "valleys" then
+		return {
+			height = 384,
+			speed = {x=-2, z=0},
+			thickness=5,
+			color="#FFF0FEF",
+			ambient = "#201060",
+		}
+	else
+		-- MC-style clouds: Layer 127, thickness 4, fly to the “West”
+		return {
+			height = mcl_worlds.layer_to_y(127),
+			speed = {x=-2, z=0},
+			thickness = 4,
+			color = "#FFF0FEF",
+		}
+	end
+end

mods/ENTITIES/mcl_burning/api.lua

@@ -11,6 +11,7 @@ function mcl_burning.is_affected_by_rain(obj)
 end
 
 function mcl_burning.get_collisionbox(obj, smaller, storage)
+	if not storage then return end
 	local cache = storage.collisionbox_cache
 	if cache then
 		local box = cache[smaller and 2 or 1]
@@ -29,6 +30,7 @@ end
 function mcl_burning.get_touching_nodes(obj, nodenames, storage)
 	local pos = obj:get_pos()
 	local minp, maxp = mcl_burning.get_collisionbox(obj, true, storage)
+	if not minp or not maxp then return {} end
 	local nodes = minetest.find_nodes_in_area(vector.add(pos, minp), vector.add(pos, maxp), nodenames)
 	return nodes
 end

mods/ENTITIES/mcl_item_entity/init.lua

@@ -115,7 +115,9 @@ minetest.register_globalstep(function(dtime)
 
 			local pos = player:get_pos()
 
-			if tick == true and pool[name] > 0 then
+			local pool_name = pool[name]
+
+			if tick == true and pool_name and pool_name > 0 then
 				minetest.sound_play("item_drop_pickup", {
 					pos = pos,
 					gain = 0.7,

mods/ENTITIES/mcl_mobs/api/api.lua

@@ -402,6 +402,7 @@ function mobs:register_mob(name, def)
 		ignited_by_sunlight = def.ignited_by_sunlight or false,
 		eye_height = def.eye_height or 1.5,
 		defuse_reach = def.defuse_reach or 4,
+		spawn = def.spawn,
 		-- End of MCL2 extensions
 
 		on_spawn = def.on_spawn,

mods/ENTITIES/mcl_mobs/api/mob_functions/attack_type_instructions.lua

@@ -173,9 +173,15 @@ mobs.punch_attack = function(self)
 
     dir = vector_multiply(dir,3)
 
-    if self.attacking:get_velocity().y <= 1 then
-        dir.y = 5
-    end
+	local attacking = self.attacking
+	if attacking then
+		local attacking_velocity = attacking:get_velocity() or attacking:get_player_velocity()
+		if attacking_velocity then
+			if attacking_velocity.y <= 1 then
+				dir.y = 5
+			end
+		end
+	end
 
     self.attacking:add_velocity(dir)
 end

mods/ENTITIES/mcl_mobs/api/mob_functions/death_logic.lua

@@ -99,7 +99,8 @@ mobs.death_logic = function(self, dtime)
     self.death_animation_timer = self.death_animation_timer + dtime
 
 	--get all attached entities and sort through them
-	local attached_entities = self.object:get_children()
+	-- TODO: support 5.1.1
+	local attached_entities = self.object.get_children and self.object:get_children() or {}
 	if #attached_entities > 0 then
 		for _,entity in pairs(attached_entities) do
 			--kick the player off

mods/ENTITIES/mcl_mobs/api/mob_functions/interaction.lua

@@ -185,7 +185,8 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
 
 	--if player is falling multiply damage by 1.5
 	--critical hit
-	if hitter:get_velocity().y < 0 then
+	local hitter_velocity = hitter:get_velocity() or hitter:get_player_velocity() or vector.new(0, 0, 0)
+	if hitter_velocity.y < 0 then
 		damage = damage * 1.5
 		mobs.critical_effect(self)
 	end
@@ -207,7 +208,9 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
 		self.pause_timer = 0.4
 
 		--don't do knockback from a rider
-		for _,obj in pairs(self.object:get_children()) do
+		local object_children = self.object.get_children and self.object:get_children()
+		-- TODO: support 5.1.1
+		for _,obj in pairs(object_children or {}) do
 			if obj == hitter then
 				return
 			end

mods/ENTITIES/mcl_mobs/api/spawning.lua

@@ -267,6 +267,8 @@ function mobs:spawn_setup(def)
 	local day_toggle       = def.day_toggle
 	local on_spawn         = def.on_spawn
 	local check_position   = def.check_position
+	local group_size_min   = def.group_size_min or 1
+	local group_size_max   = def.group_size_max or 1
 
 	-- chance/spawn number override in minetest.conf for registered mob
 	local numbers = minetest.settings:get(name)
@@ -300,10 +302,23 @@ function mobs:spawn_setup(def)
 		day_toggle       = day_toggle,
 		check_position   = check_position,
 		on_spawn         = on_spawn,
+		group_size_min   = group_size_min,
+		group_size_max   = group_size_max,
 	}
 	summary_chance = summary_chance + chance
 end
 
+function mobs.spawn_mob(name, pos)
+	local def = minetest.registered_entities[name]
+	if not def then return end
+	if def.spawn then
+		return def.spawn(pos)
+	end
+	return minetest.add_entity(pos, name)
+end
+
+local spawn_mob = mobs.spawn_mob
+
 function mobs:spawn_specific(name, dimension, type_of_spawning, biomes, min_light, max_light, interval, chance, aoc, min_height, max_height, day_toggle, on_spawn)
 
 	-- Do mobs spawn at all?
@@ -341,6 +356,8 @@ function mobs:spawn_specific(name, dimension, type_of_spawning, biomes, min_ligh
 	spawn_dictionary[key]["min_height"] = min_height
 	spawn_dictionary[key]["max_height"] = max_height
 	spawn_dictionary[key]["day_toggle"] = day_toggle
+	spawn_dictionary[key]["group_size_min"] = 1
+	spawn_dictionary[key]["group_size_max"] = 3
 
 	summary_chance = summary_chance + chance
 end
@@ -442,9 +459,9 @@ if mobs_spawn then
 				and (mob_def.check_position and mob_def.check_position(spawning_position) or true)
 				then
 					--everything is correct, spawn mob
-					local object = minetest.add_entity(spawning_position, mob_def.name)
+					local object = spawn_mob(mob_def.name, spawning_position)
 					if object then
-						return mob_def.on_spawn and mob_def.on_spawn(object, pos)
+						return mob_def.on_spawn and mob_def.on_spawn(object, spawning_position)
 					end
 			end
 			current_summary_chance = current_summary_chance - mob_chance

mods/ENTITIES/mobs_mc/rabbit.lua

@@ -2,118 +2,27 @@
 
 local S = minetest.get_translator(minetest.get_current_modname())
 
-local rabbit = {
-	description = S("Rabbit"),
-	type = "animal",
-	spawn_class = "passive",
-	passive = true,
-	reach = 1,
-	rotate = 270,
-	hp_min = 3,
-	hp_max = 3,
-	xp_min = 1,
-	xp_max = 3,
-	collisionbox = {-0.2, -0.01, -0.2, 0.2, 0.49, 0.2},
+local mob_name = "mobs_mc:rabbit"
 
-	visual = "mesh",
-	mesh = "mobs_mc_rabbit.b3d",
-	textures = {
+local textures = {
         {"mobs_mc_rabbit_brown.png"},
         {"mobs_mc_rabbit_gold.png"},
         {"mobs_mc_rabbit_white.png"},
         {"mobs_mc_rabbit_white_splotched.png"},
         {"mobs_mc_rabbit_salt.png"},
         {"mobs_mc_rabbit_black.png"},
-	},
-	visual_size = {x=1.5, y=1.5},
-	sounds = {
-		random = "mobs_mc_rabbit_random",
-		damage = "mobs_mc_rabbit_hurt",
-		death = "mobs_mc_rabbit_death",
-		attack = "mobs_mc_rabbit_attack",
-		eat = "mobs_mc_animal_eat_generic",
-		distance = 16,
-	},
-	makes_footstep_sound = false,
-	walk_velocity = 1,
-	run_velocity = 3.7,
-	follow_velocity = 1.1,
-	floats = 1,
-	runaway = true,
-	jump = true,
-	drops = {
-		{name = mobs_mc.items.rabbit_raw, chance = 1, min = 0, max = 1, looting = "common",},
-		{name = mobs_mc.items.rabbit_hide, chance = 1, min = 0, max = 1, looting = "common",},
-		{name = mobs_mc.items.rabbit_foot, chance = 10, min = 0, max = 1, looting = "rare", looting_factor = 0.03,},
-	},
-	fear_height = 4,
-	animation = {
-		speed_normal = 25,		speed_run = 50,
-		stand_start = 0,		stand_end = 0,
-		walk_start = 0,		walk_end = 20,
-		run_start = 0,		run_end = 20,
-	},
-	-- Follow (yellow) dangelions, carrots and golden carrots
-	follow = mobs_mc.follow.rabbit,
-	view_range = 8,
-	-- Eat carrots and reduce their growth stage by 1
-	replace_rate = 10,
-	replace_what = mobs_mc.replace.rabbit,
-	on_rightclick = function(self, clicker)
-		-- Feed, tame protect or capture
-		if mobs:feed_tame(self, clicker, 1, true, true) then return end
-	end,
-	do_custom = function(self)
-		-- Easter egg: Change texture if rabbit is named “Toast”
-		if self.nametag == "Toast" and not self._has_toast_texture then
-			self._original_rabbit_texture = self.base_texture
-			self.base_texture = { "mobs_mc_rabbit_toast.png" }
-			self.object:set_properties({ textures = self.base_texture })
-			self._has_toast_texture = true
-		elseif self.nametag ~= "Toast" and self._has_toast_texture then
-			self.base_texture = self._original_rabbit_texture
-			self.object:set_properties({ textures = self.base_texture })
-			self._has_toast_texture = false
-		end
-	end,
 }
 
-mobs:register_mob("mobs_mc:rabbit", rabbit)
+local sounds = {
+	random = "mobs_mc_rabbit_random",
+	damage = "mobs_mc_rabbit_hurt",
+	death = "mobs_mc_rabbit_death",
+	attack = "mobs_mc_rabbit_attack",
+	eat = "mobs_mc_animal_eat_generic",
+	distance = 16,
+}
 
--- The killer bunny (Only with spawn egg)
-local killer_bunny = table.copy(rabbit)
-killer_bunny.description = S("Killer Bunny")
-killer_bunny.type = "monster"
-killer_bunny.spawn_class = "hostile"
-killer_bunny.attack_type = "dogfight"
-killer_bunny.specific_attack = { "player", "mobs_mc:wolf", "mobs_mc:dog" }
-killer_bunny.damage = 8
-killer_bunny.passive = false
--- 8 armor points
-killer_bunny.armor = 50
-killer_bunny.textures = { "mobs_mc_rabbit_caerbannog.png" }
-killer_bunny.view_range = 16
-killer_bunny.replace_rate = nil
-killer_bunny.replace_what = nil
-killer_bunny.on_rightclick = nil
-killer_bunny.run_velocity = 6
-killer_bunny.do_custom = function(self)
-	if not self._killer_bunny_nametag_set then
-		self.nametag = S("The Killer Bunny")
-		self._killer_bunny_nametag_set = true
-	end
-end
-
-mobs:register_mob("mobs_mc:killer_bunny", killer_bunny)
-
--- Mob spawning rules.
--- Different skins depending on spawn location <- we'll get to this when the spawning algorithm is fleshed out
-
-mobs:spawn_specific(
-"mobs_mc:rabbit",
-"overworld",
-"ground",
-{
+local biome_list = {
 	"FlowerForest_beach",
 	"Forest_beach",
 	"StoneBeach",
@@ -161,73 +70,149 @@ mobs:spawn_specific(
 	"MesaBryce",
 	"JungleEdge",
 	"SavannaM",
-},
-9,
-minetest.LIGHT_MAX+1,
-30,
-15000,
-8,
-mobs_mc.spawn_height.overworld_min,
-mobs_mc.spawn_height.overworld_max)
-
---[[
-local spawn = {
-	name = "mobs_mc:rabbit",
-	neighbors = {"air"},
-	chance = 15000,
-	active_object_count = 10,
-	min_light = 0,
-	max_light = minetest.LIGHT_MAX+1,
-	min_height = mobs_mc.spawn_height.overworld_min,
-	max_height = mobs_mc.spawn_height.overworld_max,
 }
 
-local spawn_desert = table.copy(spawn)
-spawn_desert.nodes = mobs_mc.spawn.desert
-spawn_desert.on_spawn = function(self, pos)
-	local texture = "mobs_mc_rabbit_gold.png"
-	self.base_texture = { "mobs_mc_rabbit_gold.png" }
-	self.object:set_properties({textures = self.base_texture})
-end
-mobs:spawn(spawn_desert)
-
-local spawn_snow = table.copy(spawn)
-spawn_snow.nodes = mobs_mc.spawn.snow
-spawn_snow.on_spawn = function(self, pos)
+local function spawn_rabbit(pos)
+	local biome_data = minetest.get_biome_data(pos)
+	local biome_name = biome_data and minetest.get_biome_name(biome_data.biome) or ""
+	local mob = minetest.add_entity(pos, mob_name)
+	if not mob then return end
+	local self = mob:get_luaentity()
 	local texture
-	local r = math.random(1, 100)
-	-- 80% white fur
-	if r <= 80 then
-		texture = "mobs_mc_rabbit_white.png"
-	-- 20% black and white fur
+	if biome_name:find("Desert") then
+		texture = "mobs_mc_rabbit_gold.png"
 	else
-		texture = "mobs_mc_rabbit_white_splotched.png"
+		local r = math.random(1, 100)
+		if biome_name:find("Ice") or biome_name:find("snow") or biome_name:find("Cold") then
+			-- 80% white fur
+			if r <= 80 then
+				texture = "mobs_mc_rabbit_white.png"
+			-- 20% black and white fur
+			else
+				texture = "mobs_mc_rabbit_white_splotched.png"
+			end
+		else
+			-- 50% brown fur
+			if r <= 50 then
+				texture = "mobs_mc_rabbit_brown.png"
+			-- 40% salt fur
+			elseif r <= 90 then
+				texture = "mobs_mc_rabbit_salt.png"
+			-- 10% black fur
+			else
+				texture = "mobs_mc_rabbit_black.png"
+			end
+		end
 	end
-	self.base_texture = { texture }
-	self.object:set_properties({textures = self.base_texture})
+	self.base_texture = {texture}
+	self.object:set_properties({textures = {texture}})
 end
-mobs:spawn(spawn_snow)
 
-local spawn_grass = table.copy(spawn)
-spawn_grass.nodes = mobs_mc.spawn.grassland
-spawn_grass.on_spawn = function(self, pos)
-	local texture
-	local r = math.random(1, 100)
-	-- 50% brown fur
-	if r <= 50 then
-		texture = "mobs_mc_rabbit_brown.png"
-	-- 40% salt fur
-	elseif r <= 90 then
-		texture = "mobs_mc_rabbit_salt.png"
-	-- 10% black fur
-	else
-		texture = "mobs_mc_rabbit_black.png"
+local function do_custom_rabbit(self)
+	-- Easter egg: Change texture if rabbit is named “Toast”
+	if self.nametag == "Toast" and not self._has_toast_texture then
+		self._original_rabbit_texture = self.base_texture
+		self.base_texture = { "mobs_mc_rabbit_toast.png" }
+		self.object:set_properties({ textures = self.base_texture })
+		self._has_toast_texture = true
+	elseif self.nametag ~= "Toast" and self._has_toast_texture then
+		self.base_texture = self._original_rabbit_texture
+		self.object:set_properties({ textures = self.base_texture })
+		self._has_toast_texture = false
 	end
-	self.base_texture = { texture }
-	self.object:set_properties({textures = self.base_texture})
 end
-mobs:spawn(spawn_grass)
-]]--
+
+local rabbit = {
+	description = S("Rabbit"),
+	type = "animal",
+	spawn_class = "passive",
+	passive = true,
+	reach = 1,
+	rotate = 270,
+	hp_min = 3,
+	hp_max = 3,
+	xp_min = 1,
+	xp_max = 3,
+	collisionbox = {-0.2, -0.01, -0.2, 0.2, 0.49, 0.2},
+	visual = "mesh",
+	mesh = "mobs_mc_rabbit.b3d",
+	textures = textures,
+	visual_size = {x=1.5, y=1.5},
+	sounds = sounds,
+	makes_footstep_sound = false,
+	walk_velocity = 1,
+	run_velocity = 3.7,
+	follow_velocity = 1.1,
+	floats = 1,
+	runaway = true,
+	jump = true,
+	drops = {
+		{name = mobs_mc.items.rabbit_raw, chance = 1, min = 0, max = 1, looting = "common",},
+		{name = mobs_mc.items.rabbit_hide, chance = 1, min = 0, max = 1, looting = "common",},
+		{name = mobs_mc.items.rabbit_foot, chance = 10, min = 0, max = 1, looting = "rare", looting_factor = 0.03,},
+	},
+	fear_height = 4,
+	animation = {
+		speed_normal = 25, speed_run = 50,
+		stand_start  =  0, stand_end =  0,
+		walk_start   =  0, walk_end  = 20,
+		run_start    =  0, run_end   = 20,
+	},
+	-- Follow (yellow) dangelions, carrots and golden carrots
+	follow = mobs_mc.follow.rabbit,
+	view_range = 8,
+	-- Eat carrots and reduce their growth stage by 1
+	replace_rate = 10,
+	replace_what = mobs_mc.replace.rabbit,
+	on_rightclick = function(self, clicker)
+		-- Feed, tame protect or capture
+		if mobs:feed_tame(self, clicker, 1, true, true) then return end
+	end,
+	do_custom = do_custom_rabbit,
+	spawn = spawn_rabbit
+}
+
+mobs:register_mob(mob_name, rabbit)
+
+-- The killer bunny (Only with spawn egg)
+local killer_bunny = table.copy(rabbit)
+killer_bunny.description = S("Killer Bunny")
+killer_bunny.type = "monster"
+killer_bunny.spawn_class = "hostile"
+killer_bunny.attack_type = "dogfight"
+killer_bunny.specific_attack = { "player", "mobs_mc:wolf", "mobs_mc:dog" }
+killer_bunny.damage = 8
+killer_bunny.passive = false
+-- 8 armor points
+killer_bunny.armor = 50
+killer_bunny.textures = { "mobs_mc_rabbit_caerbannog.png" }
+killer_bunny.view_range = 16
+killer_bunny.replace_rate = nil
+killer_bunny.replace_what = nil
+killer_bunny.on_rightclick = nil
+killer_bunny.run_velocity = 6
+killer_bunny.do_custom = function(self)
+	if not self._killer_bunny_nametag_set then
+		self.nametag = S("The Killer Bunny")
+		self._killer_bunny_nametag_set = true
+	end
+end
+
+mobs:register_mob("mobs_mc:killer_bunny", killer_bunny)
+
+-- Mob spawning rules.
+-- Different skins depending on spawn location <- we customized spawn function
+
+mobs:spawn_setup({
+	name = mob_name,
+	min_light = 9,
+	chance = 1000,
+	aoc = 8,
+	biomes = biome_list,
+	group_size_max = 1,
+	baby_min = 1,
+	baby_max = 2,
+})
 
 -- Spawn egg
 mobs:register_egg("mobs_mc:rabbit", S("Rabbit"), "mobs_mc_spawn_icon_rabbit.png", 0)

mods/ENVIRONMENT/mcl_moon/init.lua

@@ -53,10 +53,18 @@ minetest.register_globalstep(function(dtime)
 	local moon_arg = {texture = get_moon_texture()}
 	local players = minetest.get_connected_players()
 	for p=1, #players do
-		players[p]:set_moon(moon_arg)
+		if players[p].set_moon then
+			players[p]:set_moon(moon_arg)
+		else
+			-- TODO: use old sky api
+		end
 	end
 end)
 
 minetest.register_on_joinplayer(function(player)
-	player:set_moon({texture = get_moon_texture(), scale=3.75})
+	if player.set_moon then
+		player:set_moon({texture = get_moon_texture(), scale=3.75})
+	else
+		-- TODO: use old sky api
+	end
 end)

mods/ENVIRONMENT/mcl_weather/skycolor.lua

@@ -1,6 +1,46 @@
 local mods_loaded = false
 local NIGHT_VISION_RATIO = 0.45
 
+local function set_sky(player, def)
+	if player.set_sun then
+		-- new api
+		player:set_sky(def)
+	else
+		-- TODO
+		-- old api
+	end
+end
+
+local function set_sun(player, def)
+	if player.set_sun then
+		-- new api
+		player:set_sun(def)
+	else
+		-- TODO
+		-- old api
+	end
+end
+
+local function set_moon(player, def)
+	if player.set_sun then
+		-- new api
+		player:set_moon(def)
+	else
+		-- TODO
+		-- old api
+	end
+end
+
+local function set_stars(player, def)
+	if player.set_sun then
+		-- new api
+		player:set_stars(def)
+	else
+		-- TODO
+		-- old api
+	end
+end
+
 mcl_weather.skycolor = {
 	-- Should be activated before do any effect.
 	active = true,
@@ -83,7 +123,7 @@ mcl_weather.skycolor = {
 			if dim == "overworld" then
 				if (mcl_weather.state == "none") then
 					-- Clear weather
-					player:set_sky({
+					set_sky(player, {
 						type = "regular",
 						sky_color = {
 							day_sky = "#92B9FF",
@@ -95,16 +135,17 @@ mcl_weather.skycolor = {
 						},
 						clouds = true,
 					})
-					player:set_sun({visible = true, sunrise_visible = true})
-					player:set_moon({visible = true})
-					player:set_stars({visible = true})
+					set_sun(player, {visible = true, sunrise_visible = true})
+					set_moon(player, {visible = true})
+					set_stars(player, {visible = true})
 					mcl_weather.skycolor.override_day_night_ratio(player, nil)
 				else
 					-- Weather skies
 					local day_color = mcl_weather.skycolor.get_sky_layer_color(0.5)
 					local dawn_color = mcl_weather.skycolor.get_sky_layer_color(0.75)
 					local night_color = mcl_weather.skycolor.get_sky_layer_color(0)
-					player:set_sky({ type = "regular",
+					set_sky(player, {
+						type = "regular",
 						sky_color = {
 							day_sky = day_color,
 							day_horizon = day_color,
@@ -115,9 +156,9 @@ mcl_weather.skycolor = {
 						},
 						clouds = true,
 					})
-					player:set_sun({visible = false, sunrise_visible = false})
-					player:set_moon({visible = false})
-					player:set_stars({visible = false})
+					set_sun(player, {visible = false, sunrise_visible = false})
+					set_moon(player, {visible = false})
+					set_stars(player, {visible = false})
 
 					local lf = mcl_weather.get_current_light_factor()
 					if mcl_weather.skycolor.current_layer_name() == "lightning" then
@@ -136,32 +177,35 @@ mcl_weather.skycolor = {
 				end
 			elseif dim == "end" then
 				local t = "mcl_playerplus_end_sky.png"
-				player:set_sky({ type = "skybox",
+				set_sky(player, {
+					type = "skybox",
 					base_color = "#000000",
 					textures = {t,t,t,t,t,t},
 					clouds = false,
 				})
-				player:set_sun({visible = false , sunrise_visible = false})
-				player:set_moon({visible = false})
-				player:set_stars({visible = false})
+				set_sun(player, {visible = false , sunrise_visible = false})
+				set_moon(player, {visible = false})
+				set_stars(player, {visible = false})
 				mcl_weather.skycolor.override_day_night_ratio(player, 0.5)
 			elseif dim == "nether" then
-				player:set_sky({ type = "plain",
+				set_sky(player, {
+					type = "plain",
 					base_color = "#300808",
 					clouds = false,
 				})
-				player:set_sun({visible = false , sunrise_visible = false})
-				player:set_moon({visible = false})
-				player:set_stars({visible = false})
+				set_sun(player, {visible = false , sunrise_visible = false})
+				set_moon(player, {visible = false})
+				set_stars(player, {visible = false})
 				mcl_weather.skycolor.override_day_night_ratio(player, nil)
 			elseif dim == "void" then
-				player:set_sky({ type = "plain",
+				set_sky(player, {
+					type = "plain",
 					base_color = "#000000",
 					clouds = false,
 				})
-				player:set_sun({visible = false, sunrise_visible = false})
-				player:set_moon({visible = false})
-				player:set_stars({visible = false})
+				set_sun(player, {visible = false, sunrise_visible = false})
+				set_moon(player, {visible = false})
+				set_stars(player, {visible = false})
 			end
 		end
 	end,
@@ -241,7 +285,7 @@ local function initsky(player)
 	end
 
 	-- MC-style clouds: Layer 127, thickness 4, fly to the “West”
-	player:set_clouds({height=mcl_worlds.layer_to_y(127), speed={x=-2, z=0}, thickness=4, color="#FFF0FEF"})
+	player:set_clouds(mcl_worlds:get_cloud_parameters() or {height=mcl_worlds.layer_to_y(127), speed={x=-2, z=0}, thickness=4, color="#FFF0FEF"})
 end
 
 minetest.register_on_joinplayer(initsky)

mods/HELP/mcl_craftguide/init.lua

@@ -1080,10 +1080,10 @@ if progressive_mode then
 			if not awaiting_connection_player_names[name] then
 				local data   = player_data[name]
 				local inv_items = get_inv_items(player)
-				local diff      = table_diff(inv_items, data.inv_items)
+				local diff      = table_diff(inv_items, data.inv_items or {})
 
 				if #diff > 0 then
-					data.inv_items = table_merge(diff, data.inv_items)
+					data.inv_items = table_merge(diff, data.inv_items or {})
 				end
 			end
 		end

mods/HUD/mcl_bossbars/init.lua

@@ -124,12 +124,12 @@ minetest.register_globalstep(function(dtime)
 		local name = player:get_player_name()
 		local bars = mcl_bossbars.bars[name]
 		local huds = mcl_bossbars.huds[name]
-		table.sort(bars, function(a, b) return a.priority < b.priority end)
+		table.sort(bars or {}, function(a, b) return a.priority < b.priority end)
 		local huds_new = {}
 		local bars_new = {}
 		local i = 0
 
-		while #huds > 0 or #bars > 0 do
+		while huds and bars and (#huds > 0 or #bars > 0) do
 			local bar = table.remove(bars, 1)
 			local hud = table.remove(huds, 1)
 

mods/HUD/mcl_info/init.lua

@@ -89,7 +89,7 @@ minetest.register_chatcommand("debug",{
 			minetest.chat_send_player(name, S("Error! Possible values are integer numbers from @1 to @2", 0, 3))
 			return
 		end
-		if dbg == default_dbg then
+		if dbg == default_debug then
 			player_dbg[name] = nil
 		else
 			player_dbg[name] = dbg

mods/ITEMS/mcl_bows/arrow.lua

@@ -507,6 +507,7 @@ function ARROW_ENTITY.on_activate(self, staticdata, dtime_s)
 end
 
 minetest.register_on_respawnplayer(function(player)
+	if not player.get_children then return end
 	for _, obj in pairs(player:get_children()) do
 		local ent = obj:get_luaentity()
 		if ent and ent.name and string.find(ent.name, "mcl_bows:arrow_entity") then

mods/ITEMS/mcl_cauldrons/init.lua

@@ -128,8 +128,9 @@ minetest.register_craft({
 minetest.register_abm({
 	label = "cauldrons",
 	nodenames = {"group:cauldron_filled"},
-	interval = 0.5,
+	interval = 1,
 	chance = 1,
+	-- TODO: Move to playerinfo/playerplus/mob api
 	action = function(pos, node)
 		for _, obj in pairs(minetest.get_objects_inside_radius(pos, 0.4)) do
 			if mcl_burning.is_burning(obj) then

mods/ITEMS/mcl_mushroom/init.lua

@@ -257,7 +257,7 @@ minetest.register_abm({
 minetest.register_abm({
 	label = "mcl_mushroom:warped_checknode",
 	nodenames = {"mcl_mushroom:warped_checknode"},
-	interval = 0.1,
+	interval = 1,
 	chance = 1,
 	action = function(pos)
     local nodepos = minetest.get_node({x = pos.x, y = pos.y + 1, z = pos.z})
@@ -448,7 +448,7 @@ minetest.register_abm({
 minetest.register_abm({
 	label = "mcl_mushroom:crimson_checknode",
 	nodenames = {"mcl_mushroom:crimson_checknode"},
-	interval = 0.1,
+	interval = 1,
 	chance = 1,
 	action = function(pos)
     local nodepos = minetest.get_node({x = pos.x, y = pos.y + 1, z = pos.z})

mods/ITEMS/mcl_portals/portal_end.lua

@@ -244,8 +244,9 @@ end
 minetest.register_abm({
 	label = "End portal teleportation",
 	nodenames = {"mcl_portals:portal_end"},
-	interval = 0.1,
+	interval = 1,
 	chance = 1,
+	-- TODO: Move to playerinfo/playerplus/mob api
 	action = mcl_portals.end_portal_teleport,
 })
 

mods/ITEMS/mcl_portals/portal_gateway.lua

@@ -106,9 +106,10 @@ local function teleport(pos, obj)
 end
 
 minetest.register_abm({
+	-- TODO: Move to playerinfo/playerplus/mob api
 	label = "End gateway portal teleportation",
 	nodenames = {"mcl_portals:portal_gateway"},
-	interval = 0.1,
+	interval = 1,
 	chance = 1,
 	action = function(pos)
 		if preparing[minetest.pos_to_string(pos)] then return end

mods/ITEMS/mcl_portals/portal_nether.lua

@@ -729,8 +729,8 @@ mcl_structures.register_structure({name = "nether_portal", place_function = mcl_
 minetest.register_abm({
 	label = "Nether portal teleportation and particles",
 	nodenames = {PORTAL},
-	interval = 0.8,
-	chance = 3,
+	interval = 1,
+	chance = 2,
 	action = function(pos, node)
 		-- Don't use call stack!
 		local upper_node_name = get_node({x = pos.x, y = pos.y + 1, z = pos.z}).name
@@ -811,6 +811,7 @@ minetest.register_abm({
 				})
 			end
 		end
+		-- TODO: Move to playerinfo/playerplus/mob api
 		for _, obj in pairs(minetest.get_objects_inside_radius(pos, 1)) do	--maikerumine added for objects to travel
 			local lua_entity = obj:get_luaentity()				--maikerumine added for objects to travel
 			if (obj:is_player() or lua_entity) and prevent_portal_chatter(obj) then

mods/MAPGEN/mcl_biomes/init.lua

@@ -22,6 +22,10 @@ local OCEAN_MIN = -15
 local DEEP_OCEAN_MAX = OCEAN_MIN - 1
 local DEEP_OCEAN_MIN = -31
 
+local minetest_get_perlin = minetest.get_perlin
+local math_floor = math.floor
+local math_abs = math.abs
+
 --[[ Special biome field: _mcl_biome_type:
 Rough categorization of biomes: One of "snowy", "cold", "medium" and "hot"
 Based off <https://minecraft.gamepedia.com/Biomes> ]]
@@ -3922,6 +3926,16 @@ local function register_decorations()
 end
 
 -- Decorations in non-Overworld dimensions
+
+local chorus_noise_params = {
+	offset = -0.012,
+	scale = 0.024,
+	spread = {x = 100, y = 100, z = 100},
+	seed = 257,
+	octaves = 3,
+	persistence = 0.6,
+}
+
 local function register_dimension_decorations()
 	--[[ NETHER ]]
 	-- TODO: Nether
@@ -3935,14 +3949,7 @@ local function register_dimension_decorations()
 		place_on = {"mcl_end:end_stone", "air"},
 		flags = "all_floors",
 		sidelen = 16,
-		noise_params = {
-			offset = -0.012,
-			scale = 0.024,
-			spread = {x = 100, y = 100, z = 100},
-			seed = 257,
-			octaves = 3,
-			persist = 0.6
-		},
+		noise_params = chorus_noise_params,
 		y_min = mcl_mapgen.end_.min,
 		y_max = mcl_mapgen.end_.max,
 		decoration = "mcl_end:chorus_flower",
@@ -3962,6 +3969,8 @@ end
 -- Detect mapgen to select functions
 --
 
+local chorus_perlin_noise
+
 if not mcl_mapgen.singlenode then
 	if not superflat then
 		if not mcl_mapgen.v6 then
@@ -3994,8 +4003,10 @@ if not mcl_mapgen.singlenode then
 			vm_context.gennotify = vm_context.gennotify or minetest.get_mapgen_object("gennotify")
 			local gennotify = vm_context.gennotify
 			for _, pos in pairs(gennotify["decoration#"..deco_id_chorus_plant] or {}) do
+				chorus_perlin_noise = chorus_perlin_noise or minetest_get_perlin(chorus_noise_params)
 				local realpos = { x = pos.x, y = pos.y + 1, z = pos.z }
-				local pr = PseudoRandom(vm_context.blockseed)
+				local noise = chorus_perlin_noise:get_3d(realpos)
+				local pr = PseudoRandom(math_floor(math_abs(noise * 32767)) % 32768)
 				minetest.after(1, mcl_end.grow_chorus_plant, realpos, false, pr)
 			end
 			return vm_context
@@ -4003,4 +4014,3 @@ if not mcl_mapgen.singlenode then
 	end
 
 end
-

mods/MAPGEN/mcl_mapgen_core/init.lua

@@ -1101,7 +1101,7 @@ local function register_mgv6_decorations()
 
 end
 
-local mg_flags = minetest.settings:get_flags("mg_flags")
+local mg_flags = minetest.settings.get_flags and minetest.settings:get_flags("mg_flags") or {}
 
 -- Inform other mods of dungeon setting for MCL2-style dungeons
 mcl_vars.mg_dungeons = mcl_mapgen.dungeons

mods/MAPGEN/mcl_strongholds/init.lua

@@ -0,0 +1 @@
+-- moved into mcl_structures

mods/MAPGEN/mcl_strongholds/mod.conf

@@ -0,0 +1,3 @@
+name = mcl_strongholds
+author = Wuzzy
+description = Mod has been moved into mcl_structures. This is a dummy thing to overwrite the old thing, kay27 01/25/22

mods/MAPGEN/mcl_structures/init.lua

@@ -108,6 +108,7 @@ end
 
 function process_mapgen_block_lvm(vm_context)
 	local nodes = minetest.find_nodes_in_area(vm_context.minp, vm_context.maxp, {"group:struct"}, true)
+	nodes = mcl_compatibility.sort_nodes(nodes)
 	for node_name, pos_list in pairs(nodes) do
 		local lvm_callback = on_finished_block_callbacks[node_name]
 		if lvm_callback then
@@ -118,6 +119,7 @@ end
 
 function process_mapgen_chunk(minp, maxp, seed, vm_context)
 	local nodes = minetest.find_nodes_in_area(minp, maxp, {"group:struct"}, true)
+	nodes = mcl_compatibility.sort_nodes(nodes)
 	for node_name, pos_list in pairs(nodes) do
 		local chunk_callback = on_finished_chunk_callbacks[node_name]
 		if chunk_callback then

mods/MAPGEN/mcl_structures/mod.conf

@@ -1,4 +1,4 @@
 name = mcl_structures
 author = Wuzzy, kay27, cora
 description = Structures for MineClone 2/5
-depends = mcl_loot, mcl_mapgen, mcl_worlds
+depends = mcl_init, mcl_loot, mcl_mapgen, mcl_worlds

mods/MISC/mcl_commands/gamemode.lua

@@ -20,6 +20,7 @@ minetest.register_on_shutdown(function()
 end)
 
 local core_is_creative_enabled = minetest.is_creative_enabled
+	or function() return false end
 
 minetest.is_creative_enabled = function(name)
 	local id = player_to_gamemode_id[name]

mods/MISC/mcl_commands/summon.lua

@@ -3,13 +3,41 @@ local S = minetest.get_translator(minetest.get_current_modname())
 local orig_func = minetest.registered_chatcommands["spawnentity"].func
 local cmd = table.copy(minetest.registered_chatcommands["spawnentity"])
 cmd.func = function(name, param)
-	local ent = minetest.registered_entities[param]
-	if minetest.settings:get_bool("only_peaceful_mobs", false) and ent and ent._cmi_is_mob and ent.type == "monster" then
-		return false, S("Only peaceful mobs allowed!")
-	else
-		local bool, msg = orig_func(name, param)
-		return bool, msg
+	local params = param:split(" ")
+	if not params[1] or params[3] then
+		return false, S("Usage: /spawnentity <EntityName> [<X>,<Y>,<Z>]")
 	end
+	local entity_name = params[1]
+	local pos = params[2]
+	local entity_def = minetest.registered_entities[entity_name]
+	if not entity_def then
+		entity_name = "mobs_mc:" .. entity_name
+		entity_def = minetest.registered_entities[entity_name]
+		if not entity_def then
+			return false, S("Error: Unknown entity name")
+		end
+	end
+	if entity_def._cmi_is_mob then
+		if minetest.settings:get_bool("only_peaceful_mobs", false) and entity_def.type == "monster" then
+			return false, S("Only peaceful mobs allowed!")
+		end
+		mobs.spawn_mob(
+			entity_name,
+			pos
+				and minetest.string_to_pos(pos)
+				or vector.add(
+					minetest.get_player_by_name(name):get_pos(),
+					{
+						x = math.random()-0.5,
+						y = math.random(),
+						z = math.random()-0.5
+					}
+				)
+		)
+		return true, S("Mob @1 spawned", entity_name)
+	end
+	local bool, msg = orig_func(name, param)
+	return bool, msg
 end
 minetest.unregister_chatcommand("spawnentity")
 minetest.register_chatcommand("summon", cmd)

mods/PLAYER/mcl_anticheat/init.lua

@@ -63,7 +63,7 @@ local function update_player(player_object)
 
 	local noclip = #find_nodes_in_area({x = x, y = head_y, z = z}, {x = x + 1, y = head_y + 1, z = z + 1}, "group:opaque") == 8
 
-	local velocity = player_object:get_velocity()
+	local velocity = player_object:get_velocity() or player_object:get_player_velocity()
 	if vector_length(velocity) < 0.00000001 then
 		player_doesnt_move[name] = (player_doesnt_move[name] or 0) + 1
 	else
@@ -122,7 +122,7 @@ local function check_player(name)
 		if not obj_player then
 			return
 		end
-		local velocity = obj_player:get_velocity()
+		local velocity = obj_player:get_velocity() or obj_player:get_player_velocity()
 		local pos = obj_player:get_pos()
 		local x, y, z = floor(pos.x), floor(pos.y), floor(pos.z)
 		while #find_nodes_in_area({x = x, y = y, z = z}, {x = x + 1, y = y, z = z + 1}, "air") == 4 do

mods/PLAYER/mcl_antispam/init.lua

@@ -0,0 +1,112 @@
+local ban_spammers = true
+local kick_spammers = true
+local revoke_shout_for_spammers = true
+local limit_messages = 10
+local limit_message_length = 200
+local block_special_chars = true
+local enable_antispam = ban_spammers or kick_spammers or revoke_shout_for_spammers
+
+local function update_settings()
+	ban_spammers = minetest.settings:get_bool("ban_spammers", true)
+	kick_spammers = minetest.settings:get_bool("kick_spammers", true)
+	revoke_shout_for_spammers = minetest.settings:get_bool("revoke_shout_for_spammers", true)
+	limit_messages = tonumber(minetest.settings:get("limit_messages") or 10)
+	limit_message_length = tonumber(minetest.settings:get("limit_message_length") or 200)
+	block_special_chars = minetest.settings:get_bool("block_special_chars", true)
+	enable_antispam = ban_spammers or kick_spammers or revoke_shout_for_spammers
+	minetest.after(7, update_settings)
+end
+update_settings()
+
+local last_messages = {}
+local exceeders = {}
+local special_users = {}
+
+local function ban(name)
+	if revoke_shout_for_spammers then
+		local privs = minetest.get_player_privs(name)
+		if privs then
+			privs.shout = nil
+			minetest.set_player_privs(name, privs)
+		end
+	end
+	if ban_spammers then
+		minetest.ban_player(name)
+	elseif kick_spammers then
+		minetest.kick_player(name)
+	end
+end
+
+local last_char = string.char(127)
+
+local function on_chat_message(name, message)
+	if not enable_antispam then return end
+	local length = message:len()
+	if last_messages.job then
+		last_messages.job:cancel()
+		last_messages.job = nil
+	end
+	if last_messages.name and last_messages.name == name then
+		last_messages.count = last_messages.count + 1
+		last_messages.summary_length = last_messages.summary_length + length
+		if last_messages.count >= limit_messages then
+			ban(name)
+		end
+	else
+		last_messages.name = name
+		last_messages.count = 1
+		last_messages.summary_length = length
+	end
+	last_messages.job = minetest.after(30, function()
+		last_messages.name = nil
+		last_messages.job = nil
+	end)
+	if limit_message_length > 0 and message:len() > limit_message_length then
+		if exceeders[name] then
+			exceeders[name] = exceeders[name] + 1
+			if exceeders[name] > limit_messages then
+				ban(name)
+			end
+		else
+			exceeders[name] = 1
+		end
+		message = message:sub(1, limit_message_length) .. ">8 >8 >8"
+		minetest.chat_send_all("<" .. name .. "> " .. message)
+		return true
+	else
+		if exceeders[name] then
+			exceeders[name] = nil
+		end
+	end
+	if block_special_chars then
+		local sc = false
+		local msg = ""
+		for i = 1, #message do
+			local c = message:sub(i,i)
+			if c >= " " and c <= last_char then
+				msg = msg .. c
+			else
+				sc = true
+			end
+		end
+		if sc then
+			if special_users[name] then
+				special_users[name] = special_users[name] + 1
+				if special_users[name] > limit_messages then
+					ban(name)
+				end
+			else
+				special_users[name] = 1
+			end
+			message = msg
+			minetest.chat_send_all("<" .. name .. "> " .. message)
+			return true
+		else
+			if special_users[name] then
+				special_users[name] = nil
+			end
+		end
+	end
+end
+
+minetest.register_on_chat_message(on_chat_message)

mods/PLAYER/mcl_antispam/mod.conf

@@ -0,0 +1,2 @@
+name = mcl_antispam
+author = kay27

mods/PLAYER/mcl_player/init.lua

@@ -90,7 +90,11 @@ function mcl_player.player_set_model(player, model_name)
 end
 
 local function set_texture(player, index, texture)
-	local textures = player_textures[player:get_player_name()] or {}
+	local textures = player_textures[player:get_player_name()]
+	if not textures then
+		player_textures[player:get_player_name()] = {"blank.png", "blank.png", "blank.png"}
+		textures = player_textures[player:get_player_name()]
+	end
 	textures[index] = texture
 	player:set_properties({textures = textures})
 end

mods/PLAYER/mcl_player/mod.conf

@@ -1,3 +1,4 @@
 name = mcl_player
 author = celeron55
 description = Adds the 3D player model, taken from Minetest Game 0.4.16. 
+depends = mcl_playerinfo

mods/PLAYER/mcl_playerinfo/init.lua

@@ -63,6 +63,10 @@ minetest.register_globalstep(function(dtime)
 
 		-- what is around me?
 		local node_stand, node_stand_below, node_head, node_feet = get_player_nodes(pos)
+
+		if not mcl_playerinfo[name] then
+			mcl_playerinfo[name] = {}
+		end
 		mcl_playerinfo[name].node_stand = node_stand
 		mcl_playerinfo[name].node_stand_below = node_stand_below
 		mcl_playerinfo[name].node_head = node_head

mods/PLAYER/mcl_playerplus/init.lua

@@ -279,6 +279,11 @@ minetest.register_globalstep(function(dtime)
 		local fly_node = minetest.get_node({x = fly_pos.x, y = fly_pos.y - 0.5, z = fly_pos.z}).name
 		local elytra = mcl_playerplus.elytra[name]
 
+		if not elytra then
+			mcl_playerplus.elytra[player] = {}
+			elytra = mcl_playerplus.elytra[player]
+		end
+
 		elytra.active = player:get_inventory():get_stack("armor", 3):get_name() == "mcl_armor:elytra"
 			and not player:get_attach()
 			and (elytra.active or control.jump and player_velocity.y < -6)
@@ -404,7 +409,8 @@ minetest.register_globalstep(function(dtime)
 		-- Update jump status immediately since we need this info in real time.
 		-- WARNING: This section is HACKY as hell since it is all just based on heuristics.
 
-		if mcl_playerplus_internal[name].jump_cooldown > 0 then
+		local mcl_playerplus_internal_name = mcl_playerplus_internal[name]
+		if mcl_playerplus_internal_name and mcl_playerplus_internal_name.jump_cooldown > 0 then
 			mcl_playerplus_internal[name].jump_cooldown = mcl_playerplus_internal[name].jump_cooldown - dtime
 		end
 
@@ -728,6 +734,9 @@ minetest.register_globalstep(function(dtime)
 		end
 
 		-- Update internal values
+		if not mcl_playerplus_internal[name] then
+			mcl_playerplus_internal[name] = {}
+		end
 		mcl_playerplus_internal[name].lastPos = pos
 
 	end

settingtypes.txt

@@ -169,6 +169,20 @@ kick_cheaters (Kick Cheaters) bool false
 # Cheat kicking threshold
 kick_threshold (Cheat Kicking Threshold) int 10
 
+[Antispam]
+# Maximum player messages in a sequence
+limit_messages (Maximum player messages in a sequence) int 10
+# Maximum message length
+limit_message_length (Maximum message length) int 200
+# Block special characters
+block_special_chars (Block special characters) bool true
+# Ban spammers
+ban_spammers (Ban spammers) bool true
+# Kick spammers
+kick_spammers (Kick spammers) bool true
+# Revoke shout priv for spammers
+revoke_shout_for_spammers (Revoke shout priv for spammers) bool true
+
 [Debugging]
 # If enabled, this will show the itemstring of an item in the description.
 mcl_item_id_debug (Item ID Debug) bool false