Fix #1777 (discord link in readme)

This reverts commit a1acf6d3c1.

.luacheckrc

@@ -40,4 +40,16 @@ read_globals = {
 			"factorial"
 		}
 	},
+    ------
+    --MODS
+    ------
+
+    --GENERAL
+    "default",
+
+    --ENTITIES
+    "cmi",
+
+    --HUD
+    "sfinv", "sfinv_buttons", "unified_inventory", "cmsg", "inventory_plus",
 }

CONTRIBUTING.md

@@ -1,5 +1,5 @@
 # Contributing to MineClone 2
-So you want to MineClone 2?
+So you want to contribute to MineClone 2?
 Wow, thank you! :-)
 
 But first, some things to note:
@@ -46,6 +46,28 @@ Your commit names should be relatively descriptive, e.g. when saying "Fix #issue
 
 Contributors will be credited in `CREDITS.md`.
 
+## Code Style
+
+Each mod must provide `mod.conf`.
+Each mod which add API functions should store functions inside a global table named like the mod.
+Public functions should not use self references but rather just access the table directly.
+Functions should be defined in this way:
+```
+function mcl_xyz.stuff(param) end
+```
+Insteed of this way:
+```
+mcl_xyz.stuff = function(param) end
+```
+Indentation must be unified, more likely with tabs.
+
+Time sensitive mods should make a local copy of most used API functions to improve performances.
+```
+local vector = vector
+local get_node = minetest.get_node
+```
+
+
 ## Features > 1.12
 
 If you want to make a feature that was added in a Minecraft version later than 1.12, you should fork MineClone5 (mineclone5 branch in the repository) and add your changes to this.

README.md

@@ -85,7 +85,7 @@ Please report all bugs and missing Minecraft features here:
 ## Chating with the community
 Join our discord server at:
 
-<https://discord.gg/84GKcxczG3>
+<https://discord.gg/xE4z8EEpDC>
 
 ## Project description
 The main goal of **MineClone 2** is to be a clone of Minecraft and to be released as free software.

mods/CORE/_mcl_autogroup/init.lua

@@ -83,7 +83,7 @@ local function get_hardness_values_for_groups()
 
 	for _, ndef in pairs(minetest.registered_nodes) do
 		for g, _ in pairs(mcl_autogroup.registered_diggroups) do
-			if ndef.groups[g] ~= nil then
+			if ndef.groups[g] then
 				maps[g][ndef._mcl_hardness or 0] = true
 			end
 		end
@@ -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
@@ -298,7 +298,7 @@ function mcl_autogroup.get_wear(toolname, diggroup)
 	return math.ceil(65535 / uses)
 end
 
-local overwrite = function()
+local function overwrite()
 	for nname, ndef in pairs(minetest.registered_nodes) do
 		local newgroups = table.copy(ndef.groups)
 		if (nname ~= "ignore" and ndef.diggable) then
@@ -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/controls/init.lua

@@ -1,6 +1,8 @@
 local get_connected_players = minetest.get_connected_players
 local clock = os.clock
 
+local pairs = pairs
+
 controls = {}
 controls.players = {}
 

mods/CORE/flowlib/init.lua

@@ -1,62 +1,71 @@
+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
-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 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)
 	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]}
+	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
@@ -64,32 +73,28 @@ flowlib.node_is_liquid = node_is_liquid
 --This code is more efficient
 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,44 +113,37 @@ 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}
 	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)
-	
+	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
-local move_centre = function(pos,realpos,node,radius)
+
+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 = minetest.get_node({x=pos.x-1,y=pos.y,z=pos.z})
+			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 = minetest.get_node({x=pos.x+1,y=pos.y,z=pos.z})
+			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})
+			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 = minetest.get_node({x=pos.x,y=pos.y,z=pos.z+1})
+			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

mods/CORE/mcl_attached/init.lua

@@ -1,17 +1,21 @@
+local vector = vector
+
+local facedir_to_dir = minetest.facedir_to_dir
+local get_item_group = minetest.get_item_group
+local remove_node = minetest.remove_node
+local get_node = minetest.get_node
+
 local original_function = minetest.check_single_for_falling
 
-minetest.check_single_for_falling = function(pos)
+function minetest.check_single_for_falling(pos)
 	local ret_o = original_function(pos)
-
 	local ret = false
 	local node = minetest.get_node(pos)
-	if minetest.get_item_group(node.name, "attached_node_facedir") ~= 0 then
-		local dir = minetest.facedir_to_dir(node.param2)
+	if get_item_group(node.name, "attached_node_facedir") ~= 0 then
+		local dir = facedir_to_dir(node.param2)
 		if dir then
-			local cpos = vector.add(pos, dir)
-			local cnode = minetest.get_node(cpos)
-			if minetest.get_item_group(cnode.name, "solid") == 0 then
-				minetest.remove_node(pos)
+			if get_item_group(get_node(vector.add(pos, dir)).name, "solid") == 0 then
+				remove_node(pos)
 				local drops = minetest.get_node_drops(node.name, "")
 				for dr=1, #drops do
 					minetest.add_item(pos, drops[dr])
@@ -20,7 +24,6 @@ minetest.check_single_for_falling = function(pos)
 			end
 		end
 	end
-
 	return ret_o or ret
 end
 

mods/CORE/mcl_bubble_column/LICENSE

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

mods/CORE/mcl_bubble_column/README.md

@@ -1,3 +0,0 @@
-# mcl_bubble_column
-bubble_column mod for mineclone2
-put in /mtdir/games/mineclone2/mods/CORE/

mods/CORE/mcl_bubble_column/init.lua

@@ -1,369 +0,0 @@
-local S = minetest.get_translator("mcl_bubble_column")
-
-local WATER_ALPHA = 179
-local WATER_VISC = 1
-local LAVA_VISC = 7
-local LIGHT_LAVA = minetest.LIGHT_MAX
-local USE_TEXTURE_ALPHA
-if minetest.features.use_texture_alpha_string_modes then
-	USE_TEXTURE_ALPHA = "blend"
-	WATER_ALPHA = nil
-end
-
-minetest.register_node("mcl_bubble_column:water_flowing_up", {
-	description = S("Bubble Column Flowing Water (up)"),
-	_doc_items_create_entry = false,
-	wield_image = "default_water_flowing_animated.png^[verticalframe:64:0",
-	drawtype = "flowingliquid",
-	tiles = {"default_water_flowing_animated.png^[verticalframe:64:0"},
-	special_tiles = {
-		{
-			image="default_water_flowing_animated.png",
-			backface_culling=false,
-			animation={type="vertical_frames", aspect_w=16, aspect_h=16, length=4.0}
-		},
-		{
-			image="default_water_flowing_animated.png",
-			backface_culling=false,
-			animation={type="vertical_frames", aspect_w=16, aspect_h=16, length=4.0}
-		},
-	},
-	sounds = mcl_sounds.node_sound_water_defaults(),
-	is_ground_content = false,
-	alpha = WATER_ALPHA,
-	use_texture_alpha = USE_TEXTURE_ALPHA,
-	paramtype = "light",
-	paramtype2 = "flowingliquid",
-	walkable = false,
-	pointable = false,
-	diggable = false,
-	buildable_to = true,
-	drop = "",
-	drowning = 4,
-	liquidtype = "flowing",
-	liquid_alternative_flowing = "mcl_bubble_column:water_flowing_up",
-	liquid_alternative_source = "mcl_bubble_column:water_source_up",
-	liquid_viscosity = WATER_VISC,
-	liquid_range = 7,
-	post_effect_color = {a=209, r=0x03, g=0x3C, b=0x5C},
-	groups = { water=3, liquid=3, puts_out_fire=1, not_in_creative_inventory=1, freezes=1, melt_around=1, dig_by_piston=1},
-	_mcl_blast_resistance = 100,
-	-- Hardness intentionally set to infinite instead of 100 (Minecraft value) to avoid problems in creative mode
-	_mcl_hardness = -1,
-})
-
-minetest.register_node("mcl_bubble_column:water_source_up", {
-	description = S("Bubble Column Water Source"),
-	_doc_items_entry_name = S("Water"),
-	_doc_items_longdesc = S("Boosts you up"),
-	_doc_items_hidden = false,
-	drawtype = "liquid",
-	tiles = {
-		{name="default_water_source_animated.png", animation={type="vertical_frames", aspect_w=16, aspect_h=16, length=5.0}}
-	},
-	special_tiles = {
-		-- New-style water source material (mostly unused)
-		{
-			name="default_water_source_animated.png",
-			animation={type="vertical_frames", aspect_w=16, aspect_h=16, length=5.0},
-			backface_culling = false,
-		}
-	},
-	sounds = mcl_sounds.node_sound_water_defaults(),
-	is_ground_content = false,
-	alpha = WATER_ALPHA,
-	use_texture_alpha = USE_TEXTURE_ALPHA,
-	paramtype = "light",
-	walkable = false,
-	pointable = false,
-	diggable = false,
-	buildable_to = true,
-	drop = "",
-	drowning = 4,
-	liquidtype = "source",
-	liquid_alternative_flowing = "mcl_bubble_column:water_flowing_up",
-	liquid_alternative_source = "mcl_bubble_column:water_source_up",
-	liquid_viscosity = WATER_VISC,
-	liquid_range = 7,
-	post_effect_color = {a=209, r=0x03, g=0x3C, b=0x5C},
-	stack_max = 64,
-	groups = { water=3, liquid=3, puts_out_fire=1, not_in_creative_inventory=1, dig_by_piston=1},
-	_mcl_blast_resistance = 100,
-	-- Hardness intentionally set to infinite instead of 100 (Minecraft value) to avoid problems in creative mode
-	_mcl_hardness = -1,
-})
-
-minetest.register_globalstep(function()
-    for _,player in ipairs(minetest.get_connected_players()) do
-        local name = player:get_player_name()
-        local pos = player:get_pos()
-        local node = minetest.get_node(pos)
-        if node.name == "mcl_bubble_column:water_source_up" then
-            local velocity = player:get_player_velocity()
-            local velocityadd = {x = 0, y = 3, z = 0}
-            player:add_player_velocity(velocityadd)
-        end
-    end
-end)
-
-minetest.register_abm{
-    label = "entities go up",
-    nodenames = {"mcl_bubble_column:water_source_up"},
-    interval = 0.05,
-    chance = 1,
-    action = function(pos)
-        for _,entity in pairs(minetest.get_objects_inside_radius(pos, 1.5)) do
-        	local pos = entity:get_pos()
-            local velocity = entity:get_velocity()
-            local velocityadd = {x = 0, y = 2, z = 0}
-            entity:add_velocity(velocityadd)
-    	end
-    end,
-}
-
-minetest.register_abm{
-    label = "bubbles go up",
-    nodenames = {"mcl_bubble_column:water_source_up"},
-    interval = 1,
-    chance = 1,
-    action = function(pos)
-        local uppos = vector.add(pos, {x = 0, y = 1, z = 0})
-        local upposnode = minetest.get_node(uppos)
-        if upposnode.name == "mcl_core:water_source" then
-            minetest.set_node(uppos, {name = "mcl_bubble_column:water_source_up"})
-        end
-    end,
-}
-
-minetest.register_abm{
-    label = "start bubble column",
-    nodenames = {"mcl_nether:soul_sand"},
-    interval = 1,
-    chance = 1,
-    action = function(pos)
-        local downpos = vector.add(pos, {x = 0, y = 1, z = 0})
-        local downposnode = minetest.get_node(downpos)
-        if downposnode.name == "mcl_core:water_source" then
-            minetest.set_node(downpos, {name = "mcl_bubble_column:water_source_up"})
-        end
-    end,
-}
-
-minetest.register_abm{
-    label = "stop bubble column",
-    nodenames = {"mcl_bubble_column:water_source_up"},
-    interval = 1,
-    chance = 1,
-    action = function(pos)
-        local downpos = vector.add(pos, {x = 0, y = -1, z = 0})
-        local downposnode = minetest.get_node(downpos)
-        if downposnode.name == "mcl_core:water_source" then
-            minetest.set_node(pos, {name = "mcl_core:water_source"})
-        end
-    end,
-}
-minetest.register_abm{
-    label = "bubbles up",
-    nodenames = {"mcl_bubble_column:water_source_up"},
-    interval = 1,
-    chance = 1,
-    action = function(pos)
-        minetest.add_particlespawner({
-			amount = 10,
-			time = 0.15,
-			minpos = vector.add(pos, { x = -0.25, y = 0, z = -0.25 }),
-			maxpos = vector.add(pos, { x = 0.25, y = 0, z = 0.75 }),
-			attached = player,
-			minvel = {x = -0.2, y = 0, z = -0.2},
-			maxvel = {x = 0.5, y = 0, z = 0.5},
-			minacc = {x = -0.4, y = 4, z = -0.4},
-			maxacc = {x = 0.5, y = 1, z = 0.5},
-			minexptime = 0.3,
-			maxexptime = 0.8,
-			minsize = 0.7,
-			maxsize = 2.4,
-			texture = "mcl_particles_bubble.png"
-		})
-    end,
-}
---whirlpools(take you down)
-
-
-minetest.register_node("mcl_bubble_column:water_flowing_down", {
-	description = S("Bubble Column Flowing Water(down)"),
-	_doc_items_create_entry = false,
-	wield_image = "default_water_flowing_animated.png^[verticalframe:64:0",
-	drawtype = "flowingliquid",
-	tiles = {"default_water_flowing_animated.png^[verticalframe:64:0"},
-	special_tiles = {
-		{
-			image="default_water_flowing_animated.png",
-			backface_culling=false,
-			animation={type="vertical_frames", aspect_w=16, aspect_h=16, length=4.0}
-		},
-		{
-			image="default_water_flowing_animated.png",
-			backface_culling=false,
-			animation={type="vertical_frames", aspect_w=16, aspect_h=16, length=4.0}
-		},
-	},
-	sounds = mcl_sounds.node_sound_water_defaults(),
-	is_ground_content = false,
-	alpha = WATER_ALPHA,
-	use_texture_alpha = USE_TEXTURE_ALPHA,
-	paramtype = "light",
-	paramtype2 = "flowingliquid",
-	walkable = false,
-	pointable = false,
-	diggable = false,
-	buildable_to = true,
-	drop = "",
-	drowning = 4,
-	liquidtype = "flowing",
-	liquid_alternative_flowing = "mcl_bubble_column:water_flowing_down",
-	liquid_alternative_source = "mcl_bubble_column:water_source_down",
-	liquid_viscosity = WATER_VISC,
-	liquid_range = 7,
-	post_effect_color = {a=209, r=0x03, g=0x3C, b=0x5C},
-	groups = { water=3, liquid=3, puts_out_fire=1, not_in_creative_inventory=1, freezes=1, melt_around=1, dig_by_piston=1},
-	_mcl_blast_resistance = 100,
-	-- Hardness intentionally set to infinite instead of 100 (Minecraft value) to avoid problems in creative mode
-	_mcl_hardness = -1,
-})
-
-minetest.register_node("mcl_bubble_column:water_source_down", {
-	description = S("Whirlpool Water Source"),
-	_doc_items_entry_name = S("Water"),
-	_doc_items_longdesc = S("Takes you down!"),
-	_doc_items_hidden = false,
-	drawtype = "liquid",
-	tiles = {
-		{name="default_water_source_animated.png", animation={type="vertical_frames", aspect_w=16, aspect_h=16, length=5.0}}
-	},
-	special_tiles = {
-		-- New-style water source material (mostly unused)
-		{
-			name="default_water_source_animated.png",
-			animation={type="vertical_frames", aspect_w=16, aspect_h=16, length=5.0},
-			backface_culling = false,
-		}
-	},
-	sounds = mcl_sounds.node_sound_water_defaults(),
-	is_ground_content = false,
-	alpha = WATER_ALPHA,
-	use_texture_alpha = USE_TEXTURE_ALPHA,
-	paramtype = "light",
-	walkable = false,
-	pointable = false,
-	diggable = false,
-	buildable_to = true,
-	drop = "",
-	drowning = 4,
-	liquidtype = "source",
-	liquid_alternative_flowing = "mcl_bubble_column:water_flowing_down",
-	liquid_alternative_source = "mcl_bubble_column:water_source_down",
-	liquid_viscosity = WATER_VISC,
-	liquid_range = 7,
-	post_effect_color = {a=209, r=0x03, g=0x3C, b=0x5C},
-	stack_max = 64,
-	groups = { water=3, liquid=3, puts_out_fire=1, not_in_creative_inventory=1, dig_by_piston=1},
-	_mcl_blast_resistance = 100,
-	-- Hardness intentionally set to infinite instead of 100 (Minecraft value) to avoid problems in creative mode
-	_mcl_hardness = -1,
-})
-
-
-minetest.register_globalstep(function()
-    for _,player in ipairs(minetest.get_connected_players()) do
-        local name = player:get_player_name()
-        local pos = player:get_pos()
-        local node = minetest.get_node(pos)
-        if node.name == "mcl_bubble_column:water_source_down" then
-            local velocity = player:get_player_velocity()
-            local velocityadd = {x = 0, y = -0.5, z = 0}
-            player:add_player_velocity(velocityadd)
-        end
-    end
-end)
-
-
-minetest.register_abm{
-    label = "entities go down",
-    nodenames = {"mcl_bubble_column:water_source_down"},
-    interval = 0.05,
-    chance = 1,
-    action = function(pos)
-        for _,entity in pairs(minetest.get_objects_inside_radius(pos, 1.5)) do
-        	local pos = entity:get_pos()
-            local velocity = entity:get_velocity()
-            local velocityadd = {x = 0, y = -3, z = 0}
-            entity:add_velocity(velocityadd)
-    	end
-    end,
-}
-
-minetest.register_abm{
-    label = "whirlpools go up",
-    nodenames = {"mcl_bubble_column:water_source_down"},
-    interval = 1,
-    chance = 1,
-    action = function(pos)
-        local uppos = vector.add(pos, {x = 0, y = 1, z = 0})
-        local upposnode = minetest.get_node(uppos)
-        if upposnode.name == "mcl_core:water_source" then
-            minetest.set_node(uppos, {name = "mcl_bubble_column:water_source_down"})
-        end
-    end,
-}
-
-minetest.register_abm{
-    label = "start whirlpool",
-    nodenames = {"mcl_nether:magma"},
-    interval = 1,
-    chance = 1,
-    action = function(pos)
-        local downpos = vector.add(pos, {x = 0, y = 1, z = 0})
-        local downposnode = minetest.get_node(downpos)
-        if downposnode.name == "mcl_core:water_source" then
-            minetest.set_node(downpos, {name = "mcl_bubble_column:water_source_down"})
-        end
-    end,
-}
-
-minetest.register_abm{
-    label = "stop whirlpool",
-    nodenames = {"mcl_bubble_column:water_source_down"},
-    interval = 1,
-    chance = 1,
-    action = function(pos)
-        local downpos = vector.add(pos, {x = 0, y = -1, z = 0})
-        local downposnode = minetest.get_node(downpos)
-        if downposnode.name == "mcl_core:water_source" then
-            minetest.set_node(pos, {name = "mcl_core:water_source"})
-        end
-    end,
-}
-minetest.register_abm{
-    label = "bubbles down",
-    nodenames = {"mcl_bubble_column:water_source_down"},
-    interval = 1,
-    chance = 1,
-    action = function(pos)
-        minetest.add_particlespawner({
-			amount = 10,
-			time = 0.15,
-			minpos = vector.add(pos, { x = -0.25, y = 0, z = -0.25 }),
-			maxpos = vector.add(pos, { x = 0.25, y = 0, z = 0.75 }),
-			attached = player,
-			minvel = {x = -0.2, y = 0, z = -0.2},
-			maxvel = {x = 0.5, y = 0, z = 0.5},
-			minacc = {x = -0.4, y = -4, z = -0.4},
-			maxacc = {x = 0.5, y = -1, z = 0.5},
-			minexptime = 0.3,
-			maxexptime = 0.8,
-			minsize = 0.7,
-			maxsize = 2.4,
-			texture = "mcl_particles_bubble.png"
-		})
-    end,
-}

