Git Update

API.md

@@ -17,6 +17,10 @@ Items can have these fields:
    anvil.
    See `mcl_banners` for an example.
 
+Tools can have these fields:
+* `_mcl_diggroups`: Specifies the digging groups that a tool can dig and how
+  efficiently.  See `_mcl_autogroup` for more information.
+
 All nodes can have these fields:
 
 * `_mcl_hardness`: Hardness of the block, ranges from 0 to infinity (represented by -1). Determines digging times. Default: 0
@@ -39,7 +43,7 @@ A lot of things are possible by using one of the APIs in the mods. Note that not
 * Dispenser support: `ITEMS/REDSTONE/mcl_dispensers`
 
 ## Mobs
-* Mobs: `ENTITIES/mcl_mods`
+* Mobs: `ENTITIES/mcl_mobs`
 
 MineClone 2 uses its own mobs framework, called “Mobs Redo: MineClone 2 Edition” or “MRM” for short.
 This is a fork of Mobs Redo [`mobs`] by TenPlus1.
@@ -67,6 +71,9 @@ chances are good that it works out of the box.
 * Get flowing direction of liquids: `CORE/flowlib`
 * `on_walk_over` callback for nodes: `CORE/walkover` 
 * Get node names close to player (to reduce constant querying): `PLAYER/mcl_playerinfo`
+* Explosion API
+* Music discs API
+* Flowers and flower pots
 
 ### Unstable APIs
 The following APIs may be subject to change in future. You could already use these APIs but there will probably be breaking changes in the future, or the API is not as fleshed out as it should be. Use at your own risk!
@@ -79,12 +86,10 @@ The following APIs may be subject to change in future. You could already use the
 
 ### Planned APIs
 
-* Flowers
 * Saplings and trees
 * Custom banner patterns
 * Custom dimensions
 * Custom portals
-* Music discs
 * Dispenser and dropper support
 * Proper sky and weather APIs
-* Explosion API
+

CONTRIBUTING.md

@@ -1,5 +1,5 @@
 # Contributing to MineClone 2
-So you want to MineClone 2?
+So you want to contribute to MineClone 2?
 Wow, thank you! :-)
 
 But first, some things to note:
@@ -7,13 +7,11 @@ But first, some things to note:
 MineClone 2's development target is to make a free software clone of Minecraft,
 ***version 1.12***, ***PC edition***, *** + Optifine features supported by the Minetest Engine ***.
 
-MineClone 2 is maintained by two persons. Namely, kay27 and EliasFleckenstein. You can find us
+MineClone 2 is maintained by three persons. Namely, kay27, EliasFleckenstein and jordan4ibanez. You can find us
-in the Minetest forums (forums.minetest.net), in IRC in the #minetest
+in the Minetest forums (forums.minetest.net), in IRC in the #mineclone2
 channel on irc.freenode.net. And finally, you can send e-mails to
 <eliasfleckenstein@web.de> or <kay27@bk.ru>.
 
-There is **no** guarantee we will accept anything from anybody.
-
 By sending us patches or asking us to include your changes in this game,
 you agree that they fall under the terms of the LGPLv2.1, which basically
 means they will become part of a free software.
@@ -26,8 +24,7 @@ For small and medium changes:
 
 * Fork the repository
 * Do your change in a new branch
-* Upload the repository somewhere where it can be accessed from the Internet and
+* Create a pull request to get your changes merged into master
-  notify us
 
 For small changes, sending us a patch is also good.
 
@@ -41,40 +38,52 @@ reserve the right to revert everything that we don't like.
 For bigger changes, we strongly recommend to use feature branches and
 discuss with me first.
 
-Contributors will be credited in `README.md`.
+If your code causes bugs and crashes, it is your responsibility to fix them as soon as possible.
 
-## Quality remarks
+We mostly use plain merging rather than rebasing or squash merging.
-Again: There is ***no*** guarantee we will accept anything from anybody.
-But we will gladly take in code from others when we feel it saves us work
-in the long run.
 
-### Inclusion criteria
+Your commit names should be relatively descriptive, e.g. when saying "Fix #issueid", the commit message should also contain the title of the issue.
-Depending on what you add, the chances for inclusion vary:
 
-### High chance for inclusion
+Contributors will be credited in `CREDITS.md`.
-* Gameplay features in Minecraft which are missing in MineClone 2
 
-### Medium chance for inclusion (discuss first)
+## Code Style
-* Features which don't a impact on gameplay
-* GUI improvement
-* Features from pocket or console edition
 
-### Low chance for inclusion (discuss/optimize first)
+Each mod must provide `mod.conf`.
-* Overhaul of architecture / mod structure
+Each mod which add API functions should store functions inside a global table named like the mod.
-* Mass-itemstring changes all over the place
+Public functions should not use self references but rather just access the table directly.
-* Added files have a unusual high file size
+Functions should be defined in this way:
-* Indentation looks like crazy
+```lua
-* Single commits which add several unrelated things
+function mcl_xyz.stuff(param) end
-* Gameplay features which don't exist in Minecraft
+```
+Insteed of this way:
+```lua
+mcl_xyz.stuff = function(param) end
+```
+Indentation must be unified, more likely with tabs.
 
-### Instant rejection
+Time sensitive mods should make a local copy of most used API functions to improve performances.
-* Proprietary **anything**
+```lua
-* Code contains `minetest.env` anywhere
+local vector = vector
+local get_node = minetest.get_node
+```
 
-## Coding style guide
+
-* Indentations should reflect the code flow
+## Features > 1.12
-* Use tabs, not spaces for indentation (tab size = 8)
+
-* Never use `minetest.env`
+If you want to make a feature that was added in a Minecraft version later than 1.12, you should fork MineClone5 (mineclone5 branch in the repository) and add your changes to this.
+
+## What we accept
+
+* Every MC features up to version 1.12 JE.
+* Every already finished and working good features from versions above (only when making a MineClone5 PR / Contribution).
+* Except features which couldn't be done easily and bugfree because of Minetest engine limitations. Eg. we CAN extend world boundaries by playing with map chunks, just teleporting player onto next layer after 31000 , but it would cost too much (time, code, bugs, performance, stability, etc).
+* Some features, approved by the rest of the community, I mean maybe some voting and really missing any negative feedback.
+
+## What we reject
+
+* Any features which cause critical bugs, sending them to rework/fix or trying to fix immediately.
+* Some small portions of big entirely missing features which just definitely break gamplay balance give nothing useful
+* Controversial features, which some people support while others do not should be discussed well, with publishing forum announcements, at least during the week. In case if there are still doubts - send them into the mod.
 
 ## Reporting bugs
 Report all bugs and missing Minecraft features here:

CREDITS.md

@@ -0,0 +1,118 @@
+# Credits
+
+## Creator of MineClone
+* davedevils
+
+## Creator of MineClone2
+* Wuzzy
+
+## Maintainers
+* Fleckenstein
+* kay27
+* jordan4ibanez
+
+## Developers
+* bzoss
+* AFCMS
+* epCode
+* ryvnf
+* iliekprogrammar
+* MysticTempest
+* Rootyjr
+* Nicu
+* aligator
+* Code-Sploit
+* NO11
+
+## Contributors
+* Laurent Rocher
+* HimbeerserverDE
+* TechDudie
+* Alexander Minges
+* ArTee3
+* ZeDique la Ruleta
+* pitchum
+* wuniversales
+* Bu-Gee
+* David McMackins II
+* Nicholas Niro
+* Wouters Dorian
+* Blue Blancmange
+* Jared Moody
+* Li0n
+* Midgard
+* Saku Laesvuori
+* Yukitty
+* ZedekThePD
+* aldum
+* dBeans
+* nickolas360
+* yutyo
+* ztianyang
+* j45
+
+## MineClone5
+* kay27
+* Debiankaios
+* epCode
+* NO11
+* j45
+
+## Original Mod Authors
+* Wuzzy
+* Fleckenstein
+* BlockMen
+* TenPlus1
+* PilzAdam
+* ryvnf
+* stujones11
+* Arcelmi
+* celeron55
+* maikerumine
+* GunshipPenguin
+* Qwertymine3
+* Rochambeau
+* rubenwardy
+* stu
+* jordan4ibanez
+* 4aiman
+* Kahrl
+* Krock
+* UgnilJoZ
+* lordfingle
+* 22i
+* bzoss
+* kilbith
+* xeranas
+* kddekadenz
+* sofar
+* 4Evergreen4
+* jordan4ibanez
+* paramat
+
+## 3D Models
+* 22i
+* tobyplowy
+* epCode
+
+## Textures
+* XSSheep
+* Wuzzy
+* kingoscargames
+* leorockway
+* xMrVizzy
+* yutyo
+* NO11
+
+## Translations
+* Wuzzy
+* Rocher Laurent
+* wuniversales
+* kay27
+* pitchum
+
+## Special thanks
+* celeron55 for creating Minetest
+* Jordach for the jukebox music compilation from Big Freaking Dig
+* The workaholics who spent way too much time writing for the Minecraft Wiki. It's an invaluable resource for creating this game
+* Notch and Jeb for being the major forces behind Minecraft

GROUPS.md

@@ -21,7 +21,7 @@ The basic digging time groups determine by which tools a node can be dug.
 * `swordy=1`: Diggable by sword (any material), and this node is *not* a cobweb
 * `swordy_cobweb=1`: Diggable by sword (any material), and this node is a cobweb
 * `shearsy=1`: Diggable by shears, and this node is *not* wool
-* `shearsy=wool=1`: Diggable by shears, and this node is wool
+* `shearsy_wool=1`: Diggable by shears, and this node is wool
 * `handy=1`: Breakable by hand and this node gives it useful drop when dug by hand. All nodes which are breakable by pickaxe, axe, shovel, sword or shears are also automatically breakable by hand, but not neccess
 * `creative_breakable=1`: Block is breakable by hand in creative mode. This group is implied if the node belongs to any other digging group
 
@@ -149,7 +149,7 @@ These groups are used mostly for informational purposes
 * `trapdoor=2`: Open trapdoor
 * `glass=1`: Glass (full cubes only)
 * `rail=1`: Rail
-* `music_record`: Music Disc (rating is track ID)
+* `music_record`: Item is Music Disc
 * `tnt=1`: Block is TNT
 * `boat=1`: Boat
 * `minecart=1`: Minecart

LEGAL.md

