Add missing mcl_util functions

Add Moss to groups: soil_bamboo, soil_sugarcane
Add moss to allowed flower placement blocks

.editorconfig

@@ -4,7 +4,7 @@ root = true
 end_of_line = lf
 
 [*.lua]
-charset = utf-8
+charset = utf8
 indent_style = tab
 insert_final_newline = true
 trim_trailing_whitespace = true

.gitignore

@@ -6,5 +6,3 @@
 /.idea/
 *.xcf
 .Rproj.user
-prompt.txt
-__pycache__

mods/CORE/mcl_explosions/locale/mcl_explosions.oc.tr

@@ -1,2 +0,0 @@
-# textdomain:mcl_explosions
-@1 was caught in an explosion.=@1 z-es mòrt dins una explosion

mods/CORE/mcl_init/init.lua

@@ -36,8 +36,6 @@ mcl_vars.MAP_BLOCKSIZE = math.max(1, minetest.MAP_BLOCKSIZE or 16)
 mcl_vars.mapgen_limit = math.max(1, tonumber(minetest.get_mapgen_setting("mapgen_limit")) or 31000)
 mcl_vars.MAX_MAP_GENERATION_LIMIT = math.max(1, minetest.MAX_MAP_GENERATION_LIMIT or 31000)
 
--- Central chunk is offset from 0,0,0 coordinates by 32 nodes (2 blocks)
--- See more in https://git.minetest.land/MineClone2/MineClone2/wiki/World-structure%3A-positions%2C-boundaries%2C-blocks%2C-chunks%2C-dimensions%2C-barriers-and-the-void
 local central_chunk_offset = -math.floor(mcl_vars.chunksize / 2)
 
 mcl_vars.central_chunk_offset_in_nodes = central_chunk_offset * mcl_vars.MAP_BLOCKSIZE

mods/CORE/mcl_util/init.lua

@@ -22,6 +22,13 @@ function table.update_nil(t, ...)
 	return t
 end
 
+-- Copies the table then updates
+function table.merge(t, ...)
+	local t2 = table.copy(t)
+	return table.update(t2, ...)
+end
+
+
 ---Works the same as `pairs`, but order returned by keys
 ---
 ---Taken from https://www.lua.org/pil/19.3.html
