Merge pull request 'yet another fork update' (#9) from MineClone2/MineClone2:master into master

Reviewed-on: #9

.gitignore

@@ -4,3 +4,4 @@
 *.blend2
 *.blend3
 /.idea/
+*.xcf

API.md

@@ -41,6 +41,7 @@ A lot of things are possible by using one of the APIs in the mods. Note that not
 * Beds: `ITEMS/mcl_beds`
 * Buckets: `ITEMS/mcl_buckets`
 * Dispenser support: `ITEMS/REDSTONE/mcl_dispensers`
+* Campfires: `ITEMS/mcl_campfires`
 
 ### Mobs
 * Mobs: `ENTITIES/mcl_mobs`

CONTRIBUTING.md

@@ -2,8 +2,8 @@
 So you want to contribute to MineClone2?
 Wow, thank you! :-)
 
-MineClone2 is maintained by Nicu and Cora. If you have any
+MineClone2 is maintained by AncientMariner and Nicu. If you have any 
-problems or questions, contact us (See Links section below).
+problems or questions, contact us on Discord/Matrix (See Links section below).
 
 You can help with MineClone2's development in many different ways,
 whether you're a programmer or not.
@@ -240,7 +240,7 @@ work causes problems, we ask you fix the issues as soon as possible.
 
 ### Changing Gameplay
 Pull Requests that change gameplay have to be properly researched and
-need to state their sources. These PRs also need Fleckenstein's approval
+need to state their sources. These PRs also need the maintainer's approval
 before they are merged.
 You can use these sources:
 
@@ -375,7 +375,7 @@ merged.
 - Resolving conflicts and problems within the community
 
 #### Current maintainers
-* Cora - responsible for gameplay review, publishing releases,
+* AncientMariner - responsible for gameplay review, publishing releases,
 technical guidelines
 * Nicu - responsible for community related issues
 

CREDITS.md

@@ -35,7 +35,8 @@
 * SumianVoice
 * MrRar
 * talamh
-* Faerraven
+* Faerraven / Michieal
+* FossFanatic
 
 ## Contributors
 * Laurent Rocher
@@ -96,6 +97,12 @@
 * TheOnlyJoeEnderman
 * Ranko Saotome
 * Gregor Parzefall
+* Wbjitscool
+* b3nderman
+* CyberMango
+* gldrk
+* SmokeyDope
+* atomdmac
 
 ## MineClone5
 * kay27
@@ -147,11 +154,13 @@
 * jordan4ibanez
 * paramat
 * cora
+* Faerraven / Michieal
 
 ## 3D Models
 * 22i
 * tobyplowy
 * epCode
+* Faerraven / Michieal
 
 ## Textures
 * XSSheep
@@ -166,6 +175,7 @@
 * RandomLegoBrick
 * cora
 * Faerraven / Michieal
+* Nicu
 
 ## Translations
 * Wuzzy
@@ -180,9 +190,13 @@
 * snowyu
 * 3raven
 * SakuraRiu
+* anarquimico
+* syl
 
 ## Funders
 * 40W
+* bauknecht
+* Cora
 
 ## Special thanks
 * celeron55 for creating Minetest
@@ -190,4 +204,7 @@
 * wsor for working tirelessly in the shadows for the good of all of us, particularly helping with solving contentDB and copyright issues.
 * 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
