more items usable to smelt (#4184)

- group:bee_nest
- group:beehive
- mcl_cartography_table:cartography_table
- mcl_core:deadbush
- mcl_fletching_table:fletching_table
- mcl_lectern:lectern
- mcl_loom:loom
- mcl_mangrove:mangrove_roots
- mcl_smithing_table:table

Reviewed-on: https://git.minetest.land/MineClone2/MineClone2/pulls/4184
Reviewed-by: Mikita Wiśniewski <rudzik8@protonmail.com>
Co-authored-by: nixnoxus <nixnoxus@web.de>
Co-committed-by: nixnoxus <nixnoxus@web.de>

.editorconfig

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

.gitignore

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

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

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

mods/CORE/mcl_init/init.lua

@@ -36,6 +36,8 @@ 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

@@ -160,7 +160,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 then
+	if undef and undef.on_rightclick and not invert_wall then
 		undef.on_rightclick(pointed_thing.under, unode, placer,
 			itemstack, pointed_thing)
 		return
@@ -198,26 +198,12 @@ function mcl_util.rotate_axis_and_place(itemstack, placer, pointed_thing, infini
 
 	local p2
 	if is_y then
-		if invert_wall then
+		p2 = 0
-			if fdir == 3 or fdir == 1 then
-				p2 = 12
-			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
@@ -271,12 +257,21 @@ 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)
+function mcl_util.select_stack(src_inventory, src_list, dst_inventory, dst_list, condition, count)
 	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
@@ -294,9 +289,13 @@ 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)
-	if not source_inventory:is_empty(source_list) then
+	-- Can't move items we don't have
+	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 not stack:is_empty() then
+	if stack:is_empty() then return false end
+
 	local new_stack = ItemStack(stack)
 	new_stack:set_count(1)
 	if not destination_inventory:room_for_item(destination_list, new_stack) then
@@ -306,9 +305,6 @@ function mcl_util.move_item(source_inventory, source_list, source_stack_id, dest
 	source_inventory:set_stack(source_list, source_stack_id, stack)
 	destination_inventory:add_item(destination_list, new_stack)
 	return true
-		end
-	end
-	return false
 end
 
 --- Try pushing item from hopper inventory to destination inventory
@@ -328,25 +324,23 @@ 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)
+		stack_id = mcl_util.select_stack(hop_inv, hop_list, dst_inv, dst_list, nil, 1)
 	end
+	if not stack_id then return false end
 
-	if stack_id ~= nil then
+	-- Move the item
 	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 false
+	return ok
 end
 
 -- Try pulling from source inventory to hopper inventory
@@ -371,7 +365,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)
+		stack_id = mcl_util.select_stack(src_inv, src_list, hop_inv, hop_list, nil, 1)
 	end
 
 	if stack_id ~= nil then

mods/CORE/tga_encoder/LICENSE

@@ -0,0 +1,674 @@
+                    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,4 +1,87 @@
 # 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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,105 @@
+#!/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

@@ -0,0 +1,181 @@
+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,60 +9,566 @@ local image = setmetatable({}, {
 })
 
 function image:constructor(pixels)
-	self.data = ""
 	self.pixels = pixels
 	self.width = #pixels[1]
 	self.height = #pixels
-
-	self:encode()
 end
 
-function image:encode_colormap_spec()
+local pixel_depth_by_color_format = {
-	self.data = self.data
+	["Y8"] = 8,
-		.. string.char(0, 0) -- first entry index
+	["A1R5G5B5"] = 16,
-		.. string.char(0, 0) -- number of entries
+	["B8G8R8"] = 24,
-		.. string.char(0) -- bits per pixel
+	["B8G8R8A8"] = 32,
-end
+}
 
-function image:encode_image_spec()
+function image:encode_colormap_spec(properties)
-	self.data = self.data
+	local colormap = properties.colormap
-		.. string.char(0, 0) -- X-origin
+	local colormap_pixel_depth = 0
-		.. string.char(0, 0) -- Y-origin
+	if 0 ~= #colormap then
-		.. string.char(self.width  % 256, math.floor(self.width  / 256)) -- width
+		colormap_pixel_depth = pixel_depth_by_color_format[
-		.. string.char(self.height % 256, math.floor(self.height / 256)) -- height
+			properties.color_format
-		.. string.char(24) -- pixel depth (RGB = 3 bytes = 24 bits)
+		]
-		.. string.char(0) -- image descriptor
+		-- ensure that each pixel references a legal colormap entry
-end
-
-function image:encode_header()
-	self.data = self.data
-		.. string.char(0) -- image id
-		.. string.char(0) -- color map type
-		.. string.char(10) -- image type (RLE RGB = 10)
-	self:encode_colormap_spec() -- color map specification
-	self:encode_image_spec() -- image specification
-end
-
-function image:encode_data()
-	local current_pixel = ''
-	local previous_pixel = ''
-	local count = 1
-	local packets = {}
-	local rle_packet = ''
 		for _, row in ipairs(self.pixels) do
 			for _, pixel in ipairs(row) do