@@ -160,7 +167,7 @@ function mcl_util.rotate_axis_and_place(itemstack, placer, pointed_thing, infini
 		return
 	end
 	local undef = minetest.registered_nodes[unode.name]
-	if undef and undef.on_rightclick and not invert_wall then
+	if undef and undef.on_rightclick then
 		undef.on_rightclick(pointed_thing.under, unode, placer,
 			itemstack, pointed_thing)
 		return
@@ -198,12 +205,26 @@ function mcl_util.rotate_axis_and_place(itemstack, placer, pointed_thing, infini
 
 	local p2
 	if is_y then
-		p2 = 0
+		if invert_wall then
-	elseif is_x then
+			if fdir == 3 or fdir == 1 then
 				p2 = 12
-	elseif is_z then
+			else
 				p2 = 6
 			end
+		end
+	elseif is_x then
+		if invert_wall then
+			p2 = 0
+		else
+			p2 = 12
+		end
+	elseif is_z then
+		if invert_wall then
+			p2 = 0
+		else
+			p2 = 6
+		end
+	end
 	minetest.set_node(pos, {name = wield_name, param2 = p2})
 
 	if not infinitestacks then
@@ -257,21 +278,12 @@ end
 ---@param dst_inventory InvRef Destination inventory to push to
 ---@param dst_list string Name of destination inventory list to push to
 ---@param condition? fun(stack: ItemStack) Condition which items are allowed to be transfered.
----@param count? integer Number of items to try to transfer at once
 ---@return integer Item stack number to be transfered
-function mcl_util.select_stack(src_inventory, src_list, dst_inventory, dst_list, condition, count)
+function mcl_util.select_stack(src_inventory, src_list, dst_inventory, dst_list, condition)
 	local src_size = src_inventory:get_size(src_list)
 	local stack
 	for i = 1, src_size do
 		stack = src_inventory:get_stack(src_list, i)
-
-		-- Allow for partial stack movement
-		if count and stack:get_count() >= count then
-			local new_stack = ItemStack(stack)
-			new_stack:set_count(count)
-			stack = new_stack
-		end
-
 		if not stack:is_empty() and dst_inventory:room_for_item(dst_list, stack) and ((condition == nil or condition(stack))) then
 			return i
 		end
@@ -289,13 +301,9 @@ end
 -- Returns true on success and false on failure
 -- Possible failures: No item in source slot, destination inventory full
 function mcl_util.move_item(source_inventory, source_list, source_stack_id, destination_inventory, destination_list)
-	-- Can't move items we don't have
+	if not source_inventory:is_empty(source_list) then
-	if source_inventory:is_empty(source_list) then return false end
-
-	-- Can't move from an empty stack
 		local stack = source_inventory:get_stack(source_list, source_stack_id)
-	if stack:is_empty() then return false end
+		if not stack:is_empty() then
-
 			local new_stack = ItemStack(stack)
 			new_stack:set_count(1)
 			if not destination_inventory:room_for_item(destination_list, new_stack) then
@@ -306,6 +314,9 @@ function mcl_util.move_item(source_inventory, source_list, source_stack_id, dest
 			destination_inventory:add_item(destination_list, new_stack)
 			return true
 		end
+	end
+	return false
+end
 
 --- Try pushing item from hopper inventory to destination inventory
 ---@param pos Vector
@@ -324,23 +335,25 @@ function mcl_util.hopper_push(pos, dst_pos)
 	local dst_list = 'main'
 	local dst_inv, stack_id
 
-	-- Find a inventory stack in the destination
 	if dst_def._mcl_hoppers_on_try_push then
 		dst_inv, dst_list, stack_id = dst_def._mcl_hoppers_on_try_push(dst_pos, pos, hop_inv, hop_list)
 	else
 		local dst_meta = minetest.get_meta(dst_pos)
 		dst_inv = dst_meta:get_inventory()
-		stack_id = mcl_util.select_stack(hop_inv, hop_list, dst_inv, dst_list, nil, 1)
+		stack_id = mcl_util.select_stack(hop_inv, hop_list, dst_inv, dst_list)
 	end
-	if not stack_id then return false end
 
-	-- Move the item
+	if stack_id ~= nil then
 		local ok = mcl_util.move_item(hop_inv, hop_list, stack_id, dst_inv, dst_list)
 		if dst_def._mcl_hoppers_on_after_push then
 			dst_def._mcl_hoppers_on_after_push(dst_pos)
 		end
+		if ok then
+			return true
+		end
+	end
 
-	return ok
+	return false
 end
 
 -- Try pulling from source inventory to hopper inventory
@@ -365,7 +378,7 @@ function mcl_util.hopper_pull(pos, src_pos)
 	else
 		local src_meta = minetest.get_meta(src_pos)
 		src_inv = src_meta:get_inventory()
-		stack_id = mcl_util.select_stack(src_inv, src_list, hop_inv, hop_list, nil, 1)
+		stack_id = mcl_util.select_stack(src_inv, src_list, hop_inv, hop_list)
 	end
 
 	if stack_id ~= nil then
@@ -624,6 +637,21 @@ function mcl_util.replace_mob(obj, mob)
 	return obj
 end
 
+
+function mcl_util.traverse_tower(pos, dir, callback)
+	local node = minetest.get_node(pos)
+	local i = 0
+	while minetest.get_node(pos).name == node.name do
+		if callback and callback(pos, dir, node) then
+			return pos,i,true
+		end
+		i = i + 1
+		pos = vector.offset(pos, 0, dir, 0)
+	end
+	return vector.offset(pos, 0, -dir, 0), i
+end
+
+
 function mcl_util.get_pointed_thing(player, liquid)
 	local pos = vector.offset(player:get_pos(), 0, player:get_properties().eye_height, 0)
 	local look_dir = vector.multiply(player:get_look_dir(), 5)

mods/CORE/tga_encoder/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/tga_encoder/README.md

@@ -1,87 +1,4 @@
 # tga_encoder
 A TGA Encoder written in Lua without the use of external Libraries.
 
-Created by fleckenstein for MineClone2, then improved by erlehmann.
-
 May be used as a Minetest mod.
-
-See `examples.lua` for example code and usage hints.
-
-## Use Cases for `tga_encoder`
-
-### Encoding Textures for Editing
-
-TGA images of types 1/2/3 consist of header data followed by a pixel array.
-
-This makes it trivial to parse TGA files – and even edit pixels in-place.
-
-No checksums need to be updated on any kind of in-place texture editing.
-
-**Tip**: When storing an editable image in item meta, use zlib compression.
-
-### Legacy Minetest Texture Encoding
-
-Minetest 5.4 did not include `minetest.encode_png()` (or any equvivalent).
-
-Since `tga_encoder` is written in pure Lua, it does not need engine support.
-
-**Tip:** Look at `examples.lua` and the Minetest mod `mcl_maps` for guidance.
-
-### Advanced Texture Format Control
-
-The function `minetest.encode_png()` always encodes images as 32bpp RGBA.
-
-`tga_encoder` allows saving images as grayscale, 16bpp RGBA and 24bpp RGB.
-
-For generating maps from terrain, color-mapped formats can be more useful.
-
-### Encoding Very Small Textures
-
-Images of size 8×8 or below are often smaller than an equivalent PNG file.
-
-Note that on many filesystems files use at least 4096 bytes (i.e. 64×64).
-
-Therefore, saving bytes on files up to a few 100 bytes is often useless.
-
-### Encoding Reference Textures
-
-TGA is a simple format, which makes it easy to create reference textures.
-
-Using a hex editor, one can trivially see how all the pixels are stored.
-
-## Supported Image Types
-
-For all types, images are encoded in a fast single pass (i.e. append-only).
-
-### Color-Mapped Images (Type 1)
-
-These images contain a palette, followed by pixel data.
-
-* `A1R5G5B5` (8bpp RGB)
-* `B8G8R8` (8bpp RGB)
-* `B8G8R8A8` (8bpp RGBA)
-
-### True-Color Images (Type 2)
-
-These images contain uncompressed RGB(A) pixel data.
-
-* `A1R5G5B5` (16bpp RGBA)
-* `B8G8R8` (24bpp RGB)
-* `B8G8R8A8` (32bpp RGBA)
-
-### Grayscale Images (Type 3)
-
-* `Y8` (8bpp grayscale)
-
-### Run-Length Encoded (RLE), True-Color Images (Type 10)
-
-These images contain compressed RGB(A) pixel data.
-
-* `A1R5G5B5` (16bpp RGBA)
-* `B8G8R8` (24bpp RGB)
-* `B8G8R8A8` (32bpp RGBA)
-
-## TODO
-
-* Actually support `R8G8B8A8` input for `A1R5G5B5` output
-* Add both zoomable and explorable maps to `mcl_maps`.

mods/CORE/tga_encoder/colormap_generator.lua

@@ -1,32 +0,0 @@
-dofile("init.lua")
-
--- This generates images necessary to colorize 16 Minetest nodes in 4096 colors.
--- It serves as a demonstration of what you can achieve using colormapped nodes.
--- It is be useful for grass or beam or glass nodes that need to blend smoothly.
-
--- Sample depth rescaling is done according to the algorithm presented in:
--- <https://www.w3.org/TR/2003/REC-PNG-20031110/#13Sample-depth-rescaling>
-local max_sample_in = math.pow(2, 4) - 1
-local max_sample_out = math.pow(2, 8) - 1
-
-for r = 0,15 do
-	local pixels = {}
-	for g = 0,15 do
-		if nil == pixels[g + 1] then
-			pixels[g + 1] = {}
-		end
-		for b = 0,15 do
-			local color = {
-				math.floor((r * max_sample_out / max_sample_in) + 0.5),
-				math.floor((g * max_sample_out / max_sample_in) + 0.5),
-				math.floor((b * max_sample_out / max_sample_in) + 0.5),
-			}
-			pixels[g + 1][b + 1] = color
-		end
-	end
-	local filename = "colormap_" .. tostring(r) .. ".tga"
-	tga_encoder.image(pixels):save(
-		filename,
-		{ color_format="A1R5G5B5" } -- waste less bits
-	)
-end

mods/CORE/tga_encoder/donut.lua

@@ -1,105 +0,0 @@
-#!/usr/bin/env lua5.1
--- -*- coding: utf-8 -*-
-
--- 3D “donut” shape rendering using floating-point math
--- see <https://www.a1k0n.net/2011/07/20/donut-math.html>
-
--- cargo-culted by erle 2023-09-18
-
-local theta_spacing = 0.01  -- 0.07
-local phi_spacing = 0.002  -- 0.02
-
-local R1 = 1
-local R2 = 2
-local K2 = 5
-
-local screen_height = 256
-local screen_width = 256
-
-local K1 = screen_width * K2 * 3 / ( 8 * ( R1 + R2 ) )
-
-local output = {}
-local zbuffer = {}
-
-local grey = { 120, 120, 120 }
-local gray = { 136, 136, 136 }
-
-for y = 1,screen_height,1 do
-   output[y] = {}
-   zbuffer[y] = {}
-   for x = 1,screen_width,1 do
-      local hori = math.floor( ( (y - 1) / 32 ) % 2 )
-      local vert = math.floor( ( (x - 1) / 32 ) % 2 )
-      output[y][x] = hori ~= vert and grey or gray
-      zbuffer[y][x] = 0
-   end
-end
-
-function render_frame(A, B)
-   -- precompute sines and cosines of A and B
-   local cosA = math.cos(A)
-   local sinA = math.sin(A)
-   local cosB = math.cos(B)
-   local sinB = math.sin(B)
-
-   -- theta goas around the cross-sectional circle of a torus
-   local theta = 0
-   while theta <= 2*math.pi do
-      if ( theta < 2*math.pi * 1/8 ) or ( theta > 2*math.pi * 7/8 ) then
-         theta = theta + (theta_spacing * 16)
-      else
-         theta = theta + theta_spacing
-      end
-      -- precompute sines and cosines of theta
-      local costheta = math.cos(theta)
-      local sintheta = math.sin(theta)
-
-      -- phi goes around the center of revolution of a torus
-      local phi = 0
-      while phi <= 2*math.pi do
-         if ( phi > 2*math.pi * 3/8 ) and ( phi < 2*math.pi * 5/8 ) then
-            phi = phi + (phi_spacing * 128)
-         else
-            phi = phi + phi_spacing
-         end
-        -- precompute sines and cosines of phi
-         local cosphi = math.cos(phi)
-         local sinphi = math.sin(phi)
-
-         -- 2D (x, y) coordinates of the circle, before revolving
-         local circlex = R2 + R1*costheta
-         local circley = R1*sintheta
-
-         -- 3D (x, y, z) coordinates after rotation
-         local x = circlex*(cosB*cosphi + sinA*sinB*sinphi) - circley*cosA*sinB
-         local y = circlex*(sinB*cosphi - sinA*cosB*sinphi) + circley*cosA*cosB
-         local z = K2 + cosA*circlex*sinphi + circley*sinA
-
-         local ooz = 1/z
-
-         -- x and y projection
-         local xp = math.floor(screen_width/2 + K1*ooz*x)
-         local yp = math.floor(screen_height/2 + K1*ooz*y)
-
-         -- calculate luminance
-         local L = cosphi*costheta*sinB - cosA*costheta*sinphi - sinA*sintheta + cosB*( cosA*sintheta - costheta*sinA*sinphi )
-         -- if (L > 0) then
-         if (true) then
-            if (ooz > zbuffer[yp][xp]) then
-                   zbuffer[yp][xp] = ooz
-                   local luminance = math.max( math.ceil( L * 180 ), 0 )
-                   -- luminance is now in the range 0 to 255
-                   r = math.ceil( (luminance + xp) / 2 )
-                   g = math.ceil( (luminance + yp) / 2 )
-                   b = math.ceil( (luminance + xp + yp) / 3 )
-                   output[yp][xp] = { r, g, b }
-            end
-         end
-      end
-   end
-end
-
-dofile('init.lua')
-
-render_frame(-0.7, 0.7)
-tga_encoder.image(output):save("donut.tga")

mods/CORE/tga_encoder/examples.lua

@@ -1,181 +0,0 @@
-dofile("init.lua")
-
--- encode a bitmap
-local _ = { 0, 0, 0 }
-local R = { 255, 127, 127 }
-local pixels = {
-	{ _, _, _, _, _, _, _ },
-	{ _, _, _, R, _, _, _ },
-	{ _, _, R, R, R, _, _ },
-	{ _, R, R, R, R, R, _ },
-	{ _, R, R, R, R, R, _ },
-	{ _, _, R, _, R, _, _ },
-	{ _, _, _, _, _, _, _ },
-}
-tga_encoder.image(pixels):save("bitmap_small.tga")
-
--- test that image can be encoded
-local bitmap_small_0 = tga_encoder.image(pixels)
-bitmap_small_0:encode()
-assert(191 == #bitmap_small_0.data)
-
--- test that imbage can be encoded with parameters
-local bitmap_small_1 = tga_encoder.image(pixels)
-bitmap_small_1:encode(
-	{
-		colormap = {},
-		color_format = "B8G8R8",
-		compression = "RAW",
-	}
-)
-assert(191 == #bitmap_small_1.data)
-
--- change a single pixel, then rescale the bitmap
-local pixels_orig = pixels
-pixels_orig[4][4] = { 255, 255, 255 }
-local pixels = {}
-for x = 1,56,1 do
-	local x_orig = math.ceil(x/8)
-	for z = 1,56,1 do
-		local z_orig = math.ceil(z/8)
-		local color = pixels_orig[z_orig][x_orig]
-		pixels[z] = pixels[z] or {}
-		pixels[z][x] = color
-	end
-end
-tga_encoder.image(pixels):save("bitmap_large.tga")
-
--- note that the uncompressed grayscale TGA file written in this
--- example is 80 bytes – but an optimized PNG file is 81 bytes …
-local pixels = {}
-for x = 1,6,1 do -- left to right
-	for z = 1,6,1 do -- bottom to top
-		local color = { math.min(x * z * 4 - 1, 255) }
-		pixels[z] = pixels[z] or {}
-		pixels[z][x] = color
-	end
-end
-tga_encoder.image(pixels):save("gradient_8bpp_raw.tga", {color_format="Y8", compression="RAW"})
-
-local pixels = {}
-for x = 1,16,1 do -- left to right
-	for z = 1,16,1 do -- bottom to top
-		local r = math.min(x * 32 - 1, 255)
-		local g = math.min(z * 32 - 1, 255)
-		local b = 0
-		-- blue rectangle in top right corner
-		if x > 8 and z > 8 then
-			r = 0
-			g = 0
-			b = math.min(z * 16 - 1, 255)
-		end
-		local color = { r, g, b }
-		pixels[z] = pixels[z] or {}
-		pixels[z][x] = color
-	end
-end
-local gradients = tga_encoder.image(pixels)
-gradients:save("gradients_8bpp_raw.tga", {color_format="Y8", compression="RAW"})
-gradients:save("gradients_16bpp_raw.tga", {color_format="A1R5G5B5", compression="RAW"})
-gradients:save("gradients_16bpp_rle.tga", {color_format="A1R5G5B5", compression="RLE"})
-gradients:save("gradients_24bpp_raw.tga", {color_format="B8G8R8", compression="RAW"})
-gradients:save("gradients_24bpp_rle.tga", {color_format="B8G8R8", compression="RLE"})
-
-for x = 1,16,1 do -- left to right
-	for z = 1,16,1 do -- bottom to top
-		local color = pixels[z][x]
-		color[#color+1] = ((x * x) + (z * z)) % 256
-		pixels[z][x] = color
-	end
-end
-gradients:save("gradients_32bpp_raw.tga", {color_format="B8G8R8A8", compression="RAW"})
--- the RLE-compressed file is larger than just dumping pixels because
--- the gradients in this picture can not be compressed well using RLE
-gradients:save("gradients_32bpp_rle.tga", {color_format="B8G8R8A8", compression="RLE"})
-
-local pixels = {}
-for x = 1,512,1 do -- left to right
-	for z = 1,512,1 do -- bottom to top
-		local oz = (z - 256) / 256 + 0.75
-		local ox = (x - 256) / 256
-		local px, pz, i = 0, 0, 0
-		while (px * px) + (pz * pz) <= 4 and i < 128 do
-			px = (px * px) - (pz * pz) + oz
-			pz = (2 * px  * pz) + ox
-			i =  i + 1
-		end
-		local color = {
-			math.max(0, math.min(255, math.floor(px * 64))),
-			math.max(0, math.min(255, math.floor(pz * 64))),
-			math.max(0, math.min(255, math.floor(i))),
-		}
-		pixels[z] = pixels[z] or {}
-		pixels[z][x] = color
-	end
-end
-tga_encoder.image(pixels):save("fractal_8bpp.tga", {color_format="Y8"})
-tga_encoder.image(pixels):save("fractal_16bpp.tga", {color_format="A1R5G5B5"})
-tga_encoder.image(pixels):save("fractal_24bpp.tga", {color_format="B8G8R8"})
-
--- encode a colormapped bitmap
-local K = { 0 }
-local B = { 1 }
-local R = { 2 }
-local G = { 3 }
-local W = { 4 }
-local colormap = {
-	{   1,   2,   3 }, -- K
-	{   0,   0, 255 }, -- B
-	{ 255,   0,   0 }, -- R
-	{   0, 255,   0 }, -- G
-	{ 253, 254, 255 }, -- W
-}
-local pixels = {
-	{ W, K, W, K, W, K, W },
-	{ R, G, B, R, G, B, K },
-	{ K, W, K, W, K, W, K },
-	{ G, B, R, G, B, R, W },
-	{ W, W, W, K, K, K, W },
-	{ B, R, G, B, R, G, K },
-	{ B, R, G, B, R, G, W },
-}
--- note that the uncompressed colormapped TGA file written in this
--- example is 108 bytes – but an optimized PNG file is 121 bytes …
-tga_encoder.image(pixels):save("colormapped_B8G8R8.tga", {colormap=colormap})
--- encoding as A1R5G5B5 saves 1 byte per palette entry → 103 bytes
-tga_encoder.image(pixels):save("colormapped_A1R5G5B5.tga", {colormap=colormap, color_format="A1R5G5B5"})
-
--- encode a colormapped bitmap with transparency
-local _ = { 0 }
-local K = { 1 }
-local W = { 2 }
-local colormap = {
-	{   0,   0,   0,   0 },
-	{   0,   0,   0, 255 },
-	{ 255, 255, 255, 255 },
-}
-local pixels = {
-	{ _, K, K, K, K, K, _ },
-	{ _, K, W, W, W, K, _ },
-	{ K, K, W, W, W, K, K },
-	{ K, W, W, W, W, W, K },
-	{ _, K, W, W, W, K, _ },
-	{ _, _, K, W, K, _, _ },
-	{ _, _, _, K, _, _, _ },
-}
-tga_encoder.image(pixels):save("colormapped_B8G8R8A8.tga", {colormap=colormap})
-
--- encoding a colormapped image with illegal colormap indexes should error out
-local colormap = {
-	{   0,   0,   0,   0 },
-	{   0,   0,   0, 255 },
-}
-local status, message = pcall(
-	function ()
-		tga_encoder.image(pixels):encode({colormap=colormap})
-	end
-)
-assert(
-	false == status and
-	"init.lua:36: colormap index 2 not in colormap of size 2" == message
-)

mods/CORE/tga_encoder/init.lua

@@ -9,566 +9,60 @@ local image = setmetatable({}, {
 })
 
 function image:constructor(pixels)
+	self.data = ""
 	self.pixels = pixels
 	self.width = #pixels[1]
 	self.height = #pixels
+
+	self:encode()
 end
 
-local pixel_depth_by_color_format = {
+function image:encode_colormap_spec()
-	["Y8"] = 8,
+	self.data = self.data
-	["A1R5G5B5"] = 16,
+		.. string.char(0, 0) -- first entry index
-	["B8G8R8"] = 24,
+		.. string.char(0, 0) -- number of entries
-	["B8G8R8A8"] = 32,
+		.. string.char(0) -- bits per pixel
-}
-
-function image:encode_colormap_spec(properties)
-	local colormap = properties.colormap
-	local colormap_pixel_depth = 0
-	if 0 ~= #colormap then
-		colormap_pixel_depth = pixel_depth_by_color_format[
-			properties.color_format
-		]
-		-- ensure that each pixel references a legal colormap entry
-		for _, row in ipairs(self.pixels) do
-			for _, pixel in ipairs(row) do
-				local colormap_index = pixel[1]
-				if colormap_index >= #colormap then
-					error(
-						"colormap index " .. colormap_index ..
-						" not in colormap of size " .. #colormap
-					)
-				end
-			end
-		end
-	end
-	local colormap_spec =
-		string.char(0, 0) .. -- first entry index
-		string.char(#colormap % 256, math.floor(#colormap / 256)) .. -- number of entries
-		string.char(colormap_pixel_depth) -- bits per pixel
-	self.data = self.data .. colormap_spec
 end
 
-function image:encode_image_spec(properties)
+function image:encode_image_spec()
-	local color_format = properties.color_format
+	self.data = self.data
-	assert(
+		.. string.char(0, 0) -- X-origin
-		"Y8" == color_format or -- (8 bit grayscale = 1 byte = 8 bits)
+		.. string.char(0, 0) -- Y-origin
-		"A1R5G5B5" == color_format or -- (A1R5G5B5 = 2 bytes = 16 bits)
+		.. string.char(self.width  % 256, math.floor(self.width  / 256)) -- width
-		"B8G8R8" == color_format or -- (B8G8R8 = 3 bytes = 24 bits)
+		.. string.char(self.height % 256, math.floor(self.height / 256)) -- height
-		"B8G8R8A8" == color_format -- (B8G8R8A8 = 4 bytes = 32 bits)
+		.. string.char(24) -- pixel depth (RGB = 3 bytes = 24 bits)
-	)
+		.. string.char(0) -- image descriptor
-	local scanline_order = properties.scanline_order
-	assert (
-		"bottom-top" == scanline_order or
-		"top-bottom" == scanline_order
-	)
-	local pixel_depth
-	if 0 ~= #properties.colormap then
-		pixel_depth = self.pixel_depth
-	else
-		pixel_depth = pixel_depth_by_color_format[color_format]
-	end
-	assert( nil ~= pixel_depth)
-	-- the origin is the bottom left corner of the image (always)
-	local x_origin_lo = 0
-	local x_origin_hi = 0
-	local y_origin_lo = 0
-	local y_origin_hi = 0
-	local image_descriptor = 0 -- equal to bottom-top scanline order
-	local width_lo = self.width % 256
-	local width_hi = math.floor(self.width  / 256)
-	local height_lo = self.height % 256
-	local height_hi = math.floor(self.height / 256)
-	if "top-bottom" == scanline_order then
-		image_descriptor = 32
-		y_origin_lo = height_lo
-		y_origin_hi = height_hi
-	end
-	self.data = self.data .. string.char (
-		x_origin_lo, x_origin_hi,
-		y_origin_lo, y_origin_hi,
-		width_lo, width_hi,
-		height_lo, height_hi,
-		pixel_depth,
-		image_descriptor
-	)
 end
 
-function image:encode_colormap(properties)
+function image:encode_header()
-	local colormap = properties.colormap
-	if 0 == #colormap then
-		return
-	end
-	local color_format = properties.color_format
-	assert (
-		"A1R5G5B5" == color_format or
-		"B8G8R8" == color_format or
-		"B8G8R8A8" == color_format
-	)
-	local colors = {}
-	if "A1R5G5B5" == color_format then
-		-- Sample depth rescaling is done according to the algorithm presented in:
-		-- <https://www.w3.org/TR/2003/REC-PNG-20031110/#13Sample-depth-rescaling>
-		local max_sample_in = math.pow(2, 8) - 1
-		local max_sample_out = math.pow(2, 5) - 1
-		for i = 1,#colormap,1 do
-			local color = colormap[i]
-			local colorword = 32768 +
-				((math.floor((color[1] * max_sample_out / max_sample_in) + 0.5)) * 1024) +
-				((math.floor((color[2] * max_sample_out / max_sample_in) + 0.5)) * 32) +
-				((math.floor((color[3] * max_sample_out / max_sample_in) + 0.5)) * 1)
-			local color_bytes = string.char(
-				colorword % 256,
-				math.floor(colorword / 256)
-			)
-			colors[#colors + 1] = color_bytes
-		end
-	elseif "B8G8R8" == color_format then
-		for i = 1,#colormap,1 do
-			local color = colormap[i]
-			local color_bytes = string.char(
-				color[3], -- B
-				color[2], -- G
-				color[1]  -- R
-			)
-			colors[#colors + 1] = color_bytes
-		end
-	elseif "B8G8R8A8" == color_format then
-		for i = 1,#colormap,1 do
-			local color = colormap[i]
-			local color_bytes = string.char(
-				color[3], -- B
-				color[2], -- G
-				color[1], -- R
-				color[4]  -- A
-			)
-			colors[#colors + 1] = color_bytes
-		end
-	end
-	assert( 0 ~= #colors )
-	self.data = self.data .. table.concat(colors)
-end
-
-function image:encode_header(properties)
-	local color_format = properties.color_format
-	local colormap = properties.colormap
-	local compression = properties.compression
-	local colormap_type
-	local image_type
-	if "Y8" == color_format and "RAW" == compression then
-		colormap_type = 0
-		image_type = 3 -- grayscale
-	elseif (
-		"A1R5G5B5" == color_format or
-		"B8G8R8" == color_format or
-		"B8G8R8A8" == color_format
-	) then
-		if "RAW" == compression then
-			if 0 ~= #colormap then
-				colormap_type = 1
-				image_type = 1 -- colormapped RGB(A)
-			else
-				colormap_type = 0
-				image_type = 2 -- RAW RGB(A)
-			end
-		elseif "RLE" == compression then
-			colormap_type = 0
-			image_type = 10 -- RLE RGB
-		end
-	end
-	assert( nil ~= colormap_type )
-	assert( nil ~= image_type )
 	self.data = self.data
 		.. string.char(0) -- image id
-		.. string.char(colormap_type)
+		.. string.char(0) -- color map type
-		.. string.char(image_type)
+		.. string.char(10) -- image type (RLE RGB = 10)
-	self:encode_colormap_spec(properties) -- color map specification
+	self:encode_colormap_spec() -- color map specification
-	self:encode_image_spec(properties) -- image specification
+	self:encode_image_spec() -- image specification
-	self:encode_colormap(properties)
 end
 
-function image:encode_data(properties)
+function image:encode_data()
-	local color_format = properties.color_format
+	local current_pixel = ''
-	local colormap = properties.colormap
+	local previous_pixel = ''
-	local compression = properties.compression
-
-	local data_length_before = #self.data
-	if "Y8" == color_format and "RAW" == compression then
-		if 8 == self.pixel_depth then
-			self:encode_data_Y8_as_Y8_raw()
-		elseif 24 == self.pixel_depth then
-			self:encode_data_R8G8B8_as_Y8_raw()
-		end
-	elseif "A1R5G5B5" == color_format then
-		if 0 ~= #colormap then
-			if "RAW" == compression then
-				if 8 == self.pixel_depth then
-					self:encode_data_Y8_as_Y8_raw()
-				end
-			end
-		else
-			if "RAW" == compression then
-				self:encode_data_R8G8B8_as_A1R5G5B5_raw()
-			elseif "RLE" == compression then
-				self:encode_data_R8G8B8_as_A1R5G5B5_rle()
-			end
-		end
-	elseif "B8G8R8" == color_format then
-		if 0 ~= #colormap then
-			if "RAW" == compression then
-				if 8 == self.pixel_depth then
-					self:encode_data_Y8_as_Y8_raw()
-				end
-			end
-		else
-			if "RAW" == compression then
-				self:encode_data_R8G8B8_as_B8G8R8_raw()
-			elseif "RLE" == compression then
-			   self:encode_data_R8G8B8_as_B8G8R8_rle()
-			end
-		end
-	elseif "B8G8R8A8" == color_format then
-		if 0 ~= #colormap then
-			if "RAW" == compression then
-				if 8 == self.pixel_depth then
-					self:encode_data_Y8_as_Y8_raw()
-				end
-			end
-		else
-			if "RAW" == compression then
-				self:encode_data_R8G8B8A8_as_B8G8R8A8_raw()
-			elseif "RLE" == compression then
-				self:encode_data_R8G8B8A8_as_B8G8R8A8_rle()
-			end
-		end
-	end
-	local data_length_after = #self.data
-	assert(
-		data_length_after ~= data_length_before,
-		"No data encoded for color format: " .. color_format
-	)
-end
-
-function image:encode_data_Y8_as_Y8_raw()
-	assert(8 == self.pixel_depth)
-	local raw_pixels = {}
-	for _, row in ipairs(self.pixels) do
-		for _, pixel in ipairs(row) do
-			local raw_pixel = string.char(pixel[1])
-			raw_pixels[#raw_pixels + 1] = raw_pixel
-		end
-	end
-	self.data = self.data .. table.concat(raw_pixels)
-end
-
-function image:encode_data_R8G8B8_as_Y8_raw()
-	assert(24 == self.pixel_depth)
-	local raw_pixels = {}
-	for _, row in ipairs(self.pixels) do
-		for _, pixel in ipairs(row) do
-			-- the HSP RGB to brightness formula is
-			-- sqrt( 0.299 r² + .587 g² + .114 b² )
-			-- see <https://alienryderflex.com/hsp.html>
-			local gray = math.floor(
-				math.sqrt(
-					0.299 * pixel[1]^2 +
-					0.587 * pixel[2]^2 +
-					0.114 * pixel[3]^2
-				) + 0.5
-			)
-			local raw_pixel = string.char(gray)
-			raw_pixels[#raw_pixels + 1] = raw_pixel
-		end
-	end
-	self.data = self.data .. table.concat(raw_pixels)
-end
-
-function image:encode_data_R8G8B8_as_A1R5G5B5_raw()
-	assert(24 == self.pixel_depth)
-	local raw_pixels = {}
-	-- Sample depth rescaling is done according to the algorithm presented in:
-	-- <https://www.w3.org/TR/2003/REC-PNG-20031110/#13Sample-depth-rescaling>
-	local max_sample_in = math.pow(2, 8) - 1
-	local max_sample_out = math.pow(2, 5) - 1
-	for _, row in ipairs(self.pixels) do
-		for _, pixel in ipairs(row) do
-			local colorword = 32768 +
-				((math.floor((pixel[1] * max_sample_out / max_sample_in) + 0.5)) * 1024) +
-				((math.floor((pixel[2] * max_sample_out / max_sample_in) + 0.5)) * 32) +
-				((math.floor((pixel[3] * max_sample_out / max_sample_in) + 0.5)) * 1)
-			local raw_pixel = string.char(colorword % 256, math.floor(colorword / 256))
-			raw_pixels[#raw_pixels + 1] = raw_pixel
-		end
-	end
-	self.data = self.data .. table.concat(raw_pixels)
-end
-
-function image:encode_data_R8G8B8_as_A1R5G5B5_rle()
-	assert(24 == self.pixel_depth)
-	local colorword = nil
-	local previous_r = nil
-	local previous_g = nil
-	local previous_b = nil
-	local raw_pixel = ''
-	local raw_pixels = {}
 	local count = 1
 	local packets = {}
-	local raw_packet = ''
-	local rle_packet = ''
-	-- Sample depth rescaling is done according to the algorithm presented in:
-	-- <https://www.w3.org/TR/2003/REC-PNG-20031110/#13Sample-depth-rescaling>
-	local max_sample_in = math.pow(2, 8) - 1
-	local max_sample_out = math.pow(2, 5) - 1
-	for _, row in ipairs(self.pixels) do
-		for _, pixel in ipairs(row) do
-			if pixel[1] ~= previous_r or pixel[2] ~= previous_g or pixel[3] ~= previous_b or count == 128 then
-				if nil ~= previous_r then
-					colorword = 32768 +
-						((math.floor((previous_r * max_sample_out / max_sample_in) + 0.5)) * 1024) +
-						((math.floor((previous_g * max_sample_out / max_sample_in) + 0.5)) * 32) +
-						((math.floor((previous_b * max_sample_out / max_sample_in) + 0.5)) * 1)
-					if 1 == count then
-						-- remember pixel verbatim for raw encoding
-						raw_pixel = string.char(colorword % 256, math.floor(colorword / 256))
-						raw_pixels[#raw_pixels + 1] = raw_pixel
-						if 128 == #raw_pixels then
-							raw_packet = string.char(#raw_pixels - 1)
-							packets[#packets + 1] = raw_packet
-							for i=1, #raw_pixels do
-								packets[#packets +1] = raw_pixels[i]
-							end
-							raw_pixels = {}
-						end
-					else
-						-- encode raw pixels, if any
-						if #raw_pixels > 0 then
-							raw_packet = string.char(#raw_pixels - 1)
-							packets[#packets + 1] = raw_packet
-							for i=1, #raw_pixels do
-								packets[#packets +1] = raw_pixels[i]
-							end
-							raw_pixels = {}
-						end
-						-- RLE encoding
-						rle_packet = string.char(128 + count - 1, colorword % 256, math.floor(colorword / 256))
-						packets[#packets +1] = rle_packet
-					end
-				end
-				count = 1
-				previous_r = pixel[1]
-				previous_g = pixel[2]
-				previous_b = pixel[3]
-			else
-				count = count + 1
-			end
-		end
-	end
-	colorword = 32768 +
-		((math.floor((previous_r * max_sample_out / max_sample_in) + 0.5)) * 1024) +
-		((math.floor((previous_g * max_sample_out / max_sample_in) + 0.5)) * 32) +
-		((math.floor((previous_b * max_sample_out / max_sample_in) + 0.5)) * 1)
-	if 1 == count then
-		raw_pixel = string.char(colorword % 256, math.floor(colorword / 256))
-		raw_pixels[#raw_pixels + 1] = raw_pixel
-		raw_packet = string.char(#raw_pixels - 1)
-		packets[#packets + 1] = raw_packet
-		for i=1, #raw_pixels do
-			packets[#packets +1] = raw_pixels[i]
-		end
-		raw_pixels = {}
-	else
-		-- encode raw pixels, if any
-		if #raw_pixels > 0 then
-			raw_packet = string.char(#raw_pixels - 1)
-			packets[#packets + 1] = raw_packet
-			for i=1, #raw_pixels do
-				packets[#packets +1] = raw_pixels[i]
-			end
-			raw_pixels = {}
-		end
-		-- RLE encoding
-		rle_packet = string.char(128 + count - 1, colorword % 256, math.floor(colorword / 256))
-		packets[#packets +1] = rle_packet
-	end
-	self.data = self.data .. table.concat(packets)
-end
-
-function image:encode_data_R8G8B8_as_B8G8R8_raw()
-	assert(24 == self.pixel_depth)
-	local raw_pixels = {}
-	for _, row in ipairs(self.pixels) do
-		for _, pixel in ipairs(row) do
-			local raw_pixel = string.char(pixel[3], pixel[2], pixel[1])
-			raw_pixels[#raw_pixels + 1] = raw_pixel
-		end
-	end
-	self.data = self.data .. table.concat(raw_pixels)
-end
-
-function image:encode_data_R8G8B8_as_B8G8R8_rle()
-	assert(24 == self.pixel_depth)
-	local previous_r = nil
-	local previous_g = nil
-	local previous_b = nil
-	local raw_pixel = ''
-	local raw_pixels = {}
-	local count = 1
-	local packets = {}
-	local raw_packet = ''
 	local rle_packet = ''
 	for _, row in ipairs(self.pixels) do
 		for _, pixel in ipairs(row) do
-			if pixel[1] ~= previous_r or pixel[2] ~= previous_g or pixel[3] ~= previous_b or count == 128 then
+			current_pixel = string.char(pixel[3], pixel[2], pixel[1])
-				if nil ~= previous_r then
+			if current_pixel ~= previous_pixel or count == 128 then
-					if 1 == count then
-						-- remember pixel verbatim for raw encoding
-						raw_pixel = string.char(previous_b, previous_g, previous_r)
-						raw_pixels[#raw_pixels + 1] = raw_pixel
-						if 128 == #raw_pixels then
-							raw_packet = string.char(#raw_pixels - 1)
-							packets[#packets + 1] = raw_packet
-							for i=1, #raw_pixels do
-								packets[#packets +1] = raw_pixels[i]
-							end
-							raw_pixels = {}
-						end
-					else
-						-- encode raw pixels, if any
-						if #raw_pixels > 0 then
-							raw_packet = string.char(#raw_pixels - 1)
-							packets[#packets + 1] = raw_packet
-							for i=1, #raw_pixels do
-								packets[#packets +1] = raw_pixels[i]
-							end
-							raw_pixels = {}
-						end
-						-- RLE encoding
-						rle_packet = string.char(128 + count - 1, previous_b, previous_g, previous_r)
 				packets[#packets +1] = rle_packet
-					end
-				end
 				count = 1
-				previous_r = pixel[1]
+				previous_pixel = current_pixel
-				previous_g = pixel[2]
-				previous_b = pixel[3]
 			else
 				count = count + 1
 			end
+			rle_packet = string.char(128 + count - 1) .. current_pixel
 		end
 	end
-	if 1 == count then
-		raw_pixel = string.char(previous_b, previous_g, previous_r)
-		raw_pixels[#raw_pixels + 1] = raw_pixel
-		raw_packet = string.char(#raw_pixels - 1)
-		packets[#packets + 1] = raw_packet
-		for i=1, #raw_pixels do
-			packets[#packets +1] = raw_pixels[i]
-		end
-		raw_pixels = {}
-	else
-		-- encode raw pixels, if any
-		if #raw_pixels > 0 then
-			raw_packet = string.char(#raw_pixels - 1)
-			packets[#packets + 1] = raw_packet
-			for i=1, #raw_pixels do
-				packets[#packets +1] = raw_pixels[i]
-			end
-			raw_pixels = {}
-		end
-		-- RLE encoding
-		rle_packet = string.char(128 + count - 1, previous_b, previous_g, previous_r)
 	packets[#packets +1] = rle_packet
-	end
-	self.data = self.data .. table.concat(packets)
-end
-
-function image:encode_data_R8G8B8A8_as_B8G8R8A8_raw()
-	assert(32 == self.pixel_depth)
-	local raw_pixels = {}
-	for _, row in ipairs(self.pixels) do
-		for _, pixel in ipairs(row) do
-			local raw_pixel = string.char(pixel[3], pixel[2], pixel[1], pixel[4])
-			raw_pixels[#raw_pixels + 1] = raw_pixel
-		end
-	end
-	self.data = self.data .. table.concat(raw_pixels)
-end
-
-function image:encode_data_R8G8B8A8_as_B8G8R8A8_rle()
-	assert(32 == self.pixel_depth)
-	local previous_r = nil
-	local previous_g = nil
-	local previous_b = nil
-	local previous_a = nil
-	local raw_pixel = ''
-	local raw_pixels = {}
-	local count = 1
-	local packets = {}
-	local raw_packet = ''
-	local rle_packet = ''
-	for _, row in ipairs(self.pixels) do
-		for _, pixel in ipairs(row) do
-			if pixel[1] ~= previous_r or pixel[2] ~= previous_g or pixel[3] ~= previous_b or pixel[4] ~= previous_a or count == 128 then
-				if nil ~= previous_r then
-					if 1 == count then
-						-- remember pixel verbatim for raw encoding
-						raw_pixel = string.char(previous_b, previous_g, previous_r, previous_a)
-						raw_pixels[#raw_pixels + 1] = raw_pixel
-						if 128 == #raw_pixels then
-							raw_packet = string.char(#raw_pixels - 1)
-							packets[#packets + 1] = raw_packet
-							for i=1, #raw_pixels do
-								packets[#packets +1] = raw_pixels[i]
-							end
-							raw_pixels = {}
-						end
-					else
-						-- encode raw pixels, if any
-						if #raw_pixels > 0 then
-							raw_packet = string.char(#raw_pixels - 1)
-							packets[#packets + 1] = raw_packet
-							for i=1, #raw_pixels do
-								packets[#packets +1] = raw_pixels[i]
-							end
-							raw_pixels = {}
-						end
-						-- RLE encoding
-						rle_packet = string.char(128 + count - 1, previous_b, previous_g, previous_r, previous_a)
-						packets[#packets +1] = rle_packet
-					end
-				end
-				count = 1
-				previous_r = pixel[1]
-				previous_g = pixel[2]
-				previous_b = pixel[3]
-				previous_a = pixel[4]
-			else
-				count = count + 1
-			end
-		end
-	end
-	if 1 == count then
-		raw_pixel = string.char(previous_b, previous_g, previous_r, previous_a)
-		raw_pixels[#raw_pixels + 1] = raw_pixel
-		raw_packet = string.char(#raw_pixels - 1)
-		packets[#packets + 1] = raw_packet
-		for i=1, #raw_pixels do
-			packets[#packets +1] = raw_pixels[i]
-		end
-		raw_pixels = {}
-	else
-		-- encode raw pixels, if any
-		if #raw_pixels > 0 then
-			raw_packet = string.char(#raw_pixels - 1)
-			packets[#packets + 1] = raw_packet
-			for i=1, #raw_pixels do
-				packets[#packets +1] = raw_pixels[i]
-			end
-			raw_pixels = {}
-		end
-		-- RLE encoding
-		rle_packet = string.char(128 + count - 1, previous_b, previous_g, previous_r, previous_a)
-		packets[#packets +1] = rle_packet
-	end
 	self.data = self.data .. table.concat(packets)
 end
 
@@ -581,45 +75,15 @@ function image:encode_footer()
 		.. string.char(0)
 end
 
-function image:encode(properties)
+function image:encode()
-	local properties = properties or {}
+	self:encode_header() -- header
-	properties.colormap = properties.colormap or {}
-	properties.compression = properties.compression or "RAW"
-        properties.scanline_order = properties.scanline_order or "bottom-top"
-
-	self.pixel_depth = #self.pixels[1][1] * 8
-
-	local color_format_defaults_by_pixel_depth = {
-		[8] = "Y8",
-		[24] = "B8G8R8",
-		[32] = "B8G8R8A8",
-	}
-	if nil == properties.color_format then
-		if 0 ~= #properties.colormap then
-			properties.color_format =
-				color_format_defaults_by_pixel_depth[
-				#properties.colormap[1] * 8
-				]
-		else
-			properties.color_format =
-				color_format_defaults_by_pixel_depth[
-					self.pixel_depth
-				]
-		end
-	end
-	assert( nil ~= properties.color_format )
-
-	self.data = ""
-	self:encode_header(properties) -- header
 	-- no color map and image id data
-	self:encode_data(properties) -- encode data
+	self:encode_data() -- encode data
 	-- no extension or developer area
 	self:encode_footer() -- footer
 end
 
-function image:save(filename, properties)
+function image:save(filename)
-	self:encode(properties)
-
 	local f = assert(io.open(filename, "wb"))
 	f:write(self.data)
 	f:close()

mods/CORE/tga_encoder/logo.lua

@@ -1,51 +0,0 @@
-dofile("init.lua")
-
-local colormap = {
-	{   0,   0,   0 }, -- black
-	{ 255, 255, 255 }, -- white
-	{ 255,   0,   0 }, -- red
-	{   0, 255,   0 }, -- green
-	{   0,   0, 255 }, -- blue
-}
-
-local _ = { 0 }
-local W = { 1 }
-local R = { 2 }
-local G = { 3 }
-local B = { 4 }
-
-local pixels_tiny = {
-	{ W, W, W, W, W, W, W, W, W, W, W, W, },
-	{ W, _, _, _, _, _, _, _, _, _, _, W, },
-	{ W, _, _, _, _, _, _, B, _, B, _, W, },
-	{ W, _, _, _, _, _, _, B, B, B, _, W, },
-	{ W, _, _, _, G, G, G, B, _, B, _, W, },
-	{ W, _, _, _, G, _, G, B, B, B, _, W, },
-	{ W, _, _, R, G, _, _, _, _, _, _, W, },
-	{ W, _, _, R, G, G, G, _, _, _, _, W, },
-	{ W, _, _, R, _, _, _, _, _, _, _, W, },
-	{ W, _, R, R, R, _, _, _, _, _, _, W, },
-	{ W, _, _, _, _, _, _, _, _, _, _, W, },
-	{ W, W, W, W, W, W, W, W, W, W, W, W, },
-}
-
-local pixels_huge = {}
-
-local size_tiny = #pixels_tiny
-local size_huge = 1200
-local scale = size_huge / size_tiny
-
-for x_huge = 1,size_huge,1 do
-	local x_tiny = math.ceil( x_huge / scale )
-	for z_huge = 1,size_huge,1 do
-		local z_tiny = math.ceil( z_huge / scale )
-		if nil == pixels_huge[z_huge] then
-		   pixels_huge[z_huge] = {}
-		end
-		pixels_huge[z_huge][x_huge] = pixels_tiny[z_tiny][x_tiny]
-	end
-end
-
-tga_encoder.image(pixels_tiny):save("logo_tiny.tga", {colormap=colormap})
-tga_encoder.image(pixels_huge):save("logo_huge.tga", {colormap=colormap})
-

mods/CORE/tga_encoder/mod.conf

@@ -1,2 +1,3 @@
 name = tga_encoder
+author = Fleckenstein
 description = A TGA Encoder written in Lua without the use of external Libraries.

mods/CORE/tga_encoder/tools/generate_test_textures.lua

@@ -1,180 +0,0 @@
-#!/usr/bin/env lua5.1
-dofile("../init.lua")
-
-local _ = { 0 }
-local R = { 1 }
-local G = { 2 }
-local B = { 3 }
-
-local pixels_colormapped_bt = {
-	{ _, _, _, _, _, B, _, B, },
-	{ _, _, _, _, _, B, B, B, },
-	{ _, _, G, G, G, B, _, B, },
-	{ _, _, G, _, G, B, B, B, },
-	{ _, R, G, _, _, _, _, _, },
-	{ _, R, G, G, G, _, _, _, },
-	{ _, R, _, _, _, _, _, _, },
-	{ R, R, R, _, _, _, _, _, },
-}
-
-local pixels_colormapped_tb = {
-	{ R, R, R, _, _, _, _, _, },
-	{ _, R, _, _, _, _, _, _, },
-	{ _, R, G, G, G, _, _, _, },
-	{ _, R, G, _, _, _, _, _, },
-	{ _, _, G, _, G, B, B, B, },
-	{ _, _, G, G, G, B, _, B, },
-	{ _, _, _, _, _, B, B, B, },
-	{ _, _, _, _, _, B, _, B, },
-}
-
-image_colormapped_bt = tga_encoder.image(pixels_colormapped_bt)
-image_colormapped_tb = tga_encoder.image(pixels_colormapped_tb)
-
-colormap_32bpp = {
-	{    0,   0,   0, 128 },
-	{ 255,    0,   0, 255 },
-	{    0, 255,   0, 255 },
-	{    0,   0, 255, 255 },
-}
-image_colormapped_bt:save(
-	"type1_32bpp_bt.tga",
-	{ colormap = colormap_32bpp, color_format = "B8G8R8A8", scanline_order = "bottom-top" }
-)
-image_colormapped_tb:save(
-	"type1_32bpp_tb.tga",
-	{ colormap = colormap_32bpp, color_format = "B8G8R8A8", scanline_order = "top-bottom" }
-)
-image_colormapped_bt:save(
-	"type1_16bpp_bt.tga",
-	{ colormap = colormap_32bpp, color_format = "A1R5G5B5", scanline_order = "bottom-top" }
-)
-image_colormapped_tb:save(
-	"type1_16bpp_tb.tga",
-	{ colormap = colormap_32bpp, color_format = "A1R5G5B5", scanline_order = "top-bottom" }
-)
-
-colormap_24bpp = {
-	{    0,   0,   0 },
-	{ 255,    0,   0 },
-	{    0, 255,   0 },
-	{    0,   0, 255 },
-}
-image_colormapped_bt:save(
-	"type1_24bpp_bt.tga",
-	{ colormap = colormap_32bpp, color_format = "B8G8R8", scanline_order = "bottom-top" }
-)
-image_colormapped_tb:save(
-	"type1_24bpp_tb.tga",
-	{ colormap = colormap_32bpp, color_format = "B8G8R8", scanline_order = "top-bottom" }
-)
-
-local _ = {    0,   0,   0, 128 }
-local R = { 255,    0,   0, 255 }
-local G = {    0, 255,   0, 255 }
-local B = {    0,   0, 255, 255 }
-
-local pixels_rgba_bt = {
-	{ _, _, _, _, _, B, _, B, },
-	{ _, _, _, _, _, B, B, B, },
-	{ _, _, G, G, G, B, _, B, },
-	{ _, _, G, _, G, B, B, B, },
-	{ _, R, G, _, _, _, _, _, },
-	{ _, R, G, G, G, _, _, _, },
-	{ _, R, _, _, _, _, _, _, },
-	{ R, R, R, _, _, _, _, _, },
-}
-
-local pixels_rgba_tb = {
-	{ R, R, R, _, _, _, _, _, },
-	{ _, R, _, _, _, _, _, _, },
-	{ _, R, G, G, G, _, _, _, },
-	{ _, R, G, _, _, _, _, _, },
-	{ _, _, G, _, G, B, B, B, },
-	{ _, _, G, G, G, B, _, B, },
-	{ _, _, _, _, _, B, B, B, },
-	{ _, _, _, _, _, B, _, B, },
-}
-
-image_rgba_bt = tga_encoder.image(pixels_rgba_bt)
-image_rgba_tb = tga_encoder.image(pixels_rgba_tb)
-
-image_rgba_bt:save(
-	"type2_32bpp_bt.tga",
-	{ color_format="B8G8R8A8", compression="RAW", scanline_order = "bottom-top" }
-)
-image_rgba_tb:save(
-	"type2_32bpp_tb.tga",
-	{ color_format="B8G8R8A8", compression="RAW", scanline_order = "top-bottom" }
-)
-image_rgba_bt:save(
-	"type10_32bpp_bt.tga",
-	{ color_format="B8G8R8A8", compression="RLE", scanline_order = "bottom-top" }
-)
-image_rgba_tb:save(
-	"type10_32bpp_tb.tga",
-	{ color_format="B8G8R8A8", compression="RLE", scanline_order = "top-bottom" }
-)
-
-local _ = {    0,   0,   0 }
-local R = { 255,    0,   0 }
-local G = {    0, 255,   0 }
-local B = {    0,   0, 255 }
-
-local pixels_rgb_bt = {
-	{ _, _, _, _, _, B, _, B, },
-	{ _, _, _, _, _, B, B, B, },
-	{ _, _, G, G, G, B, _, B, },
-	{ _, _, G, _, G, B, B, B, },
-	{ _, R, G, _, _, _, _, _, },
-	{ _, R, G, G, G, _, _, _, },
-	{ _, R, _, _, _, _, _, _, },
-	{ R, R, R, _, _, _, _, _, },
-}
-
-local pixels_rgb_tb = {
-	{ R, R, R, _, _, _, _, _, },
-	{ _, R, _, _, _, _, _, _, },
-	{ _, R, G, G, G, _, _, _, },
-	{ _, R, G, _, _, _, _, _, },
-	{ _, _, G, _, G, B, B, B, },
-	{ _, _, G, G, G, B, _, B, },
-	{ _, _, _, _, _, B, B, B, },
-	{ _, _, _, _, _, B, _, B, },
-}
-
-image_rgb_bt = tga_encoder.image(pixels_rgb_bt)
-image_rgb_tb = tga_encoder.image(pixels_rgb_tb)
-
-image_rgb_bt:save(
-	"type2_24bpp_bt.tga",
-	{ color_format="B8G8R8", compression="RAW", scanline_order = "bottom-top" }
-)
-image_rgb_tb:save(
-	"type2_24bpp_tb.tga",
-	{ color_format="B8G8R8", compression="RAW", scanline_order = "top-bottom" }
-)
-image_rgb_bt:save(
-	"type10_24bpp_bt.tga",
-	{ color_format="B8G8R8", compression="RLE", scanline_order = "bottom-top" }
-)
-image_rgb_tb:save(
-	"type10_24bpp_tb.tga",
-	{ color_format="B8G8R8", compression="RLE", scanline_order = "top-bottom" }
-)
-image_rgb_bt:save(
-	"type2_16bpp_bt.tga",
-	{ color_format="A1R5G5B5", compression="RAW", scanline_order = "bottom-top" }
-)
-image_rgb_tb:save(
-	"type2_16bpp_tb.tga",
-	{ color_format="A1R5G5B5", compression="RAW", scanline_order = "top-bottom" }
-)
-image_rgb_bt:save(
-	"type10_16bpp_bt.tga",
-	{ color_format="A1R5G5B5", compression="RLE", scanline_order = "bottom-top" }
-)
-image_rgb_tb:save(
-	"type10_16bpp_tb.tga",
-	{ color_format="A1R5G5B5", compression="RLE", scanline_order = "top-bottom" }
-)

mods/ENTITIES/mcl_boats/init.lua

@@ -168,7 +168,7 @@ end
 
 
 function boat.on_activate(self, staticdata, dtime_s)
-	self.object:set_armor_groups({fleshy = 125})
+	self.object:set_armor_groups({fleshy = 100})
 	local data = minetest.deserialize(staticdata)
 	if type(data) == "table" then
 		self._v = data.v

mods/ENTITIES/mcl_boats/locale/mcl_boats.oc.tr

@@ -1,21 +0,0 @@
-# textdomain: mcl_boats
-Acacia Boat=Barca de Cacèir
-Birch Boat=Barca de Beç
-Boat=Barca
-Boats are used to travel on the surface of water.=Las barcas son utilizadas per voiatja per aigas.
-Dark Oak Boat=Barca de Ròure Nèir
-Jungle Boat=Barca d'Acajó
-Oak Boat=Barca de Ròure
-Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Use [Sneak] to leave the boat, punch the boat to make it drop as an item.=Fasetz un clic dreit sobre una sorça d'aiga per plaça la barca. Fasetz un clic dreit sobre la barca per rintrar. Utilizatz [Gaucha] e [Dreita] per menar, [Davant] per accelerar e [Darrèir] per ralentir o racuolar. Utilizatz [Sneak] per z-o quitar, tustatz la barca per z-o faire tombar coma objècte.
-Spruce Boat=Barca de Sap
-Water vehicle=Veïcule per aiga
-Sneak to dismount=Se baissar per descendre
-Obsidian Boat=Barca d'Obsidiana
-Mangrove Boat=Barca de Paletuvèir
-Oak Chest Boat=Barca de Ròure embei una Mala
-Spruce Chest Boat=Barca de Sap embei una Mala
-Birch Chest Boat=Barca de Beç embei una Mala
-Jungle Chest Boat=Barca d'Acajó embei una Mala
-Acacia Chest Boat=Barca de Cacèir embei una Mala
-Dark Oak Chest Boat=Barca de Ròure Nèir embei una Mala
-Mangrove Chest Boat=Barca de Paletuvèir embei una Mala

mods/ENTITIES/mcl_falling_nodes/locale/mcl_falling_nodes.oc.tr

@@ -1,3 +0,0 @@
-# textdomain: mcl_falling_nodes
-@1 was smashed by a falling anvil.=@1 a estat espotit per un enclutge
-@1 was smashed by a falling block.=@1 a estat espotit per un blòc

mods/ENTITIES/mcl_item_entity/init.lua

@@ -113,55 +113,6 @@ local function disable_physics(object, luaentity, ignore_check, reset_movement)
 	end
 end
 
-local function try_object_pickup(player, inv, object, checkpos)
-	if not inv then return end
-
-	local le = object:get_luaentity()
-
-	-- Check magnet timer
-	if not (le._magnet_timer >= 0) then return end
-	if not (le._magnet_timer < item_drop_settings.magnet_time) then return end
-
-	-- Don't try to collect again
-	if le._removed then return end
-
-	-- Ignore if itemstring is not set yet
-	if le.itemstring == "" then return end
-
-	-- Add what we can to the inventory
-	local itemstack = ItemStack(le.itemstring)
-	local leftovers = inv:add_item("main", itemstack )
-
-	check_pickup_achievements(object, player)
-
-	if leftovers:is_empty() then
-		-- Destroy entity
-		-- This just prevents this section to be run again because object:remove() doesn't remove the item immediately.
-		le.target = checkpos
-		le._removed = true
-
-		-- Stop the object
-		object:set_velocity(vector.zero())
-		object:set_acceleration(vector.zero())
-		object:move_to(checkpos)
-
-		-- Update sound pool
-		local name = player:get_player_name()
-		pool[name] = ( pool[name] or 0 ) + 1
-
-		-- Make sure the object gets removed
-		minetest.after(0.25, function()
-			--safety check
-			if object and object:get_luaentity() then
-				object:remove()
-			end
-		end)
-	else
-		-- Update entity itemstring
-		le.itemstring = leftovers:to_string()
-	end
-end
-
 minetest.register_globalstep(function(_)
 	tick = not tick
 
@@ -196,7 +147,40 @@ minetest.register_globalstep(function(_)
 					object:get_luaentity() and object:get_luaentity().name == "__builtin:item" and object:get_luaentity()._magnet_timer
 					and (object:get_luaentity()._insta_collect or (object:get_luaentity().age > item_drop_settings.age)) then
 
-					try_object_pickup( player, inv, object, checkpos )
+					if object:get_luaentity()._magnet_timer >= 0 and
+						object:get_luaentity()._magnet_timer < item_drop_settings.magnet_time and inv and
+						inv:room_for_item("main", ItemStack(object:get_luaentity().itemstring)) then
+
+						-- Collection
+						if not object:get_luaentity()._removed then
+							-- Ignore if itemstring is not set yet
+							if object:get_luaentity().itemstring ~= "" then
+								inv:add_item("main", ItemStack(object:get_luaentity().itemstring))
+
+								check_pickup_achievements(object, player)
+
+								-- Destroy entity
+								-- This just prevents this section to be run again because object:remove() doesn't remove the item immediately.
+								object:get_luaentity().target = checkpos
+								object:get_luaentity()._removed = true
+
+								object:set_velocity(vector.zero())
+								object:set_acceleration(vector.zero())
+
+								object:move_to(checkpos)
+
+								pool[name] = pool[name] + 1
+
+								minetest.after(0.25, function()
+									--safety check
+									if object and object:get_luaentity() then
+										object:remove()
+									end
+								end)
+							end
+						end
+					end
+
 				elseif not object:is_player() and object:get_luaentity() and object:get_luaentity().name == "mcl_experience:orb" then
 					local entity = object:get_luaentity()
 					entity.collector = player:get_player_name()

mods/ENTITIES/mcl_minecarts/functions.lua

@@ -135,33 +135,3 @@ function mcl_minecarts:get_rail_direction(pos_, dir, ctrl, old_switch, railtype)
 	end
 	return {x=0, y=0, z=0}
 end
-
-local plane_adjacents = {
-	vector.new(-1,0,0),
-	vector.new(1,0,0),
-	vector.new(0,0,-1),
-	vector.new(0,0,1),
-}
-
-function mcl_minecarts:get_start_direction(pos)
-	local dir
-	local i = 0
-	while (not dir and i < #plane_adjacents) do
-		i = i+1
-		local node = minetest.get_node_or_nil(vector.add(pos, plane_adjacents[i]))
-		if node ~= nil
-		and minetest.get_item_group(node.name, "rail") == 0
-		and minetest.get_item_group(node.name, "solid") == 1
-		and minetest.get_item_group(node.name, "opaque") == 1
-		then
-			dir = mcl_minecarts:check_front_up_down(pos, vector.multiply(plane_adjacents[i], -1), true)
-		end
-	end
-	return dir
-end
-
-function mcl_minecarts:set_velocity(obj, dir, factor)
-	obj._velocity = vector.multiply(dir, factor or 3)
-	obj._old_pos = nil
-	obj._punched = true
-end

mods/ENTITIES/mcl_minecarts/init.lua

@@ -241,7 +241,9 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 			if vector.equals(cart_dir, {x=0, y=0, z=0}) then
 				return
 			end
-			mcl_minecarts:set_velocity(self, cart_dir)
+			self._velocity = vector.multiply(cart_dir, 3)
+			self._old_pos = nil
+			self._punched = true
 			return
 		end
 
@@ -298,7 +300,9 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 		time_from_last_punch = math.min(time_from_last_punch, tool_capabilities.full_punch_interval)
 		local f = 3 * (time_from_last_punch / tool_capabilities.full_punch_interval)
 
-		mcl_minecarts:set_velocity(self, cart_dir, f)
+		self._velocity = vector.multiply(cart_dir, f)
+		self._old_pos = nil
+		self._punched = true
 	end
 
 	cart.on_activate_by_rail = on_activate_by_rail
@@ -466,7 +470,7 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 			return
 		end
 
-		local dir, last_switch, restart_pos = nil, nil, nil
+		local dir, last_switch = nil, nil
 		if not pos then
 			pos = self.object:get_pos()
 		end
@@ -493,9 +497,6 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 				minetest.swap_node(rou_pos, newnode)
 				mesecon.receptor_on(rou_pos)
 			end
-			if node.name == "mcl_minecarts:golden_rail_on" then
-				restart_pos = rou_pos
-			end
 			if node_old.name == "mcl_minecarts:detector_rail_on" then
 				local newnode = {name="mcl_minecarts:detector_rail", param2 = node_old.param2}
 				minetest.swap_node(rou_old, newnode)
@@ -646,14 +647,6 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 		if update.pos then
 			self.object:set_pos(pos)
 		end
-		
-		-- stopped on "mcl_minecarts:golden_rail_on"
-		if vector.equals(vel, {x=0, y=0, z=0}) and restart_pos then
-			local dir = mcl_minecarts:get_start_direction(restart_pos)
-			if dir then
-				mcl_minecarts:set_velocity(self, dir)
-			end
-		end
 	end
 
 	function cart:get_staticdata()
@@ -694,15 +687,7 @@ function mcl_minecarts.place_minecart(itemstack, pointed_thing, placer)
 	if le then
 		le._railtype = railtype
 	end
-	local cart_dir
+	local cart_dir = mcl_minecarts:get_rail_direction(railpos, {x=1, y=0, z=0}, nil, nil, railtype)
-	if node.name == "mcl_minecarts:golden_rail_on" then
-		cart_dir = mcl_minecarts:get_start_direction(railpos)
-	end
-	if cart_dir then
-		mcl_minecarts:set_velocity(le, cart_dir)
-	else
-		cart_dir = mcl_minecarts:get_rail_direction(railpos, {x=1, y=0, z=0}, nil, nil, railtype)
-	end
 	cart:set_yaw(minetest.dir_to_yaw(cart_dir))
 
 	local pname = ""

mods/ENTITIES/mcl_minecarts/locale/mcl_minecarts.oc.tr

@@ -1,36 +0,0 @@
-# textdomain: mcl_minecarts
-Minecart=Vagonet
-Minecarts can be used for a quick transportion on rails.=Los vagonet pòdon èsser utilizats per un transpòrt rapide per ralhs.
-Minecarts only ride on rails and always follow the tracks. At a T-junction with no straight way ahead, they turn left. The speed is affected by the rail type.=Los vagonets ròtlon mas per ralhs e seguisson totjorn la pista. A una joncion T embei ren davant, tòrnon a gaucha.
-You can place the minecart on rails. Right-click it to enter it. Punch it to get it moving.=Podètz plaçar le vagonet per ralhs. Fasetz un clic dreit dessobre per çai rentrar. Tustatz z-o per z-o faire bojar.
-To obtain the minecart, punch it while holding down the sneak key.=Per aver le vagonet, tustatz z-o embei la tocha sneak enfonçada.
-A minecart with TNT is an explosive vehicle that travels on rail.=Un vagonet embei TNT z-es un vagonet explosiu que voiatja per ralhs.
-Place it on rails. Punch it to move it. The TNT is ignited with a flint and steel or when the minecart is on an powered activator rail.=Plaçatz z-o per ralhs. Tustatz z-o per z-o desplaçar. La TNT z-es atubada embei un batifuòc o quand le vagonet z-es per un ralh d'activacion atubat.
-To obtain the minecart and TNT, punch them while holding down the sneak key. You can't do this if the TNT was ignited.=Per obtenèr le vagonet e la TNT, tustatz z-o embei la tocha sneak enfonçada. Podètz pas faire quo si la TNT z-es atubada.
-A minecart with furnace is a vehicle that travels on rails. It can propel itself with fuel.=Un vagonet embei un fornil z-es un veïcule que voiatja per ralhs. Pòt se propulsar embei dau carburant.
-Place it on rails. If you give it some coal, the furnace will start burning for a long time and the minecart will be able to move itself. Punch it to get it moving.=Plaçatz z-o per ralhs. Si li balhatz dau charbon, le fornil vai començar de borlar lòngtemps e porà rotlar. Tustatz z-o per z-o faire bojar.
-To obtain the minecart and furnace, punch them while holding down the sneak key.=Per obtener le vagonet e le fornil, tustatz z-o embei la tocha sneak enfonçada.
-Minecart with Chest=Vagonet embei una Mala
-Minecart with Furnace=Vagonet embei un Fornil
-Minecart with Command Block=Vagonet embei un Blòc de Comandas
-Minecart with Hopper=Vagonet embei un Embure
-Minecart with TNT=Vagonet embei de la TNT
-Place them on the ground to build your railway, the rails will automatically connect to each other and will turn into curves, T-junctions, crossings and slopes as needed.=Plaçatz z-o per sòu per construrre vostre chamin de fèrre, los ralhs se conectaron entre ilhs e faron de las corbas, de las junccions en T, en traversadas et en pentas au besonh.
-Rail=Ralh
-Rails can be used to build transport tracks for minecarts. Normal rails slightly slow down minecarts due to friction.=Los ralhs pòdon èsser utilizats per construrre los chamins de transpòrt per los vagonets. Los ralhs normaus ralentissons gentament los vagonet per causa de friccion.
-Powered Rail=Ralh Atubat
-Rails can be used to build transport tracks for minecarts. Powered rails are able to accelerate and brake minecarts.=Los ralhs pòdon èsser utilizats per construrre los chamins de transpòrt per los vagonets. Los ralhs atubats son per faire accelerar o frenar los vagonets.
-Without redstone power, the rail will brake minecarts. To make this rail accelerate minecarts, power it with redstone power.=Sens energia de pèirotge, le ralh vai frenar los vagonets. Per que le ralh accelera los vagonets, alimentatz z-o embei de l'energia de pèirotge.
-Activator Rail=Ralh d'Activacion
-Rails can be used to build transport tracks for minecarts. Activator rails are used to activate special minecarts.=Los ralhs pòdon èsser utilizats per construrre los chamins de transpòrt per los vagonets. Los ralhs d'activacion son utilizats per activar daus vagonets speciaus.
-To make this rail activate minecarts, power it with redstone power and send a minecart over this piece of rail.=Per activar le ralh, alimentatz z-o embei de l'energia de pèirotge e fasetz rotlar un vagonet per aqueste ralh.
-Detector Rail=Ralh de Deteccion
-Rails can be used to build transport tracks for minecarts. A detector rail is able to detect a minecart above it and powers redstone mechanisms.=Los ralhs pòdon èsser utilizats per construirre los chamins de transpòrt per los vagonets. Los ralhs de deteccion pòdon detectar un vagonet per ilhs e atubar un mecanisme de pèirotge.
-To detect a minecart and provide redstone power, connect it to redstone trails or redstone mechanisms and send any minecart over the rail.=Per detectar un vagonet e produrre de l'energia de pèirotge, conectatz le ralh a de la pèirotge e fasetz rotlar un vagonet per i-aul.
-Track for minecarts=Pista per vagonets
-Speed up when powered, slow down when not powered=Acceleratz quand z-es atubat, ralentissetz quand z-es pas atubat.
-Activates minecarts when powered=Activa los vagonets quand pas atubat.
-Emits redstone power when a minecart is detected=Emeta de l'energia de pèirotge quand un vagonet z-es detectat.
-Vehicle for fast travel on rails=Veicule per voiatjar vistament per ralhs.
-Can be ignited by tools or powered activator rail=Pòt èsser atubat embei daus otilhs o un ralh d'activacion
-Sneak to dismount=Se baissar per descendre

mods/ENTITIES/mcl_minecarts/rails.lua

@@ -112,22 +112,6 @@ register_rail("mcl_minecarts:golden_rail_on",
 				onstate = "mcl_minecarts:golden_rail_on",
 				rules = rail_rules_long,
 			},
-			effector = {
-				action_on = function(pos, node)
-					local dir = mcl_minecarts:get_start_direction(pos)
-					if not dir then return end
-					local objs = minetest.get_objects_inside_radius(pos, 1)
-					for _, o in pairs(objs) do
-						local l = o:get_luaentity()
-						local v = o:get_velocity()
-						if l and string.sub(l.name, 1, 14) == "mcl_minecarts:"
-						and v and vector.equals(v, vector.zero())
-						then
-							mcl_minecarts:set_velocity(l, dir)
-						end
-					end
-end,
-			},
 		},
 		drop = "mcl_minecarts:golden_rail",
 	},

mods/ENTITIES/mcl_mobs/breeding.lua

@@ -322,7 +322,7 @@ function mob_class:toggle_sit(clicker,p)
 		particle = "mobs_mc_wolf_icon_roam.png"
 		self.order = "roam"
 		self.state = "stand"
-		self.walk_chance = 50
+		self.walk_chance = default_walk_chance
 		self.jump = true
 		self:set_animation("stand")
 		-- TODO: Add sitting model

mods/ENTITIES/mcl_mobs/combat.lua

@@ -35,19 +35,14 @@ function mob_class:day_docile()
 	end
 end
 
--- get this mob to attack the object
+-- attack player/mob
-function mob_class:do_attack(object)
+function mob_class:do_attack(player)
 
 	if self.state == "attack" or self.state == "die" then
 		return
 	end
 
-
+	self.attack = player
-	if object:is_player() and not minetest.settings:get_bool("enable_damage") then
-		return
-	end
-
-	self.attack = object
 	self.state = "attack"
 
 	-- TODO: Implement war_cry sound without being annoying

mods/ENTITIES/mcl_mobs/init.lua

@@ -325,19 +325,12 @@ function mcl_mobs.register_mob(name, def)
 
 		_spawner = def._spawner,
 	}
+	minetest.register_entity(name, setmetatable(final_def,mcl_mobs.mob_class_meta))
 
 	if minetest.get_modpath("doc_identifier") ~= nil then
 		doc.sub.identifier.register_object(name, "basics", "mobs")
-
-		if def.unused ~= true then
-			doc.add_entry("mobs", name, {
-				name = def.description or name,
-				data = final_def,
-			})
-		end
 	end
 
-	minetest.register_entity(name, setmetatable(final_def,mcl_mobs.mob_class_meta))
 end -- END mcl_mobs.register_mob function
 
 
@@ -369,13 +362,12 @@ function mcl_mobs.register_arrow(name, def)
 		collisionbox = {0, 0, 0, 0, 0, 0}, -- remove box around arrows
 		timer = 0,
 		switch = 0,
-		_lifetime = def._lifetime or 7,
+		_lifetime = def._lifetime or 150,
 		owner_id = def.owner_id,
 		rotate = def.rotate,
-		on_punch = def.on_punch or function(self, puncher, time_from_last_punch, tool_capabilities, dir, damage)
+		on_punch = def.on_punch or function(self)
-			local vel = self.object:get_velocity():length()
+			local vel = self.object:get_velocity()
-			self.object:set_velocity({x=dir.x * vel, y=dir.y * vel, z=dir.z * vel})
+			self.object:set_velocity({x=vel.x * -1, y=vel.y * -1, z=vel.z * -1})
-			self._puncher = puncher
 		end,
 		collisionbox = def.collisionbox or {0, 0, 0, 0, 0, 0},
 		automatic_face_movement_dir = def.rotate
@@ -385,7 +377,7 @@ function mcl_mobs.register_arrow(name, def)
 
 		on_step = def.on_step or function(self, dtime)
 
-			self.timer = self.timer + dtime
+			self.timer = self.timer + 1
 
 			local pos = self.object:get_pos()
 
@@ -451,24 +443,24 @@ function mcl_mobs.register_arrow(name, def)
 
 			if self.hit_player or self.hit_mob or self.hit_object then
 
-				for _,object in pairs(minetest.get_objects_inside_radius(pos, 1.5)) do
+				for _,player in pairs(minetest.get_objects_inside_radius(pos, 1.5)) do
 
 					if self.hit_player
-					and object:is_player() then
+					and player:is_player() then
 
-						self.hit_player(self, object)
+						self.hit_player(self, player)
 						self.object:remove();
 						return
 					end
 
-					local entity = object:get_luaentity()
+					local entity = player:get_luaentity()
 
 					if entity
 					and self.hit_mob
 					and entity.is_mob == true
-					and (tostring(object) ~= self.owner_id or self.timer > 2)
+					and tostring(player) ~= self.owner_id
 					and entity.name ~= self.object:get_luaentity().name then
-						self.hit_mob(self, object)
+						self.hit_mob(self, player)
 						self.object:remove();
 						return
 					end
@@ -476,9 +468,9 @@ function mcl_mobs.register_arrow(name, def)
 					if entity
 					and self.hit_object
 					and (not entity.is_mob)
-					and (tostring(object) ~= self.owner_id or self.timer > 2)
+					and tostring(player) ~= self.owner_id
 					and entity.name ~= self.object:get_luaentity().name then
-						self.hit_object(self, object)
+						self.hit_object(self, player)
 						self.object:remove();
 						return
 					end

mods/ENTITIES/mcl_mobs/locale/mcl_mobs.oc.tr

@@ -1,13 +0,0 @@
-# textdomain: mcl_mobs
-Peaceful mode active! No monsters will spawn.=Mòde tranquile actiu! Gis de mostre vai aparèisser.
-This allows you to place a single mob.=Quo permet de plaça una creatura.
-Just place it where you want the mob to appear. Animals will spawn tamed, unless you hold down the sneak key while placing. If you place this on a mob spawner, you change the mob it spawns.=Plaçatz z-o a l'endreit que volètz veire la creatura aparèisser. Las bèstias seron dejà domesticadas, defòra si laissatz la tocha se baissar enfonçada. Si z-o plaçatz sobre un generator de creaturas, chamjatz la creatura generada.
-You need the “maphack” privilege to change the mob spawner.=Avètz besonh dau privilègi "maphack" per chamjar le generator de creaturas.
-Name Tag=Étiquette de nom
-A name tag is an item to name a mob.=Una etiqueta z-es un otilh per chamjar le nom de la creatura.
-Before you use the name tag, you need to set a name at an anvil. Then you can use the name tag to name a mob. This uses up the name tag.=Davant d'utilizar l'etiqueta, vos fau li botar un nom embei una enclutge. Après, podètz utilizar l'etiqueta per nomar una creatura. L'etiqueta pòt èsser utilizada un còp.
-Only peaceful mobs allowed!=Mas las creaturas pacificas son autorizadas!
-Give names to mobs=Balha daus noms a las creaturas
-Set name at anvil=Botar le nom embei l'enclutge
-Removes specified mobs except nametagged and tamed ones. For the second parameter, use nametagged/tamed to select only nametagged/tamed mobs, or a range to specify a maximum distance from the player.=Lèva las creaturas specifiadas defòra de las que son nomadas o domesticadas. Per le paramètre segònd, utilizar nomat/domesticat per mas seleccionar las creaturas nomadas/domesticadas, o una distança per specifiar la distança maximum embei li joairi.
-Default usage. Clearing hostile mobs. For more options please type: /help clearmobs=Usage par défaut. Lèva las creaturas ostilas. Per mai d'opcions, escriure : /help clearmobs

mods/ENTITIES/mcl_mobs/physics.lua

@@ -761,61 +761,6 @@ function mob_class:do_env_damage()
 		end
 	end
 
-	-- Cactus damage
-	local near = minetest.find_node_near(pos, 1, "mcl_core:cactus", true)
-	if not near and near ~= nil then
-		near = find_node_near({x=pos.x, y=pos.y-1, z=pos.z}, 1, "mcl_core:cactus", true)
-	end
-	if near then
-		-- is mob touching the cactus?
-		local dist = vector.distance(pos, near)
-		local dist_feet = vector.distance({x=pos.x, y=pos.y-1, z=pos.z}, near)
-		local large_mob = false
-		local medium_mob = false
-		if self.name == "mobs_mc:ender_dragon" or
-			self.name == "mobs_mc:ghast" or
-			self.name == "mobs_mc:guardian_elder" or
-			self.name == "mobs_mc:slime_big" or
-			self.name == "mobs_mc:magma_cube_big" or
-			self.name == "mobs_mc:wither" then
-
-			large_mob = true
-		elseif self.name == "mobs_mc:hoglin" or
-			self.name == "mobs_mc:zoglin" or
-			self.name == "mobs_mc:horse" or
-			self.name == "mobs_mc:skeleton_horse" or
-			self.name == "mobs_mc:zombie_horse" or
-			self.name == "mobs_mc:donkey" or
-			self.name == "mobs_mc:mule" or
-			self.name == "mobs_mc:iron_golem" or
-			self.name == "mobs_mc:polar_bear" or
-			self.name == "mobs_mc:spider" or
-			self.name == "mobs_mc:cave_spider" or
-			self.name == "mobs_mc:strider" then
-
-			medium_mob = true
-		end
-		if (not large_mob and not medium_mob and (dist < 1.03 or dist_feet < 1.6)) or (medium_mob and (dist < 1.165 or dist_feet < 1.73)) or (large_mob and (dist < 1.25 or dist_feet < 1.9)) then
-			if self.health ~= 0 then
-				self:damage_mob("cactus", 2)
-
-				if self:check_for_death("cactus", {type = "environment",
-						pos = pos, node = self.standing_in}) then
-					return true
-				end
-			end
-		end
-	end
-	-- is mob standing on the cactus?
-	if self.standing_on == "mcl_core:cactus" or self.standing_in == "mcl_core:cactus" or self.standing_under == "mcl_core:cactus" then
-		self:damage_mob("cactus", 2)
-
-		if self:check_for_death("cactus", {type = "environment",
-				pos = pos, node = self.standing_in}) then
-			return true
-		end
-	end
-
 	-- Drowning damage
 	if self.breath_max ~= -1 then
 		local drowning = false

mods/ENTITIES/mcl_mobs/spawning.lua

@@ -13,9 +13,10 @@ local get_node                     = minetest.get_node
 local get_item_group               = minetest.get_item_group
 local get_node_light               = minetest.get_node_light
 local find_nodes_in_area_under_air = minetest.find_nodes_in_area_under_air
-local mt_get_biome_name            = minetest.get_biome_name
+local get_biome_name               = minetest.get_biome_name
 local get_objects_inside_radius    = minetest.get_objects_inside_radius
 local get_connected_players        = minetest.get_connected_players
+local minetest_get_perlin          = minetest.get_perlin
 
 local math_random    = math.random
 local math_floor     = math.floor
@@ -96,6 +97,19 @@ local mobs_spawn = minetest.settings:get_bool("mobs_spawn", true) ~= false
 local spawn_protected = minetest.settings:get_bool("mobs_spawn_protected") ~= false
 local logging = minetest.settings:get_bool("mcl_logging_mobs_spawn",true)
 
+local noise_params = {
+	offset = 0,
+	scale  = 3,
+	spread = {
+		x = 301,
+		y = 50,
+		z = 304,
+	},
+	seed = 100,
+	octaves = 3,
+	persistence = 0.5,
+}
+
 -- THIS IS THE BIG LIST OF ALL BIOMES - used for programming/updating mobs
 -- Also used for missing parameter
 -- Please update the list when adding new biomes!
@@ -432,6 +446,7 @@ WARNING: BIOME INTEGRATION NEEDED -> How to get biome through lua??
 local spawn_dictionary = {}
 --this is where all of the spawning information  is kept for mobs that don't naturally spawn
 local non_spawn_dictionary = {}
+local summary_chance = 0
 
 function mcl_mobs:spawn_setup(def)
 	if not mobs_spawn then return end
@@ -493,6 +508,7 @@ function mcl_mobs:spawn_setup(def)
 		check_position   = check_position,
 		on_spawn         = on_spawn,
 	}
+	summary_chance = summary_chance + chance
 end
 
 function mcl_mobs:mob_light_lvl(mob_name, dimension)
@@ -596,8 +612,10 @@ function mcl_mobs:spawn_specific(name, dimension, type_of_spawning, biomes, min_
 	spawn_dictionary[key]["day_toggle"] = day_toggle
 	spawn_dictionary[key]["check_position"] = check_position
 
+	summary_chance = summary_chance + chance
 end
 
+
 local two_pi = 2 * math.pi
 local function get_next_mob_spawn_pos(pos)
 	-- TODO We should consider spawning something a little further away sporadically.
@@ -664,29 +682,7 @@ local function has_room(self,pos)
 	return true
 end
 
-mcl_mobs.custom_biomecheck = nil
 
-function mcl_mobs.register_custom_biomecheck(custom_biomecheck)
-	mcl_mobs.custom_biomecheck = custom_biomecheck
-end
-
-
-local function get_biome_name(pos)
-	if mcl_mobs.custom_biomecheck then
-		return mcl_mobs.custom_biomecheck (pos)
-	else
-		local gotten_biome = minetest.get_biome_data(pos)
-
-		if not gotten_biome then
-			return
-		end
-
-		gotten_biome = mt_get_biome_name(gotten_biome.biome)
-		--minetest.log ("biome: " .. dump(gotten_biome))
-
-		return gotten_biome
-	end
-end
 
 local function spawn_check(pos, spawn_def)
 	if not spawn_def or not pos then return end
@@ -696,10 +692,11 @@ local function spawn_check(pos, spawn_def)
 	local mob_def = minetest.registered_entities[spawn_def.name]
 	local mob_type = mob_def.type
 	local gotten_node = get_node(pos).name
-	if not gotten_node then return end
+	local gotten_biome = minetest.get_biome_data(pos)
 
-	local biome_name = get_biome_name(pos)
+	if not gotten_node or not gotten_biome then return end
-	if not biome_name then return end
+
+	gotten_biome = get_biome_name(gotten_biome.biome) --makes it easier to work with
 
 	local is_ground = minetest.get_item_group(gotten_node,"solid") ~= 0
 	if not is_ground then
@@ -717,9 +714,8 @@ local function spawn_check(pos, spawn_def)
 	if pos.y >= spawn_def.min_height
 			and pos.y <= spawn_def.max_height
 			and spawn_def.dimension == dimension
-			and biome_check(spawn_def.biomes, biome_name) then
+			and biome_check(spawn_def.biomes, gotten_biome) then
 
-		mcl_log("Spawn level 1 check - Passed")
 		if  (is_ground or spawn_def.type_of_spawning ~= "ground")
 				and (spawn_def.type_of_spawning ~= "ground" or not is_leaf)
 				and (not is_farm_animal(spawn_def.name) or is_grass)
@@ -729,7 +725,6 @@ local function spawn_check(pos, spawn_def)
 				and (spawn_def.check_position and spawn_def.check_position(pos) or spawn_def.check_position == nil)
 				and ( not spawn_protected or not minetest.is_protected(pos, "") ) then
 
-			mcl_log("Spawn level 2 check - Passed")
 			local gotten_light = get_node_light(pos)
 
 			if modern_lighting then
@@ -880,6 +875,8 @@ minetest.register_chatcommand("spawn_mob",{
 
 if mobs_spawn then
 
+	local perlin_noise
+
 	-- Get pos to spawn, x and z are randomised, y is range
 
 
@@ -976,21 +973,9 @@ if mobs_spawn then
 		return spawning_position
 	end
 
-	local cumulative_chance = nil
-	local mob_library_worker_table = nil
-	local function initialize_spawn_data()
-		if not mob_library_worker_table then
-			mob_library_worker_table = table_copy(spawn_dictionary)
-		end
-		if not cumulative_chance then
-			cumulative_chance = 0
-			for k, v in pairs(mob_library_worker_table) do
-				cumulative_chance = cumulative_chance + v.chance
-			end
-		end
-	end
-
 	local function spawn_a_mob(pos, cap_space_hostile, cap_space_non_hostile)
+		--create a disconnected clone of the spawn dictionary, prevents memory leak
+		local mob_library_worker_table = table_copy(spawn_dictionary)
 
 		local spawning_position = find_spawning_position(pos, FIND_SPAWN_POS_RETRIES)
 		if not spawning_position then
@@ -1003,25 +988,22 @@ if mobs_spawn then
 		--output_mob_stats(mob_counts_wide)
 
 		--grab mob that fits into the spawning location
-		--use random weighted choice with replacement to grab a mob, don't exclude any possibilities
+		--randomly grab a mob, don't exclude any possibilities
-		--shuffle table once every loop to provide equal inclusion probability to all mobs
+		perlin_noise = perlin_noise or minetest_get_perlin(noise_params)
-		--repeat grabbing a mob to maintain existing spawn rates
+		local noise = perlin_noise:get_3d(spawning_position)
-		local spawn_loop_counter = #mob_library_worker_table
+		local current_summary_chance = summary_chance
 
-		while spawn_loop_counter > 0 do
 		table.shuffle(mob_library_worker_table)
-			local mob_chance_offset = math_random(1, cumulative_chance)
+
+		while #mob_library_worker_table > 0 do
+			local mob_chance_offset = (math_round(noise * current_summary_chance + 12345) % current_summary_chance) + 1
 			local mob_index = 1
 			local mob_chance = mob_library_worker_table[mob_index].chance
 			local step_chance = mob_chance
 			while step_chance < mob_chance_offset do
 				mob_index = mob_index + 1
-				if mob_index <= #mob_library_worker_table then
 				mob_chance = mob_library_worker_table[mob_index].chance
 				step_chance = step_chance + mob_chance
-				else
-					break
-				end
 			end
 			--minetest.log(mob_def.name.." "..step_chance.. " "..mob_chance)
 
@@ -1106,7 +1088,8 @@ if mobs_spawn then
 				end
 
 			end
-			spawn_loop_counter = spawn_loop_counter - 1
+			current_summary_chance = current_summary_chance - mob_chance
+			table_remove(mob_library_worker_table, mob_index)
 		end
 	end
 
@@ -1118,7 +1101,6 @@ if mobs_spawn then
 
 		timer = timer + dtime
 		if timer < WAIT_FOR_SPAWN_ATTEMPT then return end
-		initialize_spawn_data()
 		timer = 0
 
 		local players = get_connected_players()

mods/ENTITIES/mcl_paintings/locale/mcl_paintings.oc.tr

@@ -1,2 +0,0 @@
-# textdomain:mcl_paintings
-Painting=Quadre

mods/ENTITIES/mobs_mc/LICENSE-media.md

@@ -305,9 +305,6 @@ Origin of those models:
     * `mobs_mc_rabbit_random.*.ogg` (CC0)
         * Changes were made.
         * Source: <https://freesound.org/people/Alshred/>
-* [epCode]
-    * `extra_mobs_hoglin*.ogg` (LGPL 3.0)
-        * Source: <https://git.minetest.land/epCode/extra_mobs/src/branch/master/sounds>
 
 Note: Many of these sounds have been more or less modified to fit the game.
 

mods/ENTITIES/mobs_mc/axolotl.lua

@@ -1,7 +1,6 @@
 local S = minetest.get_translator(minetest.get_current_modname())
 
 local axolotl = {
-	description = S("Axolotl"),
 	type = "animal",
 	spawn_class = "axolotl",
 	can_despawn = true,
@@ -172,7 +171,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-100,
+4000,
 3,
 water-16,
 water+1)

mods/ENTITIES/mobs_mc/bat.lua

@@ -150,7 +150,7 @@ mcl_mobs:spawn_specific(
 0,
 maxlight,
 20,
-100,
+5000,
 2,
 mcl_vars.mg_overworld_min,
 mobs_mc.water_level-1)

mods/ENTITIES/mobs_mc/blaze.lua

@@ -151,7 +151,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-1000,
+5000,
 3,
 mcl_vars.mg_nether_min,
 mcl_vars.mg_nether_max)

mods/ENTITIES/mobs_mc/chicken.lua

@@ -157,7 +157,7 @@ mcl_mobs:spawn_specific(
 },
 9,
 minetest.LIGHT_MAX+1,
-30, 100,
+30, 17000,
 3,
 mobs_mc.water_level,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/cod.lua

@@ -30,7 +30,6 @@ local S = minetest.get_translator(minetest.get_current_modname())
 --###################
 
 local cod = {
-	description = S("Cod"),
 	type = "animal",
 	spawn_class = "water_ambient",
 	can_despawn = true,
@@ -267,7 +266,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-750,
+4000,
 3,
 water-16,
 water+1)

mods/ENTITIES/mobs_mc/cow+mooshroom.lua

@@ -207,7 +207,7 @@ mcl_mobs:spawn_specific(
 9,
 minetest.LIGHT_MAX+1,
 30,
-80,
+17000,
 10,
 mobs_mc.water_level,
 mcl_vars.mg_overworld_max)
@@ -225,7 +225,7 @@ mcl_mobs:spawn_specific(
 9,
 minetest.LIGHT_MAX+1,
 30,
-80,
+17000,
 5,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/creeper.lua

@@ -136,7 +136,7 @@ mcl_mobs.register_mob("mobs_mc:creeper", {
 })
 
 mcl_mobs.register_mob("mobs_mc:creeper_charged", {
-	description = S("Charged Creeper"),
+	description = S("Creeper"),
 	type = "monster",
 	spawn_class = "hostile",
 	hp_min = 20,
@@ -407,7 +407,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 20,
-1000,
+16500,
 2,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/dolphin.lua

@@ -30,7 +30,6 @@ local S = minetest.get_translator(minetest.get_current_modname())
 --###################
 
 local dolphin = {
-	description = S("Dolphin"),
 	type = "animal",
 	spawn_class = "water",
 	can_despawn = true,
@@ -245,7 +244,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-70,
+4000,
 3,
 water-16,
 water+1)

mods/ENTITIES/mobs_mc/enderman.lua

@@ -668,7 +668,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-100,
+3000,
 12,
 mcl_vars.mg_end_min,
 mcl_vars.mg_end_max)
@@ -816,7 +816,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-100,
+19000,
 2,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)
@@ -833,7 +833,7 @@ mcl_mobs:spawn_specific(
 0,
 11,
 30,
-100,
+27500,
 4,
 mcl_vars.mg_nether_min,
 mcl_vars.mg_nether_max)
@@ -849,7 +849,7 @@ mcl_mobs:spawn_specific(
 0,
 11,
 30,
-100,
+5000,
 4,
 mcl_vars.mg_nether_min,
 mcl_vars.mg_nether_max)

mods/ENTITIES/mobs_mc/ghast.lua

@@ -20,7 +20,7 @@ mcl_mobs.register_mob("mobs_mc:ghast", {
 	hp_max = 10,
 	xp_min = 5,
 	xp_max = 5,
-	collisionbox = {-2, 0, -2, 2, 4, 2, rotate=true},
+	collisionbox = {-2, 5, -2, 2, 9, 2},
 	visual = "mesh",
 	mesh = "mobs_mc_ghast.b3d",
 	spawn_in_group = 1,
@@ -33,7 +33,7 @@ mcl_mobs.register_mob("mobs_mc:ghast", {
 		death = "mobs_mc_zombie_death",
 		attack = "mobs_fireball",
 		random = "mobs_eerie",
-		distance = 80,
+		distance = 16,
 		-- TODO: damage
 		-- TODO: better death
 	},
@@ -50,11 +50,11 @@ mcl_mobs.register_mob("mobs_mc:ghast", {
 		run_start = 0,		run_end = 40,
 	},
 	fall_damage = 0,
-	view_range = 64,
+	view_range = 100,
 	attack_type = "dogshoot",
 	arrow = "mobs_mc:fireball",
-	shoot_interval = 5,
+	shoot_interval = 3.5,
-	shoot_offset = -0.5,
+	shoot_offset = -5,
 	dogshoot_switch = 1,
 	dogshoot_count_max =1,
 	passive = false,
@@ -97,7 +97,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-400,
+72000,
 2,
 mcl_vars.mg_nether_min,
 mcl_vars.mg_nether_max)
@@ -107,9 +107,8 @@ mcl_mobs.register_arrow("mobs_mc:fireball", {
 	visual = "sprite",
 	visual_size = {x = 1, y = 1},
 	textures = {"mcl_fire_fire_charge.png"},
-	velocity = 5,
+	velocity = 15,
 	collisionbox = {-.5, -.5, -.5, .5, .5, .5},
-	_lifetime = 10,
 	_is_fireball = true,
 
 	hit_player = function(self, player)
@@ -131,10 +130,6 @@ mcl_mobs.register_arrow("mobs_mc:fireball", {
 			damage_groups = {fleshy = 6},
 		}, nil)
 		mcl_mobs.mob_class.boom(self,self.object:get_pos(), 1, true)
-		local ent = mob:get_luaentity()
-		if not ent or ent.health <= 0 then
-			awards.unlock(self._puncher:get_player_name(), "mcl:fireball_redir_serv")
-		end
 	end,
 
 	hit_node = function(self, pos, node)

mods/ENTITIES/mobs_mc/glow_squid.lua

@@ -30,7 +30,6 @@ for i=1,4 do
 end
 
 mcl_mobs.register_mob("mobs_mc:glow_squid", {
-	description = S("Glow Squid"),
 	type = "animal",
 	spawn_class = "water_underground",
 	can_despawn = true,
@@ -238,7 +237,7 @@ mcl_mobs:spawn_specific(
 		0,
 		minetest.LIGHT_MAX + 1,
 		30,
-		100,
+		10000,
 		3,
 		water - 16,
 		water)

mods/ENTITIES/mobs_mc/hoglin+zoglin.lua

@@ -31,9 +31,8 @@ local hoglin = {
 	} },
 	visual_size = {x=3, y=3},
 	sounds = {
-		random = "extra_mobs_hoglin.1",
+		random = "extra_mobs_hoglin",
 		damage = "extra_mobs_hoglin_hurt",
-		death = "extra_mobs_hoglin_hurt",
 		distance = 16,
 	},
 	jump = true,
@@ -93,12 +92,6 @@ local zoglin = table.copy(hoglin)
 zoglin.description = S("Zoglin")
 zoglin.fire_resistant = 1
 zoglin.textures = {"extra_mobs_zoglin.png"}
-sounds = {
-		random = "extra_mobs_hoglin.2",
-		damage = "extra_mobs_hoglin_hurt",
-		death = "extra_mobs_hoglin_hurt",
-		distance = 16,
-        }
 zoglin.do_custom = function()
 	return
 end
@@ -136,7 +129,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-200,
+6000,
 3,
 mcl_vars.mg_nether_min,
 mcl_vars.mg_nether_max)

mods/ENTITIES/mobs_mc/horse.lua

@@ -609,7 +609,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-40,
+15000,
 4,
 mobs_mc.water_level+3,
 mcl_vars.mg_overworld_max)
@@ -632,7 +632,7 @@ mcl_mobs:spawn_specific(
 9,
 minetest.LIGHT_MAX+1,
 30,
-10,
+15000,
 4,
 mobs_mc.water_level+3,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/llama.lua

@@ -291,7 +291,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-50,
+15000,
 5,
 mobs_mc.water_level+15,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/locale/mobs_mc.oc.tr

@@ -1,73 +0,0 @@
-# textdomain: mobs_mc
-Agent=Agent
-Axolotl=Axolòtl
-Bat=Ratapenada
-Blaze=Flamor
-Chicken=Polet
-Cow=Vacha
-Mooshroom=Vachairòla
-Creeper=Creeper
-Ender Dragon=Dragon de Finuèit
-Enderman=Finuèairi
-Endermite=Finuèibau
-Ghast=Òrra
-Elder Guardian=Ancian Gardian
-Guardian=Gardian
-Horse=Ega
-Skeleton Horse=Ega Squeleta
-Zombie Horse=Ega Zombia
-Donkey=Asne
-Mule=Miule
-Iron Golem=Golem de Fèrre
-Llama=Lamà
-Ocelot=Ocelòt
-Parrot=Papagai
-Pig=Cochon
-Polar Bear=Ors Blanc
-Rabbit=Lapin
-Killer Bunny=Lapin Tuaire
-Sheep=Moton
-Shulker=Coirafin
-Silverfish=Peiçon d'Argent
-Skeleton=Squeleta
-Stray=Trainabiaça
-Wither Skeleton=Squeleta Sechaire
-Magma Cube=Cube de Magmà
-Slime=Slime
-Snow Golem=Golem d'Ivèrn
-Spider=Aranha
-Cave Spider=Aranha Venimósa
-Squid=Pofre
-Vex=Vex
-Evoker=Invocataire
-Illusioner=Fisiciaire
-Villager=Vialatgés
-Vindicator=Vindicataire
-Zombie Villager=Vialatgés Zombia
-Witch=Fachinèira
-Wither=Le Sechaire
-Wolf=Lop
-Husk=Zombia Momificat
-Zombie=Zombia
-Zombie Piglin=Porcadés Zombia
-Farmer=Boriaire
-Fisherman=Peschaire
-Fletcher=Archèir
-Shepherd=Bergèir
-Librarian=Bibliotecaire
-Cartographer=Cartografe
-Armorer=Armurèir
-Leatherworker=Tanaire
-Butcher=Maselèir
-Weapon Smith=Farjaire d'Armas
-Tool Smith=Farjaire d'Otilhs
-Cleric=Clerc
-Nitwit=Simple
-Cod=Merluça
-Salmon=Saumon
-Dolphin=Daufin
-Pillager=Pilhard
-Tropical fish=Peiçon tropicau
-Hoglin=Porcard
-Strider=Trèva
-Glow Squid=Pofre Lusent

mods/ENTITIES/mobs_mc/ocelot.lua

@@ -186,7 +186,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-300,
+15000,
 5,
 mobs_mc.water_level+15,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/parrot.lua

@@ -235,7 +235,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 7,
-400,
+30000,
 1,
 mobs_mc.water_level+7,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/pig.lua

@@ -258,7 +258,7 @@ mcl_mobs:spawn_specific(
 9,
 minetest.LIGHT_MAX+1,
 30,
-100,
+15000,
 8,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/piglin.lua

@@ -16,13 +16,6 @@ local trading_items = {
 	{ 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 },
-	{ itemstring = "mcl_enchanting:book_enchanted", amount_min = 1, amount_max = 1 },
-	{ itemstring = "mcl_armor:boots_iron_enchanted", amount_min = 1, amount_max = 1 },
-	{ itemstring = "mcl_blackstone:blackstone", amount_min = 8, amount_max = 16 },
-	{ itemstring = "mcl_bows:arrow", amount_min = 6, amount_max = 12 },
-	{ itemstring = "mcl_core:crying_obsidian", amount_min = 1, amount_max = 1 },
-	{ itemstring = "mcl_fire:fire_charge", amount_min = 1, amount_max = 1 },
-	--{ itemstring = "FIXME:spectral_arrow", amount_min = 6, amount_max = 12 },
 }
 
 local S = minetest.get_translator("mobs_mc")
@@ -68,10 +61,8 @@ local piglin = {
 	} },
 	visual_size = {x=1, y=1},
 	sounds = {
-		random = "mobs_mc_zombiepig_random",
+		random = "extra_mobs_piglin",
-		war_cry = "mobs_mc_zombiepig_war_cry",                  death = "mobs_mc_zombiepig_death",
+		damage = "extra_mobs_piglin_hurt",
-		damage = "mobs_mc_zombiepig_hurt.2",
-		death = "mobs_mc_zombiepig_death.2",
 		distance = 16,
 	},
 	jump = true,
@@ -149,18 +140,14 @@ local piglin = {
 				local c_pos = self.object:get_pos()
 				if c_pos then
 					self.what_traded = trading_items[math.random(#trading_items)]
-					local stack = ItemStack(self.what_traded.itemstring)
+					for x = 1, math.random(self.what_traded.amount_min, self.what_traded.amount_max) do
-					stack:set_count(math.random(self.what_traded.amount_min, self.what_traded.amount_max))
-					if mcl_enchanting.is_enchanted(self.what_traded.itemstring) then
-						local enchantment = "soul_speed"
-						mcl_enchanting.enchant(stack, enchantment, mcl_enchanting.random(nil, 1, mcl_enchanting.enchantments[enchantment].max_level))
-					end
 						local p = c_pos
 						local nn=minetest.find_nodes_in_area_under_air(vector.offset(c_pos,-1,-1,-1),vector.offset(c_pos,1,1,1),{"group:solid"})
 						if nn and #nn > 0 then
 							p = vector.offset(nn[math.random(#nn)],0,1,0)
 						end
-					minetest.add_item(p, stack)
+						minetest.add_item(p, self.what_traded.itemstring)
+					end
 				end
 			end)
 		end
@@ -343,13 +330,8 @@ mcl_mobs.register_mob("mobs_mc:baby_zombified_piglin", baby_zombified_piglin)
 
 -- Compatibility code. These were removed, and now are called zombie piglins. They don't spawn.
 -- This is only to catch old cases. Maybe could be an alias?
-local pigman_unused = table.copy(zombified_piglin)
+mcl_mobs.register_mob("mobs_mc:pigman", zombified_piglin)
-pigman_unused.unused = true
+mcl_mobs.register_mob("mobs_mc:baby_pigman", baby_zombified_piglin)
-local baby_pigman_unused = table.copy(baby_zombified_piglin)
-baby_pigman_unused.unused = true
-
-mcl_mobs.register_mob("mobs_mc:pigman", pigman_unused)
-mcl_mobs.register_mob("mobs_mc:baby_pigman", baby_pigman_unused)
 
 
 -- Piglin Brute --
@@ -415,7 +397,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-150,
+6000,
 3,
 mcl_vars.mg_lava_nether_max,
 mcl_vars.mg_nether_max)
@@ -431,7 +413,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-150,
+6000,
 3,
 mcl_vars.mg_lava_nether_max,
 mcl_vars.mg_nether_max)
@@ -447,7 +429,7 @@ mcl_mobs:spawn_specific(
 		0,
 		minetest.LIGHT_MAX+1,
 		30,
-		1000,
+		6000,
 		3,
 		mcl_vars.mg_nether_min,
 		mcl_vars.mg_nether_max)
@@ -464,7 +446,7 @@ mcl_mobs:spawn_specific(
 		0,
 		minetest.LIGHT_MAX+1,
 		30,
-		50,
+		100000,
 		4,
 		mcl_vars.mg_nether_min,
 		mcl_vars.mg_nether_max)

mods/ENTITIES/mobs_mc/polar_bear.lua

@@ -86,7 +86,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-50,
+7000,
 3,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/rabbit.lua

@@ -148,7 +148,7 @@ mcl_mobs:spawn_specific(
 9,
 minetest.LIGHT_MAX+1,
 30,
-40,
+15000,
 8,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/salmon.lua

@@ -10,7 +10,6 @@ local S = minetest.get_translator(minetest.get_current_modname())
 --###################
 
 local salmon = {
-	description = S("Salmon"),
 	type = "animal",
 	spawn_class = "water_ambient",
 	can_despawn = true,
@@ -221,7 +220,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-260,
+4000,
 3,
 water-16,
 water+1)

mods/ENTITIES/mobs_mc/sheep.lua

@@ -379,7 +379,7 @@ mcl_mobs:spawn_specific(
 9,
 minetest.LIGHT_MAX+1,
 30,
-120,
+15000,
 3,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/skeleton+stray.lua

@@ -44,13 +44,6 @@ local skeleton = {
 			"mcl_bows_bow_0.png", -- wielded_item
 		}
 	},
-	-- TODO: change random to new api when min minetest version is 5.8
-	sounds = {
-		random = "mobs_mc_skeleton_random.2",
-		death = "mobs_mc_skeleton_death",
-		damage = "mobs_mc_skeleton_hurt",
-		distance = 16,
-	},
 	walk_velocity = 1.2,
 	run_velocity = 2.0,
 	damage = 2,
@@ -306,7 +299,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 20,
-800,
+17000,
 2,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)
@@ -323,7 +316,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-800,
+10000,
 3,
 mcl_vars.mg_nether_min,
 mcl_vars.mg_nether_max)
@@ -343,7 +336,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 20,
-1200,
+19000,
 2,
 mobs_mc.water_level,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/skeleton_wither.lua

@@ -37,7 +37,7 @@ mcl_mobs.register_mob("mobs_mc:witherskeleton", {
 	visual_size = {x=1.2, y=1.2},
 	makes_footstep_sound = true,
 	sounds = {
-		random = "mobs_mc_skeleton_random.1",
+		random = "mobs_mc_skeleton_random",
 		death = "mobs_mc_skeleton_death",
 		damage = "mobs_mc_skeleton_hurt",
 		distance = 16,
@@ -116,7 +116,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-500,
+5000,
 5,
 mcl_vars.mg_nether_min,
 mcl_vars.mg_nether_max)

mods/ENTITIES/mobs_mc/slime+magma_cube.lua

@@ -6,7 +6,6 @@ local MAPBLOCK_SIZE = 16
 local seed = minetest.get_mapgen_setting("seed")
 
 local slime_chunk_match
-local slime_chunk_spawn_max = mcl_worlds.layer_to_y(40)
 local x_modifier
 local z_modifier
 
@@ -167,16 +166,16 @@ local swamp_light_max = 7
 local function slime_spawn_check(pos, environmental_light, artificial_light, sky_light)
 	local maxlight = swamp_light_max
 
-	if pos.y <= slime_chunk_spawn_max and is_slime_chunk(pos) then
+	if is_slime_chunk(pos) then
 		maxlight = minetest.LIGHT_MAX + 1
 	end
 
-	return math.max(artificial_light, sky_light) <= maxlight
+	return artificial_light <= maxlight
 end
 
 -- Slime
 local slime_big = {
-	description = S("Slime - big"),
+	description = S("Slime"),
 	type = "monster",
 	spawn_class = "hostile",
 	group_attack = { "mobs_mc:slime_big", "mobs_mc:slime_small", "mobs_mc:slime_tiny" },
@@ -231,7 +230,6 @@ local slime_big = {
 mcl_mobs.register_mob("mobs_mc:slime_big", slime_big)
 
 local slime_small = table.copy(slime_big)
-slime_small.description = S("Slime - small")
 slime_small.sounds.base_pitch = 1.15
 slime_small.hp_min = 4
 slime_small.hp_max = 4
@@ -249,7 +247,6 @@ slime_small.on_die = spawn_children_on_die("mobs_mc:slime_tiny", 0.6, 1.0)
 mcl_mobs.register_mob("mobs_mc:slime_small", slime_small)
 
 local slime_tiny = table.copy(slime_big)
-slime_tiny.description = S("Slime - tiny")
 slime_tiny.sounds.base_pitch = 1.3
 slime_tiny.hp_min = 1
 slime_tiny.hp_max = 1
@@ -324,7 +321,7 @@ cave_biomes,
 0,
 minetest.LIGHT_MAX+1,
 30,
-1000,
+12000,
 4,
 cave_min,
 cave_max,
@@ -338,7 +335,7 @@ swampy_biomes,
 0,
 swamp_light_max,
 30,
-1000,
+12000,
 4,
 swamp_min,
 swamp_max)
@@ -351,7 +348,7 @@ cave_biomes,
 0,
 minetest.LIGHT_MAX+1,
 30,
-1000,
+8500,
 4,
 cave_min,
 cave_max,
@@ -365,7 +362,7 @@ swampy_biomes,
 0,
 swamp_light_max,
 30,
-1000,
+8500,
 4,
 swamp_min,
 swamp_max)
@@ -378,7 +375,7 @@ cave_biomes,
 0,
 minetest.LIGHT_MAX+1,
 30,
-1000,
+10000,
 4,
 cave_min,
 cave_max,
@@ -392,14 +389,14 @@ swampy_biomes,
 0,
 swamp_light_max,
 30,
-1000,
+10000,
 4,
 swamp_min,
 swamp_max)
 
 -- Magma cube
 local magma_cube_big = {
-	description = S("Magma Cube - big"),
+	description = S("Magma Cube"),
 	type = "monster",
 	spawn_class = "hostile",
 	hp_min = 16,
@@ -460,7 +457,6 @@ local magma_cube_big = {
 mcl_mobs.register_mob("mobs_mc:magma_cube_big", magma_cube_big)
 
 local magma_cube_small = table.copy(magma_cube_big)
-magma_cube_small.description = S("Magma Cube - small")
 magma_cube_small.sounds.jump = "mobs_mc_magma_cube_small"
 magma_cube_small.sounds.death = "mobs_mc_magma_cube_small"
 magma_cube_small.hp_min = 4
@@ -482,7 +478,6 @@ magma_cube_small.on_die = spawn_children_on_die("mobs_mc:magma_cube_tiny", 0.6,
 mcl_mobs.register_mob("mobs_mc:magma_cube_small", magma_cube_small)
 
 local magma_cube_tiny = table.copy(magma_cube_big)
-magma_cube_tiny.description = S("Magma Cube - tiny")
 magma_cube_tiny.sounds.jump = "mobs_mc_magma_cube_small"
 magma_cube_tiny.sounds.death = "mobs_mc_magma_cube_small"
 magma_cube_tiny.sounds.base_pitch = 1.25
@@ -517,7 +512,7 @@ magma_cube_biomes,
 0,
 minetest.LIGHT_MAX+1,
 30,
-100,
+15000,
 4,
 nether_min,
 nether_max)
@@ -530,7 +525,7 @@ magma_cube_biomes,
 0,
 minetest.LIGHT_MAX+1,
 30,
-100,
+15500,
 4,
 nether_min,
 nether_max)
@@ -543,7 +538,7 @@ magma_cube_biomes,
 0,
 minetest.LIGHT_MAX+1,
 30,
-100,
+16000,
 4,
 nether_min,
 nether_max)

mods/ENTITIES/mobs_mc/spider.lua

@@ -287,7 +287,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-1000,
+17000,
 2,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/squid.lua

@@ -211,7 +211,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-80,
+5500,
 3,
 water-16,
 water+1)

mods/ENTITIES/mobs_mc/strider.lua

@@ -11,7 +11,6 @@ local S = minetest.get_translator("mobs_mc")
 
 
 local strider = {
-	description = S("Strider"),
 	type = "animal",
 	passive = true,
 	spawn_class = "passive",
@@ -31,8 +30,6 @@ local strider = {
 	} },
 	visual_size = {x=3, y=3},
 	sounds = {
-		eat = "mobs_mc_animal_eat_generic",
-		distance = 16,
 	},
 	jump = true,
 	makes_footstep_sound = true,
@@ -54,7 +51,6 @@ local strider = {
 		walk_start = 1,
 		walk_end = 20,
 	},
-	follow = { "mcl_crimson:warped_fungus" },
 	lava_damage = 0,
 	fire_damage = 0,
 	light_damage = 0,
@@ -71,13 +67,8 @@ local strider = {
 	do_custom = function(self, dtime)
 
 		if minetest.find_node_near(self.object:get_pos(), 2, {"mcl_core:lava_source","mcl_core:lava_flowing","mcl_nether:nether_lava_source","mcl_nether:nether_lava_flowing"}) then
-			if self.driver then
-				self.walk_velocity = 4
-				self.run_velocity = 8
-			else
 			self.walk_velocity = 2
 			self.run_velocity = 4
-			end
 			self.base_texture[1] = "extra_mobs_strider.png"
 			self.shaking = false
 		else
@@ -131,7 +122,7 @@ local strider = {
 
 		local wielditem = clicker:get_wielded_item()
 
-		if wielditem:get_name() == "mcl_crimson:warped_fungus" then
+		if wielditem:get_name() ~= "mcl_crimson:warped_fungus" then
 			if self:feed_tame(clicker, 1, true, true) then return end
 		end
 
@@ -206,7 +197,6 @@ mcl_mobs.register_mob("mobs_mc:strider", strider)
 -- Baby strider.
 
 local baby_strider = table.copy(strider)
-baby_strider.description = S("Baby Strider")
 baby_strider.collisionbox = {-.3, -0.01, -.3, .3, 0.94, .3}
 baby_strider.xp_min = 13
 baby_strider.xp_max = 13
@@ -216,7 +206,7 @@ textures = { {
 } }
 baby_strider.walk_velocity = 1.2
 baby_strider.run_velocity = 2.4
-baby_strider.child = true
+baby_strider.child = 1
 
 mcl_mobs.register_mob("mobs_mc:baby_strider", baby_strider)
 
@@ -235,7 +225,7 @@ mcl_mobs:spawn_setup({
 	},
 	min_height = mcl_vars.mg_nether_min,
 	max_height = mcl_vars.mg_nether_max,
-	chance = 200,
+	chance = 2000,
 })
 
 mcl_mobs:spawn_setup({
@@ -251,7 +241,7 @@ mcl_mobs:spawn_setup({
 	},
 	min_height = mcl_vars.mg_nether_min,
 	max_height = mcl_vars.mg_nether_max,
-	chance = 20,
+	chance = 100,
 })
 
 -- spawn eggs

mods/ENTITIES/mobs_mc/tropical_fish.lua

@@ -58,7 +58,6 @@ local function set_textures(self)
 end
 
 local tropical_fish = {
-	description = S("Tropical Fish"),
 	type = "animal",
 	spawn_class = "water_ambient",
 	can_despawn = true,
@@ -184,7 +183,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-750,
+4000,
 3,
 water-16,
 water+1)

mods/ENTITIES/mobs_mc/villager.lua

@@ -1989,17 +1989,6 @@ local trade_inventory = {
 					-- Otherwise, 20% chance to unlock if used freshly reset trade
 					unlock_stuff = true
 				end
-				-- calculate xp based on the price
-				local emeralds = 0
-				if wanted1:get_name() == "mcl_core:emerald" then
-					emeralds = wanted1:get_count()
-				elseif wanted2:get_name() == "mcl_core:emerald" then
-					emeralds = wanted2:get_count()
-				else
-					local offered = inv:get_stack("offered", 1)
-					emeralds = offered:get_name() == "mcl_core:emerald" and offered:get_count() or 0
-				end
-				local xp = 2 + math.ceil(emeralds / (64/4)) -- 1..64 emeralds = 3..6 xp
 				local update_formspec = false
 				if unlock_stuff then
 					-- First-time trade unlock all trades and unlock next trade tier
@@ -2011,7 +2000,6 @@ local trade_inventory = {
 						set_textures(trader)
 						update_max_tradenum(trader)
 						update_formspec = true
-						xp = xp + 5
 					end
 					for t=1, #trades do
 						trades[t].locked = false
@@ -2022,7 +2010,6 @@ local trade_inventory = {
 					-- TODO: Replace by Regeneration I
 					trader.health = math.min(trader.hp_max, trader.health + 4)
 				end
-				mcl_experience.add_xp(player, xp)
 				trade.trade_counter = trade.trade_counter + 1
 				mcl_log("Trade counter is: ".. trade.trade_counter)
 				-- Semi-randomly lock trade for repeated trade (not if there's only 1 trade)
@@ -2060,7 +2047,6 @@ local trade_inventory = {
 				if update_formspec then
 					show_trade_formspec(name, trader, tradenum)
 				end
-
 			else
 				minetest.log("error", "[mobs_mc] Player took item from trader output but player_trading_with or player_tradenum is nil!")
 			end
@@ -2350,7 +2336,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-2,
+20,
 4,
 mobs_mc.water_level+1,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/villager_zombie.lua

@@ -225,7 +225,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-50,
+4090,
 4,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/wither.lua

@@ -437,7 +437,7 @@ mcl_mobs.register_mob("mobs_mc:wither", {
 
 })
 
-local wither_rose_soil = { "group:grass_block", "mcl_core:dirt", "mcl_core:coarse_dirt", "mcl_nether:netherrack", "group:soul_block", "mcl_mud:mud", "mcl_moss:moss" }
+local wither_rose_soil = { "group:grass_block", "mcl_core:dirt", "mcl_core:coarse_dirt", "mcl_nether:netherrack", "group:soul_block", "mcl_mud:mud", "mcl_lush_caves:moss" }
 local function spawn_wither_rose(obj)
 	local n = minetest.find_node_near(obj:get_pos(),2,wither_rose_soil)
 	if n then
@@ -463,7 +463,7 @@ mcl_mobs.register_arrow("mobs_mc:wither_skull", {
 	},
 	velocity = 7,
 	rotate = 90,
-	_lifetime = 15,
+	_lifetime = 350,
 	on_punch = function(self) end,
 
 	-- direct hit
@@ -516,7 +516,7 @@ mcl_mobs.register_arrow("mobs_mc:wither_skull_strong", {
 	},
 	velocity = 4,
 	rotate = 90,
-	_lifetime = 25,
+	_lifetime = 500,
 	on_punch = function(self) end,
 
 	-- direct hit

mods/ENTITIES/mobs_mc/wolf.lua

@@ -135,7 +135,6 @@ end
 
 -- Tamed wolf (aka “dog”)
 local dog = table.copy(wolf)
-dog.description = S("Dog")
 dog.can_despawn = false
 dog.passive = true
 dog.hp_min = 20
@@ -225,7 +224,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-80,
+9000,
 7,
 mobs_mc.water_level+3,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/zombie.lua

@@ -243,7 +243,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-1000,
+6000,
 4,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)
@@ -332,7 +332,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-50,
+60000,
 4,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)
@@ -348,7 +348,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-2400,
+6500,
 4,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)
@@ -362,7 +362,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-120,
+65000,
 4,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/HELP/doc/doc/init.lua

@@ -53,7 +53,7 @@ doc.data = {}
 doc.data.categories = {}
 doc.data.aliases = {}
 -- Default order (includes categories of other mods from the Docuentation System modpack)
-doc.data.category_order = {"basics", "nodes", "tools", "craftitems", "advanced", "mobs"}
+doc.data.category_order = {"basics", "nodes", "tools", "craftitems", "advanced"}
 doc.data.category_count = 0
 doc.data.players = {}
 

mods/HELP/doc/doc_identifier/init.lua

@@ -116,11 +116,7 @@ function doc_identifier.identify(itemstack, user, pointed_thing)
 				end
 			-- A known registered object
 			elseif ro then
-				if doc.entry_exists("mobs", le.name) then
-					doc.show_entry(username, "mobs", le.name, true)
-				else
 				doc.show_entry(username, ro.category, ro.entry, true)
-				end
 			-- Undefined object (error)
 			elseif minetest.registered_entities[le.name] == nil then
 				show_message(username, "error_unknown", le.name)

mods/HELP/doc/doc_items/init.lua

@@ -1136,86 +1136,6 @@ doc.add_category("craftitems", {
 	end
 })
 
-doc.add_category("mobs", {
-	name = S("Mobs"),
-	description = S("different mobs"),
-	build_formspec = function(data, playername)
-		if data then
-			local datastring = ""
-
-			if data.description then
-				datastring = datastring .. S("Description: @1", data.description)
-				datastring = newline2(datastring)
-			end
-
-			if data.type then
-				datastring = datastring .. S("Type: @1", data.type)
-				datastring = newline2(datastring)
-			end
-			
-			if data.spawn_class then
-				datastring = datastring .. S("spawn class: @1", data.spawn_class)
-				datastring = newline2(datastring)
-			end
-
-			if data.jump then
-				datastring = datastring .. S("Can Jump")
-				datastring = newline2(datastring)
-			end
-
-			if data.fly then
-				datastring = datastring .. S("Can Fly")
-				datastring = newline2(datastring)
-			end
-			
-			if data.drops then
-				count = 0
-				for _,item in ipairs(data.drops) do
-					count = count + 1
-				end
-
-				if count > 0 then
-					datastring = datastring .. S("drops: ")
-					datastring = newline(datastring)
-
-					for _,item in ipairs(data.drops) do
-						local itemDescription = ItemStack(item.name):get_short_description()
-						datastring = datastring .. itemDescription
-						datastring = newline(datastring)
-					end
-
-					datastring = newline2(datastring)
-				end
-			end
-
-			if data.follow then
-				datastring = datastring .. S("follows player when these items are held:")
-				datastring = newline(datastring)
-
-				if type(data.follow) == "string" then
-					datastring = datastring .. data.follow
-					datastring = newline(datastring)
-				else
-					for i=1, #data.follow do
-						local itemstring = data.follow[i]
-						local itemDescription = ItemStack(itemstring):get_short_description()
-						datastring = datastring .. itemDescription
-						datastring = newline(datastring)
-					end
-				end
-				
-				datastring = newline2(datastring)
-			end
-
-			local formstring = doc.widgets.text(datastring, nil, nil, doc.FORMSPEC.ENTRY_WIDTH - 1.2)
-			
-			return formstring
-		else
-			return "label[0,1;NO DATA AVALIABLE!]"
-		end
-	end
-})
-
 -- Register group definition stuff
 -- More (user-)friendly group names to replace the rather technical names
 -- for better understanding

mods/HELP/mcl_doc_basics/locale/mcl_doc_basics.fr.tr

@@ -447,7 +447,7 @@ The values for X, Y and Z work like this:=Les valeurs pour X, Y et Z fonctionnen
 You can view your current position in the debug screen (open with [F5]).=Vous pouvez afficher votre position actuelle dans l'écran de débogage (ouvrir avec [F5]).
 
 # MCL2 extensions
-Creative Mode=Mode créatif
+Creative Mode=Mode Creatif
 Enabling Creative Mode in MineClone 2 applies the following changes:=L'activation du mode créatif dans MineClone 2 applique les modifications suivantes:
 • You keep the things you've placed=• Vous gardez les choses que vous avez placées
 • Creative inventory is available to obtain most items easily=• Un inventaire créatif est disponible pour obtenir facilement la plupart des objets

mods/HELP/tt/init.lua

@@ -76,7 +76,6 @@ function tt.reload_itemstack_description(itemstack)
 			orig_desc = minetest.colorize(tt.NAME_COLOR, meta:get_string("name"))
 		end
 		local desc = apply_snippets(orig_desc, itemstring, toolcaps or def.tool_capabilities, itemstack)
-		if desc == def.description and meta:get_string("description") == "" then return end
 		meta:set_string("description", desc)
 	end
 end

mods/HUD/mcl_achievements/init.lua

@@ -550,13 +550,6 @@ awards.register_achievement("mcl:obsidian", {
 	type = "Advancement",
 	group = "Overworld",
 })
-awards.register_achievement("mcl:fireball_redir_serv", {
-	title		= S("Fireball Redirection Service"),
-	description = S("Defeat a ghast with his own weapon."),
-	icon		= "mcl_fire_fire_charge.png",
-	type = "Advancement",
-	group = "Nether",
-})
 
 awards.register_achievement("mcl:hero_of_the_village", {
 	title = S("Hero of the Village"),

mods/HUD/mcl_achievements/locale/mcl_achievements.fr.tr

@@ -15,7 +15,7 @@ Eat a cooked porkchop.=Mangez du porc cuit.
 Eat a cooked rabbit.=Mangez du lapin cuit.
 Get really desperate and eat rotten flesh.=Soyez vraiment désespéré et mangez de la chair pourrie.
 Getting Wood=Obtenir du bois
-Getting an Upgrade=Obtenir une amélioration
+Getting an Upgrade=Obtenir une augmentation de niveau
 Hit a skeleton, wither skeleton or stray by bow and arrow from a distance of at least 20 meters.=Frappez un squelette, wither squelette ou stray à l'arc et à la flèche à une distance d'au moins 20 mètres.
 Hot Topic=Sujet brûlant
 Into Fire=Dans le feu

mods/HUD/mcl_experience/orb.lua

@@ -177,6 +177,7 @@ minetest.register_entity("mcl_experience:orb", {
 	delete_timer = 0,
 	radius = 4,
 
+
 	on_activate = function(self, staticdata, dtime_s)
 		self.object:set_velocity(vector.new(
 			math.random(-2,2)*math.random(),
@@ -186,13 +187,9 @@ minetest.register_entity("mcl_experience:orb", {
 		self.object:set_armor_groups({immortal = 1})
 		self.object:set_velocity({x = 0, y = 2, z = 0})
 		self.object:set_acceleration(gravity)
-
+		local xp = tonumber(staticdata)
-		-- Assign 0 xp in case the entity was persisted even though it should not have been (static_save = false)
-		-- This was a minetest bug for a while: https://github.com/minetest/minetest/issues/14420
-		local xp = tonumber(staticdata) or 0
 		self._xp = xp
 	        size = xp_to_size(xp)
-
 	        self.object:set_properties({
 			visual_size = {x = size, y = size},
 			glow = 14,

mods/HUD/mcl_inventory/creative.lua

@@ -204,8 +204,7 @@ local function init(player)
 	local playername = player:get_player_name()
 	minetest.create_detached_inventory("creative_" .. playername, {
 		allow_move = function(inv, from_list, from_index, to_list, to_index, count, player)
-			if minetest.is_creative_enabled(playername) and
+			if minetest.is_creative_enabled(playername) then
-			   from_list ~= to_list then
 				return count
 			else
 				return 0
@@ -542,6 +541,7 @@ function mcl_inventory.set_creative_formspec(player)
 			"style[" .. this_tab .. ";border=false;bgimg=;bgimg_pressed=;noclip=true]",
 			"image[" .. offset[this_tab] .. ";1.5,1.44;" .. bg_img .. "]",
 			"item_image_button[" .. boffset[this_tab] .. ";1,1;" .. tab_icon[this_tab] .. ";" .. this_tab .. ";]",
+			"tooltip[blocks;" .. F(filtername[this_tab]) .. "]"
 		})
 	end
 
@@ -570,33 +570,20 @@ function mcl_inventory.set_creative_formspec(player)
 
 		listrings,
 
-		tab(name, "blocks") ..
+		tab(name, "blocks"),
-		"tooltip[blocks;"..F(filtername["blocks"]).."]"..
+		tab(name, "deco"),
-		tab(name, "deco") ..
+		tab(name, "redstone"),
-		"tooltip[deco;"..F(filtername["deco"]).."]"..
+		tab(name, "rail"),
-		tab(name, "redstone") ..
+		tab(name, "misc"),
-		"tooltip[redstone;"..F(filtername["redstone"]).."]"..
+		tab(name, "nix"),
-		tab(name, "rail") ..
-		"tooltip[rail;"..F(filtername["rail"]).."]"..
-		tab(name, "misc") ..
-		"tooltip[misc;"..F(filtername["misc"]).."]"..
-		tab(name, "nix") ..
-		"tooltip[nix;"..F(filtername["nix"]).."]"..
 
-		tab(name, "food") ..
+		tab(name, "food"),
-		"tooltip[food;"..F(filtername["food"]).."]"..
+		tab(name, "tools"),
-		tab(name, "tools") ..
+		tab(name, "combat"),
-		"tooltip[tools;"..F(filtername["tools"]).."]"..
+		tab(name, "mobs"),
-		tab(name, "combat") ..
+		tab(name, "brew"),
-		"tooltip[combat;"..F(filtername["combat"]).."]"..
+		tab(name, "matr"),
-		tab(name, "mobs") ..
+		tab(name, "inv"),
-		"tooltip[mobs;"..F(filtername["mobs"]).."]"..
-		tab(name, "brew") ..
-		"tooltip[brew;"..F(filtername["brew"]).."]"..
-		tab(name, "matr") ..
-		"tooltip[matr;"..F(filtername["matr"]).."]"..
-		tab(name, "inv") ..
-		"tooltip[inv;"..F(filtername["inv"]).."]"
 	})
 
 	if name == "nix" then
@@ -607,7 +594,6 @@ function mcl_inventory.set_creative_formspec(player)
 		formspec = formspec .. table.concat({
 			"field[5.325,0.15;6.1,0.6;search;;" .. minetest.formspec_escape(filter) .. "]",
 			"field_close_on_enter[search;false]",
-			"field_enter_after_edit[search;true]",
 			"set_focus[search;true]",
 		})
 	end

mods/HUD/mcl_inventory/init.lua

@@ -3,19 +3,6 @@ mcl_inventory = {}
 dofile(minetest.get_modpath(minetest.get_current_modname()) .. "/creative.lua")
 dofile(minetest.get_modpath(minetest.get_current_modname()) .. "/survival.lua")
 
-local old_is_creative_enabled = minetest.is_creative_enabled
-
-function minetest.is_creative_enabled(name)
-	if old_is_creative_enabled(name) then return true end
-	if not name then return false end
-	assert(type(name) == "string", "minetest.is_creative_enabled requires a string (the playername) argument.")
-	local p = minetest.get_player_by_name(name)
-	if p then
-		return p:get_meta():get_string("gamemode") == "creative"
-	end
-	return false
-end
-
 ---@param player mt.PlayerObjectRef
 ---@param armor_change_only? boolean
 local function set_inventory(player, armor_change_only)
@@ -86,14 +73,12 @@ end)
 
 ---@param player mt.PlayerObjectRef
 function mcl_inventory.update_inventory(player)
-	local player_name = player:get_player_name()
+	local player_gamemode = mcl_gamemode.get_gamemode(player)
-	local is_gamemode_creative = minetest.is_creative_enabled(player_name)
+	if player_gamemode == "creative" then
-	if is_gamemode_creative then
 		mcl_inventory.set_creative_formspec(player)
-	elseif not is_gamemode_creative then
+	elseif player_gamemode == "survival" then
 		player:set_inventory_formspec(mcl_inventory.build_survival_formspec(player))
 	end
-	mcl_meshhand.update_player(player)
 end
 
 mcl_gamemode.register_on_gamemode_change(function(player, old_gamemode, new_gamemode)

mods/HUD/mcl_inventory/survival.lua

@@ -1,15 +1,18 @@
 ---@diagnostic disable need-check-nil
+
+local table = table
+local ipairs = ipairs
+
 local S = minetest.get_translator("mcl_inventory")
 local F = minetest.formspec_escape
 
 ---@type {id: string, description: string, item_icon: string, build: (fun(player: ObjectRef): string), handle: fun(player: ObjectRef, fields: table), access: (fun(player): boolean), show_inventory: boolean}[]
 mcl_inventory.registered_survival_inventory_tabs = {}
 
-
 ---@param def {id: string, description: string, item_icon: string, build: (fun(player: ObjectRef): string), handle: fun(player: ObjectRef, fields: table), access: (fun(player): boolean), show_inventory: boolean}
 function mcl_inventory.register_survival_inventory_tab(def)
 	if #mcl_inventory.registered_survival_inventory_tabs == 7 then
-		error("Too many tabs registered!")
+		error("Too much tabs registered!")
 	end
 
 	assert(def.id)
@@ -131,10 +134,10 @@ local main_page_static = table.concat({
 
 	--Listring
 	"listring[current_player;main]",
-	"listring[current_player;craft]",
-	"listring[current_player;main]",
 	"listring[current_player;armor]",
 	"listring[current_player;main]",
+	"listring[current_player;craft]",
+	"listring[current_player;main]",
 })
 
 mcl_inventory.register_survival_inventory_tab({
@@ -201,14 +204,13 @@ function mcl_inventory.build_survival_formspec(player)
 end
 
 minetest.register_on_player_receive_fields(function(player, formname, fields)
-	local player_name = player:get_player_name()
 	if formname == "" and #mcl_inventory.registered_survival_inventory_tabs ~= 1 and
-		not minetest.is_creative_enabled(player_name) then
+		mcl_gamemode.get_gamemode(player) == "survival" then
 		for _, d in ipairs(mcl_inventory.registered_survival_inventory_tabs) do
 			if fields["tab_" .. d.id] and d.access(player) then
 				player_current_tab[player] = d.id
 				mcl_inventory.update_inventory(player)
-				break
+				return
 			end
 		end
 

mods/ITEMS/REDSTONE/mesecons_lightstone/init.lua

@@ -2,24 +2,7 @@ local S = minetest.get_translator(minetest.get_current_modname())
 
 local light = minetest.LIGHT_MAX
 
-local function generate_action_on(color)
+minetest.register_node("mesecons_lightstone:lightstone_off", {
-	local n = "mesecons_lightstone:lightstone_on"
-	if color then n = n .. "_" .. color end
-	return function(pos, node)
-		minetest.swap_node(pos, {name=n, param2 = node.param2})
-	end
-end
-
-local function generate_action_off(color)
-	local n = "mesecons_lightstone:lightstone_off"
-	if color then n = n .. "_" .. color end
-	return function(pos, node)
-		minetest.swap_node(pos, {name=n, param2 = node.param2})
-	end
-end
-
-local ls_off_name = "mesecons_lightstone:lightstone_off"
-local ls_off_def = {
 	tiles = {"jeija_lightstone_gray_off.png"},
 	groups = {handy=1, mesecon_effector_off = 1, mesecon = 2},
 	is_ground_content = false,
@@ -28,16 +11,16 @@ local ls_off_def = {
 	_doc_items_longdesc = S("Redstone lamps are simple redstone components which glow brightly (light level @1) when they receive redstone power.", light),
 	sounds = mcl_sounds.node_sound_glass_defaults(),
 	mesecons = {effector = {
-		action_on = generate_action_on(),
+		action_on = function(pos, node)
+			minetest.swap_node(pos, {name="mesecons_lightstone:lightstone_on", param2 = node.param2})
+		end,
 		rules = mesecon.rules.alldirs,
 	}},
 	_mcl_blast_resistance = 0.3,
 	_mcl_hardness = 0.3,
-}
+})
-minetest.register_node(ls_off_name, ls_off_def)
 
-local ls_on_name = "mesecons_lightstone:lightstone_on"
+minetest.register_node("mesecons_lightstone:lightstone_on", {
-local ls_on_def = {
 	tiles = {"jeija_lightstone_gray_on.png"},
 	groups = {handy=1, not_in_creative_inventory=1, mesecon = 2, opaque = 1},
 	drop = "node mesecons_lightstone:lightstone_off",
@@ -46,59 +29,14 @@ local ls_on_def = {
 	light_source = light,
 	sounds = mcl_sounds.node_sound_glass_defaults(),
 	mesecons = {effector = {
-		action_off = generate_action_off(),
+		action_off = function(pos, node)
+			minetest.swap_node(pos, {name="mesecons_lightstone:lightstone_off", param2 = node.param2})
+		end,
 		rules = mesecon.rules.alldirs,
 	}},
 	_mcl_blast_resistance = 0.3,
 	_mcl_hardness = 0.3,
-}
-minetest.register_node(ls_on_name, ls_on_def)
-
-local colored_lamps = {
-	{"white",      S("White Redstone Lamp"),      	"white"},
-	{"grey",       S("Grey Redstone Lamp"),       	"dark_grey"},
-	{"silver",     S("Light Grey Redstone Lamp"),	"grey"},
-	{"black",      S("Black Redstone Lamp"),      	"black"},
-	{"red",        S("Red Redstone Lamp"),        	"red"},
-	{"yellow",     S("Yellow Redstone Lamp"),     	"yellow"},
-	{"green",      S("Green Redstone Lamp"),      	"dark_green"},
-	{"cyan",       S("Cyan Redstone Lamp"),       	"cyan"},
-	{"blue",       S("Blue Redstone Lamp"),       	"blue"},
-	{"magenta",    S("Magenta Redstone Lamp"),    	"magenta"},
-	{"orange",     S("Orange Redstone Lamp"),     	"orange"},
-	{"purple",     S("Purple Redstone Lamp"),     	"violet"},
-	{"brown",      S("Brown Redstone Lamp"),      	"brown"},
-	{"pink",       S("Pink Redstone Lamp"),       	"pink"},
-	{"lime",       S("Lime Redstone Lamp"),       	"green"},
-	{"lightblue",  S("Light Blue Redstone Lamp"), 	"lightblue"},
-}
-for _, row in ipairs(colored_lamps) do
-	local name = row[1]
-	local desc = row[2]
-	local dye = row[3]
-	local mask = "^[hsl:0:-100^(mcl_lightstone_mask.png^[multiply:" .. name .. "^[opacity:100)"
-	if name == "lightblue" then
-		mask = "^[hsl:0:-100^(mcl_lightstone_mask.png^[multiply:" .. name .. "^[hsl:0:200^[opacity:100)"
-	end
-	local name_off = ls_off_name .. "_" .. name
-	local def_off = table.copy(ls_off_def)
-	def_off.description = desc
-	def_off._doc_items_longdesc = nil
-	def_off._doc_items_create_entry = false
-	def_off.mesecons.effector.action_on = generate_action_on(name)
-	def_off.tiles[1] = def_off.tiles[1] .. mask
-	local def_on = table.copy(ls_on_def)
-	def_on.drop = name_off
-	def_on.tiles[1] = def_on.tiles[1] .. mask
-	def_on.mesecons.effector.action_off = generate_action_off(name)
-	minetest.register_node(name_off, def_off)
-	minetest.register_node(ls_on_name.."_"..name, def_on)
-	minetest.register_craft({
-		type = "shapeless",
-		output = name_off,
-		recipe = {ls_off_name, "mcl_dye:" .. dye}
 })
-end
 
 minetest.register_craft({
     output = "mesecons_lightstone:lightstone_off",

mods/ITEMS/REDSTONE/mesecons_lightstone/locale/mesecons_lightstone.de.tr

@@ -2,19 +2,3 @@
 Redstone Lamp=Redstonelampe
 Redstone lamps are simple redstone components which glow brightly (light level @1) when they receive redstone power.=Redstonelampen sind einfache Redstonekomponenten, die hell aufleuchten (Helligkeitspegel von @1), wenn sie Redstoneenergie erhalten.
 Glows when powered by redstone power=Leuchtet, wenn mit Redstoneenergie versorgt
-White Redstone Lamp=Weiße Redstonelampe
-Grey Redstone Lamp=Graue Redstonelampe
-Light Grey Redstone Lamp=Hellgraue Redstonelampe
-Black Redstone Lamp=Schwartze Redstonelampe
-Red Redstone Lamp=Rote Redstonelampe
-Yellow Redstone Lamp=Gelbe Redstonelampe
-Green Redstone Lamp=Grüne Redstonelampe
-Cyan Redstone Lamp=Türkise Redstonelampe
-Blue Redstone Lamp=Blaue Redstonelampe
-Magenta Redstone Lamp=Magenta Redstonelampe
-Orange Redstone Lamp=Orange Redstonelampe
-Purple Redstone Lamp=Violette Redstonelampe
-Brown Redstone Lamp=Braune Redstonelampe
-Pink Redstone Lamp=Rosa Redstonelampe
-Lime Redstone Lamp=Lindgrüne Redstonelampe
-Light Blue Redstone Lamp=Hellblaue Redstonelampe

mods/ITEMS/REDSTONE/mesecons_lightstone/locale/mesecons_lightstone.pl.tr

@@ -2,19 +2,3 @@
 Redstone Lamp=Lampa czerwienitowa
 Redstone lamps are simple redstone components which glow brightly (light level @1) when they receive redstone power.=Lampy czerwienitowe to mechanizmy czerwienitowe, które jasno świecą (poziom światła @1), gdy są zasilone energią czerwienitową.
 Glows when powered by redstone power=Świeci gdy zasilana czerwienitem
-White Redstone Lamp=Biała lampa czerwienitowa
-Grey Redstone Lamp=Szara lampa czerwienitowa
-Light Grey Redstone Lamp=Jasnoszara lampa czerwienitowa
-Black Redstone Lamp=Czarna lampa czerwienitowa
-Red Redstone Lamp=Czerwona lampa czerwienitowa
-Yellow Redstone Lamp=Żółta lampa czerwienitowa
-Green Redstone Lamp=Zielona lampa czerwienitowa
-Cyan Redstone Lamp=Błękitna lampa czerwienitowa
-Blue Redstone Lamp=Niebieska lampa czerwienitowa
-Magenta Redstone Lamp=Karmazynowa lampa czerwienitowa
-Orange Redstone Lamp=Pomarańczowa lampa czerwienitowa
-Purple Redstone Lamp=Fioletowa lampa czerwienitowa
-Brown Redstone Lamp=Brązowa lampa czerwienitowa
-Pink Redstone Lamp=Różowa lampa czerwienitowa
-Lime Redstone Lamp=Jasnozielona lampa czerwienitowa
-Light Blue Redstone Lamp=Jasnoniebieska lampa czerwienitowa

mods/ITEMS/REDSTONE/mesecons_lightstone/locale/template.txt

@@ -2,19 +2,3 @@
 Redstone Lamp=
 Redstone lamps are simple redstone components which glow brightly (light level @1) when they receive redstone power.=
 Glows when powered by redstone power=
-White Redstone Lamp=
-Grey Redstone Lamp=
-Light Grey Redstone Lamp=
-Black Redstone Lamp=
-Red Redstone Lamp=
-Yellow Redstone Lamp=
-Green Redstone Lamp=
-Cyan Redstone Lamp=
-Blue Redstone Lamp=
-Magenta Redstone Lamp=
-Orange Redstone Lamp=
-Purple Redstone Lamp=
-Brown Redstone Lamp=
-Pink Redstone Lamp=
-Lime Redstone Lamp=
-Light Blue Redstone Lamp=

mods/ITEMS/mcl_amethyst/locale/mcl_amethyst.de.tr

@@ -1,19 +0,0 @@
-# textdomain: mcl_amethyst
-Amethyst Cluster=Amethysthaufen
-Amethyst Cluster is the final growth of amethyst bud.=Der Amethysthaufen ist das endgültige Wachstum der Amethystknospe.
-Amethyst Shard=Amethystsplitter
-An amethyst shard is a crystalline mineral.=Ein Amethystsplitter ist ein kristallines Mineral.
-Block of Amethyst=Amethystblock
-Budding Amethyst=Amethystknospe
-Calcite=Kalzit
-Calcite can be found as part of amethyst geodes.=Kalzit kann als Teil von Amethystgeoden gefunden werden.
-Large Amethyst Bud=Große Amethystknospe
-Large Amethyst Bud is the third growth of amethyst bud.=Die große Amethystknospe ist die dritte Wachstumsstufe der Amethystknospe.
-Medium Amethyst Bud=Mittelgroße Amethystknospe
-Medium Amethyst Bud is the second growth of amethyst bud.=Die mittelgroße Amethystknospe ist die zweite Wachstumsstufe der Amethystknospe.
-Small Amethyst Bud=Kleine Amethystknospe
-Small Amethyst Bud is the first growth of amethyst bud.=Die kleine Amethystknospe ist die erste Wachstumsstufe der Amethystknospe.
-The Block of Amethyst is a decoration block crafted from amethyst shards.=Der Amethystblock ist ein aus Amethystsplittern gefertigter Dekorationsblock.
-The Budding Amethyst can grow amethyst=Knospender Amethyst kann Amethyst wachsen lassen.
-Tinted Glass=Getöntes Glas
-Tinted Glass is a type of glass which blocks lights while it is visually transparent.=Getöntes Glas ist eine Art von Glas, das Licht blockiert, während es visuell transparent ist.

mods/ITEMS/mcl_armor/api.lua

@@ -129,7 +129,6 @@ function mcl_armor.register_set(def)
 		local groups = table.copy(groups)
 		groups["armor_" .. name] = 1
 		groups["combat_armor_" .. name] = 1
-		groups["armor_" .. def.name] = 1
 		groups.armor = 1
 		groups.combat_armor = 1
 		groups.mcl_armor_points = def.points[name]

mods/ITEMS/mcl_armor/init.lua

@@ -71,6 +71,5 @@ dofile(modpath .. "/api.lua")
 dofile(modpath .. "/player.lua")
 dofile(modpath .. "/damage.lua")
 dofile(modpath .. "/register.lua")
-dofile(modpath .. "/leather.lua")
 dofile(modpath .. "/alias.lua")
 dofile(modpath .. "/trims.lua")

mods/ITEMS/mcl_armor/leather.lua

@@ -1,207 +0,0 @@
-local C = minetest.colorize
-
-local colors = {
-	-- { ID, decription, wool, dye }
-	{ "red", "Red", "mcl_dye:red", "#951d1d" },
-	{ "blue", "Blue", "mcl_dye:blue", "#2a2c94" },
-	{ "cyan", "Cyan", "mcl_dye:cyan", "#0d7d8e" },
-	{ "grey", "Grey", "mcl_dye:dark_grey", "#363a3f" },
-	{ "silver", "Light Grey", "mcl_dye:grey", "#818177" },
-	{ "black", "Black", "mcl_dye:black", "#020307" },
-	{ "yellow", "Yellow", "mcl_dye:yellow", "#f2b410" },
-	{ "green", "Green", "mcl_dye:dark_green", "#495d20" },
-	{ "magenta", "Magenta", "mcl_dye:magenta", "#ae2ea4" },
-	{ "orange", "Orange", "mcl_dye:orange", "#e36501" },
-	{ "purple", "Purple", "mcl_dye:violet", "#681ba1" },
-	{ "brown", "Brown", "mcl_dye:brown", "#623b1a" },
-	{ "pink", "Pink", "mcl_dye:pink", "#d66691" },
-	{ "lime", "Lime", "mcl_dye:green", "#60ad13" },
-	{ "light_blue", "Light Blue", "mcl_dye:lightblue", "#1f8eca" },
-	{ "white", "White", "mcl_dye:white", "#d1d7d8" },
-}
-
-local function color_string_to_table(colorstring)
-	return {
-		r = tonumber(colorstring:sub(2,3), 16), -- 16 as second parameter allows hexadecimal
-		g = tonumber(colorstring:sub(4,5), 16),
-		b = tonumber(colorstring:sub(6,7), 16),
-	}
-end
-
-local function av(a, b)
-	return (a + b)/2
-end
-
-local function calculate_color(first, last)
-    return {
-		r = av(first.r, last.r),
-		g = av(first.g, last.g),
-		b = av(first.b, last.b),
-    }
-end
-
-local function get_texture_function(texture)
-	local function get_texture(_, itemstack)
-		local out
-		local color = itemstack:get_meta():get_string("mcl_armor:color")
-		if color == "" or color == nil then
-			out = texture
-		else
-			out = texture.."^[hsl:0:100:50^[multiply:"..color
-		end
-
-		if mcl_enchanting.is_enchanted(itemstack:get_name()) then
-			return out..mcl_enchanting.overlay
-		else
-			return out
-		end
-	end
-	return get_texture
-end
-
-function mcl_armor.colorize_leather_armor(itemstack, colorstring)
-	if not itemstack or minetest.get_item_group(itemstack:get_name(), "armor_leather") == 0 then
-		return
-	end
-	local color = color_string_to_table(colorstring)
-	colorstring = minetest.colorspec_to_colorstring(color)
-	local meta = itemstack:get_meta()
-	local old_color = meta:get_string("mcl_armor:color")
-	if old_color == colorstring then return
-	elseif old_color ~= "" then
-		color = calculate_color(
-			color_string_to_table(minetest.colorspec_to_colorstring(old_color)),
-			color
-		)
-		colorstring = minetest.colorspec_to_colorstring(color)
-	end
-	meta:set_string("mcl_armor:color", colorstring)
-	meta:set_string("inventory_image",
-		itemstack:get_definition().inventory_image .. "^[hsl:0:100:50^[multiply:" .. colorstring
-	)
-	tt.reload_itemstack_description(itemstack)
-	return itemstack
-end
-
-function mcl_armor.wash_leather_armor(itemstack)
-	if not itemstack or minetest.get_item_group(itemstack:get_name(), "armor_leather") == 0 then
-		return
-	end
-	local meta = itemstack:get_meta()
-	meta:set_string("mcl_armor:color", "")
-	meta:set_string("inventory_image", "")
-	tt.reload_itemstack_description(itemstack)
-	return itemstack
-end
-
-mcl_armor.register_set({
-	name = "leather",
-	description = "Leather",
-	descriptions = {
-		head = "Cap",
-		torso = "Tunic",
-		legs = "Pants",
-	},
-	durability = 80,
-	enchantability = 15,
-	points = {
-		head = 1,
-		torso = 3,
-		legs = 2,
-		feet = 1,
-	},
-	textures = {
-		head = get_texture_function("mcl_armor_helmet_leather.png"),
-		torso = get_texture_function("mcl_armor_chestplate_leather.png"),
-		legs = get_texture_function("mcl_armor_leggings_leather.png"),
-		feet = get_texture_function("mcl_armor_boots_leather.png"),
-	},
-	craft_material = "mcl_mobitems:leather",
-})
-
-tt.register_priority_snippet(function(_, _, itemstack)
-	if not itemstack or minetest.get_item_group(itemstack:get_name(), "armor_leather") == 0 then
-		return
-	end
-	local color = itemstack:get_meta():get_string("mcl_armor:color")
-	if color and color ~= "" then
-		local text = C(mcl_colors.GRAY, "Dyed: "..color)
-		return text, false
-	end
-end)
-
-for name, element in pairs(mcl_armor.elements) do
-	local modname = minetest.get_current_modname()
-	local itemname = modname .. ":" .. element.name .. "_leather"
-	minetest.register_craft({
-		type = "shapeless",
-		output = itemname,
-		recipe = {
-			itemname,
-			"group:dye",
-		},
-	})
-	local ench_itemname = itemname .. "_enchanted"
-	minetest.register_craft({
-		type = "shapeless",
-		output = ench_itemname,
-		recipe = {
-			ench_itemname,
-			"group:dye",
-		},
-	})
-end
-
-local function colorizing_crafting(itemstack, player, old_craft_grid, craft_inv)
-	if minetest.get_item_group(itemstack:get_name(), "armor_leather") == 0 then
-		return
-	end
-
-	local found_la = nil
-	local dye_color = nil
-	for _, item in pairs(old_craft_grid) do
-		local name = item:get_name()
-		if name == "" then
-			-- continue
-		elseif minetest.get_item_group(name, "armor_leather") > 0 then
-			if found_la then return end
-			found_la = item
-		elseif minetest.get_item_group(name, "dye") > 0 then
-			if dye_color then return end
-			for _, row in pairs(colors) do
-				if row[3] == name then dye_color = row[4] end
-			end
-		else return end
-	end
-
-	return mcl_armor.colorize_leather_armor(found_la, dye_color) or ItemStack()
-end
-
-minetest.register_craft_predict(colorizing_crafting)
-minetest.register_on_craft(colorizing_crafting)
-
-
-minetest.register_chatcommand("color_leather", {
-	params = "<color>",
-	description = "Colorize a piece of leather armor, or wash it",
-	privs = {debug = true},
-	func = function(name, param)
-		local player = minetest.get_player_by_name(name)
-		if player then
-			local item = player:get_wielded_item()
-			if not item or minetest.get_item_group(item:get_name(), "armor_leather") == 0 then
-				return false, "Not leather armor."
-			end
-			if param == "wash" then
-				player:set_wielded_item(mcl_armor.wash_leather_armor(item))
-				return true, "Washed."
-			end
-			local colorstring = minetest.colorspec_to_colorstring(param)
-			if not colorstring then return false, "Invalid color" end
-			player:set_wielded_item(mcl_armor.colorize_leather_armor(item, colorstring))
-			return true, "Done: " .. colorstring
-		else
-			return false, "Player isn't online"
-		end
-	end,
-})

mods/ITEMS/mcl_armor/locale/mcl_armor.de.tr

@@ -1,6 +1,6 @@
 # textdomain: mcl_armor
 This is a piece of equippable armor which reduces the amount of damage you receive.=Dies ist ein Teil einer tragbaren Rüstung, die die Menge an Schaden, den Sie erleiden, reduziert.
-To equip it, put it on the corresponding armor slot in your inventory menu.=Um es zu tragen, legen Sie es in den passenden Rüstungsplatz in Ihrem Inventarmenü.
+To equip it, put it on the corresponding armor slot in your inventory menu.=Um es zu tragen, legen Sie es in den passenden Rüstungsplatz in ihrem Inventarmenü.
 Leather Cap=Lederkappe
 Iron Helmet=Eisenhelm
 Golden Helmet=Goldhelm

mods/ITEMS/mcl_armor/mod.conf

@@ -1,5 +1,5 @@
 name = mcl_armor
 author = stu
 description = Adds craftable armor that is visible to other players.
-depends = mcl_core, mcl_player, mcl_enchanting, mcl_damage, mcl_colors, mcl_grindstone
+depends = mcl_core, mcl_player, mcl_enchanting, mcl_damage, mcl_grindstone
 optional_depends = mcl_fire, ethereal, bakedclay

mods/ITEMS/mcl_armor/register.lua

@@ -1,5 +1,24 @@
 local S = minetest.get_translator(minetest.get_current_modname())
 
+mcl_armor.register_set({
+	name = "leather",
+	description = "Leather",
+	descriptions = {
+		head = "Cap",
+		torso = "Tunic",
+		legs = "Pants",
+	},
+	durability = 80,
+	enchantability = 15,
+	points = {
+		head = 1,
+		torso = 3,
+		legs = 2,
+		feet = 1,
+	},
+	craft_material = "mcl_mobitems:leather",
+})
+
 mcl_armor.register_set({
 	name = "gold",
 	description = "Golden",
@@ -208,27 +227,5 @@ minetest.register_tool("mcl_armor:elytra", {
 	on_place = mcl_armor.equip_on_use,
 	on_secondary_use = mcl_armor.equip_on_use,
 	_mcl_armor_element = "torso",
-	_mcl_armor_texture = function(obj, itemstack)
+	_mcl_armor_texture = "mcl_armor_elytra.png"
-		if obj:is_player() then
-			local cape = mcl_skins.player_skins[obj].cape
-			if cape ~= "blank.png" then
-				return cape:gsub("_body", "_elytra")
-			end
-		end
-		return "mcl_armor_elytra.png"
-	end,
-	_on_equip =  function(obj, itemstack)
-		if not obj:is_player() then return end
-		local cape = mcl_skins.player_skins[obj].cape
-		if cape ~= "blank.png" then
-			local skinval = mcl_player.player_get_skin(obj)
-			skinval = skinval:gsub("%^" .. cape, "")
-			mcl_player.player_set_skin(obj, skinval)
-			-- this doesn't mess with the data mcl_skins has, so when mcl_skins reloads (which happens when the elytra is unequipped), the normal cape returns
-		end
-	end,
-	_on_unequip = function(obj, itemstack)
-		if not obj:is_player() then return end
-		mcl_skins.update_player_skin(obj)
-	end
 })

mods/ITEMS/mcl_bamboo/bamboo_base.lua

@@ -280,7 +280,31 @@ local bamboo_block_def = {
 	_mcl_blast_resistance = 3,
 	_mcl_hardness = 2,
 	_mcl_stripped_variant = "mcl_bamboo:bamboo_block_stripped", -- this allows us to use the built in Axe's strip block.
-	on_place = mcl_util.rotate_axis,
+	on_place = function(itemstack, placer, pointed_thing)
+		if not pointed_thing then
+			return itemstack
+		end
+
+		if pointed_thing.type ~= "node" then -- make sure that pointed_thing is not null and is pointing at a node.
+			return itemstack
+		end
+
+		local pos = pointed_thing.under
+
+		if mcl_bamboo.is_protected(pos, placer) then
+			return
+		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,
 }
 
 minetest.register_node("mcl_bamboo:bamboo_block", bamboo_block_def)

mods/ITEMS/mcl_bamboo/bamboo_items.lua

@@ -316,16 +316,11 @@ minetest.register_node(SCAFFOLDING_NAME, {
 			-- A quick check, that may or may not work, to attempt to prevent placing things on the side of other nodes.
 			local dir = vector.subtract(pointed.under, pointed.above)
 			local wdir = minetest.dir_to_wallmounted(dir)
-			local anode = minetest.get_node(pointed.above).name
 			if wdir == 1 then
-				if (anode == "air" or minetest.registered_nodes[anode].buildable_to) and not mcl_bamboo.is_protected(pointed.above, placer) then
 				minetest.set_node(pointed.above, { name = SCAFFOLDING_NAME, param2 = 0 })
 				if not minetest.is_creative_enabled(placer:get_player_name()) then
 					itemstack:take_item(1)
 				end
-				else
-					return
-				end
 				return itemstack
 			else
 				return

mods/ITEMS/mcl_barrels/init.lua

@@ -117,6 +117,7 @@ minetest.register_node("mcl_barrels:barrel_closed", {
 	_doc_items_longdesc = S("Barrels are containers which provide 27 inventory slots."),
 	_doc_items_usagehelp = S("To access its inventory, rightclick it. When broken, the items will drop out."),
 	tiles = { "mcl_barrels_barrel_top.png^[transformR270", "mcl_barrels_barrel_bottom.png", "mcl_barrels_barrel_side.png" },
+	is_ground_content = false,
 	paramtype = "light",
 	paramtype2 = "facedir",
 	on_place = function(itemstack, placer, pointed_thing)
@@ -166,6 +167,7 @@ minetest.register_node("mcl_barrels:barrel_open", {
 	_doc_items_usagehelp = S("To access its inventory, rightclick it. When broken, the items will drop out."),
 	_doc_items_create_entry = false,
 	tiles = { "mcl_barrels_barrel_top_open.png", "mcl_barrels_barrel_bottom.png", "mcl_barrels_barrel_side.png" },
+	is_ground_content = false,
 	paramtype = "light",
 	paramtype2 = "facedir",
 	drop = "mcl_barrels:barrel_closed",

mods/ITEMS/mcl_beacons/init.lua

@@ -236,6 +236,7 @@ minetest.register_node("mcl_beacons:beacon", {
 	collisionbox = {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
 	mesh = "mcl_beacon.b3d",
 	tiles = {"beacon_UV.png"},
+	is_ground_content = false,
 	use_texture_alpha = "clip",
 	on_construct = function(pos)
 		local meta = minetest.get_meta(pos)

mods/ITEMS/mcl_beds/api.lua

@@ -77,31 +77,16 @@ local function rotate(pos, node, user, mode, new_param2)
 end
 
 
-local creative_dig = {}
 local function destruct_bed(pos, oldnode)
 	local node = oldnode or minetest_get_node_or_nil(pos)
 	if not node then return end
 
 	local pos2, node2, bottom = get_bed_next_node(pos, oldnode)
 
-	-- Check creative dig flags and don't drop an item if the bed was dug by a player in
-	-- creative mode
-	local pos_hash = minetest.hash_node_position(pos)
-	local pos2_hash = minetest.hash_node_position(pos2)
-	local creative_mode = creative_dig[pos_hash] or creative_dig[pos2_hash]
-
 	if bottom then
 		if node2 and string.sub(node2.name, -4) == "_top" then
 			minetest_remove_node(pos2)
 		end
-
-		-- Drop the bed only when removing the top to prevent duplication and only if
-		-- it wasn't dug by a player in creative mode
-		local bed_node_def = minetest.registered_nodes[node.name]
-		if bed_node_def and bed_node_def._mcl_beds_drop and not creative_mode then
-			local stack = ItemStack(bed_node_def._mcl_beds_drop)
-			minetest.add_item(pos2, stack)
-		end
 	else
 		if node2 and string.sub(node2.name, -7) == "_bottom" then
 			minetest_remove_node(pos2)
@@ -109,29 +94,6 @@ local function destruct_bed(pos, oldnode)
 	end
 end
 
-local function dig_bed(pos, node, digger)
-	local pos_hash = minetest.hash_node_position(pos)
-
-	if digger then
-		local name = digger:get_player_name()
-		if minetest.is_protected(pos, name) then
-			minetest.record_protection_violation(pos, name)
-			return
-		end
-
-		-- Set creative dig flags to stop dropping items
-		if minetest.is_creative_enabled(name) then
-			creative_dig[pos_hash] = true
-		end
-	end
-
-	-- Trigger the destruct_bed function
-	minetest.remove_node(pos)
-
-	-- Clean up creative dig flag
-	creative_dig[pos_hash] = nil
-end
-
 local function kick_player_after_destruct(destruct_pos)
 	for name, player_bed_pos in pairs(mcl_beds.bed_pos) do
 		if vector.distance(destruct_pos, player_bed_pos) < 0.1 then
@@ -164,26 +126,6 @@ if minetest.get_modpath("mcl_sounds") then
 	})
 end
 
-local function place_bed(name, placer, pos, dir)
-	local botpos = vector_add(pos, minetest_facedir_to_dir(dir))
-
-	if minetest.is_protected(botpos, placer:get_player_name()) and
-			not minetest.check_player_privs(placer, "protection_bypass") then
-		minetest.record_protection_violation(botpos, placer:get_player_name())
-		return false
-	end
-
-	local botdef = minetest.registered_nodes[minetest_get_node(botpos).name]
-	if not botdef or not botdef.buildable_to then
-		return false
-	end
-
-	minetest.set_node(pos, {name = name .. "_bottom", param2 = dir})
-	minetest.set_node(botpos, {name = name .. "_top", param2 = dir})
-
-	return true
-end
-
 function mcl_beds.register_bed(name, def)
 	local common_box = {
 			type = "fixed",
@@ -214,8 +156,7 @@ function mcl_beds.register_bed(name, def)
 		sounds = def.sounds or default_sounds,
 		selection_box = common_box,
 		collision_box = common_box,
-		_mcl_beds_drop = def.recipe and name or "",
+		drop = def.recipe and name or "",
-		drop = "",
 		node_placement_prediction = "",
 		
 		on_place = function(itemstack, placer, pointed_thing)
@@ -248,23 +189,30 @@ function mcl_beds.register_bed(name, def)
 				return itemstack
 			end
 
-			-- Try to place in three directions: inline with the view and rotated to
-			-- the right and left
 			local dir = minetest.dir_to_facedir(placer:get_look_dir())
-			if place_bed(name, placer, pos, dir) or
+			local botpos = vector_add(pos, minetest_facedir_to_dir(dir))
-			   place_bed(name, placer, pos, (dir+1)%4) or
+
-			   place_bed(name, placer, pos, (dir+3)%4) or
+			if minetest.is_protected(botpos, placer:get_player_name()) and
-			   place_bed(name, placer, pos, (dir+2)%4) then
+					not minetest.check_player_privs(placer, "protection_bypass") then
-				-- Bed was places
+				minetest.record_protection_violation(botpos, placer:get_player_name())
+				return itemstack
+			end
+
+			local botdef = minetest.registered_nodes[minetest_get_node(botpos).name]
+			if not botdef or not botdef.buildable_to then
+				return itemstack
+			end
+
+			minetest.set_node(pos, {name = name .. "_bottom", param2 = dir})
+			minetest.set_node(botpos, {name = name .. "_top", param2 = dir})
+
 			if not minetest.is_creative_enabled(placer:get_player_name()) then
 				itemstack:take_item()
 			end
-			end
 			return itemstack
 		end,
 
 		after_destruct = destruct_bed,
-		on_dig = dig_bed,
 
 		on_destruct = kick_player_after_destruct,
 
@@ -291,7 +239,7 @@ function mcl_beds.register_bed(name, def)
 		_mcl_hardness = 0.2,
 		_mcl_blast_resistance = 1,
 		sounds = def.sounds or default_sounds,
-		drop = "",
+		drop = def.recipe and name or "",
 		selection_box = common_box,
 		collision_box = common_box,
 		
@@ -302,7 +250,6 @@ function mcl_beds.register_bed(name, def)
 
 		on_rotate = rotate,
 		after_destruct = destruct_bed,
-		on_dig = dig_bed,
 	})
 
 	minetest.register_alias(name, name .. "_bottom")

mods/ITEMS/mcl_beds/respawn_anchor.lua

@@ -33,6 +33,7 @@ for i=0,4 do
 				"respawn_anchor_bottom.png",
 				"respawn_anchor_side0.png"
 			},
+			is_ground_content = false,
 			on_rightclick = rightclick,
 			groups = {pickaxey=1, material_stone=1},
 			_mcl_hardness = 22.5,

mods/ITEMS/mcl_beehives/init.lua

@@ -191,18 +191,6 @@ minetest.register_craft({
 	},
 })
 
-minetest.register_craft({
-	type = "fuel",
-	recipe = "group:bee_nest",
-	burntime = 15,
-})
-
-minetest.register_craft({
-	type = "fuel",
-	recipe = "group:beehive",
-	burntime = 15,
-})
-
 -- Temporary ABM to update honey levels
 minetest.register_abm({
 	label = "Update Beehive Honey Levels",

mods/ITEMS/mcl_books/init.lua

@@ -475,11 +475,8 @@ minetest.register_node("mcl_books:bookshelf", {
 	_mcl_hoppers_on_try_push = function(pos, hop_pos, hop_inv, hop_list)
 		local meta = minetest.get_meta(pos)
 		local inv = meta:get_inventory()
-		local function filter(stack)
+		return inv, "main", mcl_util.select_stack(hop_inv, hop_list, inv, "main",
-			return minetest.get_item_group(stack:get_name(), "book") == 1 or
+				function(stack) return minetest.get_item_group(stack:get_name(), "book") == 1 or stack:get_name() == "mcl_enchanting:book_enchanted" end)
-			       stack:get_name() == "mcl_enchanting:book_enchanted"
-		end
-		return inv, "main", mcl_util.select_stack(hop_inv, hop_list, inv, "main", filter, 1)
 	end,
 })
 

mods/ITEMS/mcl_bows/rocket.lua

@@ -27,11 +27,11 @@ local function damage_explosion(self, damagemulitplier)
 	for _,obj in pairs(objects) do
 		if obj:is_player() then
 			mcl_util.deal_damage(obj, damagemulitplier - vector.distance(p, obj:get_pos()), {type = "explosion"})
-		elseif obj:get_luaentity() and obj:get_luaentity().is_mob then
+		elseif obj:get_luaentity().is_mob then
 			obj:punch(self.object, 1.0, {
 				full_punch_interval=1.0,
 				damage_groups={fleshy=damagemulitplier - vector.distance(p, obj:get_pos())},
-			}, self.object:get_velocity()) -- TODO possibly change the punch dir to be outwards instead of rocket velocity
+			}, self.object:get_velocity())
 		end
 	end
 end