@@ -0,0 +1,52 @@
+# Legal information
+This is a fan game, not developed or endorsed by Mojang AB.
+
+Copying is an act of love. Please copy and share! <3
+Here's the detailed legalese for those who need it:
+
+## License of source code
+MineClone 2 (by kay27, EliasFleckenstein, Wuzzy, davedevils and countless others)
+is an imitation of Minecraft.
+
+MineClone 2 is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License (in the LICENSE.txt file) for more
+details.
+
+In the mods you might find in the read-me or license
+text files a different license. This counts as dual-licensing.
+You can choose which license applies to you: Either the
+license of MineClone 2 (GNU GPLv3) or the mod's license.
+
+MineClone 2 is a direct continuation of the discontinued MineClone
+project by davedevils.
+
+Mod credits:
+See `README.txt` or `README.md` in each mod directory for information about other authors.
+For mods that do not have such a file, the license is the source code license
+of MineClone 2 and the author is Wuzzy.
+
+## License of media (textures and sounds)
+No non-free licenses are used anywhere.
+
+The textures, unless otherwise noted, are based on the Pixel Perfection resource pack for Minecraft 1.11,
+authored by XSSheep. Most textures are verbatim copies, while some textures have been changed or redone
+from scratch.
+The glazed terracotta textures have been created by (MysticTempest)[https://github.com/MysticTempest].
+Source: <https://www.planetminecraft.com/texture_pack/131pixel-perfection/>
+License: [CC BY-SA 4.0](http://creativecommons.org/licenses/by-sa/4.0/)
+
+The main menu images are release under: [CC0](https://creativecommons.org/publicdomain/zero/1.0/)
+
+All other files, unless mentioned otherwise, fall under:
+Creative Commons Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
+http://creativecommons.org/licenses/by-sa/3.0/
+
+See README.txt in each mod directory for detailed information about other authors.
+

MISSING_ENGINE_FEATURES.md

@@ -1,40 +0,0 @@
-# Missing features in Minetest to recreate Minecraft features
-
-A side goal of the MineClone 2 project is to find any shortcomings of Minetest which make it impossible to recreate a Minecraft feature exactly.
-This file lists some of the missing features in Minetest which MineClone 2 would require.
-
-## No workaround possible
-For these features, no easy Lua workaround could be found.
-
-### Lua API
-#### Tools/wielded item
-- “Lock” hotbar for a brief time after using an item, making it impossible to switch item or to attach/mine/build until the delay is over (For eating with delay)
-- Tool charging: Holding down the mouse and releasing it, applying a “power level” (For bow and arrows, more charge = higher arrow range) ([issue 5212](https://github.com/minetest/minetest/issues/5212))
-- [Dual Wielding](http://minecraft.gamepedia.com/Dual_wield)
-- Eating/drinking animation ([issue 2811](https://github.com/minetest/minetest/issues/2811))
-
-#### Nodes
-- Light level 15 for nodes (not sunlight)
-- Nodes makes light level drop by 2 or or more per node ([issue 5209](https://github.com/minetest/minetest/issues/5209))
-
-## Interface
-- Inventory: Hold down right mouse button while holding an item stack to drop items into the slots as you move the mouse. Makes crafting MUCH faster
-- Sneak+Leftclick on crafting output crafts as many items as possible and immediately puts it into the player inventory ([issue 5211](https://github.com/minetest/minetest/issues/5211))
-- Sneak+click puts items in different inventories depending on the item type (maybe group-based)? Required for sneak-clicking to armor slots
-
-## Workaround theoretically possible
-For these features, a workaround (or hack ;-)) by using Lua is theoretically possible. But engine support would be clearly better, more performant, more reliable, etc.
-
-### Lua API
-#### Nodes
-- Change walking speed on block (soul sand)
-- Change jumping height on block (soul sand), 
-- Change object movement speed *through* a block, but for non-liquids (for cobweb)
-- Add `on_walk_over` event
-- Set frequency in which players lose breath. 2 seconds are hardcoded in Minetest, in Minecraft it's 1 second
-- Set damage frequency of `damage_per_second`. In Minecraft many things damage players every half-second rather than every second
-- Possible to damage players directly when they are with the head inside. This allows to add Minecraft-like suffocation
-- Sneak+click on inventory slot should be able to put items into additional “fallback inventories” if the first inventory is full. Useful for large chests
-
-#### Nice-to-haye
-- Utility function to rotate pillar-like nodes, requiring only 3 possible orientations (X, Y, Z). Basically this is `minetest.rotate_node` but with less orientations; the purpur pillar would mess up if a mirrored rotation would be possible. This is already implemented in MCL2, See `mcl_util` for more infos

README.md

@@ -2,7 +2,7 @@
 An unofficial Minecraft-like game for Minetest. Forked from MineClone by davedevils.
 Developed by many people. Not developed or endorsed by Mojang AB.
 
-Version: 0.70.0
+Version: 0.72.0 (in development)
 
 ### Gameplay
 You start in a randomly-generated world made entirely of cubes. You can explore
@@ -65,16 +65,8 @@ map builders. They can not be obtained in-game or in the creative inventory.
 Use the `/giveme` chat command to obtain them. See the in-game help for
 an explanation.
 
-#### Incomplete items
-These items do not work yet, but you can get them with `/giveme` for testing:
-
-* Minecart with Chest: `mcl_minecarts:chest_minecart`
-* Minecart with Furnace: `mcl_minecarts:furnace_minecart`
-* Minecart with Hopper: `mcl_minecarts:hopper_minecart`
-* Minecart with Command Block: `mcl_minecarts:command_block_minecart`
-
 ## Installation
-This game requires [Minetest](http://minetest.net) to run (version 5.0.0 or
+This game requires [Minetest](http://minetest.net) to run (version 5.3.0 or
 later). So you need to install Minetest first. Only stable versions of Minetest
 are officially supported.
 There is no support for running MineClone 2 in development versions of Minetest.
@@ -83,23 +75,38 @@ To install MineClone 2 (if you haven't already), move this directory into the
 “games” directory of your Minetest data directory. Consult the help of
 Minetest to learn more.
 
+## Useful links
+The MineClone2 repository is hosted at Mesehub. To contribute or report issues, head there.
+
+* Mesehub: <https://git.minetest.land/MineClone2/MineClone2>
+* Discord: <https://discord.gg/xE4z8EEpDC>
+* YouTube <https://www.youtube.com/channel/UClI_YcsXMF3KNeJtoBfnk9A>
+* IRC: <https://web.libera.chat/#mineclone2>
+* Matrix: <https://app.element.io/#/room/#mc2:matrix.org>
+* Reddit: <https://www.reddit.com/r/MineClone2/>
+* Minetest forums: <https://forum.minetest.net/viewtopic.php?f=50&t=16407>
+
 ## Project description
 The main goal of **MineClone 2** is to be a clone of Minecraft and to be released as free software.
 
 * **Target of development: Minecraft, PC Edition, version 1.12** (later known as “Java Edition”)
 * MineClone2 also includes Optifine features supported by the Minetest
-* Features of later Minecraft versions might sneak in, but they have a low priority
+* In general, Minecraft is aimed to be cloned as good as possible
-* In general, Minecraft is aimed to be cloned as good as Minetest currently permits (no hacks)
 * Cloning the gameplay has highest priority
-* MineClone 2 will use different graphics and sounds, but with a similar style
+* MineClone 2 will use different assets, but with a similar style
-* Cloning the interface has no priority. It will only be roughly imitated
+* Limitations found in Minetest will be documented in the course of development
-* Limitations found in Minetest will be written down and reported in the course of development
+* Features of later Minecraft versions are collected in the mineclone5 branch
+
+## Using features from newer versions of Minecraft
+For > 1.12 features, checkout MineClone5. It includes features from newer Minecraft versions.
+Download it here: https://git.minetest.land/MineClone2/MineClone2/src/branch/mineclone5
 
 ## Completion status
-This game is currently in **alpha** stage.
+This game is currently in **beta** stage.
-It is playable, but unfinished, many bugs are to be expected.
+It is playable, but not yet feature-complete.
-Backwards-compability is *not* guaranteed, updating your world might cause small and
+Backwards-compability is not entirely guaranteed, updating your world might cause small bugs.
-big bugs (such as “missing node” errors or even crashes).
+If you want to use the git version of MineClone2 in production, consider using the production branch.
+It is updated weekly and contains relatively stable code for servers.
 
 The following main features are available:
 
@@ -128,7 +135,7 @@ The following main features are available:
 * Clock
 * Compass
 * Sponge
-* Slime block (does not interact with redstone)
+* Slime block
 * Small plants and saplings
 * Dyes
 * Banners
@@ -140,19 +147,19 @@ The following main features are available:
 * Creative inventory
 * Farming
 * Writable books
-* A few server commands
+* Commands
+* Villages
+* The End
 * And more!
 
 The following features are incomplete:
 
-* Generated structures (especially villages)
 * Some monsters and animals
 * Redstone-related things
-* The End
 * Special minecarts
 * A couple of non-trivial blocks and items
 
-Bonus features (not found in Minecraft 1.11):
+Bonus features (not found in Minecraft 1.12):
 
 * Built-in crafting guide which shows you crafting and smelting recipes
 * In-game help system containing extensive help about gameplay basics, blocks, items and more
@@ -177,142 +184,14 @@ Technical differences from Minecraft:
 * Different textures (Pixel Perfection)
 * Different sounds (various sources)
 * Different engine (Minetest)
+* Different easter eggs
 
 … and finally, MineClone 2 is free software (“free” as in “freedom”)!
 
-## Reporting bugs
-Please report all bugs and missing Minecraft features here:
-
-<https://git.minetest.land/MineClone2/MineClone2/issues>
-
 ## Other readme files
 
 * `LICENSE.txt`: The GPLv3 license text
 * `CONTRIBUTING.md`: Information for those who want to contribute
-* `MISSING_ENGINE_FEATURES.md`: List of missing features in Minetest which MineClone 2 would need for improvement
 * `API.md`: For Minetest modders who want to mod this game
-
+* `LEGAL.md`: Legal information
-## Credits
+* `CREDITS.md`: List of everyone who contributed
-There are so many people to list (sorry). Check out the respective mod directories for details. This section is only a rough overview of the core authors of this game.
-
-### Coding
-* [Wuzzy](https://forum.minetest.net/memberlist.php?mode=viewprofile&u=3082): Main programmer of most mods (retired)
-* davedevils: Creator of MineClone on which MineClone 2 is based on
-* [ex-bart](https://github.com/ex-bart): Redstone comparators
-* [Rootyjr](https://github.com/Rootyjr): Fishing rod and bugfixes
-* [aligator](https://github.com/aligator): Improvement of doors
-* [ryvnf](https://github.com/ryvnf): Explosion mechanics
-* MysticTempest: Bugfixes
-* [bzoss](https://github.com/bzoss): Status effects, potions, brewing stand
-* kay27 <kay27@bk.ru>: Experience system, bugfixes, optimizations (Current maintainer)
-* [EliasFleckenstein03](https://github.com/EliasFleckenstein03): End crystals, enchanting, burning mobs / players, animated chests, bugfixes (Current maintainer)
-* 2mac: Fix bug with powered rail
-* Lots of other people: TO BE WRITTEN (see mod directories for details)
-
-#### Mod credits (summary)
-
-* `controls`: Arcelmi
-* `flowlib`: Qwertymine13
-* `walkover`: lordfingle
-* `drippingwater`: kddekadenz
-* `mobs_mc`: maikerumine, 22i and others
-* `awards`: rubenwardy
-* `screwdriver`: RealBadAngel, Maciej Kastakin, Minetest contributors
-* `xpanes`: Minetest contributors
-* `mesecons` mods: Jeija and contributors
-* `wieldview`: Stuart Jones
-* `mcl_meshhand`: Based on `newhand` by jordan4ibanez
-* `mcl_mobs`: Based on Mobs Redo [`mobs`] by TenPlus1 and contributors
-* Most other mods: Wuzzy
-
-Detailed credits for each mod can be found in the individual mod directories.
-
-### Graphics
-* [XSSheep](http://www.minecraftforum.net/members/XSSheep): Main author; creator of the Pixel Perfection resource pack of Minecraft 1.11
-* [Wuzzy](https://forum.minetest.net/memberlist.php?mode=viewprofile&u=3082): Main menu imagery and various edits and additions of texture pack
-* [kingoscargames](https://github.com/kingoscargames): Various edits and additions of existing textures
-* [leorockway](https://github.com/leorockway): Some edits of mob textures
-* [xMrVizzy](https://minecraft.curseforge.com/members/xMrVizzy): Glazed terracotta (textures are subject to be replaced later)
-* yutyo <tanakinci2002@gmail.com>: MineClone 2 logo
-* Other authors: GUI images
-
-### Translations
-* Wuzzy: German
-* Rocher Laurent <rocherl@club-internet.fr>: French
-* wuniversales: Spanish
-* kay27 <kay27@bk.ru>: Russian
-
-### Models
-* [22i](https://github.com/22i): Creator of all models
-* [tobyplowy](https://github.com/tobyplowy): UV-mapping fixes to said models
-
-### Sounds and music
-Various sources. See the respective mod directories for details.
-
-### Special thanks
-
-* davedevils for starting MineClone, the original version of this game
-* Wuzzy for starting and maintaining MineClone2 for several years
-* celeron55 for creating Minetest
-* Minetest's modding community for providing a huge selection of mods, some of which ended up in MineClone 2
-* Jordach for the jukebox music compilation from Big Freaking Dig
-* The workaholics who spent way too much time writing for the Minecraft Wiki. It's an invaluable resource for creating this game
-* Notch and Jeb for being the major forces behind Minecraft
-* XSSheep for creating the Pixel Perfection resource pack
-* [22i](https://github.com/22i) for providing great models and support
-* [maikerumine](http://github.com/maikerumine) for kicking off mobs and biomes
-
-## Info for programmers
-You find interesting and useful infos in `API.md`.
-
-## Legal information
-This is a fan game, not developed or endorsed by Mojang AB.
-
-Copying is an act of love. Please copy and share! <3
-Here's the detailed legalese for those who need it:
-
-### License of source code
-MineClone 2 (by kay27, EliasFleckenstein, Wuzzy, davedevils and countless others)
-is an imitation of Minecraft.
-
-MineClone 2 is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License (in the LICENSE.txt file) for more
-details.
-
-In the mods you might find in the read-me or license
-text files a different license. This counts as dual-licensing.
-You can choose which license applies to you: Either the
-license of MineClone 2 (GNU GPLv3) or the mod's license.
-
-MineClone 2 is a direct continuation of the discontinued MineClone
-project by davedevils.
-
-Mod credits:
-See `README.txt` or `README.md` in each mod directory for information about other authors.
-For mods that do not have such a file, the license is the source code license
-of MineClone 2 and the author is Wuzzy.
-
-### License of media (textures and sounds)
-No non-free licenses are used anywhere.
-
-The textures, unless otherwise noted, are based on the Pixel Perfection resource pack for Minecraft 1.11,
-authored by XSSheep. Most textures are verbatim copies, while some textures have been changed or redone
-from scratch.
-The glazed terracotta textures have been created by (MysticTempest)[https://github.com/MysticTempest].
-Source: <https://www.planetminecraft.com/texture_pack/131pixel-perfection/>
-License: [CC BY-SA 4.0](http://creativecommons.org/licenses/by-sa/4.0/)
-
-The main menu images are release under: [CC0](https://creativecommons.org/publicdomain/zero/1.0/)
-
-All other files, unless mentioned otherwise, fall under:
-Creative Commons Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
-http://creativecommons.org/licenses/by-sa/3.0/
-
-See README.txt in each mod directory for detailed information about other authors.

description.txt

@@ -1 +1 @@
-A survival sandbox game. Survive, gather, hunt, mine, build, explore, and do much more. Faithful clone of Minecraft 1.11. This is a work in progress! Expect bugs!
+A survival sandbox game. Survive, gather, hunt, mine, build, explore, and do much more. Faithful clone of Minecraft 1.12. This is a work in progress! Expect bugs!

minetest.conf

@@ -1,5 +1,8 @@
 # This is a game specific minetest.conf file, do not edit
 
+# If any of these settings are set in your minetest.conf file in ~/.minetest (Linux) or in the root directory of the game (Run in place/Windows)
+# They will override these settings
+
 # Basic game rules
 time_speed = 72
 
@@ -31,3 +34,14 @@ mgvalleys_spflags = noaltitude_chill,noaltitude_dry,nohumid_rivers,vary_river_de
 
 # MCL2-specific stuff
 keepInventory = false
+
+# Performance settings
+dedicated_server_step = 0.05 #tick rate
+# abm_interval = 0.25
+# max_objects_per_block = 4096
+# max_packets_per_iteration = 10096
+
+# Clientmodding to support official client
+enable_client_modding = true
+csm_restriction_flags = 0
+enable_mod_channels = true

mods/CORE/_mcl_autogroup/README.txt

@@ -4,6 +4,11 @@ Specifically, this mod has 2 purposes:
 1) Automatically adding the group “solid” for blocks considered “solid” in Minecraft.
 2) Generating digging time group for all nodes based on node metadata (it's complicated)
 
+This mod also requires another mod called “mcl_autogroup” to function properly.
+“mcl_autogroup” exposes the API used to register digging groups, while this mod
+uses those digging groups to set the digging time groups for all the nodes and
+tools.
+
 See init.lua for more infos.
 
 The leading underscore in the name “_mcl_autogroup” was added to force Minetest to load this mod as late as possible.

mods/CORE/_mcl_autogroup/description.txt

@@ -1 +0,0 @@
-MineClone 2 core mod which automatically adds groups to all items. Very important for digging times.

mods/CORE/_mcl_autogroup/init.lua

@@ -1,169 +1,365 @@
---[[ Mining times. Yeah, mining times … Alright, this is going to be FUN!
+--[[
+This mod implements a HACK to make 100% sure the digging times of all tools
+match Minecraft's perfectly.  The digging times system of Minetest is very
+different, so this weird group trickery has to be used.  In Minecraft, each
+block has a hardness and the actual Minecraft digging time is determined by
+this:
 
-This mod does include a HACK to make 100% sure the digging times of all tools match Minecraft's perfectly.
-The digging times system of Minetest is very different, so this weird group trickery has to be used.
-In Minecraft, each block has a hardness and the actual Minecraft digging time is determined by this:
 1) The block's hardness
-2) The tool being used
+2) The tool being used (the tool speed and its efficiency level)
-3) Whether the tool is considered as “eligible” for the block
+3) Whether the tool is considered as "eligible" for the block
    (e.g. only diamond pick eligible for obsidian)
-See Minecraft Wiki <http://minecraft.gamepedia.com/Minecraft_Wiki> for more information.
 
-In MineClone 2, all diggable node have the hardness set in the custom field “_mcl_hardness” (0 by default).
+See Minecraft Wiki <http://minecraft.gamepedia.com/Minecraft_Wiki> for more
-The nodes are also required to specify the “eligible” tools in groups like “pickaxey”, “shovely”, etc.
+information.
-This mod then calculates the real digging time based on the node meta data. The real digging times
-are then added into mcl_autogroup.digtimes where the table indices are group rating and the values are the
-digging times in seconds. These digging times can be then added verbatim into the tool definitions.
 
-Example:
+How the mod is used
-mcl_autogroup.digtimes.pickaxey_dig_diamond[1] = 0.2
+===================
 
-→ This means that when a node has been assigned the group “pickaxey_dig_diamond=1”, it can be dug by the
+In MineClone 2, all diggable nodes have the hardness set in the custom field
-diamond pickaxe in 0.2 seconds.
+"_mcl_hardness" (0 by default).  These values are used together with digging
+groups by this mod to create the correct digging times for nodes.  Digging
+groups are registered using the following code:
 
+    mcl_autogroup.register_diggroup("shovely")
+    mcl_autogroup.register_diggroup("pickaxey", {
+        levels = { "wood", "gold", "stone", "iron", "diamond" }
+    })
 
+The first line registers a simple digging group.  The second line registers a
+digging group with 5 different levels (in this case one for each material of a
+pickaxes).
 
-This strange setup with mcl_autogroup has been done to minimize the amount of required digging times
+Nodes indicate that they belong to a particular digging group by being member of
-a single tool needs to use. If this is not being done, the loading time will increase considerably
+the digging group in their node definition.  "mcl_core:dirt" for example has
-(>10s).
+shovely=1 in its groups.  If the digging group has multiple levels the value of
+the group indicates which digging level the node requires.
+"mcl_core:stone_with_gold" for example has pickaxey=4 because it requires a
+pickaxe of level 4 be mined.
 
-]]
+For tools to be able to dig nodes of digging groups they need to use the have
+the custom field "_mcl_diggroups" function to get the groupcaps.  The value of
+this field is a table which defines which groups the tool can dig and how
+efficiently.
 
-local materials = { "wood", "gold", "stone", "iron", "diamond" }
+    _mcl_diggroups = {
-local basegroups = { "pickaxey", "axey", "shovely" }
+        handy = { speed = 1, level = 1, uses = 0 },
-local minigroups = { "handy", "shearsy", "swordy", "shearsy_wool", "swordy_cobweb" }
+        pickaxey = { speed = 1, level = 0, uses = 0 },
-local divisors = {
+    }
-	["wood"] = 2,
-	["gold"] = 12,
-	["stone"] = 4,
-	["iron"] = 6,
-	["diamond"] = 8,
-	["handy"] = 1,
-	["shearsy"] = 15,
-	["swordy"] = 1.5,
-	["shearsy_wool"] = 5,
-	["swordy_cobweb"] = 15,
-}
-local max_efficiency_level = 5
 
-mcl_autogroup = {}
+The "uses" field indicate how many uses (0 for infinite) a tool has when used on
-mcl_autogroup.digtimes = {}
+the specified digging group.  The "speed" field is a multiplier to the dig speed
-mcl_autogroup.creativetimes = {}	-- Copy of digtimes, except that all values are 0. Used for creative mode
+on that digging group.
 
-for m=1, #materials do
+The "level" field indicates which levels of the group the tool can harvest.  A
-	for g=1, #basegroups do
+level of 0 means that the tool cannot harvest blocks of that node.  A level of 1
-		mcl_autogroup.digtimes[basegroups[g].."_dig_"..materials[m]] = {}
+or above means that the tool can harvest nodes with that level or below.  See
-		mcl_autogroup.creativetimes[basegroups[g].."_dig_"..materials[m]] = {}
+"mcl_tools/init.lua" for examples on how "_mcl_diggroups" is used in practice.
-		for e=1, max_efficiency_level do
+
-			mcl_autogroup.digtimes[basegroups[g].."_dig_"..materials[m].."_efficiency_"..e] = {}
+Information about the mod
+=========================
+
+The mod is split up into two parts, mcl_autogroup and _mcl_autogroup.
+mcl_autogroup contains the API functions used to register custom digging groups.
+_mcl_autogroup contains most of the code.  The leading underscore in the name
+"_mcl_autogroup" is used to force Minetest to load that part of the mod as late
+as possible.  Minetest loads mods in reverse alphabetical order.
+
+This also means that it is very important that no mod adds _mcl_autogroup as a
+dependency.
+--]]
+
+assert(minetest.get_modpath("mcl_autogroup"), "This mod requires the mod mcl_autogroup to function")
+
+-- Returns a table containing the unique "_mcl_hardness" for nodes belonging to
+-- each diggroup.
+local function get_hardness_values_for_groups()
+	local maps = {}
+	local values = {}
+	for g, _ in pairs(mcl_autogroup.registered_diggroups) do
+		maps[g] = {}
+		values[g] = {}
+	end
+
+	for _, ndef in pairs(minetest.registered_nodes) do
+		for g, _ in pairs(mcl_autogroup.registered_diggroups) do
+			if ndef.groups[g] then
+				maps[g][ndef._mcl_hardness or 0] = true
+			end
+		end
+	end
+
+	for g, map in pairs(maps) do
+		for k, _ in pairs(map) do
+			table.insert(values[g], k)
+		end
+	end
+
+	for g, _ in pairs(mcl_autogroup.registered_diggroups) do
+		table.sort(values[g])
+	end
+	return values
+end
+
+-- Returns a table containing a table indexed by "_mcl_hardness_value" to get
+-- its index in the list of unique hardnesses for each diggroup.
+local function get_hardness_lookup_for_groups(hardness_values)
+	local map = {}
+	for g, values in pairs(hardness_values) do
+		map[g] = {}
+		for k, v in pairs(values) do
+			map[g][v] = k
+		end
+	end
+	return map
+end
+
+-- Array of unique hardness values for each group which affects dig time.
+local hardness_values = get_hardness_values_for_groups()
+
+-- Map indexed by hardness values which return the index of that value in
+-- hardness_value.  Used for quick lookup.
+local hardness_lookup = get_hardness_lookup_for_groups(hardness_values)
+
+--[[local function compute_creativetimes(group)
+	local creativetimes = {}
+
+	for index, hardness in pairs(hardness_values[group]) do
+		table.insert(creativetimes, 0)
+	end
+
+	return creativetimes
+end]]
+
+-- Get the list of digging times for using a specific tool on a specific
+-- diggroup.
+--
+-- Parameters:
+-- group - the group which it is digging
+-- can_harvest - if the tool can harvest the block
+-- speed - dig speed multiplier for tool (default 1)
+-- efficiency - efficiency level for the tool if applicable
+local function get_digtimes(group, can_harvest, speed, efficiency)
+	local speed = speed or 1
+	if efficiency then
+		speed = speed + efficiency * efficiency + 1
+	end
+
+	local digtimes = {}
+
+	for index, hardness in pairs(hardness_values[group]) do
+		local digtime = (hardness or 0) / speed
+		if can_harvest then
+			digtime = digtime * 1.5
+		else
+			digtime = digtime * 5
+		end
+
+		if digtime <= 0.05 then
+			digtime = 0
+		else
+			digtime = math.ceil(digtime * 20) / 20
+		end
+		table.insert(digtimes, digtime)
+	end
+
+	return digtimes
+end
+
+-- Get one groupcap field for using a specific tool on a specific group.
+local function get_groupcap(group, can_harvest, multiplier, efficiency, uses)
+	return {
+		times = get_digtimes(group, can_harvest, multiplier, efficiency),
+		uses = uses,
+		maxlevel = 0,
+	}
+end
+
+-- Add the groupcaps from a field in "_mcl_diggroups" to the groupcaps of a
+-- tool.
+local function add_groupcaps(toolname, groupcaps, groupcaps_def, efficiency)
+	if not groupcaps_def then
+		return
+	end
+
+	for g, capsdef in pairs(groupcaps_def) do
+		local mult = capsdef.speed or 1
+		local uses = capsdef.uses
+		local def = mcl_autogroup.registered_diggroups[g]
+		local max_level = def.levels and #def.levels or 1
+
+		assert(capsdef.level, toolname .. ' is missing level for ' .. g)
+		local level = math.min(capsdef.level, max_level)
+
+		if def.levels then
+			groupcaps[g .. "_dig_default"] = get_groupcap(g, false, mult, efficiency, uses)
+			if level > 0 then
+				groupcaps[g .. "_dig_" .. def.levels[level]] = get_groupcap(g, true, mult, efficiency, uses)
+			end
+		else
+			groupcaps[g .. "_dig"] = get_groupcap(g, level > 0, mult, efficiency, uses)
 		end
 	end
 end
-for g=1, #minigroups do
+
-	mcl_autogroup.digtimes[minigroups[g].."_dig"] = {}
+-- Checks if the given node would drop its useful drop if dug by a given tool.
-	mcl_autogroup.creativetimes[minigroups[g].."_dig"] = {}
+-- Returns true if it will yield its useful drop, false otherwise.
-	for e=1, max_efficiency_level do
+function mcl_autogroup.can_harvest(nodename, toolname)
-		mcl_autogroup.digtimes[minigroups[g].."_dig_efficiency_"..e] = {}
+	local ndef = minetest.registered_nodes[nodename]
-		mcl_autogroup.creativetimes[minigroups[g].."_dig_efficiency_"..e] = {}
+
+	if not ndef then
+		return false
 	end
+
+	if minetest.get_item_group(nodename, "dig_immediate") >= 2 then
+		return true
+	end
+
+	-- Check if it can be dug by tool
+	local tdef = minetest.registered_tools[toolname]
+	if tdef and tdef._mcl_diggroups then
+		for g, gdef in pairs(tdef._mcl_diggroups) do
+			if ndef.groups[g] then
+				if ndef.groups[g] <= gdef.level then
+					return true
+				end
+			end
+		end
+	end
+
+	-- Check if it can be dug by hand
+	local tdef = minetest.registered_tools[""]
+	if tdef then
+		for g, gdef in pairs(tdef._mcl_diggroups) do
+			if ndef.groups[g] then
+				if ndef.groups[g] <= gdef.level then
+					return true
+				end
+			end
+		end
+	end
+
+	return false
 end
 
-local overwrite = function()
+-- Get one groupcap field for using a specific tool on a specific group.
+--[[local function get_groupcap(group, can_harvest, multiplier, efficiency, uses)
+	return {
+		times = get_digtimes(group, can_harvest, multiplier, efficiency),
+		uses = uses,
+		maxlevel = 0,
+	}
+end]]
+
+-- Returns the tool_capabilities from a tool definition or a default set of
+-- tool_capabilities
+local function get_tool_capabilities(tdef)
+	if tdef.tool_capabilities then
+		return tdef.tool_capabilities
+	end
+
+	-- If the damage group and punch interval from hand is not included,
+	-- then the user will not be able to attack with the tool.
+	local hand_toolcaps = minetest.registered_tools[""].tool_capabilities
+	return {
+		full_punch_interval = hand_toolcaps.full_punch_interval,
+		damage_groups = hand_toolcaps.damage_groups
+	}
+end
+
+-- Get the groupcaps for a tool.  This function returns "groupcaps" table of
+-- digging which should be put in the "tool_capabilities" of the tool definition
+-- or in the metadata of an enchanted tool.
+--
+-- Parameters:
+-- toolname - Name of the tool being enchanted (like "mcl_tools:diamond_pickaxe")
+-- efficiency - The efficiency level the tool is enchanted with (default 0)
+--
+-- NOTE:
+-- This function can only be called after mod initialization.  Otherwise a mod
+-- would have to add _mcl_autogroup as a dependency which would break the mod
+-- loading order.
+function mcl_autogroup.get_groupcaps(toolname, efficiency)
+	local tdef = minetest.registered_tools[toolname]
+	local groupcaps = table.copy(get_tool_capabilities(tdef).groupcaps or {})
+	add_groupcaps(toolname, groupcaps, tdef._mcl_diggroups, efficiency)
+	return groupcaps
+end
+
+-- Get the wear from using a tool on a digging group.
+--
+-- Parameters
+-- toolname - Name of the tool used
+-- diggroup - The name of the diggroup the tool is used on
+--
+-- NOTE:
+-- This function can only be called after mod initialization.  Otherwise a mod
+-- would have to add _mcl_autogroup as a dependency which would break the mod
+-- loading order.
+function mcl_autogroup.get_wear(toolname, diggroup)
+	local tdef = minetest.registered_tools[toolname]
+	local uses = tdef._mcl_diggroups[diggroup].uses
+	return math.ceil(65535 / uses)
+end
+
+local function overwrite()
 	for nname, ndef in pairs(minetest.registered_nodes) do
-		local groups_changed = false
 		local newgroups = table.copy(ndef.groups)
 		if (nname ~= "ignore" and ndef.diggable) then
-			-- Automatically assign the “solid” group for solid nodes
+			-- Automatically assign the "solid" group for solid nodes
 			if (ndef.walkable == nil or ndef.walkable == true)
 					and (ndef.collision_box == nil or ndef.collision_box.type == "regular")
 					and (ndef.node_box == nil or ndef.node_box.type == "regular")
 					and (ndef.groups.not_solid == 0 or ndef.groups.not_solid == nil) then
 				newgroups.solid = 1
-				groups_changed = true
 			end
-			-- Automatically assign the “opaque” group for opaque nodes
+			-- Automatically assign the "opaque" group for opaque nodes
 			if (not (ndef.paramtype == "light" or ndef.sunlight_propagates)) and
 					(ndef.groups.not_opaque == 0 or ndef.groups.not_opaque == nil) then
 				newgroups.opaque = 1
-				groups_changed = true
 			end
 
-			local function calculate_group(hardness, material, diggroup, newgroups, actual_rating, expected_rating, efficiency)
+			--local creative_breakable = false
-				local time, validity_factor
-				if actual_rating >= expected_rating then
-					-- Valid tool
-					validity_factor = 1.5
-				else
-					-- Wrong tool (higher digging time)
-					validity_factor = 5
-				end
-				local speed_multiplier = divisors[material]
-				if efficiency then
-					speed_multiplier = speed_multiplier + efficiency * efficiency + 1
-				end
-				time = (hardness * validity_factor) / speed_multiplier
-				if time <= 0.05 then
-					time = 0
-				else
-					time = math.ceil(time * 20) / 20
-				end
-				table.insert(mcl_autogroup.digtimes[diggroup], time)
-				if not efficiency then
-					table.insert(mcl_autogroup.creativetimes[diggroup], 0)
-				end
-				newgroups[diggroup] = #mcl_autogroup.digtimes[diggroup]
-				return newgroups
-			end
 
-			-- Hack in digging times
+			-- Assign groups used for digging this node depending on
-			local hardness = ndef._mcl_hardness
+			-- the registered digging groups
-			if not hardness then
+			for g, gdef in pairs(mcl_autogroup.registered_diggroups) do
-				hardness = 0
+				--creative_breakable = true
-			end
+				local index = hardness_lookup[g][ndef._mcl_hardness or 0]
+				if ndef.groups[g] then
+					if gdef.levels then
+						newgroups[g .. "_dig_default"] = index
 
-			-- Handle pickaxey, axey and shovely
+						for i = ndef.groups[g], #gdef.levels do
-			for _, basegroup in pairs(basegroups) do
+							newgroups[g .. "_dig_" .. gdef.levels[i]] = index
-				if (hardness ~= -1 and ndef.groups[basegroup]) then
-					for g=1,#materials do
-						local diggroup = basegroup.."_dig_"..materials[g]
-						newgroups = calculate_group(hardness, materials[g], diggroup, newgroups, g, ndef.groups[basegroup])
-						for e=1,max_efficiency_level do
-							newgroups = calculate_group(hardness, materials[g], diggroup .. "_efficiency_" .. e, newgroups, g, ndef.groups[basegroup], e)
 						end
-						groups_changed = true
+					else
-					end
+						newgroups[g .. "_dig"] = index
-				end
-			end
-			for m=1, #minigroups do
-				local minigroup = minigroups[m]
-				if hardness ~= -1 then
-					local diggroup = minigroup.."_dig"
-					-- actual rating
-					local ar = ndef.groups[minigroup]
-					if ar == nil then
-						ar = 0
-					end
-					if (minigroup == "handy")
-							or
-							(ndef.groups.shearsy_wool and minigroup == "shearsy_wool" and ndef.groups.wool)
-							or
-							(ndef.groups.swordy_cobweb and minigroup == "swordy_cobweb" and nname == "mcl_core:cobweb")
-							or
-							(ndef.groups[minigroup] and minigroup ~= "swordy_cobweb" and minigroup ~= "shearsy_wool") then
-						newgroups = calculate_group(hardness, minigroup, diggroup, newgroups, ar, 1)
-						for e=1,max_efficiency_level do
-							newgroups = calculate_group(hardness, minigroup, diggroup .. "_efficiency_" .. e, newgroups, ar, 1, e)
-						end
-						groups_changed = true
 					end
 				end
 			end
 
-			if groups_changed then
+			-- Automatically assign the node to the
-				minetest.override_item(nname, {
+			-- creative_breakable group if it belongs to any digging
-					groups = newgroups
+			-- group.
-				})
+			newgroups["creative_breakable"] = 1
-			end
+
+			minetest.override_item(nname, {
+				groups = newgroups
+			})
+		end
+	end
+
+	for tname, tdef in pairs(minetest.registered_tools) do
+		-- Assign groupcaps for digging the registered digging groups
+		-- depending on the _mcl_diggroups in the tool definition
+		if tdef._mcl_diggroups then
+			local toolcaps = table.copy(get_tool_capabilities(tdef))
+			toolcaps.groupcaps = mcl_autogroup.get_groupcaps(tname)
+
+			minetest.override_item(tname, {
+				tool_capabilities = toolcaps
+			})
 		end
 	end
 end

mods/CORE/_mcl_autogroup/mod.conf

@@ -1 +1,3 @@
 name = _mcl_autogroup
+author = ryvnf
+description = MineClone 2 core mod which automatically adds groups to all items. Very important for digging times.

mods/CORE/biomeinfo/init.lua

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

mods/CORE/biomeinfo/mod.conf

@@ -1,2 +1,3 @@
 name = biomeinfo
+author = Wuzzy
 description = Simple API to get data about biomes.

mods/CORE/controls/API.md

@@ -0,0 +1,23 @@
+# controls
+
+## controls.players
+Table containing player controls at runtime.
+WARNING: Never use this table in writing
+
+## controls.register_on_press(func)
+Register a function that will be executed with (player, keyname) every time a player press a key.
+
+## controls.registered_on_press
+Table containing functions registered with controls.register_on_press().
+
+## controls.register_on_release(func)
+Register a function that will be executed with (player, keyname, clock_from_last_press) every time a player release a key.
+
+## controls.registered_on_release
+Table containing functions registered with controls.register_on_release().
+
+## controls.register_on_hold(func)
+Register a function that will be executed with (player, keyname, clock_from_start_hold) every time a player hold a key.
+
+## controls.registered_on_hold
+Table containing functions registered with controls.register_on_hold().

mods/CORE/controls/init.lua

@@ -1,3 +1,8 @@
+local get_connected_players = minetest.get_connected_players
+local clock = os.clock
+
+local pairs = pairs
+
 controls = {}
 controls.players = {}
 
@@ -17,15 +22,15 @@ function controls.register_on_hold(func)
 end
 
 local known_controls = {
-	jump=true,
+	jump = true,
-	right=true,
+	right = true,
-	left=true,
+	left = true,
-	LMB=true,
+	LMB = true,
-	RMB=true,
+	RMB = true,
-	sneak=true,
+	sneak = true,
-	aux1=true,
+	aux1 = true,
-	down=true,
+	down = true,
-	up=true,
+	up = true,
 }
 
 minetest.register_on_joinplayer(function(player)
@@ -42,31 +47,31 @@ minetest.register_on_leaveplayer(function(player)
 end)
 
 minetest.register_globalstep(function(dtime)
-	for _, player in pairs(minetest.get_connected_players()) do
+	for _, player in pairs(get_connected_players()) do
 		local player_name = player:get_player_name()
 		local player_controls = player:get_player_control()
 		if controls.players[player_name] then
-		for cname, cbool in pairs(player_controls) do
+			for cname, cbool in pairs(player_controls) do
-		if known_controls[cname] == true then
+				if known_controls[cname] == true then
-			--Press a key
+					--Press a key
-			if cbool==true and controls.players[player_name][cname][1]==false then
+					if cbool == true and controls.players[player_name][cname][1] == false then
-				for _, func in pairs(controls.registered_on_press) do
+						for _, func in pairs(controls.registered_on_press) do
-					func(player, cname)
+							func(player, cname)
+						end
+						controls.players[player_name][cname] = {true, clock()}
+					elseif cbool == true and controls.players[player_name][cname][1] == true then
+						for _, func in pairs(controls.registered_on_hold) do
+							func(player, cname, clock()-controls.players[player_name][cname][2])
+						end
+					--Release a key
+					elseif cbool == false and controls.players[player_name][cname][1] == true then
+						for _, func in pairs(controls.registered_on_release) do
+							func(player, cname, clock()-controls.players[player_name][cname][2])
+						end
+						controls.players[player_name][cname] = {false}
+					end
 				end
-				controls.players[player_name][cname] = {true, os.clock()}
-			elseif cbool==true and controls.players[player_name][cname][1]==true then
-				for _, func in pairs(controls.registered_on_hold) do
-					func(player, cname, os.clock()-controls.players[player_name][cname][2])
-				end
-			--Release a key
-			elseif cbool==false and controls.players[player_name][cname][1]==true then
-				for _, func in pairs(controls.registered_on_release) do
-					func(player, cname, os.clock()-controls.players[player_name][cname][2])
-				end
-				controls.players[player_name][cname] = {false}
 			end
 		end
-		end
-		end
 	end
 end)

mods/CORE/controls/mod.conf

@@ -1 +1,4 @@
-name=controls
+name = controls
+author = Arcelmi
+description = Controls framework by Arcelmi
+

mods/CORE/flowlib/API.md

@@ -0,0 +1,45 @@
+# flowlib
+Simple flow functions.
+
+## flowlib.is_touching(realpos, nodepos, radius)
+Return true if a sphere of <radius> at <realpos> collide with node at <nodepos>.
+* realpos: position
+* nodepos: position
+* radius: number
+
+## flowlib.is_water(pos)
+Return true if node at <pos> is water, false overwise.
+* pos: position
+
+## flowlib.node_is_water(node)
+Return true if <node> is water, false overwise.
+* node: node
+
+## flowlib.is_lava(pos)
+Return true if node at <pos> is lava, false overwise.
+* pos: position
+
+## flowlib.node_is_lava(node)
+Return true if <node> is lava, false overwise.
+* node: node
+
+## flowlib.is_liquid(pos)
+Return true if node at <pos> is liquid, false overwise.
+* pos: position
+
+## flowlib.node_is_liquid(node)
+Return true if <node> is liquid, false overwise.
+* node: node
+
+## flowlib.quick_flow(pos, node)
+Return direction where the water is flowing (to be use to push mobs, items...).
+* pos: position
+* node: node
+
+## flowlib.move_centre(pos, realpos, node, radius)
+Return the pos of the nearest not water block near from <pos> in a sphere of <radius> at <realpos>.
+WARNING: This function is never used in mcl2, use at your own risk. The informations described here may be wrong.
+* pos: position
+* realpos: position, position of the entity
+* node: node
+* radius: number

mods/CORE/flowlib/init.lua

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

mods/CORE/flowlib/mod.conf

@@ -1 +1,4 @@
 name = flowlib
+author = Qwertymine3
+description = Simple flow functions for use in Minetest mods by Qwertymine3
+

mods/CORE/mcl_attached/description.txt

@@ -1 +0,0 @@
-Adds additional ways for nodes to be attached.

mods/CORE/mcl_attached/init.lua

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

mods/CORE/mcl_attached/mod.conf

@@ -0,0 +1,3 @@
+name = mcl_attached
+author = Wuzzy
+description = Adds additional ways for nodes to be attached.

mods/CORE/mcl_autogroup/API.md

@@ -0,0 +1,27 @@
+# mcl_autogroup
+This mod emulate digging times from mc.
+
+## mcl_autogroup.can_harvest(nodename, toolname)
+Return true if <nodename> can be dig with <toolname>.
+* nodename: string, valid nodename
+* toolname: (optional) string, valid toolname
+
+## mcl_autogroup.get_groupcaps(toolname, efficiency)
+This function is used to calculate diggroups for tools.
+WARNING: This function can only be called after mod initialization.
+* toolname: string, name of the tool being enchanted (like "mcl_tools:diamond_pickaxe")
+* efficiency: (optional) integer, the efficiency level the tool is enchanted with (default 0)
+
+## mcl_autogroup.get_wear(toolname, diggroup)
+Return the max wear of <toolname> with <diggroup>
+WARNING: This function can only be called after mod initialization.
+* toolname: string, name of the tool used
+* diggroup: string, the name of the diggroup the tool is used on
+
+## mcl_autogroup.register_diggroup(group, def)
+* group: string, name of the group to register as a digging group
+* def: (optional) table, table with information about the diggroup (defaults to {} if unspecified)
+    * level: (optional) string, if specified it is an array containing the names of the different digging levels the digging group supports
+
+## mcl_autogroup.registered_diggroups
+List of registered diggroups, indexed by name.

mods/CORE/mcl_autogroup/init.lua

@@ -0,0 +1,28 @@
+--[[
+This is one part of a mod to replicate the digging times from Minecraft.  This
+part only exposes a function to register digging groups.  The rest of the mod is
+implemented and documented in the _mcl_autogroup.
+
+The mod is split up into two parts, mcl_autogroup and _mcl_autogroup.
+mcl_autogroup contains the API functions used to register custom digging groups.
+_mcl_autogroup contains most of the code.  The leading underscore in the name
+"_mcl_autogroup" is used to force Minetest to load that part of the mod as late
+as possible.  Minetest loads mods in reverse alphabetical order.
+--]]
+mcl_autogroup = {}
+mcl_autogroup.registered_diggroups = {}
+
+assert(minetest.get_modpath("_mcl_autogroup"), "This mod requires the mod _mcl_autogroup to function")
+
+-- Register a group as a digging group.
+--
+-- Parameters:
+-- group - Name of the group to register as a digging group
+-- def - Table with information about the diggroup (defaults to {} if unspecified)
+--
+-- Values in def:
+-- level - If specified it is an array containing the names of the different
+--         digging levels the digging group supports.
+function mcl_autogroup.register_diggroup(group, def)
+	mcl_autogroup.registered_diggroups[group] = def or {}
+end

mods/CORE/mcl_autogroup/mod.conf

@@ -0,0 +1,3 @@
+name = mcl_autogroup
+author = ryvnf
+description = MineClone 2 core mod which automatically adds groups to all items. Very important for digging times.

mods/CORE/mcl_colors/API.md

@@ -0,0 +1,8 @@
+# mcl_colors
+Mod providing global table containing legacity minecraft colors to be used in mods.
+
+## mcl_colors.*
+Colors by upper name, in hex value.
+
+## mcl_colors.background.*
+Background colors by upper name, in hex value.

mods/CORE/mcl_colors/init.lua

@@ -0,0 +1,36 @@
+mcl_colors = {
+	BLACK = "#000000",
+	DARK_BLUE = "#0000AA",
+	DARK_GREEN = "#00AA00",
+	DARK_AQUA = "#00AAAA",
+	DARK_RED = "#AA0000",
+	DARK_PURPLE = "#AA00AA",
+	GOLD = "#FFAA00",
+	GRAY = "#AAAAAA",
+	DARK_GRAY = "#555555",
+	BLUE = "#5555FF",
+	GREEN = "#55FF55",
+	AQUA = "#55FFFF",
+	RED = "#FF5555",
+	LIGHT_PURPLE = "#FF55FF",
+	YELLOW = "#FFFF55",
+	WHITE = "#FFFFFF",
+	background = {
+		BLACK = "#000000",
+		DARK_BLUE = "#00002A",
+		DARK_GREEN = "#002A00",
+		DARK_AQUA = "#002A2A",
+		DARK_RED = "#2A0000",
+		DARK_PURPLE = "#2A002A",
+		GOLD = "#2A2A00",
+		GRAY = "#2A2A2A",
+		DARK_GRAY = "#151515",
+		BLUE = "#15153F",
+		GREEN = "#153F15",
+		AQUA = "#153F3F",
+		RED = "#3F1515",
+		LIGHT_PURPLE = "#3F153F",
+		YELLOW = "#3F3F15",
+		WHITE = "#373501",
+	}
+}

mods/CORE/mcl_colors/mod.conf

@@ -0,0 +1,3 @@
+name = mcl_colors
+author = Fleckenstein
+description = The HTML sequences for the minecraft colors

mods/CORE/mcl_damage/init.lua

@@ -0,0 +1,169 @@
+mcl_damage = {
+	modifiers = {},
+	damage_callbacks = {},
+	death_callbacks = {},
+	types = {
+		in_fire = {is_fire = true},
+		lightning_bolt = {is_lightning = true},
+		on_fire = {is_fire = true, bypasses_armor = true},
+		lava = {is_fire = true},
+		hot_floor = {is_fire = true},
+		in_wall = {bypasses_armor = true},
+		drown = {bypasses_armor = true},
+		starve = {bypasses_armor = true, bypasses_magic = true},
+		cactus = {},
+		fall = {bypasses_armor = true},
+		fly_into_wall = {bypasses_armor = true}, -- unused
+		out_of_world = {bypasses_armor = true, bypasses_magic = true, bypasses_invulnerability = true},
+		generic = {bypasses_armor = true},
+		magic = {is_magic = true, bypasses_armor = true},
+		dragon_breath = {is_magic = true, bypasses_armor = true},	-- this is only used for dragon fireball; dragon fireball does not actually deal impact damage tho, so this is unreachable
+		wither = {bypasses_armor = true}, -- unused
+		wither_skull = {is_magic = true, is_explosion = true}, -- this is non-MC but a workaround to get the proper death message
+		anvil = {},
+		falling_node = {},	-- this is falling_block in MC
+		mob = {},
+		player = {},
+		arrow = {is_projectile = true},
+		fireball = {is_projectile = true, is_fire = true},
+		thorns = {is_magic = true},
+		explosion = {is_explosion = true},
+		cramming = {bypasses_armor = true}, -- unused
+		fireworks = {is_explosion = true}, -- unused
+	}
+}
+
+function mcl_damage.register_modifier(func, priority)
+	table.insert(mcl_damage.modifiers, {func = func, priority = priority or 0})
+end
+
+function mcl_damage.register_on_damage(func)
+	table.insert(mcl_damage.damage_callbacks, func)
+end
+
+function mcl_damage.register_on_death(func)
+	table.insert(mcl_damage.death_callbacks, func)
+end
+
+function mcl_damage.run_modifiers(obj, damage, reason)
+	for _, modf in ipairs(mcl_damage.modifiers) do
+		damage = modf.func(obj, damage, reason) or damage
+		if damage == 0 then
+			return 0
+		end
+	end
+
+	return damage
+end
+
+local function run_callbacks(funcs, ...)
+	for _, func in pairs(funcs) do
+		func(...)
+	end
+end
+
+function mcl_damage.run_damage_callbacks(obj, damage, reason)
+	run_callbacks(mcl_damage.damage_callbacks, obj, damage, reason)
+end
+
+function mcl_damage.run_death_callbacks(obj, reason)
+	run_callbacks(mcl_damage.death_callbacks, obj, reason)
+end
+
+function mcl_damage.from_punch(mcl_reason, object)
+	mcl_reason.direct = object
+	local luaentity = mcl_reason.direct:get_luaentity()
+	if luaentity then
+		if luaentity._is_arrow then
+			mcl_reason.type = "arrow"
+		elseif luaentity._is_fireball then
+			mcl_reason.type = "fireball"
+		elseif luaentity._cmi_is_mob then
+			mcl_reason.type = "mob"
+		end
+		mcl_reason.source = mcl_reason.source or luaentity._source_object
+	else
+		mcl_reason.type = "player"
+	end
+end
+
+function mcl_damage.finish_reason(mcl_reason)
+	mcl_reason.source = mcl_reason.source or mcl_reason.direct
+	mcl_reason.flags = mcl_damage.types[mcl_reason.type]
+end
+
+function mcl_damage.from_mt(mt_reason)
+	if mt_reason._mcl_chached_reason then
+		return mt_reason._mcl_chached_reason
+	end
+
+	local mcl_reason
+
+	if mt_reason._mcl_reason then
+		mcl_reason = mt_reason._mcl_reason
+	else
+		mcl_reason = {type = "generic"}
+
+		if mt_reason._mcl_type then
+			mcl_reason.type = mt_reason._mcl_type
+		elseif mt_reason.type == "fall" then
+			mcl_reason.type = "fall"
+		elseif mt_reason.type == "drown" then
+			mcl_reason.type = "drown"
+		elseif mt_reason.type == "punch" then
+			mcl_damage.from_punch(mcl_reason, mt_reason.object)
+		elseif mt_reason.type == "node_damage" and mt_reason.node then
+			if minetest.get_item_group(mt_reason.node, "fire") > 0 then
+				mcl_reason.type = "in_fire"
+			end
+			if minetest.get_item_group(mt_reason.node, "lava") > 0 then
+				mcl_reason.type = "lava"
+			end
+		end
+
+		for key, value in pairs(mt_reason) do
+			if key:find("_mcl_") == 1 then
+				mcl_reason[key:sub(6, #key)] = value
+			end
+		end
+	end
+
+	mcl_damage.finish_reason(mcl_reason)
+	mt_reason._mcl_cached_reason = mcl_reason
+
+	return mcl_reason
+end
+
+function mcl_damage.register_type(name, def)
+	mcl_damage.types[name] = def
+end
+
+minetest.register_on_player_hpchange(function(player, hp_change, mt_reason)
+	if hp_change < 0 then
+		if player:get_hp() <= 0 then
+			return 0
+		end
+		hp_change = -mcl_damage.run_modifiers(player, -hp_change, mcl_damage.from_mt(mt_reason))
+	end
+	return hp_change
+end, true)
+
+minetest.register_on_player_hpchange(function(player, hp_change, mt_reason)
+	if player:get_hp() > 0 then
+		mt_reason.approved = true
+		if hp_change < 0 then
+			mcl_damage.run_damage_callbacks(player, -hp_change, mcl_damage.from_mt(mt_reason))
+		end
+	end
+end, false)
+
+minetest.register_on_dieplayer(function(player, mt_reason)
+	if mt_reason.approved then
+		mcl_damage.run_death_callbacks(player, mcl_damage.from_mt(mt_reason))
+	end
+end)
+
+minetest.register_on_mods_loaded(function()
+	table.sort(mcl_damage.modifiers, function(a, b) return a.priority < b.priority end)
+end)
+

mods/CORE/mcl_damage/mod.conf

@@ -0,0 +1,3 @@
+name = mcl_damage
+author = Fleckenstein
+description = Minecraft-like damage reason system

mods/CORE/mcl_explosions/API.md

@@ -0,0 +1,15 @@
+# mcl_explosions
+This mod provide helper functions to create explosions.
+
+## mcl_explosions.explode(pos, strength, info, puncher)
+* pos: position, initial position of the explosion
+* strenght: number, radius of the explosion
+* info: table, explosion informations:
+    * drop_chance: number, if specified becomes the drop chance of all nodes in the explosion (default: 1.0 / strength)
+    * max_blast_resistance: int, if specified the explosion will treat all non-indestructible nodes as having a blast resistance of no more than this value
+    * sound: bool, if true, the explosion will play a sound (default: true)
+    * particles: bool, if true, the explosion will create particles (default: true)
+    * fire: bool, if true, 1/3 nodes become fire (default: false)
+    * griefing: bool, if true, the explosion will destroy nodes (default: true)
+    * grief_protected: bool, if true, the explosion will also destroy nodes which have been protected (default: false)
+* puncher: (optional) entity, will be used as source for damage done by the explosion

mods/CORE/mcl_explosions/init.lua

@@ -12,11 +12,23 @@ under the LGPLv2.1 license.
 
 mcl_explosions = {}
 
-local mod_death_messages = minetest.get_modpath("mcl_death_messages") ~= nil
+local mod_fire = minetest.get_modpath("mcl_fire")
-local mod_fire = minetest.get_modpath("mcl_fire") ~= nil
+--local CONTENT_FIRE = minetest.get_content_id("mcl_fire:fire")
-local CONTENT_FIRE = minetest.get_content_id("mcl_fire:fire")
 
-local S = minetest.get_translator("mcl_explosions")
+local math = math
+local vector = vector
+local table = table
+
+local hash_node_position = minetest.hash_node_position
+local get_objects_inside_radius = minetest.get_objects_inside_radius
+local get_position_from_hash = minetest.get_position_from_hash
+local get_node_drops = minetest.get_node_drops
+local get_name_from_content_id = minetest.get_name_from_content_id
+local get_voxel_manip = minetest.get_voxel_manip
+local bulk_set_node = minetest.bulk_set_node
+local check_for_falling = minetest.check_for_falling
+local add_item = minetest.add_item
+local pos_to_string = minetest.pos_to_string
 
 -- Saved sphere explosion shapes for various radiuses
 local sphere_shapes = {}
@@ -57,46 +69,44 @@ local function compute_sphere_rays(radius)
 	local rays = {}
 	local sphere = {}
 
-	for i=1, 2 do
+	local function add_ray(pos)
+		sphere[hash_node_position(pos)] = pos
+	end
+
+	for y = -radius, radius do
+		for z = -radius, radius do
+			for x = -radius, 0 do
+				local d = x * x + y * y + z * z
+				if d <= radius * radius then
+					add_ray(vector.new(x, y, z))
+					add_ray(vector.new(-x, y, z))
+					break
+				end
+			end
+		end
+	end
+
+	for x = -radius, radius do
+		for z = -radius, radius do
+			for y = -radius, 0 do
+				local d = x * x + y * y + z * z
+				if d <= radius * radius then
+					add_ray(vector.new(x, y, z))
+					add_ray(vector.new(x, -y, z))
+					break
+				end
+			end
+		end
+	end
+
+	for x = -radius, radius do
 		for y = -radius, radius do
-			for z = -radius, radius do
+			for z = -radius, 0 do
-				for x = -radius, 0, 1 do
+				local d = x * x + y * y + z * z
-					local d = x * x + y * y + z * z
+				if d <= radius * radius then
-					if d <= radius * radius then
+					add_ray(vector.new(x, y, z))
-						local pos = { x = x, y = y, z = z }
+					add_ray(vector.new(x, y, -z))
-						sphere[minetest.hash_node_position(pos)] = pos
+					break
-						break
-					end
-				end
-			end
-		end
-	end
-
-	for i=1,2 do
-		for x = -radius, radius do
-			for z = -radius, radius do
-				for y = -radius, 0, 1 do
-					local d = x * x + y * y + z * z
-					if d <= radius * radius then
-						local pos = { x = x, y = y, z = z }
-						sphere[minetest.hash_node_position(pos)] = pos
-						break
-					end
-				end
-			end
-		end
-	end
-
-	for i=1,2 do
-		for x = -radius, radius do
-			for y = -radius, radius do
-				for z = -radius, 0, 1 do
-					local d = x * x + y * y + z * z
-					if d <= radius * radius then
-						local pos = { x = x, y = y, z = z }
-						sphere[minetest.hash_node_position(pos)] = pos
-						break
-					end
 				end
 			end
 		end
@@ -140,7 +150,8 @@ end
 -- raydirs - The directions for each ray
 -- radius - The maximum distance each ray will go
 -- info - Table containing information about explosion
--- puncher - object that punches other objects (optional)
+-- direct - direct source object of the damage (optional)
+-- source - indirect source object of the damage (optional)
 --
 -- Values in info:
 -- drop_chance - The chance that destroyed nodes will drop their items
@@ -149,12 +160,14 @@ end
 -- max_blast_resistance - The explosion will treat all non-indestructible nodes
 --                        as having a blast resistance of no more than this
 --                        value
+-- grief_protected - If true, the explosion will also destroy nodes which have
+--                   been protected
 --
 -- Note that this function has been optimized, it contains code which has been
 -- inlined to avoid function calls and unnecessary table creation. This was
 -- measured to give a significant performance increase.
-local function trace_explode(pos, strength, raydirs, radius, info, puncher)
+local function trace_explode(pos, strength, raydirs, radius, info, direct, source)
-	local vm = minetest.get_voxel_manip()
+	local vm = get_voxel_manip()
 
 	local emin, emax = vm:read_from_map(vector.subtract(pos, radius),
 		vector.add(pos, radius))
@@ -164,20 +177,18 @@ local function trace_explode(pos, strength, raydirs, radius, info, puncher)
 
 	local ystride = (emax.x - emin_x + 1)
 	local zstride = ystride * (emax.y - emin_y + 1)
-	local pos_x = pos.x
-	local pos_y = pos.y
-	local pos_z = pos.z
 
-	local area = VoxelArea:new {
+	--[[local area = VoxelArea:new {
 		MinEdge = emin,
 		MaxEdge = emax
-	}
+	}]]
 	local data = vm:get_data()
 	local destroy = {}
 
 	local drop_chance = info.drop_chance
 	local fire = info.fire
 	local max_blast_resistance = info.max_blast_resistance
+	local grief_protected = info.grief_protected
 
 	-- Trace rays for environment destruction
 	if info.griefing then
@@ -194,16 +205,17 @@ local function trace_explode(pos, strength, raydirs, radius, info, puncher)
 				local npos_x = math.floor(rpos_x + 0.5)
 				local npos_y = math.floor(rpos_y + 0.5)
 				local npos_z = math.floor(rpos_z + 0.5)
+				local npos = { x = npos_x, y = npos_y, z = npos_z }
 				local idx = (npos_z - emin_z) * zstride + (npos_y - emin_y) * ystride +
 						npos_x - emin_x + 1
 
 				local cid = data[idx]
-				local br = node_blastres[cid]
+				local br = node_blastres[cid] or INDESTRUCT_BLASTRES
 				if br < INDESTRUCT_BLASTRES and br > max_blast_resistance then
 					br = max_blast_resistance
 				end
 
-				local hash = minetest.hash_node_position({x=npos_x, y=npos_y, z=npos_z})
+				local hash = hash_node_position(npos)
 
 				rpos_x = rpos_x + STEP_LENGTH * rdir_x
 				rpos_y = rpos_y + STEP_LENGTH * rdir_y
@@ -215,8 +227,10 @@ local function trace_explode(pos, strength, raydirs, radius, info, puncher)
 					break
 				end
 
-				if cid ~= minetest.CONTENT_AIR and not minetest.is_protected({x = npos_x, y = npos_y, z = npos_z}, "") then
+				if cid ~= minetest.CONTENT_AIR then
-					destroy[hash] = idx
+					if not minetest.is_protected(npos, "") or grief_protected then
+						destroy[hash] = idx
+					end
 				end
 			end
 		end
@@ -224,14 +238,14 @@ local function trace_explode(pos, strength, raydirs, radius, info, puncher)
 
 	-- Entities in radius of explosion
 	local punch_radius = 2 * strength
-	local objs = minetest.get_objects_inside_radius(pos, punch_radius)
+	local objs = get_objects_inside_radius(pos, punch_radius)
 
 	-- Trace rays for entity damage
 	for _, obj in pairs(objs) do
 		local ent = obj:get_luaentity()
 
 		-- Ignore items to lower lag
-		if obj:is_player() or (ent and ent.name ~= '__builtin.item') then
+		if (obj:is_player() or (ent and ent.name ~= "__builtin.item")) and obj:get_hp() > 0 then
 			local opos = obj:get_pos()
 			local collisionbox = nil
 
@@ -244,12 +258,12 @@ local function trace_explode(pos, strength, raydirs, radius, info, puncher)
 
 			if collisionbox then
 				-- Create rays from random points in the collision box
-				local x1 = collisionbox[1] * 2
+				local x1 = collisionbox[1]
-				local y1 = collisionbox[2] * 2
+				local y1 = collisionbox[2]
-				local z1 = collisionbox[3] * 2
+				local z1 = collisionbox[3]
-				local x2 = collisionbox[4] * 2
+				local x2 = collisionbox[4]
-				local y2 = collisionbox[5] * 2
+				local y2 = collisionbox[5]
-				local z2 = collisionbox[6] * 2
+				local z2 = collisionbox[6]
 				local x_len = math.abs(x2 - x1)
 				local y_len = math.abs(y2 - y1)
 				local z_len = math.abs(z2 - z1)
@@ -305,7 +319,6 @@ local function trace_explode(pos, strength, raydirs, radius, info, puncher)
 					impact = 0
 				end
 				local damage = math.floor((impact * impact + impact) * 7 * strength + 1)
-				local source = puncher or obj
 
 				local sleep_formspec_doesnt_close_mt53 = false
 				if obj:is_player() then
@@ -317,26 +330,22 @@ local function trace_explode(pos, strength, raydirs, radius, info, puncher)
 							sleep_formspec_doesnt_close_mt53 = true
 						end
 					end
-					if mod_death_messages then
-						mcl_death_messages.player_damage(obj, S("@1 was caught in an explosion.", name))
-					end
-					if rawget(_G, "armor") and armor.last_damage_types then
-						armor.last_damage_types[name] = "explosion"
-					end
 				end
 
 				if sleep_formspec_doesnt_close_mt53 then
-					minetest.after(0.3, function(obj, damage, impact, punch_dir) -- 0.2 is minimum delay for closing old formspec and open died formspec -- TODO: REMOVE THIS IN THE FUTURE
+					minetest.after(0.3, function() -- 0.2 is minimum delay for closing old formspec and open died formspec -- TODO: REMOVE THIS IN THE FUTURE
-						if not obj then return end
+						if not obj:is_player() then
-						obj:punch(obj, 10, { damage_groups = { full_punch_interval = 1, fleshy = damage, knockback = impact * 20.0 } }, punch_dir)
+							return
-						obj:add_player_velocity(vector.multiply(punch_dir, impact * 20))
+						end
-					end, obj, damage, impact, vector.new(punch_dir))
-				else
-					obj:punch(source, 10, { damage_groups = { full_punch_interval = 1, fleshy = damage, knockback = impact * 20.0 } }, punch_dir)
 
-					if obj:is_player() then
+						mcl_util.deal_damage(obj, damage, {type = "explosion", direct = direct, source = source})
-						obj:add_player_velocity(vector.multiply(punch_dir, impact * 20))
+
-					elseif ent.tnt_knockback then
+						obj:add_velocity(vector.multiply(punch_dir, impact * 20))
+					end)
+				else
+					mcl_util.deal_damage(obj, damage, {type = "explosion", direct = direct, source = source})
+
+					if obj:is_player() or ent.tnt_knockback then
 						obj:add_velocity(vector.multiply(punch_dir, impact * 20))
 					end
 				end
@@ -352,52 +361,51 @@ local function trace_explode(pos, strength, raydirs, radius, info, puncher)
 		local on_blast = node_on_blast[data[idx]]
 		local remove = true
 
-		if do_drop or on_blast ~= nil then
+		if do_drop or on_blast then
-			local npos = minetest.get_position_from_hash(hash)
+			local npos = get_position_from_hash(hash)
-			if on_blast ~= nil then
+			if on_blast then
 				on_blast(npos, 1.0, do_drop)
 				remove = false
 			else
-				local name = minetest.get_name_from_content_id(data[idx])
+				local name = get_name_from_content_id(data[idx])
-				local drop = minetest.get_node_drops(name, "")
+				local drop = get_node_drops(name, "")
 
 				for _, item in ipairs(drop) do
 					if type(item) ~= "string" then
 						item = item:get_name() .. item:get_count()
 					end
-					minetest.add_item(npos, item)
+					add_item(npos, item)
 				end
 			end
 		end
 		if remove then
 			if mod_fire and fire and math.random(1, 3) == 1 then
-				table.insert(fires, minetest.get_position_from_hash(hash))
+				table.insert(fires, get_position_from_hash(hash))
 			else
-				table.insert(airs, minetest.get_position_from_hash(hash))
+				table.insert(airs, get_position_from_hash(hash))
 			end
 		end
 	end
 	-- We use bulk_set_node instead of LVM because we want to have on_destruct and
 	-- on_construct being called
 	if #airs > 0 then
-		minetest.bulk_set_node(airs, {name="air"})
+		bulk_set_node(airs, {name="air"})
 	end
 	if #fires > 0 then
-		minetest.bulk_set_node(fires, {name="mcl_fire:fire"})
+		bulk_set_node(fires, {name="mcl_fire:fire"})
 	end
 	-- Update falling nodes
 	for a=1, #airs do
 		local p = airs[a]
-		minetest.check_for_falling({x=p.x, y=p.y+1, z=p.z})
+		check_for_falling({x=p.x, y=p.y+1, z=p.z})
 	end
 	for f=1, #fires do
 		local p = fires[f]
-		minetest.check_for_falling({x=p.x, y=p.y+1, z=p.z})
+		check_for_falling({x=p.x, y=p.y+1, z=p.z})
 	end
 
 	-- Log explosion
-	minetest.log('action', 'Explosion at ' .. minetest.pos_to_string(pos) ..
+	minetest.log("action", "Explosion at "..pos_to_string(pos).." with strength "..strength.." and radius "..radius)
-		' with strength ' .. strength .. ' and radius ' .. radius)
 end
 
 -- Create an explosion with strength at pos.
@@ -406,7 +414,8 @@ end
 -- pos - The position where the explosion originates from
 -- strength - The blast strength of the explosion (a TNT explosion uses 4)
 -- info - Table containing information about explosion
--- puncher - object that is reported as source of punches/damage (optional)
+-- direct - direct source object of the damage (optional)
+-- source - indirect source object of the damage (optional)
 --
 -- Values in info:
 -- drop_chance - If specified becomes the drop chance of all nodes in the
@@ -418,7 +427,9 @@ end
 -- particles - If true, the explosion will create particles (default: true)
 -- fire - If true, 1/3 nodes become fire (default: false)
 -- griefing - If true, the explosion will destroy nodes (default: true)
-function mcl_explosions.explode(pos, strength, info, puncher)
+-- grief_protected - If true, the explosion will also destroy nodes which have
+--                   been protected (default: false)
+function mcl_explosions.explode(pos, strength, info, direct, source)
 	if info == nil then
 		info = {}
 	end
@@ -437,6 +448,7 @@ function mcl_explosions.explode(pos, strength, info, puncher)
 	if info.sound == nil then info.sound = true end
 	if info.fire == nil then info.fire = false end
 	if info.griefing == nil then info.griefing = true end
+	if info.grief_protected == nil then info.grief_protected = false end
 	if info.max_blast_resistance == nil then
 		info.max_blast_resistance = INDESTRUCT_BLASTRES
 	end
@@ -446,7 +458,7 @@ function mcl_explosions.explode(pos, strength, info, puncher)
 		info.drop_chance = 0
 	end
 
-	trace_explode(pos, strength, shape, radius, info, puncher)
+	trace_explode(pos, strength, shape, radius, info, direct, source)
 
 	if info.particles then
 		add_particles(pos, radius)

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

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

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

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

mods/CORE/mcl_explosions/locale/mcl_explosions.pl.tr

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

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

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

mods/CORE/mcl_explosions/locale/template.txt

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

mods/CORE/mcl_explosions/mod.conf

@@ -1,4 +1,5 @@
 name = mcl_explosions
+author = ryvnf
 description = A common API to create explosions.
 depends = mcl_particles
 optional_depends = mcl_fire

mods/CORE/mcl_init/description.txt

@@ -1 +0,0 @@
-Initialization mod of MineClone 2. Defines some common shared variables and sets up initial default settings which have to be set at the beginning.

mods/CORE/mcl_init/init.lua

@@ -21,6 +21,9 @@ mcl_vars.gui_bg_img = "background9[1,1;1,1;mcl_base_textures_background9.png;tru
 -- Legacy
 mcl_vars.inventory_header = ""
 
+-- Tool wield size
+mcl_vars.tool_wield_scale = { x = 1.8, y = 1.8, z = 1 }
+
 -- Mapgen variables
 local mg_name = minetest.get_mapgen_setting("mg_name")
 local minecraft_height_limit = 256
@@ -29,22 +32,59 @@ local singlenode = mg_name == "singlenode"
 
 -- Calculate mapgen_edge_min/mapgen_edge_max
 mcl_vars.chunksize = math.max(1, tonumber(minetest.get_mapgen_setting("chunksize")) or 5)
-mcl_vars.MAP_BLOCKSIZE = math.max(1, core.MAP_BLOCKSIZE or 16)
+mcl_vars.MAP_BLOCKSIZE = math.max(1, minetest.MAP_BLOCKSIZE or 16)
 mcl_vars.mapgen_limit = math.max(1, tonumber(minetest.get_mapgen_setting("mapgen_limit")) or 31000)
-mcl_vars.MAX_MAP_GENERATION_LIMIT = math.max(1, core.MAX_MAP_GENERATION_LIMIT or 31000)
+mcl_vars.MAX_MAP_GENERATION_LIMIT = math.max(1, minetest.MAX_MAP_GENERATION_LIMIT or 31000)
 local central_chunk_offset = -math.floor(mcl_vars.chunksize / 2)
-local chunk_size_in_nodes = mcl_vars.chunksize * mcl_vars.MAP_BLOCKSIZE
+mcl_vars.central_chunk_offset_in_nodes = central_chunk_offset * mcl_vars.MAP_BLOCKSIZE
+mcl_vars.chunk_size_in_nodes = mcl_vars.chunksize * mcl_vars.MAP_BLOCKSIZE
 local central_chunk_min_pos = central_chunk_offset * mcl_vars.MAP_BLOCKSIZE
-local central_chunk_max_pos = central_chunk_min_pos + chunk_size_in_nodes - 1
+local central_chunk_max_pos = central_chunk_min_pos + mcl_vars.chunk_size_in_nodes - 1
 local ccfmin = central_chunk_min_pos - mcl_vars.MAP_BLOCKSIZE -- Fullminp/fullmaxp of central chunk, in nodes
 local ccfmax = central_chunk_max_pos + mcl_vars.MAP_BLOCKSIZE
 local mapgen_limit_b = math.floor(math.min(mcl_vars.mapgen_limit, mcl_vars.MAX_MAP_GENERATION_LIMIT) / mcl_vars.MAP_BLOCKSIZE)
 local mapgen_limit_min = -mapgen_limit_b * mcl_vars.MAP_BLOCKSIZE
 local mapgen_limit_max = (mapgen_limit_b + 1) * mcl_vars.MAP_BLOCKSIZE - 1
-local numcmin = math.max(math.floor((ccfmin - mapgen_limit_min) / chunk_size_in_nodes), 0) -- Number of complete chunks from central chunk
+local numcmin = math.max(math.floor((ccfmin - mapgen_limit_min) / mcl_vars.chunk_size_in_nodes), 0) -- Number of complete chunks from central chunk
-local numcmax = math.max(math.floor((mapgen_limit_max - ccfmax) / chunk_size_in_nodes), 0) -- fullminp/fullmaxp to effective mapgen limits.
+local numcmax = math.max(math.floor((mapgen_limit_max - ccfmax) / mcl_vars.chunk_size_in_nodes), 0) -- fullminp/fullmaxp to effective mapgen limits.
-mcl_vars.mapgen_edge_min = central_chunk_min_pos - numcmin * chunk_size_in_nodes
+mcl_vars.mapgen_edge_min = central_chunk_min_pos - numcmin * mcl_vars.chunk_size_in_nodes
-mcl_vars.mapgen_edge_max = central_chunk_max_pos + numcmax * chunk_size_in_nodes
+mcl_vars.mapgen_edge_max = central_chunk_max_pos + numcmax * mcl_vars.chunk_size_in_nodes
+
+local function coordinate_to_block(x)
+	return math.floor(x / mcl_vars.MAP_BLOCKSIZE)
+end
+
+local function coordinate_to_chunk(x)
+	return math.floor((coordinate_to_block(x) - central_chunk_offset) / mcl_vars.chunksize)
+end
+
+function mcl_vars.pos_to_block(pos)
+	return {
+		x = coordinate_to_block(pos.x),
+		y = coordinate_to_block(pos.y),
+		z = coordinate_to_block(pos.z)
+	}
+end
+
+function mcl_vars.pos_to_chunk(pos)
+	return {
+		x = coordinate_to_chunk(pos.x),
+		y = coordinate_to_chunk(pos.y),
+		z = coordinate_to_chunk(pos.z)
+	}
+end
+
+local k_positive = math.ceil(mcl_vars.MAX_MAP_GENERATION_LIMIT / mcl_vars.chunk_size_in_nodes)
+local k_positive_z = k_positive * 2
+local k_positive_y = k_positive_z * k_positive_z
+
+function mcl_vars.get_chunk_number(pos) -- unsigned int
+	local c = mcl_vars.pos_to_chunk(pos)
+	return
+		(c.y + k_positive) * k_positive_y +
+		(c.z + k_positive) * k_positive_z +
+		 c.x + k_positive
+end
 
 if not superflat and not singlenode then
 	-- Normal mode
@@ -91,7 +131,7 @@ else
 	mcl_vars.mg_bedrock_is_rough = false
 end
 
-mcl_vars.mg_overworld_max = 31000
+mcl_vars.mg_overworld_max = mcl_vars.mapgen_edge_max
 
 -- The Nether (around Y = -29000)
 mcl_vars.mg_nether_min = -29067 -- Carefully chosen to be at a mapchunk border
@@ -138,3 +178,86 @@ minetest.craftitemdef_default.stack_max = 64
 -- Set random seed for all other mods (Remember to make sure no other mod calls this function)
 math.randomseed(os.time())
 
+local chunks = {} -- intervals of chunks generated
+function mcl_vars.add_chunk(pos)
+	local n = mcl_vars.get_chunk_number(pos) -- unsigned int
+	local prev
+	for i, d in pairs(chunks) do
+		if n <= d[2] then -- we've found it
+			if (n == d[2]) or (n >= d[1]) then return end -- already here
+			if n == d[1]-1 then -- right before:
+				if prev and (prev[2] == n-1) then
+					prev[2] = d[2]
+					table.remove(chunks, i)
+					return
+				end
+				d[1] = n
+				return
+			end
+			if prev and (prev[2] == n-1) then --join to previous
+				prev[2] = n
+				return
+			end
+			table.insert(chunks, i, {n, n}) -- insert new interval before i
+			return
+		end
+		prev = d
+	end
+	chunks[#chunks+1] = {n, n}
+end
+function mcl_vars.is_generated(pos)
+	local n = mcl_vars.get_chunk_number(pos) -- unsigned int
+	for i, d in pairs(chunks) do
+		if n <= d[2] then
+			return (n >= d[1])
+		end
+	end
+	return false
+end
+
+-- "Trivial" (actually NOT) function to just read the node and some stuff to not just return "ignore", like mt 5.4 does.
+-- p: Position, if it's wrong, {name="error"} node will return.
+-- force: optional (default: false) - Do the maximum to still read the node within us_timeout.
+-- us_timeout: optional (default: 244 = 0.000244 s = 1/80/80/80), set it at least to 3000000 to let mapgen to finish its job.
+--
+-- returns node definition, eg. {name="air"}. Unfortunately still can return {name="ignore"}.
+function mcl_vars.get_node(p, force, us_timeout)
+	-- check initial circumstances
+	if not p or not p.x or not p.y or not p.z then return {name="error"} end
+
+	-- try common way
+	local node = minetest.get_node(p)
+	if node.name ~= "ignore" then
+		return node
+	end
+
+	-- copy table to get sure it won't changed by other threads
+	local pos = {x=p.x,y=p.y,z=p.z}
+
+	-- try LVM
+	minetest.get_voxel_manip():read_from_map(pos, pos)
+	node = minetest.get_node(pos)
+	if node.name ~= "ignore" or not force then
+		return node
+	end
+
+	-- all ways failed - need to emerge (or forceload if generated)
+	local us_timeout = us_timeout or 244
+	if mcl_vars.is_generated(pos) then
+		minetest.chat_send_all("IMPOSSIBLE! Please report this to MCL2 issue tracker!")
+		minetest.forceload_block(pos)
+	else
+		minetest.emerge_area(pos, pos)
+	end
+
+	local t = minetest.get_us_time()
+
+	node = minetest.get_node(pos)
+
+	while (not node or node.name == "ignore") and (minetest.get_us_time() - t < us_timeout) do
+		node = minetest.get_node(pos)
+	end
+
+	return node
+	-- it still can return "ignore", LOL, even if force = true, but only after time out
+end

mods/CORE/mcl_init/mod.conf

@@ -1 +1,3 @@
 name = mcl_init
+author = Wuzzy
+description = Initialization mod of MineClone 2. Defines some common shared variables and sets up initial default settings which have to be set at the beginning.

mods/CORE/mcl_loot/description.txt

@@ -1 +0,0 @@
-API for filling a chest with random treasures.

mods/CORE/mcl_loot/init.lua

@@ -40,10 +40,9 @@ function mcl_loot.get_loot(loot_definitions, pr)
 		total_weight = total_weight + (loot_definitions.items[i].weight or 1)
 	end
 
-	local stacks_min = loot_definitions.stacks_min
+	--local stacks_min = loot_definitions.stacks_min or 1
-	local stacks_max = loot_definitions.stacks_max
+	--local stacks_max = loot_definitions.stacks_max or 1
-	if not stacks_min then stacks_min = 1 end
+
-	if not stacks_max then stacks_max = 1 end
 	local stacks = pr:next(loot_definitions.stacks_min, loot_definitions.stacks_max)
 	for s=1, stacks do
 		local r = pr:next(1, total_weight)
@@ -111,14 +110,14 @@ end
 Returns a table of length `max_slot` and all natural numbers between 1 and `max_slot`
 in a random order.
 ]]
-local function get_random_slots(max_slot)
+local function get_random_slots(max_slot, pr)
 	local slots = {}
 	for s=1, max_slot do
 		slots[s] = s
 	end
 	local slots_out = {}
 	while #slots > 0 do
-		local r = math.random(1, #slots)
+		local r = pr and pr:next(1, #slots) or math.random(1, #slots)
 		table.insert(slots_out, slots[r])
 		table.remove(slots, r)
 	end
@@ -135,9 +134,9 @@ Items will be added from start of the table to end.
 If the inventory already has occupied slots, or is
 too small, placement of some items might fail.
 ]]
-function mcl_loot.fill_inventory(inv, listname, items)
+function mcl_loot.fill_inventory(inv, listname, items, pr)
 	local size = inv:get_size(listname)
-	local slots = get_random_slots(size)
+	local slots = get_random_slots(size, pr)
 	local leftovers = {}
 	-- 1st pass: Add items into random slots
 	for i=1, math.min(#items, size) do

mods/CORE/mcl_loot/mod.conf

@@ -1 +1,3 @@
 name = mcl_loot
+author = Wuzzy
+description = API for filling a chest with random treasures.

mods/CORE/mcl_particles/description.txt

@@ -1 +0,0 @@
-Contains particle images of MineClone 2. No code.

mods/CORE/mcl_particles/init.lua

@@ -1,3 +1,12 @@
+local vector = vector
+local table = table
+
+local hash_node_position = minetest.hash_node_position
+local add_particlespawner = minetest.add_particlespawner
+local delete_particlespawner = minetest.delete_particlespawner
+
+local ipairs = ipairs
+
 mcl_particles = {}
 
 -- Table of particlespawner IDs on a per-node hash basis
@@ -32,11 +41,11 @@ function mcl_particles.add_node_particlespawner(pos, particlespawner_definition,
 	if allowed_level == 0 or levels[level] > allowed_level then
 		return
 	end
-	local poshash = minetest.hash_node_position(pos)
+	local poshash = hash_node_position(pos)
 	if not poshash then
 		return
 	end
-	local id = minetest.add_particlespawner(particlespawner_definition)
+	local id = add_particlespawner(particlespawner_definition)
 	if id == -1 then
 		return
 	end
@@ -47,6 +56,8 @@ function mcl_particles.add_node_particlespawner(pos, particlespawner_definition,
 	return id
 end
 
+local add_node_particlespawner = mcl_particles.add_node_particlespawner
+
 -- Deletes all particlespawners that are assigned to a node position.
 -- If no particlespawners exist for this position, nothing happens.
 -- pos: Node positon. MUST use integer values!
@@ -55,14 +66,66 @@ function mcl_particles.delete_node_particlespawners(pos)
 	if allowed_level == 0 then
 		return false
 	end
-	local poshash = minetest.hash_node_position(pos)
+	local poshash = hash_node_position(pos)
 	local ids = particle_nodes[poshash]
 	if ids then
 		for i=1, #ids do
-			minetest.delete_particlespawner(ids[i])
+			delete_particlespawner(ids[i])
 		end
 		particle_nodes[poshash] = nil
 		return true
 	end
 	return false
 end
+
+-- 3 exptime variants because the animation is not tied to particle expiration time.
+-- 3 colorized variants to imitate minecraft's
+local smoke_pdef_cached = {}
+
+function mcl_particles.spawn_smoke(pos, name, smoke_pdef_base)
+	local new_minpos = vector.add(pos, smoke_pdef_base.minrelpos)
+	local new_maxpos = vector.add(pos, smoke_pdef_base.maxrelpos)
+
+	-- populate the cache
+	if smoke_pdef_cached[name] then
+		for i, smoke_pdef in ipairs(smoke_pdef_cached[name]) do
+			smoke_pdef.minpos = new_minpos
+			smoke_pdef.maxpos = new_maxpos
+			add_node_particlespawner(pos, smoke_pdef, "high")
+		end
+		-- cache already populated
+	else
+		smoke_pdef_cached[name] = {}
+
+		local smoke_pdef = table.copy(smoke_pdef_base)
+		smoke_pdef.amount = smoke_pdef_base.amount / 9
+		smoke_pdef.time = 0
+		smoke_pdef.animation = {
+			type = "vertical_frames",
+			aspect_w = 8,
+			aspect_h = 8,
+			-- length = 3 exptime variants
+		}
+		smoke_pdef.collisiondetection = true
+		smoke_pdef.minpos = new_minpos
+		smoke_pdef.maxpos = new_maxpos
+
+		-- the last frame plays for 1/8 * N seconds, so we can take advantage of it
+		-- to have varying exptime for each variant.
+		local exptimes = { 0.175, 0.375, 1.0 }
+		local colorizes = { "199", "209", "243" } -- round(78%, 82%, 90% of 256) - 1
+
+		for _,exptime in ipairs(exptimes) do
+			for _,colorize in ipairs(colorizes) do
+				smoke_pdef.maxexptime = exptime * smoke_pdef_base.maxexptime
+				smoke_pdef.animation.length = exptime + 0.1
+				-- minexptime must be set such that the last frame is actully rendered,
+				-- even if its very short. Larger exptime -> larger range
+				smoke_pdef.minexptime = math.min(exptime, (7.0/8.0 * (exptime + 0.1) + 0.1))
+				smoke_pdef.texture = "mcl_particles_smoke_anim.png^[colorize:#000000:" ..colorize
+				add_node_particlespawner(pos, smoke_pdef, "high")
+				table.insert(smoke_pdef_cached[name], table.copy(smoke_pdef))
+			end
+		end
+	end
+end

mods/CORE/mcl_particles/mod.conf

@@ -1 +1,3 @@
 name = mcl_particles
+author = Wuzzy
+description = Contains particle images of MineClone 2. No code.

mods/CORE/mcl_sounds/description.txt

@@ -1 +0,0 @@
-This mod contains the core sounds of MineClone 2 as well as helper function for mods to access them.

mods/CORE/mcl_sounds/mod.conf

@@ -1 +1,3 @@
 name = mcl_sounds
+author = Wuzzy
+description = This mod contains the core sounds of MineClone 2 as well as helper function for mods to access them.

mods/CORE/mcl_util/depends.txt

@@ -1 +0,0 @@
-mcl_init

mods/CORE/mcl_util/description.txt

@@ -1 +0,0 @@
-Helper functions for MineClone 2.

mods/CORE/mcl_util/init.lua

@@ -150,7 +150,7 @@ function mcl_util.get_eligible_transfer_item_slot(src_inventory, src_list, dst_i
 end
 
 -- Returns true if itemstack is a shulker box
-local is_not_shulker_box = function(itemstack)
+local function is_not_shulker_box(itemstack)
 	local g = minetest.get_item_group(itemstack:get_name(), "shulker_box")
 	return g == 0 or g == nil
 end
@@ -212,7 +212,7 @@ function mcl_util.move_item_container(source_pos, destination_pos, source_list,
 	end
 
 	-- Normalize double container by forcing to always use the left segment first
-	local normalize_double_container = function(pos, node, ctype)
+	local function normalize_double_container(pos, node, ctype)
 		if ctype == 6 then
 			pos = mcl_util.get_double_container_neighbor_pos(pos, node.param2, "right")
 			if not pos then
@@ -406,52 +406,144 @@ function mcl_util.get_object_center(obj)
 	return pos
 end
 
-local get_node_emerge_queue = {}
+function mcl_util.get_color(colorstr)
-local function ecb_get_far_node(blockpos, action, calls_remaining, param)
+	local mc_color = mcl_colors[colorstr:upper()]
-	if calls_remaining <= 0 and param then
+	if mc_color then
-		minetest.log("verbose","[mcl_util] ecb done for param = "..param.." node.name="..minetest.get_node(minetest.string_to_pos(param)).name)
+		colorstr = mc_color
-		get_node_emerge_queue[param] = nil
+	elseif #colorstr ~= 7 or colorstr:sub(1, 1) ~= "#" then
+		return
+	end
+	local hex = tonumber(colorstr:sub(2, 7), 16)
+	if hex then
+		return colorstr, hex
 	end
 end
 
-function mcl_util.get_far_node(pos, force)
+function mcl_util.call_on_rightclick(itemstack, player, pointed_thing)
-	local node = minetest.get_node(pos)
+	-- Call on_rightclick if the pointed node defines it
-	if node.name ~= "ignore" then
+	if pointed_thing and pointed_thing.type == "node" then
-		return node
+		local pos = pointed_thing.under
-	end
+		local node = minetest.get_node(pos)
-
+		if player and not player:get_player_control().sneak then
-	minetest.get_voxel_manip():read_from_map(pos, pos)
+			local nodedef = minetest.registered_nodes[node.name]
-	node = minetest.get_node(pos)
+			local on_rightclick = nodedef and nodedef.on_rightclick
-	if node.name ~= "ignore" or not force then
+			if on_rightclick then
-		return node
+				return on_rightclick(pos, node, player, itemstack, pointed_thing) or itemstack
-	end
+			end
-
-	local blockpos = vector.multiply(vector.floor(vector.divide(pos, mcl_vars.MAP_BLOCKSIZE)), mcl_vars.MAP_BLOCKSIZE)
-	local key = minetest.pos_to_string(blockpos)
-
-	for i=1,2 do -- give engine 2 chances to emerge the data
-		if not get_node_emerge_queue[key] then
-			get_node_emerge_queue[key] = 1
-			minetest.log("verbose","[mcl_util] emerge during get_far_node("..minetest.pos_to_string(pos).."), key="..key..", blockpos="..minetest.pos_to_string(blockpos))
-			minetest.emerge_area(blockpos, vector.add(blockpos, mcl_vars.MAP_BLOCKSIZE-1), ecb_get_far_node, key)
-		end
-
-		while not get_node_emerge_queue[key] do end
-		minetest.log("verbose","[mcl_util] emerge finished for node "..minetest.pos_to_string(pos)..", key="..key..", blockpos="..minetest.pos_to_string(blockpos)..", node.name="..mcl_util.get_far_node(pos).name)
-
-		node = minetest.get_node(pos)
-		if node.name ~= "ignore" then
-			return node
-		end
-
-		minetest.get_voxel_manip():read_from_map(pos, pos)
-		node = minetest.get_node(pos)
-		if node.name ~= "ignore" or not force then
-			return node
 		end
 	end
-
+end
-	node.name = "air" -- engine continuously returns "ignore" - probably it is a bug
+
-	minetest.swap_node(pos, node) -- engine continuously returns "ignore" - probably it is a bug
+function mcl_util.calculate_durability(itemstack)
-	return node -- engine continuously returns "ignore" - probably it is a bug
+	local unbreaking_level = mcl_enchanting.get_enchantment(itemstack, "unbreaking")
+	local armor_uses = minetest.get_item_group(itemstack:get_name(), "mcl_armor_uses")
+
+	local uses
+
+	if armor_uses > 0 then
+		uses = armor_uses
+		if unbreaking_level > 0 then
+			uses = uses / (0.6 + 0.4 / (unbreaking_level + 1))
+		end
+	else
+		local def = itemstack:get_definition()
+		if def then
+			local fixed_uses = def._mcl_uses
+			if fixed_uses then
+				uses = fixed_uses
+				if unbreaking_level > 0 then
+					uses = uses * (unbreaking_level + 1)
+				end
+			end
+		end
+		uses = uses or (next(itemstack:get_tool_capabilities().groupcaps) or {}).uses
+	end
+
+	return uses or 0
+end
+
+function mcl_util.use_item_durability(itemstack, n)
+	local uses = mcl_util.calculate_durability(itemstack)
+	itemstack:add_wear(65535 / uses * n)
+end
+
+function mcl_util.deal_damage(target, damage, mcl_reason)
+	local luaentity = target:get_luaentity()
+
+	if luaentity then
+		if luaentity.deal_damage then
+			luaentity:deal_damage(damage, mcl_reason or {type = "generic"})
+			return
+		elseif luaentity._cmi_is_mob then
+			-- local puncher = mcl_reason and mcl_reason.direct or target
+			-- target:punch(puncher, 1.0, {full_punch_interval = 1.0, damage_groups = {fleshy = damage}}, vector.direction(puncher:get_pos(), target:get_pos()), damage)
+			if luaentity.health > 0 then
+				luaentity.health = luaentity.health - damage
+			end
+			return
+		end
+	end
+
+	local hp = target:get_hp()
+
+	if hp > 0 then
+		target:set_hp(hp - damage, {_mcl_reason = mcl_reason})
+	end
+end
+
+function mcl_util.get_hp(obj)
+	local luaentity = obj:get_luaentity()
+
+	if luaentity and luaentity._cmi_is_mob then
+		return luaentity.health
+	else
+		return obj:get_hp()
+	end
+end
+
+function mcl_util.get_inventory(object, create)
+	if object:is_player() then
+		return object:get_inventory()
+	else
+		local luaentity = object:get_luaentity()
+		local inventory = luaentity.inventory
+
+		if create and not inventory and luaentity.create_inventory then
+			inventory = luaentity:create_inventory()
+		end
+
+		return inventory
+	end
+end
+
+function mcl_util.get_wielded_item(object)
+	if object:is_player() then
+		return object:get_wielded_item()
+	else
+		-- ToDo: implement getting wielditems from mobs as soon as mobs have wielditems
+		return ItemStack()
+	end
+end
+
+function mcl_util.get_object_name(object)
+	if object:is_player() then
+		return object:get_player_name()
+	else
+		local luaentity = object:get_luaentity()
+
+		if not luaentity then
+			return tostring(object)
+		end
+
+		return luaentity.nametag and luaentity.nametag ~= "" and luaentity.nametag or luaentity.description or luaentity.name
+	end
+end
+
+function mcl_util.replace_mob(obj, mob)
+	local rot = obj:get_yaw()
+	local pos = obj:get_pos()
+	obj:remove()
+	obj = minetest.add_entity(pos, mob)
+	obj:set_yaw(rot)
+	return obj
 end

mods/CORE/mcl_util/mod.conf

@@ -1 +1,4 @@
 name = mcl_util
+author = Wuzzy
+description = Helper functions for MineClone 2.
+depends = mcl_init

mods/CORE/mcl_worlds/API.md

@@ -0,0 +1,81 @@
+# mcl_worlds
+This mod provides utility functions about positions and dimensions.
+
+## mcl_worlds.is_in_void(pos)
+This function returns:
+
+* true, true: if pos is in deep void (deadly)
+* true, false: if the pos is in void (non deadly)
+* false, false: owerwise
+
+Params:
+
+* pos: position
+
+## mcl_worlds.y_to_layer(y)
+This function is used to calculate the minetest y layer and dimension of the given <y> minecraft layer.
+Mainly used for ore generation.
+Takes an Y coordinate as input and returns:
+
+* The corresponding Minecraft layer (can be nil if void)
+* The corresponding Minecraft dimension ("overworld", "nether" or "end") or "void" if <y> is in the void
+If the Y coordinate is not located in any dimension, it will return: nil, "void"
+
+Params:
+
+* y: int
+
+## mcl_worlds.pos_to_dimension(pos)
+This function return the Minecraft dimension of <pos> ("overworld", "nether" or "end") or "void" if <y> is in the void.
+
+* pos: position
+
+## mcl_worlds.layer_to_y(layer, mc_dimension)
+Takes a Minecraft layer and a “dimension” name and returns the corresponding Y coordinate for MineClone 2.
+mc_dimension can be "overworld", "nether", "end" (default: "overworld").
+
+* layer: int
+* mc_dimension: string
+
+## mcl_worlds.has_weather(pos)
+Returns true if <pos> can have weather, false owerwise.
+Weather can be only in the overworld.
+
+* pos: position
+
+## mcl_worlds.has_dust(pos)
+Returns true if <pos> can have nether dust, false owerwise.
+Nether dust can be only in the nether.
+
+* pos: position
+
+## mcl_worlds.compass_works(pos)
+Returns true if compasses are working at <pos>, false owerwise.
+In mc, you cant use compass in the nether and the end.
+
+* pos: position
+
+## mcl_worlds.compass_works(pos)
+Returns true if clock are working at <pos>, false owerwise.
+In mc, you cant use clock in the nether and the end.
+
+* pos: position
+
+## mcl_worlds.register_on_dimension_change(function(player, dimension, last_dimension))
+Register a callback function func(player, dimension).
+It will be called whenever a player changes between dimensions.
+The void counts as dimension.
+
+* player: player, the player who changed of dimension
+* dimension: string, The new dimension of the player ("overworld", "nether", "end", "void").
+* last_dimension: string, The dimension where the player was ("overworld", "nether", "end", "void").
+
+
+## mcl_worlds.registered_on_dimension_change
+Table containing all function registered with mcl_worlds.register_on_dimension_change()
+
+## mcl_worlds.dimension_change(player, dimension)
+Notify this mod of a dimension change of <player> to <dimension>
+
+* player: player, player who changed the dimension
+* dimension: string, new dimension ("overworld", "nether", "end", "void")

mods/CORE/mcl_worlds/depends.txt

@@ -1 +0,0 @@
-mcl_init

mods/CORE/mcl_worlds/description.txt

@@ -1 +0,0 @@
-Utility functions for worlds and the “dimensions”.

mods/CORE/mcl_worlds/init.lua

@@ -1,12 +1,14 @@
 mcl_worlds = {}
 
+local get_connected_players = minetest.get_connected_players
+
 -- For a given position, returns a 2-tuple:
 -- 1st return value: true if pos is in void
 -- 2nd return value: true if it is in the deadly part of the void
 function mcl_worlds.is_in_void(pos)
 	local void =
 		not ((pos.y < mcl_vars.mg_overworld_max and pos.y > mcl_vars.mg_overworld_min) or
-		(pos.y < mcl_vars.mg_nether_max and pos.y > mcl_vars.mg_nether_min) or
+		(pos.y < mcl_vars.mg_nether_max+128 and pos.y > mcl_vars.mg_nether_min) or
 		(pos.y < mcl_vars.mg_end_max and pos.y > mcl_vars.mg_end_min))
 
 	local void_deadly = false
@@ -15,11 +17,11 @@ function mcl_worlds.is_in_void(pos)
 		-- Overworld → Void → End → Void → Nether → Void
 		if pos.y < mcl_vars.mg_overworld_min and pos.y > mcl_vars.mg_end_max then
 			void_deadly = pos.y < mcl_vars.mg_overworld_min - deadly_tolerance
-		elseif pos.y < mcl_vars.mg_end_min and pos.y > mcl_vars.mg_nether_max then
+		elseif pos.y < mcl_vars.mg_end_min and pos.y > mcl_vars.mg_nether_max+128 then
 			-- The void between End and Nether. Like usual, but here, the void
 			-- *above* the Nether also has a small tolerance area, so player
 			-- can fly above the Nether without getting hurt instantly.
-			void_deadly = (pos.y < mcl_vars.mg_end_min - deadly_tolerance) and (pos.y > mcl_vars.mg_nether_max + deadly_tolerance)
+			void_deadly = (pos.y < mcl_vars.mg_end_min - deadly_tolerance) and (pos.y > mcl_vars.mg_nether_max+128 + deadly_tolerance)
 		elseif pos.y < mcl_vars.mg_nether_min then
 			void_deadly = pos.y < mcl_vars.mg_nether_min - deadly_tolerance
 		end
@@ -33,60 +35,64 @@ end
 -- If the Y coordinate is not located in any dimension, it will return:
 --     nil, "void"
 function mcl_worlds.y_to_layer(y)
-       if y >= mcl_vars.mg_overworld_min then
+	if y >= mcl_vars.mg_overworld_min then
-               return y - mcl_vars.mg_overworld_min, "overworld"
+		return y - mcl_vars.mg_overworld_min, "overworld"
-       elseif y >= mcl_vars.mg_nether_min and y <= mcl_vars.mg_nether_max then
+	elseif y >= mcl_vars.mg_nether_min and y <= mcl_vars.mg_nether_max+128 then
-               return y - mcl_vars.mg_nether_min, "nether"
+		return y - mcl_vars.mg_nether_min, "nether"
-       elseif y >= mcl_vars.mg_end_min and y <= mcl_vars.mg_end_max then
+	elseif y >= mcl_vars.mg_end_min and y <= mcl_vars.mg_end_max then
-               return y - mcl_vars.mg_end_min, "end"
+		return y - mcl_vars.mg_end_min, "end"
-       else
+	else
-               return nil, "void"
+		return nil, "void"
-       end
+	end
 end
 
+local y_to_layer = mcl_worlds.y_to_layer
+
 -- Takes a pos and returns the dimension it belongs to (same as above)
 function mcl_worlds.pos_to_dimension(pos)
-	local _, dim = mcl_worlds.y_to_layer(pos.y)
+	local _, dim = y_to_layer(pos.y)
 	return dim
 end
 
+local pos_to_dimension = mcl_worlds.pos_to_dimension
+
 -- Takes a Minecraft layer and a “dimension” name
 -- and returns the corresponding Y coordinate for
 -- MineClone 2.
 -- mc_dimension is one of "overworld", "nether", "end" (default: "overworld").
 function mcl_worlds.layer_to_y(layer, mc_dimension)
-       if mc_dimension == "overworld" or mc_dimension == nil then
+	   if mc_dimension == "overworld" or mc_dimension == nil then
-               return layer + mcl_vars.mg_overworld_min
+			   return layer + mcl_vars.mg_overworld_min
-       elseif mc_dimension == "nether" then
+	   elseif mc_dimension == "nether" then
-               return layer + mcl_vars.mg_nether_min
+			   return layer + mcl_vars.mg_nether_min
-       elseif mc_dimension == "end" then
+	   elseif mc_dimension == "end" then
-               return layer + mcl_vars.mg_end_min
+			   return layer + mcl_vars.mg_end_min
-       end
+	   end
 end
 
 -- Takes a position and returns true if this position can have weather
 function mcl_worlds.has_weather(pos)
-       -- Weather in the Overworld and the high part of the void below
+	-- Weather in the Overworld and the high part of the void below
-       return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64
+	return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64
 end
 
 -- Takes a position and returns true if this position can have Nether dust
 function mcl_worlds.has_dust(pos)
-       -- Weather in the Overworld and the high part of the void below
+	-- Weather in the Overworld and the high part of the void below
-       return pos.y <= mcl_vars.mg_nether_max + 64 and pos.y >= mcl_vars.mg_nether_min - 64
+	return pos.y <= mcl_vars.mg_nether_max + 138 and pos.y >= mcl_vars.mg_nether_min - 10
 end
 
 -- Takes a position (pos) and returns true if compasses are working here
 function mcl_worlds.compass_works(pos)
-       -- It doesn't work in Nether and the End, but it works in the Overworld and in the high part of the void below
+	-- It doesn't work in Nether and the End, but it works in the Overworld and in the high part of the void below
-       local _, dim = mcl_worlds.y_to_layer(pos.y)
+	local _, dim = mcl_worlds.y_to_layer(pos.y)
-       if dim == "nether" or dim == "end" then
+	if dim == "nether" or dim == "end" then
-               return false
+		return false
-       elseif dim == "void" then
+	elseif dim == "void" then
-               return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64
+		return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64
-       else
+	else
-               return true
+		return true
-       end
+	end
 end
 
 -- Takes a position (pos) and returns true if clocks are working here
@@ -112,12 +118,15 @@ local last_dimension = {}
 -- * player: Player who changed the dimension
 -- * dimension: New dimension ("overworld", "nether", "end", "void")
 function mcl_worlds.dimension_change(player, dimension)
+	local playername = player:get_player_name()
 	for i=1, #mcl_worlds.registered_on_dimension_change do
-		mcl_worlds.registered_on_dimension_change[i](player, dimension)
+		mcl_worlds.registered_on_dimension_change[i](player, dimension, last_dimension[playername])
-		last_dimension[player:get_player_name()] = dimension
 	end
+	last_dimension[playername] = dimension
 end
 
+local dimension_change = mcl_worlds.dimension_change
+
 ----------------------- INTERNAL STUFF ----------------------
 
 -- Update the dimension callbacks every DIM_UPDATE seconds
@@ -125,19 +134,19 @@ local DIM_UPDATE = 1
 local dimtimer = 0
 
 minetest.register_on_joinplayer(function(player)
-	last_dimension[player:get_player_name()] = mcl_worlds.pos_to_dimension(player:get_pos())
+	last_dimension[player:get_player_name()] = pos_to_dimension(player:get_pos())
 end)
 
 minetest.register_globalstep(function(dtime)
 	-- regular updates based on iterval
 	dimtimer = dimtimer + dtime;
 	if dimtimer >= DIM_UPDATE then
-		local players = minetest.get_connected_players()
+		local players = get_connected_players()
-		for p=1, #players do
+		for p = 1, #players do
-			local dim = mcl_worlds.pos_to_dimension(players[p]:get_pos())
+			local dim = pos_to_dimension(players[p]:get_pos())
 			local name = players[p]:get_player_name()
 			if dim ~= last_dimension[name] then
-				mcl_worlds.dimension_change(players[p], dim)
+				dimension_change(players[p], dim)
 			end
 		end
 		dimtimer = 0

mods/CORE/mcl_worlds/mod.conf

@@ -0,0 +1,5 @@
+name = mcl_worlds
+author = Wuzzy
+description = Utility functions for worlds and the “dimensions”.
+depends = mcl_init
+ 

mods/CORE/tga_encoder/README.md

@@ -0,0 +1,4 @@
+# tga_encoder
+A TGA Encoder written in Lua without the use of external Libraries.
+
+May be used as a Minetest mod.

mods/CORE/tga_encoder/init.lua

@@ -0,0 +1,78 @@
+tga_encoder = {}
+
+local image = setmetatable({}, {
+	__call = function(self, ...)
+		local t = setmetatable({}, {__index = self})
+		t:constructor(...)
+		return t
+	end,
+})
+
+function image:constructor(pixels)
+	self.data = ""
+	self.pixels = pixels
+	self.width = #pixels[1]
+	self.height = #pixels
+
+	self:encode()
+end
+
+function image:encode_colormap_spec()
+	self.data = self.data
+		.. string.char(0, 0) -- first entry index
+		.. string.char(0, 0) -- number of entries
+		.. string.char(0) -- bits per pixel
+end
+
+function image:encode_image_spec()
+	self.data = self.data
+		.. string.char(0, 0) -- X-origin
+		.. string.char(0, 0) -- Y-origin
+		.. string.char(self.width  % 256, math.floor(self.width  / 256)) -- width
+		.. string.char(self.height % 256, math.floor(self.height / 256)) -- height
+		.. string.char(24) -- pixel depth (RGB = 3 bytes = 24 bits)
+		.. string.char(0) -- image descriptor
+end
+
+function image:encode_header()
+	self.data = self.data
+		.. string.char(0) -- image id
+		.. string.char(0) -- color map type
+		.. string.char(2) -- image type (uncompressed true-color image = 2)
+	self:encode_colormap_spec() -- color map specification
+	self:encode_image_spec() -- image specification
+end
+
+function image:encode_data()
+	for _, row in ipairs(self.pixels) do
+		for _, pixel in ipairs(row) do
+			self.data = self.data
+				.. string.char(pixel[3], pixel[2], pixel[1])
+		end
+	end
+end
+
+function image:encode_footer()
+	self.data = self.data
+		.. string.char(0, 0, 0, 0) -- extension area offset
+		.. string.char(0, 0, 0, 0) -- developer area offset
+		.. "TRUEVISION-XFILE"
+		.. "."
+		.. string.char(0)
+end
+
+function image:encode()
+	self:encode_header() -- header
+	-- no color map and image id data
+	self:encode_data() -- encode data
+	-- no extension or developer area
+	self:encode_footer() -- footer
+end
+
+function image:save(filename)
+	local f = assert(io.open(filename, "w"))
+	f:write(self.data)
+	f:close()
+end
+
+tga_encoder.image = image

mods/CORE/tga_encoder/mod.conf

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

mods/CORE/walkover/init.lua

@@ -1,4 +1,11 @@
 -- register extra flavours of a base nodedef
+
+local get_connected_players = minetest.get_connected_players
+local get_node = minetest.get_node
+local vector_add = vector.add
+local ceil = math.ceil
+local pairs = pairs
+
 walkover = {}
 walkover.registered_globals = {}
 
@@ -6,30 +13,40 @@ function walkover.register_global(func)
 	table.insert(walkover.registered_globals, func)
 end
 
+local on_walk = {}
+local registered_globals = {}
+
+minetest.register_on_mods_loaded(function()
+	for name,def in pairs(minetest.registered_nodes) do
+		if def.on_walk_over then
+			on_walk[name] = def.on_walk_over
+		end
+	end
+	for _,func in ipairs(walkover.registered_globals) do --cache registered globals
+		table.insert(registered_globals, func)
+	end
+end)
+
 local timer = 0
 minetest.register_globalstep(function(dtime)
 	timer = timer + dtime;
 	if timer >= 0.3 then
-		for _,player in pairs(minetest.get_connected_players()) do
+		for _,player in pairs(get_connected_players()) do
-	    local pp = player:get_pos()
+		local pp = player:get_pos()
-	    pp.y = math.ceil(pp.y)
+		pp.y = ceil(pp.y)
-            local loc = vector.add(pp, {x=0,y=-1,z=0})
+			local loc = vector_add(pp, {x=0,y=-1,z=0})
-            if loc ~= nil then
+			if loc then
-               
+				local nodeiamon = get_node(loc)
-                local nodeiamon = minetest.get_node(loc)
+				if nodeiamon then
-                
+					if on_walk[nodeiamon.name] then
-                if nodeiamon ~= nil then
+						on_walk[nodeiamon.name](loc, nodeiamon, player)
-                    local def = minetest.registered_nodes[nodeiamon.name]
+					end
-                    if def ~= nil and def.on_walk_over ~= nil then
+					for i = 1, #registered_globals do
-                        def.on_walk_over(loc, nodeiamon, player)
+						registered_globals[i](loc, nodeiamon, player)
-                    end
+					end
-                    for _, func in ipairs(walkover.registered_globals) do
+				end
-						func(loc, nodeiamon, player)
+			end
-                    end
+		end
-                end   
-            end
-        end
-	 
 		timer = 0
 	end
 end)

mods/CORE/walkover/mod.conf

@@ -0,0 +1,4 @@
+name = walkover
+author = lordfingle
+description = Some mode developers have shown an interest in having an `on_walk_over` event. This is useful for pressure-plates and the like.
+

mods/ENTITIES/drippingwater/depends.txt

@@ -1 +0,0 @@
-mcl_core

mods/ENTITIES/drippingwater/init.lua

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

mods/ENTITIES/drippingwater/mod.conf

@@ -0,0 +1,4 @@
+name = drippingwater
+author = kddekadenz 
+description = Drops are generated rarely under solid nodes
+depends = mcl_core

mods/ENTITIES/mcl_boats/README.txt

@@ -20,4 +20,4 @@ Authors include:
 * Various Minetest / Minetest Game developers and contributors (2012-2016)
 * maikerumine (2017)
 * Wuzzy (2017)
-
+* Fleckenstein (2020-2021)

mods/ENTITIES/mcl_boats/depends.txt

@@ -1,3 +0,0 @@
-mcl_player
-mcl_core?
-doc_identifier?

mods/ENTITIES/mcl_boats/description.txt

@@ -1 +0,0 @@
-Adds drivable boats.

mods/ENTITIES/mcl_boats/init.lua

@@ -1,13 +1,22 @@
-local S = minetest.get_translator("mcl_boats")
+local S = minetest.get_translator(minetest.get_current_modname())
---
--- Helper functions
---
 
-local function is_water(pos)
+local boat_visual_size = {x = 1, y = 1, z = 1}
+local paddling_speed = 22
+local boat_y_offset = 0.35
+local boat_y_offset_ground = boat_y_offset + 0.6
+local boat_side_offset = 1.001
+local boat_max_hp = 4
+
+local function is_group(pos, group)
 	local nn = minetest.get_node(pos).name
-	return minetest.get_item_group(nn, "water") ~= 0
+	return minetest.get_item_group(nn, group) ~= 0
 end
 
+local is_water = flowlib.is_water
+
+local function is_ice(pos)
+	return is_group(pos, "ice")
+end
 
 local function get_sign(i)
 	if i == 0 then
@@ -17,64 +26,24 @@ local function get_sign(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
 
-local boat_visual_size = {x = 3, y = 3}
--- Note: This mod assumes the default player visual_size is {x=1, y=1}
-local driver_visual_size = { x = 1/boat_visual_size.x, y = 1/boat_visual_size.y }
-local paddling_speed = 22
-local boat_y_offset = 0.35
-local boat_y_offset_ground = boat_y_offset + 0.6
-local boat_side_offset = 1.001
-
---
--- 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 = "mcl_boats_boat.b3d",
-	textures = {"mcl_boats_texture_oak_boat.png"},
-	visual_size = boat_visual_size,
-	hp_max = 4,
-
-	_driver = nil, -- Attached driver (player) or nil if none
-	_passenger = nil,
-	_v = 0, -- Speed
-	_last_v = 0, -- Temporary speed variable
-	_removed = false, -- If true, boat entity is considered removed (e.g. after punch) and should be ignored
-	_itemstring = "mcl_boats:boat", -- Itemstring of the boat item (implies boat type)
-	_animation = 0, -- 0: not animated; 1: paddling forwards; -1: paddling forwards
-}
-
-local function detach_player(player, change_pos)
-	player:set_detach()
-	player:set_properties({visual_size = {x=1, y=1}})
-	mcl_player.player_attached[player:get_player_name()] = false
-	mcl_player.player_set_animation(player, "stand" , 30)
-	if change_pos then
-		 player:set_pos(vector.add(player:get_pos(), vector.new(0, 0.2, 0)))
-	end
-end
-
 local function check_object(obj)
 	return obj and (obj:is_player() or obj:get_luaentity()) and obj
 end
 
+local function get_visual_size(obj)
+	return obj:is_player() and {x = 1, y = 1, z = 1} or obj:get_luaentity()._old_visual_size or obj:get_properties().visual_size
+end
+
 local function set_attach(boat)
 	boat._driver:set_attach(boat.object, "",
 		{x = 0, y = 0.42, z = -1}, {x = 0, y = 0, z = 0})
@@ -87,59 +56,102 @@ local function set_double_attach(boat)
 		{x = 0, y = 0.42, z = -2.2}, {x = 0, y = 0, z = 0})
 end
 
-minetest.register_on_respawnplayer(detach_player)
+local function attach_object(self, obj)
+	if self._driver then
+		if self._driver:is_player() then
+			self._passenger = obj
+		else
+			self._passenger = self._driver
+			self._driver = obj
+		end
+		set_double_attach(self)
+	else
+		self._driver = obj
+		set_attach(self)
+	end
+
+	local visual_size = get_visual_size(obj)
+	local yaw = self.object:get_yaw()
+	obj:set_properties({visual_size = vector.divide(visual_size, boat_visual_size)})
+
+	if obj:is_player() then
+		local name = obj:get_player_name()
+		mcl_player.player_attached[name] = true
+		minetest.after(0.2, function(name)
+			local player = minetest.get_player_by_name(name)
+			if player then
+				mcl_player.player_set_animation(player, "sit" , 30)
+			end
+		end, name)
+		obj:set_look_horizontal(yaw)
+		mcl_title.set(obj, "actionbar", {text=S("Sneak to dismount"), color="white", stay=60})
+	else
+		obj:get_luaentity()._old_visual_size = visual_size
+	end
+end
+
+local function detach_object(obj, change_pos)
+	obj:set_detach()
+	obj:set_properties({visual_size = get_visual_size(obj)})
+	if obj:is_player() then
+		mcl_player.player_attached[obj:get_player_name()] = false
+		mcl_player.player_set_animation(obj, "stand" , 30)
+	else
+		obj:get_luaentity()._old_visual_size = nil
+	end
+	if change_pos then
+		 obj:set_pos(vector.add(obj:get_pos(), vector.new(0, 0.2, 0)))
+	end
+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 = "mcl_boats_boat.b3d",
+	textures = {"mcl_boats_texture_oak_boat.png"},
+	visual_size = boat_visual_size,
+	hp_max = boat_max_hp,
+	damage_texture_modifier = "^[colorize:white:0",
+
+	_driver = nil, -- Attached driver (player) or nil if none
+	_passenger = nil,
+	_v = 0, -- Speed
+	_last_v = 0, -- Temporary speed variable
+	_removed = false, -- If true, boat entity is considered removed (e.g. after punch) and should be ignored
+	_itemstring = "mcl_boats:boat", -- Itemstring of the boat item (implies boat type)
+	_animation = 0, -- 0: not animated; 1: paddling forwards; -1: paddling forwards
+	_regen_timer = 0,
+	_damage_anim = 0,
+}
+
+minetest.register_on_respawnplayer(detach_object)
 
 function boat.on_rightclick(self, clicker)
 	if self._passenger or not clicker or clicker:get_attach() then
 		return
 	end
-	local name = clicker:get_player_name()
+	attach_object(self, clicker)
-	--[[if attach and attach:get_luaentity() then
-		local luaentity = attach:get_luaentity()
-		if luaentity._driver then
-			luaentity._driver = nil
-		end
-		clicker:set_detach()
-		clicker:set_properties({visual_size = {x=1, y=1}})
-	end--]]
-	if self._driver then
-		if self._driver:is_player() then
-			self._passenger = clicker
-		else
-			-- for later use: transport mobs in boats
-			self._passenger = self._driver
-			self._driver = clicker
-		end
-		set_double_attach(self)
-	else
-		self._driver = clicker
-		set_attach(self)
-	end
-	clicker:set_properties({ visual_size = driver_visual_size })
-	mcl_player.player_attached[name] = true
-	minetest.after(0.2, function(name)
-		local player = minetest.get_player_by_name(name)
-		if player then
-			mcl_player.player_set_animation(player, "sit" , 30)
-		end
-	end, name)
-	clicker:set_look_horizontal(self.object:get_yaw())
-	mcl_tmp_message.message(clicker, S("Sneak to dismount"))
 end
 
 
 function boat.on_activate(self, staticdata, dtime_s)
-	--self.object:set_armor_groups({immortal = 1})
+	self.object:set_armor_groups({fleshy = 100})
 	local data = minetest.deserialize(staticdata)
 	if type(data) == "table" then
 		self._v = data.v
 		self._last_v = self._v
 		self._itemstring = data.itemstring
-		self.object:set_properties({textures = data.textures, damage_texture_modifier = ""})
+		self.object:set_properties({textures = data.textures})
 	end
 end
 
-
 function boat.get_staticdata(self)
 	return minetest.serialize({
 		v = self._v,
@@ -148,8 +160,9 @@ function boat.get_staticdata(self)
 	})
 end
 
-
 function boat.on_death(self, killer)
+	mcl_burning.extinguish(self.object)
+
 	if killer and killer:is_player() and minetest.is_creative_enabled(killer:get_player_name()) then
 		local inv = killer:get_inventory()
 		if not inv:contains_item("main", self._itemstring) then
@@ -159,37 +172,62 @@ function boat.on_death(self, killer)
 		minetest.add_item(self.object:get_pos(), self._itemstring)
 	end
 	if self._driver then
-		detach_player(self._driver)
+		detach_object(self._driver)
 	end
 	if self._passenger then
-		detach_player(self._passenger)
+		detach_object(self._passenger)
 	end
 	self._driver = nil
 	self._passenger = nil
 end
 
+function boat.on_punch(self, puncher, time_from_last_punch, tool_capabilities, dir, damage)
+	if damage > 0 then
+		self._regen_timer = 0
+	end
+end
+
 function boat.on_step(self, dtime, moveresult)
+	mcl_burning.tick(self.object, dtime, self)
+
 	self._v = get_v(self.object:get_velocity()) * get_sign(self._v)
-	local on_water = true
-	local in_water = false
 	local v_factor = 1
 	local v_slowdown = 0.02
 	local p = self.object:get_pos()
-	if (not is_water({x=p.x, y=p.y-boat_y_offset, z=p.z})) then
+	local on_water = true
+	local on_ice = false
+	local in_water = is_water({x=p.x, y=p.y-boat_y_offset+1, z=p.z})
+	local waterp = {x=p.x, y=p.y-boat_y_offset - 0.1, z=p.z}
+	if not is_water(waterp) then
 		on_water = false
-		v_factor = 0.5
+		if not in_water and is_ice(waterp) then
-		v_slowdown = 0.04
+			on_ice = true
-	elseif (is_water({x=p.x, y=p.y-boat_y_offset+1, z=p.z})) then
+		else
+			v_slowdown = 0.04
+			v_factor = 0.5
+		end
+	elseif in_water then
 		on_water = false
 		in_water = true
 		v_factor = 0.75
 		v_slowdown = 0.05
 	end
 
+	local hp = self.object:get_hp()
+	local regen_timer = self._regen_timer + dtime
+	if hp >= boat_max_hp then
+		regen_timer = 0
+	elseif regen_timer >= 0.5 then
+		hp = hp + 1
+		self.object:set_hp(hp)
+		regen_timer = 0
+	end
+	self._regen_timer = regen_timer
+
 	if moveresult and moveresult.collides then
-		for _, collision in ipairs(moveresult.collisions) do
+		for _, collision in pairs(moveresult.collisions) do
 			local pos = collision.node_pos
-			if collision.type == "node" and minetest.get_node_group(minetest.get_node(pos).name, "dig_by_boat") > 0 then
+			if collision.type == "node" and minetest.get_item_group(minetest.get_node(pos).name, "dig_by_boat") > 0 then
 				minetest.dig_node(pos)
 			end
 		end
@@ -207,7 +245,7 @@ function boat.on_step(self, dtime, moveresult)
 		else
 			local ctrl = self._passenger:get_player_control()
 			if ctrl and ctrl.sneak then
-				detach_player(self._passenger, true)
+				detach_object(self._passenger, true)
 				self._passenger = nil
 			end
 		end
@@ -219,7 +257,7 @@ function boat.on_step(self, dtime, moveresult)
 		end
 		local ctrl = self._driver:get_player_control()
 		if ctrl and ctrl.sneak then
-			detach_player(self._driver, true)
+			detach_object(self._driver, true)
 			self._driver = nil
 			return
 		end
@@ -268,11 +306,19 @@ function boat.on_step(self, dtime, moveresult)
 			self.object:set_animation({x=0, y=40}, 0, 0, true)
 			self._animation = 0
 		end
+
+		for _, obj in pairs(minetest.get_objects_inside_radius(self.object:get_pos(), 1.3)) do
+			local entity = obj:get_luaentity()
+			if entity and entity._cmi_is_mob then
+				attach_object(self, obj)
+				break
+			end
+		end
 	end
 	local s = get_sign(self._v)
-	if not on_water and not in_water and math.abs(self._v) > 1.0 then
+	if not on_ice and not on_water and not in_water and math.abs(self._v) > 2.0 then
-		v_slowdown = math.min(math.abs(self._v) - 1.0, v_slowdown * 5)
+		v_slowdown = math.min(math.abs(self._v) - 2.0, v_slowdown * 5)
-	elseif in_water and math.abs(self._v) > 1.5 then
+	elseif not on_ice and in_water and math.abs(self._v) > 1.5 then
 		v_slowdown = math.min(math.abs(self._v) - 1.5, v_slowdown * 5)
 	end
 	self._v = self._v - v_slowdown * s
@@ -282,10 +328,10 @@ function boat.on_step(self, dtime, moveresult)
 
 	p.y = p.y - boat_y_offset
 	local new_velo
-	local new_acce = {x = 0, y = 0, z = 0}
+	local new_acce
-	if not is_water(p) then
+	if not is_water(p) and not on_ice then
 		-- Not on water or inside water: Free fall
-		local nodedef = minetest.registered_nodes[minetest.get_node(p).name]
+		--local nodedef = minetest.registered_nodes[minetest.get_node(p).name]
 		new_acce = {x = 0, y = -9.8, z = 0}
 		new_velo = get_velocity(self._v, self.object:get_yaw(),
 			self.object:get_velocity().y)
@@ -313,12 +359,17 @@ function boat.on_step(self, dtime, moveresult)
 	end
 
 	-- Terminal velocity: 8 m/s per axis of travel
+	local terminal_velocity = on_ice and 57.1 or 8.0
 	for _,axis in pairs({"z","y","x"}) do
-		if math.abs(new_velo[axis]) > 8 then
+		if math.abs(new_velo[axis]) > terminal_velocity then
-			new_velo[axis] = 8 * get_sign(new_velo[axis])
+			new_velo[axis] = terminal_velocity * get_sign(new_velo[axis])
 		end
 	end
 
+	local yaw = self.object:get_yaw()
+	local anim = (boat_max_hp - hp - regen_timer * 2) / boat_max_hp * math.pi / 4
+
+	self.object:set_rotation(vector.new(anim, yaw, anim))
 	self.object:set_velocity(new_velo)
 	self.object:set_acceleration(new_acce)
 end
@@ -343,7 +394,7 @@ for b=1, #boat_ids do
 	if b == 1 then
 		help = true
 		longdesc = S("Boats are used to travel on the surface of water.")
-		usagehelp = S("Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Rightclick the boat again to leave it, punch the boat to make it drop as an item.")
+		usagehelp = S("Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Use [Sneak] to leave the boat, punch the boat to make it drop as an item.")
 		helpname = S("Boat")
 	end
 	tt_help = S("Water vehicle")
@@ -419,6 +470,6 @@ minetest.register_craft({
 	burntime = 20,
 })
 
-if minetest.get_modpath("doc_identifier") ~= nil then
+if minetest.get_modpath("doc_identifier") then
 	doc.sub.identifier.register_object("mcl_boats:boat", "craftitems", "mcl_boats:boat")
 end

mods/ENTITIES/mcl_boats/locale/mcl_boats.de.tr

@@ -6,6 +6,7 @@ Boats are used to travel on the surface of water.=Boote werden benutzt, um sich
 Dark Oak Boat=Schwarzeichenboot
 Jungle Boat=Dschungelboot
 Oak Boat=Eichenboot
-Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Rightclick the boat again to leave it, punch the boat to make it drop as an item.=Rechtsklicken Sie auf eine Wasserquelle, um das Boot zu platzieren. Rechtsklicken Sie auf das Boot, um es zu betreten. Mit [Links] und [Rechts] lenken, mit [Vorwärts] und [Rückwärts] Geschwindigkeit regeln oder rückwärts fahren. Rechtsklicken Sie erneut auf das Boot, um es zu verlassen, schlagen Sie das Boot, um es als Gegenstand fallen zu lassen.
+Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Use [Sneak] to leave the boat, punch the boat to make it drop as an item.=Rechtsklicken Sie auf eine Wasserquelle, um das Boot zu platzieren. Rechtsklicken Sie auf das Boot, um es zu betreten. Mit [Links] und [Rechts] lenken, mit [Vorwärts] und [Rückwärts] Geschwindigkeit regeln oder rückwärts fahren. Nutzen sie [Schleichen], um das Boot zu verlassen, schlagen Sie das Boot, um es als Gegenstand fallen zu lassen.
 Spruce Boat=Fichtenboot
 Water vehicle=Wasserfahrzeug
+Sneak to dismount=Zum Aussteigen schleichen

mods/ENTITIES/mcl_boats/locale/mcl_boats.fr.tr

@@ -6,6 +6,7 @@ Boats are used to travel on the surface of water.=Les bateaux sont utilisés pou
 Dark Oak Boat=Bateau en Chêne Noir
 Jungle Boat=Bateau en Acajou
 Oak Boat=Bateau en Chêne
-Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Rightclick the boat again to leave it, punch the boat to make it drop as an item.=Faites un clic droit sur une source d'eau pour placer le bateau. Faites un clic droit sur le bateau pour y entrer. Utilisez [Gauche] et [Droite] pour diriger, [Avant] pour accélérer et [Arrière] pour ralentir ou reculer. Cliquez de nouveau avec le bouton droit sur le bateau pour le quitter, frappez le bateau pour le faire tomber en tant qu'objet.
+Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Use [Sneak] to leave the boat, punch the boat to make it drop as an item.=Faites un clic droit sur une source d'eau pour placer le bateau. Faites un clic droit sur le bateau pour y entrer. Utilisez [Gauche] et [Droite] pour diriger, [Avant] pour accélérer et [Arrière] pour ralentir ou reculer. Utilisez [Sneak] pour le quitter, frappez le bateau pour le faire tomber en tant qu'objet.
 Spruce Boat=Bateau en Sapin
-Water vehicle=Véhicule aquatique
+Water vehicle=Véhicule aquatique
+Sneak to dismount=

mods/ENTITIES/mcl_boats/locale/mcl_boats.pl.tr

@@ -0,0 +1,12 @@
+# textdomain: mcl_boats
+Acacia Boat=Akacjowa łódź
+Birch Boat=Brzozowa łódź
+Boat=Łódź
+Boats are used to travel on the surface of water.=Łodzie są wykorzystywane do podróżowania po powierzchni wody.
+Dark Oak Boat=Ciemno-dębowa łódź
+Jungle Boat=Tropikalna łódź
+Oak Boat=Dębowa łódź
+Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Use [Sneak] to leave the boat, punch the boat to make it drop as an item.=Kliknij prawym przyciskiem myszy na źródło wody by postawić łódź. Kliknij prawym przyciskiem myszy by w nią wsiąść. Użyj przycisków [Lewy] oraz [Prawy] by sterować, [Naprzód] by przyspieszyć i [W tył] by zwolnić lub się cofać. Kliknij [Skradanie] by z niej wyjść, uderz ją by wziąć ją jako przedmiot.
+Spruce Boat=Świerkowa łódź
+Water vehicle=Pojazd wodny
+Sneak to dismount=Skradaj się by opuścić łódź

mods/ENTITIES/mcl_boats/locale/template.txt

@@ -6,6 +6,7 @@ Boats are used to travel on the surface of water.=
 Dark Oak Boat=
 Jungle Boat=
 Oak Boat=
-Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Rightclick the boat again to leave it, punch the boat to make it drop as an item.=
+Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Use [Sneak] to leave the boat, punch the boat to make it drop as an item.=
 Spruce Boat=
 Water vehicle=
+Sneak to dismount=

mods/ENTITIES/mcl_boats/mod.conf

@@ -1 +1,7 @@
 name = mcl_boats
+author = PilzAdam
+description = Adds drivable boats.
+depends = mcl_player, flowlib, mcl_title
+optional_depends = mcl_core, doc_identifier
+
+

mods/ENTITIES/mcl_burning/api.lua

@@ -0,0 +1,138 @@
+function mcl_burning.get_storage(obj)
+	return obj:is_player() and mcl_burning.storage[obj] or obj:get_luaentity()
+end
+
+function mcl_burning.is_burning(obj)
+	return mcl_burning.get_storage(obj).burn_time
+end
+
+function mcl_burning.is_affected_by_rain(obj)
+	return mcl_weather.get_weather() == "rain" and mcl_weather.is_outdoor(obj:get_pos())
+end
+
+function mcl_burning.get_collisionbox(obj, smaller, storage)
+	local cache = storage.collisionbox_cache
+	if cache then
+		local box = cache[smaller and 2 or 1]
+		return box[1], box[2]
+	else
+		local box = obj:get_properties().collisionbox
+		local minp, maxp = vector.new(box[1], box[2], box[3]), vector.new(box[4], box[5], box[6])
+		local s_vec = vector.new(0.1, 0.1, 0.1)
+		local s_minp = vector.add(minp, s_vec)
+		local s_maxp = vector.subtract(maxp, s_vec)
+		storage.collisionbox_cache = {{minp, maxp}, {s_minp, s_maxp}}
+		return minp, maxp
+	end
+end
+
+function mcl_burning.get_touching_nodes(obj, nodenames, storage)
+	local pos = obj:get_pos()
+	local minp, maxp = mcl_burning.get_collisionbox(obj, true, storage)
+	local nodes = minetest.find_nodes_in_area(vector.add(pos, minp), vector.add(pos, maxp), nodenames)
+	return nodes
+end
+
+function mcl_burning.set_on_fire(obj, burn_time)
+	if obj:get_hp() < 0 then
+		return
+	end
+
+	local storage = mcl_burning.get_storage(obj)
+
+	local luaentity = obj:get_luaentity()
+	if luaentity and luaentity.fire_resistant then
+		return
+	end
+
+	if obj:is_player() and minetest.is_creative_enabled(obj:get_player_name()) then
+		burn_time = 0
+	else
+		local max_fire_prot_lvl = 0
+		local inv = mcl_util.get_inventory(obj)
+		local armor_list = inv and inv:get_list("armor")
+
+		if armor_list then
+			for _, stack in pairs(armor_list) do
+				local fire_prot_lvl = mcl_enchanting.get_enchantment(stack, "fire_protection")
+				if fire_prot_lvl > max_fire_prot_lvl then
+					max_fire_prot_lvl = fire_prot_lvl
+				end
+			end
+		end
+
+		if max_fire_prot_lvl > 0 then
+			burn_time = burn_time - math.floor(burn_time * max_fire_prot_lvl * 0.15)
+		end
+	end
+
+	if not storage.burn_time or burn_time >= storage.burn_time then
+		if obj:is_player() then
+			mcl_burning.channels[obj]:send_all(tostring(mcl_burning.animation_frames))
+			mcl_burning.channels[obj]:send_all("start")
+		end
+		storage.burn_time = burn_time
+		storage.fire_damage_timer = 0
+
+		local fire_entity = minetest.add_entity(obj:get_pos(), "mcl_burning:fire")
+		local minp, maxp = mcl_burning.get_collisionbox(obj, false, storage)
+		local obj_size = obj:get_properties().visual_size
+
+		local vertical_grow_factor = 1.2
+		local horizontal_grow_factor = 1.1
+		local grow_vector = vector.new(horizontal_grow_factor, vertical_grow_factor, horizontal_grow_factor)
+
+		local size = vector.subtract(maxp, minp)
+		size = vector.multiply(size, grow_vector)
+		size = vector.divide(size, obj_size)
+		local offset = vector.new(0, size.y * 10 / 2, 0)
+
+		fire_entity:set_properties({visual_size = size})
+		fire_entity:set_attach(obj, "", offset, {x = 0, y = 0, z = 0})
+		local fire_luaentity = fire_entity:get_luaentity()
+
+		for _, other in pairs(minetest.get_objects_inside_radius(fire_entity:get_pos(), 0)) do
+			local other_luaentity = other:get_luaentity()
+			if other_luaentity and other_luaentity.name == "mcl_burning:fire" and other_luaentity ~= fire_luaentity then
+				other:remove()
+				break
+			end
+		end
+	end
+end
+
+function mcl_burning.extinguish(obj)
+	if mcl_burning.is_burning(obj) then
+		local storage = mcl_burning.get_storage(obj)
+		if obj:is_player() then
+			mcl_burning.channels[obj]:send_all("stop")
+			mcl_burning.storage[obj] = {}
+		else
+			storage.burn_time = nil
+			storage.fire_damage_timer = nil
+		end
+	end
+end
+
+function mcl_burning.tick(obj, dtime, storage)
+	if storage.burn_time then
+		storage.burn_time = storage.burn_time - dtime
+
+		if storage.burn_time <= 0 or mcl_burning.is_affected_by_rain(obj) or #mcl_burning.get_touching_nodes(obj, "group:puts_out_fire", storage) > 0 then
+			mcl_burning.extinguish(obj)
+			return true
+		else
+			storage.fire_damage_timer = storage.fire_damage_timer + dtime
+
+			if storage.fire_damage_timer >= 1 then
+				storage.fire_damage_timer = 0
+
+				local luaentity = obj:get_luaentity()
+
+				if not luaentity or not luaentity.fire_damage_resistant then
+					mcl_util.deal_damage(obj, 1, {type = "on_fire"})
+				end
+			end
+		end
+	end
+end

mods/ENTITIES/mcl_burning/engine.lua

@@ -1,304 +0,0 @@
-local S = minetest.get_translator("mcl_burning")
-
-function mcl_burning.get_default(datatype)
-	local default_table = {string = "", float = 0.0, int = 0, bool = false}
-	return default_table[datatype]
-end
-
-function mcl_burning.get(obj, datatype, name)
-	local key
-	if obj:is_player() then
-		local meta = obj:get_meta()
-		return meta["get_" .. datatype](meta, "mcl_burning:" .. name)
-	else
-		local luaentity = obj:get_luaentity()
-		return luaentity and luaentity["mcl_burning_" .. name] or mcl_burning.get_default(datatype)
-	end
-end
-
-function mcl_burning.set(obj, datatype, name, value)
-	if obj:is_player() then
-		local meta = obj:get_meta()
-		meta["set_" .. datatype](meta, "mcl_burning:" .. name, value or mcl_burning.get_default(datatype))
-	else
-		local luaentity = obj:get_luaentity()
-		if mcl_burning.get_default(datatype) == value then
-			value = nil
-		end
-		luaentity["mcl_burning_" .. name] = value
-	end
-end
-
-function mcl_burning.is_burning(obj)
-	return mcl_burning.get(obj, "float", "burn_time") > 0
-end
-
-function mcl_burning.is_affected_by_rain(obj)
-	return mcl_weather.get_weather() == "rain" and mcl_weather.is_outdoor(obj:get_pos())
-end
-
-function mcl_burning.get_collisionbox(obj, smaller)
-	local box = obj:get_properties().collisionbox
-	local minp, maxp = vector.new(box[1], box[2], box[3]), vector.new(box[4], box[5], box[6])
-	if smaller then
-		local s_vec = vector.new(0.1, 0.1, 0.1)
-		minp = vector.add(minp, s_vec)
-		maxp = vector.subtract(maxp, s_vec)
-	end
-	return minp, maxp
-end
-
-function mcl_burning.get_touching_nodes(obj, nodenames)
-	local pos = obj:get_pos()
-	local box = obj:get_properties().collisionbox
-	local minp, maxp = mcl_burning.get_collisionbox(obj, true)
-	local nodes = minetest.find_nodes_in_area(vector.add(pos, minp), vector.add(pos, maxp), nodenames)
-	return nodes
-end
-
-function mcl_burning.get_highest_group_value(obj, groupname)
-	local nodes = mcl_burning.get_touching_nodes(obj, "group:" .. groupname, true)
-	local highest_group_value = 0
-
-	for _, pos in pairs(nodes) do
-		local node = minetest.get_node(pos)
-		local group_value = minetest.get_item_group(node.name, groupname)
-		if group_value > highest_group_value then
-			highest_group_value = group_value
-		end
-	end
-
-	return highest_group_value
-end
-
-function mcl_burning.damage(obj)
-	local luaentity = obj:get_luaentity()
-	local health
-
-	if luaentity then
-		health = luaentity.health
-	end
-
-	local hp = health or obj:get_hp()
-
-	if hp <= 0 then
-		return
-	end
-
-	local do_damage = true
-
-	if obj:is_player() then
-		if mcl_potions.player_has_effect(obj, "fire_proof") then
-			do_damage = false
-		else
-			local name = obj:get_player_name()
-			armor.last_damage_types[name] = "fire"
-			local deathmsg = S("@1 burned to death.", name)
-			local reason = mcl_burning.get(obj, "string", "reason")
-			if reason ~= "" then
-				deathmsg = S("@1 was burned by @2.", name, reason)
-			end
-			mcl_death_messages.player_damage(obj, deathmsg)
-		end
-	else
-		if luaentity.fire_damage_resistant then
-			do_damage = false
-		end
-	end
-
-	if do_damage then
-		local damage = mcl_burning.get(obj, "float", "damage")
-		if damage == 0 then
-			damage = 1
-		end
-		local new_hp = hp - damage
-		if health then
-			luaentity.health = new_hp
-		else
-			obj:set_hp(new_hp)
-		end
-	end
-end
-
-function mcl_burning.set_on_fire(obj, burn_time, damage, reason)
-	local luaentity = obj:get_luaentity()
-	if luaentity and luaentity.fire_resistant then
-		return
-	end
-
-	local old_burn_time = mcl_burning.get(obj, "float", "burn_time")
-	local max_fire_prot_lvl = 0
-
-	if obj:is_player() then
-		if minetest.is_creative_enabled(obj:get_player_name()) then
-			burn_time = burn_time / 100
-		end
-
-		local inv = obj:get_inventory()
-
-		for i = 2, 5 do
-			local stack = inv:get_stack("armor", i)
-
-			local fire_prot_lvl = mcl_enchanting.get_enchantment(stack, "fire_protection")
-			max_fire_prot_lvl = math.max(max_fire_prot_lvl, fire_prot_lvl)
-		end
-	end
-
-	if max_fire_prot_lvl > 0 then
-		burn_time = burn_time - math.floor(burn_time * max_fire_prot_lvl * 0.15)
-	end
-
-	if old_burn_time <= burn_time then
-		local sound_id = mcl_burning.get(obj, "int", "sound_id")
-		if sound_id == 0 then
-			sound_id = minetest.sound_play("fire_fire", {
-				object = obj,
-				gain = 0.18,
-				max_hear_distance = 16,
-				loop = true,
-			}) + 1
-		end
-
-		local hud_id
-		if obj:is_player() then
-			hud_id = mcl_burning.get(obj, "int", "hud_id")
-			if hud_id == 0 then
-				hud_id = obj:hud_add({
-					hud_elem_type = "image",
-					position = {x = 0.5, y = 0.5},
-					scale = {x = -100, y = -100},
-					text = "fire_basic_flame.png",
-					z_index = 1000,
-				}) + 1
-			end
-		end
-		mcl_burning.set(obj, "float", "burn_time", burn_time)
-		mcl_burning.set(obj, "float", "damage", damage)
-		mcl_burning.set(obj, "string", "reason", reason)
-		mcl_burning.set(obj, "int", "hud_id", hud_id)
-		mcl_burning.set(obj, "int", "sound_id", sound_id)
-
-		local fire_entity = minetest.add_entity(obj:get_pos(), "mcl_burning:fire")
-		local minp, maxp = mcl_burning.get_collisionbox(obj)
-		local obj_size = obj:get_properties().visual_size
-
-		local vertical_grow_factor = 1.2
-		local horizontal_grow_factor = 1.1
-		local grow_vector = vector.new(horizontal_grow_factor, vertical_grow_factor, horizontal_grow_factor)
-
-		local size = vector.subtract(maxp, minp)
-		size = vector.multiply(size, grow_vector)
-		size = vector.divide(size, obj_size)
-		local offset = vector.new(0, size.y * 10 / 2, 0)
-
-		fire_entity:set_properties({visual_size = size})
-		fire_entity:set_attach(obj, "", offset, {x = 0, y = 0, z = 0})
-		mcl_burning.update_animation_frame(obj, fire_entity, 0)
-	end
-end
-
-function mcl_burning.extinguish(obj)
-	if mcl_burning.is_burning(obj) then
-		local sound_id = mcl_burning.get(obj, "int", "sound_id") - 1
-		minetest.sound_stop(sound_id)
-
-		if obj:is_player() then
-			local hud_id = mcl_burning.get(obj, "int", "hud_id") - 1
-			obj:hud_remove(hud_id)
-		end
-
-		mcl_burning.set(obj, "float", "damage")
-		mcl_burning.set(obj, "string", "reason")
-		mcl_burning.set(obj, "float", "burn_time")
-		mcl_burning.set(obj, "float", "damage_timer")
-		mcl_burning.set(obj, "int", "hud_id")
-		mcl_burning.set(obj, "int", "sound_id")
-	end
-end
-
-function mcl_burning.catch_fire_tick(obj, dtime)
-	if mcl_burning.is_affected_by_rain(obj) or #mcl_burning.get_touching_nodes(obj, "group:puts_out_fire") > 0 then
-		mcl_burning.extinguish(obj)
-	else
-		local set_on_fire_value = mcl_burning.get_highest_group_value(obj, "set_on_fire")
-
-		if set_on_fire_value > 0 then
-			mcl_burning.set_on_fire(obj, set_on_fire_value)
-		end
-	end
-end
-
-function mcl_burning.tick(obj, dtime)
-	local burn_time = mcl_burning.get(obj, "float", "burn_time") - dtime
-
-	if burn_time <= 0 then
-		mcl_burning.extinguish(obj)
-	else
-		mcl_burning.set(obj, "float", "burn_time", burn_time)
-
-		local damage_timer = mcl_burning.get(obj, "float", "damage_timer") + dtime
-
-		if damage_timer >= 1 then
-			damage_timer = 0
-			mcl_burning.damage(obj)
-		end
-
-		mcl_burning.set(obj, "float", "damage_timer", damage_timer)
-	end
-
-	mcl_burning.catch_fire_tick(obj, dtime)
-end
-
-function mcl_burning.update_animation_frame(obj, fire_entity, animation_frame)
-	local fire_texture = "mcl_burning_entity_flame_animated.png^[opacity:180^[verticalframe:" .. mcl_burning.animation_frames .. ":" .. animation_frame
-	local fire_HUD_texture = "mcl_burning_hud_flame_animated.png^[opacity:180^[verticalframe:" .. mcl_burning.animation_frames .. ":" .. animation_frame
-	fire_entity:set_properties({textures = {"blank.png", "blank.png", fire_texture, fire_texture, fire_texture, fire_texture}})
-	if obj:is_player() then
-		local hud_id = mcl_burning.get(obj, "int", "hud_id") - 1
-		obj:hud_change(hud_id, "text", fire_HUD_texture)
-	end
-end
-
-function mcl_burning.fire_entity_step(self, dtime)
-	if self.removed then
-		return
-	end
-
-	local obj = self.object
-	local parent = obj:get_attach()
-	local do_remove
-
-	self.doing_step = true
-
-	if not parent or not mcl_burning.is_burning(parent) then
-		do_remove = true
-	else
-		for _, other in ipairs(minetest.get_objects_inside_radius(obj:get_pos(), 0)) do
-			local luaentity = obj:get_luaentity()
-			if luaentity and luaentity.name == "mcl_burning:fire" and not luaentity.doing_step and not luaentity.removed then
-				do_remove = true
-				break
-			end
-		end
-	end
-
-	self.doing_step = false
-
-	if do_remove then
-		self.removed = true
-		obj:remove()
-		return
-	end
-
-	local animation_timer = self.animation_timer + dtime
-	if animation_timer >= 0.015 then
-		animation_timer = 0
-		local animation_frame = self.animation_frame + 1
-		if animation_frame > mcl_burning.animation_frames - 1 then
-			animation_frame = 0
-		end
-		mcl_burning.update_animation_frame(parent, obj, animation_frame)
-		self.animation_frame = animation_frame
-	end
-	self.animation_timer = animation_timer
-end

mods/ENTITIES/mcl_burning/init.lua

@@ -1,29 +1,42 @@
-local S = minetest.get_translator("mcl_burning")
+local modpath = minetest.get_modpath(minetest.get_current_modname())
-local modpath = minetest.get_modpath("mcl_burning")
+
+local pairs = pairs
+
+local get_connected_players = minetest.get_connected_players
+local get_item_group = minetest.get_item_group
 
 mcl_burning = {
+	storage = {},
+	channels = {},
 	animation_frames = tonumber(minetest.settings:get("fire_animation_frames")) or 8
 }
 
-dofile(modpath .. "/engine.lua")
+dofile(modpath .. "/api.lua")
-
-minetest.register_entity("mcl_burning:fire", {
-	initial_properties = {
-		physical = false,
-		collisionbox = {0, 0, 0, 0, 0, 0},
-		visual = "cube",
-		pointable = false,
-		glow = -1,
-	},
-	
-	animation_frame = 0,
-	animation_timer = 0,
-	on_step = mcl_burning.fire_entity_step,
-})
 
 minetest.register_globalstep(function(dtime)
-	for _, player in ipairs(minetest.get_connected_players()) do
+	for _, player in pairs(get_connected_players()) do
-		mcl_burning.tick(player, dtime)
+		local storage = mcl_burning.storage[player]
+		if not mcl_burning.tick(player, dtime, storage) and not mcl_burning.is_affected_by_rain(player) then
+			local nodes = mcl_burning.get_touching_nodes(player, {"group:puts_out_fire", "group:set_on_fire"}, storage)
+			local burn_time = 0
+
+			for _, pos in pairs(nodes) do
+				local node = minetest.get_node(pos)
+				if get_item_group(node.name, "puts_out_fire") > 0 then
+					burn_time = 0
+					break
+				end
+
+				local value = get_item_group(node.name, "set_on_fire")
+				if value > burn_time then
+					burn_time = value
+				end
+			end
+
+			if burn_time > 0 then
+				mcl_burning.set_on_fire(player, burn_time)
+			end
+		end
 	end
 end)
 
@@ -31,6 +44,68 @@ minetest.register_on_respawnplayer(function(player)
 	mcl_burning.extinguish(player)
 end)
 
+minetest.register_on_joinplayer(function(player)
+	local storage
+
+	local burn_data = player:get_meta():get_string("mcl_burning:data")
+	if burn_data == "" then
+		storage = {}
+	else
+		storage = minetest.deserialize(burn_data)
+	end
+
+	mcl_burning.storage[player] = storage
+	mcl_burning.channels[player] = minetest.mod_channel_join("mcl_burning:" .. player:get_player_name())
+end)
+
 minetest.register_on_leaveplayer(function(player)
-	mcl_burning.set(player, "int", "hud_id")
+	player:get_meta():set_string("mcl_burning:data", minetest.serialize(mcl_burning.storage[player]))
-end)
+	mcl_burning.storage[player] = nil
+end)
+
+
+minetest.register_entity("mcl_burning:fire", {
+	initial_properties = {
+		physical = false,
+		collisionbox = {0, 0, 0, 0, 0, 0},
+		visual = "upright_sprite",
+		textures = {
+			name = "mcl_burning_entity_flame_animated.png",
+			animation = {
+				type = "vertical_frames",
+				aspect_w = 16,
+				aspect_h = 16,
+				length = 1.0,
+			},
+		},
+		spritediv = {x = 1, y = mcl_burning.animation_frames},
+		pointable = false,
+		glow = -1,
+		backface_culling = false,
+	},
+	animation_frame = 0,
+	animation_timer = 0,
+	on_activate = function(self)
+		self.object:set_sprite({x = 0, y = 0}, mcl_burning.animation_frames, 1.0 / mcl_burning.animation_frames)
+	end,
+	on_step = function(self)
+		if not self:sanity_check() then
+			self.object:remove()
+		end
+	end,
+	sanity_check = function(self)
+		local parent = self.object:get_attach()
+
+		if not parent then
+			return false
+		end
+
+		local storage = mcl_burning.get_storage(parent)
+
+		if not storage or not storage.burn_time then
+			return false
+		end
+
+		return true
+	end,
+})

mods/ENTITIES/mcl_falling_nodes/description.txt

@@ -1 +0,0 @@
-Falling node entities, Minecraft-style

mods/ENTITIES/mcl_falling_nodes/init.lua

@@ -1,7 +1,4 @@
-local S = minetest.get_translator("mcl_falling_nodes")
+local function get_falling_depth(self)
-local dmes = minetest.get_modpath("mcl_death_messages") ~= nil
-
-local get_falling_depth = function(self)
 	if not self._startpos then
 		-- Fallback
 		self._startpos = self.object:get_pos()
@@ -9,56 +6,45 @@ local get_falling_depth = function(self)
 	return self._startpos.y - vector.round(self.object:get_pos()).y
 end
 
-local deal_falling_damage = function(self, dtime)
+local function deal_falling_damage(self, dtime)
 	if minetest.get_item_group(self.node.name, "falling_node_damage") == 0 then
 		return
 	end
-	-- Cause damage to any player it hits.
+	-- Cause damage to any entity it hits.
 	-- Algorithm based on MC anvils.
-	-- TODO: Support smashing other objects, too.
 	local pos = self.object:get_pos()
 	if not self._startpos then
 		-- Fallback
 		self._startpos = pos
 	end
-	local objs = minetest.get_objects_inside_radius(pos, 1)
+	self._hit = self._hit or {}
-	for _,v in ipairs(objs) do
+	for _, obj in ipairs(minetest.get_objects_inside_radius(pos, 1)) do
-		local hp = v:get_hp()
+		local entity = obj:get_luaentity()
-		if v:is_player() and hp ~= 0 then
+		if entity and entity.name == "__builtin:item" then
-			if not self._hit_players then
+			obj:remove()
-				self._hit_players = {}
+		elseif mcl_util.get_hp(obj) > 0 and not self._hit[obj] then
-			end
+			self._hit[obj] = true
-			local name = v:get_player_name()
+			local way = self._startpos.y - pos.y
-			local hit = false
+			local damage = (way - 1) * 2
-			for _,v in ipairs(self._hit_players) do
+			damage = math.min(40, math.max(0, damage))
-				if name == v then
+			if damage >= 1 then
-					hit = true
+				-- Reduce damage if wearing a helmet
-				end
+				local inv = mcl_util.get_inventory(obj)
-			end
+				if inv then
-			if not hit then
+					local helmet = inv:get_stack("armor", 2)
-				table.insert(self._hit_players, name)
+					if minetest.get_item_group(helmet:get_name(), "combat_armor") > 0 then
-				local way = self._startpos.y - pos.y
+						damage = damage / 4 * 3
-				local damage = (way - 1) * 2
+						mcl_util.use_item_durability(helmet, 1)
-				damage = math.min(40, math.max(0, damage))
+						inv:set_stack("armor", 2, helmet)
-				if damage >= 1 then
-					hp = hp - damage
-					if hp < 0 then
-						hp = 0
 					end
-					if v:is_player() then
-						-- TODO: Reduce damage if wearing a helmet
-						local msg
-						if minetest.get_item_group(self.node.name, "anvil") ~= 0 then
-							msg = S("@1 was smashed by a falling anvil.", v:get_player_name())
-						else
-							msg = S("@1 was smashed by a falling block.", v:get_player_name())
-						end
-						if dmes then
-							mcl_death_messages.player_damage(v, msg)
-						end
-					end
-					v:set_hp(hp, { type = "punch", from = "mod" })
 				end
+				local dmg_type
+				if minetest.get_item_group(self.node.name, "anvil") ~= 0 then
+					dmg_type = "anvil"
+				else
+					dmg_type = "falling_node"
+				end
+				mcl_util.deal_damage(obj, damage, {type = dmg_type})
 			end
 		end
 	end
@@ -74,10 +60,8 @@ minetest.register_entity(":__builtin:falling_node", {
 		collide_with_objects = false,
 		collisionbox = {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5},
 	},
-
 	node = {},
 	meta = {},
-
 	set_node = function(self, node, meta)
 		local def = minetest.registered_nodes[node.name]
 		-- Change falling node if definition tells us to
@@ -104,7 +88,6 @@ minetest.register_entity(":__builtin:falling_node", {
 			glow = glow,
 		})
 	end,
-
 	get_staticdata = function(self)
 		local meta = self.meta
 		-- Workaround: Save inventory seperately from metadata.
@@ -125,10 +108,9 @@ minetest.register_entity(":__builtin:falling_node", {
 		}
 		return minetest.serialize(ds)
 	end,
-
 	on_activate = function(self, staticdata)
 		self.object:set_armor_groups({immortal = 1})
-		
+
 		local ds = minetest.deserialize(staticdata)
 		if ds then
 			self._startpos = ds._startpos
@@ -148,7 +130,6 @@ minetest.register_entity(":__builtin:falling_node", {
 		end
 		self._startpos = vector.round(self._startpos)
 	end,
-
 	on_step = function(self, dtime)
 		-- Set gravity
 		local acceleration = self.object:get_acceleration()
@@ -162,7 +143,7 @@ minetest.register_entity(":__builtin:falling_node", {
 		local np = {x = pos.x, y = pos.y + 0.3, z = pos.z}
 		local n2 = minetest.get_node(np)
 		if n2.name == "mcl_portals:portal_end" then
-			-- TODO: Teleport falling node. 
+			-- TODO: Teleport falling node.
 			self.object:remove()
 			return
 		end
@@ -200,10 +181,9 @@ minetest.register_entity(":__builtin:falling_node", {
 				return
 			end
 			local nd = minetest.registered_nodes[n2.name]
-			if n2.name == "mcl_portals:portal_end" then
+			--if n2.name == "mcl_portals:portal_end" then
-				-- TODO: Teleport falling node. 
+			-- TODO: Teleport falling node.
-
+            if (nd and nd.buildable_to == true) or minetest.get_item_group(self.node.name, "crush_after_fall") ~= 0 then
-			elseif (nd and nd.buildable_to == true) or minetest.get_item_group(self.node.name, "crush_after_fall") ~= 0 then
 				-- Replace destination node if it's buildable to
 				minetest.remove_node(np)
 				-- Run script hook
@@ -270,7 +250,6 @@ minetest.register_entity(":__builtin:falling_node", {
 				self.object:set_pos(npos)
 			end
 		end
-
 		deal_falling_damage(self, dtime)
 	end
 })

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

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

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

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

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

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

mods/ENTITIES/mcl_falling_nodes/locale/mcl_falling_nodes.pl.tr

@@ -0,0 +1,3 @@
+# textdomain: mcl_falling_nodes
+@1 was smashed by a falling anvil.=@1 została zmiażdżona przez spadające kowadło.
+@1 was smashed by a falling block.=@1 została zmiażdżona przez spadający blok.

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

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

mods/ENTITIES/mcl_falling_nodes/locale/template.txt

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

mods/ENTITIES/mcl_falling_nodes/mod.conf

@@ -1 +1,3 @@
 name = mcl_falling_nodes
+author = Wuzzy
+description = Falling node entities, Minecraft-style

mods/ENTITIES/mcl_item_entity/depends.txt

@@ -1,2 +0,0 @@
-flowlib
-mcl_enchanting