Revert "Revert "Merge pull request 'Massively overhaul spawning algorithm for mobs' (#1487) from jordan4ibanez/MineClone2-MobTweaks:master into master""

This reverts commit 6a1a634cba.

CONTRIBUTING.md

@@ -7,11 +7,13 @@ 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 three persons. Namely, kay27, EliasFleckenstein and jordan4ibanez. You can find us
-in the Minetest forums (forums.minetest.net), in IRC in the #mineclone2
+MineClone 2 is maintained by two persons. Namely, kay27 and EliasFleckenstein. You can find us
+in the Minetest forums (forums.minetest.net), in IRC in the #minetest
 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.
@@ -24,7 +26,8 @@ For small and medium changes:
 
 * Fork the repository
 * Do your change in a new branch
-* Create a pull request to get your changes merged into master
+* Upload the repository somewhere where it can be accessed from the Internet and
+  notify us
 
 For small changes, sending us a patch is also good.
 
@@ -38,30 +41,40 @@ 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.
 
-If your code causes bugs and crashes, it is your responsibility to fix them as soon as possible.
+Contributors will be credited in `README.md`.
 
-We mostly use plain merging rather than rebasing or squash merging.
+## Quality remarks
+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.
 
-Your commit names should be relatively descriptive, e.g. when saying "Fix #issueid", the commit message should also contain the title of the issue.
+### Inclusion criteria
+Depending on what you add, the chances for inclusion vary:
 
-Contributors will be credited in `CREDITS.md`.
+### High chance for inclusion
+* Gameplay features in Minecraft which are missing in MineClone 2
 
-## Features > 1.12
+### Medium chance for inclusion (discuss first)
+* Features which don't a impact on gameplay
+* GUI improvement
+* Features from pocket or console edition
 
-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.
+### Low chance for inclusion (discuss/optimize first)
+* Overhaul of architecture / mod structure
+* Mass-itemstring changes all over the place
+* Added files have a unusual high file size
+* Indentation looks like crazy
+* Single commits which add several unrelated things
+* Gameplay features which don't exist in Minecraft
 
-## What we accept
+### Instant rejection
+* Proprietary **anything**
+* Code contains `minetest.env` anywhere
 
-* 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.
+## Coding style guide
+* Indentations should reflect the code flow
+* Use tabs, not spaces for indentation (tab size = 8)
+* Never use `minetest.env`
 
 ## Reporting bugs
 Report all bugs and missing Minecraft features here:

CREDITS.md

@@ -1,117 +0,0 @@
-# Credits
-
-## Creator of MineClone
-* davedevils
-
-## Creator of MineClone2
-* Wuzzy
-
-## Maintainers
-* Fleckenstein
-* kay27
-* oilboi
-
-## Developers
-* bzoss
-* AFCMS
-* epCode
-* ryvnf
-* iliekprogrammar
-* MysticTempest
-* Rootyjr
-* Nicu
-* aligator
-* Code-Sploit
-
-## 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
-* NO11
-* 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
-* oilboi
-* 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
-
-## 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

LEGAL.md

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

@@ -0,0 +1,40 @@
+# 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.72.0 (in development)
+Version: 0.71.0
 
 ### Gameplay
 You start in a randomly-generated world made entirely of cubes. You can explore
@@ -65,8 +65,16 @@ 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.3.0 or
+This game requires [Minetest](http://minetest.net) to run (version 5.0.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.
@@ -75,37 +83,23 @@ 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.
 
-## Reporting bugs
-Please report all bugs and missing Minecraft features here:
-
-<https://git.minetest.land/MineClone2/MineClone2/issues>
-
-## Chating with the community
-Join our discord server at:
-
-<https://discord.gg/84GKcxczG3>
-
 ## 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
-* In general, Minecraft is aimed to be cloned as good as possible
+* 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 Minetest currently permits (no hacks)
 * Cloning the gameplay has highest priority
-* MineClone 2 will use different assets, but with a similar style
-* Limitations found in Minetest will be documented 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
+* MineClone 2 will use different graphics and sounds, but with a similar style
+* Cloning the interface has no priority. It will only be roughly imitated
+* Limitations found in Minetest will be written down and reported in the course of development
 
 ## Completion status
-This game is currently in **beta** stage.
-It is playable, but not yet feature-complete.
-Backwards-compability is not entirely guaranteed, updating your world might cause small bugs.
-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.
+This game is currently in **alpha** stage.
+It is playable, but unfinished, many bugs are to be expected.
+Backwards-compability is *not* guaranteed, updating your world might cause small and
+big bugs (such as “missing node” errors or even crashes).
 
 The following main features are available:
 
@@ -134,7 +128,7 @@ The following main features are available:
 * Clock
 * Compass
 * Sponge
-* Slime block
+* Slime block (does not interact with redstone)
 * Small plants and saplings
 * Dyes
 * Banners
@@ -146,19 +140,19 @@ The following main features are available:
 * Creative inventory
 * Farming
 * Writable books
-* Commands
-* Villages
-* The End
+* A few server commands
 * 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.12):
+Bonus features (not found in Minecraft 1.11):
 
 * 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
@@ -183,14 +177,148 @@ 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>
+
+## Chating with the community
+Join our discord server at:
+
+<https://discord.gg/84GKcxczG3>
+
 ## 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.md`: List of everyone who contributed
+
+## Credits
+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)
+* epCode: Better player animations, new logo
+* 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.

mods/CORE/mcl_particles/init.lua

@@ -66,58 +66,3 @@ function mcl_particles.delete_node_particlespawners(pos)
 	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 min = math.min
-	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
-			mcl_particles.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 = min(exptime, (7.0/8.0 * (exptime + 0.1) + 0.1))
-				smoke_pdef.texture = "mcl_particles_smoke_anim.png^[colorize:#000000:" ..colorize
-
-				mcl_particles.add_node_particlespawner(pos, smoke_pdef, "high")
-
-				table.insert(smoke_pdef_cached[name], table.copy(smoke_pdef))
-			end
-		end
-	end
-end

mods/ENTITIES/mcl_mobs/api.lua

@@ -61,6 +61,8 @@ end
 
 -- Load settings
 local damage_enabled = minetest.settings:get_bool("enable_damage")
+local mobs_spawn = minetest.settings:get_bool("mobs_spawn", true) ~= false
+
 local disable_blood = minetest.settings:get_bool("mobs_disable_blood")
 local mobs_drop_items = minetest.settings:get_bool("mobs_drop_items") ~= false
 local mobs_griefing = minetest.settings:get_bool("mobs_griefing") ~= false
@@ -82,6 +84,11 @@ if minetest.settings:get_bool("only_peaceful_mobs", false) then
 	end)
 end
 
+-- calculate aoc range for mob count
+local aosrb = tonumber(minetest.settings:get("active_object_send_range_blocks"))
+local abr = tonumber(minetest.settings:get("active_block_range"))
+local aoc_range = max(aosrb, abr) * 16
+
 -- pathfinding settings
 local enable_pathfinding = true
 local stuck_timeout = 3 -- how long before mob gets stuck in place and starts searching
@@ -859,12 +866,10 @@ local check_for_death = function(self, cause, cmi_cause)
 	remove_texture_mod(self, "^[colorize:#FF000040")
 	remove_texture_mod(self, "^[brighten")
 	self.passive = true
-
 	self.object:set_properties({
 		pointable = false,
 		collide_with_objects = false,
 	})
-
 	set_velocity(self, 0)
 	local acc = self.object:get_acceleration()
 	acc.x, acc.y, acc.z = 0, DEFAULT_FALL_SPEED, 0
@@ -3413,6 +3418,7 @@ local mob_activate = function(self, staticdata, def, dtime)
 	self.timer = 0
 	self.blinktimer = 0
 	self.blinkstatus = false
+	self.collide_with_objects = false
 
 	-- check existing nametag
 	if not self.nametag then