-* Dark Reaven Music (https://soundcloud.com/dark-reaven-music) for the main menu theme (Calmed Cube), which is licensed under https://creativecommons.org/licenses/by-sa/3.0/
+* Dark Reaven Music (https://soundcloud.com/dark-reaven-music) for the main menu theme (Calmed Cube) and Traitor (horizonchris96), which is licensed under https://creativecommons.org/licenses/by-sa/3.0/
+* Jester for helping to finely tune MineClone2 (https://www.youtube.com/@Jester-8-bit). Songs: Hailing Forest, Gift, 0dd BL0ck, Flock of One (License CC BY-SA 4.0)
+* Exhale & Tim Unwin for some wonderful MineClone2 tracks (https://www.youtube.com/channel/UClFo_JDWoG4NGrPQY0JPD_g). Songs: Valley of Ghosts, Lonely Blossom, Farmer (License CC BY-SA 4.0)
+* Diminixed for 3 fantastic tracks and remastering and leveling volumes. Songs: Afternoon Lullaby (pianowtune02), Spooled (ambientwip02), Never Grow Up (License CC BY-SA 4.0)

HOW_TO_PLAY.md

@@ -0,0 +1,21 @@
+Survive, farm, build, explore, play with friends, and do much more. Inspired by a well known block game, pushing beyond.
+
+How to play:
+
+#### Download Minetest
+- Navigate to https://www.minetest.net/ to download the client.
+- Once installed, open and select the "Content" tab
+
+#### Install MineClone2 from ContentDB
+- Click "Browse Online Content" and filter by Games (select "Games" from the dropdown box)
+- Find "MineClone2" (should be first on the list or on the first page)
+- Click the [+] button next to MineClone2 and wait for download to finish
+- Click "Back to Main Menu"
+
+#### Create new world and play
+- Click "Start Game" tab
+- At the bottom click the MineClone2 icon (the 2 dirt with grass blocks)
+- Click "New", give your world a name
+- You can leave seed blank or put in a word of your choice
+- Select your new world
+- Click "Play Game" and enjoy!

MODELS.md

@@ -0,0 +1,70 @@
+#Models in Minetest/Mineclone2
+
+Models are an important part of all entities & unique nodes in Mineclone2. They provide a 3 dimensional map of an object for which textures are then applied to. This document is for modders, it quickly highlights some important information for the software needed to open models in Mineclone2.
+
+## Minetest Wiki
+For more detailed information on actually using blender to create and modify models for Minetest/Mineclone2, please visit the Minetest wiki's page on using Blender [Here](https://wiki.minetest.net/Using_Blender)
+
+##Recommended software
+
+###Blender
+
+Blender is a very popular and free modeling software supported on Windows, MacOS, and most Linux distributions. It is recommended to use Blender to create and modify 3D models within the minetest engine. 
+
+Download blender [Here](https://www.blender.org/download/)
+
+### .b3d addon for blender
+
+Blitz 3D (.b3d) Is one of the main animated model formats used for entities in the minetest engine. It cannot be imported to blender without a plugin called "Import-Export:Bitz 3D format (.b3d)".
+
+The most up to date version of this Blender plugin can be downloaded [Here](https://github.com/GreenXenith/io_scene_b3d/releases/tag/f189786)
+
+##Types of model formats
+
+###Animated, skinned models
+* Blitz 3D files (.b3d)
+
+* Microsoft DirectX (.x) (binary & text, compression is not supported)
+
+###Static meshes
+* Wavefront OBJ (.obj)
+
+Note: The sometimes accompanying .mtl files are not supported and can safely be deleted.
+
+Note: Do not use .b3d and .x files for static meshes at the moment, Minetest currently spawns animated mesh scene nodes for these, which may result in reduced performance.
+
+### Supported texture formats
+
+* .png
+
+* .jpg
+
+* .bmp (depreciated, please use .png or .jpg)
+
+* .tga (depreciated, please use .png or .jpg)
+
+Note: Any formats not mentioned above but known to work in the past were removed in 5.5.0 and aren't supported anymore.
+
+##Pros & Cons of .b3d vs .x
+
+###B3D
+* [+] Binary format means a small size
+
+* [-] Difficult to postprocess after exporting
+
+* [-] Difficult to debug problems
+
+###X (text version)
+* [+] Can be parsed easily with lua scripts
+
+* [+] Can be easily generated by scripts
+
+* [+] Easy to debug issues (you can just read it)
+
+* [+] Can be optimized by quantizing some data
+
+* [-] Blender exporter is kinda buggy and inefficient
+
+* [-] Probably still bigger than an equivalent .b3d
+
+Note: Avoid using the binary X format! It's actually just a tokenized version of the ASCII representation, and may actually be less efficient than a sufficiently optimized text .x file!

README.md

@@ -2,8 +2,6 @@
 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.82 (in development)
-
 ### Gameplay
 You start in a randomly-generated world made entirely of cubes. You can explore
 the world and dig and build almost every block in the world to create new
@@ -80,7 +78,7 @@ The MineClone2 repository is hosted at Mesehub. To contribute or report issues,
 
 * Mesehub: <https://git.minetest.land/MineClone2/MineClone2>
 * Discord: <https://discord.gg/xE4z8EEpDC>
-* YouTube <https://www.youtube.com/channel/UClI_YcsXMF3KNeJtoBfnk9A>
+* YouTube: <https://www.youtube.com/channel/UClI_YcsXMF3KNeJtoBfnk9A>
 * IRC: <https://web.libera.chat/#mineclone2>
 * Matrix: <https://app.element.io/#/room/#mc2:matrix.org>
 * Reddit: <https://www.reddit.com/r/MineClone2/>

README_locale/README.fr.md

@@ -1,48 +1,45 @@
 # MineClone2
-Un jeu non-officiel similaire à Minecraft pour Minetest. Forké depuis Mineclone par davedevils. Développé par de nombreuses personnes. Ni développé ou supporté par Mojang AB.
+Un jeu non-officiel similaire à Minecraft pour Minetest. Forké depuis Mineclone par davedevils. Développé par de nombreuses personnes. Pas développé ni supporté par Mojang AB.
-
- Version: 0.79 (en dévelopment)
 
 ### Gameplay 
-
 Vous atterissez dans un monde fait entièrement de cubes et généré aléatoirement. Vous pouvez explorer le monde, miner et construire presque n'importe quel bloc pour créer de nouvelles structures. Vous pouvez choisir de jouer en "mode survie" dans lequel vous devez combattre des monstres et la faim et progresser lentement dans différents aspects du jeu, comme l'extraction de minerai, l'agriculture, la construction de machines et ainsi de suite. Ou alors vous pouvez jouer en "mode créatif" où vous pouvez construire à peu près n'importe quoi instantanément.
 
 ### Résumé du Gameplay
 
 * Jeu de type bac-à-sable, sans objetifs
-* Survie : combattre des monstres hostiles et la faim
+* Survie : combattez des monstres hostiles et la faim
-* Creuser pour du minerai et d'autres trésors
+* Creusez pour du minerai et d'autres trésors
-* Magie : gagner de l'expérience et enchanter les outils
+* Magie : gagnez de l'expérience et enchantez les outils
-* Utiliser les blocs ramassés pour construire de magnifiques bâtiments, votre imagination est la limite
+* Utilisez les blocs ramassés pour construire de magnifiques bâtiments, votre imagination est la seule limite
-* Ramasser des fleurs (et d'autres sources de teinture) et colorez votre monde
+* Ramassez des fleurs (et d'autres sources de teinture) et colorez votre monde
 * Trouvez des graines et commencez à cultiver
 * Trouvez ou fabriquez des centaines d'objets
-* Construisez un réseau ferroviaire complexe et amusez vous avec les wagonnets
+* Construisez un réseau ferroviaire complexe et amusez-vous avec les wagonnets
 * En mode créatif vous pouvez construire presque n'importe quoi gratuitement et sans limite
 
 ## Comment jouer (démarrer rapidement)
 ### Commencer
 * **Frappez un arbre** jusqu'à ce qu'il casse et donne du bois
 * Placez le **bois dans la grille 2x2** (la "grille de fabrication" de votre menu d'inventaire) et fabriquez 4 planches de bois
-* Placer les 4 planches de bois dans la grille 2x2 et **fabriquez une table d'artisanat**
+* Placer les 4 planches de bois dans la grille 2x2 et **fabriquez un établi**
-* **Cliquez droit la table d'artisanat** (icone livre) pour apprendre toutes les recettes possibles
+* **Faites un clic droit sur l'établi** (icone livre) pour apprendre toutes les recettes possibles
 * **Fabriquez une pioche de bois** pour miner la pierre
-* Différents outils minent différentes sortes de blocs. Essayez les !
+* Différents outils minent différentes sortes de blocs. Essayez-les !
-* Continuez à jouer comme vous voulez. Amusez vous !
+* Continuez à jouer comme vous voulez. Amusez-vous !
 
 ### Agriculture
 * Trouvez des graines
 * Fabriquez une houe
-* Cliquez droit la terre ou des blocs similaires avec la houe pour créer des terres agricoles
+* Faites un clic droit sur la terre ou des blocs similaires avec la houe pour créer des terres agricoles
 * Placer des graines sur des terres agricoles et regardez les pousser
 * Récoltez les plantes une fois matûres
 * Les terres agricoles proche de l'eau deviennent humides et accélèrent la croissance
 
 ### Four
-* Fabriquer un Four
+* Fabriquez un four
 * Le four permet d'obtenir plus d'objets
-* L'emplacement du haut doit contienir un objet fondable (par ex : minerai de fer)
+* L'emplacement du haut doit contenir un objet fondable (par ex : minerai de fer)
-* L'emplacement du bas doit contienir un objet combustible (par ex : charbon)
+* L'emplacement du bas doit contenir un objet combustible (par ex : charbon)
 * Voir le guide d'artisanat pour en apprendre plus sur les objets fondables et combustibles
 
 ### Aide supplémentaire
@@ -62,43 +59,43 @@ Il n'y a pas de support de MineClone2 dans les versions développement de Minete
 Pour installer MineClone2 (si ce n'est pas déjà fait), déplacez ce dossier dans le dossier “games” de Minetest. Consultez l'aide de Minetest pour en apprendre plus.
 
 ## Liens utiles 
-Le dépôt de MineClone2 est hébergé sur Mesehub. Pour contribuer ou rapporter des problèmes, aller là-bas.
+Le dépôt de MineClone2 est hébergé sur Mesehub. Pour contribuer ou signaler des problèmes, allez là-bas.
 
-* Mesehub: <https://git.minetest.land/MineClone2/MineClone2>
+* Mesehub : <https://git.minetest.land/MineClone2/MineClone2>
-* Discord: <https://discord.gg/xE4z8EEpDC>
+* Discord : <https://discord.gg/xE4z8EEpDC>
-* YouTube <https://www.youtube.com/channel/UClI_YcsXMF3KNeJtoBfnk9A>
+* YouTube : <https://www.youtube.com/channel/UClI_YcsXMF3KNeJtoBfnk9A>
-* IRC: <https://web.libera.chat/#mineclone2>
+* IRC : <https://web.libera.chat/#mineclone2>
-* Matrix: <https://app.element.io/#/room/#mc2:matrix.org>
+* Matrix : <https://app.element.io/#/room/#mc2:matrix.org>
-* Reddit: <https://www.reddit.com/r/MineClone2/>
+* Reddit : <https://www.reddit.com/r/MineClone2/>
-* Minetest forums: <https://forum.minetest.net/viewtopic.php?f=50&t=16407>
+* Forums Minetest : <https://forum.minetest.net/viewtopic.php?f=50&t=16407>
-* ContentDB: <https://content.minetest.net/packages/wuzzy/mineclone2/>
+* ContentDB : <https://content.minetest.net/packages/wuzzy/mineclone2/>
-* OpenCollective: <https://opencollective.com/mineclone2>
+* OpenCollective : <https://opencollective.com/mineclone2>
 
 ## Objectif
-* Créer un clone stable, moddable, libre et gratuit basé sur le moteur de jeu Minetest avec des fonctionalités abouties, utilisable à la fois en mode solo et multijoueur. Actuellement, beaucoup des fonctionalités de **Minecraft Java Edition** sont déjà implémentées et leur amélioration est prioritaire sur les nouvelles demandes.
+* Essentiellement, créer un clone de Minecraft stable, moddable, libre et gratuit basé sur le moteur de jeu Minetest avec des fonctionnalités abouties, utilisable à la fois en mode solo et multijoueur. Actuellement, beaucoup des fonctionnalités de **Minecraft Java Edition** sont déjà implémentées et leur amélioration est prioritaire sur les nouvelles demandes.
-* Avec une priorité moindre, implémenter les fonctionalités des versions **Minecraft + OptiFine** (OtiFine autant que supporté par le moteur Minetest). Cela signifie que les fonctionalités présentes dans les versions listées sont priorisées.
+* Avec une priorité moindre, implémenter les fonctionnalités des versions **Minecraft + OptiFine** (OptiFine autant que supporté par le moteur Minetest). Cela signifie que les fonctionnalités présentes dans les versions listées sont priorisées.
-* Dans l'idéal, créer une expérience performante qui tourne bien sur des ordinateurs à basse performance. Malheureusement, en raison des mécanismes de Minecraft et des limitations du moteur Minetest ainsi que de la petite taille de la communauté de joueurs sur des ordinateurs à basse performances, les optimisations sont difficiles à explorer.
+* Dans l'idéal, créer une expérience performante qui tourne bien sur des ordinateurs à basse performance. Malheureusement, en raison des mécanismes de Minecraft et des limitations du moteur Minetest ainsi que de la petite taille de la communauté de joueurs sur des ordinateurs à basses performances, les optimisations sont difficiles à explorer.
 
 ## Statut de complétion
 Ce jeu est actuellement au stade **beta**.
-Il est jouable mais incomplet en fonctionalités.
+Il est jouable mais incomplet en fonctionnalités.
 La rétro-compatibilité n'est pas entièrement garantie, mettre votre monde à jour peut causer de petits bugs.
 Si vous voulez utiliser la version de développement de MineClone2 en production, la branche master est habituellement relativement stable. Les branches de test fusionnent souvent des pull requests expérimentales et doivent être considérées comme moins stable.
 
-Les principales fonctionalités suivantes sont disponibles :
+Les principales fonctionnalités suivantes sont disponibles :
 
 * Outils, armes
 * Armure
-* Système de fabrication : grille 2x2, table d'artisanat (grille 3x3), four, incluant un guide de fabrication
+* Système de fabrication : grille 2x2, établi (grille 3x3), four, incluant un guide de fabrication
-* Coffres, grands coffres, coffre ender, boite de shulker
+* Coffres, grands coffres, coffre ender, boites de Shulker
 * Fours, entonnoirs
 * Faim
 * La plupart des monstres et animaux
-* Tout les minerais de Minecraft
+* Tous les minerais de Minecraft
 * La plupart des blocs de l'overworld
 * Eau et lave
 * Météo
-* 28 biomes + 5 biomes du nether
+* 28 biomes + 5 biomes du Nether
 * Le Nether, monde souterrain brûlant dans une autre dimension
 * Circuits Redstone (partiel)
 * Effets de Statut (partiel)
@@ -107,10 +104,10 @@ Les principales fonctionalités suivantes sont disponibles :
 * Brassage, potions, flèches trempées (partiel)
 * Bâteaux
 * Feu
-* Blocs de construction : escaliers, dalles, portes, trappes, barrière, portillon, muret
+* Blocs de construction : escaliers, dalles, portes, trappes, barrières, portillons, murets
 * Horloge
 * Boussole
-* Eponge
+* Éponge
 * Bloc de slime 
 * Petites plantes et pousses
 * Teintures
@@ -118,26 +115,30 @@ Les principales fonctionalités suivantes sont disponibles :
 * Blocs de décoration : verre, verre teinté, vitres, barres de fer, terre cuites (et couleurs), têtes et plus
 * Cadres d'objets 
 * Juke-boxes
+* Lits
+* Menu d'inventaire
+* Inventaire créatif
+* Agriculture
 * Livres pour écrire
 * Commandes
 * Villages
 * L'End 
 * et plus !
 
-Les fonctionalités suivantes sont incomplètes :
+Les fonctionnalités suivantes sont incomplètes :
 
-* certains monstres et animaux
+* Certains monstres et animaux
-* certains composants de Redstone
+* Certains composants de Redstone
 * Wagonnets spéciaux
-* quelques blocs et objets non-triviaux
+* Quelques blocs et objets non-triviaux
 
-Fonctionalités bonus (absentes de Minecraft) :
+Fonctionnalités bonus (absentes de Minecraft) :
 
 * Guide d'artisanat intégré au jeu qui montre les recettes d'artisanat et de cuisson
 * Système d'aide intégré au jeu contenant des informations à propos des techniques de base, blocs, objets et plus
-* Recettes d'artisanat temporaires. Elles existent uniquement pour rendre des objets accessibles qui ne le seraient pas autrement sauf en mode créatif. Elles seront retirées au cours de l'avancement du développement et de l'ajout de nouvelles fonctionalités.
+* Recettes d'artisanat temporaires. Elles existent uniquement pour rendre des objets accessibles qui ne le seraient pas autrement sauf en mode créatif. Elles seront retirées au cours de l'avancement du développement et de l'ajout de nouvelles fonctionnalités.
 * Pousses dans les coffres en mapgen v6
-* Entièrement moddable (grâce la puissante API lua de Minetest)
+* Entièrement moddable (grâce la puissante API Lua de Minetest)
 * Nouveaux blocs et objets :
     * Outil de recherche, montre l'aide de ce qu'il touche
     * Plus de dalles et d'escaliers
@@ -149,22 +150,24 @@ Fonctionalités bonus (absentes de Minecraft) :
     * Avant-poste du Nether (Forteresse)
 
 Différences techniques avec Minecraft :
+
 * Limite en hauteur de 31000 blocs (bien plus grand que Minecraft)
 * Taille horizontale du monde 62000×62000 blocs (bien plus petit que Minecraft mais toujours très grand)
 * Toujours assez incomplet et buggé
-* Des blocs, objets, ennemis et fonctionalités manquent
+* Des blocs, objets, ennemis et fonctionnalités manquent
 * Quelques objets ont des noms légèrement différents pour être plus faciles à distinguer
 * Des musiques différentes pour le juke-boxe
 * Des textures différentes (Pixel Perfection)
 * Des sons différents (sources diverses)
 * Un moteur de jeu différent (Minetest)
 * Des bonus cachés différents
+
 ...et enfin MineClone2 est un logiciel libre !
 
 ## Autres fichiers readme
 
-* `LICENSE.txt`: Le texte de la license GPLv3
+* `LICENSE.txt` : Le texte de la licence GPLv3
-* `CONTRIBUTING.md`: Information pour ceux qui veulent contribuer
+* `CONTRIBUTING.md` : Information pour ceux qui veulent contribuer
-* `API.md`: Pour les modders Minetest qui veulent modder ce jeu
+* `API.md` : Pour les modders Minetest qui veulent modder ce jeu
-* `LEGAL.md`: Information légale
+* `LEGAL.md` : Information légale
-* `CREDITS.md`: Liste des contributeurs
+* `CREDITS.md` : Liste de toutes les personnes qui ont contribué

RELEASE.md

@@ -1,19 +1,75 @@
+### Standard Release
+
 #File to document release steps with a view to evolving into a script
 
 #Update CREDITS.md
-#Update version in README.md (soon to be game.conf from of 0.82.0)
+#Update version in game.conf
 
 lua tools/generate_ingame_credits.lua
 
 git add CREDITS.md
 git add mods/HUD/mcl_credits/people.lua
+git add game.conf
 
-git add README.md
+#git add RELEASE.md
-# To uncomment when applicable
-#git add game.conf
 
-git commit -m "Pre-release update credits and set version 0.81.1"
+git commit -m "Pre-release update credits and set version 0.82.0"
 
-git tag 0.81.1
+git tag 0.82.0
 
-git push origin 0.81.1
+git push origin 0.82.0
+
+#Update version in game.conf to -SNAPSHOT
+
+git commit -m "Post-release set version 0.82.0-SNAPSHOT"
+
+### Hotfix Release
+
+##### Prepare release branch
+
+When hotfixing, you should never release new features. Any new code increases risk of new bugs which has additional testing/release concerns. 
+To mitigate this, you just release the last release, and the relevant bug fix. For this, we do the following:
+
+* Create release branch from the last release tag, push it:
+
+git checkout -b release/0.82.1 0.82.0
+
+git push origin release/0.82.1
+
+##### Prepare feature branch and fix
+
+* Create feature branch from that release branch (can review it to check only fix is there, nothing else, and use to also merge into master separately)
+
+git checkout -b hotfix_bug_1_branch
+
+* Fix crash/serious bug and commit
+* Push branch and create pr to the release and also the master branch (Do not rebase, to reduce merge conflict risk. Do not delete after first merge or it needs to be repushed)
+
+##### Update version and tag the release
+
+* After all fixes are in release branch, pull it locally  (best to avoid a merge conflict as feature branch will need to be merged into master also, which already changed version):
+
+* Update version in game.conf to hotfix version and commit it. Example: version=0.82.1
+
+* Tag it, push tag and branch:
+
+git tag 0.82.1
+
+git push origin 0.82.1
+
+git push origin release/0.82.1
+
+Note: If you have to do more than 1 hotfix release, can do it on the same release branch.
+
+### Release via ContentDB
+
+* Go to MineClone2 page (https://content.minetest.net/packages/Wuzzy/mineclone2/)
+* Click +Release
+* Enter the release tag number in the title and Git reference box. For example (without quotes): "0.82.1"
+* In the minimum minetest version, put the oldest supported version (as of 14/02/2023 it is 5.5), leave the Maximum minetest version blank
+* Click save. Release is now live.
+
+##### Inform people
+
+* Add a comment to the forum post with the release number and what is involved, and maintainer will update main post.
+* Add a comment in Discord announcement

game.conf

@@ -1,4 +1,4 @@
 title = MineClone 2
 description = A survival sandbox game. Survive, gather, hunt, build, explore, and do much more.
 disallowed_mapgens = v6
-version=MCL2-0.82-indev
+version=0.82.0-SNAPSHOT

mods/CORE/_mcl_autogroup/init.lua

@@ -204,7 +204,7 @@ end
 
 -- Checks if the given node would drop its useful drop if dug by a given tool.
 -- Returns true if it will yield its useful drop, false otherwise.
-function mcl_autogroup.can_harvest(nodename, toolname)
+function mcl_autogroup.can_harvest(nodename, toolname, player)
 	local ndef = minetest.registered_nodes[nodename]
 
 	if not ndef then
@@ -228,7 +228,9 @@ function mcl_autogroup.can_harvest(nodename, toolname)
 	end
 
 	-- Check if it can be dug by hand
-	local tdef = minetest.registered_tools[""]
+	if not player or not player:is_player() then return false end
+	local name = player:get_inventory():get_stack("hand", 1):get_name()
+	local tdef = minetest.registered_items[name]
 	if tdef then
 		for g, gdef in pairs(tdef._mcl_diggroups) do
 			if ndef.groups[g] then
@@ -260,7 +262,7 @@ local function get_tool_capabilities(tdef)
 
 	-- If the damage group and punch interval from hand is not included,
 	-- then the user will not be able to attack with the tool.
-	local hand_toolcaps = minetest.registered_tools[""].tool_capabilities
+	local hand_toolcaps = mcl_meshhand.survival_hand_tool_caps
 	return {
 		full_punch_interval = hand_toolcaps.full_punch_interval,
 		damage_groups = hand_toolcaps.damage_groups
@@ -280,7 +282,7 @@ end
 -- would have to add _mcl_autogroup as a dependency which would break the mod
 -- loading order.
 function mcl_autogroup.get_groupcaps(toolname, efficiency)
-	local tdef = minetest.registered_tools[toolname]
+	local tdef = minetest.registered_items[toolname]
 	local groupcaps = table.copy(get_tool_capabilities(tdef).groupcaps or {})
 	add_groupcaps(toolname, groupcaps, tdef._mcl_diggroups, efficiency)
 	return groupcaps
@@ -298,6 +300,10 @@ end
 -- loading order.
 function mcl_autogroup.get_wear(toolname, diggroup)
 	local tdef = minetest.registered_tools[toolname]
+	if not tdef then
+		minetest.log("warning", "Adding wear for tool: " .. tostring(toolname) .. " failed with diggroup: " .. tostring(diggroup))
+		return nil
+	end
 	local uses = tdef._mcl_diggroups[diggroup].uses
 	return math.ceil(65535 / uses)
 end
@@ -350,7 +356,7 @@ local function overwrite()
 		end
 	end
 
-	for tname, tdef in pairs(minetest.registered_tools) do
+	for tname, tdef in pairs(minetest.registered_items) do
 		-- Assign groupcaps for digging the registered digging groups
 		-- depending on the _mcl_diggroups in the tool definition
 		if tdef._mcl_diggroups then

mods/CORE/mcl_autogroup/API.md

@@ -1,10 +1,11 @@
 # mcl_autogroup
 This mod emulate digging times from mc.
 
-## mcl_autogroup.can_harvest(nodename, toolname)
+## mcl_autogroup.can_harvest(nodename, toolname, player)
-Return true if <nodename> can be dig with <toolname>.
+Return true if <nodename> can be dig with <toolname> by <player>.
 * nodename: string, valid nodename
 * toolname: (optional) string, valid toolname
+* player: (optinal) ObjectRef, valid player
 
 ## mcl_autogroup.get_groupcaps(toolname, efficiency)
 This function is used to calculate diggroups for tools.

mods/CORE/mcl_damage/init.lua

@@ -155,7 +155,6 @@ end, true)
 minetest.register_on_player_hpchange(function(player, hp_change, mt_reason)
 	if not damage_enabled then return 0 end
 	if player:get_hp() > 0 then
-		mt_reason.approved = true
 		if hp_change < 0 then
 			mcl_damage.run_damage_callbacks(player, -hp_change, mcl_damage.from_mt(mt_reason))
 		end
@@ -163,9 +162,7 @@ minetest.register_on_player_hpchange(function(player, hp_change, mt_reason)
 end, false)
 
 minetest.register_on_dieplayer(function(player, mt_reason)
-	if mt_reason.approved then
+	mcl_damage.run_death_callbacks(player, mcl_damage.from_mt(mt_reason))
-		mcl_damage.run_death_callbacks(player, mcl_damage.from_mt(mt_reason))
-	end
 	minetest.log("action","Player "..player:get_player_name().." died at "..minetest.pos_to_string(vector.round(player:get_pos())))
 end)
 

mods/CORE/mcl_explosions/init.lua

@@ -13,6 +13,7 @@ under the LGPLv2.1 license.
 mcl_explosions = {}
 
 local mod_fire = minetest.get_modpath("mcl_fire")
+local explosions_griefing = minetest.settings:get_bool("mcl_explosions_griefing", true)
 --local CONTENT_FIRE = minetest.get_content_id("mcl_fire:fire")
 
 local math = math
@@ -191,7 +192,7 @@ local function trace_explode(pos, strength, raydirs, radius, info, direct, sourc
 	local grief_protected = info.grief_protected
 
 	-- Trace rays for environment destruction
-	if info.griefing then
+	if info.griefing and explosions_griefing then
 		for i = 1, #raydirs do
 			local rpos_x = pos.x
 			local rpos_y = pos.y

mods/CORE/mcl_util/init.lua

@@ -2,8 +2,8 @@ mcl_util = {}
 
 -- Updates all values in t using values from to*.
 function table.update(t, ...)
-	for _, to in ipairs{...} do
+	for _, to in ipairs {...} do
-		for k,v in pairs(to) do
+		for k, v in pairs(to) do
 			t[k] = v
 		end
 	end
@@ -12,8 +12,8 @@ end
 
 -- Updates nil values in t using values from to*.
 function table.update_nil(t, ...)
-	for _, to in ipairs{...} do
+	for _, to in ipairs {...} do
-		for k,v in pairs(to) do
+		for k, v in pairs(to) do
 			if t[k] == nil then
 				t[k] = v
 			end
@@ -22,9 +22,9 @@ function table.update_nil(t, ...)
 	return t
 end
 
-local LOGGING_ON = minetest.settings:get_bool("mcl_logging_default",false)
+local LOGGING_ON = minetest.settings:get_bool("mcl_logging_default", false)
 local LOG_MODULE = "[MCL2]"
-function mcl_util.mcl_log (message, module, bypass_default_logger)
+function mcl_util.mcl_log(message, module, bypass_default_logger)
 	local selected_module = LOG_MODULE
 	if module then
 		selected_module = module
@@ -34,7 +34,6 @@ function mcl_util.mcl_log (message, module, bypass_default_logger)
 	end
 end
 
-
 function mcl_util.file_exists(name)
 	if type(name) ~= "string" then return end
 	local f = io.open(name)
@@ -69,7 +68,7 @@ function mcl_util.rotate_axis_and_place(itemstack, placer, pointed_thing, infini
 	local undef = minetest.registered_nodes[unode.name]
 	if undef and undef.on_rightclick then
 		undef.on_rightclick(pointed_thing.under, unode, placer,
-				itemstack, pointed_thing)
+			itemstack, pointed_thing)
 		return
 	end
 	local fdir = minetest.dir_to_facedir(placer:get_look_dir())
@@ -151,23 +150,23 @@ end
 function mcl_util.get_double_container_neighbor_pos(pos, param2, side)
 	if side == "right" then
 		if param2 == 0 then
-			return {x=pos.x-1, y=pos.y, z=pos.z}
+			return {x = pos.x - 1, y = pos.y, z = pos.z}
 		elseif param2 == 1 then
-			return {x=pos.x, y=pos.y, z=pos.z+1}
+			return {x = pos.x, y = pos.y, z = pos.z + 1}
 		elseif param2 == 2 then
-			return {x=pos.x+1, y=pos.y, z=pos.z}
+			return {x = pos.x + 1, y = pos.y, z = pos.z}
 		elseif param2 == 3 then
-			return {x=pos.x, y=pos.y, z=pos.z-1}
+			return {x = pos.x, y = pos.y, z = pos.z - 1}
 		end
 	else
 		if param2 == 0 then
-			return {x=pos.x+1, y=pos.y, z=pos.z}
+			return {x = pos.x + 1, y = pos.y, z = pos.z}
 		elseif param2 == 1 then
-			return {x=pos.x, y=pos.y, z=pos.z-1}
+			return {x = pos.x, y = pos.y, z = pos.z - 1}
 		elseif param2 == 2 then
-			return {x=pos.x-1, y=pos.y, z=pos.z}
+			return {x = pos.x - 1, y = pos.y, z = pos.z}
 		elseif param2 == 3 then
-			return {x=pos.x, y=pos.y, z=pos.z+1}
+			return {x = pos.x, y = pos.y, z = pos.z + 1}
 		end
 	end
 end
@@ -185,7 +184,7 @@ end
 function mcl_util.get_eligible_transfer_item_slot(src_inventory, src_list, dst_inventory, dst_list, condition)
 	local size = src_inventory:get_size(src_list)
 	local stack
-	for i=1, size do
+	for i = 1, size do
 		stack = src_inventory:get_stack(src_list, i)
 		if not stack:is_empty() and (condition == nil or condition(stack, src_inventory, src_list, dst_inventory, dst_list)) then
 			return i
@@ -288,10 +287,10 @@ function mcl_util.move_item_container(source_pos, destination_pos, source_list,
 		-- Main inventory for most container types
 		if sctype == 2 or sctype == 3 or sctype == 5 or sctype == 6 or sctype == 7 then
 			source_list = "main"
-		-- Furnace: output
+			-- Furnace: output
 		elseif sctype == 4 then
 			source_list = "dst"
-		-- Unknown source container type. Bail out
+			-- Unknown source container type. Bail out
 		else
 			return false
 		end
@@ -344,7 +343,7 @@ function mcl_util.move_item_container(source_pos, destination_pos, source_list,
 			-- Main inventory for most container types
 			if dctype == 2 or dctype == 3 or dctype == 5 or dctype == 6 or dctype == 7 then
 				destination_list = "main"
-			-- Furnace source slot
+				-- Furnace source slot
 			elseif dctype == 4 then
 				destination_list = "src"
 			end
@@ -409,7 +408,7 @@ end
 -- Returns true if item (itemstring or ItemStack) can be used as a furnace fuel.
 -- Returns false otherwise
 function mcl_util.is_fuel(item)
-	return minetest.get_craft_result({method="fuel", width=1, items={item}}).time ~= 0
+	return minetest.get_craft_result({method = "fuel", width = 1, items = {item}}).time ~= 0
 end
 
 -- Returns a on_place function for plants
@@ -456,7 +455,7 @@ function mcl_util.generate_on_place_plant_function(condition)
 
 			if success then
 				if idef.sounds and idef.sounds.place then
-					minetest.sound_play(idef.sounds.place, {pos=pointed_thing.above, gain=1}, true)
+					minetest.sound_play(idef.sounds.place, {pos = pointed_thing.above, gain = 1}, true)
 				end
 			end
 			itemstack = new_itemstack
@@ -557,6 +556,11 @@ function mcl_util.deal_damage(target, damage, mcl_reason)
 		end
 	end
 
+	local is_immortal = target:get_armor_groups().immortal or 0
+	if is_immortal>0 then
+		return
+	end
+
 	local hp = target:get_hp()
 
 	if hp > 0 then
@@ -643,78 +647,80 @@ end
 
 local function roundN(n, d)
 	if type(n) ~= "number" then return n end
-    local m = 10^d
+	local m = 10 ^ d
-    return math.floor(n * m + 0.5) / m
+	return math.floor(n * m + 0.5) / m
 end
 
-local function close_enough(a,b)
+local function close_enough(a, b)
-	local rt=true
+	local rt = true
 	if type(a) == "table" and type(b) == "table" then
-		for k,v in pairs(a) do
+		for k, v in pairs(a) do
-			if roundN(v,2) ~= roundN(b[k],2) then
+			if roundN(v, 2) ~= roundN(b[k], 2) then
-				rt=false
+				rt = false
 				break
 			end
 		end
 	else
-		rt = roundN(a,2) == roundN(b,2)
+		rt = roundN(a, 2) == roundN(b, 2)
 	end
 	return rt
 end
 
-local function props_changed(props,oldprops)
+local function props_changed(props, oldprops)
-	local changed=false
+	local changed = false
-	local p={}
+	local p = {}
-	for k,v in pairs(props) do
+	for k, v in pairs(props) do
-		if not close_enough(v,oldprops[k]) then
+		if not close_enough(v, oldprops[k]) then
-			p[k]=v
+			p[k] = v
-			changed=true
+			changed = true
 		end
 	end
-	return changed,p
+	return changed, p
 end
 
 --tests for roundN
-local test_round1=15
+local test_round1 = 15
-local test_round2=15.00199999999
+local test_round2 = 15.00199999999
-local test_round3=15.00111111
+local test_round3 = 15.00111111
-local test_round4=15.00999999
+local test_round4 = 15.00999999
 
-assert(roundN(test_round1,2)==roundN(test_round1,2))
+assert(roundN(test_round1, 2) == roundN(test_round1, 2))
-assert(roundN(test_round1,2)==roundN(test_round2,2))
+assert(roundN(test_round1, 2) == roundN(test_round2, 2))
-assert(roundN(test_round1,2)==roundN(test_round3,2))
+assert(roundN(test_round1, 2) == roundN(test_round3, 2))
-assert(roundN(test_round1,2)~=roundN(test_round4,2))
+assert(roundN(test_round1, 2) ~= roundN(test_round4, 2))
 
 -- tests for close_enough
-local test_cb = {-0.35,0,-0.35,0.35,0.8,0.35} --collisionboxes
+local test_cb = {-0.35, 0, -0.35, 0.35, 0.8, 0.35} --collisionboxes
-local test_cb_close = {-0.351213,0,-0.35,0.35,0.8,0.351212}
+local test_cb_close = {-0.351213, 0, -0.35, 0.35, 0.8, 0.351212}
-local test_cb_diff = {-0.35,0,-1.35,0.35,0.8,0.35}
+local test_cb_diff = {-0.35, 0, -1.35, 0.35, 0.8, 0.35}
 
 local test_eh = 1.65 --eye height
 local test_eh_close = 1.65123123
 local test_eh_diff = 1.35
 
-local test_nt = { r = 225, b = 225, a = 225, g = 225 } --nametag
+local test_nt = {r = 225, b = 225, a = 225, g = 225} --nametag
-local test_nt_diff = { r = 225, b = 225, a = 0, g = 225 }
+local test_nt_diff = {r = 225, b = 225, a = 0, g = 225}
 
-assert(close_enough(test_cb,test_cb_close))
+assert(close_enough(test_cb, test_cb_close))
-assert(not close_enough(test_cb,test_cb_diff))
+assert(not close_enough(test_cb, test_cb_diff))
-assert(close_enough(test_eh,test_eh_close))
+assert(close_enough(test_eh, test_eh_close))
-assert(not close_enough(test_eh,test_eh_diff))
+assert(not close_enough(test_eh, test_eh_diff))
-assert(not close_enough(test_nt,test_nt_diff)) --no floats involved here
+assert(not close_enough(test_nt, test_nt_diff)) --no floats involved here
 
 --tests for properties_changed
-local test_properties_set1={collisionbox = {-0.35,0,-0.35,0.35,0.8,0.35}, eye_height = 0.65, nametag_color = { r = 225, b = 225, a = 225, g = 225 }}
+local test_properties_set1 = {collisionbox = {-0.35, 0, -0.35, 0.35, 0.8, 0.35}, eye_height = 0.65,
-local test_properties_set2={collisionbox = {-0.35,0,-0.35,0.35,0.8,0.35}, eye_height = 1.35, nametag_color = { r = 225, b = 225, a = 225, g = 225 }}
+	nametag_color = {r = 225, b = 225, a = 225, g = 225}}
+local test_properties_set2 = {collisionbox = {-0.35, 0, -0.35, 0.35, 0.8, 0.35}, eye_height = 1.35,
+	nametag_color = {r = 225, b = 225, a = 225, g = 225}}
 
-local test_p1,_=props_changed(test_properties_set1,test_properties_set1)
+local test_p1, _ = props_changed(test_properties_set1, test_properties_set1)
-local test_p2,_=props_changed(test_properties_set1,test_properties_set2)
+local test_p2, _ = props_changed(test_properties_set1, test_properties_set2)
 
 assert(not test_p1)
 assert(test_p2)
 
-function mcl_util.set_properties(obj,props)
+function mcl_util.set_properties(obj, props)
-	local changed,p=props_changed(props,obj:get_properties())
+	local changed, p = props_changed(props, obj:get_properties())
 	if changed then
 		obj:set_properties(p)
 	end
@@ -728,3 +734,312 @@ function mcl_util.set_bone_position(obj, bone, pos, rot)
 		obj:set_bone_position(bone, pos or current_pos, rot or current_rot)
 	end
 end
+
+---Return a function to use in `on_place`.
+---
+---Allow to bypass the `buildable_to` node field in a `on_place` callback.
+---
+---You have to make sure that the nodes you return true for have `buildable_to = true`.
+---@param func fun(node_name: string): boolean Return `true` if node must not replace the buildable_to node which have `node_name`
+---@return fun(itemstack: ItemStack, placer: ObjectRef, pointed_thing: pointed_thing, param2: integer): ItemStack?
+function mcl_util.bypass_buildable_to(func)
+	--------------------------
+	-- MINETEST CODE: UTILS --
+	--------------------------
+
+	local function copy_pointed_thing(pointed_thing)
+		return {
+			type  = pointed_thing.type,
+			above = pointed_thing.above and vector.copy(pointed_thing.above),
+			under = pointed_thing.under and vector.copy(pointed_thing.under),
+			ref   = pointed_thing.ref,
+		}
+	end
+
+	local function user_name(user)
+		return user and user:get_player_name() or ""
+	end
+
+	-- Returns a logging function. For empty names, does not log.
+	local function make_log(name)
+		return name ~= "" and minetest.log or function() end
+	end
+
+	local function check_attached_node(p, n, group_rating)
+		local def = core.registered_nodes[n.name]
+		local d = vector.zero()
+		if group_rating == 3 then
+			-- always attach to floor
+			d.y = -1
+		elseif group_rating == 4 then
+			-- always attach to ceiling
+			d.y = 1
+		elseif group_rating == 2 then
+			-- attach to facedir or 4dir direction
+			if (def.paramtype2 == "facedir" or
+				def.paramtype2 == "colorfacedir") then
+				-- Attach to whatever facedir is "mounted to".
+				-- For facedir, this is where tile no. 5 point at.
+
+				-- The fallback vector here is in case 'facedir to dir' is nil due
+				-- to voxelmanip placing a wallmounted node without resetting a
+				-- pre-existing param2 value that is out-of-range for facedir.
+				-- The fallback vector corresponds to param2 = 0.
+				d = core.facedir_to_dir(n.param2) or vector.new(0, 0, 1)
+			elseif (def.paramtype2 == "4dir" or
+				def.paramtype2 == "color4dir") then
+				-- Similar to facedir handling
+				d = core.fourdir_to_dir(n.param2) or vector.new(0, 0, 1)
+			end
+		elseif def.paramtype2 == "wallmounted" or
+			def.paramtype2 == "colorwallmounted" then
+			-- Attach to whatever this node is "mounted to".
+			-- This where tile no. 2 points at.
+
+			-- The fallback vector here is used for the same reason as
+			-- for facedir nodes.
+			d = core.wallmounted_to_dir(n.param2) or vector.new(0, 1, 0)
+		else
+			d.y = -1
+		end
+		local p2 = vector.add(p, d)
+		local nn = core.get_node(p2).name
+		local def2 = core.registered_nodes[nn]
+		if def2 and not def2.walkable then
+			return false
+		end
+		return true
+	end
+
+	return function(itemstack, placer, pointed_thing, param2)
+		-------------------
+		-- MINETEST CODE --
+		-------------------
+		local def = itemstack:get_definition()
+		if def.type ~= "node" or pointed_thing.type ~= "node" then
+			return itemstack
+		end
+
+		local under = pointed_thing.under
+		local oldnode_under = minetest.get_node_or_nil(under)
+		local above = pointed_thing.above
+		local oldnode_above = minetest.get_node_or_nil(above)
+		local playername = user_name(placer)
+		local log = make_log(playername)
+
+		if not oldnode_under or not oldnode_above then
+			log("info", playername .. " tried to place"
+				.. " node in unloaded position " .. minetest.pos_to_string(above))
+			return itemstack
+		end
+
+		local olddef_under = minetest.registered_nodes[oldnode_under.name]
+		olddef_under = olddef_under or minetest.nodedef_default
+		local olddef_above = minetest.registered_nodes[oldnode_above.name]
+		olddef_above = olddef_above or minetest.nodedef_default
+
+		if not olddef_above.buildable_to and not olddef_under.buildable_to then
+			log("info", playername .. " tried to place"
+				.. " node in invalid position " .. minetest.pos_to_string(above)
+				.. ", replacing " .. oldnode_above.name)
+			return itemstack
+		end
+
+		---------------------
+		-- CUSTOMIZED CODE --
+		---------------------
+
+		-- Place above pointed node
+		local place_to = vector.copy(above)
+
+		-- If node under is buildable_to, check for callback result and place into it instead
+		if olddef_under.buildable_to and not func(oldnode_under.name) then
+			log("info", "node under is buildable to")
+			place_to = vector.copy(under)
+		end
+
+		-------------------
+		-- MINETEST CODE --
+		-------------------
+
+		if minetest.is_protected(place_to, playername) then
+			log("action", playername
+				.. " tried to place " .. def.name
+				.. " at protected position "
+				.. minetest.pos_to_string(place_to))
+			minetest.record_protection_violation(place_to, playername)
+			return itemstack
+		end
+
+		local oldnode = minetest.get_node(place_to)
+		local newnode = {name = def.name, param1 = 0, param2 = param2 or 0}
+
+		-- Calculate direction for wall mounted stuff like torches and signs
+		if def.place_param2 ~= nil then
+			newnode.param2 = def.place_param2
+		elseif (def.paramtype2 == "wallmounted" or
+			def.paramtype2 == "colorwallmounted") and not param2 then
+			local dir = vector.subtract(under, above)
+			newnode.param2 = minetest.dir_to_wallmounted(dir)
+			-- Calculate the direction for furnaces and chests and stuff
+		elseif (def.paramtype2 == "facedir" or
+			def.paramtype2 == "colorfacedir" or
+			def.paramtype2 == "4dir" or
+			def.paramtype2 == "color4dir") and not param2 then
+			local placer_pos = placer and placer:get_pos()
+			if placer_pos then
+				local dir = vector.subtract(above, placer_pos)
+				newnode.param2 = minetest.dir_to_facedir(dir)
+				log("info", "facedir: " .. newnode.param2)
+			end
+		end
+
+		local metatable = itemstack:get_meta():to_table().fields
+
+		-- Transfer color information
+		if metatable.palette_index and not def.place_param2 then
+			local color_divisor = nil
+			if def.paramtype2 == "color" then
+				color_divisor = 1
+			elseif def.paramtype2 == "colorwallmounted" then
+				color_divisor = 8
+			elseif def.paramtype2 == "colorfacedir" then
+				color_divisor = 32
+			elseif def.paramtype2 == "color4dir" then
+				color_divisor = 4
+			elseif def.paramtype2 == "colordegrotate" then
+				color_divisor = 32
+			end
+			if color_divisor then
+				local color = math.floor(metatable.palette_index / color_divisor)
+				local other = newnode.param2 % color_divisor
+				newnode.param2 = color * color_divisor + other
+			end
+		end
+
+		-- Check if the node is attached and if it can be placed there
+		local an = minetest.get_item_group(def.name, "attached_node")
+		if an ~= 0 and
+			not check_attached_node(place_to, newnode, an) then
+			log("action", "attached node " .. def.name ..
+				" cannot be placed at " .. minetest.pos_to_string(place_to))
+			return itemstack
+		end
+
+		log("action", playername .. " places node "
+			.. def.name .. " at " .. minetest.pos_to_string(place_to))
+
+		-- Add node and update
+		minetest.add_node(place_to, newnode)
+
+		-- Play sound if it was done by a player
+		if playername ~= "" and def.sounds and def.sounds.place then
+			minetest.sound_play(def.sounds.place, {
+				pos = place_to,
+				exclude_player = playername,
+			}, true)
+		end
+
+		local take_item = true
+
+		-- Run callback
+		if def.after_place_node then
+			-- Deepcopy place_to and pointed_thing because callback can modify it
+			local place_to_copy = vector.copy(place_to)
+			local pointed_thing_copy = copy_pointed_thing(pointed_thing)
+			if def.after_place_node(place_to_copy, placer, itemstack,
+				pointed_thing_copy) then
+				take_item = false
+			end
+		end
+
+		-- Run script hook
+		for _, callback in ipairs(minetest.registered_on_placenodes) do
+			-- Deepcopy pos, node and pointed_thing because callback can modify them
+			local place_to_copy = vector.copy(place_to)
+			local newnode_copy = {name = newnode.name, param1 = newnode.param1, param2 = newnode.param2}
+			local oldnode_copy = {name = oldnode.name, param1 = oldnode.param1, param2 = oldnode.param2}
+			local pointed_thing_copy = copy_pointed_thing(pointed_thing)
+			if callback(place_to_copy, newnode_copy, placer, oldnode_copy, itemstack, pointed_thing_copy) then
+				take_item = false
+			end
+		end
+
+		if take_item then
+			itemstack:take_item()
+		end
+		return itemstack
+	end
+end
+
+--[[Check for a protection violation in a given area.
+--
+-- Applies is_protected() to a 3D lattice of points in the defined volume. The points are spaced
+-- evenly throughout the volume and have a spacing similar to, but no larger than, "interval".
+--
+-- @param pos1          A position table of the area volume's first edge.
+-- @param pos2          A position table of the area volume's second edge.
+-- @param player        The player performing the action.
+-- @param interval	    Optional. Max spacing between checked points at the volume.
+--      Default: Same as minetest.is_area_protected.
+--
+-- @return	true on protection violation detection. false otherwise.
+--
+-- @notes   *All corners and edges of the defined volume are checked.
+]]
+function mcl_util.check_area_protection(pos1, pos2, player, interval)
+	local name = player and player:get_player_name() or ""
+
+	local protected_pos = minetest.is_area_protected(pos1, pos2, name, interval)
+	if protected_pos then
+		minetest.record_protection_violation(protected_pos, name)
+		return true
+	end
+
+	return false
+end
+
+--[[Check for a protection violation on a single position.
+--
+-- @param position      A position table to check for protection violation.
+-- @param player        The player performing the action.
+--
+-- @return	true on protection violation detection. false otherwise.
+]]
+function mcl_util.check_position_protection(position, player)
+	local name = player and player:get_player_name() or ""
+
+	if minetest.is_protected(position, name) then
+		minetest.record_protection_violation(position, name)
+		return true
+	end
+
+	return false
+end
+
+local palette_indexes = {grass_palette_index = 0, foliage_palette_index = 0, water_palette_index = 0}
+function mcl_util.get_palette_indexes_from_pos(pos)
+	local biome_data = minetest.get_biome_data(pos)
+	local biome = biome_data.biome
+	local biome_name = minetest.get_biome_name(biome)
+	local reg_biome = minetest.registered_biomes[biome_name]
+	if reg_biome and reg_biome._mcl_grass_palette_index and reg_biome._mcl_foliage_palette_index and reg_biome._mcl_water_palette_index then
+		local gpi = reg_biome._mcl_grass_palette_index
+		local fpi = reg_biome._mcl_foliage_palette_index
+		local wpi = reg_biome._mcl_water_palette_index
+		local palette_indexes = {grass_palette_index = gpi, foliage_palette_index = fpi, water_palette_index = wpi}
+		return palette_indexes
+	else
+		return palette_indexes
+	end
+end
+
+function mcl_util.get_colorwallmounted_rotation(pos)
+	local colorwallmounted_node = minetest.get_node(pos)
+	for i = 0, 32, 1 do
+		local colorwallmounted_rotation = colorwallmounted_node.param2 - (i * 8)
+		if colorwallmounted_rotation < 6 then
+			return colorwallmounted_rotation
+		end
+	end
+end

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

@@ -1,13 +1,13 @@
 # textdomain: mcl_boats
-Acacia Boat=Bateau en Acacia
+Acacia Boat=Bateau en acacia
-Birch Boat=Bateau en Bouleau
+Birch Boat=Bateau en bouleau
 Boat=Bateau
 Boats are used to travel on the surface of water.=Les bateaux sont utilisés pour voyager à la surface de l'eau.
-Dark Oak Boat=Bateau en Chêne Noir
+Dark Oak Boat=Bateau en chêne noir
-Jungle Boat=Bateau en Acajou
+Jungle Boat=Bateau en acajou
-Oak Boat=Bateau en Chêne
+Oak Boat=Bateau en chêne
 Rightclick on a water source to place the boat. Rightclick the boat to enter it. Use [Left] and [Right] to steer, [Forwards] to speed up and [Backwards] to slow down or move backwards. Use [Sneak] to leave the boat, punch the boat to make it drop as an item.=Faites un clic droit sur une source d'eau pour placer le bateau. Faites un clic droit sur le bateau pour y entrer. Utilisez [Gauche] et [Droite] pour diriger, [Avant] pour accélérer et [Arrière] pour ralentir ou reculer. Utilisez [Sneak] pour le quitter, frappez le bateau pour le faire tomber en tant qu'objet.
-Spruce Boat=Bateau en Sapin
+Spruce Boat=Bateau en sapin
 Water vehicle=Véhicule aquatique
 Sneak to dismount=Se baisser pour descendre
-Obsidian Boat=Bateau en Obsidienne
+Obsidian Boat=Bateau en obsidienne

mods/ENTITIES/mcl_burning/api.lua

@@ -153,6 +153,11 @@ function mcl_burning.extinguish(obj)
 end
 
 function mcl_burning.tick(obj, dtime, storage)
+	if not storage then
+		minetest.log("warning", "No storage for burning tick. Should not happen: " .. dump(obj))
+		return
+	end
+
 	if storage.burn_time then
 		storage.burn_time = storage.burn_time - dtime
 

mods/ENTITIES/mcl_item_entity/init.lua

@@ -252,10 +252,17 @@ function minetest.handle_node_drops(pos, drops, digger)
 	-- NOTE: This function override allows digger to be nil.
 	-- This means there is no digger. This is a special case which allows this function to be called
 	-- by hand. Creative Mode is intentionally ignored in this case.
-
+	if digger and digger:is_player() and minetest.is_creative_enabled(digger:get_player_name()) then
-	if (digger and digger:is_player() and minetest.is_creative_enabled(digger:get_player_name())) or doTileDrops == false then
+		local inv = digger:get_inventory()
+		if inv then
+			for _, item in ipairs(drops) do
+				if not inv:contains_item("main", item, true) then
+					inv:add_item("main", item)
+				end
+			end
+		end
 		return
-	end
+	elseif not doTileDrops then return end
 
 	-- Check if node will yield its useful drop by the digger's tool
 	local dug_node = minetest.get_node(pos)
@@ -263,9 +270,9 @@ function minetest.handle_node_drops(pos, drops, digger)
 	local tool
 	if digger then
 		tool = digger:get_wielded_item()
-		tooldef = minetest.registered_tools[tool:get_name()]
+		tooldef = minetest.registered_items[tool:get_name()]
 
-		if not mcl_autogroup.can_harvest(dug_node.name, tool:get_name()) then
+		if not mcl_autogroup.can_harvest(dug_node.name, tool:get_name(), digger) then
 			return
 		end
 	end

mods/ENTITIES/mcl_minecarts/init.lua

@@ -66,6 +66,7 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 		on_rightclick = on_rightclick,
 
 		_driver = nil, -- player who sits in and controls the minecart (only for minecart!)
+		_passenger = nil, -- for mobs
 		_punched = false, -- used to re-send _velocity and position
 		_velocity = {x=0, y=0, z=0}, -- only used on punch
 		_start_pos = nil, -- Used to calculate distance for “On A Rail” achievement
@@ -86,6 +87,7 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 		local data = minetest.deserialize(staticdata)
 		if type(data) == "table" then
 			self._railtype = data._railtype
+			self._passenger = data._passenger
 		end
 		self.object:set_armor_groups({immortal=1})
 
@@ -177,6 +179,8 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 
 	cart.on_activate_by_rail = on_activate_by_rail
 
+	local passenger_attach_position = vector.new(0, -1.75, 0)
+
 	function cart:on_step(dtime)
 		local ctrl, player = nil, nil
 		if self._driver then
@@ -212,6 +216,32 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 			end
 		end
 
+		-- Grab mob
+		if math.random(1,20) > 15 and not self._passenger then
+			if self.name == "mcl_minecarts:minecart" then
+				local mobsnear = minetest.get_objects_inside_radius(self.object:get_pos(), 1.3)
+				for n=1, #mobsnear do
+					local mob = mobsnear[n]
+					if mob then
+						local entity = mob:get_luaentity()
+						if entity and entity.is_mob then
+							self._passenger = entity
+							mob:set_attach(self.object, "", passenger_attach_position, vector.zero())
+							break
+						end
+					end
+				end
+			end
+		-- Make room in the minecart after the mob dies
+		elseif self._passenger then
+			if math.random(1,20) == 1 then
+				local dead = self._passenger:check_for_death()
+				if dead == true then
+					self._passenger = nil
+				end
+			end
+		end
+
 		-- Drop minecart if it isn't on a rail anymore
 		if self._last_float_check >= mcl_minecarts.check_float_time then
 			pos = self.object:get_pos()

mods/ENTITIES/mcl_minecarts/locale/mcl_minecarts.fr.tr

@@ -10,15 +10,15 @@ To obtain the minecart and TNT, punch them while holding down the sneak key. You
 A minecart with furnace is a vehicle that travels on rails. It can propel itself with fuel.=Une wagonnet avec un four est un véhicule qui se déplace sur rails. Il peut se propulser avec du carburant.
 Place it on rails. If you give it some coal, the furnace will start burning for a long time and the minecart will be able to move itself. Punch it to get it moving.=Placez-le sur des rails. Si vous lui donnez du charbon, le four commencera à brûler pendant longtemps et le wagonnet pourra se déplacer. Frappez-le pour le faire bouger.
 To obtain the minecart and furnace, punch them while holding down the sneak key.=Pour obtenir le wagonnet et le four, frappez-les tout en maintenant la touche furtive enfoncée.
-Minecart with Chest=Wagonnet avec Coffre
+Minecart with Chest=Wagonnet avec coffre
-Minecart with Furnace=Wagonnet avec Four
+Minecart with Furnace=Wagonnet avec four
-Minecart with Command Block=Wagonnet avec Bloc de Commande
+Minecart with Command Block=Wagonnet avec bloc de commande
-Minecart with Hopper=Wagonnet avec Entonoir
+Minecart with Hopper=Wagonnet avec entonnoir
 Minecart with TNT=Wagonnet avec TNT
 Place them on the ground to build your railway, the rails will automatically connect to each other and will turn into curves, T-junctions, crossings and slopes as needed.=Placez-les sur le sol pour construire votre chemin de fer, les rails se connecteront automatiquement les uns aux autres et se transformeront en courbes, en jonctions en T, en traversées et en pentes au besoin.
 Rail=Rail
 Rails can be used to build transport tracks for minecarts. Normal rails slightly slow down minecarts due to friction.=Les rails peuvent être utilisés pour construire des voies de transport pour les wagonnets. Les rails ralentissent légèrement les wagonnets en raison de la friction.
-Powered Rail=Rail allimenté
+Powered Rail=Rail alimenté
 Rails can be used to build transport tracks for minecarts. Powered rails are able to accelerate and brake minecarts.=Les rails peuvent être utilisés pour construire des voies de transport pour les wagonnets. Les rails motorisés sont capables d'accélérer et de freiner les wagonnets.
 Without redstone power, the rail will brake minecarts. To make this rail accelerate minecarts, power it with redstone power.=Sans énergie de redstone, le rail freinera les wagonnets. Pour que ce rail accélère les minecarts, alimentez-le avec une source d'énergie redstone.
 Activator Rail=Rail d'activation

mods/ENTITIES/mcl_minecarts/rails.lua

@@ -2,7 +2,7 @@ local S = minetest.get_translator(minetest.get_current_modname())
 
 -- Template rail function
 local function register_rail(itemstring, tiles, def_extras, creative)
-	local groups = {handy=1,pickaxey=1, attached_node=1,rail=1,connect_to_raillike=minetest.raillike_group("rail"),dig_by_water=1,destroy_by_lava_flow=1, transport=1}
+	local groups = {handy=1,pickaxey=1, attached_node=1,rail=1,connect_to_raillike=minetest.raillike_group("rail"),dig_by_water=0,destroy_by_lava_flow=0, transport=1}
 	if creative == false then
 		groups.not_in_creative_inventory = 1
 	end

mods/ENTITIES/mcl_mobs/api.lua

@@ -4,26 +4,27 @@ local math, vector, minetest, mcl_mobs = math, vector, minetest, mcl_mobs
 -- API for Mobs Redo: MineClone 2 Edition (MRM)
 
 local PATHFINDING = "gowp"
+local CRASH_WARN_FREQUENCY = 60
+local LIFETIMER_DISTANCE = 47
 
 -- Localize
 local S = minetest.get_translator("mcl_mobs")
 
-local LOGGING_ON = minetest.settings:get_bool("mcl_logging_mobs_villager",false)
+local DEVELOPMENT = minetest.settings:get_bool("mcl_development",false)
-local function mcl_log (message)
-	if LOGGING_ON then
-		mcl_util.mcl_log (message, "[Mobs]", true)
-	end
-end
 
 -- Invisibility mod check
 mcl_mobs.invis = {}
 
 local remove_far = true
-local mobs_griefing = minetest.settings:get_bool("mobs_griefing") ~= false
+
-local spawn_protected = minetest.settings:get_bool("mobs_spawn_protected") ~= false
 local mobs_debug = minetest.settings:get_bool("mobs_debug", false) -- Shows helpful debug info above each mob
 local spawn_logging = minetest.settings:get_bool("mcl_logging_mobs_spawn",true)
 
+local MAPGEN_LIMIT = mcl_vars.mapgen_limit
+local MAPGEN_MOB_LIMIT = MAPGEN_LIMIT - 90
+-- 30927 seems to be the edge of the world, so could be closer, but this is safer
+
+
 -- Peaceful mode message so players will know there are no monsters
 if minetest.settings:get_bool("only_peaceful_mobs", false) then
 	minetest.register_on_joinplayer(function(player)
@@ -32,15 +33,6 @@ if minetest.settings:get_bool("only_peaceful_mobs", false) then
 	end)
 end
 
-local node_ok = function(pos, fallback)
-	fallback = fallback or mcl_mobs.fallback_node
-	local node = minetest.get_node_or_nil(pos)
-	if node and minetest.registered_nodes[node.name] then
-		return node
-	end
-	return minetest.registered_nodes[fallback]
-end
-
 function mob_class:update_tag() --update nametag and/or the debug box
 	local tag
 	if mobs_debug then
@@ -69,6 +61,18 @@ function mob_class:update_tag() --update nametag and/or the debug box
 	})
 end
 
+function mob_class:jock_to(mob, reletive_pos, rot)
+	local pos = self.object:get_pos()
+	if not pos then return end
+
+	self.jockey = mob
+	local jock = minetest.add_entity(pos, mob)
+	if not jock then return end
+	jock:get_luaentity().docile_by_day = false
+	jock:get_luaentity().riden_by_jock = true
+	self.object:set_attach(jock, "", reletive_pos, rot)
+end
+
 function mob_class:get_staticdata()
 
 	for _,p in pairs(minetest.get_connected_players()) do
@@ -130,8 +134,8 @@ function mob_class:mob_activate(staticdata, def, dtime)
 		end
 	end
 
-	if not self.base_texture then
+	--If textures in definition change, reload textures
-
+	if not self.base_texture or (def.textures and table.indexof(def.textures, self.base_texture) == -1) then
 		-- compatiblity with old simple mobs textures
 		if type(def.textures[1]) == "string" then
 			def.textures = {def.textures}
@@ -262,6 +266,13 @@ function mob_class:mob_activate(staticdata, def, dtime)
 	self._current_animation = nil
 	self:set_animation( "stand")
 
+
+	if self.riden_by_jock then --- Keep this function before self.on_spawn() is run.
+		self.object:remove()
+		return
+	end
+
+
 	if self.on_spawn and not self.on_spawn_run then
 		if self.on_spawn(self) then
 			self.on_spawn_run = true
@@ -278,6 +289,9 @@ function mob_class:mob_activate(staticdata, def, dtime)
 		self._run_armor_init = true
 	end
 
+
+
+
 	if def.after_activate then
 		def.after_activate(self, staticdata, def, dtime)
 	end
@@ -306,13 +320,13 @@ function mob_class:do_states(dtime)
 end
 
 local function update_timers (self, dtime)
-	-- knockback timer
+	-- knockback timer. set in on_punch
 	if self.pause_timer > 0 then
 		self.pause_timer = self.pause_timer - dtime
 		return true
 	end
 
-	-- attack timer
+	-- attack timer. Not anymore, it seems. Used for also occassionally processing mob step too!
 	self.timer = self.timer + dtime
 
 	if self.state ~= "attack" and self.state ~= PATHFINDING then
@@ -328,88 +342,192 @@ local function update_timers (self, dtime)
 	end
 end
 
--- main mob function
+function mob_class:outside_limits()
-function mob_class:on_step(dtime)
+	local pos = self.object:get_pos()
-	self.lifetimer = self.lifetimer - dtime
+	if pos then
+		local posx = math.abs(pos.x)
+		local posy = math.abs(pos.y)
+		local posz = math.abs(pos.z)
+		if posx > MAPGEN_MOB_LIMIT or posy > MAPGEN_MOB_LIMIT or posz > MAPGEN_MOB_LIMIT then
+			--minetest.log("action", "Getting close to limits of worldgen: " .. minetest.pos_to_string(pos))
+			if posx > MAPGEN_LIMIT or posy > MAPGEN_LIMIT or posz > MAPGEN_LIMIT then
+				minetest.log("action", "Warning mob past limits of worldgen: " .. minetest.pos_to_string(pos))
+			else
+				if self.state ~= "stand" then
+					minetest.log("action", "Warning mob close to limits of worldgen: " .. minetest.pos_to_string(pos))
+					self.state = "stand"
+					self:set_animation("stand")
+					self.object:set_acceleration(vector.zero())
+					self.object:set_velocity(vector.zero())
+				end
+			end
+			return true
+		end
+	end
+end
 
+local function on_step_work (self, dtime)
 	local pos = self.object:get_pos()
 	if not pos then return end
 
-	if self:check_despawn(pos) then return true end
+	if self:check_despawn(pos, dtime) then return true end
+	if self:outside_limits() then return end
+
+	-- Start: Death/damage processing
+	-- All damage needs to be undertaken at the start. We need to exit processing if the mob dies.
+	if self:check_death_and_slow_mob() then
+		--minetest.log("action", "Mob is dying: ".. tostring(self.name))
+		-- Do we abandon out of here now?
+	end
 
-	self:slow_mob()
 	if self:falling(pos) then return end
 
-	self:check_suspend()
+	local player_in_active_range = self:player_in_active_range()
-	self:check_water_flow()
 
-	self:env_danger_movement_checks (dtime)
+	self:check_suspend(player_in_active_range)
 
 	if not self.fire_resistant then
 		mcl_burning.tick(self.object, dtime, self)
-		-- mcl_burning.tick may remove object immediately
+		if not self.object:get_pos() then return end -- mcl_burning.tick may remove object immediately
-		if not self.object:get_pos() then return end
-	end
 
-	if mobs_debug then self:update_tag() end
+		if self:check_for_death("fire", {type = "fire"}) then
-
+			return true
-	if self.state == "die" then return end
-
-	if self.jump_sound_cooloff > 0 then
-		self.jump_sound_cooloff = self.jump_sound_cooloff - dtime
-	end
-	if self.opinion_sound_cooloff > 0 then
-		self.opinion_sound_cooloff = self.opinion_sound_cooloff - dtime
-	end
-
-	--Mob following code.
-	self:follow_flop()
-	--set animation speed relitive to velocity
-	self:set_animation_speed()
-	self:check_smooth_rotation(dtime)
-	self:check_head_swivel(dtime)
-
-	self:do_jump()
-	self:set_armor_texture()
-	self:check_runaway_from()
-
-	self:monster_attack()
-	self:npc_attack()
-	self:check_breeding()
-	self:check_aggro(dtime)
-
-	-- run custom function (defined in mob lua file)
-	if self.do_custom then
-		if self.do_custom(self, dtime) == false then
-			return
 		end
 	end
 
-	if update_timers(self, dtime) then return end
+	if self:env_damage (dtime, pos) then return end
 
-	self:check_particlespawners(dtime)
+	if self.state == "die" then return end
-	self:check_item_pickup()
+	-- End: Death/damage processing
 
-	-- mob plays random sound at times. Should be 120. Zombie and mob farms are ridiculous
+	self:check_water_flow()
-	if math.random(1, 70) == 1 then
+	self:env_danger_movement_checks (dtime)
-		self:mob_sound("random", true)
+
+	-- Follow code is heavy and probably shouldn't run when not in range, but we need to extract the cancel follow stuff
+	self:check_follow()
+	self:flop()
+
+	self:check_smooth_rotation(dtime)
+
+	if player_in_active_range then
+		self:set_animation_speed() -- set animation speed relative to velocity
+
+		self:check_head_swivel(dtime)
+
+		if self.jump_sound_cooloff > 0 then self.jump_sound_cooloff = self.jump_sound_cooloff - dtime end
+		self:do_jump()
+
+		self:check_runaway_from()
+		self:monster_attack()
+		self:npc_attack()
+
+		self:check_herd(dtime)
 	end
 
-	if self:env_damage (dtime, pos) then return end
+	self:check_aggro(dtime)
-	if self:do_states(dtime) then return end
+
+	if self.do_custom and self.do_custom(self, dtime) == false then return end
+
+	-- In certain circumstances, we abandon processing of certain functionality
+	local skip_processing = false
+	if update_timers(self, dtime) then
+		skip_processing = true
+	end
+
+	if not skip_processing then
+		self:check_breeding()
+
+		if player_in_active_range then
+			self:check_item_pickup()
+			self:set_armor_texture()
+
+			if self.opinion_sound_cooloff > 0 then
+				self.opinion_sound_cooloff = self.opinion_sound_cooloff - dtime
+			end
+			-- mob plays random sound at times. Should be 120. Zombie and mob farms are ridiculous
+			if math.random(1, 70) == 1 then
+				self:mob_sound("random", true)
+			end
+		end
+
+		self:check_particlespawners(dtime)
+
+		if self:do_states(dtime) then return end
+	end
+
+	if mobs_debug then self:update_tag() end
 
 	if not self.object:get_luaentity() then
 		return false
 	end
 end
 
+local last_crash_warn_time = 0
+
+local function log_error (stack_trace, info, info2)
+	minetest.log("action", "--- Bug report start (please provide a few lines before this also for context) ---")
+	minetest.log("action", "Error: " .. stack_trace)
+	minetest.log("action", "Bug info: " .. info)
+	if info2 then
+		minetest.log("action", "Bug info additional: " .. info2)
+	end
+	minetest.log("action", "--- Bug report end ---")
+end
+
+local function warn_user_error ()
+	local current_time = os.time()
+	local time_since_warning = current_time - last_crash_warn_time
+
+	--minetest.log("previous_crash_time: " .. current_time)
+	--minetest.log("last_crash_time: " .. last_crash_warn_time)
+	--minetest.log("time_since_warning: " .. time_since_warning)
+
+	if time_since_warning > CRASH_WARN_FREQUENCY then
+		last_crash_warn_time = current_time
+		minetest.log("A game crashing bug was prevented. Please provide debug.log information to MineClone2 dev team for investigation. (Search for: --- Bug report start)")
+	end
+end
+
+local on_step_error_handler = function ()
+	warn_user_error ()
+	local info = debug.getinfo(1, "SnlufL")
+	log_error(tostring(debug.traceback()), dump(info))
+end
+
+
+
+-- main mob function
+function mob_class:on_step(dtime)
+	if not DEVELOPMENT then
+		-- Removed as bundled Lua (5.1 doesn't support xpcall)
+		--local status, retVal = xpcall(on_step_work, on_step_error_handler, self, dtime)
+		local status, retVal = pcall(on_step_work, self, dtime)
+		if status then
+			return retVal
+		else
+			warn_user_error ()
+			local pos = self.object:get_pos()
+			if pos then
+				local node = minetest.get_node(pos)
+				if node and node.name == "ignore" then
+					minetest.log("warning", "Pos is ignored: " .. dump(pos))
+				end
+			end
+			log_error (dump(retVal), dump(pos), dump(self))
+		end
+	else
+		return on_step_work (self, dtime)
+	end
+end
+
 local timer = 0
-minetest.register_globalstep(function(dtime)
+
+local function update_lifetimer(dtime)
 	timer = timer + dtime
 	if timer < 1 then return end
 	for _, player in pairs(minetest.get_connected_players()) do
 		local pos = player:get_pos()
-		for _, obj in pairs(minetest.get_objects_inside_radius(pos, 47)) do
+		for _, obj in pairs(minetest.get_objects_inside_radius(pos, LIFETIMER_DISTANCE)) do
 			local lua = obj:get_luaentity()
 			if lua and lua.is_mob then
 				lua.lifetimer = math.max(20, lua.lifetimer)
@@ -418,22 +536,125 @@ minetest.register_globalstep(function(dtime)
 		end
 	end
 	timer = 0
+end
+
+minetest.register_globalstep(function(dtime)
+	update_lifetimer(dtime)
 end)
 
-minetest.register_chatcommand("clearmobs",{
+
-	privs={maphack=true},
+minetest.register_chatcommand("clearmobs", {
-	params = "<all>|<nametagged>|<range>",
+	privs = { maphack = true },
-	description=S("Removes all spawned mobs except nametagged and tamed ones. all removes all mobs, nametagged only nametagged ones and with the range paramter all mobs in a distance of the current player are removed."),
+	params = "[all|monster|passive|<mob name> [<range>|nametagged|tamed]]",
-	func=function(n,param)
+	description = S("Removes specified mobs except nametagged and tamed ones. For the second parameter, use nametagged/tamed to select only nametagged/tamed mobs, or a range to specify a maximum distance from the player."),
-		local p = minetest.get_player_by_name(n)
+	func = function(player, param)
-		local num=tonumber(param)
+		local default = false
+		if not param or param == "" then
+			default = true
+			minetest.chat_send_player(player,
+					S("Default usage. Clearing hostile mobs. For more options please type: /help clearmobs"))
+		end
+		local mob, unsafe = param:match("^([%w]+)[ ]?([%w%d]*)$")
+
+		local all = false
+		local nametagged = false
+		local tamed = false
+
+		local mob_name, mob_type, range
+
+		-- Param 1 resolve
+		if mob and mob ~= "" then
+			if mob == "all" then
+				all = true
+			elseif mob == "passive" or mob == "monster" then
+				mob_type = mob
+			elseif mob then
+				mob_name = mob
+			end
+			--minetest.log ("mob: [" .. mob .. "]")
+		else
+			--minetest.log("No valid first param")
+			if default then
+				--minetest.log("Use default")
+				mob_type = "monster"
+			end
+			--return
+		end
+
+		-- Param 2 resolve
+		if unsafe and unsafe ~= "" then
+			--minetest.log ("unsafe: [" .. unsafe .. "]")
+			if unsafe == "nametagged" then
+				nametagged = true
+			elseif unsafe == "tamed" then
+				tamed = true
+			end
+
+			local num = tonumber(unsafe)
+			if num then range = num end
+		end
+
+		local p = minetest.get_player_by_name(player)
+
 		for _,o in pairs(minetest.luaentities) do
-			if o.is_mob then
+			if o and o.is_mob then
-				if  param == "all" or
+				local mob_match = false
-				( param == "nametagged" and o.nametag ) or
+
-				( param == "" and ( not o.nametag or o.nametag == "" ) and not o.tamed ) or
+				if all then
-				( num and num > 0 and vector.distance(p:get_pos(),o.object:get_pos()) <= num ) then
+					--minetest.log("Match - All mobs specified")
-					o.object:remove()
+					mob_match = true
+				elseif mob_type then
+
+					--minetest.log("Match - o.type: ".. tostring(o.type))
+					--minetest.log("mob_type: ".. tostring(mob_type))
+					if mob_type == "monster" and o.type == mob_type then
+						--minetest.log("Match - monster")
+						mob_match = true
+					elseif mob_type == "passive" and o.type ~= "monster" and o.type ~= "npc" then
+						--minetest.log("Match - passive")
+						mob_match = true
+					else
+						--minetest.log("No match for type.")
+					end
+
+				elseif mob_name and (o.name == mob_name or string.find(o.name, mob_name)) then
+					--minetest.log("Match - mob_name = ".. tostring(o.name))
+					mob_match = true
+				else
+					--minetest.log("No match - o.type = ".. tostring(o.type))
+					--minetest.log("No match - mob_name = ".. tostring(o.name))
+					--minetest.log("No match - mob_type = ".. tostring(mob_name))
+				end
+
+				if mob_match then
+					local in_range = true
+					if (not range or range <= 0 ) then
+						in_range = true
+					else
+						if ( vector.distance(p:get_pos(),o.object:get_pos()) <= range ) then
+							in_range = true
+						else
+							--minetest.log("Out of range")
+							in_range = false
+						end
+					end
+
+					--minetest.log("o.nametag: ".. tostring(o.nametag))
+
+					if nametagged then
+						if o.nametag then
+							--minetest.log("Namedtagged and it has a name tag. Kill it")
+							o.object:remove()
+						end
+					elseif tamed then
+						if o.tamed then
+							--minetest.log("Tamed. Kill it")
+							o.object:remove()
+						end
+					elseif in_range and (not o.nametag or o.nametag == "") and not o.tamed then
+						--minetest.log("No nametag or tamed. Kill it")
+						o.object:remove()
+					end
 				end
 			end
 		end

mods/ENTITIES/mcl_mobs/breeding.lua

@@ -2,8 +2,8 @@ local math, vector, minetest, mcl_mobs = math, vector, minetest, mcl_mobs
 local mob_class = mcl_mobs.mob_class
 
 local HORNY_TIME = 30
-local HORNY_AGAIN_TIME = 300
+local HORNY_AGAIN_TIME = 30 -- was 300 or 15*20
-local CHILD_GROW_TIME = 60*20
+local CHILD_GROW_TIME = 60
 
 local LOGGING_ON = minetest.settings:get_bool("mcl_logging_mobs_villager",false)
 
@@ -178,7 +178,7 @@ function mob_class:check_breeding()
 				-- jump when fully grown so as not to fall into ground
 				self.object:set_velocity({
 					x = 0,
-					y = self.jump_height*3,
+					y = self.jump_height,
 					z = 0
 				})
 			end
@@ -190,18 +190,16 @@ function mob_class:check_breeding()
 		end
 
 		return
-	end
+	else
+		-- horny animal can mate for HORNY_TIME seconds,
+		-- afterwards horny animal cannot mate again for HORNY_AGAIN_TIME seconds
+		if self.horny == true then
+			self.hornytimer = self.hornytimer + 1
 
-	-- horny animal can mate for HORNY_TIME seconds,
+			if self.hornytimer >= HORNY_TIME + HORNY_AGAIN_TIME then
-	-- afterwards horny animal cannot mate again for HORNY_AGAIN_TIME seconds
+				self.hornytimer = 0
-	if self.horny == true
+				self.horny = false
-	and self.hornytimer < HORNY_TIME + HORNY_AGAIN_TIME then
+			end
-
-		self.hornytimer = self.hornytimer + 1
-
-		if self.hornytimer >= HORNY_TIME + HORNY_AGAIN_TIME then
-			self.hornytimer = 0
-			self.horny = false
 		end
 	end
 

mods/ENTITIES/mcl_mobs/combat.lua

@@ -329,10 +329,7 @@ end
 
 -- find someone to attack
 function mob_class:monster_attack()
-	if not damage_enabled
+	if not damage_enabled or self.passive ~= false or self.state == "attack" or self:day_docile() then
-	or self.passive ~= false
-	or self.state == "attack"
-	or self:day_docile() then
 		return
 	end
 
@@ -341,9 +338,11 @@ function mob_class:monster_attack()
 	local player, obj, min_player
 	local type, name = "", ""
 	local min_dist = self.view_range + 1
-	local objs = minetest.get_objects_inside_radius(s, self.view_range)
+
 	local blacklist_attack = {}
 
+	local objs = minetest.get_objects_inside_radius(s, self.view_range)
+
 	for n = 1, #objs do
 		if not objs[n]:is_player() then
 			obj = objs[n]:get_luaentity()
@@ -359,32 +358,29 @@ function mob_class:monster_attack()
 	end
 
 	for n = 1, #objs do
-
-
 		if objs[n]:is_player() then
 			if mcl_mobs.invis[ objs[n]:get_player_name() ] or (not self:object_in_range(objs[n])) then
 				type = ""
 			elseif (self.type == "monster" or self._aggro) then
+				-- self.aggro made player be attacked by npc again if out of range then back in again
+				-- Does it serve a purpose other than that?
 				player = objs[n]
 				type = "player"
 				name = "player"
 			end
 		else
 			obj = objs[n]:get_luaentity()
-
 			if obj then
 				player = obj.object
 				type = obj.type
 				name = obj.name or ""
 			end
-
 		end
 
 		-- find specific mob to attack, failing that attack player/npc/animal
 		if specific_attack(self.specific_attack, name)
-		and (type == "player" or ( type == "npc" and self.attack_npcs )
+				and (type == "player" or ( type == "npc" and self.attack_npcs )
-			or (type == "animal" and self.attack_animals == true)) then
+				or (type == "animal" and self.attack_animals == true)) then
-
 			p = player:get_pos()
 			sp = s
 
@@ -400,10 +396,9 @@ function mob_class:monster_attack()
 					attacked_p = true
 				end
 			end
+
 			-- choose closest player to attack
-			if dist < min_dist
+			if dist < min_dist and not attacked_p and self:line_of_sight( sp, p, 2) == true then
-			and not attacked_p
-			and self:line_of_sight( sp, p, 2) == true then
 				min_dist = dist
 				min_player = player
 			end
@@ -434,11 +429,9 @@ function mob_class:npc_attack()
 	local objs = minetest.get_objects_inside_radius(s, self.view_range)
 
 	for n = 1, #objs do
-
 		obj = objs[n]:get_luaentity()
 
 		if obj and obj.type == "monster" then
-
 			p = obj.object:get_pos()
 			sp = s
 
@@ -448,8 +441,7 @@ function mob_class:npc_attack()
 			p.y = p.y + 1
 			sp.y = sp.y + 1
 
-			if dist < min_dist
+			if dist < min_dist and self:line_of_sight( sp, p, 2) == true then
-			and self:line_of_sight( sp, p, 2) == true then
 				min_dist = dist
 				min_player = obj.object
 			end
@@ -746,7 +738,7 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)
 
 	local name = hitter:get_player_name() or ""
 
-	-- attack puncher and call other mobs for help
+	-- attack puncher
 	if self.passive == false
 	and self.state ~= "flop"
 	and (self.child == false or self.type == "monster")
@@ -758,37 +750,37 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)
 			self:do_attack(hitter)
 			self._aggro= true
 		end
+	end
 
-		-- alert others to the attack
+	-- alert others to the attack
-		local objs = minetest.get_objects_inside_radius(hitter:get_pos(), self.view_range)
+	local objs = minetest.get_objects_inside_radius(hitter:get_pos(), self.view_range)
-		local obj = nil
+	local obj = nil
 
-		for n = 1, #objs do
+	for n = 1, #objs do
 
-			obj = objs[n]:get_luaentity()
+		obj = objs[n]:get_luaentity()
 
-			if obj then
+		if obj then
-				-- only alert members of same mob or friends
+			-- only alert members of same mob or friends
-				if obj.group_attack
+			if obj.group_attack
-				and obj.state ~= "attack"
+			and obj.state ~= "attack"
-				and obj.owner ~= name then
+			and obj.owner ~= name then
-					if obj.name == self.name then
+				if obj.name == self.name then
-						obj:do_attack(hitter)
+					obj:do_attack(hitter)
-					elseif type(obj.group_attack) == "table" then
+				elseif type(obj.group_attack) == "table" then
-						for i=1, #obj.group_attack do
+					for i=1, #obj.group_attack do
-							if obj.name == obj.group_attack[i] then
+						if obj.group_attack[i] == self.name then
-								obj._aggro = true
+							obj._aggro = true
-								obj:do_attack(hitter)
+							obj:do_attack(hitter)
-								break
+							break
-							end
 						end
 					end
 				end
+			end
 
-				-- have owned mobs attack player threat
+			-- have owned mobs attack player threat
-				if obj.owner == name and obj.owner_loyal then
+			if obj.owner == name and obj.owner_loyal then
-					obj:do_attack(self.object)
+				obj:do_attack(self.object)
-				end
 			end
 		end
 	end
@@ -796,12 +788,23 @@ end
 
 function mob_class:check_aggro(dtime)
 	if not self._aggro or not self.attack then return end
-	if not self._check_aggro_timer or self._check_aggro_timer > 5 then
+
+	if not self._check_aggro_timer then
 		self._check_aggro_timer = 0
-		if not self.attack:get_pos() or vector.distance(self.attack:get_pos(),self.object:get_pos()) > 128 then
+	end
-			self._aggro = nil
+
-			self.attack = nil
+	if self._check_aggro_timer > 5 then
-			self.state = "stand"
+		self._check_aggro_timer = 0
+
+		if self.attack then
+			-- TODO consider removing this in favour of what is done in do_states_attack
+			-- Attack is dropped in do_states_attack if out of range, so won't even trigger here
+			-- I do not think this code does anything. Are mobs still loaded in at 128?
+			if not self.attack:get_pos() or vector.distance(self.attack:get_pos(),self.object:get_pos()) > 128 then
+				self._aggro = nil
+				self.attack = nil
+				self.state = "stand"
+			end
 		end
 	end
 	self._check_aggro_timer = self._check_aggro_timer + dtime
@@ -823,7 +826,10 @@ function mob_class:do_states_attack (dtime)
 		self.state = "stand"
 		self:set_velocity( 0)
 		self:set_animation( "stand")
+
 		self.attack = nil
+		self._aggro = nil
+
 		self.v_start = false
 		self.timer = 0
 		self.blinktimer = 0

mods/ENTITIES/mcl_mobs/effects.lua

@@ -1,4 +1,4 @@
-local math, vector, minetest, mcl_mobs = math, vector, minetest, mcl_mobs
+local math, tonumber, vector, minetest, mcl_mobs = math, tonumber, vector, minetest, mcl_mobs
 local mob_class = mcl_mobs.mob_class
 local active_particlespawners = {}
 local disable_blood = minetest.settings:get_bool("mobs_disable_blood")
@@ -8,6 +8,15 @@ local player_transfer_distance = tonumber(minetest.settings:get("player_transfer
 if player_transfer_distance == 0 then player_transfer_distance = math.huge end
 
 
+local function validate_vector (vect)
+	if vect then
+		if tonumber(vect.x) and tonumber(vect.y) and tonumber(vect.z) then
+			return true
+		end
+	end
+	return false
+end
+
 -- custom particle effects
 function mcl_mobs.effect(pos, amount, texture, min_size, max_size, radius, gravity, glow, go_down)
 
@@ -232,13 +241,17 @@ function mob_class:set_animation(anim, fixed_frame)
 	if not self.animation or not anim then
 		return
 	end
+
+	if self.jockey and self.object:get_attach() then
+		anim = "jockey"
+	elseif not self.object:get_attach() then
+		self.jockey = nil
+	end
+	
 	if self.state == "die" and anim ~= "die" and anim ~= "stand" then
 		return
 	end
 
-	if self.jockey then
-		anim = "jockey"
-	end
 
 
 	if self:flight_check() and self.fly and anim == "walk" then anim = "fly" end
@@ -280,30 +293,63 @@ local function dir_to_pitch(dir)
 	return -math.atan2(-dir.y, xz)
 end
 
-function mob_class:check_head_swivel(dtime)
+local function who_are_you_looking_at (self)
-	if not self.head_swivel or type(self.head_swivel) ~= "string" then return end
-	local final_rotation = vector.new(0,0,0)
-	local oldp,oldr = self.object:get_bone_position(self.head_swivel)
-
 	local pos = self.object:get_pos()
 
-	for _, obj in pairs(minetest.get_objects_inside_radius(pos, 10)) do
+	local stop_look_at_player_chance = math.random(833/self.curiosity)
-		if obj:is_player() and not self.attack or obj:get_luaentity() and obj:get_luaentity().name == self.name and self ~= obj:get_luaentity() then
+	-- was 10000 - div by 12 for avg entities as outside loop
-			if not self._locked_object then
+
-				if math.random(5000/self.curiosity) == 1 or vector.distance(pos,obj:get_pos())<4 and obj:is_player() then
+	local stop_look_at_player = stop_look_at_player_chance == 1
-					self._locked_object = obj
-				end
-			else
-				if math.random(10000/self.curiosity) == 1 then
-					self._locked_object = nil
-				end
-			end
-		end
-	end
 
 	if self.attack or self.following then
 		self._locked_object = self.attack or self.following
+	elseif self._locked_object then
+		if stop_look_at_player then
+			--minetest.log("Stop look: ".. self.name)
+			self._locked_object = nil
+		end
+	elseif not self._locked_object then
+		if math.random(1, 30) then
+			--minetest.log("Change look check: ".. self.name)
+
+			-- For the wither this was 20/60=0.33, so probably need to rebalance and divide rates.
+			-- but frequency of check isn't good as it is costly. Making others too infrequent requires testing
+			local chance = 20/self.curiosity
+
+			if chance < 1 then chance = 1 end
+			local look_at_player_chance = math.random(chance)
+
+			-- was 5000 but called in loop based on entities. so div by 12 as estimate avg of entities found,
+			-- then div by 20 as less freq lookup
+
+			local look_at_player = look_at_player_chance == 1
+
+			for _, obj in pairs(minetest.get_objects_inside_radius(pos, 8)) do
+				if obj:is_player() and vector.distance(pos,obj:get_pos()) < 4 then
+					--minetest.log("Change look to player: ".. self.name)
+					self._locked_object = obj
+					break
+				elseif obj:is_player() or (obj:get_luaentity() and obj:get_luaentity().name == self.name and self ~= obj:get_luaentity()) then
+					if look_at_player then
+						--minetest.log("Change look to mob: ".. self.name)
+						self._locked_object = obj
+						break
+					end
+				end
+			end
+		end
+
 	end
+end
+
+function mob_class:check_head_swivel(dtime)
+	if not self.head_swivel or type(self.head_swivel) ~= "string" then return end
+
+
+	who_are_you_looking_at (self)
+
+	local final_rotation = vector.new(0,0,0)
+	local oldp,oldr = self.object:get_bone_position(self.head_swivel)
 
 	if self._locked_object and (self._locked_object:is_player() or self._locked_object:get_luaentity()) and self._locked_object:get_hp() > 0 then
 		local _locked_object_eye_height = 1.5
@@ -318,40 +364,41 @@ function mob_class:check_head_swivel(dtime)
 			if self.object:get_attach() then
 				self_rot = self.object:get_attach():get_rotation()
 			end
-			if self.rot then
-				local player_pos = self._locked_object:get_pos()
-				local direction_player = vector.direction(vector.add(self.object:get_pos(), vector.new(0, self.head_eye_height*.7, 0)), vector.add(player_pos, vector.new(0, _locked_object_eye_height, 0)))
-				local mob_yaw = math.deg(-(-(self_rot.y)-(-minetest.dir_to_yaw(direction_player))))+self.head_yaw_offset
-				local mob_pitch = math.deg(-dir_to_pitch(direction_player))*self.head_pitch_multiplier
 
-				if (mob_yaw < -60 or mob_yaw > 60) and not (self.attack and self.state == "attack" and not self.runaway) then
+			local player_pos = self._locked_object:get_pos()
-					final_rotation = vector.multiply(oldr, 0.9)
+			local direction_player = vector.direction(vector.add(self.object:get_pos(), vector.new(0, self.head_eye_height*.7, 0)), vector.add(player_pos, vector.new(0, _locked_object_eye_height, 0)))
-				elseif self.attack and self.state == "attack" and not self.runaway then
+			local mob_yaw = math.deg(-(-(self_rot.y)-(-minetest.dir_to_yaw(direction_player))))+self.head_yaw_offset
-					if self.head_yaw == "y" then
+			local mob_pitch = math.deg(-dir_to_pitch(direction_player))*self.head_pitch_multiplier
-						final_rotation = vector.new(mob_pitch, mob_yaw, 0)
-					elseif self.head_yaw == "z" then
-						final_rotation = vector.new(mob_pitch, 0, -mob_yaw)
-					end
 
-				else
+			if (mob_yaw < -60 or mob_yaw > 60) and not (self.attack and self.state == "attack" and not self.runaway) then
+				final_rotation = vector.multiply(oldr, 0.9)
+			elseif self.attack and self.state == "attack" and not self.runaway then
+				if self.head_yaw == "y" then
+					final_rotation = vector.new(mob_pitch, mob_yaw, 0)
+				elseif self.head_yaw == "z" then
+					final_rotation = vector.new(mob_pitch, 0, -mob_yaw)
+				end
 
-					if self.head_yaw == "y" then
+			else
-						final_rotation = vector.new(((mob_pitch-oldr.x)*.3)+oldr.x, ((mob_yaw-oldr.y)*.3)+oldr.y, 0)
+
-					elseif self.head_yaw == "z" then
+				if self.head_yaw == "y" then
-						final_rotation = vector.new(((mob_pitch-oldr.x)*.3)+oldr.x, 0, -(((mob_yaw-oldr.y)*.3)+oldr.y)*3)
+					final_rotation = vector.new(((mob_pitch-oldr.x)*.3)+oldr.x, ((mob_yaw-oldr.y)*.3)+oldr.y, 0)
-					end
+				elseif self.head_yaw == "z" then
+					final_rotation = vector.new(((mob_pitch-oldr.x)*.3)+oldr.x, 0, -(((mob_yaw-oldr.y)*.3)+oldr.y)*3)
 				end
 			end
 		end
 	elseif not self._locked_object and math.abs(oldr.y) > 3 and math.abs(oldr.x) < 3 then
 		final_rotation = vector.multiply(oldr, 0.9)
 	else
-		final_rotation = vector.new(0,0,0)
+		--final_rotation = vector.new(0,0,0)
 	end
 
 	mcl_util.set_bone_position(self.object,self.head_swivel, vector.new(0,self.bone_eye_height,self.horrizonatal_head_height), final_rotation)
 end
 
+
+
 function mob_class:set_animation_speed()
 	local v = self.object:get_velocity()
 	if v then
@@ -367,7 +414,7 @@ function mob_class:set_animation_speed()
 			end
 		end
 		--set_speed
-		if self.acc then
+		if validate_vector(self.acc) then
 			self.object:add_velocity(self.acc)
 		end
 	end

mods/ENTITIES/mcl_mobs/init.lua

@@ -497,12 +497,11 @@ function mcl_mobs.register_egg(mob, desc, background_color, overlay_color, addeg
 				return def.on_rightclick(pointed_thing.under, under, placer, itemstack)
 			end
 
-			if pos
+			if pos and within_limits(pos, 0)  and not minetest.is_protected(pos, placer:get_player_name()) then
-			and within_limits(pos, 0)
-			and not minetest.is_protected(pos, placer:get_player_name()) then
-
 				local name = placer:get_player_name()
 				local privs = minetest.get_player_privs(name)
+
+
 				if under.name == "mcl_mobspawners:spawner" then
 					if minetest.is_protected(pointed_thing.under, name) then
 						minetest.record_protection_violation(pointed_thing.under, name)
@@ -512,7 +511,14 @@ function mcl_mobs.register_egg(mob, desc, background_color, overlay_color, addeg
 						minetest.chat_send_player(name, S("You need the “maphack” privilege to change the mob spawner."))
 						return itemstack
 					end
-					mcl_mobspawners.setup_spawner(pointed_thing.under, itemstack:get_name())
+
+					local dim = mcl_worlds.pos_to_dimension(placer:get_pos())
+					local mob_light_lvl = {mcl_mobs:mob_light_lvl(itemstack:get_name(),dim)}
+
+					--minetest.log("min light: " .. mob_light_lvl[1])
+					--minetest.log("max light: " .. mob_light_lvl[2])
+
+					mcl_mobspawners.setup_spawner(pointed_thing.under, itemstack:get_name(), mob_light_lvl[1], mob_light_lvl[2])
 					if not minetest.is_creative_enabled(name) then
 						itemstack:take_item()
 					end

mods/ENTITIES/mcl_mobs/locale/template.txt

@@ -9,3 +9,5 @@ Before you use the name tag, you need to set a name at an anvil. Then you can us
 Only peaceful mobs allowed!=
 Give names to mobs=
 Set name at anvil=
+Removes specified mobs except nametagged and tamed ones. For the second parameter, use nametagged/tamed to select only nametagged/tamed mobs, or a range to specify a maximum distance from the player.=
+Default usage. Clearing hostile mobs. For more options please type: /help clearmobs=

mods/ENTITIES/mcl_mobs/mod.conf

@@ -2,4 +2,4 @@ name = mcl_mobs
 author = PilzAdam
 description = Adds a mob API for mods to add animals or monsters, etc.
 depends = mcl_particles
-optional_depends = mcl_weather, mcl_explosions, mcl_hunger, mcl_worlds, invisibility, lucky_block, cmi, doc_identifier, mcl_armor, mcl_portals, mcl_experience
+optional_depends = mcl_weather, mcl_explosions, mcl_hunger, mcl_worlds, invisibility, lucky_block, cmi, doc_identifier, mcl_armor, mcl_portals, mcl_experience, mcl_sculk

mods/ENTITIES/mcl_mobs/movement.lua

@@ -3,10 +3,7 @@ local mob_class = mcl_mobs.mob_class
 local DEFAULT_FALL_SPEED = -9.81*1.5
 local FLOP_HEIGHT = 6
 local FLOP_HOR_SPEED = 1.5
-local PATHFINDING = "gowp"
 
-local node_ice = "mcl_core:ice"
-local node_snowblock = "mcl_core:snowblock"
 local node_snow = "mcl_core:snow"
 
 
@@ -21,14 +18,19 @@ local function atan(x)
 	end
 end
 
+local registered_fallback_node = minetest.registered_nodes[mcl_mobs.fallback_node]
+
 -- get node but use fallback for nil or unknown
 local node_ok = function(pos, fallback)
-	fallback = fallback or mcl_mobs.fallback_node
 	local node = minetest.get_node_or_nil(pos)
 	if node and minetest.registered_nodes[node.name] then
 		return node
 	end
-	return minetest.registered_nodes[fallback]
+	if fallback then
+		return minetest.registered_nodes[fallback]
+	else
+		return registered_fallback_node
+	end
 end
 
 -- Returns true is node can deal damage to self
@@ -200,14 +202,19 @@ function mob_class:can_jump_cliff()
 end
 
 -- is mob facing a cliff or danger
-function mob_class:is_at_cliff_or_danger()
+function mob_class:is_at_cliff_or_danger(can_jump_cliff)
-	if self.fear_height == 0 or self:can_jump_cliff() or self._jumping_cliff or not self.object:get_luaentity() then -- 0 for no falling protection!
+	if can_jump_cliff == nil then
+		can_jump_cliff = self:can_jump_cliff()
+	end
+
+	if self.fear_height == 0 or can_jump_cliff or self._jumping_cliff or not self.object:get_luaentity() then -- 0 for no falling protection!
 		return false
 	end
 
 	local yaw = self.object:get_yaw()
 	local dir_x = -math.sin(yaw) * (self.collisionbox[4] + 0.5)
 	local dir_z = math.cos(yaw) * (self.collisionbox[4] + 0.5)
+
 	local pos = self.object:get_pos()
 	local ypos = pos.y + self.collisionbox[2] -- just above floor
 
@@ -234,14 +241,24 @@ end
 
 
 -- copy the 'mob facing cliff_or_danger check' from above, and rework to avoid water
-function mob_class:is_at_water_danger()
+function mob_class:is_at_water_danger(can_jump_cliff)
-	if not self.object:get_luaentity() or self:can_jump_cliff() or self._jumping_cliff then
+	if can_jump_cliff == nil then
+		can_jump_cliff = self:can_jump_cliff()
+	end
+
+	if not self.object:get_luaentity() or can_jump_cliff or self._jumping_cliff then
 		return false
 	end
 	local yaw = self.object:get_yaw()
+	local pos = self.object:get_pos()
+
+	if not yaw or not pos then
+		return
+	end
+
 	local dir_x = -math.sin(yaw) * (self.collisionbox[4] + 0.5)
 	local dir_z = math.cos(yaw) * (self.collisionbox[4] + 0.5)
-	local pos = self.object:get_pos()
+
 	local ypos = pos.y + self.collisionbox[2] -- just above floor
 
 	local free_fall, blocker = minetest.line_of_sight(
@@ -270,7 +287,9 @@ end
 
 function mob_class:env_danger_movement_checks(dtime)
 	local yaw = 0
-	if self:is_at_water_danger() and self.state ~= "attack" then
+
+	local can_jump_cliff = self:can_jump_cliff()
+	if self.state ~= "attack" and self:is_at_water_danger(can_jump_cliff) then
 		if math.random(1, 10) <= 6 then
 			self:set_velocity(0)
 			self.state = "stand"
@@ -278,13 +297,9 @@ function mob_class:env_danger_movement_checks(dtime)
 			yaw = yaw + math.random(-0.5, 0.5)
 			yaw = self:set_yaw( yaw, 8)
 		end
-	else
-		if self.move_in_group ~= false then
-			self:check_herd(dtime)
-		end
 	end
 
-	if self:is_at_cliff_or_danger() then
+	if self:is_at_cliff_or_danger(can_jump_cliff) then
 		self:set_velocity(0)
 		self.state = "stand"
 		self:set_animation( "stand")
@@ -453,7 +468,7 @@ end
 
 
 -- find and replace what mob is looking for (grass, wheat etc.)
-function mob_class:replace(pos)
+function mob_class:replace_node(pos)
 
 	if not self.replace_rate
 	or not self.replace_what
@@ -607,75 +622,51 @@ end
 
 
 -- follow player if owner or holding item, if fish outta water then flop
-function mob_class:follow_flop()
+function mob_class:check_follow()
-
 	-- find player to follow
-	if (self.follow ~= ""
+	if (self.follow ~= "" or self.order == "follow") and not self.following
-	or self.order == "follow")
-	and not self.following
 	and self.state ~= "attack"
 	and self.order ~= "sit"
 	and self.state ~= "runaway" then
-
 		local s = self.object:get_pos()
 		local players = minetest.get_connected_players()
-
 		for n = 1, #players do
-
+			if (self:object_in_range(players[n])) and not mcl_mobs.invis[ players[n]:get_player_name() ] then
-			if (self:object_in_range(players[n]))
-			and not mcl_mobs.invis[ players[n]:get_player_name() ] then
-
 				self.following = players[n]
-
 				break
 			end
 		end
 	end
 
-	if self.type == "npc"
+	if self.type == "npc" and self.order == "follow"
-	and self.order == "follow"
+			and self.state ~= "attack" and self.order ~= "sit" and self.owner ~= "" then
-	and self.state ~= "attack"
-	and self.order ~= "sit"
-	and self.owner ~= "" then
 
-		-- npc stop following player if not owner
+		if self.following and self.owner and self.owner ~= self.following:get_player_name() then
-		if self.following
-		and self.owner
-		and self.owner ~= self.following:get_player_name() then
 			self.following = nil
 		end
 	else
 		-- stop following player if not holding specific item,
 		-- mob is horny, fleeing or attacking
-		if self.following
+		if self.following and self.following:is_player()
-		and self.following:is_player()
+				and (self:follow_holding(self.following) == false or self.horny or self.state == "runaway") then
-		and (self:follow_holding(self.following) == false or
-		self.horny or self.state == "runaway") then
 			self.following = nil
 		end
-
 	end
 
 	-- follow that thing
 	if self.following then
-
 		local s = self.object:get_pos()
+
 		local p
-
 		if self.following:is_player() then
-
 			p = self.following:get_pos()
-
 		elseif self.following.object then
-
 			p = self.following.object:get_pos()
 		end
 
 		if p then
-
 			local dist = vector.distance(p, s)
 
-			-- dont follow if out of range
 			if (not self:object_in_range(self.following)) then
 				self.following = nil
 			else
@@ -685,17 +676,12 @@ function mob_class:follow_flop()
 				}
 
 				local yaw = (atan(vec.z / vec.x) +math.pi/ 2) - self.rotate
-
 				if p.x > s.x then yaw = yaw +math.pi end
-
 				self:set_yaw( yaw, 2.35)
 
 				-- anyone but standing npc's can move along
-				if dist > 3
+				if dist > 3 and self.order ~= "stand" then
-				and self.order ~= "stand" then
-
  					self:set_velocity(self.follow_velocity)
-
 					if self.walk_chance ~= 0 then
 						self:set_animation( "run")
 					end
@@ -703,17 +689,18 @@ function mob_class:follow_flop()
 					self:set_velocity(0)
 					self:set_animation( "stand")
 				end
-
 				return
 			end
 		end
 	end
+end
 
+function mob_class:flop()
 	-- swimmers flop when out of their element, and swim again when back in
 	if self.fly then
 		local s = self.object:get_pos()
-		if self:flight_check( s) == false then
 
+		if self:flight_check(s) == false then
 			self.state = "flop"
 			self.object:set_acceleration({x = 0, y = DEFAULT_FALL_SPEED, z = 0})
 
@@ -732,7 +719,6 @@ function mob_class:follow_flop()
 			end
 
 			self:set_animation( "stand", true)
-
 			return
 		elseif self.state == "flop" then
 			self.state = "stand"
@@ -763,7 +749,10 @@ end
 local check_herd_timer = 0
 function mob_class:check_herd(dtime)
 	local pos = self.object:get_pos()
-	if not pos then return end
+	if not pos or self.state == "attack" then return end
+	-- Does any mob not move in group. Weird check for something not set?
+	if self.move_in_group == false then return end
+
 	check_herd_timer = check_herd_timer + dtime
 	if check_herd_timer < 4 then return end
 	check_herd_timer = 0

mods/ENTITIES/mcl_mobs/pathfinding.lua

@@ -3,6 +3,9 @@ local mob_class = mcl_mobs.mob_class
 
 local PATHFINDING_FAIL_THRESHOLD = 100 -- no. of ticks to fail before giving up. 20p/s. 5s helps them get through door
 local PATHFINDING_FAIL_WAIT = 30 -- how long to wait before trying to path again
+local PATHING_START_DELAY = 4 -- When doing non-prioritised pathing, how long to wait until last mob pathed
+
+local PATHFINDING_SEARCH_DISTANCE = 50 -- How big the square is that pathfinding will look
 
 local PATHFINDING = "gowp"
 
@@ -107,14 +110,20 @@ local function generate_enriched_path(wp_in, door_open_pos, door_close_pos, cur_
 	return wp_out
 end
 
-function mob_class:ready_to_path()
+local last_pathing_time = os.time()
+
+function mob_class:ready_to_path(prioritised)
 	mcl_log("Check ready to path")
 	if self._pf_last_failed and (os.time() - self._pf_last_failed) < PATHFINDING_FAIL_WAIT then
 		mcl_log("Not ready to path as last fail is less than threshold: " .. (os.time() - self._pf_last_failed))
 		return false
 	else
-		mcl_log("We are ready to pathfind, no previous fail or we are past threshold")
+		local time_since_path_start = os.time() - last_pathing_time
-		return true
+		mcl_log("time_since_path_start: " .. tostring(time_since_path_start))
+		if prioritised or (time_since_path_start) > PATHING_START_DELAY then
+			mcl_log("We are ready to pathfind, no previous fail or we are past threshold")
+			return true
+		end
 	end
 end
 
@@ -144,7 +153,7 @@ local function calculate_path_through_door (p, cur_door_pos, t)
 			if n.name == "air" then
 				mcl_log("We have air space next to door at: " .. minetest.pos_to_string(pos_closest_to_door))
 
-				prospective_wp = minetest.find_path(p,pos_closest_to_door,150,1,4)
+				prospective_wp = minetest.find_path(p, pos_closest_to_door, PATHFINDING_SEARCH_DISTANCE, 1, 4)
 
 				if prospective_wp then
 					mcl_log("Found a path to next to door".. minetest.pos_to_string(pos_closest_to_door))
@@ -154,7 +163,7 @@ local function calculate_path_through_door (p, cur_door_pos, t)
 
 					if t then
 						mcl_log("We have t, lets go from door to target")
-						local wp_otherside_door_to_target = minetest.find_path(other_side_of_door,t,150,1,4)
+						local wp_otherside_door_to_target = minetest.find_path(other_side_of_door, t, PATHFINDING_SEARCH_DISTANCE, 1, 4)
 
 						if wp_otherside_door_to_target and #wp_otherside_door_to_target > 0 then
 							append_paths (prospective_wp, wp_otherside_door_to_target)
@@ -190,9 +199,13 @@ local function calculate_path_through_door (p, cur_door_pos, t)
 	return enriched_path
 end
 
-function mob_class:gopath(target,callback_arrived)
+
+
+function mob_class:gopath(target, callback_arrived, prioritised)
 	if self.state == PATHFINDING then mcl_log("Already pathfinding, don't set another until done.") return end
-	if not self:ready_to_path() then return end
+	if not self:ready_to_path(prioritised) then return end
+
+	last_pathing_time = os.time()
 
 	self.order = nil
 
@@ -200,7 +213,7 @@ function mob_class:gopath(target,callback_arrived)
 	local t = vector.offset(target,0,1,0)
 
 	--Check direct route
-	local wp = minetest.find_path(p,t,150,1,4)
+	local wp = minetest.find_path(p, t, PATHFINDING_SEARCH_DISTANCE, 1, 4)
 
 	if not wp then
 		mcl_log("### No direct path. Path through door closest to target.")
@@ -410,7 +423,7 @@ function mob_class:check_gowp(dtime)
 			mcl_log("No current target")
 		end
 
-		local final_wp = minetest.find_path(p,self._target,150,1,4)
+		local final_wp = minetest.find_path(p, self._target, PATHFINDING_SEARCH_DISTANCE, 1, 4)
 		if final_wp then
 			mcl_log("We can get to target here.")
 		--	self.waypoints = final_wp

mods/ENTITIES/mcl_mobs/physics.lua

@@ -47,7 +47,8 @@ end
 
 function mob_class:player_in_active_range()
 	for _,p in pairs(minetest.get_connected_players()) do
-		if vector.distance(self.object:get_pos(),p:get_pos()) <= mob_active_range then return true end
+		local pos = self.object:get_pos()
+		if pos and vector.distance(pos, p:get_pos()) <= mob_active_range then return true end
 		-- slightly larger than the mc 32 since mobs spawn on that circle and easily stand still immediately right after spawning.
 	end
 end
@@ -182,15 +183,17 @@ function mob_class:collision()
 	return({x,z})
 end
 
-function mob_class:slow_mob()
+function mob_class:check_death_and_slow_mob()
 	local d = 0.85
-	if self:check_dying() then d = 0.92 end
+	local dying = self:check_dying()
+	if dying then d = 0.92 end
 
 	local v = self.object:get_velocity()
 	if v then
 		--diffuse object velocity
 		self.object:set_velocity({x = v.x*d, y = v.y, z = v.z*d})
 	end
+	return dying
 end
 
 -- move mob in facing direction
@@ -308,6 +311,8 @@ end
 function mob_class:set_yaw(yaw, delay, dtime)
 	if self.noyaw then return end
 
+	if not self.object:get_yaw() or not self.object:get_pos() then return end
+
 	if self.state ~= PATHFINDING then
 		self._turn_to = yaw
 	end
@@ -459,6 +464,14 @@ function mob_class:check_for_death(cause, cmi_cause)
 	self:mob_sound("death")
 
 	local function death_handle(self)
+		if cmi_cause and cmi_cause["type"] then
+			--minetest.log("cmi_cause: " .. tostring(cmi_cause["type"]))
+		end
+		--minetest.log("cause: " .. tostring(cause))
+
+		-- TODO other env damage shouldn't drop xp
+		-- "rain", "water", "drowning", "suffocation"
+
 		-- dropped cooked item if mob died in fire or lava
 		if cause == "lava" or cause == "fire" then
 			self:item_drop(true, 0)
@@ -475,9 +488,21 @@ function mob_class:check_for_death(cause, cmi_cause)
 			self:item_drop(cooked, looting)
 
 			if ((not self.child) or self.type ~= "animal") and (minetest.get_us_time() - self.xp_timestamp <= math.huge) then
-				mcl_experience.throw_xp(self.object:get_pos(), math.random(self.xp_min, self.xp_max))
+				local pos = self.object:get_pos()
+				local xp_amount = math.random(self.xp_min, self.xp_max)
+
+				if not mcl_sculk.handle_death(pos, xp_amount) then
+					--minetest.log("Xp not thrown")
+					if minetest.is_creative_enabled("") ~= true then
+						mcl_experience.throw_xp(pos, xp_amount)
+					end
+				else
+					--minetest.log("xp thrown")
+				end
 			end
 		end
+
+
 	end
 
 	-- execute custom death function
@@ -497,6 +522,12 @@ function mob_class:check_for_death(cause, cmi_cause)
 		end
 	end
 
+	if self.jockey or self.riden_by_jock then
+		self.riden_by_jock = nil
+		self.jockey = nil
+	end
+
+
 	local collisionbox
 	if self.collisionbox then
 		collisionbox = table.copy(self.collisionbox)
@@ -519,17 +550,16 @@ function mob_class:check_for_death(cause, cmi_cause)
 
 	self:set_velocity(0)
 	local acc = self.object:get_acceleration()
-	acc.x, acc.y, acc.z = 0, DEFAULT_FALL_SPEED, 0
+	if acc then
-	self.object:set_acceleration(acc)
+		acc.x, acc.y, acc.z = 0, DEFAULT_FALL_SPEED, 0
+		self.object:set_acceleration(acc)
+	end
 
 	local length
 	-- default death function and die animation (if defined)
 	if self.instant_death then
 		length = 0
-	elseif self.animation
+	elseif self.animation and self.animation.die_start and self.animation.die_end then
-	and self.animation.die_start
-	and self.animation.die_end then
-
 		local frames = self.animation.die_end - self.animation.die_start
 		local speed = self.animation.die_speed or 15
 		length = math.max(frames / speed, 0) + DEATH_DELAY
@@ -545,7 +575,6 @@ function mob_class:check_for_death(cause, cmi_cause)
 		if not self.object:get_luaentity() then
 			return
 		end
-
 		death_handle(self)
 		local dpos = self.object:get_pos()
 		local cbox = self.collisionbox
@@ -554,6 +583,7 @@ function mob_class:check_for_death(cause, cmi_cause)
 		self.object:remove()
 		mcl_mobs.death_effect(dpos, yaw, cbox, not self.instant_death)
 	end
+
 	if length <= 0 then
 		kill(self)
 	else
@@ -604,24 +634,34 @@ function mob_class:do_env_damage()
 		return true
 	end
 
-	local sunlight = minetest.get_natural_light(pos, self.time_of_day)
+	local node = minetest.get_node(pos)
-
+	if node then
-	-- bright light harms mob
+		if node.name ~= "ignore" then
-	if self.light_damage ~= 0 and (sunlight or 0) > 12 then
+			-- put below code in this block if we can prove that unloaded maps are causing crash.
-		if self:deal_light_damage(pos, self.light_damage) then
+			-- it should warn then error
-			return true
+		else
+			--minetest.log("warning", "Pos is ignored: " .. dump(pos))
 		end
-	end
+
-	local _, dim = mcl_worlds.y_to_layer(pos.y)
+		local sunlight = minetest.get_natural_light(pos, self.time_of_day)
-	if (self.sunlight_damage ~= 0 or self.ignited_by_sunlight) and (sunlight or 0) >= minetest.LIGHT_MAX and dim == "overworld" then
+
-		if self.armor_list and not self.armor_list.helmet or not self.armor_list or self.armor_list and self.armor_list.helmet and self.armor_list.helmet == "" then
+		if self.light_damage ~= 0 and (sunlight or 0) > 12 then
-			if self.ignited_by_sunlight then
+			if self:deal_light_damage(pos, self.light_damage) then
-				mcl_burning.set_on_fire(self.object, 10)
-			else
-				self:deal_light_damage(pos, self.sunlight_damage)
 				return true
 			end
 		end
+		local _, dim = mcl_worlds.y_to_layer(pos.y)
+		if (self.sunlight_damage ~= 0 or self.ignited_by_sunlight) and (sunlight or 0) >= minetest.LIGHT_MAX and dim == "overworld" then
+			if self.armor_list and not self.armor_list.helmet or not self.armor_list or self.armor_list and self.armor_list.helmet and self.armor_list.helmet == "" then
+				if self.ignited_by_sunlight then
+					mcl_burning.set_on_fire(self.object, 10)
+				else
+					self:deal_light_damage(pos, self.sunlight_damage)
+					return true
+				end
+			end
+		end
+
 	end
 
 	local y_level = self.collisionbox[2]
@@ -642,11 +682,11 @@ function mob_class:do_env_damage()
 	end
 
 	local nodef = minetest.registered_nodes[self.standing_in]
+	local nodef2 = minetest.registered_nodes[self.standing_on]
 
 	-- rain
 	if self.rain_damage > 0 then
 		if mcl_weather.rain.raining and mcl_weather.is_outdoor(pos) then
-
 			self.health = self.health - self.rain_damage
 
 			if self:check_for_death("rain", {type = "environment",
@@ -659,13 +699,9 @@ function mob_class:do_env_damage()
 	pos.y = pos.y + 1 -- for particle effect position
 
 	-- water damage
-	if self.water_damage > 0
+	if self.water_damage > 0 and nodef.groups.water then
-	and nodef.groups.water then
-
 		if self.water_damage ~= 0 then
-
 			self.health = self.health - self.water_damage
-
 			mcl_mobs.effect(pos, 5, "mcl_particles_smoke.png", nil, nil, 1, nil)
 
 			if self:check_for_death("water", {type = "environment",
@@ -673,15 +709,10 @@ function mob_class:do_env_damage()
 				return true
 			end
 		end
-
+	elseif self.lava_damage > 0 and (nodef.groups.lava) then
-	-- lava damage
+		-- lava damage
-	elseif self.lava_damage > 0
-	and (nodef.groups.lava) then
-
 		if self.lava_damage ~= 0 then
-
 			self.health = self.health - self.lava_damage
-
 			mcl_mobs.effect(pos, 5, "fire_basic_flame.png", nil, nil, 1, nil)
 			mcl_burning.set_on_fire(self.object, 10)
 
@@ -690,15 +721,20 @@ function mob_class:do_env_damage()
 				return true
 			end
 		end
-
+	elseif self.fire_damage > 0 and (nodef2.groups.fire) then
-	-- fire damage
+		-- magma damage
-	elseif self.fire_damage > 0
-	and (nodef.groups.fire) then
-
 		if self.fire_damage ~= 0 then
-
 			self.health = self.health - self.fire_damage
 
+			if self:check_for_death("fire", {type = "environment",
+											 pos = pos, node = self.standing_in}) then
+				return true
+			end
+		end
+	elseif self.fire_damage > 0 and (nodef.groups.fire) then
+		-- fire damage
+		if self.fire_damage ~= 0 then
+			self.health = self.health - self.fire_damage
 			mcl_mobs.effect(pos, 5, "fire_basic_flame.png", nil, nil, 1, nil)
 			mcl_burning.set_on_fire(self.object, 5)
 
@@ -707,12 +743,9 @@ function mob_class:do_env_damage()
 				return true
 			end
 		end
-
-	-- damage_per_second node check
 	elseif nodef.damage_per_second ~= 0 and not nodef.groups.lava and not nodef.groups.fire then
-
+		-- damage_per_second node check
 		self.health = self.health - nodef.damage_per_second
-
 		mcl_mobs.effect(pos, 5, "mcl_particles_smoke.png")
 
 		if self:check_for_death("dps", {type = "environment",
@@ -724,6 +757,7 @@ function mob_class:do_env_damage()
 	-- Drowning damage
 	if self.breath_max ~= -1 then
 		local drowning = false
+
 		if self.breathes_in_water then
 			if minetest.get_item_group(self.standing_in, "water") == 0 then
 				drowning = true
@@ -731,10 +765,9 @@ function mob_class:do_env_damage()
 		elseif nodef.drowning > 0 then
 			drowning = true
 		end
+
 		if drowning then
-
 			self.breath = math.max(0, self.breath - 1)
-
 			mcl_mobs.effect(pos, 2, "bubble.png", nil, nil, 1, nil)
 			if self.breath <= 0 then
 				local dmg
@@ -785,25 +818,25 @@ function mob_class:do_env_damage()
 		self.suffocation_timer = 0
 	end
 
-	return self:check_for_death("", {type = "unknown"})
+	return self:check_for_death("unknown", {type = "unknown"})
 end
 
 function mob_class:env_damage (dtime, pos)
 	-- environmental damage timer (every 1 second)
 	self.env_damage_timer = self.env_damage_timer + dtime
 
-	if (self.state == "attack" and self.env_damage_timer > 1)
+
-			or self.state ~= "attack" then
+	if self.env_damage_timer > 1 then
-		self:check_entity_cramming()
 		self.env_damage_timer = 0
 
+		self:check_entity_cramming()
+
 		-- check for environmental damage (water, fire, lava etc.)
 		if self:do_env_damage() then
 			return true
 		end
 
-		-- node replace check (cow eats grass etc.)
+		self:replace_node(pos) -- (sheep eats grass etc.)
-		self:replace(pos)
 	end
 end
 
@@ -870,33 +903,32 @@ function mob_class:falling(pos)
 
 	-- floating in water (or falling)
 	local v = self.object:get_velocity()
+	if v then
+		if v.y > 0 then
+			-- apply gravity when moving up
+			self.object:set_acceleration({
+				x = 0,
+				y = DEFAULT_FALL_SPEED,
+				z = 0
+			})
 
-	if v.y > 0 then
+		elseif v.y <= 0 and v.y > self.fall_speed then
-
+			-- fall downwards at set speed
-		-- apply gravity when moving up
+			self.object:set_acceleration({
-		self.object:set_acceleration({
+				x = 0,
-			x = 0,
+				y = self.fall_speed,
-			y = DEFAULT_FALL_SPEED,
+				z = 0
-			z = 0
+			})
-		})
+		else
-
+			-- stop accelerating once max fall speed hit
-	elseif v.y <= 0 and v.y > self.fall_speed then
+			self.object:set_acceleration({x = 0, y = 0, z = 0})
-
+		end
-		-- fall downwards at set speed
-		self.object:set_acceleration({
-			x = 0,
-			y = self.fall_speed,
-			z = 0
-		})
-	else
-		-- stop accelerating once max fall speed hit
-		self.object:set_acceleration({x = 0, y = 0, z = 0})
 	end
 
+	local acc = self.object:get_acceleration()
+
 	if minetest.registered_nodes[node_ok(pos).name].groups.lava then
-
+		if acc and self.floats_on_lava == 1 then
-		if self.floats_on_lava == 1 then
-
 			self.object:set_acceleration({
 				x = 0,
 				y = -self.fall_speed / (math.max(1, v.y) ^ 2),
@@ -907,9 +939,7 @@ function mob_class:falling(pos)
 
 	-- in water then float up
 	if minetest.registered_nodes[node_ok(pos).name].groups.water then
-
+		if acc and self.floats == 1 then
-		if self.floats == 1 then
-
 			self.object:set_acceleration({
 				x = 0,
 				y = -self.fall_speed / (math.max(1, v.y) ^ 2),
@@ -917,10 +947,8 @@ function mob_class:falling(pos)
 			})
 		end
 	else
-
 		-- fall damage onto solid ground
-		if self.fall_damage == 1
+		if self.fall_damage == 1 and self.object:get_velocity().y == 0 then
-		and self.object:get_velocity().y == 0 then
 			local n = node_ok(vector.offset(pos,0,-1,0)).name
 			local d = (self.old_y or 0) - self.object:get_pos().y
 
@@ -981,24 +1009,31 @@ end
 function mob_class:check_dying()
 	if ((self.state and self.state=="die") or self:check_for_death()) and not self.animation.die_end then
 		local rot = self.object:get_rotation()
-		rot.z = ((math.pi/2-rot.z)*.2)+rot.z
+		if rot then
-		self.object:set_rotation(rot)
+			rot.z = ((math.pi/2-rot.z)*.2)+rot.z
+			self.object:set_rotation(rot)
+		end
 		return true
 	end
 end
 
-function mob_class:check_suspend()
+function mob_class:check_suspend(player_in_active_range)
-	if not self:player_in_active_range() then
+	local pos = self.object:get_pos()
-		local pos = self.object:get_pos()
+
+	if pos and not player_in_active_range then
 		local node_under = node_ok(vector.offset(pos,0,-1,0)).name
-		local acc = self.object:get_acceleration()
+
 		self:set_animation( "stand", true)
-		if acc.y > 0 or node_under ~= "air" then
+
-			self.object:set_acceleration(vector.new(0,0,0))
+		local acc = self.object:get_acceleration()
-			self.object:set_velocity(vector.new(0,0,0))
+		if acc then
-		end
+			if acc.y > 0 or node_under ~= "air" then
-		if acc.y == 0 and node_under == "air" then
+				self.object:set_acceleration(vector.zero())
-			self:falling(pos)
+				self.object:set_velocity(vector.zero())
+			end
+			if acc.y == 0 and node_under == "air" then
+				self:falling(pos)
+			end
 		end
 		return true
 	end

mods/ENTITIES/mcl_mobs/spawning.lua

@@ -24,25 +24,60 @@ local vector_floor    = vector.floor
 
 local table_copy     = table.copy
 local table_remove   = table.remove
-
 local pairs = pairs
+
+local LOGGING_ON = minetest.settings:get_bool("mcl_logging_mobs_spawning", false)
+local function mcl_log (message)
+	if LOGGING_ON then
+		mcl_util.mcl_log (message, "[Mobs spawn]", true)
+	end
+end
+
 local dbg_spawn_attempts = 0
 local dbg_spawn_succ = 0
 local dbg_spawn_counts = {}
--- range for mob count
+
-local aoc_range = 136
 local remove_far = true
 
+local WAIT_FOR_SPAWN_ATTEMPT = 10
+local FIND_SPAWN_POS_RETRIES = 16
+local FIND_SPAWN_POS_RETRIES_SUCCESS_RESPIN = 8
+
+local MOB_SPAWN_ZONE_INNER = 24
+local MOB_SPAWN_ZONE_MIDDLE = 32
+local MOB_SPAWN_ZONE_OUTER = 128
+
+-- range for mob count
+local MOB_CAP_INNER_RADIUS = 32
+local aoc_range = 136
+
+local MISSING_CAP_DEFAULT = 15
+local MOBS_CAP_CLOSE = 5
+
+local SPAWN_MAPGEN_LIMIT  = mcl_vars.mapgen_limit - 150
+
 local mob_cap = {
-	monster = tonumber(minetest.settings:get("mcl_mob_cap_monster")) or 70,
+	hostile = tonumber(minetest.settings:get("mcl_mob_cap_monster")) or 70,
-	animal = tonumber(minetest.settings:get("mcl_mob_cap_animal")) or 10,
+	passive = tonumber(minetest.settings:get("mcl_mob_cap_animal")) or 13,
 	ambient = tonumber(minetest.settings:get("mcl_mob_cap_ambient")) or 15,
-	water = tonumber(minetest.settings:get("mcl_mob_cap_water")) or 5, --currently unused
+	water = tonumber(minetest.settings:get("mcl_mob_cap_water")) or 8,
 	water_ambient = tonumber(minetest.settings:get("mcl_mob_cap_water_ambient")) or 20, --currently unused
 	player = tonumber(minetest.settings:get("mcl_mob_cap_player")) or 75,
 	total = tonumber(minetest.settings:get("mcl_mob_cap_total")) or 500,
 }
 
+local peaceful_percentage_spawned = tonumber(minetest.settings:get("mcl_mob_peaceful_percentage_spawned")) or 35
+local peaceful_group_percentage_spawned = tonumber(minetest.settings:get("mcl_mob_peaceful_group_percentage_spawned")) or 15
+local hostile_group_percentage_spawned = tonumber(minetest.settings:get("mcl_mob_hostile_group_percentage_spawned")) or 20
+
+mcl_log("Mob cap hostile: " .. mob_cap.hostile)
+mcl_log("Mob cap water: " .. mob_cap.water)
+mcl_log("Mob cap passive: " .. mob_cap.passive)
+
+mcl_log("Percentage of peacefuls spawned: " .. peaceful_percentage_spawned)
+mcl_log("Percentage of peaceful spawns are group: " .. peaceful_group_percentage_spawned)
+mcl_log("Percentage of hostile spawns are group: " .. hostile_group_percentage_spawned)
+
 --do mobs spawn?
 local mobs_spawn = minetest.settings:get_bool("mobs_spawn", true) ~= false
 local spawn_protected = minetest.settings:get_bool("mobs_spawn_protected") ~= false
@@ -169,6 +204,8 @@ local list_of_all_biomes = {
 	"MushroomIslandShore",
 	"JungleM_shore",
 	"Jungle_shore",
+	"BambooJungleM_shore",
+	"BambooJungle_shore",
 	"MangroveSwamp_shore",
 
 	-- dimension biome:
@@ -216,6 +253,10 @@ local list_of_all_biomes = {
 	"JungleEdge",
 	"SavannaM",
 	"MangroveSwamp",
+	"BambooJungle",
+	"BambooJungleEdge",
+	"BambooJungleEdgeM",
+	"BambooJungleM",
 }
 
 -- count how many mobs are in an area
@@ -244,6 +285,60 @@ local function count_mobs_total(mob_type)
 	return num
 end
 
+local function count_mobs_add_entry (mobs_list, mob_cat)
+	if mobs_list[mob_cat] then
+		mobs_list[mob_cat] = mobs_list[mob_cat] + 1
+	else
+		mobs_list[mob_cat] = 1
+	end
+end
+
+--categorise_by can be name or type or spawn_class
+local function count_mobs_all(categorise_by, pos)
+	local mobs_found_wide = {}
+	local mobs_found_close = {}
+
+	local num = 0
+	for _,entity in pairs(minetest.luaentities) do
+		if entity and entity.is_mob then
+
+			local add_entry = false
+			--local mob_type = entity.type -- animal / monster / npc
+			local mob_cat = entity[categorise_by]
+
+			if pos then
+				local mob_pos = entity.object:get_pos()
+				if mob_pos then
+					local distance = vector.distance(pos, mob_pos)
+					--mcl_log("distance: ".. distance)
+					if distance <= MOB_SPAWN_ZONE_MIDDLE then
+						--mcl_log("distance is close")
+						count_mobs_add_entry (mobs_found_close, mob_cat)
+						count_mobs_add_entry (mobs_found_wide, mob_cat)
+						add_entry = true
+					elseif distance <= MOB_SPAWN_ZONE_OUTER then
+						--mcl_log("distance is wide")
+						count_mobs_add_entry (mobs_found_wide, mob_cat)
+						add_entry = true
+					else
+						--mcl_log("mob_pos: " .. minetest.pos_to_string(mob_pos))
+					end
+				end
+			else
+				count_mobs_add_entry (mobs_found_wide, mob_cat)
+				add_entry = true
+			end
+
+
+			if add_entry then
+				num = num + 1
+			end
+		end
+	end
+	--mcl_log("num: ".. num)
+	return mobs_found_close, mobs_found_wide, num
+end
+
 local function count_mobs_total_cap(mob_type)
 	local num = 0
 	for _,l in pairs(minetest.luaentities) do
@@ -256,6 +351,32 @@ local function count_mobs_total_cap(mob_type)
 	return num
 end
 
+local function output_mob_stats(mob_counts, total_mobs, chat_display)
+	if (total_mobs) then
+		local total_output = "Total mobs found: " .. total_mobs
+		if chat_display then
+			minetest.log(total_output)
+		else
+			minetest.log("action", total_output)
+		end
+
+	end
+	local detailed = ""
+	if mob_counts then
+		for k, v1 in pairs(mob_counts) do
+			detailed = detailed .. tostring(k) ..  ": " .. tostring(v1) ..  "; "
+		end
+	end
+	if detailed and detailed ~= "" then
+		if chat_display then
+			minetest.log(detailed)
+		else
+			minetest.log("action", detailed)
+		end
+	end
+end
+
+
 -- global functions
 
 function mcl_mobs:spawn_abm_check(pos, node, name)
@@ -292,6 +413,8 @@ WARNING: BIOME INTEGRATION NEEDED -> How to get biome through lua??
 
 --this is where all of the spawning information is kept
 local spawn_dictionary = {}
+--this is where all of the spawning information  is kept for mobs that don't naturally spawn
+local non_spawn_dictionary = {}
 local summary_chance = 0
 
 function mcl_mobs:spawn_setup(def)
@@ -357,7 +480,69 @@ function mcl_mobs:spawn_setup(def)
 	summary_chance = summary_chance + chance
 end
 
-function mcl_mobs:spawn_specific(name, dimension, type_of_spawning, biomes, min_light, max_light, interval, chance, aoc, min_height, max_height, day_toggle, on_spawn)
+function mcl_mobs:mob_light_lvl(mob_name, dimension)
+	local spawn_dictionary_consolidated = {}
+
+	if non_spawn_dictionary[mob_name] then
+		local mob_dimension = non_spawn_dictionary[mob_name][dimension]
+		if mob_dimension then
+			--minetest.log("Found in non spawn dictionary for dimension")
+			return mob_dimension.min_light, mob_dimension.max_light
+		else
+			--minetest.log("Found in non spawn dictionary but not for dimension")
+			local overworld_non_spawn_def = non_spawn_dictionary[mob_name]["overworld"]
+			if overworld_non_spawn_def then
+				return overworld_non_spawn_def.min_light, overworld_non_spawn_def.max_light
+			end
+		end
+	else
+		--minetest.log("must be in spawning dictionary")
+		for i,v in pairs(spawn_dictionary) do
+			local current_mob_name = spawn_dictionary[i].name
+			local current_mob_dim = spawn_dictionary[i].dimension
+			if mob_name == current_mob_name then
+				if not spawn_dictionary_consolidated[current_mob_name] then
+					spawn_dictionary_consolidated[current_mob_name] = {}
+				end
+				spawn_dictionary_consolidated[current_mob_name][current_mob_dim] = {
+					["min_light"] = spawn_dictionary[i].min_light,
+					["max_light"] = spawn_dictionary[i].max_light
+				}
+			end
+		end
+
+		if spawn_dictionary_consolidated[mob_name] then
+			--minetest.log("is in consolidated")
+			local mob_dimension = spawn_dictionary_consolidated[mob_name][dimension]
+			if mob_dimension then
+				--minetest.log("found for dimension")
+				return mob_dimension.min_light, mob_dimension.max_light
+			else
+				--minetest.log("not found for dimension, use overworld def")
+				local mob_dimension_default = spawn_dictionary_consolidated[mob_name]["overworld"]
+				if mob_dimension_default then
+					return mob_dimension_default.min_light, mob_dimension_default.max_light
+				end
+			end
+		else
+			--minetest.log("not in consolidated")
+		end
+	end
+
+	minetest.log("action", "There are no light levels for mob (" .. tostring(mob_name) .. ") in dimension (" .. tostring(dimension) .. "). Return defaults")
+	return 0, minetest.LIGHT_MAX+1
+end
+
+function mcl_mobs:non_spawn_specific(mob_name,dimension,min_light,max_light)
+	table.insert(non_spawn_dictionary, mob_name)
+	non_spawn_dictionary[mob_name] = {
+		[dimension] = {
+			min_light = min_light , max_light = max_light
+		}
+	}
+end
+
+function mcl_mobs:spawn_specific(name, dimension, type_of_spawning, biomes, min_light, max_light, interval, chance, aoc, min_height, max_height, day_toggle, on_spawn, check_position)
 
 	-- Do mobs spawn at all?
 	if not mobs_spawn then
@@ -394,22 +579,28 @@ function mcl_mobs:spawn_specific(name, dimension, type_of_spawning, biomes, min_
 	spawn_dictionary[key]["min_height"] = min_height
 	spawn_dictionary[key]["max_height"] = max_height
 	spawn_dictionary[key]["day_toggle"] = day_toggle
+	spawn_dictionary[key]["check_position"] = check_position
 
 	summary_chance = summary_chance + chance
 end
 
+
 local two_pi = 2 * math.pi
 local function get_next_mob_spawn_pos(pos)
-	local distance = math_random(25, 32)
+	-- TODO We should consider spawning something a little further away sporadically.
+	-- It would be good for sky farms and variance, rather than all being on the 24 - 32 block away radius
+	local distance = math_random(MOB_SPAWN_ZONE_INNER, MOB_SPAWN_ZONE_MIDDLE)
 	local angle = math_random() * two_pi
+
+	-- TODO Floor xoff and zoff and add 0.5 so it tries to spawn in the middle of the square. Less failed attempts.
 	local xoff = math_round(distance * math_cos(angle))
-	local yoff = math_round(distance * math_sin(angle))
+	local zoff = math_round(distance * math_sin(angle))
-	return vector.offset(pos, xoff, 0, yoff)
+	return vector.offset(pos, xoff, 0, zoff)
 end
 
 local function decypher_limits(posy)
 	posy = math_floor(posy)
-	return posy - 32, posy + 32
+	return posy - MOB_SPAWN_ZONE_MIDDLE, posy + MOB_SPAWN_ZONE_MIDDLE
 end
 
 --a simple helper function for mob_spawn
@@ -460,15 +651,20 @@ local function has_room(self,pos)
 	return true
 end
 
-local function spawn_check(pos,spawn_def,ignore_caps)
+
-	if not spawn_def then return end
+
+local function spawn_check(pos, spawn_def)
+	if not spawn_def or not pos then return end
+
 	dbg_spawn_attempts = dbg_spawn_attempts + 1
 	local dimension = mcl_worlds.pos_to_dimension(pos)
 	local mob_def = minetest.registered_entities[spawn_def.name]
 	local mob_type = mob_def.type
 	local gotten_node = get_node(pos).name
 	local gotten_biome = minetest.get_biome_data(pos)
+
 	if not gotten_node or not gotten_biome then return end
+
 	gotten_biome = get_biome_name(gotten_biome.biome) --makes it easier to work with
 
 	local is_ground = minetest.get_item_group(gotten_node,"solid") ~= 0
@@ -483,34 +679,38 @@ local function spawn_check(pos,spawn_def,ignore_caps)
 	local is_leaf  = get_item_group(gotten_node, "leaves") ~= 0
 	local is_bedrock  = gotten_node == "mcl_core:bedrock"
 	local is_grass = minetest.get_item_group(gotten_node,"grass_block") ~= 0
-	local mob_count_wide = 0
 
-	local mob_count = 0
+	if pos.y >= spawn_def.min_height
-	if not ignore_caps then
+			and pos.y <= spawn_def.max_height
-		mob_count = count_mobs(pos,32,mob_type)
+			and spawn_def.dimension == dimension
-		mob_count_wide = count_mobs(pos,aoc_range,mob_type)
+			and biome_check(spawn_def.biomes, gotten_biome) then
-	end
 
-	if pos and spawn_def
+		--mcl_log("Level 1 spawn check passed")
-	and ( mob_count_wide < (mob_cap[mob_type] or 15) )
+		--minetest.log("Mob: " .. mob_def.name)
-	and ( mob_count < 5 )
+
-	and pos.y >= spawn_def.min_height
+		if  (is_ground or spawn_def.type_of_spawning ~= "ground")
-	and pos.y <= spawn_def.max_height
+				and (spawn_def.type_of_spawning ~= "ground" or not is_leaf)
-	and spawn_def.dimension == dimension
+				and (not is_farm_animal(spawn_def.name) or is_grass)
-	and biome_check(spawn_def.biomes, gotten_biome)
+				and (spawn_def.type_of_spawning ~= "water" or is_water)
-	and (is_ground or spawn_def.type_of_spawning ~= "ground")
+				and not is_bedrock
-	and (spawn_def.type_of_spawning ~= "ground" or not is_leaf)
+				and has_room(mob_def,pos)
-	and has_room(mob_def,pos)
+				and (spawn_def.check_position and spawn_def.check_position(pos) or spawn_def.check_position == nil)
-	and (spawn_def.check_position and spawn_def.check_position(pos) or true)
+				and ( not spawn_protected or not minetest.is_protected(pos, "") ) then
-	and (not is_farm_animal(spawn_def.name) or is_grass)
+
-	and (spawn_def.type_of_spawning ~= "water" or is_water)
+			--mcl_log("Level 2 spawn check passed")
-	and ( not spawn_protected or not minetest.is_protected(pos, "") )
+
-	and not is_bedrock then
+			local gotten_light = get_node_light(pos)
-		--only need to poll for node light if everything else worked
+			if gotten_light >= spawn_def.min_light and gotten_light <= spawn_def.max_light then
-		local gotten_light = get_node_light(pos)
+				--mcl_log("Level 3 spawn check passed")
-		if gotten_light >= spawn_def.min_light and gotten_light <= spawn_def.max_light then
+				return true
-			return true
+			else
+				mcl_log("Spawn check level 3 failed")
+			end
+		else
+			mcl_log("Spawn check level 2 failed")
 		end
+	else
+		mcl_log("Spawn check level 1 failed")
 	end
 	return false
 end
@@ -529,8 +729,7 @@ function mcl_mobs.spawn(pos,id)
 end
 
 
-local function spawn_group(p,mob,spawn_on,group_max,group_min)
+local function spawn_group(p,mob,spawn_on,amount_to_spawn)
-	if not group_min then group_min = 1 end
 	local nn= minetest.find_nodes_in_area_under_air(vector.offset(p,-5,-3,-5),vector.offset(p,5,3,5),spawn_on)
 	local o
 	table.shuffle(nn)
@@ -538,9 +737,10 @@ local function spawn_group(p,mob,spawn_on,group_max,group_min)
 		nn = {}
 		table.insert(nn,p)
 	end
-	for i = 1, math.random(group_min,group_max) do
+
+	for i = 1, amount_to_spawn do
 		local sp = vector.offset(nn[math.random(#nn)],0,1,0)
-		if spawn_check(nn[math.random(#nn)],mob,true) then
+		if spawn_check(nn[math.random(#nn)],mob) then
 			if mob.type_of_spawning == "water" then
 				sp = get_water_spawn(sp)
 			end
@@ -628,25 +828,116 @@ if mobs_spawn then
 
 	local perlin_noise
 
-	local function spawn_a_mob(pos, dimension, y_min, y_max)
+	-- Get pos to spawn, x and z are randomised, y is range
-		--create a disconnected clone of the spawn dictionary
+
-		--prevents memory leak
+
+	local function mob_cap_space (pos, mob_type, mob_counts_close, mob_counts_wide)
+
+		-- Some mob examples
+		--type = "monster", spawn_class = "hostile",
+		--type = "animal", spawn_class = "passive",
+		--local cod = { type = "animal", spawn_class = "water",
+
+		local type_cap = mob_cap[mob_type] or MISSING_CAP_DEFAULT
+		local close_zone_cap = MOBS_CAP_CLOSE
+
+		local mob_total_wide = mob_counts_wide[mob_type]
+		if not mob_total_wide then
+			--mcl_log("none of type found. set as 0")
+			mob_total_wide = 0
+		end
+
+		local cap_space_wide = type_cap - mob_total_wide
+		if cap_space_wide < 1 then
+			cap_space_wide = 0
+		end
+
+		local mob_total_close = mob_counts_close[mob_type]
+		if not mob_total_close then
+			--mcl_log("none of type found. set as 0")
+			mob_total_close = 0
+		end
+
+		local cap_space_close = close_zone_cap - mob_total_close
+		if cap_space_close < 1 then
+			cap_space_close = 0
+		end
+
+		--mcl_log("spawn_class: " .. spawn_class)
+
+		if false and mob_type == "water" then
+			mcl_log("mob_type: " .. mob_type .. " and pos: " .. minetest.pos_to_string(pos))
+			mcl_log("wide: " .. mob_total_wide .. "/" .. type_cap)
+			mcl_log("cap_space_wide: " .. cap_space_wide)
+			mcl_log("close: " .. mob_total_close .. "/" .. close_zone_cap)
+			mcl_log("cap_space_close: " .. cap_space_close)
+		end
+
+		return cap_space_wide, cap_space_close
+	end
+
+	local function find_spawning_position(pos, max_times)
+		local spawning_position
+
+		local max_loops = 1
+		if max_times then max_loops = max_times end
+
+		local y_min, y_max = decypher_limits(pos.y)
+
+		mcl_log("mapgen_limit: " .. SPAWN_MAPGEN_LIMIT)
+		local i = 0
+		repeat
+			local goal_pos = get_next_mob_spawn_pos(pos)
+
+			if math.abs(goal_pos.x) <= SPAWN_MAPGEN_LIMIT and math.abs(pos.y) <= SPAWN_MAPGEN_LIMIT and math.abs(goal_pos.z) <= SPAWN_MAPGEN_LIMIT then
+				local spawning_position_list = find_nodes_in_area_under_air(
+						{x = goal_pos.x, y = y_min, z = goal_pos.z},
+						{x = goal_pos.x, y = y_max, z = goal_pos.z},
+						{"group:solid", "group:water", "group:lava"}
+				)
+				if #spawning_position_list > 0 then
+					mcl_log("Spawning positions available: " .. minetest.pos_to_string(goal_pos))
+					spawning_position = spawning_position_list[math_random(1, #spawning_position_list)]
+				else
+					mcl_log("Spawning position isn't good. Do not spawn: " .. minetest.pos_to_string(goal_pos))
+				end
+
+			else
+				mcl_log("Pos outside mapgen limits: " .. minetest.pos_to_string(goal_pos))
+			end
+
+
+			i = i + 1
+			if i >= max_loops then
+				mcl_log("Cancel finding spawn positions at: " .. max_loops)
+				break
+			end
+		until spawning_position
+		return spawning_position
+	end
+
+	local function spawn_a_mob(pos)
+		--create a disconnected clone of the spawn dictionary, prevents memory leak
 		local mob_library_worker_table = table_copy(spawn_dictionary)
-		local goal_pos = get_next_mob_spawn_pos(pos)
+
+		local spawning_position = find_spawning_position(pos, FIND_SPAWN_POS_RETRIES)
+		if not spawning_position then
+			minetest.log("action", "[Mobs spawn] Cannot find a valid spawn position after retries: " .. FIND_SPAWN_POS_RETRIES)
+			return
+		end
+
+		local mob_counts_close, mob_counts_wide, total_mobs = count_mobs_all("spawn_class", spawning_position)
+		--output_mob_stats(mob_counts_close, total_mobs)
+		--output_mob_stats(mob_counts_wide)
+
 		--grab mob that fits into the spawning location
 		--randomly grab a mob, don't exclude any possibilities
-		local spawning_position_list = find_nodes_in_area_under_air(
-			{x = goal_pos.x, y = y_min, z = goal_pos.z},
-			{x = goal_pos.x, y = y_max, z = goal_pos.z},
-			{"group:solid", "group:water", "group:lava"}
-		)
-		if #spawning_position_list <= 0 then return end
-		local spawning_position = spawning_position_list[math_random(1, #spawning_position_list)]
-
 		perlin_noise = perlin_noise or minetest_get_perlin(noise_params)
 		local noise = perlin_noise:get_3d(spawning_position)
 		local current_summary_chance = summary_chance
+
 		table.shuffle(mob_library_worker_table)
+
 		while #mob_library_worker_table > 0 do
 			local mob_chance_offset = (math_round(noise * current_summary_chance + 12345) % current_summary_chance) + 1
 			local mob_index = 1
@@ -657,39 +948,95 @@ if mobs_spawn then
 				mob_chance = mob_library_worker_table[mob_index].chance
 				step_chance = step_chance + mob_chance
 			end
-			local mob_def = mob_library_worker_table[mob_index]
 			--minetest.log(mob_def.name.." "..step_chance.. " "..mob_chance)
+
+			local mob_def = mob_library_worker_table[mob_index]
 			if mob_def and mob_def.name and minetest.registered_entities[mob_def.name] then
-				local spawn_in_group = minetest.registered_entities[mob_def.name].spawn_in_group or 4
+
-				local spawn_in_group_min = minetest.registered_entities[mob_def.name].spawn_in_group_min or 1
+				local mob_def_ent = minetest.registered_entities[mob_def.name]
-				local mob_type = minetest.registered_entities[mob_def.name].type
+				--local mob_type = mob_def_ent.type
-				if spawn_check(spawning_position,mob_def) then
+				local mob_spawn_class = mob_def_ent.spawn_class
-					if mob_def.type_of_spawning == "water" then
+
-						spawning_position = get_water_spawn(spawning_position)
+				--mcl_log("mob_spawn_class: " .. mob_spawn_class)
-						if not spawning_position then
+
-							minetest.log("warning","[mcl_mobs] no water spawn for mob "..mob_def.name.." found at "..minetest.pos_to_string(vector.round(pos)))
+				local cap_space_wide, cap_space_close = mob_cap_space (spawning_position, mob_spawn_class, mob_counts_close, mob_counts_wide)
+
+
+				if cap_space_close > 0 and cap_space_wide > 0 then
+					--mcl_log("Cap space available")
+
+					-- Spawn caps for animals and water creatures fill up rapidly. Need to throttle this somewhat
+					-- for performance and for early game challenge. We don't want to reduce hostiles though.
+					local spawn_hostile = (mob_spawn_class == "hostile")
+					local spawn_passive = (mob_spawn_class ~= "hostile") and math.random(100) < peaceful_percentage_spawned
+					-- or not hostile
+					--mcl_log("Spawn_passive: " .. tostring(spawn_passive))
+					--mcl_log("Spawn_hostile: " .. tostring(spawn_hostile))
+
+					if (spawn_hostile or spawn_passive) and spawn_check(spawning_position,mob_def) then
+						if mob_def.type_of_spawning == "water" then
+							spawning_position = get_water_spawn(spawning_position)
+							if not spawning_position then
+								minetest.log("warning","[mcl_mobs] no water spawn for mob "..mob_def.name.." found at "..minetest.pos_to_string(vector.round(pos)))
+								return
+							end
+						end
+						if mob_def_ent.can_spawn and not mob_def_ent.can_spawn(spawning_position) then
+							minetest.log("warning","[mcl_mobs] mob "..mob_def.name.." refused to spawn at "..minetest.pos_to_string(vector.round(spawning_position)))
 							return
 						end
-					end
-					if minetest.registered_entities[mob_def.name].can_spawn and not minetest.registered_entities[mob_def.name].can_spawn(spawning_position) then
-						minetest.log("warning","[mcl_mobs] mob "..mob_def.name.." refused to spawn at "..minetest.pos_to_string(vector.round(spawning_position)))
-						return
-					end
-					--everything is correct, spawn mob
-					local object
-					if spawn_in_group and ( mob_type ~= "monster" or math.random(5) == 1 ) then
-						if logging then
-							minetest.log("action", "[mcl_mobs] A group of mob " .. mob_def.name .. " spawns on " ..minetest.get_node(vector.offset(spawning_position,0,-1,0)).name .." at " .. minetest.pos_to_string(spawning_position, 1))
-						end
-						object = spawn_group(spawning_position,mob_def,{minetest.get_node(vector.offset(spawning_position,0,-1,0)).name},spawn_in_group,spawn_in_group_min)
 
-					else
+						--everything is correct, spawn mob
-						if logging then
+						local spawn_in_group = mob_def_ent.spawn_in_group or 4
-							minetest.log("action", "[mcl_mobs] Mob " .. mob_def.name .. " spawns on " ..minetest.get_node(vector.offset(spawning_position,0,-1,0)).name .." at ".. minetest.pos_to_string(spawning_position, 1))
+
+						local spawn_group_hostile = (mob_spawn_class == "hostile") and (math.random(100) < hostile_group_percentage_spawned)
+						local spawn_group_passive = (mob_spawn_class ~= "hostile") and (math.random(100) < peaceful_group_percentage_spawned)
+
+						mcl_log("spawn_group_hostile: " .. tostring(spawn_group_hostile))
+						mcl_log("spawn_group_passive: " .. tostring(spawn_group_passive))
+
+						local spawned
+						if spawn_in_group and (spawn_group_hostile or spawn_group_passive) then
+							local group_min = mob_def_ent.spawn_in_group_min or 1
+							if not group_min then group_min = 1 end
+
+							local amount_to_spawn = math.random(group_min,spawn_in_group)
+
+							if amount_to_spawn > cap_space_wide then
+								mcl_log("Spawning quantity: " .. amount_to_spawn)
+								mcl_log("Throttle amount to cap space: " .. cap_space_wide)
+								amount_to_spawn = cap_space_wide
+							end
+
+							if logging then
+								minetest.log("action", "[mcl_mobs] A group of " ..amount_to_spawn .. " " .. mob_def.name .. " mob spawns on " ..minetest.get_node(vector.offset(spawning_position,0,-1,0)).name .." at " .. minetest.pos_to_string(spawning_position, 1))
+							end
+							spawned = spawn_group(spawning_position,mob_def,{minetest.get_node(vector.offset(spawning_position,0,-1,0)).name}, amount_to_spawn)
+						else
+							if logging then
+								minetest.log("action", "[mcl_mobs] Mob " .. mob_def.name .. " spawns on " ..minetest.get_node(vector.offset(spawning_position,0,-1,0)).name .." at ".. minetest.pos_to_string(spawning_position, 1))
+							end
+							spawned = mcl_mobs.spawn(spawning_position, mob_def.name)
 						end
-						object = mcl_mobs.spawn(spawning_position, mob_def.name)
+
+						if spawned then
+							--mcl_log("We have spawned")
+							mob_counts_close, mob_counts_wide, total_mobs = count_mobs_all("type", pos)
+							local new_spawning_position = find_spawning_position(pos, FIND_SPAWN_POS_RETRIES_SUCCESS_RESPIN)
+							if new_spawning_position then
+								mcl_log("Setting new spawning position")
+								spawning_position = new_spawning_position
+							else
+								mcl_log("Cannot set new spawning position")
+							end
+						end
+					else
+						--mcl_log("Spawn check failed")
 					end
+				else
+					mcl_log("Cap space full")
 				end
+
 			end
 			current_summary_chance = current_summary_chance - mob_chance
 			table_remove(mob_library_worker_table, mob_index)
@@ -701,28 +1048,32 @@ if mobs_spawn then
 
 	local timer = 0
 	minetest.register_globalstep(function(dtime)
+
 		timer = timer + dtime
-		if timer < 10 then return end
+		if timer < WAIT_FOR_SPAWN_ATTEMPT then return end
 		timer = 0
+
 		local players = get_connected_players()
 		local total_mobs = count_mobs_total_cap()
 		if total_mobs > mob_cap.total or total_mobs > #players * mob_cap.player then
 			minetest.log("action","[mcl_mobs] global mob cap reached. no cycle spawning.")
 			return
 		end --mob cap per player
+
 		for _, player in pairs(players) do
 			local pos = player:get_pos()
 			local dimension = mcl_worlds.pos_to_dimension(pos)
 			-- ignore void and unloaded area
 			if dimension ~= "void" and dimension ~= "default" then
-				local y_min, y_max = decypher_limits(pos.y)
+				spawn_a_mob(pos)
-				spawn_a_mob(pos, dimension, y_min, y_max)
 			end
 		end
 	end)
 end
 
-function mob_class:check_despawn(pos)
+function mob_class:check_despawn(pos, dtime)
+	self.lifetimer = self.lifetimer - dtime
+
 	-- Despawning: when lifetimer expires, remove mob
 	if remove_far
 	and self.can_despawn == true
@@ -746,14 +1097,16 @@ function mob_class:check_despawn(pos)
 	end
 end
 
+
 minetest.register_chatcommand("mobstats",{
 	privs = { debug = true },
 	func = function(n,param)
-		minetest.chat_send_player(n,dump(dbg_spawn_counts))
+		--minetest.chat_send_player(n,dump(dbg_spawn_counts))
 		local pos = minetest.get_player_by_name(n):get_pos()
-		minetest.chat_send_player(n,"mobs within 32 radius of player:"..count_mobs(pos,32))
+		minetest.chat_send_player(n,"mobs: within 32 radius of player/total loaded :"..count_mobs(pos,MOB_CAP_INNER_RADIUS) .. "/" .. count_mobs_total())
-		minetest.chat_send_player(n,"total mobs:"..count_mobs_total())
+		minetest.chat_send_player(n,"spawning attempts since server start:" .. dbg_spawn_succ .. "/" .. dbg_spawn_attempts)
-		minetest.chat_send_player(n,"spawning attempts since server start:"..dbg_spawn_attempts)
+
-		minetest.chat_send_player(n,"successful spawns since server start:"..dbg_spawn_succ)
+		local mob_counts_close, mob_counts_wide, total_mobs = count_mobs_all("name") -- Can use "type"
+		output_mob_stats(mob_counts_wide, total_mobs, true)
 	end
 })

mods/ENTITIES/mobs_mc/blaze.lua

@@ -207,5 +207,6 @@ mcl_mobs.register_arrow("mobs_mc:blaze_fireball", {
 	end
 })
 
--- spawn eggs
+mcl_mobs:non_spawn_specific("mobs_mc:blaze", "overworld", 0, 11)
+-- spawn eggs.
 mcl_mobs.register_egg("mobs_mc:blaze", S("Blaze"), "#f6b201", "#fff87e", 0)

mods/ENTITIES/mobs_mc/chicken.lua

@@ -12,13 +12,13 @@ mcl_mobs.register_mob("mobs_mc:chicken", {
 	description = S("Chicken"),
 	type = "animal",
 	spawn_class = "passive",
-
+	passive = true,
+	runaway = true,
 	hp_min = 4,
 	hp_max = 4,
 	xp_min = 1,
 	xp_max = 3,
 	collisionbox = {-0.2, -0.01, -0.2, 0.2, 0.69, 0.2},
-	runaway = true,
 	floats = 1,
 	head_swivel = "head.control",
 	bone_eye_height = 4,

mods/ENTITIES/mobs_mc/cod.lua

@@ -40,14 +40,14 @@ local cod = {
 	xp_max = 3,
 	armor = 100,
 	rotate = 180,
-	spawn_in_group_min = 3,
+	spawn_in_group_min = 2, -- was 3
-	spawn_in_group = 8,
+	spawn_in_group = 4, -- was 8 nerfed until we can cap them properly locally. this is a group size, not a per spawn attempt
 	tilt_swim = true,
 	collisionbox = {-0.3, 0.0, -0.3, 0.3, 0.79, 0.3},
 	visual = "mesh",
 	mesh = "extra_mobs_cod.b3d",
 	textures = {
-		{"extra_mobs_cod.png"}
+		{"mobs_mc_cod.png"}
 	},
 	sounds = {
 	},

mods/ENTITIES/mobs_mc/cow+mooshroom.lua

@@ -7,13 +7,14 @@ local cow_def = {
 	type = "animal",
 	spawn_class = "passive",
 	passive = true,
+	runaway = true,
 	hp_min = 10,
 	hp_max = 10,
 	xp_min = 1,
 	xp_max = 3,
 	collisionbox = {-0.45, -0.01, -0.45, 0.45, 1.39, 0.45},
 	spawn_in_group = 4,
-	spawn_in_group_min = 3,
+	spawn_in_group_min = 2,
 	visual = "mesh",
 	mesh = "mobs_mc_cow.b3d",
 	textures = { {
@@ -40,7 +41,6 @@ local cow_def = {
 		max = 2,
 		looting = "common",},
 	},
-	runaway = true,
 	sounds = {
 		random = "mobs_mc_cow",
 		damage = "mobs_mc_cow_hurt",
@@ -93,8 +93,8 @@ mcl_mobs.register_mob("mobs_mc:cow", cow_def)
 -- Mooshroom
 local mooshroom_def = table.copy(cow_def)
 mooshroom_def.description = S("Mooshroom")
-mooshroom_def.spawn_in_group_min = 4
+mooshroom_def.spawn_in_group_min = 2
-mooshroom_def.spawn_in_group = 8
+mooshroom_def.spawn_in_group = 4
 mooshroom_def.textures = { {"mobs_mc_mooshroom.png", "mobs_mc_mushroom_red.png"}, {"mobs_mc_mooshroom_brown.png", "mobs_mc_mushroom_brown.png" } }
 mooshroom_def.on_rightclick = function(self, clicker)
 	if self:feed_tame(clicker, 1, true, false) then return end

mods/ENTITIES/mobs_mc/creeper.lua

@@ -39,7 +39,7 @@ mcl_mobs.register_mob("mobs_mc:creeper", {
 	},
 	makes_footstep_sound = true,
 	walk_velocity = 1.05,
-	run_velocity = 2.1,
+	run_velocity = 2.0,
 	runaway_from = { "mobs_mc:ocelot", "mobs_mc:cat" },
 	attack_type = "explode",
 

mods/ENTITIES/mobs_mc/dolphin.lua

@@ -42,8 +42,8 @@ local dolphin = {
 	walk_chance = 100,
 	breath_max = 120,
 	rotate = 180,
-	spawn_in_group_min = 3,
+	spawn_in_group_min = 2, -- was 3
-	spawn_in_group = 5,
+	spawn_in_group = 4, -- was 4. nerfed until water has own cap, and it represents max pack size rather than per spawn attempt
 	tilt_swim = true,
 	collisionbox = {-0.3, 0.0, -0.3, 0.3, 0.79, 0.3},
 	visual = "mesh",

mods/ENTITIES/mobs_mc/ender_dragon.lua

@@ -174,3 +174,4 @@ mcl_mobs.register_egg("mobs_mc:enderdragon", S("Ender Dragon"), "#252525", "#b31
 
 
 mcl_wip.register_wip_item("mobs_mc:enderdragon")
+mcl_mobs:non_spawn_specific("mobs_mc:enderdragon","overworld",0,minetest.LIGHT_MAX+1)

mods/ENTITIES/mobs_mc/enderman.lua

@@ -259,6 +259,7 @@ mcl_mobs.register_mob("mobs_mc:enderman", {
 	description = S("Enderman"),
 	type = "monster",
 	spawn_class = "passive",
+	can_despawn = true,
 	passive = true,
 	pathfinding = 1,
 	hp_min = 40,
@@ -344,7 +345,8 @@ mcl_mobs.register_mob("mobs_mc:enderman", {
 					self:teleport(nil)
 				end
 			end
-		else return end
+		end
+
 		-- AGRESSIVELY WARP/CHASE PLAYER BEHAVIOUR HERE.
 		if self.state == "attack" then
 			if self.attack then
@@ -357,9 +359,11 @@ mcl_mobs.register_mob("mobs_mc:enderman", {
 				end
 			end
 		else --if not attacking try to tp to the dark
-			local light = minetest.get_node_light(enderpos)
+			if dim == 'overworld' then
-			if light and light > minetest.LIGHT_MAX then
+				local light = minetest.get_node_light(enderpos)
-				self:teleport(nil)
+				if light and light > minetest.LIGHT_MAX then
+					self:teleport(nil)
+				end
 			end
 		end
 		-- ARROW / DAYTIME PEOPLE AVOIDANCE BEHAVIOUR HERE.
@@ -386,6 +390,7 @@ mcl_mobs.register_mob("mobs_mc:enderman", {
 				end
 			end
 		end
+
 		-- PROVOKED BEHAVIOUR HERE.
 		local enderpos = self.object:get_pos()
 		if self.provoked == "broke_contact" then
@@ -442,6 +447,23 @@ mcl_mobs.register_mob("mobs_mc:enderman", {
 				end
 			end
 		end
+
+		-- ATTACK ENDERMITE
+		local enderpos = self.object:get_pos()
+		if math.random(1,140) == 1 then
+			local mobsnear = minetest.get_objects_inside_radius(enderpos, 64)
+			for n=1, #mobsnear do
+				local mob = mobsnear[n]
+				if mob then
+					local entity = mob:get_luaentity()
+					if entity and entity.name == "mobs_mc:endermite" then
+						self.attack = mob
+						self.state = 'attack'
+					end
+				end
+			end
+		end
+
 		-- TAKE AND PLACE STUFF BEHAVIOUR BELOW.
 		if not mobs_griefing then
 			return
@@ -469,6 +491,7 @@ mcl_mobs.register_mob("mobs_mc:enderman", {
 					local dug = minetest.get_node_or_nil(take_pos)
 					if dug and dug.name == "air" then
 						self._taken_node = node.name
+						self.can_despawn = false
 						local def = minetest.registered_nodes[self._taken_node]
 						-- Update animation and texture accordingly (adds visibly carried block)
 						local block_type
@@ -519,6 +542,7 @@ mcl_mobs.register_mob("mobs_mc:enderman", {
 				if success then
 					local def = minetest.registered_nodes[self._taken_node]
 					-- Update animation accordingly (removes visible block)
+					self.can_despawn = true
 					self.animation = select_enderman_animation("normal")
 					self:set_animation(self.animation.current)
 					if def.sounds and def.sounds.place then

mods/ENTITIES/mobs_mc/endermite.lua

@@ -39,3 +39,4 @@ mcl_mobs.register_mob("mobs_mc:endermite", {
 })
 
 mcl_mobs.register_egg("mobs_mc:endermite", S("Endermite"), "#161616", "#6d6d6d", 0)
+mcl_mobs:non_spawn_specific("mobs_mc:endermite","overworld",0,7)

mods/ENTITIES/mobs_mc/ghast.lua

@@ -139,6 +139,6 @@ mcl_mobs.register_arrow("mobs_mc:fireball", {
 
 
 
-
+mcl_mobs:non_spawn_specific("mobs_mc:ghast","overworld","0","7")
 -- spawn eggs
 mcl_mobs.register_egg("mobs_mc:ghast", S("Ghast"), "#f9f9f9", "#bcbcbc", 0)

mods/ENTITIES/mobs_mc/glow_squid.lua

@@ -25,7 +25,7 @@ local base_psdef = {
 local psdefs = {}
 for i=1,4 do
 	local p = table.copy(base_psdef)
-	p.texture = "extra_mobs_glow_squid_glint"..i..".png"
+	p.texture = "mobs_mc_glow_squid_glint"..i..".png"
 	table.insert(psdefs,p)
 end
 
@@ -47,7 +47,7 @@ mcl_mobs.register_mob("mobs_mc:glow_squid", {
 	visual = "mesh",
 	mesh = "extra_mobs_glow_squid.b3d",
 	textures = {
-		{ "extra_mobs_glow_squid.png" }
+		{ "mobs_mc_glow_squid.png" }
 	},
 	sounds = {
 		damage = { name = "mobs_mc_squid_hurt", gain = 0.3 },

mods/ENTITIES/mobs_mc/guardian.lua

@@ -102,6 +102,6 @@ mcl_mobs.register_mob("mobs_mc:guardian", {
 -- Spawning disabled due to size issues
 -- TODO: Re-enable spawning
 --mcl_mobs:spawn_specific("mobs_mc:guardian", { "mcl_core:water_source", "mclx_core:river_water_source" }, { "mcl_core:water_source", "mclx_core:river_water_source" }, 0, minetest.LIGHT_MAX+1, 30, 25000, 2, mcl_vars.mg_overworld_min, mobs_mc.water_level - 10)
-
+mcl_mobs:non_spawn_specific("mobs_mc:guardian","overworld",0,minetest.LIGHT_MAX+1)
 -- spawn eggs
 mcl_mobs.register_egg("mobs_mc:guardian", S("Guardian"), "#5a8272", "#f17d31", 0)

mods/ENTITIES/mobs_mc/guardian_elder.lua

@@ -113,5 +113,4 @@ mcl_mobs.register_mob("mobs_mc:guardian_elder", {
 
 -- spawn eggs
 mcl_mobs.register_egg("mobs_mc:guardian_elder", S("Elder Guardian"), "#ceccba", "#747693", 0)
-
+mcl_mobs:non_spawn_specific("mobs_mc:guardian_elder","overworld",0,minetest.LIGHT_MAX+1)
-

mods/ENTITIES/mobs_mc/hoglin+zoglin.lua

@@ -36,7 +36,7 @@ local hoglin = {
 	jump = true,
 	makes_footstep_sound = true,
 	walk_velocity = 1,
-	run_velocity = 4,
+	run_velocity = 2.8,
 	drops = {
 		{name = "mobs_mcitems:leather",
 		chance = 1,
@@ -120,7 +120,6 @@ mcl_mobs:spawn_specific(
 "nether",
 "ground",
 {
-"Nether",
 "CrimsonForest"
 },
 0,
@@ -131,5 +130,7 @@ minetest.LIGHT_MAX+1,
 mcl_vars.mg_nether_min,
 mcl_vars.mg_nether_max)
 
+mcl_mobs:non_spawn_specific("mobs_mc:hoglin","overworld",0,7)
+
 -- spawn eggs
 mcl_mobs.register_egg("mobs_mc:hoglin", S("Hoglin"), "#85682e", "#2b2140", 0)

mods/ENTITIES/mobs_mc/horse.lua

@@ -125,7 +125,7 @@ local horse = {
 	type = "animal",
 	spawn_class = "passive",
 	spawn_in_group_min = 2,
-	spawn_in_group = 6,
+	spawn_in_group = 4, -- was 6. nerfed until group size is a cap rather than per spawn cycle
 	visual = "mesh",
 	mesh = "mobs_mc_horse.b3d",
 	visual_size = {x=3.0, y=3.0},
@@ -646,3 +646,5 @@ mcl_mobs.register_egg("mobs_mc:skeleton_horse", S("Skeleton Horse"), "#68684f",
 --mobs:register_egg("mobs_mc:zombie_horse", S("Zombie Horse"), "#2a5a37", "#84d080", 0)
 mcl_mobs.register_egg("mobs_mc:donkey", S("Donkey"), "#534539", "#867566", 0)
 mcl_mobs.register_egg("mobs_mc:mule", S("Mule"), "#1b0200", "#51331d", 0)
+mcl_mobs:non_spawn_specific("mobs_mc:mule","overworld",9,minetest.LIGHT_MAX+1)
+mcl_mobs:non_spawn_specific("mobs_mc:skeleton_horse","overworld",9,minetest.LIGHT_MAX+1)

mods/ENTITIES/mobs_mc/iron_golem.lua

@@ -15,7 +15,7 @@ mcl_mobs.register_mob("mobs_mc:iron_golem", {
 	description = S("Iron Golem"),
 	type = "npc",
 	spawn_class = "passive",
-	passive = true,
+	passive = false,
 	hp_min = 100,
 	hp_max = 100,
 	breath_max = -1,
@@ -42,7 +42,7 @@ mcl_mobs.register_mob("mobs_mc:iron_golem", {
 	damage = 14,
 	knock_back = false,
 	reach = 3,
-	group_attack = true,
+	group_attack = { "mobs_mc:villager" },
 	attacks_monsters = true,
 	attack_type = "dogfight",
 	_got_poppy = false,
@@ -206,3 +206,4 @@ function mobs_mc.check_iron_golem_summon(pos)
 		end
 	end
 end
+mcl_mobs:non_spawn_specific("mobs_mc:iron_golem","overworld",0,minetest.LIGHT_MAX+1)

mods/ENTITIES/mobs_mc/llama.lua

@@ -56,8 +56,8 @@ mcl_mobs.register_mob("mobs_mc:llama", {
 	shoot_interval = 5.5,
 	arrow = "mobs_mc:llamaspit",
 	shoot_offset = 1, --3.5 *would* be a good value visually but it somehow messes with the projectiles trajectory
-	spawn_in_group_min = 4,
+	spawn_in_group_min = 2, -- was 4
-	spawn_in_group = 6,
+	spawn_in_group = 4, -- was 6 nerfed until we can cap them properly locally. this is a group size, not a per spawn attempt
 
 	head_swivel = "head.control",
 	bone_eye_height = 11,

mods/ENTITIES/mobs_mc/ocelot.lua

@@ -164,7 +164,7 @@ cat.on_spawn  = function(self)
 	if not self._texture then
 		self._texture = cat.textures[math.random(#cat.textures)]
 	end
-	self.object:set_properties({textures = {self._texture}})
+	self.object:set_properties({textures = self._texture})
 end
 
 mcl_mobs.register_mob("mobs_mc:cat", cat)

mods/ENTITIES/mobs_mc/pig.lua

@@ -6,6 +6,7 @@ mcl_mobs.register_mob("mobs_mc:pig", {
 	description = S("Pig"),
 	type = "animal",
 	spawn_class = "passive",
+	passive = true,
 	runaway = true,
 	hp_min = 10,
 	hp_max = 10,

mods/ENTITIES/mobs_mc/piglin.lua

@@ -62,8 +62,8 @@ local piglin = {
 	},
 	jump = true,
 	makes_footstep_sound = true,
-	walk_velocity = 4.317,
+	walk_velocity = 1.4,
-	run_velocity = 5.6121,
+	run_velocity = 2.8,
 	drops = {
 		{name = "mcl_bows:crossbow",
 		chance = 10,
@@ -283,6 +283,7 @@ piglin_brute.group_attack = { "mobs_mc:piglin", "mobs_mc:piglin_brute" }
 mcl_mobs.register_mob("mobs_mc:piglin_brute", piglin_brute)
 
 
+mcl_mobs:non_spawn_specific("mobs_mc:piglin","overworld",0,7)
 -- Regular spawning in the Nether
 mcl_mobs:spawn_specific(
 "mobs_mc:piglin",
@@ -299,7 +300,7 @@ minetest.LIGHT_MAX+1,
 3,
 mcl_vars.mg_lava_nether_max,
 mcl_vars.mg_nether_max)
-
+mcl_mobs:non_spawn_specific("mobs_mc:sword_piglin","overworld",0,7)
 mcl_mobs:spawn_specific(
 "mobs_mc:sword_piglin",
 "nether",
@@ -318,3 +319,4 @@ mcl_vars.mg_nether_max)
 -- spawn eggs
 mcl_mobs.register_egg("mobs_mc:piglin", S("Piglin"), "#7b4a17","#d5c381", 0)
 mcl_mobs.register_egg("mobs_mc:piglin_brute", S("Piglin Brute"), "#562b0c","#ddc89d", 0)
+mcl_mobs:non_spawn_specific("mobs_mc:piglin_brute","overworld",0,7)

mods/ENTITIES/mobs_mc/pillager.lua

@@ -122,3 +122,4 @@ pillager = {
 
 mcl_mobs.register_mob("mobs_mc:pillager", pillager)
 mcl_mobs.register_egg("mobs_mc:pillager", S("Pillager"), "#532f36", "#959b9b", 0)
+mcl_mobs:non_spawn_specific("mobs_mc:pillager","overworld",0,7)

mods/ENTITIES/mobs_mc/rabbit.lua

@@ -217,3 +217,4 @@ mcl_mobs.register_egg("mobs_mc:rabbit", S("Rabbit"), "#995f40", "#734831", 0)
 
 -- Note: This spawn egg does not exist in Minecraft
 mcl_mobs.register_egg("mobs_mc:killer_bunny", S("Killer Bunny"), "#f2f2f2", "#ff0000", 0)
+mcl_mobs:non_spawn_specific("mobs_mc:killer_bunny","overworld",9,minetest.LIGHT_MAX+1)

mods/ENTITIES/mobs_mc/salmon.lua

@@ -25,7 +25,7 @@ local salmon = {
 	visual = "mesh",
 	mesh = "extra_mobs_salmon.b3d",
 	textures = {
-		{"extra_mobs_salmon.png"}
+		{"mobs_mc_salmon.png"}
 	},
 	sounds = {
 	},

mods/ENTITIES/mobs_mc/sheep.lua

@@ -56,6 +56,7 @@ mcl_mobs.register_mob("mobs_mc:sheep", {
 	description = S("Sheep"),
 	type = "animal",
 	spawn_class = "passive",
+	passive = true,
 	hp_min = 8,
 	hp_max = 8,
 	xp_min = 1,

mods/ENTITIES/mobs_mc/shulker.lua

@@ -178,7 +178,7 @@ mcl_mobs.register_arrow("mobs_mc:shulkerbullet", {
 
 
 mcl_mobs.register_egg("mobs_mc:shulker", S("Shulker"), "#946694", "#4d3852", 0)
-
+mcl_mobs:non_spawn_specific("mobs_mc:shulker","overworld",0,minetest.LIGHT_MAX+1)
 --[[
 mcl_mobs:spawn_specific(
 "mobs_mc:shulker",

mods/ENTITIES/mobs_mc/silverfish.lua

@@ -56,3 +56,4 @@ mcl_mobs.register_mob("mobs_mc:silverfish", {
 })
 
 mcl_mobs.register_egg("mobs_mc:silverfish", S("Silverfish"), "#6d6d6d", "#313131", 0)
+mcl_mobs:non_spawn_specific("mobs_mc:silverfish","overworld",0,11)

mods/ENTITIES/mobs_mc/skeleton+stray.lua

@@ -45,7 +45,7 @@ local skeleton = {
 		}
 	},
 	walk_velocity = 1.2,
-	run_velocity = 2.4,
+	run_velocity = 2.0,
 	damage = 2,
 	reach = 2,
 	drops = {
@@ -89,23 +89,11 @@ local skeleton = {
 		die_speed = 15,
 		die_loop = false,
 	},
-	jock = "mobs_mc:spider",
 	on_spawn = function(self)
-		minetest.after(1,function()
+		if math.random(100) == 1 then
-			if self and self.object then
+			self:jock_to("mobs_mc:spider", vector.zero(), vector.zero())
-				if math.random(100) == 1 or self.jockey == true then -- 1% like from MCwiki
+		end
-					self.jockey = true
+		return true
-					local jock = minetest.add_entity(self.object:get_pos(), "mobs_mc:spider")
-					jock:get_luaentity().docile_by_day = false
-					self.object:set_attach(jock, "", vector.new(0,0,0), vector.new(0,0,0))
-				end
-				self.jockey = false
-				return true
-			end
-		end)
-	end,
-	on_detach=function(self, parent)
-		self.jockey = false
 	end,
 	ignited_by_sunlight = true,
 	view_range = 16,

mods/ENTITIES/mobs_mc/skeleton_wither.lua

@@ -43,7 +43,7 @@ mcl_mobs.register_mob("mobs_mc:witherskeleton", {
 		distance = 16,
 	},
 	walk_velocity = 1.2,
-	run_velocity = 2.4,
+	run_velocity = 2.0,
 	damage = 7,
 	reach = 2,
 	drops = {
@@ -118,3 +118,4 @@ mcl_vars.mg_nether_max)
 --]]
 -- spawn eggs
 mcl_mobs.register_egg("mobs_mc:witherskeleton", S("Wither Skeleton"), "#141414", "#474d4d", 0)
+mcl_mobs:non_spawn_specific("mobs_mc:witherskeleton","overworld",0,7)

mods/ENTITIES/mobs_mc/slime+magma_cube.lua

@@ -1,10 +1,111 @@
 --License for code WTFPL and otherwise stated in readmes
-
--- FIXME: Slimes should spawn only in "slime chunks" which make up only
--- 10% of the map.
---
 local S = minetest.get_translator("mobs_mc")
 
+local MAPBLOCK_SIZE = 16
+
+local seed = minetest.get_mapgen_setting("seed")
+
+local slime_chunk_match
+local x_modifier
+local z_modifier
+
+local function split_by_char (inputstr, sep, limit)
+	if sep == nil then
+		sep = "%d"
+	end
+	local t = {}
+
+	local i = 0
+	for str in string.gmatch(inputstr, "(["..sep.."])") do
+		i = i --+ 1
+		table.insert(t, tonumber(str))
+		if limit and i >= limit then
+			break
+		end
+	end
+	return t
+end
+
+--Seed: "16002933932875202103" == random seed
+--Seed: "1807191622654296300" == cheese
+--Seed: "1" = 1
+local function process_seed (seed)
+	--minetest.log("seed: " .. seed)
+
+	local split_chars = split_by_char(tostring(seed), nil, 10)
+
+	slime_chunk_match = split_chars[1]
+	x_modifier = split_chars[2]
+	z_modifier = split_chars[3]
+
+	--minetest.log("x_modifier: " .. tostring(x_modifier))
+	--minetest.log("z_modifier: " .. tostring(z_modifier))
+	--minetest.log("slime_chunk_match: " .. tostring(slime_chunk_match))
+end
+
+local processed = process_seed (seed)
+
+
+local function convert_to_chunk_value (co_ord, modifier)
+	local converted = math.floor(math.abs(co_ord) / MAPBLOCK_SIZE)
+
+	if modifier then
+		converted = (converted + modifier)
+	end
+	converted = converted % 10
+
+	--minetest.log("co_ord: " .. co_ord)
+	--minetest.log("converted: " .. converted)
+	return converted
+end
+
+assert(convert_to_chunk_value(-16) == 1, "Incorrect convert_to_chunk_value result")
+assert(convert_to_chunk_value(-15) == 0, "Incorrect convert_to_chunk_value result")
+assert(convert_to_chunk_value(-1) == 0, "Incorrect convert_to_chunk_value result")
+assert(convert_to_chunk_value(0) == 0, "Incorrect convert_to_chunk_value result")
+assert(convert_to_chunk_value(1) == 0, "Incorrect convert_to_chunk_value result")
+assert(convert_to_chunk_value(15) == 0, "Incorrect convert_to_chunk_value result")
+assert(convert_to_chunk_value(16) == 1, "Incorrect convert_to_chunk_value result")
+assert(convert_to_chunk_value(31) == 1, "Incorrect convert_to_chunk_value result")
+assert(convert_to_chunk_value(32) == 2, "Incorrect convert_to_chunk_value result")
+assert(convert_to_chunk_value(1599) == 9, "Incorrect convert_to_chunk_value result")
+assert(convert_to_chunk_value(1600) == 0, "Incorrect convert_to_chunk_value result")
+
+assert(convert_to_chunk_value(0,9) == 9, "Incorrect convert_to_chunk_value result")
+assert(convert_to_chunk_value(16,5) == 6, "Incorrect convert_to_chunk_value result")
+assert(convert_to_chunk_value(1599,4) == 3, "Incorrect convert_to_chunk_value result")
+
+local function calculate_chunk_value (pos, x_mod, z_mod)
+	local chunk_val = math.abs(convert_to_chunk_value(pos.x, x_mod) - convert_to_chunk_value(pos.z, z_mod)) % 10
+	return chunk_val
+end
+
+assert(calculate_chunk_value(vector.new(0,0,0)) == 0, "calculate_chunk_value failed")
+assert(calculate_chunk_value(vector.new(0,0,0), 1, 1) == 0, "calculate_chunk_value failed")
+assert(calculate_chunk_value(vector.new(0,0,0), 2, 1) == 1, "calculate_chunk_value failed")
+assert(calculate_chunk_value(vector.new(64,0,16)) == (4-1), "calculate_chunk_value failed")
+assert(calculate_chunk_value(vector.new(16,0,64)) == (3), "calculate_chunk_value failed")
+assert(calculate_chunk_value(vector.new(-160,0,-160)) == 0, "calculate_chunk_value failed")
+
+local function is_slime_chunk(pos)
+	if not pos then return end
+
+	local chunk_val = calculate_chunk_value (pos, x_modifier, z_modifier)
+	local slime_chunk = chunk_val == slime_chunk_match
+
+	--minetest.log("x: " ..pos.x ..  ", z:" .. pos.z)
+
+	--minetest.log("seed slime_chunk_match: " .. tostring(slime_chunk_match))
+	--minetest.log("chunk_val: " .. tostring(chunk_val))
+	--minetest.log("Is slime chunk: " .. tostring(slime_chunk))
+	return slime_chunk
+end
+
+local check_position = function (pos)
+	return is_slime_chunk(pos)
+end
+
+
 -- Returns a function that spawns children in a circle around pos.
 -- To be used as on_die callback.
 -- self: mob reference
@@ -104,8 +205,8 @@ local slime_big = {
 	attack_type = "dogfight",
 	passive = false,
 	jump = true,
-	walk_velocity = 2.5,
+	walk_velocity = 1.9,
-	run_velocity = 2.5,
+	run_velocity = 1.9,
 	walk_chance = 0,
 	jump_height = 5.2,
 	fear_height = 0,
@@ -125,8 +226,8 @@ slime_small.collisionbox = {-0.51, -0.01, -0.51, 0.51, 1.00, 0.51}
 slime_small.visual_size = {x=6.25, y=6.25}
 slime_small.damage = 3
 slime_small.reach = 2.75
-slime_small.walk_velocity = 1.3
+slime_small.walk_velocity = 1.8
-slime_small.run_velocity = 1.3
+slime_small.run_velocity = 1.8
 slime_small.jump_height = 4.3
 slime_small.spawn_small_alternative = "mobs_mc:slime_tiny"
 slime_small.on_die = spawn_children_on_die("mobs_mc:slime_tiny", 0.6, 1.0)
@@ -149,8 +250,8 @@ slime_tiny.drops = {
 	min = 0,
 	max = 2,},
 }
-slime_tiny.walk_velocity = 0.7
+slime_tiny.walk_velocity = 1.7
-slime_tiny.run_velocity = 0.7
+slime_tiny.run_velocity = 1.7
 slime_tiny.jump_height = 3
 slime_tiny.spawn_small_alternative = nil
 slime_tiny.on_die = nil
@@ -212,7 +313,8 @@ minetest.LIGHT_MAX+1,
 12000,
 4,
 cave_min,
-cave_max)
+cave_max,
+nil, nil, check_position)
 
 mcl_mobs:spawn_specific(
 "mobs_mc:slime_tiny",
@@ -238,7 +340,8 @@ minetest.LIGHT_MAX+1,
 8500,
 4,
 cave_min,
-cave_max)
+cave_max,
+nil, nil, check_position)
 
 mcl_mobs:spawn_specific(
 "mobs_mc:slime_small",
@@ -264,7 +367,8 @@ minetest.LIGHT_MAX+1,
 10000,
 4,
 cave_min,
-cave_max)
+cave_max,
+nil, nil, check_position)
 
 mcl_mobs:spawn_specific(
 "mobs_mc:slime_big",
@@ -300,8 +404,8 @@ local magma_cube_big = {
 		attack = "mobs_mc_magma_cube_attack",
 		distance = 16,
 	},
-	walk_velocity = 4,
+	walk_velocity = 2.5,
-	run_velocity = 4,
+	run_velocity = 2.5,
 	damage = 6,
 	reach = 3,
 	armor = 53,
@@ -353,7 +457,7 @@ magma_cube_small.visual_size = {x=6.25, y=6.25}
 magma_cube_small.damage = 3
 magma_cube_small.reach = 2.75
 magma_cube_small.walk_velocity = .8
-magma_cube_small.run_velocity = 2.6
+magma_cube_small.run_velocity = 2.0
 magma_cube_small.jump_height = 6
 magma_cube_small.damage = 4
 magma_cube_small.reach = 2.75
@@ -431,6 +535,11 @@ nether_max)
 -- spawn eggs
 mcl_mobs.register_egg("mobs_mc:magma_cube_big", S("Magma Cube"), "#350000", "#fcfc00")
 
+-- non_spawn_specific is typically for mobs who don't spawn in the overworld, or mobs that don't spawn
+-- naturally. However, slimes are a particular case where they spawn under different conditions in the same
+-- dimension.
+mcl_mobs:non_spawn_specific("mobs_mc:slime_big","overworld",0,minetest.LIGHT_MAX+1)
+mcl_mobs:non_spawn_specific("mobs_mc:magma_cube_big","overworld",0, minetest.LIGHT_MAX+1)
 mcl_mobs.register_egg("mobs_mc:slime_big", S("Slime"), "#52a03e", "#7ebf6d")
 
 -- FIXME: add spawn eggs for small and tiny slimes and magma cubes

mods/ENTITIES/mobs_mc/snowman.lua

@@ -197,3 +197,4 @@ end
 
 -- Spawn egg
 mcl_mobs.register_egg("mobs_mc:snowman", S("Snow Golem"), "#f2f2f2", "#fd8f47", 0)
+mcl_mobs:non_spawn_specific("mobs_mc:snowman","overworld",0,minetest.LIGHT_MAX+1)

mods/ENTITIES/mobs_mc/spider.lua

@@ -62,9 +62,6 @@ local spider = {
 			self.object:get_children()[1]:set_detach()
 		end
 	end,
-	detach_child=function(self, child)
-		child:get_luaentity().jockey = false
-	end,
 	head_swivel = "Head_Control",
 	bone_eye_height = 1,
 	curiosity = 10,
@@ -86,7 +83,7 @@ local spider = {
 		distance = 16,
 	},
 	walk_velocity = 1.3,
-	run_velocity = 2.8,
+	run_velocity = 2.4,
 	jump = true,
 	jump_height = 4,
 	view_range = 16,
@@ -292,6 +289,8 @@ mcl_mobs:spawn_specific(
 mcl_vars.mg_overworld_min,
 mcl_vars.mg_overworld_max)
 
+mcl_mobs:non_spawn_specific("mobs_mc:cave_spider","overworld",0,7)
+
 -- spawn eggs
 mcl_mobs.register_egg("mobs_mc:spider", S("Spider"), "#342d26", "#a80e0e", 0)
 mcl_mobs.register_egg("mobs_mc:cave_spider", S("Cave Spider"), "#0c424e", "#a80e0e", 0)

mods/ENTITIES/mobs_mc/strider.lua

@@ -246,3 +246,4 @@ mcl_mobs:spawn_setup({
 
 -- spawn eggs
 mcl_mobs.register_egg("mobs_mc:strider", S("Strider"), "#000000", "#FF0000", 0)
+mcl_mobs:non_spawn_specific("mobs_mc:strider","overworld",0,minetest.LIGHT_MAX+1)