Merge branch 'master' into pumpkin_hud

.luacheckrc

@@ -47,6 +47,9 @@ read_globals = {
     --GENERAL
     "default",
 
+    --ENTITIES
+    "cmi",
+
     --HUD
     "sfinv", "sfinv_buttons", "unified_inventory", "cmsg", "inventory_plus",
 }

mods/CORE/_mcl_autogroup/init.lua

@@ -121,7 +121,7 @@ local hardness_values = get_hardness_values_for_groups()
 -- hardness_value.  Used for quick lookup.
 local hardness_lookup = get_hardness_lookup_for_groups(hardness_values)
 
-local function compute_creativetimes(group)
+--[[local function compute_creativetimes(group)
 	local creativetimes = {}
 
 	for index, hardness in pairs(hardness_values[group]) do
@@ -129,7 +129,7 @@ local function compute_creativetimes(group)
 	end
 
 	return creativetimes
-end
+end]]
 
 -- Get the list of digging times for using a specific tool on a specific
 -- diggroup.
@@ -239,13 +239,13 @@ function mcl_autogroup.can_harvest(nodename, toolname)
 end
 
 -- Get one groupcap field for using a specific tool on a specific group.
-local function get_groupcap(group, can_harvest, multiplier, efficiency, uses)
+--[[local function get_groupcap(group, can_harvest, multiplier, efficiency, uses)
 	return {
 		times = get_digtimes(group, can_harvest, multiplier, efficiency),
 		uses = uses,
 		maxlevel = 0,
 	}
-end
+end]]
 
 -- Returns the tool_capabilities from a tool definition or a default set of
 -- tool_capabilities
@@ -315,12 +315,12 @@ local overwrite = function()
 				newgroups.opaque = 1
 			end
 
-			local creative_breakable = false
+			--local creative_breakable = false
 
 			-- Assign groups used for digging this node depending on
 			-- the registered digging groups
 			for g, gdef in pairs(mcl_autogroup.registered_diggroups) do
-				creative_breakable = true
+				--creative_breakable = true
 				local index = hardness_lookup[g][ndef._mcl_hardness or 0]
 				if ndef.groups[g] then
 					if gdef.levels then

mods/CORE/biomeinfo/init.lua

@@ -81,11 +81,11 @@ if v6_use_snow_biomes then
 end
 local v6_freq_desert = tonumber(minetest.get_mapgen_setting("mgv6_freq_desert") or 0.45)
 
-local NOISE_MAGIC_X = 1619
-local NOISE_MAGIC_Y = 31337
-local NOISE_MAGIC_Z = 52591
-local NOISE_MAGIC_SEED = 1013
-local noise2d = function(x, y, seed)
+--local NOISE_MAGIC_X = 1619
+--local NOISE_MAGIC_Y = 31337
+--local NOISE_MAGIC_Z = 52591
+--local NOISE_MAGIC_SEED = 1013
+local function noise2d(x, y, seed)
 	-- TODO: implement noise2d function for biome blend
 	return 0
 --[[

mods/CORE/flowlib/init.lua

@@ -1,95 +1,100 @@
+local math = math
+
+local get_node = minetest.get_node
+local get_item_group = minetest.get_item_group
+
+local registered_nodes = minetest.registered_nodes
+
 flowlib = {}
 
 --sum of direction vectors must match an array index
+
+--(sum,root)
+--(0,1), (1,1+0=1), (2,1+1=2), (3,1+2^2=5), (4,2^2+2^2=8)
+
+local inv_roots = {
+	[0] = 1,
+	[1] = 1,
+	[2] = 0.70710678118655,
+	[4] = 0.5,
+	[5] = 0.44721359549996,
+	[8] = 0.35355339059327,
+}
+
 local function to_unit_vector(dir_vector)
-	--(sum,root)
-	-- (0,1), (1,1+0=1), (2,1+1=2), (3,1+2^2=5), (4,2^2+2^2=8)
-	local inv_roots = {[0] = 1, [1] = 1, [2] = 0.70710678118655, [4] = 0.5
-		, [5] = 0.44721359549996, [8] = 0.35355339059327}
-	local sum = dir_vector.x*dir_vector.x + dir_vector.z*dir_vector.z
-	return {x=dir_vector.x*inv_roots[sum],y=dir_vector.y
-		,z=dir_vector.z*inv_roots[sum]}
+	local sum = dir_vector.x * dir_vector.x + dir_vector.z * dir_vector.z
+	return {x = dir_vector.x * inv_roots[sum], y = dir_vector.y, z = dir_vector.z * inv_roots[sum]}
 end
 
-local is_touching = function(realpos,nodepos,radius)
+local function is_touching(realpos,nodepos,radius)
 	local boarder = 0.5 - radius
-	return (math.abs(realpos - nodepos) > (boarder))
+	return math.abs(realpos - nodepos) > (boarder)
 end
 
 flowlib.is_touching = is_touching
 
-local is_water = function(pos)
-	return (minetest.get_item_group(minetest.get_node(
-			{x=pos.x,y=pos.y,z=pos.z}).name
-		, "water") ~= 0)
+local function is_water(pos)
+	return get_item_group(get_node(pos).name, "water") ~= 0
 end
 
 flowlib.is_water = is_water
 
-local node_is_water = function(node)
-	return (minetest.get_item_group(node.name, "water") ~= 0)
+local function node_is_water(node)
+	return get_item_group(node.name, "water") ~= 0
 end
 
 flowlib.node_is_water = node_is_water
 
-local is_lava = function(pos)
-	return (minetest.get_item_group(minetest.get_node(
-			{x=pos.x,y=pos.y,z=pos.z}).name
-		, "lava") ~= 0)
+local function is_lava(pos)
+	return get_item_group(get_node(pos).name, "lava") ~= 0
 end
 
 flowlib.is_lava = is_lava
 
-local node_is_lava = function(node)
-	return (minetest.get_item_group(node.name, "lava") ~= 0)
+local function node_is_lava(node)
+	return get_item_group(node.name, "lava") ~= 0
 end
 
 flowlib.node_is_lava = node_is_lava
 
 
-local is_liquid = function(pos)
-	return (minetest.get_item_group(minetest.get_node(
-			{x=pos.x,y=pos.y,z=pos.z}).name
-		, "liquid") ~= 0)
+local function is_liquid(pos)
+	return get_item_group(get_node(pos).name, "liquid") ~= 0
 end
 
 flowlib.is_liquid = is_liquid
 
-local node_is_liquid = function(node)
-	return (minetest.get_item_group(node.name, "liquid") ~= 0)
+local function node_is_liquid(node)
+	return minetest.get_item_group(node.name, "liquid") ~= 0
 end
 
 flowlib.node_is_liquid = node_is_liquid
 
 --This code is more efficient
-local function quick_flow_logic(node,pos_testing,direction)
+local function quick_flow_logic(node, pos_testing, direction)
 	local name = node.name
-	if not minetest.registered_nodes[name] then
+	if not registered_nodes[name] then
 		return 0
 	end
-	if minetest.registered_nodes[name].liquidtype == "source" then
-		local node_testing = minetest.get_node(pos_testing)
-		local param2_testing = node_testing.param2
-		if not minetest.registered_nodes[node_testing.name] then
+	if registered_nodes[name].liquidtype == "source" then
+		local node_testing = get_node(pos_testing)
+		if not registered_nodes[node_testing.name] then
 			return 0
 		end
-		if minetest.registered_nodes[node_testing.name].liquidtype 
-		~= "flowing" then
+		if registered_nodes[node_testing.name].liquidtype ~= "flowing" then
 			return 0
 		else
 			return direction
 		end
-	elseif minetest.registered_nodes[name].liquidtype == "flowing" then
-		local node_testing = minetest.get_node(pos_testing)
+	elseif registered_nodes[name].liquidtype == "flowing" then
+		local node_testing = get_node(pos_testing)
 		local param2_testing = node_testing.param2
-		if not minetest.registered_nodes[node_testing.name] then
+		if not registered_nodes[node_testing.name] then
 			return 0
 		end
-		if minetest.registered_nodes[node_testing.name].liquidtype 
-		== "source" then
+		if registered_nodes[node_testing.name].liquidtype == "source" then
 			return -direction
-		elseif minetest.registered_nodes[node_testing.name].liquidtype 
-		== "flowing" then
+		elseif registered_nodes[node_testing.name].liquidtype == "flowing" then
 			if param2_testing < node.param2 then
 				if (node.param2 - param2_testing) > 6 then
 					return -direction
@@ -108,48 +113,41 @@ local function quick_flow_logic(node,pos_testing,direction)
 	return 0
 end
 
-local quick_flow = function(pos,node)
-	local x = 0
-	local z = 0
-	
+local function quick_flow(pos, node)
 	if not node_is_liquid(node)  then
-		return {x=0,y=0,z=0}
+		return {x = 0, y = 0, z = 0}
 	end
-	
-	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})
+	local x = quick_flow_logic(node,{x = pos.x-1, y = pos.y, z = pos.z},-1) + quick_flow_logic(node,{x = pos.x+1, y = pos.y, z = pos.z}, 1)
+	local z = quick_flow_logic(node,{x = pos.x, y = pos.y, z = pos.z-1},-1) + 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
 
 flowlib.quick_flow = quick_flow
 
+--if not in water but touching, move centre to touching block
+--x has higher precedence than z
+--if pos changes with x, it affects z
 
-	--if not in water but touching, move centre to touching block
-	--x has higher precedence than z
-	--if pos changes with x, it affects z
-local move_centre = function(pos,realpos,node,radius)
-	if is_touching(realpos.x,pos.x,radius) then
-		if is_liquid({x=pos.x-1,y=pos.y,z=pos.z}) then
-			node = minetest.get_node({x=pos.x-1,y=pos.y,z=pos.z})
-			pos = {x=pos.x-1,y=pos.y,z=pos.z}
-		elseif is_liquid({x=pos.x+1,y=pos.y,z=pos.z}) then
-			node = minetest.get_node({x=pos.x+1,y=pos.y,z=pos.z})
-			pos = {x=pos.x+1,y=pos.y,z=pos.z}
+local function move_centre(pos, realpos, node, radius)
+	if is_touching(realpos.x, pos.x, radius) then
+		if is_liquid({x = pos.x-1, y = pos.y, z = pos.z}) then
+			node = get_node({x=pos.x-1, y = pos.y, z = pos.z})
+			pos = {x = pos.x-1, y = pos.y, z = pos.z}
+		elseif is_liquid({x = pos.x+1, y = pos.y, z = pos.z}) then
+			node = get_node({x = pos.x+1, y = pos.y, z = pos.z})
+			pos = {x = pos.x+1, y = pos.y, z = pos.z}
 		end
 	end
-	if is_touching(realpos.z,pos.z,radius) then
-		if is_liquid({x=pos.x,y=pos.y,z=pos.z-1}) then
-			node = minetest.get_node({x=pos.x,y=pos.y,z=pos.z-1})
-			pos = {x=pos.x,y=pos.y,z=pos.z-1}
-		elseif is_liquid({x=pos.x,y=pos.y,z=pos.z+1}) then
-			node = minetest.get_node({x=pos.x,y=pos.y,z=pos.z+1})
-			pos = {x=pos.x,y=pos.y,z=pos.z+1}
+	if is_touching(realpos.z, pos.z, radius) then
+		if is_liquid({x = pos.x, y = pos.y, z = pos.z - 1}) then
+			node = get_node({x = pos.x, y = pos.y, z = pos.z - 1})
+			pos = {x = pos.x, y = pos.y, z = pos.z - 1}
+		elseif is_liquid({x = pos.x, y = pos.y, z = pos.z + 1}) then
+			node = get_node({x = pos.x, y = pos.y, z = pos.z + 1})
+			pos = {x = pos.x, y = pos.y, z = pos.z + 1}
 		end
 	end
-	return pos,node
+	return pos, node
 end
 
 flowlib.move_centre = move_centre

mods/CORE/mcl_explosions/init.lua

@@ -13,9 +13,7 @@ under the LGPLv2.1 license.
 mcl_explosions = {}
 
 local mod_fire = minetest.get_modpath("mcl_fire") ~= nil
-local CONTENT_FIRE = minetest.get_content_id("mcl_fire:fire")
-
-local S = minetest.get_translator("mcl_explosions")
+--local CONTENT_FIRE = minetest.get_content_id("mcl_fire:fire")
 
 local hash_node_position = minetest.hash_node_position
 local get_objects_inside_radius = minetest.get_objects_inside_radius