mods/CORE/mcl_explosions/init.lua

@@ -12,10 +12,12 @@ 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 mod_fire = minetest.get_modpath("mcl_fire")
+--local CONTENT_FIRE = minetest.get_content_id("mcl_fire:fire")
 
-local S = minetest.get_translator("mcl_explosions")
+local math = math
+local vector = vector
+local table = table
 
 local hash_node_position = minetest.hash_node_position
 local get_objects_inside_radius = minetest.get_objects_inside_radius
@@ -26,6 +28,7 @@ local get_voxel_manip = minetest.get_voxel_manip
 local bulk_set_node = minetest.bulk_set_node
 local check_for_falling = minetest.check_for_falling
 local add_item = minetest.add_item
+local pos_to_string = minetest.pos_to_string
 
 -- Saved sphere explosion shapes for various radiuses
 local sphere_shapes = {}
@@ -66,50 +69,48 @@ local function compute_sphere_rays(radius)
 	local rays = {}
 	local sphere = {}
 
-	for i=1, 2 do
+	local function add_ray(pos)
+		sphere[hash_node_position(pos)] = pos
+	end
+
 	for y = -radius, radius do
 		for z = -radius, radius do
-				for x = -radius, 0, 1 do
+			for x = -radius, 0 do
 				local d = x * x + y * y + z * z
 				if d <= radius * radius then
-						local pos = { x = x, y = y, z = z }
-						sphere[hash_node_position(pos)] = pos
+					add_ray(vector.new(x, y, z))
+					add_ray(vector.new(-x, y, z))
 					break
 				end
 			end
 		end
 	end
-	end
 
-	for i=1,2 do
 	for x = -radius, radius do
 		for z = -radius, radius do
-				for y = -radius, 0, 1 do
+			for y = -radius, 0 do
 				local d = x * x + y * y + z * z
 				if d <= radius * radius then
-						local pos = { x = x, y = y, z = z }
-						sphere[hash_node_position(pos)] = pos
+					add_ray(vector.new(x, y, z))
+					add_ray(vector.new(x, -y, z))
 					break
 				end
 			end
 		end
 	end
-	end
 
-	for i=1,2 do
 	for x = -radius, radius do
 		for y = -radius, radius do
-				for z = -radius, 0, 1 do
+			for z = -radius, 0 do
 				local d = x * x + y * y + z * z
 				if d <= radius * radius then
-						local pos = { x = x, y = y, z = z }
-						sphere[hash_node_position(pos)] = pos
+					add_ray(vector.new(x, y, z))
+					add_ray(vector.new(x, y, -z))
 					break
 				end
 			end
 		end
 	end