-			current_pixel = string.char(pixel[3], pixel[2], pixel[1])
+				local colormap_index = pixel[1]
-			if current_pixel ~= previous_pixel or count == 128 then
+				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)
+	local color_format = properties.color_format
+	assert(
+		"Y8" == color_format or -- (8 bit grayscale = 1 byte = 8 bits)
+		"A1R5G5B5" == color_format or -- (A1R5G5B5 = 2 bytes = 16 bits)
+		"B8G8R8" == color_format or -- (B8G8R8 = 3 bytes = 24 bits)
+		"B8G8R8A8" == color_format -- (B8G8R8A8 = 4 bytes = 32 bits)
+	)
+	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)
+	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(image_type)
+	self:encode_colormap_spec(properties) -- color map specification
+	self:encode_image_spec(properties) -- image specification
+	self:encode_colormap(properties)
+end
+
+function image:encode_data(properties)
+	local color_format = properties.color_format
+	local colormap = properties.colormap
+	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_pixel = current_pixel
+				previous_r = pixel[1]
+				previous_g = pixel[2]
+				previous_b = pixel[3]
 			else
 				count = count + 1
 			end
-			rle_packet = string.char(128 + count - 1) .. current_pixel
 		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
+				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)
+						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_g = pixel[2]
+				previous_b = pixel[3]
+			else
+				count = count + 1
+			end
+		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
 
@@ -75,15 +581,45 @@ function image:encode_footer()
 		.. string.char(0)
 end
 
-function image:encode()
+function image:encode(properties)
-	self:encode_header() -- header
+	local properties = properties or {}
+	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() -- encode data
+	self:encode_data(properties) -- encode data
 	-- no extension or developer area
 	self:encode_footer() -- footer
 end
 
-function image:save(filename)
+function image:save(filename, properties)
+	self:encode(properties)
+
 	local f = assert(io.open(filename, "wb"))
 	f:write(self.data)
 	f:close()

mods/CORE/tga_encoder/logo.lua

@@ -0,0 +1,51 @@
+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,3 +1,2 @@
 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

@@ -0,0 +1,180 @@
+#!/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 = 100})
+	self.object:set_armor_groups({fleshy = 125})
 	local data = minetest.deserialize(staticdata)
 	if type(data) == "table" then
 		self._v = data.v

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

@@ -0,0 +1,21 @@
+# 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

@@ -0,0 +1,3 @@
+# 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,6 +113,55 @@ 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
 
@@ -147,40 +196,7 @@ 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
 
-					if object:get_luaentity()._magnet_timer >= 0 and
+					try_object_pickup( player, inv, object, checkpos )
-						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,3 +135,33 @@ 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,9 +241,7 @@ 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
-			self._velocity = vector.multiply(cart_dir, 3)
+			mcl_minecarts:set_velocity(self, cart_dir)
-			self._old_pos = nil
-			self._punched = true
 			return
 		end
 
@@ -300,9 +298,7 @@ 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)
 
-		self._velocity = vector.multiply(cart_dir, f)
+		mcl_minecarts:set_velocity(self, cart_dir, f)
-		self._old_pos = nil
-		self._punched = true
 	end
 
 	cart.on_activate_by_rail = on_activate_by_rail
@@ -470,7 +466,7 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 			return
 		end
 
-		local dir, last_switch = nil, nil
+		local dir, last_switch, restart_pos = nil, nil, nil
 		if not pos then
 			pos = self.object:get_pos()
 		end
@@ -497,6 +493,9 @@ 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)
@@ -647,6 +646,14 @@ 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()
@@ -687,7 +694,15 @@ function mcl_minecarts.place_minecart(itemstack, pointed_thing, placer)
 	if le then
 		le._railtype = railtype
 	end
-	local cart_dir = mcl_minecarts:get_rail_direction(railpos, {x=1, y=0, z=0}, nil, nil, railtype)
+	local cart_dir
+	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

@@ -0,0 +1,36 @@
+# 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,6 +112,22 @@ 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 = default_walk_chance
+		self.walk_chance = 50
 		self.jump = true
 		self:set_animation("stand")
 		-- TODO: Add sitting model

mods/ENTITIES/mcl_mobs/combat.lua

@@ -35,14 +35,19 @@ function mob_class:day_docile()
 	end
 end
 
--- attack player/mob
+-- get this mob to attack the object
-function mob_class:do_attack(player)
+function mob_class:do_attack(object)
 
 	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,12 +325,19 @@ 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
 
 
@@ -362,12 +369,13 @@ 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 150,
+		_lifetime = def._lifetime or 7,
 		owner_id = def.owner_id,
 		rotate = def.rotate,