@@ -174,14 +172,11 @@ local function trace_explode(pos, strength, raydirs, radius, info, direct, sourc
 
 	local ystride = (emax.x - emin_x + 1)
 	local zstride = ystride * (emax.y - emin_y + 1)
-	local pos_x = pos.x
-	local pos_y = pos.y
-	local pos_z = pos.z
 
-	local area = VoxelArea:new {
+	--[[local area = VoxelArea:new {
 		MinEdge = emin,
 		MaxEdge = emax
-	}
+	}]]
 	local data = vm:get_data()
 	local destroy = {}
 

mods/CORE/mcl_explosions/locale/mcl_explosions.de.tr

@@ -1,2 +0,0 @@
-# textdomain:mcl_explosions
-@1 was caught in an explosion.=@1 wurde Opfer einer Explosion.

mods/CORE/mcl_explosions/locale/mcl_explosions.fr.tr

@@ -1,2 +0,0 @@
-# textdomain:mcl_explosions
-@1 was caught in an explosion.=@1 a été pris dans une explosion.

mods/CORE/mcl_explosions/locale/mcl_explosions.ru.tr

@@ -1,2 +0,0 @@
-# textdomain:mcl_explosions
-@1 was caught in an explosion.=@1 не удалось пережить взрыва.

mods/CORE/mcl_explosions/locale/template.txt

@@ -1,2 +0,0 @@
-# textdomain:mcl_explosions
-@1 was caught in an explosion.=

mods/CORE/mcl_loot/init.lua

@@ -40,10 +40,9 @@ function mcl_loot.get_loot(loot_definitions, pr)
 		total_weight = total_weight + (loot_definitions.items[i].weight or 1)
 	end
 
-	local stacks_min = loot_definitions.stacks_min
-	local stacks_max = loot_definitions.stacks_max
-	if not stacks_min then stacks_min = 1 end
-	if not stacks_max then stacks_max = 1 end
+	--local stacks_min = loot_definitions.stacks_min or 1
+	--local stacks_max = loot_definitions.stacks_max or 1
+
 	local stacks = pr:next(loot_definitions.stacks_min, loot_definitions.stacks_max)
 	for s=1, stacks do
 		local r = pr:next(1, total_weight)

mods/CORE/mcl_particles/init.lua

@@ -1,3 +1,12 @@
+local vector = vector
+local table = table
+
+local hash_node_position = minetest.hash_node_position
+local add_particlespawner = minetest.add_particlespawner
+local delete_particlespawner = minetest.delete_particlespawner
+
+local ipairs = ipairs
+
 mcl_particles = {}
 
 -- Table of particlespawner IDs on a per-node hash basis
@@ -32,11 +41,11 @@ function mcl_particles.add_node_particlespawner(pos, particlespawner_definition,
 	if allowed_level == 0 or levels[level] > allowed_level then
 		return
 	end
-	local poshash = minetest.hash_node_position(pos)
+	local poshash = hash_node_position(pos)
 	if not poshash then
 		return
 	end
-	local id = minetest.add_particlespawner(particlespawner_definition)
+	local id = add_particlespawner(particlespawner_definition)
 	if id == -1 then
 		return
 	end
@@ -47,6 +56,8 @@ function mcl_particles.add_node_particlespawner(pos, particlespawner_definition,
 	return id
 end
 
+local add_node_particlespawner = mcl_particles.add_node_particlespawner
+
 -- Deletes all particlespawners that are assigned to a node position.
 -- If no particlespawners exist for this position, nothing happens.
 -- pos: Node positon. MUST use integer values!
@@ -55,11 +66,11 @@ function mcl_particles.delete_node_particlespawners(pos)
 	if allowed_level == 0 then
 		return false
 	end
-	local poshash = minetest.hash_node_position(pos)
+	local poshash = hash_node_position(pos)
 	local ids = particle_nodes[poshash]
 	if ids then
 		for i=1, #ids do
-			minetest.delete_particlespawner(ids[i])
+			delete_particlespawner(ids[i])
 		end
 		particle_nodes[poshash] = nil
 		return true
@@ -72,7 +83,6 @@ end
 local smoke_pdef_cached = {}
 
 function mcl_particles.spawn_smoke(pos, name, smoke_pdef_base)
-	local min = math.min
 	local new_minpos = vector.add(pos, smoke_pdef_base.minrelpos)
 	local new_maxpos = vector.add(pos, smoke_pdef_base.maxrelpos)
 
@@ -81,7 +91,7 @@ function mcl_particles.spawn_smoke(pos, name, smoke_pdef_base)
 		for i, smoke_pdef in ipairs(smoke_pdef_cached[name]) do
 			smoke_pdef.minpos = new_minpos
 			smoke_pdef.maxpos = new_maxpos
-			mcl_particles.add_node_particlespawner(pos, smoke_pdef, "high")
+			add_node_particlespawner(pos, smoke_pdef, "high")
 		end
 		-- cache already populated
 	else
@@ -111,11 +121,9 @@ function mcl_particles.spawn_smoke(pos, name, smoke_pdef_base)
 				smoke_pdef.animation.length = exptime + 0.1
 				-- minexptime must be set such that the last frame is actully rendered,
 				-- even if its very short. Larger exptime -> larger range
-				smoke_pdef.minexptime = min(exptime, (7.0/8.0 * (exptime + 0.1) + 0.1))
+				smoke_pdef.minexptime = math.min(exptime, (7.0/8.0 * (exptime + 0.1) + 0.1))
 				smoke_pdef.texture = "mcl_particles_smoke_anim.png^[colorize:#000000:" ..colorize
-
-				mcl_particles.add_node_particlespawner(pos, smoke_pdef, "high")
-
+				add_node_particlespawner(pos, smoke_pdef, "high")
 				table.insert(smoke_pdef_cached[name], table.copy(smoke_pdef))
 			end
 		end

mods/CORE/mcl_util/init.lua

@@ -457,9 +457,7 @@ function mcl_util.calculate_durability(itemstack)
 			end
 		end
 		if not uses then
-			local toolcaps = itemstack:get_tool_capabilities()
-			local groupcaps = toolcaps.groupcaps
-			for _, v in pairs(groupcaps) do
+			for _, v in pairs(itemstack:get_tool_capabilities().groupcaps) do
 				uses = v.uses
 				break
 			end

mods/CORE/mcl_worlds/init.lua

@@ -33,15 +33,15 @@ end
 -- If the Y coordinate is not located in any dimension, it will return:
 --     nil, "void"
 function mcl_worlds.y_to_layer(y)
-       if y >= mcl_vars.mg_overworld_min then
-               return y - mcl_vars.mg_overworld_min, "overworld"
-       elseif y >= mcl_vars.mg_nether_min and y <= mcl_vars.mg_nether_max+128 then
-               return y - mcl_vars.mg_nether_min, "nether"
-       elseif y >= mcl_vars.mg_end_min and y <= mcl_vars.mg_end_max then
-               return y - mcl_vars.mg_end_min, "end"
-       else
-               return nil, "void"
-       end
+	if y >= mcl_vars.mg_overworld_min then
+		return y - mcl_vars.mg_overworld_min, "overworld"
+	elseif y >= mcl_vars.mg_nether_min and y <= mcl_vars.mg_nether_max+128 then
+		return y - mcl_vars.mg_nether_min, "nether"
+	elseif y >= mcl_vars.mg_end_min and y <= mcl_vars.mg_end_max then
+		return y - mcl_vars.mg_end_min, "end"
+	else
+		return nil, "void"
+	end
 end
 
 -- Takes a pos and returns the dimension it belongs to (same as above)
@@ -55,38 +55,38 @@ end
 -- MineClone 2.
 -- mc_dimension is one of "overworld", "nether", "end" (default: "overworld").
 function mcl_worlds.layer_to_y(layer, mc_dimension)
-       if mc_dimension == "overworld" or mc_dimension == nil then
-               return layer + mcl_vars.mg_overworld_min
-       elseif mc_dimension == "nether" then
-               return layer + mcl_vars.mg_nether_min
-       elseif mc_dimension == "end" then
-               return layer + mcl_vars.mg_end_min
-       end
+	   if mc_dimension == "overworld" or mc_dimension == nil then
+			   return layer + mcl_vars.mg_overworld_min
+	   elseif mc_dimension == "nether" then
+			   return layer + mcl_vars.mg_nether_min
+	   elseif mc_dimension == "end" then
+			   return layer + mcl_vars.mg_end_min
+	   end
 end
 
 -- Takes a position and returns true if this position can have weather
 function mcl_worlds.has_weather(pos)
-       -- Weather in the Overworld and the high part of the void below
-       return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64
+	-- Weather in the Overworld and the high part of the void below
+	return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64
 end
 
 -- Takes a position and returns true if this position can have Nether dust
 function mcl_worlds.has_dust(pos)
-       -- Weather in the Overworld and the high part of the void below
-       return pos.y <= mcl_vars.mg_nether_max + 138 and pos.y >= mcl_vars.mg_nether_min - 10
+	-- Weather in the Overworld and the high part of the void below
+	return pos.y <= mcl_vars.mg_nether_max + 138 and pos.y >= mcl_vars.mg_nether_min - 10
 end
 
 -- Takes a position (pos) and returns true if compasses are working here
 function mcl_worlds.compass_works(pos)
-       -- It doesn't work in Nether and the End, but it works in the Overworld and in the high part of the void below
-       local _, dim = mcl_worlds.y_to_layer(pos.y)
-       if dim == "nether" or dim == "end" then
-               return false
-       elseif dim == "void" then
-               return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64
-       else
-               return true
-       end
+	-- It doesn't work in Nether and the End, but it works in the Overworld and in the high part of the void below
+	local _, dim = mcl_worlds.y_to_layer(pos.y)
+	if dim == "nether" or dim == "end" then
+		return false
+	elseif dim == "void" then
+		return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64
+	else
+		return true
+	end
 end
 
 -- Takes a position (pos) and returns true if clocks are working here
@@ -112,11 +112,11 @@ local last_dimension = {}
 -- * player: Player who changed the dimension
 -- * dimension: New dimension ("overworld", "nether", "end", "void")
 function mcl_worlds.dimension_change(player, dimension)
-    local playername = player:get_player_name()
+	local playername = player:get_player_name()
 	for i=1, #mcl_worlds.registered_on_dimension_change do
 		mcl_worlds.registered_on_dimension_change[i](player, dimension, last_dimension[playername])
 	end
-    last_dimension[playername] = dimension
+	last_dimension[playername] = dimension
 end
 
 ----------------------- INTERNAL STUFF ----------------------

mods/CORE/walkover/init.lua

@@ -31,24 +31,21 @@ minetest.register_globalstep(function(dtime)
 	timer = timer + dtime;
 	if timer >= 0.3 then
 		for _,player in pairs(get_connected_players()) do
-	    local pp = player:get_pos()
-	    pp.y = ceil(pp.y)
-            local loc = vector_add(pp, {x=0,y=-1,z=0})
-            if loc ~= nil then
-               
-                local nodeiamon = get_node(loc)
-                
-                if nodeiamon ~= nil then
-                    if on_walk[nodeiamon.name] then
-                        on_walk[nodeiamon.name](loc, nodeiamon, player)
-                    end
-                    for i = 1, #registered_globals do
+		local pp = player:get_pos()
+		pp.y = ceil(pp.y)
+			local loc = vector_add(pp, {x=0,y=-1,z=0})
+			if loc ~= nil then
+				local nodeiamon = get_node(loc)
+				if nodeiamon ~= nil then
+					if on_walk[nodeiamon.name] then
+						on_walk[nodeiamon.name](loc, nodeiamon, player)
+					end
+					for i = 1, #registered_globals do
 						registered_globals[i](loc, nodeiamon, player)
-                    end
-                end   
-            end
-        end
-	 
+					end
+				end
+			end
+		end
 		timer = 0
 	end
 end)

mods/ENTITIES/drippingwater/init.lua

@@ -1,6 +1,8 @@
 --Dripping Water Mod
 --by kddekadenz
 
+local math = math
+
 -- License of code, textures & sounds: CC0
 
 --Drop entities
@@ -20,26 +22,21 @@ minetest.register_entity("drippingwater:drop_water", {
 	spritediv = {x=1, y=1},
 	initial_sprite_basepos = {x=0, y=0},
 	static_save = false,
-
 	on_activate = function(self, staticdata)
 		self.object:set_sprite({x=0,y=0}, 1, 1, true)
 	end,
-
 	on_step = function(self, dtime)
-	local k = math.random(1,222)
-	local ownpos = self.object:get_pos()
-
-	if k==1 then
-	self.object:set_acceleration({x=0, y=-5, z=0})
-	end
-
-	if minetest.get_node({x=ownpos.x, y=ownpos.y +0.5, z=ownpos.z}).name == "air" then
-	self.object:set_acceleration({x=0, y=-5, z=0})
-	end
-	
+		local k = math.random(1,222)
+		local ownpos = self.object:get_pos()
+		if k==1 then
+			self.object:set_acceleration({x=0, y=-5, z=0})
+		end
+		if minetest.get_node({x=ownpos.x, y=ownpos.y +0.5, z=ownpos.z}).name == "air" then
+			self.object:set_acceleration({x=0, y=-5, z=0})
+		end
 		if minetest.get_node({x=ownpos.x, y=ownpos.y -0.5, z=ownpos.z}).name ~= "air" then
-		self.object:remove()
-		minetest.sound_play({name="drippingwater_drip"}, {pos = ownpos, gain = 0.5, max_hear_distance = 8}, true)
+			self.object:remove()
+			minetest.sound_play({name="drippingwater_drip"}, {pos = ownpos, gain = 0.5, max_hear_distance = 8}, true)
 		end
 	end,
 })
@@ -61,27 +58,21 @@ minetest.register_entity("drippingwater:drop_lava", {
 	spritediv = {x=1, y=1},
 	initial_sprite_basepos = {x=0, y=0},
 	static_save = false,
-
 	on_activate = function(self, staticdata)
 		self.object:set_sprite({x=0,y=0}, 1, 0, true)
 	end,
-
 	on_step = function(self, dtime)
-	local k = math.random(1,222)
-	local ownpos = self.object:get_pos()
-
-	if k==1 then
-	self.object:set_acceleration({x=0, y=-5, z=0})
-	end
-
-	if minetest.get_node({x=ownpos.x, y=ownpos.y +0.5, z=ownpos.z}).name == "air" then
-	self.object:set_acceleration({x=0, y=-5, z=0})
-	end
-
-		
+		local k = math.random(1,222)
+		local ownpos = self.object:get_pos()
+		if k == 1 then
+			self.object:set_acceleration({x=0, y=-5, z=0})
+		end
+		if minetest.get_node({x=ownpos.x, y=ownpos.y +0.5, z=ownpos.z}).name == "air" then
+			self.object:set_acceleration({x=0, y=-5, z=0})
+		end
 		if minetest.get_node({x=ownpos.x, y=ownpos.y -0.5, z=ownpos.z}).name ~= "air" then
-		self.object:remove()
-		minetest.sound_play({name="drippingwater_lavadrip"}, {pos = ownpos, gain = 0.5, max_hear_distance = 8}, true)
+			self.object:remove()
+			minetest.sound_play({name="drippingwater_lavadrip"}, {pos = ownpos, gain = 0.5, max_hear_distance = 8}, true)
 		end
 	end,
 })
@@ -90,36 +81,34 @@ minetest.register_entity("drippingwater:drop_lava", {
 
 --Create drop
 
-minetest.register_abm(
-        {
+minetest.register_abm({
 	label = "Create water drops",
 	nodenames = {"group:opaque", "group:leaves"},
 	neighbors = {"group:water"},
-        interval = 2,
-        chance = 22,
-        action = function(pos)
-		if minetest.get_item_group(minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name, "water") ~= 0 and
-				minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "air" then
+	interval = 2,
+	chance = 22,
+	action = function(pos)
+		if minetest.get_item_group(minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name, "water") ~= 0
+			and minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "air" then
 			local i = math.random(-45,45) / 100
 			minetest.add_entity({x=pos.x + i, y=pos.y - 0.501, z=pos.z + i}, "drippingwater:drop_water")
 		end
-        end,
+	end,
 })
 
 --Create lava drop
 
-minetest.register_abm(
-        {
+minetest.register_abm({
 	label = "Create lava drops",
 	nodenames = {"group:opaque"},
 	neighbors = {"group:lava"},
-        interval = 2,
-        chance = 22,
-        action = function(pos)
-		if minetest.get_item_group(minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name, "lava") ~= 0 and
-				minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "air" then
+	interval = 2,
+	chance = 22,
+	action = function(pos)
+		if minetest.get_item_group(minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name, "lava") ~= 0
+			and	minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "air" then
 			local i = math.random(-45,45) / 100
 			minetest.add_entity({x=pos.x + i, y=pos.y - 0.501, z=pos.z + i}, "drippingwater:drop_lava")
 		end
-        end,
+	end,
 })

mods/ENTITIES/mcl_boats/init.lua

@@ -328,10 +328,10 @@ function boat.on_step(self, dtime, moveresult)
 
 	p.y = p.y - boat_y_offset
 	local new_velo
-	local new_acce = {x = 0, y = 0, z = 0}
+	local new_acce
 	if not is_water(p) and not on_ice then
 		-- Not on water or inside water: Free fall
-		local nodedef = minetest.registered_nodes[minetest.get_node(p).name]
+		--local nodedef = minetest.registered_nodes[minetest.get_node(p).name]
 		new_acce = {x = 0, y = -9.8, z = 0}
 		new_velo = get_velocity(self._v, self.object:get_yaw(),
 			self.object:get_velocity().y)

mods/ENTITIES/mcl_burning/api.lua

@@ -1,5 +1,3 @@
-local S = minetest.get_translator("mcl_burning")
-
 function mcl_burning.get_storage(obj)
 	return obj:is_player() and mcl_burning.storage[obj] or obj:get_luaentity()
 end

mods/ENTITIES/mcl_burning/init.lua

@@ -1,5 +1,4 @@
-local S = minetest.get_translator("mcl_burning")
-local modpath = minetest.get_modpath("mcl_burning")
+local modpath = minetest.get_modpath(minetest.get_current_modname())
 
 mcl_burning = {
 	storage = {},
@@ -56,7 +55,6 @@ minetest.register_on_leaveplayer(function(player)
 	local storage = mcl_burning.storage[player]
 	storage.fire_hud_id = nil
 	player:get_meta():set_string("mcl_burning:data", minetest.serialize(storage))
-
 	mcl_burning.storage[player] = nil
 end)
 
@@ -70,10 +68,8 @@ minetest.register_entity("mcl_burning:fire", {
 		glow = -1,
 		backface_culling = false,
 	},
-
 	animation_frame = 0,
 	animation_timer = 0,
-
 	on_step = function(self, dtime)
 		local parent, storage = self:sanity_check()
 

mods/ENTITIES/mcl_falling_nodes/init.lua

@@ -1,7 +1,4 @@
-local S = minetest.get_translator("mcl_falling_nodes")
-local has_mcl_armor = minetest.get_modpath("mcl_armor")
-
-local get_falling_depth = function(self)
+local function get_falling_depth(self)
 	if not self._startpos then
 		-- Fallback
 		self._startpos = self.object:get_pos()
@@ -9,7 +6,7 @@ local get_falling_depth = function(self)
 	return self._startpos.y - vector.round(self.object:get_pos()).y
 end
 
-local deal_falling_damage = function(self, dtime)
+local function deal_falling_damage(self, dtime)
 	if minetest.get_item_group(self.node.name, "falling_node_damage") == 0 then
 		return
 	end
@@ -38,7 +35,7 @@ local deal_falling_damage = function(self, dtime)
 						inv:set_stack("armor", 2, helmet)
 					end
 				end
-				local deathmsg, dmg_type
+				local dmg_type
 				if minetest.get_item_group(self.node.name, "anvil") ~= 0 then
 					dmg_type = "anvil"
 				else
@@ -60,10 +57,8 @@ minetest.register_entity(":__builtin:falling_node", {
 		collide_with_objects = false,
 		collisionbox = {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
 	},
-
 	node = {},
 	meta = {},
-
 	set_node = function(self, node, meta)
 		local def = minetest.registered_nodes[node.name]
 		-- Change falling node if definition tells us to
@@ -90,7 +85,6 @@ minetest.register_entity(":__builtin:falling_node", {
 			glow = glow,
 		})
 	end,
-
 	get_staticdata = function(self)
 		local meta = self.meta
 		-- Workaround: Save inventory seperately from metadata.
@@ -111,7 +105,6 @@ minetest.register_entity(":__builtin:falling_node", {
 		}
 		return minetest.serialize(ds)
 	end,
-
 	on_activate = function(self, staticdata)
 		self.object:set_armor_groups({immortal = 1})
 
@@ -134,7 +127,6 @@ minetest.register_entity(":__builtin:falling_node", {
 		end
 		self._startpos = vector.round(self._startpos)
 	end,
-
 	on_step = function(self, dtime)
 		-- Set gravity
 		local acceleration = self.object:get_acceleration()
@@ -186,10 +178,9 @@ minetest.register_entity(":__builtin:falling_node", {
 				return
 			end
 			local nd = minetest.registered_nodes[n2.name]
-			if n2.name == "mcl_portals:portal_end" then
-				-- TODO: Teleport falling node.
-
-			elseif (nd and nd.buildable_to == true) or minetest.get_item_group(self.node.name, "crush_after_fall") ~= 0 then
+			--if n2.name == "mcl_portals:portal_end" then
+			-- TODO: Teleport falling node.
+            if (nd and nd.buildable_to == true) or minetest.get_item_group(self.node.name, "crush_after_fall") ~= 0 then
 				-- Replace destination node if it's buildable to
 				minetest.remove_node(np)
 				-- Run script hook
@@ -256,7 +247,6 @@ minetest.register_entity(":__builtin:falling_node", {
 				self.object:set_pos(npos)
 			end
 		end
-
 		deal_falling_damage(self, dtime)
 	end
 })

mods/ENTITIES/mcl_falling_nodes/locale/mcl_falling_nodes.de.tr

@@ -1,3 +0,0 @@
-# textdomain: mcl_falling_nodes
-@1 was smashed by a falling anvil.=@1 wurde von einem fallenden Amboss zerschmettert.
-@1 was smashed by a falling block.=@1 wurde von einem fallenden Block zerschmettert.

mods/ENTITIES/mcl_falling_nodes/locale/mcl_falling_nodes.es.tr

@@ -1,3 +0,0 @@
-# textdomain: mcl_falling_nodes
-@1 was smashed by a falling anvil.=@1 fue aplastado por la caída de un yunque.
-@1 was smashed by a falling block.=@1 fue aplastado por la caída de un bloque.

mods/ENTITIES/mcl_falling_nodes/locale/mcl_falling_nodes.fr.tr

@@ -1,3 +0,0 @@
-# textdomain: mcl_falling_nodes
-@1 was smashed by a falling anvil.=@1 a été écrasé par une enclume qui tombait.
-@1 was smashed by a falling block.=@1 a été écrasé par un bloc qui tombait.

mods/ENTITIES/mcl_falling_nodes/locale/mcl_falling_nodes.ru.tr

@@ -1,3 +0,0 @@
-# textdomain: mcl_falling_nodes
-@1 was smashed by a falling anvil.=@1 придавило падающей наковальней.
-@1 was smashed by a falling block.=@1 раздавило падающим блоком.

mods/ENTITIES/mcl_falling_nodes/locale/template.txt

@@ -1,3 +0,0 @@
-# textdomain: mcl_falling_nodes
-@1 was smashed by a falling anvil.=
-@1 was smashed by a falling block.=

mods/ENTITIES/mcl_item_entity/init.lua

@@ -426,13 +426,9 @@ minetest.register_entity(":__builtin:item", {
 		if itemtable then
 			itemname = stack:to_table().name
 		end
-		local item_texture = nil
-		local item_type = ""
 		local glow
 		local def = minetest.registered_items[itemname]
 		if def then
-			item_texture = def.inventory_image
-			item_type = def.type
 			description = def.description
 			glow = def.light_source
 		end

mods/ENTITIES/mcl_minecarts/functions.lua

@@ -1,3 +1,5 @@
+local vector = vector
+
 function mcl_minecarts:get_sign(z)
 	if z == 0 then
 		return 0
@@ -38,11 +40,9 @@ end
 
 function mcl_minecarts:check_front_up_down(pos, dir_, check_down, railtype)
 	local dir = vector.new(dir_)
-	local cur = nil
-	
 	-- Front
 	dir.y = 0
-	cur = vector.add(pos, dir)
+	local cur = vector.add(pos, dir)
 	if mcl_minecarts:is_rail(cur, railtype) then
 		return dir
 	end
@@ -65,7 +65,7 @@ end
 
 function mcl_minecarts:get_rail_direction(pos_, dir, ctrl, old_switch, railtype)
 	local pos = vector.round(pos_)
-	local cur = nil
+	local cur
 	local left_check, right_check = true, true
 
 	-- Check left and right
@@ -122,7 +122,6 @@ function mcl_minecarts:get_rail_direction(pos_, dir, ctrl, old_switch, railtype)
 			return cur
 		end
 	end
-	
 	-- Backwards
 	if not old_switch then
 		cur = mcl_minecarts:check_front_up_down(pos, {
@@ -134,7 +133,5 @@ function mcl_minecarts:get_rail_direction(pos_, dir, ctrl, old_switch, railtype)
 			return cur
 		end
 	end
-	
 	return {x=0, y=0, z=0}
 end
-

mods/ENTITIES/mcl_minecarts/init.lua

@@ -486,7 +486,6 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 		if update.pos then
 			self.object:set_pos(pos)
 		end
-		update = nil
 	end
 
 	function cart:get_staticdata()
@@ -817,31 +816,30 @@ minetest.register_craft({
 })
 
 -- TODO: Re-enable crafting of special minecarts when they have been implemented
-if false then
-	minetest.register_craft({
-		output = "mcl_minecarts:furnace_minecart",
-		recipe = {
-			{"mcl_furnaces:furnace"},
-			{"mcl_minecarts:minecart"},
-		},
-	})
+--[[minetest.register_craft({
+	output = "mcl_minecarts:furnace_minecart",
+	recipe = {
+		{"mcl_furnaces:furnace"},
+		{"mcl_minecarts:minecart"},
+	},
+})
 
-	minetest.register_craft({
-		output = "mcl_minecarts:hopper_minecart",
-		recipe = {
-			{"mcl_hoppers:hopper"},
-			{"mcl_minecarts:minecart"},
-		},
-	})
+minetest.register_craft({
+	output = "mcl_minecarts:hopper_minecart",
+	recipe = {
+		{"mcl_hoppers:hopper"},
+		{"mcl_minecarts:minecart"},
+	},
+})
+
+minetest.register_craft({
+	output = "mcl_minecarts:chest_minecart",
+	recipe = {
+		{"mcl_chests:chest"},
+		{"mcl_minecarts:minecart"},
+	},
+})]]
 
-	minetest.register_craft({
-		output = "mcl_minecarts:chest_minecart",
-		recipe = {
-			{"mcl_chests:chest"},
-			{"mcl_minecarts:minecart"},
-		},
-	})
-end
 
 if has_mcl_wip then
 	mcl_wip.register_wip_item("mcl_minecarts:chest_minecart")

mods/ENTITIES/mcl_mobs/api/api.lua

@@ -11,133 +11,111 @@ local minetest_get_objects_inside_radius    = minetest.get_objects_inside_radius
 local minetest_get_modpath                  = minetest.get_modpath
 local minetest_registered_nodes             = minetest.registered_nodes
 local minetest_get_node                     = minetest.get_node
-local minetest_get_item_group               = minetest.get_item_group
+--local minetest_get_item_group               = minetest.get_item_group
 local minetest_registered_entities          = minetest.registered_entities
-local minetest_line_of_sight                = minetest.line_of_sight
-local minetest_after                        = minetest.after
-local minetest_sound_play                   = minetest.sound_play
-local minetest_add_particlespawner          = minetest.add_particlespawner
-local minetest_registered_items             = minetest.registered_items
-local minetest_set_node                     = minetest.set_node
+--local minetest_line_of_sight                = minetest.line_of_sight
+--local minetest_after                        = minetest.after
+--local minetest_sound_play                   = minetest.sound_play
+--local minetest_add_particlespawner          = minetest.add_particlespawner
+--local minetest_registered_items             = minetest.registered_items
+--local minetest_set_node                     = minetest.set_node
 local minetest_add_item                     = minetest.add_item
-local minetest_get_craft_result             = minetest.get_craft_result
-local minetest_find_path                    = minetest.find_path
-local minetest_is_protected                 = minetest.is_protected
+--local minetest_get_craft_result             = minetest.get_craft_result
+--local minetest_find_path                    = minetest.find_path
 local minetest_is_creative_enabled          = minetest.is_creative_enabled
-local minetest_find_node_near               = minetest.find_node_near
-local minetest_find_nodes_in_area_under_air = minetest.find_nodes_in_area_under_air
-local minetest_raycast                      = minetest.raycast
-local minetest_get_us_time                  = minetest.get_us_time
+--local minetest_find_node_near               = minetest.find_node_near
+--local minetest_find_nodes_in_area_under_air = minetest.find_nodes_in_area_under_air
+--local minetest_raycast                      = minetest.raycast
+--local minetest_get_us_time                  = minetest.get_us_time
 local minetest_add_entity                   = minetest.add_entity
-local minetest_get_natural_light            = minetest.get_natural_light
-local minetest_get_node_or_nil              = minetest.get_node_or_nil
+--local minetest_get_natural_light            = minetest.get_natural_light
+--local minetest_get_node_or_nil              = minetest.get_node_or_nil
 
 -- localize math functions
-local math_pi     = math.pi
-local math_sin    = math.sin
-local math_cos    = math.cos
-local math_abs    = math.abs
-local math_min    = math.min
-local math_max    = math.max
-local math_atan   = math.atan
-local math_random = math.random
-local math_floor  = math.floor
+local math = math
 
 -- localize vector functions
-local vector_new    = vector.new
-local vector_add    = vector.add
-local vector_length = vector.length
-local vector_direction = vector.direction
-local vector_normalize = vector.normalize
-local vector_multiply = vector.multiply
-local vector_divide  = vector.divide
+local vector = vector
+
+local string = string
 
 -- mob constants
-local BREED_TIME          = 30
-local BREED_TIME_AGAIN    = 300
-local CHILD_GROW_TIME     = 60*20
-local DEATH_DELAY         = 0.5
+--local BREED_TIME          = 30
+--local BREED_TIME_AGAIN    = 300
+--local CHILD_GROW_TIME     = 60*20
+--local DEATH_DELAY         = 0.5
 local DEFAULT_FALL_SPEED  = -10
-local FLOP_HEIGHT         = 5.0
-local FLOP_HOR_SPEED      = 1.5
+--local FLOP_HEIGHT         = 5.0
+--local FLOP_HOR_SPEED      = 1.5
 local GRAVITY             = minetest_settings:get("movement_gravity")-- + 9.81
 
+local MAX_MOB_NAME_LENGTH = 30
 
-local MOB_CAP   = {}
+
+--[[local MOB_CAP   = {}
 MOB_CAP.hostile = 70
 MOB_CAP.passive = 10
 MOB_CAP.ambient = 15
 MOB_CAP.water   = 15
+]]
 
 -- Load main settings
-local damage_enabled    = minetest_settings:get_bool("enable_damage")
-local disable_blood     = minetest_settings:get_bool("mobs_disable_blood")
-local mobs_drop_items   = minetest_settings:get_bool("mobs_drop_items") ~= false
-local mobs_griefing     = minetest_settings:get_bool("mobs_griefing") ~= false
-local spawn_protected   = minetest_settings:get_bool("mobs_spawn_protected") ~= false
-local remove_far        = true
+--local damage_enabled    = minetest_settings:get_bool("enable_damage")
+--local disable_blood     = minetest_settings:get_bool("mobs_disable_blood")
+--local mobs_drop_items   = minetest_settings:get_bool("mobs_drop_items") ~= false
+--local mobs_griefing     = minetest_settings:get_bool("mobs_griefing") ~= false
+--local spawn_protected   = minetest_settings:get_bool("mobs_spawn_protected") ~= false
+--local remove_far        = true
 local difficulty        = tonumber(minetest_settings:get("mob_difficulty")) or 1.0
-local show_health       = false
-local max_per_block     = tonumber(minetest_settings:get("max_objects_per_block") or 64)
-local mobs_spawn_chance = tonumber(minetest_settings:get("mobs_spawn_chance") or 2.5)
+--local show_health       = false
+--local max_per_block     = tonumber(minetest_settings:get("max_objects_per_block") or 64)
+---local mobs_spawn_chance = tonumber(minetest_settings:get("mobs_spawn_chance") or 2.5)
 
 -- pathfinding settings
-local enable_pathfinding = true
-local stuck_timeout      = 3 -- how long before mob gets stuck in place and starts searching
-local stuck_path_timeout = 10 -- how long will mob follow path before giving up
+--local enable_pathfinding = true
+--local stuck_timeout      = 3 -- how long before mob gets stuck in place and starts searching
+--local stuck_path_timeout = 10 -- how long will mob follow path before giving up
 
 -- default nodes
-local node_ice       = "mcl_core:ice"
-local node_snowblock = "mcl_core:snowblock"
-local node_snow      = "mcl_core:snow"
+--local node_ice       = "mcl_core:ice"
+--local node_snowblock = "mcl_core:snowblock"
+--local node_snow      = "mcl_core:snow"
 mobs.fallback_node   = minetest.registered_aliases["mapgen_dirt"] or "mcl_core:dirt"
 
-local mod_weather     = minetest_get_modpath("mcl_weather") ~= nil
-local mod_explosions  = minetest_get_modpath("mcl_explosions") ~= nil
-local mod_mobspawners = minetest_get_modpath("mcl_mobspawners") ~= nil
-local mod_hunger      = minetest_get_modpath("mcl_hunger") ~= nil
-local mod_worlds      = minetest_get_modpath("mcl_worlds") ~= nil
-local mod_armor       = minetest_get_modpath("mcl_armor") ~= nil
-local mod_experience  = minetest_get_modpath("mcl_experience") ~= nil
+--local mod_weather     = minetest_get_modpath("mcl_weather")
+--local mod_explosions  = minetest_get_modpath("mcl_explosions")
+local mod_mobspawners = minetest_get_modpath("mcl_mobspawners")
+--local mod_hunger      = minetest_get_modpath("mcl_hunger")
+--local mod_worlds      = minetest_get_modpath("mcl_worlds")
+--local mod_armor       = minetest_get_modpath("mcl_armor")
+--local mod_experience  = minetest_get_modpath("mcl_experience")
 
 
 -- random locals I found
-local los_switcher    = false
-local height_switcher = false
+--local los_switcher    = false
+--local height_switcher = false
 
 -- Get translator
 local S = minetest.get_translator("mcl_mobs")
 
 -- CMI support check
-local use_cmi = minetest.global_exists("cmi")
-
-
--- Invisibility mod check
-mobs.invis = {}
-if minetest.global_exists("invisibility") then
-	mobs.invis = invisibility
-end
-
+--local use_cmi = minetest.global_exists("cmi")
 
 -- creative check
 function mobs.is_creative(name)
 	return minetest_is_creative_enabled(name)
 end
 
-
-local atan = function(x)
+--[[local function atan(x)
 	if not x or x ~= x then
 		return 0
 	else
-		return math_atan(x)
+		return math.atan(x)
 	end
-end
-
-
-
+end]]
 
 -- Shows helpful debug info above each mob
-local mobs_debug = minetest_settings:get_bool("mobs_debug", false)
+--local mobs_debug = minetest_settings:get_bool("mobs_debug", false)
 
 -- Peaceful mode message so players will know there are no monsters
 if minetest_settings:get_bool("only_peaceful_mobs", false) then
@@ -191,7 +169,7 @@ function mobs:register_mob(name, def)
 		if (not value) or (value == default) or (value == special) then
 			return default
 		else
-			return math_max(min, value * difficulty)
+			return math.max(min, value * difficulty)
 		end
 	end
 
@@ -366,15 +344,11 @@ function mobs:register_mob(name, def)
 		random_sound_timer_min = 3,
 		random_sound_timer_max = 10,
 
-
 		--head code variables
 		--defaults are for the cow's default
 		--because I don't know what else to set them
 		--to :P
 
-		has_head = def.has_head or false,
-		head_bone = def.head_bone,
-
 		--you must use these to adjust the mob's head positions
 
 		--has_head is used as a logic gate (quick easy check)
@@ -444,7 +418,7 @@ function mobs:register_mob(name, def)
 		--on_detach_child = mob_detach_child,
 
 		on_activate = function(self, staticdata, dtime)
-			self.object:set_acceleration(vector_new(0,-GRAVITY, 0))
+			self.object:set_acceleration(vector.new(0,-GRAVITY, 0))
 			return mobs.mob_activate(self, staticdata, def, dtime)
 		end,
 
@@ -556,10 +530,10 @@ function mobs:register_arrow(name, def)
 			and def.tail_texture then
 
 				--do this to prevent clipping through main entity sprite
-				local pos_adjustment = vector_multiply(vector_normalize(vel), -1)
+				local pos_adjustment = vector.multiply(vector.normalize(vel), -1)
 				local divider = def.tail_distance_divider or 1
-				pos_adjustment = vector_divide(pos_adjustment, divider)
-				local new_pos = vector_add(pos, pos_adjustment)
+				pos_adjustment = vector.divide(pos_adjustment, divider)
+				local new_pos = vector.add(pos, pos_adjustment)
 				minetest.add_particle({
 					pos = new_pos,
 					velocity = {x = 0, y = 0, z = 0},
@@ -693,12 +667,12 @@ function mobs:register_egg(mob, desc, background, addegg, no_creative)
 
 			if pos
 			--and within_limits(pos, 0)
-			and not minetest_is_protected(pos, placer:get_player_name()) then
+			and not minetest.is_protected(pos, placer:get_player_name()) then
 
 				local name = placer:get_player_name()
 				local privs = minetest.get_player_privs(name)
 				if mod_mobspawners and under.name == "mcl_mobspawners:spawner" then
-					if minetest_is_protected(pointed_thing.under, name) then
+					if minetest.is_protected(pointed_thing.under, name) then
 						minetest.record_protection_violation(pointed_thing.under, name)
 						return itemstack
 					end
@@ -743,7 +717,7 @@ function mobs:register_egg(mob, desc, background, addegg, no_creative)
 						nametag = string.sub(nametag, 1, MAX_MOB_NAME_LENGTH)
 					end
 					ent.nametag = nametag
-					update_tag(ent)
+					--update_tag(ent)
 				end
 
 				-- if not in creative then take item

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

@@ -1,12 +1,8 @@
-local math_random = math.random
-local math_pi     = math.pi
-local math_floor  = math.floor
-local math_round  = math.round
+local math = math
+local vector = vector
+local string = string
 
-local vector_multiply = vector.multiply
-local vector_add      = vector.add
-local vector_new      = vector.new
-local vector_distance = vector.distance
+local tonumber = tonumber
 
 local minetest_yaw_to_dir                   = minetest.yaw_to_dir
 local minetest_get_item_group               = minetest.get_item_group
@@ -28,7 +24,7 @@ end
 
 --a simple helper function for rounding
 --http://lua-users.org/wiki/SimpleRound
-function round2(num, numDecimalPlaces)
+local function round2(num, numDecimalPlaces)
 	return tonumber(string.format("%." .. (numDecimalPlaces or 0) .. "f", num))
 end
 
@@ -50,24 +46,23 @@ local cliff_check = function(self,dtime)
 	end
 
 	local pos = self.object:get_pos()
-    local dir = minetest_yaw_to_dir(self.yaw)
+	local dir = minetest_yaw_to_dir(self.yaw)
 	local collisionbox = self.object:get_properties().collisionbox
 	local radius = collisionbox[4] + 0.5
 
-	dir = vector_multiply(dir,radius)
+	dir = vector.multiply(dir,radius)
 
-	local free_fall, blocker = minetest_line_of_sight(
+	local free_fall = minetest_line_of_sight(
 		{x = pos.x + dir.x, y = pos.y, z = pos.z + dir.z},
 		{x = pos.x + dir.x, y = pos.y - self.fear_height, z = pos.z + dir.z})
 
 	return free_fall
 end
 
-
 -- state switching logic (stand, walk, run, attacks)
 local land_state_list_wandering = {"stand", "walk"}
 
-local land_state_switch = function(self, dtime)
+local function land_state_switch(self, dtime)
 
 	--do math before sure not attacking, following, or running away so continue
 	--doing random walking for mobs if all states are not met
@@ -137,7 +132,6 @@ local land_state_execution = function(self,dtime)
 		return
 	end
 
-
 	--timer to time out looking for mate
 	if self.breed_lookout_timer and self.breed_lookout_timer > 0 then
 		self.breed_lookout_timer = self.breed_lookout_timer - dtime
@@ -176,12 +170,12 @@ local land_state_execution = function(self,dtime)
 			if velocity.y < 0 then
 				--lua is acting really weird so we have to help it
 				if round2(self.object:get_acceleration().y, 1) == -self.gravity then
-					self.object:set_acceleration(vector_new(0,0,0))
+					self.object:set_acceleration(vector.new(0,0,0))
 					mobs.mob_fall_slow(self)
 				end
 			else
 				if round2(self.object:get_acceleration().y, 1) == 0 then
-					self.object:set_acceleration(vector_new(0,-self.gravity,0))
+					self.object:set_acceleration(vector.new(0,-self.gravity,0))
 				end
 			end
 		end
@@ -207,14 +201,12 @@ local land_state_execution = function(self,dtime)
 
 		mobs.lock_yaw(self)
 	elseif self.state == "follow" then
-
 		--always look at players
 		mobs.set_yaw_while_following(self)
 
 		--check distance
-		local distance_from_follow_person = vector_distance(self.object:get_pos(), self.following_person:get_pos())
+		local distance_from_follow_person = vector.distance(self.object:get_pos(), self.following_person:get_pos())
 		local distance_2d = mobs.get_2d_distance(self.object:get_pos(), self.following_person:get_pos())
-				
 		--don't push the player if too close
 		--don't spin around randomly
 		if self.follow_distance < distance_from_follow_person and self.minimum_follow_distance < distance_2d then
@@ -240,7 +232,7 @@ local land_state_execution = function(self,dtime)
 			self.walk_timer = math.random(1,6) + math.random()
 
 			--set the mob into a random direction
-			self.yaw = (math_random() * (math.pi * 2))
+			self.yaw = (math.random() * (math.pi * 2))
 		end
 
 		--do animation
@@ -253,15 +245,13 @@ local land_state_execution = function(self,dtime)
 		local node_in_front_of = mobs.jump_check(self)
 
 		if node_in_front_of == 1 then
-
 			mobs.jump(self)
-		
-		--turn if on the edge of cliff
-		--(this is written like this because unlike
-		--jump_check which simply tells the mob to jump
-		--this requires a mob to turn, removing the
-		--ease of a full implementation for it in a single
-		--function)
+			--turn if on the edge of cliff
+			--(this is written like this because unlike
+			--jump_check which simply tells the mob to jump
+			--this requires a mob to turn, removing the
+			--ease of a full implementation for it in a single
+			--function)
 		elseif node_in_front_of == 2 or (self.fear_height ~= 0 and cliff_check(self,dtime)) then
 			--turn 45 degrees if so
 			quick_rotate(self,dtime)
@@ -292,9 +282,7 @@ local land_state_execution = function(self,dtime)
 		local node_in_front_of = mobs.jump_check(self)
 
 		if node_in_front_of == 1 then
-
 			mobs.jump(self)
-		
 		--turn if on the edge of cliff
 		--(this is written like this because unlike
 		--jump_check which simply tells the mob to jump
@@ -342,7 +330,7 @@ local land_state_execution = function(self,dtime)
 			mobs.set_velocity(self, self.walk_velocity)
 
 			--smoosh together basically
-			if vector_distance(self.object:get_pos(), mate:get_pos()) <= self.breed_distance then
+			if vector.distance(self.object:get_pos(), mate:get_pos()) <= self.breed_distance then
 				mobs.set_mob_animation(self, "stand")
 				if self.special_breed_timer == 0 then
 					self.special_breed_timer = 2 --breeding takes 2 seconds
@@ -353,7 +341,7 @@ local land_state_execution = function(self,dtime)
 
 					--pop a baby out, it's a miracle!
 					local baby_pos = vector.divide(vector.add(self.object:get_pos(), mate:get_pos()), 2)
-					local baby_mob = minetest.add_entity(pos, self.name, minetest.serialize({baby = true, grow_up_timer = self.grow_up_goal, bred = true}))
+					minetest.add_entity(baby_pos, self.name, minetest.serialize({baby = true, grow_up_timer = self.grow_up_goal, bred = true}))
 
 					mobs.play_sound_specific(self,"item_drop_pickup")
 
@@ -376,13 +364,12 @@ local land_state_execution = function(self,dtime)
 		end
 
 	end
-	
 	if float_now then
 		mobs.float(self)
 	else
 		local acceleration = self.object:get_acceleration()
 		if acceleration and acceleration.y == 0 then
-			self.object:set_acceleration(vector_new(0,-self.gravity,0))
+			self.object:set_acceleration(vector.new(0,-self.gravity,0))
 		end
 	end
 end
@@ -416,16 +403,16 @@ end
 --check if a mob needs to turn while swimming
 local swim_turn_check = function(self,dtime)
 
-    local pos = self.object:get_pos()
-    pos.y = pos.y + 0.1
-    local dir = minetest_yaw_to_dir(self.yaw)
+	local pos = self.object:get_pos()
+	pos.y = pos.y + 0.1
+	local dir = minetest_yaw_to_dir(self.yaw)
 
-    local collisionbox = self.object:get_properties().collisionbox
+	local collisionbox = self.object:get_properties().collisionbox
 	local radius = collisionbox[4] + 0.5
 
-    vector_multiply(dir, radius)
+	vector.multiply(dir, radius)
 
-    local test_dir = vector.add(pos,dir)
+	local test_dir = vector.add(pos,dir)
 
 	local green_flag_1 = minetest_get_item_group(minetest_get_node(test_dir).name, "solid") ~= 0
 
@@ -437,11 +424,11 @@ local swim_physics_swapper = function(self,inside_swim_node)
 
 	--should be swimming, gravity is applied, switch to floating
 	if inside_swim_node and self.object:get_acceleration().y ~= 0 then
-		self.object:set_acceleration(vector_new(0,0,0))
+		self.object:set_acceleration(vector.new(0,0,0))
 	--not be swim, gravity isn't applied, switch to falling
 	elseif not inside_swim_node and self.object:get_acceleration().y == 0 then
 		self.pitch = 0
-		self.object:set_acceleration(vector_new(0,-self.gravity,0))
+		self.object:set_acceleration(vector.new(0,-self.gravity,0))
 	end
 end
 
@@ -482,22 +469,17 @@ local swim_state_execution = function(self,dtime)
 			end
 
 			mobs.lock_yaw(self)
-
 		elseif self.state == "swim" then
-
 			self.walk_timer = self.walk_timer - dtime
-
 			--reset the walk timer
 			if self.walk_timer <= 0 then
-	
 				--re-randomize the walk timer
 				self.walk_timer = math.random(1,6) + math.random()
-	
 				--set the mob into a random direction
-				self.yaw = (math_random() * (math.pi * 2))
+				self.yaw = (math.random() * (math.pi * 2))
 
 				--create a truly random pitch, since there is no easy access to pitch math that I can find
-				self.pitch = math_random() * math.random(1,3) * random_pitch_multiplier[math_random(1,2)]
+				self.pitch = math.random() * math.random(1,3) * random_pitch_multiplier[math.random(1,2)]
 			end
 
 			--do animation
@@ -541,8 +523,8 @@ ______ _
 |  _| | | | | |
 | |   | | |_| |
 \_|   |_|\__, |
-          __/ |
-         |___/ 
+		  __/ |
+		 |___/
 ]]--
 
 -- state switching logic (stand, walk, run, attacks)
@@ -566,16 +548,16 @@ end
 --check if a mob needs to turn while flying
 local fly_turn_check = function(self,dtime)
 
-    local pos = self.object:get_pos()
-    pos.y = pos.y + 0.1
-    local dir = minetest_yaw_to_dir(self.yaw)
+	local pos = self.object:get_pos()
+	pos.y = pos.y + 0.1
+	local dir = minetest_yaw_to_dir(self.yaw)
 
-    local collisionbox = self.object:get_properties().collisionbox
+	local collisionbox = self.object:get_properties().collisionbox
 	local radius = collisionbox[4] + 0.5
 
-    vector_multiply(dir, radius)
+	vector.multiply(dir, radius)
 
-    local test_dir = vector.add(pos,dir)
+	local test_dir = vector.add(pos,dir)
 
 	local green_flag_1 = minetest_get_item_group(minetest_get_node(test_dir).name, "solid") ~= 0
 
@@ -587,11 +569,11 @@ local fly_physics_swapper = function(self,inside_fly_node)
 
 	--should be flyming, gravity is applied, switch to floating
 	if inside_fly_node and self.object:get_acceleration().y ~= 0 then
-		self.object:set_acceleration(vector_new(0,0,0))
+		self.object:set_acceleration(vector.new(0,0,0))
 	--not be fly, gravity isn't applied, switch to falling
 	elseif not inside_fly_node and self.object:get_acceleration().y == 0 then
 		self.pitch = 0
-		self.object:set_acceleration(vector_new(0,-self.gravity,0))
+		self.object:set_acceleration(vector.new(0,-self.gravity,0))
 	end
 end
 
@@ -635,15 +617,13 @@ local fly_state_execution = function(self,dtime)
 
 			--reset the walk timer
 			if self.walk_timer <= 0 then
-	
 				--re-randomize the walk timer
 				self.walk_timer = math.random(1,6) + math.random()
-	
 				--set the mob into a random direction
-				self.yaw = (math_random() * (math.pi * 2))
+				self.yaw = (math.random() * (math.pi * 2))
 
 				--create a truly random pitch, since there is no easy access to pitch math that I can find
-				self.pitch = math_random() * math.random(1,3) * random_pitch_multiplier[math_random(1,2)]
+				self.pitch = math.random() * math.random(1,3) * random_pitch_multiplier[math.random(1,2)]
 			end
 
 			--do animation
@@ -663,9 +643,7 @@ local fly_state_execution = function(self,dtime)
 
 			--enable rotation locking
 			mobs.movement_rotation_lock(self)
-
 		elseif self.state == "attack" then
-		
 			--execute mob attack type
 			--if self.attack_type == "explode" then
 
@@ -699,38 +677,37 @@ end
 --[[
    ___
   |_  |
-    | |_   _ _ __ ___  _ __  
-    | | | | | '_ ` _ \| '_ \ 
+	| |_   _ _ __ ___  _ __
+	| | | | | '_ ` _ \| '_ \
 /\__/ / |_| | | | | | | |_) |
 \____/ \__,_|_| |_| |_| .__/
-                      | |    
-                      |_|    
+					  | |
+					  |_|
 ]]--
 
 
 --check if a mob needs to turn while jumping
-local jump_turn_check = function(self,dtime)
+--[[local function jump_turn_check(self, dtime)
+	local pos = self.object:get_pos()
+	pos.y = pos.y + 0.1
+	local dir = minetest_yaw_to_dir(self.yaw)
 
-    local pos = self.object:get_pos()
-    pos.y = pos.y + 0.1
-    local dir = minetest_yaw_to_dir(self.yaw)
-
-    local collisionbox = self.object:get_properties().collisionbox
+	local collisionbox = self.object:get_properties().collisionbox
 	local radius = collisionbox[4] + 0.5
 
-    vector_multiply(dir, radius)
+	vector.multiply(dir, radius)
 
-    local test_dir = vector.add(pos,dir)
+	local test_dir = vector.add(pos,dir)
 
 	local green_flag_1 = minetest_get_item_group(minetest_get_node(test_dir).name, "solid") ~= 0
 
-	return(green_flag_1)
-end
+	return green_flag_1
+end]]
 
 -- state switching logic (stand, jump, run, attacks)
 local jump_state_list_wandering = {"stand", "jump"}
 
-local jump_state_switch = function(self, dtime)
+local function jump_state_switch(self, dtime)
 	self.state_timer = self.state_timer - dtime
 	if self.state_timer <= 0 then
 		self.state_timer = math.random(4,10) + math.random()
@@ -739,8 +716,8 @@ local jump_state_switch = function(self, dtime)
 end
 
 -- states are executed here
-local jump_state_execution = function(self,dtime)
-
+local function jump_state_execution(self, dtime)
+	local node_in_front_of = mobs.jump_check(self)
 	local pos = self.object:get_pos()
 	local collisionbox = self.object:get_properties().collisionbox
 	--get the center of the mob
@@ -775,7 +752,7 @@ local jump_state_execution = function(self,dtime)
 			self.walk_timer = math.random(1,6) + math.random()
 
 			--set the mob into a random direction
-			self.yaw = (math_random() * (math.pi * 2))
+			self.yaw = (math.random() * (math.pi * 2))
 		end
 
 		--do animation
@@ -793,15 +770,10 @@ local jump_state_execution = function(self,dtime)
 		mobs.jump_move(self,self.walk_velocity)
 
 	elseif self.state == "run" then
-
 		print("run")
-
 	elseif self.state == "attack" then
-
 		print("attack")
-
 	end
-	
 	if float_now then
 		mobs.float(self)
 	end
@@ -817,8 +789,8 @@ ___  ___      _         _                 _
 | |\/| |/ _` | | '_ \  | |    / _ \ / _` | |/ __|
 | |  | | (_| | | | | | | |___| (_) | (_| | | (__
 \_|  |_/\__,_|_|_| |_| \_____/\___/ \__, |_|\___|
-                                     __/ |       
-                                    |___/        
+									 __/ |
+									|___/
 ]]--
 
 --the main loop
@@ -916,7 +888,6 @@ mobs.mob_step = function(self, dtime)
 
 		elseif self.breath < self.breath_max then
 			self.breath = self.breath + dtime
-			
 			--clean timer reset
 			if self.breath > self.breath_max then
 				self.breath = self.breath_max
@@ -948,10 +919,6 @@ mobs.mob_step = function(self, dtime)
 		end
 	end
 
-	
-
-	
-
 	--baby grows up
 	if self.baby then
 		--print(self.grow_up_timer)
@@ -969,8 +936,6 @@ mobs.mob_step = function(self, dtime)
 		end
 	end
 
-
-
 	--do custom mob instructions
 	if self.do_custom then
 		-- when false skip going any further
@@ -1015,7 +980,7 @@ mobs.mob_step = function(self, dtime)
 			self.memory = self.memory - dtime
 			--get if memory player is within viewing range
 			if self.attacking and self.attacking:is_player() then
-				local distance = vector_distance(self.object:get_pos(), self.attacking:get_pos())
+				local distance = vector.distance(self.object:get_pos(), self.attacking:get_pos())
 				if distance > self.view_range then
 					self.memory = 0
 				end
@@ -1124,28 +1089,22 @@ mobs.mob_step = function(self, dtime)
 	--overrides absolutely everything
 	--mobs get stuck in cobwebs like players
 	if not self.ignores_cobwebs then
-
 		local pos = self.object:get_pos()
 		local node = pos and minetest_get_node(pos).name
-		
 		if node == "mcl_core:cobweb" then
-
 			--fight the rest of the api
 			if self.object:get_acceleration().y ~= 0 then
-				self.object:set_acceleration(vector_new(0,0,0))
+				self.object:set_acceleration(vector.new(0,0,0))
 			end
-
 			mobs.stick_in_cobweb(self)
-
 			self.was_stuck_in_cobweb = true
-
 		else
 			--do not override other functions
 			if self.was_stuck_in_cobweb == true then
 				--return the mob back to normal
 				self.was_stuck_in_cobweb = nil
 				if self.object:get_acceleration().y == 0 and not self.swim and not self.fly then
-					self.object:set_acceleration(vector_new(0,-self.gravity,0))
+					self.object:set_acceleration(vector.new(0,-self.gravity,0))
 				end
 			end
 		end

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

@@ -1,7 +1,7 @@
-local math_pi     = math.pi
-local math_floor  = math.floor
-local math_random = math.random
-local HALF_PI     = math_pi/2
+local math = math
+local vector = vector
+
+local HALF_PI     = math.pi/2
 
 
 local vector_direction = vector.direction
@@ -48,7 +48,6 @@ mobs.set_mob_animation = function(self, anim, fixed_frame)
 		self.animation[anim .. "_speed"] or self.animation.speed_normal or 15,
 		0, self.animation[anim .. "_loop"] ~= false)
 
-
 	self.current_animation = anim
 end
 
@@ -65,14 +64,14 @@ mobs.death_effect = function(pos, yaw, collisionbox, rotate)
 		max = { x = 0.5, y = 0.5, z = 0.5 }
 	end
 	if rotate then
-		min = vector.rotate(min, {x=0, y=yaw, z=math_pi/2})
-		max = vector.rotate(max, {x=0, y=yaw, z=math_pi/2})
+		min = vector.rotate(min, {x=0, y=yaw, z=math.pi/2})
+		max = vector.rotate(max, {x=0, y=yaw, z=math.pi/2})
 		min, max = vector.sort(min, max)
 		min = vector.multiply(min, 0.5)
 		max = vector.multiply(max, 0.5)
 	end
 
-	minetest_add_particlespawner({
+	minetest.add_particlespawner({
 		amount = 50,
 		time = 0.001,
 		minpos = vector.add(pos, min),
@@ -88,7 +87,7 @@ mobs.death_effect = function(pos, yaw, collisionbox, rotate)
 		texture = "mcl_particles_mob_death.png^[colorize:#000000:255",
 	})
 
-	minetest_sound_play("mcl_mobs_mob_poof", {
+	minetest.sound_play("mcl_mobs_mob_poof", {
 		pos = pos,
 		gain = 1.0,
 		max_hear_distance = 8,
@@ -99,7 +98,6 @@ end
 --this allows auto facedir rotation while making it so mobs
 --don't look like wet noodles flopping around
 mobs.movement_rotation_lock = function(self)
-	
 	local current_engine_yaw = self.object:get_yaw()
 	local current_lua_yaw = self.yaw
 

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

@@ -1,5 +1,5 @@
 local vector_direction = vector.direction
-local minetest_dir_to_yaw = minetest.dir_to_yaw
+--local minetest_dir_to_yaw = minetest.dir_to_yaw
 local vector_distance = vector.distance
 local vector_multiply = vector.multiply
 local math_random  = math.random
@@ -75,7 +75,6 @@ mobs.explode_attack_walk = function(self,dtime)
 		mobs.jump(self)
     end
 
-
     --do biggening explosion thing
     if self.explosion_animation and self.explosion_animation > self.explosion_timer then
         mcl_explosions.explode(self.object:get_pos(), self.explosion_strength,{ drop_chance = 1.0 })
@@ -113,7 +112,6 @@ ______                 _
 
 
 mobs.punch_attack_walk = function(self,dtime)
-    
     --this needs an exception
     if self.attacking == nil or not self.attacking:is_player() then
         self.attacking = nil
@@ -282,7 +280,6 @@ ______          _           _   _ _
 local random_pitch_multiplier = {-1,1}
 
 mobs.projectile_attack_fly = function(self, dtime)
-
     --this needs an exception
     if self.attacking == nil or not self.attacking:is_player() then
         self.attacking = nil

mods/ENTITIES/mcl_mobs/api/mob_functions/backup_code_api.txt

@@ -1,4 +1,7 @@
-local disable_physics = function(object, luaentity, ignore_check, reset_movement)
+local math = math
+local vector = vector
+
+local function disable_physics(object, luaentity, ignore_check, reset_movement)
 	if luaentity.physical_state == true or ignore_check == true then
 		luaentity.physical_state = false
 		object:set_properties({
@@ -12,7 +15,7 @@ local disable_physics = function(object, luaentity, ignore_check, reset_movement
 end
 
 ----For Water Flowing:
-local enable_physics = function(object, luaentity, ignore_check)
+local function enable_physics(object, luaentity, ignore_check)
 	if luaentity.physical_state == false or ignore_check == true then
 		luaentity.physical_state = true
 		object:set_properties({
@@ -272,7 +275,7 @@ local falling = function(self, pos)
 
 			self.object:set_acceleration({
 				x = 0,
-				y = -self.fall_speed / (math_max(1, v.y) ^ 2),
+				y = -self.fall_speed / (math.max(1, v.y) ^ 2),
 				z = 0
 			})
 		end
@@ -503,9 +506,9 @@ local follow_flop = function(self)
 			if sdef and sdef.walkable then
 				mob_sound(self, "flop")
 				self.object:set_velocity({
-					x = math_random(-FLOP_HOR_SPEED, FLOP_HOR_SPEED),
+					x = math.random(-FLOP_HOR_SPEED, FLOP_HOR_SPEED),
 					y = FLOP_HEIGHT,
-					z = math_random(-FLOP_HOR_SPEED, FLOP_HOR_SPEED),
+					z = math.random(-FLOP_HOR_SPEED, FLOP_HOR_SPEED),
 				})
 			end
 
@@ -987,7 +990,7 @@ local check_for_death = function(self, cause, cmi_cause)
 			item_drop(self, cooked, looting)
 
 			if mod_experience and ((not self.child) or self.type ~= "animal") and (minetest_get_us_time() - self.xp_timestamp <= 5000000) then
-				mcl_experience.throw_experience(self.object:get_pos(), math_random(self.xp_min, self.xp_max))
+				mcl_experience.throw_experience(self.object:get_pos(), math.random(self.xp_min, self.xp_max))
 			end
 		end
 	end
@@ -1361,7 +1364,7 @@ local do_attack = function(self, player)
 	self.state = "attack"
 
 	-- TODO: Implement war_cry sound without being annoying
-	--if math_random(0, 100) < 90 then
+	--if math.random(0, 100) < 90 then
 		--mob_sound(self, "war_cry", true)
 	--end
 end
@@ -1396,7 +1399,7 @@ local mob_sound = function(self, soundname, is_opinion, fixed_pitch)
 				pitch = base_pitch
 			end
 			-- randomize the pitch a bit
-			pitch = pitch + math_random(-10, 10) * 0.005
+			pitch = pitch + math.random(-10, 10) * 0.005
 		end
 		minetest_sound_play(sound, {
 			object = self.object,
@@ -1699,7 +1702,7 @@ local do_env_damage = function(self)
 		end
 		if drowning then
 
-			self.breath = math_max(0, self.breath - 1)
+			self.breath = math.max(0, self.breath - 1)
 
 			effect(pos, 2, "bubble.png", nil, nil, 1, nil)
 			if self.breath <= 0 then
@@ -2044,7 +2047,7 @@ local breed = function(self)
 
 					-- Give XP
 					if mod_experience then
-						mcl_experience.throw_experience(pos, math_random(1, 7))
+						mcl_experience.throw_experience(pos, math.random(1, 7))
 					end
 
 					-- custom breed function
@@ -2061,7 +2064,7 @@ local breed = function(self)
 
 
 					-- Use texture of one of the parents
-					local p = math_random(1, 2)
+					local p = math.random(1, 2)
 					if p == 1 then
 						ent_c.base_texture = parent1.base_texture
 					else
@@ -2091,7 +2094,7 @@ local replace = function(self, pos)
 	or not self.replace_what
 	or self.child == true
 	or self.object:get_velocity().y ~= 0
-	or math_random(1, self.replace_rate) > 1 then
+	or math.random(1, self.replace_rate) > 1 then
 		return
 	end
 
@@ -2099,7 +2102,7 @@ local replace = function(self, pos)
 
 	if type(self.replace_what[1]) == "table" then
 
-		local num = math_random(#self.replace_what)
+		local num = math.random(#self.replace_what)
 
 		what = self.replace_what[num][1] or ""
 		with = self.replace_what[num][2] or ""
@@ -2163,7 +2166,7 @@ function do_states(self)
 
 	if self.state == "stand" then
 
-		if math_random(1, 4) == 1 then
+		if math.random(1, 4) == 1 then
 
 			local lp = nil
 			local s = self.object:get_pos()
@@ -2189,7 +2192,7 @@ function do_states(self)
 
 				if lp.x > s.x then yaw = yaw + math_pi end
 			else
-				yaw = yaw + math_random(-0.5, 0.5)
+				yaw = yaw + math.random(-0.5, 0.5)
 			end
 
 			yaw = set_yaw(self, yaw, 8)
@@ -2204,7 +2207,7 @@ function do_states(self)
 
 			if self.walk_chance ~= 0
 			and self.facing_fence ~= true
-			and math_random(1, 100) <= self.walk_chance
+			and math.random(1, 100) <= self.walk_chance
 			and is_at_cliff_or_danger(self) == false then
 
 				set_velocity(self, self.walk_velocity)
@@ -2254,7 +2257,7 @@ function do_states(self)
 							{x = s.x + 5, y = s.y + 1, z = s.z + 5},
 							{"group:solid"})
 
-						lp = #lp > 0 and lp[math_random(#lp)]
+						lp = #lp > 0 and lp[math.random(#lp)]
 
 						-- did we find land?
 						if lp then
@@ -2280,8 +2283,8 @@ function do_states(self)
 			else
 
 				-- Randomly turn
-				if math_random(1, 100) <= 30 then
-					yaw = yaw + math_random(-0.5, 0.5)
+				if math.random(1, 100) <= 30 then
+					yaw = yaw + math.random(-0.5, 0.5)
 					yaw = set_yaw(self, yaw, 8)
 				end
 			end
@@ -2289,9 +2292,9 @@ function do_states(self)
 			yaw = set_yaw(self, yaw, 8)
 
 		-- otherwise randomly turn
-		elseif math_random(1, 100) <= 30 then
+		elseif math.random(1, 100) <= 30 then
 
-			yaw = yaw + math_random(-0.5, 0.5)
+			yaw = yaw + math.random(-0.5, 0.5)
 			yaw = set_yaw(self, yaw, 8)
 		end
 
@@ -2302,7 +2305,7 @@ function do_states(self)
 		end
 		if self.facing_fence == true
 		or cliff_or_danger
-		or math_random(1, 100) <= 30 then
+		or math.random(1, 100) <= 30 then
 
 			set_velocity(self, 0)
 			self.state = "stand"
@@ -2602,7 +2605,7 @@ function do_states(self)
 						self.timer = 0
 
 						if self.double_melee_attack
-						and math_random(1, 2) == 1 then
+						and math.random(1, 2) == 1 then
 							set_animation(self, "punch2")
 						else
 							set_animation(self, "punch")
@@ -2669,7 +2672,7 @@ function do_states(self)
 			if self.shoot_interval
 			and self.timer > self.shoot_interval
 			and not minetest_raycast(p, self.attack:get_pos(), false, false):next()
-			and math_random(1, 100) <= 60 then
+			and math.random(1, 100) <= 60 then
 
 				self.timer = 0
 				set_animation(self, "shoot")
@@ -2759,7 +2762,7 @@ end
 
 
 -- Code to execute before custom on_rightclick handling
-local on_rightclick_prefix = function(self, clicker)
+local function on_rightclick_prefix(self, clicker)
 	local item = clicker:get_wielded_item()
 
 	-- Name mob with nametag
@@ -2785,17 +2788,17 @@ local on_rightclick_prefix = function(self, clicker)
 	return false
 end
 
-local create_mob_on_rightclick = function(on_rightclick)
+--[[local function create_mob_on_rightclick(on_rightclick)
 	return function(self, clicker)
 		local stop = on_rightclick_prefix(self, clicker)
 		if (not stop) and (on_rightclick) then
 			on_rightclick(self, clicker)
 		end
 	end
-end
+end]]
 
 -- set and return valid yaw
-local set_yaw = function(self, yaw, delay, dtime)
+local function set_yaw(self, yaw, delay, dtime)
 
 	if not yaw or yaw ~= yaw then
 		yaw = 0
@@ -2805,7 +2808,7 @@ local set_yaw = function(self, yaw, delay, dtime)
 
 	if delay == 0 then
 		if self.shaking and dtime then
-			yaw = yaw + (math_random() * 2 - 1) * 5 * dtime
+			yaw = yaw + (math.random() * 2 - 1) * 5 * dtime
 		end
 		self.yaw(yaw)
 		update_roll(self)
@@ -2825,8 +2828,7 @@ function mobs:yaw(self, yaw, delay, dtime)
 end
 
 
-mob_step = function()
-
+--mob_step = function()
 	--if self.state == "die" then
 	--	print("need custom die stop moving thing")
 	--	return
@@ -2901,7 +2903,7 @@ mob_step = function()
 	--end
 
 	-- mob plays random sound at times
-	--if math_random(1, 70) == 1 then
+	--if math.random(1, 70) == 1 then
 	--	mob_sound(self, "random", true)
 	--end
 
@@ -2934,11 +2936,11 @@ mob_step = function()
 
 
 	--if is_at_water_danger(self) and self.state ~= "attack" then
-	--	if math_random(1, 10) <= 6 then
+	--	if math.random(1, 10) <= 6 then
 	--		set_velocity(self, 0)
 	--		self.state = "stand"
 	--		set_animation(self, "stand")
-	--		yaw = yaw + math_random(-0.5, 0.5)
+	--		yaw = yaw + math.random(-0.5, 0.5)
 	--		yaw = set_yaw(self, yaw, 8)
 	--	end
 	--end
@@ -2982,7 +2984,7 @@ mob_step = function()
 			mcl_burning.extinguish(self.object)
 			self.object:remove()
 		elseif self.lifetimer <= 10 then
-			if math_random(10) < 4 then
+			if math.random(10) < 4 then
 				self.despawn_immediately = true
 			else
 				self.lifetimer = 20
@@ -2991,4 +2993,4 @@ mob_step = function()
 	end
 	]]--
 
-end
+--end

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

@@ -1,14 +1,13 @@
 local minetest_get_objects_inside_radius = minetest.get_objects_inside_radius
 
-local vector_distance = vector.distance
+local vector = vector
 
 --check to see if someone nearby has some tasty food
 mobs.check_following = function(self) -- returns true or false
-
     --ignore
     if not self.follow then
         self.following_person = nil
-        return(false)
+        return false
     end
 
     --hey look, this thing works for passive mobs too!
@@ -20,20 +19,20 @@ mobs.check_following = function(self) -- returns true or false
         --safety check
         if not stack then
             self.following_person = nil
-            return(false)
+            return false
         end
 
         local item_name = stack:get_name()
         --all checks have passed, that guy has some good looking food
         if item_name == self.follow then
             self.following_person = follower
-            return(true)
+            return true
         end
     end
 
     --everything failed
     self.following_person = nil
-    return(false)
+    return false
 end
 
 --a function which attempts to make mobs enter
@@ -42,25 +41,25 @@ mobs.enter_breed_state = function(self,clicker)
 
     --do not breed if baby
     if self.baby then
-        return(false)
+        return false
     end
 
     --do not do anything if looking for mate or
     --if cooling off from breeding
     if self.breed_lookout_timer > 0 or self.breed_timer > 0 then
-        return(false)
+        return false
     end
 
     --if this is caught, that means something has gone
     --seriously wrong
     if not clicker or not clicker:is_player() then
-        return(false)
+        return false
     end
 
     local stack = clicker:get_wielded_item()
     --safety check
     if not stack then
-        return(false)
+        return false
     end
 
     local item_name = stack:get_name()
@@ -73,11 +72,11 @@ mobs.enter_breed_state = function(self,clicker)
         self.breed_lookout_timer = self.breed_lookout_timer_goal
         self.bred = true
         mobs.play_sound_specific(self,"mobs_mc_animal_eat_generic")
-        return(true)
+        return true
     end
 
     --everything failed
-    return(false)
+    return false
 end
 
 
@@ -104,15 +103,15 @@ mobs.look_for_mate = function(self)
 
 			local pos2 = mate:get_pos()
 
-			local distance = vector_distance(pos1,pos2)
+			local distance = vector.distance(pos1,pos2)
 
 			if distance <= radius then
-				if line_of_sight then
+				if minetest.line_of_sight then
 					--must add eye height or stuff breaks randomly because of
 					--seethrough nodes being a blocker (like grass)
-					if minetest_line_of_sight(
-							vector_new(pos1.x, pos1.y, pos1.z), 
-							vector_new(pos2.x, pos2.y + mate:get_properties().eye_height, pos2.z)
+					if minetest.line_of_sight(
+							vector.new(pos1.x, pos1.y, pos1.z),
+							vector.new(pos2.x, pos2.y + mate:get_properties().eye_height, pos2.z)
 						) then
 						mates_detected = mates_detected + 1
 						mates_in_area[mate] = distance
@@ -161,7 +160,7 @@ mobs.make_baby_grow_faster = function(self,clicker)
         local stack = clicker:get_wielded_item()
         --safety check
         if not stack then
-            return(false)
+            return false
         end
 
         local item_name = stack:get_name()
@@ -175,10 +174,8 @@ mobs.make_baby_grow_faster = function(self,clicker)
             end
 
             mobs.play_sound_specific(self,"mobs_mc_animal_eat_generic")
-
-            return(true)
+            return true
         end
     end
-
-    return(false)
+    return false
 end

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

@@ -8,10 +8,8 @@ local vector_direction = vector.direction
 local integer_test = {-1,1}
 
 mobs.collision = function(self)
-				
 	local pos = self.object:get_pos()
 
-
 	if not self or not self.object or not self.object:get_luaentity() then
 		return
 	end
@@ -104,11 +102,9 @@ mobs.collision = function(self)
 						end
 					end
 				end
-			
 				self.object:add_velocity(vel1)
 				object:add_velocity(vel2)
 			end
-			
 		end
 	end
 end
@@ -116,7 +112,6 @@ end
 
 --this is used for arrow collisions
 mobs.arrow_hit = function(self, player)
-	
     player:punch(self.object, 1.0, {
         full_punch_interval = 1.0,
         damage_groups = {fleshy = self._damage}

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

@@ -1,5 +1,5 @@
 local minetest_add_item = minetest.add_item
-local minetest_sound_play = minetest.sound_play
+--local minetest_sound_play = minetest.sound_play
 
 local math_pi     = math.pi
 local math_random = math.random
@@ -19,7 +19,7 @@ local item_drop = function(self, cooked, looting_level)
 		return
 	end
 
-	local obj, item, num
+	local obj, item
 	local pos = self.object:get_pos()
 
 	self.drops = self.drops or {} -- nil check
@@ -56,8 +56,11 @@ local item_drop = function(self, cooked, looting_level)
 			-- cook items when true
 			if cooked then
 
-				local output = minetest_get_craft_result({
-					method = "cooking", width = 1, items = {item}})
+				local output = minetest.get_craft_result({
+					method = "cooking",
+                    width = 1,
+                    items = {item},
+                })
 
 				if output and output.item and not output.item:is_empty() then
 					item = output.item:get_name()
@@ -117,15 +120,10 @@ mobs.death_logic = function(self, dtime)
 
     --the final POOF of a mob despawning
     if self.death_animation_timer >= 1.25 then
-
         item_drop(self,false,1)
-
         mobs.death_effect(self)
-
 		mcl_experience.throw_experience(self.object:get_pos(), math_random(self.xp_min, self.xp_max))
-		
         self.object:remove()
-
         return
     end
 

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

@@ -1,5 +1,5 @@
 local minetest_line_of_sight = minetest.line_of_sight
-local minetest_dir_to_yaw    = minetest.dir_to_yaw
+--local minetest_dir_to_yaw    = minetest.dir_to_yaw
 local minetest_yaw_to_dir    = minetest.yaw_to_dir
 local minetest_get_node      = minetest.get_node
 local minetest_get_item_group = minetest.get_item_group
@@ -18,19 +18,16 @@ local table_copy = table.copy
 local math_abs = math.abs
 
 -- default function when mobs are blown up with TNT
-local do_tnt = function(obj, damage)
-
+--[[local function do_tnt(obj, damage)
 	obj.object:punch(obj.object, 1.0, {
 		full_punch_interval = 1.0,
 		damage_groups = {fleshy = damage},
 	}, nil)
-
 	return false, true, {}
-end
+end]]
 
 --a fast function to be able to detect only players without using objects_in_radius
 mobs.detect_closest_player_within_radius = function(self, line_of_sight, radius, object_height_adder)
-	
 	local pos1 = self.object:get_pos()
 	local players_in_area = {}
 	local winner_player = nil
@@ -180,15 +177,10 @@ end
 -- check if within physical map limits (-30911 to 30927)
 -- within_limits, wmin, wmax = nil, -30913, 30928
 mobs.within_limits = function(pos, radius)
+    local wmin, wmax
 	if mcl_vars then
 		if mcl_vars.mapgen_edge_min and mcl_vars.mapgen_edge_max then
 			wmin, wmax = mcl_vars.mapgen_edge_min, mcl_vars.mapgen_edge_max
-			within_limits = function(pos, radius)
-				return pos
-					and (pos.x - radius) > wmin and (pos.x + radius) < wmax
-					and (pos.y - radius) > wmin and (pos.y + radius) < wmax
-					and (pos.z - radius) > wmin and (pos.z + radius) < wmax
-			end
 		end
 	end
 	return pos

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

@@ -1,112 +1,98 @@
-local vector_new = vector.new
-
+local math = math
+local vector = vector
 
 --converts yaw to degrees
 local degrees = function(yaw)
 	return(yaw*180.0/math.pi)
 end
 
-
 mobs.do_head_logic = function(self,dtime)
 
-    local player = minetest.get_player_by_name("singleplayer")
+	local player = minetest.get_player_by_name("singleplayer")
 
-    local look_at = player:get_pos()
-    look_at.y = look_at.y + player:get_properties().eye_height
+	local look_at = player:get_pos()
+	look_at.y = look_at.y + player:get_properties().eye_height
+
+	local pos = self.object:get_pos()
+
+	local body_yaw = self.object:get_yaw()
+
+	local body_dir = minetest.yaw_to_dir(body_yaw)
+
+	pos.y = pos.y + self.head_height_offset
+
+	local head_offset = vector.multiply(body_dir, self.head_direction_offset)
+
+	pos = vector.add(pos, head_offset)
+
+	minetest.add_particle({
+		pos = pos,
+		velocity = {x=0, y=0, z=0},
+		acceleration = {x=0, y=0, z=0},
+		expirationtime = 0.2,
+		size = 1,
+		texture = "default_dirt.png",
+	})
+
+	local bone_pos = vector.new(0,0,0)
+
+	--(horizontal)
+	bone_pos.y = self.head_bone_pos_y
+
+	--(vertical)
+	bone_pos.z = self.head_bone_pos_z
+
+	--print(yaw)
+
+	--local _, bone_rot = self.object:get_bone_position("head")
+
+	--bone_rot.x = bone_rot.x + (dtime * 10)
+	--bone_rot.z = bone_rot.z + (dtime * 10)
+
+	local head_yaw = minetest.dir_to_yaw(vector.direction(pos,look_at)) - body_yaw
+
+	if self.reverse_head_yaw then
+		head_yaw = head_yaw * -1
+	end
+
+	--over rotation protection
+	--stops radians from going out of spec
+	if head_yaw > math.pi then
+		head_yaw = head_yaw - (math.pi * 2)
+	elseif head_yaw < -math.pi then
+		head_yaw = head_yaw + (math.pi * 2)
+	end
 
 
+	local check_failed = false
+	--upper check + 90 degrees or upper math.radians (3.14/2)
+	if head_yaw > math.pi - (math.pi/2) then
+		head_yaw = 0
+		check_failed = true
+	--lower check - 90 degrees or lower negative math.radians (-3.14/2)
+	elseif head_yaw < -math.pi + (math.pi/2) then
+		head_yaw = 0
+		check_failed = true
+	end
 
+	local head_pitch = 0
 
-    local pos = self.object:get_pos()
+	--DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
+	--head_yaw = 0
+	--DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
 
-    local body_yaw = self.object:get_yaw()
+	if not check_failed then
+		head_pitch = minetest.dir_to_yaw(vector.new(vector.distance(vector.new(pos.x,0,pos.z),vector.new(look_at.x,0,look_at.z)),0,pos.y-look_at.y))+(math.pi/2)
+	end
 
-    local body_dir = minetest.yaw_to_dir(body_yaw)
+	if self.head_pitch_modifier then
+		head_pitch = head_pitch + self.head_pitch_modifier
+	end
 
-
-    pos.y = pos.y + self.head_height_offset
-
-    local head_offset = vector.multiply(body_dir, self.head_direction_offset)
-
-    pos = vector.add(pos, head_offset)
-
-
-
-
-    minetest.add_particle({
-    	pos = pos,
-    	velocity = {x=0, y=0, z=0},
-    	acceleration = {x=0, y=0, z=0},
-    	expirationtime = 0.2,
-    	size = 1,
-    	texture = "default_dirt.png",
-    })
-
-
-    local bone_pos = vector_new(0,0,0)
-
-
-    --(horizontal)
-    bone_pos.y = self.head_bone_pos_y
-
-    --(vertical)
-    bone_pos.z = self.head_bone_pos_z
-
-    --print(yaw)
-
-    --local _, bone_rot = self.object:get_bone_position("head")
-
-    --bone_rot.x = bone_rot.x + (dtime * 10)
-    --bone_rot.z = bone_rot.z + (dtime * 10)
-
-
-    local head_yaw 
-    head_yaw = minetest.dir_to_yaw(vector.direction(pos,look_at)) - body_yaw
-
-    if self.reverse_head_yaw then
-        head_yaw = head_yaw * -1
-    end
-
-    --over rotation protection
-    --stops radians from going out of spec
-    if head_yaw > math.pi then
-        head_yaw = head_yaw - (math.pi * 2)
-    elseif head_yaw < -math.pi then
-        head_yaw = head_yaw + (math.pi * 2)
-    end
-
-
-    local check_failed = false
-    --upper check + 90 degrees or upper math.radians (3.14/2)
-    if head_yaw > math.pi - (math.pi/2) then
-        head_yaw = 0
-        check_failed = true
-    --lower check - 90 degrees or lower negative math.radians (-3.14/2)
-    elseif head_yaw < -math.pi + (math.pi/2) then
-        head_yaw = 0
-        check_failed = true
-    end
-
-    local head_pitch = 0
-
-    --DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG 
-    --head_yaw = 0
-    --DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG 
-
-    if not check_failed then
-        head_pitch = minetest.dir_to_yaw(vector.new(vector.distance(vector.new(pos.x,0,pos.z),vector.new(look_at.x,0,look_at.z)),0,pos.y-look_at.y))+(math.pi/2)
-    end
-
-    if self.head_pitch_modifier then
-        head_pitch = head_pitch + self.head_pitch_modifier
-    end
-
-    if self.swap_y_with_x then
-        self.object:set_bone_position(self.head_bone, bone_pos, vector_new(degrees(head_pitch),degrees(head_yaw),0))
-    else
-        self.object:set_bone_position(self.head_bone, bone_pos, vector_new(degrees(head_pitch),0,degrees(head_yaw)))
-    end
-
-
-    --set_bone_position([bone, position, rotation])
+	if self.swap_y_with_x then
+		self.object:set_bone_position(self.head_bone, bone_pos, vector.new(degrees(head_pitch),degrees(head_yaw),0))
+	else
+		self.object:set_bone_position(self.head_bone, bone_pos, vector.new(degrees(head_pitch),0,degrees(head_yaw)))
+	end
+	--set_bone_position([bone, position, rotation])
 end

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

@@ -2,22 +2,19 @@ local minetest_after      = minetest.after
 local minetest_sound_play = minetest.sound_play
 local minetest_dir_to_yaw = minetest.dir_to_yaw
 
-local math_floor  = math.floor
-local math_min    = math.min
-local math_random = math.random
-
-local vector_direction = vector.direction
-local vector_multiply  = vector.multiply
+local math = math
+local vector = vector
 
 local MAX_MOB_NAME_LENGTH = 30
 
+local mod_hunger = minetest.get_modpath("mcl_hunger")
+
 mobs.feed_tame = function(self)
     return nil
 end
 
 -- Code to execute before custom on_rightclick handling
-local on_rightclick_prefix = function(self, clicker)
-
+local function on_rightclick_prefix(self, clicker)
 	local item = clicker:get_wielded_item()
 
 	-- Name mob with nametag
@@ -60,7 +57,6 @@ end
 
 -- deal damage and effects when mob punched
 mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
-
 	--don't do anything if the mob is already dead
 	if self.health <= 0 then
 		return
@@ -94,14 +90,13 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
 		pos2.y = 0
 
 
-		local dir = vector_direction(pos2,pos1)
+		local dir = vector.direction(pos2,pos1)
 
 		local yaw = minetest_dir_to_yaw(dir)
 
 		self.yaw = yaw
 	end
 
-
 	-- custom punch function
 	if self.do_punch then
 		-- when false skip going any further
@@ -115,21 +110,18 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
 		return
 	end
 
-	
 	-- error checking when mod profiling is enabled
 	if not tool_capabilities then
 		minetest.log("warning", "[mobs_mc] Mod profiling enabled, damage not enabled")
 		return
 	end
 
-
 	local is_player = hitter:is_player()
 
-
 	-- punch interval
 	local weapon = hitter:get_wielded_item()
 
-	local punch_interval = 1.4
+	--local punch_interval = 1.4
 
 	-- exhaust attacker
 	if mod_hunger and is_player then
@@ -139,7 +131,6 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
 	-- calculate mob damage
 	local damage = 0
 	local armor = self.object:get_armor_groups() or {}
-	local tmp
 
 	--calculate damage groups
 	for group,_ in pairs( (tool_capabilities.damage_groups or {}) ) do
@@ -163,13 +154,13 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
 
 	-- healing
 	if damage <= -1 then
-		self.health = self.health - math_floor(damage)
+		self.health = self.health - math.floor(damage)
 		return
 	end
 
-	if tool_capabilities then
-		punch_interval = tool_capabilities.full_punch_interval or 1.4
-	end
+	--if tool_capabilities then
+	--	punch_interval = tool_capabilities.full_punch_interval or 1.4
+	--end
 
 	-- add weapon wear manually
 	-- Required because we have custom health handling ("health" property)
@@ -183,7 +174,7 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
 				local weapon = hitter:get_wielded_item(player)
 				local def = weapon:get_definition()
 				if def.tool_capabilities and def.tool_capabilities.punch_attack_uses then
-					local wear = math_floor(65535/tool_capabilities.punch_attack_uses)
+					local wear = math.floor(65535/tool_capabilities.punch_attack_uses)
 					weapon:add_wear(wear)
 					hitter:set_wielded_item(weapon)
 				end
@@ -240,7 +231,6 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
 			up = 0
 		end
 
-
 		--0.75 for perfect distance to not be too easy, and not be too hard
 		local multiplier = 0.75
 
@@ -255,20 +245,15 @@ mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
 		if self.hostile then
 			multiplier = multiplier + 2
 		end
-
-		dir = vector_multiply(dir,multiplier)
-
+		dir = vector.multiply(dir,multiplier)
 		dir.y = up
-
 		--add the velocity
 		self.object:add_velocity(dir)
-
 	end
 end
 
 --do internal per mob projectile calculations
 mobs.shoot_projectile = function(self)
-
 	local pos1 = self.object:get_pos()
 	--add mob eye height
 	pos1.y = pos1.y + self.eye_height
@@ -278,7 +263,7 @@ mobs.shoot_projectile = function(self)
 	pos2.y = pos2.y + self.attacking:get_properties().eye_height
 
 	--get direction
-	local dir = vector_direction(pos1,pos2)
+	local dir = vector.direction(pos1,pos2)
 
 	--call internal shoot_arrow function
 	self.shoot_arrow(self,pos1,dir)

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

@@ -1,9 +1,8 @@
 local minetest_add_particlespawner = minetest.add_particlespawner
 
 mobs.death_effect = function(self)
-
     local pos = self.object:get_pos()
-    local yaw = self.object:get_yaw()
+    --local yaw = self.object:get_yaw()
     local collisionbox = self.object:get_properties().collisionbox
 
     local min, max
@@ -33,7 +32,7 @@ end
 mobs.critical_effect = function(self)
 
     local pos = self.object:get_pos()
-    local yaw = self.object:get_yaw()
+    --local yaw = self.object:get_yaw()
     local collisionbox = self.object:get_properties().collisionbox
 
     local min, max
@@ -62,9 +61,8 @@ end
 
 --when feeding a mob
 mobs.feed_effect = function(self)
-
     local pos = self.object:get_pos()
-    local yaw = self.object:get_yaw()
+    --local yaw = self.object:get_yaw()
     local collisionbox = self.object:get_properties().collisionbox
 
     local min, max
@@ -94,7 +92,7 @@ end
 --hearts when tamed
 mobs.tamed_effect = function(self)
     local pos = self.object:get_pos()
-    local yaw = self.object:get_yaw()
+    --local yaw = self.object:get_yaw()
     local collisionbox = self.object:get_properties().collisionbox
 
     local min, max
@@ -124,7 +122,7 @@ end
 --hearts when breeding
 mobs.breeding_effect = function(self)
     local pos = self.object:get_pos()
-    local yaw = self.object:get_yaw()
+    --local yaw = self.object:get_yaw()
     local collisionbox = self.object:get_properties().collisionbox
 
     local min, max

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

@@ -1,16 +1,10 @@
-local math_pi     = math.pi
-local math_sin    = math.sin
-local math_cos    = math.cos
-local math_random = math.random
-local HALF_PI     = math_pi / 2
-local DOUBLE_PI   = math_pi * 2
+-- localize math functions
+local math = math
+local HALF_PI     = math.pi / 2
+local DOUBLE_PI   = math.pi * 2
 
 -- localize vector functions
-local vector_new      = vector.new
-local vector_length   = vector.length
-local vector_multiply = vector.multiply
-local vector_distance = vector.distance
-local vector_normalize = vector.normalize
+local vector = vector
 
 local minetest_yaw_to_dir = minetest.yaw_to_dir
 local minetest_dir_to_yaw = minetest.dir_to_yaw
@@ -19,18 +13,17 @@ local DEFAULT_JUMP_HEIGHT = 5
 local DEFAULT_FLOAT_SPEED = 4
 local DEFAULT_CLIMB_SPEED = 3
 
-
 mobs.stick_in_cobweb = function(self)
 	local current_velocity = self.object:get_velocity()
 
-	local goal_velocity = vector_multiply(vector_normalize(current_velocity), 0.4)
+	local goal_velocity = vector.multiply(vector.normalize(current_velocity), 0.4)
 
 	goal_velocity.y = -0.5
 
 	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
 
 	--smooths out mobs a bit
-	if vector_length(new_velocity_addition) >= 0.0001 then
+	if vector.length(new_velocity_addition) >= 0.0001 then
 		self.object:add_velocity(new_velocity_addition)
 	end
 end
@@ -40,7 +33,7 @@ mobs.float = function(self)
 
 	local acceleration = self.object:get_acceleration()
 	if acceleration and acceleration.y ~= 0 then
-		self.object:set_acceleration(vector_new(0,0,0))
+		self.object:set_acceleration(vector.new(0,0,0))
 	else
 		return
 	end
@@ -59,7 +52,7 @@ mobs.float = function(self)
 	new_velocity_addition.z = 0
 
 	--smooths out mobs a bit
-	if vector_length(new_velocity_addition) >= 0.0001 then
+	if vector.length(new_velocity_addition) >= 0.0001 then
 		self.object:add_velocity(new_velocity_addition)
 	end
 end
@@ -81,7 +74,7 @@ mobs.climb = function(self)
 	new_velocity_addition.z = 0
 
 	--smooths out mobs a bit
-	if vector_length(new_velocity_addition) >= 0.0001 then
+	if vector.length(new_velocity_addition) >= 0.0001 then
 		self.object:add_velocity(new_velocity_addition)
 	end
 end
@@ -109,22 +102,22 @@ mobs.set_velocity = function(self, v)
 	local current_velocity = self.object:get_velocity()
 
 	local goal_velocity = {
-		x = (math_sin(yaw) * -v),
+		x = (math.sin(yaw) * -v),
 		y = 0,
-		z = (math_cos(yaw) * v),
+		z = (math.cos(yaw) * v),
 	}
 
 
 	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
 
-	if vector_length(new_velocity_addition) > vector_length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector_length(goal_velocity) / vector_length(new_velocity_addition)))
+	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
+		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
 	end
 
 	new_velocity_addition.y = 0
 
 	--smooths out mobs a bit
-	if vector_length(new_velocity_addition) >= 0.0001 then
+	if vector.length(new_velocity_addition) >= 0.0001 then
 		self.object:add_velocity(new_velocity_addition)
 	end
 end
@@ -139,7 +132,7 @@ mobs.get_velocity = function(self)
 	v.y = 0
 
 	if v then
-		return vector_length(v)
+		return vector.length(v)
 	end
 
 	return 0
@@ -155,7 +148,7 @@ mobs.jump = function(self, velocity)
 	--fallback velocity to allow modularity
     velocity = velocity or DEFAULT_JUMP_HEIGHT
 
-    self.object:add_velocity(vector_new(0,velocity,0))
+    self.object:add_velocity(vector.new(0,velocity,0))
 end
 
 --make mobs fall slowly
@@ -175,15 +168,15 @@ mobs.mob_fall_slow = function(self)
 	new_velocity_addition.x = 0
 	new_velocity_addition.z = 0
 
-	if vector_length(new_velocity_addition) > vector_length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector_length(goal_velocity) / vector_length(new_velocity_addition)))
+	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
+		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
 	end
 
 	new_velocity_addition.x = 0
 	new_velocity_addition.z = 0
 
 	--smooths out mobs a bit
-	if vector_length(new_velocity_addition) >= 0.0001 then
+	if vector.length(new_velocity_addition) >= 0.0001 then
 		self.object:add_velocity(new_velocity_addition)
 	end
 
@@ -215,13 +208,13 @@ mobs.flop = function(self, velocity)
     velocity = velocity or DEFAULT_JUMP_HEIGHT
 
 	--create a random direction (2d yaw)
-	local dir = DOUBLE_PI * math_random()
+	local dir = DOUBLE_PI * math.random()
 
 	--create a random force value
-	local force = math_random(0,3) + math_random()
+	local force = math.random(0,3) + math.random()
 
 	--convert the yaw to a direction vector then multiply it times the force
-	local final_additional_force = vector_multiply(minetest_yaw_to_dir(dir), force)
+	local final_additional_force = vector.multiply(minetest_yaw_to_dir(dir), force)
 
 	--place in the "flop" velocity to make the mob flop
 	final_additional_force.y = velocity
@@ -249,20 +242,20 @@ mobs.set_swim_velocity = function(self, v)
 	local current_velocity = self.object:get_velocity()
 
 	local goal_velocity = {
-		x = (math_sin(yaw) * -v),
+		x = (math.sin(yaw) * -v),
 		y = pitch,
-		z = (math_cos(yaw) * v),
+		z = (math.cos(yaw) * v),
 	}
 
 
 	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
 
-	if vector_length(new_velocity_addition) > vector_length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector_length(goal_velocity) / vector_length(new_velocity_addition)))
+	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
+		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
 	end
 
 	--smooths out mobs a bit
-	if vector_length(new_velocity_addition) >= 0.0001 then
+	if vector.length(new_velocity_addition) >= 0.0001 then
 		self.object:add_velocity(new_velocity_addition)
 	end
 end
@@ -294,20 +287,20 @@ mobs.set_fly_velocity = function(self, v)
 	local current_velocity = self.object:get_velocity()
 
 	local goal_velocity = {
-		x = (math_sin(yaw) * -v),
+		x = (math.sin(yaw) * -v),
 		y = pitch,
-		z = (math_cos(yaw) * v),
+		z = (math.cos(yaw) * v),
 	}
 
 
 	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
 
-	if vector_length(new_velocity_addition) > vector_length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector_length(goal_velocity) / vector_length(new_velocity_addition)))
+	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
+		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
 	end
 
 	--smooths out mobs a bit
-	if vector_length(new_velocity_addition) >= 0.0001 then
+	if vector.length(new_velocity_addition) >= 0.0001 then
 		self.object:add_velocity(new_velocity_addition)
 	end
 end
@@ -319,7 +312,7 @@ mobs.calculate_pitch = function(pos1, pos2)
 		return false
 	end
 
-    return(minetest_dir_to_yaw(vector_new(vector_distance(vector_new(pos1.x,0,pos1.z),vector_new(pos2.x,0,pos2.z)),0,pos1.y - pos2.y)) + HALF_PI)
+    return(minetest_dir_to_yaw(vector.new(vector.distance(vector.new(pos1.x,0,pos1.z),vector.new(pos2.x,0,pos2.z)),0,pos1.y - pos2.y)) + HALF_PI)
 end
 
 --make mobs fly up or down based on their y difference
@@ -356,27 +349,27 @@ mobs.jump_move = function(self, velocity)
 	mobs.set_velocity(self,0)
 
 	--fallback velocity to allow modularity
-    jump_height = DEFAULT_JUMP_HEIGHT
+    local jump_height = DEFAULT_JUMP_HEIGHT
 
 	local yaw = (self.yaw or 0)
 
 	local current_velocity = self.object:get_velocity()
 
 	local goal_velocity = {
-		x = (math_sin(yaw) * -velocity),
+		x = (math.sin(yaw) * -velocity),
 		y = jump_height,
-		z = (math_cos(yaw) * velocity),
+		z = (math.cos(yaw) * velocity),
 	}
 
 
 	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
 
-	if vector_length(new_velocity_addition) > vector_length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector_length(goal_velocity) / vector_length(new_velocity_addition)))
+	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
+		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
 	end
 
 	--smooths out mobs a bit
-	if vector_length(new_velocity_addition) >= 0.0001 then
+	if vector.length(new_velocity_addition) >= 0.0001 then
 		self.object:add_velocity(new_velocity_addition)
 	end
 end

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

@@ -1,10 +1,12 @@
 local math_random = math.random
 
-local minetest_settings                     = minetest.settings
+local minetest_settings = minetest.settings
+
+-- CMI support check
+local use_cmi = minetest.global_exists("cmi")
 
 -- get entity staticdata
 mobs.mob_staticdata = function(self)
-
 	--despawn mechanism
 	--don't despawned tamed or bred mobs
 	if not self.tamed and not self.bred then
@@ -142,8 +144,6 @@ mobs.mob_activate = function(self, staticdata, def, dtime)
 		self.health = math_random (self.hp_min, self.hp_max)
 	end
 
-	
-
 	if not self.random_sound_timer then
 		self.random_sound_timer = math_random(self.random_sound_timer_min,self.random_sound_timer_max)
 	end
@@ -186,7 +186,6 @@ mobs.mob_activate = function(self, staticdata, def, dtime)
 
 	self.texture_mods = {}
 
-
 	self.v_start = false
 	self.timer = 0
 	self.blinktimer = 0
@@ -200,7 +199,6 @@ mobs.mob_activate = function(self, staticdata, def, dtime)
 		self.object:set_texture_mod("")
 	end
 
-
 	-- set anything changed above
 	self.object:set_properties(self)
 

mods/ENTITIES/mcl_mobs/api/mount.lua

@@ -1,8 +1,11 @@
 
 -- lib_mount by Blert2112 (edited by TenPlus1)
 
-local enable_crash = false
-local crash_threshold = 6.5 -- ignored if enable_crash=false
+--local enable_crash = false
+--local crash_threshold = 6.5 -- ignored if enable_crash=false
+
+local math = math
+local vector = vector
 
 ------------------------------------------------------------------------------
 
@@ -10,7 +13,7 @@ local crash_threshold = 6.5 -- ignored if enable_crash=false
 -- Helper functions
 --
 
-local node_ok = function(pos, fallback)
+--[[local function node_ok(pos, fallback)
 
 	fallback = fallback or mobs.fallback_node
 
@@ -21,10 +24,10 @@ local node_ok = function(pos, fallback)
 	end
 
 	return {name = fallback}
-end
+end]]
 
 
-local function node_is(pos)
+--[[local function node_is(pos)
 
 	local node = node_ok(pos)
 
@@ -45,7 +48,7 @@ local function node_is(pos)
 	end
 
 	return "other"
-end
+end]]
 
 
 local function get_sign(i)
@@ -60,13 +63,11 @@ local function get_sign(i)
 end
 
 
-local function get_velocity(v, yaw, y)
-
+--[[local function get_velocity(v, yaw, y)
 	local x = -math.sin(yaw) * v
 	local z =  math.cos(yaw) * v
-
 	return {x = x, y = y, z = z}
-end
+end]]
 
 
 local function get_v(v)
@@ -172,7 +173,7 @@ function mobs.detach(player, offset)
 
 	--pos = {x = pos.x + offset.x, y = pos.y + 0.2 + offset.y, z = pos.z + offset.z}
 
-	player:add_velocity(vector.new(math.random(-6,6),math.random(5,8),math.random(-6,6))) --throw the rider off
+	player:add_velocity(vector.new(math.random(-6,6), math.random(5,8), math.random(-6,6))) --throw the rider off
 
 	--[[
 	minetest.after(0.1, function(name, pos)
@@ -187,13 +188,13 @@ end
 
 function mobs.drive(entity, moving_anim, stand_anim, can_fly, dtime)
 
-	local rot_view = 0
+	--local rot_view = 0
 
-	if entity.player_rotation.y == 90 then
-		rot_view = math.pi/2
-	end
+	--if entity.player_rotation.y == 90 then
+	--	rot_view = math.pi/2
+	--end
 
-	local acce_y = 0
+	--local acce_y = 0
 	local velo = entity.object:get_velocity()
 
 	entity.v = get_v(velo) * get_sign(entity.v)
@@ -388,7 +389,6 @@ end
 -- directional flying routine by D00Med (edited by TenPlus1)
 
 function mobs.fly(entity, dtime, speed, shoots, arrow, moving_anim, stand_anim)
-
 	if true then
 		print("succ")
 		return

mods/ENTITIES/mcl_mobs/api/spawning.lua

@@ -9,9 +9,9 @@ local get_objects_inside_radius    = minetest.get_objects_inside_radius
 
 local math_random    = math.random
 local math_floor     = math.floor
-local max            = math.max
+--local max            = math.max
 
-local vector_distance = vector.distance
+--local vector_distance = vector.distance
 local vector_new      = vector.new
 local vector_floor    = vector.floor
 

mods/ENTITIES/mcl_mobs/mod.conf

@@ -2,4 +2,4 @@ name = mcl_mobs
 author = PilzAdam
 description = Adds a mob API for mods to add animals or monsters, etc.
 depends = mcl_particles
-optional_depends = mcl_weather, mcl_explosions, mcl_hunger, mcl_worlds, invisibility, cmi, doc_identifier, mcl_armor, mcl_portals, mcl_experience
+optional_depends = mcl_weather, mcl_explosions, mcl_hunger, mcl_worlds, cmi, doc_identifier, mcl_armor, mcl_portals, mcl_experience

mods/ITEMS/mcl_end/chorus_plant.lua

@@ -450,6 +450,8 @@ function mcl_end.grow_chorus_plant_step(pos, node, pr)
 end
 
 --- ABM ---
+local seed = minetest.get_mapgen_params().seed
+local pr = PseudoRandom(seed)
 minetest.register_abm({
 	label = "Chorus plant growth",
 	nodenames = { "mcl_end:chorus_flower" },

mods/ITEMS/mcl_nether/lava.lua

@@ -1,12 +1,6 @@
 -- Lava in the Nether
 
-local S = minetest.get_translator("mcl_nether")
-local N = function(s) return s end
-
-local msg = {
-	N("@1 has become one with the lava."),
-	N("@1 has been consumed by the lava."),
-}
+local S = minetest.get_translator(minetest.get_current_modname())
 
 -- TODO: Increase flow speed. This could be done by reducing viscosity,
 -- but this would also allow players to swim faster in lava.
@@ -20,7 +14,6 @@ lava_src_def._doc_items_usagehelp = nil
 lava_src_def.liquid_range = 7
 lava_src_def.liquid_alternative_source = "mcl_nether:nether_lava_source"
 lava_src_def.liquid_alternative_flowing = "mcl_nether:nether_lava_flowing"
-lava_src_def._mcl_node_death_message = msg,
 minetest.register_node("mcl_nether:nether_lava_source", lava_src_def)
 
 local lava_flow_def = table.copy(minetest.registered_nodes["mcl_core:lava_flowing"])
@@ -29,7 +22,6 @@ lava_flow_def._doc_items_create_entry = false
 lava_flow_def.liquid_range = 7
 lava_flow_def.liquid_alternative_flowing = "mcl_nether:nether_lava_flowing"
 lava_flow_def.liquid_alternative_source = "mcl_nether:nether_lava_source"
-lava_flow_def._mcl_node_death_message = msg,
 minetest.register_node("mcl_nether:nether_lava_flowing", lava_flow_def)
 
 -- Add entry aliases for the Help

mods/ITEMS/mcl_nether/locale/mcl_nether.de.tr

@@ -38,5 +38,3 @@ Place this item on soul sand to plant it and watch it grow.=Platzieren Sie den G
 Burns your feet=Verbrennt Ihre Füße
 Grows on soul sand=Wächst auf Seelensand
 Reduces walking speed=Reduziert das Schritttempo
-@1 has become one with the lava.=@1 wurde eins mit der Lava.
-@1 has been consumed by the lava.=@1 wurde von der Lava verzehrt.

mods/ITEMS/mcl_nether/locale/mcl_nether.fr.tr

@@ -38,5 +38,3 @@ Place this item on soul sand to plant it and watch it grow.=Placez cet article s
 Burns your feet=Vous brûle les pieds
 Grows on soul sand=Pousse sur le sable de l'âme
 Reduces walking speed=Réduit la vitesse de marche
-@1 has become one with the lava.=@1 est devenu un avec la lave.
-@1 has been consumed by the lava.=@1 a été consumé par la lave.

mods/ITEMS/mcl_nether/locale/mcl_nether.ru.tr

@@ -38,5 +38,3 @@ Place this item on soul sand to plant it and watch it grow.=Поместите
 Burns your feet=Обжигает ваши ноги
 Grows on soul sand=Растёт на песке душ
 Reduces walking speed=Уменьшает скорость ходьбы
-@1 has become one with the lava.=@1 породнился(лась) с лавой.
-@1 has been consumed by the lava.=@1 был(а) поглощен(а) лавой.

mods/ITEMS/mcl_nether/locale/template.txt

@@ -38,5 +38,3 @@ Place this item on soul sand to plant it and watch it grow.=
 Burns your feet=
 Grows on soul sand=
 Reduces walking speed=
-@1 has become one with the lava.=
-@1 has been consumed by the lava.=

mods/MAPGEN/tsm_railcorridors/init.lua

@@ -114,7 +114,8 @@ if not tsm_railcorridors.nodes.corridor_woods_function then
 end
 
 -- Random Perlin noise generators
-local pr, pr_carts, pr_treasures, pr_deco, webperlin_major, webperlin_minor
+local pr, pr_carts, pr_deco, webperlin_major, webperlin_minor
+--local pr_treasures
 
 local function InitRandomizer(seed)
 	-- Mostly used for corridor gen.
@@ -124,7 +125,7 @@ local function InitRandomizer(seed)
 	-- Separate randomizer for carts because spawning carts is very timing-dependent
 	pr_carts = PseudoRandom(seed-654)
 	-- Chest contents randomizer
-	pr_treasures = PseudoRandom(seed+777)
+	--pr_treasures = PseudoRandom(seed+777)
 	-- Used for cobweb generation, both noises have to reach a high value for cobwebs to appear
 	webperlin_major = PerlinNoise(934, 3, 0.6, 500)
 	webperlin_minor = PerlinNoise(834, 3, 0.6, 50)