-	end
 
 	for _, pos in pairs(sphere) do
 		rays[#rays + 1] = vector.normalize(pos)
@@ -176,14 +177,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 = {}
 
@@ -247,7 +245,7 @@ local function trace_explode(pos, strength, raydirs, radius, info, direct, sourc
 		local ent = obj:get_luaentity()
 
 		-- Ignore items to lower lag
-		if (obj:is_player() or (ent and ent.name ~= '__builtin.item')) and obj:get_hp() > 0 then
+		if (obj:is_player() or (ent and ent.name ~= "__builtin.item")) and obj:get_hp() > 0 then
 			local opos = obj:get_pos()
 			local collisionbox = nil
 
@@ -260,12 +258,12 @@ local function trace_explode(pos, strength, raydirs, radius, info, direct, sourc
 
 			if collisionbox then
 				-- Create rays from random points in the collision box
-				local x1 = collisionbox[1] * 2
-				local y1 = collisionbox[2] * 2
-				local z1 = collisionbox[3] * 2
-				local x2 = collisionbox[4] * 2
-				local y2 = collisionbox[5] * 2
-				local z2 = collisionbox[6] * 2
+				local x1 = collisionbox[1]
+				local y1 = collisionbox[2]
+				local z1 = collisionbox[3]
+				local x2 = collisionbox[4]
+				local y2 = collisionbox[5]
+				local z2 = collisionbox[6]
 				local x_len = math.abs(x2 - x1)
 				local y_len = math.abs(y2 - y1)
 				local z_len = math.abs(z2 - z1)
@@ -363,9 +361,9 @@ local function trace_explode(pos, strength, raydirs, radius, info, direct, sourc
 		local on_blast = node_on_blast[data[idx]]
 		local remove = true
 
-		if do_drop or on_blast ~= nil then
+		if do_drop or on_blast then
 			local npos = get_position_from_hash(hash)
-			if on_blast ~= nil then
+			if on_blast then
 				on_blast(npos, 1.0, do_drop)
 				remove = false
 			else
@@ -407,8 +405,7 @@ local function trace_explode(pos, strength, raydirs, radius, info, direct, sourc
 	end
 
 	-- Log explosion
-	minetest.log('action', 'Explosion at ' .. minetest.pos_to_string(pos) ..
-		' with strength ' .. strength .. ' and radius ' .. radius)
+	minetest.log("action", "Explosion at "..pos_to_string(pos).." with strength "..strength.." and radius "..radius)
 end
 
 -- Create an explosion with strength at pos.

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

@@ -150,7 +150,7 @@ function mcl_util.get_eligible_transfer_item_slot(src_inventory, src_list, dst_i
 end
 
 -- Returns true if itemstack is a shulker box
-local is_not_shulker_box = function(itemstack)
+local function is_not_shulker_box(itemstack)
 	local g = minetest.get_item_group(itemstack:get_name(), "shulker_box")
 	return g == 0 or g == nil
 end
@@ -212,7 +212,7 @@ function mcl_util.move_item_container(source_pos, destination_pos, source_list,
 	end
 
 	-- Normalize double container by forcing to always use the left segment first
-	local normalize_double_container = function(pos, node, ctype)
+	local function normalize_double_container(pos, node, ctype)
 		if ctype == 6 then
 			pos = mcl_util.get_double_container_neighbor_pos(pos, node.param2, "right")
 			if not pos then
@@ -456,14 +456,7 @@ function mcl_util.calculate_durability(itemstack)
 				end
 			end
 		end
-		if not uses then
-			local toolcaps = itemstack:get_tool_capabilities()
-			local groupcaps = toolcaps.groupcaps
-			for _, v in pairs(groupcaps) do
-				uses = v.uses
-				break
-			end
-		end
+		uses = uses or (next(itemstack:get_tool_capabilities().groupcaps) or {}).uses
 	end
 
 	return uses or 0

mods/CORE/mcl_worlds/API.md

@@ -61,20 +61,21 @@ In mc, you cant use clock in the nether and the end.
 
 * pos: position
 
-## mcl_worlds.register_on_dimension_change(function(player, dimension))
+## mcl_worlds.register_on_dimension_change(function(player, dimension, last_dimension))
 Register a callback function func(player, dimension).
 It will be called whenever a player changes between dimensions.
 The void counts as dimension.
 
-* player: player, the player who changed the dimension
-* dimension: position, The new dimension of the player ("overworld", "nether", "end", "void").
+* player: player, the player who changed of dimension
+* dimension: string, The new dimension of the player ("overworld", "nether", "end", "void").
+* last_dimension: string, The dimension where the player was ("overworld", "nether", "end", "void").
 
 
 ## mcl_worlds.registered_on_dimension_change
 Table containing all function registered with mcl_worlds.register_on_dimension_change()
 
 ## mcl_worlds.dimension_change(player, dimension)
-Notify this mod of a dimmension change of <player> to <dimension>
+Notify this mod of a dimension change of <player> to <dimension>
 
 * player: player, player who changed the dimension
 * dimension: string, new dimension ("overworld", "nether", "end", "void")

mods/CORE/mcl_worlds/init.lua

@@ -1,5 +1,7 @@
 mcl_worlds = {}
 
+local get_connected_players = minetest.get_connected_players
+
 -- For a given position, returns a 2-tuple:
 -- 1st return value: true if pos is in void
 -- 2nd return value: true if it is in the deadly part of the void
@@ -44,12 +46,16 @@ function mcl_worlds.y_to_layer(y)
 	end
 end
 
+local y_to_layer = mcl_worlds.y_to_layer
+
 -- Takes a pos and returns the dimension it belongs to (same as above)
 function mcl_worlds.pos_to_dimension(pos)
-	local _, dim = mcl_worlds.y_to_layer(pos.y)
+	local _, dim = y_to_layer(pos.y)
 	return dim
 end
 
+local pos_to_dimension = mcl_worlds.pos_to_dimension
+
 -- Takes a Minecraft layer and a “dimension” name
 -- and returns the corresponding Y coordinate for
 -- MineClone 2.
@@ -112,12 +118,15 @@ 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()
 	for i=1, #mcl_worlds.registered_on_dimension_change do
-		mcl_worlds.registered_on_dimension_change[i](player, dimension)
-		last_dimension[player:get_player_name()] = dimension
+		mcl_worlds.registered_on_dimension_change[i](player, dimension, last_dimension[playername])
 	end
+	last_dimension[playername] = dimension
 end
 
+local dimension_change = mcl_worlds.dimension_change
+
 ----------------------- INTERNAL STUFF ----------------------
 
 -- Update the dimension callbacks every DIM_UPDATE seconds
@@ -125,19 +134,19 @@ local DIM_UPDATE = 1
 local dimtimer = 0
 
 minetest.register_on_joinplayer(function(player)
-	last_dimension[player:get_player_name()] = mcl_worlds.pos_to_dimension(player:get_pos())
+	last_dimension[player:get_player_name()] = pos_to_dimension(player:get_pos())
 end)
 
 minetest.register_globalstep(function(dtime)
 	-- regular updates based on iterval
 	dimtimer = dimtimer + dtime;
 	if dimtimer >= DIM_UPDATE then
-		local players = minetest.get_connected_players()
+		local players = get_connected_players()
 		for p = 1, #players do
-			local dim = mcl_worlds.pos_to_dimension(players[p]:get_pos())
+			local dim = pos_to_dimension(players[p]:get_pos())
 			local name = players[p]:get_player_name()
 			if dim ~= last_dimension[name] then
-				mcl_worlds.dimension_change(players[p], dim)
+				dimension_change(players[p], dim)
 			end
 		end
 		dimtimer = 0

mods/CORE/walkover/init.lua

@@ -4,6 +4,7 @@ local get_connected_players = minetest.get_connected_players
 local get_node = minetest.get_node
 local vector_add = vector.add
 local ceil = math.ceil
+local pairs = pairs
 
 walkover = {}
 walkover.registered_globals = {}
@@ -34,11 +35,9 @@ minetest.register_globalstep(function(dtime)
 		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
-               
+			if loc then
 				local nodeiamon = get_node(loc)
-                
-                if nodeiamon ~= nil then
+				if nodeiamon then
 					if on_walk[nodeiamon.name] then
 						on_walk[nodeiamon.name](loc, nodeiamon, player)
 					end
@@ -48,7 +47,6 @@ minetest.register_globalstep(function(dtime)
 				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,23 +22,18 @@ 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
-	
 		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)
@@ -61,24 +58,18 @@ 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
-
-		
 		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)
@@ -90,16 +81,15 @@ 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
+		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
@@ -108,16 +98,15 @@ minetest.register_abm(
 
 --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
+		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

mods/ENTITIES/extra_mobs/LICENSE

@@ -1,625 +0,0 @@
-GNU GENERAL PUBLIC LICENSE
-
-Version 3, 29 June 2007
-
-Copyright © 2007 Free Software Foundation, Inc. <https://fsf.org/>
-
-Everyone is permitted to copy and distribute verbatim copies of this license
-document, but changing it is not allowed.
-
-Preamble
-
-The GNU General Public License is a free, copyleft license for software and
-other kinds of works.
-
-The licenses for most software and other practical works are designed to take
-away your freedom to share and change the works. By contrast, the GNU General
-Public License is intended to guarantee your freedom to share and change all
-versions of a program--to make sure it remains free software for all its users.
-We, the Free Software Foundation, use the GNU General Public License for most
-of our software; it applies also to any other work released this way by its
-authors. You can apply it to your programs, too.
-
-When we speak of free software, we are referring to freedom, not price. Our
-General Public Licenses are designed to make sure that you have the freedom
-to distribute copies of free software (and charge for them if you wish), that
-you receive source code or can get it if you want it, that you can change
-the software or use pieces of it in new free programs, and that you know you
-can do these things.
-
-To protect your rights, we need to prevent others from denying you these rights
-or asking you to surrender the rights. Therefore, you have certain responsibilities
-if you distribute copies of the software, or if you modify it: responsibilities
-to respect the freedom of others.
-
-For example, if you distribute copies of such a program, whether gratis or
-for a fee, you must pass on to the recipients the same freedoms that you received.
-You must make sure that they, too, receive or can get the source code. And
-you must show them these terms so they know their rights.
-
-Developers that use the GNU GPL protect your rights with two steps: (1) assert
-copyright on the software, and (2) offer you this License giving you legal
-permission to copy, distribute and/or modify it.
-
-For the developers' and authors' protection, the GPL clearly explains that
-there is no warranty for this free software. For both users' and authors'
-sake, the GPL requires that modified versions be marked as changed, so that
-their problems will not be attributed erroneously to authors of previous versions.
-
-Some devices are designed to deny users access to install or run modified
-versions of the software inside them, although the manufacturer can do so.
-This is fundamentally incompatible with the aim of protecting users' freedom
-to change the software. The systematic pattern of such abuse occurs in the
-area of products for individuals to use, which is precisely where it is most
-unacceptable. Therefore, we have designed this version of the GPL to prohibit
-the practice for those products. If such problems arise substantially in other
-domains, we stand ready to extend this provision to those domains in future
-versions of the GPL, as needed to protect the freedom of users.
-
-Finally, every program is threatened constantly by software patents. States
-should not allow patents to restrict development and use of software on general-purpose
-computers, but in those that do, we wish to avoid the special danger that
-patents applied to a free program could make it effectively proprietary. To
-prevent this, the GPL assures that patents cannot be used to render the program
-non-free.
-
-The precise terms and conditions for copying, distribution and modification
-follow.
-
-TERMS AND CONDITIONS
-
-   0. Definitions.
-
-   "This License" refers to version 3 of the GNU General Public License.
-
-"Copyright" also means copyright-like laws that apply to other kinds of works,
-such as semiconductor masks.
-
-"The Program" refers to any copyrightable work licensed under this License.
-Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals
-or organizations.
-
-To "modify" a work means to copy from or adapt all or part of the work in
-a fashion requiring copyright permission, other than the making of an exact
-copy. The resulting work is called a "modified version" of the earlier work
-or a work "based on" the earlier work.
-
-A "covered work" means either the unmodified Program or a work based on the
-Program.
-
-To "propagate" a work means to do anything with it that, without permission,
-would make you directly or secondarily liable for infringement under applicable
-copyright law, except executing it on a computer or modifying a private copy.
-Propagation includes copying, distribution (with or without modification),
-making available to the public, and in some countries other activities as
-well.
-
-To "convey" a work means any kind of propagation that enables other parties
-to make or receive copies. Mere interaction with a user through a computer
-network, with no transfer of a copy, is not conveying.
-
-An interactive user interface displays "Appropriate Legal Notices" to the
-extent that it includes a convenient and prominently visible feature that
-(1) displays an appropriate copyright notice, and (2) tells the user that
-there is no warranty for the work (except to the extent that warranties are
-provided), that licensees may convey the work under this License, and how
-to view a copy of this License. If the interface presents a list of user commands
-or options, such as a menu, a prominent item in the list meets this criterion.
-
-   1. Source Code.
-
-The "source code" for a work means the preferred form of the work for making
-modifications to it. "Object code" means any non-source form of a work.
-
-A "Standard Interface" means an interface that either is an official standard
-defined by a recognized standards body, or, in the case of interfaces specified
-for a particular programming language, one that is widely used among developers
-working in that language.
-
-The "System Libraries" of an executable work include anything, other than
-the work as a whole, that (a) is included in the normal form of packaging
-a Major Component, but which is not part of that Major Component, and (b)
-serves only to enable use of the work with that Major Component, or to implement
-a Standard Interface for which an implementation is available to the public
-in source code form. A "Major Component", in this context, means a major essential
-component (kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to produce
-the work, or an object code interpreter used to run it.
-
-The "Corresponding Source" for a work in object code form means all the source
-code needed to generate, install, and (for an executable work) run the object
-code and to modify the work, including scripts to control those activities.
-However, it does not include the work's System Libraries, or general-purpose
-tools or generally available free programs which are used unmodified in performing
-those activities but which are not part of the work. For example, Corresponding
-Source includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically linked
-subprograms that the work is specifically designed to require, such as by
-intimate data communication or control flow between those subprograms and
-other parts of the work.
-
-The Corresponding Source need not include anything that users can regenerate
-automatically from other parts of the Corresponding Source.
-
-   The Corresponding Source for a work in source code form is that same work.
-
-   2. Basic Permissions.
-
-All rights granted under this License are granted for the term of copyright
-on the Program, and are irrevocable provided the stated conditions are met.
-This License explicitly affirms your unlimited permission to run the unmodified
-Program. The output from running a covered work is covered by this License
-only if the output, given its content, constitutes a covered work. This License
-acknowledges your rights of fair use or other equivalent, as provided by copyright
-law.
-
-You may make, run and propagate covered works that you do not convey, without
-conditions so long as your license otherwise remains in force. You may convey
-covered works to others for the sole purpose of having them make modifications
-exclusively for you, or provide you with facilities for running those works,
-provided that you comply with the terms of this License in conveying all material
-for which you do not control copyright. Those thus making or running the covered
-works for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of your copyrighted
-material outside their relationship with you.
-
-Conveying under any other circumstances is permitted solely under the conditions
-stated below. Sublicensing is not allowed; section 10 makes it unnecessary.
-
-   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-No covered work shall be deemed part of an effective technological measure
-under any applicable law fulfilling obligations under article 11 of the WIPO
-copyright treaty adopted on 20 December 1996, or similar laws prohibiting
-or restricting circumvention of such measures.
-
-When you convey a covered work, you waive any legal power to forbid circumvention
-of technological measures to the extent such circumvention is effected by
-exercising rights under this License with respect to the covered work, and
-you disclaim any intention to limit operation or modification of the work
-as a means of enforcing, against the work's users, your or third parties'
-legal rights to forbid circumvention of technological measures.
-
-   4. Conveying Verbatim Copies.
-
-You may convey verbatim copies of the Program's source code as you receive
-it, in any medium, provided that you conspicuously and appropriately publish
-on each copy an appropriate copyright notice; keep intact all notices stating
-that this License and any non-permissive terms added in accord with section
-7 apply to the code; keep intact all notices of the absence of any warranty;
-and give all recipients a copy of this License along with the Program.
-
-You may charge any price or no price for each copy that you convey, and you
-may offer support or warranty protection for a fee.
-
-   5. Conveying Modified Source Versions.
-
-You may convey a work based on the Program, or the modifications to produce
-it from the Program, in the form of source code under the terms of section
-4, provided that you also meet all of these conditions:
-
-a) The work must carry prominent notices stating that you modified it, and
-giving a relevant date.
-
-b) The work must carry prominent notices stating that it is released under
-this License and any conditions added under section 7. This requirement modifies
-the requirement in section 4 to "keep intact all notices".
-
-c) You must license the entire work, as a whole, under this License to anyone
-who comes into possession of a copy. This License will therefore apply, along
-with any applicable section 7 additional terms, to the whole of the work,
-and all its parts, regardless of how they are packaged. This License gives
-no permission to license the work in any other way, but it does not invalidate
-such permission if you have separately received it.
-
-d) If the work has interactive user interfaces, each must display Appropriate
-Legal Notices; however, if the Program has interactive interfaces that do
-not display Appropriate Legal Notices, your work need not make them do so.
-
-A compilation of a covered work with other separate and independent works,
-which are not by their nature extensions of the covered work, and which are
-not combined with it such as to form a larger program, in or on a volume of
-a storage or distribution medium, is called an "aggregate" if the compilation
-and its resulting copyright are not used to limit the access or legal rights
-of the compilation's users beyond what the individual works permit. Inclusion
-of a covered work in an aggregate does not cause this License to apply to
-the other parts of the aggregate.
-
-   6. Conveying Non-Source Forms.
-
-You may convey a covered work in object code form under the terms of sections
-4 and 5, provided that you also convey the machine-readable Corresponding
-Source under the terms of this License, in one of these ways:
-
-a) Convey the object code in, or embodied in, a physical product (including
-a physical distribution medium), accompanied by the Corresponding Source fixed
-on a durable physical medium customarily used for software interchange.
-
-b) Convey the object code in, or embodied in, a physical product (including
-a physical distribution medium), accompanied by a written offer, valid for
-at least three years and valid for as long as you offer spare parts or customer
-support for that product model, to give anyone who possesses the object code
-either (1) a copy of the Corresponding Source for all the software in the
-product that is covered by this License, on a durable physical medium customarily
-used for software interchange, for a price no more than your reasonable cost
-of physically performing this conveying of source, or (2) access to copy the
-Corresponding Source from a network server at no charge.
-
-c) Convey individual copies of the object code with a copy of the written
-offer to provide the Corresponding Source. This alternative is allowed only
-occasionally and noncommercially, and only if you received the object code
-with such an offer, in accord with subsection 6b.
-
-d) Convey the object code by offering access from a designated place (gratis
-or for a charge), and offer equivalent access to the Corresponding Source
-in the same way through the same place at no further charge. You need not
-require recipients to copy the Corresponding Source along with the object
-code. If the place to copy the object code is a network server, the Corresponding
-Source may be on a different server (operated by you or a third party) that
-supports equivalent copying facilities, provided you maintain clear directions
-next to the object code saying where to find the Corresponding Source. Regardless
-of what server hosts the Corresponding Source, you remain obligated to ensure
-that it is available for as long as needed to satisfy these requirements.
-
-e) Convey the object code using peer-to-peer transmission, provided you inform
-other peers where the object code and Corresponding Source of the work are
-being offered to the general public at no charge under subsection 6d.
-
-A separable portion of the object code, whose source code is excluded from
-the Corresponding Source as a System Library, need not be included in conveying
-the object code work.
-
-A "User Product" is either (1) a "consumer product", which means any tangible
-personal property which is normally used for personal, family, or household
-purposes, or (2) anything designed or sold for incorporation into a dwelling.
-In determining whether a product is a consumer product, doubtful cases shall
-be resolved in favor of coverage. For a particular product received by a particular
-user, "normally used" refers to a typical or common use of that class of product,
-regardless of the status of the particular user or of the way in which the
-particular user actually uses, or expects or is expected to use, the product.
-A product is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent the
-only significant mode of use of the product.
-
-"Installation Information" for a User Product means any methods, procedures,
-authorization keys, or other information required to install and execute modified
-versions of a covered work in that User Product from a modified version of
-its Corresponding Source. The information must suffice to ensure that the
-continued functioning of the modified object code is in no case prevented
-or interfered with solely because modification has been made.
-
-If you convey an object code work under this section in, or with, or specifically
-for use in, a User Product, and the conveying occurs as part of a transaction
-in which the right of possession and use of the User Product is transferred
-to the recipient in perpetuity or for a fixed term (regardless of how the
-transaction is characterized), the Corresponding Source conveyed under this
-section must be accompanied by the Installation Information. But this requirement
-does not apply if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has been installed
-in ROM).
-
-The requirement to provide Installation Information does not include a requirement
-to continue to provide support service, warranty, or updates for a work that
-has been modified or installed by the recipient, or for the User Product in
-which it has been modified or installed. Access to a network may be denied
-when the modification itself materially and adversely affects the operation
-of the network or violates the rules and protocols for communication across
-the network.
-
-Corresponding Source conveyed, and Installation Information provided, in accord
-with this section must be in a format that is publicly documented (and with
-an implementation available to the public in source code form), and must require
-no special password or key for unpacking, reading or copying.
-
-   7. Additional Terms.
-
-"Additional permissions" are terms that supplement the terms of this License
-by making exceptions from one or more of its conditions. Additional permissions
-that are applicable to the entire Program shall be treated as though they
-were included in this License, to the extent that they are valid under applicable
-law. If additional permissions apply only to part of the Program, that part
-may be used separately under those permissions, but the entire Program remains
-governed by this License without regard to the additional permissions.
-
-When you convey a copy of a covered work, you may at your option remove any
-additional permissions from that copy, or from any part of it. (Additional
-permissions may be written to require their own removal in certain cases when
-you modify the work.) You may place additional permissions on material, added
-by you to a covered work, for which you have or can give appropriate copyright
-permission.
-
-Notwithstanding any other provision of this License, for material you add
-to a covered work, you may (if authorized by the copyright holders of that
-material) supplement the terms of this License with terms:
-
-a) Disclaiming warranty or limiting liability differently from the terms of
-sections 15 and 16 of this License; or
-
-b) Requiring preservation of specified reasonable legal notices or author
-attributions in that material or in the Appropriate Legal Notices displayed
-by works containing it; or
-
-c) Prohibiting misrepresentation of the origin of that material, or requiring
-that modified versions of such material be marked in reasonable ways as different
-from the original version; or
-
-d) Limiting the use for publicity purposes of names of licensors or authors
-of the material; or
-
-e) Declining to grant rights under trademark law for use of some trade names,
-trademarks, or service marks; or
-
-f) Requiring indemnification of licensors and authors of that material by
-anyone who conveys the material (or modified versions of it) with contractual
-assumptions of liability to the recipient, for any liability that these contractual
-assumptions directly impose on those licensors and authors.
-
-All other non-permissive additional terms are considered "further restrictions"
-within the meaning of section 10. If the Program as you received it, or any
-part of it, contains a notice stating that it is governed by this License
-along with a term that is a further restriction, you may remove that term.
-If a license document contains a further restriction but permits relicensing
-or conveying under this License, you may add to a covered work material governed
-by the terms of that license document, provided that the further restriction
-does not survive such relicensing or conveying.
-
-If you add terms to a covered work in accord with this section, you must place,
-in the relevant source files, a statement of the additional terms that apply
-to those files, or a notice indicating where to find the applicable terms.
-
-Additional terms, permissive or non-permissive, may be stated in the form
-of a separately written license, or stated as exceptions; the above requirements
-apply either way.
-
-   8. Termination.
-
-You may not propagate or modify a covered work except as expressly provided
-under this License. Any attempt otherwise to propagate or modify it is void,
-and will automatically terminate your rights under this License (including
-any patent licenses granted under the third paragraph of section 11).
-
-However, if you cease all violation of this License, then your license from
-a particular copyright holder is reinstated (a) provisionally, unless and
-until the copyright holder explicitly and finally terminates your license,
-and (b) permanently, if the copyright holder fails to notify you of the violation
-by some reasonable means prior to 60 days after the cessation.
-
-Moreover, your license from a particular copyright holder is reinstated permanently
-if the copyright holder notifies you of the violation by some reasonable means,
-this is the first time you have received notice of violation of this License
-(for any work) from that copyright holder, and you cure the violation prior
-to 30 days after your receipt of the notice.
-
-Termination of your rights under this section does not terminate the licenses
-of parties who have received copies or rights from you under this License.
-If your rights have been terminated and not permanently reinstated, you do
-not qualify to receive new licenses for the same material under section 10.
-
-   9. Acceptance Not Required for Having Copies.
-
-You are not required to accept this License in order to receive or run a copy
-of the Program. Ancillary propagation of a covered work occurring solely as
-a consequence of using peer-to-peer transmission to receive a copy likewise
-does not require acceptance. However, nothing other than this License grants
-you permission to propagate or modify any covered work. These actions infringe
-copyright if you do not accept this License. Therefore, by modifying or propagating
-a covered work, you indicate your acceptance of this License to do so.
-
-   10. Automatic Licensing of Downstream Recipients.
-
-Each time you convey a covered work, the recipient automatically receives
-a license from the original licensors, to run, modify and propagate that work,
-subject to this License. You are not responsible for enforcing compliance
-by third parties with this License.
-
-An "entity transaction" is a transaction transferring control of an organization,
-or substantially all assets of one, or subdividing an organization, or merging
-organizations. If propagation of a covered work results from an entity transaction,
-each party to that transaction who receives a copy of the work also receives
-whatever licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the Corresponding
-Source of the work from the predecessor in interest, if the predecessor has
-it or can get it with reasonable efforts.
-
-You may not impose any further restrictions on the exercise of the rights
-granted or affirmed under this License. For example, you may not impose a
-license fee, royalty, or other charge for exercise of rights granted under
-this License, and you may not initiate litigation (including a cross-claim
-or counterclaim in a lawsuit) alleging that any patent claim is infringed
-by making, using, selling, offering for sale, or importing the Program or
-any portion of it.
-
-   11. Patents.
-
-A "contributor" is a copyright holder who authorizes use under this License
-of the Program or a work on which the Program is based. The work thus licensed
-is called the contributor's "contributor version".
-
-A contributor's "essential patent claims" are all patent claims owned or controlled
-by the contributor, whether already acquired or hereafter acquired, that would
-be infringed by some manner, permitted by this License, of making, using,
-or selling its contributor version, but do not include claims that would be
-infringed only as a consequence of further modification of the contributor
-version. For purposes of this definition, "control" includes the right to
-grant patent sublicenses in a manner consistent with the requirements of this
-License.
-
-Each contributor grants you a non-exclusive, worldwide, royalty-free patent
-license under the contributor's essential patent claims, to make, use, sell,
-offer for sale, import and otherwise run, modify and propagate the contents
-of its contributor version.
-
-In the following three paragraphs, a "patent license" is any express agreement
-or commitment, however denominated, not to enforce a patent (such as an express
-permission to practice a patent or covenant not to sue for patent infringement).
-To "grant" such a patent license to a party means to make such an agreement
-or commitment not to enforce a patent against the party.
-
-If you convey a covered work, knowingly relying on a patent license, and the
-Corresponding Source of the work is not available for anyone to copy, free
-of charge and under the terms of this License, through a publicly available
-network server or other readily accessible means, then you must either (1)
-cause the Corresponding Source to be so available, or (2) arrange to deprive
-yourself of the benefit of the patent license for this particular work, or
-(3) arrange, in a manner consistent with the requirements of this License,
-to extend the patent license to downstream recipients. "Knowingly relying"
-means you have actual knowledge that, but for the patent license, your conveying
-the covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that country
-that you have reason to believe are valid.
-
-If, pursuant to or in connection with a single transaction or arrangement,
-you convey, or propagate by procuring conveyance of, a covered work, and grant
-a patent license to some of the parties receiving the covered work authorizing
-them to use, propagate, modify or convey a specific copy of the covered work,
-then the patent license you grant is automatically extended to all recipients
-of the covered work and works based on it.
-
-A patent license is "discriminatory" if it does not include within the scope
-of its coverage, prohibits the exercise of, or is conditioned on the non-exercise
-of one or more of the rights that are specifically granted under this License.
-You may not convey a covered work if you are a party to an arrangement with
-a third party that is in the business of distributing software, under which
-you make payment to the third party based on the extent of your activity of
-conveying the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory patent
-license (a) in connection with copies of the covered work conveyed by you
-(or copies made from those copies), or (b) primarily for and in connection
-with specific products or compilations that contain the covered work, unless
-you entered into that arrangement, or that patent license was granted, prior
-to 28 March 2007.
-
-Nothing in this License shall be construed as excluding or limiting any implied
-license or other defenses to infringement that may otherwise be available
-to you under applicable patent law.
-
-   12. No Surrender of Others' Freedom.
-
-If conditions are imposed on you (whether by court order, agreement or otherwise)
-that contradict the conditions of this License, they do not excuse you from
-the conditions of this License. If you cannot convey a covered work so as
-to satisfy simultaneously your obligations under this License and any other
-pertinent obligations, then as a consequence you may not convey it at all.
-For example, if you agree to terms that obligate you to collect a royalty
-for further conveying from those to whom you convey the Program, the only
-way you could satisfy both those terms and this License would be to refrain
-entirely from conveying the Program.
-
-   13. Use with the GNU Affero General Public License.
-
-Notwithstanding any other provision of this License, you have permission to
-link or combine any covered work with a work licensed under version 3 of the
-GNU Affero General Public License into a single combined work, and to convey
-the resulting work. The terms of this License will continue to apply to the
-part which is the covered work, but the special requirements of the GNU Affero
-General Public License, section 13, concerning interaction through a network
-will apply to the combination as such.
-
-   14. Revised Versions of this License.
-
-The Free Software Foundation may publish revised and/or new versions of the
-GNU General Public License from time to time. Such new versions will be similar
-in spirit to the present version, but may differ in detail to address new
-problems or concerns.
-
-Each version is given a distinguishing version number. If the Program specifies
-that a certain numbered version of the GNU General Public License "or any
-later version" applies to it, you have the option of following the terms and
-conditions either of that numbered version or of any later version published
-by the Free Software Foundation. If the Program does not specify a version
-number of the GNU General Public License, you may choose any version ever
-published by the Free Software Foundation.
-
-If the Program specifies that a proxy can decide which future versions of
-the GNU General Public License can be used, that proxy's public statement
-of acceptance of a version permanently authorizes you to choose that version
-for the Program.
-
-Later license versions may give you additional or different permissions. However,
-no additional obligations are imposed on any author or copyright holder as
-a result of your choosing to follow a later version.
-
-   15. Disclaimer of Warranty.
-
-THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE
-LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
-EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM
-PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
-CORRECTION.
-
-   16. Limitation of Liability.
-
-IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
-ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM
-AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
-INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO
-USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
-INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE
-PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER
-PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
-   17. Interpretation of Sections 15 and 16.
-
-If the disclaimer of warranty and limitation of liability provided above cannot
-be given local legal effect according to their terms, reviewing courts shall
-apply local law that most closely approximates an absolute waiver of all civil
-liability in connection with the Program, unless a warranty or assumption
-of liability accompanies a copy of the Program in return for a fee. END OF
-TERMS AND CONDITIONS
-
-How to Apply These Terms to Your New Programs
-
-If you develop a new program, and you want it to be of the greatest possible
-use to the public, the best way to achieve this is to make it free software
-which everyone can redistribute and change under these terms.
-
-To do so, attach the following notices to the program. It is safest to attach
-them to the start of each source file to most effectively state the exclusion
-of warranty; and each file should have at least the "copyright" line and a
-pointer to where the full notice is found.
-
-<one line to give the program's name and a brief idea of what it does.>
-
-Copyright (C) <year> <name of author>
-
-This program is free software: you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free Software
-Foundation, either version 3 of the License, or (at your option) any later
-version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-this program. If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program does terminal interaction, make it output a short notice like
-this when it starts in an interactive mode:
-
-<program> Copyright (C) <year> <name of author>
-
-This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-
-This is free software, and you are welcome to redistribute it under certain
-conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License. Of course, your program's commands might
-be different; for a GUI interface, you would use an "about box".
-
-You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary. For
-more information on this, and how to apply and follow the GNU GPL, see <https://www.gnu.org/licenses/>.
-
-The GNU General Public License does not permit incorporating your program
-into proprietary programs. If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library. If this is what you want to do, use the GNU Lesser General Public
-License instead of this License. But first, please read <https://www.gnu.org/
-licenses /why-not-lgpl.html>.