-		on_punch = def.on_punch or function(self)
+		on_punch = def.on_punch or function(self, puncher, time_from_last_punch, tool_capabilities, dir, damage)
-			local vel = self.object:get_velocity()
+			local vel = self.object:get_velocity():length()
-			self.object:set_velocity({x=vel.x * -1, y=vel.y * -1, z=vel.z * -1})
+			self.object:set_velocity({x=dir.x * vel, y=dir.y * vel, z=dir.z * vel})
+			self._puncher = puncher
 		end,
 		collisionbox = def.collisionbox or {0, 0, 0, 0, 0, 0},
 		automatic_face_movement_dir = def.rotate
@@ -377,7 +385,7 @@ function mcl_mobs.register_arrow(name, def)
 
 		on_step = def.on_step or function(self, dtime)
 
-			self.timer = self.timer + 1
+			self.timer = self.timer + dtime
 
 			local pos = self.object:get_pos()
 
@@ -443,24 +451,24 @@ function mcl_mobs.register_arrow(name, def)
 
 			if self.hit_player or self.hit_mob or self.hit_object then
 
-				for _,player in pairs(minetest.get_objects_inside_radius(pos, 1.5)) do
+				for _,object in pairs(minetest.get_objects_inside_radius(pos, 1.5)) do
 
 					if self.hit_player
-					and player:is_player() then
+					and object:is_player() then
 
-						self.hit_player(self, player)
+						self.hit_player(self, object)
 						self.object:remove();
 						return
 					end
 
-					local entity = player:get_luaentity()
+					local entity = object:get_luaentity()
 
 					if entity
 					and self.hit_mob
 					and entity.is_mob == true
-					and tostring(player) ~= self.owner_id
+					and (tostring(object) ~= self.owner_id or self.timer > 2)
 					and entity.name ~= self.object:get_luaentity().name then
-						self.hit_mob(self, player)
+						self.hit_mob(self, object)
 						self.object:remove();
 						return
 					end
@@ -468,9 +476,9 @@ function mcl_mobs.register_arrow(name, def)
 					if entity
 					and self.hit_object
 					and (not entity.is_mob)
-					and tostring(player) ~= self.owner_id
+					and (tostring(object) ~= self.owner_id or self.timer > 2)
 					and entity.name ~= self.object:get_luaentity().name then
-						self.hit_object(self, player)
+						self.hit_object(self, object)
 						self.object:remove();
 						return
 					end

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

@@ -0,0 +1,13 @@
+# 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,6 +761,61 @@ 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,10 +13,9 @@ 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 get_biome_name               = minetest.get_biome_name
+local mt_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
@@ -97,19 +96,6 @@ 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!
@@ -446,7 +432,6 @@ 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
@@ -508,7 +493,6 @@ 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)
@@ -612,10 +596,8 @@ 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.
@@ -682,7 +664,29 @@ 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
@@ -692,11 +696,10 @@ 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
-	local gotten_biome = minetest.get_biome_data(pos)
+	if not gotten_node then return end
 
