update

mods/advtrains/advtrains/crafting.lua

@@ -20,6 +20,32 @@ minetest.register_craft({
 		{'', '', 'default:steel_ingot'},
 	},
 })
+--Wallmounted Signal
+minetest.register_craft({
+	output = 'advtrains:signal_wall_r_off 2',
+	recipe = {
+		{'dye:red', 'default:steel_ingot', 'default:steel_ingot'},
+		{'', 'default:steel_ingot', ''},
+		{'dye:dark_green', 'default:steel_ingot', 'default:steel_ingot'},
+	},
+})
+
+--Wallmounted Signals can be converted into every orientation by shapeless crafting
+minetest.register_craft({
+	output = 'advtrains:signal_wall_l_off',
+	type = "shapeless",
+	recipe = {'advtrains:signal_wall_r_off'},
+})
+minetest.register_craft({
+	output = 'advtrains:signal_wall_t_off',
+	type = "shapeless",
+	recipe = {'advtrains:signal_wall_l_off'},
+})
+minetest.register_craft({
+	output = 'advtrains:signal_wall_r_off',
+	type = "shapeless",
+	recipe = {'advtrains:signal_wall_t_off'},
+})
 
 --trackworker
 minetest.register_craft({

mods/advtrains/advtrains_interlocking/tcb_ts_ui.lua

@@ -118,6 +118,16 @@ minetest.register_node("advtrains_interlocking:tcb_node", {
 	end,
 })
 
+
+-- Crafting
+minetest.register_craft({
+	output = 'advtrains_interlocking:tcb_node 4',
+	recipe = {
+		{'mesecons:wire_00000000_off', 'basic_materials:ic', 'mesecons:wire_00000000_off'},
+	},
+})
+
+
 minetest.register_on_punchnode(function(pos, node, player, pointed_thing)
 	local pname = player:get_player_name()
 	if not minetest.check_player_privs(pname, "interlocking") then

mods/advtrains/advtrains_interlocking/tsr_rail.lua

@@ -23,6 +23,16 @@ local adefunc = function(def, preset, suffix, rotation)
 				advtrains.interlocking.npr_rails[pe] = nil
 			end,
 			on_receive_fields = function(pos, formname, fields, player)
+				local pname = player:get_player_name()
+				if not minetest.check_player_privs(pname, {interlocking=true}) then
+					minetest.chat_send_player(pname, "Interlocking privilege required!")
+					return
+				end
+				if minetest.is_protected(pos, pname) then
+					minetest.chat_send_player(pname, "This rail is protected!")
+					minetest.record_protection_violation(pos, pname)
+					return
+				end
 				if fields.npr then
 					local pe = advtrains.encode_pos(pos)
 					advtrains.interlocking.npr_rails[pe] = tonumber(fields.npr)

mods/advtrains/advtrains_signals_ks/init.lua

@@ -199,7 +199,7 @@ for _, rtab in ipairs({
 				save_in_at_nodedb = 1,
 				not_in_creative_inventory = (rtab.ici and prts.ici) and 0 or 1,
 			},
-			drop = "advtrains_signals_ks:sign_e_0",
+			drop = "advtrains_signals_ks:sign_8_0",
 			inventory_image = "advtrains_signals_ks_sign_8.png",
 			sounds = default.node_sound_stone_defaults(),
 			advtrains = {
@@ -241,3 +241,40 @@ for _, rtab in ipairs({
 	advtrains.trackplacer.add_worked("advtrains_signals_ks:mast","mast", "_"..rot)
 end
 
+-- Crafting
+
+minetest.register_craft({
+	output = "advtrains_signals_ks:hs_danger_0 2",
+	recipe = {
+		{'default:steel_ingot', 'dye:red', 'default:steel_ingot'},
+		{'dye:yellow', 'default:steel_ingot', 'dye:dark_green'},
+		{'default:steel_ingot', 'advtrains_signals_ks:mast_mast_0', 'default:steel_ingot'},
+	},
+})
+
+minetest.register_craft({
+	output = "advtrains_signals_ks:mast_mast_0 10",
+	recipe = {
+		{'default:steel_ingot'},
+		{'dye:cyan'},
+		{'default:steel_ingot'},
+	},
+})
+
+minetest.register_craft({
+	output = "advtrains_signals_ks:ra_danger_0 2",
+	recipe = {
+		{'dye:red', 'dye:white', 'dye:red'},
+		{'dye:white', 'default:steel_ingot', 'default:steel_ingot'},
+		{'default:steel_ingot', 'advtrains_signals_ks:mast_mast_0', 'default:steel_ingot'},
+	},
+})
+
+minetest.register_craft({
+	output = "advtrains_signals_ks:sign_8_0 2",
+	recipe = {
+		{'basic_materials:plastic_sheet', 'dye:black'},
+		{'default:stick', ''},
+		{'default:stick', ''},
+	},
+})

mods/advtrains/advtrains_train_industrial/init.lua

@@ -105,3 +105,45 @@ advtrains.register_wagon("wagon_wood", {
 		box=8*3,
 	},
 }, S("Industrial wood wagon"), "advtrains_wagon_wood_inv.png")
+
+-- Craftings
+
+minetest.register_craft({
+	output = 'advtrains:engine_industrial',
+	recipe = {
+		{'default:steelblock', 'default:steelblock', 'default:steelblock'},
+		{'advtrains:driver_cab', 'default:steelblock', 'default:steelblock'},
+		{'advtrains:wheel', '', 'advtrains:wheel'},
+	},
+})
+
+--Engine Industrial Big
+minetest.register_craft({
+	output = 'advtrains:engine_industrial_big',
+	recipe = {
+		{'default:glass', 'default:steelblock', 'default:steelblock'},
+		{'advtrains:driver_cab', 'default:steelblock', 'default:steelblock'},
+		{'advtrains:wheel', 'advtrains:wheel', 'advtrains:wheel'},
+	},
+})
+
+
+--Industrial tank wagon
+minetest.register_craft({
+	output = 'advtrains:wagon_tank',
+	recipe = {
+		{'default:steelblock', 'default:steel_ingot', 'default:steelblock'},
+		{'advtrains:steelblock', '', 'default:steelblock'},
+		{'advtrains:wheel', 'default:steelblock', 'advtrains:wheel'},
+	},
+})
+
+--Industrial wood wagon
+minetest.register_craft({
+	output = 'advtrains:wagon_wood',
+	recipe = {
+		{'default:steel_ingot', '', 'default:steel_ingot'},
+		{'advtrains:steelblock', 'default:steelblock', 'default:steelblock'},
+		{'advtrains:wheel', '', 'advtrains:wheel'},
+	},
+})

mods/advtrains/advtrains_train_japan/init.lua

@@ -138,3 +138,25 @@ advtrains.register_wagon("wagon_japan", {
 	drops={"default:steelblock 4"},
 }, S("Japanese Train Wagon"), "advtrains_wagon_japan_inv.png")
 
+-- Crafting
+
+minetest.register_craft({
+	output = 'advtrains:engine_japan',
+	recipe = {
+		{'default:steelblock', 'default:steelblock', ''},
+		{'xpanes:pane_flat', 'default:steelblock', 'xpanes:pane_flat'},
+		{'advtrains:wheel', 'advtrains:wheel', 'advtrains:wheel'},
+	},
+})
+
+minetest.register_craft({
+output = 'advtrains:wagon_japan',
+	recipe = {
+		{'default:steelblock', 'default:steelblock', 'default:steelblock'},
+		{'xpanes:pane_flat', 'default:steelblock', 'xpanes:pane_flat'},
+		{'advtrains:wheel', '', 'advtrains:wheel'},
+	},
+})
+
+
+

mods/advtrains/advtrains_train_track/init.lua

@@ -298,6 +298,29 @@ advtrains.register_tracks("default", {
 	end
 				     }, advtrains.trackpresets.t_30deg_straightonly)
 
+minetest.register_craft({
+	type="shapeless",
+	output = 'advtrains:dtrack_load_placer',
+	recipe = {
+		"advtrains:dtrack_placer",
+		"basic_materials:ic",
+		"default:chest"
+	},
+})
+minetest.register_craft({
+	type="shapeless",
+	output = 'advtrains:dtrack_unload_placer',
+	recipe = {
+		"advtrains:dtrack_load_placer",
+	},
+})
+minetest.register_craft({
+	type="shapeless",
+	output = 'advtrains:dtrack_load_placer',
+	recipe = {
+		"advtrains:dtrack_unload_placer",
+	},
+})
 
 
 if mesecon then

mods/ambience/init.lua

@@ -125,7 +125,7 @@ local get_ambience = function(player, tod, name)
 
 
 	-- get foot and head level nodes at player position
-	local pos = player:get_pos()
+	local pos = player:get_pos() ; if not pos then return end
 
 	pos.y = pos.y + 1.4 -- head level
 

mods/bonemeal/init.lua

@@ -63,24 +63,22 @@ local dry_grass = {
 	"default:dry_grass_5", "", ""
 }
 
--- add all in-game flowers except waterlily
+-- loads mods then add all in-game flowers except waterlily
 local flowers = {}
 
+minetest.after(0.1, function()
+
 	for node, def in pairs(minetest.registered_nodes) do
 
-	if def.groups.flower and not node:find("waterlily") then
+		if def.groups
+		and def.groups.flower
+		and not node:find("waterlily")
+		and not node:find("xdecor:potted_") then
 			flowers[#flowers + 1] = node
 		end
 	end
+end)
 
--- add additional bakedclay flowers if enabled
-if minetest.get_modpath("bakedclay") then
-	flowers[#flowers + 1] = "bakedclay:delphinium"
-	flowers[#flowers + 1] = "bakedclay:thistle"
-	flowers[#flowers + 1] = "bakedclay:lazarus"
-	flowers[#flowers + 1] = "bakedclay:mannagrass"
-	flowers[#flowers + 1] = ""
-end
 
 -- default biomes deco
 local deco = {

mods/builtin_item/init.lua

@@ -22,28 +22,30 @@ end
 
 -- If item_entity_ttl is not set, enity will have default life time
 -- Setting it to -1 disables the feature
-
 local time_to_live = tonumber(core.settings:get("item_entity_ttl")) or 900
 local gravity = tonumber(core.settings:get("movement_gravity")) or 9.81
 local destroy_item = core.settings:get_bool("destroy_item") ~= false
 
 
--- water flow functions by QwertyMine3, edited by TenPlus1
+-- localize some math functions
-local inv_roots = {
+local abs = math.abs
-	[0] = 1
+local sqrt = math.sqrt
-}
+
+
+-- water flow functions by QwertyMine3, edited by TenPlus1 and Gustavo6046
+local inv_roots = {[0] = 1}
 
 local function to_unit_vector(dir_vector)
 
 	local sum = dir_vector.x * dir_vector.x + dir_vector.z * dir_vector.z
-	local invr_sum = 0
+	local invr_sum
 
 	-- find inverse square root if possible
 	if inv_roots[sum] ~= nil then
 		invr_sum = inv_roots[sum]
 	else
 		-- not found, compute and save the inverse square root
-		invr_sum = 1.0 / math.sqrt(sum)
+		invr_sum = 1.0 / sqrt(sum)
 		inv_roots[sum] = invr_sum
 	end
 
@@ -104,9 +106,6 @@ local function quick_flow_logic(node, pos_testing, direction)
 end
 
 
--- reciprocal of the length of an unit square's diagonal
-local DIAG_WEIGHT = 2 / math.sqrt(2)
-
 local function quick_flow(pos, node)
 
 	local x, z = 0.0, 0.0
@@ -118,7 +117,6 @@ local function quick_flow(pos, node)
 
 	return to_unit_vector({x = x, y = 0, z = z})
 end
--- END water flow functions
 
 
 -- particle effects for when item is destroyed
@@ -141,10 +139,19 @@ local function add_effects(pos)
 	})
 end
 
+-- print vector, helpful when debugging
+local function vec_print(head, vec)
+	print(head, vec.x, vec.y, vec.z)
+end
+
+
+local water_force = tonumber(minetest.settings:get("builtin_item.waterflow_force") or 1.6)
+local water_drag = tonumber(minetest.settings:get("builtin_item.waterflow_drag") or 0.8)
+local dry_friction = tonumber(minetest.settings:get("builtin_item.friction_dry") or 2.5)
+local air_drag = tonumber(minetest.settings:get("builtin_item.air_drag") or 0.4)
+local items_collect_on_slippery = tonumber(
+		minetest.settings:get("builtin_item.items_collect_on_slippery") or 1) ~= 0
 
-local water_force = 0.8
-local water_friction = 0.8
-local dry_friction = 2.5
 
 core.register_entity(":__builtin:item", {
 
@@ -159,14 +166,17 @@ core.register_entity(":__builtin:item", {
 		spritediv = {x = 1, y = 1},
 		initial_sprite_basepos = {x = 0, y = 0},
 		is_visible = false,
-		infotext = "",
+		infotext = ""
 	},
 
 	itemstring = "",
-	moving_state = true,
+	falling_state = true,
 	slippery_state = false,
+	waterflow_state = false,
 	age = 0,
 
+	accel = {x = 0, y = 0, z = 0},
+
 	set_item = function(self, item)
 
 		local stack = ItemStack(item or self.itemstring)
@@ -200,11 +210,14 @@ core.register_entity(":__builtin:item", {
 			name = name1
 		end
 
+		-- small random size bias to counter Z-fighting
+		local bias = math.random() * 1e-3
+
 		self.object:set_properties({
 			is_visible = true,
 			visual = "wielditem",
 			textures = {itemname},
-			visual_size = {x = size, y = size},
+			visual_size = {x = size + bias, y = size + bias, z = size + bias},
 			collisionbox = {-size, -col_height, -size, size, col_height, size},
 			selectionbox = {-size, -size, -size, size, size, size},
 			automatic_rotate = 0.314 / size,
@@ -217,11 +230,13 @@ core.register_entity(":__builtin:item", {
 
 	get_staticdata = function(self)
 
-		return core.serialize({
+		local data = {
 			itemstring = self.itemstring,
 			age = self.age,
 			dropped_by = self.dropped_by
-		})
+		}
+
+		return core.serialize(data)
 	end,
 
 	on_activate = function(self, staticdata, dtime_s)
@@ -240,8 +255,6 @@ core.register_entity(":__builtin:item", {
 		end
 
 		self.object:set_armor_groups({immortal = 1})
-		self.object:set_velocity({x = 0, y = 2, z = 0})
-		self.object:set_acceleration({x = 0, y = -gravity, z = 0})
 		self:set_item()
 	end,
 
@@ -271,11 +284,23 @@ core.register_entity(":__builtin:item", {
 
 		-- Merge the remote stack into this one
 		local pos = object:get_pos()
+
 		pos.y = pos.y + ((total_count - count) / max_count) * 0.15
 
 		self.object:move_to(pos)
 		self.age = 0 -- Handle as new entity
 
+		-- Merge velocities
+		local vel_a = self.object:get_velocity()
+		local vel_b = object:get_velocity()
+
+		self.object:set_velocity({
+			x = (vel_a.x + vel_b.x) / 2,
+			y = (vel_a.y + vel_b.y) / 2,
+			z = (vel_a.z + vel_b.z) / 2
+		})
+
+		-- Merge stacks
 		own_stack:set_count(total_count)
 		self:set_item(own_stack)
 
@@ -285,22 +310,10 @@ core.register_entity(":__builtin:item", {
 		return true
 	end,
 
-	on_step = function(self, dtime, moveresult)
+	step_update_node_state = function(self, moveresult, dtime)
 
 		local pos = self.object:get_pos()
 
-		self.age = self.age + dtime
-
-		if time_to_live > 0 and self.age > time_to_live then
-
-			self.itemstring = ""
-			self.object:remove()
-
-			add_effects(pos)
-
-			return
-		end
-
 		-- get nodes every 1/4 second
 		self.timer = (self.timer or 0) + dtime
 
@@ -312,6 +325,7 @@ core.register_entity(":__builtin:item", {
 
 			-- get ground node for collision
 			self.node_under = nil
+			self.falling_state = true
 
 			if moveresult.touching_ground then
 
@@ -320,6 +334,7 @@ core.register_entity(":__builtin:item", {
 					if info.axis == "y" then
 
 						self.node_under = core.get_node(info.node_pos)
+						self.falling_state = false
 
 						break
 					end
@@ -331,8 +346,13 @@ core.register_entity(":__builtin:item", {
 
 			self.timer = 0
 		end
+	end,
 
+	step_node_inside_checks = function(self)
+
+		local pos = self.object:get_pos()
 		local node = self.node_inside
+		local def = self.def_inside
 
 		-- Delete in 'ignore' nodes
 		if node and node.name == "ignore" then
@@ -340,23 +360,22 @@ core.register_entity(":__builtin:item", {
 			self.itemstring = ""
 			self.object:remove()
 
-			return
+			return true
 		end
 
-		-- do custom step function
+		-- item inside block, move to vacant space
-		local name = ItemStack(self.itemstring):get_name() or ""
+		if def and (def.walkable == nil or def.walkable == true)
-		local custom = core.registered_items[name]
+		and (def.collision_box == nil or def.collision_box.type == "regular")
-			and core.registered_items[name].dropped_step
+		and (def.node_box == nil or def.node_box.type == "regular") then
 
-		if custom and custom(self, pos, dtime) == false then
+			local npos = minetest.find_node_near(pos, 1, "air")
-			return -- skip further checks if false
+
+			if npos then
+				self.object:move_to(npos)
 			end
 
-		local vel = self.object:get_velocity()
+			self.node_inside = nil -- force get_node
-		local def = self.def_inside
+		end
-		local is_slippery = false
-		local is_moving = (def and not def.walkable) or
-			vel.x ~= 0 or vel.y ~= 0 or vel.z ~= 0
 
 		-- destroy item when dropped into lava (if enabled)
 		if destroy_item and def and def.groups and def.groups.lava then
@@ -372,125 +391,156 @@ core.register_entity(":__builtin:item", {
 
 			add_effects(pos)
 
+			return true
+		end
+
+		return false
+	end,
+
+	step_check_slippery = function(self)
+
+		-- don't check for slippery ground if we're not on
+		-- any ground to begin with
+		local node = self.node_under
+		local def = self.def_under
+
+		if self.falling_state or not node then
+			self.slippery_state = false
 			return
 		end
 
-		-- water flowing
+		if node and def and def.walkable then
-		if def and def.liquidtype == "flowing" then
-
-			-- force applies on acceleration over time, thus multiply
-			local force = water_force * dtime
-			-- friction applies on velocity over time,     thus exponentiate
-			local friction = (1.0 + water_friction) ^ dtime
-
-			-- get flow velocity and current vel/acc state
-			local vec = quick_flow(pos, node)
-			local a = self.object:get_acceleration()
-
-			self.object:set_acceleration({
-				x = a.x + vec.x * force,
-				y = a.y,
-				z = a.z + vec.z * force
-			})
-
-			-- apply friction to prevent items going too fast, and also to make
-			-- water flow override previous horizontal momentum more quickly
-
-			local v = self.object:get_velocity()
-
-			-- adjust friction for going against the current
-			local v_horz = { x = v.x, y = 0, z = v.z }
-			local v_dir = to_unit_vector(v_horz)
-			local flow_dot = v_dir.x * vec.x + v_dir.y * vec.y
-
-			-- also maps flow_dot from [-1,0] to [0.5,2.5]
-			friction = 1.0 + ((friction - 1.0) * (flow_dot + 1.5))
-
-			self.object:set_velocity({
-				x = v.x / friction,
-				y = v.y / friction,
-				z = v.z / friction
-			})
-
-			return
-		end
-
-		-- item inside block, move to vacant space
-		if def and (def.walkable == nil or def.walkable == true)
-		and (def.collision_box == nil or def.collision_box.type == "regular")
-		and (def.node_box == nil or def.node_box.type == "regular") then
-
-			local npos = minetest.find_node_near(pos, 1, "air")
-
-			if npos then
-				self.object:move_to(npos)
-			end
-
-			self.node_inside = nil -- force get_node
-
-			return
-		end
-
-		-- Switch locals to node under
-		node = self.node_under
-		def = self.def_under
-
-
-		-- Slippery node check
-		if def and def.walkable then
 
 			local slippery = core.get_item_group(node.name, "slippery")
 
-			is_slippery = slippery ~= 0
+			self.slippery_state = slippery ~= 0
+		end
+	end,
 
-			if is_slippery and (math.abs(vel.x) > 0.2 or math.abs(vel.z) > 0.2) then
+	step_water_physics = function(self)
 
-				-- Horizontal deceleration
+		local pos = self.object:get_pos()
+		local vel = self.object:get_velocity()
+		local node = self.node_inside
+		local def = self.def_inside
+
+		self.waterflow_state = def and def.liquidtype == "flowing"
+
+		if self.waterflow_state then
+
+			-- get flow velocity
+			local flow_vel = quick_flow(pos, node)
+
+			-- calculate flow force and drag
+			local flow_force_x = flow_vel.x * water_force
+			local flow_force_z = flow_vel.z * water_force
+
+			local flow_drag_x = (flow_force_x - vel.x) * water_drag
+			local flow_drag_z = (flow_force_z - vel.z) * water_drag
+
+			-- apply water force and friction
+			self.accel.x = self.accel.x + flow_force_x + flow_drag_x
+			self.accel.z = self.accel.z + flow_force_z + flow_drag_z
+		end
+	end,
+
+	step_air_drag_physics = function(self)
+
+		local vel = self.object:get_velocity()
+
+		-- apply air drag
+		if self.falling_state or (self.slippery_state and not self.waterflow_state) then
+			self.accel.x = self.accel.x - vel.x * air_drag
+			self.accel.z = self.accel.z - vel.z * air_drag
+		end
+	end,
+
+	step_gravity = function(self)
+
+		if self.falling_state then
+			self.accel.y = self.accel.y - gravity
+		end
+	end,
+
+	step_ground_friction = function(self)
+
+		-- don't apply ground friction when falling!
+		if self.falling_state then
+			return
+		end
+
+		local vel = self.object:get_velocity()
+
+		if self.slippery_state then
+
+			local node = self.node_under
+
+			-- apply slip factor (tiny friction that depends on the actual block type)
+			if (abs(vel.x) > 0.2 or abs(vel.z) > 0.2) then
+
+				local slippery = core.get_item_group(node.name, "slippery")
 				local slip_factor = 4.0 / (slippery + 4)
 
-				self.object:set_acceleration({
+				self.accel.x = self.accel.x - vel.x * slip_factor
-					x = -vel.x * slip_factor,
+				self.accel.z = self.accel.z - vel.z * slip_factor
-					y = 0,
-					z = -vel.z * slip_factor
-				})
-
-			elseif vel.y == 0 then
-				is_moving = false
-			end
 			end
 
-		if self.moving_state == is_moving
-		and self.slippery_state == is_slippery then
-			return -- No further updates until moving state changes
-		end
-
-		self.moving_state = is_moving
-		self.slippery_state = is_slippery
-
-		local a_curr = self.object:get_acceleration()
-		local v_curr = self.object:get_velocity()
-
-		if is_moving then
-
-			self.object:set_acceleration({
-				x = a_curr.x,
-				y = a_curr.y - gravity,
-				z = a_curr.z
-			})
 		else
-			self.object:set_acceleration({x = 0, y = 0, z = 0})
+			self.accel.x = self.accel.x - vel.x * dry_friction
+			self.accel.z = self.accel.z - vel.z * dry_friction
+		end
+	end,
 
-			-- preserve *some* velocity so items don't get stuck on the very ledges
+	step_apply_forces = function(self)
-			-- of nodes once they move just enough to leave the hitbox of flowing water
+		self.object:set_acceleration(self.accel)
-			self.object:set_velocity({
+	end,
-				x = v_curr.x / dry_friction,
+
-				y = v_curr.y / dry_friction,
+	step_check_timeout = function(self, dtime)
-				z = v_curr.z / dry_friction
+
-			})
+		local pos = self.object:get_pos()
+
+		self.age = self.age + dtime
+
+		if time_to_live > 0 and self.age > time_to_live then
+
+			self.itemstring = ""
+			self.object:remove()
+
+			add_effects(pos)
+
+			return true
 		end
 
-		--Only collect items if not moving
+		return false
-		if is_moving then
+	end,
+
+	step_check_custom_step = function(self, dtime, moveresult)
+
+		local pos = self.object:get_pos()
+
+		-- do custom step function
+		local name = ItemStack(self.itemstring):get_name() or ""
+		local custom = core.registered_items[name]
+			and core.registered_items[name].dropped_step
+
+		if custom and custom(self, pos, dtime, moveresult) == false then
+			return true -- skip further checks if false
+		end
+
+		return false
+	end,
+
+	step_try_collect = function(self)
+
+		local self_pos = self.object:get_pos()
+
+		-- Don't collect items if falling
+		if self.falling_state then
+			return
+		end
+
+		-- Check if we should collect items while sliding
+		if self.slippery_state and not items_collect_on_slippery then
 			return
 		end
 
@@ -501,16 +551,19 @@ core.register_entity(":__builtin:item", {
 			return
 		end
 
-		local objects = core.get_objects_inside_radius(pos, 1.0)
+		local objects = core.get_objects_inside_radius(self_pos, 1.0)
 
-		for k, obj in pairs(objects) do
+		for _, obj in pairs(objects) do
 
 			local entity = obj:get_luaentity()
 
-			if entity and entity.name == "__builtin:item" then
+			if entity and entity.name == "__builtin:item" and not entity.is_falling then
 
 				if self:try_merge_with(own_stack, obj, entity) then
 
+					-- item will be moved up due to try_merge_with
+					self.falling_state = true
+
 					own_stack = ItemStack(self.itemstring)
 
 					if own_stack:get_free_space() == 0 then
@@ -521,6 +574,41 @@ core.register_entity(":__builtin:item", {
 		end
 	end,
 
+	on_step = function(self, dtime, moveresult)
+
+		-- reset acceleration
+		self.accel = {x = 0, y = 0, z = 0}
+
+		-- check item timeout
+		if self:step_check_timeout(dtime) then
+			return -- deleted, stop here
+		end
+
+		-- check custom step function
+		if self:step_check_custom_step(dtime, moveresult) then
+			return -- overriden
+		end
+
+		-- do general checks
+		self:step_update_node_state(moveresult, dtime)
+
+		if self:step_node_inside_checks() then
+			return -- destroyed
+		end
+
+		self:step_check_slippery()
+
+		-- do physics checks, then apply
+		self:step_water_physics()
+		self:step_ground_friction()
+		self:step_gravity()
+
+		self:step_apply_forces()
+
+		-- do item checks
+		self:step_try_collect()
+	end,
+
 	on_punch = function(self, hitter)
 
 		local inv = hitter:get_inventory()

mods/builtin_item/init.lua_

@@ -0,0 +1,541 @@
+-- Minetest: builtin/item_entity.lua
+
+-- override ice to make slippery for 0.4.16
+if not minetest.raycast then
+	minetest.override_item("default:ice", {
+		groups = {cracky = 3, puts_out_fire = 1, cools_lava = 1, slippery = 3}})
+end
+
+
+function core.spawn_item(pos, item)
+
+	local stack = ItemStack(item)
+	local obj = core.add_entity(pos, "__builtin:item")
+
+	if obj then
+		obj:get_luaentity():set_item(stack:to_string())
+	end
+
+	return obj
+end
+
+
+-- If item_entity_ttl is not set, enity will have default life time
+-- Setting it to -1 disables the feature
+
+local time_to_live = tonumber(core.settings:get("item_entity_ttl")) or 900
+local gravity = tonumber(core.settings:get("movement_gravity")) or 9.81
+local destroy_item = core.settings:get_bool("destroy_item") ~= false
+
+
+-- water flow functions by QwertyMine3, edited by TenPlus1
+local inv_roots = {
+	[0] = 1
+}
+
+local function to_unit_vector(dir_vector)
+
+	local sum = dir_vector.x * dir_vector.x + dir_vector.z * dir_vector.z
+	local invr_sum = 0
+
+	-- find inverse square root if possible
+	if inv_roots[sum] ~= nil then
+		invr_sum = inv_roots[sum]
+	else
+		-- not found, compute and save the inverse square root
+		invr_sum = 1.0 / math.sqrt(sum)
+		inv_roots[sum] = invr_sum
+	end
+
+	return {
+		x = dir_vector.x * invr_sum,
+		y = dir_vector.y,
+		z = dir_vector.z * invr_sum
+	}
+end
+
+
+local function node_ok(pos)
+
+	local node = minetest.get_node_or_nil(pos)
+
+	if node and minetest.registered_nodes[node.name] then
+		return node
+	end
+
+	return minetest.registered_nodes["default:dirt"]
+end
+
+
+local function quick_flow_logic(node, pos_testing, direction)
+
+	local node_testing = node_ok(pos_testing)
+	local param2 = node.param2
+
+	if not minetest.registered_nodes[node.name].groups.liquid then
+		param2 = 0
+	end
+
+	if minetest.registered_nodes[node_testing.name].liquidtype ~= "flowing"
+	and minetest.registered_nodes[node_testing.name].liquidtype ~= "source" then
+		return 0
+	end
+
+	local param2_testing = node_testing.param2
+
+	if param2_testing < param2 then
+
+		if (param2 - param2_testing) > 6 then
+			return -direction
+		else
+			return direction
+		end
+
+	elseif param2_testing > param2 then
+
+		if (param2_testing - param2) > 6 then
+			return direction
+		else
+			return -direction
+		end
+	end
+
+	return 0
+end
+
+
+-- reciprocal of the length of an unit square's diagonal
+local DIAG_WEIGHT = 2 / math.sqrt(2)
+
+local function quick_flow(pos, node)
+
+	local x, z = 0.0, 0.0
+
+	x = x + quick_flow_logic(node, {x = pos.x - 1, y = pos.y, z = pos.z},-1)
+	x = x + quick_flow_logic(node, {x = pos.x + 1, y = pos.y, z = pos.z}, 1)
+	z = z + quick_flow_logic(node, {x = pos.x, y = pos.y, z = pos.z - 1},-1)
+	z = z + quick_flow_logic(node, {x = pos.x, y = pos.y, z = pos.z + 1}, 1)
+
+	return to_unit_vector({x = x, y = 0, z = z})
+end
+-- END water flow functions
+
+
+-- particle effects for when item is destroyed
+local function add_effects(pos)
+
+	minetest.add_particlespawner({
+		amount = 1,
+		time = 0.25,
+		minpos = pos,
+		maxpos = pos,
+		minvel = {x = -1, y = 2, z = -1},
+		maxvel = {x = 1, y = 4, z = 1},
+		minacc = {x = 0, y = 0, z = 0},
+		maxacc = {x = 0, y = 0, z = 0},
+		minexptime = 1,
+		maxexptime = 3,
+		minsize = 1,
+		maxsize = 4,
+		texture = "tnt_smoke.png",
+	})
+end
+
+
+local water_force = 0.8
+local water_friction = 0.8
+local dry_friction = 2.5
+
+core.register_entity(":__builtin:item", {
+
+	initial_properties = {
+		hp_max = 1,
+		physical = true,
+		collide_with_objects = false,
+		collisionbox = {-0.3, -0.3, -0.3, 0.3, 0.3, 0.3},
+		visual = "wielditem",
+		visual_size = {x = 0.4, y = 0.4},
+		textures = {""},
+		spritediv = {x = 1, y = 1},
+		initial_sprite_basepos = {x = 0, y = 0},
+		is_visible = false,
+		infotext = "",
+	},
+
+	itemstring = "",
+	moving_state = true,
+	slippery_state = false,
+	age = 0,
+
+	set_item = function(self, item)
+
+		local stack = ItemStack(item or self.itemstring)
+
+		self.itemstring = stack:to_string()
+
+		if self.itemstring == "" then
+			return
+		end
+
+		local itemname = stack:is_known() and stack:get_name() or "unknown"
+		local max_count = stack:get_stack_max()
+		local count = math.min(stack:get_count(), max_count)
+		local size = 0.2 + 0.1 * (count / max_count) ^ (1 / 3)
+		local col_height = size * 0.75
+		local def = core.registered_nodes[itemname]
+		local glow = def and def.light_source
+		local c1, c2 = "",""
+
+		if not(stack:get_count() == 1) then
+			c1 = " x"..tostring(stack:get_count())
+			c2 = " "..tostring(stack:get_count())
+		end
+
+		local name1 = stack:get_meta():get_string("description")
+		local name
+
+		if name1 == "" then
+			name = core.registered_items[itemname].description
+		else
+			name = name1
+		end
+
+		self.object:set_properties({
+			is_visible = true,
+			visual = "wielditem",
+			textures = {itemname},
+			visual_size = {x = size, y = size},
+			collisionbox = {-size, -col_height, -size, size, col_height, size},
+			selectionbox = {-size, -size, -size, size, size, size},
+			automatic_rotate = 0.314 / size,
+			wield_item = self.itemstring,
+			glow = glow,
+			infotext = name .. c1 .. "\n(" .. itemname .. c2 .. ")"
+		})
+
+	end,
+
+	get_staticdata = function(self)
+
+		return core.serialize({
+			itemstring = self.itemstring,
+			age = self.age,
+			dropped_by = self.dropped_by
+		})
+	end,
+
+	on_activate = function(self, staticdata, dtime_s)
+
+		if string.sub(staticdata, 1, string.len("return")) == "return" then
+
+			local data = core.deserialize(staticdata)
+
+			if data and type(data) == "table" then
+				self.itemstring = data.itemstring
+				self.age = (data.age or 0) + dtime_s
+				self.dropped_by = data.dropped_by
+			end
+		else
+			self.itemstring = staticdata
+		end
+
+		self.object:set_armor_groups({immortal = 1})
+		self.object:set_velocity({x = 0, y = 2, z = 0})
+		self.object:set_acceleration({x = 0, y = -gravity, z = 0})
+		self:set_item()
+	end,
+
+	try_merge_with = function(self, own_stack, object, entity)
+
+		if self.age == entity.age then
+			return false -- Can not merge with itself
+		end
+
+		local stack = ItemStack(entity.itemstring)
+		local name = stack:get_name()
+
+		if own_stack:get_name() ~= name
+		or own_stack:get_meta() ~= stack:get_meta()
+		or own_stack:get_wear() ~= stack:get_wear()
+		or own_stack:get_free_space() == 0 then
+			return false -- Can not merge different or full stack
+		end
+
+		local count = own_stack:get_count()
+		local total_count = stack:get_count() + count
+		local max_count = stack:get_stack_max()
+
+		if total_count > max_count then
+			return false
+		end
+
+		-- Merge the remote stack into this one
+		local pos = object:get_pos()
+		pos.y = pos.y + ((total_count - count) / max_count) * 0.15
+
+		self.object:move_to(pos)
+		self.age = 0 -- Handle as new entity
+
+		own_stack:set_count(total_count)
+		self:set_item(own_stack)
+
+		entity.itemstring = ""
+		object:remove()
+
+		return true
+	end,
+
+	on_step = function(self, dtime, moveresult)
+
+		local pos = self.object:get_pos()
+
+		self.age = self.age + dtime
+
+		if time_to_live > 0 and self.age > time_to_live then
+
+			self.itemstring = ""
+			self.object:remove()
+
+			add_effects(pos)
+
+			return
+		end
+
+		-- get nodes every 1/4 second
+		self.timer = (self.timer or 0) + dtime
+
+		if self.timer > 0.25 or not self.node_inside then
+
+			self.node_inside = minetest.get_node_or_nil(pos)
+			self.def_inside = self.node_inside
+					and core.registered_nodes[self.node_inside.name]
+
+			-- get ground node for collision
+			self.node_under = nil
+
+			if moveresult.touching_ground then
+
+				for _, info in ipairs(moveresult.collisions) do
+
+					if info.axis == "y" then
+
+						self.node_under = core.get_node(info.node_pos)
+
+						break
+					end
+				end
+			end
+
+			self.def_under = self.node_under
+					and core.registered_nodes[self.node_under.name]
+
+			self.timer = 0
+		end
+
+		local node = self.node_inside
+
+		-- Delete in 'ignore' nodes
+		if node and node.name == "ignore" then
+
+			self.itemstring = ""
+			self.object:remove()
+
+			return
+		end
+
+		-- do custom step function
+		local name = ItemStack(self.itemstring):get_name() or ""
+		local custom = core.registered_items[name]
+			and core.registered_items[name].dropped_step
+
+		if custom and custom(self, pos, dtime) == false then
+			return -- skip further checks if false
+		end
+
+		local vel = self.object:get_velocity()
+		local def = self.def_inside
+		local is_slippery = false
+		local is_moving = (def and not def.walkable) or
+			vel.x ~= 0 or vel.y ~= 0 or vel.z ~= 0
+
+		-- destroy item when dropped into lava (if enabled)
+		if destroy_item and def and def.groups and def.groups.lava then
+
+			minetest.sound_play("builtin_item_lava", {
+				pos = pos,
+				max_hear_distance = 6,
+				gain = 0.5
+			})
+
+			self.itemstring = ""
+			self.object:remove()
+
+			add_effects(pos)
+
+			return
+		end
+
+		-- water flowing
+		if def and def.liquidtype == "flowing" then
+
+			-- force applies on acceleration over time, thus multiply
+			local force = water_force * dtime
+			-- friction applies on velocity over time,     thus exponentiate
+			local friction = (1.0 + water_friction) ^ dtime
+
+			-- get flow velocity and current vel/acc state
+			local vec = quick_flow(pos, node)
+			local a = self.object:get_acceleration()
+
+			self.object:set_acceleration({
+				x = a.x + vec.x * force,
+				y = a.y,
+				z = a.z + vec.z * force
+			})
+
+			-- apply friction to prevent items going too fast, and also to make
+			-- water flow override previous horizontal momentum more quickly
+
+			local v = self.object:get_velocity()
+
+			-- adjust friction for going against the current
+			local v_horz = { x = v.x, y = 0, z = v.z }
+			local v_dir = to_unit_vector(v_horz)
+			local flow_dot = v_dir.x * vec.x + v_dir.y * vec.y
+
+			-- also maps flow_dot from [-1,0] to [0.5,2.5]
+			friction = 1.0 + ((friction - 1.0) * (flow_dot + 1.5))
+
+			self.object:set_velocity({
+				x = v.x / friction,
+				y = v.y / friction,
+				z = v.z / friction
+			})
+
+			return
+		end
+
+		-- item inside block, move to vacant space
+		if def and (def.walkable == nil or def.walkable == true)
+		and (def.collision_box == nil or def.collision_box.type == "regular")
+		and (def.node_box == nil or def.node_box.type == "regular") then
+
+			local npos = minetest.find_node_near(pos, 1, "air")
+
+			if npos then
+				self.object:move_to(npos)
+			end
+
+			self.node_inside = nil -- force get_node
+
+			return
+		end
+
+		-- Switch locals to node under
+		node = self.node_under
+		def = self.def_under
+
+
+		-- Slippery node check
+		if def and def.walkable then
+
+			local slippery = core.get_item_group(node.name, "slippery")
+
+			is_slippery = slippery ~= 0
+
+			if is_slippery and (math.abs(vel.x) > 0.2 or math.abs(vel.z) > 0.2) then
+
+				-- Horizontal deceleration
+				local slip_factor = 4.0 / (slippery + 4)
+
+				self.object:set_acceleration({
+					x = -vel.x * slip_factor,
+					y = 0,
+					z = -vel.z * slip_factor
+				})
+
+			elseif vel.y == 0 then
+				is_moving = false
+			end
+		end
+
+		if self.moving_state == is_moving
+		and self.slippery_state == is_slippery then
+			return -- No further updates until moving state changes
+		end
+
+		self.moving_state = is_moving
+		self.slippery_state = is_slippery
+
+		local a_curr = self.object:get_acceleration()
+		local v_curr = self.object:get_velocity()
+
+		if is_moving then
+
+			self.object:set_acceleration({
+				x = a_curr.x,
+				y = a_curr.y - gravity,
+				z = a_curr.z
+			})
+		else
+			self.object:set_acceleration({x = 0, y = 0, z = 0})
+
+			-- preserve *some* velocity so items don't get stuck on the very ledges
+			-- of nodes once they move just enough to leave the hitbox of flowing water
+			self.object:set_velocity({
+				x = v_curr.x / dry_friction,
+				y = v_curr.y / dry_friction,
+				z = v_curr.z / dry_friction
+			})
+		end
+
+		--Only collect items if not moving
+		if is_moving then
+			return
+		end
+
+		-- Collect the items around to merge with
+		local own_stack = ItemStack(self.itemstring)
+
+		if own_stack:get_free_space() == 0 then
+			return
+		end
+
+		local objects = core.get_objects_inside_radius(pos, 1.0)
+
+		for k, obj in pairs(objects) do
+
+			local entity = obj:get_luaentity()
+
+			if entity and entity.name == "__builtin:item" then
+
+				if self:try_merge_with(own_stack, obj, entity) then
+
+					own_stack = ItemStack(self.itemstring)
+
+					if own_stack:get_free_space() == 0 then
+						return
+					end
+				end
+			end
+		end
+	end,
+
+	on_punch = function(self, hitter)
+
+		local inv = hitter:get_inventory()
+
+		if inv and self.itemstring ~= "" then
+
+			local left = inv:add_item("main", self.itemstring)
+
+			if left and not left:is_empty() then
+				self:set_item(left)
+				return
+			end
+		end
+
+		self.itemstring = ""
+		self.object:remove()
+	end,
+})

mods/builtin_item/settingtypes.txt

@@ -0,0 +1,40 @@
+# Controls how much force should be exerted on
+# dropped items when they are pushed by flowing water.
+#
+# The larger this number, the faster items become when
+# carried by water.
+waterflow_force (Force of water flow on dropped items) float 1.6
+
+# Controls how much drag force should be exerted on
+# dropped items when they are submerged in flowing water
+# but have a different momentum vector than the flow velocity.
+#
+# The larger this number, the larger the resistance of water
+# to the push of an item. In other words, items thrown at
+# flowing water in a direction opposite that of the flow will
+# be pushed more quickly in the other direction with higher drag,
+# even if the actual flow force remains the same.
+waterflow_drag (Drag of water flow on dropped items) float 0.8
+
+# Controls how much friction force should be exerted on
+# dropped items when they move horizontally on the
+# ground.
+#
+# The larger this number, the quickier items will come to
+# a halt horizontally after falling on the floor.
+friction_dry (Friction of dry ground on dropped items) float 2.5
+
+# Controls how much horizontal drag force should be exerted on
+# dropped items when they move horizontally in air.
+#
+# The larger this number, the quickier horizontal velocity tends
+# toward zero.
+air_drag (Horizontal drag of air on falling items) float 0.4
+
+# Allow items on the floor to collect even on slippery floors.
+#
+# Dropped items can 'collect', that is, to have their
+# stacks merged if they're close enough and are of the same item
+# type. By default they can do this even on a slippery floor, like
+# ice, but this setting allows disabling that.
+builtin_item.items_collect_on_slippery (Collect items on slippery ground) bool true

mods/cottages/nodes_anvil.lua

@@ -229,9 +229,9 @@ minetest.register_node("cottages:anvil", {
 		end
 		minetest.after(2, function()
 			if( puncher ) then
-				puncher:hud_remove(hud1);
+				if(hud1) then puncher:hud_remove(hud1); end
-				puncher:hud_remove(hud2);
+				if(hud2) then puncher:hud_remove(hud2); end
-				puncher:hud_remove(hud3);
+				if(hud3) then puncher:hud_remove(hud3); end
 			end
 		end)
 

mods/cottages/nodes_straw.lua

@@ -333,13 +333,13 @@ minetest.register_node("cottages:threshing_floor", {
 
 		minetest.after(2, function()
 			if( puncher ) then
-				puncher:hud_remove(hud1);
+				if(hud1) then puncher:hud_remove(hud1); end
-				puncher:hud_remove(hud2);
+				if(hud2) then puncher:hud_remove(hud2); end
-				puncher:hud_remove(hud3);
+				if(hud3) then puncher:hud_remove(hud3); end
-				puncher:hud_remove(hud4);
+				if(hud4) then puncher:hud_remove(hud4); end
-				puncher:hud_remove(hud5);
+				if(hud5) then puncher:hud_remove(hud5); end
-				puncher:hud_remove(hud6);
+				if(hud6) then puncher:hud_remove(hud6); end
-				puncher:hud_remove(hud0);
+				if(hud0) then puncher:hud_remove(hud0); end
 			end
 		end)
 	end,

mods/farming/food.lua

@@ -348,7 +348,6 @@ minetest.register_craftitem("farming:pasta", {
 	groups = {food_pasta = 1}
 })
 
-if minetest.get_modpath("mobs_animal") or minetest.get_modpath("xanadu")then
 minetest.register_craft({
 	output = "farming:pasta",
 	type = "shapeless",
@@ -358,7 +357,7 @@ minetest.register_craft({
 	},
 	replacements = {{"group:food_mixing_bowl", "farming:mixing_bowl"}}
 })
-else
+
 minetest.register_craft({
 	output = "farming:pasta",
 	type = "shapeless",
@@ -371,7 +370,6 @@ minetest.register_craft({
 		{"group:food_oil", "vessels:glass_bottle"}
 	}
 })
-end
 
 -- Spaghetti
 
@@ -399,7 +397,6 @@ minetest.register_craftitem("farming:bibimbap", {
 	on_use = minetest.item_eat(8, "farming:bowl")
 })
 
-if minetest.get_modpath("mobs_animal") or minetest.get_modpath("xanadu")then
 minetest.register_craft({
 	output = "farming:bibimbap",
 	type = "shapeless",
@@ -410,7 +407,7 @@ minetest.register_craft({
 	},
 	replacements = {{"group:food_skillet", "farming:skillet"}}
 })
-else
+
 minetest.register_craft({
 	output = "farming:bibimbap",
 	type = "shapeless",
@@ -421,7 +418,6 @@ minetest.register_craft({
 	},
 	replacements = {{"group:food_skillet", "farming:skillet"}}
 })
-end
 
 -- Burger
 

mods/farming/locale/zh_CN.txt

@@ -59,7 +59,7 @@ Cornstarch=玉米淀粉
 Bottle of Ethanol=一瓶乙醇
 Cotton Seed=棉籽
 Cotton=棉花
-String=字符串
+String=线
 Cucumber=黄瓜
 Garlic clove=蒜瓣
 Garlic=大蒜

mods/farming/soil.lua

@@ -148,7 +148,7 @@ minetest.register_abm({
 		if minetest.registered_nodes[nn]
 		and minetest.registered_nodes[nn].walkable
 		and minetest.get_item_group(nn, "plant") == 0 then
-			minetest.set_node(pos, {name = "default:dirt"})
+			minetest.set_node(pos, {name = ndef.soil.base})
 			return
 		end
 

mods/homedecor_modpack/homedecor_books/init.lua

@@ -27,7 +27,7 @@ for _, c in ipairs(bookcolors) do
 	local color, hue = unpack(c)
 
 	local function book_dig(pos, node, digger)
-		if minetest.is_protected(pos, digger:get_player_name()) then return end
+		if not digger or minetest.is_protected(pos, digger:get_player_name()) then return end
 		local meta = minetest.get_meta(pos)
 		local data = minetest.serialize({
 			title = meta:get_string("title") or "",

mods/homedecor_modpack/homedecor_lighting/init.lua

@@ -162,7 +162,10 @@ if minetest.get_modpath("digilines") then
 		if puncher:get_player_control().sneak then
 			local name = puncher:get_player_name()
 			player_last_clicked[name] = pos
-			local form = "field[channel;Channel;]"
+			local form = "formspec_version[4]"..
+					"size[8,4]"..
+					"button_exit[3,2.5;2,0.5;proceed;Proceed]"..
+					"field[1.75,1.5;4.5,0.5;channel;Channel;]"
 			minetest.show_formspec(name, "homedecor:lamp_set_channel", form)
 		end
 	end

mods/ilights/init.lua

@@ -141,7 +141,10 @@ if minetest.get_modpath("digilines") then
 			local name = puncher:get_player_name()
 			player_last_clicked[name] = pos
 			local meta = minetest.get_meta(pos)
-			local form = "field[channel;Channel;]"
+			local form = "formspec_version[4]"..
+					"size[8,4]"..
+					"button_exit[3,2.5;2,0.5;proceed;Proceed]"..
+					"field[1.75,1.5;4.5,0.5;channel;Channel;]"
 			minetest.show_formspec(name, "ilights:set_channel", form)
 		end
 	end

mods/intllib/init.lua

@@ -201,7 +201,8 @@ function intllib.get_strings(modname, langcode)
 		local modpath = minetest.get_modpath(modname)
 		msgstr = { }
 		for _, l in ipairs(get_locales(langcode)) do
-			local t = intllib.load_strings(modpath.."/locale/"..l..".txt") or { }
+			local t = intllib.load_strings(modpath.."/locale/"..modname.."."..l..".tr")
+				or intllib.load_strings(modpath.."/locale/"..l..".txt") or { }
 			for k, v in pairs(t) do
 				msgstr[k] = msgstr[k] or v
 			end

mods/skinsdb/meta/character_1950.txt

@@ -0,0 +1,3 @@
+Effy
+aonymous
+CC BY-SA 3.0

mods/stamina/init.lua

@@ -31,7 +31,7 @@ SPRINT_DRAIN = 0.35			-- how fast to drain satation while sprinting (0-1)
 local function get_int_attribute(player)
 
 	-- pipeworks fake player check
-	if not player.get_attribute then
+	if not player or not player.get_attribute then
 		return nil
 	end
 
@@ -204,27 +204,14 @@ local function set_sprinting(name, sprinting)
 end
 
 
--- Time based stamina functions
+local function drunk_tick()
-local stamina_timer, health_timer, action_timer, poison_timer, drunk_timer = 0,0,0,0,0
 
-local function stamina_globaltimer(dtime)
+	for _,player in ipairs(minetest.get_connected_players()) do
-
-	stamina_timer = stamina_timer + dtime
-	health_timer = health_timer + dtime
-	action_timer = action_timer + dtime
-	poison_timer = poison_timer + dtime
-	drunk_timer = drunk_timer + dtime
-
-	local players = minetest.get_connected_players()
-
-	-- simulate drunk walking (thanks LumberJ)
-	if drunk_timer > 1.0 then
-
-		for _,player in pairs(players) do
 
 		local name = player:get_player_name()
 
-			if stamina.players[name]
+		if name
+		and stamina.players[name]
 		and stamina.players[name].drunk then
 
 			-- play burp sound every 20 seconds when drunk
@@ -242,66 +229,63 @@ local function stamina_globaltimer(dtime)
 				stamina.players[name].drunk = nil
 				stamina.players[name].units = 0
 
+				if not stamina.players[name].poisoned then
+
 					player:hud_change(stamina.players[name].hud_id,
 							"text", "stamina_hud_fg.png")
 				end
+			end
 
 			-- effect only works when not riding boat/cart/horse etc.
 			if not player:get_attach() then
 
-					local yaw = player:get_look_horizontal()
+				local yaw = player:get_look_horizontal() + math.random(-0.5, 0.5)
-
-					yaw = yaw + math.random(-0.5, 0.5)
 
 				player:set_look_horizontal(yaw)
 			end
 		end
-
-			drunk_timer = 0
 	end
 end
 
 
-	-- hurt player when poisoned
+local function health_tick()
-	if poison_timer > STAMINA_POISON_TICK then
 
-		for _,player in pairs(players) do
+	for _,player in ipairs(minetest.get_connected_players()) do
 
+		local air = player:get_breath() or 0
+		local hp = player:get_hp()
+		local h = get_int_attribute(player)
 		local name = player:get_player_name()
 
-			if stamina.players[name]
+		if name then
-			and stamina.players[name].poisoned
-			and stamina.players[name].poisoned > 0 then
 
-				stamina.players[name].poisoned =
+			-- damage player by 1 hp if saturation is < 2
-					stamina.players[name].poisoned - 1
+			if h and h < STAMINA_STARVE_LVL
-
+			and hp > 0 then
-				local hp = player:get_hp() - 1
+				player:set_hp(hp - STAMINA_STARVE, {hunger = true})
-
-				if hp > 0 then
-					player:set_hp(hp, {poison = true})
 			end
 
-			elseif stamina.players[name]
+			-- don't heal if drowning or dead or poisoned
-			and stamina.players[name].poisoned then
+			if h and h >= STAMINA_HEAL_LVL
+			and h >= hp
+			and hp > 0
+			and air > 0
+			and not stamina.players[name].poisoned then
 
-				player:hud_change(stamina.players[name].hud_id,
+				player:set_hp(hp + STAMINA_HEAL)
-						"text", "stamina_hud_fg.png")
 
-				stamina.players[name].poisoned = nil
+				stamina_update_level(player, h - 1)
+			end
 		end
-
-			poison_timer = 0
 	end
 end
 
 
-		-- sprint control and particle animation
+local function action_tick()
-	if action_timer > STAMINA_MOVE_TICK then
 
-		for _,player in pairs(players) do
+	for _,player in ipairs(minetest.get_connected_players()) do
 
-			local controls = player:get_player_control()
+		local controls = player and player:get_player_control()
 
 		-- Determine if the player is walking or jumping
 		if controls then
@@ -320,10 +304,11 @@ local function stamina_globaltimer(dtime)
 		--- START sprint
 		if enable_sprint then
 
-				local name = player:get_player_name()
+			local name = player and player:get_player_name()
 
 			-- check if player can sprint (stamina must be over 6 points)
-				if stamina.players[name]
+			if name
+			and stamina.players[name]
 			and not stamina.players[name].poisoned
 			and not stamina.players[name].drunk
 			and controls and controls.aux1 and controls.up
@@ -337,7 +322,10 @@ local function stamina_globaltimer(dtime)
 
 					local pos = player:get_pos()
 					local node = minetest.get_node({
-							x = pos.x, y = pos.y - 1, z = pos.z})
+						x = pos.x,
+						y = pos.y - 1,
+						z = pos.z
+					})
 
 					if node.name ~= "air" then
 
@@ -367,65 +355,100 @@ local function stamina_globaltimer(dtime)
 
 				stamina_update_level(player,
 						level - (SPRINT_DRAIN * STAMINA_MOVE_TICK))
-				else
+
+			elseif name then
 				set_sprinting(name, false)
 			end
 		end
 		-- END sprint
-
-			action_timer = 0
 	end
 end
 
 
+local function poison_tick()
+
+	for _,player in ipairs(minetest.get_connected_players()) do
+
+		local name = player and player:get_player_name()
+
+		if name
+		and stamina.players[name]
+		and stamina.players[name].poisoned
+		and stamina.players[name].poisoned > 0 then
+
+			stamina.players[name].poisoned =
+				stamina.players[name].poisoned - 1
+
+			local hp = player:get_hp() - 1
+
+			if hp > 0 then
+				player:set_hp(hp, {poison = true})
+			end
+
+		elseif name
+		and stamina.players[name]
+		and stamina.players[name].poisoned then
+
+			if not stamina.players[name].drunk then
+
+				player:hud_change(stamina.players[name].hud_id,
+						"text", "stamina_hud_fg.png")
+			end
+
+			stamina.players[name].poisoned = nil
+		end
+	end
+end
+
+
+local function stamina_tick()
+
+	for _,player in ipairs(minetest.get_connected_players()) do
+
+		local h = get_int_attribute(player)
+
+		if h and h > STAMINA_TICK_MIN then
+			stamina_update_level(player, h - 1)
+		end
+	end
+end
+
+
+-- Time based stamina functions
+local stamina_timer, health_timer, action_timer, poison_timer, drunk_timer = 0,0,0,0,0
+
+local function stamina_globaltimer(dtime)
+
+	stamina_timer = stamina_timer + dtime
+	health_timer = health_timer + dtime
+	action_timer = action_timer + dtime
+	poison_timer = poison_timer + dtime
+	drunk_timer = drunk_timer + dtime
+
+	-- simulate drunk walking (thanks LumberJ)
+	if drunk_timer > 1.0 then
+		drunk_tick() ; drunk_timer = 0
+	end
+
+	-- hurt player when poisoned
+	if poison_timer > STAMINA_POISON_TICK then
+		poison_tick() ; poison_timer = 0
+	end
+
+		-- sprint control and particle animation
+	if action_timer > STAMINA_MOVE_TICK then
+		action_tick() ; action_timer = 0
+	end
+
 	-- lower saturation by 1 point after STAMINA_TICK
 	if stamina_timer > STAMINA_TICK then
-
+		stamina_tick() ; stamina_timer = 0
-		for _,player in pairs(players) do
-
-			local h = get_int_attribute(player)
-
-			if h > STAMINA_TICK_MIN then
-				stamina_update_level(player, h - 1)
 	end
 
-			stamina_timer = 0
-		end
-	end
-
-
 	-- heal or damage player, depending on saturation
 	if health_timer > STAMINA_HEALTH_TICK then
-
+		health_tick() ; health_timer = 0
-		for _,player in pairs(players) do
-
-			local air = player:get_breath() or 0
-			local hp = player:get_hp()
-			local h = get_int_attribute(player)
-			local name = player:get_player_name()
-
-			-- damage player by 1 hp if saturation is < 2 (of 30)
-			if h and h < STAMINA_STARVE_LVL
-			and hp > 0 then
-				player:set_hp(hp - STAMINA_STARVE, {hunger = true})
 	end
-
-			-- don't heal if drowning or dead or poisoned
-			if h and h >= STAMINA_HEAL_LVL
-			and h >= hp
-			and hp > 0
-			and air > 0
-			and not stamina.players[name].poisoned then
-
-				player:set_hp(hp + STAMINA_HEAL)
-
-				stamina_update_level(player, h - 1)
-			end
-
-			health_timer = 0
-		end
-	end
-
 end