@@ -3901,12 +3907,6 @@ minetest.register_entity(name, {
 	on_detach_child = mob_detach_child,
 
 	on_activate = function(self, staticdata, dtime)
-		--this is a temporary hack so mobs stop
-		--glitching and acting really weird with the
-		--default built in engine collision detection
-		self.object:set_properties({
-			collide_with_objects = false,
-		})	
 		return mob_activate(self, staticdata, def, dtime)
 	end,
 
@@ -3924,6 +3924,534 @@ end
 
 end -- END mobs:register_mob function
 
+
+
+
+
+
+
+
+
+
+
+
+
+--BEGIN SPAWNING ALGORITHM
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+-- count how many mobs of one type are inside an area
+--[[
+local count_mobs = function(pos, mobtype)
+
+	local num = 0
+	local objs = minetest.get_objects_inside_radius(pos, aoc_range)
+
+	for n = 1, #objs do
+
+		local obj = objs[n]:get_luaentity()
+
+		if obj and obj.name and obj._cmi_is_mob then
+
+			-- count passive mobs only
+			if mobtype == "!passive" then
+				if obj.spawn_class == "passive" then
+					num = num + 1
+				end
+			-- count hostile mobs only
+			elseif mobtype == "!hostile" then
+				if obj.spawn_class == "hostile" then
+					num = num + 1
+				end
+			-- count ambient mobs only
+			elseif mobtype == "!ambient" then
+				if obj.spawn_class == "ambient" then
+					num = num + 1
+				end
+			-- count water mobs only
+			elseif mobtype == "!water" then
+				if obj.spawn_class == "water" then
+					num = num + 1
+				end
+			-- count mob type
+			elseif mobtype and obj.name == mobtype then
+				num = num + 1
+			-- count total mobs
+			elseif not mobtype then
+				num = num + 1
+			end
+		end
+	end
+
+	return num
+end
+]]--
+
+-- global functions
+
+function mobs:spawn_abm_check(pos, node, name)
+	-- global function to add additional spawn checks
+	-- return true to stop spawning mob
+end
+
+
+--[[
+	Custom elements changed:
+name:
+the mobs name
+
+dimension: 
+"overworld"
+"nether"
+"end"
+
+types of spawning:
+"air"
+"water"
+"ground"
+"lava"
+
+what is aoc???
+
+WARNING: BIOME INTEGRATION NEEDED -> How to get biome through lua??
+]]--
+
+--this is where all of the spawning information is kept
+local spawn_dictionary = {
+	["overworld"] = {},
+	["nether"] = {},
+	["end"] = {}
+}
+
+function mobs:spawn_specific(
+	name,
+	dimension,
+	type_of_spawning, 
+	min_light, 
+	max_light, 
+	interval, 
+	chance, 
+	aoc, 
+	min_height, 
+	max_height, 
+	day_toggle, 
+	on_spawn)
+
+	
+	-- Do mobs spawn at all?
+	if not mobs_spawn then
+		return
+	end
+
+	-- chance/spawn number override in minetest.conf for registered mob
+	local numbers = minetest.settings:get(name)
+
+	if numbers then
+		numbers = numbers:split(",")
+		chance = tonumber(numbers[1]) or chance
+		aoc = tonumber(numbers[2]) or aoc
+
+		if chance == 0 then
+			minetest.log("warning", string.format("[mobs] %s has spawning disabled", name))
+			return
+		end
+
+		minetest.log("action",
+			string.format("[mobs] Chance setting for %s changed to %s (total: %s)", name, chance, aoc))
+	end
+
+	local spawn_action
+	spawn_action = function(pos, node, active_object_count, active_object_count_wider, name)
+
+			local orig_pos = table.copy(pos)
+			-- is mob actually registered?
+			if not mobs.spawning_mobs[name]
+			or not minetest.registered_entities[name] then
+				minetest.log("warning", "Mob spawn of "..name.." failed, unknown entity or mob is not registered for spawning!")
+				return
+			end
+
+			-- additional custom checks for spawning mob
+			if mobs:spawn_abm_check(pos, node, name) == true then
+				minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, ABM check rejected!")
+				return
+			end
+
+			-- count nearby mobs in same spawn class
+			local entdef = minetest.registered_entities[name]
+			local spawn_class = entdef and entdef.spawn_class
+			if not spawn_class then
+				if entdef.type == "monster" then
+					spawn_class = "hostile"
+				else
+					spawn_class = "passive"
+				end
+			end
+			local in_class_cap = count_mobs(pos, "!"..spawn_class) < MOB_CAP[spawn_class]
+			-- do not spawn if too many of same mob in area
+			if active_object_count_wider >= max_per_block -- large-range mob cap
+			or (not in_class_cap) -- spawn class mob cap
+			or count_mobs(pos, name) >= aoc then -- per-mob mob cap
+				-- too many entities
+				minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, too crowded!")
+				return
+			end
+
+			-- if toggle set to nil then ignore day/night check
+			if day_toggle ~= nil then
+
+				local tod = (minetest.get_timeofday() or 0) * 24000
+
+				if tod > 4500 and tod < 19500 then
+					-- daylight, but mob wants night
+					if day_toggle == false then
+						-- mob needs night
+						minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, mob needs light!")
+						return
+					end
+				else
+					-- night time but mob wants day
+					if day_toggle == true then
+						-- mob needs day
+						minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, mob needs daylight!")
+						return
+					end
+				end
+			end
+
+			-- spawn above node
+			pos.y = pos.y + 1
+
+			-- only spawn away from player
+			local objs = minetest.get_objects_inside_radius(pos, 24)
+
+			for n = 1, #objs do
+
+				if objs[n]:is_player() then
+					-- player too close
+					minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, player too close!")
+					return
+				end
+			end
+
+			-- mobs cannot spawn in protected areas when enabled
+			if not spawn_protected
+			and minetest.is_protected(pos, "") then
+				minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, position is protected!")
+				return
+			end
+
+			-- are we spawning within height limits?
+			if pos.y > max_height
+			or pos.y < min_height then
+				minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, out of height limit!")
+				return
+			end
+
+			-- are light levels ok?
+			local light = minetest.get_node_light(pos)
+			if not light
+			or light > max_light
+			or light < min_light then
+				minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, bad light!")
+				return
+			end
+
+			-- do we have enough space to spawn mob?
+			local ent = minetest.registered_entities[name]
+			local width_x = max(1, math.ceil(ent.collisionbox[4] - ent.collisionbox[1]))
+			local min_x, max_x
+			if width_x % 2 == 0 then
+				max_x = math.floor(width_x/2)
+				min_x = -(max_x-1)
+			else
+				max_x = math.floor(width_x/2)
+				min_x = -max_x
+			end
+
+			local width_z = max(1, math.ceil(ent.collisionbox[6] - ent.collisionbox[3]))
+			local min_z, max_z
+			if width_z % 2 == 0 then
+				max_z = math.floor(width_z/2)
+				min_z = -(max_z-1)
+			else
+				max_z = math.floor(width_z/2)
+				min_z = -max_z
+			end
+
+			local max_y = max(0, math.ceil(ent.collisionbox[5] - ent.collisionbox[2]) - 1)
+
+			for y = 0, max_y do
+				for x = min_x, max_x do
+					for z = min_z, max_z do
+						local pos2 = {x = pos.x+x, y = pos.y+y, z = pos.z+z}
+						if minetest.registered_nodes[node_ok(pos2).name].walkable == true then
+							-- inside block
+							minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, too little space!")
+							if ent.spawn_small_alternative ~= nil and (not minetest.registered_nodes[node_ok(pos).name].walkable) then
+								minetest.log("info", "Trying to spawn smaller alternative mob: "..ent.spawn_small_alternative)
+								spawn_action(orig_pos, node, active_object_count, active_object_count_wider, ent.spawn_small_alternative)
+							end
+							return
+						end
+					end
+				end
+			end
+
+			-- tweak X/Y/Z spawn pos
+			if width_x % 2 == 0 then
+				pos.x = pos.x + 0.5
+			end
+			if width_z % 2 == 0 then
+				pos.z = pos.z + 0.5
+			end
+			pos.y = pos.y - 0.5
+
+			local mob = minetest.add_entity(pos, name)
+			minetest.log("action", "Mob spawned: "..name.." at "..minetest.pos_to_string(pos))
+
+			if on_spawn then
+
+				local ent = mob:get_luaentity()
+
+				on_spawn(ent, pos)
+			end
+	end
+
+	local function spawn_abm_action(pos, node, active_object_count, active_object_count_wider)
+		spawn_action(pos, node, active_object_count, active_object_count_wider, name)
+	end
+
+
+	--load information into the spawn dictionary
+	local key = #spawn_dictionary[dimension] + 1
+
+	spawn_dictionary[dimension][key] = {}
+	spawn_dictionary[dimension][key]["name"]       = name
+	spawn_dictionary[dimension][key]["type"]       = type_of_spawning
+	spawn_dictionary[dimension][key]["min_light"]  = min_light
+	spawn_dictionary[dimension][key]["max_light"]  = max_light
+	spawn_dictionary[dimension][key]["interval"]   = interval
+	spawn_dictionary[dimension][key]["chance"]     = chance
+	spawn_dictionary[dimension][key]["aoc"]        = aoc
+	spawn_dictionary[dimension][key]["min_height"] = min_height
+	spawn_dictionary[dimension][key]["max_height"] = max_height
+	spawn_dictionary[dimension][key]["day_toggle"] = day_toggle
+	spawn_dictionary[dimension][key]["on_spawn"]   = spawn_abm_action
+	
+	--[[
+	minetest.register_abm({
+		label = name .. " spawning",
+		nodenames = nodes,
+		neighbors = neighbors,
+		interval = interval,
+		chance = floor(max(1, chance * mobs_spawn_chance)),
+		catch_up = false,
+		action = spawn_abm_action,
+	})
+	]]--
+end
+
+
+-- compatibility with older mob registration
+-- we're going to forget about this for now -j4i
+--[[
+function mobs:register_spawn(name, nodes, max_light, min_light, chance, active_object_count, max_height, day_toggle)
+
+	mobs:spawn_specific(name, nodes, {"air"}, min_light, max_light, 30,
+		chance, active_object_count, -31000, max_height, day_toggle)
+end
+]]--
+
+
+--I'm not sure what this does but disabling it doesn't cause a crash -j4i
+-- MarkBu's spawn function
+--[[
+function mobs:spawn(def)
+
+	local name = def.name
+	local nodes = def.nodes or {"group:soil", "group:stone"}
+	local neighbors = def.neighbors or {"air"}
+	local min_light = def.min_light or 0
+	local max_light = def.max_light or 15
+	local interval = def.interval or 30
+	local chance = def.chance or 5000
+	local active_object_count = def.active_object_count or 1
+	local min_height = def.min_height or -31000
+	local max_height = def.max_height or 31000
+	local day_toggle = def.day_toggle
+	local on_spawn = def.on_spawn
+
+	mobs:spawn_specific(name, nodes, neighbors, min_light, max_light, interval,
+		chance, active_object_count, min_height, max_height, day_toggle, on_spawn)
+end
+]]--
+
+
+local axis
+--inner and outer part of square donut radius
+local inner = 1
+local outer = 70
+local int = {-1,1}
+local position_calculation = function(pos)
+
+	pos = vector.floor(pos)
+
+	--this is used to determine the axis buffer from the player
+	axis = math.random(0,1)
+
+	--cast towards the direction
+	if axis == 0 then --x
+		pos.x = pos.x + math.random(inner,outer)*int[math.random(1,2)]
+		pos.z = pos.z + math.random(-outer,outer)
+	else --z
+		pos.z = pos.z + math.random(inner,outer)*int[math.random(1,2)]
+		pos.x = pos.x + math.random(-outer,outer)
+	end
+	return(pos)
+end
+
+--[[
+local decypher_limits_dictionary = {
+	["overworld"] = {mcl_vars.mg_overworld_min,mcl_vars.mg_overworld_max},
+	["nether"]    = {mcl_vars.mg_nether_min,   mcl_vars.mg_nether_max},
+	["end"]       = {mcl_vars.mg_end_min,      mcl_vars.mg_end_max}
+}
+]]--
+
+local function decypher_limits(posy)
+	--local min_max_table = decypher_limits_dictionary[dimension]
+	--return min_max_table[1],min_max_table[2]
+	posy = math.floor(posy)
+	return posy - 32, posy + 32
+end
+
+
+--todo mob limiting
+--MAIN LOOP
+local timer = 0
+minetest.register_globalstep(function(dtime)
+	timer = timer + dtime
+	if timer >= 15 then
+		timer = 0
+		for _,player in ipairs(minetest.get_connected_players()) do
+			for i = 1,math.random(5) do
+				local player_pos = player:get_pos()
+				local _,dimension = mcl_worlds.y_to_layer(player_pos.y)
+				local min,max = decypher_limits(player_pos.y)
+
+				local goal_pos = position_calculation(player_pos)
+				
+
+				local mob_def = spawn_dictionary[dimension][math.random(1,#spawn_dictionary[dimension])]
+
+				if not mob_def then --to catch a crazy error if it ever happens
+					minetest.log("error", "WARNING!! mob spawning attempted to index a NIL mob!")
+					goto continue
+				end
+
+				if mob_def.type == "ground" then
+
+					local spawning_position_list = minetest.find_nodes_in_area_under_air(vector.new(goal_pos.x,min,goal_pos.z), vector.new(goal_pos.x,max,goal_pos.z), {"group:solid"})
+
+					if #spawning_position_list <= 0 then
+						goto continue
+					end
+					
+					local spawning_position = spawning_position_list[math.random(1,#spawning_position_list)]
+
+					spawning_position.y = spawning_position.y + 1
+
+					local gotten_light = minetest.get_node_light(spawning_position)
+
+					if gotten_light and gotten_light >= mob_def.min_light and gotten_light <= mob_def.max_light then
+						minetest.add_entity(spawning_position, mob_def.name)
+					end
+				elseif mob_def.type == "air" then
+					local spawning_position_list = minetest.find_nodes_in_area(vector.new(goal_pos.x,min,goal_pos.z), vector.new(goal_pos.x,max,goal_pos.z), {"air"})
+
+					if #spawning_position_list <= 0 then
+						goto continue
+					end
+					
+					local spawning_position = spawning_position_list[math.random(1,#spawning_position_list)]
+
+					local gotten_light = minetest.get_node_light(spawning_position)
+
+					if gotten_light and gotten_light >= mob_def.min_light and gotten_light <= mob_def.max_light then
+						minetest.add_entity(spawning_position, mob_def.name)
+					end
+				elseif mob_def.type == "water" then
+					local spawning_position_list = minetest.find_nodes_in_area(vector.new(goal_pos.x,min,goal_pos.z), vector.new(goal_pos.x,max,goal_pos.z), {"group:water"})
+
+					if #spawning_position_list <= 0 then
+						goto continue
+					end
+					
+					local spawning_position = spawning_position_list[math.random(1,#spawning_position_list)]
+
+					local gotten_light = minetest.get_node_light(spawning_position)
+
+					if gotten_light and gotten_light >= mob_def.min_light and gotten_light <= mob_def.max_light then
+						minetest.add_entity(spawning_position, mob_def.name)
+					end
+				--elseif mob_def.type == "lava" then
+					--implement later
+				end
+				--local spawn minetest.find_nodes_in_area_under_air(vector.new(pos.x,pos.y-find_node_height,pos.z), vector.new(pos.x,pos.y+find_node_height,pos.z), {"group:solid"})
+
+
+				::continue:: --this is a safety catch
+			end
+		end
+	end
+end)
+
+
+
+
+
+
+
+
+
+
+
+
+
+--END SPAWNING ALGORITHM
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 -- register arrow for shoot attack
 function mobs:register_arrow(name, def)

mods/ENTITIES/mcl_mobs/init.lua

@@ -4,11 +4,8 @@ local path = minetest.get_modpath(minetest.get_current_modname())
 -- Mob API
 dofile(path .. "/api.lua")
 
--- Spawning Algorithm
-dofile(path .. "/spawning.lua")
-
 -- Rideable Mobs
 dofile(path .. "/mount.lua")
 
 -- Mob Items
-dofile(path .. "/crafts.lua")
+dofile(path .. "/crafts.lua")

mods/ENTITIES/mcl_mobs/spawning.lua

@@ -1,647 +0,0 @@
---lua locals
-local get_node       = minetest.get_node
-local get_item_group = minetest.get_item_group
-local get_node_light = minetest.get_node_light
-local find_nodes_in_area_under_air = minetest.find_nodes_in_area_under_air
-local new_vector     = vector.new
-local math_random    = math.random
-local get_biome_name = minetest.get_biome_name
-local max            = math.max
-local get_objects_inside_radius = minetest.get_objects_inside_radius
-local vector_distance = vector.distance
-
--- range for mob count
-local aoc_range = 32
---[[
-
-THIS IS THE BIG LIST OF ALL BIOMES - used for programming/updating mobs
-
-underground:
-"FlowerForest_underground",
-"JungleEdge_underground",local spawning_position = spawning_position_list[math.random(1,#spawning_position_list)]
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-
-ocean:
-"RoofedForest_ocean",
-"JungleEdgeM_ocean",
-"BirchForestM_ocean",
-"BirchForest_ocean",
-"IcePlains_deep_ocean",
-"Jungle_deep_ocean",
-"Savanna_ocean",
-"MesaPlateauF_ocean",
-"ExtremeHillsM_deep_ocean",
-"Savanna_deep_ocean",
-"SunflowerPlains_ocean",
-"Swampland_deep_ocean",
-"Swampland_ocean",
-"MegaSpruceTaiga_deep_ocean",
-"ExtremeHillsM_ocean",
-"JungleEdgeM_deep_ocean",
-"SunflowerPlains_deep_ocean",
-"BirchForest_deep_ocean",
-"IcePlainsSpikes_ocean",
-"Mesa_ocean",
-"StoneBeach_ocean",
-"Plains_deep_ocean",
-"JungleEdge_deep_ocean",
-"SavannaM_deep_ocean",
-"Desert_deep_ocean",
-"Mesa_deep_ocean",
-"ColdTaiga_deep_ocean",
-"Plains_ocean",
-"MesaPlateauFM_ocean",
-"Forest_deep_ocean",
-"JungleM_deep_ocean",
-"FlowerForest_deep_ocean",
-"MushroomIsland_ocean",
-"MegaTaiga_ocean",
-"StoneBeach_deep_ocean",
-"IcePlainsSpikes_deep_ocean",
-"ColdTaiga_ocean",
-"SavannaM_ocean",
-"MesaPlateauF_deep_ocean",
-"MesaBryce_deep_ocean",
-"ExtremeHills+_deep_ocean",
-"ExtremeHills_ocean",
-"MushroomIsland_deep_ocean",
-"Forest_ocean",
-"MegaTaiga_deep_ocean",
-"JungleEdge_ocean",
-"MesaBryce_ocean",
-"MegaSpruceTaiga_ocean",
-"ExtremeHills+_ocean",
-"Jungle_ocean",
-"RoofedForest_deep_ocean",
-"IcePlains_ocean",
-"FlowerForest_ocean",
-"ExtremeHills_deep_ocean",
-"MesaPlateauFM_deep_ocean",
-"Desert_ocean",
-"Taiga_ocean",
-"BirchForestM_deep_ocean",
-"Taiga_deep_ocean",
-"JungleM_ocean",
-
-water or beach?
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-
-beach:
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-
-dimension biome:
-"Nether",
-"End",
-
-Overworld regular:
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-]]--
-
-
-
-
-local mobs_spawn = minetest.settings:get_bool("mobs_spawn", true) ~= false
--- count how many mobs of one type are inside an area
-
-local count_mobs = function(pos,mobtype)
-	local num = 0
-	local objs = get_objects_inside_radius(pos, aoc_range)
-	for n = 1, #objs do
-		local obj = objs[n]:get_luaentity()
-		if obj and obj.name and obj._cmi_is_mob then
-			-- count hostile mobs only
-			if mobtype == "hostile" then
-				if obj.spawn_class == "hostile" then
-					num = num + 1
-				end
-			-- count passive mobs only
-			else
-				num = num + 1
-			end
-		end
-	end
-
-	return num
-end
-
-
--- global functions
-
-function mobs:spawn_abm_check(pos, node, name)
-	-- global function to add additional spawn checks
-	-- return true to stop spawning mob
-end
-
-
---[[
-	Custom elements changed:
-
-name:
-the mobs name
-
-dimension:
-"overworld"
-"nether"
-"end"
-
-types of spawning:
-"water"
-"ground"
-"lava"
-
-biomes: tells the spawner to allow certain mobs to spawn in certain biomes
-{"this", "that", "grasslands", "whatever"}
-
-
-what is aoc??? objects in area
-
-WARNING: BIOME INTEGRATION NEEDED -> How to get biome through lua??
-]]--
-
-
---this is where all of the spawning information is kept
-local spawn_dictionary = {}
-
-function mobs:spawn_specific(name, dimension, type_of_spawning, biomes, min_light, max_light, interval, chance, aoc, min_height, max_height, day_toggle, on_spawn)
-
-	--print(dump(biomes))
-
-	-- Do mobs spawn at all?
-	if not mobs_spawn then
-		return
-	end
-
-	-- chance/spawn number override in minetest.conf for registered mob
-	local numbers = minetest.settings:get(name)
-
-	if numbers then
-		numbers = numbers:split(",")
-		chance = tonumber(numbers[1]) or chance
-		aoc = tonumber(numbers[2]) or aoc
-
-		if chance == 0 then
-			minetest.log("warning", string.format("[mobs] %s has spawning disabled", name))
-			return
-		end
-
-		minetest.log("action",
-			string.format("[mobs] Chance setting for %s changed to %s (total: %s)", name, chance, aoc))
-	end
-
-	--[[
-	local spawn_action
-	spawn_action = function(pos, node, active_object_count, active_object_count_wider, name)
-
-			local orig_pos = table.copy(pos)
-			-- is mob actually registered?
-			if not mobs.spawning_mobs[name]
-			or not minetest.registered_entities[name] then
-				minetest.log("warning", "Mob spawn of "..name.." failed, unknown entity or mob is not registered for spawning!")
-				return
-			end
-
-			-- additional custom checks for spawning mob
-			if mobs:spawn_abm_check(pos, node, name) == true then
-				minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, ABM check rejected!")
-				return
-			end
-
-			-- count nearby mobs in same spawn class
-			local entdef = minetest.registered_entities[name]
-			local spawn_class = entdef and entdef.spawn_class
-			if not spawn_class then
-				if entdef.type == "monster" then
-					spawn_class = "hostile"
-				else
-					spawn_class = "passive"
-				end
-			end
-			local in_class_cap = count_mobs(pos, "!"..spawn_class) < MOB_CAP[spawn_class]
-			-- do not spawn if too many of same mob in area
-			if active_object_count_wider >= max_per_block -- large-range mob cap
-			or (not in_class_cap) -- spawn class mob cap
-			or count_mobs(pos, name) >= aoc then -- per-mob mob cap
-				-- too many entities
-				minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, too crowded!")
-				return
-			end
-
-			-- if toggle set to nil then ignore day/night check
-			if day_toggle ~= nil then
-
-				local tod = (minetest.get_timeofday() or 0) * 24000
-
-				if tod > 4500 and tod < 19500 then
-					-- daylight, but mob wants night
-					if day_toggle == false then
-						-- mob needs night
-						minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, mob needs light!")
-						return
-					end
-				else
-					-- night time but mob wants day
-					if day_toggle == true then
-						-- mob needs day
-						minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, mob needs daylight!")
-						return
-					end
-				end
-			end
-
-			-- spawn above node
-			pos.y = pos.y + 1
-
-			-- only spawn away from player
-			local objs = minetest.get_objects_inside_radius(pos, 24)
-
-			for n = 1, #objs do
-
-				if objs[n]:is_player() then
-					-- player too close
-					minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, player too close!")
-					return
-				end
-			end
-
-			-- mobs cannot spawn in protected areas when enabled
-			if not spawn_protected
-			and minetest.is_protected(pos, "") then
-				minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, position is protected!")
-				return
-			end
-
-			-- are we spawning within height limits?
-			if pos.y > max_height
-			or pos.y < min_height then
-				minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, out of height limit!")
-				return
-			end
-
-			-- are light levels ok?
-			local light = minetest.get_node_light(pos)
-			if not light
-			or light > max_light
-			or light < min_light then
-				minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, bad light!")
-				return
-			end
-
-			-- do we have enough space to spawn mob?
-			local ent = minetest.registered_entities[name]
-			local width_x = max(1, math.ceil(ent.collisionbox[4] - ent.collisionbox[1]))
-			local min_x, max_x
-			if width_x % 2 == 0 then
-				max_x = math.floor(width_x/2)
-				min_x = -(max_x-1)
-			else
-				max_x = math.floor(width_x/2)
-				min_x = -max_x
-			end
-
-			local width_z = max(1, math.ceil(ent.collisionbox[6] - ent.collisionbox[3]))
-			local min_z, max_z
-			if width_z % 2 == 0 then
-				max_z = math.floor(width_z/2)
-				min_z = -(max_z-1)
-			else
-				max_z = math.floor(width_z/2)
-				min_z = -max_z
-			end
-
-			local max_y = max(0, math.ceil(ent.collisionbox[5] - ent.collisionbox[2]) - 1)
-
-			for y = 0, max_y do
-				for x = min_x, max_x do
-					for z = min_z, max_z do
-						local pos2 = {x = pos.x+x, y = pos.y+y, z = pos.z+z}
-						if minetest.registered_nodes[node_ok(pos2).name].walkable == true then
-							-- inside block
-							minetest.log("info", "Mob spawn of "..name.." at "..minetest.pos_to_string(pos).." failed, too little space!")
-							if ent.spawn_small_alternative ~= nil and (not minetest.registered_nodes[node_ok(pos).name].walkable) then
-								minetest.log("info", "Trying to spawn smaller alternative mob: "..ent.spawn_small_alternative)
-								spawn_action(orig_pos, node, active_object_count, active_object_count_wider, ent.spawn_small_alternative)
-							end
-							return
-						end
-					end
-				end
-			end
-
-			-- tweak X/Y/Z spawn pos
-			if width_x % 2 == 0 then
-				pos.x = pos.x + 0.5
-			end
-			if width_z % 2 == 0 then
-				pos.z = pos.z + 0.5
-			end
-			pos.y = pos.y - 0.5
-
-			local mob = minetest.add_entity(pos, name)
-			minetest.log("action", "Mob spawned: "..name.." at "..minetest.pos_to_string(pos))
-
-			if on_spawn then
-
-				local ent = mob:get_luaentity()
-
-				on_spawn(ent, pos)
-			end
-	end
-
-	local function spawn_abm_action(pos, node, active_object_count, active_object_count_wider)
-		spawn_action(pos, node, active_object_count, active_object_count_wider, name)
-	end
-	]]--
-
-	local entdef = minetest.registered_entities[name]
-	local spawn_class
-	if entdef.type == "monster" then
-		spawn_class = "hostile"
-	else
-		spawn_class = "passive"
-	end
-
-	--load information into the spawn dictionary
-	local key = #spawn_dictionary + 1
-	spawn_dictionary[key]               = {}
-	spawn_dictionary[key]["name"]       = name
-	spawn_dictionary[key]["dimension"]  = dimension
-	spawn_dictionary[key]["type_of_spawning"] = type_of_spawning
-	spawn_dictionary[key]["biomes"]     = biomes
-	spawn_dictionary[key]["min_light"]  = min_light
-	spawn_dictionary[key]["max_light"]  = max_light
-	spawn_dictionary[key]["interval"]   = interval
-	spawn_dictionary[key]["chance"]     = chance
-	spawn_dictionary[key]["aoc"]        = aoc
-	spawn_dictionary[key]["min_height"] = min_height
-	spawn_dictionary[key]["max_height"] = max_height
-	spawn_dictionary[key]["day_toggle"] = day_toggle
-	--spawn_dictionary[key]["on_spawn"]   = spawn_abm_action
-	spawn_dictionary[key]["spawn_class"] = spawn_class
-
-	--[[
-	minetest.register_abm({
-		label = name .. " spawning",
-		nodenames = nodes,
-		neighbors = neighbors,
-		interval = interval,
-		chance = floor(max(1, chance * mobs_spawn_chance)),
-		catch_up = false,
-		action = spawn_abm_action,
-	})
-	]]--
-end
-
--- compatibility with older mob registration
--- we're going to forget about this for now -j4i
---[[
-function mobs:register_spawn(name, nodes, max_light, min_light, chance, active_object_count, max_height, day_toggle)
-
-	mobs:spawn_specific(name, nodes, {"air"}, min_light, max_light, 30,
-		chance, active_object_count, -31000, max_height, day_toggle)
-end
-]]--
-
-
---Don't disable this yet-j4i
--- MarkBu's spawn function
-
-function mobs:spawn(def)
-	--does nothing for now
-	--[[
-	local name = def.name
-	local nodes = def.nodes or {"group:soil", "group:stone"}
-	local neighbors = def.neighbors or {"air"}
-	local min_light = def.min_light or 0
-	local max_light = def.max_light or 15
-	local interval = def.interval or 30
-	local chance = def.chance or 5000
-	local active_object_count = def.active_object_count or 1
-	local min_height = def.min_height or -31000
-	local max_height = def.max_height or 31000
-	local day_toggle = def.day_toggle
-	local on_spawn = def.on_spawn
-
-	mobs:spawn_specific(name, nodes, neighbors, min_light, max_light, interval,
-		chance, active_object_count, min_height, max_height, day_toggle, on_spawn)
-		]]--
-end
-
-
-
-local axis
---inner and outer part of square donut radius
-local inner = 1
-local outer = 65
-local int = {-1,1}
-local position_calculation = function(pos)
-
-	pos = vector.floor(pos)
-
-	--this is used to determine the axis buffer from the player
-	axis = math.random(0,1)
-
-	--cast towards the direction
-	if axis == 0 then --x
-		pos.x = pos.x + math.random(inner,outer)*int[math.random(1,2)]
-		pos.z = pos.z + math.random(-outer,outer)
-	else --z
-		pos.z = pos.z + math.random(inner,outer)*int[math.random(1,2)]
-		pos.x = pos.x + math.random(-outer,outer)
-	end
-	return(pos)
-end
-
---[[
-local decypher_limits_dictionary = {
-	["overworld"] = {mcl_vars.mg_overworld_min,mcl_vars.mg_overworld_max},
-	["nether"]    = {mcl_vars.mg_nether_min,   mcl_vars.mg_nether_max},
-	["end"]       = {mcl_vars.mg_end_min,      mcl_vars.mg_end_max}
-}
-]]--
-
-local function decypher_limits(posy)
-	--local min_max_table = decypher_limits_dictionary[dimension]
-	--return min_max_table[1],min_max_table[2]
-	posy = math.floor(posy)
-	return posy - 32, posy + 32
-end
-
---a simple helper function for mob_spawn
-local function biome_check(biome_list, biome_goal)
-	for _,data in ipairs(biome_list) do
-		if data == biome_goal then
-			return true
-		end
-	end
-
-	return false
-end
-
-
---todo mob limiting
---MAIN LOOP
-
-if mobs_spawn then
-	local timer = 0
-	minetest.register_globalstep(function(dtime)
-		timer = timer + dtime
-		if timer >= 8 then
-			timer = 0
-			for _,player in pairs(minetest.get_connected_players()) do
-				for i = 1,math_random(3,8) do
-					repeat -- after this line each "break" means "continue"
-						local player_pos = player:get_pos()
-
-						local _,dimension = mcl_worlds.y_to_layer(player_pos.y)
-
-						if dimension == "void" or dimension == "default" then
-							break -- ignore void and unloaded area
-						end
-
-						local min,max = decypher_limits(player_pos.y)
-
-						local goal_pos = position_calculation(player_pos)
-
-						local spawning_position_list = find_nodes_in_area_under_air(new_vector(goal_pos.x,min,goal_pos.z), vector.new(goal_pos.x,max,goal_pos.z), {"group:solid", "group:water", "group:lava"})
-
-						--couldn't find node
-						if #spawning_position_list <= 0 then
-							break
-						end
-
-						local spawning_position = spawning_position_list[math_random(1,#spawning_position_list)]
-
-						--Prevent strange behavior/too close to player
-						if not spawning_position or vector_distance(player_pos, spawning_position) < 15 then
-							break
-						end
-
-						local gotten_node = get_node(spawning_position).name
-
-						if not gotten_node or gotten_node == "air" then --skip air nodes
-							break
-						end
-
-						local gotten_biome = minetest.get_biome_data(spawning_position)
-
-						if not gotten_biome then
-							break --skip if in unloaded area
-						end
-
-						gotten_biome = get_biome_name(gotten_biome.biome) --makes it easier to work with
-
-						--grab random mob
-						local mob_def = spawn_dictionary[math.random(1,#spawn_dictionary)]
-
-						if not mob_def then
-							break --skip if something ridiculous happens (nil mob def)
-						end
-
-						--skip if not correct dimension
-						if mob_def.dimension ~= dimension then
-							break
-						end
-
-						--skip if not in correct biome
-						if not biome_check(mob_def.biomes, gotten_biome) then
-							break
-						end
-
-						--add this so mobs don't spawn inside nodes
-						spawning_position.y = spawning_position.y + 1
-
-						if spawning_position.y < mob_def.min_height or spawning_position.y > mob_def.max_height then
-							break
-						end
-
-						--only need to poll for node light if everything else worked
-						local gotten_light = get_node_light(spawning_position)
-
-						--don't spawn if not in light limits
-						if gotten_light < mob_def.min_light or gotten_light > mob_def.max_light then
-							break
-						end
-
-						local is_water = get_item_group(gotten_node, "water") ~= 0
-						local is_lava  = get_item_group(gotten_node, "lava") ~= 0
-
-						if mob_def.type_of_spawning == "ground" and is_water then
-							break
-						end
-
-						if mob_def.type_of_spawning == "ground" and is_lava then
-							break
-						end
-
-						--finally do the heavy check (for now) of mobs in area
-						if count_mobs(spawning_position, mob_def.spawn_class) >= mob_def.aoc then
-							break
-						end
-
-						--adjust the position for water and lava mobs
-						if mob_def.type_of_spawning == "water"  or mob_def.type_of_spawning == "lava" then
-							spawning_position.y = spawning_position.y - 1
-						end
-
-						--everything is correct, spawn mob
-						minetest.add_entity(spawning_position, mob_def.name)
-					until true --this is a safety catch
-				end
-			end
-		end
-	end)
-end

mods/ENTITIES/mobs_mc/0_gameconfig.lua

@@ -290,13 +290,13 @@ mobs_mc.spawn = {
 mobs_mc.spawn_height = {
 	water = tonumber(minetest.settings:get("water_level")) or 0, -- Water level in the Overworld
 
-	-- Overworld boundaries (inclusive) --I adjusted this to be more reasonable
-	overworld_min = -64,-- -2999,
+	-- Overworld boundaries (inclusive)
+	overworld_min = -2999,
 	overworld_max = 31000,
 
 	-- Nether boundaries (inclusive)
-	nether_min = -29067,-- -3369,
-	nether_max = -28939,-- -3000,
+	nether_min = -3369,
+	nether_max = -3000,
 
 	-- End boundaries (inclusive)
 	end_min = -6200,

mods/ENTITIES/mobs_mc/bat.lua

@@ -64,81 +64,7 @@ else
 end
 
 -- Spawn on solid blocks at or below Sea level and the selected light level
-mobs:spawn_specific(
-"mobs_mc:bat",
-"overworld",
-"ground",
-{
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-},
-0,
-maxlight,
-20,
-5000,
-2,
-mobs_mc.spawn_height.overworld_min,
-mobs_mc.spawn_height.water-1)
+mobs:spawn_specific("mobs_mc:bat", "overworld", "air", 0, maxlight, 20, 5000, 2, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.water-1)
 
 
 -- spawn eggs

mods/ENTITIES/mobs_mc/blaze.lua

@@ -128,18 +128,7 @@ mobs:register_mob("mobs_mc:blaze", {
 	end,
 })
 
-mobs:spawn_specific(
-"mobs_mc:blaze",
-"nether",
-"ground",
-{"Nether"},
-0,
-minetest.LIGHT_MAX+1,
-30,
-5000,
-3,
-mobs_mc.spawn_height.nether_min,
-mobs_mc.spawn_height.nether_max)
+mobs:spawn_specific("mobs_mc:blaze", "nether", "ground", 0, minetest.LIGHT_MAX+1, 30, 5000, 3, mobs_mc.spawn_height.nether_min, mobs_mc.spawn_height.nether_max)
 
 -- Blaze fireball
 mobs:register_arrow("mobs_mc:blaze_fireball", {

mods/ENTITIES/mobs_mc/chicken.lua

@@ -100,34 +100,7 @@ mobs:register_mob("mobs_mc:chicken", {
 })
 
 --spawn
-mobs:spawn_specific(
-"mobs_mc:chicken", 
-"overworld", 
-"ground",
-{
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"ColdTaiga",
-"SunflowerPlains",
-"RoofedForest",
-"MesaPlateauFM_grasstop",
-"ExtremeHillsM",
-"BirchForestM",
-},
-9, 
-minetest.LIGHT_MAX+1, 
-30, 17000, 
-3, 
-mobs_mc.spawn_height.water,
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:chicken", "overworld", "ground", 9, minetest.LIGHT_MAX+1, 30, 17000, 3, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:chicken", S("Chicken"), "mobs_mc_spawn_icon_chicken.png", 0)

mods/ENTITIES/mobs_mc/cow+mooshroom.lua

@@ -145,53 +145,9 @@ mobs:register_mob("mobs_mc:mooshroom", mooshroom_def)
 
 
 -- Spawning
-mobs:spawn_specific(
-"mobs_mc:cow",
-"overworld", 
-"ground",
-{
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"ColdTaiga",
-"SunflowerPlains",
-"RoofedForest",
-"MesaPlateauFM_grasstop",
-"ExtremeHillsM",
-"BirchForestM",
-},
-9, 
-minetest.LIGHT_MAX+1, 
-30, 
-17000, 
-10, 
-mobs_mc.spawn_height.water, 
-mobs_mc.spawn_height.overworld_max)
-
-
-
-mobs:spawn_specific(
-"mobs_mc:mooshroom", 
-"overworld", 
-"ground",
-{
-"MushroomIslandShore",
-"MushroomIsland"
-},
-9, 
-minetest.LIGHT_MAX+1, 
-30, 
-17000, 
-5, 
-mobs_mc.spawn_height.overworld_min, 
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:cow", "overworld", "ground", 9, minetest.LIGHT_MAX+1, 30, 17000, 10, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
+--WARNING: THIS NEEDS A BIOME INTEGRATION
+mobs:spawn_specific("mobs_mc:mooshroom", "overworld", "ground", 9, minetest.LIGHT_MAX+1, 30, 17000, 5, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 
 -- spawn egg
 mobs:register_egg("mobs_mc:cow", S("Cow"), "mobs_mc_spawn_icon_cow.png", 0)

mods/ENTITIES/mobs_mc/creeper.lua

@@ -253,158 +253,7 @@ mobs:register_mob("mobs_mc:creeper_charged", {
 	glow = 3,
 })
 
-mobs:spawn_specific(
-"mobs_mc:creeper", 
-"overworld", 
-"ground",
-{
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-"RoofedForest_ocean",
-"JungleEdgeM_ocean",
-"BirchForestM_ocean",
-"BirchForest_ocean",
-"IcePlains_deep_ocean",
-"Jungle_deep_ocean",
-"Savanna_ocean",
-"MesaPlateauF_ocean",
-"ExtremeHillsM_deep_ocean",
-"Savanna_deep_ocean",
-"SunflowerPlains_ocean",
-"Swampland_deep_ocean",
-"Swampland_ocean",
-"MegaSpruceTaiga_deep_ocean",
-"ExtremeHillsM_ocean",
-"JungleEdgeM_deep_ocean",
-"SunflowerPlains_deep_ocean",
-"BirchForest_deep_ocean",
-"IcePlainsSpikes_ocean",
-"Mesa_ocean",
-"StoneBeach_ocean",
-"Plains_deep_ocean",
-"JungleEdge_deep_ocean",
-"SavannaM_deep_ocean",
-"Desert_deep_ocean",
-"Mesa_deep_ocean",
-"ColdTaiga_deep_ocean",
-"Plains_ocean",
-"MesaPlateauFM_ocean",
-"Forest_deep_ocean",
-"JungleM_deep_ocean",
-"FlowerForest_deep_ocean",
-"MushroomIsland_ocean",
-"MegaTaiga_ocean",
-"StoneBeach_deep_ocean",
-"IcePlainsSpikes_deep_ocean",
-"ColdTaiga_ocean",
-"SavannaM_ocean",
-"MesaPlateauF_deep_ocean",
-"MesaBryce_deep_ocean",
-"ExtremeHills+_deep_ocean",
-"ExtremeHills_ocean",
-"MushroomIsland_deep_ocean",
-"Forest_ocean",
-"MegaTaiga_deep_ocean",
-"JungleEdge_ocean",
-"MesaBryce_ocean",
-"MegaSpruceTaiga_ocean",
-"ExtremeHills+_ocean",
-"Jungle_ocean",
-"RoofedForest_deep_ocean",
-"IcePlains_ocean",
-"FlowerForest_ocean",
-"ExtremeHills_deep_ocean",
-"MesaPlateauFM_deep_ocean",
-"Desert_ocean",
-"Taiga_ocean",
-"BirchForestM_deep_ocean",
-"Taiga_deep_ocean",
-"JungleM_ocean",
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-},
-0, 
-7, 
-20, 
-16500, 
-2, 
-mobs_mc.spawn_height.overworld_min, 
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:creeper", "overworld", "ground", 0, 7, 20, 16500, 2, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:creeper", S("Creeper"), "mobs_mc_spawn_icon_creeper.png", 0)

mods/ENTITIES/mobs_mc/depends.txt

@@ -1 +0,0 @@
-mcl_mobs

mods/ENTITIES/mobs_mc/ender_dragon.lua

@@ -60,23 +60,7 @@ mobs:register_mob("mobs_mc:enderdragon", {
 	},
 	ignores_nametag = true,
 	do_custom = function(self)
-		mcl_bossbars.update_boss(self.object, "Ender Dragon", "light_purple")
-		for _, obj in ipairs(minetest.get_objects_inside_radius(self.object:get_pos(), 80)) do
-			local luaentity = obj:get_luaentity()
-			if luaentity and luaentity.name == "mcl_end:crystal" then
-				if luaentity.beam then
-					if luaentity.beam == self.beam then
-						break
-					end
-				else
-					if self.beam then
-						self.beam:remove()
-					end
-					minetest.add_entity(self.object:get_pos(), "mcl_end:crystal_beam"):get_luaentity():init(self.object, obj)
-					break
-				end
-			end
-		end
+		mcl_bossbars.update_boss(self, "Ender Dragon", "light_purple")
 		if self._portal_pos then
 			-- migrate old format
 			if type(self._portal_pos) == "string" then

mods/ENTITIES/mobs_mc/enderman.lua

@@ -323,7 +323,7 @@ mobs:register_mob("mobs_mc:enderman", {
 			--	self:teleport(nil)
 			--	self.state = ""
 			--else
-				if self.attack ~= nil and not minetest.settings:get_bool("creative_mode") then
+				if self.attack ~= nil then
 					self.state = 'attack'
 				end
 			--end
@@ -346,28 +346,29 @@ mobs:register_mob("mobs_mc:enderman", {
 					--skip player if they have no data - log it
 					if not player_eye_height then
 						minetest.log("error", "Enderman at location: ".. dump(enderpos).." has indexed a null player!")
-					else
-
-						--calculate very quickly the exact location the player is looking
-						--within the distance between the two "heads" (player and enderman)
-						local look_pos = vector.new(player_pos.x, player_pos.y + player_eye_height, player_pos.z)
-						local look_pos_base = look_pos
-						local ender_eye_pos = vector.new(enderpos.x, enderpos.y + 2.75, enderpos.z)
-						local eye_distance_from_player = vector.distance(ender_eye_pos, look_pos)
-						look_pos = vector.add(look_pos, vector.multiply(look_dir, eye_distance_from_player))
-					
-						--if looking in general head position, turn hostile
-						if minetest.line_of_sight(ender_eye_pos, look_pos_base) and vector.distance(look_pos, ender_eye_pos) <= 0.4 then
-							self.provoked = "staring"
-							self.attack = minetest.get_player_by_name(obj:get_player_name())
-							break
-						else -- I'm not sure what this part does, but I don't want to break anything - jordan4ibanez
-							if self.provoked == "staring" then
-								self.provoked = "broke_contact"
-							end						
-						end
-
+						goto continue
 					end
+
+					--calculate very quickly the exact location the player is looking
+					--within the distance between the two "heads" (player and enderman)
+					local look_pos = vector.new(player_pos.x, player_pos.y + player_eye_height, player_pos.z)
+					local look_pos_base = look_pos
+					local ender_eye_pos = vector.new(enderpos.x, enderpos.y + 2.75, enderpos.z)
+					local eye_distance_from_player = vector.distance(ender_eye_pos, look_pos)
+					look_pos = vector.add(look_pos, vector.multiply(look_dir, eye_distance_from_player))
+					
+					--if looking in general head position, turn hostile
+					if minetest.line_of_sight(ender_eye_pos, look_pos_base) and vector.distance(look_pos, ender_eye_pos) <= 0.4 then
+						self.provoked = "staring"
+						self.attack = minetest.get_player_by_name(obj:get_player_name())
+						break
+					else -- I'm not sure what this part does, but I don't want to break anything - jordan4ibanez
+						if self.provoked == "staring" then
+							self.provoked = "broke_contact"
+						end						
+					end
+
+					::continue:: -- this is a sweep over statement, this can be used to continue even when errors occurred
 				end
 			end
 		end
@@ -561,189 +562,11 @@ mobs:register_mob("mobs_mc:enderman", {
 
 
 -- End spawn
-mobs:spawn_specific(
-"mobs_mc:enderman", 
-"end", 
-"ground",
-{
-"End"
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-3000, 
-12, 
-mobs_mc.spawn_height.end_min, 
-mobs_mc.spawn_height.end_max)
+mobs:spawn_specific("mobs_mc:enderman", "end", "ground", 0, minetest.LIGHT_MAX+1, 30, 3000, 12, mobs_mc.spawn_height.end_min, mobs_mc.spawn_height.end_max)
 -- Overworld spawn
-mobs:spawn_specific(
-"mobs_mc:enderman", 
-"overworld", 
-"ground",
-{
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-"RoofedForest_ocean",
-"JungleEdgeM_ocean",
-"BirchForestM_ocean",
-"BirchForest_ocean",
-"IcePlains_deep_ocean",
-"Jungle_deep_ocean",
-"Savanna_ocean",
-"MesaPlateauF_ocean",
-"ExtremeHillsM_deep_ocean",
-"Savanna_deep_ocean",
-"SunflowerPlains_ocean",
-"Swampland_deep_ocean",
-"Swampland_ocean",
-"MegaSpruceTaiga_deep_ocean",
-"ExtremeHillsM_ocean",
-"JungleEdgeM_deep_ocean",
-"SunflowerPlains_deep_ocean",
-"BirchForest_deep_ocean",
-"IcePlainsSpikes_ocean",
-"Mesa_ocean",
-"StoneBeach_ocean",
-"Plains_deep_ocean",
-"JungleEdge_deep_ocean",
-"SavannaM_deep_ocean",
-"Desert_deep_ocean",
-"Mesa_deep_ocean",
-"ColdTaiga_deep_ocean",
-"Plains_ocean",
-"MesaPlateauFM_ocean",
-"Forest_deep_ocean",
-"JungleM_deep_ocean",
-"FlowerForest_deep_ocean",
-"MushroomIsland_ocean",
-"MegaTaiga_ocean",
-"StoneBeach_deep_ocean",
-"IcePlainsSpikes_deep_ocean",
-"ColdTaiga_ocean",
-"SavannaM_ocean",
-"MesaPlateauF_deep_ocean",
-"MesaBryce_deep_ocean",
-"ExtremeHills+_deep_ocean",
-"ExtremeHills_ocean",
-"MushroomIsland_deep_ocean",
-"Forest_ocean",
-"MegaTaiga_deep_ocean",
-"JungleEdge_ocean",
-"MesaBryce_ocean",
-"MegaSpruceTaiga_ocean",
-"ExtremeHills+_ocean",
-"Jungle_ocean",
-"RoofedForest_deep_ocean",
-"IcePlains_ocean",
-"FlowerForest_ocean",
-"ExtremeHills_deep_ocean",
-"MesaPlateauFM_deep_ocean",
-"Desert_ocean",
-"Taiga_ocean",
-"BirchForestM_deep_ocean",
-"Taiga_deep_ocean",
-"JungleM_ocean",
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-},
-0, 
-7, 
-30, 
-19000, 
-2, 
-mobs_mc.spawn_height.overworld_min, 
-mobs_mc.spawn_height.overworld_max)
-
+mobs:spawn_specific("mobs_mc:enderman", "overworld", "ground", 0, 7, 30, 19000, 2, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 -- Nether spawn (rare)
-mobs:spawn_specific(
-"mobs_mc:enderman", 
-"nether", 
-"ground",
-{
-"Nether"
-},
-0, 
-7, 
-30, 
-27500, 
-4, 
-mobs_mc.spawn_height.nether_min, 
-mobs_mc.spawn_height.nether_max)
+mobs:spawn_specific("mobs_mc:enderman", "nether", "ground", 0, 7, 30, 27500, 4, mobs_mc.spawn_height.nether_min, mobs_mc.spawn_height.nether_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:enderman", S("Enderman"), "mobs_mc_spawn_icon_enderman.png", 0)

mods/ENTITIES/mobs_mc/ghast.lua

@@ -75,20 +75,7 @@ mobs:register_mob("mobs_mc:ghast", {
 })
 
 
-mobs:spawn_specific(
-"mobs_mc:ghast", 
-"nether", 
-"ground",
-{
-"Nether"
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-18000, 
-2, 
-mobs_mc.spawn_height.nether_min, 
-mobs_mc.spawn_height.nether_max)
+mobs:spawn_specific("mobs_mc:ghast", "nether", "air", 0, minetest.LIGHT_MAX+1, 30, 18000, 2, mobs_mc.spawn_height.nether_min, mobs_mc.spawn_height.nether_max)
 
 -- fireball (projectile)
 mobs:register_arrow("mobs_mc:fireball", {

mods/ENTITIES/mobs_mc/horse.lua

@@ -510,56 +510,8 @@ mobs:register_mob("mobs_mc:mule", mule)
 
 --===========================
 --Spawn Function
-mobs:spawn_specific(
-"mobs_mc:horse",
-"overworld",
-"ground",
-{
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"ColdTaiga",
-"SunflowerPlains",
-"RoofedForest",
-"MesaPlateauFM_grasstop",
-"ExtremeHillsM",
-"BirchForestM",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-15000, 
-4, 
-mobs_mc.spawn_height.water+3, 
-mobs_mc.spawn_height.overworld_max)
-
-
-mobs:spawn_specific(
-"mobs_mc:donkey", 
-"overworld", 
-"ground",
-{
-"Mesa",
-"MesaPlateauFM_grasstop",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-15000, 
-4, 
-mobs_mc.spawn_height.water+3, 
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:horse", "overworld", "ground", 0, minetest.LIGHT_MAX+1, 30, 15000, 4, mobs_mc.spawn_height.water+3, mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:donkey", "overworld", "ground", 0, minetest.LIGHT_MAX+1, 30, 15000, 4, mobs_mc.spawn_height.water+3, mobs_mc.spawn_height.overworld_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:horse", S("Horse"), "mobs_mc_spawn_icon_horse.png", 0)

mods/ENTITIES/mobs_mc/llama.lua

@@ -217,25 +217,7 @@ mobs:register_mob("mobs_mc:llama", {
 })
 
 --spawn
-mobs:spawn_specific(
-"mobs_mc:llama",
-"overworld",
-"ground",
-{
-"Mesa",
-"MesaPlateauFM_grasstop",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-15000, 
-5, 
-mobs_mc.spawn_height.water+15, 
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:llama", "overworld", "ground", 0, minetest.LIGHT_MAX+1, 30, 15000, 5, mobs_mc.spawn_height.water+15, mobs_mc.spawn_height.overworld_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:llama", S("Llama"), "mobs_mc_spawn_icon_llama.png", 0)

mods/ENTITIES/mobs_mc/ocelot.lua

@@ -153,23 +153,7 @@ local base_spawn_chance = 5000
 
 -- Spawn ocelot
 --they get the same as the llama because I'm trying to rework so much of this code right now -j4i
-mobs:spawn_specific(
-"mobs_mc:ocelot", 
-"overworld", 
-"ground",
-{
-"Jungle",
-"JungleEdgeM",
-"JungleM",
-"JungleEdge",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-15000, 
-5, 
-mobs_mc.spawn_height.water+15, 
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:ocelot", "overworld", "ground", 0, minetest.LIGHT_MAX+1, 30, 15000, 5, mobs_mc.spawn_height.water+15, mobs_mc.spawn_height.overworld_max)
 --[[
 mobs:spawn({
 	name = "mobs_mc:ocelot",

mods/ENTITIES/mobs_mc/parrot.lua

@@ -91,23 +91,7 @@ mobs:register_mob("mobs_mc:parrot", {
 })
 
 -- Parrots spawn rarely in jungles. TODO: Also check for jungle *biome* <- I'll get to this eventually -j4i
-mobs:spawn_specific(
-"mobs_mc:parrot",
-"overworld", 
-"ground",
-{
-"Jungle",
-"JungleEdgeM",
-"JungleM",
-"JungleEdge",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-7, 
-30000, 
-1, 
-mobs_mc.spawn_height.water+7, 
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:parrot","overworld", "air", 0, minetest.LIGHT_MAX+1, 7, 30000, 1, mobs_mc.spawn_height.water+7, mobs_mc.spawn_height.overworld_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:parrot", S("Parrot"), "mobs_mc_spawn_icon_parrot.png", 0)

mods/ENTITIES/mobs_mc/pig.lua

@@ -182,35 +182,7 @@ mobs:register_mob("mobs_mc:pig", {
 	end,
 })
 
-mobs:spawn_specific(
-"mobs_mc:pig", 
-"overworld", 
-"ground",
-{
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"ColdTaiga",
-"SunflowerPlains",
-"RoofedForest",
-"MesaPlateauFM_grasstop",
-"ExtremeHillsM",
-"BirchForestM",
-},
-9, 
-minetest.LIGHT_MAX+1, 
-30, 
-15000, 
-8, 
-mobs_mc.spawn_height.overworld_min, 
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:pig", "overworld", "ground", 9, minetest.LIGHT_MAX+1, 30, 15000, 8, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:pig", S("Pig"), "mobs_mc_spawn_icon_pig.png", 0)

mods/ENTITIES/mobs_mc/polar_bear.lua

@@ -67,23 +67,7 @@ mobs:register_mob("mobs_mc:polar_bear", {
 })
 
 
-mobs:spawn_specific(
-"mobs_mc:polar_bear",
-"overworld",
-"ground",
-{
-"ColdTaiga",
-"IcePlainsSpikes",
-"IcePlains",
-"ExtremeHills+_snowtop",
-},
-0,
-minetest.LIGHT_MAX+1,
-30,
-7000,
-3,
-mobs_mc.spawn_height.overworld_min,
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:polar_bear", "overworld", "ground", 0, minetest.LIGHT_MAX+1, 30, 7000, 3, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 
 -- spawn egg
 mobs:register_egg("mobs_mc:polar_bear", S("Polar Bear"), "mobs_mc_spawn_icon_polarbear.png", 0)

mods/ENTITIES/mobs_mc/rabbit.lua

@@ -109,35 +109,7 @@ mobs:register_mob("mobs_mc:killer_bunny", killer_bunny)
 -- Mob spawning rules.
 -- Different skins depending on spawn location <- we'll get to this when the spawning algorithm is fleshed out
 
-mobs:spawn_specific(
-"mobs_mc:rabbit", 
-"overworld", 
-"ground",
-{
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"ColdTaiga",
-"SunflowerPlains",
-"RoofedForest",
-"MesaPlateauFM_grasstop",
-"ExtremeHillsM",
-"BirchForestM",
-},
-9, 
-minetest.LIGHT_MAX+1, 
-30, 
-15000, 
-8, 
-mobs_mc.spawn_height.overworld_min, 
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:rabbit", "overworld", "ground", 9, minetest.LIGHT_MAX+1, 30, 15000, 8, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 
 --[[
 local spawn = {

mods/ENTITIES/mobs_mc/sheep.lua

@@ -303,35 +303,7 @@ mobs:register_mob("mobs_mc:sheep", {
 		end
 	end,
 })
-mobs:spawn_specific(
-"mobs_mc:sheep",
-"overworld",
-"ground",
-{
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"ColdTaiga",
-"SunflowerPlains",
-"RoofedForest",
-"MesaPlateauFM_grasstop",
-"ExtremeHillsM",
-"BirchForestM",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-15000, 
-3, 
-mobs_mc.spawn_height.overworld_min, 
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:sheep", "overworld", "ground", 0, minetest.LIGHT_MAX+1, 30, 15000, 3, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:sheep", S("Sheep"), "mobs_mc_spawn_icon_sheep.png", 0)

mods/ENTITIES/mobs_mc/shulker.lua

@@ -81,17 +81,4 @@ mobs:register_arrow("mobs_mc:shulkerbullet", {
 
 mobs:register_egg("mobs_mc:shulker", S("Shulker"), "mobs_mc_spawn_icon_shulker.png", 0)
 
-mobs:spawn_specific(
-"mobs_mc:shulker", 
-"end", 
-"ground",
-{
-"End"
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-5000, 
-2, 
-mobs_mc.spawn_height.end_min, 
-mobs_mc.spawn_height.end_max)
+mobs:spawn_specific("mobs_mc:shulker", "end", "ground", 0, minetest.LIGHT_MAX+1, 30, 5000, 2, mobs_mc.spawn_height.end_min, mobs_mc.spawn_height.end_max)

mods/ENTITIES/mobs_mc/skeleton+stray.lua

@@ -30,14 +30,13 @@ local skeleton = {
 		"mcl_bows_bow_0.png", -- bow
 		"mobs_mc_skeleton.png", -- skeleton
 	} },
-	visual_size = {x=1, y=1},
+	visual_size = {x=3, y=3},
 	makes_footstep_sound = true,
-	textures = {
-		{
-			"mobs_mc_empty.png", -- armor
-			"mobs_mc_skeleton.png", -- texture
-			"mcl_bows_bow_0.png", -- wielded_item
-		}
+	sounds = {
+		random = "mobs_mc_skeleton_random",
+		death = "mobs_mc_skeleton_death",
+		damage = "mobs_mc_skeleton_hurt",
+		distance = 16,
 	},
 	walk_velocity = 1.2,
 	run_velocity = 2.4,
@@ -112,9 +111,9 @@ local stray = table.copy(skeleton)
 stray.mesh = "mobs_mc_stray.b3d"
 stray.textures = {
 	{
-		"mobs_mc_stray_overlay.png",
-		"mobs_mc_stray.png",
 		"mcl_bows_bow_0.png",
+		"mobs_mc_stray.png",
+		"mobs_mc_stray_overlay.png",
 	},
 }
 -- TODO: different sound (w/ echo)
@@ -140,195 +139,13 @@ table.insert(stray.drops, {
 mobs:register_mob("mobs_mc:stray", stray)
 
 -- Overworld spawn
-mobs:spawn_specific(
-"mobs_mc:skeleton",
-"overworld",
-"ground",
-{
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-"RoofedForest_ocean",
-"JungleEdgeM_ocean",
-"BirchForestM_ocean",
-"BirchForest_ocean",
-"IcePlains_deep_ocean",
-"Jungle_deep_ocean",
-"Savanna_ocean",
-"MesaPlateauF_ocean",
-"ExtremeHillsM_deep_ocean",
-"Savanna_deep_ocean",
-"SunflowerPlains_ocean",
-"Swampland_deep_ocean",
-"Swampland_ocean",
-"MegaSpruceTaiga_deep_ocean",
-"ExtremeHillsM_ocean",
-"JungleEdgeM_deep_ocean",
-"SunflowerPlains_deep_ocean",
-"BirchForest_deep_ocean",
-"IcePlainsSpikes_ocean",
-"Mesa_ocean",
-"StoneBeach_ocean",
-"Plains_deep_ocean",
-"JungleEdge_deep_ocean",
-"SavannaM_deep_ocean",
-"Desert_deep_ocean",
-"Mesa_deep_ocean",
-"ColdTaiga_deep_ocean",
-"Plains_ocean",
-"MesaPlateauFM_ocean",
-"Forest_deep_ocean",
-"JungleM_deep_ocean",
-"FlowerForest_deep_ocean",
-"MushroomIsland_ocean",
-"MegaTaiga_ocean",
-"StoneBeach_deep_ocean",
-"IcePlainsSpikes_deep_ocean",
-"ColdTaiga_ocean",
-"SavannaM_ocean",
-"MesaPlateauF_deep_ocean",
-"MesaBryce_deep_ocean",
-"ExtremeHills+_deep_ocean",
-"ExtremeHills_ocean",
-"MushroomIsland_deep_ocean",
-"Forest_ocean",
-"MegaTaiga_deep_ocean",
-"JungleEdge_ocean",
-"MesaBryce_ocean",
-"MegaSpruceTaiga_ocean",
-"ExtremeHills+_ocean",
-"Jungle_ocean",
-"RoofedForest_deep_ocean",
-"IcePlains_ocean",
-"FlowerForest_ocean",
-"ExtremeHills_deep_ocean",
-"MesaPlateauFM_deep_ocean",
-"Desert_ocean",
-"Taiga_ocean",
-"BirchForestM_deep_ocean",
-"Taiga_deep_ocean",
-"JungleM_ocean",
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-},
-0,
-7,
-20,
-17000,
-2,
-mobs_mc.spawn_height.overworld_min,
-mobs_mc.spawn_height.overworld_max)
-
-
+mobs:spawn_specific("mobs_mc:skeleton", "overworld", "ground", 0, 7, 20, 17000, 2, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 -- Nether spawn
-mobs:spawn_specific(
-"mobs_mc:skeleton",
-"nether",
-"ground",
-{
-"Nether"
-},
-0,
-7,
-30,
-10000,
-3,
-mobs_mc.spawn_height.nether_min,
-mobs_mc.spawn_height.nether_max)
+mobs:spawn_specific("mobs_mc:skeleton", "nether", "ground", 0, 7, 30, 10000, 3, mobs_mc.spawn_height.nether_min, mobs_mc.spawn_height.nether_max)
 
 -- Stray spawn
 -- TODO: Spawn directly under the sky
-mobs:spawn_specific(
-"mobs_mc:stray",
-"overworld",
-"ground",
-{
-"ColdTaiga",
-"IcePlainsSpikes",
-"IcePlains",
-"ExtremeHills+_snowtop",
-},
-0,
-7,
-20,
-19000,
-2,
-mobs_mc.spawn_height.water,
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:stray", "overworld", "ground", 0, 7, 20, 19000, 2, mobs_mc.spawn_height.water, mobs_mc.spawn_height.overworld_max)
 
 
 -- spawn eggs

mods/ENTITIES/mobs_mc/skeleton_wither.lua

@@ -25,12 +25,11 @@ mobs:register_mob("mobs_mc:witherskeleton", {
 	mesh = "mobs_mc_witherskeleton.b3d",
 	textures = {
 		{
-			"mobs_mc_empty.png", -- armor
-			"mobs_mc_wither_skeleton.png", -- wither skeleton
 			"default_tool_stonesword.png", -- sword
+			"mobs_mc_wither_skeleton.png", -- wither skeleton
 		}
 	},
-	visual_size = {x=1.2, y=1.2},
+	visual_size = {x=3.6, y=3.6},
 	makes_footstep_sound = true,
 	sounds = {
 		random = "mobs_mc_skeleton_random",
@@ -95,20 +94,7 @@ mobs:register_mob("mobs_mc:witherskeleton", {
 })
 
 --spawn
-mobs:spawn_specific(
-"mobs_mc:witherskeleton",
-"nether",
-"ground",
-{
-"Nether"
-},
-0,
-7,
-30,
-5000,
-5,
-mobs_mc.spawn_height.nether_min,
-mobs_mc.spawn_height.nether_max)
+mobs:spawn_specific("mobs_mc:witherskeleton", "nether", "ground", 0, 7, 30, 5000, 5, mobs_mc.spawn_height.nether_min, mobs_mc.spawn_height.nether_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:witherskeleton", S("Wither Skeleton"), "mobs_mc_spawn_icon_witherskeleton.png", 0)

mods/ENTITIES/mobs_mc/slime+magma_cube.lua

@@ -157,137 +157,9 @@ mobs:register_mob("mobs_mc:slime_tiny", slime_tiny)
 local smin = mobs_mc.spawn_height.overworld_min
 local smax = mobs_mc.spawn_height.water - 23
 
-mobs:spawn_specific(
-"mobs_mc:slime_tiny", 
-"overworld", 
-"ground",
-{
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-12000, 
-4, 
-smin, 
-smax)
-
-mobs:spawn_specific(
-"mobs_mc:slime_small", 
-"overworld", 
-"ground",
-{
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-}, 
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-8500, 
-4, 
-smin, 
-smax)
-
-mobs:spawn_specific(
-"mobs_mc:slime_big", 
-"overworld", 
-"ground", 
-{
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-10000, 
-4, 
-smin, 
-smax)
+mobs:spawn_specific("mobs_mc:slime_tiny", "overworld", "ground", 0, minetest.LIGHT_MAX+1, 30, 12000, 4, smin, smax)
+mobs:spawn_specific("mobs_mc:slime_small", "overworld", "ground", 0, minetest.LIGHT_MAX+1, 30, 8500, 4, smin, smax)
+mobs:spawn_specific("mobs_mc:slime_big", "overworld", "ground", 0, minetest.LIGHT_MAX+1, 30, 10000, 4, smin, smax)
 
 -- Magma cube
 local magma_cube_big = {
@@ -400,51 +272,9 @@ mobs:register_mob("mobs_mc:magma_cube_tiny", magma_cube_tiny)
 local mmin = mobs_mc.spawn_height.nether_min
 local mmax = mobs_mc.spawn_height.nether_max
 
-mobs:spawn_specific(
-"mobs_mc:magma_cube_tiny", 
-"nether", 
-"ground",
-{
-"Nether"
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-15000, 
-4, 
-mmin, 
-mmax)
-
-
-mobs:spawn_specific(
-"mobs_mc:magma_cube_small", 
-"nether", 
-"ground",
-{
-"Nether"
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-15500, 
-4, 
-mmin, 
-mmax)
-
-mobs:spawn_specific(
-"mobs_mc:magma_cube_big", 
-"nether", 
-"ground",
-{
-"Nether"
-},	
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-16000, 
-4, 
-mmin, 
-mmax)
+mobs:spawn_specific("mobs_mc:magma_cube_tiny", "nether", "ground", 0, minetest.LIGHT_MAX+1, 30, 15000, 4, mmin, mmax)
+mobs:spawn_specific("mobs_mc:magma_cube_small", "nether", "ground", 0, minetest.LIGHT_MAX+1, 30, 15500, 4, mmin, mmax)
+mobs:spawn_specific("mobs_mc:magma_cube_big", "nether", "ground", 0, minetest.LIGHT_MAX+1, 30, 16000, 4, mmin, mmax)
 
 --mobs:spawn_specific("mobs_mc:magma_cube_tiny", mobs_mc.spawn.nether_fortress, {"air"}, 0, minetest.LIGHT_MAX+1, 30, 11000, 4, mmin, mmax)
 --mobs:spawn_specific("mobs_mc:magma_cube_small", mobs_mc.spawn.nether_fortress, {"air"}, 0, minetest.LIGHT_MAX+1, 30, 11100, 4, mmin, mmax)

mods/ENTITIES/mobs_mc/spider.lua

@@ -87,158 +87,7 @@ cave_spider.sounds.base_pitch = 1.25
 mobs:register_mob("mobs_mc:cave_spider", cave_spider)
 
 
-mobs:spawn_specific(
-"mobs_mc:spider", 
-"overworld", 
-"ground",
-{
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-"RoofedForest_ocean",
-"JungleEdgeM_ocean",
-"BirchForestM_ocean",
-"BirchForest_ocean",
-"IcePlains_deep_ocean",
-"Jungle_deep_ocean",
-"Savanna_ocean",
-"MesaPlateauF_ocean",
-"ExtremeHillsM_deep_ocean",
-"Savanna_deep_ocean",
-"SunflowerPlains_ocean",
-"Swampland_deep_ocean",
-"Swampland_ocean",
-"MegaSpruceTaiga_deep_ocean",
-"ExtremeHillsM_ocean",
-"JungleEdgeM_deep_ocean",
-"SunflowerPlains_deep_ocean",
-"BirchForest_deep_ocean",
-"IcePlainsSpikes_ocean",
-"Mesa_ocean",
-"StoneBeach_ocean",
-"Plains_deep_ocean",
-"JungleEdge_deep_ocean",
-"SavannaM_deep_ocean",
-"Desert_deep_ocean",
-"Mesa_deep_ocean",
-"ColdTaiga_deep_ocean",
-"Plains_ocean",
-"MesaPlateauFM_ocean",
-"Forest_deep_ocean",
-"JungleM_deep_ocean",
-"FlowerForest_deep_ocean",
-"MushroomIsland_ocean",
-"MegaTaiga_ocean",
-"StoneBeach_deep_ocean",
-"IcePlainsSpikes_deep_ocean",
-"ColdTaiga_ocean",
-"SavannaM_ocean",
-"MesaPlateauF_deep_ocean",
-"MesaBryce_deep_ocean",
-"ExtremeHills+_deep_ocean",
-"ExtremeHills_ocean",
-"MushroomIsland_deep_ocean",
-"Forest_ocean",
-"MegaTaiga_deep_ocean",
-"JungleEdge_ocean",
-"MesaBryce_ocean",
-"MegaSpruceTaiga_ocean",
-"ExtremeHills+_ocean",
-"Jungle_ocean",
-"RoofedForest_deep_ocean",
-"IcePlains_ocean",
-"FlowerForest_ocean",
-"ExtremeHills_deep_ocean",
-"MesaPlateauFM_deep_ocean",
-"Desert_ocean",
-"Taiga_ocean",
-"BirchForestM_deep_ocean",
-"Taiga_deep_ocean",
-"JungleM_ocean",
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-},
-0, 
-7, 
-30, 
-17000, 
-2, 
-mobs_mc.spawn_height.overworld_min, 
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:spider", "overworld", "ground", 0, 7, 30, 17000, 2, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:spider", S("Spider"), "mobs_mc_spawn_icon_spider.png", 0)

mods/ENTITIES/mobs_mc/squid.lua

@@ -62,158 +62,7 @@ mobs:register_mob("mobs_mc:squid", {
 
 local water = mobs_mc.spawn_height.water
 --name, nodes, neighbours, minlight, maxlight, interval, chance, active_object_count, min_height, max_height
-mobs:spawn_specific(
-"mobs_mc:squid",
-"overworld",
-"water",
-{
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-"RoofedForest_ocean",
-"JungleEdgeM_ocean",
-"BirchForestM_ocean",
-"BirchForest_ocean",
-"IcePlains_deep_ocean",
-"Jungle_deep_ocean",
-"Savanna_ocean",
-"MesaPlateauF_ocean",
-"ExtremeHillsM_deep_ocean",
-"Savanna_deep_ocean",
-"SunflowerPlains_ocean",
-"Swampland_deep_ocean",
-"Swampland_ocean",
-"MegaSpruceTaiga_deep_ocean",
-"ExtremeHillsM_ocean",
-"JungleEdgeM_deep_ocean",
-"SunflowerPlains_deep_ocean",
-"BirchForest_deep_ocean",
-"IcePlainsSpikes_ocean",
-"Mesa_ocean",
-"StoneBeach_ocean",
-"Plains_deep_ocean",
-"JungleEdge_deep_ocean",
-"SavannaM_deep_ocean",
-"Desert_deep_ocean",
-"Mesa_deep_ocean",
-"ColdTaiga_deep_ocean",
-"Plains_ocean",
-"MesaPlateauFM_ocean",
-"Forest_deep_ocean",
-"JungleM_deep_ocean",
-"FlowerForest_deep_ocean",
-"MushroomIsland_ocean",
-"MegaTaiga_ocean",
-"StoneBeach_deep_ocean",
-"IcePlainsSpikes_deep_ocean",
-"ColdTaiga_ocean",
-"SavannaM_ocean",
-"MesaPlateauF_deep_ocean",
-"MesaBryce_deep_ocean",
-"ExtremeHills+_deep_ocean",
-"ExtremeHills_ocean",
-"MushroomIsland_deep_ocean",
-"Forest_ocean",
-"MegaTaiga_deep_ocean",
-"JungleEdge_ocean",
-"MesaBryce_ocean",
-"MegaSpruceTaiga_ocean",
-"ExtremeHills+_ocean",
-"Jungle_ocean",
-"RoofedForest_deep_ocean",
-"IcePlains_ocean",
-"FlowerForest_ocean",
-"ExtremeHills_deep_ocean",
-"MesaPlateauFM_deep_ocean",
-"Desert_ocean",
-"Taiga_ocean",
-"BirchForestM_deep_ocean",
-"Taiga_deep_ocean",
-"JungleM_ocean",
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-},
-0,
-minetest.LIGHT_MAX+1,
-30,
-5500,
-3,
-water-16,
-water+1)
+mobs:spawn_specific("mobs_mc:squid", "overworld", "water", 0, minetest.LIGHT_MAX+1, 30, 5500, 3, water-16, water)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:squid", S("Squid"), "mobs_mc_spawn_icon_squid.png", 0)

mods/ENTITIES/mobs_mc/villager.lua

@@ -1074,35 +1074,7 @@ mobs:register_mob("mobs_mc:villager", {
 
 
 
-mobs:spawn_specific(
-"mobs_mc:villager", 
-"overworld", 
-"ground",
-{
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"ColdTaiga",
-"SunflowerPlains",
-"RoofedForest",
-"MesaPlateauFM_grasstop",
-"ExtremeHillsM",
-"BirchForestM",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-20, 
-4, 
-mobs_mc.spawn_height.water+1, 
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:villager", "overworld", "ground", 0, minetest.LIGHT_MAX+1, 30, 20, 4, mobs_mc.spawn_height.water+1, mobs_mc.spawn_height.overworld_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:villager", S("Villager"), "mobs_mc_spawn_icon_villager.png", 0)

mods/ENTITIES/mobs_mc/villager_zombie.lua

@@ -146,99 +146,8 @@ mobs:register_mob("mobs_mc:villager_zombie", {
 	harmed_by_heal = true,
 })
 
-mobs:spawn_specific(
-"mobs_mc:villager_zombie", 
-"overworld", 
-"ground",
-{
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-},
-0, 
-7, 
-30, 
-4090, 
-4, 
-mobs_mc.spawn_height.overworld_min, 
-mobs_mc.spawn_height.overworld_max)
---mobs:spawn_specific("mobs_mc:villager_zombie", "overworld", "ground", 0, 7, 30, 60000, 4, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:villager_zombie", "overworld", "ground", 0, 7, 30, 4090, 4, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:villager_zombie", "overworld", "ground", 0, 7, 30, 60000, 4, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 
 -- spawn eggs
 mobs:register_egg("mobs_mc:villager_zombie", S("Zombie Villager"), "mobs_mc_spawn_icon_zombie_villager.png", 0)

mods/ENTITIES/mobs_mc/wither.lua

@@ -73,7 +73,7 @@ mobs:register_mob("mobs_mc:wither", {
 			self.object:set_properties({textures={self.base_texture}})
 			self.armor = {undead = 80, fleshy = 80}
 		end
-		mcl_bossbars.update_boss(self.object, "Wither", "dark_purple")
+		mcl_bossbars.update_boss(self, "Wither", "dark_purple")
 	end,
 	on_spawn = function(self)
 		minetest.sound_play("mobs_mc_wither_spawn", {object=self.object, gain=1.0, max_hear_distance=64})

mods/ENTITIES/mobs_mc/wolf.lua

@@ -232,34 +232,6 @@ end
 mobs:register_mob("mobs_mc:dog", dog)
 
 -- Spawn
-mobs:spawn_specific(
-"mobs_mc:wolf",
-"overworld",
-"ground",
-{
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"ColdTaiga",
-"SunflowerPlains",
-"RoofedForest",
-"MesaPlateauFM_grasstop",
-"ExtremeHillsM",
-"BirchForestM",
-},
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-9000, 
-7, 
-mobs_mc.spawn_height.water+3, 
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:wolf", "overworld", "ground", 0, minetest.LIGHT_MAX+1, 30, 9000, 7, mobs_mc.spawn_height.water+3, mobs_mc.spawn_height.overworld_max)
 
 mobs:register_egg("mobs_mc:wolf", S("Wolf"), "mobs_mc_spawn_icon_wolf.png", 0)

mods/ENTITIES/mobs_mc/zombie.lua

@@ -58,11 +58,7 @@ local zombie = {
 	visual = "mesh",
 	mesh = "mobs_mc_zombie.b3d",
 	textures = {
-		{
-			"mobs_mc_empty.png", -- armor
-			"mobs_mc_zombie.png", -- texture
-			"mobs_mc_empty.png", -- wielded_item
-		}
+		{"mobs_mc_zombie.png"},
 	},
 	visual_size = {x=3, y=3},
 	makes_footstep_sound = true,
@@ -115,13 +111,7 @@ mobs:register_mob("mobs_mc:baby_zombie", baby_zombie)
 -- Husk.
 -- Desert variant of the zombie
 local husk = table.copy(zombie)
-husk.textures = {
-		{
-			"mobs_mc_empty.png", -- armor
-			"mobs_mc_husk.png", -- texture
-			"mobs_mc_empty.png", -- wielded_item
-		}
-	}
+husk.textures = {{"mobs_mc_husk.png"}}
 husk.ignited_by_sunlight = false
 husk.sunlight_damage = 0
 husk.drops = drops_common
@@ -145,227 +135,11 @@ mobs:register_mob("mobs_mc:baby_husk", baby_husk)
 
 -- Spawning
 
-mobs:spawn_specific(
-"mobs_mc:zombie",
-"overworld",
-"ground",
-{
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-},
-0,
-7,
-30,
-6000,
-4,
-mobs_mc.spawn_height.overworld_min,
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:zombie", "overworld", "ground", 0, 7, 30, 6000, 4, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 -- Baby zombie is 20 times less likely than regular zombies
-mobs:spawn_specific(
-"mobs_mc:baby_zombie",
-"overworld",
-"ground",
-{
-"FlowerForest_underground",
-"JungleEdge_underground",
-"StoneBeach_underground",
-"MesaBryce_underground",
-"Mesa_underground",
-"RoofedForest_underground",
-"Jungle_underground",
-"Swampland_underground",
-"MushroomIsland_underground",
-"BirchForest_underground",
-"Plains_underground",
-"MesaPlateauF_underground",
-"ExtremeHills_underground",
-"MegaSpruceTaiga_underground",
-"BirchForestM_underground",
-"SavannaM_underground",
-"MesaPlateauFM_underground",
-"Desert_underground",
-"Savanna_underground",
-"Forest_underground",
-"SunflowerPlains_underground",
-"ColdTaiga_underground",
-"IcePlains_underground",
-"IcePlainsSpikes_underground",
-"MegaTaiga_underground",
-"Taiga_underground",
-"ExtremeHills+_underground",
-"JungleM_underground",
-"ExtremeHillsM_underground",
-"JungleEdgeM_underground",
-"Mesa",
-"FlowerForest",
-"Swampland",
-"Taiga",
-"ExtremeHills",
-"Jungle",
-"Savanna",
-"BirchForest",
-"MegaSpruceTaiga",
-"MegaTaiga",
-"ExtremeHills+",
-"Forest",
-"Plains",
-"Desert",
-"ColdTaiga",
-"MushroomIsland",
-"IcePlainsSpikes",
-"SunflowerPlains",
-"IcePlains",
-"RoofedForest",
-"ExtremeHills+_snowtop",
-"MesaPlateauFM_grasstop",
-"JungleEdgeM",
-"ExtremeHillsM",
-"JungleM",
-"BirchForestM",
-"MesaPlateauF",
-"MesaPlateauFM",
-"MesaPlateauF_grasstop",
-"MesaBryce",
-"JungleEdge",
-"SavannaM",
-"FlowerForest_beach",
-"Forest_beach",
-"StoneBeach",
-"ColdTaiga_beach_water",
-"Taiga_beach",
-"Savanna_beach",
-"Plains_beach",
-"ExtremeHills_beach",
-"ColdTaiga_beach",
-"Swampland_shore",
-"MushroomIslandShore",
-"JungleM_shore",
-"Jungle_shore",
-"MesaPlateauFM_sandlevel",
-"MesaPlateauF_sandlevel",
-"MesaBryce_sandlevel",
-"Mesa_sandlevel",
-},
-0,
-7,
-30,
-60000,
-4,
-mobs_mc.spawn_height.overworld_min,
-mobs_mc.spawn_height.overworld_max)
-
-
-mobs:spawn_specific(
-"mobs_mc:husk",
-"overworld",
-"ground",
-{
-"Desert",
-"SavannaM",
-"Savanna",
-"Savanna_beach",
-},
-0,
-7,
-30,
-6500,
-4,
-mobs_mc.spawn_height.overworld_min,
-mobs_mc.spawn_height.overworld_max)
-mobs:spawn_specific(
-"mobs_mc:baby_husk",
-"overworld",
-"ground",
-{
-"Desert",
-"SavannaM",
-"Savanna",
-"Savanna_beach",
-},
-0,
-7,
-30,
-65000,
-4,
-mobs_mc.spawn_height.overworld_min,
-mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:baby_zombie", "overworld", "ground", 0, 7, 30, 60000, 4, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:husk", "overworld", "ground", 0, 7, 30, 6500, 4, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
+mobs:spawn_specific("mobs_mc:baby_husk", "overworld", "ground", 0, 7, 30, 65000, 4, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)
 
 -- Spawn eggs
 mobs:register_egg("mobs_mc:husk", S("Husk"), "mobs_mc_spawn_icon_husk.png", 0)

mods/ENTITIES/mobs_mc/zombiepig.lua

@@ -111,35 +111,9 @@ baby_pigman.child = 1
 mobs:register_mob("mobs_mc:baby_pigman", baby_pigman)
 
 -- Regular spawning in the Nether
-mobs:spawn_specific(
-"mobs_mc:pigman", 
-"nether", 
-"ground",
-{
-"Nether"
-},
-0, 
-minetest.LIGHT_MAX+1,
-30, 
-6000, 
-3, 
-mobs_mc.spawn_height.nether_min, 
-mobs_mc.spawn_height.nether_max)
+mobs:spawn_specific("mobs_mc:pigman", "nether", "ground", 0, minetest.LIGHT_MAX+1, 30, 6000, 3, mobs_mc.spawn_height.nether_min, mobs_mc.spawn_height.nether_max)
 -- Baby zombie is 20 times less likely than regular zombies
-mobs:spawn_specific(
-"mobs_mc:baby_pigman", 
-"nether", 
-"ground",
-{
-"Nether"
-}, 
-0, 
-minetest.LIGHT_MAX+1, 
-30, 
-100000, 
-4, 
-mobs_mc.spawn_height.nether_min, 
-mobs_mc.spawn_height.nether_max)
+mobs:spawn_specific("mobs_mc:baby_pigman", "nether", "ground", 0, minetest.LIGHT_MAX+1, 30, 100000, 4, mobs_mc.spawn_height.nether_min, mobs_mc.spawn_height.nether_max)
 
 -- Spawning in Nether portals in the Overworld
 --mobs:spawn_specific("mobs_mc:pigman", mobs_mc.spawn.nether_portal, {"air"}, 0, minetest.LIGHT_MAX+1, 30, 500, 4, mobs_mc.spawn_height.overworld_min, mobs_mc.spawn_height.overworld_max)

mods/HUD/mcl_bossbars/init.lua

@@ -3,7 +3,7 @@ mcl_bossbars = {
 	huds = {},
 	static = {},
 	colors = {"light_purple", "blue", "red", "green", "yellow", "dark_purple", "white"},
-	max_bars = tonumber(minetest.settings:get("max_bossbars")) or 4
+	max_bars = tonumber(minetest.settings:get("max_bossbars")) or 6
 }
 
 function mcl_bossbars.recalculate_colors()
@@ -36,12 +36,12 @@ end
 
 local last_id = 0
 
-function mcl_bossbars.add_bar(player, def, dynamic, priority)
+function mcl_bossbars.add_bar(player, def)
 	local name = player:get_player_name()
 	local bars = mcl_bossbars.bars[name]
-	local bar = {text = def.text, priority = priority or 0, timeout = def.timeout}
+	local bar = {text = def.text}
 	bar.color, bar.image = get_color_info(def.color, def.percentage)
-	if dynamic then
+	if def.dynamic then
 		for _, other in pairs(bars) do
 			if not other.id and other.color == bar.color and (other.original_text or other.text) == bar.text and other.image == bar.image then
 				if not other.count then
@@ -55,49 +55,40 @@ function mcl_bossbars.add_bar(player, def, dynamic, priority)
 		end
 	end
 	table.insert(bars, bar)
-	if not dynamic then
+	if not def.dynamic then
 		bar.raw_color = def.color
 		bar.id = last_id + 1
 		last_id = bar.id
 		mcl_bossbars.static[bar.id] = bar
-		return bar.id
+		return id
 	end
 end
 
 function mcl_bossbars.remove_bar(id)
-	mcl_bossbars.static[id].id = nil
+	mcl_bossbars.static[id].bar.static = false
 	mcl_bossbars.static[id] = nil
 end
 
-function mcl_bossbars.update_bar(id, def, priority)
+function mcl_bossbars.update_bar(id, def)
 	local old = mcl_bossbars.static[id]
 	old.color = get_color_info(def.color or old.raw_color, def.percentage or old.percentage)
 	old.text = def.text or old.text
-	old.priority = priority or old.priority
 end
 
-function mcl_bossbars.update_boss(object, name, color)
-	local props = object:get_luaentity()
-	if not props or not props._cmi_is_mob then
-		props = object:get_properties()
-		props.health = object:get_hp()
-	end
-
+function mcl_bossbars.update_boss(luaentity, name, color)
+	local object = luaentity.object
 	local bardef = {
+		text = luaentity.nametag,
+		percentage = math.floor(luaentity.health / luaentity.hp_max * 100),
 		color = color,
-		text = props.nametag,
-		percentage = math.floor(props.health / props.hp_max * 100),
+		dynamic = true,
 	}
-
 	if not bardef.text or bardef.text == "" then
 		bardef.text = name
 	end
-
-	local pos = object:get_pos()
-	for _, player in pairs(minetest.get_connected_players()) do
-		local d = vector.distance(pos, player:get_pos())
-		if d <= 80 then
-			mcl_bossbars.add_bar(player, bardef, true, d)
+	for _, obj in pairs(minetest.get_objects_inside_radius(object:get_pos(), 128)) do
+		if obj:is_player() then
+			mcl_bossbars.add_bar(obj, bardef)
 		end
 	end
 end
@@ -119,12 +110,11 @@ minetest.register_on_leaveplayer(function(player)
 	mcl_bossbars.bars[name] = nil
 end)
 
-minetest.register_globalstep(function(dtime)
+minetest.register_globalstep(function()
 	for _, player in pairs(minetest.get_connected_players()) do
 		local name = player:get_player_name()
 		local bars = mcl_bossbars.bars[name]
 		local huds = mcl_bossbars.huds[name]
-		table.sort(bars, function(a, b) return a.priority < b.priority end)
 		local huds_new = {}
 		local bars_new = {}
 		local i = 0
@@ -134,12 +124,7 @@ minetest.register_globalstep(function(dtime)
 			local hud = table.remove(huds, 1)
 
 			if bar and bar.id then
-				if bar.timeout then
-					bar.timeout = bar.timeout - dtime
-				end
-				if not bar.timeout or bar.timeout > 0 then
-					table.insert(bars_new, bar)
-				end
+				table.insert(bars_new, bar)
 			end
 
 			if bar and not hud then

mods/HUD/mcl_credits/init.lua

@@ -27,9 +27,9 @@ mcl_credits.people = {
 		"Rootyjr",
 		"Nicu",
 		"aligator",
-		"Code-Sploit",
 	}},
 	{"Contributors", 0x52FF00, {
+		"Code-Sploit",
 		"Laurent Rocher",
 		"HimbeerserverDE",
 		"TechDudie",
@@ -55,7 +55,6 @@ mcl_credits.people = {
 		"nickolas360",
 		"yutyo",
 		"ztianyang",
-		"j45",
 	}},
 	{"MineClone5", 0xA60014, {
 		"kay27",
@@ -64,38 +63,6 @@ mcl_credits.people = {
 		"NO11",
 		"j45",
 	}},
-	{"Original Mod Authors", 0x343434, {
-		"Wuzzy",
-		"Fleckenstein",
-		"BlockMen",
-		"TenPlus1",
-		"PilzAdam",
-		"ryvnf",
-		"stujones11",
-		"Arcelmi",
-		"celeron55",
-		"maikerumine",
-		"GunshipPenguin",
-		"Qwertymine3",
-		"Rochambeau",
-		"rubenwardy",
-		"stu",
-		"oilboi",
-		"4aiman",
-		"Kahrl",
-		"Krock",
-		"UgnilJoZ",
-		"lordfingle",
-		"22i",
-		"bzoss",
-		"kilbith",
-		"xeranas",
-		"kddekadenz",
-		"sofar",
-		"4Evergreen4",
-		"jordan4ibanez",
-		"paramat",
-	}},
 	{"3D Models", 0x0019FF, {
 		"22i",
 		"tobyplowy",

mods/ITEMS/REDSTONE/mesecons/internal.lua

@@ -47,34 +47,28 @@
 -- mesecon.rotate_rules_down(rules)
 -- These functions return rules that have been rotated in the specific direction
 
-local equals = vector.equals
-local get_node_force = mesecon.get_node_force
-local invertRule = mesecon.invertRule
-local copy, insert = table.copy, table.insert
-local registered_nodes = minetest.registered_nodes
-
 -- General
 function mesecon.get_effector(nodename)
-	if  registered_nodes[nodename]
-	and registered_nodes[nodename].mesecons
-	and registered_nodes[nodename].mesecons.effector then
-		return registered_nodes[nodename].mesecons.effector
+	if  minetest.registered_nodes[nodename]
+	and minetest.registered_nodes[nodename].mesecons
+	and minetest.registered_nodes[nodename].mesecons.effector then
+		return minetest.registered_nodes[nodename].mesecons.effector
 	end
 end
 
 function mesecon.get_receptor(nodename)
-	if  registered_nodes[nodename]
-	and registered_nodes[nodename].mesecons
-	and registered_nodes[nodename].mesecons.receptor then
-		return registered_nodes[nodename].mesecons.receptor
+	if  minetest.registered_nodes[nodename]
+	and minetest.registered_nodes[nodename].mesecons
+	and minetest.registered_nodes[nodename].mesecons.receptor then
+		return minetest.registered_nodes[nodename].mesecons.receptor
 	end
 end
 
 function mesecon.get_conductor(nodename)
-	if  registered_nodes[nodename]
-	and registered_nodes[nodename].mesecons
-	and registered_nodes[nodename].mesecons.conductor then
-		return registered_nodes[nodename].mesecons.conductor
+	if  minetest.registered_nodes[nodename]
+	and minetest.registered_nodes[nodename].mesecons
+	and minetest.registered_nodes[nodename].mesecons.conductor then
+		return minetest.registered_nodes[nodename].mesecons.conductor
 	end
 end
 
@@ -109,14 +103,13 @@ end
 
 -- Receptors
 -- Nodes that can power mesecons
-local function is_receptor_on(nodename)
+function mesecon.is_receptor_on(nodename)
 	local receptor = mesecon.get_receptor(nodename)
 	if receptor and receptor.state == mesecon.state.on then
 		return true
 	end
 	return false
 end
-mesecon.is_receptor_on = is_receptor_on
 
 function mesecon.is_receptor_off(nodename)
 	local receptor = mesecon.get_receptor(nodename)
@@ -134,7 +127,7 @@ function mesecon.is_receptor(nodename)
 	return false
 end
 
-local function receptor_get_rules(node)
+function mesecon.receptor_get_rules(node)
 	local receptor = mesecon.get_receptor(node.name)
 	if receptor then
 		local rules = receptor.rules
@@ -147,7 +140,6 @@ local function receptor_get_rules(node)
 
 	return mesecon.rules.default
 end
-mesecon.receptor_get_rules = receptor_get_rules
 
 -- Effectors
 -- Nodes that can be powered by mesecons
@@ -194,7 +186,7 @@ end
 
 -- Activation:
 mesecon.queue:add_function("activate", function (pos, rulename)
-	local node = get_node_force(pos)
+	local node = mesecon.get_node_force(pos)
 	if not node then return end
 
 	local effector = mesecon.get_effector(node.name)
@@ -206,7 +198,7 @@ end)
 
 function mesecon.activate(pos, node, rulename, depth)
 	if rulename == nil then
-		for _,rule in pairs(mesecon.effector_get_rules(node)) do
+		for _,rule in ipairs(mesecon.effector_get_rules(node)) do
 			mesecon.activate(pos, node, rule, depth + 1)
 		end
 		return
@@ -217,7 +209,7 @@ end
 
 -- Deactivation
 mesecon.queue:add_function("deactivate", function (pos, rulename)
-	local node = get_node_force(pos)
+	local node = mesecon.get_node_force(pos)
 	if not node then return end
 
 	local effector = mesecon.get_effector(node.name)
@@ -229,7 +221,7 @@ end)
 
 function mesecon.deactivate(pos, node, rulename, depth)
 	if rulename == nil then
-		for _,rule in pairs(mesecon.effector_get_rules(node)) do
+		for _,rule in ipairs(mesecon.effector_get_rules(node)) do
 			mesecon.deactivate(pos, node, rule, depth + 1)
 		end
 		return
@@ -240,7 +232,7 @@ end
 
 -- Change
 mesecon.queue:add_function("change", function (pos, rulename, changetype)
-	local node = get_node_force(pos)
+	local node = mesecon.get_node_force(pos)
 	if not node then return end
 
 	local effector = mesecon.get_effector(node.name)
@@ -252,7 +244,7 @@ end)
 
 function mesecon.changesignal(pos, node, rulename, newstate, depth)
 	if rulename == nil then
-		for _,rule in pairs(mesecon.effector_get_rules(node)) do
+		for _,rule in ipairs(mesecon.effector_get_rules(node)) do
 			mesecon.changesignal(pos, node, rule, newstate, depth + 1)
 		end
 		return
@@ -364,15 +356,15 @@ end
 -- some more general high-level stuff
 
 function mesecon.is_power_on(pos, rulename)
-	local node = get_node_force(pos)
-	if node and (mesecon.is_conductor_on(node, rulename) or is_receptor_on(node.name)) then
+	local node = mesecon.get_node_force(pos)
+	if node and (mesecon.is_conductor_on(node, rulename) or mesecon.is_receptor_on(node.name)) then
 		return true
 	end
 	return false
 end
 
 function mesecon.is_power_off(pos, rulename)
-	local node = get_node_force(pos)
+	local node = mesecon.get_node_force(pos)
 	if node and (mesecon.is_conductor_off(node, rulename) or mesecon.is_receptor_off(node.name)) then
 		return true
 	end
@@ -389,7 +381,7 @@ function mesecon.turnon(pos, link)
 	local depth = 1
 	while frontiers[1] do
 		local f = table.remove(frontiers, 1)
-		local node = get_node_force(f.pos)
+		local node = mesecon.get_node_force(f.pos)
 
 		if not node then
 			-- Area does not exist; do nothing
@@ -397,10 +389,10 @@ function mesecon.turnon(pos, link)
 			local rules = mesecon.conductor_get_rules(node)
 
 			-- Call turnon on neighbors
-			for _, r in pairs(mesecon.rule2meta(f.link, rules)) do
+			for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
 				local np = vector.add(f.pos, r)
-				for _, l in pairs(mesecon.rules_link_rule_all(f.pos, r)) do
-					insert(frontiers, {pos = np, link = l})
+				for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
+					table.insert(frontiers, {pos = np, link = l})
 				end
 			end
 
@@ -414,12 +406,12 @@ function mesecon.turnon(pos, link)
 		if node and f.link.spread and minetest.get_item_group(node.name, "opaque") == 1 then
 			-- Call turnon on neighbors
 			-- Warning: A LOT of nodes need to be looked at for this to work
-			for _, r in pairs(mesecon.rule2meta(f.link, mesecon.rules.mcl_alldirs_spread)) do
+			for _, r in ipairs(mesecon.rule2meta(f.link, mesecon.rules.mcl_alldirs_spread)) do
 				local np = vector.add(f.pos, r)
-				for _, l in pairs(mesecon.rules_link_rule_all(f.pos, r)) do
-					local nlink = copy(l)
+				for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
+					local nlink = table.copy(l)
 					nlink.spread = false
-					insert(frontiers, {pos = np, link = nlink})
+					table.insert(frontiers, {pos = np, link = nlink})
 				end
 			end
 		end
@@ -451,33 +443,33 @@ function mesecon.turnoff(pos, link)
 	local depth = 1
 	while frontiers[1] do
 		local f = table.remove(frontiers, 1)
-		local node = get_node_force(f.pos)
+		local node = mesecon.get_node_force(f.pos)
 
 		if not node then
 			-- No-op
 		elseif mesecon.is_conductor_on(node, f.link) then
 			local rules = mesecon.conductor_get_rules(node)
-			for _, r in pairs(mesecon.rule2meta(f.link, rules)) do
+			for _, r in ipairs(mesecon.rule2meta(f.link, rules)) do
 				local np = vector.add(f.pos, r)
 
 				-- Check if an onstate receptor is connected. If that is the case,
 				-- abort this turnoff process by returning false. `receptor_off` will
 				-- discard all the changes that we made in the voxelmanip:
-				for _, l in pairs(mesecon.rules_link_rule_all_inverted(f.pos, r)) do
-					if is_receptor_on(get_node_force(np).name) then
+				for _, l in ipairs(mesecon.rules_link_rule_all_inverted(f.pos, r)) do
+					if mesecon.is_receptor_on(mesecon.get_node_force(np).name) then
 						return false
 					end
 				end
 
 				-- Call turnoff on neighbors
-				for _, l in pairs(mesecon.rules_link_rule_all(f.pos, r)) do
-					insert(frontiers, {pos = np, link = l})
+				for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
+					table.insert(frontiers, {pos = np, link = l})
 				end
 			end
 
 			mesecon.swap_node_force(f.pos, mesecon.get_conductor_off(node, f.link))
 		elseif mesecon.is_effector(node.name) then
-			insert(signals, {
+			table.insert(signals, {
 				pos = f.pos,
 				node = node,
 				link = f.link,
@@ -488,22 +480,21 @@ function mesecon.turnoff(pos, link)
 		if node and f.link.spread and minetest.get_item_group(node.name, "opaque") == 1 then
 			-- Call turnoff on neighbors
 			-- Warning: A LOT of nodes need to be looked at for this to work
-			local fpos = f.pos
-			for _, r in pairs(mesecon.rule2meta(f.link, mesecon.rules.mcl_alldirs_spread)) do
-				local np = {x=fpos.x+r.x, y=fpos.y+r.y, z=fpos.z+r.z}
-				local n = get_node_force(np)
-				if n and is_receptor_on(n.name) then
-					local receptorrules = receptor_get_rules(n)
+			for _, r in ipairs(mesecon.rule2meta(f.link, mesecon.rules.mcl_alldirs_spread)) do
+				local np = vector.add(f.pos, r)
+				local n = mesecon.get_node_force(np)
+				if mesecon.is_receptor_on(n.name) then
+					local receptorrules = mesecon.receptor_get_rules(n)
 					for _, rr in pairs(receptorrules) do
-						if rr.spread and equals(invertRule(rr), r) then
+						if rr.spread and vector.equals(mesecon.invertRule(rr), r) then
 							return false
 						end
 					end
 				end
-				for _, l in pairs(mesecon.rules_link_rule_all(fpos, r)) do
-					local nlink = copy(l)
+				for _, l in ipairs(mesecon.rules_link_rule_all(f.pos, r)) do
+					local nlink = table.copy(l)
 					nlink.spread = false
-					insert(frontiers, {pos = np, link = nlink})
+					table.insert(frontiers, {pos = np, link = nlink})
 				end
 			end
 		end
@@ -511,7 +502,7 @@ function mesecon.turnoff(pos, link)
 		depth = depth + 1
 	end
 
-	for _, sig in pairs(signals) do
+	for _, sig in ipairs(signals) do
 		mesecon.changesignal(sig.pos, sig.node, sig.link, mesecon.state.off, sig.depth)
 		if mesecon.is_effector_on(sig.node.name) and not mesecon.is_powered(sig.pos) then
 			mesecon.deactivate(sig.pos, sig.node, sig.link, sig.depth)
@@ -525,19 +516,19 @@ end
 -- outputnode (receptor or conductor) at position `output` and has an output in direction `rule`
 function mesecon.rules_link_rule_all(output, rule)
 	local input = vector.add(output, rule)
-	local inputnode = get_node_force(input)
+	local inputnode = mesecon.get_node_force(input)
 	local inputrules = mesecon.get_any_inputrules(inputnode)
 	if not inputrules then
 		return {}
 	end
 	local rules = {}
 
-	for _, inputrule in pairs(mesecon.flattenrules(inputrules)) do
+	for _, inputrule in ipairs(mesecon.flattenrules(inputrules)) do
 		-- Check if input accepts from output
-		if equals(vector.add(input, inputrule), output) then
-			local newrule = copy(inputrule)
+		if vector.equals(vector.add(input, inputrule), output) then
+			local newrule = table.copy(inputrule)
 			newrule.spread = rule.spread
-			insert(rules, newrule)
+			table.insert(rules, newrule)
 		end
 	end
 
@@ -548,19 +539,19 @@ end
 -- inputnode (effector or conductor) at position `input` and has an input in direction `rule`
 function mesecon.rules_link_rule_all_inverted(input, rule)
 	local output = vector.add(input, rule)
-	local outputnode = get_node_force(output)
+	local outputnode = mesecon.get_node_force(output)
 	local outputrules = mesecon.get_any_outputrules(outputnode)
 	if not outputrules then
 		return {}
 	end
 	local rules = {}
 
-	for _, outputrule in pairs(mesecon.flattenrules(outputrules)) do
-		if equals(vector.add(output, outputrule), input) then
-			local newrule = copy(outputrule)
-			newrule = invertRule(newrule)
+	for _, outputrule in ipairs(mesecon.flattenrules(outputrules)) do
+		if vector.equals(vector.add(output, outputrule), input) then
+			local newrule = table.copy(outputrule)
+			newrule = mesecon.invertRule(newrule)
 			newrule.spread = rule.spread
-			insert(rules, newrule)
+			table.insert(rules, newrule)
 		end
 	end
 	return rules
@@ -571,7 +562,7 @@ function mesecon.is_powered(pos, rule, depth, sourcepos, home_pos)
 	if depth > 1 then
 		return false, false
 	end
-	local node = get_node_force(pos)
+	local node = mesecon.get_node_force(pos)
 	local rules = mesecon.get_any_inputrules(node)
 	if not rules then
 		return false, false
@@ -587,23 +578,23 @@ function mesecon.is_powered(pos, rule, depth, sourcepos, home_pos)
 
 	local function power_walk(pos, home_pos, sourcepos, rulenames, rule, depth)
 		local spread = false
-		for _, rname in pairs(rulenames) do
+		for _, rname in ipairs(rulenames) do
 			local np = vector.add(pos, rname)
-			local nn = get_node_force(np)
-			if (mesecon.is_conductor_on (nn, invertRule(rname))
-			or is_receptor_on (nn.name)) then
-				if not equals(home_pos, np) then
+			local nn = mesecon.get_node_force(np)
+			if (mesecon.is_conductor_on (nn, mesecon.invertRule(rname))
+			or mesecon.is_receptor_on (nn.name)) then
+				if not vector.equals(home_pos, np) then
 					local rulez = mesecon.get_any_outputrules(nn)
 					local spread_tmp = false
 					for r=1, #rulez do
-						if equals(invertRule(rname), rulez[r]) then
+						if vector.equals(mesecon.invertRule(rname), rulez[r]) then
 							if rulez[r].spread then
 								spread_tmp = true
 							end
 						end
 					end
 					if depth == 0 or spread_tmp then
-						insert(sourcepos, np)
+						table.insert(sourcepos, np)
 						if spread_tmp then
 							spread = true
 						end
@@ -621,7 +612,7 @@ function mesecon.is_powered(pos, rule, depth, sourcepos, home_pos)
 
 	local spread = false
 	if not rule then
-		for _, rule in pairs(mesecon.flattenrules(rules)) do
+		for _, rule in ipairs(mesecon.flattenrules(rules)) do
 			local spread_temp
 			local rulenames = mesecon.rules_link_rule_all_inverted(pos, rule)
 			sourcepos, spread_temp = power_walk(pos, home_pos, sourcepos, rulenames, rule, depth)

mods/ITEMS/REDSTONE/mesecons_torch/init.lua

@@ -117,90 +117,83 @@ minetest.register_craft({
 	{"mcl_core:stick"},}
 })
 
-local off_def = {
-	name = "mesecon_torch_off",
-	description = S("Redstone Torch (off)"),
-	doc_items_create_entry = false,
-	icon = "jeija_torches_off.png",
-	tiles = {"jeija_torches_off.png"},
-	light = 0,
-	groups = {dig_immediate=3, dig_by_water=1, redstone_torch=2, mesecon_ignore_opaque_dig=1, not_in_creative_inventory=1},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	drop = "mesecons_torch:mesecon_torch_on",
-}
-
-mcl_torches.register_torch(off_def)
-
-local off_override = {
-	mesecons = {
-		receptor = {
-			state = mesecon.state.off,
-			rules = torch_get_output_rules,
-		},
-		effector = {
-			state = mesecon.state.on,
-			rules = torch_get_input_rules,
-			action_off = torch_action_off,
+mcl_torches.register_torch("mesecon_torch_off", S("Redstone Torch (off)"),
+	nil,
+	nil,
+	"jeija_torches_off.png",
+	"mcl_torches_torch_floor.obj", "mcl_torches_torch_wall.obj",
+	{"jeija_torches_off.png"},
+	0,
+	{dig_immediate=3, dig_by_water=1, redstone_torch=2, mesecon_ignore_opaque_dig=1, not_in_creative_inventory=1},
+	mcl_sounds.node_sound_wood_defaults(),
+	{
+		mesecons = {
+			receptor = {
+				state = mesecon.state.off,
+				rules = torch_get_output_rules,
+			},
+			effector = {
+				state = mesecon.state.on,
+				rules = torch_get_input_rules,
+				action_off = torch_action_off,
+			},
 		},
+		drop = "mesecons_torch:mesecon_torch_on",
+		_doc_items_create_entry = false,
 	}
-}
+)
 
-minetest.override_item("mesecons_torch:mesecon_torch_off", off_override)
-minetest.override_item("mesecons_torch:mesecon_torch_off_wall", off_override)
+mcl_torches.register_torch("mesecon_torch_overheated", S("Redstone Torch (overheated)"),
+	nil,
+	nil,
+	"jeija_torches_off.png",
+	"mcl_torches_torch_floor.obj", "mcl_torches_torch_wall.obj",
+	{"jeija_torches_off.png"},
+	0,
+	{dig_immediate=3, dig_by_water=1, redstone_torch=2, mesecon_ignore_opaque_dig=1, not_in_creative_inventory=1},
+	mcl_sounds.node_sound_wood_defaults(),
+	{
+		drop = "mesecons_torch:mesecon_torch_on",
+		_doc_items_create_entry = false,
+		on_timer = function(pos, elapsed)
+			if not mesecon.is_powered(pos) then
+				local node = minetest.get_node(pos)
+				torch_action_off(pos, node)
+			end
+		end,
+	}
+)
 
-local overheated_def = table.copy(off_def)
-overheated_def.name = "mesecon_torch_overheated"
-overheated_def.description = S("Redstone Torch (overheated)")
 
-mcl_torches.register_torch(overheated_def)
 
-local overheated_override = {
-	on_timer = function(pos, elapsed)
-		if not mesecon.is_powered(pos) then
+mcl_torches.register_torch("mesecon_torch_on", S("Redstone Torch"),
+	S("A redstone torch is a redstone component which can be used to invert a redstone signal. It supplies its surrounding blocks with redstone power, except for the block it is attached to. A redstone torch is normally lit, but it can also be turned off by powering the block it is attached to. While unlit, a redstone torch does not power anything."),
+	S("Redstone torches can be placed at the side and on the top of full solid opaque blocks."),
+	"jeija_torches_on.png",
+	"mcl_torches_torch_floor.obj", "mcl_torches_torch_wall.obj",
+	{"jeija_torches_on.png"},
+	7,
+	{dig_immediate=3, dig_by_water=1, redstone_torch=1, mesecon_ignore_opaque_dig=1},
+	mcl_sounds.node_sound_wood_defaults(),
+	{
+		on_destruct = function(pos, oldnode)
 			local node = minetest.get_node(pos)
-			torch_action_off(pos, node)
-		end
-	end
-}
-
-minetest.override_item("mesecons_torch:mesecon_torch_overheated", overheated_override)
-minetest.override_item("mesecons_torch:mesecon_torch_overheated_wall", overheated_override)
-
-local on_def = {
-	name = "mesecon_torch_on",
-	description = S("Redstone Torch"),
-	doc_items_longdesc = S("A redstone torch is a redstone component which can be used to invert a redstone signal. It supplies its surrounding blocks with redstone power, except for the block it is attached to. A redstone torch is normally lit, but it can also be turned off by powering the block it is attached to. While unlit, a redstone torch does not power anything."),
-	doc_items_usagehelp = S("Redstone torches can be placed at the side and on the top of full solid opaque blocks."),
-	icon = "jeija_torches_on.png",
-	tiles = {"jeija_torches_on.png"},
-	light = 7,
-	groups = {dig_immediate=3, dig_by_water=1, redstone_torch=1, mesecon_ignore_opaque_dig=1},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-}
-
-mcl_torches.register_torch(on_def)
-
-local on_override = {
-	on_destruct = function(pos, oldnode)
-		local node = minetest.get_node(pos)
-		torch_action_on(pos, node)
-	end,
-	mesecons = {
-		receptor = {
-			state = mesecon.state.on,
-			rules = torch_get_output_rules
+			torch_action_on(pos, node)
+		end,
+		mesecons = {
+			receptor = {
+				state = mesecon.state.on,
+				rules = torch_get_output_rules
+			},
+			effector = {
+				state = mesecon.state.off,
+				rules = torch_get_input_rules,
+				action_on = torch_action_on,
+			},
 		},
-		effector = {
-			state = mesecon.state.off,
-			rules = torch_get_input_rules,
-			action_on = torch_action_on,
-		},
-	},
-	_tt_help = S("Provides redstone power when it's not powered itself"),
-}
-
-minetest.override_item("mesecons_torch:mesecon_torch_on", on_override)
-minetest.override_item("mesecons_torch:mesecon_torch_on_wall", on_override)
+		_tt_help = S("Provides redstone power when it's not powered itself"),
+	}
+)
 
 minetest.register_node("mesecons_torch:redstoneblock", {
 	description = S("Block of Redstone"),

mods/ITEMS/mcl_armor/armor.lua

@@ -368,7 +368,6 @@ mcl_player.player_register_model("mcl_armor_character.b3d", {
 		run_walk_mine	= {x=461, y=480},
 		sit_mount	= {x=484, y=484},
 		die	= {x=498, y=498},
-		fly = {x=502, y=581},
 	},
 })
 
@@ -397,8 +396,6 @@ mcl_player.player_register_model("mcl_armor_character_female.b3d", {
 		run_walk	= {x=440, y=459},
 		run_walk_mine	= {x=461, y=480},
 		sit_mount	= {x=484, y=484},
-		die	= {x=498, y=498},
-		fly = {x=502, y=581},
 	},
 })
 

mods/ITEMS/mcl_armor/init.lua

@@ -8,20 +8,6 @@ dofile(minetest.get_modpath(minetest.get_current_modname()).."/alias.lua")
 local longdesc = S("This is a piece of equippable armor which reduces the amount of damage you receive.")
 local usage = S("To equip it, put it on the corresponding armor slot in your inventory menu.")
 
-minetest.register_tool("mcl_armor:elytra", {
-	description = S("Elytra"),
-	_doc_items_longdesc = longdesc,
-	_doc_items_usagehelp = usage,
-	inventory_image = "mcl_armor_inv_elytra.png",
-	groups = {armor_torso=1, mcl_armor_points=0, mcl_armor_uses=10, enchantability=0},
-	sounds = {
-		_mcl_armor_equip = "mcl_armor_equip_leather",
-		_mcl_armor_unequip = "mcl_armor_unequip_leather",
-	},
-	on_place = armor.on_armor_use,
-	on_secondary_use = armor.on_armor_use,
-})
-
 minetest.register_tool("mcl_armor:helmet_leather", {
 	description = S("Leather Cap"),
 	_doc_items_longdesc = longdesc,
@@ -336,7 +322,7 @@ local craft_ingreds = {
 	gold = { "mcl_core:gold_ingot", "mcl_core:gold_nugget" },
 	diamond = { "mcl_core:diamond" },
 	chain = { nil, "mcl_core:iron_nugget"} ,
-}
+}		
 
 for k, v in pairs(craft_ingreds) do
 	-- material
@@ -403,3 +389,4 @@ for k, v in pairs(craft_ingreds) do
 		})
 	end
 end
+

mods/ITEMS/mcl_banners/init.lua

@@ -35,49 +35,6 @@ mcl_banners.colors = {
 	["unicolor_light_blue"] = {"light_blue", S("Light Blue Banner"), "mcl_wool:light_blue", "#4040CF", "mcl_dye:lightblue", N("Light Blue") },
 }
 
-
-local pattern_names = {
-      "",
-      "border",
-      "bricks",
-      "circle",
-      "creeper",
-      "cross",
-      "curly_border",
-      "diagonal_up_left",
-      "diagonal_up_right",
-      "diagonal_right",
-      "diagonal_left",
-      "flower",
-      "gradient",
-      "gradient_up",
-      "half_horizontal_bottom",
-      "half_horizontal",
-      "half_vertical",
-      "half_vertical_right",
-      "thing",
-      "rhombus",
-      "skull",
-      "small_stripes",
-      "square_bottom_left",
-      "square_bottom_right",
-      "square_top_left",
-      "square_top_right",
-      "straight_cross",
-      "stripe_bottom",
-      "stripe_center",
-      "stripe_downleft",
-      "stripe_downright",
-      "stripe_left",
-      "stripe_middle",
-      "stripe_right",
-      "stripe_top",
-      "triangle_bottom",
-      "triangle_top",
-      "triangles_bottom",
-      "triangles_top",
-}
-
 local colors_reverse = {}
 for k,v in pairs(mcl_banners.colors) do
 	colors_reverse["mcl_banners:banner_item_"..v[1]] = k
@@ -343,72 +300,24 @@ minetest.register_node("mcl_banners:hanging_banner", {
 	end,
 })
 
--- for pattern_name, pattern in pairs(patterns) do
 for colorid, colortab in pairs(mcl_banners.colors) do
-    for i, pattern_name in ipairs(pattern_names) do
 	local itemid = colortab[1]
 	local desc = colortab[2]
 	local wool = colortab[3]
 	local colorize = colortab[4]
 
-	local itemstring
-	if pattern_name == "" then
-		itemstring = "mcl_banners:banner_item_" .. itemid
-	else
-		itemstring = "mcl_banners:banner_preview" .. "_" .. pattern_name .. "_" .. itemid
-	end
-
+	local itemstring = "mcl_banners:banner_item_"..itemid
 	local inv
-	local base
-	local finished_banner
-	if pattern_name == "" then
-	    if colorize then
-		-- Base texture with base color
-		base = "mcl_banners_item_base.png^(mcl_banners_item_overlay.png^[colorize:"..colorize..")^[resize:32x32"
-	    else
-		base = "mcl_banners_item_base.png^mcl_banners_item_overlay.png^[resize:32x32"
-	    end
-	    finished_banner = base
+	if colorize then
+		inv = "mcl_banners_item_base.png^(mcl_banners_item_overlay.png^[colorize:"..colorize..")"
 	else
-		-- Banner item preview background
-		base = "mcl_banners_item_base.png^(mcl_banners_item_overlay.png^[colorize:#CCCCCC)^[resize:32x32"
-
-		desc = S("Preview Banner")
-
-		local pattern = "mcl_banners_" .. pattern_name .. ".png"
-		local color = colorize
-
-		-- Generate layer texture
-
-		-- TODO: The layer texture in the icon is squished
-		-- weirdly because the width/height aspect ratio of
-		-- the banner icon is 1:1.5, whereas the aspect ratio
-		-- of the banner entity is 1:2. A solution would be to
-		-- redraw the pattern textures as low-resolution pixel
-		-- art and use that instead.
-
-		local layer = "(([combine:20x40:-2,-2="..pattern.."^[resize:16x24^[colorize:"..color..":"..layer_ratio.."))"
-
-		function escape(text)
-			 return text:gsub("%^", "\\%^"):gsub(":", "\\:") -- :gsub("%(", "\\%("):gsub("%)", "\\%)")
-		end
-
-		finished_banner = "[combine:32x32:0,0=" .. escape(base) .. ":8,4=" .. escape(layer)
+		inv = "mcl_banners_item_base.png^mcl_banners_item_overlay.png"
 	end
 
-	inv = finished_banner
-
 	-- Banner items.
-	-- This is the player-visible banner item. It comes in 16 base colors with a lot of patterns.
+	-- This is the player-visible banner item. It comes in 16 base colors.
 	-- The multiple items are really only needed for the different item images.
 	-- TODO: Combine the items into only 1 item.
-	local groups
-	if pattern_name == "" then
-		groups = { banner = 1, deco_block = 1, flammable = -1 }
-	else
-		groups = { not_in_creative_inventory = 1 }
-	end
-
 	minetest.register_craftitem(itemstring, {
 		description = desc,
 		_tt_help = S("Paintable decoration"),
@@ -417,7 +326,7 @@ for colorid, colortab in pairs(mcl_banners.colors) do
 		wield_image = inv,
 		-- Banner group groups together the banner items, but not the nodes.
 		-- Used for crafting.
-		groups = groups,
+		groups = { banner = 1, deco_block = 1, flammable = -1 },
 		stack_max = 16,
 
 		on_place = function(itemstack, placer, pointed_thing)
@@ -583,7 +492,6 @@ for colorid, colortab in pairs(mcl_banners.colors) do
 		-- Add item to node alias
 		doc.add_entry_alias("nodes", "mcl_banners:standing_banner", "craftitems", itemstring)
 	end
-    end
 end
 
 if minetest.get_modpath("doc") then

mods/ITEMS/mcl_banners/patterncraft.lua

@@ -253,11 +253,6 @@ for colorid, colortab in pairs(mcl_banners.colors) do
 	dye_to_colorid_mapping[colortab[5]] = colorid
 end
 
-local dye_to_itemid_mapping = {}
-for colorid, colortab in pairs(mcl_banners.colors) do
-	dye_to_itemid_mapping[colortab[5]] = colortab[1]
-end
-
 -- Create a banner description containing all the layer names
 mcl_banners.make_advanced_banner_description = function(description, layers)
 	if layers == nil or #layers == 0 then
@@ -496,14 +491,7 @@ local banner_pattern_craft = function(itemstack, player, old_craft_grid, craft_i
 		imeta:set_string("description", ometa:get_string("description"))
 		imeta:set_string("name", mname)
 	end
-
-	if craft_predict then
-		local itemid_prefix = "mcl_banners:banner_preview"
-		local coloritemid = dye_to_itemid_mapping[dye]
-		return ItemStack(itemid_prefix .. "_" .. matching_pattern .. "_" .. coloritemid)
-	else
-		return itemstack
-	end
+	return itemstack
 end
 
 minetest.register_craft_predict(function(itemstack, player, old_craft_grid, craft_inv)

mods/ITEMS/mcl_compass/locale/mcl_compass.de.tr

@@ -1,4 +1,4 @@
 # textdomain: mcl_compass
-Compasses are tools which point to the world origin (X@=0, Z@=0) or the spawn point in the Overworld.=Kompasse sind Werkzeuge, die zum Ursprungspunkt der Welt (X@=0, Z@=0) oder zum Einstiegspunkt der Welt zeigen.
+Compasses are tools which point to the world origin (X@=0, Z@=0) or the spawn point in the Overworld.=Kompasse sind Werkzeuge, die zum Ursprungspunkt der Welt (X@=0, Z@=0) oder den Einstiegspunkt der Welt zeigen.
 Compass=Kompass
 Points to the world origin=Zeigt zum Startpunkt der Welt

mods/ITEMS/mcl_core/crafting.lua

@@ -46,56 +46,6 @@ minetest.register_craft({
 	}
 })
 
--- Stripped Bark
-minetest.register_craft({
-	output = "mcl_core:stripped_oak_bark 3",
-	recipe = {
-		{ "mcl_core:stripped_oak", "mcl_core:stripped_oak" },
-		{ "mcl_core:stripped_oak", "mcl_core:stripped_oak" },
-	}
-})
-
-minetest.register_craft({
-	output = "mcl_core:stripped_acacia_bark 3",
-	recipe = {
-		{ "mcl_core:stripped_acacia", "mcl_core:stripped_acacia" },
-		{ "mcl_core:stripped_acacia", "mcl_core:stripped_acacia" },
-	}
-})
-
-minetest.register_craft({
-	output = "mcl_core:stripped_dark_oak_bark 3",
-	recipe = {
-		{ "mcl_core:stripped_dark_oak", "mcl_core:stripped_dark_oak" },
-		{ "mcl_core:stripped_dark_oak", "mcl_core:stripped_dark_oak" },
-	}
-})
-
-minetest.register_craft({
-	output = "mcl_core:stripped_birch_bark 3",
-	recipe = {
-		{ "mcl_core:stripped_birch", "mcl_core:stripped_birch" },
-		{ "mcl_core:stripped_birch", "mcl_core:stripped_birch" },
-	}
-})
-
-minetest.register_craft({
-	output = "mcl_core:stripped_spruce_bark 3",
-	recipe = {
-		{ "mcl_core:stripped_spruce", "mcl_core:stripped_spruce" },
-		{ "mcl_core:stripped_spruce", "mcl_core:stripped_spruce" },
-	}
-})
-
-minetest.register_craft({
-	output = "mcl_core:stripped_jungle_bark 3",
-	recipe = {
-		{ "mcl_core:stripped_jungle", "mcl_core:stripped_jungle" },
-		{ "mcl_core:stripped_jungle", "mcl_core:stripped_jungle" },
-	}
-})
-
-
 minetest.register_craft({
 	type = 'shapeless',
 	output = 'mcl_core:mossycobble',

mods/ITEMS/mcl_core/functions.lua

@@ -190,22 +190,6 @@ minetest.register_abm({
 	end,
 })
 
--- Make cactus destroy items
-minetest.register_abm({
-	label = "Cactus destroy items",
-	nodenames = {"mcl_core:cactus"},
-	interval = 1,
-	chance = 1,
-	action = function(pos, node, active_object_count, active_object_count_wider)
-		for _,object in pairs(minetest.get_objects_inside_radius(pos, 0.9)) do
-			if not object:is_player() and object:get_luaentity() and object:get_luaentity().name == "__builtin:item" then
-				object:remove()
-			end
-		end
-	end,
-})
-
-
 minetest.register_abm({
 	label = "Sugar canes growth",
 	nodenames = {"mcl_core:reeds"},

mods/ITEMS/mcl_core/nodes_trees.lua

@@ -1,4 +1,4 @@
--- Tree nodes: Wood, Wooden Planks, Sapling, Leaves, Stripped Wood
+-- Tree nodes: Wood, Wooden Planks, Sapling, Leaves
 local S = minetest.get_translator("mcl_core")
 
 local mod_screwdriver = minetest.get_modpath("screwdriver") ~= nil
@@ -48,166 +48,6 @@ local register_tree_trunk = function(subname, description_trunk, description_bar
 	})
 end
 
--- Register stripped trunk 
-minetest.register_node("mcl_core:stripped_oak", {
-	description = "Stripped Oak Log",
-	_doc_items_longdesc = "Stripped Oak Log is a log that has been stripped of it's bark.",
-	tiles = {"mcl_core_stripped_oak_top.png", "mcl_core_stripped_oak_top.png", "mcl_core_stripped_oak_side.png"},
-	is_ground_content = false,
-	paramtype2 = "facedir",
-	on_place = mcl_util.rotate_axis,
-	groups = {handy=1,axey=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5, tree=1},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	_mcl_blast_resistance = 10,
-	_mcl_hardness = 2,
-})
-
-minetest.register_node("mcl_core:stripped_acacia", {
-	description = "Stripped Acacia Log",
-	_doc_items_longdesc = "Stripped Acacia Log is a log that has been stripped of it's bark.",
-	tiles = {"mcl_core_stripped_acacia_top.png", "mcl_core_stripped_acacia_top.png", "mcl_core_stripped_acacia_side.png"},
-	is_ground_content = false,
-	paramtype2 = "facedir",
-	on_place = mcl_util.rotate_axis,
-	groups = {handy=1,axey=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5, tree=1},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	_mcl_blast_resistance = 10,
-	_mcl_hardness = 2,
-})
-
-minetest.register_node("mcl_core:stripped_dark_oak", {
-	description = "Stripped Dark Oak Log",
-	_doc_items_longdesc = "Stripped Dark Oak Log is a log that has been stripped of it's bark.",
-	tiles = {"mcl_core_stripped_dark_oak_top.png", "mcl_core_stripped_dark_oak_top.png", "mcl_core_stripped_dark_oak_side.png"},
-	is_ground_content = false,
-	paramtype2 = "facedir",
-	on_place = mcl_util.rotate_axis,
-	groups = {handy=1,axey=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5, tree=1},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	_mcl_blast_resistance = 10,
-	_mcl_hardness = 2,
-})
-
-minetest.register_node("mcl_core:stripped_birch", {
-	description = "Stripped Birch Log",
-	_doc_items_longdesc = "Stripped Birch Log is a log that has been stripped of it's bark.",
-	tiles = {"mcl_core_stripped_birch_top.png", "mcl_core_stripped_birch_top.png", "mcl_core_stripped_birch_side.png"},
-	is_ground_content = false,
-	paramtype2 = "facedir",
-	on_place = mcl_util.rotate_axis,
-	groups = {handy=1,axey=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5, tree=1},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	_mcl_blast_resistance = 10,
-	_mcl_hardness = 2,
-})
-
-minetest.register_node("mcl_core:stripped_spruce", {
-	description = "Stripped Spruce Log",
-	_doc_items_longdesc = "Stripped Spruce Log is a log that has been stripped of it's bark.",
-	tiles = {"mcl_core_stripped_spruce_top.png", "mcl_core_stripped_spruce_top.png", "mcl_core_stripped_spruce_side.png"},
-	is_ground_content = false,
-	paramtype2 = "facedir",
-	on_place = mcl_util.rotate_axis,
-	groups = {handy=1,axey=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5, tree=1},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	_mcl_blast_resistance = 10,
-	_mcl_hardness = 2,
-})
-
-minetest.register_node("mcl_core:stripped_jungle", {
-	description = "Stripped Jungle Log",
-	_doc_items_longdesc = "Stripped Jungle Log is a log that has been stripped of it's bark.",
-	tiles = {"mcl_core_stripped_jungle_top.png", "mcl_core_stripped_jungle_top.png", "mcl_core_stripped_jungle_side.png"},
-	is_ground_content = false,
-	paramtype2 = "facedir",
-	on_place = mcl_util.rotate_axis,
-	groups = {handy=1,axey=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5, tree=1},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	_mcl_blast_resistance = 10,
-	_mcl_hardness = 2,
-})
-
-
--- Register stripped bark
-minetest.register_node("mcl_core:stripped_oak_bark", {
-	description = "Stripped Oak Bark",
-	_doc_items_longdesc = "Stripped Oak Bark is a bark that has been stripped.",
-	tiles = {"mcl_core_stripped_oak_side.png"},
-	is_ground_content = false,
-	paramtype2 = "facedir",
-	on_place = mcl_util.rotate_axis,
-	groups = {handy=1,axey=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	_mcl_blast_resistance = 10,
-	_mcl_hardness = 2,
-})
-
-minetest.register_node("mcl_core:stripped_acacia_bark", {
-	description = "Stripped Acacia Bark",
-	_doc_items_longdesc = "Stripped Acacia Bark is a bark that has been stripped.",
-	tiles = {"mcl_core_stripped_acacia_side.png"},
-	is_ground_content = false,
-	paramtype2 = "facedir",
-	on_place = mcl_util.rotate_axis,
-	groups = {handy=1,axey=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	_mcl_blast_resistance = 10,
-	_mcl_hardness = 2,
-})
-
-minetest.register_node("mcl_core:stripped_dark_oak_bark", {
-	description = "Stripped Dark Oak Bark",
-	_doc_items_longdesc = "Stripped Dark Oak Bark is a bark that has been stripped.",
-	tiles = {"mcl_core_stripped_dark_oak_side.png"},
-	is_ground_content = false,
-	paramtype2 = "facedir",
-	on_place = mcl_util.rotate_axis,
-	groups = {handy=1,axey=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	_mcl_blast_resistance = 10,
-	_mcl_hardness = 2,
-})
-
-minetest.register_node("mcl_core:stripped_birch_bark", {
-	description = "Stripped Birch Bark",
-	_doc_items_longdesc = "Stripped Birch Bark is a bark that has been stripped.",
-	tiles = {"mcl_core_stripped_birch_side.png"},
-	is_ground_content = false,
-	paramtype2 = "facedir",
-	on_place = mcl_util.rotate_axis,
-	groups = {handy=1,axey=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	_mcl_blast_resistance = 10,
-	_mcl_hardness = 2,
-})
-
-minetest.register_node("mcl_core:stripped_spruce_bark", {
-	description = "Stripped Spruce Bark",
-	_doc_items_longdesc = "Stripped Spruce Bark is a bark that has been stripped.",
-	tiles = {"mcl_core_stripped_spruce_side.png"},
-	is_ground_content = false,
-	paramtype2 = "facedir",
-	on_place = mcl_util.rotate_axis,
-	groups = {handy=1,axey=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	_mcl_blast_resistance = 10,
-	_mcl_hardness = 2,
-})
-
-minetest.register_node("mcl_core:stripped_jungle_bark", {
-	description = "Stripped Jungle Bark",
-	_doc_items_longdesc = "Stripped Jungles Bark is a bark that has been stripped.",
-	tiles = {"mcl_core_stripped_jungle_side.png"},
-	is_ground_content = false,
-	paramtype2 = "facedir",
-	on_place = mcl_util.rotate_axis,
-	groups = {handy=1,axey=1, flammable=2, building_block=1, material_wood=1, fire_encouragement=5, fire_flammability=5},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	_mcl_blast_resistance = 10,
-	_mcl_hardness = 2,
-})
-
-
 local register_wooden_planks = function(subname, description, tiles)
 	minetest.register_node("mcl_core:"..subname, {
 		description = description,
@@ -386,4 +226,4 @@ register_leaves("birchleaves", S("Birch Leaves"), S("Birch leaves are grown from
 -- Node aliases
 
 minetest.register_alias("default:acacia_tree", "mcl_core:acaciatree")
-minetest.register_alias("default:acacia_leaves", "mcl_core:acacialeaves")
+minetest.register_alias("default:acacia_leaves", "mcl_core:acacialeaves")

mods/ITEMS/mcl_doors/api_doors.lua

@@ -1,5 +1,4 @@
 local S = minetest.get_translator("mcl_doors")
-local minetest_get_meta = minetest.get_meta
 
 -- This helper function calls on_place_node callbacks.
 local function on_place_node(place_to, newnode,
@@ -165,14 +164,14 @@ function mcl_doors:register_door(name, def)
 			end
 
 			if def.only_placer_can_open then
-				local meta = minetest_get_meta(pt)
+				local meta = minetest.get_meta(pt)
 				meta:set_string("doors_owner", "")
-				meta = minetest_get_meta(pt2)
+				meta = minetest.get_meta(pt2)
 				meta:set_string("doors_owner", "")
 			end
 
-			local meta1 = minetest_get_meta(pt)
-			local meta2 = minetest_get_meta(pt2)
+			local meta1 = minetest.get_meta(pt)
+			local meta2 = minetest.get_meta(pt2)
 			-- save mirror state for the correct door
 			if left_node.name:sub(1, #name) == name then
 				meta1:set_int("is_mirrored", 1)
@@ -199,9 +198,9 @@ function mcl_doors:register_door(name, def)
 	local tb = def.tiles_bottom
 
 	local function on_open_close(pos, dir, check_name, replace, replace_dir)
-		local meta1 = minetest_get_meta(pos)
+		local meta1 = minetest.get_meta(pos)
 		pos.y = pos.y+dir
-		local meta2 = minetest_get_meta(pos)
+		local meta2 = minetest.get_meta(pos)
 
 		-- if name of other door is not the same as check_name -> return
 		if not minetest.get_node(pos).name == check_name  then
@@ -255,7 +254,7 @@ function mcl_doors:register_door(name, def)
 		if not def.only_placer_can_open then
 			return true
 		end
-		local meta = minetest_get_meta(pos)
+		local meta = minetest.get_meta(pos)
 		local pn = player:get_player_name()
 		return meta:get_string("doors_owner") == pn
 	end
@@ -293,15 +292,10 @@ function mcl_doors:register_door(name, def)
 		sounds = def.sounds,
 
 		after_destruct = function(bottom, oldnode)
-			local meta_bottom = minetest_get_meta(bottom)
-			if meta_bottom:get_int("rotation") == 1 then
-				meta_bottom:set_int("rotation", 0)
-			else
-				minetest.add_item(bottom, name)
-				local top = { x = bottom.x, y = bottom.y + 1, z = bottom.z }
-				if minetest.get_node(bottom).name ~= name.."_b_2" and minetest.get_node(top).name == name.."_t_1" then
-					minetest.remove_node(top)
-				end
+			minetest.add_item(bottom, name)
+			local top = { x = bottom.x, y = bottom.y + 1, z = bottom.z }
+			if minetest.get_node(bottom).name ~= name.."_b_2" and minetest.get_node(top).name == name.."_t_1" then
+				minetest.remove_node(top)
 			end
 		end,
 
@@ -311,19 +305,13 @@ function mcl_doors:register_door(name, def)
 			action_on = on_mesecons_signal_open,
 		}},
 
-		on_rotate = function(bottom, node, user, mode, param2)
+		on_rotate = function(pos, node, user, mode, param2)
 			if mode == screwdriver.ROTATE_FACE then
-				local meta_bottom = minetest_get_meta(bottom)
-				meta_bottom:set_int("rotation", 1)
-				node.param2 = screwdriver.rotate.facedir(bottom, node, mode)
-				minetest.swap_node(bottom, node)
-
-				local top = {x=bottom.x,y=bottom.y+1,z=bottom.z}
-				local meta_top = minetest_get_meta(top)
-				meta_top:set_int("rotation", 1)
+				minetest.remove_node(pos)
+				node.param2 = screwdriver.rotate.facedir(pos, node, mode)
+				minetest.set_node(pos, node)
 				node.name = name .."_t_1"
-				minetest.swap_node(top, node)
-
+				minetest.set_node({x=pos.x,y=pos.y+1,z=pos.z}, node)
 				return true
 			end
 			return false
@@ -365,14 +353,9 @@ function mcl_doors:register_door(name, def)
 		sounds = def.sounds,
 
 		after_destruct = function(top, oldnode)
-			local meta_top = minetest_get_meta(top)
-			if meta_top:get_int("rotation") == 1 then
-				meta_top:set_int("rotation", 0)
-			else
-				local bottom = { x = top.x, y = top.y - 1, z = top.z }
-				if minetest.get_node(top).name ~= name.."_t_2" and minetest.get_node(bottom).name == name.."_b_1" and oldnode.name == name.."_t_1" then
-					minetest.dig_node(bottom)
-				end
+			local bottom = { x = top.x, y = top.y - 1, z = top.z }
+			if minetest.get_node(top).name ~= name.."_t_2" and minetest.get_node(bottom).name == name.."_b_1" and oldnode.name == name.."_t_1" then
+				minetest.dig_node(bottom)
 			end
 		end,
 
@@ -383,19 +366,13 @@ function mcl_doors:register_door(name, def)
 			rules = mesecon.rules.flat,
 		}},
 
-		on_rotate = function(top, node, user, mode, param2)
+		on_rotate = function(pos, node, user, mode, param2)
 			if mode == screwdriver.ROTATE_FACE then
-				local meta_top = minetest_get_meta(top)
-				meta_top:set_int("rotation", 1)
-				node.param2 = screwdriver.rotate.facedir(top, node, mode)
-				minetest.swap_node(top, node)
-
-				local bottom = {x=top.x,y=top.y-1,z=top.z}
-				local meta_bottom = minetest_get_meta(bottom)
-				meta_bottom:set_int("rotation", 1)
+				minetest.remove_node(pos)
+				node.param2 = screwdriver.rotate.facedir(pos, node, mode)
+				minetest.set_node(pos, node)
 				node.name = name .."_b_1"
-				minetest.swap_node(bottom, node)
-
+				minetest.set_node({x=pos.x,y=pos.y-1,z=pos.z}, node)
 				return true
 			end
 			return false
@@ -437,15 +414,10 @@ function mcl_doors:register_door(name, def)
 		sounds = def.sounds,
 
 		after_destruct = function(bottom, oldnode)
-			local meta_bottom = minetest_get_meta(bottom)
-			if meta_bottom:get_int("rotation") == 1 then
-				meta_bottom:set_int("rotation", 0)
-			else
-				local top = { x = bottom.x, y = bottom.y + 1, z = bottom.z }
-				minetest.add_item(bottom, name)
-				if minetest.get_node(bottom).name ~= name.."_b_1" and minetest.get_node(top).name == name.."_t_2" then
-					minetest.remove_node(top)
-				end
+			minetest.add_item(bottom, name)
+			local top = { x = bottom.x, y = bottom.y + 1, z = bottom.z }
+			if minetest.get_node(bottom).name ~= name.."_b_1" and minetest.get_node(top).name == name.."_t_2" then
+				minetest.remove_node(top)
 			end
 		end,
 
@@ -455,19 +427,13 @@ function mcl_doors:register_door(name, def)
 			action_off = on_mesecons_signal_close,
 		}},
 
-		on_rotate = function(bottom, node, user, mode, param2)
+		on_rotate = function(pos, node, user, mode, param2)
 			if mode == screwdriver.ROTATE_FACE then
-				local meta_bottom = minetest_get_meta(bottom)
-				meta_bottom:set_int("rotation", 1)
-				node.param2 = screwdriver.rotate.facedir(bottom, node, mode)
-				minetest.swap_node(bottom, node)
-
-				local top = {x=bottom.x,y=bottom.y+1,z=bottom.z}
-				local meta_top = minetest_get_meta(top)
-				meta_top:set_int("rotation", 1)
+				minetest.remove_node(pos)
+				node.param2 = screwdriver.rotate.facedir(pos, node, mode)
+				minetest.set_node(pos, node)
 				node.name = name .."_t_2"
-				minetest.swap_node(top, node)
-
+				minetest.set_node({x=pos.x,y=pos.y+1,z=pos.z}, node)
 				return true
 			end
 			return false
@@ -509,14 +475,9 @@ function mcl_doors:register_door(name, def)
 		sounds = def.sounds,
 
 		after_destruct = function(top, oldnode)
-			local meta_top = minetest_get_meta(top)
-			if meta_top:get_int("rotation") == 1 then
-				meta_top:set_int("rotation", 0)
-			else
-				local bottom = { x = top.x, y = top.y - 1, z = top.z }
-				if minetest.get_node(top).name ~= name.."_t_1" and minetest.get_node(bottom).name == name.."_b_2" and oldnode.name == name.."_t_2" then
-					minetest.dig_node(bottom)
-				end
+			local bottom = { x = top.x, y = top.y - 1, z = top.z }
+			if minetest.get_node(top).name ~= name.."_t_1" and minetest.get_node(bottom).name == name.."_b_2" and oldnode.name == name.."_t_2" then
+				minetest.dig_node(bottom)
 			end
 		end,
 
@@ -527,19 +488,13 @@ function mcl_doors:register_door(name, def)
 			rules = mesecon.rules.flat,
 		}},
 
-		on_rotate = function(top, node, user, mode, param2)
+		on_rotate = function(pos, node, user, mode, param2)
 			if mode == screwdriver.ROTATE_FACE then
-				local meta_top = minetest_get_meta(top)
-				meta_top:set_int("rotation", 1)
-				node.param2 = screwdriver.rotate.facedir(top, node, mode)
-				minetest.swap_node(top, node)
-
-				local bottom = {x=top.x,y=top.y-1,z=top.z}
-				local meta_bottom = minetest_get_meta(bottom)
-				meta_bottom:set_int("rotation", 1)
+				minetest.remove_node(pos)
+				node.param2 = screwdriver.rotate.facedir(pos, node, mode)
+				minetest.set_node(pos, node)
 				node.name = name .."_b_2"
-				minetest.swap_node(bottom, node)
-
+				minetest.set_node({x=pos.x,y=pos.y-1,z=pos.z}, node)
 				return true
 			end
 			return false

mods/ITEMS/mcl_doors/locale/mcl_doors.de.tr

@@ -16,9 +16,9 @@ Birch Trapdoor=Birkenfalltür
 Spruce Trapdoor=Fichtenfalltür
 Dark Oak Trapdoor=Schwarzeichenfalltür
 Jungle Trapdoor=Dschungelfalltür
-Wooden trapdoors are horizontal barriers which can be opened and closed by hand or a redstone signal. They occupy the upper or lower part of a block, depending on how they have been placed. When open, they can be climbed like a ladder.=Holzfalltüren sind horizontale Barrieren, die von Hand oder mit einem Redstone-Signal geöffnet oder geschlossen werden können. Sie belegen den oberen oder unteren Teil eines Blocks, je nachdem, wie sie platziert wurden. Wenn geöffnet, können sie wie eine Leiter erklommen werden.
+Wooden trapdoors are horizontal barriers which can be opened and closed by hand or a redstone signal. They occupy the upper or lower part of a block, depending on how they have been placed. When open, they can be climbed like a ladder.=Holzfalltüren sind horizontale Barrieren, die von Hand oder mit einem Redstone-Signal geöffnet oder geschlossen werden können. Sie belegen den oberen oder unteren Teil eines Blocks, je nach dem, wie sie platziert wurden. Wenn geöffnet, können sie wie eine Leiter erklommen werden.
 To open or close the trapdoor, rightclick it or send a redstone signal to it.=Um die Falltür zu öffnen oder zu schließen, rechtsklicken Sie sie oder schicken Sie ein Redstone-Signal zu ihr.
 Iron Trapdoor=Eisenfalltür
-Iron trapdoors are horizontal barriers which can only be opened and closed by redstone signals, but not by hand. They occupy the upper or lower part of a block, depending on how they have been placed. When open, they can be climbed like a ladder.=Eisenfalltüren sind horizontale Barrieren, die nur mit einem Redstone-Signal geöffnet oder geschlossen werden können, nicht von Hand. Sie belegen den oberen oder unteren Teil eines Blocks, je nachdem, wie sie platziert wurden. Wenn geöffnet, können sie wie eine Leiter erklommen werden.
+Iron trapdoors are horizontal barriers which can only be opened and closed by redstone signals, but not by hand. They occupy the upper or lower part of a block, depending on how they have been placed. When open, they can be climbed like a ladder.=Eisenfalltüren sind horizontale Barrieren, die nur mit einem Redstone-Signal geöffnet oder geschlossen werden können, nicht von Hand. Sie belegen den oberen oder unteren Teil eines Blocks, je nach dem, wie sie platziert wurden. Wenn geöffnet, können sie wie eine Leiter erklommen werden.
 Openable by players and redstone power=Zu öffnen von Spielern und Redstoneenergie
 Openable by redstone power=Zu öffnen von Redstoneenergie

mods/ITEMS/mcl_enchanting/locale/mcl_enchanting.de.tr

@@ -17,8 +17,8 @@ Efficiency=Effizienz
 Increases mining speed.=Erhöht Grabegeschwindigkeit.
 Feather Falling=Federfall
 Reduces fall damage.=Reduziert Fallschaden.
-Fire Aspect=Feueraspekt
-Sets target on fire.=Zündet das Ziel an.
+Fire Aspect=Feieraspekt
+Sets target on fire.=Zündes das Ziel an.
 Fire Protection=Feuerschutz
 Reduces fire damage.=Reduziert Feuerschaden
 Flame=Flamme
@@ -31,7 +31,7 @@ Impaling=Aufspießen
 Trident deals additional damage to ocean mobs.=Dreizack richtet Zusatzschaden an Ozeanmobs an.
 Infinity=Unendlichkeit
 Shooting consumes no regular arrows.=Schüsse verbrauchen keine regulären Pfeile.
-Knockback=Rückschlag
+Knockback=Rückschlag.
 Increases knockback.=Verstärkt Rückschlag.
 Looting=Plünderer
 Increases mob loot.=Erhöht Abwürfe von Mobs.
@@ -43,7 +43,7 @@ Lure=Köder
 Decreases time until rod catches something.=Reduziert die Zeit, bis die Angel etwas fängt.
 Mending=Ausbessern
 Repair the item while gaining XP orbs.=Gegenstand reparieren, während man Erfahrungskugeln erhält.
-Multishot=Mehrfachschuss
+Multishot=Mehrschuss
 Shoot 3 arrows at the cost of one.=3 Pfeile zum Preis von 1 schießen.
 Piercing=Durchbohren
 Arrows passes through multiple objects.=Pfeile durchdringen mehrere Objekte.
@@ -74,7 +74,7 @@ Increases sweeping attack damage.=Erhöht Schwungangriffsschaden.
 Thorns=Dornen
 Reflects some of the damage taken when hit, at the cost of reducing durability with each proc.=Reflektiert etwas des Schadens beim Erleiden eines Treffers, auf Kosten der Haltbarkeit.
 Unbreaking=Haltbarkeit
-Increases item durability.=Erhöht Haltbarkeit des Gegenstands.
+Increases item durability.=Erhöht Haldbarkeit des Gegenstands.
 Inventory=Inventar
 @1 Lapis Lazuli=@1 Lapislazuli
 @1 Enchantment Levels=@1 Verzauberungsstufen

mods/ITEMS/mcl_end/end_crystal.lua

@@ -79,54 +79,6 @@ minetest.register_entity("mcl_end:crystal", {
 	_hittable_by_projectile = true
 })
 
-minetest.register_entity("mcl_end:crystal_beam", {
-	initial_properties = {
-		physical = false,
-		visual = "cube",
-		visual_size = {x = 1, y = 1, z = 1},
-		textures = {
-			"mcl_end_crystal_beam.png^[transformR90",
-			"mcl_end_crystal_beam.png^[transformR90",
-			"mcl_end_crystal_beam.png",
-			"mcl_end_crystal_beam.png",
-			"blank.png",
-			"blank.png",
-		},
-		static_save = false,
-	},
-	spin = 0,
-	init = function(self, dragon, crystal)
-		self.dragon, self.crystal = dragon, crystal
-		crystal:get_luaentity().beam = self.object
-		dragon:get_luaentity().beam = self.object
-	end,
-	on_deactivate = function(self)
-		if self.crystal and self.crystal:get_luaentity() then
-			self.crystal:get_luaentity().beam = nil
-		end
-		if self.dragon and self.dragon:get_luaentity() then
-			self.dragon:get_luaentity().beam = nil
-		end
-	end,
-	on_step = function(self, dtime)
-		if self.dragon and self.dragon:get_luaentity() and self.crystal and self.crystal:get_luaentity() then
-			self.spin = self.spin + dtime * math.pi * 2 / 4
-			local dragon_pos, crystal_pos = self.dragon:get_pos(), self.crystal:get_pos()
-
-			dragon_pos.y = dragon_pos.y + 4
-			crystal_pos.y = crystal_pos.y + 2
-
-			self.object:set_pos(vector.divide(vector.add(dragon_pos, crystal_pos), 2))
-			local rot = vector.dir_to_rotation(vector.direction(dragon_pos, crystal_pos))
-			rot.z = self.spin
-			self.object:set_rotation(rot)
-			self.object:set_properties({visual_size = {x = 0.5, y = 0.5, z = vector.distance(dragon_pos, crystal_pos)}})
-		else
-			self.object:remove()
-		end
-	end,
-})
-
 minetest.register_craftitem("mcl_end:crystal", {
 	inventory_image = "mcl_end_crystal_item.png",
 	description = S("End Crystal"),

mods/ITEMS/mcl_fences/locale/mcl_fences.de.tr

@@ -1,6 +1,6 @@
 # textdomain: mcl_fences
 Fences are structures which block the way. Fences will connect to each other and solid blocks. They cannot be jumped over with a simple jump.=Zäune sind Gebäude, die den Weg blockieren. Sie verbinden sich gegenseitig und anderen festen Blöcken. Man kann sie nicht mit normalen Sprüngen überspringen.
-Fence gates can be opened or closed and can't be jumped over. Fences will connect nicely to fence gates.=Zauntore können geöffnet und geschlossen werden und können nicht übersprungen werden. Zäune lassen sich gut mit Zauntoren verbinden.
+Fence gates can be opened or closed and can't be jumped over. Fences will connect nicely to fence gates.=Zauntore können geöffnet und geschlossen werden und können nicht übersprungen werden. Zäune werden sich gut mit Zauntoren verbinden.
 Right-click the fence gate to open or close it.=Rechtsklicken Sie auf ein Zauntor, um es zu öffnen oder zu schließen.
 Oak Fence=Eichenzaun
 Oak Fence Gate=Eichenzauntor

mods/ITEMS/mcl_fire/init.lua

@@ -47,16 +47,94 @@ local alldirs=
 	{ x = 0, y = 0, z = 1}
 }
 
-local smoke_pdef = {
-	amount = 0.009,
-	maxexptime = 4.0,
+-- 3 exptime variants because the animation is not tied to particle expiration time.
+-- 3 colorized variants to imitate minecraft's
+local smoke_pdef_base = {
+	amount = 0.001,
+	time = 0,
+	-- minpos = vector.add(pos, { x = -0.45, y = -0.45, z = -0.45 }),
+	-- maxpos = vector.add(pos, { x = 0.45, y = 0.45, z = 0.45 }),
 	minvel = { x = -0.1, y = 0.3, z = -0.1 },
 	maxvel = { x = 0.1, y = 1.6, z = 0.1 },
+	-- minexptime = 3 exptime variants,
+	-- maxexptime = 3 exptime variants
 	minsize = 4.0,
 	maxsize = 4.5,
-	minrelpos = { x = -0.45, y = -0.45, z = -0.45 },
-	maxrelpos = { x = 0.45, y = 0.45, z = 0.45 },
+	-- texture = "mcl_particles_smoke_anim.png^[colorize:#000000:(3 colourize variants)",
+	animation = {
+		type = "vertical_frames",
+		aspect_w = 8,
+		aspect_h = 8,
+		-- length = 3 exptime variants
+	},
+	collisiondetection = true,
 }
+local smoke_pdef_cached = {}
+local spawn_smoke = function(pos)
+	local min = math.min
+	local new_minpos = vector.add(pos, { x = -0.45, y = -0.45, z = -0.45 })
+	local new_maxpos = vector.add(pos, { x = 0.45, y = 0.45, z = 0.45 })
+
+	-- populate the cache
+	if not next(smoke_pdef_cached) then
+		-- 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.75, 1.5, 4.0 }
+		local colorizes = { "199", "209", "243" } -- round(78%, 82%, 90% of 256) - 1
+
+		local id = 1
+		for _,exptime in ipairs(exptimes) do
+			for _,colorize in ipairs(colorizes) do
+				smoke_pdef_base.minpos = new_minpos
+				smoke_pdef_base.maxpos = new_maxpos
+				smoke_pdef_base.maxexptime = exptime
+				smoke_pdef_base.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_base.minexptime = min(exptime, (7.0/8.0 * (exptime + 0.1) + 0.1))
+				smoke_pdef_base.texture = "mcl_particles_smoke_anim.png^[colorize:#000000:" ..colorize
+
+				smoke_pdef_cached[id] = table.copy(smoke_pdef_base)
+
+				mcl_particles.add_node_particlespawner(pos, smoke_pdef_cached[id], "high")
+
+				id = id + 1
+			end
+		end
+
+		-- cache already populated
+	else
+		for i, smoke_pdef in ipairs(smoke_pdef_cached) do
+			smoke_pdef.minpos = new_minpos
+			smoke_pdef.maxpos = new_maxpos
+			mcl_particles.add_node_particlespawner(pos, smoke_pdef, "high")
+		end
+	end
+
+--[[ Old smoke pdef
+	local spawn_smoke = function(pos)
+	mcl_particles.add_node_particlespawner(pos, {
+		amount = 0.1,
+		time = 0,
+		minpos = vector.add(pos, { x = -0.45, y = -0.45, z = -0.45 }),
+		maxpos = vector.add(pos, { x = 0.45, y = 0.45, z = 0.45 }),
+		minvel = { x = 0, y = 0.5, z = 0 },
+		maxvel = { x = 0, y = 0.6, z = 0 },
+		minexptime = 2.0,
+		maxexptime = 2.0,
+		minsize = 3.0,
+		maxsize = 4.0,
+		texture = "mcl_particles_smoke_anim.png^[colorize:#000000:127",
+		animation = {
+			type = "vertical_frames",
+			aspect_w = 8,
+			aspect_h = 8,
+			length = 2.1,
+		},
+	}, "high")
+	-- ]]
+
+end
 
 --
 -- Items
@@ -225,7 +303,7 @@ minetest.register_node("mcl_fire:fire", {
 		end
 
 		fire_timer(pos)
-		mcl_particles.spawn_smoke(pos, "fire", smoke_pdef)
+		spawn_smoke(pos)
 	end,
 	on_destruct = function(pos)
 		mcl_particles.delete_node_particlespawners(pos)
@@ -289,7 +367,7 @@ minetest.register_node("mcl_fire:eternal_fire", {
 		if has_mcl_portals then --Calling directly minetest.get_modpath consumes 4x more compute time
 			mcl_portals.light_nether_portal(pos)
 		end
-		mcl_particles.spawn_smoke(pos, "fire", smoke_pdef)
+		spawn_smoke(pos)
 	end,
 	on_destruct = function(pos)
 		mcl_particles.delete_node_particlespawners(pos)
@@ -549,7 +627,7 @@ minetest.register_lbm({
 	nodenames = {"group:fire"},
 	run_at_every_load = true,
 	action = function(pos, node)
-		mcl_particles.spawn_smoke(pos, "fire", smoke_pdef)
+		spawn_smoke(pos)
 	end,
 })
 

mods/ITEMS/mcl_fireworks/README.txt

@@ -1,7 +0,0 @@
-Firework mod for Mineclone 2
-
-by NO11 and and some parts by j45
-
-Sound credits:
-
-* mcl_firework_rocket.ogg (tnt_ignite.ogg): Own derivate work of sound by Ned Bouhalassa (CC0) created in 2005, source: <https://freesound.org/people/Ned Bouhalassa/sounds/8320/>

mods/ITEMS/mcl_fireworks/config.txt

@@ -1,2 +0,0 @@
-name = mcl_firework
-author = NO11, j45

mods/ITEMS/mcl_fireworks/crafting.lua

@@ -1,17 +0,0 @@
-minetest.register_craft({
-	type = "shapeless",
-	output = "mcl_fireworks:rocket_1 3",
-	recipe = {"mcl_core:paper", "mcl_mobitems:gunpowder"},
-})
-
-minetest.register_craft({
-	type = "shapeless",
-	output = "mcl_fireworks:rocket_2 3",
-	recipe = {"mcl_core:paper", "mcl_mobitems:gunpowder", "mcl_mobitems:gunpowder"},
-})
-
-minetest.register_craft({
-	type = "shapeless",
-	output = "mcl_fireworks:rocket_3 3",
-	recipe = {"mcl_core:paper", "mcl_mobitems:gunpowder", "mcl_mobitems:gunpowder", "mcl_mobitems:gunpowder"},
-})

mods/ITEMS/mcl_fireworks/init.lua

@@ -1,4 +0,0 @@
-local path = minetest.get_modpath("mcl_fireworks")
-
-dofile(path .. "/register.lua")
-dofile(path .. "/crafting.lua")

mods/ITEMS/mcl_fireworks/locale/mcl_fireworks.de.tr

@@ -1,3 +0,0 @@
-# textdomain: mcl_fireworks
-Firework Rocket=Feuerwerksrakete
-Flight Duration:=Flugdauer:

mods/ITEMS/mcl_fireworks/register.lua

@@ -1,69 +0,0 @@
-local S = minetest.get_translator("mcl_fireworks")
-
-player_rocketing = {}
-
-local help = S("Flight Duration:")
-local description = S("Firework Rocket")
-local rocket_sound = function()
-    minetest.sound_play("mcl_fireworks_rocket")
-end
-
-minetest.register_craftitem("mcl_fireworks:rocket_1", {
-    description = description,
-    _tt_help = help.." 1",
-    inventory_image = "mcl_fireworks_rocket.png",
-    stack_max = 64,
-    on_use = function(itemstack, user, pointed_thing)
-      local torso = user:get_inventory():get_stack("armor", 3)
-      if torso and torso:get_name() == "mcl_armor:elytra" and player_rocketing[user] ~= true then
-        player_rocketing[user] = true
-        minetest.after(2.2, function()
-          player_rocketing[user] = false
-        end)
-        itemstack:take_item()
-	      --user:add_player_velocity(vector.multiply(user:get_look_dir(), 20))
-        rocket_sound()
-      end
-      return itemstack
-    end,
-})
-
-minetest.register_craftitem("mcl_fireworks:rocket_2", {
-    description = description,
-    _tt_help = help.." 2",
-    inventory_image = "mcl_fireworks_rocket.png",
-    stack_max = 64,
-    on_use = function(itemstack, user, pointed_thing)
-      local torso = user:get_inventory():get_stack("armor", 3)
-      if torso and torso:get_name() == "mcl_armor:elytra" and player_rocketing[user] ~= true then
-        player_rocketing[user] = true
-        minetest.after(4.5, function()
-          player_rocketing[user] = false
-        end)
-        itemstack:take_item()
-	      --user:add_player_velocity(vector.multiply(user:get_look_dir(), 20))
-        rocket_sound()
-      end
-      return itemstack
-    end,
-})
-
-minetest.register_craftitem("mcl_fireworks:rocket_3", {
-    description = description,
-    _tt_help = help.." 3",
-    inventory_image = "mcl_fireworks_rocket.png",
-    stack_max = 64,
-    on_use = function(itemstack, user, pointed_thing)
-      local torso = user:get_inventory():get_stack("armor", 3)
-      if torso and torso:get_name() == "mcl_armor:elytra" and player_rocketing[user] ~= true then
-        player_rocketing[user] = true
-        minetest.after(6, function()
-          player_rocketing[user] = false
-        end)
-        itemstack:take_item()
-	      --user:add_player_velocity(vector.multiply(user:get_look_dir(), 20))
-        rocket_sound()
-      end
-      return itemstack
-    end,
-})

mods/ITEMS/mcl_fishing/locale/mcl_fishing.de.tr

@@ -7,12 +7,12 @@ Raw fish is obtained by fishing and is a food item which can be eaten safely. Co
 Cooked Fish=Gekochter Fisch
 Mmh, fish! This is a healthy food item.=Mhh, Fisch! Ein gesundes Lebensmittel.
 Raw Salmon=Roher Lachs
-Raw salmon is obtained by fishing and is a food item which can be eaten safely. Cooking it improves its nutritional value.=Rohen Lachs erhält man beim Angeln. Er ist ein Lebensmittel, das sicher verzehrt werden kann.
+Raw salmon is obtained by fishing and is a food item which can be eaten safely. Cooking it improves its nutritional value.=Lohen Lachs erhält man beim Angeln. Er ist ein Lebensmittel, der sicher verzehrt werden kann.
 Cooked Salmon=Gekochter Lachs
 This is a healthy food item which can be eaten.=Ein gesundes essbares Lebensmittel.
 Clownfish=Clownfisch
-Clownfish may be obtained by fishing (and luck) and is a food item which can be eaten safely.=Einen Clownfisch kann man beim Angeln mit etwas Glück fangen. Er ist ein Lebensmittel, das sicher verzehrt werden kann.
+Clownfish may be obtained by fishing (and luck) and is a food item which can be eaten safely.=Einen Clownfisch kann man beim Angeln mit etwas Glück fangen. Er ist ein Lebensmittel, der sicher verzehrt werden kann.
 Pufferfish=Kugelfisch
-Pufferfish are a common species of fish and can be obtained by fishing. They can technically be eaten, but they are very bad for humans. Eating a pufferfish only restores 1 hunger point and will poison you very badly (which drains your health non-fatally) and causes serious food poisoning (which increases your hunger).=Kugelfische sind eine verbreitete Fischart, die geangelt werden kann. Sie können theoretisch gegessen werden, aber sie sind sehr schlecht für Menschen. Es gibt nur 1 Hungerpunkt und es wird Sie schwer vergiften (was Ihre Gesundheit verringert, aber nicht bis zum Tod) und Ihr Hungerpegel wird aufgrund der schweren Lebensmittelvergiftung stark ansteigen.
+Pufferfish are a common species of fish and can be obtained by fishing. They can technically be eaten, but they are very bad for humans. Eating a pufferfish only restores 1 hunger point and will poison you very badly (which drains your health non-fatally) and causes serious food poisoning (which increases your hunger).=Kugelfische sind eine verbreitete Fischart, die geangelt werden können. Sie können theoretisch gegessen werden, aber sie sind sehr schlecht für Menschen. Es gibt nur 1 Hungerpunkt und es wird Sie schwer vergiften (was Ihre Gesundheit verringert, aber nicht bis zum Tod) und Ihr Hungerpegel wird aufgrund der schweren Lebensmittelvergiftung stark ansteigen.
 Catches fish in water=Fängt Fische im Wasser
 Very poisonous=Sehr giftig

mods/ITEMS/mcl_flowers/locale/mcl_flowers.de.tr

@@ -12,9 +12,9 @@ Allium=Sternlauch
 Azure Bluet=Porzellansternchen
 Blue Orchid=Blaue Orchidee
 Tall Grass=Hohes Gras
-Tall grass is a small plant which often occurs on the surface of grasslands. It can be harvested for wheat seeds. By using bone meal, tall grass can be turned into double tallgrass which is two blocks high.=Hohes Gras ist eine kleine Pflanze, die oft auf Wiesenflächen wächst. Es kann für Weizensamen abgeerntet werden. Mit Knochenmehl lässt sich hohes Gras zu doppelhohem Gras verwandeln.
+Tall grass is a small plant which often occurs on the surface of grasslands. It can be harvested for wheat seeds. By using bone meal, tall grass can be turned into double tallgrass which is two blocks high.=Hohes Gras ist eine kleine Pflanze, die oft auf Wiesenflächen wächst. Es kann für Weizensamen abgeerntet werden. Mit Knochenmehl wird sich hohes Gras zu doppelhohem Gras verwandeln.
 Fern=Farn
-Ferns are small plants which occur naturally in jungles and taigas. They can be harvested for wheat seeds. By using bone meal, a fern can be turned into a large fern which is two blocks high.=Farne sind kleine Pflanzen, die oft in Dschungeln und Taigas vorkommen. Sie können für Weizensamen abgeerntet werden. Mit Knochenmehl lässt sich ein Farn zu einem großen Farn, der zwei Blöcke hoch ist, verwandeln.
+Ferns are small plants which occur naturally in jungles and taigas. They can be harvested for wheat seeds. By using bone meal, a fern can be turned into a large fern which is two blocks high.=Farne sind kleine Pflanzen, die oft in Dschungeln und Taigas vorkommen. Sie können für Weizensamen abgeerntet werden. Mit Knochenmehl wird sich ein Farn zu einem großen Farn, der zwei Blöcke hoch ist, verwandeln.
 (Top Part)=(Oberseite)
 Peony=Pfingstrose
 A peony is a large plant which occupies two blocks. It is mainly used in dye production.=Eine Pfingstrose ist eine große Pflanze, die zwei Blöcke hoch ist. Sie wird hauptsächlich für die Farbenproduktion gebraucht.

mods/ITEMS/mcl_mobitems/locale/mcl_mobitems.de.tr

@@ -61,7 +61,7 @@ This item is mainly used for crafting.=Dieser Gegenstand wird hauptsächlich in
 Magma Cream=Magmacreme
 Magma cream is a crafting component.=Magmacreme ist eine Fertigungskomponente.
 Ghast Tear=Ghast-Träne
-Place this item in an item frame as decoration.=Platzieren Sie diesen Gegenstand in einem Rahmen als Deko.
+Place this item in an item frame as decoration.=Platzieren Sie diesen Gegenstand in einem Rahmel als Deko.
 Nether Star=Nether-Stern
 
 A nether star is dropped when the Wither dies. Place it in an item frame to show the world how hardcore you are! Or just as decoration.=Ein Netherstern wird abgeworfen, wenn der Wither stirbt. Platzieren Sie ihn in einen Rahmen, um der Welt zu zeigen, wie großartig Sie sind!

mods/ITEMS/mcl_ocean/kelp.lua

@@ -1,9 +1,6 @@
 -- TODO: whenever it becomes possible to fully implement kelp without the
 -- plantlike_rooted limitation, please update accordingly.
 --
--- TODO: whenever it becomes possible to make kelp grow infinitely without
--- resorting to making intermediate kelp stem node, please update accordingly.
---
 -- TODO: In MC, you can't actually destroy kelp by bucket'ing water in the middle.
 -- However, because of the plantlike_rooted hack, we'll just allow it for now.
 
@@ -194,18 +191,17 @@ end
 
 
 -- Converts param2 to kelp height.
--- For the special case where the max param2 is reached, interpret that as the
--- 16th kelp stem.
 function kelp.get_height(param2)
-	return math_floor(param2 / 16) + math_floor(param2 % 16 / 8)
+	return math_floor(param2 / 16)
 end
 
 
 -- Obtain pos and node of the tip of kelp.
-function kelp.get_tip(pos, height)
-	-- Optional params: height
-	local height = height or kelp.get_height(mt_get_node(pos).param2)
-	local pos_tip = {x=pos.x, y=pos.y+height+1, z=pos.z}
+function kelp.get_tip(pos, param2)
+	-- Optional params: param2
+	local height = kelp.get_height(param2 or mt_get_node(pos).param2)
+	local pos_tip = {x=pos.x, y=pos.y, z=pos.z}
+	pos_tip.y = pos_tip.y + height + 1
 	return pos_tip, mt_get_node(pos_tip), height
 end
 
@@ -214,7 +210,7 @@ end
 function kelp.find_unsubmerged(pos, node, height)
 	-- Optional params: node, height
 	local node = node or mt_get_node(pos)
-	local height = height or ((node.param2 >= 0 and node.param2 < 16) and 1) or kelp.get_height(node.param2)
+	local height = height or kelp.get_height(node.param2)
 
 	local walk_pos = {x=pos.x, z=pos.z}
 	local y = pos.y
@@ -231,8 +227,7 @@ end
 
 -- Obtain next param2.
 function kelp.next_param2(param2)
-	-- param2 max value is 255, so adding to 256 causes overflow.
-	return math_min(param2+16 - param2 % 16, 255);
+	return param2+16 - param2 % 16
 end
 
 
@@ -316,7 +311,7 @@ function kelp.init_timer(pos, pos_hash)
 end
 
 
--- Apply next kelp height. The surface is swapped. so on_construct is skipped.
+-- Apply next kelp height.
 function kelp.next_height(pos, node, pos_tip, node_tip, submerged, downward_flowing)
 	-- Modified params: node
 	-- Optional params: node, set_node, pos_tip, node_tip, submerged, downward_flowing
@@ -372,9 +367,9 @@ end
 
 
 -- Drops the items for detached kelps.
-function kelp.detach_drop(pos, height)
-	-- Optional params: height
-	local height = height or kelp.get_height(mt_get_node(pos).param2)
+function kelp.detach_drop(pos, param2)
+	-- Optional params: param2
+	local height = kelp.get_height(param2 or mt_get_node(pos).param2)
 	local y = pos.y
 	local walk_pos = {x=pos.x, z=pos.z}
 	for i=1,height do
@@ -389,18 +384,17 @@ end
 -- Synonymous to digging the kelp.
 -- NOTE: this is intended for whenever kelp truly becomes segmented plants
 -- instead of rooted to the floor. Don't try to remove dig_pos.
-function kelp.detach_dig(dig_pos, pos, drop, node, height)
-	-- Optional params: drop, node, height
+function kelp.detach_dig(dig_pos, pos, node, drop)
+	-- Optional params: drop
 
-	local node = node or mt_get_node(pos)
-	local height = height or kelp.get_height(node.param2)
+	local param2 = node.param2
 	-- pos.y points to the surface, offset needed to point to the first kelp.
 	local new_height = dig_pos.y - (pos.y+1)
 
 	-- Digs the entire kelp.
 	if new_height <= 0 then
 		if drop then
-			kelp.detach_drop(dig_pos, height)
+			kelp.detach_drop(dig_pos, param2)
 		end
 		mt_set_node(pos, {
 			name=mt_registered_nodes[node.name].node_dig_prediction,
@@ -410,7 +404,7 @@ function kelp.detach_dig(dig_pos, pos, drop, node, height)
 	-- Digs the kelp beginning at a height.
 	else
 		if drop then
-			kelp.detach_drop(dig_pos, height - new_height)
+			kelp.detach_drop(dig_pos, param2 - new_height)
 		end
 		mt_swap_node(pos, {name=node.name, param=node.param, param2=16*new_height})
 	end
@@ -422,7 +416,7 @@ end
 --------------------------------------------------------------------------------
 
 function kelp.surface_on_dig(pos, node, digger)
-	kelp.detach_dig(pos, pos, true, node)
+	kelp.detach_dig(pos, pos, node, true)
 end
 
 
@@ -436,11 +430,11 @@ function kelp.surface_on_timer(pos)
 	local pos_hash
 
 	-- Update detahed kelps
-	local dig_pos,_, height = kelp.find_unsubmerged(pos, node)
+	local dig_pos = kelp.find_unsubmerged(pos, node)
 	if dig_pos then
 		pos_hash = mt_hash_node_position(pos)
 		mt_sound_play(mt_registered_nodes[node.name].sounds.dug, { gain = 0.5, pos = dig_pos }, true)
-		kelp.detach_dig(dig_pos, pos, true, node, height)
+		kelp.detach_dig(dig_pos, pos, node, true)
 		kelp.store_age(kelp.roll_init_age(), pos, pos_hash)
 	end
 
@@ -469,7 +463,7 @@ function kelp.surface_on_destruct(pos)
 
 	-- on_falling callback. Activated by pistons for falling nodes too.
 	if kelp.is_falling(pos, node) then
-		kelp.detach_drop(pos, kelp.get_height(node.param2))
+		kelp.detach_drop(pos, node.param2)
 	end
 
 	-- Removes position from queue
@@ -480,7 +474,7 @@ end
 
 function kelp.surface_on_mvps_move(pos, node, oldpos, nodemeta)
 	-- Pistons moving falling nodes will have already activated on_falling callback.
-	kelp.detach_dig(pos, pos, mt_get_item_group(node.name, "falling_node") ~= 1, node)
+	kelp.detach_dig(pos, pos, node, mt_get_item_group(node.name, "falling_node") ~= 1)
 end
 
 
@@ -524,7 +518,7 @@ function kelp.kelp_on_place(itemstack, placer, pointed_thing)
 	end
 
 
-	local pos_tip, node_tip, def_tip, new_surface, height
+	local pos_tip, node_tip, def_tip, new_kelp
 	-- Kelp must also be placed on the top/tip side of the surface/kelp
 	if pos_under.y >= pos_above.y then
 		return itemstack
@@ -532,33 +526,31 @@ function kelp.kelp_on_place(itemstack, placer, pointed_thing)
 
 	-- When placed on kelp.
 	if mt_get_item_group(nu_name, "kelp") == 1 then
-		height = kelp.get_height(node_under.param2)
-		pos_tip,node_tip = kelp.get_tip(pos_under, height)
+		pos_tip,node_tip = kelp.get_tip(pos_under, node_under.param2)
 		def_tip = mt_registered_nodes[node_tip.name]
 
 	-- When placed on surface.
 	else
-		new_surface = false
+		new_kelp = false
 		for _,surface in pairs(kelp.surfaces) do
 			if nu_name == surface.nodename then
 				node_under.name = "mcl_ocean:kelp_" ..surface.name
 				node_under.param2 = 0
-				new_surface = true
+				new_kelp = true
 				break
 			end
 		end
 		-- Surface must support kelp
-		if not new_surface then
+		if not new_kelp then
 			return itemstack
 		end
 
 		pos_tip = pos_above
 		node_tip = mt_get_node(pos_above)
 		def_tip = mt_registered_nodes[node_tip.name]
-		height = 0
 	end
 
-	-- Next kelp must also be submerged in water.
+	-- New kelp must also be submerged in water.
 	local downward_flowing = kelp.is_downward_flowing(pos_tip, node_tip)
 	local submerged = kelp.is_submerged(node_tip)
 	if not submerged then
@@ -570,19 +562,14 @@ function kelp.kelp_on_place(itemstack, placer, pointed_thing)
 	if def_node.sounds then
 		mt_sound_play(def_node.sounds.place, { gain = 0.5, pos = pos_under }, true)
 	end
-	-- TODO: get rid of rooted plantlike hack
-	if height < 16 then
-		kelp.next_height(pos_under, node_under, pos_tip, node_tip, def_tip, submerged, downward_flowing)
-	else
-		mt_add_item(pos_tip, "mcl_ocean:kelp")
-	end
+	kelp.next_height(pos_under, node_under, pos_tip, node_tip, def_tip, submerged, downward_flowing)
 	if not mt_is_creative_enabled(player_name) then
 		itemstack:take_item()
 	end
 
-	-- Initialize age and timer when it's planted on a new surface.
+	-- Initialize age and timer when it's a new kelp
 	local pos_hash = mt_hash_node_position(pos_under)
-	if new_surface then
+	if new_kelp then
 		kelp.init_age(pos_under, nil, pos_hash)
 		kelp.init_timer(pos_under, pos_hash)
 	else

mods/ITEMS/mcl_portals/portal_nether.lua

@@ -490,12 +490,10 @@ local function ecb_scan_area_2(blockpos, action, calls_remaining, param)
 	end
 
 	if param.next_chunk_1 and param.next_chunk_2 and param.next_pos then
-		local pos1, pos2, p = param.next_chunk_1, param.next_chunk_2, param.next_pos
-		if p.x >= pos1.x and p.x <= pos2.x and p.y >= pos1.y and p.y <= pos2.y and p.z >= pos1.z and p.z <= pos2.z then
-			log("action", "[mcl_portals] Making additional search in chunk below, because current one doesn't contain any air space for portal, target pos "..pos_to_string(p))
-			minetest.emerge_area(pos1, pos2, ecb_scan_area_2, {pos = p, pos1 = pos1, pos2 = pos2, name=name, obj=obj})
-			return
-		end
+		local pos1, pos2, pos = param.next_chunk_1, param.next_chunk_2, param.next_pos
+		log("action", "[mcl_portals] Making additional search in chunk below, because current one doesn't contain any air space for portal, target pos "..pos_to_string(pos))
+		minetest.emerge_area(pos1, pos2, ecb_scan_area_2, {pos = pos, pos1 = pos1, pos2 = pos2, name=name, obj=obj})
+		return
 	end
 
 	log("action", "[mcl_portals] found no space, reverting to target pos "..pos_to_string(pos).." - creating a portal")
@@ -538,7 +536,7 @@ local function create_portal(pos, limit1, limit2, name, obj)
 	-- Basically the copy of code above, with minor additions to continue the search in single additional chunk below:
 	local next_chunk_1 = {x = pos1.x, y = pos1.y - mcl_vars.chunk_size_in_nodes, z = pos1.z}
 	local next_chunk_2 = add(next_chunk_1, mcl_vars.chunk_size_in_nodes - 1)
-	local next_pos = {x = pos.x, y=max(next_chunk_2.y, limit1.y), z = pos.z}
+	local next_pos = {x = pos.x, y=next_chunk_2.y, z = pos.z}
 	if limit1 and limit1.x and limit1.y and limit1.z then
 		pos1 = {x = max(min(limit1.x, pos.x), pos1.x), y = max(min(limit1.y, pos.y), pos1.y), z = max(min(limit1.z, pos.z), pos1.z)}
 		next_chunk_1 = {x = max(min(limit1.x, next_pos.x), next_chunk_1.x), y = max(min(limit1.y, next_pos.y), next_chunk_1.y), z = max(min(limit1.z, next_pos.z), next_chunk_1.z)}

mods/ITEMS/mcl_potions/functions.lua

@@ -701,10 +701,6 @@ function mcl_potions.healing_func(player, hp)
 
 	local obj = player:get_luaentity()
 
-	if player:get_hp() == 0 then
-		return
-	end
-
 	if obj and obj.harmed_by_heal then hp = -hp end
 
 	if hp > 0 then

mods/ITEMS/mcl_tools/init.lua

@@ -352,56 +352,6 @@ minetest.register_tool("mcl_tools:shovel_diamond", {
 })
 
 -- Axes
-
-local make_stripped_trunk = function(itemstack, placer, pointed_thing)
-	if pointed_thing.type == "node" then
-		local pos = minetest.get_pointed_thing_position(pointed_thing)
-		local node = minetest.get_node(pos)
-		local node_name = node.name
-		if placer and not placer:get_player_control().sneak then
-			if minetest.registered_nodes[node_name] and minetest.registered_nodes[node_name].on_rightclick then
-				return minetest.registered_nodes[node_name].on_rightclick(pointed_thing.under, node, placer, itemstack) or itemstack
-			end
-		end
-		if minetest.is_protected(pointed_thing.under, placer:get_player_name()) then
-			minetest.record_protection_violation(pointed_thing.under, placer:get_player_name())
-			return itemstack
-		end
-		if not minetest.is_creative_enabled(placer:get_player_name()) then
-			-- Add wear (as if digging a axey node)
-			local toolname = itemstack:get_name()
-			local wear = mcl_autogroup.get_wear(toolname, "axey")
-			itemstack:add_wear(wear)
-		end
-		if node_name == "mcl_core:tree" then
-			minetest.swap_node(pointed_thing.under, {name="mcl_core:stripped_oak"})
-		elseif node_name == "mcl_core:darktree" then
-			minetest.swap_node(pointed_thing.under, {name="mcl_core:stripped_dark_oak"})
-		elseif node_name == "mcl_core:acaciatree" then
-			minetest.swap_node(pointed_thing.under, {name="mcl_core:stripped_acacia"})
-		elseif node_name == "mcl_core:birchtree" then
-			minetest.swap_node(pointed_thing.under, {name="mcl_core:stripped_birch"})
-		elseif node_name == "mcl_core:sprucetree" then
-			minetest.swap_node(pointed_thing.under, {name="mcl_core:stripped_spruce"})
-		elseif node_name == "mcl_core:jungletree" then
-			minetest.swap_node(pointed_thing.under, {name="mcl_core:stripped_jungle"})
-		elseif node_name == "mcl_core:tree_bark" then
-			minetest.swap_node(pointed_thing.under, {name="mcl_core:stripped_oak_bark"})
-		elseif node_name == "mcl_core:darktree_bark" then
-			minetest.swap_node(pointed_thing.under, {name="mcl_core:stripped_dark_oak_bark"})
-		elseif node_name == "mcl_core:acaciatree_bark" then
-			minetest.swap_node(pointed_thing.under, {name="mcl_core:stripped_acacia_bark"})
-		elseif node_name == "mcl_core:birchtree_bark" then
-			minetest.swap_node(pointed_thing.under, {name="mcl_core:stripped_birch_bark"})
-		elseif node_name == "mcl_core:sprucetree_bark" then
-			minetest.swap_node(pointed_thing.under, {name="mcl_core:stripped_spruce_bark"})
-		elseif node_name == "mcl_core:jungletree_bark" then
-			minetest.swap_node(pointed_thing.under, {name="mcl_core:stripped_jungle_bark"})
-		end
-	end
-	return itemstack
-end
-
 minetest.register_tool("mcl_tools:axe_wood", {
 	description = S("Wooden Axe"),
 	_doc_items_longdesc = axe_longdesc,
@@ -415,7 +365,6 @@ minetest.register_tool("mcl_tools:axe_wood", {
 		damage_groups = {fleshy=7},
 		punch_attack_uses = 30,
 	},
-	on_place = make_stripped_trunk,
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "group:wood",
 	_mcl_toollike_wield = true,
@@ -435,7 +384,6 @@ minetest.register_tool("mcl_tools:axe_stone", {
 		damage_groups = {fleshy=9},
 		punch_attack_uses = 66,
 	},
-	on_place = make_stripped_trunk,
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:cobble",
 	_mcl_toollike_wield = true,
@@ -456,7 +404,6 @@ minetest.register_tool("mcl_tools:axe_iron", {
 		damage_groups = {fleshy=9},
 		punch_attack_uses = 126,
 	},
-	on_place = make_stripped_trunk,
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:iron_ingot",
 	_mcl_toollike_wield = true,
@@ -476,7 +423,6 @@ minetest.register_tool("mcl_tools:axe_gold", {
 		damage_groups = {fleshy=7},
 		punch_attack_uses = 17,
 	},
-	on_place = make_stripped_trunk,
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:gold_ingot",
 	_mcl_toollike_wield = true,
@@ -496,7 +442,6 @@ minetest.register_tool("mcl_tools:axe_diamond", {
 		damage_groups = {fleshy=9},
 		punch_attack_uses = 781,
 	},
-	on_place = make_stripped_trunk,
 	sound = { breaks = "default_tool_breaks" },
 	_repair_material = "mcl_core:diamond",
 	_mcl_toollike_wield = true,

mods/ITEMS/mcl_torches/api.lua

@@ -1,267 +0,0 @@
-local smoke_pdef = {
-	amount = 0.5,
-	maxexptime = 2.0,
-	minvel = { x = 0.0, y = 0.5, z = 0.0 },
-	maxvel = { x = 0.0, y = 0.6, z = 0.0 },
-	minsize = 1.5,
-	maxsize = 1.5,
-	minrelpos = { x = -1/16, y = 0.04, z = -1/16 },
-	maxrelpos = { x =  1/16, y = 0.06, z =  1/16 },
-}
-
-local spawn_flames_floor = function(pos)
-	-- Flames
-	mcl_particles.add_node_particlespawner(pos, {
-		amount = 8,
-		time = 0,
-		minpos = vector.add(pos, { x = -0.1, y = 0.05, z = -0.1 }),
-		maxpos = vector.add(pos, { x = 0.1, y = 0.15, z = 0.1 }),
-		minvel = { x = -0.01, y = 0, z = -0.01 },
-		maxvel = { x = 0.01, y = 0.1, z = 0.01 },
-		minexptime = 0.3,
-		maxexptime = 0.6,
-		minsize = 0.7,
-		maxsize = 2,
-		texture = "mcl_particles_flame.png",
-		glow = minetest.registered_nodes[minetest.get_node(pos).name].light_source,
-	}, "low")
-	-- Smoke
-	mcl_particles.spawn_smoke(pos, "torch", smoke_pdef)
-end
-
-local spawn_flames_wall = function(pos)
-	local minrelpos, maxrelpos
-	local node = minetest.get_node(pos)
-	local dir = minetest.wallmounted_to_dir(node.param2)
-
-	local smoke_pdef = table.copy(smoke_pdef)
-
-	if dir.x < 0 then
-		smoke_pdef.minrelpos = { x = -0.38, y = 0.04, z = -0.1 }
-		smoke_pdef.maxrelpos = { x = -0.2, y = 0.14, z = 0.1 }
-	elseif dir.x > 0 then
-		smoke_pdef.minrelpos = { x = 0.2, y = 0.04, z = -0.1 }
-		smoke_pdef.maxrelpos = { x = 0.38, y = 0.14, z = 0.1 }
-	elseif dir.z < 0 then
-		smoke_pdef.minrelpos = { x = -0.1, y = 0.04, z = -0.38 }
-		smoke_pdef.maxrelpos = { x = 0.1, y = 0.14, z = -0.2 }
-	elseif dir.z > 0 then
-		smoke_pdef.minrelpos = { x = -0.1, y = 0.04, z = 0.2 }
-		smoke_pdef.maxrelpos = { x = 0.1, y = 0.14, z = 0.38 }
-	else
-		return
-	end
-
-
-	-- Flames
-	mcl_particles.add_node_particlespawner(pos, {
-		amount = 8,
-		time = 0,
-		minpos = vector.add(pos, smoke_pdef.minrelpos),
-		maxpos = vector.add(pos, smoke_pdef.maxrelpos),
-		minvel = { x = -0.01, y = 0, z = -0.01 },
-		maxvel = { x = 0.01, y = 0.1, z = 0.01 },
-		minexptime = 0.3,
-		maxexptime = 0.6,
-		minsize = 0.7,
-		maxsize = 2,
-		texture = "mcl_particles_flame.png",
-		glow = minetest.registered_nodes[node.name].light_source,
-	}, "low")
-	-- Smoke
-	mcl_particles.spawn_smoke(pos, "torch", smoke_pdef)
-end
-
-local remove_flames = function(pos)
-	mcl_particles.delete_node_particlespawners(pos)
-end
-
---
--- 3d torch part
---
-
--- Check if placement at given node is allowed
-local function check_placement_allowed(node, wdir)
-	-- Torch placement rules: Disallow placement on some nodes. General rule: Solid, opaque, full cube collision box nodes are allowed.
-	-- Special allowed nodes:
-	-- * soul sand
-	-- * mob spawner
-	-- * chorus flower
-	-- * glass, barrier, ice
-	-- * Fence, wall, end portal frame with ender eye: Only on top
-	-- * Slab, stairs: Only on top if upside down
-
-	-- Special forbidden nodes:
-	-- * Piston, sticky piston
-	local def = minetest.registered_nodes[node.name]
-	if not def then
-		return false
-	-- No ceiling torches
-	elseif wdir == 0 then
-		return false
-	elseif not def.buildable_to then
-		if node.name ~= "mcl_core:ice" and node.name ~= "mcl_nether:soul_sand" and node.name ~= "mcl_mobspawners:spawner" and node.name ~= "mcl_core:barrier" and node.name ~= "mcl_end:chorus_flower" and node.name ~= "mcl_end:chorus_flower_dead" and (not def.groups.glass) and
-				((not def.groups.solid) or (not def.groups.opaque)) then
-			-- Only allow top placement on these nodes
-			if node.name == "mcl_end:dragon_egg" or node.name == "mcl_portals:end_portal_frame_eye" or def.groups.fence == 1 or def.groups.wall or def.groups.slab_top == 1 or def.groups.anvil or def.groups.pane or (def.groups.stair == 1 and minetest.facedir_to_dir(node.param2).y ~= 0) then
-				if wdir ~= 1 then
-					return false
-				end
-			else
-				return false
-			end
-		elseif minetest.get_item_group(node.name, "piston") >= 1 then
-			return false
-		end
-	end
-	return true
-end
-
-function mcl_torches.register_torch(def)
-	local itemstring = minetest.get_current_modname() .. ":" .. def.name
-	local itemstring_wall = itemstring .. "_wall"
-
-	def.light = def.light or minetest.LIGHT_MAX
-	def.mesh_floor = def.mesh_floor or "mcl_torches_torch_floor.obj"
-	def.mesh_wall = def.mesh_wall or "mcl_torches_torch_wall.obj"
-
-	local groups = def.groups or {}
-
-	groups.attached_node = 1
-	groups.torch = 1
-	groups.torch_particles = def.particles and 1
-	groups.dig_by_water = 1
-	groups.destroy_by_lava_flow = 1
-	groups.dig_by_piston = 1
-
-	local floordef = {
-		description = def.description,
-		_doc_items_longdesc = def.doc_items_longdesc,
-		_doc_items_usagehelp = def.doc_items_usagehelp,
-		_doc_items_hidden = def.doc_items_hidden,
-		_doc_items_create_entry = def._doc_items_create_entry,
-		drawtype = "mesh",
-		mesh = def.mesh_floor,
-		inventory_image = def.icon,
-		wield_image = def.icon,
-		tiles = def.tiles,
-		use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or false,
-		paramtype = "light",
-		paramtype2 = "wallmounted",
-		sunlight_propagates = true,
-		is_ground_content = false,
-		walkable = false,
-		liquids_pointable = false,
-		light_source = def.light,
-		groups = groups,
-		drop = def.drop or itemstring,
-		selection_box = {
-			type = "wallmounted",
-			wall_top = {-1/16, -1/16, -1/16, 1/16, 0.5, 1/16},
-			wall_bottom = {-1/16, -0.5, -1/16, 1/16, 1/16, 1/16},
-		},
-		sounds = def.sounds,
-		node_placement_prediction = "",
-		on_place = function(itemstack, placer, pointed_thing)
-			if pointed_thing.type ~= "node" then
-				-- no interaction possible with entities, for now.
-				return itemstack
-			end
-
-			local under = pointed_thing.under
-			local node = minetest.get_node(under)
-			local def = minetest.registered_nodes[node.name]
-			if not def then return itemstack end
-
-			-- Call on_rightclick if the pointed node defines it
-			if placer and not placer:get_player_control().sneak then
-				if minetest.registered_nodes[node.name] and minetest.registered_nodes[node.name].on_rightclick then
-					return minetest.registered_nodes[node.name].on_rightclick(under, node, placer, itemstack) or itemstack
-				end
-			end
-
-			local above = pointed_thing.above
-			local wdir = minetest.dir_to_wallmounted({x = under.x - above.x, y = under.y - above.y, z = under.z - above.z})
-
-			if check_placement_allowed(node, wdir) == false then
-				return itemstack
-			end
-
-			local itemstring = itemstack:get_name()
-			local fakestack = ItemStack(itemstack)
-			local idef = fakestack:get_definition()
-			local retval
-
-			if wdir == 1 then
-				retval = fakestack:set_name(itemstring)
-			else
-				retval = fakestack:set_name(itemstring_wall)
-			end
-			if not retval then
-				return itemstack
-			end
-
-			local success
-			itemstack, success = minetest.item_place(fakestack, placer, pointed_thing, wdir)
-			itemstack:set_name(itemstring)
-
-			if success and idef.sounds and idef.sounds.place then
-				minetest.sound_play(idef.sounds.place, {pos=under, gain=1}, true)
-			end
-			return itemstack
-		end,
-		on_rotate = false,
-		on_construct = def.particles and spawn_flames_floor,
-		on_destruct = def.particles and remove_flames,
-	}
-	minetest.register_node(itemstring, floordef)
-
-	local groups_wall = table.copy(groups)
-	groups_wall.torch = 2
-
-	local walldef = {
-		drawtype = "mesh",
-		mesh = def.mesh_wall,
-		tiles = def.tiles,
-		use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or false,
-		paramtype = "light",
-		paramtype2 = "wallmounted",
-		sunlight_propagates = true,
-		is_ground_content = false,
-		walkable = false,
-		light_source = def.light,
-		groups = groups_wall,
-		drop = def.drop or itemstring,
-		selection_box = {
-			type = "wallmounted",
-			wall_top = {-0.1, -0.1, -0.1, 0.1, 0.5, 0.1},
-			wall_bottom = {-0.1, -0.5, -0.1, 0.1, 0.1, 0.1},
-			wall_side = {-0.5, -0.5, -0.1, -0.2, 0.1, 0.1},
-		},
-		sounds = def.sounds,
-		on_rotate = false,
-		on_construct = def.particles and spawn_flames_wall,
-		on_destruct = def.particles and remove_flames,
-	}
-	minetest.register_node(itemstring_wall, walldef)
-
-	-- Add entry alias for the Help
-	if minetest.get_modpath("doc") then
-		doc.add_entry_alias("nodes", itemstring, "nodes", itemstring_wall)
-	end
-end
-
-minetest.register_lbm({
-	label = "Torch flame particles",
-	name = "mcl_torches:flames",
-	nodenames = {"group:torch_particles"},
-	run_at_every_load = true,
-	action = function(pos, node)
-		local torch_group = minetest.get_node_group(node.name, "torch")
-		if torch_group == 1 then
-			spawn_flames_floor(pos)
-		elseif torch_group == 2 then
-			spawn_flames_wall(pos)
-		end
-	end,
-})

mods/ITEMS/mcl_torches/init.lua

@@ -1,6 +1,338 @@
+local S = minetest.get_translator("mcl_torches")
+local LIGHT_TORCH = minetest.LIGHT_MAX
+
+local spawn_flames_floor = function(pos)
+	-- Flames
+	mcl_particles.add_node_particlespawner(pos, {
+		amount = 8,
+		time = 0,
+		minpos = vector.add(pos, { x = -0.1, y = 0.05, z = -0.1 }),
+		maxpos = vector.add(pos, { x = 0.1, y = 0.15, z = 0.1 }),
+		minvel = { x = -0.01, y = 0, z = -0.01 },
+		maxvel = { x = 0.01, y = 0.1, z = 0.01 },
+		minexptime = 0.3,
+		maxexptime = 0.6,
+		minsize = 0.7,
+		maxsize = 2,
+		texture = "mcl_particles_flame.png",
+		glow = LIGHT_TORCH,
+	}, "low")
+	-- Smoke
+	mcl_particles.add_node_particlespawner(pos, {
+		amount = 0.5,
+		time = 0,
+		minpos = vector.add(pos, { x = -1/16, y = 0.04, z = -1/16 }),
+		maxpos = vector.add(pos, { x = -1/16, y = 0.06, z = -1/16 }),
+		minvel = { x = 0, y = 0.5, z = 0 },
+		maxvel = { x = 0, y = 0.6, z = 0 },
+		minexptime = 2.0,
+		maxexptime = 2.0,
+		minsize = 1.5,
+		maxsize = 1.5,
+		texture = "mcl_particles_smoke_anim.png",
+		animation = {
+			type = "vertical_frames",
+			aspect_w = 8,
+			aspect_h = 8,
+			length = 2.05,
+		},
+	}, "medium")
+end
+
+local spawn_flames_wall = function(pos, param2)
+	local minrelpos, maxrelpos
+	local dir = minetest.wallmounted_to_dir(param2)
+	if dir.x < 0 then
+		minrelpos = { x = -0.38, y = 0.04, z = -0.1 }
+		maxrelpos = { x = -0.2, y = 0.14, z = 0.1 }
+	elseif dir.x > 0 then
+		minrelpos = { x = 0.2, y = 0.04, z = -0.1 }
+		maxrelpos = { x = 0.38, y = 0.14, z = 0.1 }
+	elseif dir.z < 0 then
+		minrelpos = { x = -0.1, y = 0.04, z = -0.38 }
+		maxrelpos = { x = 0.1, y = 0.14, z = -0.2 }
+	elseif dir.z > 0 then
+		minrelpos = { x = -0.1, y = 0.04, z = 0.2 }
+		maxrelpos = { x = 0.1, y = 0.14, z = 0.38 }
+	else
+		return
+	end
+	-- Flames
+	mcl_particles.add_node_particlespawner(pos, {
+		amount = 8,
+		time = 0,
+		minpos = vector.add(pos, minrelpos),
+		maxpos = vector.add(pos, maxrelpos),
+		minvel = { x = -0.01, y = 0, z = -0.01 },
+		maxvel = { x = 0.01, y = 0.1, z = 0.01 },
+		minexptime = 0.3,
+		maxexptime = 0.6,
+		minsize = 0.7,
+		maxsize = 2,
+		texture = "mcl_particles_flame.png",
+		glow = LIGHT_TORCH,
+	}, "low")
+	-- Smoke
+	mcl_particles.add_node_particlespawner(pos, {
+		amount = 0.5,
+		time = 0,
+		minpos = vector.add(pos, minrelpos),
+		maxpos = vector.add(pos, maxrelpos),
+		minvel = { x = 0, y = 0.5, z = 0 },
+		maxvel = { x = 0, y = 0.6, z = 0 },
+		minexptime = 2.0,
+		maxexptime = 2.0,
+		minsize = 1.5,
+		maxsize = 1.5,
+		texture = "mcl_particles_smoke_anim.png",
+		animation = {
+			type = "vertical_frames",
+			aspect_w = 8,
+			aspect_h = 8,
+			length = 2.05,
+		},
+	}, "medium")
+end
+
+local remove_flames = function(pos)
+	mcl_particles.delete_node_particlespawners(pos)
+end
+
+--
+-- 3d torch part
+--
+
+-- Check if placement at given node is allowed
+local function check_placement_allowed(node, wdir)
+	-- Torch placement rules: Disallow placement on some nodes. General rule: Solid, opaque, full cube collision box nodes are allowed.
+	-- Special allowed nodes:
+	-- * soul sand
+	-- * mob spawner
+	-- * chorus flower
+	-- * glass, barrier, ice
+	-- * Fence, wall, end portal frame with ender eye: Only on top
+	-- * Slab, stairs: Only on top if upside down
+
+	-- Special forbidden nodes:
+	-- * Piston, sticky piston
+	local def = minetest.registered_nodes[node.name]
+	if not def then
+		return false
+	-- No ceiling torches
+	elseif wdir == 0 then
+		return false
+	elseif not def.buildable_to then
+		if node.name ~= "mcl_core:ice" and node.name ~= "mcl_nether:soul_sand" and node.name ~= "mcl_mobspawners:spawner" and node.name ~= "mcl_core:barrier" and node.name ~= "mcl_end:chorus_flower" and node.name ~= "mcl_end:chorus_flower_dead" and (not def.groups.glass) and
+				((not def.groups.solid) or (not def.groups.opaque)) then
+			-- Only allow top placement on these nodes
+			if node.name == "mcl_end:dragon_egg" or node.name == "mcl_portals:end_portal_frame_eye" or def.groups.fence == 1 or def.groups.wall or def.groups.slab_top == 1 or def.groups.anvil or def.groups.pane or (def.groups.stair == 1 and minetest.facedir_to_dir(node.param2).y ~= 0) then
+				if wdir ~= 1 then
+					return false
+				end
+			else
+				return false
+			end
+		elseif minetest.get_item_group(node.name, "piston") >= 1 then
+			return false
+		end
+	end
+	return true
+end
+
 mcl_torches = {}
 
-local modpath = minetest.get_modpath("mcl_torches")
+mcl_torches.register_torch = function(substring, description, doc_items_longdesc, doc_items_usagehelp, icon, mesh_floor, mesh_wall, tiles, light, groups, sounds, moredef, moredef_floor, moredef_wall)
+	local itemstring = minetest.get_current_modname()..":"..substring
+	local itemstring_wall = minetest.get_current_modname()..":"..substring.."_wall"
+
+	if light == nil then light = minetest.LIGHT_MAX end
+	if mesh_floor == nil then mesh_floor = "mcl_torches_torch_floor.obj" end
+	if mesh_wall == nil then mesh_wall = "mcl_torches_torch_wall.obj" end
+	if groups == nil then groups = {} end
+
+	groups.attached_node = 1
+	groups.torch = 1
+	groups.dig_by_water = 1
+	groups.destroy_by_lava_flow = 1
+	groups.dig_by_piston = 1
+
+	local floordef = {
+		description = description,
+		_doc_items_longdesc = doc_items_longdesc,
+		_doc_items_usagehelp = doc_items_usagehelp,
+		drawtype = "mesh",
+		mesh = mesh_floor,
+		inventory_image = icon,
+		wield_image = icon,
+		tiles = tiles,
+		use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or false,
+		paramtype = "light",
+		paramtype2 = "wallmounted",
+		sunlight_propagates = true,
+		is_ground_content = false,
+		walkable = false,
+		liquids_pointable = false,
+		light_source = light,
+		groups = groups,
+		drop = itemstring,
+		selection_box = {
+			type = "wallmounted",
+			wall_top = {-1/16, -1/16, -1/16, 1/16, 0.5, 1/16},
+			wall_bottom = {-1/16, -0.5, -1/16, 1/16, 1/16, 1/16},
+		},
+		sounds = sounds,
+		node_placement_prediction = "",
+		on_place = function(itemstack, placer, pointed_thing)
+			if pointed_thing.type ~= "node" then
+				-- no interaction possible with entities, for now.
+				return itemstack
+			end
+
+			local under = pointed_thing.under
+			local node = minetest.get_node(under)
+			local def = minetest.registered_nodes[node.name]
+			if not def then return itemstack end
+
+			-- Call on_rightclick if the pointed node defines it
+			if placer and not placer:get_player_control().sneak then
+				if minetest.registered_nodes[node.name] and minetest.registered_nodes[node.name].on_rightclick then
+					return minetest.registered_nodes[node.name].on_rightclick(under, node, placer, itemstack) or itemstack
+				end
+			end
+
+			local above = pointed_thing.above
+			local wdir = minetest.dir_to_wallmounted({x = under.x - above.x, y = under.y - above.y, z = under.z - above.z})
+
+			if check_placement_allowed(node, wdir) == false then
+				return itemstack
+			end
+
+			local itemstring = itemstack:get_name()
+			local fakestack = ItemStack(itemstack)
+			local idef = fakestack:get_definition()
+			local retval
+
+			if wdir == 1 then
+				retval = fakestack:set_name(itemstring)
+			else
+				retval = fakestack:set_name(itemstring_wall)
+			end
+			if not retval then
+				return itemstack
+			end
+
+			local success
+			itemstack, success = minetest.item_place(fakestack, placer, pointed_thing, wdir)
+			itemstack:set_name(itemstring)
+
+			if success and idef.sounds and idef.sounds.place then
+				minetest.sound_play(idef.sounds.place, {pos=under, gain=1}, true)
+			end
+			return itemstack
+		end,
+		on_rotate = false,
+	}
+	if moredef ~= nil then
+		for k,v in pairs(moredef) do
+			floordef[k] = v
+		end
+	end
+	if moredef_floor ~= nil then
+		for k,v in pairs(moredef_floor) do
+			floordef[k] = v
+		end
+	end
+	minetest.register_node(itemstring, floordef)
+
+	local groups_wall = table.copy(groups)
+	groups_wall.torch = 2
+
+	local walldef = {
+		drawtype = "mesh",
+		mesh = mesh_wall,
+		tiles = tiles,
+		use_texture_alpha = minetest.features.use_texture_alpha_string_modes and "opaque" or false,
+		paramtype = "light",
+		paramtype2 = "wallmounted",
+		sunlight_propagates = true,
+		is_ground_content = false,
+		walkable = false,
+		light_source = light,
+		groups = groups_wall,
+		drop = itemstring,
+		selection_box = {
+			type = "wallmounted",
+			wall_top = {-0.1, -0.1, -0.1, 0.1, 0.5, 0.1},
+			wall_bottom = {-0.1, -0.5, -0.1, 0.1, 0.1, 0.1},
+			wall_side = {-0.5, -0.5, -0.1, -0.2, 0.1, 0.1},
+		},
+		sounds = sounds,
+		on_rotate = false,
+	}
+	if moredef ~= nil then
+		for k,v in pairs(moredef) do
+			walldef[k] = v
+		end
+	end
+	if moredef_wall ~= nil then
+		for k,v in pairs(moredef_wall) do
+			walldef[k] = v
+		end
+	end
+	minetest.register_node(itemstring_wall, walldef)
+
+
+	-- Add entry alias for the Help
+	if minetest.get_modpath("doc") then
+		doc.add_entry_alias("nodes", itemstring, "nodes", itemstring_wall)
+	end
+
+end
+
+mcl_torches.register_torch("torch",
+	S("Torch"),
+	S("Torches are light sources which can be placed at the side or on the top of most blocks."),
+	nil,
+	"default_torch_on_floor.png",
+	"mcl_torches_torch_floor.obj", "mcl_torches_torch_wall.obj",
+	{{
+		name = "default_torch_on_floor_animated.png",
+		animation = {type = "vertical_frames", aspect_w = 16, aspect_h = 16, length = 3.3}
+	}},
+	LIGHT_TORCH,
+	{dig_immediate=3, torch=1, deco_block=1},
+	mcl_sounds.node_sound_wood_defaults(),
+	{_doc_items_hidden = false,
+	on_destruct = function(pos)
+		remove_flames(pos)
+	end},
+	{on_construct = function(pos)
+		spawn_flames_floor(pos)
+	end},
+	{on_construct = function(pos)
+		local node = minetest.get_node(pos)
+		spawn_flames_wall(pos, node.param2)
+	end})
+
+minetest.register_craft({
+	output = "mcl_torches:torch 4",
+	recipe = {
+		{ "group:coal" },
+		{ "mcl_core:stick" },
+	}
+})
+
+minetest.register_lbm({
+	label = "Torch flame particles",
+	name = "mcl_torches:flames",
+	nodenames = {"mcl_torches:torch", "mcl_torches:torch_wall"},
+	run_at_every_load = true,
+	action = function(pos, node)
+		if node.name == "mcl_torches:torch" then
+			spawn_flames_floor(pos)
+		elseif node.name == "mcl_torches:torch_wall" then
+			spawn_flames_wall(pos, node.param2)
+		end
+	end,
+})
 
-dofile(modpath .. "/api.lua")
-dofile(modpath .. "/register.lua")

mods/ITEMS/mcl_torches/register.lua

@@ -1,27 +0,0 @@
-local S = minetest.get_translator("mcl_torches")
-
-mcl_torches.register_torch({
-	name = "torch",
-	description = S("Torch"),
-	doc_items_longdesc = S("Torches are light sources which can be placed at the side or on the top of most blocks."),
-	doc_items_hidden = false,
-	icon = "default_torch_on_floor.png",
-	tiles = {{
-		name = "default_torch_on_floor_animated.png",
-		animation = {type = "vertical_frames", aspect_w = 16, aspect_h = 16, length = 3.3}
-	}},
-	-- this is 15 in minecraft
-	light = 14,
-	groups = {dig_immediate = 3, deco_block = 1},
-	sounds = mcl_sounds.node_sound_wood_defaults(),
-	particles = true,
-})
-
-minetest.register_craft({
-	output = "mcl_torches:torch 4",
-	recipe = {
-		{"group:coal"},
-		{"mcl_core:stick"},
-	}
-})
-

mods/ITEMS/mcl_wool/locale/mcl_wool.de.tr

@@ -22,7 +22,7 @@ Blue Carpet=Blauer Teppich
 Magenta Wool=Magenta Wolle
 Magenta Carpet=Magenta Teppich
 Orange Wool=Orange Wolle
-Orange Carpet=Oranger Teppich
+Orange Carpet=Orange Teppich
 Purple Wool=Violette Wolle
 Purple Carpet=Violetter Teppich
 Brown Wool=Braune Wolle

mods/ITEMS/screwdriver/locale/screwdriver.de.tr

@@ -1,2 +1,2 @@
 # textdomain: screwdriver
-Screwdriver=Schraubenzieher
+Screwdriver=Schraubendreher

mods/MAPGEN/mcl_dungeons/init.lua

@@ -9,38 +9,15 @@ if mcl_vars.mg_dungeons == false or mg_name == "singlenode" then
 	return
 end
 
---lua locals
---minetest
-local registered_nodes = minetest.registered_nodes
-local swap_node        = minetest.swap_node
-local set_node         = minetest.set_node
-local dir_to_facedir   = minetest.dir_to_facedir
-local get_meta         = minetest.get_meta
-local emerge_area      = minetest.emerge_area
+local min_y = math.max(mcl_vars.mg_overworld_min, mcl_vars.mg_bedrock_overworld_max) + 1
+local max_y = mcl_vars.mg_overworld_max - 1
 
---vector
-local vector_add       = vector.add
-local vector_subtract  = vector.subtract
-
---table
-local table_insert     = table.insert
-local table_sort       = table.sort
-
---math
-local math_min         = math.min
-local math_max         = math.max
-local math_ceil        = math.ceil
-
---custom mcl_vars
 local get_node = mcl_vars.get_node
 
-
-local min_y = math_max(mcl_vars.mg_overworld_min, mcl_vars.mg_bedrock_overworld_max) + 1
-local max_y = mcl_vars.mg_overworld_max - 1
 -- Calculate the number of dungeon spawn attempts
 -- In Minecraft, there 8 dungeon spawn attempts Minecraft chunk (16*256*16 = 65536 blocks).
 -- Minetest chunks don't have this size, so scale the number accordingly.
-local attempts = math_ceil(((mcl_vars.chunksize * mcl_vars.MAP_BLOCKSIZE) ^ 3) / 8192) -- 63 = 80*80*80/8192
+local attempts = math.ceil(((mcl_vars.chunksize * mcl_vars.MAP_BLOCKSIZE) ^ 3) / 8192) -- 63 = 80*80*80/8192
 
 local dungeonsizes = {
 	{ x=5, y=4, z=5},
@@ -74,8 +51,8 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
 	local y_floor = y
 	local y_ceiling = y + dim.y + 1
 	if check then for tx = x+1, x+dim.x do for tz = z+1, z+dim.z do
-		if not registered_nodes[get_node({x = tx, y = y_floor  , z = tz}).name].walkable
-		or not registered_nodes[get_node({x = tx, y = y_ceiling, z = tz}).name].walkable then return false end
+		if not minetest.registered_nodes[get_node({x = tx, y = y_floor  , z = tz}).name].walkable
+		or not minetest.registered_nodes[get_node({x = tx, y = y_ceiling, z = tz}).name].walkable then return false end
 	end end end
 
 	-- Check for air openings (2 stacked air at ground level) in wall positions
@@ -92,25 +69,25 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
 		openings_counter = openings_counter + 1
 		if not openings[x] then openings[x]={} end
 		openings[x][z] = true
-		table_insert(corners, {x=x, z=z})
+		table.insert(corners, {x=x, z=z})
 	end
 	if get_node({x=x2, y=y+1, z=z}).name == "air" and get_node({x=x2, y=y+2, z=z}).name == "air" then
 		openings_counter = openings_counter + 1
 		if not openings[x2] then openings[x2]={} end
 		openings[x2][z] = true
-		table_insert(corners, {x=x2, z=z})
+		table.insert(corners, {x=x2, z=z})
 	end
 	if get_node({x=x, y=y+1, z=z2}).name == "air" and get_node({x=x, y=y+2, z=z2}).name == "air" then
 		openings_counter = openings_counter + 1
 		if not openings[x] then openings[x]={} end
 		openings[x][z2] = true
-		table_insert(corners, {x=x, z=z2})
+		table.insert(corners, {x=x, z=z2})
 	end
 	if get_node({x=x2, y=y+1, z=z2}).name == "air" and get_node({x=x2, y=y+2, z=z2}).name == "air" then
 		openings_counter = openings_counter + 1
 		if not openings[x2] then openings[x2]={} end
 		openings[x2][z2] = true
-		table_insert(corners, {x=x2, z=z2})
+		table.insert(corners, {x=x2, z=z2})
 	end
 
 	for wx = x+1, x+dim.x do
@@ -203,16 +180,16 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
 			secondChance = false
 		end
 		lastRandom = r
-		table_insert(chestSlots, r)
+		table.insert(chestSlots, r)
 	end
-	table_sort(chestSlots)
+	table.sort(chestSlots)
 	local currentChest = 1
 
 	-- Calculate the mob spawner position, to be re-used for later
-	local sp = {x = x + math_ceil(dim.x/2), y = y+1, z = z + math_ceil(dim.z/2)}
-	local rn = registered_nodes[get_node(sp).name]
+	local sp = {x = x + math.ceil(dim.x/2), y = y+1, z = z + math.ceil(dim.z/2)}
+	local rn = minetest.registered_nodes[get_node(sp).name]
 	if rn and rn.is_ground_content then
-		table_insert(spawner_posses, sp)
+		table.insert(spawner_posses, sp)
 	end
 
 	-- Generate walls and floor
@@ -226,13 +203,13 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
 		-- Do not overwrite nodes with is_ground_content == false (e.g. bedrock)
 		-- Exceptions: cobblestone and mossy cobblestone so neighborings dungeons nicely connect to each other
 		local name = get_node(p).name
-		if registered_nodes[name].is_ground_content or name == "mcl_core:cobble" or name == "mcl_core:mossycobble" then
+		if minetest.registered_nodes[name].is_ground_content or name == "mcl_core:cobble" or name == "mcl_core:mossycobble" then
 			-- Floor
 			if ty == y then
 				if pr:next(1,4) == 1 then
-					swap_node(p, {name = "mcl_core:cobble"})
+					minetest.swap_node(p, {name = "mcl_core:cobble"})
 				else
-					swap_node(p, {name = "mcl_core:mossycobble"})
+					minetest.swap_node(p, {name = "mcl_core:mossycobble"})
 				end
 
 				-- Generate walls
@@ -244,14 +221,14 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
 				-- Check if it's an opening first
 				if (ty == maxy) or (not (openings[tx] and openings[tx][tz]))  then
 					-- Place wall or ceiling
-					swap_node(p, {name = "mcl_core:cobble"})
+					minetest.swap_node(p, {name = "mcl_core:cobble"})
 				elseif ty < maxy - 1 then
 					-- Normally the openings are already clear, but not if it is a corner
 					-- widening. Make sure to clear at least the bottom 2 nodes of an opening.
-					if name ~= "air" then swap_node(p, {name = "air"}) end
+					if name ~= "air" then minetest.swap_node(p, {name = "air"}) end
 				elseif name ~= "air" then
 					-- This allows for variation between 2-node and 3-node high openings.
-					swap_node(p, {name = "mcl_core:cobble"})
+					minetest.swap_node(p, {name = "mcl_core:cobble"})
 				end
 				-- If it was an opening, the lower 3 blocks are not touched at all
 
@@ -259,9 +236,9 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
 			else
 				if (ty==y+1) and (tx==x+1 or tx==maxx-1 or tz==z+1 or tz==maxz-1) and (currentChest < totalChests + 1) and (chestSlots[currentChest] == chestSlotCounter) then
 					currentChest = currentChest + 1
-					table_insert(chests, {x=tx, y=ty, z=tz})
+					table.insert(chests, {x=tx, y=ty, z=tz})
 				else
-					swap_node(p, {name = "air"})
+					minetest.swap_node(p, {name = "air"})
 				end
 
 				local forChest = ty==y+1 and (tx==x+1 or tx==maxx-1 or tz==z+1 or tz==maxz-1)
@@ -269,9 +246,9 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
 				-- Place next chest at the wall (if it was its chosen wall slot)
 				if forChest and (currentChest < totalChests + 1) and (chestSlots[currentChest] == chestSlotCounter) then
 					currentChest = currentChest + 1
-					table_insert(chests, {x=tx, y=ty, z=tz})
+					table.insert(chests, {x=tx, y=ty, z=tz})
 				-- else
-					--swap_node(p, {name = "air"})
+					--minetest.swap_node(p, {name = "air"})
 				end
 				if forChest then
 					chestSlotCounter = chestSlotCounter + 1
@@ -286,15 +263,15 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
 		local surroundings = {}
 		for s=1, #surround_vectors do
 			-- Detect the 4 horizontal neighbors
-			local spos = vector_add(pos, surround_vectors[s])
-			local wpos = vector_subtract(pos, surround_vectors[s])
+			local spos = vector.add(pos, surround_vectors[s])
+			local wpos = vector.subtract(pos, surround_vectors[s])
 			local nodename = get_node(spos).name
 			local nodename2 = get_node(wpos).name
-			local nodedef = registered_nodes[nodename]
-			local nodedef2 = registered_nodes[nodename2]
+			local nodedef = minetest.registered_nodes[nodename]
+			local nodedef2 = minetest.registered_nodes[nodename2]
 			-- The chest needs an open space in front of it and a walkable node (except chest) behind it
 			if nodedef and nodedef.walkable == false and nodedef2 and nodedef2.walkable == true and nodename2 ~= "mcl_chests:chest" then
-				table_insert(surroundings, spos)
+				table.insert(surroundings, spos)
 			end
 		end
 		-- Set param2 (=facedir) of this chest
@@ -305,11 +282,11 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
 		else
 			-- 1 or multiple possible open directions: Choose random facedir
 			local face_to = surroundings[pr:next(1, #surroundings)]
-			facedir = dir_to_facedir(vector_subtract(pos, face_to))
+			facedir = minetest.dir_to_facedir(vector.subtract(pos, face_to))
 		end
 
-		set_node(pos, {name="mcl_chests:chest", param2=facedir})
-		local meta = get_meta(pos)
+		minetest.set_node(pos, {name="mcl_chests:chest", param2=facedir})
+		local meta = minetest.get_meta(pos)
 
 		local loottable =
 		{
@@ -359,7 +336,7 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
 
 		-- Bonus loot for v6 mapgen: Otherwise unobtainable saplings.
 		if mg_name == "v6" then
-			table_insert(loottable, {
+			table.insert(loottable, {
 				stacks_min = 1,
 				stacks_max = 3,
 				items = {
@@ -379,7 +356,7 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
 	for s=#spawner_posses, 1, -1 do
 		local sp = spawner_posses[s]
 		-- ... and place it and select a random mob
-		set_node(sp, {name = "mcl_mobspawners:spawner"})
+		minetest.set_node(sp, {name = "mcl_mobspawners:spawner"})
 		local mobs = {
 			"mobs_mc:zombie",
 			"mobs_mc:zombie",
@@ -393,7 +370,7 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
 end
 
 local function dungeons_nodes(minp, maxp, blockseed)
-	local ymin, ymax = math_max(min_y, minp.y),  math_min(max_y, maxp.y)
+	local ymin, ymax = math.max(min_y, minp.y),  math.min(max_y, maxp.y)
 	if ymax < ymin then return false end
 	local pr = PseudoRandom(blockseed)
 	for a=1, attempts do
@@ -405,7 +382,7 @@ local function dungeons_nodes(minp, maxp, blockseed)
 		local p2 = {x = x+dim.x+1, y = y+dim.y+1, z = z+dim.z+1}
 		minetest.log("verbose","[mcl_dungeons] size=" ..minetest.pos_to_string(dim) .. ", emerge from "..minetest.pos_to_string(p1) .. " to " .. minetest.pos_to_string(p2))
 		local param = {p1=p1, p2=p2, dim=dim, pr=pr}
-		emerge_area(p1, p2, ecb_spawn_dungeon, param)
+		minetest.emerge_area(p1, p2, ecb_spawn_dungeon, param)
 	end
 end
 
@@ -415,7 +392,7 @@ function mcl_dungeons.spawn_dungeon(p1, _, pr)
 	local p2 = {x = p1.x+dim.x+1, y = p1.y+dim.y+1, z = p1.z+dim.z+1}
 	minetest.log("verbose","[mcl_dungeons] size=" ..minetest.pos_to_string(dim) .. ", emerge from "..minetest.pos_to_string(p1) .. " to " .. minetest.pos_to_string(p2))
 	local param = {p1=p1, p2=p2, dim=dim, pr=pr, dontcheck=true}
-	emerge_area(p1, p2, ecb_spawn_dungeon, param)
+	minetest.emerge_area(p1, p2, ecb_spawn_dungeon, param)
 end
 
 mcl_mapgen_core.register_generator("dungeons", nil, dungeons_nodes, 999999)