-	if not gotten_node or not gotten_biome then return end
+	local biome_name = get_biome_name(pos)
-
+	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
@@ -714,8 +717,9 @@ 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, gotten_biome) then
+			and biome_check(spawn_def.biomes, biome_name) 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)
@@ -725,6 +729,7 @@ 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
@@ -875,8 +880,6 @@ minetest.register_chatcommand("spawn_mob",{
 
 if mobs_spawn then
 
-	local perlin_noise
-
 	-- Get pos to spawn, x and z are randomised, y is range
 
 
@@ -973,9 +976,21 @@ 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
@@ -988,22 +1003,25 @@ if mobs_spawn then
 		--output_mob_stats(mob_counts_wide)
 
 		--grab mob that fits into the spawning location
-		--randomly grab a mob, don't exclude any possibilities
+		--use random weighted choice with replacement to grab a mob, don't exclude any possibilities
-		perlin_noise = perlin_noise or minetest_get_perlin(noise_params)
+		--shuffle table once every loop to provide equal inclusion probability to all mobs
-		local noise = perlin_noise:get_3d(spawning_position)
+		--repeat grabbing a mob to maintain existing spawn rates
-		local current_summary_chance = summary_chance
+		local spawn_loop_counter = #mob_library_worker_table
 
+		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)
 
@@ -1088,8 +1106,7 @@ if mobs_spawn then
 				end
 
 			end
-			current_summary_chance = current_summary_chance - mob_chance
+			spawn_loop_counter = spawn_loop_counter - 1
-			table_remove(mob_library_worker_table, mob_index)
 		end
 	end
 
@@ -1101,6 +1118,7 @@ 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

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

mods/ENTITIES/mobs_mc/LICENSE-media.md

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

mods/ENTITIES/mobs_mc/bat.lua

@@ -150,7 +150,7 @@ mcl_mobs:spawn_specific(
 0,
 maxlight,
 20,
-5000,
+100,
 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,
-5000,
+1000,
 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, 17000,
+30, 100,
 3,
 mobs_mc.water_level,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/cod.lua

@@ -30,6 +30,7 @@ local S = minetest.get_translator(minetest.get_current_modname())
 --###################
 
 local cod = {
+	description = S("Cod"),
 	type = "animal",
 	spawn_class = "water_ambient",
 	can_despawn = true,
@@ -266,7 +267,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-4000,
+750,
 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,
-17000,
+80,
 10,
 mobs_mc.water_level,
 mcl_vars.mg_overworld_max)
@@ -225,7 +225,7 @@ mcl_mobs:spawn_specific(
 9,
 minetest.LIGHT_MAX+1,
 30,
-17000,
+80,
 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("Creeper"),
+	description = S("Charged Creeper"),
 	type = "monster",
 	spawn_class = "hostile",
 	hp_min = 20,
@@ -407,7 +407,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 20,
-16500,
+1000,
 2,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/dolphin.lua

@@ -30,6 +30,7 @@ local S = minetest.get_translator(minetest.get_current_modname())
 --###################
 
 local dolphin = {
+	description = S("Dolphin"),
 	type = "animal",
 	spawn_class = "water",
 	can_despawn = true,
@@ -244,7 +245,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-4000,
+70,
 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,
-3000,
+100,
 12,
 mcl_vars.mg_end_min,
 mcl_vars.mg_end_max)
@@ -816,7 +816,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-19000,
+100,
 2,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)
@@ -833,7 +833,7 @@ mcl_mobs:spawn_specific(
 0,
 11,
 30,
-27500,
+100,
 4,
 mcl_vars.mg_nether_min,
 mcl_vars.mg_nether_max)
@@ -849,7 +849,7 @@ mcl_mobs:spawn_specific(
 0,
 11,
 30,
-5000,
+100,
 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, 5, -2, 2, 9, 2},
+	collisionbox = {-2, 0, -2, 2, 4, 2, rotate=true},
 	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 = 16,
+		distance = 80,
 		-- 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 = 100,
+	view_range = 64,
 	attack_type = "dogshoot",
 	arrow = "mobs_mc:fireball",
-	shoot_interval = 3.5,
+	shoot_interval = 5,
-	shoot_offset = -5,
+	shoot_offset = -0.5,
 	dogshoot_switch = 1,
 	dogshoot_count_max =1,
 	passive = false,
@@ -97,7 +97,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-72000,
+400,
 2,
 mcl_vars.mg_nether_min,
 mcl_vars.mg_nether_max)
@@ -107,8 +107,9 @@ mcl_mobs.register_arrow("mobs_mc:fireball", {
 	visual = "sprite",
 	visual_size = {x = 1, y = 1},
 	textures = {"mcl_fire_fire_charge.png"},
-	velocity = 15,
+	velocity = 5,
 	collisionbox = {-.5, -.5, -.5, .5, .5, .5},
+	_lifetime = 10,
 	_is_fireball = true,
 
 	hit_player = function(self, player)
@@ -130,6 +131,10 @@ 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,6 +30,7 @@ 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,
@@ -237,7 +238,7 @@ mcl_mobs:spawn_specific(
 		0,
 		minetest.LIGHT_MAX + 1,
 		30,
-		10000,
+		100,
 		3,
 		water - 16,
 		water)

mods/ENTITIES/mobs_mc/hoglin+zoglin.lua

@@ -31,8 +31,9 @@ local hoglin = {
 	} },
 	visual_size = {x=3, y=3},
 	sounds = {
-		random = "extra_mobs_hoglin",
+		random = "extra_mobs_hoglin.1",
 		damage = "extra_mobs_hoglin_hurt",
+		death = "extra_mobs_hoglin_hurt",
 		distance = 16,
 	},
 	jump = true,
@@ -92,6 +93,12 @@ 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
@@ -129,7 +136,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-6000,
+200,
 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,
-15000,
+40,
 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,
-15000,
+10,
 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,
-15000,
+50,
 5,
 mobs_mc.water_level+15,
 mcl_vars.mg_overworld_max)

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

@@ -0,0 +1,73 @@
+# 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,
-15000,
+300,
 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,
-30000,
+400,
 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,
-15000,
+100,
 8,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/piglin.lua

@@ -16,6 +16,13 @@ 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")
@@ -61,8 +68,10 @@ local piglin = {
 	} },
 	visual_size = {x=1, y=1},
 	sounds = {
-		random = "extra_mobs_piglin",
+		random = "mobs_mc_zombiepig_random",
-		damage = "extra_mobs_piglin_hurt",
+		war_cry = "mobs_mc_zombiepig_war_cry",                  death = "mobs_mc_zombiepig_death",
+		damage = "mobs_mc_zombiepig_hurt.2",
+		death = "mobs_mc_zombiepig_death.2",
 		distance = 16,
 	},
 	jump = true,
