Merge pull request 'Release 1.10' (#261) from compatibility into production-compatible

Reviewed-on: MineClone5/MineClone5#261

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_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/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/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/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,

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/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/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/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_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

tools/create_texture__mcl_end_crystal_beam.py

@@ -0,0 +1,28 @@
+import png
+from random import randrange
+
+w, h = 16, 256;
+
+s = [[int(0) for c in range(w)] for c in range(h)] 
+
+def drawpixel(x, y, t):
+	if (x >= 0) and (x < w) and (y >= 0) and (y < h):
+		s[y][x] = t
+
+# R, G, B, Alpha (0xFF = opaque):
+palette=[
+	(0x00,0x00,0x00,0x00),
+	(0xFF,0xFF,0x70,0xCC),
+	(0xFF,0x80,0xDF,0xCC),
+	(0x80,0xFF,0xDF,0xCC)
+]
+
+for x in range(w):
+	for y in range(h):
+		n = randrange(4)
+		if n == 1:
+			drawpixel(x, y, randrange(3) + 1)
+
+w = png.Writer(len(s[0]), len(s), palette=palette, bitdepth=2)
+f = open('mcl_end_crystal_beam.png', 'wb')
+w.write(f, s)