mods/ENTITIES/extra_mobs/README.md

@@ -1,3 +0,0 @@
-# extra_mobs
-
-A mod that adds aditional mobs to Mineclone 2, namely mobs that were added in updates of Minecraft past 1.12 (Mineclone's goal)

mods/ENTITIES/extra_mobs/TODO.txt

@@ -1,39 +0,0 @@
-TODO.Mobs:
-
-  Mountain Goats
-
-  Fish
-
-  Dolfins
-
-  Fox
-
-  Pandas
-
-  Zombified Piglins
-
-  Pillagers
-
-  Ravagers
-
-  Phantoms
-
-  Hoglins
-
-  Zoglins
-
-  Drowneds
-
-  Glow Squids
-
-  Axolotls
-
-Done.Mobs:
-
-  Piglins
-
-  Strider
-
-  Herobrine (optional)
-
-  Hoglin/Zoglin

mods/ENTITIES/extra_mobs/cod.lua

@@ -1,262 +0,0 @@
---MCmobs v0.4
---maikerumine
---made for MC like Survival game
---License for code WTFPL and otherwise stated in readmes
-
-local pi = math.pi
-local atann = math.atan
-local atan = function(x)
-	if not x or x ~= x then
-		return 0
-	else
-		return atann(x)
-	end
-end
-
-local dir_to_pitch = function(dir)
-	local dir2 = vector.normalize(dir)
-	local xz = math.abs(dir.x) + math.abs(dir.z)
-	return -math.atan2(-dir.y, xz)
-end
-
-local function degrees(rad)
-	return rad * 180.0 / math.pi
-end
-
-local S = minetest.get_translator("extra_mobs")
-
---###################
---################### cod
---###################
-
-local cod = {
-    type = "animal",
-    spawn_class = "water",
-    can_despawn = true,
-    passive = true,
-    hp_min = 3,
-    hp_max = 3,
-    xp_min = 1,
-    xp_max = 3,
-    armor = 100,
-	rotate = 270,
-    tilt_swim = true,
-    collisionbox = {-0.3, 0.0, -0.3, 0.3, 0.79, 0.3},
-    visual = "mesh",
-    mesh = "extra_mobs_cod.b3d",
-    textures = {
-        {"extra_mobs_cod.png"}
-    },
-    sounds = {
-    },
-    animation = {
-		stand_start = 1,
-		stand_end = 20,
-		walk_start = 1,
-		walk_end = 20,
-		run_start = 1,
-		run_end = 20,
-	},
-    drops = {
-		{name = "mcl_fishing:fish_raw",
-		chance = 1,
-		min = 1,
-		max = 1,},
-        {name = "mcl_dye:white",
-		chance = 20,
-		min = 1,
-		max = 1,},
-	},
-    visual_size = {x=3, y=3},
-    makes_footstep_sound = false,
-    swim = true,
-    breathes_in_water = true,
-    jump = false,
-    view_range = 16,
-    runaway = true,
-    fear_height = 4,
-    do_custom = function(self)
-      self.object:set_bone_position("body", vector.new(0,1,0), vector.new(degrees(dir_to_pitch(self.object:get_velocity())) * -1 + 90,0,0))
-      if minetest.get_item_group(self.standing_in, "water") ~= 0 then
-				if self.object:get_velocity().y < 2.5 then
-        	self.object:add_velocity({ x = 0 , y = math.random(-.002, .002) , z = 0 })
-				end
-      end
-      for _,object in pairs(minetest.get_objects_inside_radius(self.object:get_pos(), 10)) do
-  			local lp = object:get_pos()
-  			local s = self.object:get_pos()
-  			local vec = {
-  				x = lp.x - s.x,
-  				y = lp.y - s.y,
-  				z = lp.z - s.z
-  			}
-  			if object and not object:is_player() and object:get_luaentity() and object:get_luaentity().name == "extra_mobs:cod" then
-  				self.state = "runaway"
-  				self.object:set_rotation({x=0,y=(atan(vec.z / vec.x) + 3 * pi / 2) - self.rotate,z=0})
-  			end
-  		end
-    end
-}
-
-mobs:register_mob("extra_mobs:cod", cod)
-
-
---spawning TODO: in schools
-
-local water = mobs_mc.spawn_height.water + 1
-
-mobs:spawn_specific(
-"extra_mobs:cod",
-"overworld",
-"water",
-{
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-"RoofedForest_ocean",
-"JungleEdgeM_ocean",
-"BirchForestM_ocean",
-"BirchForest_ocean",
-"IcePlains_deep_ocean",
-"Jungle_deep_ocean",
-"Savanna_ocean",
-"MesaPlateauF_ocean",
-"ExtremeHillsM_deep_ocean",
-"Savanna_deep_ocean",
-"SunflowerPlains_ocean",
-"Swampland_deep_ocean",
-"Swampland_ocean",
-"MegaSpruceTaiga_deep_ocean",
-"ExtremeHillsM_ocean",
-"JungleEdgeM_deep_ocean",
-"SunflowerPlains_deep_ocean",
-"BirchForest_deep_ocean",
-"IcePlainsSpikes_ocean",
-"Mesa_ocean",
-"StoneBeach_ocean",
-"Plains_deep_ocean",
-"JungleEdge_deep_ocean",
-"SavannaM_deep_ocean",
-"Desert_deep_ocean",
-"Mesa_deep_ocean",
-"ColdTaiga_deep_ocean",
-"Plains_ocean",
-"MesaPlateauFM_ocean",
-"Forest_deep_ocean",
-"JungleM_deep_ocean",
-"FlowerForest_deep_ocean",
-"MushroomIsland_ocean",
-"MegaTaiga_ocean",
-"StoneBeach_deep_ocean",
-"IcePlainsSpikes_deep_ocean",
-"ColdTaiga_ocean",
-"SavannaM_ocean",
-"MesaPlateauF_deep_ocean",
-"MesaBryce_deep_ocean",
-"ExtremeHills+_deep_ocean",
-"ExtremeHills_ocean",
-"MushroomIsland_deep_ocean",
-"Forest_ocean",
-"MegaTaiga_deep_ocean",
-"JungleEdge_ocean",
-"MesaBryce_ocean",
-"MegaSpruceTaiga_ocean",
-"ExtremeHills+_ocean",
-"Jungle_ocean",
-"RoofedForest_deep_ocean",
-"IcePlains_ocean",
-"FlowerForest_ocean",
-"ExtremeHills_deep_ocean",
-"MesaPlateauFM_deep_ocean",
-"Desert_ocean",
-"Taiga_ocean",
-"BirchForestM_deep_ocean",
-"Taiga_deep_ocean",
-"JungleM_ocean",
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-4000, 
-3, 
-water-16, 
-water)
-
---spawn egg
-mobs:register_egg("extra_mobs:cod", S("Cod"), "extra_mobs_spawn_icon_cod.png", 0)

mods/ENTITIES/extra_mobs/credits.txt

@@ -1,3 +0,0 @@
-Strider textures -- [NO11]
-Fox textures -- [NO11]
-fungus on a stick ability -- [TechDudie]

mods/ENTITIES/extra_mobs/depends.txt

@@ -1 +0,0 @@
-mobs_mc

mods/ENTITIES/extra_mobs/dolphin.lua

@@ -1,249 +0,0 @@
---MCmobs v0.4
---maikerumine
---made for MC like Survival game
---License for code WTFPL and otherwise stated in readmes
-
-local pi = math.pi
-local atann = math.atan
-local atan = function(x)
-	if not x or x ~= x then
-		return 0
-	else
-		return atann(x)
-	end
-end
-
-local dir_to_pitch = function(dir)
-	local dir2 = vector.normalize(dir)
-	local xz = math.abs(dir.x) + math.abs(dir.z)
-	return -math.atan2(-dir.y, xz)
-end
-
-local function degrees(rad)
-	return rad * 180.0 / math.pi
-end
-
-local S = minetest.get_translator("extra_mobs")
-
---###################
---################### dolphin
---###################
-
-local dolphin = {
-    type = "monster",
-    spawn_class = "water",
-    can_despawn = true,
-    passive = true,
-    hp_min = 10,
-    hp_max = 10,
-    xp_min = 1,
-    xp_max = 3,
-    armor = 100,
-	walk_chance = 100,
-	breath_max = 120,
-	rotate = 270,
-    tilt_swim = true,
-    collisionbox = {-0.3, 0.0, -0.3, 0.3, 0.79, 0.3},
-    visual = "mesh",
-    mesh = "extra_mobs_dolphin.b3d",
-    textures = {
-        {"extra_mobs_dolphin.png"}
-    },
-    sounds = {
-    },
-    animation = {
-		stand_start = 20,
-		stand_end = 20,
-		walk_start = 0,
-		walk_end = 15,
-		run_start = 30,
-		run_end = 45,
-		},
-		drops = {
-			{name = "mcl_fishing:fish_raw",
-			chance = 1,
-			min = 0,
-			max = 1,},
-		},
-    visual_size = {x=3, y=3},
-    makes_footstep_sound = false,
-    swim = true,
-    breathes_in_water = true,
-    jump = false,
-    view_range = 16,
-    fear_height = 4,
-		walk_velocity = 3,
-		run_velocity = 6,
-		reach = 2,
-		damage = 2.5,
-		attack_type = "dogfight",
-		do_custom = function(self)
-      self.object:set_bone_position("body", vector.new(0,1,0), vector.new(degrees(dir_to_pitch(self.object:get_velocity())) * -1 + 90,0,0))
-      if minetest.get_item_group(self.standing_in, "water") ~= 0 then
-				if self.object:get_velocity().y < 5 then
-        	self.object:add_velocity({ x = 0 , y = math.random(-.007, .007), z = 0 })
-				end
-      end
-    end,
-}
-
-mobs:register_mob("extra_mobs:dolphin", dolphin)
-
-
---spawning TODO: in schools
-local water = mobs_mc.spawn_height.water + 1
-mobs:spawn_specific(
-"extra_mobs:dolphin", 
-"overworld", 
-"water",
-{
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-"RoofedForest_ocean",
-"JungleEdgeM_ocean",
-"BirchForestM_ocean",
-"BirchForest_ocean",
-"IcePlains_deep_ocean",
-"Jungle_deep_ocean",
-"Savanna_ocean",
-"MesaPlateauF_ocean",
-"ExtremeHillsM_deep_ocean",
-"Savanna_deep_ocean",
-"SunflowerPlains_ocean",
-"Swampland_deep_ocean",
-"Swampland_ocean",
-"MegaSpruceTaiga_deep_ocean",
-"ExtremeHillsM_ocean",
-"JungleEdgeM_deep_ocean",
-"SunflowerPlains_deep_ocean",
-"BirchForest_deep_ocean",
-"IcePlainsSpikes_ocean",
-"Mesa_ocean",
-"StoneBeach_ocean",
-"Plains_deep_ocean",
-"JungleEdge_deep_ocean",
-"SavannaM_deep_ocean",
-"Desert_deep_ocean",
-"Mesa_deep_ocean",
-"ColdTaiga_deep_ocean",
-"Plains_ocean",
-"MesaPlateauFM_ocean",
-"Forest_deep_ocean",
-"JungleM_deep_ocean",
-"FlowerForest_deep_ocean",
-"MushroomIsland_ocean",
-"MegaTaiga_ocean",
-"StoneBeach_deep_ocean",
-"IcePlainsSpikes_deep_ocean",
-"ColdTaiga_ocean",
-"SavannaM_ocean",
-"MesaPlateauF_deep_ocean",
-"MesaBryce_deep_ocean",
-"ExtremeHills+_deep_ocean",
-"ExtremeHills_ocean",
-"MushroomIsland_deep_ocean",
-"Forest_ocean",
-"MegaTaiga_deep_ocean",
-"JungleEdge_ocean",
-"MesaBryce_ocean",
-"MegaSpruceTaiga_ocean",
-"ExtremeHills+_ocean",
-"Jungle_ocean",
-"RoofedForest_deep_ocean",
-"IcePlains_ocean",
-"FlowerForest_ocean",
-"ExtremeHills_deep_ocean",
-"MesaPlateauFM_deep_ocean",
-"Desert_ocean",
-"Taiga_ocean",
-"BirchForestM_deep_ocean",
-"Taiga_deep_ocean",
-"JungleM_ocean",
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-4000, 
-3, 
-water-16, 
-water)
-
---spawn egg
-mobs:register_egg("extra_mobs:dolphin", S("dolphin"), "extra_mobs_spawn_icon_dolphin.png", 0)

mods/ENTITIES/extra_mobs/fox.lua

@@ -1,177 +0,0 @@
---MCmobs v0.4
---maikerumine
---made for MC like Survival game
---License for code WTFPL and otherwise stated in readmes
-local pi = math.pi
-local atann = math.atan
-local atan = function(x)
-	if not x or x ~= x then
-		return 0
-	else
-		return atann(x)
-	end
-end
-
-local S = minetest.get_translator("extra_mobs")
-
---###################
---################### fox
---###################
-
-local followitem = ""
-if minetest.get_modpath("mc_sweet_berry") then
-    followitem = "mc_sweet_berry:sweet_berry"
-else
-    followitem = nil
-end
-
-local fox = {
-	type = "monster",
-	passive = false,
-	spawn_class = "hostile",
-	hp_min = 10,
-	hp_max = 10,
-	xp_min = 1,
-	xp_max = 2,
-	armor = {fleshy = 90},
-	attack_type = "dogfight",
-	damage = 2,
-	reach = 1.5,
-	collisionbox = {-0.3, -0.01, -0.3, 0.3, 0.84, 0.3},
-	visual = "mesh",
-	mesh = "extra_mobs_fox.b3d",
-	textures = { {
-		"extra_mobs_fox.png",
-		"extra_mobs_trans.png",
-	} },
-	visual_size = {x=3, y=3},
-	sounds = {
-	},
-	jump = true,
-	makes_footstep_sound = true,
-	walk_velocity = 3,
-	run_velocity = 6,
-	drops = {
-	},
-	animation = {
-		stand_speed = 7,
-		walk_speed = 7,
-		run_speed = 15,
-		stand_start = 11,
-		stand_end = 11,
-		walk_start = 0,
-		walk_end = 10,
-		run_start = 0,
-		run_end = 10,
-		pounce_start = 11,
-		pounce_end = 31,
-		lay_start = 34,
-		lay_end = 34,
-	},
-	runaway = true,
-	on_spawn = function(self)
-		if minetest.find_node_near(self.object:get_pos(), 4, "mcl_core:snow") ~= nil or minetest.find_node_near(self.object:get_pos(), 4, "mcl_core:dirt_with_grass_snow") ~= nil then
-			self.object:set_properties({textures={"extra_mobs_artic_fox.png", "extra_mobs_trans.png"}})
-		end
-	end,
-	do_custom = function(self)
-		if self.child == true then
-			self.object:set_properties({textures={self.base_texture[1], self.base_texture[1]}})
-		end
-		if self.state ~= "attack" and math.random(1, 5000) == 1 then
-			self.state = "lay"
-			self.object:set_animation({x= 12, y=16})
-			minetest.after(math.random(10, 500), function()
-				if self.state == "lay" then
-					self.state = "stand"
-				end
-			end)
-		end
-		for _,object in pairs(minetest.get_objects_inside_radius(self.object:get_pos(), 8)) do
-			if object and not object:is_player() and object:get_luaentity() and object:get_luaentity().name == "extra_mobs:fox" and self.state ~= "attack" and math.random(1, 500) == 1 then
-				 self.horny = true
-			end
-			local lp = object:get_pos()
-			local s = self.object:get_pos()
-			local vec = {
-				x = lp.x - s.x,
-				y = lp.y - s.y,
-				z = lp.z - s.z
-			}
-			if object and object:is_player() and not object:get_player_control().sneak or not object:is_player() and object:get_luaentity() and object:get_luaentity().name == "mobs_mc:wolf" then
-				self.state = "runaway"
-				self.object:set_rotation({x=0,y=(atan(vec.z / vec.x) + 3 * pi / 2) - self.rotate,z=0})
-				if self.reach > vector.distance(self.object:get_pos(), object:get_pos()) and self.timer > .9 then
-					self.timer = 0
-					object:punch(self.object, 1.0, {
-						full_punch_interval = 1.0,
-						damage_groups = {fleshy = self.damage}
-					}, nil)
-				end
-			end
-		end
-	end,
-	do_punch = function(self)
-		self.state = "runaway"
-	end,
-	follow = followitem,
-	fear_height = 4,
-	view_range = 16,
-	specific_attack = { "mobs_mc:chicken", "extra_mobs:cod", "extra_mobs:salmon" },
-}
-
-mobs:register_mob("extra_mobs:fox", fox)
-
--- spawning
-mobs:spawn_specific(
-"extra_mobs:fox", 
-"overworld", 
-"ground",
-{
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"ColdTaiga",
-"SunflowerPlains",
-"RoofedForest",
-"MesaPlateauFM_grasstop",
-"ExtremeHillsM",
-"BirchForestM",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-6000, 
-3, 
-mobs_mc.spawn_height.water, 
-mobs_mc.spawn_height.overworld_max)
-
---mobs:spawn_specific("extra_mobs:fox", "overworld", "ground", 0, minetest.LIGHT_MAX+1, 30, 6000, 3, 0, 500)
---[[
-mobs:spawn_specific(
-"extra_mobs:artic_fox", 
-"overworld", 
-"ground", 
-{
-"ColdTaiga",
-"IcePlainsSpikes",
-"IcePlains",
-"ExtremeHills+_snowtop",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-6000, 
-3, 
-mobs_mc.spawn_height.water, 
-mobs_mc.spawn_height.overworld_max)
-]]--
--- spawn eggs
-mobs:register_egg("extra_mobs:fox", S("Fox"), "extra_mobs_spawn_icon_fox.png", 0)

mods/ENTITIES/extra_mobs/glow_squid.lua

@@ -1,233 +0,0 @@
---MCmobs v0.4
---maikerumine
---made for MC like Survival game
---License for code WTFPL and otherwise stated in readmes
-
-local S = minetest.get_translator("extra_mobs")
-
-mobs:register_mob("extra_mobs:glow_squid",{
-    type = "animal",
-    spawn_class = "water",
-    can_despawn = true,
-    passive = true,
-    hp_min = 10,
-    hp_max = 10,
-    xp_min = 1,
-    xp_max = 3,
-    armor = 100,
-    rotate = 270,
-    tilt_swim = true,
-    -- FIXME: If the qlow squid is near the floor, it turns black
-    collisionbox = {-0.4, 0.0, -0.4, 0.4, 0.9, 0.4},
-    visual = "mesh",
-    mesh = "extra_mobs_glow_squid.b3d",
-    textures = {
-        {"extra_mobs_glow_squid.png"}
-    },
-    sounds = {
-	damage = {name="mobs_mc_squid_hurt", gain=0.3},
-	death = {name="mobs_mc_squid_death", gain=0.4},
-	flop = "mobs_mc_squid_flop",
-	distance = 16,
-    },
-    animation = {
-	    stand_start = 1,
-	    stand_end = 60,
-	    walk_start = 1,
-	    walk_end = 60,
-	    run_start = 1,
-	    run_end = 60,
-	},
-    drops = {
-	    {name = "extra_mobs:glow_ink_sac",
-	    chance = 1,
-	    min = 1,
-	    max = 3,
-	    looting = "common",},
-	},
-    visual_size = {x=3, y=3},
-    makes_footstep_sound = false,
-    swim = true,
-    breathes_in_water = true,
-    jump = false,
-    view_range = 16,
-    runaway = true,
-    fear_height = 4,
-    glow = minetest.LIGHT_MAX,
-    do_custom = function(self, dtime)
-        local glowSquidPos = self.object:get_pos()
-        local chanceOfParticle = math.random(0, 2)
-        if chanceOfParticle >= 1 then
-            minetest.add_particle({
-                pos = {x=glowSquidPos.x+math.random(-2,2)*math.random()/2,y=glowSquidPos.y+math.random(-1,2),z=glowSquidPos.z+math.random(-2,2)*math.random()/2},
-                velocity = {x=math.random(-0.25,0.25), y=math.random(-0.25,0.25), z=math.random(-0.25,0.25)},
-                acceleration = {x=math.random(-0.5,0.5), y=math.random(-0.5,0.5), z=math.random(-0.5,0.5)},
-                expirationtime = math.random(),
-                size = 1.5 + math.random(),
-                collisiondetection = true,
-                vertical = false,
-                texture = "glint"..math.random(1, 4)..".png",
-                glow = minetest.LIGHT_MAX,
-            })
-        end
-    end
-})
-
--- spawning
-
-local water = mobs_mc.spawn_height.water + 1
-mobs:spawn_specific(
-"extra_mobs:glow_squid", 
-"overworld", 
-"water",
-{
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-"RoofedForest_ocean",
-"JungleEdgeM_ocean",
-"BirchForestM_ocean",
-"BirchForest_ocean",
-"IcePlains_deep_ocean",
-"Jungle_deep_ocean",
-"Savanna_ocean",
-"MesaPlateauF_ocean",
-"ExtremeHillsM_deep_ocean",
-"Savanna_deep_ocean",
-"SunflowerPlains_ocean",
-"Swampland_deep_ocean",
-"Swampland_ocean",
-"MegaSpruceTaiga_deep_ocean",
-"ExtremeHillsM_ocean",
-"JungleEdgeM_deep_ocean",
-"SunflowerPlains_deep_ocean",
-"BirchForest_deep_ocean",
-"IcePlainsSpikes_ocean",
-"Mesa_ocean",
-"StoneBeach_ocean",
-"Plains_deep_ocean",
-"JungleEdge_deep_ocean",
-"SavannaM_deep_ocean",
-"Desert_deep_ocean",
-"Mesa_deep_ocean",
-"ColdTaiga_deep_ocean",
-"Plains_ocean",
-"MesaPlateauFM_ocean",
-"Forest_deep_ocean",
-"JungleM_deep_ocean",
-"FlowerForest_deep_ocean",
-"MushroomIsland_ocean",
-"MegaTaiga_ocean",
-"StoneBeach_deep_ocean",
-"IcePlainsSpikes_deep_ocean",
-"ColdTaiga_ocean",
-"SavannaM_ocean",
-"MesaPlateauF_deep_ocean",
-"MesaBryce_deep_ocean",
-"ExtremeHills+_deep_ocean",
-"ExtremeHills_ocean",
-"MushroomIsland_deep_ocean",
-"Forest_ocean",
-"MegaTaiga_deep_ocean",
-"JungleEdge_ocean",
-"MesaBryce_ocean",
-"MegaSpruceTaiga_ocean",
-"ExtremeHills+_ocean",
-"Jungle_ocean",
-"RoofedForest_deep_ocean",
-"IcePlains_ocean",
-"FlowerForest_ocean",
-"ExtremeHills_deep_ocean",
-"MesaPlateauFM_deep_ocean",
-"Desert_ocean",
-"Taiga_ocean",
-"BirchForestM_deep_ocean",
-"Taiga_deep_ocean",
-"JungleM_ocean",
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-10000, 
-3, 
-water-16, 
-water)
-
--- spawn egg
-mobs:register_egg("extra_mobs:glow_squid", S("Glow Squid"), "extra_mobs_spawn_icon_glow_squid.png", 0)

mods/ENTITIES/extra_mobs/glow_squid_items.lua

@@ -1,329 +0,0 @@
-local S = minetest.get_translator("extra_mobs")
-
-minetest.register_craftitem("extra_mobs:glow_ink_sac", {
-	description = S("Glow Ink Sac"),
-	_doc_items_longdesc = S("Use it to craft the Glow Item Frame."),
-	_doc_items_usagehelp = S("Use the Glow Ink Sac and the normal Item Frame to craft the Glow Item Frame."),
-	inventory_image = "extra_mobs_glow_ink_sac.png",
-	groups = { craftitem = 1 },
-})
-
-
---------------------
-
---[[This mod is originally by Zeg9, but heavily modified for MineClone 2.
-
-Model created by 22i, licensed under the
-GNU GPLv3 <https://www.gnu.org/licenses/gpl-3.0.html>.
-
-Source: <https://github.com/22i/amc>
-]]
-
-
-local VISUAL_SIZE = 0.3
-
-minetest.register_entity("extra_mobs:glow_item_frame_item",{
-	hp_max = 1,
-	visual = "wielditem",
-	visual_size = {x=VISUAL_SIZE, y=VISUAL_SIZE},
-	physical = false,
-	pointable = false,
-	textures = { "blank.png" },
-	_texture = "blank.png",
-	_scale = 1,
-	glow = minetest.LIGHT_MAX,
-
-	on_activate = function(self, staticdata)
-		if staticdata ~= nil and staticdata ~= "" then
-			local data = staticdata:split(';')
-			if data and data[1] and data[2] then
-				self._nodename = data[1]
-				self._texture = data[2]
-				if data[3] then
-					self._scale = data[3]
-				else
-					self._scale = 1
-				end
-			end
-		end
-		if self._texture ~= nil then
-			self.object:set_properties({
-				textures={self._texture},
-				visual_size={x=VISUAL_SIZE/self._scale, y=VISUAL_SIZE/self._scale},
-			})
-		end
-	end,
-	get_staticdata = function(self)
-		if self._nodename ~= nil and self._texture ~= nil then
-			local ret = self._nodename .. ';' .. self._texture
-			if self._scale ~= nil then
-				ret = ret .. ';' .. self._scale
-			end
-			return ret
-		end
-		return ""
-	end,
-
-	_update_texture = function(self)
-		if self._texture ~= nil then
-			self.object:set_properties({
-				textures={self._texture},
-				visual_size={x=VISUAL_SIZE/self._scale, y=VISUAL_SIZE/self._scale},
-			})
-		end
-	end,
-})
-
-
-local facedir = {}
-facedir[0] = {x=0,y=0,z=1}
-facedir[1] = {x=1,y=0,z=0}
-facedir[2] = {x=0,y=0,z=-1}
-facedir[3] = {x=-1,y=0,z=0}
-
-local remove_item_entity = function(pos, node)
-	local objs = nil
-	if node.name == "extra_mobs:glow_item_frame" then
-		objs = minetest.get_objects_inside_radius(pos, .5)
-	end
-	if objs then
-		for _, obj in ipairs(objs) do
-			if obj and obj:get_luaentity() and obj:get_luaentity().name == "extra_mobs:glow_item_frame_item" then
-				obj:remove()
-			end
-		end
-	end
-end
-
-local update_item_entity = function(pos, node, param2)
-	remove_item_entity(pos, node)
-	local meta = minetest.get_meta(pos)
-	local inv = meta:get_inventory()
-	local item = inv:get_stack("main", 1)
-	if not item:is_empty() then
-		if not param2 then
-			param2 = node.param2
-		end
-		if node.name == "extra_mobs:glow_item_frame" then
-			local posad = facedir[param2]
-			pos.x = pos.x + posad.x*6.5/16
-			pos.y = pos.y + posad.y*6.5/16
-			pos.z = pos.z + posad.z*6.5/16
-		end
-		local e = minetest.add_entity(pos, "extra_mobs:glow_item_frame_item")
-		local lua = e:get_luaentity()
-		lua._nodename = node.name
-		local itemname = item:get_name()
-		if itemname == "" or itemname == nil then
-			lua._texture = "blank.png"
-			lua._scale = 1
-		else
-			lua._texture = itemname
-			local def = minetest.registered_items[itemname]
-			if def and def.wield_scale then
-				lua._scale = def.wield_scale.x
-			else
-				lua._scale = 1
-			end
-		end
-		lua:_update_texture()
-		if node.name == "extra_mobs:glow_item_frame" then
-			local yaw = math.pi*2 - param2 * math.pi/2
-			e:set_yaw(yaw)
-		end
-	end
-end
-
-local drop_item = function(pos, node, meta, clicker)
-	local cname = ""
-	if clicker and clicker:is_player() then
-		cname = clicker:get_player_name()
-	end
-	if node.name == "extra_mobs:glow_item_frame" and not minetest.is_creative_enabled(cname) then
-		local inv = meta:get_inventory()
-		local item = inv:get_stack("main", 1)
-		if not item:is_empty() then
-			minetest.add_item(pos, item)
-		end
-	end
-	meta:set_string("infotext", "")
-	remove_item_entity(pos, node)
-end
-
-minetest.register_node("extra_mobs:glow_item_frame",{
-	description = S("Glow Item Frame"),
-	_tt_help = S("Can hold an item and glows"),
-	_doc_items_longdesc = S("Glow Item frames are decorative blocks in which items can be placed."),
-	_doc_items_usagehelp = S("Just place any item on the item frame. Use the item frame again to retrieve the item."),
-	drawtype = "mesh",
-	is_ground_content = false,
-	mesh = "extra_mobs_glow_item_frame.obj",
-	selection_box = { type = "fixed", fixed = {-6/16, -6/16, 7/16, 6/16, 6/16, 0.5} },
-	collision_box = { type = "fixed", fixed = {-6/16, -6/16, 7/16, 6/16, 6/16, 0.5} },
-	tiles = {"extra_mobs_glow_item_frame_border.png", "extra_mobs_glow_item_frame_border.png", "extra_mobs_glow_item_frame_border.png", "extra_mobs_glow_item_frame_border.png", "extra_mobs_glow_item_frame_border.png", "extra_mobs_glow_item_frame_border.png"},
-	inventory_image = "extra_mobs_glow_item_frame_item.png",
-	wield_image = "extra_mobs_glow_item_frame.png",
-	paramtype = "light",
-	paramtype2 = "facedir",
-
-    --FIXME: should only be glowing, no light source. How is that possible with a node?
-    light_source = 1,
-
-	sunlight_propagates = true,
-	groups = { dig_immediate=3,deco_block=1,dig_by_piston=1,container=7,attached_node_facedir=1 },
-	sounds = mcl_sounds.node_sound_defaults(),
-	node_placement_prediction = "",
-	on_place = function(itemstack, placer, pointed_thing)
-		if pointed_thing.type ~= "node" then
-			return itemstack
-		end
-
-		-- Use pointed node's on_rightclick function first, if present
-		local node = minetest.get_node(pointed_thing.under)
-		if placer and not placer:get_player_control().sneak then
-			if minetest.registered_nodes[node.name] and minetest.registered_nodes[node.name].on_rightclick then
-				return minetest.registered_nodes[node.name].on_rightclick(pointed_thing.under, node, placer, itemstack) or itemstack
-			end
-		end
-
-		return minetest.item_place(itemstack, placer, pointed_thing, minetest.dir_to_facedir(vector.direction(pointed_thing.above, pointed_thing.under)))
-	end,
-	on_construct = function(pos)
-		local meta = minetest.get_meta(pos)
-		local inv = meta:get_inventory()
-		inv:set_size("main", 1)
-	end,
-	on_rightclick = function(pos, node, clicker, itemstack)
-		if not itemstack then
-			return
-		end
-		local pname = clicker:get_player_name()
-		if minetest.is_protected(pos, pname) then
-			minetest.record_protection_violation(pos, pname)
-			return
-		end
-		local meta = minetest.get_meta(pos)
-		drop_item(pos, node, meta, clicker)
-		local inv = meta:get_inventory()
-		if itemstack:is_empty() then
-			remove_item_entity(pos, node)
-			meta:set_string("infotext", "")
-			inv:set_stack("main", 1, "")
-			return itemstack
-		end
-		local put_itemstack = ItemStack(itemstack)
-		put_itemstack:set_count(1)
-		inv:set_stack("main", 1, put_itemstack)
-		update_item_entity(pos, node)
-		-- Add node infotext when item has been named
-		local imeta = itemstack:get_meta()
-		local iname = imeta:get_string("name")
-		if iname then
-			meta:set_string("infotext", iname)
-		end
-
-		if not minetest.is_creative_enabled(clicker:get_player_name()) then
-			itemstack:take_item()
-		end
-		return itemstack
-	end,
-	allow_metadata_inventory_move = function(pos, from_list, from_index, to_list, to_index, count, player)
-		local name = player:get_player_name()
-		if minetest.is_protected(pos, name) then
-			minetest.record_protection_violation(pos, name)
-			return 0
-		else
-			return count
-		end
-	end,
-	allow_metadata_inventory_take = function(pos, listname, index, stack, player)
-		local name = player:get_player_name()
-		if minetest.is_protected(pos, name) then
-			minetest.record_protection_violation(pos, name)
-			return 0
-		else
-			return stack:get_count()
-		end
-	end,
-	allow_metadata_inventory_put = function(pos, listname, index, stack, player)
-		local name = player:get_player_name()
-		if minetest.is_protected(pos, name) then
-			minetest.record_protection_violation(pos, name)
-			return 0
-		else
-			return stack:get_count()
-		end
-	end,
-	on_destruct = function(pos)
-		local meta = minetest.get_meta(pos)
-		local node = minetest.get_node(pos)
-		drop_item(pos, node, meta)
-	end,
-	on_rotate = function(pos, node, user, mode, param2)
-		if mode == screwdriver.ROTATE_FACE then
-			-- Rotate face
-			local meta = minetest.get_meta(pos)
-			local node = minetest.get_node(pos)
-
-			local objs = nil
-			if node.name == "extra_mobs:glow_item_frame" then
-				objs = minetest.get_objects_inside_radius(pos, .5)
-			end
-			if objs then
-				for _, obj in ipairs(objs) do
-					if obj and obj:get_luaentity() and obj:get_luaentity().name == "extra_mobs:glow_item_frame_item" then
-						update_item_entity(pos, node, (node.param2+1) % 4)
-						break
-					end
-				end
-			end
-			return
-		elseif mode == screwdriver.ROTATE_AXIS then
-			return false
-		end
-	end,
-	
-})
-
-minetest.register_craft({
-    type = "shapeless",
-	output = 'extra_mobs:glow_item_frame',
-	recipe = {'mcl_itemframes:item_frame', 'extra_mobs:glow_ink_sac'},
-})
-
-minetest.register_lbm({
-	label = "Update legacy item frames",
-	name = "extra_mobs:update_legacy_glow_item_frames",
-	nodenames = {"extra_mobs:glow_frame"},
-	action = function(pos, node)
-		-- Swap legacy node, then respawn entity
-		node.name = "extra_mobs:glow_item_frame"
-		local meta = minetest.get_meta(pos)
-		local item = meta:get_string("item")
-		minetest.swap_node(pos, node)
-		if item ~= "" then
-			local itemstack = ItemStack(minetest.deserialize(meta:get_string("itemdata")))
-			local inv = meta:get_inventory()
-			inv:set_size("main", 1)
-			if not itemstack:is_empty() then
-				inv:set_stack("main", 1, itemstack)
-			end
-		end
-		update_item_entity(pos, node)
-	end,
-})
-
--- FIXME: Item entities can get destroyed by /clearobjects
-minetest.register_lbm({
-	label = "Respawn item frame item entities",
-	name = "extra_mobs:respawn_entities",
-	nodenames = {"extra_mobs:glow_item_frame"},
-	run_at_every_load = true,
-	action = function(pos, node)
-		update_item_entity(pos, node)
-	end,
-})
-
-minetest.register_alias("extra_mobs:glow_frame", "extra_mobs:glow_item_frame")
-
---------------------

mods/ENTITIES/extra_mobs/herobrine.lua

@@ -1,85 +0,0 @@
-local S = minetest.get_translator("extra_mobs")
-
-local pr = PseudoRandom(os.time()*(-334))
-
-minetest.register_entity("extra_mobs:hb_eye", {
-	visual = "mesh",
-	mesh = "mcl_armor_character.b3d",
-	textures = {"extra_mobs_herobrine_eyes.png", "extra_mobs_trans.png", "extra_mobs_trans.png" },
-	visual_size = {x=1, y=1},
-	on_activate = function(self)
-		for _,hb in pairs(minetest.get_objects_inside_radius(self.object:get_pos(), 1)) do
-			if not hb:is_player() and hb:get_luaentity().name == "extra_mobs:herobrine" then
-				self.object:set_attach(hb, "Head", {x=0,y=-13.5,z=0}, {x=0,y=0,z=0})
-			end
-		end
-	end,
-	do_custom = function(self)
-		if self.object:get_attach() == nil then
-			self.object:remove()
-		end
-	end,
-	glow = 10
-})
-
-mobs:register_mob("extra_mobs:herobrine", {
-	type = "monster",
-	spawn_class = "hostile",
-	hp_min = 20,
-	hp_max = 20,
-	xp_min = 1000,
-	xp_max = 1000,
-	collisionbox = {-0.3, -0.01, -0.3, 0.3, 2, 0.3},
-	visual = "mesh",
-	mesh = "mcl_armor_character.b3d",
-	textures = {"character.png", "extra_mobs_trans.png", "extra_mobs_trans.png" },
-	visual_size = {x=1, y=1},
-	makes_footstep_sound = false,
-	walk_velocity = 0,
-	run_velocity = 0,
-	damage = 10,
-	reach = 1,
-	armor = {fleshy = 0},
-	view_range = 1000,
-	attack_type = "dogfight",
-	can_despawn = false,
-	on_spawn = function(self)
-		--if self.object:get_children() == nil then
-		minetest.add_entity(self.object:get_pos(), "extra_mobs:hb_eye")
-		--end
-	end,
-	do_custom = function(self)
-		for _,object in pairs(minetest.get_objects_inside_radius(self.object:get_pos(), 30)) do
-			if object:is_player() then
-				pos = self.object:get_pos()
-				local randomCube = vector.new( pos.x + 8*(pr:next(0,16)-8), pos.y + 8*(pr:next(0,16)-8), pos.z + 8*(pr:next(0,16)-8) )
-				local nodes = minetest.find_nodes_in_area_under_air(vector.subtract(randomCube, 4), vector.add(randomCube, 4), {"group:solid", "group:cracky", "group:crumbly"})
-				local telepos
-				if nodes ~= nil then
-					if #nodes > 0 then
-						-- Up to 64 attempts to teleport
-						for n=1, math.min(64, #nodes) do
-							local r = pr:next(1, #nodes)
-							local nodepos = nodes[r]
-							local node_ok = true
-							-- Selected node needs to have 3 nodes of free space above
-							for u=1, 3 do
-								local node = minetest.get_node({x=nodepos.x, y=nodepos.y+u, z=nodepos.z})
-								if minetest.registered_nodes[node.name].walkable then
-									node_ok = false
-									break
-								end
-							end
-							if node_ok then
-								telepos = {x=nodepos.x, y=nodepos.y+1, z=nodepos.z}
-							end
-						end
-						if telepos then
-							self.object:set_pos(telepos)
-						end
-					end
-				end
-			end
-		end
-	end,
-})

mods/ENTITIES/extra_mobs/hoglin+zoglin.lua

@@ -1,134 +0,0 @@
---MCmobs v0.4
---maikerumine
---made for MC like Survival game
---License for code WTFPL and otherwise stated in readmes
-
-local S = minetest.get_translator("extra_mobs")
-
---###################
---################### hoglin
---###################
-
-local hoglin = {
-	type = "monster",
-	passive = false,
-	spawn_class = "hostile",
-	hp_min = 40,
-	hp_max = 40,
-	xp_min = 9,
-	xp_max = 9,
-	armor = {fleshy = 90},
-	attack_type = "dogfight",
-	damage = 4,
-	reach = 3,
-	collisionbox = {-.6, -0.01, -.6, .6, 1.4, .6},
-	visual = "mesh",
-	mesh = "extra_mobs_hoglin.b3d",
-	textures = { {
-		"extra_mobs_hoglin.png",
-	} },
-	visual_size = {x=3, y=3},
-	sounds = {
-		random = "extra_mobs_hoglin",
-		damage = "extra_mobs_hoglin_hurt",
-		distance = 16,
-	},
-	jump = true,
-	makes_footstep_sound = true,
-	walk_velocity = 1,
-	run_velocity = 4,
-	drops = {
-		{name = "mcl_mobsitems:leather",
-		chance = 1,
-		min = 0,
-		max = 1,},
-	},
-	drops = {
-		{name = "mcl_mobitems:porkchop",
-		chance = 1,
-		min = 2,
-		max = 4,},
-	},
-	animation = {
-		stand_speed = 7,
-		walk_speed = 7,
-		run_speed = 15,
-		stand_start = 24,
-		stand_end = 24,
-		walk_start = 11,
-		walk_end = 21,
-		run_start = 1,
-		run_end = 10,
-		punch_start = 22,
-		punch_end = 32,
-	},
-	fear_height = 4,
-	view_range = 32,
-	floats = 0,
-	custom_attack = function(self)
-		if self.state == "attack" and self.reach > vector.distance(self.object:get_pos(), self.attack:get_pos()) then
-			self.attack:add_velocity({x=0,y=13,z=0})
-			self.attack:punch(self.object, 1.0, {
-				full_punch_interval = 1.0,
-				damage_groups = {fleshy = self.damage}
-			}, nil)
-		end
-	end,
-	do_custom = function(self)
-		if self.object:get_pos().y > -100 then
-			local zog = minetest.add_entity(self.object:get_pos(), "extra_mobs:zoglin")
-			zog:set_rotation(self.object:get_rotation())
-			self.object:remove()
-		end
-	end,
-	attack_animals = true,
-}
-
-mobs:register_mob("extra_mobs:hoglin", hoglin)
-
-local zoglin = table.copy(hoglin)
-zoglin.fire_resistant = 1
-zoglin.textures = {"extra_mobs_zoglin.png"}
-zoglin.do_custom = function()
-	return
-end
-zoglin.attacks_monsters = true
-zoglin.lava_damage = 0
-zoglin.fire_damage = 0
-mobs:register_mob("extra_mobs:zoglin", zoglin)
-
--- Baby hoglin.
---[[
-local baby_hoglin = table.copy(hoglin)
-baby_hoglin.collisionbox = {-.3, -0.01, -.3, .3, 0.94, .3}
-baby_hoglin.xp_min = 20
-baby_hoglin.xp_max = 20
-baby_hoglin.visual_size = {x=hoglin.visual_size.x/2, y=hoglin.visual_size.y/2}
-textures = { {
-	"extra_mobs_hoglin.png",
-	"extra_mobs_trans.png",
-} }
-baby_hoglin.walk_velocity = 1.2
-baby_hoglin.run_velocity = 2.4
-baby_hoglin.child = 1
-
-mobs:register_mob("extra_mobs:baby_hoglin", baby_hoglin)]]
-
--- Regular spawning in the Nether
-mobs:spawn_specific(
-"extra_mobs:hoglin", 
-"nether", 
-"ground",
-{
-"Nether"
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-6000, 
-3, 
-mobs_mc.spawn_height.nether_min, 
-mobs_mc.spawn_height.nether_max)
-
--- spawn eggs
-mobs:register_egg("extra_mobs:hoglin", S("Hoglin"), "extra_mobs_spawn_icon_hoglin.png", 0)

mods/ENTITIES/extra_mobs/init.lua

@@ -1,28 +0,0 @@
---MCmobs v0.4
---maikerumine
---made for MC like Survival game
---License for code WTFPL and otherwise stated in readmes
-
-local path = minetest.get_modpath("extra_mobs")
-
-if not minetest.get_modpath("mobs_mc_gameconfig") then
-	mobs_mc = {}
-end
-
---Monsters
-dofile(path .. "/herobrine.lua")
-dofile(path .. "/hoglin+zoglin.lua")
-dofile(path .. "/piglin.lua")
-
---Animals
-dofile(path .. "/strider.lua")
-dofile(path .. "/fox.lua")
-dofile(path .. "/cod.lua")
-dofile(path .. "/salmon.lua")
-dofile(path .. "/dolphin.lua")
-dofile(path .. "/glow_squid.lua")
-
---Items
-dofile(path .. "/glow_squid_items.lua")
-
-

mods/ENTITIES/extra_mobs/mod.conf

@@ -1,3 +0,0 @@
-name = extra_mobs
-depends = mcl_mobs, mobs_mc
-optional_depends = mc_warped_fungus_stick, mc_sweet_berry

mods/ENTITIES/extra_mobs/models/extra_mobs_glow_item_frame.obj

@@ -1,156 +0,0 @@
-# Blender v2.76 (sub 0) OBJ File: 'itemframe1facedir.blend'
-# www.blender.org
-mtllib itemframe1facedir.mtl
-o right.frame_Cube.005
-v -0.313413 -0.313413 0.435326
-v -0.313413 0.313413 0.435326
-v -0.313413 -0.313413 0.498008
-v -0.313413 0.313413 0.498008
-v -0.376095 -0.313413 0.435326
-v -0.376095 0.313413 0.435326
-v -0.376095 -0.313413 0.498008
-v -0.376095 0.313413 0.498008
-vt 0.875000 0.812500
-vt 0.812500 0.812500
-vt 0.812500 0.187500
-vt 0.875000 0.187500
-vt 1.000000 0.812500
-vt 0.937500 0.812500
-vt 0.937500 0.187500
-vt 1.000000 0.187500
-vt -0.000000 0.937500
-vt 0.062500 0.937500
-vt 0.062500 1.000000
-vt -0.000000 1.000000
-vn 1.000000 0.000000 -0.000000
-vn 0.000000 0.000000 1.000000
-vn -1.000000 0.000000 0.000000
-vn -0.000000 0.000000 -1.000000
-vn 0.000000 -1.000000 -0.000000
-vn 0.000000 1.000000 0.000000
-usemtl None
-s off
-f 2/1/1 4/2/1 3/3/1 1/4/1
-f 4/1/2 8/2/2 7/3/2 3/4/2
-f 8/5/3 6/6/3 5/7/3 7/8/3
-f 6/1/4 2/2/4 1/3/4 5/4/4
-f 1/9/5 3/10/5 7/11/5 5/12/5
-f 6/9/6 8/10/6 4/11/6 2/12/6
-o left.frame_Cube.004
-v 0.376095 -0.313413 0.435326
-v 0.376095 0.313413 0.435326
-v 0.376095 -0.313413 0.498008
-v 0.376095 0.313413 0.498008
-v 0.313413 -0.313413 0.435326
-v 0.313413 0.313413 0.435326
-v 0.313413 -0.313413 0.498008
-v 0.313413 0.313413 0.498008
-vt 0.875000 0.812500
-vt 0.812500 0.812500
-vt 0.812500 0.187500
-vt 0.875000 0.187500
-vt 1.000000 0.812500
-vt 0.937500 0.812500
-vt 0.937500 0.187500
-vt 1.000000 0.187500
-vt -0.000000 0.937500
-vt 0.062500 0.937500
-vt 0.062500 1.000000
-vt -0.000000 1.000000
-vn 1.000000 0.000000 -0.000000
-vn 0.000000 0.000000 1.000000
-vn -1.000000 0.000000 0.000000
-vn 0.000000 0.000000 -1.000000
-vn 0.000000 -1.000000 -0.000000
-vn 0.000000 1.000000 0.000000
-usemtl None
-s off
-f 10/13/7 12/14/7 11/15/7 9/16/7
-f 12/13/8 16/14/8 15/15/8 11/16/8
-f 16/17/9 14/18/9 13/19/9 15/20/9
-f 14/13/10 10/14/10 9/15/10 13/16/10
-f 9/21/11 11/22/11 15/23/11 13/24/11
-f 14/21/12 16/22/12 12/23/12 10/24/12
-o lower.frame_Cube.003
-v 0.376095 -0.376095 0.435326
-v 0.376095 -0.313413 0.435326
-v 0.376095 -0.376095 0.498008
-v 0.376095 -0.313413 0.498008
-v -0.376095 -0.376095 0.435326
-v -0.376095 -0.313413 0.435326
-v -0.376095 -0.376095 0.498008
-v -0.376095 -0.313413 0.498008
-vt 0.187500 0.187500
-vt 0.125000 0.187500
-vt 0.125000 0.125000
-vt 0.187500 0.125000
-vt 0.875000 0.187500
-vt 0.875000 0.125000
-vt 0.812500 0.187500
-vt 0.812500 0.125000
-vt 0.875000 0.937500
-vt 0.875000 1.000000
-vt 0.125000 1.000000
-vt 0.125000 0.937500
-vn 1.000000 0.000000 0.000000
-vn 0.000000 0.000000 1.000000
-vn -1.000000 0.000000 0.000000
-vn -0.000000 0.000000 -1.000000
-vn 0.000000 -1.000000 0.000000
-vn 0.000000 1.000000 0.000000
-usemtl None
-s off
-f 18/25/13 20/26/13 19/27/13 17/28/13
-f 20/29/14 24/26/14 23/27/14 19/30/14
-f 24/29/15 22/31/15 21/32/15 23/30/15
-f 22/29/16 18/26/16 17/27/16 21/30/16
-f 17/33/17 19/34/17 23/35/17 21/36/17
-f 22/30/18 24/29/18 20/26/18 18/27/18
-o upper.frame_Cube.002
-v 0.376095 0.313413 0.435326
-v 0.376095 0.376095 0.435326
-v 0.376095 0.313413 0.498008
-v 0.376095 0.376095 0.498008
-v -0.376095 0.313413 0.435326
-v -0.376095 0.376095 0.435326
-v -0.376095 0.313413 0.498008
-v -0.376095 0.376095 0.498008
-vt 0.187500 0.875000
-vt 0.125000 0.875000
-vt 0.125000 0.812500
-vt 0.187500 0.812500
-vt 0.875000 0.875000
-vt 0.875000 0.812500
-vt 0.812500 0.875000
-vt 0.812500 0.812500
-vt 0.875000 0.937500
-vt 0.875000 1.000000
-vt 0.125000 1.000000
-vt 0.125000 0.937500
-vn 1.000000 0.000000 0.000000
-vn 0.000000 0.000000 1.000000
-vn -1.000000 0.000000 0.000000
-vn -0.000000 0.000000 -1.000000
-vn 0.000000 -1.000000 0.000000
-vn 0.000000 1.000000 0.000000
-usemtl None
-s off
-f 26/37/19 28/38/19 27/39/19 25/40/19
-f 28/41/20 32/38/20 31/39/20 27/42/20
-f 32/41/21 30/43/21 29/44/21 31/42/21
-f 30/41/22 26/38/22 25/39/22 29/42/22
-f 25/45/23 27/46/23 31/47/23 29/48/23
-f 30/48/24 32/38/24 28/41/24 26/45/24
-o background_Plane
-v 0.313413 -0.313413 0.466667
-v -0.313413 -0.313413 0.466667
-v 0.313413 0.313413 0.466667
-v -0.313413 0.313413 0.466667
-vt 0.187500 0.187500
-vt 0.812500 0.187500
-vt 0.812500 0.812500
-vt 0.187500 0.812500
-vn -0.000000 0.000000 -1.000000
-usemtl None
-s off
-f 33/49/25 34/50/25 36/51/25 35/52/25

mods/ENTITIES/extra_mobs/piglin.lua

@@ -1,298 +0,0 @@
---MCmobs v0.4
---maikerumine
---made for MC like Survival game
---License for code WTFPL and otherwise stated in readmes
-
-local trading_items = {
-	{ itemstring = "mcl_core:obsidian", amount_min = 1, amount_max = 1 },
-	{ itemstring = "mcl_core:gravel", amount_min = 8, amount_max = 16 },
-	{ itemstring = "mcl_mobitems:leather", amount_min = 4, amount_max = 10 },
-	{ itemstring = "mcl_nether:soul_sand", amount_min = 4, amount_max = 16 },
-	{ itemstring = "mcl_nether:nether_brick", amount_min = 4, amount_max = 16 },
-	{ itemstring = "mcl_mobitems:string", amount_min = 3, amount_max = 9 },
-	{ itemstring = "mcl_nether:quartz", amount_min = 4, amount_max = 10 },
-	{ itemstring = "mcl_potions:water", amount_min = 1, amount_max = 1 },
-	{ itemstring = "mcl_core:iron_nugget", amount_min = 10, amount_max = 36 },
-	{ itemstring = "mcl_throwing:ender_pearl", amount_min = 2, amount_max = 6 },
-	{ itemstring = "mcl_potions:fire_resistance", amount_min = 1, amount_max = 1 },
-	{ itemstring = "mcl_potions:fire_resistance_splash", amount_min = 1, amount_max = 1 },
-}
-
-local S = minetest.get_translator("extra_mobs")
-local mod_bows = minetest.get_modpath("mcl_bows") ~= nil
-
---###################
---################### piglin
---###################
-local piglin = {
-	type = "monster",
-	passive = false,
-	spawn_class = "hostile",
-	hp_min = 16,
-	hp_max = 16,
-	xp_min = 9,
-	xp_max = 9,
-	armor = {fleshy = 90},
-	damage = 4,
-	reach = 3,
-	collisionbox = {-0.3, -0.01, -0.3, 0.3, 1.94, 0.3},
-	visual = "mesh",
-	mesh = "extra_mobs_piglin.b3d",
-	textures = { {
-		"extra_mobs_piglin.png",
-		"mcl_bows_bow_2.png",
-	} },
-	visual_size = {x=1, y=1},
-	sounds = {
-		random = "extra_mobs_piglin",
-		damage = "extra_mobs_piglin_hurt",
-		distance = 16,
-	},
-	jump = true,
-	makes_footstep_sound = true,
-	walk_velocity = 4.317,
-	run_velocity = 5.6121,
-	drops = {
-		{name = "mcl_bows:crossbow",
-		chance = 10,
-		min = 1,
-		max = 1,},
-	},
-	animation = {
-		stand_speed = 30,
-		walk_speed = 30,
-		run_speed = 30,
-		stand_start = 0,
-		stand_end = 79,
-		walk_start = 168,
-		walk_end = 187,
-		run_start = 440,
-		run_end = 459,
-	},
-	fear_height = 4,
-	view_range = 16,
-	on_spawn = function(self)
-		self.weapon = self.base_texture[2]
-		self.gold_items = 0
-	end,
-  do_custom = function(self)
-		if self.object:get_pos().y > -100 then
-			--local zog = minetest.add_entity(self.object:get_pos(), "extra_mobs:zombified_piglin")
-			--zog:set_rotation(self.object:get_rotation())
-			--self.object:remove()
-		end
-		if self.trading == true then
-			self.state = "trading"
-			self.object:set_bone_position("Arm_Right_Pitch_Control", vector.new(-3,5.785,0), vector.new(20,-20,18))
-			self.object:set_bone_position("Head", vector.new(0,6.3,0), vector.new(-40,0,0))
-			self.base_texture[2] = "default_gold_ingot.png"
-			self.object:set_properties({textures = self.base_texture})
-		else
-			self.object:set_bone_position("Wield_Item", vector.new(.5,4.5,-1.6), vector.new(90,0,20))
-			self.base_texture[2] = self.weapon
-			self.object:set_properties({textures = self.base_texture})
-			self.object:set_bone_position("Head", vector.new(0,6.3,0), vector.new(0,0,0))
-			self.object:set_bone_position("Arm_Right_Pitch_Control", vector.new(-3,5.785,0), vector.new(0,0,0))
-		end
-
-		if self.state ~= "attack" then
-			self._attacked_by_player = false
-		end
-    if self.state == "attack" and self.attack:is_player() then
-			for i=1, 6 do
-				local stack = self.attack:get_inventory():get_stack("armor", i)
-				local item = stack:get_name()
-				if item == "mcl_armor:chestplate_gold" or item == "mcl_armor:leggings_gold" or item == "mcl_armor:helmet_gold" or item == "mcl_armor:boots_gold" then
-					if self._attacked_by_player == false then
-						self.state = "stand"
-					end
-				end
-    	end
-    end
-  end,
-	on_rightclick = function(self, clicker)
-		if clicker:is_player() and clicker:get_wielded_item():get_name() == "mcl_core:gold_ingot" and self.state ~= "attack" and self.gold_items < 3 then
-			local item_gold = clicker:get_wielded_item()
-			item_gold:take_item(1)
-			clicker:set_wielded_item(item_gold)
-			self.state = "stand"
-			self.object:set_animation({x=0,y=79})
-			self.trading = true
-			self.gold_items = self.gold_items + 1
-			self.object:set_bone_position("Wield_Item", vector.new(-1.5,4.9,1.8), vector.new(135,0,90))
-			minetest.after(5, function()
-				self.gold_items = self.gold_items - 1
-				if self.gold_items == 0 then
-					self.trading = false
-					self.state = "stand"
-				end
-				local c_pos = self.object:get_pos()
-				self.what_traded = trading_items[math.random(#trading_items)]
-				for x = 1, math.random(self.what_traded.amount_min, self.what_traded.amount_max) do
-					minetest.add_item({x=math.random(c_pos.x - 1, c_pos.x + 1), y=math.random(c_pos.y - 1, c_pos.y + 1), z= math.random(c_pos.z - 1, c_pos.z + 1)}, self.what_traded.itemstring)
-				end
-			end)
-		end
-	end,
-	do_punch = function(self, hitter)
-		if hitter:is_player() then
-			self._attacked_by_player = true
-		end
-	end,
-	attack_type = "dogshoot",
-	arrow = "mcl_bows:arrow_entity",
-	shoot_arrow = function(self, pos, dir)
-		if mod_bows then
-			-- 2-4 damage per arrow
-			local dmg = math.max(4, math.random(2, 8))
-			mobs.shoot_projectile_handling("mcl_bows:arrow", pos, dir, self.object:get_yaw(), self.object, nil, dmg)
-		end
-	end,
-	shoot_interval = 1.2,
-	shoot_offset = 1.5,
-	dogshoot_switch = 1,
-	dogshoot_count_max =1.8,
-}
-
-mobs:register_mob("extra_mobs:piglin", piglin)
-
-
-local sword_piglin = table.copy(piglin)
-sword_piglin.mesh = "extra_mobs_sword_piglin.b3d"
-sword_piglin.textures = {"extra_mobs_piglin.png", "default_tool_goldsword.png"}
-sword_piglin.on_spawn = function(self)
-	self.gold_items = 0
-	self.weapon = self.base_texture[2]
-	self.object:set_bone_position("Wield_Item", vector.new(0,3.9,1.3), vector.new(90,0,0))
-end
-sword_piglin.drops = {
-	{name = "mcl_tools:sword_gold",
-	chance = 10,
-	min = 1,
-	max = 1,},
-}
-sword_piglin.attack_type = "dogfight"
-sword_piglin.animation = {
-	stand_speed = 30,
-	walk_speed = 30,
-	punch_speed = 45,
-	run_speed = 30,
-	stand_start = 0,
-	stand_end = 79,
-	walk_start = 168,
-	walk_end = 187,
-	run_start = 440,
-	run_end = 459,
-	punch_start = 189,
-	punch_end = 198,
-}
-mobs:register_mob("extra_mobs:sword_piglin", sword_piglin)
-
-local zombified_piglin = table.copy(piglin)
-zombified_piglin.fire_resistant = 1
-zombified_piglin.do_custom = function()
-	return
-end
-zombified_piglin.on_spawn = function()
-	return
-end
-zombified_piglin.on_rightclick = function()
-	return
-end
-zombified_piglin.lava_damage = 0
-zombified_piglin.fire_damage = 0
-zombified_piglin.attack_animals = true
-zombified_piglin.mesh = "extra_mobs_sword_piglin.b3d"
-zombified_piglin.textures = {"extra_mobs_zombified_piglin.png", "default_tool_goldsword.png", "extra_mobs_trans.png"}
-zombified_piglin.attack_type = "dogfight"
-zombified_piglin.animation = {
-	stand_speed = 30,
-	walk_speed = 30,
-	punch_speed = 45,
-	run_speed = 30,
-	stand_start = 0,
-	stand_end = 79,
-	walk_start = 168,
-	walk_end = 187,
-	run_start = 440,
-	run_end = 459,
-	punch_start = 189,
-	punch_end = 198,
-}
-mobs:register_mob("extra_mobs:zombified_piglin", zombified_piglin)
-
-
-local piglin_brute = table.copy(piglin)
-piglin_brute.xp_min = 20
-piglin_brute.xp_max = 20
-piglin_brute.hp_min = 50
-piglin_brute.hp_max = 50
-piglin_brute.fire_resistant = 1
-piglin_brute.do_custom = function()
-	return
-end
-piglin_brute.on_spawn = function()
-	return
-end
-piglin_brute.on_rightclick = function()
-	return
-end
-piglin_brute.attacks_monsters = true
-piglin_brute.lava_damage = 0
-piglin_brute.fire_damage = 0
-piglin_brute.attack_animals = true
-piglin_brute.mesh = "extra_mobs_sword_piglin.b3d"
-piglin_brute.textures = {"extra_mobs_piglin_brute.png", "default_tool_goldaxe.png", "extra_mobs_trans.png"}
-piglin_brute.attack_type = "dogfight"
-piglin_brute.animation = {
-	stand_speed = 30,
-	walk_speed = 30,
-	punch_speed = 45,
-	run_speed = 30,
-	stand_start = 0,
-	stand_end = 79,
-	walk_start = 168,
-	walk_end = 187,
-	run_start = 440,
-	run_end = 459,
-	punch_start = 189,
-	punch_end = 198,
-}
-piglin_brute.can_despawn = false
-piglin_brute.group_attack = { "extra_mobs:piglin", "extra_mobs:piglin_brute" }
-mobs:register_mob("extra_mobs:piglin_brute", piglin_brute)
-
-
--- Regular spawning in the Nether
-mobs:spawn_specific(
-"extra_mobs:piglin", 
-"nether", 
-"ground",
-{
-"Nether"
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-6000, 
-3, 
-mobs_mc.spawn_height.nether_min, 
-mobs_mc.spawn_height.nether_max)
-
-mobs:spawn_specific(
-"extra_mobs:sword_piglin", 
-"nether", 
-"ground",
-{
-"Nether"
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-6000, 
-3, 
-mobs_mc.spawn_height.nether_min, 
-mobs_mc.spawn_height.nether_max)
--- spawn eggs
-mobs:register_egg("extra_mobs:piglin", S("piglin"), "extra_mobs_spawn_icon_piglin.png", 0)
-mobs:register_egg("extra_mobs:piglin_brute", S("piglin Brute"), "extra_mobs_spawn_icon_piglin.png", 0)

mods/ENTITIES/extra_mobs/salmon.lua

@@ -1,219 +0,0 @@
---MCmobs v0.4
---maikerumine
---made for MC like Survival game
---License for code WTFPL and otherwise stated in readmes
-
-local S = minetest.get_translator("extra_mobs")
-
---###################
---################### salmon
---###################
-
-local salmon = {
-    type = "animal",
-    spawn_class = "water",
-    can_despawn = true,
-    passive = true,
-    hp_min = 3,
-    hp_max = 3,
-    xp_min = 1,
-    xp_max = 3,
-    armor = 100,
-    rotate = 270,
-    tilt_swim = true,
-    collisionbox = {-0.4, 0.0, -0.4, 0.4, 0.79, 0.4},
-    visual = "mesh",
-    mesh = "extra_mobs_salmon.b3d",
-    textures = {
-        {"extra_mobs_salmon.png"}
-    },
-    sounds = {
-    },
-    animation = {
-		stand_start = 1,
-		stand_end = 20,
-		walk_start = 1,
-		walk_end = 20,
-		run_start = 1,
-		run_end = 20,
-	},
-    drops = {
-		{name = "mcl_fishing:salmon_raw",
-		chance = 1,
-		min = 1,
-		max = 1,},
-        {name = "mcl_dye:white",
-		chance = 20,
-		min = 1,
-		max = 1,},
-	},
-    visual_size = {x=3, y=3},
-    makes_footstep_sound = false,
-    swim = true,
-    breathes_in_water = true,
-    jump = false,
-    view_range = 16,
-    runaway = true,
-    fear_height = 4,
-}
-
-mobs:register_mob("extra_mobs:salmon", salmon)
-
-
---spawning TODO: in schools
-local water = mobs_mc.spawn_height.water + 1
-mobs:spawn_specific(
-"extra_mobs:salmon", 
-"overworld", 
-"water", 
-{
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-"RoofedForest_ocean",
-"JungleEdgeM_ocean",
-"BirchForestM_ocean",
-"BirchForest_ocean",
-"IcePlains_deep_ocean",
-"Jungle_deep_ocean",
-"Savanna_ocean",
-"MesaPlateauF_ocean",
-"ExtremeHillsM_deep_ocean",
-"Savanna_deep_ocean",
-"SunflowerPlains_ocean",
-"Swampland_deep_ocean",
-"Swampland_ocean",
-"MegaSpruceTaiga_deep_ocean",
-"ExtremeHillsM_ocean",
-"JungleEdgeM_deep_ocean",
-"SunflowerPlains_deep_ocean",
-"BirchForest_deep_ocean",
-"IcePlainsSpikes_ocean",
-"Mesa_ocean",
-"StoneBeach_ocean",
-"Plains_deep_ocean",
-"JungleEdge_deep_ocean",
-"SavannaM_deep_ocean",
-"Desert_deep_ocean",
-"Mesa_deep_ocean",
-"ColdTaiga_deep_ocean",
-"Plains_ocean",
-"MesaPlateauFM_ocean",
-"Forest_deep_ocean",
-"JungleM_deep_ocean",
-"FlowerForest_deep_ocean",
-"MushroomIsland_ocean",
-"MegaTaiga_ocean",
-"StoneBeach_deep_ocean",
-"IcePlainsSpikes_deep_ocean",
-"ColdTaiga_ocean",
-"SavannaM_ocean",
-"MesaPlateauF_deep_ocean",
-"MesaBryce_deep_ocean",
-"ExtremeHills+_deep_ocean",
-"ExtremeHills_ocean",
-"MushroomIsland_deep_ocean",
-"Forest_ocean",
-"MegaTaiga_deep_ocean",
-"JungleEdge_ocean",
-"MesaBryce_ocean",
-"MegaSpruceTaiga_ocean",
-"ExtremeHills+_ocean",
-"Jungle_ocean",
-"RoofedForest_deep_ocean",
-"IcePlains_ocean",
-"FlowerForest_ocean",
-"ExtremeHills_deep_ocean",
-"MesaPlateauFM_deep_ocean",
-"Desert_ocean",
-"Taiga_ocean",
-"BirchForestM_deep_ocean",
-"Taiga_deep_ocean",
-"JungleM_ocean",
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-4000, 
-3, 
-water-16, 
-water)
-
---spawn egg
-mobs:register_egg("extra_mobs:salmon", S("Salmon"), "extra_mobs_spawn_icon_salmon.png", 0)

mods/ENTITIES/extra_mobs/strider.lua

@@ -1,232 +0,0 @@
---MCmobs v0.4
---maikerumine
---made for MC like Survival game
---License for code WTFPL and otherwise stated in readmes
-
-local S = minetest.get_translator("extra_mobs")
-
---###################
---################### STRIDER
---###################
-
-
-local strider = {
-	type = "animal",
-	passive = true,
-	spawn_class = "passive",
-	hp_min = 20,
-	hp_max = 20,
-	xp_min = 9,
-	xp_max = 9,
-	armor = {fleshy = 90},
-	attack_type = "dogfight",
-	damage = 2,
-	reach = 2,
-	collisionbox = {-.6, -0.01, -.6, .6, 1.94, .6},
-	visual = "mesh",
-	mesh = "extra_mobs_strider.b3d",
-	textures = { {
-		"extra_mobs_strider.png",
-	} },
-	visual_size = {x=3, y=3},
-	sounds = {
-	},
-	jump = true,
-	makes_footstep_sound = true,
-	walk_velocity = 2,
-	run_velocity = 4,
-	runaway = true,
-	drops = {
-		{name = "mcl_mobsitems:string",
-		chance = 1,
-		min = 2,
-		max = 5,},
-	},
-	animation = {
-		stand_speed = 15,
-		walk_speed = 15,
-		run_speed = 30,
-		stand_start = 5,
-		stand_end = 5,
-		walk_start = 1,
-		walk_end = 20,
-	},
-	lava_damage = 0,
-	fire_damage = 0,
-	light_damage = 0,
-	water_damage = 5,
-	fear_height = 4,
-	view_range = 16,
-	fire_resistant = true,
-	floats_on_lava = 1,
-	floats = 0,
-	do_custom = function(self, dtime)
-
-		if minetest.find_node_near(self.object:get_pos(), 2, "mcl_core:lava_source") ~= nil or minetest.find_node_near(self.object:get_pos(), 2, "mcl_core:lava_flowing") ~= nil or minetest.find_node_near(self.object:get_pos(), 2, "mcl_nether:nether_lava_source") ~= nil or minetest.find_node_near(self.object:get_pos(), 2, "mcl_nether:nether_lava_flowing") ~= nil then
-			self.walk_velocity = 2
-			self.run_velocity = 4
-			self.base_texture[1] = "extra_mobs_strider.png"
-			self.shaking = false
-		else
-			self.base_texture[1] = "extra_mobs_strider_cold.png"
-			self.walk_velocity = .5
-			self.run_velocity = 1
-			self.shaking = true
-		end
-
-		self.object:set_properties({textures=self.base_texture, shaking=self.shaking, run_velocity=self.run_velocity, walk_velocity=self.walk_velocity})
-
-		-- set needed values if not already present
-		if not self.v2 then
-			self.v2 = 0
-			self.max_speed_forward = 8
-			self.max_speed_reverse = 4
-			self.accel = 2
-			self.terrain_type = 3
-			self.driver_attach_at = {x = 0, y = 5.5, z = -1.75}
-			self.driver_eye_offset = {x = 0, y = 10, z = 0}
-			self.driver_scale = {x = 1/self.visual_size.x, y = 1/self.visual_size.y}
-		end
-
-		-- if driver present allow control of horse
-		if self.driver then
-
-			mobs.drive(self, "walk", "stand", false, dtime)
-
-			return false -- skip rest of mob functions
-		end
-
-		return true
-	end,
-
-	on_die = function(self, pos)
-
-		-- drop saddle when horse is killed while riding
-		-- also detach from horse properly
-		if self.driver then
-			mobs.detach(self.driver, {x = 1, y = 0, z = 1})
-		end
-	end,
-
-	on_rightclick = function(self, clicker)
-		if not clicker or not clicker:is_player() then
-			return
-		end
-
-		local wielditem = clicker:get_wielded_item()
-
-		local controlitem = ""
-		if minetest.get_modpath("mc") then
-            controlitem = "mc_warped_fungus_stick:warped_fungus_stick"
-        else
-            controlitem = mobs_mc.items.carrot_on_a_stick
-        end
-		if wielditem:get_name() ~= controlitem then
-			if mobs:feed_tame(self, clicker, 1, true, true) then return end
-		end
-
-		if self.child then
-			return
-		end
-
-		local item = clicker:get_wielded_item()
-		if item:get_name() == mobs_mc.items.saddle and self.saddle ~= "yes" then
-			self.base_texture = {
-				"extra_mobs_strider.png",
-				"mobs_mc_pig_saddle.png", -- saddle
-			}
-			self.object:set_properties({
-				textures = self.base_texture
-			})
-			self.saddle = "yes"
-			self.tamed = true
-			self.drops = {
-				{name = "mcl_mobitems:string",
-				chance = 1,
-				min = 1,
-				max = 3,},
-				{name = "mcl_mobitems:saddle",
-				chance = 1,
-				min = 1,
-				max = 1,},
-			}
-			if not minetest.is_creative_enabled(clicker:get_player_name()) then
-				local inv = clicker:get_inventory()
-				local stack = inv:get_stack("main", clicker:get_wield_index())
-				stack:take_item()
-				inv:set_stack("main", clicker:get_wield_index(), stack)
-			end
-			minetest.sound_play({name = "mcl_armor_equip_leather"}, {gain=0.5, max_hear_distance=8, pos=self.object:get_pos()}, true)
-			return
-		end
-
-		-- Mount or detach player
-		local name = clicker:get_player_name()
-		if self.driver and clicker == self.driver then
-			-- Detach if already attached
-			mobs.detach(clicker, {x=1, y=0, z=0})
-			return
-
-		elseif not self.driver and self.saddle == "yes" and wielditem:get_name() == controlitem then
-			-- Ride pig if it has a saddle and player uses a carrot on a stick
-
-			mobs.attach(self, clicker)
-
-			if not minetest.is_creative_enabled(clicker:get_player_name()) then
-
-				local inv = self.driver:get_inventory()
-				-- 26 uses
-				if wielditem:get_wear() > 63000 then
-					-- Break carrot on a stick
-					local def = wielditem:get_definition()
-					if def.sounds and def.sounds.breaks then
-						minetest.sound_play(def.sounds.breaks, {pos = clicker:get_pos(), max_hear_distance = 8, gain = 0.5}, true)
-					end
-					wielditem = {name = mobs_mc.items.fishing_rod, count = 1}
-				else
-					wielditem:add_wear(2521)
-				end
-				inv:set_stack("main",self.driver:get_wield_index(), wielditem)
-			end
-			return
-		end
-	end,
-}
-
-mobs:register_mob("extra_mobs:strider", strider)
-
--- Baby strider.
-
-local baby_strider = table.copy(strider)
-baby_strider.collisionbox = {-.3, -0.01, -.3, .3, 0.94, .3}
-baby_strider.xp_min = 13
-baby_strider.xp_max = 13
-baby_strider.visual_size = {x=strider.visual_size.x/2, y=strider.visual_size.y/2}
-textures = { {
-	"extra_mobs_strider.png",
-	"extra_mobs_trans.png",
-} }
-baby_strider.walk_velocity = 1.2
-baby_strider.run_velocity = 2.4
-baby_strider.child = 1
-
-mobs:register_mob("extra_mobs:baby_strider", baby_strider)
-
--- Regular spawning in the Nether
-mobs:spawn_specific(
-"extra_mobs:strider",
-"nether", 
-"lava",
-{
-"Nether"
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-6000, 
-3, 
-mobs_mc.spawn_height.nether_min, 
-mobs_mc.spawn_height.nether_max)
-
--- spawn eggs
-mobs:register_egg("extra_mobs:strider", S("Strider"), "extra_mobs_spawn_icon_strider.png", 0)

mods/ENTITIES/mcl_boats/init.lua

@@ -1,4 +1,4 @@
-local S = minetest.get_translator("mcl_boats")
+local S = minetest.get_translator(minetest.get_current_modname())
 
 local boat_visual_size = {x = 1, y = 1, z = 1}
 local paddling_speed = 22
@@ -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)
@@ -470,6 +470,6 @@ minetest.register_craft({
 	burntime = 20,
 })
 
-if minetest.get_modpath("doc_identifier") ~= nil then
+if minetest.get_modpath("doc_identifier") then
 	doc.sub.identifier.register_object("mcl_boats:boat", "craftitems", "mcl_boats:boat")
 end

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,9 @@
-local S = minetest.get_translator("mcl_burning")
-local modpath = minetest.get_modpath("mcl_burning")
+local modpath = minetest.get_modpath(minetest.get_current_modname())
+
+local pairs = pairs
+
+local get_connected_players = minetest.get_connected_players
+local get_item_group = minetest.get_item_group
 
 mcl_burning = {
 	storage = {},
@@ -9,7 +13,7 @@ mcl_burning = {
 dofile(modpath .. "/api.lua")
 
 minetest.register_globalstep(function(dtime)
-	for _, player in pairs(minetest.get_connected_players()) do
+	for _, player in pairs(get_connected_players()) do
 		local storage = mcl_burning.storage[player]
 		if not mcl_burning.tick(player, dtime, storage) and not mcl_burning.is_affected_by_rain(player) then
 			local nodes = mcl_burning.get_touching_nodes(player, {"group:puts_out_fire", "group:set_on_fire"}, storage)
@@ -17,12 +21,12 @@ minetest.register_globalstep(function(dtime)
 
 			for _, pos in pairs(nodes) do
 				local node = minetest.get_node(pos)
-				if minetest.get_item_group(node.name, "puts_out_fire") > 0 then
+				if get_item_group(node.name, "puts_out_fire") > 0 then
 					burn_time = 0
 					break
 				end
 
-				local value = minetest.get_item_group(node.name, "set_on_fire")
+				local value = get_item_group(node.name, "set_on_fire")
 				if value > burn_time then
 					burn_time = value
 				end
@@ -56,7 +60,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)
 
@@ -68,11 +71,10 @@ minetest.register_entity("mcl_burning:fire", {
 		visual = "cube",
 		pointable = false,
 		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
+			--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 (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

@@ -1,5 +1,5 @@
 --these are lua locals, used for higher performance
-local minetest,math,vector,ipairs = minetest,math,vector,ipairs
+local minetest, math, vector, ipairs, pairs = minetest, math, vector, ipairs, pairs
 
 --this is used for the player pool in the sound buffer
 local pool = {}
@@ -38,7 +38,7 @@ item_drop_settings.drop_single_item      = false --if true, the drop control dro
 
 item_drop_settings.magnet_time           = 0.75 -- how many seconds an item follows the player before giving up
 
-local get_gravity = function()
+local function get_gravity()
 	return tonumber(minetest.settings:get("movement_gravity")) or 9.81
 end
 
@@ -60,7 +60,7 @@ mcl_item_entity.register_pickup_achievement("mcl_mobitems:blaze_rod", "mcl:blaze
 mcl_item_entity.register_pickup_achievement("mcl_mobitems:leather", "mcl:killCow")
 mcl_item_entity.register_pickup_achievement("mcl_core:diamond", "mcl:diamonds")
 
-local check_pickup_achievements = function(object, player)
+local function check_pickup_achievements(object, player)
 	if has_awards then
 		local itemname = ItemStack(object:get_luaentity().itemstring):get_name()
 		local playername = player:get_player_name()
@@ -72,7 +72,7 @@ local check_pickup_achievements = function(object, player)
 	end
 end
 
-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({
@@ -83,7 +83,7 @@ local enable_physics = function(object, luaentity, ignore_check)
 	end
 end
 
-local disable_physics = function(object, luaentity, ignore_check, reset_movement)
+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({
@@ -98,13 +98,11 @@ end
 
 
 minetest.register_globalstep(function(dtime)
-
 	tick = not tick
 
 	for _,player in pairs(minetest.get_connected_players()) do
 		if player:get_hp() > 0 or not minetest.settings:get_bool("enable_damage") then
 
-
 			local name = player:get_player_name()
 
 			local pos = player:get_pos()
@@ -235,7 +233,7 @@ function minetest.handle_node_drops(pos, drops, digger)
 	local dug_node = minetest.get_node(pos)
 	local tooldef
 	local tool
-	if digger ~= nil then
+	if digger then
 		tool = digger:get_wielded_item()
 		tooldef = minetest.registered_tools[tool:get_name()]
 
@@ -316,7 +314,7 @@ function minetest.handle_node_drops(pos, drops, digger)
 			end
 			-- Spawn item and apply random speed
 			local obj = minetest.add_item(dpos, drop_item)
-			if obj ~= nil then
+			if obj then
 				local x = math.random(1, 5)
 				if math.random(1,2) == 1 then
 					x = -x
@@ -365,6 +363,17 @@ if not time_to_live then
 	time_to_live = 300
 end
 
+local function cxcz(o, cw, one, zero)
+	if cw < 0 then
+		table.insert(o, { [one]=1, y=0, [zero]=0 })
+		table.insert(o, { [one]=-1, y=0, [zero]=0 })
+	else
+		table.insert(o, { [one]=-1, y=0, [zero]=0 })
+		table.insert(o, { [one]=1, y=0, [zero]=0 })
+	end
+	return o
+end
+
 minetest.register_entity(":__builtin:item", {
 	initial_properties = {
 		hp_max = 1,
@@ -385,7 +394,7 @@ minetest.register_entity(":__builtin:item", {
 	-- The itemstring MUST be set immediately to a non-empty string after creating the entity.
 	-- The hand is NOT permitted as dropped item. ;-)
 	-- Item entities will be deleted if they still have an empty itemstring on their first on_step tick.
-	itemstring = '',
+	itemstring = "",
 
 	-- If true, item will fall
 	physical_state = true,
@@ -426,13 +435,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
@@ -580,7 +585,7 @@ minetest.register_entity(":__builtin:item", {
 			return
 		end
 		self.age = self.age + dtime
-		if self._collector_timer ~= nil then
+		if self._collector_timer then
 			self._collector_timer = self._collector_timer + dtime
 		end
 		if time_to_live > 0 and self.age > time_to_live then
@@ -648,16 +653,6 @@ minetest.register_entity(":__builtin:item", {
 			-- 1st: closest
 			-- 2nd: other direction
 			-- 3rd and 4th: other axis
-			local cxcz = function(o, cw, one, zero)
-				if cw < 0 then
-					table.insert(o, { [one]=1, y=0, [zero]=0 })
-					table.insert(o, { [one]=-1, y=0, [zero]=0 })
-				else
-					table.insert(o, { [one]=-1, y=0, [zero]=0 })
-					table.insert(o, { [one]=1, y=0, [zero]=0 })
-				end
-				return o
-			end
 			if math.abs(cx) < math.abs(cz) then
 				order = cxcz(order, cx, "x", "z")
 				order = cxcz(order, cz, "z", "x")

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

@@ -1,9 +1,10 @@
-local S = minetest.get_translator("mcl_minecarts")
+local modname = minetest.get_current_modname()
+local S = minetest.get_translator(modname)
 
 local has_mcl_wip = minetest.get_modpath("mcl_wip")
 
 mcl_minecarts = {}
-mcl_minecarts.modpath = minetest.get_modpath("mcl_minecarts")
+mcl_minecarts.modpath = minetest.get_modpath(modname)
 mcl_minecarts.speed_max = 10
 mcl_minecarts.check_float_time = 15
 
@@ -204,7 +205,7 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 			rou_pos = vector.round(pos)
 			node = minetest.get_node(rou_pos)
 			local g = minetest.get_item_group(node.name, "connect_to_raillike")
-			if g ~= self._railtype and self._railtype ~= nil then
+			if g ~= self._railtype and self._railtype then
 				-- Detach driver
 				if player then
 					if self._old_pos then
@@ -486,7 +487,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()
@@ -497,7 +497,7 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 end
 
 -- Place a minecart at pointed_thing
-mcl_minecarts.place_minecart = function(itemstack, pointed_thing, placer)
+function mcl_minecarts.place_minecart(itemstack, pointed_thing, placer)
 	if not pointed_thing.type == "node" then
 		return
 	end
@@ -524,7 +524,7 @@ mcl_minecarts.place_minecart = function(itemstack, pointed_thing, placer)
 	local cart = minetest.add_entity(railpos, entity_id)
 	local railtype = minetest.get_item_group(node.name, "connect_to_raillike")
 	local le = cart:get_luaentity()
-	if le ~= nil then
+	if le then
 		le._railtype = railtype
 	end
 	local cart_dir = mcl_minecarts:get_rail_direction(railpos, {x=1, y=0, z=0}, nil, nil, railtype)
@@ -541,7 +541,7 @@ mcl_minecarts.place_minecart = function(itemstack, pointed_thing, placer)
 end
 
 
-local register_craftitem = function(itemstring, entity_id, description, tt_help, longdesc, usagehelp, icon, creative)
+local function register_craftitem(itemstring, entity_id, description, tt_help, longdesc, usagehelp, icon, creative)
 	entity_mapping[itemstring] = entity_id
 
 	local groups = { minecart = 1, transport = 1 }
@@ -607,7 +607,7 @@ Register a minecart
 local function register_minecart(itemstring, entity_id, description, tt_help, longdesc, usagehelp, mesh, textures, icon, drop, on_rightclick, on_activate_by_rail, creative)
 	register_entity(entity_id, mesh, textures, drop, on_rightclick, on_activate_by_rail)
 	register_craftitem(itemstring, entity_id, description, tt_help, longdesc, usagehelp, icon, creative)
-	if minetest.get_modpath("doc_identifier") ~= nil then
+	if minetest.get_modpath("doc_identifier") then
 		doc.sub.identifier.register_object(entity_id, "craftitems", itemstring)
 	end
 end
@@ -817,8 +817,7 @@ minetest.register_craft({
 })
 
 -- TODO: Re-enable crafting of special minecarts when they have been implemented
-if false then
-	minetest.register_craft({
+--[[minetest.register_craft({
 	output = "mcl_minecarts:furnace_minecart",
 	recipe = {
 		{"mcl_furnaces:furnace"},
@@ -840,8 +839,8 @@ if false then
 		{"mcl_chests:chest"},
 		{"mcl_minecarts:minecart"},
 	},
-	})
-end
+})]]
+
 
 if has_mcl_wip then
 	mcl_wip.register_wip_item("mcl_minecarts:chest_minecart")