@@ -140,14 +149,18 @@ local piglin = {
 				local c_pos = self.object:get_pos()
 				if c_pos then
 					self.what_traded = trading_items[math.random(#trading_items)]
-					for x = 1, math.random(self.what_traded.amount_min, self.what_traded.amount_max) do
+					local stack = ItemStack(self.what_traded.itemstring)
+					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, self.what_traded.itemstring)
+					minetest.add_item(p, stack)
-					end
 				end
 			end)
 		end
@@ -330,8 +343,13 @@ 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?
-mcl_mobs.register_mob("mobs_mc:pigman", zombified_piglin)
+local pigman_unused = table.copy(zombified_piglin)
-mcl_mobs.register_mob("mobs_mc:baby_pigman", baby_zombified_piglin)
+pigman_unused.unused = true
+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 --
@@ -397,7 +415,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-6000,
+150,
 3,
 mcl_vars.mg_lava_nether_max,
 mcl_vars.mg_nether_max)
@@ -413,7 +431,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-6000,
+150,
 3,
 mcl_vars.mg_lava_nether_max,
 mcl_vars.mg_nether_max)
@@ -429,7 +447,7 @@ mcl_mobs:spawn_specific(
 		0,
 		minetest.LIGHT_MAX+1,
 		30,
-		6000,
+		1000,
 		3,
 		mcl_vars.mg_nether_min,
 		mcl_vars.mg_nether_max)
@@ -446,7 +464,7 @@ mcl_mobs:spawn_specific(
 		0,
 		minetest.LIGHT_MAX+1,
 		30,
-		100000,
+		50,
 		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,
-7000,
+50,
 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,
-15000,
+40,
 8,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/salmon.lua

@@ -10,6 +10,7 @@ local S = minetest.get_translator(minetest.get_current_modname())
 --###################
 
 local salmon = {
+	description = S("Salmon"),
 	type = "animal",
 	spawn_class = "water_ambient",
 	can_despawn = true,
@@ -220,7 +221,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-4000,
+260,
 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,
-15000,
+120,
 3,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/skeleton+stray.lua

@@ -44,6 +44,13 @@ 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,
@@ -299,7 +306,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 20,
-17000,
+800,
 2,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)
@@ -316,7 +323,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-10000,
+800,
 3,
 mcl_vars.mg_nether_min,
 mcl_vars.mg_nether_max)
@@ -336,7 +343,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 20,
-19000,
+1200,
 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",
+		random = "mobs_mc_skeleton_random.1",
 		death = "mobs_mc_skeleton_death",
 		damage = "mobs_mc_skeleton_hurt",
 		distance = 16,
@@ -116,7 +116,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-5000,
+500,
 5,
 mcl_vars.mg_nether_min,
 mcl_vars.mg_nether_max)

mods/ENTITIES/mobs_mc/slime+magma_cube.lua

@@ -6,6 +6,7 @@ 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
 
@@ -166,16 +167,16 @@ local swamp_light_max = 7
 local function slime_spawn_check(pos, environmental_light, artificial_light, sky_light)
 	local maxlight = swamp_light_max
 
-	if is_slime_chunk(pos) then
+	if pos.y <= slime_chunk_spawn_max and is_slime_chunk(pos) then
 		maxlight = minetest.LIGHT_MAX + 1
 	end
 
-	return artificial_light <= maxlight
+	return math.max(artificial_light, sky_light) <= maxlight
 end
 
 -- Slime
 local slime_big = {
-	description = S("Slime"),
+	description = S("Slime - big"),
 	type = "monster",
 	spawn_class = "hostile",
 	group_attack = { "mobs_mc:slime_big", "mobs_mc:slime_small", "mobs_mc:slime_tiny" },
@@ -230,6 +231,7 @@ 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
@@ -247,6 +249,7 @@ 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
@@ -321,7 +324,7 @@ cave_biomes,
 0,
 minetest.LIGHT_MAX+1,
 30,
-12000,
+1000,
 4,
 cave_min,
 cave_max,
@@ -335,7 +338,7 @@ swampy_biomes,
 0,
 swamp_light_max,
 30,
-12000,
+1000,
 4,
 swamp_min,
 swamp_max)
@@ -348,7 +351,7 @@ cave_biomes,
 0,
 minetest.LIGHT_MAX+1,
 30,
-8500,
+1000,
 4,
 cave_min,
 cave_max,
@@ -362,7 +365,7 @@ swampy_biomes,
 0,
 swamp_light_max,
 30,
-8500,
+1000,
 4,
 swamp_min,
 swamp_max)
@@ -375,7 +378,7 @@ cave_biomes,
 0,
 minetest.LIGHT_MAX+1,
 30,
-10000,
+1000,
 4,
 cave_min,
 cave_max,
@@ -389,14 +392,14 @@ swampy_biomes,
 0,
 swamp_light_max,
 30,
-10000,
+1000,
 4,
 swamp_min,
 swamp_max)
 
 -- Magma cube
 local magma_cube_big = {
-	description = S("Magma Cube"),
+	description = S("Magma Cube - big"),
 	type = "monster",
 	spawn_class = "hostile",
 	hp_min = 16,
@@ -457,6 +460,7 @@ 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
@@ -478,6 +482,7 @@ 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
@@ -512,7 +517,7 @@ magma_cube_biomes,
 0,
 minetest.LIGHT_MAX+1,
 30,
-15000,
+100,
 4,
 nether_min,
 nether_max)
