Change "Junglewood" to "Jungle Wood"

Action of some abm's call functions directly, instead of calling the function inside a function.

.gitignore

@@ -1,7 +1,22 @@
-## Generic ignorable patterns and files
+## Files related to minetest development cycle
-*~
+/*.patch
-.*.swp
+# GNU Patch reject file
-*bak*
+*.rej
-tags
-*.vim
 
+## Editors and Development environments
+*~
+*.swp
+*.bak*
+*.orig
+# Vim
+*.vim
+# Kate
+.*.kate-swp
+.swp.*
+# Eclipse (LDT)
+.project
+.settings/
+.buildpath
+.metadata
+# Idea IDE
+.idea/*

.luacheckrc

@@ -0,0 +1,21 @@
+unused_args = false
+allow_defined_top = true
+
+read_globals = {
+	"DIR_DELIM",
+	"minetest", "core",
+	"dump",
+	"vector",
+	"VoxelManip", "VoxelArea",
+	"PseudoRandom", "ItemStack",
+	"Settings",
+	"unpack",
+	-- Silence "accessing undefined field copy of global table".
+	table = { fields = { "copy" } }
+}
+
+-- Overwrites minetest.handle_node_drops
+files["mods/creative/init.lua"].globals = { "minetest" }
+
+-- Don't report on legacy definitions of globals.
+files["mods/default/legacy.lua"].global = false

.travis.yml

@@ -0,0 +1,12 @@
+language: generic
+sudo: false
+addons:
+  apt:
+    packages:
+    - luarocks
+before_install:
+  - luarocks install --local luacheck
+script: 
+- $HOME/.luarocks/bin/luacheck --no-color ./mods
+notifications:
+  email: false

LICENSE.txt

@@ -0,0 +1,519 @@
+License of media (textures and sounds)
+--------------------------------------
+Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+See README.txt in each mod directory for information about other authors.
+
+Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
+http://creativecommons.org/licenses/by-sa/3.0/
+
+License of menu/header.png
+Copyright (C) 2015 paramat CC BY-SA 3.0
+
+
+License of source code
+----------------------
+Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+See README.txt in each mod directory for information about other authors.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+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 this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser 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 Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "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
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY 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
+LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey 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 library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

README.txt

@@ -1,50 +1,28 @@
-The main game for the Minetest game engine [minetest_game]
+Minetest Game [minetest_game]
-==========================================================
+=============================
+The main subgame for the Minetest engine
+========================================
 
-To build the wholeness of the Minetest project, insert this repository as
+To use this subgame with the Minetest engine, insert this repository as
-  /games/minetest_game
+	/games/minetest_game
-in the Minetest Engine.
 
-The Minetest Engine can be found in:
+The Minetest engine can be found in:
-  https://github.com/minetest/minetest/
+	https://github.com/minetest/minetest/
 
 Compatibility
 --------------
-The minetest_game github master HEAD is generally compatible with the github
+The Minetest Game github master HEAD is generally compatible with the github
-master HEAD of minetest.
+master HEAD of the Minetest engine.
 
-Additionally, when the minetest engine is tagged to be a certain version (eg.
+Additionally, when the Minetest engine is tagged to be a certain version (eg.
-0.4.dev-20120326), minetest_game is tagged with the version too.
+0.4.10), Minetest Game is tagged with the version too.
 
-When stable releases are made, minetest_game is packaged and made available in
+When stable releases are made, Minetest Game is packaged and made available in
-  http://minetest.net/download.php
+	http://minetest.net/download
 and in case the repository has grown too much, it may be reset. In that sense,
 this is not a "real" git repository. (Package maintainers please note!)
 
-License of source code
+Licensing
-----------------------
+---------
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
-See README.txt in each mod directory for information about other authors.
 
-This program is free software; you can redistribute it and/or modify
+See LICENSE.txt
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-License of media (textures and sounds)
---------------------------------------
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
-See README.txt in each mod directory for information about other authors.
-
-Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)                                 
-http://creativecommons.org/licenses/by-sa/3.0/
-  

game.conf

@@ -1,2 +1 @@
-name = Minetest
+name = Minetest Game
-

game_api.txt

@@ -0,0 +1,864 @@
+Minetest Game API
+=================
+GitHub Repo: https://github.com/minetest/minetest_game
+
+Introduction
+------------
+
+The Minetest Game subgame offers multiple new possibilities in addition to the Minetest engine's built-in API,
+allowing you to add new plants to farming mod, buckets for new liquids, new stairs and custom panes.
+For information on the Minetest API, visit https://github.com/minetest/minetest/blob/master/doc/lua_api.txt
+Please note:
+
+ * [XYZ] refers to a section the Minetest API
+ * [#ABC] refers to a section in this document
+ * [pos] refers to a position table `{x = -5, y = 0, z = 200}`
+
+Bucket API
+----------
+
+The bucket API allows registering new types of buckets for non-default liquids.
+
+	bucket.register_liquid(
+		"default:lava_source",   -- name of the source node
+		"default:lava_flowing",  -- name of the flowing node
+		"bucket:bucket_lava",    -- name of the new bucket item (or nil if liquid is not takeable)
+		"bucket_lava.png",       -- texture of the new bucket item (ignored if itemname == nil)
+		"Lava Bucket",           -- text description of the bucket item
+		{lava_bucket = 1},       -- groups of the bucket item, OPTIONAL
+		false                    -- force-renew, OPTIONAL. Force the liquid source to renew if it has
+		                         -- a source neighbour, even if defined as 'liquid_renewable = false'.
+		                         -- Needed to avoid creating holes in sloping rivers.
+	)
+
+The filled bucket item is returned to the player that uses an empty bucket pointing to the given liquid source.
+When punching with an empty bucket pointing to an entity or a non-liquid node, the on_punch of the entity or node will be triggered.
+
+Beds API
+--------
+
+	beds.register_bed(
+		"beds:bed",    -- Bed name
+		def            -- See [#Bed definition]
+	)
+
+ * `beds.read_spawns() `   Returns a table containing players respawn positions
+ * `beds.kick_players()`  Forces all players to leave bed
+ * `beds.skip_night()`   Sets world time to morning and saves respawn position of all players currently sleeping
+
+### Bed definition
+
+	{
+		description = "Simple Bed",
+		inventory_image = "beds_bed.png",
+		wield_image = "beds_bed.png",
+		tiles = {
+			bottom = {'Tile definition'}, -- the tiles of the bottom part of the bed.
+			top = {Tile definition} -- the tiles of the bottom part of the bed.
+		},
+		nodebox = {
+			bottom = 'regular nodebox',     -- bottom part of bed (see [Node boxes])
+			top = 'regular nodebox',        -- top part of bed (see [Node boxes])
+		},
+		selectionbox = 'regular nodebox',  -- for both nodeboxes (see [Node boxes])
+		recipe = {                                         -- Craft recipe
+			{"group:wool", "group:wool", "group:wool"},
+			{"group:wood", "group:wood", "group:wood"}
+		}
+	}
+
+Creative API
+------------
+
+Use `creative.register_tab(name, title, items)` to add a tab with filtered items.
+For example,
+
+	creative.register_tab("tools", "Tools", minetest.registered_tools)
+
+is used to show all tools. Name is used in the sfinv page name, title is the
+human readable title.
+
+`is_enabled_for` is used to check whether a player is in creative mode:
+
+    creative.is_enabled_for(name)
+
+Override this to allow per-player game modes.
+
+The contents of `creative.formspec_add` is appended to every creative inventory
+page. Mods can use it to add additional formspec elements onto the default
+creative inventory formspec to be drawn after each update.
+
+Doors API
+---------
+
+The doors mod allows modders to register custom doors and trapdoors.
+
+`doors.register_door(name, def)`
+
+ * Registers new door
+ * `name` Name for door
+ * `def`  See [#Door definition]
+
+`doors.register_trapdoor(name, def)`
+
+ * Registers new trapdoor
+ * `name` Name for trapdoor
+ * `def`  See [#Trapdoor definition]
+
+`doors.register_fencegate(name, def)`
+
+ * Registers new fence gate
+ * `name` Name for fence gate
+ * `def`  See [#Fence gate definition]
+
+`doors.get(pos)`
+
+ * `pos` A position as a table, e.g `{x = 1, y = 1, z = 1}`
+ * Returns an ObjectRef to a door, or nil if the position does not contain a door
+
+    ### Methods
+
+        :open(player)   -- Open the door object, returns if door was opened
+        :close(player)  -- Close the door object, returns if door was closed
+        :toggle(player) -- Toggle the door state, returns if state was toggled
+        :state()        -- returns the door state, true = open, false = closed
+
+    the "player" parameter can be omitted in all methods. If passed then
+    the usual permission checks will be performed to make sure the player
+    has the permissions needed to open this door. If omitted then no
+    permission checks are performed.
+
+### Door definition
+
+	description = "Door description",
+	inventory_image = "mod_door_inv.png",
+	groups = {choppy = 2},
+	tiles = {"mod_door.png"}, -- UV map.
+	recipe = craftrecipe,
+	sounds = default.node_sound_wood_defaults(), -- optional
+	sound_open = sound play for open door, -- optional
+	sound_close = sound play for close door, -- optional
+	protected = false, -- If true, only placer can open the door (locked for others)
+
+### Trapdoor definition
+
+	description = "Trapdoor description",
+	inventory_image = "mod_trapdoor_inv.png",
+	groups = {choppy = 2},
+	tile_front = "doors_trapdoor.png", -- the texture for the front and back of the trapdoor
+	tile_side = "doors_trapdoor_side.png", -- the tiles of the four side parts of the trapdoor
+	sounds = default.node_sound_wood_defaults(), -- optional
+	sound_open = sound play for open door, -- optional
+	sound_close = sound play for close door, -- optional
+	protected = false, -- If true, only placer can open the door (locked for others)
+
+### Fence gate definition
+
+	description = "Wooden Fence Gate",
+	texture = "default_wood.png",
+	material = "default:wood",
+	groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 2},
+	sounds = default.node_sound_wood_defaults(), -- optional
+
+Fence API
+---------
+
+Allows creation of new fences with "fencelike" drawtype.
+
+`default.register_fence(name, item definition)`
+
+ Registers a new fence. Custom fields texture and material are required, as
+ are name and description. The rest is optional. You can pass most normal
+ nodedef fields here except drawtype. The fence group will always be added
+ for this node.
+
+### fence definition
+
+	name = "default:fence_wood",
+	description = "Wooden Fence",
+	texture = "default_wood.png",
+	material = "default:wood",
+	groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 2},
+	sounds = default.node_sound_wood_defaults(),
+
+Walls API
+---------
+
+The walls API allows easy addition of stone auto-connecting wall nodes.
+
+walls.register(name, desc, texture, mat, sounds)
+^ name = "walls:stone_wall". Node name.
+^ desc = "A Stone wall"
+^ texture = "default_stone.png"
+^ mat = "default:stone". Used to auto-generate crafting recipe.
+^ sounds = sounds: see [#Default sounds]
+
+Farming API
+-----------
+
+The farming API allows you to easily register plants and hoes.
+
+`farming.register_hoe(name, hoe definition)`
+ * Register a new hoe, see [#hoe definition]
+
+`farming.register_plant(name, Plant definition)`
+ * Register a new growing plant, see [#Plant definition]
+
+`farming.registered_plants[name] = definition`
+ * Table of registered plants, indexed by plant name
+
+### Hoe Definition
+
+
+	{
+		description = "",                      -- Description for tooltip
+		inventory_image = "unknown_item.png",  -- Image to be used as wield- and inventory image
+		max_uses = 30,                         -- Uses until destroyed
+		material = "",                         -- Material for recipes
+		recipe = {                             -- Craft recipe, if material isn't used
+			{"air", "air", "air"},
+			{"", "group:stick"},
+			{"", "group:stick"},
+		}
+	}
+
+### Plant definition
+
+	{
+		description = "",                      -- Description of seed item
+		inventory_image = "unknown_item.png",  -- Image to be used as seed's wield- and inventory image
+		steps = 8,                             -- How many steps the plant has to grow, until it can be harvested
+		-- ^ Always provide a plant texture for each step, format: modname_plantname_i.png (i = stepnumber)
+		minlight = 13,                         -- Minimum light to grow
+		maxlight = default.LIGHT_MAX           -- Maximum light to grow
+	}
+
+Fire API
+--------
+
+New node def property:
+
+`on_burn(pos)`
+
+ * Called when fire attempts to remove a burning node.
+ * `pos` Position of the burning node.
+
+ `on_ignite(pos, igniter)`
+
+  * Called when Flint and steel (or a mod defined ignitor) is used on a node.
+    Defining it may prevent the default action (spawning flames) from triggering.
+  * `pos` Position of the ignited node.
+  * `igniter` Player that used the tool, when available.
+
+
+Give Initial Stuff API
+----------------------
+
+`give_initial_stuff.give(player)`
+
+^ Give initial stuff to "player"
+
+`give_initial_stuff.add(stack)`
+
+^ Add item to the initial stuff
+^ Stack can be an ItemStack or a item name eg: "default:dirt 99"
+^ Can be called after the game has loaded
+
+`give_initial_stuff.clear()`
+
+^ Removes all items from the initial stuff
+^ Can be called after the game has loaded
+
+`give_initial_stuff.get_list()`
+
+^ returns list of item stacks
+
+`give_initial_stuff.set_list(list)`
+
+^ List of initial items with numeric indices.
+
+`give_initial_stuff.add_from_csv(str)`
+
+^ str is a comma separated list of initial stuff
+^ Adds items to the list of items to be given
+
+
+TNT API
+----------
+
+`tnt.register_tnt(definition)`
+
+^ Register a new type of tnt.
+
+ * `name` The name of the node. If no prefix is given `tnt` is used.
+ * `description` A description for your TNT.
+ * `radius` The radius within which the TNT can destroy nodes. The default is 3.
+ * `damage_radius` The radius within which the TNT can damage players and mobs. By default it is twice the `radius`.
+ * `disable_drops` Disable drops. By default it is set to false.
+ * `ignore_protection` Don't check `minetest.is_protected` before removing a node.
+ * `ignore_on_blast` Don't call `on_blast` even if a node has one.
+ * `tiles` Textures for node
+  * `side`  Side tiles. By default the name of the tnt with a suffix of `_side.png`.
+  * `top`  Top tile. By default the name of the tnt with a suffix of `_top.png`.
+  * `bottom` Bottom tile. By default the name of the tnt with a suffix of `_bottom.png`.
+  * `burning` Top tile when lit. By default the name of the tnt with a suffix of `_top_burning_animated.png".
+
+`tnt.boom(position, definition)`
+
+^ Create an explosion.
+
+* `position` The center of explosion.
+* `definition` The TNT definion as passed to `tnt.register`
+
+`tnt.burn(position, [nodename])`
+
+^ Ignite node at position, triggering its `on_ignite` callback (see fire mod).
+If no such callback exists, fallback to turn tnt group nodes to their
+"_burning" variant.
+  nodename isn't required unless already known.
+
+To make dropping items from node inventories easier, you can use the
+following helper function from 'default':
+
+default.get_inventory_drops(pos, inventory, drops)
+
+^ Return drops from node inventory "inventory" in drops.
+
+* `pos` - the node position
+* `inventory` - the name of the inventory (string)
+* `drops` - an initialized list
+
+The function returns no values. The drops are returned in the `drops`
+parameter, and drops is not reinitialized so you can call it several
+times in a row to add more inventory items to it.
+
+
+`on_blast` callbacks:
+
+Both nodedefs and entitydefs can provide an `on_blast()` callback
+
+`nodedef.on_blast(pos, intensity)`
+^ Allow drop and node removal overriding
+* `pos` - node position
+* `intensity` - TNT explosion measure. larger or equal to 1.0
+^ Should return a list of drops (e.g. {"default:stone"})
+^ Should perform node removal itself. If callback exists in the nodedef
+^ then the TNT code will not destroy this node.
+
+`entitydef.on_blast(luaobj, damage)`
+^ Allow TNT effects on entities to be overridden
+* `luaobj` - LuaEntityRef of the entity
+* `damage` - suggested HP damage value
+^ Should return a list of (bool do_damage, bool do_knockback, table drops)
+* `do_damage` - if true then TNT mod wil damage the entity
+* `do_knockback` - if true then TNT mod will knock the entity away
+* `drops` - a list of drops, e.g. {"wool:red"}
+
+
+Screwdriver API
+---------------
+
+The screwdriver API allows you to control a node's behaviour when a screwdriver is used on it.
+To use it, add the `on_screwdriver` function to the node definition.
+
+`on_rotate(pos, node, user, mode, new_param2)`
+
+ * `pos` Position of the node that the screwdriver is being used on
+ * `node` that node
+ * `user` The player who used the screwdriver
+ * `mode` screwdriver.ROTATE_FACE or screwdriver.ROTATE_AXIS
+ * `new_param2` the new value of param2 that would have been set if on_rotate wasn't there
+ * return value: false to disallow rotation, nil to keep default behaviour, true to allow
+ 	it but to indicate that changed have already been made (so the screwdriver will wear out)
+ * use `on_rotate = false` to always disallow rotation
+ * use `on_rotate = screwdriver.rotate_simple` to allow only face rotation
+
+
+Sethome API
+-----------
+
+The sethome API adds three global functions to allow mods to read a players home position,
+set a players home position and teleport a player to home position.
+
+`sethome.get(name)`
+
+ * `name` Player who's home position you wish to get
+ * return value: false if no player home coords exist, position table if true
+
+`sethome.set(name, pos)`
+
+ * `name` Player who's home position you wish to set
+ * `pos` Position table containing coords of home position
+ * return value: false if unable to set and save new home position, otherwise true
+
+`sethome.go(name)`
+
+ * `name` Player you wish to teleport to their home position
+ * return value: false if player cannot be sent home, otherwise true
+
+
+Sfinv API
+---------
+
+### sfinv Methods
+
+**Pages**
+
+* sfinv.set_page(player, pagename) - changes the page
+* sfinv.get_homepage_name(player) - get the page name of the first page to show to a player
+* sfinv.register_page(name, def) - register a page, see section below
+* sfinv.override_page(name, def) - overrides fields of an page registered with register_page.
+    * Note: Page must already be defined, (opt)depend on the mod defining it.
+* sfinv.set_player_inventory_formspec(player) - (re)builds page formspec
+             and calls set_inventory_formspec().
+* sfinv.get_formspec(player, context) - builds current page's formspec
+
+**Contexts**
+
+* sfinv.get_or_create_context(player) - gets the player's context
+* sfinv.set_context(player, context)
+
+**Theming**
+
+* sfinv.make_formspec(player, context, content, show_inv, size) - adds a theme to a formspec
+    * show_inv, defaults to false. Whether to show the player's main inventory
+    * size, defaults to `size[8,8.6]` if not specified
+* sfinv.get_nav_fs(player, context, nav, current_idx) - creates tabheader or ""
+
+### sfinv Members
+
+* pages - table of pages[pagename] = def
+* pages_unordered - array table of pages in order of addition (used to build navigation tabs).
+* contexts - contexts[playername] = player_context
+* enabled - set to false to disable. Good for inventory rehaul mods like unified inventory
+
+### Context
+
+A table with these keys:
+
+* page - current page name
+* nav - a list of page names
+* nav_titles - a list of page titles
+* nav_idx - current nav index (in nav and nav_titles)
+* any thing you want to store
+    * sfinv will clear the stored data on log out / log in
+
+### sfinv.register_page
+
+sfinv.register_page(name, def)
+
+def is a table containing:
+
+* `title` - human readable page name (required)
+* `get(self, player, context)` - returns a formspec string. See formspec variables. (required)
+* `is_in_nav(self, player, context)` - return true to show in the navigation (the tab header, by default)
+* `on_player_receive_fields(self, player, context, fields)` - on formspec submit.
+* `on_enter(self, player, context)` - called when the player changes pages, usually using the tabs.
+* `on_leave(self, player, context)` - when leaving this page to go to another, called before other's on_enter
+
+### get formspec
+
+Use sfinv.make_formspec to apply a layout:
+
+	return sfinv.make_formspec(player, context, [[
+		list[current_player;craft;1.75,0.5;3,3;]
+		list[current_player;craftpreview;5.75,1.5;1,1;]
+		image[4.75,1.5;1,1;gui_furnace_arrow_bg.png^[transformR270]
+		listring[current_player;main]
+		listring[current_player;craft]
+		image[0,4.25;1,1;gui_hb_bg.png]
+		image[1,4.25;1,1;gui_hb_bg.png]
+		image[2,4.25;1,1;gui_hb_bg.png]
+		image[3,4.25;1,1;gui_hb_bg.png]
+		image[4,4.25;1,1;gui_hb_bg.png]
+		image[5,4.25;1,1;gui_hb_bg.png]
+		image[6,4.25;1,1;gui_hb_bg.png]
+		image[7,4.25;1,1;gui_hb_bg.png]
+	]], true)
+
+See above (methods section) for more options.
+
+### Customising themes
+
+Simply override this function to change the navigation:
+
+	function sfinv.get_nav_fs(player, context, nav, current_idx)
+		return "navformspec"
+	end
+
+And override this function to change the layout:
+
+	function sfinv.make_formspec(player, context, content, show_inv, size)
+		local tmp = {
+			size or "size[8,8.6]",
+			theme_main,
+			sfinv.get_nav_fs(player, context, context.nav_titles, context.nav_idx),
+			content
+		}
+		if show_inv then
+			tmp[4] = theme_inv
+		end
+		return table.concat(tmp, "")
+	end
+
+Stairs API
+----------
+
+The stairs API lets you register stairs and slabs and ensures that they are registered the same way as those
+delivered with Minetest Game, to keep them compatible with other mods.
+
+`stairs.register_stair(subname, recipeitem, groups, images, description, sounds)`
+
+ * Registers a stair.
+ * `subname`: Basically the material name (e.g. cobble) used for the stair name. Nodename pattern: "stairs:stair_subname"
+ * `recipeitem`: Item used in the craft recipe, e.g. "default:cobble", may be `nil`
+ * `groups`: see [Known damage and digging time defining groups]
+ * `images`: see [Tile definition]
+ * `description`: used for the description field in the stair's definition
+ * `sounds`: see [#Default sounds]
+
+`stairs.register_slab(subname, recipeitem, groups, images, description, sounds)`
+
+ * Registers a slabs
+ * `subname`: Basically the material name (e.g. cobble) used for the stair name. Nodename pattern: "stairs:stair_subname"
+ * `recipeitem`: Item used in the craft recipe, e.g. "default:cobble"
+ * `groups`: see [Known damage and digging time defining groups]
+ * `images`: see [Tile definition]
+ * `description`: used for the description field in the stair's definition
+ * `sounds`: see [#Default sounds]
+
+`stairs.register_stair_and_slab(subname, recipeitem, groups, images, desc_stair, desc_slab, sounds)`
+
+ * A wrapper for stairs.register_stair and stairs.register_slab
+ * Uses almost the same arguments as stairs.register_stair
+ * `desc_stair`: Description for stair node
+ * `desc_slab`: Description for slab node
+
+Xpanes API
+----------
+
+Creates panes that automatically connect to each other
+
+`xpanes.register_pane(subname, def)`
+
+ * `subname`: used for nodename. Result: "xpanes:subname" and "xpanes:subname_{2..15}"
+ * `def`: See [#Pane definition]
+
+### Pane definition
+
+	{
+		textures = {"texture for sides", (unused), "texture for top and bottom"}, -- More tiles aren't supported
+		groups = {group = rating}, -- Uses the known node groups, see [Known damage and digging time defining groups]
+		sounds = SoundSpec,        -- See [#Default sounds]
+		recipe = {{"","","","","","","","",""}}, -- Recipe field only
+	}
+
+Raillike definitions
+--------------------
+
+The following nodes use the group `connect_to_raillike` and will only connect to
+raillike nodes within this group and the same group value.
+Use `minetest.raillike_group(<Name>)` to get the group value.
+
+| Node type             | Raillike group name
+|-----------------------|---------------------
+| default:rail          | "rail"
+| tnt:gunpowder         | "gunpowder"
+| tnt:gunpowder_burning	| "gunpowder"
+
+Example:
+If you want to add a new rail type and want it to connect with default:rail,
+add `connect_to_raillike=minetest.raillike_group("rail")` into the `groups` table
+of your node.
+
+
+Default sounds
+--------------
+
+Sounds inside the default table can be used within the sounds field of node definitions.
+
+ * `default.node_sound_defaults()`
+ * `default.node_sound_stone_defaults()`
+ * `default.node_sound_dirt_defaults()`
+ * `default.node_sound_sand_defaults()`
+ * `default.node_sound_wood_defaults()`
+ * `default.node_sound_leaves_defaults()`
+ * `default.node_sound_glass_defaults()`
+ * `default.node_sound_metal_defaults()`
+
+Default constants
+-----------------
+
+`default.LIGHT_MAX`  The maximum light level (see [Node definition] light_source)
+
+Player API
+----------
+
+The player API can register player models and update the player's appearence
+
+`default.player_register_model(name, def)`
+
+ * Register a new model to be used by players.
+ * name: model filename such as "character.x", "foo.b3d", etc.
+ * def: See [#Model definition]
+
+`default.registered_player_models[name]`
+
+ * Get a model's definition
+ * see [#Model definition]
+
+`default.player_set_model(player, model_name)`
+
+ * Change a player's model
+ * `player`: PlayerRef
+ * `model_name`: model registered with player_register_model()
+
+`default.player_set_animation(player, anim_name [, speed])`
+
+ * Applies an animation to a player
+ * anim_name: name of the animation.
+ * speed: frames per second. If nil, default from the model is used
+
+`default.player_set_textures(player, textures)`
+
+ * Sets player textures
+ * `player`: PlayerRef
+ * `textures`: array of textures, If `textures` is nil, the default textures from the model def are used
+
+default.player_get_animation(player)
+
+ * Returns a table containing fields `model`, `textures` and `animation`.
+ * Any of the fields of the returned table may be nil.
+ * player: PlayerRef
+
+### Model Definition
+
+	{
+		animation_speed = 30,            -- Default animation speed, in FPS.
+		textures = {"character.png", },  -- Default array of textures.
+		visual_size = {x = 1, y = 1},    -- Used to scale the model.
+		animations = {
+			-- <anim_name> = {x = <start_frame>, y = <end_frame>},
+			foo = {x = 0, y = 19},
+			bar = {x = 20, y = 39},
+		-- ...
+		},
+	}
+
+Leafdecay
+---------
+
+To enable leaf decay for leaves when a tree is cut down by a player,
+register the tree with the default.register_leafdecay(leafdecaydef)
+function.
+
+If `param2` of any registered node is ~= 0, the node will always be
+preserved. Thus, if the player places a node of that kind, you will
+want to set `param2 = 1` or so.
+
+The function `default.after_place_leaves` can be set as
+`after_place_node of a node` to set param2 to 1 if the player places
+the node (should not be used for nodes that use param2 otherwise
+(e.g. facedir)).
+
+If the node is in the `leafdecay_drop` group then it will always be
+dropped as an item.
+
+`default.register_leafdecay(leafdecaydef)`
+
+`leafdecaydef` is a table, with following members:
+	{
+		trunks = {"default:tree"}, -- nodes considered trunks
+		leaves = {"default:leaves", "default:apple"},
+			-- nodes considered for removal
+		radius = 3, -- radius to consider for searching
+	}
+
+Note: all the listed nodes in `trunks` have their `on_after_destruct`
+callback overridden. All the nodes listed in `leaves` have their
+`on_timer` callback overridden.
+
+
+Dyes
+----
+
+To make recipes that will work with any dye ever made by anybody, define
+them based on groups. You can select any group of groups, based on your need for
+amount of colors.
+
+### Color groups
+
+Base color groups:
+
+ * `basecolor_white`
+ * `basecolor_grey`
+ * `basecolor_black`
+ * `basecolor_red`
+ * `basecolor_yellow`
+ * `basecolor_green`
+ * `basecolor_cyan`
+ * `basecolor_blue`
+ * `basecolor_magenta`
+
+Extended color groups ( * means also base color )
+
+ * `excolor_white` *
+ * `excolor_lightgrey`
+ * `excolor_grey` *
+ * `excolor_darkgrey`
+ * `excolor_black` *
+ * `excolor_red` *
+ * `excolor_orange`
+ * `excolor_yellow` *
+ * `excolor_lime`
+ * `excolor_green` *
+ * `excolor_aqua`
+ * `excolor_cyan` *
+ * `excolor_sky_blue`
+ * `excolor_blue` *
+ * `excolor_violet`
+ * `excolor_magenta` *
+ * `excolor_red_violet`
+
+The whole unifieddyes palette as groups:
+
+ * `unicolor_<excolor>`
+
+For the following, no white/grey/black is allowed:
+
+ * `unicolor_medium_<excolor>`
+ * `unicolor_dark_<excolor>`
+ * `unicolor_light_<excolor>`
+ * `unicolor_<excolor>_s50`
+ * `unicolor_medium_<excolor>_s50`
+ * `unicolor_dark_<excolor>_s50`
+
+Example of one shapeless recipe using a color group:
+
+	minetest.register_craft({
+		type = "shapeless",
+		output = '<mod>:item_yellow',
+		recipe = {'<mod>:item_no_color', 'group:basecolor_yellow'},
+	})
+
+### Color lists
+
+ * `dye.basecolors` are an array containing the names of available base colors
+
+ * `dye.excolors` are an array containing the names of the available extended colors
+
+Trees
+-----
+
+ * `default.grow_tree(pos, is_apple_tree)`
+  * Grows a mgv6 tree or apple tree at pos
+
+ * `default.grow_jungle_tree(pos)`
+  * Grows a mgv6 jungletree at pos
+
+ * `default.grow_pine_tree(pos)`
+  * Grows a mgv6 pinetree at pos
+
+ * `default.grow_new_apple_tree(pos)`
+  * Grows a new design apple tree at pos
+
+ * `default.grow_new_jungle_tree(pos)`
+  * Grows a new design jungle tree at pos
+
+ * `default.grow_new_pine_tree(pos)`
+  * Grows a new design pine tree at pos
+
+ * `default.grow_new_snowy_pine_tree(pos)`
+  * Grows a new design snowy pine tree at pos
+
+ * `default.grow_new_acacia_tree(pos)`
+  * Grows a new design acacia tree at pos
+
+ * `default.grow_new_aspen_tree(pos)`
+  * Grows a new design aspen tree at pos
+
+ * `default.grow_bush(pos)`
+  * Grows a bush at pos
+
+ * `default.grow_acacia_bush(pos)`
+  * Grows an acaia bush at pos
+
+Carts
+-----
+
+	carts.register_rail(
+		"mycarts:myrail", -- Rail name
+		nodedef,          -- standard nodedef
+		railparams        -- rail parameter struct (optional)
+	)
+
+	railparams = {
+		on_step(obj, dtime), -- Event handler called when
+		                     -- cart is on rail
+		acceleration, -- integer acceleration factor (negative
+		              -- values to brake)
+	}
+
+	The event handler is called after all default calculations
+	are made, so the custom on_step handler can override things
+	like speed, acceleration, player attachment. The handler will
+	likely be called many times per second, so the function needs
+	to make sure that the event is handled properly.
+
+Key API
+-------
+
+The key API allows mods to add key functionality to nodes that have
+ownership or specific permissions. Using the API will make it so
+that a node owner can use skeleton keys on their nodes to create keys
+for that node in that location, and give that key to other players,
+allowing them some sort of access that they otherwise would not have
+due to node protection.
+
+To make your new nodes work with the key API, you need to register
+two callback functions in each nodedef:
+
+
+`on_key_use(pos, player)`
+ * Is called when a player right-clicks (uses) a normal key on your
+ * node.
+ * `pos` - position of the node
+ * `player` - PlayerRef
+ * return value: none, ignored
+
+The `on_key_use` callback should validate that the player is wielding
+a key item with the right key meta secret. If needed the code should
+deny access to the node functionality.
+
+If formspecs are used, the formspec callbacks should duplicate these
+checks in the metadata callback functions.
+
+
+`on_skeleton_key_use(pos, player, newsecret)`
+
+ * Is called when a player right-clicks (uses) a skeleton key on your
+ * node.
+ * `pos` - position of the node
+ * `player` - PlayerRef
+ * `newsecret` - a secret value(string)
+ * return values:
+ * `secret` - `nil` or the secret value that unlocks the door
+ * `name` - a string description of the node ("a locked chest")
+ * `owner` - name of the node owner
+
+The `on_skeleton_key_use` function should validate that the player has
+the right permissions to make a new key for the item. The newsecret
+value is useful if the node has no secret value. The function should
+store this secret value somewhere so that in the future it may compare
+key secrets and match them to allow access. If a node already has a
+secret value, the function should return that secret value instead
+of the newsecret value. The secret value stored for the node should
+not be overwritten, as this would invalidate existing keys.
+
+Aside from the secret value, the function should retun a descriptive
+name for the node and the owner name. The return values are all
+encoded in the key that will be given to the player in replacement
+for the wielded skeleton key.
+
+if `nil` is returned, it is assumed that the wielder did not have
+permissions to create a key for this node, and no key is created.

minetest.conf.example

@@ -0,0 +1,53 @@
+# This file contains settings of Minetest Game that can be changed in minetest.conf
+# By default, all the settings are commented and not functional.
+# Uncomment settings by removing the preceding #.
+
+# Whether creative mode (fast digging of all blocks, unlimited resources) should be enabled
+#creative_mode = false
+
+# Sets the behaviour of the inventory items when a player dies.
+#  "bones": Store all items inside a bone node but drop items if inside protected area
+#  "drop": Drop all items on the ground
+#  "keep": Player keeps all items
+#bones_mode = "bones"
+
+# The time in seconds after which the bones of a dead player can be looted by everyone
+# 0 to disable
+#share_bones_time = 1200
+
+# How much earlier the bones of a dead player can be looted by
+# everyone if the player dies in a protected area they don't own.
+# 0 to disable. By default it is "share_bones_time" divide by four.
+#share_bones_time_early = 300
+
+# Whether fire should be enabled. If disabled, 'basic flame' nodes will disappear.
+# 'permanent flame' nodes will remain with either setting.
+#enable_fire = true
+
+# Enable flame sound.
+#flame_sound = true
+
+# Whether lavacooling should be enabled.
+#enable_lavacooling = true
+
+# Whether the stuff in initial_stuff should be given to new players
+#give_initial_stuff = false
+#initial_stuff = default:pick_steel,default:axe_steel,default:shovel_steel,default:torch 99,default:cobble 99
+
+# Whether the TNT mod should be enabled
+#enable_tnt = <true in singleplayer, false in multiplayer>
+
+# The radius of a TNT explosion
+#tnt_radius = 3
+
+# Enable the stairs mod ABM that replaces the old 'upside down'
+# stair and slab nodes in old maps with the new param2 versions.
+#enable_stairs_replace_abm = false
+
+# Whether you allow respawning in beds
+# Default value is true
+#enable_bed_respawn = true
+
+# Whether players can skip night by sleeping
+# Default value is true
+#enable_bed_night_skip = true

mods/beds/README.txt

@@ -0,0 +1,26 @@
+Minetest Game mod: beds
+=======================
+See license.txt for license information.
+
+Authors of source code
+----------------------
+Originally by BlockMen (MIT)
+Various Minetest developers and contributors (MIT)
+
+Authors of media (textures)
+---------------------------
+BlockMen (CC BY-SA 3.0)
+
+This mod adds a bed to Minetest which allows to skip the night.
+To sleep, rightclick the bed. If playing in singleplayer mode the night gets skipped
+immediately. If playing multiplayer you get shown how many other players are in bed too,
+if all players are sleeping the night gets skipped. The night skip can be forced if more
+than 50% of the players are lying in bed and use this option.
+
+Another feature is a controlled respawning. If you have slept in bed (not just lying in
+it) your respawn point is set to the beds location and you will respawn there after
+death.
+You can disable the respawn at beds by setting "enable_bed_respawn = false" in
+minetest.conf.
+You can disable the night skip feature by setting "enable_bed_night_skip = false" in
+minetest.conf or by using the /set command in-game.

mods/beds/api.lua

@@ -0,0 +1,167 @@
+
+local reverse = true
+
+local function destruct_bed(pos, n)
+	local node = minetest.get_node(pos)
+	local other
+
+	if n == 2 then
+		local dir = minetest.facedir_to_dir(node.param2)
+		other = vector.subtract(pos, dir)
+	elseif n == 1 then
+		local dir = minetest.facedir_to_dir(node.param2)
+		other = vector.add(pos, dir)
+	end
+
+	if reverse then
+		reverse = not reverse
+		minetest.remove_node(other)
+		minetest.check_for_falling(other)
+	else
+		reverse = not reverse
+	end
+end
+
+function beds.register_bed(name, def)
+	minetest.register_node(name .. "_bottom", {
+		description = def.description,
+		inventory_image = def.inventory_image,
+		wield_image = def.wield_image,
+		drawtype = "nodebox",
+		tiles = def.tiles.bottom,
+		paramtype = "light",
+		paramtype2 = "facedir",
+		is_ground_content = false,
+		stack_max = 1,
+		groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 3, bed = 1},
+		sounds = def.sounds or default.node_sound_wood_defaults(),
+		node_box = {
+			type = "fixed",
+			fixed = def.nodebox.bottom,
+		},
+		selection_box = {
+			type = "fixed",
+			fixed = def.selectionbox,
+		},
+
+		on_place = function(itemstack, placer, pointed_thing)
+			local under = pointed_thing.under
+			local node = minetest.get_node(under)
+			local udef = minetest.registered_nodes[node.name]
+			if udef and udef.on_rightclick and
+					not (placer and placer:get_player_control().sneak) then
+				return udef.on_rightclick(under, node, placer, itemstack,
+					pointed_thing) or itemstack
+			end
+
+			local pos
+			if minetest.registered_items[minetest.get_node(under).name].buildable_to then
+				pos = under
+			else
+				pos = pointed_thing.above
+			end
+
+			if minetest.is_protected(pos, placer:get_player_name()) and
+					not minetest.check_player_privs(placer, "protection_bypass") then
+				minetest.record_protection_violation(pos, placer:get_player_name())
+				return itemstack
+			end
+
+			local node_def = minetest.registered_nodes[minetest.get_node(pos).name]
+			if not node_def or not node_def.buildable_to then
+				return itemstack
+			end
+
+			local dir = minetest.dir_to_facedir(placer:get_look_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 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 (creative and creative.is_enabled_for
+					and creative.is_enabled_for(placer:get_player_name())) then
+				itemstack:take_item()
+			end
+			return itemstack
+		end,
+
+		on_destruct = function(pos)
+			destruct_bed(pos, 1)
+		end,
+
+		on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
+			beds.on_rightclick(pos, clicker)
+			return itemstack
+		end,
+
+		on_rotate = function(pos, node, user, mode, new_param2)
+			local dir = minetest.facedir_to_dir(node.param2)
+			local p = vector.add(pos, dir)
+			local node2 = minetest.get_node_or_nil(p)
+			if not node2 or not minetest.get_item_group(node2.name, "bed") == 2 or
+					not node.param2 == node2.param2 then
+				return false
+			end
+			if minetest.is_protected(p, user:get_player_name()) then
+				minetest.record_protection_violation(p, user:get_player_name())
+				return false
+			end
+			if mode ~= screwdriver.ROTATE_FACE then
+				return false
+			end
+			local newp = vector.add(pos, minetest.facedir_to_dir(new_param2))
+			local node3 = minetest.get_node_or_nil(newp)
+			local node_def = node3 and minetest.registered_nodes[node3.name]
+			if not node_def or not node_def.buildable_to then
+				return false
+			end
+			if minetest.is_protected(newp, user:get_player_name()) then
+				minetest.record_protection_violation(newp, user:get_player_name())
+				return false
+			end
+			node.param2 = new_param2
+			-- do not remove_node here - it will trigger destroy_bed()
+			minetest.set_node(p, {name = "air"})
+			minetest.set_node(pos, node)
+			minetest.set_node(newp, {name = name .. "_top", param2 = new_param2})
+			return true
+		end,
+	})
+
+	minetest.register_node(name .. "_top", {
+		drawtype = "nodebox",
+		tiles = def.tiles.top,
+		paramtype = "light",
+		paramtype2 = "facedir",
+		is_ground_content = false,
+		pointable = false,
+		groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 3, bed = 2},
+		sounds = def.sounds or default.node_sound_wood_defaults(),
+		drop = name .. "_bottom",
+		node_box = {
+			type = "fixed",
+			fixed = def.nodebox.top,
+		},
+		on_destruct = function(pos)
+			destruct_bed(pos, 2)
+		end,
+	})
+
+	minetest.register_alias(name, name .. "_bottom")
+
+	minetest.register_craft({
+		output = name,
+		recipe = def.recipe
+	})
+end

mods/beds/beds.lua

@@ -0,0 +1,104 @@
+-- Fancy shaped bed
+
+beds.register_bed("beds:fancy_bed", {
+	description = "Fancy Bed",
+	inventory_image = "beds_bed_fancy.png",
+	wield_image = "beds_bed_fancy.png",
+	tiles = {
+		bottom = {
+			"beds_bed_top1.png",
+			"default_wood.png",
+			"beds_bed_side1.png",
+			"beds_bed_side1.png^[transformFX",
+			"default_wood.png",
+			"beds_bed_foot.png",
+		},
+		top = {
+			"beds_bed_top2.png",
+			"default_wood.png",
+			"beds_bed_side2.png",
+			"beds_bed_side2.png^[transformFX",
+			"beds_bed_head.png",
+			"default_wood.png",
+		}
+	},
+	nodebox = {
+		bottom = {
+			{-0.5, -0.5, -0.5, -0.375, -0.065, -0.4375},
+			{0.375, -0.5, -0.5, 0.5, -0.065, -0.4375},
+			{-0.5, -0.375, -0.5, 0.5, -0.125, -0.4375},
+			{-0.5, -0.375, -0.5, -0.4375, -0.125, 0.5},
+			{0.4375, -0.375, -0.5, 0.5, -0.125, 0.5},
+			{-0.4375, -0.3125, -0.4375, 0.4375, -0.0625, 0.5},
+		},
+		top = {
+			{-0.5, -0.5, 0.4375, -0.375, 0.1875, 0.5},
+			{0.375, -0.5, 0.4375, 0.5, 0.1875, 0.5},
+			{-0.5, 0, 0.4375, 0.5, 0.125, 0.5},
+			{-0.5, -0.375, 0.4375, 0.5, -0.125, 0.5},
+			{-0.5, -0.375, -0.5, -0.4375, -0.125, 0.5},
+			{0.4375, -0.375, -0.5, 0.5, -0.125, 0.5},
+			{-0.4375, -0.3125, -0.5, 0.4375, -0.0625, 0.4375},
+		}
+	},
+	selectionbox = {-0.5, -0.5, -0.5, 0.5, 0.06, 1.5},
+	recipe = {
+		{"", "", "group:stick"},
+		{"wool:red", "wool:red", "wool:white"},
+		{"group:wood", "group:wood", "group:wood"},
+	},
+})
+
+-- Simple shaped bed
+
+beds.register_bed("beds:bed", {
+	description = "Simple Bed",
+	inventory_image = "beds_bed.png",
+	wield_image = "beds_bed.png",
+	tiles = {
+		bottom = {
+			"beds_bed_top_bottom.png^[transformR90",
+			"default_wood.png",
+			"beds_bed_side_bottom_r.png",
+			"beds_bed_side_bottom_r.png^[transformfx",
+			"beds_transparent.png",
+			"beds_bed_side_bottom.png"
+		},
+		top = {
+			"beds_bed_top_top.png^[transformR90",
+			"default_wood.png",
+			"beds_bed_side_top_r.png",
+			"beds_bed_side_top_r.png^[transformfx",
+			"beds_bed_side_top.png",
+			"beds_transparent.png",
+		}
+	},
+	nodebox = {
+		bottom = {-0.5, -0.5, -0.5, 0.5, 0.06, 0.5},
+		top = {-0.5, -0.5, -0.5, 0.5, 0.06, 0.5},
+	},
+	selectionbox = {-0.5, -0.5, -0.5, 0.5, 0.06, 1.5},
+	recipe = {
+		{"wool:red", "wool:red", "wool:white"},
+		{"group:wood", "group:wood", "group:wood"}
+	},
+})
+
+-- Aliases for PilzAdam's beds mod
+
+minetest.register_alias("beds:bed_bottom_red", "beds:bed_bottom")
+minetest.register_alias("beds:bed_top_red", "beds:bed_top")
+
+-- Fuel
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "beds:fancy_bed_bottom",
+	burntime = 13,
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "beds:bed_bottom",
+	burntime = 12,
+})

mods/beds/depends.txt

@@ -0,0 +1,2 @@
+default
+wool

mods/beds/functions.lua

@@ -0,0 +1,220 @@
+local pi = math.pi
+local player_in_bed = 0
+local is_sp = minetest.is_singleplayer()
+local enable_respawn = minetest.settings:get_bool("enable_bed_respawn")
+if enable_respawn == nil then
+	enable_respawn = true
+end
+
+-- Helper functions
+
+local function get_look_yaw(pos)
+	local n = minetest.get_node(pos)
+	if n.param2 == 1 then
+		return pi / 2, n.param2
+	elseif n.param2 == 3 then
+		return -pi / 2, n.param2
+	elseif n.param2 == 0 then
+		return pi, n.param2
+	else
+		return 0, n.param2
+	end
+end
+
+local function is_night_skip_enabled()
+	local enable_night_skip = minetest.settings:get_bool("enable_bed_night_skip")
+	if enable_night_skip == nil then
+		enable_night_skip = true
+	end
+	return enable_night_skip
+end
+
+local function check_in_beds(players)
+	local in_bed = beds.player
+	if not players then
+		players = minetest.get_connected_players()
+	end
+
+	for n, player in ipairs(players) do
+		local name = player:get_player_name()
+		if not in_bed[name] then
+			return false
+		end
+	end
+
+	return #players > 0
+end
+
+local function lay_down(player, pos, bed_pos, state, skip)
+	local name = player:get_player_name()
+	local hud_flags = player:hud_get_flags()
+
+	if not player or not name then
+		return
+	end
+
+	-- stand up
+	if state ~= nil and not state then
+		local p = beds.pos[name] or nil
+		if beds.player[name] ~= nil then
+			beds.player[name] = nil
+			player_in_bed = player_in_bed - 1
+		end
+		-- skip here to prevent sending player specific changes (used for leaving players)
+		if skip then
+			return
+		end
+		if p then
+			player:setpos(p)
+		end
+
+		-- physics, eye_offset, etc
+		player:set_eye_offset({x = 0, y = 0, z = 0}, {x = 0, y = 0, z = 0})
+		player:set_look_horizontal(math.random(1, 180) / 100)
+		default.player_attached[name] = false
+		player:set_physics_override(1, 1, 1)
+		hud_flags.wielditem = true
+		default.player_set_animation(player, "stand" , 30)
+
+	-- lay down
+	else
+		beds.player[name] = 1
+		beds.pos[name] = pos
+		player_in_bed = player_in_bed + 1
+
+		-- physics, eye_offset, etc
+		player:set_eye_offset({x = 0, y = -13, z = 0}, {x = 0, y = 0, z = 0})
+		local yaw, param2 = get_look_yaw(bed_pos)
+		player:set_look_horizontal(yaw)
+		local dir = minetest.facedir_to_dir(param2)
+		local p = {x = bed_pos.x + dir.x / 2, y = bed_pos.y, z = bed_pos.z + dir.z / 2}
+		player:set_physics_override(0, 0, 0)
+		player:setpos(p)
+		default.player_attached[name] = true
+		hud_flags.wielditem = false
+		default.player_set_animation(player, "lay" , 0)
+	end
+
+	player:hud_set_flags(hud_flags)
+end
+
+local function update_formspecs(finished)
+	local ges = #minetest.get_connected_players()
+	local form_n
+	local is_majority = (ges / 2) < player_in_bed
+
+	if finished then
+		form_n = beds.formspec .. "label[2.7,11; Good morning.]"
+	else
+		form_n = beds.formspec .. "label[2.2,11;" .. tostring(player_in_bed) ..
+			" of " .. tostring(ges) .. " players are in bed]"
+		if is_majority and is_night_skip_enabled() then
+			form_n = form_n .. "button_exit[2,8;4,0.75;force;Force night skip]"
+		end
+	end
+
+	for name,_ in pairs(beds.player) do
+		minetest.show_formspec(name, "beds_form", form_n)
+	end
+end
+
+
+-- Public functions
+
+function beds.kick_players()
+	for name, _ in pairs(beds.player) do
+		local player = minetest.get_player_by_name(name)
+		lay_down(player, nil, nil, false)
+	end
+end
+
+function beds.skip_night()
+	minetest.set_timeofday(0.23)
+end
+
+function beds.on_rightclick(pos, player)
+	local name = player:get_player_name()
+	local ppos = player:getpos()
+	local tod = minetest.get_timeofday()
+
+	if tod > 0.2 and tod < 0.805 then
+		if beds.player[name] then
+			lay_down(player, nil, nil, false)
+		end
+		minetest.chat_send_player(name, "You can only sleep at night.")
+		return
+	end
+
+	-- move to bed
+	if not beds.player[name] then
+		lay_down(player, ppos, pos)
+		beds.set_spawns() -- save respawn positions when entering bed
+	else
+		lay_down(player, nil, nil, false)
+	end
+
+	if not is_sp then
+		update_formspecs(false)
+	end
+
+	-- skip the night and let all players stand up
+	if check_in_beds() then
+		minetest.after(2, function()
+			if not is_sp then
+				update_formspecs(is_night_skip_enabled())
+			end
+			if is_night_skip_enabled() then
+				beds.skip_night()
+				beds.kick_players()
+			end
+		end)
+	end
+end
+
+
+-- Callbacks
+-- Only register respawn callback if respawn enabled
+if enable_respawn then
+	-- respawn player at bed if enabled and valid position is found
+	minetest.register_on_respawnplayer(function(player)
+		local name = player:get_player_name()
+		local pos = beds.spawn[name]
+		if pos then
+			player:setpos(pos)
+			return true
+		end
+	end)
+end
+
+minetest.register_on_leaveplayer(function(player)
+	local name = player:get_player_name()
+	lay_down(player, nil, nil, false, true)
+	beds.player[name] = nil
+	if check_in_beds() then
+		minetest.after(2, function()
+			update_formspecs(is_night_skip_enabled())
+			if is_night_skip_enabled() then
+				beds.skip_night()
+				beds.kick_players()
+			end
+		end)
+	end
+end)
+
+minetest.register_on_player_receive_fields(function(player, formname, fields)
+	if formname ~= "beds_form" then
+		return
+	end
+	if fields.quit or fields.leave then
+		lay_down(player, nil, nil, false)
+		update_formspecs(false)
+	end
+
+	if fields.force then
+		update_formspecs(is_night_skip_enabled())
+		if is_night_skip_enabled() then
+			beds.skip_night()
+			beds.kick_players()
+		end
+	end
+end)

mods/beds/init.lua

@@ -0,0 +1,17 @@
+beds = {}
+beds.player = {}
+beds.pos = {}
+beds.spawn = {}
+
+beds.formspec = "size[8,15;true]" ..
+	"bgcolor[#080808BB; true]" ..
+	"button_exit[2,12;4,0.75;leave;Leave Bed]"
+
+local modpath = minetest.get_modpath("beds")
+
+-- Load files
+
+dofile(modpath .. "/functions.lua")
+dofile(modpath .. "/api.lua")
+dofile(modpath .. "/beds.lua")
+dofile(modpath .. "/spawns.lua")

mods/beds/license.txt

@@ -0,0 +1,60 @@
+License of source code
+----------------------
+
+The MIT License (MIT)
+Copyright (C) 2014-2016 BlockMen
+Copyright (C) 2014-2016 Various Minetest developers and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+For more details:
+https://opensource.org/licenses/MIT
+
+
+Licenses of media (textures)
+----------------------------
+
+Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
+Copyright (C) 2014-2016 BlockMen
+
+You are free to:
+Share — copy and redistribute the material in any medium or format.
+Adapt — remix, transform, and build upon the material for any purpose, even commercially.
+The licensor cannot revoke these freedoms as long as you follow the license terms.
+
+Under the following terms:
+
+Attribution — You must give appropriate credit, provide a link to the license, and
+indicate if changes were made. You may do so in any reasonable manner, but not in any way
+that suggests the licensor endorses you or your use.
+
+ShareAlike — If you remix, transform, or build upon the material, you must distribute
+your contributions under the same license as the original.
+
+No additional restrictions — You may not apply legal terms or technological measures that
+legally restrict others from doing anything the license permits.
+
+Notices:
+
+You do not have to comply with the license for elements of the material in the public
+domain or where your use is permitted by an applicable exception or limitation.
+No warranties are given. The license may not give you all of the permissions necessary
+for your intended use. For example, other rights such as publicity, privacy, or moral
+rights may limit how you use the material.
+
+For more details:
+http://creativecommons.org/licenses/by-sa/3.0/

mods/beds/spawns.lua

@@ -0,0 +1,63 @@
+local world_path = minetest.get_worldpath()
+local org_file = world_path .. "/beds_spawns"
+local file = world_path .. "/beds_spawns"
+local bkwd = false
+
+-- check for PA's beds mod spawns
+local cf = io.open(world_path .. "/beds_player_spawns", "r")
+if cf ~= nil then
+	io.close(cf)
+	file = world_path .. "/beds_player_spawns"
+	bkwd = true
+end
+
+function beds.read_spawns()
+	local spawns = beds.spawn
+	local input = io.open(file, "r")
+	if input and not bkwd then
+		repeat
+			local x = input:read("*n")
+			if x == nil then
+				break
+			end
+			local y = input:read("*n")
+			local z = input:read("*n")
+			local name = input:read("*l")
+			spawns[name:sub(2)] = {x = x, y = y, z = z}
+		until input:read(0) == nil
+		io.close(input)
+	elseif input and bkwd then
+		beds.spawn = minetest.deserialize(input:read("*all"))
+		input:close()
+		beds.save_spawns()
+		os.rename(file, file .. ".backup")
+		file = org_file
+	end
+end
+
+beds.read_spawns()
+
+function beds.save_spawns()
+	if not beds.spawn then
+		return
+	end
+	local data = {}
+	local output = io.open(org_file, "w")
+	for k, v in pairs(beds.spawn) do
+		table.insert(data, string.format("%.1f %.1f %.1f %s\n", v.x, v.y, v.z, k))
+	end
+	output:write(table.concat(data))
+	io.close(output)
+end
+
+function beds.set_spawns()
+	for name,_ in pairs(beds.player) do
+		local player = minetest.get_player_by_name(name)
+		local p = player:getpos()
+		-- but don't change spawn location if borrowing a bed
+		if not minetest.is_protected(p, name) then
+			beds.spawn[name] = p
+		end
+	end
+	beds.save_spawns()
+end

mods/boats/README.txt

@@ -0,0 +1,15 @@
+Minetest Game mod: boats
+========================
+See license.txt for license information.
+
+Authors of source code
+----------------------
+Originally by PilzAdam (MIT)
+Various Minetest developers and contributors (MIT)
+
+Authors of media (textures and model)
+-------------------------------------
+Textures: Zeg9 (CC BY-SA 3.0)
+Model: thetoon and Zeg9 (CC BY-SA 3.0),
+  modified by PavelS(SokolovPavel) (CC BY-SA 3.0),
+  modified by sofar (CC BY-SA 3.0)

mods/boats/depends.txt

@@ -1,2 +1 @@
 default
-

mods/boats/init.lua

@@ -0,0 +1,271 @@
+--
+-- Helper functions
+--
+
+local function is_water(pos)
+	local nn = minetest.get_node(pos).name
+	return minetest.get_item_group(nn, "water") ~= 0
+end
+
+
+local function get_sign(i)
+	if i == 0 then
+		return 0
+	else
+		return i / math.abs(i)
+	end
+end
+
+
+local function get_velocity(v, yaw, y)
+	local x = -math.sin(yaw) * v
+	local z =  math.cos(yaw) * v
+	return {x = x, y = y, z = z}
+end
+
+
+local function get_v(v)
+	return math.sqrt(v.x ^ 2 + v.z ^ 2)
+end
+
+--
+-- Boat entity
+--
+
+local boat = {
+	physical = true,
+	-- Warning: Do not change the position of the collisionbox top surface,
+	-- lowering it causes the boat to fall through the world if underwater
+	collisionbox = {-0.5, -0.35, -0.5, 0.5, 0.3, 0.5},
+	visual = "mesh",
+	mesh = "boats_boat.obj",
+	textures = {"default_wood.png"},
+
+	driver = nil,
+	v = 0,
+	last_v = 0,
+	removed = false
+}
+
+
+function boat.on_rightclick(self, clicker)
+	if not clicker or not clicker:is_player() then
+		return
+	end
+	local name = clicker:get_player_name()
+	if self.driver and clicker == self.driver then
+		self.driver = nil
+		clicker:set_detach()
+		default.player_attached[name] = false
+		default.player_set_animation(clicker, "stand" , 30)
+		local pos = clicker:getpos()
+		pos = {x = pos.x, y = pos.y + 0.2, z = pos.z}
+		minetest.after(0.1, function()
+			clicker:setpos(pos)
+		end)
+	elseif not self.driver then
+		local attach = clicker:get_attach()
+		if attach and attach:get_luaentity() then
+			local luaentity = attach:get_luaentity()
+			if luaentity.driver then
+				luaentity.driver = nil
+			end
+			clicker:set_detach()
+		end
+		self.driver = clicker
+		clicker:set_attach(self.object, "",
+			{x = 0, y = 11, z = -3}, {x = 0, y = 0, z = 0})
+		default.player_attached[name] = true
+		minetest.after(0.2, function()
+			default.player_set_animation(clicker, "sit" , 30)
+		end)
+		clicker:set_look_horizontal(self.object:getyaw())
+	end
+end
+
+
+function boat.on_activate(self, staticdata, dtime_s)
+	self.object:set_armor_groups({immortal = 1})
+	if staticdata then
+		self.v = tonumber(staticdata)
+	end
+	self.last_v = self.v
+end
+
+
+function boat.get_staticdata(self)
+	return tostring(self.v)
+end
+
+
+function boat.on_punch(self, puncher)
+	if not puncher or not puncher:is_player() or self.removed then
+		return
+	end
+	if self.driver and puncher == self.driver then
+		self.driver = nil
+		puncher:set_detach()
+		default.player_attached[puncher:get_player_name()] = false
+	end
+	if not self.driver then
+		self.removed = true
+		local inv = puncher:get_inventory()
+		if not (creative and creative.is_enabled_for
+				and creative.is_enabled_for(puncher:get_player_name()))
+				or not inv:contains_item("main", "boats:boat") then
+			local leftover = inv:add_item("main", "boats:boat")
+			-- if no room in inventory add a replacement boat to the world
+			if not leftover:is_empty() then
+				minetest.add_item(self.object:getpos(), leftover)
+			end
+		end
+		-- delay remove to ensure player is detached
+		minetest.after(0.1, function()
+			self.object:remove()
+		end)
+	end
+end
+
+
+function boat.on_step(self, dtime)
+	self.v = get_v(self.object:getvelocity()) * get_sign(self.v)
+	if self.driver then
+		local ctrl = self.driver:get_player_control()
+		local yaw = self.object:getyaw()
+		if ctrl.up then
+			self.v = self.v + 0.1
+		elseif ctrl.down then
+			self.v = self.v - 0.1
+		end
+		if ctrl.left then
+			if self.v < 0 then
+				self.object:setyaw(yaw - (1 + dtime) * 0.03)
+			else
+				self.object:setyaw(yaw + (1 + dtime) * 0.03)
+			end
+		elseif ctrl.right then
+			if self.v < 0 then
+				self.object:setyaw(yaw + (1 + dtime) * 0.03)
+			else
+				self.object:setyaw(yaw - (1 + dtime) * 0.03)
+			end
+		end
+	end
+	local velo = self.object:getvelocity()
+	if self.v == 0 and velo.x == 0 and velo.y == 0 and velo.z == 0 then
+		self.object:setpos(self.object:getpos())
+		return
+	end
+	local s = get_sign(self.v)
+	self.v = self.v - 0.02 * s
+	if s ~= get_sign(self.v) then
+		self.object:setvelocity({x = 0, y = 0, z = 0})
+		self.v = 0
+		return
+	end
+	if math.abs(self.v) > 5 then
+		self.v = 5 * get_sign(self.v)
+	end
+
+	local p = self.object:getpos()
+	p.y = p.y - 0.5
+	local new_velo
+	local new_acce = {x = 0, y = 0, z = 0}
+	if not is_water(p) then
+		local nodedef = minetest.registered_nodes[minetest.get_node(p).name]
+		if (not nodedef) or nodedef.walkable then
+			self.v = 0
+			new_acce = {x = 0, y = 1, z = 0}
+		else
+			new_acce = {x = 0, y = -9.8, z = 0}
+		end
+		new_velo = get_velocity(self.v, self.object:getyaw(),
+			self.object:getvelocity().y)
+		self.object:setpos(self.object:getpos())
+	else
+		p.y = p.y + 1
+		if is_water(p) then
+			local y = self.object:getvelocity().y
+			if y >= 5 then
+				y = 5
+			elseif y < 0 then
+				new_acce = {x = 0, y = 20, z = 0}
+			else
+				new_acce = {x = 0, y = 5, z = 0}
+			end
+			new_velo = get_velocity(self.v, self.object:getyaw(), y)
+			self.object:setpos(self.object:getpos())
+		else
+			new_acce = {x = 0, y = 0, z = 0}
+			if math.abs(self.object:getvelocity().y) < 1 then
+				local pos = self.object:getpos()
+				pos.y = math.floor(pos.y) + 0.5
+				self.object:setpos(pos)
+				new_velo = get_velocity(self.v, self.object:getyaw(), 0)
+			else
+				new_velo = get_velocity(self.v, self.object:getyaw(),
+					self.object:getvelocity().y)
+				self.object:setpos(self.object:getpos())
+			end
+		end
+	end
+	self.object:setvelocity(new_velo)
+	self.object:setacceleration(new_acce)
+end
+
+
+minetest.register_entity("boats:boat", boat)
+
+
+minetest.register_craftitem("boats:boat", {
+	description = "Boat",
+	inventory_image = "boats_inventory.png",
+	wield_image = "boats_wield.png",
+	wield_scale = {x = 2, y = 2, z = 1},
+	liquids_pointable = true,
+	groups = {flammable = 2},
+
+	on_place = function(itemstack, placer, pointed_thing)
+		local under = pointed_thing.under
+		local node = minetest.get_node(under)
+		local udef = minetest.registered_nodes[node.name]
+		if udef and udef.on_rightclick and
+				not (placer and placer:get_player_control().sneak) then
+			return udef.on_rightclick(under, node, placer, itemstack,
+				pointed_thing) or itemstack
+		end
+
+		if pointed_thing.type ~= "node" then
+			return itemstack
+		end
+		if not is_water(pointed_thing.under) then
+			return itemstack
+		end
+		pointed_thing.under.y = pointed_thing.under.y + 0.5
+		boat = minetest.add_entity(pointed_thing.under, "boats:boat")
+		if boat then
+			boat:setyaw(placer:get_look_horizontal())
+			if not (creative and creative.is_enabled_for
+					and creative.is_enabled_for(placer:get_player_name())) then
+				itemstack:take_item()
+			end
+		end
+		return itemstack
+	end,
+})
+
+
+minetest.register_craft({
+	output = "boats:boat",
+	recipe = {
+		{"",           "",           ""          },
+		{"group:wood", "",           "group:wood"},
+		{"group:wood", "group:wood", "group:wood"},
+	},
+})
+
+minetest.register_craft({
+	type = "fuel",
+	recipe = "boats:boat",
+	burntime = 20,
+})

mods/boats/license.txt

@@ -0,0 +1,63 @@
+License of source code
+----------------------
+
+The MIT License (MIT)
+Copyright (C) 2012-2016 PilzAdam
+Copyright (C) 2012-2016 Various Minetest developers and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+For more details:
+https://opensource.org/licenses/MIT
+
+
+Licenses of media (textures and model)
+--------------------------------------
+
+Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
+Copyright (C) 2012-2016 Zeg9
+Copyright (C) 2012-2016 thetoon
+Copyright (C) 2012-2016 PavelS(SokolovPavel)
+Copyright (C) 2016 sofar (sofar@foo-projects.org)
+
+You are free to:
+Share — copy and redistribute the material in any medium or format.
+Adapt — remix, transform, and build upon the material for any purpose, even commercially.
+The licensor cannot revoke these freedoms as long as you follow the license terms.
+
+Under the following terms:
+
+Attribution — You must give appropriate credit, provide a link to the license, and
+indicate if changes were made. You may do so in any reasonable manner, but not in any way
+that suggests the licensor endorses you or your use.
+
+ShareAlike — If you remix, transform, or build upon the material, you must distribute
+your contributions under the same license as the original.
+
+No additional restrictions — You may not apply legal terms or technological measures that
+legally restrict others from doing anything the license permits.
+
+Notices:
+
+You do not have to comply with the license for elements of the material in the public
+domain or where your use is permitted by an applicable exception or limitation.
+No warranties are given. The license may not give you all of the permissions necessary
+for your intended use. For example, other rights such as publicity, privacy, or moral
+rights may limit how you use the material.
+
+For more details:
+http://creativecommons.org/licenses/by-sa/3.0/

mods/boats/models/boats_boat.obj

@@ -0,0 +1,358 @@
+# Blender v2.76 (sub 11) OBJ File: 'boat.blend'
+# www.blender.org
+mtllib boat.mtl
+o boats_boat
+v -6.786140 -3.033999 -9.415440
+v -6.786140 -1.967150 -9.415440
+v -6.786140 -1.967150 8.793510
+v -6.786140 -3.033999 8.793510
+v 5.732520 -1.967150 -9.415440
+v 5.732520 -3.033999 -9.415440
+v 5.732520 -3.033999 8.793510
+v 5.732520 -1.967150 8.793510
+v -2.233900 -3.033999 -9.415440
+v -2.233900 -1.967150 -9.415440
+v -2.233900 -1.967150 8.793510
+v -2.233900 -3.033999 8.793510
+v 2.318340 -3.033999 -9.415440
+v 2.318340 -1.967150 -9.415440
+v 2.318340 -1.967150 8.793510
+v 2.318340 -3.033999 8.793510
+v -3.371960 -3.033999 8.793510
+v -3.371960 -1.967150 8.793510
+v -3.371960 -1.967150 -9.415440
+v -3.371960 -3.033999 -9.415440
+v 2.318340 0.276645 8.793510
+v 1.180280 -1.967150 8.793510
+v 5.732520 0.276645 8.793510
+v 5.732520 1.039180 8.793510
+v 6.870580 0.276645 8.793510
+v 6.870580 -1.967150 8.793510
+v 2.318340 1.039180 8.793510
+v 1.180280 0.276645 8.793510
+v 1.180280 1.039180 8.793510
+v 1.180280 -3.033999 8.793510
+v -2.233900 0.276645 8.793510
+v -3.371960 0.276645 8.793510
+v -2.233900 1.039180 8.793510
+v -3.371960 1.039180 8.793510
+v -6.786140 0.276645 8.793510
+v -7.786200 0.276645 8.793510
+v -7.786200 -1.967150 8.793510
+v -6.786140 1.039180 8.793510
+v 1.180280 -1.967150 -9.415440
+v 1.180280 -3.033999 -9.415440
+v 2.318340 0.276645 -9.415440
+v 1.180280 0.276645 -9.415440
+v 2.318340 1.039180 -9.415440
+v 5.732520 0.276645 -9.415440
+v 6.870580 -1.967150 -9.415440
+v 5.732520 1.039180 -9.415440
+v 6.870580 0.276645 -9.415440
+v 0.042220 1.039180 -9.415440
+v 1.180280 1.039180 -9.415440
+v 0.042220 -1.967150 -9.415440
+v -1.095840 -1.967150 -9.415440
+v -2.233900 0.276645 -9.415440
+v -3.371960 0.276645 -9.415440
+v -2.233900 1.039180 -9.415440
+v -1.095840 1.039180 -9.415440
+v -3.371960 1.039180 -9.415440
+v -6.786140 0.276645 -9.415440
+v -6.786140 1.039180 -9.415440
+v -7.786200 -1.967150 -9.415440
+v -7.786200 0.276645 -9.415440
+v -1.095840 0.156645 -12.044100
+v -1.095840 -4.601110 -9.415440
+v -1.095840 1.039181 -10.802900
+v -1.095840 2.868579 -10.802900
+v -1.095840 2.868580 -7.883420
+v -1.095840 3.746069 -12.034100
+v -1.095840 3.746070 -7.883420
+v -1.095840 0.156645 -14.294900
+v -1.095840 -4.601110 -14.284900
+v 0.042220 -4.601110 -14.284900
+v 0.042220 -4.601110 -9.415440
+v 0.042220 1.039181 -10.802900
+v 0.042220 0.156645 -12.044100
+v 0.042220 2.868579 -10.802900
+v 0.042220 0.156645 -14.294900
+v 0.042220 3.746069 -12.034100
+v 0.042220 3.746070 -7.883420
+v 0.042220 2.868580 -7.883420
+v -1.096322 -3.033999 -9.415440
+v 0.044046 -3.035397 -9.415440
+vt 1.000000 0.187500
+vt -1.000000 0.312500
+vt 1.000000 0.312500
+vt 0.687500 1.000000
+vt 0.500000 0.875000
+vt 0.500000 0.625000
+vt -1.000000 0.062500
+vt 1.000000 0.062500
+vt 1.000000 -0.000000
+vt -1.000000 0.125000
+vt 1.000000 0.125000
+vt 0.437500 0.125000
+vt 0.312500 0.500000
+vt 0.312500 0.125000
+vt 1.000000 0.625000
+vt -1.000000 0.500000
+vt 1.000000 0.500000
+vt 0.187500 0.687500
+vt -0.187500 0.687500
+vt -0.187500 0.312500
+vt 1.000000 0.812500
+vt -1.000000 0.937500
+vt -1.000000 0.812500
+vt 0.812500 0.687500
+vt 1.187500 0.687500
+vt 0.812500 0.312500
+vt 1.000000 0.562500
+vt 0.312500 0.437500
+vt 1.000000 0.437500
+vt 1.000000 0.750000
+vt -1.000000 0.875000
+vt -1.000000 0.750000
+vt -1.000000 1.000000
+vt 1.000000 1.000000
+vt 0.437500 0.625000
+vt 0.562500 0.437500
+vt 0.562500 0.625000
+vt -1.000000 0.437500
+vt -1.000000 0.000000
+vt 0.500000 0.062500
+vt 0.375000 0.750000
+vt 0.500000 0.750000
+vt -1.000000 0.250000
+vt -1.000000 0.687500
+vt 1.000000 0.687500
+vt 0.625000 0.375000
+vt 1.000000 0.375000
+vt 1.000000 0.250000
+vt 1.000000 0.937500
+vt 0.437500 0.812500
+vt 0.312500 0.312500
+vt 0.312500 0.812500
+vt 0.437500 0.312500
+vt 0.437500 0.437500
+vt 0.687500 0.812500
+vt 0.000000 0.687500
+vt 0.000000 0.812500
+vt -1.000000 0.562500
+vt 0.875000 0.812500
+vt 0.875000 0.687500
+vt 0.250000 0.312500
+vt 0.562500 0.187500
+vt 0.250000 0.187500
+vt -1.000000 0.187500
+vt 0.312500 0.625000
+vt 0.312500 0.187500
+vt 0.312500 -0.187500
+vt 1.000000 -0.187500
+vt 0.687500 0.500000
+vt -0.000000 1.000000
+vt 0.000000 0.875000
+vt 0.437500 0.500000
+vt -1.000000 0.625000
+vt 0.812500 0.187500
+vt 1.187500 0.187500
+vt 1.187500 0.312500
+vt 1.312500 0.312500
+vt 1.312500 0.687500
+vt 0.687500 0.187500
+vt 0.687500 0.312500
+vt 1.187500 0.812500
+vt 0.812500 0.812500
+vt 0.187500 0.312500
+vt 0.312500 0.687500
+vt 0.687500 0.687500
+vt -0.187500 0.187500
+vt 0.187500 0.187500
+vt -0.312500 0.687500
+vt -0.312500 0.312500
+vt 0.187500 0.812500
+vt -0.187500 0.812500
+vt 0.437500 0.687500
+vt 0.437500 0.187500
+vt 0.562500 0.812500
+vt 0.562500 0.687500
+vt 0.312500 0.562500
+vt 1.000000 0.875000
+vt 0.375000 0.062500
+vt -1.000000 0.375000
+vt 0.625000 0.500000
+vt 0.875000 0.562500
+vt 0.937500 0.812500
+vt 0.937500 0.687500
+vt 0.875000 0.937500
+vt 0.562500 0.312500
+vn -1.000000 0.000000 0.000000
+vn 1.000000 0.000000 0.000000
+vn 0.000000 0.000000 1.000000
+vn 0.000000 0.000000 -1.000000
+vn 0.000000 -1.000000 0.000000
+vn 0.000000 1.000000 0.000000
+vn 0.000000 -0.002100 -1.000000
+vn 0.001200 -1.000000 0.000000
+vn 0.000000 0.002800 -1.000000
+vn -0.001200 -1.000000 0.000200
+g boats_boat_boats_boat_None
+usemtl None
+s off
+f 41/1/1 27/2/1 43/3/1
+f 76/4/2 74/5/2 72/6/2
+f 8/7/2 6/1/2 5/8/2
+f 15/9/1 13/10/1 16/11/1
+f 51/12/3 71/13/3 50/14/3
+f 56/15/2 32/16/2 53/17/2
+f 15/18/3 8/19/3 23/20/3
+f 22/21/2 40/22/2 39/23/2
+f 19/24/4 2/25/4 53/26/4
+f 70/27/5 62/28/5 69/29/5
+f 11/30/5 19/31/5 10/32/5
+f 4/15/5 20/33/5 17/34/5
+f 72/35/3 64/36/3 63/37/3
+f 13/8/5 7/38/5 16/7/5
+f 23/39/6 47/11/6 44/9/6
+f 68/40/7 70/41/7 69/42/7
+f 80/43/8 40/10/8 30/11/8
+f 3/15/1 1/32/1 4/30/1
+f 20/44/2 18/27/2 17/45/2
+f 74/17/5 65/46/5 64/47/5
+f 31/43/1 54/47/1 52/48/1
+f 22/47/5 14/43/5 15/48/5
+f 46/1/2 23/7/2 44/8/2
+f 57/21/1 38/22/1 58/49/1
+f 61/50/9 76/51/9 73/52/9
+f 37/45/5 2/23/5 3/21/5
+f 78/28/3 67/53/3 65/54/3
+f 64/5/1 66/4/1 63/6/1
+f 76/55/6 67/56/6 77/57/6
+f 47/17/2 26/10/2 45/11/2
+f 5/16/5 26/47/5 8/17/5
+f 33/58/6 48/59/6 55/60/6
+f 29/38/2 42/3/2 49/29/2
+f 32/44/6 52/21/6 53/45/6
+f 58/15/6 34/33/6 56/34/6
+f 27/7/6 46/29/6 43/8/6
+f 73/61/6 68/62/6 61/63/6
+f 21/58/6 42/29/6 28/38/6
+f 11/29/1 9/58/1 12/27/1
+f 59/45/1 36/2/1 60/3/1
+f 60/9/6 35/10/6 57/11/6
+f 41/1/1 21/64/1 27/2/1
+f 72/6/2 48/65/2 50/66/2
+f 50/66/2 71/67/2 70/68/2
+f 70/68/2 75/17/2 73/69/2
+f 76/4/2 77/70/2 74/5/2
+f 77/70/2 78/71/2 74/5/2
+f 50/66/2 70/68/2 73/69/2
+f 73/69/2 76/4/2 72/6/2
+f 72/6/2 50/66/2 73/69/2
+f 8/7/2 7/64/2 6/1/2
+f 15/9/1 14/39/1 13/10/1
+f 51/12/3 62/72/3 71/13/3
+f 56/15/2 34/73/2 32/16/2
+f 32/26/3 34/74/3 38/75/3
+f 35/76/3 36/77/3 37/78/3
+f 32/26/3 38/75/3 35/76/3
+f 29/66/3 33/79/3 31/80/3
+f 32/26/3 35/76/3 3/25/3
+f 28/51/3 29/66/3 31/80/3
+f 31/80/3 32/26/3 18/24/3
+f 3/25/3 4/81/3 17/82/3
+f 35/76/3 37/78/3 3/25/3
+f 21/83/3 28/51/3 22/84/3
+f 3/25/3 17/82/3 18/24/3
+f 11/85/3 12/55/3 30/52/3
+f 32/26/3 3/25/3 18/24/3
+f 11/85/3 30/52/3 22/84/3
+f 31/80/3 18/24/3 11/85/3
+f 24/86/3 27/87/3 21/83/3
+f 28/51/3 31/80/3 11/85/3
+f 11/85/3 22/84/3 28/51/3
+f 24/86/3 21/83/3 23/20/3
+f 26/88/3 25/89/3 23/20/3
+f 23/20/3 21/83/3 15/18/3
+f 15/18/3 16/90/3 7/91/3
+f 21/83/3 22/84/3 15/18/3
+f 8/19/3 26/88/3 23/20/3
+f 15/18/3 7/91/3 8/19/3
+f 22/21/2 30/49/2 40/22/2
+f 47/89/4 45/88/4 5/19/4
+f 5/19/4 6/91/4 13/90/4
+f 5/19/4 13/90/4 14/18/4
+f 44/20/4 47/89/4 5/19/4
+f 43/87/4 46/86/4 44/20/4
+f 41/83/4 43/87/4 44/20/4
+f 44/20/4 5/19/4 14/18/4
+f 39/84/4 40/52/4 80/50/4
+f 44/20/4 14/18/4 41/83/4
+f 42/51/4 41/83/4 39/84/4
+f 39/84/4 80/50/4 50/92/4
+f 41/83/4 14/18/4 39/84/4
+f 48/93/4 49/66/4 42/51/4
+f 50/92/4 48/93/4 42/51/4
+f 80/50/4 79/94/4 50/92/4
+f 50/92/4 42/51/4 39/84/4
+f 54/79/4 55/62/4 52/80/4
+f 50/92/4 79/94/4 51/95/4
+f 52/80/4 55/62/4 51/95/4
+f 51/95/4 79/94/4 10/85/4
+f 79/94/4 9/55/4 10/85/4
+f 53/26/4 52/80/4 10/85/4
+f 58/75/4 56/74/4 53/26/4
+f 59/78/4 60/77/4 57/76/4
+f 57/76/4 58/75/4 53/26/4
+f 52/80/4 51/95/4 10/85/4
+f 19/24/4 20/82/4 1/81/4
+f 53/26/4 10/85/4 19/24/4
+f 59/78/4 57/76/4 2/25/4
+f 19/24/4 1/81/4 2/25/4
+f 2/25/4 57/76/4 53/26/4
+f 70/27/5 71/96/5 62/28/5
+f 11/30/5 18/97/5 19/31/5
+f 4/15/5 1/73/5 20/33/5
+f 72/35/3 74/54/3 64/36/3
+f 13/8/5 6/29/5 7/38/5
+f 23/39/6 25/10/6 47/11/6
+f 68/40/7 75/98/7 70/41/7
+f 30/11/5 12/17/5 79/99/5
+f 79/99/10 80/43/10 30/11/10
+f 12/17/5 9/16/5 79/99/5
+f 3/15/1 2/73/1 1/32/1
+f 20/44/2 19/58/2 18/27/2
+f 74/17/5 78/100/5 65/46/5
+f 31/43/1 33/99/1 54/47/1
+f 22/47/5 39/99/5 14/43/5
+f 46/1/2 24/64/2 23/7/2
+f 57/21/1 35/23/1 38/22/1
+f 61/50/9 66/53/9 76/51/9
+f 37/45/5 59/44/5 2/23/5
+f 78/28/3 77/51/3 67/53/3
+f 62/67/1 51/66/1 69/68/1
+f 51/66/1 55/65/1 63/6/1
+f 68/17/1 69/68/1 61/69/1
+f 61/69/1 69/68/1 51/66/1
+f 61/69/1 51/66/1 63/6/1
+f 65/71/1 67/70/1 64/5/1
+f 61/69/1 63/6/1 66/4/1
+f 64/5/1 67/70/1 66/4/1
+f 76/55/6 66/85/6 67/56/6
+f 47/17/2 25/16/2 26/10/2
+f 5/16/5 45/99/5 26/47/5
+f 55/60/6 54/101/6 33/58/6
+f 33/58/6 29/22/6 48/59/6
+f 48/59/6 72/102/6 63/103/6
+f 29/22/6 49/104/6 48/59/6
+f 48/59/6 63/103/6 55/60/6
+f 29/38/2 28/2/2 42/3/2
+f 32/44/6 31/23/6 52/21/6
+f 58/15/6 38/73/6 34/33/6
+f 27/7/6 24/38/6 46/29/6
+f 73/61/6 75/105/6 68/62/6
+f 21/58/6 41/27/6 42/29/6
+f 11/29/1 10/38/1 9/58/1
+f 59/45/1 37/44/1 36/2/1
+f 60/9/6 36/39/6 35/10/6

mods/bones/README.txt

@@ -0,0 +1,12 @@
+Minetest Game mod: bones
+========================
+See license.txt for license information.
+
+Authors of source code
+----------------------
+Originally by PilzAdam (MIT)
+Various Minetest developers and contributors (MIT)
+
+Authors of media (textures)
+---------------------------
+All textures: paramat (CC BY-SA 3.0)

mods/bones/depends.txt

@@ -0,0 +1 @@
+default

mods/bones/init.lua

@@ -0,0 +1,249 @@
+-- Minetest 0.4 mod: bones
+-- See README.txt for licensing and other information.
+
+local function is_owner(pos, name)
+	local owner = minetest.get_meta(pos):get_string("owner")
+	if owner == "" or owner == name or minetest.check_player_privs(name, "protection_bypass") then
+		return true
+	end
+	return false
+end
+
+local bones_formspec =
+	"size[8,9]" ..
+	default.gui_bg ..
+	default.gui_bg_img ..
+	default.gui_slots ..
+	"list[current_name;main;0,0.3;8,4;]" ..
+	"list[current_player;main;0,4.85;8,1;]" ..
+	"list[current_player;main;0,6.08;8,3;8]" ..
+	"listring[current_name;main]" ..
+	"listring[current_player;main]" ..
+	default.get_hotbar_bg(0,4.85)
+
+local share_bones_time = tonumber(minetest.settings:get("share_bones_time")) or 1200
+local share_bones_time_early = tonumber(minetest.settings:get("share_bones_time_early")) or share_bones_time / 4
+
+minetest.register_node("bones:bones", {
+	description = "Bones",
+	tiles = {
+		"bones_top.png^[transform2",
+		"bones_bottom.png",
+		"bones_side.png",
+		"bones_side.png",
+		"bones_rear.png",
+		"bones_front.png"
+	},
+	paramtype2 = "facedir",
+	groups = {dig_immediate = 2},
+	sounds = default.node_sound_gravel_defaults(),
+
+	can_dig = function(pos, player)
+		local inv = minetest.get_meta(pos):get_inventory()
+		local name = ""
+		if player then
+			name = player:get_player_name()
+		end
+		return is_owner(pos, name) and inv:is_empty("main")
+	end,
+
+	allow_metadata_inventory_move = function(pos, from_list, from_index, to_list, to_index, count, player)
+		if is_owner(pos, player:get_player_name()) then
+			return count
+		end
+		return 0
+	end,
+
+	allow_metadata_inventory_put = function(pos, listname, index, stack, player)
+		return 0
+	end,
+
+	allow_metadata_inventory_take = function(pos, listname, index, stack, player)
+		if is_owner(pos, player:get_player_name()) then
+			return stack:get_count()
+		end
+		return 0
+	end,
+
+	on_metadata_inventory_take = function(pos, listname, index, stack, player)
+		local meta = minetest.get_meta(pos)
+		if meta:get_inventory():is_empty("main") then
+			minetest.remove_node(pos)
+		end
+	end,
+
+	on_punch = function(pos, node, player)
+		if not is_owner(pos, player:get_player_name()) then
+			return
+		end
+
+		if minetest.get_meta(pos):get_string("infotext") == "" then
+			return
+		end
+
+		local inv = minetest.get_meta(pos):get_inventory()
+		local player_inv = player:get_inventory()
+		local has_space = true
+
+		for i = 1, inv:get_size("main") do
+			local stk = inv:get_stack("main", i)
+			if player_inv:room_for_item("main", stk) then
+				inv:set_stack("main", i, nil)
+				player_inv:add_item("main", stk)
+			else
+				has_space = false
+				break
+			end
+		end
+
+		-- remove bones if player emptied them
+		if has_space then
+			if player_inv:room_for_item("main", {name = "bones:bones"}) then
+				player_inv:add_item("main", {name = "bones:bones"})
+			else
+				minetest.add_item(pos,"bones:bones")
+			end
+			minetest.remove_node(pos)
+		end
+	end,
+
+	on_timer = function(pos, elapsed)
+		local meta = minetest.get_meta(pos)
+		local time = meta:get_int("time") + elapsed
+		if time >= share_bones_time then
+			meta:set_string("infotext", meta:get_string("owner") .. "'s old bones")
+			meta:set_string("owner", "")
+		else
+			meta:set_int("time", time)
+			return true
+		end
+	end,
+	on_blast = function(pos)
+	end,
+})
+
+local function may_replace(pos, player)
+	local node_name = minetest.get_node(pos).name
+	local node_definition = minetest.registered_nodes[node_name]
+
+	-- if the node is unknown, we return false
+	if not node_definition then
+		return false
+	end
+
+	-- allow replacing air and liquids
+	if node_name == "air" or node_definition.liquidtype ~= "none" then
+		return true
+	end
+
+	-- don't replace filled chests and other nodes that don't allow it
+	local can_dig_func = node_definition.can_dig
+	if can_dig_func and not can_dig_func(pos, player) then
+		return false
+	end
+
+	-- default to each nodes buildable_to; if a placed block would replace it, why shouldn't bones?
+	-- flowers being squished by bones are more realistical than a squished stone, too
+	-- exception are of course any protected buildable_to
+	return node_definition.buildable_to and not minetest.is_protected(pos, player:get_player_name())
+end
+
+local drop = function(pos, itemstack)
+	local obj = minetest.add_item(pos, itemstack:take_item(itemstack:get_count()))
+	if obj then
+		obj:setvelocity({
+			x = math.random(-10, 10) / 9,
+			y = 5,
+			z = math.random(-10, 10) / 9,
+		})
+	end
+end
+
+minetest.register_on_dieplayer(function(player)
+
+	local bones_mode = minetest.settings:get("bones_mode") or "bones"
+	if bones_mode ~= "bones" and bones_mode ~= "drop" and bones_mode ~= "keep" then
+		bones_mode = "bones"
+	end
+
+	-- return if keep inventory set or in creative mode
+	if bones_mode == "keep" or (creative and creative.is_enabled_for
+			and creative.is_enabled_for(player:get_player_name())) then
+		return
+	end
+
+	local player_inv = player:get_inventory()
+	if player_inv:is_empty("main") and
+		player_inv:is_empty("craft") then
+		return
+	end
+
+	local pos = vector.round(player:getpos())
+	local player_name = player:get_player_name()
+
+	-- check if it's possible to place bones, if not find space near player
+	if bones_mode == "bones" and not may_replace(pos, player) then
+		local air = minetest.find_node_near(pos, 1, {"air"})
+		if air and not minetest.is_protected(air, player_name) then
+			pos = air
+		else
+			bones_mode = "drop"
+		end
+	end
+
+	if bones_mode == "drop" then
+
+		-- drop inventory items
+		for i = 1, player_inv:get_size("main") do
+			drop(pos, player_inv:get_stack("main", i))
+		end
+		player_inv:set_list("main", {})
+
+		-- drop crafting grid items
+		for i = 1, player_inv:get_size("craft") do
+			drop(pos, player_inv:get_stack("craft", i))
+		end
+		player_inv:set_list("craft", {})
+
+		drop(pos, ItemStack("bones:bones"))
+		return
+	end
+
+	local param2 = minetest.dir_to_facedir(player:get_look_dir())
+	minetest.set_node(pos, {name = "bones:bones", param2 = param2})
+
+	local meta = minetest.get_meta(pos)
+	local inv = meta:get_inventory()
+	inv:set_size("main", 8 * 4)
+	inv:set_list("main", player_inv:get_list("main"))
+
+	for i = 1, player_inv:get_size("craft") do
+		local stack = player_inv:get_stack("craft", i)
+		if inv:room_for_item("main", stack) then
+			inv:add_item("main", stack)
+		else
+			--drop if no space left
+			drop(pos, stack)
+		end
+	end
+
+	player_inv:set_list("main", {})
+	player_inv:set_list("craft", {})
+
+	meta:set_string("formspec", bones_formspec)
+	meta:set_string("owner", player_name)
+
+	if share_bones_time ~= 0 then
+		meta:set_string("infotext", player_name .. "'s fresh bones")
+
+		if share_bones_time_early == 0 or not minetest.is_protected(pos, player_name) then
+			meta:set_int("time", 0)
+		else
+			meta:set_int("time", (share_bones_time - share_bones_time_early))
+		end
+
+		minetest.get_node_timer(pos):start(10)
+	else
+		meta:set_string("infotext", player_name.."'s bones")
+	end
+end)

mods/bones/license.txt

@@ -0,0 +1,58 @@
+License of source code
+----------------------
+
+The MIT License (MIT)
+Copyright (C) 2012-2016 PilzAdam
+Copyright (C) 2012-2016 Various Minetest developers and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+For more details:
+https://opensource.org/licenses/MIT
+
+
+Licenses of media (textures)
+----------------------------
+
+Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
+Copyright (C) 2016 paramat
+
+You are free to:
+Share — copy and redistribute the material in any medium or format.
+Adapt — remix, transform, and build upon the material for any purpose, even commercially.
+The licensor cannot revoke these freedoms as long as you follow the license terms.
+
+Under the following terms:
+
+Attribution — You must give appropriate credit, provide a link to the license, and
+indicate if changes were made. You may do so in any reasonable manner, but not in any way
+that suggests the licensor endorses you or your use.
+
+ShareAlike — If you remix, transform, or build upon the material, you must distribute
+your contributions under the same license as the original.
+
+No additional restrictions — You may not apply legal terms or technological measures that
+legally restrict others from doing anything the license permits.
+
+Notices:
+
+You do not have to comply with the license for elements of the material in the public
+domain or where your use is permitted by an applicable exception or limitation.
+No warranties are given. The license may not give you all of the permissions necessary
+for your intended use. For example, other rights such as publicity, privacy, or moral
+rights may limit how you use the material.
+

mods/bucket/README.txt

@@ -1,26 +1,13 @@
-Minetest 0.4 mod: bucket
+Minetest Game mod: bucket
 =========================
+See license.txt for license information.
 
-License of source code:
+Authors of source code
------------------------
+----------------------
-Copyright (C) 2011-2012 Kahrl <kahrl@gmx.net>
+Kahrl <kahrl@gmx.net> (LGPL 2.1)
-Copyright (C) 2011-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+celeron55, Perttu Ahola <celeron55@gmail.com> (LGPL 2.1)
-
+Various Minetest developers and contributors (LGPL 2.1)
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-http://www.gnu.org/licenses/lgpl-2.1.html
-
-License of media (textures and sounds)
---------------------------------------
-Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)                                 
-http://creativecommons.org/licenses/by-sa/3.0/
-
-Authors of media files
------------------------
-Everything not listed in here:
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
-
 
+Authors of media (textures)
+---------------------------
+ElementW (CC BY-SA 3.0)

mods/bucket/init.lua

@@ -16,47 +16,94 @@ minetest.register_craft({
 bucket = {}
 bucket.liquids = {}
 
+local function check_protection(pos, name, text)
+	if minetest.is_protected(pos, name) then
+		minetest.log("action", (name ~= "" and name or "A mod")
+			.. " tried to " .. text
+			.. " at protected position "
+			.. minetest.pos_to_string(pos)
+			.. " with a bucket")
+		minetest.record_protection_violation(pos, name)
+		return true
+	end
+	return false
+end
+
 -- Register a new liquid
---   source = name of the source node
+--    source = name of the source node
---   flowing = name of the flowing node
+--    flowing = name of the flowing node
---   itemname = name of the new bucket item (or nil if liquid is not takeable)
+--    itemname = name of the new bucket item (or nil if liquid is not takeable)
---   inventory_image = texture of the new bucket item (ignored if itemname == nil)
+--    inventory_image = texture of the new bucket item (ignored if itemname == nil)
+--    name = text description of the bucket item
+--    groups = (optional) groups of the bucket item, for example {water_bucket = 1}
+--    force_renew = (optional) bool. Force the liquid source to renew if it has a
+--                  source neighbour, even if defined as 'liquid_renewable = false'.
+--                  Needed to avoid creating holes in sloping rivers.
 -- This function can be called from any mod (that depends on bucket).
-function bucket.register_liquid(source, flowing, itemname, inventory_image)
+function bucket.register_liquid(source, flowing, itemname, inventory_image, name,
+		groups, force_renew)
 	bucket.liquids[source] = {
 		source = source,
 		flowing = flowing,
 		itemname = itemname,
+		force_renew = force_renew,
 	}
 	bucket.liquids[flowing] = bucket.liquids[source]
 
 	if itemname ~= nil then
 		minetest.register_craftitem(itemname, {
+			description = name,
 			inventory_image = inventory_image,
 			stack_max = 1,
 			liquids_pointable = true,
-			on_use = function(itemstack, user, pointed_thing)
+			groups = groups,
+
+			on_place = function(itemstack, user, pointed_thing)
 				-- Must be pointing to node
 				if pointed_thing.type ~= "node" then
 					return
 				end
+
+				local node = minetest.get_node_or_nil(pointed_thing.under)
+				local ndef = node and minetest.registered_nodes[node.name]
+
+				-- Call on_rightclick if the pointed node defines it
+				if ndef and ndef.on_rightclick and
+				   user and not user:get_player_control().sneak then
+					return ndef.on_rightclick(
+						pointed_thing.under,
+						node, user,
+						itemstack)
+				end
+
+				local lpos
+
 				-- Check if pointing to a buildable node
-				n = minetest.env:get_node(pointed_thing.under)
+				if ndef and ndef.buildable_to then
-				if minetest.registered_nodes[n.name].buildable_to then
 					-- buildable; replace the node
-					minetest.env:add_node(pointed_thing.under, {name=source})
+					lpos = pointed_thing.under
 				else
 					-- not buildable to; place the liquid above
 					-- check if the node above can be replaced
-					n = minetest.env:get_node(pointed_thing.above)
+
-					if minetest.registered_nodes[n.name].buildable_to then
+					lpos = pointed_thing.above
-						minetest.env:add_node(pointed_thing.above,{name=source})
+					node = minetest.get_node_or_nil(lpos)
-					else
+					local above_ndef = node and minetest.registered_nodes[node.name]
+
+					if not above_ndef or not above_ndef.buildable_to then
 						-- do not remove the bucket with the liquid
-						return
+						return itemstack
 					end
 				end
-				return {name="bucket:bucket_empty"}
+
+				if check_protection(lpos, user
+						and user:get_player_name()
+						or "", "place "..source) then
+					return
+				end
+
+				minetest.set_node(lpos, {name = source})
+				return ItemStack("bucket:bucket_empty")
 			end
 		})
 	end
@@ -65,19 +112,69 @@ end
 minetest.register_craftitem("bucket:bucket_empty", {
 	description = "Empty Bucket",
 	inventory_image = "bucket.png",
-	stack_max = 1,
+	stack_max = 99,
 	liquids_pointable = true,
 	on_use = function(itemstack, user, pointed_thing)
-		-- Must be pointing to node
+		if pointed_thing.type == "object" then
-		if pointed_thing.type ~= "node" then
+			pointed_thing.ref:punch(user, 1.0, { full_punch_interval=1.0 }, nil)
+			return user:get_wielded_item()
+		elseif pointed_thing.type ~= "node" then
+			-- do nothing if it's neither object nor node
 			return
 		end
 		-- Check if pointing to a liquid source
-		n = minetest.env:get_node(pointed_thing.under)
+		local node = minetest.get_node(pointed_thing.under)
-		liquiddef = bucket.liquids[n.name]
+		local liquiddef = bucket.liquids[node.name]
-		if liquiddef ~= nil and liquiddef.source == n.name and liquiddef.itemname ~= nil then
+		local item_count = user:get_wielded_item():get_count()
-			minetest.env:add_node(pointed_thing.under, {name="air"})
+
-			return {name=liquiddef.itemname}
+		if liquiddef ~= nil
+		and liquiddef.itemname ~= nil
+		and node.name == liquiddef.source then
+			if check_protection(pointed_thing.under,
+					user:get_player_name(),
+					"take ".. node.name) then
+				return
+			end
+
+			-- default set to return filled bucket
+			local giving_back = liquiddef.itemname
+
+			-- check if holding more than 1 empty bucket
+			if item_count > 1 then
+
+				-- if space in inventory add filled bucked, otherwise drop as item
+				local inv = user:get_inventory()
+				if inv:room_for_item("main", {name=liquiddef.itemname}) then
+					inv:add_item("main", liquiddef.itemname)
+				else
+					local pos = user:getpos()
+					pos.y = math.floor(pos.y + 0.5)
+					minetest.add_item(pos, liquiddef.itemname)
+				end
+
+				-- set to return empty buckets minus 1
+				giving_back = "bucket:bucket_empty "..tostring(item_count-1)
+
+			end
+
+			-- force_renew requires a source neighbour
+			local source_neighbor = false
+			if liquiddef.force_renew then
+				source_neighbor =
+					minetest.find_node_near(pointed_thing.under, 1, liquiddef.source)
+			end
+			if not (source_neighbor and liquiddef.force_renew) then
+				minetest.add_node(pointed_thing.under, {name = "air"})
+			end
+
+			return ItemStack(giving_back)
+		else
+			-- non-liquid nodes will have their on_punch triggered
+			local node_def = minetest.registered_nodes[node.name]
+			if node_def then
+				node_def.on_punch(pointed_thing.under, node, user, pointed_thing)
+			end
+			return user:get_wielded_item()
 		end
 	end,
 })
@@ -86,18 +183,33 @@ bucket.register_liquid(
 	"default:water_source",
 	"default:water_flowing",
 	"bucket:bucket_water",
-	"bucket_water.png"
+	"bucket_water.png",
+	"Water Bucket",
+	{water_bucket = 1}
+)
+
+bucket.register_liquid(
+	"default:river_water_source",
+	"default:river_water_flowing",
+	"bucket:bucket_river_water",
+	"bucket_river_water.png",
+	"River Water Bucket",
+	{water_bucket = 1},
+	true
 )
 
 bucket.register_liquid(
 	"default:lava_source",
 	"default:lava_flowing",
 	"bucket:bucket_lava",
-	"bucket_lava.png"
+	"bucket_lava.png",
+	"Lava Bucket"
 )
 
 minetest.register_craft({
 	type = "fuel",
 	recipe = "bucket:bucket_lava",
 	burntime = 60,
+	replacements = {{"bucket:bucket_lava", "bucket:bucket_empty"}},
 })
+

mods/bucket/license.txt

@@ -0,0 +1,51 @@
+License of source code
+----------------------
+
+GNU Lesser General Public License, version 2.1
+Copyright (C) 2011-2016 Kahrl <kahrl@gmx.net>
+Copyright (C) 2011-2016 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2011-2016 Various Minetest developers and contributors
+
+This program is free software; you can redistribute it and/or modify it under the terms
+of the GNU Lesser General Public License as published by the Free Software Foundation;
+either version 2.1 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 Lesser General Public License for more details:
+https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
+
+
+Licenses of media (textures)
+----------------------------
+
+Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
+Copyright (C) 2015-2016 ElementW
+
+You are free to:
+Share — copy and redistribute the material in any medium or format.
+Adapt — remix, transform, and build upon the material for any purpose, even commercially.
+The licensor cannot revoke these freedoms as long as you follow the license terms.
+
+Under the following terms:
+
+Attribution — You must give appropriate credit, provide a link to the license, and
+indicate if changes were made. You may do so in any reasonable manner, but not in any way
+that suggests the licensor endorses you or your use.
+
+ShareAlike — If you remix, transform, or build upon the material, you must distribute
+your contributions under the same license as the original.
+
+No additional restrictions — You may not apply legal terms or technological measures that
+legally restrict others from doing anything the license permits.
+
+Notices:
+
+You do not have to comply with the license for elements of the material in the public
+domain or where your use is permitted by an applicable exception or limitation.
+No warranties are given. The license may not give you all of the permissions necessary
+for your intended use. For example, other rights such as publicity, privacy, or moral
+rights may limit how you use the material.
+
+For more details:
+http://creativecommons.org/licenses/by-sa/3.0/

mods/carts/README.txt

@@ -0,0 +1,22 @@
+Carts (formerly boost_cart)
+==========================
+
+Carts, based almost entirely on the mod boost_cart [1], which
+itself is based on (and fully compatible with) the carts mod [2].
+
+The model was originally designed by stujones11 [3] (CC-0).
+
+Cart textures are based on original work from PixelBOX (WTFPL).
+
+
+[1] https://github.com/SmallJoker/boost_cart/
+[2] https://github.com/PilzAdam/carts/
+[3] https://github.com/stujones11/railcart/
+
+
+Features
+----------
+- A fast cart for your railway or roller coaster (up to 7 m/s!)
+- Boost and brake rails
+- Rail junction switching with the 'right-left' walking keys
+- Handbrake with the 'back' key

mods/carts/cart_entity.lua

@@ -0,0 +1,403 @@
+local cart_entity = {
+	physical = false, -- otherwise going uphill breaks
+	collisionbox = {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
+	visual = "mesh",
+	mesh = "carts_cart.b3d",
+	visual_size = {x=1, y=1},
+	textures = {"carts_cart.png"},
+
+	driver = nil,
+	punched = false, -- used to re-send velocity and position
+	velocity = {x=0, y=0, z=0}, -- only used on punch
+	old_dir = {x=1, y=0, z=0}, -- random value to start the cart on punch
+	old_pos = nil,
+	old_switch = 0,
+	railtype = nil,
+	attached_items = {}
+}
+
+function cart_entity:on_rightclick(clicker)
+	if not clicker or not clicker:is_player() then
+		return
+	end
+	local player_name = clicker:get_player_name()
+	if self.driver and player_name == self.driver then
+		self.driver = nil
+		carts:manage_attachment(clicker, nil)
+	elseif not self.driver then
+		self.driver = player_name
+		carts:manage_attachment(clicker, self.object)
+	end
+end
+
+function cart_entity:on_activate(staticdata, dtime_s)
+	self.object:set_armor_groups({immortal=1})
+	if string.sub(staticdata, 1, string.len("return")) ~= "return" then
+		return
+	end
+	local data = minetest.deserialize(staticdata)
+	if not data or type(data) ~= "table" then
+		return
+	end
+	self.railtype = data.railtype
+	if data.old_dir then
+		self.old_dir = data.old_dir
+	end
+	if data.old_vel then
+		self.old_vel = data.old_vel
+	end
+end
+
+function cart_entity:get_staticdata()
+	return minetest.serialize({
+		railtype = self.railtype,
+		old_dir = self.old_dir,
+		old_vel = self.old_vel
+	})
+end
+
+function cart_entity:on_punch(puncher, time_from_last_punch, tool_capabilities, direction)
+	local pos = self.object:getpos()
+	if not self.railtype then
+		local node = minetest.get_node(pos).name
+		self.railtype = minetest.get_item_group(node, "connect_to_raillike")
+	end
+	-- Punched by non-player
+	if not puncher or not puncher:is_player() then
+		local cart_dir = carts:get_rail_direction(pos, self.old_dir, nil, nil, self.railtype)
+		if vector.equals(cart_dir, {x=0, y=0, z=0}) then
+			return
+		end
+		self.velocity = vector.multiply(cart_dir, 2)
+		self.punched = true
+		return
+	end
+	-- Player digs cart by sneak-punch
+	if puncher:get_player_control().sneak then
+		if self.sound_handle then
+			minetest.sound_stop(self.sound_handle)
+		end
+		-- Detach driver and items
+		if self.driver then
+			if self.old_pos then
+				self.object:setpos(self.old_pos)
+			end
+			local player = minetest.get_player_by_name(self.driver)
+			carts:manage_attachment(player, nil)
+		end
+		for _,obj_ in ipairs(self.attached_items) do
+			if obj_ then
+				obj_:set_detach()
+			end
+		end
+		-- Pick up cart
+		local inv = puncher:get_inventory()
+		if not (creative and creative.is_enabled_for
+				and creative.is_enabled_for(puncher:get_player_name()))
+				or not inv:contains_item("main", "carts:cart") then
+			local leftover = inv:add_item("main", "carts:cart")
+			-- If no room in inventory add a replacement cart to the world
+			if not leftover:is_empty() then
+				minetest.add_item(self.object:getpos(), leftover)
+			end
+		end
+		self.object:remove()
+		return
+	end
+	-- Player punches cart to alter velocity
+	local vel = self.object:getvelocity()
+	if puncher:get_player_name() == self.driver then
+		if math.abs(vel.x + vel.z) > carts.punch_speed_max then
+			return
+		end
+	end
+
+	local punch_dir = carts:velocity_to_dir(puncher:get_look_dir())
+	punch_dir.y = 0
+	local cart_dir = carts:get_rail_direction(pos, punch_dir, nil, nil, self.railtype)
+	if vector.equals(cart_dir, {x=0, y=0, z=0}) then
+		return
+	end
+
+	local punch_interval = 1
+	if tool_capabilities and tool_capabilities.full_punch_interval then
+		punch_interval = tool_capabilities.full_punch_interval
+	end
+	time_from_last_punch = math.min(time_from_last_punch or punch_interval, punch_interval)
+	local f = 2 * (time_from_last_punch / punch_interval)
+
+	self.velocity = vector.multiply(cart_dir, f)
+	self.old_dir = cart_dir
+	self.punched = true
+end
+
+local function rail_on_step_event(handler, obj, dtime)
+	if handler then
+		handler(obj, dtime)
+	end
+end
+
+-- sound refresh interval = 1.0sec
+local function rail_sound(self, dtime)
+	if not self.sound_ttl then
+		self.sound_ttl = 1.0
+		return
+	elseif self.sound_ttl > 0 then
+		self.sound_ttl = self.sound_ttl - dtime
+		return
+	end
+	self.sound_ttl = 1.0
+	if self.sound_handle then
+		local handle = self.sound_handle
+		self.sound_handle = nil
+		minetest.after(0.2, minetest.sound_stop, handle)
+	end
+	local vel = self.object:getvelocity()
+	local speed = vector.length(vel)
+	if speed > 0 then
+		self.sound_handle = minetest.sound_play(
+			"carts_cart_moving", {
+			object = self.object,
+			gain = (speed / carts.speed_max) / 2,
+			loop = true,
+		})
+	end
+end
+
+local function get_railparams(pos)
+	local node = minetest.get_node(pos)
+	return carts.railparams[node.name] or {}
+end
+
+local function rail_on_step(self, dtime)
+	local vel = self.object:getvelocity()
+	if self.punched then
+		vel = vector.add(vel, self.velocity)
+		self.object:setvelocity(vel)
+		self.old_dir.y = 0
+	elseif vector.equals(vel, {x=0, y=0, z=0}) then
+		return
+	end
+
+	local pos = self.object:getpos()
+	local update = {}
+
+	-- stop cart if velocity vector flips
+	if self.old_vel and self.old_vel.y == 0 and
+			(self.old_vel.x * vel.x < 0 or self.old_vel.z * vel.z < 0) then
+		self.old_vel = {x = 0, y = 0, z = 0}
+		self.old_pos = pos
+		self.object:setvelocity(vector.new())
+		self.object:setacceleration(vector.new())
+		rail_on_step_event(get_railparams(pos).on_step, self, dtime)
+		return
+	end
+	self.old_vel = vector.new(vel)
+
+	if self.old_pos and not self.punched then
+		local flo_pos = vector.round(pos)
+		local flo_old = vector.round(self.old_pos)
+		if vector.equals(flo_pos, flo_old) then
+			-- Do not check one node multiple times
+			return
+		end
+	end
+
+	local ctrl, player
+
+	-- Get player controls
+	if self.driver then
+		player = minetest.get_player_by_name(self.driver)
+		if player then
+			ctrl = player:get_player_control()
+		end
+	end
+
+	if self.old_pos then
+		-- Detection for "skipping" nodes
+		local found_path = carts:pathfinder(
+			pos, self.old_pos, self.old_dir, ctrl, self.old_switch, self.railtype
+		)
+
+		if not found_path then
+			-- No rail found: reset back to the expected position
+			pos = vector.new(self.old_pos)
+			update.pos = true
+		end
+	end
+
+	local cart_dir = carts:velocity_to_dir(vel)
+	local railparams
+
+	-- dir:         New moving direction of the cart
+	-- switch_keys: Currently pressed L/R key, used to ignore the key on the next rail node
+	local dir, switch_keys = carts:get_rail_direction(
+		pos, cart_dir, ctrl, self.old_switch, self.railtype
+	)
+
+	local new_acc = {x=0, y=0, z=0}
+	if vector.equals(dir, {x=0, y=0, z=0}) then
+		vel = {x = 0, y = 0, z = 0}
+		pos = vector.round(pos)
+		update.pos = true
+		update.vel = true
+	else
+		-- Direction change detected
+		if not vector.equals(dir, self.old_dir) then
+			vel = vector.multiply(dir, math.abs(vel.x + vel.z))
+			update.vel = true
+			if dir.y ~= self.old_dir.y then
+				pos = vector.round(pos)
+				update.pos = true
+			end
+		end
+		-- Center on the rail
+		if dir.z ~= 0 and math.floor(pos.x + 0.5) ~= pos.x then
+			pos.x = math.floor(pos.x + 0.5)
+			update.pos = true
+		end
+		if dir.x ~= 0 and math.floor(pos.z + 0.5) ~= pos.z then
+			pos.z = math.floor(pos.z + 0.5)
+			update.pos = true
+		end
+
+		-- Slow down or speed up..
+		local acc = dir.y * -4.0
+
+		-- Get rail for corrected position
+		railparams = get_railparams(pos)
+
+		-- no need to check for railparams == nil since we always make it exist.
+		local speed_mod = railparams.acceleration
+		if speed_mod and speed_mod ~= 0 then
+			-- Try to make it similar to the original carts mod
+			acc = acc + speed_mod
+		else
+			-- Handbrake or coast
+			if ctrl and ctrl.down then
+				acc = acc - 3
+			else
+				acc = acc - 0.4
+			end
+		end
+
+		new_acc = vector.multiply(dir, acc)
+	end
+
+	-- Limits
+	local max_vel = carts.speed_max
+	for _, v in pairs({"x","y","z"}) do
+		if math.abs(vel[v]) > max_vel then
+			vel[v] = carts:get_sign(vel[v]) * max_vel
+			new_acc[v] = 0
+			update.vel = true
+		end
+	end
+
+	self.object:setacceleration(new_acc)
+	self.old_pos = vector.new(pos)
+	if not vector.equals(dir, {x=0, y=0, z=0}) then
+		self.old_dir = vector.new(dir)
+	end
+	self.old_switch = switch_keys
+
+	if self.punched then
+		-- Collect dropped items
+		for _, obj_ in pairs(minetest.get_objects_inside_radius(pos, 1)) do
+			if not obj_:is_player() and
+					obj_:get_luaentity() and
+					not obj_:get_luaentity().physical_state and
+					obj_:get_luaentity().name == "__builtin:item" then
+
+				obj_:set_attach(self.object, "", {x=0, y=0, z=0}, {x=0, y=0, z=0})
+				self.attached_items[#self.attached_items + 1] = obj_
+			end
+		end
+		self.punched = false
+		update.vel = true
+	end
+
+	railparams = railparams or get_railparams(pos)
+
+	if not (update.vel or update.pos) then
+		rail_on_step_event(railparams.on_step, self, dtime)
+		return
+	end
+
+	local yaw = 0
+	if self.old_dir.x < 0 then
+		yaw = 0.5
+	elseif self.old_dir.x > 0 then
+		yaw = 1.5
+	elseif self.old_dir.z < 0 then
+		yaw = 1
+	end
+	self.object:setyaw(yaw * math.pi)
+
+	local anim = {x=0, y=0}
+	if dir.y == -1 then
+		anim = {x=1, y=1}
+	elseif dir.y == 1 then
+		anim = {x=2, y=2}
+	end
+	self.object:set_animation(anim, 1, 0)
+
+	self.object:setvelocity(vel)
+	if update.pos then
+		self.object:setpos(pos)
+	end
+
+	-- call event handler
+	rail_on_step_event(railparams.on_step, self, dtime)
+end
+
+function cart_entity:on_step(dtime)
+	rail_on_step(self, dtime)
+	rail_sound(self, dtime)
+end
+
+minetest.register_entity("carts:cart", cart_entity)
+
+minetest.register_craftitem("carts:cart", {
+	description = "Cart (Sneak+Click to pick up)",
+	inventory_image = minetest.inventorycube("carts_cart_top.png", "carts_cart_side.png", "carts_cart_side.png"),
+	wield_image = "carts_cart_side.png",
+	on_place = function(itemstack, placer, pointed_thing)
+		local under = pointed_thing.under
+		local node = minetest.get_node(under)
+		local udef = minetest.registered_nodes[node.name]
+		if udef and udef.on_rightclick and
+				not (placer and placer:get_player_control().sneak) then
+			return udef.on_rightclick(under, node, placer, itemstack,
+				pointed_thing) or itemstack
+		end
+
+		if not pointed_thing.type == "node" then
+			return
+		end
+		if carts:is_rail(pointed_thing.under) then
+			minetest.add_entity(pointed_thing.under, "carts:cart")
+		elseif carts:is_rail(pointed_thing.above) then
+			minetest.add_entity(pointed_thing.above, "carts:cart")
+		else
+			return
+		end
+
+		minetest.sound_play({name = "default_place_node_metal", gain = 0.5},
+			{pos = pointed_thing.above})
+
+		if not (creative and creative.is_enabled_for
+				and creative.is_enabled_for(placer:get_player_name())) then
+			itemstack:take_item()
+		end
+		return itemstack
+	end,
+})
+
+minetest.register_craft({
+	output = "carts:cart",
+	recipe = {
+		{"default:steel_ingot", "", "default:steel_ingot"},
+		{"default:steel_ingot", "default:steel_ingot", "default:steel_ingot"},
+	},
+})

mods/carts/depends.txt

@@ -0,0 +1 @@
+default

mods/carts/functions.lua

@@ -0,0 +1,221 @@
+function carts:get_sign(z)
+	if z == 0 then
+		return 0
+	else
+		return z / math.abs(z)
+	end
+end
+
+function carts:manage_attachment(player, obj)
+	if not player then
+		return
+	end
+	local status = obj ~= nil
+	local player_name = player:get_player_name()
+	if default.player_attached[player_name] == status then
+		return
+	end
+	default.player_attached[player_name] = status
+
+	if status then
+		player:set_attach(obj, "", {x=0, y=6, z=0}, {x=0, y=0, z=0})
+		player:set_eye_offset({x=0, y=-4, z=0},{x=0, y=-4, z=0})
+	else
+		player:set_detach()
+		player:set_eye_offset({x=0, y=0, z=0},{x=0, y=0, z=0})
+	end
+end
+
+function carts:velocity_to_dir(v)
+	if math.abs(v.x) > math.abs(v.z) then
+		return {x=carts:get_sign(v.x), y=carts:get_sign(v.y), z=0}
+	else
+		return {x=0, y=carts:get_sign(v.y), z=carts:get_sign(v.z)}
+	end
+end
+
+function carts:is_rail(pos, railtype)
+	local node = minetest.get_node(pos).name
+	if node == "ignore" then
+		local vm = minetest.get_voxel_manip()
+		local emin, emax = vm:read_from_map(pos, pos)
+		local area = VoxelArea:new{
+			MinEdge = emin,
+			MaxEdge = emax,
+		}
+		local data = vm:get_data()
+		local vi = area:indexp(pos)
+		node = minetest.get_name_from_content_id(data[vi])
+	end
+	if minetest.get_item_group(node, "rail") == 0 then
+		return false
+	end
+	if not railtype then
+		return true
+	end
+	return minetest.get_item_group(node, "connect_to_raillike") == railtype
+end
+
+function carts:check_front_up_down(pos, dir_, check_up, railtype)
+	local dir = vector.new(dir_)
+	local cur
+
+	-- Front
+	dir.y = 0
+	cur = vector.add(pos, dir)
+	if carts:is_rail(cur, railtype) then
+		return dir
+	end
+	-- Up
+	if check_up then
+		dir.y = 1
+		cur = vector.add(pos, dir)
+		if carts:is_rail(cur, railtype) then
+			return dir
+		end
+	end
+	-- Down
+	dir.y = -1
+	cur = vector.add(pos, dir)
+	if carts:is_rail(cur, railtype) then
+		return dir
+	end
+	return nil
+end
+
+function carts:get_rail_direction(pos_, dir, ctrl, old_switch, railtype)
+	local pos = vector.round(pos_)
+	local cur
+	local left_check, right_check = true, true
+
+	-- Check left and right
+	local left = {x=0, y=0, z=0}
+	local right = {x=0, y=0, z=0}
+	if dir.z ~= 0 and dir.x == 0 then
+		left.x = -dir.z
+		right.x = dir.z
+	elseif dir.x ~= 0 and dir.z == 0 then
+		left.z = dir.x
+		right.z = -dir.x
+	end
+
+	if ctrl then
+		if old_switch == 1 then
+			left_check = false
+		elseif old_switch == 2 then
+			right_check = false
+		end
+		if ctrl.left and left_check then
+			cur = carts:check_front_up_down(pos, left, false, railtype)
+			if cur then
+				return cur, 1
+			end
+			left_check = false
+		end
+		if ctrl.right and right_check then
+			cur = carts:check_front_up_down(pos, right, false, railtype)
+			if cur then
+				return cur, 2
+			end
+			right_check = true
+		end
+	end
+
+	-- Normal
+	cur = carts:check_front_up_down(pos, dir, true, railtype)
+	if cur then
+		return cur
+	end
+
+	-- Left, if not already checked
+	if left_check then
+		cur = carts:check_front_up_down(pos, left, false, railtype)
+		if cur then
+			return cur
+		end
+	end
+
+	-- Right, if not already checked
+	if right_check then
+		cur = carts:check_front_up_down(pos, right, false, railtype)
+		if cur then
+			return cur
+		end
+	end
+
+	-- Backwards
+	if not old_switch then
+		cur = carts:check_front_up_down(pos, {
+				x = -dir.x,
+				y = dir.y,
+				z = -dir.z
+			}, true, railtype)
+		if cur then
+			return cur
+		end
+	end
+
+	return {x=0, y=0, z=0}
+end
+
+function carts:pathfinder(pos_, old_pos, old_dir, ctrl, pf_switch, railtype)
+	local pos = vector.round(pos_)
+	local pf_pos = vector.round(old_pos)
+	local pf_dir = vector.new(old_dir)
+
+	for i = 1, 3 do
+		if vector.equals(pf_pos, pos) then
+			-- Success! Cart moved on correctly
+			return true
+		end
+
+		pf_dir, pf_switch = carts:get_rail_direction(pf_pos, pf_dir, ctrl, pf_switch, railtype)
+		if vector.equals(pf_dir, {x=0, y=0, z=0}) then
+			-- No way forwards
+			return false
+		end
+
+		pf_pos = vector.add(pf_pos, pf_dir)
+	end
+	-- Cart not found
+	return false
+end
+
+function carts:register_rail(name, def_overwrite, railparams)
+	local def = {
+		drawtype = "raillike",
+		paramtype = "light",
+		sunlight_propagates = true,
+		is_ground_content = false,
+		walkable = false,
+		selection_box = {
+			type = "fixed",
+			fixed = {-1/2, -1/2, -1/2, 1/2, -1/2+1/16, 1/2},
+		},
+		sounds = default.node_sound_metal_defaults()
+	}
+	for k, v in pairs(def_overwrite) do
+		def[k] = v
+	end
+	if not def.inventory_image then
+		def.wield_image = def.tiles[1]
+		def.inventory_image = def.tiles[1]
+	end
+
+	if railparams then
+		carts.railparams[name] = table.copy(railparams)
+	end
+
+	minetest.register_node(name, def)
+end
+
+function carts:get_rail_groups(additional_groups)
+	-- Get the default rail groups and add more when a table is given
+	local groups = {dig_immediate = 2, attached_node = 1, rail = 1, connect_to_raillike = 1}
+	if type(additional_groups) == "table" then
+		for k, v in pairs(additional_groups) do
+			groups[k] = v
+		end
+	end
+	return groups
+end

mods/carts/init.lua

@@ -0,0 +1,20 @@
+
+carts = {}
+carts.modpath = minetest.get_modpath("carts")
+carts.railparams = {}
+
+-- Maximal speed of the cart in m/s (min = -1)
+carts.speed_max = 7
+-- Set to -1 to disable punching the cart from inside (min = -1)
+carts.punch_speed_max = 5
+
+
+dofile(carts.modpath.."/functions.lua")
+dofile(carts.modpath.."/rails.lua")
+
+-- Support for non-default games
+if not default.player_attached then
+	default.player_attached = {}
+end
+
+dofile(carts.modpath.."/cart_entity.lua")

mods/carts/license.txt

@@ -0,0 +1,54 @@
+
+License of source code
+----------------------
+
+The MIT License (MIT)
+Copyright (C) 2012-2016 PilzAdam
+Copyright (C) 2014-2016 SmallJoker
+Copyright (C) 2012-2016 Various Minetest developers and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+For more details:
+https://opensource.org/licenses/MIT
+
+
+Licenses of media
+-----------------
+
+CC-0, see: https://creativecommons.org/share-your-work/public-domain/cc0/, except
+if other license is mentioned.
+
+
+Authors
+---------
+Originally from PixelBOX (Gambit):
+	carts_cart_side.png
+	carts_cart_top.png
+	carts_cart_front.png*
+	carts_cart.png*
+
+sofar + stujones11:
+	carts_cart.b3d and carts_cart.blend
+
+hexafraction, modified by sofar
+	carts_rail_*.png
+
+http://www.freesound.org/people/YleArkisto/sounds/253159/ - YleArkisto - CC-BY-3.0
+	carts_cart_moving.*.ogg

mods/carts/rails.lua

@@ -0,0 +1,59 @@
+carts:register_rail("carts:rail", {
+	description = "Rail",
+	tiles = {
+		"carts_rail_straight.png", "carts_rail_curved.png",
+		"carts_rail_t_junction.png", "carts_rail_crossing.png"
+	},
+	inventory_image = "carts_rail_straight.png",
+	wield_image = "carts_rail_straight.png",
+	groups = carts:get_rail_groups(),
+}, {})
+
+minetest.register_craft({
+	output = "carts:rail 18",
+	recipe = {
+		{"default:steel_ingot", "group:wood", "default:steel_ingot"},
+		{"default:steel_ingot", "", "default:steel_ingot"},
+		{"default:steel_ingot", "group:wood", "default:steel_ingot"},
+	}
+})
+
+minetest.register_alias("default:rail", "carts:rail")
+
+
+carts:register_rail("carts:powerrail", {
+	description = "Powered rail",
+	tiles = {
+		"carts_rail_straight_pwr.png", "carts_rail_curved_pwr.png",
+		"carts_rail_t_junction_pwr.png", "carts_rail_crossing_pwr.png"
+	},
+	groups = carts:get_rail_groups(),
+}, {acceleration = 5})
+
+minetest.register_craft({
+	output = "carts:powerrail 18",
+	recipe = {
+		{"default:steel_ingot", "group:wood", "default:steel_ingot"},
+		{"default:steel_ingot", "default:mese_crystal", "default:steel_ingot"},
+		{"default:steel_ingot", "group:wood", "default:steel_ingot"},
+	}
+})
+
+
+carts:register_rail("carts:brakerail", {
+	description = "Brake rail",
+	tiles = {
+		"carts_rail_straight_brk.png", "carts_rail_curved_brk.png",
+		"carts_rail_t_junction_brk.png", "carts_rail_crossing_brk.png"
+	},
+	groups = carts:get_rail_groups(),
+}, {acceleration = -3})
+
+minetest.register_craft({
+	output = "carts:brakerail 18",
+	recipe = {
+		{"default:steel_ingot", "group:wood", "default:steel_ingot"},
+		{"default:steel_ingot", "default:coal_lump", "default:steel_ingot"},
+		{"default:steel_ingot", "group:wood", "default:steel_ingot"},
+	}
+})

mods/creative/README.txt

@@ -1,22 +1,12 @@
-Minetest 0.4 mod: creative
+Minetest Game mod: creative
-==========================
+===========================
+See license.txt for license information.
 
-Implements creative mode.
+Authors of source code
-
+----------------------
-Switch on by using the "creative_mode" setting.
+Originally by Perttu Ahola (celeron55) <celeron55@gmail.com> (MIT)
-
+Jean-Patrick G. (kilbith) <jeanpatrick.guerrero@gmail.com> (MIT)
-Registered items that
-- have a description, and
-- do not have the group not_in_creative_inventory
-are added to the creative inventory.
-
-License of source code and media files:
----------------------------------------
-Copyright (C) 2012 Perttu Ahola (celeron55) <celeron55@gmail.com>
-
-This program is free software. It comes without any warranty, to
-the extent permitted by applicable law. You can redistribute it
-and/or modify it under the terms of the Do What The Fuck You Want
-To Public License, Version 2, as published by Sam Hocevar. See
-http://sam.zoy.org/wtfpl/COPYING for more details.
 
+Author of media (textures)
+--------------------------
+Jean-Patrick G. (kilbith) <jeanpatrick.guerrero@gmail.com> (CC BY-SA 3.0)

mods/creative/depends.txt

@@ -1 +1,2 @@
 default
+sfinv

mods/creative/init.lua

@@ -1,162 +1,63 @@
--- minetest/creative/init.lua
+creative = {}
 
-local creative_inventory = {}
+local creative_mode_cache = minetest.settings:get_bool("creative_mode")
-creative_inventory.creative_inventory_size = 0
 
--- Create detached creative inventory after loading all mods
+function creative.is_enabled_for(name)
-minetest.after(0, function()
+	return creative_mode_cache
-	local inv = minetest.create_detached_inventory("creative", {
-		allow_move = function(inv, from_list, from_index, to_list, to_index, count, player)
-			if minetest.setting_getbool("creative_mode") then
-				return count
-			else
-				return 0
-			end
-		end,
-		allow_put = function(inv, listname, index, stack, player)
-			return 0
-		end,
-		allow_take = function(inv, listname, index, stack, player)
-			if minetest.setting_getbool("creative_mode") then
-				return -1
-			else
-				return 0
-			end
-		end,
-		on_move = function(inv, from_list, from_index, to_list, to_index, count, player)
-		end,
-		on_put = function(inv, listname, index, stack, player)
-		end,
-		on_take = function(inv, listname, index, stack, player)
-			print(player:get_player_name().." takes item from creative inventory; listname="..dump(listname)..", index="..dump(index)..", stack="..dump(stack))
-			if stack then
-				print("stack:get_name()="..dump(stack:get_name())..", stack:get_count()="..dump(stack:get_count()))
-			end
-		end,
-	})
-	local creative_list = {}
-	for name,def in pairs(minetest.registered_items) do
-		if (not def.groups.not_in_creative_inventory or def.groups.not_in_creative_inventory == 0)
-				and def.description and def.description ~= "" then
-			table.insert(creative_list, name)
-		end
-	end
-	table.sort(creative_list)
-	inv:set_size("main", #creative_list)
-	for _,itemstring in ipairs(creative_list) do
-		inv:add_item("main", ItemStack(itemstring))
-	end
-	creative_inventory.creative_inventory_size = #creative_list
-	print("creative inventory size: "..dump(creative_inventory.creative_inventory_size))
-end)
-
--- Create the trash field
-local trash = minetest.create_detached_inventory("creative_trash", {
-	-- Allow the stack to be placed and remove it in on_put()
-	-- This allows the creative inventory to restore the stack
-	allow_put = function(inv, listname, index, stack, player)
-		if minetest.setting_getbool("creative_mode") then
-			return stack:get_count()
-		else
-			return 0
-		end
-	end,
-	on_put = function(inv, listname, index, stack, player)
-		inv:set_stack(listname, index, "")
-	end,
-})
-trash:set_size("main", 1)
-
-
-creative_inventory.set_creative_formspec = function(player, start_i, pagenum)
-	pagenum = math.floor(pagenum)
-	local pagemax = math.floor((creative_inventory.creative_inventory_size-1) / (6*4) + 1)
-	player:set_inventory_formspec("size[13,7.5]"..
-			--"image[6,0.6;1,2;player.png]"..
-			"list[current_player;main;5,3.5;8,4;]"..
-			"list[current_player;craft;8,0;3,3;]"..
-			"list[current_player;craftpreview;12,1;1,1;]"..
-			"list[detached:creative;main;0.3,0.5;4,6;"..tostring(start_i).."]"..
-			"label[2.0,6.55;"..tostring(pagenum).."/"..tostring(pagemax).."]"..
-			"button[0.3,6.5;1.6,1;creative_prev;<<]"..
-			"button[2.7,6.5;1.6,1;creative_next;>>]"..
-			"label[5,1.5;Trash:]"..
-			"list[detached:creative_trash;main;5,2;1,1;]")
 end
-minetest.register_on_joinplayer(function(player)
-	-- If in creative mode, modify player's inventory forms
-	if not minetest.setting_getbool("creative_mode") then
-		return
-	end
-	creative_inventory.set_creative_formspec(player, 0, 1)
-end)
-minetest.register_on_player_receive_fields(function(player, formname, fields)
-	if not minetest.setting_getbool("creative_mode") then
-		return
-	end
-	-- Figure out current page from formspec
-	local current_page = 0
-	local formspec = player:get_inventory_formspec()
-	local start_i = string.match(formspec, "list%[detached:creative;main;[%d.]+,[%d.]+;[%d.]+,[%d.]+;(%d+)%]")
-	start_i = tonumber(start_i) or 0
 
-	if fields.creative_prev then
+dofile(minetest.get_modpath("creative") .. "/inventory.lua")
-		start_i = start_i - 4*6
-	end
-	if fields.creative_next then
-		start_i = start_i + 4*6
-	end
 
-	if start_i < 0 then
+if creative_mode_cache then
-		start_i = start_i + 4*6
+	-- Dig time is modified according to difference (leveldiff) between tool
-	end
+	-- 'maxlevel' and node 'level'. Digtime is divided by the larger of
-	if start_i >= creative_inventory.creative_inventory_size then
+	-- leveldiff and 1.
-		start_i = start_i - 4*6
+	-- To speed up digging in creative, hand 'maxlevel' and 'digtime' have been
-	end
+	-- increased such that nodes of differing levels have an insignificant
-		
+	-- effect on digtime.
-	if start_i < 0 or start_i >= creative_inventory.creative_inventory_size then
+	local digtime = 42
-		start_i = 0
+	local caps = {times = {digtime, digtime, digtime}, uses = 0, maxlevel = 256}
-	end
 
-	creative_inventory.set_creative_formspec(player, start_i, start_i / (6*4) + 1)
-end)
-
-if minetest.setting_getbool("creative_mode") then
-	
 	minetest.register_item(":", {
 		type = "none",
 		wield_image = "wieldhand.png",
-		wield_scale = {x=1,y=1,z=2.5},
+		wield_scale = {x = 1, y = 1, z = 2.5},
+		range = 10,
 		tool_capabilities = {
 			full_punch_interval = 0.5,
 			max_drop_level = 3,
 			groupcaps = {
-				crumbly = {times={[1]=0.5, [2]=0.5, [3]=0.5}, uses=0, maxlevel=3},
+				crumbly = caps,
-				cracky = {times={[1]=0.5, [2]=0.5, [3]=0.5}, uses=0, maxlevel=3},
+				cracky  = caps,
-				snappy = {times={[1]=0.5, [2]=0.5, [3]=0.5}, uses=0, maxlevel=3},
+				snappy  = caps,
-				choppy = {times={[1]=0.5, [2]=0.5, [3]=0.5}, uses=0, maxlevel=3},
+				choppy  = caps,
-				oddly_breakable_by_hand = {times={[1]=0.5, [2]=0.5, [3]=0.5}, uses=0, maxlevel=3},
+				oddly_breakable_by_hand = caps,
-			}
+			},
+			damage_groups = {fleshy = 10},
 		}
 	})
-	
+end
-	minetest.register_on_placenode(function(pos, newnode, placer, oldnode, itemstack)
+
-		return true
+-- Unlimited node placement
-	end)
+minetest.register_on_placenode(function(pos, newnode, placer, oldnode, itemstack)
-	
+	return creative.is_enabled_for(placer:get_player_name())
-	function minetest.handle_node_drops(pos, drops, digger)
+end)
-		if not digger or not digger:is_player() then
+
-			return
+-- Don't pick up if the item is already in the inventory
-		end
+local old_handle_node_drops = minetest.handle_node_drops
-		local inv = digger:get_inventory()
+function minetest.handle_node_drops(pos, drops, digger)
-		if inv then
+	if not digger or not digger:is_player() then
-			for _,item in ipairs(drops) do
+		return
-				item = ItemStack(item):get_name()
+	end
-				if not inv:contains_item("main", item) then
+	if not creative.is_enabled_for(digger:get_player_name()) then
-					inv:add_item("main", item)
+		return old_handle_node_drops(pos, drops, digger)
-				end
+	end
+	local inv = digger:get_inventory()
+	if inv then
+		for _, item in ipairs(drops) do
+			if not inv:contains_item("main", item, true) then
+				inv:add_item("main", item)
 			end
 		end
 	end
-	
 end

mods/creative/inventory.lua

@@ -0,0 +1,177 @@
+local player_inventory = {}
+
+function creative.init_creative_inventory(player)
+	local player_name = player:get_player_name()
+	player_inventory[player_name] = {
+		size = 0,
+		filter = "",
+		start_i = 0
+	}
+
+	minetest.create_detached_inventory("creative_" .. player_name, {
+		allow_move = function(inv, from_list, from_index, to_list, to_index, count, player2)
+			if not to_list == "main" then
+				return count
+			else
+				return 0
+			end
+		end,
+		allow_put = function(inv, listname, index, stack, player2)
+			return 0
+		end,
+		allow_take = function(inv, listname, index, stack, player2)
+			return -1
+		end,
+		on_move = function(inv, from_list, from_index, to_list, to_index, count, player2)
+		end,
+		on_put = function(inv, listname, index, stack, player2)
+		end,
+		on_take = function(inv, listname, index, stack, player2)
+			if stack and stack:get_count() > 0 then
+				minetest.log("action", player_name .. " takes " .. stack:get_name().. " from creative inventory")
+			end
+		end,
+	}, player_name)
+
+	return player_inventory[player_name]
+end
+
+function creative.update_creative_inventory(player_name, tab_content)
+	local creative_list = {}
+	local inv = player_inventory[player_name] or
+			creative.init_creative_inventory(minetest.get_player_by_name(player_name))
+	local player_inv = minetest.get_inventory({type = "detached", name = "creative_" .. player_name})
+
+	for name, def in pairs(tab_content) do
+		if not (def.groups.not_in_creative_inventory == 1) and
+				def.description and def.description ~= "" and
+				(def.name:find(inv.filter, 1, true) or
+					def.description:lower():find(inv.filter, 1, true)) then
+			creative_list[#creative_list+1] = name
+		end
+	end
+
+	table.sort(creative_list)
+	player_inv:set_size("main", #creative_list)
+	player_inv:set_list("main", creative_list)
+	inv.size = #creative_list
+end
+
+-- Create the trash field
+local trash = minetest.create_detached_inventory("creative_trash", {
+	-- Allow the stack to be placed and remove it in on_put()
+	-- This allows the creative inventory to restore the stack
+	allow_put = function(inv, listname, index, stack, player)
+		return stack:get_count()
+	end,
+	on_put = function(inv, listname)
+		inv:set_list(listname, {})
+	end,
+})
+trash:set_size("main", 1)
+
+creative.formspec_add = ""
+
+function creative.register_tab(name, title, items)
+	sfinv.register_page("creative:" .. name, {
+		title = title,
+		is_in_nav = function(self, player, context)
+			return creative.is_enabled_for(player:get_player_name())
+		end,
+		get = function(self, player, context)
+			local player_name = player:get_player_name()
+			creative.update_creative_inventory(player_name, items)
+			local inv = player_inventory[player_name]
+			local start_i = inv.start_i or 0
+			local pagenum = math.floor(start_i / (3*8) + 1)
+			local pagemax = math.ceil(inv.size / (3*8))
+			return sfinv.make_formspec(player, context,
+				"label[6.2,3.35;" .. minetest.colorize("#FFFF00", tostring(pagenum)) .. " / " .. tostring(pagemax) .. "]" ..
+				[[
+					image[4.06,3.4;0.8,0.8;creative_trash_icon.png]
+					listcolors[#00000069;#5A5A5A;#141318;#30434C;#FFF]
+					list[current_player;main;0,4.7;8,1;]
+					list[current_player;main;0,5.85;8,3;8]
+					list[detached:creative_trash;main;4,3.3;1,1;]
+					listring[]
+					button[5.4,3.2;0.8,0.9;creative_prev;<]
+					button[7.25,3.2;0.8,0.9;creative_next;>]
+					button[2.1,3.4;0.8,0.5;creative_search;?]
+					button[2.75,3.4;0.8,0.5;creative_clear;X]
+					tooltip[creative_search;Search]
+					tooltip[creative_clear;Reset]
+					listring[current_player;main]
+					field_close_on_enter[creative_filter;false]
+				]] ..
+				"field[0.3,3.5;2.2,1;creative_filter;;" .. minetest.formspec_escape(inv.filter) .. "]" ..
+				"listring[detached:creative_" .. player_name .. ";main]" ..
+				"list[detached:creative_" .. player_name .. ";main;0,0;8,3;" .. tostring(start_i) .. "]" ..
+				default.get_hotbar_bg(0,4.7) ..
+				default.gui_bg .. default.gui_bg_img .. default.gui_slots
+				.. creative.formspec_add, false)
+		end,
+		on_enter = function(self, player, context)
+			local player_name = player:get_player_name()
+			local inv = player_inventory[player_name]
+			if inv then
+				inv.start_i = 0
+			end
+		end,
+		on_player_receive_fields = function(self, player, context, fields)
+			local player_name = player:get_player_name()
+			local inv = player_inventory[player_name]
+			assert(inv)
+
+			if fields.creative_clear then
+				inv.start_i = 0
+				inv.filter = ""
+				creative.update_creative_inventory(player_name, items)
+				sfinv.set_player_inventory_formspec(player, context)
+			elseif fields.creative_search or
+					fields.key_enter_field == "creative_filter" then
+				inv.start_i = 0
+				inv.filter = fields.creative_filter:lower()
+				creative.update_creative_inventory(player_name, items)
+				sfinv.set_player_inventory_formspec(player, context)
+			elseif not fields.quit then
+				local start_i = inv.start_i or 0
+
+				if fields.creative_prev then
+					start_i = start_i - 3*8
+					if start_i < 0 then
+						start_i = inv.size - (inv.size % (3*8))
+						if inv.size == start_i then
+							start_i = math.max(0, inv.size - (3*8))
+						end
+					end
+				elseif fields.creative_next then
+					start_i = start_i + 3*8
+					if start_i >= inv.size then
+						start_i = 0
+					end
+				end
+
+				inv.start_i = start_i
+				sfinv.set_player_inventory_formspec(player, context)
+			end
+		end
+	})
+end
+
+minetest.register_on_joinplayer(function(player)
+	creative.update_creative_inventory(player:get_player_name(), minetest.registered_items)
+end)
+
+creative.register_tab("all", "All", minetest.registered_items)
+creative.register_tab("nodes", "Nodes", minetest.registered_nodes)
+creative.register_tab("tools", "Tools", minetest.registered_tools)
+creative.register_tab("craftitems", "Items", minetest.registered_craftitems)
+
+local old_homepage_name = sfinv.get_homepage_name
+function sfinv.get_homepage_name(player)
+	if creative.is_enabled_for(player:get_player_name()) then
+		return "creative:all"
+	else
+		return old_homepage_name(player)
+	end
+end

mods/creative/license.txt

@@ -0,0 +1,60 @@
+License of source code
+----------------------
+
+The MIT License (MIT)
+Copyright (C) 2012-2016 Perttu Ahola (celeron55) <celeron55@gmail.com>
+Copyright (C) 2015-2016 Jean-Patrick G. (kilbith) <jeanpatrick.guerrero@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+For more details:
+https://opensource.org/licenses/MIT
+
+
+Licenses of media (textures)
+----------------------------
+
+Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
+Copyright (C) 2016 Jean-Patrick G. (kilbith) <jeanpatrick.guerrero@gmail.com>
+
+You are free to:
+Share — copy and redistribute the material in any medium or format.
+Adapt — remix, transform, and build upon the material for any purpose, even commercially.
+The licensor cannot revoke these freedoms as long as you follow the license terms.
+
+Under the following terms:
+
+Attribution — You must give appropriate credit, provide a link to the license, and
+indicate if changes were made. You may do so in any reasonable manner, but not in any way
+that suggests the licensor endorses you or your use.
+
+ShareAlike — If you remix, transform, or build upon the material, you must distribute
+your contributions under the same license as the original.
+
+No additional restrictions — You may not apply legal terms or technological measures that
+legally restrict others from doing anything the license permits.
+
+Notices:
+
+You do not have to comply with the license for elements of the material in the public
+domain or where your use is permitted by an applicable exception or limitation.
+No warranties are given. The license may not give you all of the permissions necessary
+for your intended use. For example, other rights such as publicity, privacy, or moral
+rights may limit how you use the material.
+
+For more details:
+http://creativecommons.org/licenses/by-sa/3.0/

mods/default/README.txt

@@ -1,95 +1,300 @@
-Minetest 0.4 mod: default
+Minetest Game mod: default
 ==========================
+See license.txt for license information.
 
-License of source code:
+Authors of source code
------------------------
+----------------------
-Copyright (C) 2011-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Originally by celeron55, Perttu Ahola <celeron55@gmail.com> (LGPL 2.1)
+Various Minetest developers and contributors (LGPL 2.1)
 
-This program is free software; you can redistribute it and/or modify
+Authors of media (textures, models and sounds)
-it under the terms of the GNU Lesser General Public License as published by
+----------------------------------------------
-the Free Software Foundation; either version 2.1 of the License, or
-(at your option) any later version.
-
-http://www.gnu.org/licenses/lgpl-2.1.html
-
-License of media (textures and sounds)
---------------------------------------
-Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)                                 
-http://creativecommons.org/licenses/by-sa/3.0/
-
-Authors of media files
------------------------
 Everything not listed in here:
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+celeron55, Perttu Ahola <celeron55@gmail.com> (CC BY-SA 3.0)
 
-Originating from work by kddekadenz/Dogers:
+Cisoun's texture pack (CC BY-SA 3.0):
-  default_grass_footstep.{1,2,3}.ogg
-  default_dig_crumbly.{1,2}.ogg
-
-Cisoun's WTFPL texture pack:
-  default_chest_front.png
-  default_chest_lock.png
-  default_chest_side.png
-  default_chest_top.png
-  default_cobble.png
-  default_dirt.png
-  default_grass.png
-  default_grass_side.png
   default_jungletree.png
-  default_jungletree_top.png
   default_lava.png
   default_leaves.png
-  default_mossycobble.png
-  default_sand.png
   default_sapling.png
-  default_sign_wall.png
+  default_bush_sapling.png
   default_stone.png
-  default_tool_mesepick.png
-  default_tool_steelpick.png
-  default_tool_steelshovel.png
-  default_tool_stonepick.png
-  default_tool_stoneshovel.png
-  default_tool_woodpick.png
-  default_tool_woodshovel.png
   default_tree.png
   default_tree_top.png
   default_water.png
 
-Originating from G4JC's Almost MC Texture Pack:
+Cisoun's conifers mod (CC BY-SA 3.0):
-  default_wood.png
+  default_pine_needles.png
+
+Originating from G4JC's Almost MC Texture Pack (CC BY-SA 3.0):
   default_torch.png
   default_torch_on_ceiling.png
   default_torch_on_floor.png
 
-VanessaE's animated torches (WTFPL):
+VanessaE's animated torches (CC BY-SA 3.0):
   default_torch_animated.png
   default_torch_on_ceiling_animated.png
   default_torch_on_floor_animated.png
   default_torch_on_floor.png
 
-RealBadAngel's animated water (WTFPL):
+RealBadAngel's animated water (CC BY-SA 3.0):
   default_water_source_animated.png
   default_water_flowing_animated.png
 
-VanessaE:
+VanessaE (CC BY-SA 3.0):
-  default_nc_back.png
+  default_desert_sand.png
-  default_nc_front.png
+  default_desert_stone.png
-  default_nc_rb.png
+  default_sand.png
-  default_nc_side.png
+  default_mese_crystal.png
+  default_mese_crystal_fragment.png
 
-Calinou's improved default textures (CC BY-SA):
+Calinou (CC BY-SA 3.0):
   default_brick.png
-  default_clay_brick.png
   default_papyrus.png
-  default_tool_steelsword.png
+  default_mineral_copper.png
+  default_glass_detail.png
 
-MirceaKitsune (WTFPL):
+MirceaKitsune (CC BY-SA 3.0):
   character.x
 
 Jordach (CC BY-SA 3.0):
   character.png
 
+PilzAdam (CC BY-SA 3.0):
+  default_jungleleaves.png
+  default_junglesapling.png
+  default_obsidian_glass.png
+  default_obsidian_shard.png
+  default_mineral_gold.png
+
+jojoa1997 (CC BY-SA 3.0):
+  default_obsidian.png
+
+InfinityProject (CC BY-SA 3.0):
+  default_mineral_diamond.png
+
+Splizard (CC BY-SA 3.0):
+  default_pine_sapling.png
+
+Zeg9 (CC BY-SA 3.0):
+  default_coal_block.png
+
+paramat (CC BY-SA 3.0):
+  wieldhand.png -- Copied from character.png by Jordach (CC BY-SA 3.0)
+  default_pinetree.png
+  default_pinetree_top.png
+  default_pinewood.png
+  default_acacia_leaves.png
+  default_acacia_leaves_simple.png
+  default_acacia_sapling.png
+  default_acacia_bush_sapling.png
+  default_acacia_tree.png
+  default_acacia_tree_top.png
+  default_acacia_wood.png
+  default_acacia_bush_stem.png
+  default_bush_stem.png
+  default_junglewood.png
+  default_jungletree_top.png
+  default_sandstone_brick.png
+  default_obsidian_brick.png
+  default_stone_brick.png
+  default_desert_stone_brick.png
+  default_sandstone_block.png
+  default_obsidian_block.png
+  default_stone_block.png
+  default_desert_stone_block.png
+  default_river_water.png
+  default_river_water_source_animated.png
+  default_river_water_flowing_animated.png
+  default_dry_grass.png
+  default_dry_grass_side.png
+  default_dry_grass_*.png
+  default_grass.png
+  default_grass_side.png
+  default_mese_block.png
+  default_silver_sand.png
+  default_mese_post_light_side.png
+  default_mese_post_light_side_dark.png
+  default_mese_post_light_top.png
+  default_silver_sandstone.png -- Derived from a texture by GreenXenith (CC-BY-SA 3.0)
+  default_silver_sandstone_brick.png -- Derived from a texture by GreenXenith (CC-BY-SA 3.0)
+  default_silver_sandstone_block.png -- Derived from a texture by GreenXenith (CC-BY-SA 3.0)
+
+brunob.santos (CC BY-SA 4.0):
+  default_desert_cobble.png
+
+BlockMen (CC BY-SA 3.0):
+  default_aspen_leaves.png -- Derived from Sofar's texture
+  default_wood.png
+  default_clay_brick.png
+  default_iron_ingot.png
+  default_gold_ingot.png
+  default_tool_steelsword.png
+  default_diamond.png
+  default_book.png
+  default_tool_*.png
+  default_lava_source_animated.png
+  default_lava_flowing_animated.png
+  default_stick.png
+  default_chest_front.png
+  default_chest_lock.png
+  default_chest_side.png
+  default_chest_top.png
+  default_mineral_mese.png
+  default_meselamp.png
+  bubble.png
+  gui_*.png
+
+Wuzzy (CC BY-SA 3.0):
+  default_bookshelf_slot.png (based on default_book.png)
+
+sofar (CC BY-SA 3.0):
+  default_book_written.png, based on default_book.png
+  default_aspen_sapling
+  default_aspen_tree
+  default_aspen_tree_top, derived from default_pine_tree_top (by paramat)
+  default_aspen_wood, derived from default_pine_wood (by paramat)
+  default_chest_inside
+
+sofar (WTFPL):
+  default_gravel.png -- Derived from Gambit's PixelBOX texture pack light gravel
+
+Neuromancer (CC BY-SA 2.0):
+  default_cobble.png, based on texture by Brane praefect
+  default_mossycobble.png, based on texture by Brane praefect
+
+Neuromancer (CC BY-SA 3.0):
+  default_dirt.png
+  default_furnace_*.png
+
+Gambit (CC BY-SA 3.0):
+  default_bronze_ingot.png
+  default_copper_ingot.png
+  default_copper_lump.png
+  default_iron_lump.png
+  default_gold_lump.png
+  default_clay_lump.png
+  default_coal.png
+  default_grass_*.png
+  default_paper.png
+  default_diamond_block.png
+  default_ladder_steel.png
+  default_sign_wall_wood.png
+  default_flint.png
+  default_snow.png
+  default_snow_side.png
+  default_snowball.png
+  default_key.png
+  default_key_skeleton.png
+
+asl97 (CC BY-SA 3.0):
+  default_ice.png
+
+KevDoy (CC BY-SA 3.0)
+  heart.png
+
+Pithydon (CC BY-SA 3.0)
+  default_coral_brown.png
+  default_coral_orange.png
+  default_coral_skeleton.png
+
+Ferk (CC0 1.0)
+  default_item_smoke.png
+  default_item_smoke.ogg, based on sound by http://opengameart.org/users/bart
+
+npx (CC BY-SA 3.0)
+  default_rainforest_litter.png
+  default_rainforest_litter_side.png
+
+kaeza (CC-BY-SA 3.0):
+  default_desert_sandstone.png
+  default_desert_sandstone_brick.png
+  default_desert_sandstone_block.png
+
+kilbith (CC BY-SA 3.0):
+  default_steel_block.png
+  default_copper_block.png
+  default_bronze_block.png
+  default_gold_block.png
+  default_tin_block.png
+  default_mineral_tin.png
+  default_tin_ingot.png
+  default_tin_lump.png
+
 Glass breaking sounds (CC BY 3.0):
   1: http://www.freesound.org/people/cmusounddesign/sounds/71947/
   2: http://www.freesound.org/people/Tomlija/sounds/97669/
   3: http://www.freesound.org/people/lsprice/sounds/88808/
+
+sonictechtonic (CC BY 3.0):
+https://www.freesound.org/people/sonictechtonic/sounds/241872/
+  player_damage.ogg
+
+Mito551 (sounds) (CC BY-SA 3.0):
+  default_dig_choppy.ogg
+  default_dig_cracky.ogg
+  default_dig_crumbly.1.ogg
+  default_dig_crumbly.2.ogg
+  default_dig_dig_immediate.ogg
+  default_dig_oddly_breakable_by_hand.ogg
+  default_dug_node.1.ogg
+  default_dug_node.2.ogg
+  default_grass_footstep.1.ogg
+  default_grass_footstep.2.ogg
+  default_grass_footstep.3.ogg
+  default_gravel_footstep.1.ogg
+  default_gravel_footstep.2.ogg
+  default_gravel_footstep.3.ogg
+  default_gravel_footstep.4.ogg
+  default_grass_footstep.1.ogg
+  default_place_node.1.ogg
+  default_place_node.2.ogg
+  default_place_node.3.ogg
+  default_place_node_hard.1.ogg
+  default_place_node_hard.2.ogg
+  default_snow_footstep.1.ogg
+  default_snow_footstep.2.ogg
+  default_hard_footstep.1.ogg
+  default_hard_footstep.2.ogg
+  default_hard_footstep.3.ogg
+  default_sand_footstep.1.ogg
+  default_sand_footstep.2.ogg
+  default_wood_footstep.1.ogg
+  default_wood_footstep.2.ogg
+  default_dirt_footstep.1.ogg
+  default_dirt_footstep.2.ogg
+  default_glass_footstep.ogg
+
+Metal sounds:
+  default_dig_metal.ogg - yadronoff - CC-BY-3.0
+  - https://www.freesound.org/people/yadronoff/sounds/320397/
+  default_dug_metal.*.ogg - Iwan Gabovitch - qubodup - CC0
+  - http://opengameart.org/users/qubodup
+  default_metal_footstep.*.ogg - Ottomaani138 - CC0
+  - https://www.freesound.org/people/Ottomaani138/sounds/232692/
+  default_place_node_metal.*.ogg - Ogrebane - CC0
+  - http://opengameart.org/content/wood-and-metal-sound-effects-volume-2
+
+Tool breaking sounds added by sofar: CC-BY-3.0
+  default_tool_breaks.* - http://www.freesound.org/people/HerbertBoland/sounds/33206/
+
+AGFX (CC BY 3.0)
+https://www.freesound.org/people/AGFX/packs/1253/
+  default_water_footstep.1.ogg
+  default_water_footstep.2.ogg
+  default_water_footstep.3.ogg
+(default_water_footstep.4.ogg is silent)
+
+blukotek (CC0 1.0)
+https://www.freesound.org/people/blukotek/sounds/251660/
+  default_dig_snappy.ogg
+
+Chests sounds added by sofar, derived of several files mixed together:
+  default_chest_open.ogg
+  default_chest_close.ogg
+    - http://www.freesound.org/people/Sevin7/sounds/269722/ CC0
+    - http://www.freesound.org/people/Percy%20Duke/sounds/23448/ CC-BY-3.0
+    - http://www.freesound.org/people/kingsamas/sounds/135576/ CC-BY-3.0
+    - http://www.freesound.org/people/bulbastre/sounds/126887/ CC-BY-3.0
+    - http://www.freesound.org/people/Yoyodaman234/sounds/183541/ CC0
+

mods/default/aliases.lua

@@ -1,10 +1,7 @@
--- legacy (Minetest 0.4 mod)
+-- mods/default/aliases.lua
--- Provides as much backwards-compatibility as feasible
-
---
--- Aliases to support loading 0.3 and old 0.4 worlds and inventories
---
 
+-- Aliases to support loading worlds using nodes following the old naming convention
+-- These can also be helpful when using chat commands, for example /giveme
 minetest.register_alias("stone", "default:stone")
 minetest.register_alias("stone_with_coal", "default:stone_with_coal")
 minetest.register_alias("stone_with_iron", "default:stone_with_iron")
@@ -25,8 +22,8 @@ minetest.register_alias("papyrus", "default:papyrus")
 minetest.register_alias("bookshelf", "default:bookshelf")
 minetest.register_alias("glass", "default:glass")
 minetest.register_alias("wooden_fence", "default:fence_wood")
-minetest.register_alias("rail", "default:rail")
+minetest.register_alias("rail", "carts:rail")
-minetest.register_alias("ladder", "default:ladder")
+minetest.register_alias("ladder", "default:ladder_wood")
 minetest.register_alias("wood", "default:wood")
 minetest.register_alias("mese", "default:mese")
 minetest.register_alias("cloud", "default:cloud")
@@ -35,15 +32,13 @@ minetest.register_alias("water_source", "default:water_source")
 minetest.register_alias("lava_flowing", "default:lava_flowing")
 minetest.register_alias("lava_source", "default:lava_source")
 minetest.register_alias("torch", "default:torch")
-minetest.register_alias("sign_wall", "default:sign_wall")
+minetest.register_alias("sign_wall", "default:sign_wall_wood")
 minetest.register_alias("furnace", "default:furnace")
 minetest.register_alias("chest", "default:chest")
 minetest.register_alias("locked_chest", "default:chest_locked")
 minetest.register_alias("cobble", "default:cobble")
 minetest.register_alias("mossycobble", "default:mossycobble")
 minetest.register_alias("steelblock", "default:steelblock")
-minetest.register_alias("nyancat", "default:nyancat")
-minetest.register_alias("nyancat_rainbow", "default:nyancat_rainbow")
 minetest.register_alias("sapling", "default:sapling")
 minetest.register_alias("apple", "default:apple")
 
@@ -69,65 +64,14 @@ minetest.register_alias("lump_of_iron", "default:iron_lump")
 minetest.register_alias("lump_of_clay", "default:clay_lump")
 minetest.register_alias("steel_ingot", "default:steel_ingot")
 minetest.register_alias("clay_brick", "default:clay_brick")
-minetest.register_alias("scorched_stuff", "default:scorched_stuff")
+minetest.register_alias("snow", "default:snow")
 
---
+-- 'mese_block' was used for a while for the block form of mese
--- Old items
+minetest.register_alias("default:mese_block", "default:mese")
---
 
-minetest.register_craftitem(":rat", {
+-- Aliases for corrected pine node names
-	description = "Rat",
+minetest.register_alias("default:pinetree", "default:pine_tree")
-	inventory_image = "rat.png",
+minetest.register_alias("default:pinewood", "default:pine_wood")
-	on_drop = function(item, dropper, pos)
-		minetest.env:add_rat(pos)
-		item:take_item()
-		return item
-	end,
-	on_place = function(item, dropped, pointed)
-		pos = minetest.get_pointed_thing_position(pointed, true)
-		if pos ~= nil then
-			minetest.env:add_rat(pos)
-			item:take_item()
-			return item
-		end
-	end
-})
 
-minetest.register_craftitem(":cooked_rat", {
+minetest.register_alias("default:ladder", "default:ladder_wood")
-	description = "Cooked rat",
+minetest.register_alias("default:sign_wall", "default:sign_wall_wood")
-	inventory_image = "cooked_rat.png",
-	on_use = minetest.item_eat(6),
-})
-
-minetest.register_craftitem(":firefly", {
-	description = "Firefly",
-	inventory_image = "firefly.png",
-	groups = {not_in_creative_inventory=1},
-	on_drop = function(item, dropper, pos)
-		minetest.env:add_firefly(pos)
-		item:take_item()
-		return item
-	end,
-	on_place = function(item, dropped, pointed)
-		pos = minetest.get_pointed_thing_position(pointed, true)
-		if pos ~= nil then
-			minetest.env:add_firefly(pos)
-			item:take_item()
-			return item
-		end
-	end
-})
-
-minetest.register_craft({
-	type = "cooking",
-	output = "cooked_rat",
-	recipe = "rat",
-})
-
-minetest.register_craft({
-	type = "cooking",
-	output = "scorched_stuff",
-	recipe = "cooked_rat",
-})
-
--- END

mods/default/craftitems.lua

@@ -0,0 +1,334 @@
+-- mods/default/craftitems.lua
+
+minetest.register_craftitem("default:stick", {
+	description = "Stick",
+	inventory_image = "default_stick.png",
+	groups = {stick = 1, flammable = 2},
+})
+
+minetest.register_craftitem("default:paper", {
+	description = "Paper",
+	inventory_image = "default_paper.png",
+	groups = {flammable = 3},
+})
+
+
+local lpp = 14 -- Lines per book's page
+local function book_on_use(itemstack, user)
+	local player_name = user:get_player_name()
+	local meta = itemstack:get_meta()
+	local title, text, owner = "", "", player_name
+	local page, page_max, lines, string = 1, 1, {}, ""
+
+	-- Backwards compatibility
+	local old_data = minetest.deserialize(itemstack:get_metadata())
+	if old_data then
+		meta:from_table({ fields = old_data })
+	end
+
+	local data = meta:to_table().fields
+
+	if data.owner then
+		title = data.title
+		text = data.text
+		owner = data.owner
+
+		for str in (text .. "\n"):gmatch("([^\n]*)[\n]") do
+			lines[#lines+1] = str
+		end
+
+		if data.page then
+			page = data.page
+			page_max = data.page_max
+
+			for i = ((lpp * page) - lpp) + 1, lpp * page do
+				if not lines[i] then break end
+				string = string .. lines[i] .. "\n"
+			end
+		end
+	end
+
+	local formspec
+	if owner == player_name then
+		formspec = "size[8,8]" .. default.gui_bg ..
+			default.gui_bg_img ..
+			"field[0.5,1;7.5,0;title;Title:;" ..
+				minetest.formspec_escape(title) .. "]" ..
+			"textarea[0.5,1.5;7.5,7;text;Contents:;" ..
+				minetest.formspec_escape(text) .. "]" ..
+			"button_exit[2.5,7.5;3,1;save;Save]"
+	else
+		formspec = "size[8,8]" .. default.gui_bg ..
+			default.gui_bg_img ..
+			"label[0.5,0.5;by " .. owner .. "]" ..
+			"tablecolumns[color;text]" ..
+			"tableoptions[background=#00000000;highlight=#00000000;border=false]" ..
+			"table[0.4,0;7,0.5;title;#FFFF00," .. minetest.formspec_escape(title) .. "]" ..
+			"textarea[0.5,1.5;7.5,7;;" ..
+				minetest.formspec_escape(string ~= "" and string or text) .. ";]" ..
+			"button[2.4,7.6;0.8,0.8;book_prev;<]" ..
+			"label[3.2,7.7;Page " .. page .. " of " .. page_max .. "]" ..
+			"button[4.9,7.6;0.8,0.8;book_next;>]"
+	end
+
+	minetest.show_formspec(player_name, "default:book", formspec)
+	return itemstack
+end
+
+minetest.register_on_player_receive_fields(function(player, formname, fields)
+	if formname ~= "default:book" then return end
+	local inv = player:get_inventory()
+	local stack = player:get_wielded_item()
+
+	if fields.save and fields.title ~= "" and fields.text ~= "" then
+		local new_stack, data
+		if stack:get_name() ~= "default:book_written" then
+			local count = stack:get_count()
+			if count == 1 then
+				stack:set_name("default:book_written")
+			else
+				stack:set_count(count - 1)
+				new_stack = ItemStack("default:book_written")
+			end
+		else
+			data = stack:get_meta():to_table().fields
+		end
+
+		if data and data.owner and data.owner ~= player:get_player_name() then
+			return
+		end
+
+		if not data then data = {} end
+		data.title = fields.title
+		data.owner = player:get_player_name()
+		data.description = "\""..fields.title.."\" by "..data.owner
+		data.text = fields.text
+		data.text_len = #data.text
+		data.page = 1
+		data.page_max = math.ceil((#data.text:gsub("[^\n]", "") + 1) / lpp)
+
+		if new_stack then
+			new_stack:get_meta():from_table({ fields = data })
+			if inv:room_for_item("main", new_stack) then
+				inv:add_item("main", new_stack)
+			else
+				minetest.add_item(player:getpos(), new_stack)
+			end
+		else
+			stack:get_meta():from_table({ fields = data })
+		end
+
+	elseif fields.book_next or fields.book_prev then
+		local data = stack:get_meta():to_table().fields
+		if not data or not data.page then
+			return
+		end
+
+		data.page = tonumber(data.page)
+		data.page_max = tonumber(data.page_max)
+
+		if fields.book_next then
+			data.page = data.page + 1
+			if data.page > data.page_max then
+				data.page = 1
+			end
+		else
+			data.page = data.page - 1
+			if data.page == 0 then
+				data.page = data.page_max
+			end
+		end
+
+		stack:get_meta():from_table({fields = data})
+		stack = book_on_use(stack, player)
+	end
+
+	-- Update stack
+	player:set_wielded_item(stack)
+end)
+
+minetest.register_craftitem("default:book", {
+	description = "Book",
+	inventory_image = "default_book.png",
+	groups = {book = 1, flammable = 3},
+	on_use = book_on_use,
+})
+
+minetest.register_craftitem("default:book_written", {
+	description = "Book With Text",
+	inventory_image = "default_book_written.png",
+	groups = {book = 1, not_in_creative_inventory = 1, flammable = 3},
+	stack_max = 1,
+	on_use = book_on_use,
+})
+
+minetest.register_craft({
+	type = "shapeless",
+	output = "default:book_written",
+	recipe = {"default:book", "default:book_written"}
+})
+
+minetest.register_on_craft(function(itemstack, player, old_craft_grid, craft_inv)
+	if itemstack:get_name() ~= "default:book_written" then
+		return
+	end
+
+	local original
+	local index
+	for i = 1, player:get_inventory():get_size("craft") do
+		if old_craft_grid[i]:get_name() == "default:book_written" then
+			original = old_craft_grid[i]
+			index = i
+		end
+	end
+	if not original then
+		return
+	end
+	local copymeta = original:get_meta():to_table()
+	-- copy of the book held by player's mouse cursor
+	itemstack:get_meta():from_table(copymeta)
+	-- put the book with metadata back in the craft grid
+	craft_inv:set_stack("craft", index, original)
+end)
+
+minetest.register_craftitem("default:skeleton_key", {
+	description = "Skeleton Key",
+	inventory_image = "default_key_skeleton.png",
+	groups = {key = 1},
+	on_use = function(itemstack, user, pointed_thing)
+		if pointed_thing.type ~= "node" then
+			return itemstack
+		end
+
+		local pos = pointed_thing.under
+		local node = minetest.get_node(pos)
+
+		if not node then
+			return itemstack
+		end
+
+		local on_skeleton_key_use = minetest.registered_nodes[node.name].on_skeleton_key_use
+		if not on_skeleton_key_use then
+			return itemstack
+		end
+
+		-- make a new key secret in case the node callback needs it
+		local random = math.random
+		local newsecret = string.format(
+			"%04x%04x%04x%04x",
+			random(2^16) - 1, random(2^16) - 1,
+			random(2^16) - 1, random(2^16) - 1)
+
+		local secret, _, _ = on_skeleton_key_use(pos, user, newsecret)
+
+		if secret then
+			local inv = minetest.get_inventory({type="player", name=user:get_player_name()})
+
+			-- update original itemstack
+			itemstack:take_item()
+
+			-- finish and return the new key
+			local new_stack = ItemStack("default:key")
+			local meta = new_stack:get_meta()
+			meta:set_string("secret", secret)
+			meta:set_string("description", "Key to "..user:get_player_name().."'s "
+				..minetest.registered_nodes[node.name].description)
+
+			if itemstack:get_count() == 0 then
+				itemstack = new_stack
+			else
+				if inv:add_item("main", new_stack):get_count() > 0 then
+					minetest.add_item(user:getpos(), new_stack)
+				end -- else: added to inventory successfully
+			end
+
+			return itemstack
+		end
+	end
+})
+
+minetest.register_craftitem("default:coal_lump", {
+	description = "Coal Lump",
+	inventory_image = "default_coal_lump.png",
+	groups = {coal = 1, flammable = 1}
+})
+
+minetest.register_craftitem("default:iron_lump", {
+	description = "Iron Lump",
+	inventory_image = "default_iron_lump.png",
+})
+
+minetest.register_craftitem("default:copper_lump", {
+	description = "Copper Lump",
+	inventory_image = "default_copper_lump.png",
+})
+
+minetest.register_craftitem("default:tin_lump", {
+	description = "Tin Lump",
+	inventory_image = "default_tin_lump.png",
+})
+
+minetest.register_craftitem("default:mese_crystal", {
+	description = "Mese Crystal",
+	inventory_image = "default_mese_crystal.png",
+})
+
+minetest.register_craftitem("default:gold_lump", {
+	description = "Gold Lump",
+	inventory_image = "default_gold_lump.png",
+})
+
+minetest.register_craftitem("default:diamond", {
+	description = "Diamond",
+	inventory_image = "default_diamond.png",
+})
+
+minetest.register_craftitem("default:clay_lump", {
+	description = "Clay Lump",
+	inventory_image = "default_clay_lump.png",
+})
+
+minetest.register_craftitem("default:steel_ingot", {
+	description = "Steel Ingot",
+	inventory_image = "default_steel_ingot.png",
+})
+
+minetest.register_craftitem("default:copper_ingot", {
+	description = "Copper Ingot",
+	inventory_image = "default_copper_ingot.png",
+})
+
+minetest.register_craftitem("default:tin_ingot", {
+	description = "Tin Ingot",
+	inventory_image = "default_tin_ingot.png",
+})
+
+minetest.register_craftitem("default:bronze_ingot", {
+	description = "Bronze Ingot",
+	inventory_image = "default_bronze_ingot.png",
+})
+
+minetest.register_craftitem("default:gold_ingot", {
+	description = "Gold Ingot",
+	inventory_image = "default_gold_ingot.png"
+})
+
+minetest.register_craftitem("default:mese_crystal_fragment", {
+	description = "Mese Crystal Fragment",
+	inventory_image = "default_mese_crystal_fragment.png",
+})
+
+minetest.register_craftitem("default:clay_brick", {
+	description = "Clay Brick",
+	inventory_image = "default_clay_brick.png",
+})
+
+minetest.register_craftitem("default:obsidian_shard", {
+	description = "Obsidian Shard",
+	inventory_image = "default_obsidian_shard.png",
+})
+
+minetest.register_craftitem("default:flint", {
+	description = "Flint",
+	inventory_image = "default_flint.png"
+})

mods/default/functions.lua

@@ -0,0 +1,574 @@
+-- mods/default/functions.lua
+
+--
+-- Sounds
+--
+
+function default.node_sound_defaults(table)
+	table = table or {}
+	table.footstep = table.footstep or
+			{name = "", gain = 1.0}
+	table.dug = table.dug or
+			{name = "default_dug_node", gain = 0.25}
+	table.place = table.place or
+			{name = "default_place_node_hard", gain = 1.0}
+	return table
+end
+
+function default.node_sound_stone_defaults(table)
+	table = table or {}
+	table.footstep = table.footstep or
+			{name = "default_hard_footstep", gain = 0.3}
+	table.dug = table.dug or
+			{name = "default_hard_footstep", gain = 1.0}
+	default.node_sound_defaults(table)
+	return table
+end
+
+function default.node_sound_dirt_defaults(table)
+	table = table or {}
+	table.footstep = table.footstep or
+			{name = "default_dirt_footstep", gain = 0.4}
+	table.dug = table.dug or
+			{name = "default_dirt_footstep", gain = 1.0}
+	table.place = table.place or
+			{name = "default_place_node", gain = 1.0}
+	default.node_sound_defaults(table)
+	return table
+end
+
+function default.node_sound_sand_defaults(table)
+	table = table or {}
+	table.footstep = table.footstep or
+			{name = "default_sand_footstep", gain = 0.12}
+	table.dug = table.dug or
+			{name = "default_sand_footstep", gain = 0.24}
+	table.place = table.place or
+			{name = "default_place_node", gain = 1.0}
+	default.node_sound_defaults(table)
+	return table
+end
+
+function default.node_sound_gravel_defaults(table)
+	table = table or {}
+	table.footstep = table.footstep or
+			{name = "default_gravel_footstep", gain = 0.4}
+	table.dug = table.dug or
+			{name = "default_gravel_footstep", gain = 1.0}
+	table.place = table.place or
+			{name = "default_place_node", gain = 1.0}
+	default.node_sound_defaults(table)
+	return table
+end
+
+function default.node_sound_wood_defaults(table)
+	table = table or {}
+	table.footstep = table.footstep or
+			{name = "default_wood_footstep", gain = 0.3}
+	table.dug = table.dug or
+			{name = "default_wood_footstep", gain = 1.0}
+	default.node_sound_defaults(table)
+	return table
+end
+
+function default.node_sound_leaves_defaults(table)
+	table = table or {}
+	table.footstep = table.footstep or
+			{name = "default_grass_footstep", gain = 0.45}
+	table.dug = table.dug or
+			{name = "default_grass_footstep", gain = 0.7}
+	table.place = table.place or
+			{name = "default_place_node", gain = 1.0}
+	default.node_sound_defaults(table)
+	return table
+end
+
+function default.node_sound_glass_defaults(table)
+	table = table or {}
+	table.footstep = table.footstep or
+			{name = "default_glass_footstep", gain = 0.3}
+	table.dig = table.dig or
+			{name = "default_glass_footstep", gain = 0.5}
+	table.dug = table.dug or
+			{name = "default_break_glass", gain = 1.0}
+	default.node_sound_defaults(table)
+	return table
+end
+
+function default.node_sound_metal_defaults(table)
+	table = table or {}
+	table.footstep = table.footstep or
+			{name = "default_metal_footstep", gain = 0.4}
+	table.dig = table.dig or
+			{name = "default_dig_metal", gain = 0.5}
+	table.dug = table.dug or
+			{name = "default_dug_metal", gain = 0.5}
+	table.place = table.place or
+			{name = "default_place_node_metal", gain = 0.5}
+	default.node_sound_defaults(table)
+	return table
+end
+
+function default.node_sound_water_defaults(table)
+	table = table or {}
+	table.footstep = table.footstep or
+			{name = "default_water_footstep", gain = 0.2}
+	default.node_sound_defaults(table)
+	return table
+end
+
+--
+-- Lavacooling
+--
+
+default.cool_lava = function(pos, node)
+	if node.name == "default:lava_source" then
+		minetest.set_node(pos, {name = "default:obsidian"})
+	else -- Lava flowing
+		minetest.set_node(pos, {name = "default:stone"})
+	end
+	minetest.sound_play("default_cool_lava",
+		{pos = pos, max_hear_distance = 16, gain = 0.25})
+end
+
+if minetest.settings:get_bool("enable_lavacooling") ~= false then
+	minetest.register_abm({
+		label = "Lava cooling",
+		nodenames = {"default:lava_source", "default:lava_flowing"},
+		neighbors = {"group:cools_lava", "group:water"},
+		interval = 1,
+		chance = 2,
+		catch_up = false,
+		action = default.cool_lava,
+	})
+end
+
+--
+-- optimized helper to put all items in an inventory into a drops list
+--
+
+function default.get_inventory_drops(pos, inventory, drops)
+	local inv = minetest.get_meta(pos):get_inventory()
+	local n = #drops
+	for i = 1, inv:get_size(inventory) do
+		local stack = inv:get_stack(inventory, i)
+		if stack:get_count() > 0 then
+			drops[n+1] = stack:to_table()
+			n = n + 1
+		end
+	end
+end
+
+--
+-- Papyrus and cactus growing
+--
+
+-- wrapping the functions in abm action is necessary to make overriding them possible
+
+function default.grow_cactus(pos, node)
+	if node.param2 >= 4 then
+		return
+	end
+	pos.y = pos.y - 1
+	if minetest.get_item_group(minetest.get_node(pos).name, "sand") == 0 then
+		return
+	end
+	pos.y = pos.y + 1
+	local height = 0
+	while node.name == "default:cactus" and height < 4 do
+		height = height + 1
+		pos.y = pos.y + 1
+		node = minetest.get_node(pos)
+	end
+	if height == 4 or node.name ~= "air" then
+		return
+	end
+	if minetest.get_node_light(pos) < 13 then
+		return
+	end
+	minetest.set_node(pos, {name = "default:cactus"})
+	return true
+end
+
+function default.grow_papyrus(pos, node)
+	pos.y = pos.y - 1
+	local name = minetest.get_node(pos).name
+	if name ~= "default:dirt_with_grass" and name ~= "default:dirt" then
+		return
+	end
+	if not minetest.find_node_near(pos, 3, {"group:water"}) then
+		return
+	end
+	pos.y = pos.y + 1
+	local height = 0
+	while node.name == "default:papyrus" and height < 4 do
+		height = height + 1
+		pos.y = pos.y + 1
+		node = minetest.get_node(pos)
+	end
+	if height == 4 or node.name ~= "air" then
+		return
+	end
+	if minetest.get_node_light(pos) < 13 then
+		return
+	end
+	minetest.set_node(pos, {name = "default:papyrus"})
+	return true
+end
+
+minetest.register_abm({
+	label = "Grow cactus",
+	nodenames = {"default:cactus"},
+	neighbors = {"group:sand"},
+	interval = 12,
+	chance = 83,
+	action = default.grow_cactus
+})
+
+minetest.register_abm({
+	label = "Grow papyrus",
+	nodenames = {"default:papyrus"},
+	neighbors = {"default:dirt", "default:dirt_with_grass"},
+	interval = 14,
+	chance = 71,
+	action = default.grow_papyrus
+})
+
+
+--
+-- dig upwards
+--
+
+function default.dig_up(pos, node, digger)
+	if digger == nil then return end
+	local np = {x = pos.x, y = pos.y + 1, z = pos.z}
+	local nn = minetest.get_node(np)
+	if nn.name == node.name then
+		minetest.node_dig(np, nn, digger)
+	end
+end
+
+
+--
+-- Fence registration helper
+--
+
+function default.register_fence(name, def)
+	minetest.register_craft({
+		output = name .. " 4",
+		recipe = {
+			{ def.material, 'group:stick', def.material },
+			{ def.material, 'group:stick', def.material },
+		}
+	})
+
+	local fence_texture = "default_fence_overlay.png^" .. def.texture ..
+			"^default_fence_overlay.png^[makealpha:255,126,126"
+	-- Allow almost everything to be overridden
+	local default_fields = {
+		paramtype = "light",
+		drawtype = "nodebox",
+		node_box = {
+			type = "connected",
+			fixed = {{-1/8, -1/2, -1/8, 1/8, 1/2, 1/8}},
+			-- connect_top =
+			-- connect_bottom =
+			connect_front = {{-1/16,3/16,-1/2,1/16,5/16,-1/8},
+				{-1/16,-5/16,-1/2,1/16,-3/16,-1/8}},
+			connect_left = {{-1/2,3/16,-1/16,-1/8,5/16,1/16},
+				{-1/2,-5/16,-1/16,-1/8,-3/16,1/16}},
+			connect_back = {{-1/16,3/16,1/8,1/16,5/16,1/2},
+				{-1/16,-5/16,1/8,1/16,-3/16,1/2}},
+			connect_right = {{1/8,3/16,-1/16,1/2,5/16,1/16},
+				{1/8,-5/16,-1/16,1/2,-3/16,1/16}},
+		},
+		connects_to = {"group:fence", "group:wood", "group:tree"},
+		inventory_image = fence_texture,
+		wield_image = fence_texture,
+		tiles = {def.texture},
+		sunlight_propagates = true,
+		is_ground_content = false,
+		groups = {},
+	}
+	for k, v in pairs(default_fields) do
+		if not def[k] then
+			def[k] = v
+		end
+	end
+
+	-- Always add to the fence group, even if no group provided
+	def.groups.fence = 1
+
+	def.texture = nil
+	def.material = nil
+
+	minetest.register_node(name, def)
+end
+
+
+--
+-- Leafdecay
+--
+
+-- Prevent decay of placed leaves
+
+default.after_place_leaves = function(pos, placer, itemstack, pointed_thing)
+	if placer and not placer:get_player_control().sneak then
+		local node = minetest.get_node(pos)
+		node.param2 = 1
+		minetest.set_node(pos, node)
+	end
+end
+
+-- Leafdecay
+local function leafdecay_after_destruct(pos, oldnode, def)
+	for _, v in pairs(minetest.find_nodes_in_area(vector.subtract(pos, def.radius),
+			vector.add(pos, def.radius), def.leaves)) do
+		local node = minetest.get_node(v)
+		local timer = minetest.get_node_timer(v)
+		if node.param2 == 0 and not timer:is_started() then
+			timer:start(math.random(20, 120) / 10)
+		end
+	end
+end
+
+local function leafdecay_on_timer(pos, def)
+	if minetest.find_node_near(pos, def.radius, def.trunks) then
+		return false
+	end
+
+	local node = minetest.get_node(pos)
+	local drops = minetest.get_node_drops(node.name)
+	for _, item in ipairs(drops) do
+		local is_leaf
+		for _, v in pairs(def.leaves) do
+			if v == item then
+				is_leaf = true
+			end
+		end
+		if minetest.get_item_group(item, "leafdecay_drop") ~= 0 or
+				not is_leaf then
+			minetest.add_item({
+				x = pos.x - 0.5 + math.random(),
+				y = pos.y - 0.5 + math.random(),
+				z = pos.z - 0.5 + math.random(),
+			}, item)
+		end
+	end
+
+	minetest.remove_node(pos)
+	minetest.check_for_falling(pos)
+end
+
+function default.register_leafdecay(def)
+	assert(def.leaves)
+	assert(def.trunks)
+	assert(def.radius)
+	for _, v in pairs(def.trunks) do
+		minetest.override_item(v, {
+			after_destruct = function(pos, oldnode)
+				leafdecay_after_destruct(pos, oldnode, def)
+			end,
+		})
+	end
+	for _, v in pairs(def.leaves) do
+		minetest.override_item(v, {
+			on_timer = function(pos)
+				leafdecay_on_timer(pos, def)
+			end,
+		})
+	end
+end
+
+--
+-- Convert dirt to something that fits the environment
+--
+
+minetest.register_abm({
+	label = "Grass spread",
+	nodenames = {"default:dirt"},
+	neighbors = {
+		"air",
+		"group:grass",
+		"group:dry_grass",
+		"default:snow",
+	},
+	interval = 6,
+	chance = 50,
+	catch_up = false,
+	action = function(pos, node)
+		-- Check for darkness: night, shadow or under a light-blocking node
+		-- Returns if ignore above
+		local above = {x = pos.x, y = pos.y + 1, z = pos.z}
+		if (minetest.get_node_light(above) or 0) < 13 then
+			return
+		end
+
+		-- Look for spreading dirt-type neighbours
+		local p2 = minetest.find_node_near(pos, 1, "group:spreading_dirt_type")
+		if p2 then
+			local n3 = minetest.get_node(p2)
+			minetest.set_node(pos, {name = n3.name})
+			return
+		end
+
+		-- Else, any seeding nodes on top?
+		local name = minetest.get_node(above).name
+		-- Snow check is cheapest, so comes first
+		if name == "default:snow" then
+			minetest.set_node(pos, {name = "default:dirt_with_snow"})
+		-- Most likely case first
+		elseif minetest.get_item_group(name, "grass") ~= 0 then
+			minetest.set_node(pos, {name = "default:dirt_with_grass"})
+		elseif minetest.get_item_group(name, "dry_grass") ~= 0 then
+			minetest.set_node(pos, {name = "default:dirt_with_dry_grass"})
+		end
+	end
+})
+
+
+--
+-- Grass and dry grass removed in darkness
+--
+
+minetest.register_abm({
+	label = "Grass covered",
+	nodenames = {"group:spreading_dirt_type"},
+	interval = 8,
+	chance = 50,
+	catch_up = false,
+	action = function(pos, node)
+		local above = {x = pos.x, y = pos.y + 1, z = pos.z}
+		local name = minetest.get_node(above).name
+		local nodedef = minetest.registered_nodes[name]
+		if name ~= "ignore" and nodedef and not ((nodedef.sunlight_propagates or
+				nodedef.paramtype == "light") and
+				nodedef.liquidtype == "none") then
+			minetest.set_node(pos, {name = "default:dirt"})
+		end
+	end
+})
+
+
+--
+-- Moss growth on cobble near water
+--
+
+minetest.register_abm({
+	label = "Moss growth",
+	nodenames = {"default:cobble", "stairs:slab_cobble", "stairs:stair_cobble", "walls:cobble"},
+	neighbors = {"group:water"},
+	interval = 16,
+	chance = 200,
+	catch_up = false,
+	action = function(pos, node)
+		if node.name == "default:cobble" then
+			minetest.set_node(pos, {name = "default:mossycobble"})
+		elseif node.name == "stairs:slab_cobble" then
+			minetest.set_node(pos, {name = "stairs:slab_mossycobble", param2 = node.param2})
+		elseif node.name == "stairs:stair_cobble" then
+			minetest.set_node(pos, {name = "stairs:stair_mossycobble", param2 = node.param2})
+		elseif node.name == "walls:cobble" then
+			minetest.set_node(pos, {name = "walls:mossycobble", param2 = node.param2})
+		end
+	end
+})
+
+
+--
+-- Checks if specified volume intersects a protected volume
+--
+
+function default.intersects_protection(minp, maxp, player_name, interval)
+	-- 'interval' is the largest allowed interval for the 3D lattice of checks
+
+	-- Compute the optimal float step 'd' for each axis so that all corners and
+	-- borders are checked. 'd' will be smaller or equal to 'interval'.
+	-- Subtracting 1e-4 ensures that the max co-ordinate will be reached by the
+	-- for loop (which might otherwise not be the case due to rounding errors).
+	local d = {}
+	for _, c in pairs({"x", "y", "z"}) do
+		if maxp[c] > minp[c] then
+			d[c] = (maxp[c] - minp[c]) / math.ceil((maxp[c] - minp[c]) / interval) - 1e-4
+		elseif maxp[c] == minp[c] then
+			d[c] = 1 -- Any value larger than 0 to avoid division by zero
+		else -- maxp[c] < minp[c], print error and treat as protection intersected
+			minetest.log("error", "maxp < minp in 'default.intersects_protection()'")
+			return true
+		end
+	end
+
+	for zf = minp.z, maxp.z, d.z do
+		local z = math.floor(zf + 0.5)
+		for yf = minp.y, maxp.y, d.y do
+			local y = math.floor(yf + 0.5)
+			for xf = minp.x, maxp.x, d.x do
+				local x = math.floor(xf + 0.5)
+				if minetest.is_protected({x = x, y = y, z = z}, player_name) then
+					return true
+				end
+			end
+		end
+	end
+
+	return false
+end
+
+
+--
+-- Coral death near air
+--
+
+minetest.register_abm({
+	nodenames = {"default:coral_brown", "default:coral_orange"},
+	neighbors = {"air"},
+	interval = 17,
+	chance = 5,
+	catch_up = false,
+	action = function(pos, node)
+		minetest.set_node(pos, {name = "default:coral_skeleton"})
+	end,
+})
+
+
+--
+-- NOTICE: This method is not an official part of the API yet!
+-- This method may change in future.
+--
+
+function default.can_interact_with_node(player, pos)
+	if player then
+		if minetest.check_player_privs(player, "protection_bypass") then
+			return true
+		end
+	else
+		return false
+	end
+
+	local meta = minetest.get_meta(pos)
+	local owner = meta:get_string("owner")
+
+	if not owner or owner == "" or owner == player:get_player_name() then
+		return true
+	end
+
+	-- is player wielding the right key?
+	local item = player:get_wielded_item()
+	if item:get_name() == "default:key" then
+		local key_meta = item:get_meta()
+
+		if key_meta:get_string("secret") == "" then
+			local key_oldmeta = item:get_metadata()
+			if key_oldmeta == "" or not minetest.parse_json(key_oldmeta) then
+				return false
+			end
+
+			key_meta:set_string("secret", minetest.parse_json(key_oldmeta).secret)
+			item:set_metadata("")
+		end
+
+		return meta:get_string("key_lock_secret") == key_meta:get_string("secret")
+	end
+
+	return false
+end

mods/default/furnace.lua

@@ -0,0 +1,330 @@
+
+--
+-- Formspecs
+--
+
+local function active_formspec(fuel_percent, item_percent)
+	local formspec =
+		"size[8,8.5]"..
+		default.gui_bg..
+		default.gui_bg_img..
+		default.gui_slots..
+		"list[current_name;src;2.75,0.5;1,1;]"..
+		"list[current_name;fuel;2.75,2.5;1,1;]"..
+		"image[2.75,1.5;1,1;default_furnace_fire_bg.png^[lowpart:"..
+		(100-fuel_percent)..":default_furnace_fire_fg.png]"..
+		"image[3.75,1.5;1,1;gui_furnace_arrow_bg.png^[lowpart:"..
+		(item_percent)..":gui_furnace_arrow_fg.png^[transformR270]"..
+		"list[current_name;dst;4.75,0.96;2,2;]"..
+		"list[current_player;main;0,4.25;8,1;]"..
+		"list[current_player;main;0,5.5;8,3;8]"..
+		"listring[current_name;dst]"..
+		"listring[current_player;main]"..
+		"listring[current_name;src]"..
+		"listring[current_player;main]"..
+		"listring[current_name;fuel]"..
+		"listring[current_player;main]"..
+		default.get_hotbar_bg(0, 4.25)
+	return formspec
+end
+
+local inactive_formspec =
+	"size[8,8.5]"..
+	default.gui_bg..
+	default.gui_bg_img..
+	default.gui_slots..
+	"list[current_name;src;2.75,0.5;1,1;]"..
+	"list[current_name;fuel;2.75,2.5;1,1;]"..
+	"image[2.75,1.5;1,1;default_furnace_fire_bg.png]"..
+	"image[3.75,1.5;1,1;gui_furnace_arrow_bg.png^[transformR270]"..
+	"list[current_name;dst;4.75,0.96;2,2;]"..
+	"list[current_player;main;0,4.25;8,1;]"..
+	"list[current_player;main;0,5.5;8,3;8]"..
+	"listring[current_name;dst]"..
+	"listring[current_player;main]"..
+	"listring[current_name;src]"..
+	"listring[current_player;main]"..
+	"listring[current_name;fuel]"..
+	"listring[current_player;main]"..
+	default.get_hotbar_bg(0, 4.25)
+
+--
+-- Node callback functions that are the same for active and inactive furnace
+--
+
+local function can_dig(pos, player)
+	local meta = minetest.get_meta(pos);
+	local inv = meta:get_inventory()
+	return inv:is_empty("fuel") and inv:is_empty("dst") and inv:is_empty("src")
+end
+
+local function allow_metadata_inventory_put(pos, listname, index, stack, player)
+	if minetest.is_protected(pos, player:get_player_name()) then
+		return 0
+	end
+	local meta = minetest.get_meta(pos)
+	local inv = meta:get_inventory()
+	if listname == "fuel" then
+		if minetest.get_craft_result({method="fuel", width=1, items={stack}}).time ~= 0 then
+			if inv:is_empty("src") then
+				meta:set_string("infotext", "Furnace is empty")
+			end
+			return stack:get_count()
+		else
+			return 0
+		end
+	elseif listname == "src" then
+		return stack:get_count()
+	elseif listname == "dst" then
+		return 0
+	end
+end
+
+local function allow_metadata_inventory_move(pos, from_list, from_index, to_list, to_index, count, player)
+	local meta = minetest.get_meta(pos)
+	local inv = meta:get_inventory()
+	local stack = inv:get_stack(from_list, from_index)
+	return allow_metadata_inventory_put(pos, to_list, to_index, stack, player)
+end
+
+local function allow_metadata_inventory_take(pos, listname, index, stack, player)
+	if minetest.is_protected(pos, player:get_player_name()) then
+		return 0
+	end
+	return stack:get_count()
+end
+
+local function swap_node(pos, name)
+	local node = minetest.get_node(pos)
+	if node.name == name then
+		return
+	end
+	node.name = name
+	minetest.swap_node(pos, node)
+end
+
+local function furnace_node_timer(pos, elapsed)
+	--
+	-- Inizialize metadata
+	--
+	local meta = minetest.get_meta(pos)
+	local fuel_time = meta:get_float("fuel_time") or 0
+	local src_time = meta:get_float("src_time") or 0
+	local fuel_totaltime = meta:get_float("fuel_totaltime") or 0
+
+	local inv = meta:get_inventory()
+	local srclist, fuellist
+
+	local cookable, cooked
+	local fuel
+
+	local update = true
+	while update do
+		update = false
+
+		srclist = inv:get_list("src")
+		fuellist = inv:get_list("fuel")
+
+		--
+		-- Cooking
+		--
+
+		-- Check if we have cookable content
+		local aftercooked
+		cooked, aftercooked = minetest.get_craft_result({method = "cooking", width = 1, items = srclist})
+		cookable = cooked.time ~= 0
+
+		-- Check if we have enough fuel to burn
+		if fuel_time < fuel_totaltime then
+			-- The furnace is currently active and has enough fuel
+			fuel_time = fuel_time + elapsed
+			-- If there is a cookable item then check if it is ready yet
+			if cookable then
+				src_time = src_time + elapsed
+				if src_time >= cooked.time then
+					-- Place result in dst list if possible
+					if inv:room_for_item("dst", cooked.item) then
+						inv:add_item("dst", cooked.item)
+						inv:set_stack("src", 1, aftercooked.items[1])
+						src_time = src_time - cooked.time
+						update = true
+					end
+				end
+			end
+		else
+			-- Furnace ran out of fuel
+			if cookable then
+				-- We need to get new fuel
+				local afterfuel
+				fuel, afterfuel = minetest.get_craft_result({method = "fuel", width = 1, items = fuellist})
+
+				if fuel.time == 0 then
+					-- No valid fuel in fuel list
+					fuel_totaltime = 0
+					src_time = 0
+				else
+					-- Take fuel from fuel list
+					inv:set_stack("fuel", 1, afterfuel.items[1])
+					update = true
+					fuel_totaltime = fuel.time + (fuel_time - fuel_totaltime)
+					src_time = src_time + elapsed
+				end
+			else
+				-- We don't need to get new fuel since there is no cookable item
+				fuel_totaltime = 0
+				src_time = 0
+			end
+			fuel_time = 0
+		end
+
+		elapsed = 0
+	end
+
+	if fuel and fuel_totaltime > fuel.time then
+		fuel_totaltime = fuel.time
+	end
+	if srclist[1]:is_empty() then
+		src_time = 0
+	end
+
+	--
+	-- Update formspec, infotext and node
+	--
+	local formspec = inactive_formspec
+	local item_state
+	local item_percent = 0
+	if cookable then
+		item_percent = math.floor(src_time / cooked.time * 100)
+		if item_percent > 100 then
+			item_state = "100% (output full)"
+		else
+			item_state = item_percent .. "%"
+		end
+	else
+		if srclist[1]:is_empty() then
+			item_state = "Empty"
+		else
+			item_state = "Not cookable"
+		end
+	end
+
+	local fuel_state = "Empty"
+	local active = "inactive "
+	local result = false
+
+	if fuel_totaltime ~= 0 then
+		active = "active "
+		local fuel_percent = math.floor(fuel_time / fuel_totaltime * 100)
+		fuel_state = fuel_percent .. "%"
+		formspec = active_formspec(fuel_percent, item_percent)
+		swap_node(pos, "default:furnace_active")
+		-- make sure timer restarts automatically
+		result = true
+	else
+		if not fuellist[1]:is_empty() then
+			fuel_state = "0%"
+		end
+		swap_node(pos, "default:furnace")
+		-- stop timer on the inactive furnace
+		minetest.get_node_timer(pos):stop()
+	end
+
+	local infotext = "Furnace " .. active .. "(Item: " .. item_state .. "; Fuel: " .. fuel_state .. ")"
+
+	--
+	-- Set meta values
+	--
+	meta:set_float("fuel_totaltime", fuel_totaltime)
+	meta:set_float("fuel_time", fuel_time)
+	meta:set_float("src_time", src_time)
+	meta:set_string("formspec", formspec)
+	meta:set_string("infotext", infotext)
+
+	return result
+end
+
+--
+-- Node definitions
+--
+
+minetest.register_node("default:furnace", {
+	description = "Furnace",
+	tiles = {
+		"default_furnace_top.png", "default_furnace_bottom.png",
+		"default_furnace_side.png", "default_furnace_side.png",
+		"default_furnace_side.png", "default_furnace_front.png"
+	},
+	paramtype2 = "facedir",
+	groups = {cracky=2},
+	legacy_facedir_simple = true,
+	is_ground_content = false,
+	sounds = default.node_sound_stone_defaults(),
+
+	can_dig = can_dig,
+
+	on_timer = furnace_node_timer,
+
+	on_construct = function(pos)
+		local meta = minetest.get_meta(pos)
+		meta:set_string("formspec", inactive_formspec)
+		local inv = meta:get_inventory()
+		inv:set_size('src', 1)
+		inv:set_size('fuel', 1)
+		inv:set_size('dst', 4)
+	end,
+
+	on_metadata_inventory_move = function(pos)
+		minetest.get_node_timer(pos):start(1.0)
+	end,
+	on_metadata_inventory_put = function(pos)
+		-- start timer function, it will sort out whether furnace can burn or not.
+		minetest.get_node_timer(pos):start(1.0)
+	end,
+	on_blast = function(pos)
+		local drops = {}
+		default.get_inventory_drops(pos, "src", drops)
+		default.get_inventory_drops(pos, "fuel", drops)
+		default.get_inventory_drops(pos, "dst", drops)
+		drops[#drops+1] = "default:furnace"
+		minetest.remove_node(pos)
+		return drops
+	end,
+
+	allow_metadata_inventory_put = allow_metadata_inventory_put,
+	allow_metadata_inventory_move = allow_metadata_inventory_move,
+	allow_metadata_inventory_take = allow_metadata_inventory_take,
+})
+
+minetest.register_node("default:furnace_active", {
+	description = "Furnace",
+	tiles = {
+		"default_furnace_top.png", "default_furnace_bottom.png",
+		"default_furnace_side.png", "default_furnace_side.png",
+		"default_furnace_side.png",
+		{
+			image = "default_furnace_front_active.png",
+			backface_culling = false,
+			animation = {
+				type = "vertical_frames",
+				aspect_w = 16,
+				aspect_h = 16,
+				length = 1.5
+			},
+		}
+	},
+	paramtype2 = "facedir",
+	light_source = 8,
+	drop = "default:furnace",
+	groups = {cracky=2, not_in_creative_inventory=1},
+	legacy_facedir_simple = true,
+	is_ground_content = false,
+	sounds = default.node_sound_stone_defaults(),
+	on_timer = furnace_node_timer,
+
+	can_dig = can_dig,
+
+	allow_metadata_inventory_put = allow_metadata_inventory_put,
+	allow_metadata_inventory_move = allow_metadata_inventory_move,
+	allow_metadata_inventory_take = allow_metadata_inventory_take,
+})
+

mods/default/item_entity.lua

@@ -0,0 +1,74 @@
+-- mods/default/item_entity.lua
+
+local builtin_item = minetest.registered_entities["__builtin:item"]
+
+local item = {
+	set_item = function(self, itemstring)
+		builtin_item.set_item(self, itemstring)
+
+		local stack = ItemStack(itemstring)
+		local itemdef = minetest.registered_items[stack:get_name()]
+		if itemdef and itemdef.groups.flammable ~= 0 then
+			self.flammable = itemdef.groups.flammable
+		end
+	end,
+
+	burn_up = function(self)
+		-- disappear in a smoke puff
+		self.object:remove()
+		local p = self.object:getpos()
+		minetest.sound_play("default_item_smoke", {
+			pos = p,
+			max_hear_distance = 8,
+		})
+		minetest.add_particlespawner({
+			amount = 3,
+			time = 0.1,
+			minpos = {x = p.x - 0.1, y = p.y + 0.1, z = p.z - 0.1 },
+			maxpos = {x = p.x + 0.1, y = p.y + 0.2, z = p.z + 0.1 },
+			minvel = {x = 0, y = 2.5, z = 0},
+			maxvel = {x = 0, y = 2.5, z = 0},
+			minacc = {x = -0.15, y = -0.02, z = -0.15},
+			maxacc = {x = 0.15, y = -0.01, z = 0.15},
+			minexptime = 4,
+			maxexptime = 6,
+			minsize = 5,
+			maxsize = 5,
+			collisiondetection = true,
+			texture = "default_item_smoke.png"
+		})
+	end,
+
+	on_step = function(self, dtime)
+		builtin_item.on_step(self, dtime)
+
+		if self.flammable then
+			-- flammable, check for igniters
+			self.ignite_timer = (self.ignite_timer or 0) + dtime
+			if self.ignite_timer > 10 then
+				self.ignite_timer = 0
+
+				local node = minetest.get_node_or_nil(self.object:getpos())
+				if not node then
+					return
+				end
+
+				-- Immediately burn up flammable items in lava
+				if minetest.get_item_group(node.name, "lava") > 0 then
+					self:burn_up()
+				else
+					--  otherwise there'll be a chance based on its igniter value
+					local burn_chance = self.flammable
+						* minetest.get_item_group(node.name, "igniter")
+					if burn_chance > 0 and math.random(0, burn_chance) ~= 0 then
+						self:burn_up()
+					end
+				end
+			end
+		end
+	end,
+}
+
+-- set defined item as new __builtin:item, with the old one as fallback table
+setmetatable(item, builtin_item)
+minetest.register_entity(":__builtin:item", item)

mods/default/leafdecay.lua

@@ -1,93 +0,0 @@
--- minetest/default/leafdecay.lua
-
--- To enable leaf decay for a node, add it to the "leafdecay" group.
---
--- The rating of the group determines how far from a node in the group "tree"
--- the node can be without decaying.
---
--- If param2 of the node is ~= 0, the node will always be preserved. Thus, if
--- the player places a node of that kind, you will want to set param2=1 or so.
-
-default.leafdecay_trunk_cache = {}
-default.leafdecay_enable_cache = true
--- Spread the load of finding trunks
-default.leafdecay_trunk_find_allow_accumulator = 0
-
-minetest.register_globalstep(function(dtime)
-	local finds_per_second = 5000
-	default.leafdecay_trunk_find_allow_accumulator =
-			math.floor(dtime * finds_per_second)
-end)
-
-minetest.register_abm({
-	nodenames = {"group:leafdecay"},
-	neighbors = {"air", "group:liquid"},
-	-- A low interval and a high inverse chance spreads the load
-	interval = 2,
-	chance = 5,
-
-	action = function(p0, node, _, _)
-		--print("leafdecay ABM at "..p0.x..", "..p0.y..", "..p0.z..")")
-		local do_preserve = false
-		local d = minetest.registered_nodes[node.name].groups.leafdecay
-		if not d or d == 0 then
-			--print("not groups.leafdecay")
-			return
-		end
-		local n0 = minetest.env:get_node(p0)
-		if n0.param2 ~= 0 then
-			--print("param2 ~= 0")
-			return
-		end
-		local p0_hash = nil
-		if default.leafdecay_enable_cache then
-			p0_hash = minetest.hash_node_position(p0)
-			local trunkp = default.leafdecay_trunk_cache[p0_hash]
-			if trunkp then
-				local n = minetest.env:get_node(trunkp)
-				local reg = minetest.registered_nodes[n.name]
-				-- Assume ignore is a trunk, to make the thing work at the border of the active area
-				if n.name == "ignore" or (reg and reg.groups.tree and reg.groups.tree ~= 0) then
-					--print("cached trunk still exists")
-					return
-				end
-				--print("cached trunk is invalid")
-				-- Cache is invalid
-				table.remove(default.leafdecay_trunk_cache, p0_hash)
-			end
-		end
-		if default.leafdecay_trunk_find_allow_accumulator <= 0 then
-			return
-		end
-		default.leafdecay_trunk_find_allow_accumulator =
-				default.leafdecay_trunk_find_allow_accumulator - 1
-		-- Assume ignore is a trunk, to make the thing work at the border of the active area
-		local p1 = minetest.env:find_node_near(p0, d, {"ignore", "group:tree"})
-		if p1 then
-			do_preserve = true
-			if default.leafdecay_enable_cache then
-				--print("caching trunk")
-				-- Cache the trunk
-				default.leafdecay_trunk_cache[p0_hash] = p1
-			end
-		end
-		if not do_preserve then
-			-- Drop stuff other than the node itself
-			itemstacks = minetest.get_node_drops(n0.name)
-			for _, itemname in ipairs(itemstacks) do
-				if itemname ~= n0.name then
-					local p_drop = {
-						x = p0.x - 0.5 + math.random(),
-						y = p0.y - 0.5 + math.random(),
-						z = p0.z - 0.5 + math.random(),
-					}
-					minetest.env:add_item(p_drop, itemname)
-				end
-			end
-			-- Remove node
-			minetest.env:remove_node(p0)
-			nodeupdate(p0)
-		end
-	end
-})
-