@@ -525,7 +530,7 @@ magma_cube_biomes,
 0,
 minetest.LIGHT_MAX+1,
 30,
-15500,
+100,
 4,
 nether_min,
 nether_max)
@@ -538,7 +543,7 @@ magma_cube_biomes,
 0,
 minetest.LIGHT_MAX+1,
 30,
-16000,
+100,
 4,
 nether_min,
 nether_max)

mods/ENTITIES/mobs_mc/spider.lua

@@ -287,7 +287,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-17000,
+1000,
 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,
-5500,
+80,
 3,
 water-16,
 water+1)

mods/ENTITIES/mobs_mc/strider.lua

@@ -11,6 +11,7 @@ local S = minetest.get_translator("mobs_mc")
 
 
 local strider = {
+	description = S("Strider"),
 	type = "animal",
 	passive = true,
 	spawn_class = "passive",
@@ -30,6 +31,8 @@ local strider = {
 	} },
 	visual_size = {x=3, y=3},
 	sounds = {
+		eat = "mobs_mc_animal_eat_generic",
+		distance = 16,
 	},
 	jump = true,
 	makes_footstep_sound = true,
@@ -51,6 +54,7 @@ local strider = {
 		walk_start = 1,
 		walk_end = 20,
 	},
+	follow = { "mcl_crimson:warped_fungus" },
 	lava_damage = 0,
 	fire_damage = 0,
 	light_damage = 0,
@@ -67,8 +71,13 @@ 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
@@ -122,7 +131,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
 
@@ -197,6 +206,7 @@ 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
@@ -206,7 +216,7 @@ textures = { {
 } }
 baby_strider.walk_velocity = 1.2
 baby_strider.run_velocity = 2.4
-baby_strider.child = 1
+baby_strider.child = true
 
 mcl_mobs.register_mob("mobs_mc:baby_strider", baby_strider)
 
@@ -225,7 +235,7 @@ mcl_mobs:spawn_setup({
 	},
 	min_height = mcl_vars.mg_nether_min,
 	max_height = mcl_vars.mg_nether_max,
-	chance = 2000,
+	chance = 200,
 })
 
 mcl_mobs:spawn_setup({
@@ -241,7 +251,7 @@ mcl_mobs:spawn_setup({
 	},
 	min_height = mcl_vars.mg_nether_min,
 	max_height = mcl_vars.mg_nether_max,
-	chance = 100,
+	chance = 20,
 })
 
 -- spawn eggs

mods/ENTITIES/mobs_mc/tropical_fish.lua

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

mods/ENTITIES/mobs_mc/villager.lua

@@ -1989,6 +1989,17 @@ 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
@@ -2000,6 +2011,7 @@ 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
@@ -2010,6 +2022,7 @@ 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)
@@ -2047,6 +2060,7 @@ 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
@@ -2336,7 +2350,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-20,
+2,
 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,
-4090,
+50,
 4,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)

mods/ENTITIES/mobs_mc/wither.lua

@@ -463,7 +463,7 @@ mcl_mobs.register_arrow("mobs_mc:wither_skull", {
 	},
 	velocity = 7,
 	rotate = 90,
-	_lifetime = 350,
+	_lifetime = 15,
 	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 = 500,
+	_lifetime = 25,
 	on_punch = function(self) end,
 
 	-- direct hit

mods/ENTITIES/mobs_mc/wolf.lua

@@ -135,6 +135,7 @@ 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
@@ -224,7 +225,7 @@ mcl_mobs:spawn_specific(
 0,
 minetest.LIGHT_MAX+1,
 30,
-9000,
+80,
 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,
-6000,
+1000,
 4,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)
@@ -332,7 +332,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-60000,
+50,
 4,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)
@@ -348,7 +348,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-6500,
+2400,
 4,
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)
@@ -362,7 +362,7 @@ mcl_mobs:spawn_specific(
 0,
 7,
 30,
-65000,
+120,
 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"}
+doc.data.category_order = {"basics", "nodes", "tools", "craftitems", "advanced", "mobs"}
 doc.data.category_count = 0
 doc.data.players = {}
 

mods/HELP/doc/doc_identifier/init.lua

@@ -116,7 +116,11 @@ 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,6 +1136,86 @@ 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,8 +447,8 @@ 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 Creatif
+Creative Mode=Mode créatif
-Enabling Creative Mode in MineClone 2 applies the following changes:=L'activation du mode créatif dans MineClone 2 applique les modifications suivantes:
+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
 • Hand breaks all default blocks instantly=• La main brise instantanément tous les blocs par défaut

mods/HELP/tt/init.lua

@@ -76,6 +76,7 @@ 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,6 +550,13 @@ 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 augmentation de niveau
+Getting an Upgrade=Obtenir une amélioration
 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,7 +177,6 @@ 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(),
@@ -187,9 +186,13 @@ 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,7 +204,8 @@ 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) then
+			if minetest.is_creative_enabled(playername) and
+			   from_list ~= to_list then
 				return count
 			else
 				return 0
@@ -541,7 +542,6 @@ 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,20 +570,33 @@ function mcl_inventory.set_creative_formspec(player)
 
 		listrings,
 
-		tab(name, "blocks"),
+		tab(name, "blocks") ..
-		tab(name, "deco"),
+		"tooltip[blocks;"..F(filtername["blocks"]).."]"..
-		tab(name, "redstone"),
+		tab(name, "deco") ..
-		tab(name, "rail"),
+		"tooltip[deco;"..F(filtername["deco"]).."]"..
-		tab(name, "misc"),
+		tab(name, "redstone") ..
-		tab(name, "nix"),
+		"tooltip[redstone;"..F(filtername["redstone"]).."]"..
+		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") ..
-		tab(name, "tools"),
+		"tooltip[food;"..F(filtername["food"]).."]"..
-		tab(name, "combat"),
+		tab(name, "tools") ..
-		tab(name, "mobs"),
+		"tooltip[tools;"..F(filtername["tools"]).."]"..
-		tab(name, "brew"),
+		tab(name, "combat") ..
-		tab(name, "matr"),
+		"tooltip[combat;"..F(filtername["combat"]).."]"..
-		tab(name, "inv"),
+		tab(name, "mobs") ..
+		"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
@@ -594,6 +607,7 @@ 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,6 +3,19 @@ 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)
@@ -73,12 +86,14 @@ end)
 
 ---@param player mt.PlayerObjectRef
 function mcl_inventory.update_inventory(player)
-	local player_gamemode = mcl_gamemode.get_gamemode(player)
+	local player_name = player:get_player_name()
-	if player_gamemode == "creative" then
+	local is_gamemode_creative = minetest.is_creative_enabled(player_name)
+	if is_gamemode_creative then
 		mcl_inventory.set_creative_formspec(player)
-	elseif player_gamemode == "survival" then
+	elseif not is_gamemode_creative 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,18 +1,15 @@
 ---@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 much tabs registered!")
+		error("Too many tabs registered!")
 	end
 
 	assert(def.id)
@@ -134,10 +131,10 @@ local main_page_static = table.concat({
 
 	--Listring
 	"listring[current_player;main]",
-	"listring[current_player;armor]",
-	"listring[current_player;main]",
 	"listring[current_player;craft]",
 	"listring[current_player;main]",
+	"listring[current_player;armor]",
+	"listring[current_player;main]",
 })
 
 mcl_inventory.register_survival_inventory_tab({
@@ -204,13 +201,14 @@ 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
-		mcl_gamemode.get_gamemode(player) == "survival" then
+		not minetest.is_creative_enabled(player_name) 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)
-				return
+				break
 			end
 		end
 

mods/ITEMS/REDSTONE/mesecons_lightstone/init.lua

@@ -2,7 +2,24 @@ local S = minetest.get_translator(minetest.get_current_modname())
 
 local light = minetest.LIGHT_MAX
 
-minetest.register_node("mesecons_lightstone:lightstone_off", {
+local function generate_action_on(color)
+	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,
@@ -11,16 +28,16 @@ minetest.register_node("mesecons_lightstone:lightstone_off", {
 	_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 = function(pos, node)
+		action_on = generate_action_on(),
-			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)
 
-minetest.register_node("mesecons_lightstone:lightstone_on", {
+local ls_on_name = "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",
@@ -29,14 +46,59 @@ minetest.register_node("mesecons_lightstone:lightstone_on", {
 	light_source = light,
 	sounds = mcl_sounds.node_sound_glass_defaults(),
 	mesecons = {effector = {
-		action_off = function(pos, node)
+		action_off = generate_action_off(),
-			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,3 +2,19 @@
 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,3 +2,19 @@
 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,3 +2,19 @@
 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

@@ -0,0 +1,19 @@
+# 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,6 +129,7 @@ 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,5 +71,6 @@ 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

@@ -0,0 +1,207 @@
+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_grindstone
+depends = mcl_core, mcl_player, mcl_enchanting, mcl_damage, mcl_colors, mcl_grindstone
 optional_depends = mcl_fire, ethereal, bakedclay

mods/ITEMS/mcl_armor/register.lua

@@ -1,24 +1,5 @@
 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",
@@ -227,5 +208,27 @@ 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 = "mcl_armor_elytra.png"
+	_mcl_armor_texture = function(obj, itemstack)
+		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,31 +280,7 @@ 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 = function(itemstack, placer, pointed_thing)
+	on_place = mcl_util.rotate_axis,
-		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,11 +316,16 @@ 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_beds/api.lua

@@ -77,16 +77,31 @@ 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)
@@ -94,6 +109,29 @@ 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
@@ -126,6 +164,26 @@ 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",
@@ -156,7 +214,8 @@ function mcl_beds.register_bed(name, def)
 		sounds = def.sounds or default_sounds,
 		selection_box = common_box,
 		collision_box = common_box,
-		drop = def.recipe and name or "",
+		_mcl_beds_drop = def.recipe and name or "",
+		drop = "",
 		node_placement_prediction = "",
 		
 		on_place = function(itemstack, placer, pointed_thing)
@@ -189,30 +248,23 @@ 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())
-			local botpos = vector_add(pos, minetest_facedir_to_dir(dir))
+			if place_bed(name, placer, pos, dir) or
-
+			   place_bed(name, placer, pos, (dir+1)%4) or
-			if minetest.is_protected(botpos, placer:get_player_name()) and
+			   place_bed(name, placer, pos, (dir+3)%4) or
-					not minetest.check_player_privs(placer, "protection_bypass") then
+			   place_bed(name, placer, pos, (dir+2)%4) then
-				minetest.record_protection_violation(botpos, placer:get_player_name())
+				-- Bed was places
-				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,
 
@@ -239,7 +291,7 @@ function mcl_beds.register_bed(name, def)
 		_mcl_hardness = 0.2,
 		_mcl_blast_resistance = 1,
 		sounds = def.sounds or default_sounds,
-		drop = def.recipe and name or "",
+		drop = "",
 		selection_box = common_box,
 		collision_box = common_box,
 		
@@ -250,6 +302,7 @@ 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_beehives/init.lua

@@ -191,6 +191,18 @@ 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,8 +475,11 @@ 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()
-		return inv, "main", mcl_util.select_stack(hop_inv, hop_list, inv, "main",
+		local function filter(stack)
-				function(stack) return minetest.get_item_group(stack:get_name(), "book") == 1 or stack:get_name() == "mcl_enchanting:book_enchanted" end)
+			return minetest.get_item_group(stack:get_name(), "book") == 1 or
+			       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().is_mob then
+		elseif obj:get_luaentity() and 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())
+			}, self.object:get_velocity()) -- TODO possibly change the punch dir to be outwards instead of rocket velocity
 		end
 	end
 end

mods/ITEMS/mcl_brewing/init.lua

@@ -379,16 +379,27 @@ end
 local function hoppers_on_try_push(pos, hop_pos, hop_inv, hop_list)
 	local meta = minetest.get_meta(pos)
 	local inv = meta:get_inventory()
-	if math.abs(pos.y - hop_pos.y) > math.abs(pos.x - hop_pos.x) and math.abs(pos.y - hop_pos.y) > math.abs(pos.z - hop_pos.z) then
+
-		return inv, "input", mcl_util.select_stack(hop_inv, hop_list, inv, "input",
+	if math.abs(pos.y - hop_pos.y) > math.abs(pos.x - hop_pos.x) and math.abs(pos.y - hop_pos.y) > math.abs(pos.z - hop_pos.z)
-			function(stack) return minetest.get_item_group(stack:get_name(), "brewitem") == 1 and minetest.get_item_group(stack:get_name(), "bottle") == 0 end)
+	then
+		local function filter(stack)
+			return minetest.get_item_group(stack:get_name(), "brewitem") == 1 and
+			       minetest.get_item_group(stack:get_name(), "bottle") == 0
+		end
+
+		return inv, "input", mcl_util.select_stack(hop_inv, hop_list, inv, "input", filter, 1)
 	else
-		local stack = mcl_util.select_stack(hop_inv, hop_list, inv, "fuel", function(stack) return stack:get_name() == "mcl_mobitems:blaze_powder" end)
+		local filter = function(stack)
+			return stack:get_name() == "mcl_mobitems:blaze_powder"
+		end
+		local stack = mcl_util.select_stack(hop_inv, hop_list, inv, "fuel", filter, 1 )
 		if stack then
 			return inv, "fuel", stack
 		else
-			return inv, "stand", mcl_util.select_stack(hop_inv, hop_list, inv, "stand",
+			local function filter(stack)
-				function(stack) return minetest.get_item_group(stack:get_name(), "bottle") == 1 end)
+				return minetest.get_item_group(stack:get_name(), "bottle") == 1
+			end
+			return inv, "stand", mcl_util.select_stack(hop_inv, hop_list, inv, "stand", filter, 1)
 		end
 	end
 end

mods/ITEMS/mcl_cartography_table/init.lua

@@ -26,3 +26,9 @@ minetest.register_craft({
 		{ "group:wood", "group:wood", "" },
 	}
 })
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "mcl_cartography_table:cartography_table",
+	burntime = 15,
+})

mods/ITEMS/mcl_cauldrons/init.lua

@@ -94,6 +94,14 @@ local function register_filled_cauldron(water_level, description, liquid)
 		drop = "mcl_cauldrons:cauldron",
 		_mcl_hardness = 2,
 		_mcl_blast_resistance = 2,
+		on_rightclick = function(pos, node, player, itemstack)
+			local outcome = mcl_armor.wash_leather_armor(itemstack)
+			if outcome then
+				minetest.sound_play("mcl_potions_bottle_pour",
+					{pos=pos, gain=0.5, max_hear_range=16},true)
+			end
+			return outcome
+		end,
 	})
 
 	-- Add entry aliases for the Help