Merge branch 'master' into mobs

DO NOT USE IN PRODUCTION, DO NOT START OLD WORLDS WITHOUT A BACKUP
These are the first steps of the new mob API. The game does actually start, but mobs do not work yet.
You will also get some warnings about mob spawners, but don't worry about that.
This is really just some 'first impression' of how the mob API is gonna look like. Some things are already complete, like the agression system.
AI and attacking have not been worked on yet.
mobs_mc and mcl_mobs have actually been merged into one piece but I will probably change that again in the future actually, and split the different mobs into different mods.
There are also a few usefull things like the universal mount API and a more general purpose smoke API, but all of this is still far from complete.
I'll put some work into the API this week but probably not next week, then I'll see but don't expect this to be done before 2022.
I'll work on it, but I'll do it slowly and progressively to not get burned out again and to still have enough time to graduate from school in the meantime.

CODE_OF_CONDUCT.md

@@ -1,128 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, religion, or sexual identity
-and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment for our
-community include:
-
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
-  overall community
-
-Examples of unacceptable behavior include:
-
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Enforcement Responsibilities
-
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
-
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
-
-## Scope
-
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official e-mail address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-eliasfleckenstein@web.de.
-All complaints will be reviewed and investigated promptly and fairly.
-
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
-
-## Enforcement Guidelines
-
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
-
-### 1. Correction
-
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
-
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
-
-### 2. Warning
-
-**Community Impact**: A violation through a single incident or series
-of actions.
-
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or
-permanent ban.
-
-### 3. Temporary Ban
-
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
-
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
-
-### 4. Permanent Ban
-
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
-
-**Consequence**: A permanent ban from any sort of public interaction within
-the community.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
-
-Community Impact Guidelines were inspired by [Mozilla's code of conduct
-enforcement ladder](https://github.com/mozilla/diversity).
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -1,414 +1,105 @@
-# Contributing to MineClone2
-So you want to contribute to MineClone2?
+# Contributing to MineClone 2
+So you want to contribute to MineClone 2?
 Wow, thank you! :-)
 
-MineClone2 is maintained by Nicu and Fleckenstein. If you have any
-problems or questions, contact us (See Links section below).
+But first, some things to note:
 
-You can help with MineClone2's development in many different ways,
-whether you're a programmer or not.
+MineClone 2's development target is to make a free software clone of Minecraft,
+***version 1.12***, ***PC edition***, *** + Optifine features supported by the Minetest Engine ***.
 
-## MineClone2's development target is to...
-- Crucially, create a stable, moddable, free/libre clone of Minecraft
-based on the Minetest engine with polished features, usable in both
-singleplayer and multiplayer. Currently, most of **Minecraft Java
-Edition 1.12.2** features are already implemented and polishing existing
-features are prioritized over new feature requests.
-- With lessened priority yet strictly, implement features targetting
-**Minecraft version 1.17 + OptiFine** (OptiFine only as far as supported
-by the Minetest Engine). This means features in parity with the listed
-Minecraft experiences are prioritized over those that don't fulfill this
-scope.
-- Optionally, create a performant experience that will run relatively
-well on really low spec computers. Unfortunately, due to Minecraft's
-mechanisms and Minetest engine's limitations along with a very small
-playerbase on low spec computers, optimizations are hard to investigate.
+MineClone 2 is maintained by three persons. Namely, kay27, EliasFleckenstein and jordan4ibanez. You can find us
+in the Minetest forums (forums.minetest.net), in IRC in the #mineclone2
+channel on irc.freenode.net. And finally, you can send e-mails to
+<eliasfleckenstein@web.de> or <kay27@bk.ru>.
 
-## Links
-* [Mesehub](https://git.minetest.land/MineClone2/MineClone2)
-* [Discord](https://discord.gg/xE4z8EEpDC)
-* [YouTube](https://www.youtube.com/channel/UClI_YcsXMF3KNeJtoBfnk9A)
-* [IRC](https://web.libera.chat/#mineclone2)
-* [Matrix](https://app.element.io/#/room/#mc2:matrix.org)
-* [Reddit](https://www.reddit.com/r/MineClone2/)
-* [Minetest forums](https://forum.minetest.net/viewtopic.php?f=50&t=16407)
-* [ContentDB](https://content.minetest.net/packages/wuzzy/mineclone2/)
-* [OpenCollective](https://opencollective.com/mineclone2)
+By sending us patches or asking us to include your changes in this game,
+you agree that they fall under the terms of the LGPLv2.1, which basically
+means they will become part of a free software.
 
-## Using git
-MineClone2 is developed using the version control system
-[git](https://git-scm.com/). If you want to contribute code to the
-project, it is **highly recommended** that you learn the git basics.
-For non-programmers and people who do not plan to contribute code to
-MineClone2, git is not required. However, git is a tool that will be
-referenced frequently because of its usefulness. As such, it is valuable
-in learning how git works and its terminology. It can also help you
-keeping your game updated, and easily test pull requests.
+## The suggested workflow
+We don't **dictate** your workflow, but in order to work with us in an efficient
+way, you can follow these suggestions:
 
-## How you can help as a non-programmer
+For small and medium changes:
 
-As someone who does not know how to write programs in Lua or does not
-know how to use the Minetest API, you can still help us out a lot. For
-example, by opening an issue in the
-[Issue tracker](https://git.minetest.land/MineClone2/MineClone2/issues),
-you can report a bug or request a feature.
-
-### Rules about both bugs and feature requests
-* Stay polite towards the developers and anyone else involved in the
-discussion.
-* Choose a descriptive title (e.g. not just "crash", "bug" or "question"
-).
-* Please write in plain, understandable English. It will be easier to
-communicate.
-* Please start the issue title with a capital letter.
-* Always check the currently opened issues before creating a new one.
-Don't report bugs that have already been reported or request features
-that already have been requested.
-* If you know about Minetest's inner workings, please think about
-whether the bug / the feature that you are reporting / requesting is
-actually an issue with Minetest itself, and if it is, head to the
-[Minetest issue tracker](https://github.com/minetest/minetest/issues)
-instead.
-* If you need any help regarding creating a Mesehub account or opening
-an issue, feel free to ask on the Discord / Matrix server or the IRC
-channel.
-
-### Reporting bugs
-* A bug is an unintended behavior or, in the worst case, a crash.
-However, it is not a bug if you believe something is missing in the
-game. In this case, please read "Requesting features"
-* If you report a crash, always include the error message. If you play
-in singleplayer, post a screenshot of the message that Minetest showed
-when the crash happened (or copy the message into your issue). If you
-are a server admin, you can find error messages in the log file of the
-server.
-* Tell us which MineClone2 and Minetest versions you are using.
-* Tell us how to reproduce the problem: What you were doing to trigger
-the bug, e.g. before the crash happened or what causes the faulty
-behavior.
-
-### Requesting features
-* Ensure the requested feature fulfills our development targets and
-goals.
-* Begging or excessive attention seeking does not help us in the
-slightest, and may very well disrupt MineClone2 development. It's better
-to put that energy into helping or researching the feature in question.
-After all, we're just volunteers working on our spare time.
-* Ensure the requested feature has not been implemented in MineClone2
-latest or development versions.
-
-### Testing code
-If you want to help us with speeding up MineClone2 development and
-making the game more stable, a great way to do that is by testing out
-new features from contributors. For most new things that get into the
-game, a pull request is created. A pull request is essentially a
-programmer saying "Look, I modified the game, please apply my changes
-to the upstream version of the game". However, every programmer makes
-mistakes sometimes, some of which are hard to spot. You can help by
-downloading this modified version of the game and trying it out - then
-tell us if the code works as expected without any issues. Ideally, you
-would report issues will pull requests similar to when you were
-reporting bugs that are the mainline (See Reporting bugs section). You
-can find currently open pull requests here:
-<https://git.minetest.land/MineClone2/MineClone2/pulls>. Note that pull
-requests that start with a `WIP:` are not done yet, and therefore might
-not work, so it's not very useful to try them out yet.
-
-### Contributing assets
-Due to license problems, MineClone2 unfortunately cannot use
-Minecraft's assets, therefore we are always looking for asset
-contributions. To contribute assets, it can be useful to learn git
-basics and read the section for Programmers of this document, however
-this is not required. It's also a good idea to join the Discord server
-(or alternatively IRC or Matrix).
-
-#### Textures
-For textures we use the Pixel Perfection texture pack. This is mostly
-enough; however in some cases - e.g. for newer Minecraft features, it's
-useful to have texture artists around. If you want to make such
-contributions, join our Discord server. Demands for textures will be
-communicated there.
-
-#### Sounds
-MineClone2 currently does not have a consistent way to handle sounds.
-The sounds in the game come from different sources, like the SnowZone
-resource pack or minetest_game. Unfortunately, MineClone2 does not play
-a sound in every situation you would get one in Minecraft. Any help with
-sounds is greatly appreciated, however if you add new sounds you should
-probably work together with a programmer, to write the code to actually
-play these sounds in game.
-
-#### 3D Models
-Most of the 3D Models in MineClone2 come from
-[22i's repository](https://github.com/22i/minecraft-voxel-blender-models).
-Similar to the textures, we need people that can make 3D Models with
-Blender on demand. Many of the models have to be patched, some new
-animations have to be added etc.
-
-#### Crediting
-Asset contributions will be credited in their own respective sections in
-CREDITS.md. If you have commited the results yourself, you will also be
-credited in the Contributors section.
-
-### Contributing Translations
-
-#### Workflow
-To add/update support for your language to MineClone2, you should take
-the steps documented in the section for Programmers, add/update the
-translation files of the mods that you want to update. You can add
-support for all mods, just some of them or only one mod; you can update
-the translation file entirely or only partly; basically any effort is
-valued. If your changes are small, you can also send them to developers
-via E-Mail, Discord, IRC or Matrix - they will credit you appropriately.
-
-#### Things to note
-You can use the script at `tools/check_translate_files.py` to compare
-the translation files for the language you are working on with the
-template files, to see what is missing and what is out of date with
-the template file. However, template files are often incomplete and/or
-out of date, sometimes they don't match the code. You can update the
-translation files if that is required, you can also modify the code in
-your translation PR if it's related to translation. You can also work on
-multiple languages at the same time in one PR.
-
-#### Crediting
-Translation contributions will be credited in their own in CREDITS.md.
-If you have commited the results yourself, you will also be credited in
-the Contributors section.
-
-### Profiling
-If you own a server, a great way to help us improve MineClone2's code
-is by giving us profiler results. Profiler results give us detailed
-information about the game's performance and let us know places to
-investigate optimization issues. This way we can make the game faster.
-
-#### Using Minetest's profiler
-Minetest has a built in profiler. Simply set `profiler.load = true` in
-your configuration file and restart the server. After running the server
-for some time, just run `/profiler save` in chat - then you will find a
-file in the world directory containing the results. Open a new issue and
-upload the file. You can name the issue "<Server name> profiler
-results".
-
-### Let us know your opinion
-It is always encouraged to actively contribute to issue discussions on
-MeseHub, let us know what you think about a topic and help us make
-decisions. Also, note that a lot of discussion takes place on the
-Discord server, so it's definitely worth checking it out.
-
-### Funding
-You can help pay for our infrastructure (Mesehub) by donating to our
-OpenCollective link (See Links section).
-
-### Crediting
-If you opened or have contributed to an issue, you receive the
-`Community` role on our Discord (after asking for it).
-OpenCollective Funders are credited in their own section in
-`CREDITS.md` and receive a special role "Funder" on our discord (unless
-they have made their donation Incognito).
-
-## How you can help as a programmer
-(Almost) all the MineClone2 development is done using pull requests.
-
-### Recommended workflow
-* Fork the repository (in case you have not already)
+* Fork the repository
 * Do your change in a new branch
 * Create a pull request to get your changes merged into master
-* Keep your pull request up to date by regularly merging upstream. It is
-imperative that conflicts are resolved prior to merging the pull
-request.
-* After the pull request got merged, you can delete the branch
 
-### Discuss first
-If you feel like a problem needs to fixed or you want to make a new
-feature, you could start writing the code right away and notifying us
-when you're done, but it never hurts to discuss things first. If there
-is no issue on the topic, open one. If there is an issue, tell us that
-you'd like to take care of it, to avoid duplicate work.
+For small changes, sending us a patch is also good.
 
-### Don't hesitate to ask for help
-We appreciate any contributing effort to MineClone2. If you are a
-relatively new programmer, you can reach us on Discord, Matrix or IRC
-for questions about git, Lua, Minetest API, MineClone2 codebase or
-anything related to MineClone2. We can help you avoid writing code that
-would be deemed inadequate, or help you become familiar with MineClone2
-better, or assist you use development tools.
+For big changes: Same as above, but consider notifying us first to avoid
+duplicate work and possible tears of rejection. ;-)
 
-### Maintain your own code, even if already got merged
-Sometimes, your code may cause crashes or bugs - we try to avoid such
-scenarios by testing every time before merging it, but if your merged
-work causes problems, we ask you fix the issues as soon as possible.
+For trusted people, we might give them direct commit access to this
+repository. In this case, you obviously don't need to fork, but you still
+need to show your contributions align with the project goals. We still
+reserve the right to revert everything that we don't like.
+For bigger changes, we strongly recommend to use feature branches and
+discuss with me first.
 
-### 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
-before they are merged.
-You can use these sources:
+If your code causes bugs and crashes, it is your responsibility to fix them as soon as possible.
 
-* Minecraft code (Name the source file and line, however DONT post any
-proprietary code). You can use
-[MCP](https://minecraft.fandom.com/wiki/Programs_and_editors/Mod_Coder_Pack)
-to decompile Minecraft or look at
-[Minestorm](https://github.com/Minestom/Minestom) code.
-* Testing things inside of Minecraft (Attach screenshots / video footage
-of the results)
-* [Official Minecraft Wiki](https://minecraft.fandom.com/wiki/Minecraft_Wiki)
-(Include a link to the specific page you used)
+We mostly use plain merging rather than rebasing or squash merging.
 
-### Stick to our guidelines
+Your commit names should be relatively descriptive, e.g. when saying "Fix #issueid", the commit message should also contain the title of the issue.
 
-#### Git Guidelines
-* We use merge rather than rebase or squash merge
-* We don't use git submodules.
-* Your commit names should be relatively descriptive, e.g. when saying
-"Fix #issueid", the commit message should also contain the title of the
-issue.
-* Try to keep your commits as atomic as possible (advise, but completely
-optional)
+Contributors will be credited in `CREDITS.md`.
 
-#### Code Guidelines
-* Each mod must provide `mod.conf`.
-* Mod names are snake case, and newly added mods start with `mcl_`, e.g.
-`mcl_core`, `mcl_farming`, `mcl_monster_eggs`. Keep in mind Minetest
-does not support capital letters in mod names.
-* To export functions, store them inside a global table named like the
-mod, e.g.
+## Code Style
 
+Each mod must provide `mod.conf`.
+Each mod which add API functions should store functions inside a global table named like the mod.
+Public functions should not use self references but rather just access the table directly.
+Functions should be defined in this way:
 ```lua
-mcl_example = {}
-
-function mcl_example.do_something()
-	-- ...
-end
+function mcl_xyz.stuff(param) end
+```
+Insteed of this way:
+```lua
+mcl_xyz.stuff = function(param) end
+```
+Indentation must be unified, more likely with tabs.
 
+Time sensitive mods should make a local copy of most used API functions to improve performances.
+```lua
+local vector = vector
+local get_node = minetest.get_node
 ```
 
-* Public functions should not use self references but rather just access
-the table directly, e.g.
 
-```lua
--- bad
-function mcl_example:do_something()
-end
+## Features > 1.12
 
--- good
-function mcl_example.do_something()
-end
-```
+If you want to make a feature that was added in a Minecraft version later than 1.12, you should fork MineClone5 (mineclone5 branch in the repository) and add your changes to this.
 
-* Use modern Minetest API, e.g. no usage of `minetest.env`
-* Tabs should be used for indent, spaces for alignment, e.g.
+## What we accept
 
-```lua
+* Every MC features up to version 1.12 JE.
+* Every already finished and working good features from versions above (only when making a MineClone5 PR / Contribution).
+* Except features which couldn't be done easily and bugfree because of Minetest engine limitations. Eg. we CAN extend world boundaries by playing with map chunks, just teleporting player onto next layer after 31000 , but it would cost too much (time, code, bugs, performance, stability, etc).
+* Some features, approved by the rest of the community, I mean maybe some voting and really missing any negative feedback.
 
--- use tabs for indent
+## What we reject
 
-for i = 1, 10 do
-	if i % 3 == 0 then
-		print(i)
-	end
-end
+* Any features which cause critical bugs, sending them to rework/fix or trying to fix immediately.
+* Some small portions of big entirely missing features which just definitely break gamplay balance give nothing useful
+* Controversial features, which some people support while others do not should be discussed well, with publishing forum announcements, at least during the week. In case if there are still doubts - send them into the mod.
 
--- use tabs for indent and spaces to align things
+## Reporting bugs
+Report all bugs and missing Minecraft features here:
 
-some_table = {
-	{"a string",                   5},
-	{"a very much longer string", 10},
-}
-```
+<https://git.minetest.land/MineClone2/MineClone2/issues>
 
-* Use double quotes for strings, e.g. `"asdf"` rather than `'asdf'`
-* Use snake_case rather than CamelCase, e.g. `my_function` rather than
-`MyFunction`
-* Don't declare functions as an assignment, e.g.
+## Direct discussion
+We have an IRC channel! Join us on #mineclone2 in freenode.net.
 
-```lua
--- bad
-local some_local_func = function()
-	-- ...
-end
+<ircs://irc.freenode.net:6697/#mineclone2>
 
-my_mod.some_func = function()
-	-- ...
-end
-
--- good
-local function some_local_func()
-	-- ...
-end
-
-function my_mod.some_func()
-	-- ...
-end
-```
-
-### Developer status
-Active and trusted contributors are often granted write access to the
-MineClone2 repository.
-
-#### Developer responsibilities
-- You should not push things directly to
-MineClone2 master - rather, do your work on a branch on your private
-repository, then create a pull request. This way other people can review
-your changes and make sure they work before they get merged.
-- Merge PRs only when they have recieved the necessary feedback and have
-been tested by at least two different people (including the author of
-the pull request), to avoid crashes or the introduction of new bugs.
-- You may also be assigned to issues or pull
-requests as a developer. In this case it is your responsibility to fix
-the issue / review and merge the pull request when it is ready. You can
-also unassign yourself from the issue / PR if you have no time or don't
-want to take care of it for some other reason. After all, everyone is a
-volunteer and we can't expect you to do work that you are not interested
-in. **The important thing is that you make sure to inform us if you
-won't take care of something that has been assigned to you.**
-- Please assign yourself to something that you want to work on to avoid
-duplicate work.
-- As a developer, it should be easy to reach you about your work. You
-should be in at least one of the public MineClone2 discussion rooms -
-preferrably Discord, but if you really don't like Discord, Matrix
-or IRC are fine too.
-
-### Maintainer status
-Maintainers carry the main responsibility for the project.
-
-#### Maintainer responsibilities
-- Making sure issues are addressed and pull requests are reviewed and
-merged, by assigning either themselves or Developers to issues / PRs
-- Making releases
-- Making sure guidelines are kept
-- Making project decisions based on community feedback
-- Granting/revoking developer access
-- Enforcing the code of conduct (See CODE_OF_CONDUCT.md)
-- Moderating official community spaces (See Links section)
-- Resolving conflicts and problems within the community
-
-#### Current maintainers
-* Fleckenstein - responsible for gameplay review, publishing releases,
-technical guidelines and issue/PR delegation
-* Nicu - responsible for community related issues
-
-#### Release process
-* Run `tools/generate_ingame_credits.lua` to update the ingame credits
-from `CREDITS.md` and commit the result (if anything changed)
+## Creating releases
 * Launch MineClone2 to make sure it still runs
 * Update the version number in README.md
-* Use `git tag <version number>` to tag the latest commit with the
-version number
-* Push to repository (don't forget `--tags`!)
-* Update ContentDB
-(https://content.minetest.net/packages/Wuzzy/mineclone2/)
-* Update first post in forum thread
-(https://forum.minetest.net/viewtopic.php?f=50&t=16407)
+* Use `git tag <version number>` to tag the latest commit with the version number
+* Push to repo (don't forget `--tags`!)
+* Update ContentDB (https://content.minetest.net/packages/Wuzzy/mineclone2/)
+* Update first post in forum thread (https://forum.minetest.net/viewtopic.php?f=50&t=16407)
 * Post release announcement and changelog in forums
-
-### Licensing
-By asking us to include your changes in this game, you agree that they
-fall under the terms of the GPLv3, which basically means they will
-become part of a free/libre software.
-
-### Crediting
-Contributors, Developers and Maintainers will be credited in
-`CREDITS.md`. If you make your first time contribution, please add
-yourself to this file. There are also Discord roles for Contributors,
-Developers and Maintainers.

CREDITS.md

@@ -8,8 +8,8 @@
 
 ## Maintainers
 * Fleckenstein
-* Nicu
 * kay27
+* jordan4ibanez
 
 ## Developers
 * bzoss
@@ -19,11 +19,10 @@
 * iliekprogrammar
 * MysticTempest
 * Rootyjr
+* Nicu
 * aligator
 * Code-Sploit
 * NO11
-* cora
-* jordan4ibanez
 
 ## Contributors
 * Laurent Rocher
@@ -49,25 +48,8 @@
 * dBeans
 * nickolas360
 * yutyo
-* Tianyang Zhang
+* ztianyang
 * j45
-* Marcin Serwin
-* erlehmann
-* E
-* Benjamin Schötz
-* Doloment
-* Sydney Gems
-* talamh
-* Emily2255
-* Emojigit
-* FinishedFragment
-* sfan5
-* Blue Blancmange
-* Jared Moody
-* SmallJoker
-* Sven792
-* aldum
-* Dieter44
 
 ## MineClone5
 * kay27
@@ -92,6 +74,7 @@
 * Rochambeau
 * rubenwardy
 * stu
+* jordan4ibanez
 * 4aiman
 * Kahrl
 * Krock
@@ -120,7 +103,6 @@
 * xMrVizzy
 * yutyo
 * NO11
-* kay27
 
 ## Translations
 * Wuzzy
@@ -128,11 +110,6 @@
 * wuniversales
 * kay27
 * pitchum
-* todoporlalibertad
-* Marcin Serwin
-
-## Funders
-* 40W
 
 ## Special thanks
 * celeron55 for creating Minetest

README.md

@@ -1,4 +1,4 @@
-# MineClone2
+# MineClone 2
 An unofficial Minecraft-like game for Minetest. Forked from MineClone by davedevils.
 Developed by many people. Not developed or endorsed by Mojang AB.
 
@@ -69,9 +69,9 @@ an explanation.
 This game requires [Minetest](http://minetest.net) to run (version 5.3.0 or
 later). So you need to install Minetest first. Only stable versions of Minetest
 are officially supported.
-There is no support for running MineClone2 in development versions of Minetest.
+There is no support for running MineClone 2 in development versions of Minetest.
 
-To install MineClone2 (if you haven't already), move this directory into the
+To install MineClone 2 (if you haven't already), move this directory into the
 “games” directory of your Minetest data directory. Consult the help of
 Minetest to learn more.
 
@@ -85,24 +85,21 @@ The MineClone2 repository is hosted at Mesehub. To contribute or report issues,
 * Matrix: <https://app.element.io/#/room/#mc2:matrix.org>
 * Reddit: <https://www.reddit.com/r/MineClone2/>
 * Minetest forums: <https://forum.minetest.net/viewtopic.php?f=50&t=16407>
-* ContentDB: <https://content.minetest.net/packages/wuzzy/mineclone2/>
-* OpenCollective: <https://opencollective.com/mineclone2>
 
-## Target
-- Crucially, create a stable, moddable, free/libre clone of Minecraft
-based on the Minetest engine with polished features, usable in both
-singleplayer and multiplayer. Currently, most of **Minecraft Java
-Edition 1.12.2** features are already implemented and polishing existing
-features are prioritized over new feature requests.
-- With lessened priority yet strictly, implement features targetting
-**Minecraft version 1.17 + OptiFine** (OptiFine only as far as supported
-by the Minetest Engine). This means features in parity with the listed
-Minecraft experiences are prioritized over those that don't fulfill this
-scope.
-- Optionally, create a performant experience that will run relatively
-well on really low spec computers. Unfortunately, due to Minecraft's
-mechanisms and Minetest engine's limitations along with a very small
-playerbase on low spec computers, optimizations are hard to investigate.
+## Project description
+The main goal of **MineClone 2** is to be a clone of Minecraft and to be released as free software.
+
+* **Target of development: Minecraft, PC Edition, version 1.12** (later known as “Java Edition”)
+* MineClone2 also includes Optifine features supported by the Minetest
+* In general, Minecraft is aimed to be cloned as good as possible
+* Cloning the gameplay has highest priority
+* MineClone 2 will use different assets, but with a similar style
+* Limitations found in Minetest will be documented in the course of development
+* Features of later Minecraft versions are collected in the mineclone5 branch
+
+## Using features from newer versions of Minecraft
+For > 1.12 features, checkout MineClone5. It includes features from newer Minecraft versions.
+Download it here: https://git.minetest.land/MineClone2/MineClone2/src/branch/mineclone5
 
 ## Completion status
 This game is currently in **beta** stage.
@@ -189,7 +186,7 @@ Technical differences from Minecraft:
 * Different engine (Minetest)
 * Different easter eggs
 
-… and finally, MineClone2 is free software (“free” as in “freedom”)!
+… and finally, MineClone 2 is free software (“free” as in “freedom”)!
 
 ## Other readme files
 

mods/CORE/mcl_damage/init.lua

@@ -13,7 +13,7 @@ mcl_damage = {
 		starve = {bypasses_armor = true, bypasses_magic = true},
 		cactus = {},
 		fall = {bypasses_armor = true},
-		fly_into_wall = {bypasses_armor = true}, -- unused
+		fly_into_wall = {bypasses_armor = true},
 		out_of_world = {bypasses_armor = true, bypasses_magic = true, bypasses_invulnerability = true},
 		generic = {bypasses_armor = true},
 		magic = {is_magic = true, bypasses_armor = true},
@@ -28,7 +28,7 @@ mcl_damage = {
 		fireball = {is_projectile = true, is_fire = true},
 		thorns = {is_magic = true},
 		explosion = {is_explosion = true},
-		cramming = {bypasses_armor = true}, -- unused
+		cramming = {bypasses_armor = true},
 		fireworks = {is_explosion = true}, -- unused
 	}
 }
@@ -74,11 +74,11 @@ function mcl_damage.from_punch(mcl_reason, object)
 	mcl_reason.direct = object
 	local luaentity = mcl_reason.direct:get_luaentity()
 	if luaentity then
-		if luaentity._is_arrow then
+		if luaentity.is_arrow then
 			mcl_reason.type = "arrow"
-		elseif luaentity._is_fireball then
+		elseif luaentity.is_fireball then
 			mcl_reason.type = "fireball"
-		elseif luaentity._cmi_is_mob then
+		elseif luaentity.is_mob then
 			mcl_reason.type = "mob"
 		end
 		mcl_reason.source = mcl_reason.source or luaentity._source_object

mods/CORE/mcl_particles/init.lua

@@ -80,52 +80,61 @@ end
 
 -- 3 exptime variants because the animation is not tied to particle expiration time.
 -- 3 colorized variants to imitate minecraft's
-local smoke_pdef_cached = {}
 
-function mcl_particles.spawn_smoke(pos, name, smoke_pdef_base)
-	local new_minpos = vector.add(pos, smoke_pdef_base.minrelpos)
-	local new_maxpos = vector.add(pos, smoke_pdef_base.maxrelpos)
+function mcl_particles.get_smoke_def(def_base)
+	local defs = {}
 
-	-- populate the cache
-	if smoke_pdef_cached[name] then
-		for i, smoke_pdef in ipairs(smoke_pdef_cached[name]) do
-			smoke_pdef.minpos = new_minpos
-			smoke_pdef.maxpos = new_maxpos
-			add_node_particlespawner(pos, smoke_pdef, "high")
-		end
-		-- cache already populated
-	else
-		smoke_pdef_cached[name] = {}
+	local def = table.copy(def_base)
+	def.amount = def.amount / 9
+	def.time = 0
+	def.animation = {
+		type = "vertical_frames",
+		aspect_w = 8,
+		aspect_h = 8,
+		-- length = 3 exptime variants
+	}
+	def.collisiondetection = true
 
-		local smoke_pdef = table.copy(smoke_pdef_base)
-		smoke_pdef.amount = smoke_pdef_base.amount / 9
-		smoke_pdef.time = 0
-		smoke_pdef.animation = {
-			type = "vertical_frames",
-			aspect_w = 8,
-			aspect_h = 8,
-			-- length = 3 exptime variants
-		}
-		smoke_pdef.collisiondetection = true
-		smoke_pdef.minpos = new_minpos
-		smoke_pdef.maxpos = new_maxpos
+	-- the last frame plays for 1/8 * N seconds, so we can take advantage of it
+	-- to have varying exptime for each variant.
+	local exptimes = {0.175, 0.375, 1.0}
+	local colorizes = {"199", "209", "243"} -- round(78%, 82%, 90% of 256) - 1
+	for _, exptime in ipairs(exptimes) do
+		for _, colorize in ipairs(colorizes) do
+			def.maxexptime = exptime * def_base.maxexptime
+			def.animation.length = exptime + 0.1
+			-- minexptime must be set such that the last frame is actully rendered,
+			-- even if its very short. Larger exptime -> larger range
+			def.minexptime = math.min(exptime, (7.0 / 8.0 * (exptime + 0.1) + 0.1))
+			def.texture = "mcl_particles_smoke_anim.png^[colorize:#000000:" .. colorize
 
-		-- the last frame plays for 1/8 * N seconds, so we can take advantage of it
-		-- to have varying exptime for each variant.
-		local exptimes = { 0.175, 0.375, 1.0 }
-		local colorizes = { "199", "209", "243" } -- round(78%, 82%, 90% of 256) - 1
-
-		for _,exptime in ipairs(exptimes) do
-			for _,colorize in ipairs(colorizes) do
-				smoke_pdef.maxexptime = exptime * smoke_pdef_base.maxexptime
-				smoke_pdef.animation.length = exptime + 0.1
-				-- minexptime must be set such that the last frame is actully rendered,
-				-- even if its very short. Larger exptime -> larger range
-				smoke_pdef.minexptime = math.min(exptime, (7.0/8.0 * (exptime + 0.1) + 0.1))
-				smoke_pdef.texture = "mcl_particles_smoke_anim.png^[colorize:#000000:" ..colorize
-				add_node_particlespawner(pos, smoke_pdef, "high")
-				table.insert(smoke_pdef_cached[name], table.copy(smoke_pdef))
-			end
+			table.insert(defs, table.copy(def))
 		end
 	end
-end
+
+	return defs
+end
+
+function mcl_particles.add_node_smoke_particlespawner(pos, defs)
+	local minpos = vector.add(pos, defs[1].minrelpos)
+	local maxpos = vector.add(pos, defs[1].maxrelpos)
+
+	for i, def in ipairs(defs) do
+		def.minpos = minpos
+		def.maxpos = maxpos
+		def.attached = nil
+		mcl_particles.add_node_particlespawner(pos, def, "high")
+	end
+end
+
+function mcl_particles.add_object_smoke_particlespawner(obj, defs)
+	local minpos = defs[1].minrelpos
+	local maxpos = defs[1].maxrelpos
+
+	for i, def in ipairs(defs) do
+		def.minpos = def.minrelpos
+		def.maxpos = def.maxrelpos
+		def.attached = obj
+		minetest.add_particlespawner(def)
+	end
+end

mods/CORE/mcl_sounds/README.txt

@@ -17,6 +17,8 @@ Glass breaking sounds (CC BY 3.0):
 
 default_tool_breaks.ogg by EdgardEdition (CC BY 3.0), http://www.freesound.org/people/EdgardEdition
 
+mcl_sounds_poof.ogg by Planman (CC 0), https://freesound.org/people/Planman/sounds/208111/
+
 Mito551 (sounds) (CC BY-SA 3.0):
   default_dig_choppy.ogg
   default_dig_cracky.ogg

mods/CORE/mcl_util/init.lua

@@ -1,27 +1,5 @@
 mcl_util = {}
 
--- Updates all values in t using values from to*.
-function table.update(t, ...)
-	for _, to in ipairs{...} do
-		for k,v in pairs(to) do
-			t[k] = v
-		end
-	end
-	return t
-end
-
--- Updates nil values in t using values from to*.
-function table.update_nil(t, ...)
-	for _, to in ipairs{...} do
-		for k,v in pairs(to) do
-			if t[k] == nil then
-				t[k] = v
-			end
-		end
-	end
-	return t
-end
-
 -- Based on minetest.rotate_and_place
 
 --[[
@@ -492,32 +470,22 @@ end
 function mcl_util.deal_damage(target, damage, mcl_reason)
 	local luaentity = target:get_luaentity()
 
-	if luaentity then
-		if luaentity.deal_damage then
-			luaentity:deal_damage(damage, mcl_reason or {type = "generic"})
-			return
-		elseif luaentity._cmi_is_mob then
-			-- local puncher = mcl_reason and mcl_reason.direct or target
-			-- target:punch(puncher, 1.0, {full_punch_interval = 1.0, damage_groups = {fleshy = damage}}, vector.direction(puncher:get_pos(), target:get_pos()), damage)
-			if luaentity.health > 0 then
-				luaentity.health = luaentity.health - damage
-			end
-			return
+	if luaentity and luaentity.deal_damage then
+		luaentity:deal_damage(damage, mcl_reason or {type = "generic"})
+	else
+		local hp = target:get_hp()
+
+		if hp > 0 then
+			target:set_hp(hp - damage, {_mcl_reason = mcl_reason})
 		end
 	end
-
-	local hp = target:get_hp()
-
-	if hp > 0 then
-		target:set_hp(hp - damage, {_mcl_reason = mcl_reason})
-	end
 end
 
 function mcl_util.get_hp(obj)
 	local luaentity = obj:get_luaentity()
 
-	if luaentity and luaentity._cmi_is_mob then
-		return luaentity.health
+	if luaentity and luaentity.is_mob then
+		return luaentity.data.health
 	else
 		return obj:get_hp()
 	end

mods/CORE/mcl_worlds/API.md

@@ -12,7 +12,7 @@ Params:
 
 * pos: position
 
-## mcl_worlds.y_to_layer(y)
+## mcl_worlds.y_to_layer(y)
 This function is used to calculate the minetest y layer and dimension of the given <y> minecraft layer.
 Mainly used for ore generation.
 Takes an Y coordinate as input and returns:
@@ -78,4 +78,4 @@ Table containing all function registered with mcl_worlds.register_on_dimension_c
 Notify this mod of a dimension change of <player> to <dimension>
 
 * player: player, player who changed the dimension
-* dimension: string, new dimension ("overworld", "nether", "end", "void")
+* dimension: string, new dimension ("overworld", "nether", "end", "void")

mods/CORE/tga_encoder/init.lua

@@ -38,32 +38,18 @@ function image:encode_header()
 	self.data = self.data
 		.. string.char(0) -- image id
 		.. string.char(0) -- color map type
-		.. string.char(10) -- image type (RLE RGB = 10)
+		.. string.char(2) -- image type (uncompressed true-color image = 2)
 	self:encode_colormap_spec() -- color map specification
 	self:encode_image_spec() -- image specification
 end
 
 function image:encode_data()
-	local current_pixel = ''
-	local previous_pixel = ''
-	local count = 1
-	local packets = {}
-	local rle_packet = ''
 	for _, row in ipairs(self.pixels) do
 		for _, pixel in ipairs(row) do
-			current_pixel = string.char(pixel[3], pixel[2], pixel[1])
-			if current_pixel ~= previous_pixel or count == 128 then
-				packets[#packets +1] = rle_packet
-				count = 1
-				previous_pixel = current_pixel
-			else
-				count = count + 1
-			end
-			rle_packet = string.char(128 + count - 1) .. current_pixel
+			self.data = self.data
+				.. string.char(pixel[3], pixel[2], pixel[1])
 		end
 	end
-	packets[#packets +1] = rle_packet
-	self.data = self.data .. table.concat(packets)
 end
 
 function image:encode_footer()

mods/ENTITIES/drippingwater/init.lua

@@ -0,0 +1,114 @@
+--Dripping Water Mod
+--by kddekadenz
+
+local math = math
+
+-- License of code, textures & sounds: CC0
+
+--Drop entities
+
+--water
+
+local water_tex = "default_water_source_animated.png^[verticalframe:16:0"
+minetest.register_entity("drippingwater:drop_water", {
+	hp_max = 1,
+	physical = true,
+	collide_with_objects = false,
+	collisionbox = {-0.025,-0.05,-0.025,0.025,-0.01,0.025},
+	pointable = false,
+	visual = "cube",
+	visual_size = {x=0.05, y=0.1},
+	textures = {water_tex, water_tex, water_tex, water_tex, water_tex, water_tex},
+	spritediv = {x=1, y=1},
+	initial_sprite_basepos = {x=0, y=0},
+	static_save = false,
+	on_activate = function(self, staticdata)
+		self.object:set_sprite({x=0,y=0}, 1, 1, true)
+	end,
+	on_step = function(self, dtime)
+		local k = math.random(1,222)
+		local ownpos = self.object:get_pos()
+		if k==1 then
+			self.object:set_acceleration({x=0, y=-5, z=0})
+		end
+		if minetest.get_node({x=ownpos.x, y=ownpos.y +0.5, z=ownpos.z}).name == "air" then
+			self.object:set_acceleration({x=0, y=-5, z=0})
+		end
+		if minetest.get_node({x=ownpos.x, y=ownpos.y -0.5, z=ownpos.z}).name ~= "air" then
+			self.object:remove()
+			minetest.sound_play({name="drippingwater_drip"}, {pos = ownpos, gain = 0.5, max_hear_distance = 8}, true)
+		end
+	end,
+})
+
+
+--lava
+
+local lava_tex = "default_lava_source_animated.png^[verticalframe:16:0"
+minetest.register_entity("drippingwater:drop_lava", {
+	hp_max = 1,
+	physical = true,
+	collide_with_objects = false,
+	collisionbox = {-0.025,-0.05,-0.025,0.025,-0.01,0.025},
+	glow = math.max(7, minetest.registered_nodes["mcl_core:lava_source"].light_source - 3),
+	pointable = false,
+	visual = "cube",
+	visual_size = {x=0.05, y=0.1},
+	textures = {lava_tex, lava_tex, lava_tex, lava_tex, lava_tex, lava_tex},
+	spritediv = {x=1, y=1},
+	initial_sprite_basepos = {x=0, y=0},
+	static_save = false,
+	on_activate = function(self, staticdata)
+		self.object:set_sprite({x=0,y=0}, 1, 0, true)
+	end,
+	on_step = function(self, dtime)
+		local k = math.random(1,222)
+		local ownpos = self.object:get_pos()
+		if k == 1 then
+			self.object:set_acceleration({x=0, y=-5, z=0})
+		end
+		if minetest.get_node({x=ownpos.x, y=ownpos.y +0.5, z=ownpos.z}).name == "air" then
+			self.object:set_acceleration({x=0, y=-5, z=0})
+		end
+		if minetest.get_node({x=ownpos.x, y=ownpos.y -0.5, z=ownpos.z}).name ~= "air" then
+			self.object:remove()
+			minetest.sound_play({name="drippingwater_lavadrip"}, {pos = ownpos, gain = 0.5, max_hear_distance = 8}, true)
+		end
+	end,
+})
+
+
+
+--Create drop
+
+minetest.register_abm({
+	label = "Create water drops",
+	nodenames = {"group:opaque", "group:leaves"},
+	neighbors = {"group:water"},
+	interval = 2,
+	chance = 22,
+	action = function(pos)
+		if minetest.get_item_group(minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name, "water") ~= 0
+			and minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "air" then
+			local i = math.random(-45,45) / 100
+			minetest.add_entity({x=pos.x + i, y=pos.y - 0.501, z=pos.z + i}, "drippingwater:drop_water")
+		end
+	end,
+})
+
+--Create lava drop
+
+minetest.register_abm({
+	label = "Create lava drops",
+	nodenames = {"group:opaque"},
+	neighbors = {"group:lava"},
+	interval = 2,
+	chance = 22,
+	action = function(pos)
+		if minetest.get_item_group(minetest.get_node({x=pos.x, y=pos.y+1, z=pos.z}).name, "lava") ~= 0
+			and	minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "air" then
+			local i = math.random(-45,45) / 100
+			minetest.add_entity({x=pos.x + i, y=pos.y - 0.501, z=pos.z + i}, "drippingwater:drop_lava")
+		end
+	end,
+})

mods/ENTITIES/drippingwater/mod.conf

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

mods/ENTITIES/drippingwater/readme.txt

@@ -1,12 +1,12 @@
-Dripping Mod
+Dripping Water Mod
 by kddekadenz
 
-modified for MineClone 2 by Wuzzy and NO11
+modified for MineClone 2 by Wuzzy
 
 
 Installing instructions:
 
-	1. Copy the mcl_dripping mod folder into games/gamemode/mods
+	1. Copy the drippingwater mod folder into games/gamemode/mods
 
 	2. Start game and enjoy :)
 

mods/ENTITIES/mcl_boats/init.lua

@@ -12,51 +12,40 @@ local function is_group(pos, group)
 	return minetest.get_item_group(nn, group) ~= 0
 end
 
-local is_water = flowlib.is_water
-
-local function is_ice(pos)
-	return is_group(pos, "ice")
-end
-
-local function get_sign(i)
-	if i == 0 then
-		return 0
-	else
-		return i / math.abs(i)
-	end
-end
-
 local function get_velocity(v, yaw, y)
-	local x = -math.sin(yaw) * v
-	local z =  math.cos(yaw) * v
-	return {x = x, y = y, z = z}
+	return vector.add(vector.new(0, y, 0), vector.multiply(minetest.yaw_to_dir(yaw), v))
 end
 
 local function get_v(v)
 	return math.sqrt(v.x ^ 2 + v.z ^ 2)
 end
 
-local function check_object(obj)
-	return obj and (obj:is_player() or obj:get_luaentity()) and obj
+function get_sign(i)
+	if not i or i == 0 then
+		return 0
+	else
+		return i / math.abs(i)
+	end
 end
 
-local function get_visual_size(obj)
-	return obj:is_player() and {x = 1, y = 1, z = 1} or obj:get_luaentity()._old_visual_size or obj:get_properties().visual_size
+local is_water = flowlib.is_water
+
+local function is_ice(pos)
+	return is_group(pos, "ice")
 end
 
 local function set_attach(boat)
-	boat._driver:set_attach(boat.object, "",
-		{x = 0, y = 0.42, z = -1}, {x = 0, y = 0, z = 0})
+	boat._driver:set_attach(boat.object, "", vector.new(0, 0.42, -1), vector.new(0, 0, 0))
 end
 
 local function set_double_attach(boat)
-	boat._driver:set_attach(boat.object, "",
-		{x = 0, y = 0.42, z = 0.8}, {x = 0, y = 0, z = 0})
-	boat._passenger:set_attach(boat.object, "",
-		{x = 0, y = 0.42, z = -2.2}, {x = 0, y = 0, z = 0})
+	boat._driver:set_attach(boat.object, "", vector.new(0, 0.42, 0.8), vector.new(0, 0, 0))
+	boat._passenger:set_attach(boat.object, "", vector.new(0, 0.42, -2.2), vector.new(0, 0, 0))
 end
 
-local function attach_object(self, obj)
+local function enter_boat(self, obj)
+	mcl_mount.mount(obj, self.object)
+
 	if self._driver then
 		if self._driver:is_player() then
 			self._passenger = obj
@@ -69,39 +58,6 @@ local function attach_object(self, obj)
 		self._driver = obj
 		set_attach(self)
 	end
-
-	local visual_size = get_visual_size(obj)
-	local yaw = self.object:get_yaw()
-	obj:set_properties({visual_size = vector.divide(visual_size, boat_visual_size)})
-
-	if obj:is_player() then
-		local name = obj:get_player_name()
-		mcl_player.player_attached[name] = true
-		minetest.after(0.2, function(name)
-			local player = minetest.get_player_by_name(name)
-			if player then
-				mcl_player.player_set_animation(player, "sit" , 30)
-			end
-		end, name)
-		obj:set_look_horizontal(yaw)
-		mcl_title.set(obj, "actionbar", {text=S("Sneak to dismount"), color="white", stay=60})
-	else
-		obj:get_luaentity()._old_visual_size = visual_size
-	end
-end
-
-local function detach_object(obj, change_pos)
-	obj:set_detach()
-	obj:set_properties({visual_size = get_visual_size(obj)})
-	if obj:is_player() then
-		mcl_player.player_attached[obj:get_player_name()] = false
-		mcl_player.player_set_animation(obj, "stand" , 30)
-	else
-		obj:get_luaentity()._old_visual_size = nil
-	end
-	if change_pos then
-		 obj:set_pos(vector.add(obj:get_pos(), vector.new(0, 0.2, 0)))
-	end
 end
 
 --
@@ -115,7 +71,7 @@ local boat = {
 	collisionbox = {-0.5, -0.35, -0.5, 0.5, 0.3, 0.5},
 	visual = "mesh",
 	mesh = "mcl_boats_boat.b3d",
-	textures = {"mcl_boats_texture_oak_boat.png", "mcl_boats_texture_oak_boat.png", "mcl_boats_texture_oak_boat.png", "mcl_boats_texture_oak_boat.png", "mcl_boats_texture_oak_boat.png"},
+	textures = {"mcl_boats_texture_oak_boat.png"},
 	visual_size = boat_visual_size,
 	hp_max = boat_max_hp,
 	damage_texture_modifier = "^[colorize:white:0",
@@ -131,16 +87,13 @@ local boat = {
 	_damage_anim = 0,
 }
 
-minetest.register_on_respawnplayer(detach_object)
-
 function boat.on_rightclick(self, clicker)
 	if self._passenger or not clicker or clicker:get_attach() then
 		return
 	end
-	attach_object(self, clicker)
+	enter_boat(self, clicker)
 end
 
-
 function boat.on_activate(self, staticdata, dtime_s)
 	self.object:set_armor_groups({fleshy = 100})
 	local data = minetest.deserialize(staticdata)
@@ -148,11 +101,6 @@ function boat.on_activate(self, staticdata, dtime_s)
 		self._v = data.v
 		self._last_v = self._v
 		self._itemstring = data.itemstring
-
-		while #data.textures < 5 do
-			table.insert(data.textures, data.textures[1])
-		end
-
 		self.object:set_properties({textures = data.textures})
 	end
 end
@@ -177,10 +125,10 @@ function boat.on_death(self, killer)
 		minetest.add_item(self.object:get_pos(), self._itemstring)
 	end
 	if self._driver then
-		detach_object(self._driver)
+		mcl_mount.throw_off(self._driver)
 	end
 	if self._passenger then
-		detach_object(self._passenger)
+		mcl_mount.throw_off(self._passenger)
 	end
 	self._driver = nil
 	self._passenger = nil
@@ -240,19 +188,13 @@ function boat.on_step(self, dtime, moveresult)
 
 	local had_passenger = self._passenger
 
-	self._driver = check_object(self._driver)
-	self._passenger = check_object(self._passenger)
+	self._driver = self._driver and self._driver:get_attach() == self.object and self._driver
+	self._passenger = self._passenger and self._passenger:get_attach() == self.object and self._passenger
 
 	if self._passenger then
 		if not self._driver then
 			self._driver = self._passenger
 			self._passenger = nil
-		else
-			local ctrl = self._passenger:get_player_control()
-			if ctrl and ctrl.sneak then
-				detach_object(self._passenger, true)
-				self._passenger = nil
-			end
 		end
 	end
 
@@ -261,13 +203,8 @@ function boat.on_step(self, dtime, moveresult)
 			set_attach(self)
 		end
 		local ctrl = self._driver:get_player_control()
-		if ctrl and ctrl.sneak then
-			detach_object(self._driver, true)
-			self._driver = nil
-			return
-		end
 		local yaw = self.object:get_yaw()
-		if ctrl.up then
+		if ctrl and ctrl.up then
 			-- Forwards
 			self._v = self._v + 0.1 * v_factor
 
@@ -276,7 +213,7 @@ function boat.on_step(self, dtime, moveresult)
 				self.object:set_animation({x=0, y=40}, paddling_speed, 0, true)
 				self._animation = 1
 			end
-		elseif ctrl.down then
+		elseif ctrl and ctrl.down then
 			-- Backwards
 			self._v = self._v - 0.1 * v_factor
 
@@ -314,8 +251,8 @@ function boat.on_step(self, dtime, moveresult)
 
 		for _, obj in pairs(minetest.get_objects_inside_radius(self.object:get_pos(), 1.3)) do
 			local entity = obj:get_luaentity()
-			if entity and entity._cmi_is_mob then
-				attach_object(self, obj)
+			if entity and entity.is_mob then
+				enter_boat(self, obj)
 				break
 			end
 		end
@@ -342,8 +279,7 @@ function boat.on_step(self, dtime, moveresult)
 			self.object:get_velocity().y)
 	else
 		p.y = p.y + 1
-		local is_obsidian_boat = self.object:get_luaentity()._itemstring == "mcl_boats:boat_obsidian"
-		if is_water(p) or is_obsidian_boat then
+		if is_water(p) then
 			-- Inside water: Slowly sink
 			local y = self.object:get_velocity().y
 			y = y - 0.01
@@ -383,13 +319,13 @@ end
 -- Register one entity for all boat types
 minetest.register_entity("mcl_boats:boat", boat)
 
-local boat_ids = { "boat", "boat_spruce", "boat_birch", "boat_jungle", "boat_acacia", "boat_dark_oak", "boat_obsidian" }
-local names = { S("Oak Boat"), S("Spruce Boat"), S("Birch Boat"), S("Jungle Boat"), S("Acacia Boat"), S("Dark Oak Boat"), S("Obsidian Boat") }
+local boat_ids = { "boat", "boat_spruce", "boat_birch", "boat_jungle", "boat_acacia", "boat_dark_oak" }
+local names = { S("Oak Boat"), S("Spruce Boat"), S("Birch Boat"), S("Jungle Boat"), S("Acacia Boat"), S("Dark Oak Boat") }
 local craftstuffs = {}
 if minetest.get_modpath("mcl_core") then
-	craftstuffs = { "mcl_core:wood", "mcl_core:sprucewood", "mcl_core:birchwood", "mcl_core:junglewood", "mcl_core:acaciawood", "mcl_core:darkwood", "mcl_core:obsidian" }
+	craftstuffs = { "mcl_core:wood", "mcl_core:sprucewood", "mcl_core:birchwood", "mcl_core:junglewood", "mcl_core:acaciawood", "mcl_core:darkwood" }
 end
-local images = { "oak", "spruce", "birch", "jungle", "acacia", "dark_oak", "obsidian" }
+local images = { "oak", "spruce", "birch", "jungle", "acacia", "dark_oak" }
 
 for b=1, #boat_ids do
 	local itemstring = "mcl_boats:"..boat_ids[b]
@@ -440,9 +376,8 @@ for b=1, #boat_ids do
 				pos = vector.add(pos, vector.multiply(dir, boat_y_offset_ground))
 			end
 			local boat = minetest.add_entity(pos, "mcl_boats:boat")
-			local texture = "mcl_boats_texture_"..images[b].."_boat.png"
 			boat:get_luaentity()._itemstring = itemstring
-			boat:set_properties({textures = { texture, texture, texture, texture, texture }})
+			boat:set_properties({textures = { "mcl_boats_texture_"..images[b].."_boat.png" }})
 			boat:set_yaw(placer:get_look_horizontal())
 			if not minetest.is_creative_enabled(placer:get_player_name()) then
 				itemstack:take_item()

mods/ENTITIES/mcl_burning/api.lua

@@ -1,5 +1,15 @@
 function mcl_burning.get_storage(obj)
-	return obj:is_player() and mcl_burning.storage[obj] or obj:get_luaentity()
+	if obj:is_player() then
+		return mcl_burning.storage[obj]
+	else
+		local luaentity = obj:get_luaentity()
+
+		if luaentity.is_mob then
+			return luaentity.data
+		end
+
+		return luaentity
+	end
 end
 
 function mcl_burning.is_burning(obj)
@@ -75,20 +85,6 @@ function mcl_burning.set_on_fire(obj, burn_time)
 		storage.fire_damage_timer = 0
 
 		local fire_entity = minetest.add_entity(obj:get_pos(), "mcl_burning:fire")
-		local minp, maxp = mcl_burning.get_collisionbox(obj, false, storage)
-		local obj_size = obj:get_properties().visual_size
-
-		local vertical_grow_factor = 1.2
-		local horizontal_grow_factor = 1.1
-		local grow_vector = vector.new(horizontal_grow_factor, vertical_grow_factor, horizontal_grow_factor)
-
-		local size = vector.subtract(maxp, minp)
-		size = vector.multiply(size, grow_vector)
-		size = vector.divide(size, obj_size)
-		local offset = vector.new(0, size.y * 10 / 2, 0)
-
-		fire_entity:set_properties({visual_size = size})
-		fire_entity:set_attach(obj, "", offset, {x = 0, y = 0, z = 0})
 		local fire_luaentity = fire_entity:get_luaentity()
 
 		for _, other in pairs(minetest.get_objects_inside_radius(fire_entity:get_pos(), 0)) do
@@ -126,12 +122,7 @@ function mcl_burning.tick(obj, dtime, storage)
 
 			if storage.fire_damage_timer >= 1 then
 				storage.fire_damage_timer = 0
-
-				local luaentity = obj:get_luaentity()
-
-				if not luaentity or not luaentity.fire_damage_resistant then
-					mcl_util.deal_damage(obj, 1, {type = "on_fire"})
-				end
+				mcl_util.deal_damage(obj, 1, {type = "on_fire"})
 			end
 		end
 	end

mods/ENTITIES/mcl_burning/init.lua

@@ -40,22 +40,37 @@ minetest.register_globalstep(function(dtime)
 	end
 end)
 
+mcl_damage.register_modifier(function(obj, damage, reason)
+	if reason.is_fire then
+		local luaentity = obj:get_luaentity()
+		if luaentity and luaentity.no_fire_damage then
+			return 0
+		end
+	end
+end, -200)
+
+mcl_damage.register_on_damage(function(obj, damage, reason)
+	if reason.direct and mcl_burning.is_burning(obj) then
+		mcl_burning.set_on_fire(obj, 5)
+	end
+end)
+
 minetest.register_on_respawnplayer(function(player)
 	mcl_burning.extinguish(player)
 end)
 
-function mcl_burning.init_player(player)
-	local meta = player:get_meta()
-	-- NOTE: mcl_burning:data may be "return nil" (which deserialize into nil) for reasons unknown.
-	if meta:get_string("mcl_burning:data"):find("return nil", 1, true) then
-		minetest.log("warning", "[mcl_burning] 'mcl_burning:data' player meta field is invalid! Please report this bug")
-	end
-	mcl_burning.storage[player] = meta:contains("mcl_burning:data") and minetest.deserialize(meta:get_string("mcl_burning:data")) or {}
-	mcl_burning.channels[player] = minetest.mod_channel_join("mcl_burning:" .. player:get_player_name())
-end
-
 minetest.register_on_joinplayer(function(player)
-	mcl_burning.init_player(player)
+	local storage
+
+	local burn_data = player:get_meta():get_string("mcl_burning:data")
+	if burn_data == "" then
+		storage = {}
+	else
+		storage = minetest.deserialize(burn_data)
+	end
+
+	mcl_burning.storage[player] = storage
+	mcl_burning.channels[player] = minetest.mod_channel_join("mcl_burning:" .. player:get_player_name())
 end)
 
 minetest.register_on_leaveplayer(function(player)
@@ -108,4 +123,23 @@ minetest.register_entity("mcl_burning:fire", {
 
 		return true
 	end,
+	update_visual_size = function(self, parent, storage)
+		parent = parent or self.object:get_attach()
+		storage = storage or mcl_burning.get_storage(parent)
+
+		local minp, maxp = mcl_burning.get_collisionbox(parent, false, storage)
+		local obj_size = parent:get_properties().visual_size
+
+		local vertical_grow_factor = 1.2
+		local horizontal_grow_factor = 1.1
+		local grow_vector = vector.new(horizontal_grow_factor, vertical_grow_factor, horizontal_grow_factor)
+
+		local size = vector.subtract(maxp, minp)
+		size = vector.multiply(size, grow_vector)
+		size = vector.divide(size, obj_size)
+		local offset = vector.new(0, size.y * 10 / 2, 0)
+
+		self.object:set_properties({visual_size = size})
+		self.object:set_attach(parent, "", offset)
+	end,
 })

mods/ENTITIES/mcl_burning/mod.conf

@@ -1,3 +1,4 @@
 name = mcl_burning
 description = Burning Objects for MineClone2
 author = Fleckenstein
+depends = mcl_damage

mods/ENTITIES/mcl_dripping/init.lua

@@ -1,66 +0,0 @@
--- Dripping Water Mod
--- by kddekadenz
-
-local math = math
-
--- License of code, textures & sounds: CC0
-
-local function register_drop(liquid, glow, sound, nodes)
-	minetest.register_entity("mcl_dripping:drop_" .. liquid, {
-		hp_max = 1,
-		physical = true,
-		collide_with_objects = false,
-		collisionbox = {-0.01, 0.01, -0.01, 0.01, 0.01, 0.01},
-		glow = glow,
-		pointable = false,
-		visual = "sprite",
-		visual_size = {x = 0.1, y = 0.1},
-		textures = {""},
-		spritediv = {x = 1, y = 1},
-		initial_sprite_basepos = {x = 0, y = 0},
-		static_save = false,
-		_dropped = false,
-		on_activate = function(self)
-			self.object:set_properties({
-				textures = {"[combine:2x2:" .. -math.random(1, 16) .. "," .. -math.random(1, 16) .. "=default_" .. liquid .. "_source_animated.png"}
-			})
-		end,
-		on_step = function(self, dtime)
-			local k = math.random(1, 222)
-			local ownpos = self.object:get_pos()
-			if k == 1 then
-				self.object:set_acceleration(vector.new(0, -5, 0))
-			end
-			if minetest.get_node(vector.offset(ownpos, 0, 0.5, 0)).name == "air" then
-				self.object:set_acceleration(vector.new(0, -5, 0))
-			end
-			if minetest.get_node(vector.offset(ownpos, 0, -0.1, 0)).name ~= "air" then
-				local ent = self.object:get_luaentity()
-				if not ent._dropped then
-					ent._dropped = true
-					minetest.sound_play({name = "drippingwater_" .. sound .. "drip"}, {pos = ownpos, gain = 0.5, max_hear_distance = 8}, true)
-				end
-				if k < 3 then
-					self.object:remove()
-				end
-			end
-		end,
-	})
-	minetest.register_abm({
-		label = "Create drops",
-		nodenames = nodes,
-		neighbors = {"group:" .. liquid},
-		interval = 2,
-		chance = 22,
-		action = function(pos)
-			if minetest.get_item_group(minetest.get_node(vector.offset(pos, 0, 1, 0)).name, liquid) ~= 0
-			and minetest.get_node(vector.offset(pos, 0, -1, 0)).name == "air" then
-				local x, z = math.random(-45, 45) / 100, math.random(-45, 45) / 100
-				minetest.add_entity(vector.offset(pos, x, -0.520, z), "mcl_dripping:drop_" .. liquid)
-			end
-		end,
-	})
-end
-
-register_drop("water", 1, "", {"group:opaque", "group:leaves"})
-register_drop("lava", math.max(7, minetest.registered_nodes["mcl_core:lava_source"].light_source - 3), "lava", {"group:opaque"})

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

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

mods/ENTITIES/mcl_item_entity/init.lua

@@ -290,10 +290,10 @@ function minetest.handle_node_drops(pos, drops, digger)
 		end
 	end
 
-	if digger and mcl_experience.throw_xp and not silk_touch_drop then
+	if digger and mcl_experience.throw_experience and not silk_touch_drop then
 		local experience_amount = minetest.get_item_group(dug_node.name,"xp")
 		if experience_amount > 0 then
-			mcl_experience.throw_xp(pos, experience_amount)
+			mcl_experience.throw_experience(pos, experience_amount)
 		end
 	end
 

mods/ENTITIES/mcl_minecarts/init.lua

@@ -198,20 +198,7 @@ local function register_entity(entity_id, mesh, textures, drop, on_rightclick, o
 		else
 			self._last_float_check = self._last_float_check + dtime
 		end
-
-		local pos, rou_pos, node = self.object:get_pos()
-		local r = 0.6
-		for _, node_pos in pairs({{r, 0}, {0, r}, {-r, 0}, {0, -r}}) do
-			if minetest.get_node(vector.offset(pos, node_pos[1], 0, node_pos[2])).name == "mcl_core:cactus" then
-				detach_driver(self)
-				for d = 1, #drop do
-					minetest.add_item(pos, drop[d])
-				end
-				self.object:remove()
-				return
-			end
-		end
-
+		local pos, rou_pos, node
 		-- 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_mobs/LICENSE-MEDIA.md

@@ -1,4 +1,4 @@
-# Credits licensing for media files in `mobs_mc`
+# Credits licensing for media files in `mcl_mobs`
 
 ## Licenses used
 
@@ -69,7 +69,7 @@ Origin of those models:
         * `mobs_mc_chicken.png`
         * `mobs_mc_wither.png`
         * `mobs_mc_wither_skeleton.png`
-        * `mobs_mc_TEMP_wither_projectile.png`	
+        * `mobs_mc_TEMP_wither_projectile.png`
     * Gerold55
         * `mobs_mc_mooshroom_brown.png` (CC0)
         * `mobs_mc_mushroom_brown.png` (CC0)

mods/ENTITIES/mcl_mobs/api.txt

@@ -1,6 +1,8 @@
 
 Mobs Redo: MineClone 2 Edition
 API documentation
+
+IMPORTANT NOTE: This is completely outdated and needs to be rewritten
 ==============================
 
 Welcome to the world of mobs in Minetest and hopefully an easy guide to defining
@@ -641,7 +643,7 @@ mobs:register_mob("mob_horse:horse", {
 	visual_size = {x = 1.20, y = 1.20},
 	mesh = "mobs_horse.x",
 	collisionbox = {-0.4, -0.01, -0.4, 0.4, 1.25, 0.4},
-	animation = { 
+	animation = {
 		speed_normal = 15,
 		speed_run = 30,
 		stand_start = 25,

mods/ENTITIES/mcl_mobs/api/ai/ai.lua

@@ -0,0 +1,29 @@
+function mcl_mobs.mob:ai_step(dtime)
+	--[[
+	if self.has_head then
+		mobs.do_head_logic(self,dtime)
+	end
+	--]]
+
+	self:float_step()
+
+	if self.jump_only then
+		jump_state_switch(self, dtime)
+		jump_state_execution(self, dtime)
+	--swimming
+	elseif self.swim then
+		swim_state_switch(self, dtime)
+		swim_state_execution(self, dtime)
+	--flying
+	elseif self.fly then
+		fly_state_switch(self, dtime)
+		fly_state_execution(self, dtime)
+	--regular mobs that walk around
+	else
+		land_state_switch(self, dtime)
+		land_state_execution(self, dtime)
+	end
+
+	--make it so mobs do not glitch out when walking around/jumping
+	self:swap_auto_step_height_adjust()
+end

mods/ENTITIES/mcl_mobs/api/ai/attack/explode.lua

@@ -0,0 +1,74 @@
+--[[
+
+mobs.explode_attack_walk = function(self,dtime)
+
+    --this needs an exception
+    if self.attacking == nil or not self.attacking:is_player() then
+        self.attacking = nil
+        return
+    end
+
+    self:look_at(self.attack)
+
+    local distance_from_attacking = vector.distance(self.object:get_pos(), self.attacking:get_pos())
+
+    --make mob walk up to player within 2 nodes distance then start exploding
+    if distance_from_attacking >= self.reach and
+    --don't allow explosion to cancel unless out of the reach boundary
+    not (self.explosion_animation ~= nil and self.explosion_animation > 0 and distance_from_attacking <= self.defuse_reach) then
+
+        mobs.set_velocity(self, self.run_velocity)
+        mobs.set_mob_animation(self,"run")
+
+        mobs.reverse_explosion_animation(self,dtime)
+    else
+        mobs.set_velocity(self,0)
+
+        --this is the only way I can reference this without dumping extra data on all mobs
+        if not self.explosion_animation then
+            self.explosion_animation = 0
+        end
+
+        --play ignite sound
+        if self.explosion_animation == 0 then
+            mobs.play_sound(self,"attack")
+        end
+
+        mobs.set_mob_animation(self,"stand")
+
+        mobs.handle_explosion_animation(self)
+
+        self.explosion_animation = self.explosion_animation + (dtime/2.5)
+    end
+
+    --make explosive mobs jump
+    --check for nodes to jump over
+    --explosive mobs will just ride against walls for now
+	local node_in_front_of = mobs.jump_check(self)
+	if node_in_front_of == 1 then
+		mobs.jump(self)
+    end
+
+
+    --do biggening explosion thing
+    if self.explosion_animation and self.explosion_animation > self.explosion_timer then
+        mcl_explosions.explode(self.object:get_pos(), self.explosion_strength,{ drop_chance = 1.0 })
+        self.object:remove()
+    end
+end
+
+
+--this is a small helper function to make working with explosion animations easier
+mobs.reverse_explosion_animation = function(self,dtime)
+
+    --if explosion animation was greater than 0 then reverse it
+    if self.explosion_animation ~= nil and self.explosion_animation > 0 then
+        self.explosion_animation = self.explosion_animation - dtime
+        if self.explosion_animation < 0 then
+            self.explosion_animation = 0
+        end
+    end
+
+    mobs.handle_explosion_animation(self)
+end
+--]]

mods/ENTITIES/mcl_mobs/api/ai/attack/projectile_common.lua

@@ -0,0 +1,31 @@
+--[[
+
+mobs.shoot_projectile_handling = function(arrow_item, pos, dir, yaw, shooter, power, damage, is_critical, bow_stack, collectable, gravity)
+	local obj = mcl_bows.shoot_arrow(arrow_item, pos, dir, yaw, shooter, power, damage, is_critical, bow_stack, collectable, gravity, true)
+
+    --play custom shoot sound
+    if shooter ~= nil and shooter.shoot_sound then
+        minetest.sound_play(shooter.shoot_sound, {pos=pos, max_hear_distance=16}, true)
+    end
+
+	return obj
+end
+
+--do internal per mob projectile calculations
+mobs.shoot_projectile = function(self)
+
+	local pos1 = self.object:get_pos()
+	--add mob eye height
+	pos1.y = pos1.y + self.eye_height
+
+	local pos2 = self.attacking:get_pos()
+	--add player eye height
+	pos2.y = pos2.y + mcl_mobs.util.get_eye_height(self.attacking)
+
+	--get direction
+	local dir = vector.direction(pos1,pos2)
+
+	--call internal shoot_arrow function
+	self.shoot_arrow(self,pos1,dir)
+end
+]]--

mods/ENTITIES/mcl_mobs/api/ai/attack/projectile_fly.lua

@@ -0,0 +1,72 @@
+--[[
+local random_pitch_multiplier = {-1,1}
+
+mobs.projectile_attack_fly = function(self, dtime)
+
+    --this needs an exception
+    if self.attacking == nil or not self.attacking:is_player() then
+        self.attacking = nil
+        return
+    end
+
+    --this is specifically for random ghast movement
+    if self.fly_random_while_attack then
+
+        --enable rotation locking
+		mobs.movement_rotation_lock(self)
+
+        self.walk_timer = self.walk_timer - dtime
+
+        --reset the walk timer
+        if self.walk_timer <= 0 then
+            --re-randomize the walk timer
+            self.walk_timer = math.random(1,6) + math.random()
+            --set the mob into a random direction
+            self.yaw = (math.random() * (math.pi * 2))
+            --create a truly random pitch, since there is no easy access to pitch math that I can find
+            self.pitch = math.random() * math.random(1,3) * random_pitch_multiplier[math.random(1,2)]
+        end
+
+        mobs.set_fly_velocity(self, self.run_velocity)
+
+    else
+
+        self:look_at(self.attack)
+
+        local distance_from_attacking = vector.distance(self.object:get_pos(), self.attacking:get_pos())
+
+        if distance_from_attacking >= self.reach then
+            mobs.set_pitch_while_attacking(self)
+            mobs.set_fly_velocity(self, self.run_velocity)
+            mobs.set_mob_animation(self,"run")
+        else
+            mobs.set_pitch_while_attacking(self)
+            mobs.set_fly_velocity(self, 0)
+            mobs.set_mob_animation(self,"stand")
+        end
+    end
+
+
+    --do this to not load data into other mobs
+    if not self.projectile_timer then
+        self.projectile_timer = math.random(self.projectile_cooldown_min, self.projectile_cooldown_max)
+    end
+
+    --run projectile timer
+    if self.projectile_timer > 0 then
+        self.projectile_timer = self.projectile_timer - dtime
+
+        --shoot
+        if self.projectile_timer <= 0 then
+
+            if self.fly_random_while_attack then
+                self:look_at(self.attack)
+                self.walk_timer = 0
+            end
+            --reset timer
+            self.projectile_timer = math.random(self.projectile_cooldown_min, self.projectile_cooldown_max)
+            mobs.shoot_projectile(self)
+        end
+    end
+end
+]]--

mods/ENTITIES/mcl_mobs/api/ai/attack/projectile_land.lua

@@ -0,0 +1,52 @@
+--[[
+
+mobs.projectile_attack_walk = function(self,dtime)
+
+    --this needs an exception
+    if self.attacking == nil or not self.attacking:is_player() then
+        self.attacking = nil
+        return
+    end
+
+    self:look_at(self.attack)
+
+    local distance_from_attacking = vector.distance(self.object:get_pos(), self.attacking:get_pos())
+
+
+    if distance_from_attacking >= self.reach then
+        mobs.set_velocity(self, self.run_velocity)
+        mobs.set_mob_animation(self,"run")
+    else
+        mobs.set_velocity(self,0)
+        mobs.set_mob_animation(self,"stand")
+    end
+
+    --do this to not load data into other mobs
+    if not self.projectile_timer then
+        self.projectile_timer = math.random(self.projectile_cooldown_min, self.projectile_cooldown_max)
+    end
+
+    --run projectile timer
+    if self.projectile_timer > 0 then
+        self.projectile_timer = self.projectile_timer - dtime
+
+        --shoot
+        if self.projectile_timer <= 0 then
+            --reset timer
+            self.projectile_timer = math.random(self.projectile_cooldown_min, self.projectile_cooldown_max)
+            mobs.shoot_projectile(self)
+        end
+    end
+
+    --make shooty mobs jump
+    --check for nodes to jump over
+    --explosive mobs will just ride against walls for now
+	local node_in_front_of = mobs.jump_check(self)
+	if node_in_front_of == 1 then
+		mobs.jump(self)
+    end
+
+end
+
+
+]]--

mods/ENTITIES/mcl_mobs/api/ai/attack/punch.lua

@@ -0,0 +1,87 @@
+--[[
+mobs.punch_attack_walk = function(self,dtime)
+
+    --this needs an exception
+    if self.attacking == nil or not self.attacking:is_player() then
+        self.attacking = nil
+        return
+    end
+
+    local distance_from_attacking = mobs.get_2d_distance(self.object:get_pos(), self.attacking:get_pos())
+
+    if distance_from_attacking >= self.minimum_follow_distance then
+        mobs.set_velocity(self, self.run_velocity)
+        mobs.set_mob_animation(self, "run")
+    else
+        mobs.set_velocity(self, 0)
+        mobs.set_mob_animation(self, "stand")
+    end
+
+    self:look_at(self.attack)
+
+    --make punchy mobs jump
+    --check for nodes to jump over
+    --explosive mobs will just ride against walls for now
+	local node_in_front_of = mobs.jump_check(self)
+
+	if node_in_front_of == 1 then
+		mobs.jump(self)
+    end
+
+    --mobs that can climb over stuff
+    if self.always_climb and node_in_front_of > 0 then
+        mobs.climb(self)
+    end
+
+
+    --auto reset punch_timer
+    if not self.punch_timer then
+        self.punch_timer = 0
+    end
+
+    if self.punch_timer > 0 then
+        self.punch_timer = self.punch_timer - dtime
+    end
+end
+
+mobs.punch_attack = function(self)
+
+    self.attacking:punch(self.object, 1.0, {
+        full_punch_interval = 1.0,
+        damage_groups = {fleshy = self.damage}
+    }, nil)
+
+    self.punch_timer = self.punch_timer_cooloff
+
+
+    --knockback
+    local pos1 = self.object:get_pos()
+    pos1.y = 0
+    local pos2 = self.attacking:get_pos()
+    pos2.y = 0
+    local dir = vector.direction(pos1,pos2)
+
+    dir = vector.multiply(dir,3)
+
+    if self.attacking:get_velocity().y <= 1 then
+        dir.y = 5
+    end
+
+    self.attacking:add_velocity(dir)
+end
+--]]
+--[[
+--integrate mob punching into collision detection
+local check_for_attack = false
+
+if self.attack_type == "punch" and self.hostile and self.attacking then
+	check_for_attack = true
+end
+
+if check_for_attack and self.punch_timer <= 0 then
+	if object == self.attacking then
+		mobs.punch_attack(self)
+	end
+end
+
+]]--

mods/ENTITIES/mcl_mobs/api/ai/climb.lua

@@ -0,0 +1,22 @@
+--[[
+mobs.climb = function(self)
+
+	local current_velocity = self.object:get_velocity()
+
+	local goal_velocity = {
+		x = 0,
+		y = DEFAULT_CLIMB_SPEED,
+		z = 0,
+	}
+
+	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
+
+	new_velocity_addition.x = 0
+	new_velocity_addition.z = 0
+
+	--smooths out mobs a bit
+	if vector.length(new_velocity_addition) >= 0.0001 then
+		self.object:add_velocity(new_velocity_addition)
+	end
+end
+]]

mods/ENTITIES/mcl_mobs/api/ai/float.lua

@@ -0,0 +1,13 @@
+function mcl_mobs.mob:float_step()
+	local vertical_speed
+
+	if self.node_type ~= self.last_node_type then
+		if self.node_type == "air" then
+			vertical_speed = self.def.float_in_air
+		elseif self.node_type == "water" then
+			vertical_speed = self.def.float_in_water
+		elseif self.node_type == "lava" then
+			vertical_speed = self.def.float_in_lava
+		end
+	end
+end

mods/ENTITIES/mcl_mobs/api/ai/fly.lua

@@ -0,0 +1,214 @@
+
+--[[
+______ _
+|  ___| |
+| |_  | |_   _
+|  _| | | | | |
+| |   | | |_| |
+\_|   |_|\__, |
+          __/ |
+         |___/
+]]--
+
+--[[
+-- state switching logic (stand, walk, run, attacks)
+local fly_state_list_wandering = {"stand", "fly"}
+
+local function fly_state_switch(self, dtime)
+
+	if self.hostile and self.attacking then
+		self.state = "attack"
+		return
+	end
+
+	self.state_timer = self.state_timer - dtime
+	if self.state_timer <= 0 then
+		self.state_timer = math.random(4, 10) + math.random()
+		self.state = fly_state_list_wandering[math.random(1, #fly_state_list_wandering)]
+	end
+end
+
+--check if a mob needs to turn while flying
+local function fly_turn_check(self, dtime)
+
+    local pos = self.object:get_pos()
+    pos.y = pos.y + 0.1
+    local dir = minetest.yaw_to_dir(self.yaw)
+
+    local collisionbox = self.object:get_properties().collisionbox
+	local radius = collisionbox[4] + 0.5
+
+    vector.multiply(dir, radius)
+
+    local test_dir = vector.add(pos,dir)
+
+	return minetest.get_item_group(minetest.get_node(test_dir).name, "solid") ~= 0
+end
+
+--this is to swap the built in engine acceleration modifier
+local function fly_physics_swapper(self, inside_fly_node)
+
+	--should be flyming, gravity is applied, switch to floating
+	if inside_fly_node and self.object:get_acceleration().y ~= 0 then
+		self.object:set_acceleration(vector.new(0, 0, 0))
+	--not be fly, gravity isn't applied, switch to falling
+	elseif not inside_fly_node and self.object:get_acceleration().y == 0 then
+		self.pitch = 0
+		self.object:set_acceleration(vector.new(0, -self.gravity, 0))
+	end
+end
+
+local random_pitch_multiplier = {-1, 1}
+-- states are executed here
+local function fly_state_execution(self, dtime)
+	local pos = self.object:get_pos()
+	pos.y = pos.y + 0.1
+	local current_node = minetest.get_node(pos).name
+	local inside_fly_node = minetest.get_item_group(current_node, "solid") == 0
+
+	local float_now = false
+	--recheck if in water or lava
+	if minetest.get_item_group(current_node, "water") ~= 0 or minetest.get_item_group(current_node, "lava") ~= 0 then
+		inside_fly_node = false
+		float_now = true
+	end
+
+	--turn gravity on or off
+	fly_physics_swapper(self, inside_fly_node)
+
+	--fly properly if inside fly node
+	if inside_fly_node then
+		if self.state == "stand" then
+
+			--do animation
+			self:set_animation("stand")
+
+			self:set_fly_velocity(0)
+
+			if self.tilt_fly then
+				self:set_static_pitch()
+			end
+
+			self:lock_yaw()
+
+		elseif self.state == "fly" then
+
+			self.walk_timer = self.walk_timer - dtime
+
+			--reset the walk timer
+			if self.walk_timer <= 0 then
+
+				--re-randomize the walk timer
+				self.walk_timer = math.random(1, 6) + math.random()
+
+				--set the mob into a random direction
+				self.yaw = (math.random() * (math.pi * 2))
+
+				--create a truly random pitch, since there is no easy access to pitch math that I can find
+				self.pitch = math.random() * math.random(1, 3) * random_pitch_multiplier[math.random(1,2)]
+			end
+
+			--do animation
+			self:set_animation("walk")
+
+			--do a quick turn to make mob continuously move
+			--if in a bird cage or something
+			if fly_turn_check(self, dtime) then
+				quick_rotate(self, dtime)
+			end
+
+			if self.tilt_fly then
+				self:set_dynamic_pitch()
+			end
+
+			self:set_fly_velocity(self.walk_velocity)
+
+			--enable rotation locking
+			self:movement_rotation_lock()
+
+		elseif self.state == "attack" then
+
+			--execute mob attack type
+			--if self.attack_type == "explode" then
+
+				--mobs.explode_attack_fly(self, dtime)
+
+			--elseif self.attack_type == "punch" then
+
+				--mobs.punch_attack_fly(self,dtime)
+
+			if self.attack_type == "projectile" then
+
+				self:projectile_attack_fly(dtime)
+
+			end
+		end
+	else
+		--make the mob float
+		if self.floats and float_now then
+			self:set_velocity(0)
+
+			self:float()
+
+			if self.tilt_fly then
+				self:set_static_pitch()
+			end
+		end
+	end
+end
+
+
+-- move mob in facing direction
+--this has been modified to be internal
+--internal = lua (self.yaw)
+--engine = c++ (self.object:get_yaw())
+mobs.set_fly_velocity = function(self, v)
+
+	local yaw = (self.yaw or 0)
+	local pitch = (self.pitch or 0)
+
+	if v == 0 then
+		pitch = 0
+	end
+
+	local current_velocity = self.object:get_velocity()
+
+	local goal_velocity = {
+		x = (math.sin(yaw) * -v),
+		y = pitch,
+		z = (math.cos(yaw) * v),
+	}
+
+
+	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
+
+	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
+		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
+	end
+
+	--smooths out mobs a bit
+	if vector.length(new_velocity_addition) >= 0.0001 then
+		self.object:add_velocity(new_velocity_addition)
+	end
+end
+
+--a quick and simple pitch calculation between two vector positions
+mobs.calculate_pitch = function(pos1, pos2)
+
+	if pos1 == nil or pos2 == nil then
+		return false
+	end
+
+    return(minetest.dir_to_yaw(vector.new(vector.distance(vector.new(pos1.x,0,pos1.z),vector.new(pos2.x,0,pos2.z)),0,pos1.y - pos2.y)) + HALF_PI)
+end
+
+--make mobs fly up or down based on their y difference
+mobs.set_pitch_while_attacking = function(self)
+	local pos1 = self.object:get_pos()
+	local pos2 = self.attacking:get_pos()
+
+	local pitch = mobs.calculate_pitch(pos2,pos1)
+
+	self.pitch = pitch
+end
+]]--

mods/ENTITIES/mcl_mobs/api/ai/follow.lua

@@ -0,0 +1,31 @@
+function mcl_mobs.mob:check_following()
+    --ignore
+    if not self.follow then
+        self.following_person = nil
+        return false
+    end
+
+    --hey look, this thing works for passive mobs too!
+    local follower = mobs.detect_closest_player_within_radius(self,true,self.view_range,self.eye_height)
+
+    --check if the follower is a player incase they log out
+    if follower and follower:is_player() then
+        local stack = follower:get_wielded_item()
+        --safety check
+        if not stack then
+            self.following_person = nil
+            return(false)
+        end
+
+        local item_name = stack:get_name()
+        --all checks have passed, that guy has some good looking food
+        if item_name == self.follow then
+            self.following_person = follower
+            return(true)
+        end
+    end
+
+    --everything failed
+    self.following_person = nil
+    return(false)
+end

mods/ENTITIES/mcl_mobs/api/ai/jump.lua

@@ -0,0 +1,169 @@
+--[[
+
+--check if a mob needs to jump
+mobs.jump_check = function(self,dtime)
+
+    local pos = self.object:get_pos()
+    pos.y = pos.y + 0.1
+    local dir = minetest.yaw_to_dir(self.yaw)
+
+    local collisionbox = self.object:get_properties().collisionbox
+	local radius = collisionbox[4] + 0.5
+
+    vector.multiply(dir, radius)
+
+	--only jump if there's a node and a non-solid node above it
+    local test_dir = vector.add(pos,dir)
+
+	local green_flag_1 = minetest.get_item_group(minetest.get_node(test_dir).name, "solid") ~= 0
+
+	test_dir.y = test_dir.y + 1
+
+	local green_flag_2 = minetest.get_item_group(minetest.get_node(test_dir).name, "solid") == 0
+
+    if green_flag_1 and green_flag_2 then
+		--can jump over node
+        return(1)
+	elseif green_flag_1 and not green_flag_2 then
+		--wall in front of mob
+		return(2)
+    end
+
+	--nothing to jump over
+	return(0)
+end
+
+--check if a mob needs to turn while jumping
+local function jump_turn_check(self, dtime)
+
+    local pos = self.object:get_pos()
+    pos.y = pos.y + 0.1
+    local dir = minetest.yaw_to_dir(self.yaw)
+
+    local collisionbox = self.object:get_properties().collisionbox
+	local radius = collisionbox[4] + 0.5
+
+    vector.multiply(dir, radius)
+
+    local test_dir = vector.add(pos,dir)
+
+	return minetest.get_item_group(minetest.get_node(test_dir).name, "solid") ~= 0
+end
+
+-- state switching logic (stand, jump, run, attacks)
+local jump_state_list_wandering = {"stand", "jump"}
+
+local function jump_state_switch(self, dtime)
+	self.state_timer = self.state_timer - dtime
+	if self.state_timer <= 0 then
+		self.state_timer = math.random(4, 10) + math.random()
+		self.state = jump_state_list_wandering[math.random(1, #jump_state_list_wandering)]
+	end
+end
+
+-- states are executed here
+local function jump_state_execution(self, dtime)
+
+	local pos = self.object:get_pos()
+	local collisionbox = self.object:get_properties().collisionbox
+	--get the center of the mob
+	pos.y = pos.y + (collisionbox[2] + collisionbox[5] / 2)
+	local current_node = minetest.get_node(pos).name
+
+	local float_now = false
+
+	--recheck if in water or lava
+	if minetest.get_item_group(current_node, "water") ~= 0 or minetest.get_item_group(current_node, "lava") ~= 0 then
+		float_now = true
+	end
+
+	if self.state == "stand" then
+
+		--do animation
+		self:set_animation("stand")
+
+		--set the velocity of the mob
+		self:set_velocity(0)
+
+		self:lock_yaw()
+
+	elseif self.state == "jump" then
+
+		self.walk_timer = self.walk_timer - dtime
+
+		--reset the jump timer
+		if self.walk_timer <= 0 then
+
+			--re-randomize the jump timer
+			self.walk_timer = math.random(1, 6) + math.random()
+
+			--set the mob into a random direction
+			self.yaw = (math.random() * (math.pi * 2))
+		end
+
+		--do animation
+		self:set_animation("walk")
+
+		--enable rotation locking
+		self:movement_rotation_lock()
+
+		--jumping mobs are more loosey goosey
+		if node_in_front_of == 1 then
+			quick_rotate(self, dtime)
+		end
+
+		--only move forward if path is clear
+		self:jump_move(self.walk_velocity)
+
+	elseif self.state == "run" then
+
+		print("run")
+
+	elseif self.state == "attack" then
+
+		print("attack")
+
+	end
+
+	if float_now then
+		self:float()
+	end
+end
+
+--special mob jump movement
+mobs.jump_move = function(self, velocity)
+
+    if self.object:get_velocity().y ~= 0 or not self.old_velocity or (self.old_velocity and self.old_velocity.y > 0) then
+        return
+    end
+
+	--make the mob stick for a split second
+	mobs.set_velocity(self,0)
+
+	--fallback velocity to allow modularity
+    jump_height = DEFAULT_JUMP_HEIGHT
+
+	local yaw = (self.yaw or 0)
+
+	local current_velocity = self.object:get_velocity()
+
+	local goal_velocity = {
+		x = (math.sin(yaw) * -velocity),
+		y = jump_height,
+		z = (math.cos(yaw) * velocity),
+	}
+
+
+	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
+
+	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
+		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
+	end
+
+	--smooths out mobs a bit
+	if vector.length(new_velocity_addition) >= 0.0001 then
+		self.object:add_velocity(new_velocity_addition)
+	end
+end
+
+]]--

mods/ENTITIES/mcl_mobs/api/ai/land.lua

@@ -0,0 +1,436 @@
+
+--[[
+ _                     _
+| |                   | |
+| |     __ _ _ __   __| |
+| |    / _` | '_ \ / _` |
+| |___| (_| | | | | (_| |
+\_____/\__,_|_| |_|\__,_|
+]]--
+
+--[[
+--this is basically reverse jump_check
+local function cliff_check(self, dtime)
+	--mobs will flip out if they are falling without this
+	if self.object:get_velocity().y ~= 0 then
+		return false
+	end
+
+	local pos = self.object:get_pos()
+    local dir = minetest.yaw_to_dir(self.yaw)
+	local collisionbox = self.properties.collisionbox
+	local radius = collisionbox[4] + 0.5
+
+	dir = vector.multiply(dir, radius)
+
+	local free_fall, blocker = minetest.line_of_sight(
+		{x = pos.x + dir.x, y = pos.y, z = pos.z + dir.z},
+		{x = pos.x + dir.x, y = pos.y - self.def.fear_height, z = pos.z + dir.z})
+
+	return free_fall
+end
+
+-- state switching logic (stand, walk, run, attacks)
+local land_state_list_wandering = {"stand", "walk"}
+
+local function land_state_switch(self, dtime)
+
+	--do math before sure not attacking, following, or running away so continue
+	--doing random walking for mobs if all states are not met
+	self.state_timer = self.state_timer - dtime
+
+	--only run away
+	if self.def.skittish and self.state == "run" then
+		self.run_timer = self.run_timer - dtime
+		if self.run_timer > 0 then
+			return
+		end
+		--continue
+	end
+
+	--ignore everything else if breeding
+	if self.breed_lookout_timer and self.breed_lookout_timer > 0 then
+		self.state = "breed"
+		return
+	--reset the state timer to get the mob out of
+	--the breed state
+	elseif self.state == "breed" then
+		self.state_timer = 0
+	end
+
+	--ignore everything else if following
+	if self:check_following() and self.breed_lookout_timer == 0 and self.breed_timer == 0 then
+		self.state = "follow"
+		return
+	--reset the state timer to get the mob out of
+	--the follow state - not the cleanest option
+	--but the easiest
+	elseif self.state == "follow" then
+		self.state_timer = 0
+	end
+
+	--only attack
+	if self.def.hostile and self.attacking then
+		self.state = "attack"
+		return
+	end
+
+	--if finally reached here then do random wander
+	if self.state_timer <= 0 then
+		self.state_timer = math.random(4, 10) + math.random()
+		self.state = land_state_list_wandering[math.random(1, #land_state_list_wandering)]
+	end
+
+end
+
+-- states are executed here
+local function land_state_execution(self, dtime)
+
+	--[[ -- this is a debug which shows the timer and makes mobs breed 100 times faster
+	print(self.breed_timer)
+	if self.breed_timer > 0 then
+		self.breed_timer = self.breed_timer - (dtime * 100)
+		if self.breed_timer <= 0 then
+			self.breed_timer = 0
+		end
+	end
+	] ]--
+
+	--timer to time out looking for mate
+	if self.breed_lookout_timer > 0 then
+		self.breed_lookout_timer = self.breed_lookout_timer - dtime
+		--looking for mate failed
+		if self.breed_lookout_timer < 0 then
+			self.breed_lookout_timer = 0
+		end
+	end
+
+	--cool off after breeding
+	if self.breed_timer > 0 then
+		self.breed_timer = self.breed_timer - dtime
+		--do this to skip the first check, using as switch
+		if self.breed_timer <= 0 then
+			self.breed_timer = 0
+		end
+	end
+
+	local pos = self.object:get_pos()
+	local collisionbox = self.properties.collisionbox
+	--get the center of the mob
+	pos.y = pos.y + (collisionbox[2] + collisionbox[5] / 2)
+	local current_node = minetest.get_node(pos).name
+	local float_now = false
+
+	--recheck if in water or lava
+	if minetest.get_item_group(current_node, "water") ~= 0 or minetest.get_item_group(current_node, "lava") ~= 0 then
+		float_now = true
+	end
+
+	--calculate fall damage
+	if self.fall_damage then
+		self:calculate_fall_damage()
+	end
+
+	if self.state == "stand" then
+
+		--do animation
+		self:set_animation("stand")
+
+		--set the velocity of the mob
+		self:set_velocity(0)
+
+		--animation fixes for explosive mobs
+		if self.attack_type == "explode" then
+			self:reverse_explosion_animation(dtime)
+		end
+
+		self:lock_yaw()
+	elseif self.state == "follow" then
+
+		--always look at players
+		self:look_at(self.following_person)
+
+		--check distance
+		local distance_from_follow_person = vector.distance(self.object:get_pos(), self.following_person:get_pos())
+		local distance_2d = mobs.get_2d_distance(self.object:get_pos(), self.following_person:get_pos())
+
+		--don't push the player if too close
+		--don't spin around randomly
+		if self.follow_distance < distance_from_follow_person and self.minimum_follow_distance < distance_2d then
+			self:set_animation("run")
+			self:set_velocity(self.run_velocity)
+
+			if self:jump_check() == 1 then
+				self:jump(self)
+			end
+		else
+			self:set_mob_animation("stand")
+			self:set_velocity(0)
+		end
+
+	elseif self.state == "walk" then
+
+		self.walk_timer = self.walk_timer - dtime
+
+		--reset the walk timer
+		if self.walk_timer <= 0 then
+
+			--re-randomize the walk timer
+			self.walk_timer = math.random(1, 6) + math.random()
+
+			--set the mob into a random direction
+			self.yaw = (math.random() * (math.pi * 2))
+		end
+
+		--do animation
+		self:set_animation("walk")
+
+		--enable rotation locking
+		self:movement_rotation_lock()
+
+		--check for nodes to jump over
+		local node_in_front_of = self:jump_check()
+
+		if node_in_front_of == 1 then
+
+			self:jump()
+
+		--turn if on the edge of cliff
+		--(this is written like this because unlike
+		--jump_check which simply tells the mob to jump
+		--this requires a mob to turn, removing the
+		--ease of a full implementation for it in a single
+		--function)
+		elseif node_in_front_of == 2 or (self.fear_height ~= 0 and cliff_check(self, dtime)) then
+			--turn 45 degrees if so
+			quick_rotate(self,dtime)
+			--stop the mob so it doesn't fall off
+			self:set_velocity(0)
+		end
+
+		--only move forward if path is clear
+		if node_in_front_of == 0 or node_in_front_of == 1 then
+			--set the velocity of the mob
+			self:set_velocity(self.walk_velocity)
+		end
+
+		--animation fixes for explosive mobs
+		if self.attack_type == "explode" then
+			self:reverse_explosion_animation(dtime)
+		end
+
+	elseif self.state == "run" then
+
+		--do animation
+		self:set_animation("run")
+
+		--enable rotation locking
+		self:movement_rotation_lock()
+
+		--check for nodes to jump over
+		local node_in_front_of = self:jump_check()
+
+		if node_in_front_of == 1 then
+
+			self:jump()
+
+		--turn if on the edge of cliff
+		--(this is written like this because unlike
+		--jump_check which simply tells the mob to jump
+		--this requires a mob to turn, removing the
+		--ease of a full implementation for it in a single
+		--function)
+		elseif node_in_front_of == 2 or (self.fear_height ~= 0 and cliff_check(self, dtime)) then
+			--turn 45 degrees if so
+			quick_rotate(self, dtime)
+			--stop the mob so it doesn't fall off
+			self:set_velocity(0)
+		end
+
+		--only move forward if path is clear
+		if node_in_front_of == 0 or node_in_front_of == 1 then
+			--set the velocity of the mob
+			self:set_velocity(self.run_velocity)
+		end
+
+	elseif self.state == "attack" then
+
+		--execute mob attack type
+		if self.attack_type == "explode" then
+
+			self:explode_attack_walk(dtime)
+
+		elseif self.attack_type == "punch" then
+
+			self:punch_attack_walk(dtime)
+
+		elseif self.attack_type == "projectile" then
+
+			self:projectile_attack_walk(dtime)
+
+		end
+	elseif self.state == "breed" then
+
+		minetest.add_particlespawner({
+			amount = 2,
+			time = 0.0001,
+			minpos = vector.add(pos, min),
+			maxpos = vector.add(pos, max),
+			minvel = vector.new(-1,1,-1),
+			maxvel = vector.new(1,3,1),
+			minexptime = 0.7,
+			maxexptime = 1,
+			minsize = 1,
+			maxsize = 2,
+			collisiondetection = false,
+			vertical = false,
+			texture = "heart.png",
+		})
+
+		local mate = self:look_for_mate()
+
+		--found a mate
+		if mate then
+			self:look_at(mate)
+			self:set_velocity(self.walk_velocity)
+
+			--smoosh together basically
+			if vector.distance(self.object:get_pos(), mate:get_pos()) <= self.breed_distance then
+				self:set_animation("stand")
+				if self.special_breed_timer == 0 then
+					self.special_breed_timer = 2 --breeding takes 2 seconds
+				end
+
+				self.special_breed_timer = self.special_breed_timer - dtime
+				if self.special_breed_timer <= 0 then
+
+					--pop a baby out, it's a miracle!
+					local baby_pos = vector.divide(vector.add(self.object:get_pos(), mate:get_pos()), 2)
+					local baby_mob = minetest.add_entity(pos, self.name, minetest.serialize({baby = true, grow_up_timer = self.grow_up_goal, bred = true}))
+
+					self:play_sound_specific("item_drop_pickup")
+
+					self.special_breed_timer = 0
+					self.breed_lookout_timer = 0
+					self.breed_timer = self.breed_timer_cooloff
+
+					local mate_entity = mate:get_luaentity()
+					mate_entity.special_breed_timer = 0
+					mate_entity.breed_lookout_timer = 0
+					mate_entity.breed_timer = self.breed_timer_cooloff -- can reuse because it's the same mob
+				end
+			else
+				self:set_animation("walk")
+			end
+		--couldn't find a mate, just stand there until the player pushes it towards one
+		--or the timer runs out
+		else
+			self:set_mob_animation("stand")
+			self:set_velocity(0)
+		end
+
+	end
+
+	if float_now then
+		self:float()
+	else
+		local acceleration = self.object:get_acceleration()
+		if acceleration and acceleration.y == 0 then
+			self.object:set_acceleration(vector.new(0, -self.gravity, 0))
+		end
+	end
+end
+
+
+-- move mob in facing direction
+--this has been modified to be internal
+--internal = lua (self.yaw)
+--engine = c++ (self.object:get_yaw())
+mobs.set_velocity = function(self, v)
+
+	local yaw = (self.yaw or 0)
+
+	local current_velocity = self.object:get_velocity()
+
+	local goal_velocity = {
+		x = (math.sin(yaw) * -v),
+		y = 0,
+		z = (math.cos(yaw) * v),
+	}
+
+
+	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
+
+	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
+		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
+	end
+
+	new_velocity_addition.y = 0
+
+	--smooths out mobs a bit
+	if vector.length(new_velocity_addition) >= 0.0001 then
+		self.object:add_velocity(new_velocity_addition)
+	end
+end
+
+
+
+-- calculate mob velocity
+mobs.get_velocity = function(self)
+
+	local v = self.object:get_velocity()
+
+	v.y = 0
+
+	if v then
+		return vector.length(v)
+	end
+
+	return 0
+end
+
+--make mobs jump
+mobs.jump = function(self, velocity)
+
+    if self.object:get_velocity().y ~= 0 or not self.old_velocity or (self.old_velocity and self.old_velocity.y > 0) then
+        return
+    end
+
+	--fallback velocity to allow modularity
+    velocity = velocity or DEFAULT_JUMP_HEIGHT
+
+    self.object:add_velocity(vector.new(0,velocity,0))
+end
+
+--make mobs fall slowly
+mobs.mob_fall_slow = function(self)
+
+	local current_velocity = self.object:get_velocity()
+
+	local goal_velocity = {
+		x = 0,
+		y = -2,
+		z = 0,
+	}
+
+
+	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
+
+	new_velocity_addition.x = 0
+	new_velocity_addition.z = 0
+
+	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
+		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
+	end
+
+	new_velocity_addition.x = 0
+	new_velocity_addition.z = 0
+
+	--smooths out mobs a bit
+	if vector.length(new_velocity_addition) >= 0.0001 then
+		self.object:add_velocity(new_velocity_addition)
+	end
+
+end
+
+]]--

mods/ENTITIES/mcl_mobs/api/ai/step_height.lua

@@ -0,0 +1,9 @@
+function mcl_mobs.mob:swap_auto_step_height_adjust()
+	local y_vel = self.object:get_velocity().y
+
+	if y_vel == 0 and self.stepheight ~= self.stepheight_backup then
+		self.stepheight = self.stepheight_backup
+	elseif y_vel ~= 0 and self.stepheight ~= 0 then
+		self.stepheight = 0
+	end
+end

mods/ENTITIES/mcl_mobs/api/ai/swim.lua

@@ -0,0 +1,206 @@
+
+--[[
+ _____          _
+/  ___|        (_)
+\ `--.__      ___ _ __ ___
+ `--. \ \ /\ / / | '_ ` _ \
+/\__/ /\ V  V /| | | | | | |
+\____/  \_/\_/ |_|_| |_| |_|
+]]--
+
+--[[
+
+-- state switching logic (stand, walk, run, attacks)
+local swim_state_list_wandering = {"stand", "swim"}
+
+local function swim_state_switch(self, dtime)
+	self.state_timer = self.state_timer - dtime
+	if self.state_timer <= 0 then
+		self.state_timer = math.random(4,10) + math.random()
+		self.state = swim_state_list_wandering[math.random(1, #swim_state_list_wandering)]
+	end
+end
+
+--check if a mob needs to turn while swimming
+local swim_turn_check = function(self,dtime)
+
+    local pos = self.object:get_pos()
+    pos.y = pos.y + 0.1
+    local dir = minetest_yaw_to_dir(self.yaw)
+
+    local collisionbox = self.object:get_properties().collisionbox
+	local radius = collisionbox[4] + 0.5
+
+    vector.multiply(dir, radius)
+
+    local test_dir = vector.add(pos,dir)
+
+	return minetest_get_item_group(minetest_get_node(test_dir).name, "solid") ~= 0
+end
+
+--this is to swap the built in engine acceleration modifier
+local function swim_physics_swapper(self, inside_swim_node)
+
+	--should be swimming, gravity is applied, switch to floating
+	if inside_swim_node and self.object:get_acceleration().y ~= 0 then
+		self.object:set_acceleration(vector.new(0, 0, 0))
+	--not be swim, gravity isn't applied, switch to falling
+	elseif not inside_swim_node and self.object:get_acceleration().y == 0 then
+		self.pitch = 0
+		self.object:set_acceleration(vector.new(0, -self.gravity, 0))
+	end
+end
+
+local random_pitch_multiplier = {-1,1}
+-- states are executed here
+local function swim_state_execution(self, dtime)
+
+	local pos = self.object:get_pos()
+
+	pos.y = pos.y + self.object:get_properties().collisionbox[5]
+	local current_node = minetest_get_node(pos).name
+	local inside_swim_node = false
+
+	--quick scan everything to see if inside swim node
+	for _,id in pairs(self.swim_in) do
+		if id == current_node then
+			inside_swim_node = true
+			break
+		end
+	end
+
+	--turn gravity on or off
+	swim_physics_swapper(self, inside_swim_node)
+
+	--swim properly if inside swim node
+	if inside_swim_node then
+
+		if self.state == "stand" then
+
+			--do animation
+			self:set_animation("stand")
+
+			self:set_swim_velocity(0)
+
+			if self.tilt_swim then
+				self:set_static_pitch()
+			end
+
+			self:lock_yaw()
+
+		elseif self.state == "swim" then
+
+			self.walk_timer = self.walk_timer - dtime
+
+			--reset the walk timer
+			if self.walk_timer <= 0 then
+
+				--re-randomize the walk timer
+				self.walk_timer = math.random(1, 6) + math.random()
+
+				--set the mob into a random direction
+				self.yaw = (math.random() * (math.pi * 2))
+
+				--create a truly random pitch, since there is no easy access to pitch math that I can find
+				self.pitch = math.random() * math.random(1, 3) * random_pitch_multiplier[math.random(1, 2)]
+			end
+
+			--do animation
+			self:set_animation("walk")
+
+			--do a quick turn to make mob continuously move
+			--if in a fish tank or something
+			if swim_turn_check(self, dtime) then
+				quick_rotate(self, dtime)
+			end
+
+			self:set_swim_velocity(self.walk_velocity)
+
+			--only enable tilt swimming if enabled
+			if self.tilt_swim then
+				self:set_dynamic_pitch()
+			end
+
+			--enable rotation locking
+			self:movement_rotation_lock()
+		end
+	--flop around if not inside swim node
+	else
+		--do animation
+		self:set_mob_animation("stand")
+
+		self:flop()
+
+		if self.tilt_swim then
+			self:set_static_pitch()
+		end
+	end
+
+end
+
+
+--make mobs flop
+mobs.flop = function(self, velocity)
+
+    if self.object:get_velocity().y ~= 0 or not self.old_velocity or (self.old_velocity and self.old_velocity.y > 0) then
+        return false
+    end
+
+	mobs.set_velocity(self, 0)
+
+	--fallback velocity to allow modularity
+    velocity = velocity or DEFAULT_JUMP_HEIGHT
+
+	--create a random direction (2d yaw)
+	local dir = DOUBLE_PI * math.random()
+
+	--create a random force value
+	local force = math.random(0,3) + math.random()
+
+	--convert the yaw to a direction vector then multiply it times the force
+	local final_additional_force = vector.multiply(minetest_yaw_to_dir(dir), force)
+
+	--place in the "flop" velocity to make the mob flop
+	final_additional_force.y = velocity
+
+    self.object:add_velocity(final_additional_force)
+
+	return true
+end
+
+
+
+-- move mob in facing direction
+--this has been modified to be internal
+--internal = lua (self.yaw)
+--engine = c++ (self.object:get_yaw())
+mobs.set_swim_velocity = function(self, v)
+
+	local yaw = (self.yaw or 0)
+	local pitch = (self.pitch or 0)
+
+	if v == 0 then
+		pitch = 0
+	end
+
+	local current_velocity = self.object:get_velocity()
+
+	local goal_velocity = {
+		x = (math.sin(yaw) * -v),
+		y = pitch,
+		z = (math.cos(yaw) * v),
+	}
+
+
+	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
+
+	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
+		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
+	end
+
+	--smooths out mobs a bit
+	if vector.length(new_velocity_addition) >= 0.0001 then
+		self.object:add_velocity(new_velocity_addition)
+	end
+end
+]]--

mods/ENTITIES/mcl_mobs/api/anger.lua

@@ -0,0 +1,205 @@
+--[[
+Implementation of the Minecraft 1.16 Anger System (copied from https://www.minecraft.net/ru-ru/article/nether-update-java, with modifications):
+
+Forgive dead players
+
+    If this gamerule is disabled, then angered mobs will stay angry even if the targeted player dies
+    If both forgiveDeadPlayers and universalAnger are enabled, an angered neutral mob will stop being angry when their target dies. They won't seek any new targets after that
+
+Neutral mob anger
+
+    When hurt by a player, the neutral mob will target that player and try to kill it
+    The mob will stay angry until the player is dead or out of sight for a while
+    Anger is persistent, so a player can't escape by temporarily logging out or switching dimension
+    If a targeted player dies near the angered mob, it will stop being angry (unless forgiveDeadPlayers is disabled)
+    Neutral mobs also get angry at other mobs who hurt them. However, that anger is not persistent
+    Angered neutral mobs will only attack the offending player, not innocent bystanders
+    Some mobs spread anger (wolf, Zombie Pigman). If a player attacks one, all nearby mobs of the same type will get angry at that player
+
+Universal anger
+
+Universal anger is basically guilt by association. A neutral mob attacked by players will be angry at players in general, regardless of who attacked them. More specifically:
+
+    A neutral mob attacked by a player will target the nearest player, even if that player wasn't the attacker
+    Every time the neutral mob is hit by a player it will update its attack target to the nearest player
+    Players can use this to make neutral mobs attack other players. Who would ever do something that devious?
+    Universal anger does not apply when a neutral mob is attacked by another mob - only when it is attacked by a player
+    Universal anger is persistent. The angered mob will stay angry even if the player logs out and logs in, or jumps through a portal and back
+    mcl_mobs.mobs that spread anger will also spread universal anger. So if a player attacks a Zombie Pigman, all other Zombie Pigmen within sight will be universally angry and attack their nearest player
+    An angered neutral mob will stop being angry if it can't see any eligible target for a while
+--]]
+
+function mcl_mobs.mob:anger_on_staticdata()
+	if self.anger_persistent then
+		self.data.anger_target_name = self.anger_target_name
+		self.data.anger_hurt_timestamp = self.anger_hurt_timestamp
+	end
+end
+
+function mcl_mobs.mob:anger_on_activate()
+	if self.data.anger_target_name then
+		self.anger = true
+		self.anger_persistent = true
+		self.anger_target_name = self.data.anger_target_name
+		self.anger_hurt_timestamp = self.data.anger_hurt_timestamp
+
+		self.data.anger_target_name = nil
+		self.data.anger_hurt_timestamp = nil
+	end
+end
+
+function mcl_mobs.mob:get_anger_attack_target()
+	if not self.anger then
+		return
+	end
+
+	-- if the mob is universally angry and the current target is unreachable, search a new one
+	local search_new_target = self.anger_universal and (
+		not self.anger_current_target -- does a current target even exist?
+		or not self.anger_current_target:is_player() -- universal anger only applies to players, so this is just a check whether the ObjectRef is still valid
+		or not self:can_see(self.anger_current_target) -- dimension check is not done since it is covered by the view distance check
+	)
+
+	if search_new_target then
+		self.anger_current_target = self:get_player_in_sight()
+		if self.anger_current_target then
+			self:debug("found new universal anger target: " .. self.anger_current_target:get_player_name())
+		end
+	end
+
+	-- if the anger is not persistant (e.g. enderman provocation, angry at mobs)
+	if not self.anger_persistent then
+		-- calm down if either the target ObjectRef is invalid or changed its dimension
+		if not self.anger_target:is_player() and not self.anger_target:get_luaentity() or not self:same_dimension_as(self.anger_target) then
+			self:debug("non persistent anger target unreachable, calming down" .. (self.anger_target_name and "[anger_target_name = " .. self.anger_target_name .. "]" or ""))
+			return nil, true
+		end
+	end
+
+	-- if this is a player, special rules apply (don't use anger_target:is_player() since the player may have logged out so it's not a valid check)
+	if self.anger_target_name then
+		-- check if player logged out (if the player had already logged out in the last step anger_target will be nil, else it will be a dangling ObjectRef that can be validated by calling is_player())
+		if not self.anger_target or not self.anger_target:is_player() then
+			if self.anger_target then
+				self:debug("anger target logged out: " .. self.anger_target_name)
+			end
+			-- in case the player relogged (if the player did not relog anger_target becomes nil and this is run in the next step as well)
+			self.anger_target = minetest.get_player_by_name(self.anger_target_name)
+			if self.anger_target then
+				self:debug("anger target relogged: " .. self.anger_target_name)
+			end
+		end
+		-- if forgiveDeadPlayers is true (it is by default)
+		if self.anger_target and minetest.settings:get_bool("mclForgiveDeadPlayers", true) then
+			-- check death timestamp of player and forget about the player in case it was killed
+			if self.anger_target:get_meta():get_int("mcl_mobs:last_death") >= self.hurt_timestamp then
+				self:debug("forgave " .. self.anger_target_name .. " since they died")
+				return nil, true
+			end
+		end
+	end
+
+	-- the actual target we want to attack
+	local target
+
+	-- note: dont use a selfmade ternary expression (v = x and a or b, in other languages that have real ternary expressions this would be v = x ? a : b) here
+	-- because anger_current_target might be nil and we don't care about the original player if they are not in the area (anger_current_target is only nil if there is absolutely no player in the area)
+	if self.anger_universal then
+		target = self.anger_current_target
+	else
+		target = self.anger_target
+		-- if the target is out of reach, it counts as not existant in terms of the reset timer
+		if target and not self:can_see(target) then
+			target = nil
+			if not self.anger_calm_timer then
+				self:debug("cannot see anger target " .. self.anger_target_name .. " anymore")
+			end
+		end
+	end
+
+	if not target and not self.anger_calm_timer then
+		-- start to calm down if noone to attack in sight
+		self:debug("anger target " .. (self.anger_universal and self.anger_target_name .. " " or "") .. "is not reachable anymore, starting calm timer")
+		self.anger_calm_timer = mcl_mobs.const.calm_down_timer
+	elseif target and self.anger_calm_timer then
+		-- stop calming down if there is someone in sight again
+		self:debug("anger target " .. (self.anger_universal and self.anger_target_name .. " " or "") .. "is reachable again, resetting calm timer")
+		self.anger_calm_timer = nil
+	end
+
+	if target then
+		return target
+	end
+
+	-- wait for the mob to calm down if there is no target, then clear variables
+	-- do_timer returns true if the timer has not elapsed yet
+	if not self:do_timer("anger_calm") then
+		self:debug("calmed down")
+		self.anger = nil
+		self.anger_target = nil
+		self.anger_target_name = nil
+		self.anger_universal = nil
+		self.anger_current_target = nil
+		self.anger_persistent = nil
+		self.anger_hurt_timestamp = nil
+	end
+end
+
+function mcl_mobs.mob:get_angry_raw(target, target_name, timestamp, universal, persistent)
+	if self.owner == target_name then
+		return false
+	end
+
+	self:debug("getting angry at " .. (target_name or tostring(target))
+		.. " persistent: " .. (persistent and "yes" or "no")
+		.. " universal: " .. (universal and "yes" or "no")
+	)
+
+	self.anger = true
+	self.anger_target = target -- even if universally angry, still remember the actual cause to apply forgiveDeadPlayers properly. anger_current_target is used to get the actual attack target
+	self.anger_target_name = target_name -- remember player name separately to work around the ObjectRef becoming invalid when the player logs out
+	-- the persistent field is used to optionally forget about the player when they log out or change dimension (e.g. provoking endermen by looking at them) or for when attacked by another mob
+	self.anger_persistent = persistent
+	self.anger_hurt_timestamp = timestamp
+
+	if universal then
+		self.anger_universal = true
+		 -- set this to nil because then universal anger is enabled every mob will look for a new target everytime a provocation happens
+		self.anger_current_target = nil
+	end
+
+	return true
+end
+
+function mcl_mobs.mob:get_angry(target)
+	local timestamp = os.time()
+	local is_player =  target:is_player()
+
+	local universal = is_player and minetest.settings:get_bool("mclUniversalAnger")
+	local target_name = is_player and target:get_player_name() or ""
+	local persistent = not is_player
+
+	self:debug("provoked by " .. (target_name or tostring(target))
+		.. " persistent: " .. (persistent and "yes" or "no")
+		.. " universal: " .. (universal and "yes" or "no")
+	)
+
+	if not self:get_angry_raw(target, target_name, timestamp, universal, persistent) then
+		return false
+	end
+
+	if self.def.group_attack then
+		for _, obj in pairs(minetest.get_objects_inside_radius(self.object:get_pos(), self.def.view_range)) do
+			local luaentity = obj:get_luaentity()
+			if luaentity and self.def.group_attack[luaentity.name] then
+				luaentity:get_angry_raw(target, target_name, timestamp, universal_anger, persistent)
+			end
+		end
+	end
+
+	return true
+end
+
+minetest.register_on_dieplayer(function(player)
+	player:get_meta():set_int("mcl_mobs:last_death", os.time())
+end)

mods/ENTITIES/mcl_mobs/api/api.lua

@@ -1,736 +0,0 @@
--- API for Mobs Redo: MineClone 2 Delux 2.0 DRM Free Early Access Super Extreme Edition
-
--- mobs library
-mobs = {}
-
--- lua locals - can grab from this to easily plop them into the api lua files
-
---localize minetest functions
-local minetest_settings                     = minetest.settings
-local minetest_get_objects_inside_radius    = minetest.get_objects_inside_radius
-local minetest_get_modpath                  = minetest.get_modpath
-local minetest_registered_nodes             = minetest.registered_nodes
-local minetest_get_node                     = minetest.get_node
---local minetest_get_item_group               = minetest.get_item_group
-local minetest_registered_entities          = minetest.registered_entities
---local minetest_line_of_sight                = minetest.line_of_sight
---local minetest_after                        = minetest.after
---local minetest_sound_play                   = minetest.sound_play
---local minetest_add_particlespawner          = minetest.add_particlespawner
---local minetest_registered_items             = minetest.registered_items
---local minetest_set_node                     = minetest.set_node
-local minetest_add_item                     = minetest.add_item
---local minetest_get_craft_result             = minetest.get_craft_result
---local minetest_find_path                    = minetest.find_path
-local minetest_is_creative_enabled          = minetest.is_creative_enabled
---local minetest_find_node_near               = minetest.find_node_near
---local minetest_find_nodes_in_area_under_air = minetest.find_nodes_in_area_under_air
---local minetest_raycast                      = minetest.raycast
---local minetest_get_us_time                  = minetest.get_us_time
-local minetest_add_entity                   = minetest.add_entity
---local minetest_get_natural_light            = minetest.get_natural_light
---local minetest_get_node_or_nil              = minetest.get_node_or_nil
-
--- localize math functions
-local math = math
-
--- localize vector functions
-local vector = vector
-
-local string = string
-
--- mob constants
---local BREED_TIME          = 30
---local BREED_TIME_AGAIN    = 300
---local CHILD_GROW_TIME     = 60*20
---local DEATH_DELAY         = 0.5
-local DEFAULT_FALL_SPEED  = -10
---local FLOP_HEIGHT         = 5.0
---local FLOP_HOR_SPEED      = 1.5
-local GRAVITY             = minetest_settings:get("movement_gravity")-- + 9.81
-
-local MAX_MOB_NAME_LENGTH = 30
-
-
---[[local MOB_CAP   = {}
-MOB_CAP.hostile = 70
-MOB_CAP.passive = 10
-MOB_CAP.ambient = 15
-MOB_CAP.water   = 15
-]]
-
--- Load main settings
---local damage_enabled    = minetest_settings:get_bool("enable_damage")
---local disable_blood     = minetest_settings:get_bool("mobs_disable_blood")
---local mobs_drop_items   = minetest_settings:get_bool("mobs_drop_items") ~= false
---local mobs_griefing     = minetest_settings:get_bool("mobs_griefing") ~= false
---local spawn_protected   = minetest_settings:get_bool("mobs_spawn_protected") ~= false
---local remove_far        = true
-local difficulty        = tonumber(minetest_settings:get("mob_difficulty")) or 1.0
---local show_health       = false
---local max_per_block     = tonumber(minetest_settings:get("max_objects_per_block") or 64)
----local mobs_spawn_chance = tonumber(minetest_settings:get("mobs_spawn_chance") or 2.5)
-
--- pathfinding settings
---local enable_pathfinding = true
---local stuck_timeout      = 3 -- how long before mob gets stuck in place and starts searching
---local stuck_path_timeout = 10 -- how long will mob follow path before giving up
-
--- default nodes
---local node_ice       = "mcl_core:ice"
---local node_snowblock = "mcl_core:snowblock"
---local node_snow      = "mcl_core:snow"
-mobs.fallback_node   = minetest.registered_aliases["mapgen_dirt"] or "mcl_core:dirt"
-
---local mod_weather     = minetest_get_modpath("mcl_weather")
---local mod_explosions  = minetest_get_modpath("mcl_explosions")
-local mod_mobspawners = minetest_get_modpath("mcl_mobspawners")
---local mod_hunger      = minetest_get_modpath("mcl_hunger")
---local mod_worlds      = minetest_get_modpath("mcl_worlds")
---local mod_armor       = minetest_get_modpath("mcl_armor")
---local mod_experience  = minetest_get_modpath("mcl_experience")
-
-
--- random locals I found
---local los_switcher    = false
---local height_switcher = false
-
--- Get translator
-local S = minetest.get_translator(minetest.get_current_modname())
-
--- CMI support check
---local use_cmi = minetest.global_exists("cmi")
-
--- creative check
-function mobs.is_creative(name)
-	return minetest_is_creative_enabled(name)
-end
-
---[[local function atan(x)
-	if not x or x ~= x then
-		return 0
-	else
-		return math.atan(x)
-	end
-end]]
-
--- Shows helpful debug info above each mob
---local mobs_debug = minetest_settings:get_bool("mobs_debug", false)
-
--- 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)
-		minetest.chat_send_player(player:get_player_name(),
-			S("Peaceful mode active! No monsters will spawn."))
-	end)
-end
-
-
-local api_path = minetest.get_modpath(minetest.get_current_modname()).."/api/mob_functions/"
-
---ignite all parts of the api
-dofile(api_path .. "flow_lib.lua")
-dofile(api_path .. "ai.lua")
-dofile(api_path .. "animation.lua")
-dofile(api_path .. "collision.lua")
-dofile(api_path .. "environment.lua")
-dofile(api_path .. "interaction.lua")
-dofile(api_path .. "movement.lua")
-dofile(api_path .. "set_up.lua")
-dofile(api_path .. "attack_type_instructions.lua")
-dofile(api_path .. "sound_handling.lua")
-dofile(api_path .. "death_logic.lua")
-dofile(api_path .. "mob_effects.lua")
-dofile(api_path .. "projectile_handling.lua")
-dofile(api_path .. "breeding.lua")
-dofile(api_path .. "head_logic.lua")
-
-
-mobs.spawning_mobs = {}
-
-
-
-
--- register mob entity
-function mobs:register_mob(name, def)
-
-	local collisionbox = def.collisionbox or {-0.25, -0.25, -0.25, 0.25, 0.25, 0.25}
-
-	-- Workaround for <https://github.com/minetest/minetest/issues/5966>:
-	-- Increase upper Y limit to avoid mobs glitching through solid nodes.
-	-- FIXME: Remove workaround if it's no longer needed.
-
-	if collisionbox[5] < 0.79 then
-		collisionbox[5] = 0.79
-	end
-
-	mobs.spawning_mobs[name] = true
-
-	local function scale_difficulty(value, default, min, special)
-		if (not value) or (value == default) or (value == special) then
-			return default
-		else
-			return math.max(min, value * difficulty)
-		end
-	end
-
-	minetest.register_entity(name, {
-		description = def.description,
-		use_texture_alpha = def.use_texture_alpha,
-		stepheight = def.stepheight or 0.6,
-		stepheight_backup = def.stepheight or 0.6,
-		name = name,
-		type = def.type,
-		attack_type = def.attack_type,
-		fly = def.fly,
-		fly_in = def.fly_in or {"air", "__airlike"},
-		owner = def.owner or "",
-		order = def.order or "",
-		on_die = def.on_die,
-		spawn_small_alternative = def.spawn_small_alternative,
-		do_custom = def.do_custom,
-		jump_height = def.jump_height or 4, -- was 6
-		rotate = def.rotate or 0, --  0=front, 90=side, 180=back, 270=side2
-		hp_min = scale_difficulty(def.hp_min, 5, 1),
-		hp_max = scale_difficulty(def.hp_max, 10, 1),
-		xp_min = def.xp_min or 1,
-		xp_max = def.xp_max or 5,
-		breath_max = def.breath_max or 6,
-		breathes_in_water = def.breathes_in_water or false,
-		physical = true,
-		collisionbox = collisionbox,
-		collide_with_objects = def.collide_with_objects or false,
-		selectionbox = def.selectionbox or def.collisionbox,
-		visual = def.visual,
-		visual_size = def.visual_size or {x = 1, y = 1},
-		mesh = def.mesh,
-		makes_footstep_sound = def.makes_footstep_sound or false,
-		view_range = def.view_range or 16,
-		walk_velocity = def.walk_velocity or 1,
-		run_velocity = def.run_velocity or 2,
-		damage = scale_difficulty(def.damage, 0, 0),
-		light_damage = def.light_damage or 0,
-		sunlight_damage = def.sunlight_damage or 0,
-		water_damage = def.water_damage or 0,
-		lava_damage = def.lava_damage or 8,
-		fire_damage = def.fire_damage or 1,
-		suffocation = def.suffocation or true,
-		fall_damage = def.fall_damage or 1,
-		fall_speed = def.fall_speed or DEFAULT_FALL_SPEED, -- must be lower than -2
-		drops = def.drops or {},
-		armor = def.armor or 100,
-		on_rightclick = mobs.create_mob_on_rightclick(def.on_rightclick),
-		arrow = def.arrow,
-		shoot_interval = def.shoot_interval,
-		sounds = def.sounds or {},
-		animation = def.animation,
-		jump = def.jump ~= false,
-		walk_chance = def.walk_chance or 50,
-		attacks_monsters = def.attacks_monsters or false,
-		group_attack = def.group_attack or false,
-		passive = def.passive or false,
-		knock_back = def.knock_back ~= false,
-		shoot_offset = def.shoot_offset or 0,
-		floats = def.floats or 1, -- floats in water by default
-		floats_on_lava = def.floats_on_lava or 0,
-		replace_rate = def.replace_rate,
-		replace_what = def.replace_what,
-		replace_with = def.replace_with,
-		replace_offset = def.replace_offset or 0,
-		on_replace = def.on_replace,
-		timer = 0,
-		state_timer = 0,
-		env_damage_timer = 0,
-		tamed = false,
-		pause_timer = 0,
-		gotten = false,
-		reach = def.reach or 3,
-		htimer = 0,
-		texture_list = def.textures,
-		child_texture = def.child_texture,
-		docile_by_day = def.docile_by_day or false,
-		time_of_day = 0.5,
-		fear_height = def.fear_height or 0,
-		runaway = def.runaway,
-		runaway_timer = 0,
-		pathfinding = def.pathfinding,
-		immune_to = def.immune_to or {},
-		explosion_radius = def.explosion_radius, -- LEGACY
-		explosion_damage_radius = def.explosion_damage_radius, -- LEGACY
-		explosiontimer_reset_radius = def.explosiontimer_reset_radius,
-		explosion_timer = def.explosion_timer or 3,
-		allow_fuse_reset = def.allow_fuse_reset ~= false,
-		stop_to_explode = def.stop_to_explode ~= false,
-		custom_attack = def.custom_attack,
-		double_melee_attack = def.double_melee_attack,
-		dogshoot_switch = def.dogshoot_switch,
-		dogshoot_count = 0,
-		dogshoot_count_max = def.dogshoot_count_max or 5,
-		dogshoot_count2_max = def.dogshoot_count2_max or (def.dogshoot_count_max or 5),
-		attack_animals = def.attack_animals or false,
-		specific_attack = def.specific_attack,
-		runaway_from = def.runaway_from,
-		owner_loyal = def.owner_loyal,
-		facing_fence = false,
-
-		_cmi_is_mob = true,
-
-		pushable = def.pushable or true,
-
-		--j4i stuff
-		yaw = 0,
-		automatic_face_movement_dir = def.rotate or 0,  --  0=front, 90=side, 180=back, 270=side2
-		automatic_face_movement_max_rotation_per_sec = 360, --degrees
-		backface_culling = true,
-		walk_timer = 0,
-		stand_timer = 0,
-		current_animation = "",
-		gravity = GRAVITY,
-		swim = def.swim,
-		swim_in = def.swim_in or {mobs_mc.items.water_source, "mcl_core:water_flowing", mobs_mc.items.river_water_source},
-		pitch_switch = "static",
-		jump_only = def.jump_only,
-		hostile = def.hostile,
-		neutral = def.neutral,
-		attacking = nil,
-		visual_size_origin = def.visual_size or {x = 1, y = 1, z = 1},
-		punch_timer_cooloff = def.punch_timer_cooloff or 0.5,
-		death_animation_timer = 0,
-		hostile_cooldown = def.hostile_cooldown or 15,
-		tilt_fly = def.tilt_fly,
-		tilt_swim = def.tilt_swim,
-		fall_slow = def.fall_slow,
-		projectile_cooldown_min = def.projectile_cooldown_min or 2,
-		projectile_cooldown_max = def.projectile_cooldown_max or 6,
-		skittish = def.skittish,
-
-		minimum_follow_distance = def.minimum_follow_distance or 0.5, --make mobs not freak out when underneath
-
-		memory = 0, -- memory timer if chasing/following
-		fly_random_while_attack = def.fly_random_while_attack,
-
-		--for spiders
-		always_climb = def.always_climb,
-
-		--despawn mechanic variables
-		lifetimer_reset = 30, --30 seconds
-		lifetimer = 30, --30 seconds
-
-		--breeding stuff
-		breed_timer = 0,
-		breed_lookout_timer = 0,
-		breed_distance = def.breed_distance or 1.5, --how far away mobs have to be to begin actual breeding
-		breed_lookout_timer_goal = 30, --30 seconds (this timer is for how long the mob looks for a mate)
-		breed_timer_cooloff = 5*60, -- 5 minutes (this timer is for how long the mob has to wait before being bred again)
-		bred = false,
-		follow = def.follow, --this item is also used for the breeding mechanism
-		follow_distance = def.follow_distance or 2,
-		baby_size = def.baby_size or 0.5,
-		baby = false,
-		grow_up_timer = 0,
-		grow_up_goal  = 20*60, --in 20 minutes the mob grows up
-		special_breed_timer = 0, --this is used for the AHEM AHEM part of breeding
-
-		backup_visual_size = def.visual_size,
-		backup_collisionbox = collisionbox,
-		backup_selectionbox = def.selectionbox or def.collisionbox,
-
-
-		--fire timer
-		burn_timer = 0,
-
-		ignores_cobwebs = def.ignores_cobwebs,
-		breath = def.breath_max or 6,
-
-		random_sound_timer_min = 3,
-		random_sound_timer_max = 10,
-
-		--head code variables
-		--defaults are for the cow's default
-		--because I don't know what else to set them
-		--to :P
-
-		--you must use these to adjust the mob's head positions
-
-		--has_head is used as a logic gate (quick easy check)
-		has_head = def.has_head or false,
-		--head_bone is the actual bone in the model which the head
-		--is attached to for animation
-		head_bone = def.head_bone or "head",
-
-		--this part controls the base position of the head calculations
-		--localized to the mob's visual yaw when gotten (self.object:get_yaw())
-		--you can enable the debug in /mob_functions/head_logic.lua by uncommenting the
-		--particle spawner code
-		head_height_offset =  def.head_height_offset or 1.0525,
-		head_direction_offset = def.head_direction_offset or 0.5,
-
-		--this part controls the visual of the head
-		head_bone_pos_y = def.head_bone_pos_y or 3.6,
-		head_bone_pos_z = def.head_bone_pos_z or -0.6,
-		head_pitch_modifier = def.head_pitch_modifier or 0,
-
-		--these variables are switches in case the model
-		--moves the wrong way
-		swap_y_with_x = def.swap_y_with_x or false,
-		reverse_head_yaw = def.reverse_head_yaw or false,
-
-		--END HEAD CODE VARIABLES
-
-		--end j4i stuff
-
-		-- MCL2 extensions
-		teleport = mobs.teleport,
-		do_teleport = def.do_teleport,
-		spawn_class = def.spawn_class,
-		ignores_nametag = def.ignores_nametag or false,
-		rain_damage = def.rain_damage or 0,
-		glow = def.glow,
-		--can_despawn = can_despawn,
-		child = def.child or false,
-		texture_mods = {},
-		shoot_arrow = def.shoot_arrow,
-		sounds_child = def.sounds_child,
-		explosion_strength = def.explosion_strength,
-		suffocation_timer = 0,
-		follow_velocity = def.follow_velocity or 2.4,
-		instant_death = def.instant_death or false,
-		fire_resistant = def.fire_resistant or false,
-		fire_damage_resistant = def.fire_damage_resistant or false,
-		ignited_by_sunlight = def.ignited_by_sunlight or false,
-		eye_height = def.eye_height or 1.5,
-		defuse_reach = def.defuse_reach or 4,
-		-- End of MCL2 extensions
-
-		on_spawn = def.on_spawn,
-
-		--on_blast = def.on_blast or do_tnt,
-
-		on_step  = mobs.mob_step,
-
-		--do_punch = def.do_punch,
-
-		on_punch = mobs.mob_punch,
-
-		--on_breed = def.on_breed,
-
-		--on_grown = def.on_grown,
-
-		--on_detach_child = mob_detach_child,
-
-		on_activate = function(self, staticdata, dtime)
-			self.object:set_acceleration(vector.new(0,-GRAVITY, 0))
-			return mobs.mob_activate(self, staticdata, def, dtime)
-		end,
-
-		get_staticdata = function(self)
-			return mobs.mob_staticdata(self)
-		end,
-
-		--harmed_by_heal = def.harmed_by_heal,
-	})
-
-	if minetest_get_modpath("doc_identifier") then
-		doc.sub.identifier.register_object(name, "basics", "mobs")
-	end
-
-end -- END mobs:register_mob function
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
--- register arrow for shoot attack
-function mobs:register_arrow(name, def)
-
-	-- errorcheck
-	if not name or not def then
-		print("failed to register arrow entity")
-		return
-	end
-
-	minetest.register_entity(name.."_entity", {
-
-		physical = false,
-		visual = def.visual,
-		visual_size = def.visual_size,
-		textures = def.textures,
-		velocity = def.velocity,
-		hit_player = def.hit_player,
-		hit_node = def.hit_node,
-		hit_mob = def.hit_mob,
-		hit_object = def.hit_object,
-		drop = def.drop or false, -- drops arrow as registered item when true
-		collisionbox = {0, 0, 0, 0, 0, 0}, -- remove box around arrows
-		timer = 0,
-		switch = 0,
-		owner_id = def.owner_id,
-		rotate = def.rotate,
-		speed = def.speed or nil,
-		on_step = function(self)
-
-			local vel = self.object:get_velocity()
-
-			local pos = self.object:get_pos()
-
-			if self.timer > 150
-			or not mobs.within_limits(pos, 0) then
-				mcl_burning.extinguish(self.object)
-				self.object:remove();
-				return
-			end
-
-			-- does arrow have a tail (fireball)
-			if def.tail
-			and def.tail == 1
-			and def.tail_texture then
-
-				--do this to prevent clipping through main entity sprite
-				local pos_adjustment = vector.multiply(vector.normalize(vel), -1)
-				local divider = def.tail_distance_divider or 1
-				pos_adjustment = vector.divide(pos_adjustment, divider)
-				local new_pos = vector.add(pos, pos_adjustment)
-				minetest.add_particle({
-					pos = new_pos,
-					velocity = {x = 0, y = 0, z = 0},
-					acceleration = {x = 0, y = 0, z = 0},
-					expirationtime = def.expire or 0.25,
-					collisiondetection = false,
-					texture = def.tail_texture,
-					size = def.tail_size or 5,
-					glow = def.glow or 0,
-				})
-			end
-
-			if self.hit_node then
-
-				local node = minetest_get_node(pos).name
-
-				if minetest_registered_nodes[node].walkable then
-
-					self.hit_node(self, pos, node)
-
-					if self.drop == true then
-
-						pos.y = pos.y + 1
-
-						self.lastpos = (self.lastpos or pos)
-
-						minetest_add_item(self.lastpos, self.object:get_luaentity().name)
-					end
-
-					self.object:remove();
-
-					return
-				end
-			end
-
-			if self.hit_player or self.hit_mob or self.hit_object then
-
-				for _,player in pairs(minetest_get_objects_inside_radius(pos, 1.5)) do
-
-					if self.hit_player
-					and player:is_player() then
-
-						if self.hit_player then
-							self.hit_player(self, player)
-						else
-							mobs.arrow_hit(self, player)
-						end
-
-						self.object:remove();
-						return
-					end
-
-					--[[
-					local entity = player:get_luaentity()
-
-					if entity
-					and self.hit_mob
-					and entity._cmi_is_mob == true
-					and tostring(player) ~= self.owner_id
-					and entity.name ~= self.object:get_luaentity().name
-					and (self._shooter and entity.name ~= self._shooter:get_luaentity().name) then
-
-						--self.hit_mob(self, player)
-						self.object:remove();
-						return
-					end
-					]]--
-
-					--[[
-					if entity
-					and self.hit_object
-					and (not entity._cmi_is_mob)
-					and tostring(player) ~= self.owner_id
-					and entity.name ~= self.object:get_luaentity().name
-					and (self._shooter and entity.name ~= self._shooter:get_luaentity().name) then
-
-						--self.hit_object(self, player)
-						self.object:remove();
-						return
-					end
-					]]--
-				end
-			end
-
-			self.lastpos = pos
-		end
-	})
-end
-
--- Register spawn eggs
-
--- Note: This also introduces the “spawn_egg” group:
--- * spawn_egg=1: Spawn egg (generic mob, no metadata)
--- * spawn_egg=2: Spawn egg (captured/tamed mob, metadata)
-function mobs:register_egg(mob, desc, background, addegg, no_creative)
-
-	local grp = {spawn_egg = 1}
-
-	-- do NOT add this egg to creative inventory (e.g. dungeon master)
-	if no_creative == true then
-		grp.not_in_creative_inventory = 1
-	end
-
-	local invimg = background
-
-	if addegg == 1 then
-		invimg = "mobs_chicken_egg.png^(" .. invimg ..
-			"^[mask:mobs_chicken_egg_overlay.png)"
-	end
-
-	-- register old stackable mob egg
-	minetest.register_craftitem(mob, {
-
-		description = desc,
-		inventory_image = invimg,
-		groups = grp,
-
-		_doc_items_longdesc = S("This allows you to place a single mob."),
-		_doc_items_usagehelp = S("Just place it where you want the mob to appear. Animals will spawn tamed, unless you hold down the sneak key while placing. If you place this on a mob spawner, you change the mob it spawns."),
-
-		on_place = function(itemstack, placer, pointed_thing)
-
-			local pos = pointed_thing.above
-
-			-- am I clicking on something with existing on_rightclick function?
-			local under = minetest_get_node(pointed_thing.under)
-			local def = minetest_registered_nodes[under.name]
-			if def and def.on_rightclick then
-				return def.on_rightclick(pointed_thing.under, under, placer, itemstack)
-			end
-
-			if pos
-			--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 mod_mobspawners and under.name == "mcl_mobspawners:spawner" then
-					if minetest.is_protected(pointed_thing.under, name) then
-						minetest.record_protection_violation(pointed_thing.under, name)
-						return itemstack
-					end
-					if not privs.maphack then
-						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())
-					if not mobs.is_creative(name) then
-						itemstack:take_item()
-					end
-					return itemstack
-				end
-
-				if not minetest_registered_entities[mob] then
-					return itemstack
-				end
-
-				if minetest_settings:get_bool("only_peaceful_mobs", false)
-						and minetest_registered_entities[mob].type == "monster" then
-					minetest.chat_send_player(name, S("Only peaceful mobs allowed!"))
-					return itemstack
-				end
-
-				local mob = minetest_add_entity(pos, mob)
-				minetest.log("action", "Mob spawned: "..name.." at "..minetest.pos_to_string(pos))
-				local ent = mob:get_luaentity()
-
-				-- don't set owner if monster or sneak pressed
-				--[[
-				if ent.type ~= "monster"
-				and not placer:get_player_control().sneak then
-					ent.owner = placer:get_player_name()
-					ent.tamed = true
-				end
-				]]--
-
-				-- set nametag
-				local nametag = itemstack:get_meta():get_string("name")
-				if nametag ~= "" then
-					if string.len(nametag) > MAX_MOB_NAME_LENGTH then
-						nametag = string.sub(nametag, 1, MAX_MOB_NAME_LENGTH)
-					end
-					ent.nametag = nametag
-					--update_tag(ent)
-				end
-
-				-- if not in creative then take item
-				if not mobs.is_creative(placer:get_player_name()) then
-					itemstack:take_item()
-				end
-			end
-
-			return itemstack
-		end,
-	})
-
-end
-
-

mods/ENTITIES/mcl_mobs/api/arrow.lua

@@ -0,0 +1,158 @@
+--[[
+function mcl_mobs.register_arrow(name, def)
+	minetest.register_entity(name.."_entity", {
+
+		physical = false,
+		visual = def.visual,
+		visual_size = def.visual_size,
+		textures = def.textures,
+		velocity = def.velocity,
+		hit_player = def.hit_player,
+		hit_node = def.hit_node,
+		hit_mob = def.hit_mob,
+		hit_object = def.hit_object,
+		drop = def.drop or false, -- drops arrow as registered item when true
+		collisionbox = {0, 0, 0, 0, 0, 0}, -- remove box around arrows
+		timer = 0,
+		switch = 0,
+		owner_id = def.owner_id,
+		rotate = def.rotate,
+		speed = def.speed or nil,
+		on_step = function(self)
+
+			local vel = self.object:get_velocity()
+
+			local pos = self.object:get_pos()
+
+			if self.timer > 150
+			or not mobs.within_limits(pos, 0) then
+				mcl_burning.extinguish(self.object)
+				self.object:remove();
+				return
+			end
+
+			-- does arrow have a tail (fireball)
+			if def.tail
+			and def.tail == 1
+			and def.tail_texture then
+
+				--do this to prevent clipping through main entity sprite
+				local pos_adjustment = vector.multiply(vector.normalize(vel), -1)
+				local divider = def.tail_distance_divider or 1
+				pos_adjustment = vector.divide(pos_adjustment, divider)
+				local new_pos = vector.add(pos, pos_adjustment)
+				minetest.add_particle({
+					pos = new_pos,
+					velocity = {x = 0, y = 0, z = 0},
+					acceleration = {x = 0, y = 0, z = 0},
+					expirationtime = def.expire or 0.25,
+					collisiondetection = false,
+					texture = def.tail_texture,
+					size = def.tail_size or 5,
+					glow = def.glow or 0,
+				})
+			end
+
+			if self.hit_node then
+
+				local node = minetest.get_node(pos).name
+
+				if minetest.registered_nodes[node].walkable then
+
+					self.hit_node(self, pos, node)
+
+					if self.drop == true then
+
+						pos.y = pos.y + 1
+
+						self.lastpos = (self.lastpos or pos)
+
+						minetest.add_item(self.lastpos, self.object:get_luaentity().name)
+					end
+
+					self.object:remove();
+
+					return
+				end
+			end
+
+			if self.hit_player or self.hit_mob or self.hit_object then
+
+				for _,player in pairs(minetest.get_objects_inside_radius(pos, 1.5)) do
+
+					if self.hit_player
+					and player:is_player() then
+
+						if self.hit_player then
+							self.hit_player(self, player)
+						else
+							mobs.arrow_hit(self, player)
+						end
+
+						self.object:remove();
+						return
+					end
+
+					--[[
+					local entity = player:get_luaentity()
+
+					if entity
+					and self.hit_mob
+					and entity._cmi_is_mob == true
+					and tostring(player) ~= self.owner_id
+					and entity.name ~= self.object:get_luaentity().name
+					and (self._shooter and entity.name ~= self._shooter:get_luaentity().name) then
+
+						--self.hit_mob(self, player)
+						self.object:remove();
+						return
+					end
+					] ]--
+
+					--[[
+					if entity
+					and self.hit_object
+					and (not entity._cmi_is_mob)
+					and tostring(player) ~= self.owner_id
+					and entity.name ~= self.object:get_luaentity().name
+					and (self._shooter and entity.name ~= self._shooter:get_luaentity().name) then
+
+						--self.hit_object(self, player)
+						self.object:remove();
+						return
+					end
+					] ]--
+				end
+			end
+
+			self.lastpos = pos
+		end
+	})
+end
+
+
+--this is used for arrow collisions
+mobs.arrow_hit = function(self, player)
+
+    player:punch(self.object, 1.0, {
+        full_punch_interval = 1.0,
+        damage_groups = {fleshy = self._damage}
+    }, nil)
+
+
+    --knockback
+    local pos1 = self.object:get_pos()
+	pos1.y = 0
+    local pos2 = player:get_pos()
+    pos2.y = 0
+    local dir = vector.direction(pos1,pos2)
+
+    dir = vector.multiply(dir,3)
+
+    if player:get_velocity().y <= 1 then
+        dir.y = 5
+    end
+
+    player:add_velocity(dir)
+end
+]]--

mods/ENTITIES/mcl_mobs/api/baby.lua

@@ -0,0 +1,26 @@
+function mcl_mobs.mob:baby_step()
+	if not self:do_timer("grow_up", true) then
+		self:baby_grow_up()
+	end
+end
+
+function mcl_mobs.mob:baby_grow_up()
+	self:debug("growing up")
+	self.data.baby = nil
+
+	if self.def.on_grow_up then
+		self.def.on_grow_up(self)
+	end
+
+	self:update_textures()
+	self:update_visual_size()
+	self:update_eye_height()
+	self:update_collisionbox()
+end
+
+function mcl_mobs.mob:boost()
+	self:debug("grow up boost")
+	self.data.grow_up_timer = self.data.grow_up_timer - self.data.grow_up_timer * mcl_mobs.const.grow_up_boost
+	-- ToDo: check whether the Minecraft wiki terminology is right about 10% or whether they actually mean 10 percent points
+	-- (10 percent would be 0.1 * self.data.grow_up_timer, 10 percent points would be 0.1 * self.def.grow_up_goal)
+end

mods/ENTITIES/mcl_mobs/api/breeding.lua

@@ -0,0 +1,27 @@
+function mcl_mobs.mob:start_breed_giveup_timer()
+	self.breed_giveup_timer = mcl_mobs.const.breed_giveup_timer
+end
+
+function mcl_mobs.mob:breeding_on_activate()
+	if self.data.breeding then
+		self:start_breed_giveup_timer()
+	end
+end
+
+function mcl_mobs.mob:init_breeding()
+	self:debug("initializing breeding")
+	self.data.bred = true
+	self.data.breeding = true
+	self:start_breed_giveup_timer()
+end
+
+-- looking for hot singles in the area
+function mcl_mobs.mob:find_mate()
+	return self:get_near_object(self.def.view_range, function(self, obj)
+		local luaentity = obj:get_luaentity()
+		return luaentity -- dont fook with hoomans
+			and luaentity.name == self.name -- this is MineClone, not Animal Crossing
+			and not luaentity.data.bred -- no polygamy pls
+			and not luaentity.data.baby -- no pedophila pls
+	end)
+end

mods/ENTITIES/mcl_mobs/api/common.lua

@@ -0,0 +1,115 @@
+function mcl_mobs.mob:debug(msg)
+	if mcl_mobs.const.debug then
+		minetest.log("[mcl_mobs] " .. tostring(self.object) .. "[" .. self.name .. "]: " .. msg)
+	end
+end
+
+function mcl_mobs.mob:do_timer(name, persistent)
+	local k = name .. "_timer"
+	local t = persistent and self.data or self
+	local v = t[k]
+
+	if not v then
+		return
+	end
+
+	local r = true
+
+	v = v - self.dtime
+	if v <= 0 then
+		self:debug(k .. " elapsed")
+		v = nil
+		r = false
+	end
+
+	t[k] = v
+
+	return r
+end
+
+function mcl_mobs.mob:same_dimension_as(obj)
+	return mcl_worlds.pos_to_dimension(obj:get_pos()) == mcl_worlds.pos_to_dimension(self.object:get_pos())
+end
+
+function mcl_mobs.mob:can_see(obj)
+	return vector.distance(obj:get_pos(), self.object:get_pos()) <= self.def.view_range
+end
+
+function mcl_mobs.mob:get_player_in_sight()
+	return self:get_near_player(self.def.view_range)
+end
+
+function mcl_mobs.mob:is_player_near(radius)
+	for _, player in pairs(minetest.get_connected_players()) do
+		if vector.distance(pos, player:get_pos()) < radius then
+			return true
+		end
+	end
+	return false
+end
+
+function mcl_mobs.mob:get_near_player(radius, condition)
+	local pos = self.object:get_pos()
+	local eye_pos = vector.new(pos.x, pos.y + self.eye_height, pos.z)
+
+	local nearest_player
+	local nearest_distance = radius -- this is very big brain right there, I feel genious
+
+	for _, player in pairs(minetest.get_connected_players()) do
+		if player:get_hp() > 0 then
+			local player_pos = obj:get_pos()
+			if vector.distance(pos, player_pos) < nearest_distance and (not condition or condition(self, player)) and minetest.line_of_sight(eye_pos, vector.new(player_pos.x, player_pos.y + player:get_properties().eye_height, player_pos.z)) then
+				nearest_player = player
+				nearest_distance = distance
+			end
+		end
+	end
+
+	return nearest_player
+end
+
+-- I know this repeats some things from the get_near_player function but things need to be optimized so these 2 functions actually differ (believe me, even tho it looks ugly, it makes sense)
+function mcl_mobs.mob:get_near_object(radius, condition)
+	local eye_pos = self.object:get_pos()
+	eye_pos.y = eye_pos.y + self.eye_height
+
+	for _, obj in ipairs(minetest.get_objects_inside_radius(pos, radius)) do
+		if obj ~= self.object and mcl_util.get_hp(obj) > 0 and (not condition or condition(self, obj)) then
+			local obj_eye_pos = obj:get_pos()
+			obj_eye_pos.y = obj_eye_pos.y + mcl_mobs.util.get_eye_height(obj)
+			if minetest.line_of_sight(eye_pos, obj_eye_pos) then
+				return obj
+			end
+		end
+	end
+end
+
+-- this function gets a definition field DYNAMICALLY (if the field is a function, call it and return the result, else return the field directly)
+function mcl_mobs.mob:evaluate(key, ...)
+	local value = self.def[key]
+
+	if value then
+		if type(value) == "function" then
+			value = value(self, ...)
+		end
+		return value
+	end
+end
+
+--[[
+--a teleport functoin
+mobs.teleport = function(self, target)
+	if self.do_teleport then
+		if self.do_teleport(self, target) == false then
+			return
+		end
+	end
+end
+
+--a simple helper function for mobs following
+mobs.get_2d_distance = function(pos1,pos2)
+	pos1.y = 0
+	pos2.y = 0
+	return(vector.distance(pos1, pos2))
+end
+]]--

mods/ENTITIES/mcl_mobs/api/damage.lua

@@ -0,0 +1,80 @@
+function mcl_mobs.mob:deal_damage(damage, reason)
+	if self.dead or self.data.invulnerable then
+		return 0
+	end
+
+	if reason.flags.is_fire and self.def.fire_damage_resistant then
+		return 0
+	end
+
+	damage = mcl_damage.run_modifiers(self.object, damage, reason)
+
+	if damage > 0 then
+		mcl_damage.run_damage_callbacks(self.object, damage, reason)
+		self.data.health = self.data.health - damage
+		self.stun_timer = mcl_mobs.const.stun_timer
+		self:update_movement()
+		self.object:set_texture_mod("^[colorize:red:120")
+
+		if self.data.health < 0 then
+			self:die(reason)
+		else
+			self:play_sound("damage")
+		end
+	end
+
+	return damage
+end
+
+function mcl_mobs.mob:on_punch(puncher, time_from_last_punch, tool_capabilities, direction, damage)
+	if damage < 0 then
+		return
+	end
+
+	local reason = {}
+	mcl_damage.from_punch(reason, puncher)
+	mcl_damage.finish_reason(reason)
+
+	if self.def.on_punch then
+		local args = {puncher = puncher, time_from_last_punch = time_from_last_punch, tool_capabilities = tool_capabilities, direction = direction}
+		if self.def.on_punch(self, damage, reason, args) == false then
+			return true
+		end
+	end
+
+	self:get_angry(reason.source)
+
+	-- PANIC AND RUN
+	if self.def.skittish then
+		self.state = "run"
+
+		self.run_timer = mcl_mobs.const.run_timer
+
+		local pos1 = self.object:get_pos()
+		pos1.y = 0
+		local pos2 = reason.source:get_pos()
+		pos2.y = 0
+
+
+		local dir = vector.direction(pos2, pos1)
+
+		self.yaw = minetest.dir_to_yaw(direction)
+	end
+
+	if reason.type == "player" then
+		mcl_hunger.exhaust(puncher:get_player_name(), mcl_hunger.EXHAUST_ATTACK)
+	end
+
+	damage = self:deal_damage(damage, reason)
+
+	if damage > 0 then
+		self:play_sound_specific("default_punch")
+		self:knockback(reason.source)
+	end
+
+	return true
+end
+
+function mcl_mobs.mob:update_armor_groups()
+	self.object:set_armor_groups(self.def.armor_groups)
+end

mods/ENTITIES/mcl_mobs/api/data.lua

@@ -0,0 +1,57 @@
+function mcl_mobs.mob:get_staticdata()
+	if self.dead then
+		self.object:remove()
+		return
+	end
+
+	self:anger_on_staticdata()
+
+	if self.def.on_staticdata then
+		if self.def.on_staticdata(self) == false then
+			self.object:remove()
+			return
+		end
+	end
+
+	return minetest.serialize(self.data)
+end
+
+function mcl_mobs.mob:on_activate(staticdata, def, dtime)
+	self.is_mob = true
+	self.def = mcl_mobs.registered_mobs[self.name] -- just access the mob def instead of spamming the luaentity itself with a copy of every single definition field that is never mutated
+	self.description = def.description -- external mods might want to access this
+
+	self.data = minetest.deserialize(staticdata) or {}
+
+	self.data.health = self.data.health or math.random(self.def.health_min, self.def.health_max)
+	self.data.breath = self.data.breath or self.def.breath_max
+	self.data.yaw = self.data.yaw or 0
+
+	self:reload_properties()
+	self:backup_movement()
+
+	self:anger_on_activate()
+	self:despawn_on_activate()
+	self:breeding_on_activate()
+
+	self:set_animation("stand")
+	self:update_collisionbox()
+	self:update_eye_height()
+	self:update_mesh()
+	self:update_nametag()
+	self:update_roll()
+	self:update_textures()
+	self:update_visual_size()
+
+	if self.def.on_spawn and not self.data.on_spawn_run then
+		self.def.on_spawn(self)
+		self.data.on_spawn_run = true
+	end
+
+	if self.def.on_activate then
+		if self.def.on_activate(self, staticdata, def, dtime) == false then
+			self.object:remove()
+			return
+		end
+	end
+end

mods/ENTITIES/mcl_mobs/api/death.lua

@@ -0,0 +1,49 @@
+function mcl_mobs.mob:die(reason)
+	self.dead = true
+	self.death_timer = mcl_mobs.const.death_timer
+
+	for _, obj in pairs(self.object:get_children()) do
+		mcl_mount.throw_off(obj)
+	end
+
+	if minetest.settings:get_bool("doMobDrops", true) then
+		self:drop_loot(reason)
+	end
+
+	self:play_sound("death")
+	self:set_animation("death")
+	self:set_properties({pointable = false})
+	self:update_acceleration()
+
+	if self.def.on_death then
+		self.def.on_death(self, reason)
+	end
+end
+
+function mcl_mobs.mob:death_step()
+	if self:do_timer("death") then
+		self:update_roll()
+	else
+		local pos = self.object:get_pos()
+
+		minetest.add_particlespawner({
+			amount = 50,
+			time = 0.0001,
+			minpos = vector.add(pos, self.collisionbox.min),
+			maxpos = vector.add(pos, self.collisionbox.max),
+			minvel = vector.new(-0.5, 0.5, -0.5),
+			maxvel = vector.new(0.5, 1.0, 0.5),
+			minexptime = 1.1,
+			maxexptime = 1.5,
+			minsize = 1,
+			maxsize = 2,
+			collisiondetection = false,
+			vertical = false,
+			texture = "mcl_particles_mob_death.png",
+		})
+
+		self:play_sound_specific("mcl_sounds_poof")
+
+		self.object:remove() -- RIP
+	end
+end

mods/ENTITIES/mcl_mobs/api/despawn.lua

@@ -0,0 +1,24 @@
+function mcl_mobs.mob:despawn_on_activate()
+	self.data.can_despawn = self.data.can_despawn ~= false and self.def.can_despawn
+	if self.data.can_despawn then
+		self.life_timer = life_timer -- how much time is left until next despawn check
+	end
+end
+
+function mcl_mobs.mob:despawn_step()
+	if not self:do_timer("life") then
+		self.life_timer = life_timer
+		return not self:check_despawn()
+	end
+	return true
+end
+
+function mcl_mobs.mob:check_despawn()
+	self:debug("checking for nearby players")
+	if not self:is_player_near(despawn_radius) then
+		self:debug("despawning")
+		self.object:remove()
+		return true
+	end
+	return false
+end

mods/ENTITIES/mcl_mobs/api/easteregg.lua

@@ -0,0 +1,34 @@
+function mcl_mobs.mob:update_easteregg()
+	local old_easteregg = self.easteregg or {}
+	local eastereggs = table.key_value_swap(mcl_mobs.eastereggs)
+
+	local easteregg_name = eastereggs[self.data.nametag]
+	local easteregg = old_easteregg
+
+	if old_easteregg.name ~= easteregg_name then
+		easteregg = {
+			name = easteregg_name,
+			[easteregg_name] = true,
+		}
+	end
+
+	if easteregg.rainbow ~= old_easteregg.rainbow then
+		if easteregg.rainbow then
+			easteregg.hue = 0
+		end
+	elseif easteregg.upside_down ~= old_easteregg.upside_down then
+		self:update_roll()
+		self:update_collisionbox()
+	end
+
+	self.easteregg = easteregg
+end
+
+function mcl_mobs.mob:easteregg_step()
+	if self.easteregg.rainbow then
+		self.easteregg.hue = self.easteregg.hue + 60 * self.dtime
+		self:update_textures()
+	elseif self.easteregg.spin then
+		self.data.yaw = self.data.yaw + 180 * dtime
+	end
+end

mods/ENTITIES/mcl_mobs/api/eggs.lua

@@ -0,0 +1,110 @@
+-- Register spawn eggs
+
+--[[
+-- Note: This also introduces the “spawn_egg” group:
+-- * spawn_egg=1: Spawn egg (generic mob, no metadata)
+-- * spawn_egg=2: Spawn egg (captured/tamed mob, metadata)
+function mobs:register_egg(mob, desc, background, addegg, no_creative)
+
+	local grp = {spawn_egg = 1}
+
+	-- do NOT add this egg to creative inventory (e.g. dungeon master)
+	if no_creative == true then
+		grp.not_in_creative_inventory = 1
+	end
+
+	local invimg = background
+
+	if addegg == 1 then
+		invimg = "mobs_chicken_egg.png^(" .. invimg ..
+			"^[mask:mobs_chicken_egg_overlay.png)"
+	end
+
+	-- register old stackable mob egg
+	minetest.register_craftitem(mob, {
+
+		description = desc,
+		inventory_image = invimg,
+		groups = grp,
+
+		_doc_items_longdesc = S("This allows you to place a single mob."),
+		_doc_items_usagehelp = S("Just place it where you want the mob to appear. Animals will spawn tamed, unless you hold down the sneak key while placing. If you place this on a mob spawner, you change the mob it spawns."),
+
+		on_place = function(itemstack, placer, pointed_thing)
+
+			local pos = pointed_thing.above
+
+			-- am I clicking on something with existing on_rightclick function?
+			local under = minetest.get_node(pointed_thing.under)
+			local def = minetest.registered_nodes[under.name]
+			if def and def.on_rightclick then
+				return def.on_rightclick(pointed_thing.under, under, placer, itemstack)
+			end
+
+			if pos
+			--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 mod_mobspawners and under.name == "mcl_mobspawners:spawner" then
+					if minetest.is_protected(pointed_thing.under, name) then
+						minetest.record_protection_violation(pointed_thing.under, name)
+						return itemstack
+					end
+					if not privs.maphack then
+						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())
+					if not mobs.is_creative(name) then
+						itemstack:take_item()
+					end
+					return itemstack
+				end
+
+				if not minetest.registered_entities[mob] then
+					return itemstack
+				end
+
+				if minetest.settings:get_bool("only_peaceful_mobs", false)
+						and minetest.registered_entities[mob].type == "monster" then
+					minetest.chat_send_player(name, S("Only peaceful mobs allowed!"))
+					return itemstack
+				end
+
+				local mob = minetest.add_entity(pos, mob)
+				minetest.log("action", "mcl_mobs.mob spawned: "..name.." at "..minetest.pos_to_string(pos))
+				local ent = mob:get_luaentity()
+
+				-- don't set owner if monster or sneak pressed
+				--[[
+				if ent.type ~= "monster"
+				and not placer:get_player_control().sneak then
+					ent.owner = placer:get_player_name()
+					ent.tamed = true
+				end
+				] ]--
+
+				-- set nametag
+				local nametag = itemstack:get_meta():get_string("name")
+				if nametag ~= "" then
+					if string.len(nametag) > MAX_MOB_NAME_LENGTH then
+						nametag = string.sub(nametag, 1, MAX_MOB_NAME_LENGTH)
+					end
+					ent.nametag = nametag
+					update_tag(ent)
+				end
+
+				-- if not in creative then take item
+				if not mobs.is_creative(placer:get_player_name()) then
+					itemstack:take_item()
+				end
+			end
+
+			return itemstack
+		end,
+	})
+
+end
+]]--

mods/ENTITIES/mcl_mobs/api/env/breath.lua

@@ -0,0 +1,22 @@
+function mcl_mobs.mob:breath_step()
+	local pos = self.object:get_pos()
+
+	pos.y = pos.y + self.eye_height
+
+	local node = minetest.get_node(pos).name
+
+	if minetest.get_item_group(node, "water") ~= 0 then
+		self.data.breath = self.data.breath - self.dtime
+
+		if self.data.breath <= 0 then
+			self:deal_damage(4, {type = "drowning"})
+			self.data.breath = 1
+		end
+
+	elseif self.data.breath < self.def.breath_max then
+		self.data.breath = self.data.breath + self.dtime
+		if self.data.breath > self.def.breath_max then
+			self.data.breath = self.def.breath_max
+		end
+	end
+end

mods/ENTITIES/mcl_mobs/api/env/collision.lua

@@ -0,0 +1,65 @@
+function mcl_mobs.mob:collision_step()
+	local own_box, own_pos, own_boundary = mcl_mobs.util.get_collision_data(self.object)
+
+	local radius = math.max(own_boundary, own_box[5])
+	local max_cramming = tonumber(minetest.settings:get("mclMaxEntityCramming")) or mcl_mobs.const.max_entity_cramming
+	local parent = self.object:get_attach()
+
+	for _, obj in pairs(minetest.get_objects_inside_radius(own_pos, radius * 1.25)) do
+		if obj ~= self.object and obj ~= parent and obj:get_attach() ~= self.object then
+			local luaentity = obj:get_luaentity()
+
+			if not luaentity and obj:get_hp() > 0 or luaentity and luaentity.is_mob and not luaentity.dead then
+				max_cramming = max_cramming - 1
+
+				if max_cramming <= 0 then
+					local target, source = self.object, obj
+					-- hurt adults before babies
+					if self.data.baby and luaentity then
+						target, source = source, target -- how the turntables...
+					end
+					mcl_util.deal_damage(target, mcl_util.get_hp(target), {type = "cramming", source = source})
+					return
+				end
+
+				local obj_box, obj_pos, obj_boundary = mcl_mobs.util.get_collision_data(obj)
+
+				-- this is checking the difference of the object collided with's possision
+				-- if positive top of other object is inside (y axis) of current object
+
+				local y_base_diff = obj_pos.y + obj_box[5] - own_pos.y
+				local y_top_diff  = own_pos.y + own_box[5] - obj_pos.y
+
+				local distance = vector.distance(
+					vector.new(own_pos.x, 0, own_pos.z),
+					vector.new(obj_pos.x, 0, obj_pos.z)
+				)
+
+				local combined_boundary = own_boundary + obj_boundary
+
+				if distance <= combined_boundary and y_base_diff >= 0 and y_top_diff >= 0 then
+					local dir = vector.direction(own_pos, obj_pos)
+					dir.y = 0
+
+					-- eliminate mob being stuck in corners
+					if dir.x == 0 and dir.z == 0 then
+						-- slightly adjust mob position to prevent equal length
+						-- corner/wall sticking
+						dir.x = dir.x + math.random() / 10 * (math.round(math.random()) * 2 - 1)
+						dir.z = dir.z + math.random() / 10 * (math.round(math.random()) * 2 - 1)
+					end
+
+					local obj_vel = vector.multiply(dir, 0.5 * (1 - distance / combined_boundary) * 1.5)
+					local own_vel = vector.multiply(obj_vel, -10)
+
+					if not luaentity then
+						obj_vel = vector.multiply(obj_vel, 2.5)
+					end
+
+					obj:add_velocity(obj_vel)
+					self.object:add_velocity(own_vel)
+				end
+			end
+		end
+	end
+end

mods/ENTITIES/mcl_mobs/api/env/env.lua

@@ -0,0 +1,23 @@
+function mcl_mobs.mob:env_step()
+	self:fall_damage_step()
+
+	if not self.def.breathes_in_water then
+		self:breath_step()
+	end
+
+	mcl_burning.tick(self.object, dtime, self.data)
+
+	if self.dead then
+		return false
+	end
+
+	if self.def.ignited_by_sunlight then
+		self:sunlight_step()
+	end
+
+	if not self.def.unpushable then
+		self:collision_step()
+	end
+
+	return true
+end

mods/ENTITIES/mcl_mobs/api/env/fall_damage.lua

@@ -0,0 +1,8 @@
+function mcl_mobs.mob:fall_damage_step()
+	-- ToDo: fall damage based on distance, not velocity
+	local velocity = self.object:get_velocity()
+
+	if self.last_velocity.y < -7 and velocity.y == 0 then
+		self:deal_damage(math.abs(self.last_velocity.y + 7) * 2, {type = "fall"})
+	end
+end

mods/ENTITIES/mcl_mobs/api/env/sunlight.lua

@@ -0,0 +1,15 @@
+function mcl_mobs.mob:sunlight_step()
+	if self.data.burn_time then
+		return
+	end
+
+	local pos = self.object:get_pos()
+	pos.y = pos.y + 0.1
+
+	if mcl_worlds.pos_to_dimension(pos) == "overworld" then
+		local ok, light = pcall(minetest.get_natural_light or minetest.get_node_light, pos, minetest.get_timeofday())
+		if ok and light >= minetest.LIGHT_MAX then
+			mcl_burning.set_on_fire(self.object, math.huge)
+		end
+	end
+end

mods/ENTITIES/mcl_mobs/api/graphics/animation.lua

@@ -0,0 +1,64 @@
+-- set defined animation
+function mcl_mobs.mob:set_animation(anim, fixed_frame)
+
+	if not self.animation or not anim then
+		return
+	end
+
+	if self.state == "die" and anim ~= "die" and anim ~= "stand" then
+		return
+	end
+
+
+	if (not self.animation[anim .. "_start"] or not self.animation[anim .. "_end"]) then
+		return
+	end
+
+	--animations break if they are constantly set
+	--so we put this return gate to check if it is
+	--already at the animation we are trying to implement
+	if self.current_animation == anim then
+		return
+	end
+
+	local a_start = self.animation[anim .. "_start"]
+	local a_end
+
+	if fixed_frame then
+		a_end = a_start
+	else
+		a_end = self.animation[anim .. "_end"]
+	end
+
+	self.object:set_animation({
+		x = a_start,
+		y = a_end},
+		self.animation[anim .. "_speed"] or self.animation.speed_normal or 15,
+		0, self.animation[anim .. "_loop"] ~= false)
+
+
+	self.current_animation = anim
+end
+
+--this is a helper function for mobs explosion animation
+function mcl_mobs.mob:handle_explosion_animation()
+
+	--secondary catch-all
+	if not self.explosion_animation then
+		self.explosion_animation = 0
+	end
+
+	--the timer works from 0 for sense of a 0 based counting
+	--but this just bumps it up so it's usable in here
+	local explosion_timer_adjust = self.explosion_animation + 1
+
+
+	local visual_size_modified = table.copy(self.visual_size_origin)
+
+	visual_size_modified.x = visual_size_modified.x * (explosion_timer_adjust ^ 3)
+	visual_size_modified.y = visual_size_modified.y * explosion_timer_adjust
+
+	self.object:set_properties({visual_size = visual_size_modified})
+end
+
+

mods/ENTITIES/mcl_mobs/api/graphics/collisionbox.lua

@@ -0,0 +1,21 @@
+function mcl_mobs.mob:update_collisionbox()
+	local box = self.def.collisionbox
+
+	if self.baby and self.def.baby_size then
+		box = mcl_mobs.util.scale_size(box, self.def.baby_size)
+	end
+
+	if self.easteregg.upside_down then
+		box[2], box[5] = -box[5], -box[2]
+	end
+
+	self.collisionbox = {
+		min = vector.new(box[1], box[2], box[3]),
+		max = vector.new(box[4], box[5], box[6]),
+	}
+
+	self:set_properties({collisionbox = box})
+
+	self.collisionbox_cache = nil
+	mcl_mount.update_children_visual_size(self.object)
+end

mods/ENTITIES/mcl_mobs/api/graphics/eye_height.lua

@@ -0,0 +1,9 @@
+function mcl_mobs.mob:update_eye_height()
+	local eye_height = self.def.eye_height
+
+	if self.data.baby and self.def.baby_size then
+		eye_height = eye_height * self.def.baby_size
+	end
+
+	self.eye_height = eye_height
+end

mods/ENTITIES/mcl_mobs/api/graphics/head.lua

@@ -0,0 +1,115 @@
+
+--[[
+local vector.new = vector.new
+
+
+--converts yaw to degrees
+local degrees = function(yaw)
+	return(yaw*180.0/math.pi)
+end
+
+
+mobs.do_head_logic = function(self,dtime)
+
+    local player = minetest.get_player_by_name("singleplayer")
+
+    local look_at = player:get_pos()
+    look_at.y = look_at.y + player:get_properties().eye_height
+
+
+
+
+    local pos = self.object:get_pos()
+
+    local body_yaw = self.object:get_yaw()
+
+    local body_dir = minetest.yaw_to_dir(body_yaw)
+
+
+    pos.y = pos.y + self.head_height_offset
+
+    local head_offset = vector.multiply(body_dir, self.head_direction_offset)
+
+    pos = vector.add(pos, head_offset)
+
+
+
+
+    minetest.add_particle({
+    	pos = pos,
+    	velocity = {x=0, y=0, z=0},
+    	acceleration = {x=0, y=0, z=0},
+    	expirationtime = 0.2,
+    	size = 1,
+    	texture = "default_dirt.png",
+    })
+
+
+    local bone_pos = vector.new(0,0,0)
+
+
+    --(horizontal)
+    bone_pos.y = self.head_bone_pos_y
+
+    --(vertical)
+    bone_pos.z = self.head_bone_pos_z
+
+    --print(yaw)
+
+    --local _, bone_rot = self.object:get_bone_position("head")
+
+    --bone_rot.x = bone_rot.x + (dtime * 10)
+    --bone_rot.z = bone_rot.z + (dtime * 10)
+
+
+    local head_yaw
+    head_yaw = minetest.dir_to_yaw(vector.direction(pos,look_at)) - body_yaw
+
+    if self.reverse_head_yaw then
+        head_yaw = head_yaw * -1
+    end
+
+    --over rotation protection
+    --stops radians from going out of spec
+    if head_yaw > math.pi then
+        head_yaw = head_yaw - (math.pi * 2)
+    elseif head_yaw < -math.pi then
+        head_yaw = head_yaw + (math.pi * 2)
+    end
+
+
+    local check_failed = false
+    --upper check + 90 degrees or upper math.radians (3.14/2)
+    if head_yaw > math.pi - (math.pi/2) then
+        head_yaw = 0
+        check_failed = true
+    --lower check - 90 degrees or lower negative math.radians (-3.14/2)
+    elseif head_yaw < -math.pi + (math.pi/2) then
+        head_yaw = 0
+        check_failed = true
+    end
+
+    local head_pitch = 0
+
+    --DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
+    --head_yaw = 0
+    --DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
+
+    if not check_failed then
+        head_pitch = minetest.dir_to_yaw(vector.new(vector.distance(vector.new(pos.x,0,pos.z),vector.new(look_at.x,0,look_at.z)),0,pos.y-look_at.y))+(math.pi/2)
+    end
+
+    if self.head_pitch_modifier then
+        head_pitch = head_pitch + self.head_pitch_modifier
+    end
+
+    if self.swap_y_with_x then
+        self.object:set_bone_position(self.head_bone, bone_pos, vector.new(degrees(head_pitch),degrees(head_yaw),0))
+    else
+        self.object:set_bone_position(self.head_bone, bone_pos, vector.new(degrees(head_pitch),0,degrees(head_yaw)))
+    end
+
+
+    --set_bone_position([bone, position, rotation])
+end
+--]]

mods/ENTITIES/mcl_mobs/api/graphics/mesh.lua

@@ -0,0 +1,6 @@
+function mcl_mobs.mob:update_mesh()
+	self:set_properties({
+		visual = "mesh",
+		mesh = self.def.model,
+	})
+end

mods/ENTITIES/mcl_mobs/api/graphics/nametag.lua

@@ -0,0 +1,7 @@
+function mcl_mobs.mob:update_nametag()
+	self:update_easteregg()
+
+	self:set_properties({
+		nametag = self.data.nametag,
+	})
+end

mods/ENTITIES/mcl_mobs/api/graphics/rotation.lua

@@ -0,0 +1,110 @@
+-- this is used when a mob is following player and for when mobs breed
+function mcl_mobs.mob:look_at(obj)
+	self:lock_yaw()
+
+	-- turn positions into pseudo 2d vectors
+	local pos1 = self.object:get_pos()
+	pos1.y = 0
+
+	local pos2 = obj:get_pos()
+	pos2.y = 0
+
+	local new_direction = vector.direction(pos1, pos2)
+	local new_yaw = minetest.dir_to_yaw(new_direction)
+
+	self.object:set_yaw(new_yaw)
+	self.yaw = new_yaw
+end
+
+-- this allows auto facedir rotation while making it so mobs
+-- don't look like wet noodles flopping around
+function mcl_mobs.mob:movement_rotation_lock()
+	local current_engine_yaw = self.object:get_yaw()
+	local current_lua_yaw = self.yaw
+
+	if current_engine_yaw > math.pi * 2 then
+		current_engine_yaw = current_engine_yaw - math.pi * 2
+	end
+
+	local diff = math.abs(current_engine_yaw - current_lua_yaw)
+
+	if diff <= 0.05 then
+		self:lock_yaw()
+	elseif diff > 0.05 then
+		self:unlock_yaw()
+	end
+end
+
+-- this is used to unlock a mob's yaw after attacking
+function mcl_mobs.mob:unlock_yaw()
+	if not self.properties.automatic_face_movement_dir then
+		self:set_properties({automatic_face_movement_dir = self.def.rotate})
+	end
+end
+
+-- this is used to lock a mob's yaw when they're standing
+function mcl_mobs.mob:lock_yaw()
+	if self.properties.automatic_face_movement_dir then
+		self:set_properties({automatic_face_movement_dir = false})
+	end
+end
+
+function mcl_mobs.mob:calculate_pitch(self)
+	local pos  = self.object:get_pos()
+	local pos2 = self.old_pos
+
+	if pos == nil or pos2 == nil then
+		return false
+	end
+
+    return minetest.dir_to_yaw(vector.new(vector.distance(vector.new(pos.x, 0, pos.z), vector.new(pos2.x, 0, pos2.z)), 0, pos.y - pos2.y)) + math.pi / 2
+end
+
+--this is a helper function used to make mobs pitch rotation dynamically flow when flying/swimming
+function mcl_mobs.mob:set_dynamic_pitch()
+	local pitch = self:calculate_pitch()
+
+	if not pitch then
+		return
+	end
+
+	local rotation = self.object:get_rotation()
+	rotation.x = pitch
+	self.object:set_rotation(rotation)
+
+	self.dynamic_pitch = true
+end
+
+--this is a helper function used to make mobs pitch rotation reset when flying/swimming
+function mcl_mobs.mob:set_static_pitch()
+	if not self.dynamic_pitch then
+		return
+	end
+
+	local current_rotation = self.object:get_rotation()
+	current_rotation.x = 0
+	self.object:set_rotation(current_rotation)
+
+	self.dynamic_pitch = nil
+end
+
+function mcl_mobs.mob:quick_rotate()
+	self.yaw = self.yaw + math.pi * 2 * 0.03125
+	if self.yaw > math.pi * 2 then
+		self.yaw = self.yaw - math.pi * 2
+	end
+end
+
+function mcl_mobs.mob:update_roll()
+	local roll = 0
+
+	if self.dead then
+		roll = math.pi * math.min(0.5, 1 - self.death_timer / mcl_mobs.const.death_timer)
+	elseif self.easteregg.upside_down then
+		roll = math.pi
+	end
+
+	local rotation = self.object:get_rotation()
+	rotation.z = roll
+	self.object:set_rotation(rotation)
+end

mods/ENTITIES/mcl_mobs/api/graphics/textures.lua

@@ -0,0 +1,17 @@
+function mcl_mobs.mob:get_special_textures()
+	if self.baby then
+		return self:evaluate("baby_textures")
+	elseif self.gotten then
+		return self:evaluate("gotten_textures")
+	elseif self.easteregg.rainbow then
+		return self:evaluate("rainbow_textures", mcl_mobs.util.color_from_hue(self.easteregg.hue))
+	end
+end
+
+function mcl_mobs.mob:get_textures()
+	return self:get_special_textures() or self:calculate_textures(self.def.textures)
+end
+
+function mcl_mobs.mob:update_textures()
+	self:set_properties({textures = self:get_textures()})
+end

mods/ENTITIES/mcl_mobs/api/graphics/visual_size.lua

@@ -0,0 +1,21 @@
+function mcl_mobs.mob:update_visual_size()
+	local size = self.def.visual_size
+
+	if self.data.size then
+		mcl_mobs.util.scale_size(size, self.data.size)
+	end
+
+	if self.data.baby and self.def.baby_size then
+		mcl_mobs.util.scale_size(size, self.def.baby_size)
+	end
+
+	local parent = self.object:get_attach()
+
+	if parent then
+		size = vector.divide(size, parent:get_properties().visual_size)
+	end
+
+	self:set_properties({visual_size = size})
+
+	mcl_mount.update_children_visual_size(self.object)
+end

mods/ENTITIES/mcl_mobs/api/interaction.lua

@@ -0,0 +1,59 @@
+function mcl_mobs.mob:on_rightclick(clicker)
+	local itemstack = clicker:get_wielded_item()
+
+	if self:on_rightclick_handler(clicker, itemstack) then
+		clicker:set_wielded_item(itemstack)
+	end
+end
+
+function mcl_mobs.mob:feed(clicker, itemname)
+	if self.data.heal_with[itemname] and self.data.health < self.def.health_max then
+		self:heal()
+	elseif self.def.boost_with[itemname] and self.data.baby then
+		self:boost()
+	elseif self.def.breed_with[itemname] and not self.data.bred then
+		self:init_breeding()
+	elseif self.data.tame_with[itemname] and not self.def.tamed then
+		self:tame(clicker)
+	else
+		return false
+	end
+
+	return true
+end
+
+function mcl_mobs.mob:on_rightclick_handler(clicker, itemstack)
+	if self.dead then
+		return false
+	end
+
+	if self.def.on_rightclick then
+		if self.def.on_rightclick(clicker, itemstack) then
+			return true
+		end
+	end
+
+	local itemname = itemstack:get_name()
+
+	if not self.def.ignores_nametag and itemname == "mcl_mobitems:nametag" then
+		local tag = item:get_meta():get_string("name")
+		if tag ~= "" then
+			self.data.nametag = tag
+			self:update_nametag()
+
+			return mcl_mobs.util.take_item(clicker, itemstack)
+		end
+	end
+
+	if self:feed(clicker, itemstack) then
+		mcl_mobs.util.take_item(clicker, itemname)
+		self:play_sound_specific("mobs_mc_animal_eat_generic")
+		return true
+	end
+
+	if not self.data.gotten and self.def.get_with[itemname] and self.def.get(self, clicker, itemstack) then
+		self.data.gotten = true
+		self.data.gotten_timer = self:evaluate("gotten_cooldown")
+		return true
+	end
+end

mods/ENTITIES/mcl_mobs/api/knockback.lua

@@ -0,0 +1,35 @@
+function mcl_mobs.mob:knockback(hitter)
+	if self.def.knockback_multiplier == 0 then
+		return
+	end
+
+	if hitter:get_attach() == self.object then
+		return
+	end
+
+	local velocity = self.object:get_velocity()
+
+	local pos1 = self.object:get_pos()
+	pos1.y = 0
+	local pos2 = hitter:get_pos()
+	pos2.y = 0
+	local dir = vector.direction(pos2, pos1)
+
+	local up = mcl_mobs.const.knockback_up
+
+	if velocity.y ~= 0 then
+		up = 0
+	end
+
+	local multiplier = mcl_mobs.const.knockback
+
+	local knockback_level = mcl_enchanting.get_enchantment(mcl_util.get_wield_item(hitter), "knockback")
+	if knockback_level > 0 then
+		multiplier = multiplier + knockback_level * 3
+	end
+
+	dir = vector.multiply(dir, multiplier * self.def.knockback_multiplier)
+	dir.y = up * self.def.knockback_multiplier
+
+	self.object:add_velocity(dir)
+end

mods/ENTITIES/mcl_mobs/api/loot.lua

@@ -0,0 +1,62 @@
+function mcl_mobs.mob:drop_loot(reason)
+	if self.data.baby and self.def.type ~= "monster" then
+		return
+	end
+
+	local enchantments = reason.source and mcl_enchanting.get_enchantments(mcl_util.get_wield_item(reason.source)) or {}
+
+	local cooked = self.data.burn_time or enchantments.fire_aspect
+	local looting = enchantments.looting or 0
+
+	mcl_experience.throw_experience(self.object:get_pos(), math.random(self.def.xp_min, self.def.xp_max))
+
+	local pos = self.object:get_pos()
+
+	for _, dropdef in pairs(self:evaluate("drops")) do
+		local chance = 1 / dropdef.chance
+		local looting_type = dropdef.looting
+
+		if looting > 0 then
+			local chance_function = dropdef.looting_chance_function
+			if chance_function then
+				chance = chance_function(looting_level)
+			elseif looting_type == "rare" then
+				chance = chance + (dropdef.looting_factor or 0.01) * looting_level
+			end
+		end
+
+		local count = 0
+
+		local do_common_looting = looting > 0 and looting_type == "common"
+
+		if math.random() < chance then
+			num = math.random(dropdef.min or 1, dropdef.max or 1)
+		elseif not dropdef.looting_ignore_chance then
+			do_common_looting = false
+		end
+
+		if do_common_looting then
+			num = num + math.floor(math.random(0, looting_level) + 0.5)
+		end
+
+		if count > 0 then
+			local item = dropdef.name
+
+			if cooked and dropdef.cookable then
+				local output = minetest.get_craft_result({method = "cooking", width = 1, items = {item}})
+
+				if output and output.item and not output.item:is_empty() then
+					item = output.item:get_name()
+				end
+			end
+
+			for x = 1, count do
+				minetest.add_item(pos, ItemStack(item)):set_velocity({
+					x = math.random(-10, 10) / 9,
+					y = 6,
+					z = math.random(-10, 10) / 9,
+				})
+			end
+		end
+	end
+end

mods/ENTITIES/mcl_mobs/api/main.lua

@@ -0,0 +1,60 @@
+function mcl_mobs.mob:on_step(dtime, moveresult)
+	self.dtime = dtime
+	self:reload_properties()
+
+	local stunned = self.stun_timer and self:do_timer("stun")
+
+	-- can be true (currently stunned), nil (not stunned) or false (stopped being stunned in this tick, which is what we want to check for here)
+	if stunned == false then
+		self.object:set_texture_mod("")
+	end
+
+	self:update_node_type()
+	self:movement_step()
+
+	if self.dead then
+		self:death_step()
+		return
+	end
+
+	if self.def.hostile and not minetest.settings:get_bool("mclPeacefulMode") then
+		self:debug("peaceful mode active, removing")
+		self:deal_damage(self.data.health, {type = "out_of_world"})
+	end
+
+	if self.data.can_despawn then
+		if not self:despawn_step() then
+			return
+		end
+	end
+
+	if self.def.on_step then
+		if self.def.on_step(self, dtime, moveresult) == false then
+			return
+		end
+	end
+
+	if not self.data.silent then
+		self:sound_step()
+	end
+
+	self:easteregg_step()
+
+	if not self:env_step() then
+		return
+	end
+
+	if self.data.baby then
+		self:baby_step()
+	end
+
+	if self.data.gotten and not self:do_timer("gotten", true) then
+		self.data.gotten = nil
+	end
+
+	if not self.data.no_ai and not stunned then
+		self:ai_step()
+	end
+
+	self:backup_movement()
+end

mods/ENTITIES/mcl_mobs/api/mob_functions/animation.lua

@@ -1,257 +0,0 @@
-local math = math
-local vector = vector
-
-local HALF_PI     = math.pi/2
-
-
-local vector_direction = vector.direction
-local vector_distance  = vector.distance
-local vector_new       = vector.new
-
-local minetest_dir_to_yaw = minetest.dir_to_yaw
-
--- set defined animation
-mobs.set_mob_animation = function(self, anim, fixed_frame)
-
-	if not self.animation or not anim then
-		return
-	end
-
-	if self.state == "die" and anim ~= "die" and anim ~= "stand" then
-		return
-	end
-
-
-	if (not self.animation[anim .. "_start"] or not self.animation[anim .. "_end"]) then
-		return
-	end
-
-	--animations break if they are constantly set
-	--so we put this return gate to check if it is
-	--already at the animation we are trying to implement
-	if self.current_animation == anim then
-		return
-	end
-
-	local a_start = self.animation[anim .. "_start"]
-	local a_end
-
-	if fixed_frame then
-		a_end = a_start
-	else
-		a_end = self.animation[anim .. "_end"]
-	end
-
-	self.object:set_animation({
-		x = a_start,
-		y = a_end},
-		self.animation[anim .. "_speed"] or self.animation.speed_normal or 15,
-		0, self.animation[anim .. "_loop"] ~= false)
-
-	self.current_animation = anim
-end
-
-
-
-
-mobs.death_effect = function(pos, yaw, collisionbox, rotate)
-	local min, max
-	if collisionbox then
-		min = {x=collisionbox[1], y=collisionbox[2], z=collisionbox[3]}
-		max = {x=collisionbox[4], y=collisionbox[5], z=collisionbox[6]}
-	else
-		min = { x = -0.5, y = 0, z = -0.5 }
-		max = { x = 0.5, y = 0.5, z = 0.5 }
-	end
-	if rotate then
-		min = vector.rotate(min, {x=0, y=yaw, z=math.pi/2})
-		max = vector.rotate(max, {x=0, y=yaw, z=math.pi/2})
-		min, max = vector.sort(min, max)
-		min = vector.multiply(min, 0.5)
-		max = vector.multiply(max, 0.5)
-	end
-
-	minetest.add_particlespawner({
-		amount = 50,
-		time = 0.001,
-		minpos = vector.add(pos, min),
-		maxpos = vector.add(pos, max),
-		minvel = vector_new(-5,-5,-5),
-		maxvel = vector_new(5,5,5),
-		minexptime = 1.1,
-		maxexptime = 1.5,
-		minsize = 1,
-		maxsize = 2,
-		collisiondetection = false,
-		vertical = false,
-		texture = "mcl_particles_mob_death.png^[colorize:#000000:255",
-	})
-
-	minetest.sound_play("mcl_mobs_mob_poof", {
-		pos = pos,
-		gain = 1.0,
-		max_hear_distance = 8,
-	}, true)
-end
-
-
---this allows auto facedir rotation while making it so mobs
---don't look like wet noodles flopping around
-mobs.movement_rotation_lock = function(self)
-	local current_engine_yaw = self.object:get_yaw()
-	local current_lua_yaw = self.yaw
-
-	if current_engine_yaw > math.pi * 2 then
-		current_engine_yaw = current_engine_yaw - (math.pi * 2)
-	end
-
-	if math.abs(current_engine_yaw - current_lua_yaw) <= 0.05 and self.object:get_properties().automatic_face_movement_dir then
-		self.object:set_properties{automatic_face_movement_dir = false}
-	elseif math.abs(current_engine_yaw - current_lua_yaw) > 0.05 and self.object:get_properties().automatic_face_movement_dir == false then
-		self.object:set_properties{automatic_face_movement_dir = self.rotate}
-	end
-end
-
-
---this is used when a mob is chasing a player
-mobs.set_yaw_while_attacking = function(self)
-
-	if self.object:get_properties().automatic_face_movement_dir then
-		self.object:set_properties{automatic_face_movement_dir = false}
-	end
-
-	--turn positions into pseudo 2d vectors
-	local pos1 = self.object:get_pos()
-	pos1.y = 0
-
-	local pos2 = self.attacking:get_pos()
-	pos2.y = 0
-
-	local new_direction = vector_direction(pos1,pos2)
-	local new_yaw = minetest_dir_to_yaw(new_direction)
-
-	self.object:set_yaw(new_yaw)
-	self.yaw = new_yaw
-end
-
---this is used to unlock a mob's yaw after attacking
-mobs.unlock_yaw = function(self)
-	if self.object:get_properties().automatic_face_movement_dir == false then
-		self.object:set_properties{automatic_face_movement_dir = self.rotate}
-	end
-end
-
---this is used to lock a mob's yaw when they're standing
-mobs.lock_yaw = function(self)
-	if self.object:get_properties().automatic_face_movement_dir then
-		self.object:set_properties{automatic_face_movement_dir = false}
-	end
-end
-
-
-local calculate_pitch = function(self)
-	local pos  = self.object:get_pos()
-	local pos2 = self.old_pos
-
-	if pos == nil or pos2 == nil then
-		return false
-	end
-
-    return minetest_dir_to_yaw(vector_new(vector_distance(vector_new(pos.x,0,pos.z),vector_new(pos2.x,0,pos2.z)),0,pos.y - pos2.y)) + HALF_PI
-end
-
---this is a helper function used to make mobs pitch rotation dynamically flow when flying/swimming
-mobs.set_dynamic_pitch = function(self)
-	local pitch = calculate_pitch(self)
-
-	if not pitch then
-		return
-	end
-
-	local current_rotation = self.object:get_rotation()
-
-	current_rotation.x = pitch
-
-	self.object:set_rotation(current_rotation)
-
-	self.pitch_switch = "dynamic"
-end
-
---this is a helper function used to make mobs pitch rotation reset when flying/swimming
-mobs.set_static_pitch = function(self)
-
-	if self.pitch_switch == "static" then
-		return
-	end
-
-	local current_rotation = self.object:get_rotation()
-
-	current_rotation.x = 0
-
-	self.object:set_rotation(current_rotation)
-	self.pitch_switch = "static"
-end
-
---this is a helper function for mobs explosion animation
-mobs.handle_explosion_animation = function(self)
-
-	--secondary catch-all
-	if not self.explosion_animation then
-		self.explosion_animation = 0
-	end
-
-	--the timer works from 0 for sense of a 0 based counting
-	--but this just bumps it up so it's usable in here
-	local explosion_timer_adjust = self.explosion_animation + 1
-
-
-	local visual_size_modified = table.copy(self.visual_size_origin)
-
-	visual_size_modified.x = visual_size_modified.x * (explosion_timer_adjust ^ 3)
-	visual_size_modified.y = visual_size_modified.y * explosion_timer_adjust
-
-	self.object:set_properties({visual_size = visual_size_modified})
-end
-
-
---this is used when a mob is following player
-mobs.set_yaw_while_following = function(self)
-
-	if self.object:get_properties().automatic_face_movement_dir then
-		self.object:set_properties{automatic_face_movement_dir = false}
-	end
-
-	--turn positions into pseudo 2d vectors
-	local pos1 = self.object:get_pos()
-	pos1.y = 0
-
-	local pos2 = self.following_person:get_pos()
-	pos2.y = 0
-
-	local new_direction = vector_direction(pos1,pos2)
-	local new_yaw = minetest_dir_to_yaw(new_direction)
-
-	self.object:set_yaw(new_yaw)
-	self.yaw = new_yaw
-end
-
---this is used for when mobs breed
-mobs.set_yaw_while_breeding = function(self, mate)
-
-	if self.object:get_properties().automatic_face_movement_dir then
-		self.object:set_properties{automatic_face_movement_dir = false}
-	end
-
-	--turn positions into pseudo 2d vectors
-	local pos1 = self.object:get_pos()
-	pos1.y = 0
-
-	local pos2 = mate:get_pos()
-	pos2.y = 0
-
-	local new_direction = vector_direction(pos1,pos2)
-	local new_yaw = minetest_dir_to_yaw(new_direction)
-
-	self.object:set_yaw(new_yaw)
-	self.yaw = new_yaw
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/attack_type_instructions.lua

@@ -1,347 +0,0 @@
-local vector_direction = vector.direction
---local minetest_dir_to_yaw = minetest.dir_to_yaw
-local vector_distance = vector.distance
-local vector_multiply = vector.multiply
-local math_random  = math.random
-
---[[
- _   _                     _   _
-| | | |                   | | | |
-| | | |     __ _ _ __   __| | | |
-| | | |    / _` | '_ \ / _` | | |
-|_| | |___| (_| | | | | (_| | |_|
-(_) \_____/\__,_|_| |_|\__,_| (_)
-]]--
-
-
-
---[[
- _____           _           _
-|  ___|         | |         | |
-| |____  ___ __ | | ___   __| | ___
-|  __\ \/ / '_ \| |/ _ \ / _` |/ _ \
-| |___>  <| |_) | | (_) | (_| |  __/
-\____/_/\_\ .__/|_|\___/ \__,_|\___|
-          | |
-          |_|
-]]--
-
-mobs.explode_attack_walk = function(self,dtime)
-
-    --this needs an exception
-    if self.attacking == nil or not self.attacking:is_player() then
-        self.attacking = nil
-        return
-    end
-
-    mobs.set_yaw_while_attacking(self)
-
-    local distance_from_attacking = vector_distance(self.object:get_pos(), self.attacking:get_pos())
-
-    --make mob walk up to player within 2 nodes distance then start exploding
-    if distance_from_attacking >= self.reach and
-    --don't allow explosion to cancel unless out of the reach boundary
-    not (self.explosion_animation and self.explosion_animation > 0 and distance_from_attacking <= self.defuse_reach) then
-
-        mobs.set_velocity(self, self.run_velocity)
-        mobs.set_mob_animation(self,"run")
-
-        mobs.reverse_explosion_animation(self,dtime)
-    else
-        mobs.set_velocity(self,0)
-
-        --this is the only way I can reference this without dumping extra data on all mobs
-        if not self.explosion_animation then
-            self.explosion_animation = 0
-        end
-
-        --play ignite sound
-        if self.explosion_animation == 0 then
-            mobs.play_sound(self,"attack")
-        end
-
-        mobs.set_mob_animation(self,"stand")
-
-        mobs.handle_explosion_animation(self)
-
-        self.explosion_animation = self.explosion_animation + (dtime/2.5)
-    end
-
-    --make explosive mobs jump
-    --check for nodes to jump over
-    --explosive mobs will just ride against walls for now
-	local node_in_front_of = mobs.jump_check(self)
-	if node_in_front_of == 1 then
-		mobs.jump(self)
-    end
-
-    --do biggening explosion thing
-    if self.explosion_animation and self.explosion_animation > self.explosion_timer then
-        mcl_explosions.explode(self.object:get_pos(), self.explosion_strength,{ drop_chance = 1.0 })
-        self.object:remove()
-    end
-end
-
-
---this is a small helper function to make working with explosion animations easier
-mobs.reverse_explosion_animation = function(self,dtime)
-    --if explosion animation was greater than 0 then reverse it
-    if self.explosion_animation and self.explosion_animation > 0 then
-        self.explosion_animation = self.explosion_animation - dtime
-        if self.explosion_animation < 0 then
-            self.explosion_animation = 0
-        end
-    end
-
-    mobs.handle_explosion_animation(self)
-end
-
-
-
-
---[[
-______                 _
-| ___ \               | |
-| |_/ /   _ _ __   ___| |__
-|  __/ | | | '_ \ / __| '_ \
-| |  | |_| | | | | (__| | | |
-\_|   \__,_|_| |_|\___|_| |_|
-]]--
-
-
-
-mobs.punch_attack_walk = function(self,dtime)
-    --this needs an exception
-    if self.attacking == nil or not self.attacking:is_player() then
-        self.attacking = nil
-        return
-    end
-
-    local distance_from_attacking = mobs.get_2d_distance(self.object:get_pos(), self.attacking:get_pos())
-
-    if distance_from_attacking >= self.minimum_follow_distance then
-        mobs.set_velocity(self, self.run_velocity)
-        mobs.set_mob_animation(self, "run")
-    else
-        mobs.set_velocity(self, 0)
-        mobs.set_mob_animation(self, "stand")
-    end
-
-    mobs.set_yaw_while_attacking(self)
-
-    --make punchy mobs jump
-    --check for nodes to jump over
-    --explosive mobs will just ride against walls for now
-	local node_in_front_of = mobs.jump_check(self)
-
-	if node_in_front_of == 1 then
-		mobs.jump(self)
-    end
-
-    --mobs that can climb over stuff
-    if self.always_climb and node_in_front_of > 0 then
-        mobs.climb(self)
-    end
-
-
-    --auto reset punch_timer
-    if not self.punch_timer then
-        self.punch_timer = 0
-    end
-
-    if self.punch_timer > 0 then
-        self.punch_timer = self.punch_timer - dtime
-    end
-end
-
-mobs.punch_attack = function(self)
-
-    self.attacking:punch(self.object, 1.0, {
-        full_punch_interval = 1.0,
-        damage_groups = {fleshy = self.damage}
-    }, nil)
-
-    self.punch_timer = self.punch_timer_cooloff
-
-
-    --knockback
-    local pos1 = self.object:get_pos()
-    pos1.y = 0
-    local pos2 = self.attacking:get_pos()
-    pos2.y = 0
-    local dir = vector_direction(pos1,pos2)
-
-    dir = vector_multiply(dir,3)
-
-    if self.attacking:get_velocity().y <= 1 then
-        dir.y = 5
-    end
-
-    self.attacking:add_velocity(dir)
-end
-
-
-
-
---[[
-______          _           _   _ _
-| ___ \        (_)         | | (_) |
-| |_/ / __ ___  _  ___  ___| |_ _| | ___
-|  __/ '__/ _ \| |/ _ \/ __| __| | |/ _ \
-| |  | | | (_) | |  __/ (__| |_| | |  __/
-\_|  |_|  \___/| |\___|\___|\__|_|_|\___|
-              _/ |
-             |__/
-]]--
-
-
-mobs.projectile_attack_walk = function(self,dtime)
-
-    --this needs an exception
-    if self.attacking == nil or not self.attacking:is_player() then
-        self.attacking = nil
-        return
-    end
-
-    mobs.set_yaw_while_attacking(self)
-
-    local distance_from_attacking = vector_distance(self.object:get_pos(), self.attacking:get_pos())
-
-
-    if distance_from_attacking >= self.reach then
-        mobs.set_velocity(self, self.run_velocity)
-        mobs.set_mob_animation(self,"run")
-    else
-        mobs.set_velocity(self,0)
-        mobs.set_mob_animation(self,"stand")
-    end
-
-    --do this to not load data into other mobs
-    if not self.projectile_timer then
-        self.projectile_timer = math_random(self.projectile_cooldown_min, self.projectile_cooldown_max)
-    end
-
-    --run projectile timer
-    if self.projectile_timer > 0 then
-        self.projectile_timer = self.projectile_timer - dtime
-
-        --shoot
-        if self.projectile_timer <= 0 then
-            --reset timer
-            self.projectile_timer = math_random(self.projectile_cooldown_min, self.projectile_cooldown_max)
-            mobs.shoot_projectile(self)
-        end
-    end
-
-    --make shooty mobs jump
-    --check for nodes to jump over
-    --explosive mobs will just ride against walls for now
-	local node_in_front_of = mobs.jump_check(self)
-	if node_in_front_of == 1 then
-		mobs.jump(self)
-    end
-
-end
-
-
-
-
-
-
-
-
-
---[[
- _  ______ _         _
-| | |  ___| |       | |
-| | | |_  | |_   _  | |
-| | |  _| | | | | | | |
-|_| | |   | | |_| | |_|
-(_) \_|   |_|\__, | (_)
-              __/ |
-             |___/
-]]--
-
-
-
-
---[[
-______          _           _   _ _
-| ___ \        (_)         | | (_) |
-| |_/ / __ ___  _  ___  ___| |_ _| | ___
-|  __/ '__/ _ \| |/ _ \/ __| __| | |/ _ \
-| |  | | | (_) | |  __/ (__| |_| | |  __/
-\_|  |_|  \___/| |\___|\___|\__|_|_|\___|
-              _/ |
-             |__/
-]]--
-
-local random_pitch_multiplier = {-1,1}
-
-mobs.projectile_attack_fly = function(self, dtime)
-    --this needs an exception
-    if self.attacking == nil or not self.attacking:is_player() then
-        self.attacking = nil
-        return
-    end
-
-    --this is specifically for random ghast movement
-    if self.fly_random_while_attack then
-
-        --enable rotation locking
-		mobs.movement_rotation_lock(self)
-
-        self.walk_timer = self.walk_timer - dtime
-
-        --reset the walk timer
-        if self.walk_timer <= 0 then
-            --re-randomize the walk timer
-            self.walk_timer = math.random(1,6) + math.random()
-            --set the mob into a random direction
-            self.yaw = (math_random() * (math.pi * 2))
-            --create a truly random pitch, since there is no easy access to pitch math that I can find
-            self.pitch = math_random() * math.random(1,3) * random_pitch_multiplier[math_random(1,2)]
-        end
-
-        mobs.set_fly_velocity(self, self.run_velocity)
-
-    else
-
-        mobs.set_yaw_while_attacking(self)
-
-        local distance_from_attacking = vector_distance(self.object:get_pos(), self.attacking:get_pos())
-
-        if distance_from_attacking >= self.reach then
-            mobs.set_pitch_while_attacking(self)
-            mobs.set_fly_velocity(self, self.run_velocity)
-            mobs.set_mob_animation(self,"run")
-        else
-            mobs.set_pitch_while_attacking(self)
-            mobs.set_fly_velocity(self, 0)
-            mobs.set_mob_animation(self,"stand")
-        end
-    end
-
-
-    --do this to not load data into other mobs
-    if not self.projectile_timer then
-        self.projectile_timer = math_random(self.projectile_cooldown_min, self.projectile_cooldown_max)
-    end
-
-    --run projectile timer
-    if self.projectile_timer > 0 then
-        self.projectile_timer = self.projectile_timer - dtime
-
-        --shoot
-        if self.projectile_timer <= 0 then
-
-            if self.fly_random_while_attack then
-                mobs.set_yaw_while_attacking(self)
-                self.walk_timer = 0
-            end
-            --reset timer
-            self.projectile_timer = math_random(self.projectile_cooldown_min, self.projectile_cooldown_max)
-            mobs.shoot_projectile(self)
-        end
-    end
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/breeding.lua

@@ -1,179 +0,0 @@
-local minetest_get_objects_inside_radius = minetest.get_objects_inside_radius
-
-local vector = vector
-
---check to see if someone nearby has some tasty food
-mobs.check_following = function(self) -- returns true or false
-    --ignore
-    if not self.follow then
-        self.following_person = nil
-        return false
-    end
-
-    --hey look, this thing works for passive mobs too!
-    local follower = mobs.detect_closest_player_within_radius(self,true,self.view_range,self.eye_height)
-
-    --check if the follower is a player incase they log out
-    if follower and follower:is_player() then
-        local stack = follower:get_wielded_item()
-        --safety check
-        if not stack then
-            self.following_person = nil
-            return false
-        end
-
-        local item_name = stack:get_name()
-        --all checks have passed, that guy has some good looking food
-        if item_name == self.follow then
-            self.following_person = follower
-            return true
-        end
-    end
-
-    --everything failed
-    self.following_person = nil
-    return false
-end
-
---a function which attempts to make mobs enter
---the breeding state
-mobs.enter_breed_state = function(self,clicker)
-
-    --do not breed if baby
-    if self.baby then
-        return false
-    end
-
-    --do not do anything if looking for mate or
-    --if cooling off from breeding
-    if self.breed_lookout_timer > 0 or self.breed_timer > 0 then
-        return false
-    end
-
-    --if this is caught, that means something has gone
-    --seriously wrong
-    if not clicker or not clicker:is_player() then
-        return false
-    end
-
-    local stack = clicker:get_wielded_item()
-    --safety check
-    if not stack then
-        return false
-    end
-
-    local item_name = stack:get_name()
-    --all checks have passed, that guy has some good looking food
-    if item_name == self.follow then
-        if not minetest.is_creative_enabled(clicker:get_player_name()) then
-            stack:take_item()
-            clicker:set_wielded_item(stack)
-        end
-        self.breed_lookout_timer = self.breed_lookout_timer_goal
-        self.bred = true
-        mobs.play_sound_specific(self,"mobs_mc_animal_eat_generic")
-        return true
-    end
-
-    --everything failed
-    return false
-end
-
-
---find the closest mate in the area
-mobs.look_for_mate = function(self)
-
-	local pos1 = self.object:get_pos()
-    pos1.y = pos1.y + self.eye_height
-
-	local mates_in_area = {}
-	local winner_mate = nil
-	local mates_detected = 0
-    local radius = self.view_range
-
-	--get mates in radius
-	for _,mate in pairs(minetest_get_objects_inside_radius(pos1, radius)) do
-
-        --look for a breeding mate
-		if mate and mate:get_luaentity()
-        and mate:get_luaentity()._cmi_is_mob
-        and mate:get_luaentity().name == self.name
-        and mate:get_luaentity().breed_lookout_timer > 0
-        and mate:get_luaentity() ~= self then
-
-			local pos2 = mate:get_pos()
-
-			local distance = vector.distance(pos1,pos2)
-
-			if distance <= radius then
-				if minetest.line_of_sight then
-					--must add eye height or stuff breaks randomly because of
-					--seethrough nodes being a blocker (like grass)
-					if minetest.line_of_sight(
-							vector.new(pos1.x, pos1.y, pos1.z),
-							vector.new(pos2.x, pos2.y + mate:get_properties().eye_height, pos2.z)
-						) then
-						mates_detected = mates_detected + 1
-						mates_in_area[mate] = distance
-					end
-				else
-					mates_detected = mates_detected + 1
-					mates_in_area[mate] = distance
-				end
-			end
-		end
-	end
-
-
-	--return if there's no one near by
-	if mates_detected <= 0 then --handle negative numbers for some crazy error that could possibly happen
-		return nil
-	end
-
-	--do a default radius max
-	local shortest_distance = radius + 1
-
-	--sort through mates and find the closest mate
-	for mate,distance in pairs(mates_in_area) do
-		if distance < shortest_distance then
-			shortest_distance = distance
-			winner_mate = mate
-		end
-	end
-	return winner_mate
-end
-
---make the baby grow up
-mobs.baby_grow_up = function(self)
-    self.baby = nil
-    self.visual_size  = self.backup_visual_size
-    self.collisionbox = self.backup_collisionbox
-    self.selectionbox = self.backup_selectionbox
-    self.object:set_properties(self)
-end
-
---makes the baby grow up faster with diminishing returns
-mobs.make_baby_grow_faster = function(self,clicker)
-    if clicker and clicker:is_player() then
-        local stack = clicker:get_wielded_item()
-        --safety check
-        if not stack then
-            return false
-        end
-
-        local item_name = stack:get_name()
-        --all checks have passed, that guy has some good looking food
-        if item_name == self.follow then
-            self.grow_up_timer = self.grow_up_timer - (self.grow_up_timer * 0.10) --take 10 percent off - diminishing returns
-
-            if not minetest.is_creative_enabled(clicker:get_player_name()) then
-                stack:take_item()
-                clicker:set_wielded_item(stack)
-            end
-
-            mobs.play_sound_specific(self,"mobs_mc_animal_eat_generic")
-            return true
-        end
-    end
-    return false
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/collision.lua

@@ -1,135 +0,0 @@
-local minetest_get_objects_inside_radius    = minetest.get_objects_inside_radius
-
-local math_random = math.random
-local vector_multiply = vector.multiply
-
-local vector_direction = vector.direction
-
-local integer_test = {-1,1}
-
-mobs.collision = function(self)
-	local pos = self.object:get_pos()
-
-	if not self or not self.object or not self.object:get_luaentity() then
-		return
-	end
-
-	--do collision detection from the base of the mob
-	local collisionbox = self.object:get_properties().collisionbox
-
-	pos.y = pos.y + collisionbox[2]
-
-	local collision_boundary = collisionbox[4]
-
-	local radius = collision_boundary
-
-	if collisionbox[5] > collision_boundary then
-		radius = collisionbox[5]
-	end
-
-	local collision_count = 0
-
-
-	local check_for_attack = false
-
-	if self.attack_type == "punch" and self.hostile and self.attacking then
-		check_for_attack = true
-	end
-
-	for _,object in ipairs(minetest_get_objects_inside_radius(pos, radius*1.25)) do
-		if object and object ~= self.object and (object:is_player() or (object:get_luaentity() and object:get_luaentity()._cmi_is_mob == true and object:get_luaentity().health > 0)) and
-		--don't collide with rider, rider don't collide with thing
-		(not object:get_attach() or (object:get_attach() and object:get_attach() ~= self.object)) and
-		(not self.object:get_attach() or (self.object:get_attach() and self.object:get_attach() ~= object)) then
-			--stop infinite loop
-			collision_count = collision_count + 1
-			--mob cramming
-			if collision_count > 30 then
-				self.health = -20
-				break
-			end
-
-			local pos2 = object:get_pos()
-
-			local object_collisionbox = object:get_properties().collisionbox
-
-			pos2.y = pos2.y + object_collisionbox[2]
-
-			local object_collision_boundary = object_collisionbox[4]
-
-
-			--this is checking the difference of the object collided with's possision
-			--if positive top of other object is inside (y axis) of current object
-			local y_base_diff = (pos2.y + object_collisionbox[5]) - pos.y
-
-			local y_top_diff = (pos.y + collisionbox[5]) - pos2.y
-
-
-			local distance = vector.distance(vector.new(pos.x,0,pos.z),vector.new(pos2.x,0,pos2.z))
-
-			if distance <= collision_boundary + object_collision_boundary and y_base_diff >= 0 and y_top_diff >= 0 then
-
-				local dir = vector.direction(pos,pos2)
-
-				dir.y = 0
-
-				--eliminate mob being stuck in corners
-				if dir.x == 0 and dir.z == 0 then
-					--slightly adjust mob position to prevent equal length
-					--corner/wall sticking
-					dir.x = dir.x + ((math_random()/10)*integer_test[math.random(1,2)])
-					dir.z = dir.z + ((math_random()/10)*integer_test[math.random(1,2)])
-				end
-
-				local velocity = dir
-
-				--0.5 is the max force multiplier
-				local force = 0.5 - (0.5 * distance / (collision_boundary + object_collision_boundary))
-
-				local vel1 = vector.multiply(velocity, -1.5)
-				local vel2 = vector.multiply(velocity,  1.5)
-
-				vel1 = vector.multiply(vel1, force * 10)
-				vel2 = vector.multiply(vel2, force)
-
-				if object:is_player() then
-					vel2 = vector_multiply(vel2, 2.5)
-
-					--integrate mob punching into collision detection
-					if check_for_attack and self.punch_timer <= 0 then
-						if object == self.attacking then
-							mobs.punch_attack(self)
-						end
-					end
-				end
-				self.object:add_velocity(vel1)
-				object:add_velocity(vel2)
-			end
-		end
-	end
-end
-
-
---this is used for arrow collisions
-mobs.arrow_hit = function(self, player)
-    player:punch(self.object, 1.0, {
-        full_punch_interval = 1.0,
-        damage_groups = {fleshy = self._damage}
-    }, nil)
-
-
-    --knockback
-    local pos1 = self.object:get_pos()
-	pos1.y = 0
-    local pos2 = player:get_pos()
-    pos2.y = 0
-    local dir = vector_direction(pos1,pos2)
-
-    dir = vector_multiply(dir,3)
-
-    if player:get_velocity().y <= 1 then
-        dir.y = 5
-    end
-
-    player:add_velocity(dir)
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/death_logic.lua

@@ -1,161 +0,0 @@
-local minetest_add_item = minetest.add_item
---local minetest_sound_play = minetest.sound_play
-
-local math_pi     = math.pi
-local math_random = math.random
-local math_floor  = math.floor
-local HALF_PI     = math_pi / 2
-
-local vector_new = vector.new
-
-
--- drop items
-local item_drop = function(self, cooked, looting_level)
-
-	looting_level = looting_level or 0
-
-	-- no drops for child mobs (except monster)
-	if (self.child and self.type ~= "monster") then
-		return
-	end
-
-	local obj, item
-	local pos = self.object:get_pos()
-
-	self.drops = self.drops or {} -- nil check
-
-	for n = 1, #self.drops do
-		local dropdef = self.drops[n]
-		local chance = 1 / dropdef.chance
-		local looting_type = dropdef.looting
-
-		if looting_level > 0 then
-			local chance_function = dropdef.looting_chance_function
-			if chance_function then
-				chance = chance_function(looting_level)
-			elseif looting_type == "rare" then
-				chance = chance + (dropdef.looting_factor or 0.01) * looting_level
-			end
-		end
-
-		local num = 0
-		local do_common_looting = (looting_level > 0 and looting_type == "common")
-		if math_random() < chance then
-			num = math_random(dropdef.min or 1, dropdef.max or 1)
-		elseif not dropdef.looting_ignore_chance then
-			do_common_looting = false
-		end
-
-		if do_common_looting then
-			num = num + math_floor(math_random(0, looting_level) + 0.5)
-		end
-
-		if num > 0 then
-			item = dropdef.name
-
-			-- cook items when true
-			if cooked then
-
-				local output = minetest.get_craft_result({
-					method = "cooking",
-                    width = 1,
-                    items = {item},
-                })
-
-				if output and output.item and not output.item:is_empty() then
-					item = output.item:get_name()
-				end
-			end
-
-			-- add item if it exists
-			for x = 1, num do
-				obj = minetest_add_item(pos, ItemStack(item .. " " .. 1))
-			end
-
-			if obj and obj:get_luaentity() then
-
-				obj:set_velocity({
-					x = math_random(-10, 10) / 9,
-					y = 6,
-					z = math_random(-10, 10) / 9,
-				})
-			elseif obj then
-				obj:remove() -- item does not exist
-			end
-		end
-	end
-
-	self.drops = {}
-end
-
-
-mobs.death_logic = function(self, dtime)
-
-	--stop crashing game when object is nil
-	if not self or not self.object or not self.object:get_luaentity() then
-		return
-	end
-
-    self.death_animation_timer = self.death_animation_timer + dtime
-
-	--get all attached entities and sort through them
-	local attached_entities = self.object:get_children()
-	if #attached_entities > 0 then
-		for _,entity in pairs(attached_entities) do
-			--kick the player off
-			if entity:is_player() then
-				mobs.detach(entity)
-			--kick mobs off
-			--if there is scaling issues, this needs an additional check
-			else
-				entity:set_detach()
-			end
-		end
-	end
-
-	--stop mob from getting in the way of other mobs you're fighting
-	if self.object:get_properties().pointable then
-		self.object:set_properties({pointable = false})
-	end
-
-    --the final POOF of a mob despawning
-    if self.death_animation_timer >= 1.25 then
-        item_drop(self,false,1)
-        mobs.death_effect(self)
-        mcl_experience.throw_xp(self.object:get_pos(), math_random(self.xp_min, self.xp_max))
-        if self.on_die then
-          self.on_die(self, self.object:get_pos())
-        end
-        self.object:remove()
-        return
-    end
-
-    --I'm sure there's a more efficient way to do this
-    --but this is the easiest, easier to work with 1 variable synced
-    --this is also not smooth
-    local death_animation_roll = self.death_animation_timer * 2 -- * 2 to make it faster
-    if death_animation_roll > 1 then
-        death_animation_roll = 1
-    end
-
-    local rot = self.object:get_rotation() --(no pun intended)
-
-    rot.z = death_animation_roll * HALF_PI
-
-    self.object:set_rotation(rot)
-
-    mobs.set_mob_animation(self,"stand", true)
-
-
-    --flying and swimming mobs just fall down
-    if self.fly or self.swim then
-        if self.object:get_acceleration().y ~= -self.gravity then
-            self.object:set_acceleration(vector_new(0,-self.gravity,0))
-        end
-    end
-
-    --when landing allow mob to slow down and just fall if in air
-    if self.pause_timer <= 0 then
-        mobs.set_velocity(self,0)
-    end
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/environment.lua

@@ -1,250 +0,0 @@
-local minetest_line_of_sight = minetest.line_of_sight
---local minetest_dir_to_yaw    = minetest.dir_to_yaw
-local minetest_yaw_to_dir    = minetest.yaw_to_dir
-local minetest_get_node      = minetest.get_node
-local minetest_get_item_group = minetest.get_item_group
-local minetest_get_objects_inside_radius = minetest.get_objects_inside_radius
-local minetest_get_node_or_nil = minetest.get_node_or_nil
-local minetest_registered_nodes = minetest.registered_nodes
-local minetest_get_connected_players = minetest.get_connected_players
-
-local vector_new = vector.new
-local vector_add = vector.add
-local vector_multiply = vector.multiply
-local vector_distance = vector.distance
-
-local table_copy = table.copy
-
-local math_abs = math.abs
-
--- default function when mobs are blown up with TNT
---[[local function do_tnt(obj, damage)
-	obj.object:punch(obj.object, 1.0, {
-		full_punch_interval = 1.0,
-		damage_groups = {fleshy = damage},
-	}, nil)
-	return false, true, {}
-end]]
-
---a fast function to be able to detect only players without using objects_in_radius
-mobs.detect_closest_player_within_radius = function(self, line_of_sight, radius, object_height_adder)
-	local pos1 = self.object:get_pos()
-	local players_in_area = {}
-	local winner_player = nil
-	local players_detected = 0
-
-	--get players in radius
-	for _,player in pairs(minetest.get_connected_players()) do
-		if player and player:get_hp() > 0 then
-
-			local pos2 = player:get_pos()
-
-			local distance = vector_distance(pos1,pos2)
-
-			if distance <= radius then
-				if line_of_sight then
-					--must add eye height or stuff breaks randomly because of
-					--seethrough nodes being a blocker (like grass)
-					if minetest_line_of_sight(
-							vector_new(pos1.x, pos1.y + object_height_adder, pos1.z),
-							vector_new(pos2.x, pos2.y + player:get_properties().eye_height, pos2.z)
-						) then
-						players_detected = players_detected + 1
-						players_in_area[player] = distance
-					end
-				else
-					players_detected = players_detected + 1
-					players_in_area[player] = distance
-				end
-			end
-		end
-	end
-
-
-	--return if there's no one near by
-	if players_detected <= 0 then --handle negative numbers for some crazy error that could possibly happen
-		return nil
-	end
-
-	--do a default radius max
-	local shortest_distance = radius + 1
-
-	--sort through players and find the closest player
-	for player,distance in pairs(players_in_area) do
-		if distance < shortest_distance then
-			shortest_distance = distance
-			winner_player = player
-		end
-	end
-	return winner_player
-end
-
-
---check if a mob needs to jump
-mobs.jump_check = function(self,dtime)
-
-    local pos = self.object:get_pos()
-    pos.y = pos.y + 0.1
-    local dir = minetest_yaw_to_dir(self.yaw)
-
-    local collisionbox = self.object:get_properties().collisionbox
-	local radius = collisionbox[4] + 0.5
-
-    vector_multiply(dir, radius)
-
-	--only jump if there's a node and a non-solid node above it
-    local test_dir = vector_add(pos,dir)
-
-	local green_flag_1 = minetest_get_item_group(minetest_get_node(test_dir).name, "solid") ~= 0
-
-	test_dir.y = test_dir.y + 1
-
-	local green_flag_2 = minetest_get_item_group(minetest_get_node(test_dir).name, "solid") == 0
-
-    if green_flag_1 and green_flag_2 then
-		--can jump over node
-        return 1
-	elseif green_flag_1 and not green_flag_2 then
-		--wall in front of mob
-		return 2
-    end
-	--nothing to jump over
-	return 0
-end
-
--- a helper function to quickly turn neutral passive mobs hostile
-local turn_hostile = function(self,detected_mob)
-	--drop in variables for attacking (stops crash)
-	detected_mob.punch_timer = 0
-	--set to hostile
-	detected_mob.hostile = true
-	--hostile_cooldown timer is initialized here
-	detected_mob.hostile_cooldown_timer = detected_mob.hostile_cooldown
-	--set target to the same
-	detected_mob.attacking = self.attacking
-end
-
---allow hostile mobs to signal to other mobs
---to switch from neutal passive to neutral hostile
-mobs.group_attack_initialization = function(self)
-
-	--get basic data
-	local friends_list
-
-	if self.group_attack == true then
-		friends_list = {self.name}
-	else
-		friends_list = table_copy(self.group_attack)
-	end
-
-	local objects_in_area = minetest_get_objects_inside_radius(self.object:get_pos(), self.view_range)
-
-	--get the player's name
-	local name = self.attacking:get_player_name()
-
-	--re-use local variable
-	local detected_mob
-
-	--run through mobs in viewing distance
-	for _,object in pairs(objects_in_area) do
-		if object and object:get_luaentity() then
-			detected_mob = object:get_luaentity()
-			-- only alert members of same mob or friends
-			if detected_mob._cmi_is_mob and detected_mob.state ~= "attack" and detected_mob.owner ~= name then
-				if detected_mob.name == self.name then
-					turn_hostile(self,detected_mob)
-				else
-					for _,id in pairs(friends_list) do
-						if detected_mob.name == id then
-							turn_hostile(self,detected_mob)
-							break
-						end
-					end
-				end
-			end
-
-			--THIS NEEDS TO BE RE-IMPLEMENTED AS A GLOBAL HIT IN MOB_PUNCH!!
-			-- have owned mobs attack player threat
-			--if obj.owner == name and obj.owner_loyal then
-			--	do_attack(obj, self.object)
-			--end
-		end
-	end
-end
-
--- check if within physical map limits (-30911 to 30927)
--- within_limits, wmin, wmax = nil, -30913, 30928
-mobs.within_limits = function(pos, radius)
-    local wmin, wmax
-	if mcl_vars then
-		if mcl_vars.mapgen_edge_min and mcl_vars.mapgen_edge_max then
-			wmin, wmax = mcl_vars.mapgen_edge_min, mcl_vars.mapgen_edge_max
-		end
-	end
-	return pos
-		and (pos.x - radius) > wmin and (pos.x + radius) < wmax
-		and (pos.y - radius) > wmin and (pos.y + radius) < wmax
-		and (pos.z - radius) > wmin and (pos.z + radius) < wmax
-end
-
--- get node but use fallback for nil or unknown
-mobs.node_ok = function(pos, fallback)
-
-	fallback = fallback or 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
-
-
---a teleport functoin
-mobs.teleport = function(self, target)
-	if self.do_teleport then
-		if self.do_teleport(self, target) == false then
-			return
-		end
-	end
-end
-
---a function used for despawning mobs
-mobs.check_for_player_within_area = function(self, radius)
-	local pos1 = self.object:get_pos()
-	--get players in radius
-	for _,player in pairs(minetest_get_connected_players()) do
-		if player and player:get_hp() > 0 then
-			local pos2 = player:get_pos()
-			local distance = vector_distance(pos1,pos2)
-			if distance < radius then
-				--found a player
-				return true
-			end
-		end
-	end
-	--did not find a player
-	return false
-end
-
-
---a simple helper function for mobs following
-mobs.get_2d_distance = function(pos1,pos2)
-	pos1.y = 0
-	pos2.y = 0
-	return vector_distance(pos1, pos2)
-end
-
--- fall damage onto solid ground
-mobs.calculate_fall_damage = function(self)
-	if self.old_velocity and self.old_velocity.y < -7 and self.object:get_velocity().y == 0 then
-		local vel = self.object:get_velocity()
-		if vel then
-			local damage = math_abs(self.old_velocity.y + 7) * 2
-			self.pause_timer = 0.4
-			self.health = self.health - damage
-		end
-	end
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/head_logic.lua

@@ -1,98 +0,0 @@
-local math = math
-local vector = vector
-
---converts yaw to degrees
-local degrees = function(yaw)
-	return yaw*180.0/math.pi
-end
-
-mobs.do_head_logic = function(self,dtime)
-
-	local player = minetest.get_player_by_name("singleplayer")
-
-	local look_at = player:get_pos()
-	look_at.y = look_at.y + player:get_properties().eye_height
-
-	local pos = self.object:get_pos()
-
-	local body_yaw = self.object:get_yaw()
-
-	local body_dir = minetest.yaw_to_dir(body_yaw)
-
-	pos.y = pos.y + self.head_height_offset
-
-	local head_offset = vector.multiply(body_dir, self.head_direction_offset)
-
-	pos = vector.add(pos, head_offset)
-
-	minetest.add_particle({
-		pos = pos,
-		velocity = {x=0, y=0, z=0},
-		acceleration = {x=0, y=0, z=0},
-		expirationtime = 0.2,
-		size = 1,
-		texture = "default_dirt.png",
-	})
-
-	local bone_pos = vector.new(0,0,0)
-
-	--(horizontal)
-	bone_pos.y = self.head_bone_pos_y
-
-	--(vertical)
-	bone_pos.z = self.head_bone_pos_z
-
-	--print(yaw)
-
-	--local _, bone_rot = self.object:get_bone_position("head")
-
-	--bone_rot.x = bone_rot.x + (dtime * 10)
-	--bone_rot.z = bone_rot.z + (dtime * 10)
-
-	local head_yaw = minetest.dir_to_yaw(vector.direction(pos,look_at)) - body_yaw
-
-	if self.reverse_head_yaw then
-		head_yaw = head_yaw * -1
-	end
-
-	--over rotation protection
-	--stops radians from going out of spec
-	if head_yaw > math.pi then
-		head_yaw = head_yaw - (math.pi * 2)
-	elseif head_yaw < -math.pi then
-		head_yaw = head_yaw + (math.pi * 2)
-	end
-
-
-	local check_failed = false
-	--upper check + 90 degrees or upper math.radians (3.14/2)
-	if head_yaw > math.pi - (math.pi/2) then
-		head_yaw = 0
-		check_failed = true
-	--lower check - 90 degrees or lower negative math.radians (-3.14/2)
-	elseif head_yaw < -math.pi + (math.pi/2) then
-		head_yaw = 0
-		check_failed = true
-	end
-
-	local head_pitch = 0
-
-	--DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
-	--head_yaw = 0
-	--DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
-
-	if not check_failed then
-		head_pitch = minetest.dir_to_yaw(vector.new(vector.distance(vector.new(pos.x,0,pos.z),vector.new(look_at.x,0,look_at.z)),0,pos.y-look_at.y))+(math.pi/2)
-	end
-
-	if self.head_pitch_modifier then
-		head_pitch = head_pitch + self.head_pitch_modifier
-	end
-
-	if self.swap_y_with_x then
-		self.object:set_bone_position(self.head_bone, bone_pos, vector.new(degrees(head_pitch),degrees(head_yaw),0))
-	else
-		self.object:set_bone_position(self.head_bone, bone_pos, vector.new(degrees(head_pitch),0,degrees(head_yaw)))
-	end
-	--set_bone_position([bone, position, rotation])
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/interaction.lua

@@ -1,276 +0,0 @@
-local minetest_after      = minetest.after
-local minetest_sound_play = minetest.sound_play
-local minetest_dir_to_yaw = minetest.dir_to_yaw
-
-local math = math
-local vector = vector
-
-local MAX_MOB_NAME_LENGTH = 30
-
-local mod_hunger = minetest.get_modpath("mcl_hunger")
-
-mobs.feed_tame = function(self)
-    return nil
-end
-
--- Code to execute before custom on_rightclick handling
-local function on_rightclick_prefix(self, clicker)
-	local item = clicker:get_wielded_item()
-
-	-- Name mob with nametag
-	if not self.ignores_nametag and item:get_name() == "mcl_mobs:nametag" then
-
-		local tag = item:get_meta():get_string("name")
-		if tag ~= "" then
-			if string.len(tag) > MAX_MOB_NAME_LENGTH then
-				tag = string.sub(tag, 1, MAX_MOB_NAME_LENGTH)
-			end
-			self.nametag = tag
-
-			mobs.update_tag(self)
-
-			if not mobs.is_creative(clicker:get_player_name()) then
-				item:take_item()
-				clicker:set_wielded_item(item)
-			end
-			return true
-		end
-
-	end
-	return false
-end
-
--- I have no idea what this does
-mobs.create_mob_on_rightclick = function(on_rightclick)
-	return function(self, clicker)
-		--don't allow rightclicking dead mobs
-		if self.health <= 0 then
-			return
-		end
-		local stop = on_rightclick_prefix(self, clicker)
-		if (not stop) and (on_rightclick) then
-			on_rightclick(self, clicker)
-		end
-	end
-end
-
-
--- deal damage and effects when mob punched
-mobs.mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
-	--don't do anything if the mob is already dead
-	if self.health <= 0 then
-		return
-	end
-
-	--neutral passive mobs switch to neutral hostile
-	if self.neutral then
-		--drop in variables for attacking (stops crash)
-		self.attacking   = hitter
-		self.punch_timer = 0
-		self.hostile = true
-		--hostile_cooldown timer is initialized here
-		self.hostile_cooldown_timer = self.hostile_cooldown
-
-		--initialize the group attack (check for other mobs in area, make them neutral hostile)
-		if self.group_attack then
-			mobs.group_attack_initialization(self)
-		end
-	end
-
-	--turn skittish mobs away and RUN
-	if self.skittish then
-
-		self.state = "run"
-
-		self.run_timer = 5 --arbitrary 5 seconds
-
-		local pos1 = self.object:get_pos()
-		pos1.y = 0
-		local pos2 = hitter:get_pos()
-		pos2.y = 0
-
-
-		local dir = vector.direction(pos2,pos1)
-
-		local yaw = minetest_dir_to_yaw(dir)
-
-		self.yaw = yaw
-	end
-
-	-- custom punch function
-	if self.do_punch then
-		-- when false skip going any further
-		if self.do_punch(self, hitter, tflp, tool_capabilities, dir) == false then
-			return
-		end
-	end
-
-	--don't do damage until pause timer resets
-	if self.pause_timer > 0 then
-		return
-	end
-
-	-- error checking when mod profiling is enabled
-	if not tool_capabilities then
-		minetest.log("warning", "[mobs_mc] Mod profiling enabled, damage not enabled")
-		return
-	end
-
-	local is_player = hitter:is_player()
-
-	-- punch interval
-	local weapon = hitter:get_wielded_item()
-
-	--local punch_interval = 1.4
-
-	-- exhaust attacker
-	if mod_hunger and is_player then
-		mcl_hunger.exhaust(hitter:get_player_name(), mcl_hunger.EXHAUST_ATTACK)
-	end
-
-	-- calculate mob damage
-	local damage = 0
-	local armor = self.object:get_armor_groups() or {}
-
-	--calculate damage groups
-	for group,_ in pairs( (tool_capabilities.damage_groups or {}) ) do
-		damage = damage + (tool_capabilities.damage_groups[group] or 0) * ((armor[group] or 0) / 100.0)
-	end
-
-	if weapon then
-		local fire_aspect_level = mcl_enchanting.get_enchantment(weapon, "fire_aspect")
-		if fire_aspect_level > 0 then
-			mcl_burning.set_on_fire(self.object, fire_aspect_level * 4)
-		end
-	end
-
-	-- check for tool immunity or special damage
-	for n = 1, #self.immune_to do
-		if self.immune_to[n][1] == weapon:get_name() then
-			damage = self.immune_to[n][2] or 0
-			break
-		end
-	end
-
-	-- healing
-	if damage <= -1 then
-		self.health = self.health - math.floor(damage)
-		return
-	end
-
-	--if tool_capabilities then
-	--	punch_interval = tool_capabilities.full_punch_interval or 1.4
-	--end
-
-	-- add weapon wear manually
-	-- Required because we have custom health handling ("health" property)
-	--minetest_is_creative_enabled("") ~= true --removed for now
-	if tool_capabilities then
-		if tool_capabilities.punch_attack_uses then
-			-- Without this delay, the wear does not work. Quite hacky ...
-			minetest_after(0, function(name)
-				local player = minetest.get_player_by_name(name)
-				if not player then return end
-				local weapon = hitter:get_wielded_item(player)
-				local def = weapon:get_definition()
-				if def.tool_capabilities and def.tool_capabilities.punch_attack_uses then
-					local wear = math.floor(65535/tool_capabilities.punch_attack_uses)
-					weapon:add_wear(wear)
-					hitter:set_wielded_item(weapon)
-				end
-			end, hitter:get_player_name())
-		end
-	end
-
-
-	--if player is falling multiply damage by 1.5
-	--critical hit
-	if hitter:get_velocity().y < 0 then
-		damage = damage * 1.5
-		mobs.critical_effect(self)
-	end
-
-
-	-- only play hit sound and show blood effects if damage is 1 or over; lower to 0.1 to ensure armor works appropriately.
-	if damage >= 0.1 then
-
-		minetest_sound_play("default_punch", {
-			object = self.object,
-			max_hear_distance = 16
-		}, true)
-
-		-- do damage
-		self.health = self.health - damage
-
-
-		--0.4 seconds until you can hurt the mob again
-		self.pause_timer = 0.4
-
-		--don't do knockback from a rider
-		for _,obj in pairs(self.object:get_children()) do
-			if obj == hitter then
-				return
-			end
-		end
-
-		-- knock back effect
-		local velocity = self.object:get_velocity()
-
-		--2d direction
-		local pos1 = self.object:get_pos()
-		pos1.y = 0
-		local pos2 = hitter:get_pos()
-		pos2.y = 0
-
-		local dir = vector.direction(pos2,pos1)
-
-		local up = 3
-
-		-- if already in air then dont go up anymore when hit
-		if velocity.y ~= 0 then
-			up = 0
-		end
-
-		--0.75 for perfect distance to not be too easy, and not be too hard
-		local multiplier = 0.75
-
-		-- check if tool already has specific knockback value
-		local knockback_enchant = mcl_enchanting.get_enchantment(hitter:get_wielded_item(), "knockback")
-		if knockback_enchant and knockback_enchant > 0 then
-			multiplier = knockback_enchant + 1 --(starts from 1, 1 would be no change)
-		end
-
-		--do this to sure you can punch a mob back when
-		--it's coming for you
-		if self.hostile then
-			multiplier = multiplier + 2
-		end
-		dir = vector.multiply(dir,multiplier)
-		dir.y = up
-		--add the velocity
-		self.object:add_velocity(dir)
-	end
-end
-
---do internal per mob projectile calculations
-mobs.shoot_projectile = function(self)
-	local pos1 = self.object:get_pos()
-	--add mob eye height
-	pos1.y = pos1.y + self.eye_height
-
-	local pos2 = self.attacking:get_pos()
-	--add player eye height
-	pos2.y = pos2.y + self.attacking:get_properties().eye_height
-
-	--get direction
-	local dir = vector.direction(pos1,pos2)
-
-	--call internal shoot_arrow function
-	self.shoot_arrow(self,pos1,dir)
-end
-
-mobs.update_tag = function(self)
-	self.object:set_properties({
-		nametag = self.nametag,
-	})
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/mob_effects.lua

@@ -1,150 +0,0 @@
-local minetest_add_particlespawner = minetest.add_particlespawner
-
-mobs.death_effect = function(self)
-    local pos = self.object:get_pos()
-    --local yaw = self.object:get_yaw()
-    local collisionbox = self.object:get_properties().collisionbox
-
-    local min, max
-
-    if collisionbox then
-        min = {x=collisionbox[1], y=collisionbox[2], z=collisionbox[3]}
-        max = {x=collisionbox[4], y=collisionbox[5], z=collisionbox[6]}
-    end
-
-    minetest_add_particlespawner({
-        amount = 50,
-        time = 0.0001,
-        minpos = vector.add(pos, min),
-        maxpos = vector.add(pos, max),
-        minvel = vector.new(-0.5,0.5,-0.5),
-        maxvel = vector.new(0.5,1,0.5),
-        minexptime = 1.1,
-        maxexptime = 1.5,
-        minsize = 1,
-        maxsize = 2,
-        collisiondetection = false,
-        vertical = false,
-        texture = "mcl_particles_mob_death.png", -- this particle looks strange
-    })
-end
-
-mobs.critical_effect = function(self)
-
-    local pos = self.object:get_pos()
-    --local yaw = self.object:get_yaw()
-    local collisionbox = self.object:get_properties().collisionbox
-
-    local min, max
-
-    if collisionbox then
-        min = {x=collisionbox[1], y=collisionbox[2], z=collisionbox[3]}
-        max = {x=collisionbox[4], y=collisionbox[5], z=collisionbox[6]}
-    end
-
-    minetest_add_particlespawner({
-        amount = 10,
-        time = 0.0001,
-        minpos = vector.add(pos, min),
-        maxpos = vector.add(pos, max),
-        minvel = vector.new(-1,1,-1),
-        maxvel = vector.new(1,3,1),
-        minexptime = 0.7,
-        maxexptime = 1,
-        minsize = 1,
-        maxsize = 2,
-        collisiondetection = false,
-        vertical = false,
-        texture = "heart.png^[colorize:black:255",
-    })
-end
-
---when feeding a mob
-mobs.feed_effect = function(self)
-    local pos = self.object:get_pos()
-    --local yaw = self.object:get_yaw()
-    local collisionbox = self.object:get_properties().collisionbox
-
-    local min, max
-
-    if collisionbox then
-        min = {x=collisionbox[1], y=collisionbox[2], z=collisionbox[3]}
-        max = {x=collisionbox[4], y=collisionbox[5], z=collisionbox[6]}
-    end
-
-    minetest_add_particlespawner({
-        amount = 10,
-        time = 0.0001,
-        minpos = vector.add(pos, min),
-        maxpos = vector.add(pos, max),
-        minvel = vector.new(-1,1,-1),
-        maxvel = vector.new(1,3,1),
-        minexptime = 0.7,
-        maxexptime = 1,
-        minsize = 1,
-        maxsize = 2,
-        collisiondetection = false,
-        vertical = false,
-        texture = "heart.png^[colorize:gray:255",
-    })
-end
-
---hearts when tamed
-mobs.tamed_effect = function(self)
-    local pos = self.object:get_pos()
-    --local yaw = self.object:get_yaw()
-    local collisionbox = self.object:get_properties().collisionbox
-
-    local min, max
-
-    if collisionbox then
-        min = {x=collisionbox[1], y=collisionbox[2], z=collisionbox[3]}
-        max = {x=collisionbox[4], y=collisionbox[5], z=collisionbox[6]}
-    end
-
-    minetest_add_particlespawner({
-        amount = 30,
-        time = 0.0001,
-        minpos = vector.add(pos, min),
-        maxpos = vector.add(pos, max),
-        minvel = vector.new(-1,1,-1),
-        maxvel = vector.new(1,3,1),
-        minexptime = 0.7,
-        maxexptime = 1,
-        minsize = 1,
-        maxsize = 2,
-        collisiondetection = false,
-        vertical = false,
-        texture = "heart.png",
-    })
-end
-
---hearts when breeding
-mobs.breeding_effect = function(self)
-    local pos = self.object:get_pos()
-    --local yaw = self.object:get_yaw()
-    local collisionbox = self.object:get_properties().collisionbox
-
-    local min, max
-
-    if collisionbox then
-        min = {x=collisionbox[1], y=collisionbox[2], z=collisionbox[3]}
-        max = {x=collisionbox[4], y=collisionbox[5], z=collisionbox[6]}
-    end
-
-    minetest_add_particlespawner({
-        amount = 2,
-        time = 0.0001,
-        minpos = vector.add(pos, min),
-        maxpos = vector.add(pos, max),
-        minvel = vector.new(-1,1,-1),
-        maxvel = vector.new(1,3,1),
-        minexptime = 0.7,
-        maxexptime = 1,
-        minsize = 1,
-        maxsize = 2,
-        collisiondetection = false,
-        vertical = false,
-        texture = "heart.png",
-    })
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/movement.lua

@@ -1,390 +0,0 @@
--- localize math functions
-local math = math
-local HALF_PI     = math.pi / 2
-local DOUBLE_PI   = math.pi * 2
-
--- localize vector functions
-local vector = vector
-
-local minetest_yaw_to_dir = minetest.yaw_to_dir
-local minetest_dir_to_yaw = minetest.dir_to_yaw
-
-local DEFAULT_JUMP_HEIGHT = 5
-local DEFAULT_FLOAT_SPEED = 4
-local DEFAULT_CLIMB_SPEED = 3
-
-mobs.stick_in_cobweb = function(self)
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = vector.multiply(vector.normalize(current_velocity), 0.4)
-
-	goal_velocity.y = -0.5
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
---this is a generic float function
-mobs.float = function(self)
-
-	local acceleration = self.object:get_acceleration()
-
-	if not acceleration then
-		return
-	end
-
-	if acceleration.y ~= 0 then
-		self.object:set_acceleration({x=0, y=0, z=0})
-	end
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = 0,
-		y = DEFAULT_FLOAT_SPEED,
-		z = 0,
-	}
-
-	local new_velocity_addition = vector.subtract(goal_velocity, current_velocity)
-
-	new_velocity_addition.x = 0
-	new_velocity_addition.z = 0
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
---this is a generic climb function
-mobs.climb = function(self)
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = 0,
-		y = DEFAULT_CLIMB_SPEED,
-		z = 0,
-	}
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	new_velocity_addition.x = 0
-	new_velocity_addition.z = 0
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
-
-
---[[
- _                     _
-| |                   | |
-| |     __ _ _ __   __| |
-| |    / _` | '_ \ / _` |
-| |___| (_| | | | | (_| |
-\_____/\__,_|_| |_|\__,_|
-]]
-
-
--- move mob in facing direction
---this has been modified to be internal
---internal = lua (self.yaw)
---engine = c++ (self.object:get_yaw())
-mobs.set_velocity = function(self, v)
-
-	local yaw = (self.yaw or 0)
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = (math.sin(yaw) * -v),
-		y = 0,
-		z = (math.cos(yaw) * v),
-	}
-
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
-	end
-
-	new_velocity_addition.y = 0
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
-
-
--- calculate mob velocity
-mobs.get_velocity = function(self)
-
-	local v = self.object:get_velocity()
-
-	v.y = 0
-
-	if v then
-		return vector.length(v)
-	end
-
-	return 0
-end
-
---make mobs jump
-mobs.jump = function(self, velocity)
-
-    if self.object:get_velocity().y ~= 0 or not self.old_velocity or (self.old_velocity and self.old_velocity.y > 0) then
-        return
-    end
-
-	--fallback velocity to allow modularity
-    velocity = velocity or DEFAULT_JUMP_HEIGHT
-
-    self.object:add_velocity(vector.new(0,velocity,0))
-end
-
---make mobs fall slowly
-mobs.mob_fall_slow = function(self)
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = 0,
-		y = -2,
-		z = 0,
-	}
-
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	new_velocity_addition.x = 0
-	new_velocity_addition.z = 0
-
-	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
-	end
-
-	new_velocity_addition.x = 0
-	new_velocity_addition.z = 0
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-
-end
-
-
---[[
- _____          _
-/  ___|        (_)
-\ `--.__      ___ _ __ ___
- `--. \ \ /\ / / | '_ ` _ \
-/\__/ /\ V  V /| | | | | | |
-\____/  \_/\_/ |_|_| |_| |_|
-]]--
-
-
-
-
---make mobs flop
-mobs.flop = function(self, velocity)
-
-    if self.object:get_velocity().y ~= 0 or not self.old_velocity or (self.old_velocity and self.old_velocity.y > 0) then
-        return false
-    end
-
-	mobs.set_velocity(self, 0)
-
-	--fallback velocity to allow modularity
-    velocity = velocity or DEFAULT_JUMP_HEIGHT
-
-	--create a random direction (2d yaw)
-	local dir = DOUBLE_PI * math.random()
-
-	--create a random force value
-	local force = math.random(0,3) + math.random()
-
-	--convert the yaw to a direction vector then multiply it times the force
-	local final_additional_force = vector.multiply(minetest_yaw_to_dir(dir), force)
-
-	--place in the "flop" velocity to make the mob flop
-	final_additional_force.y = velocity
-
-    self.object:add_velocity(final_additional_force)
-
-	return true
-end
-
-
-
--- move mob in facing direction
---this has been modified to be internal
---internal = lua (self.yaw)
---engine = c++ (self.object:get_yaw())
-mobs.set_swim_velocity = function(self, v)
-
-	local yaw = (self.yaw or 0)
-	local pitch = (self.pitch or 0)
-
-	if v == 0 then
-		pitch = 0
-	end
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = (math.sin(yaw) * -v),
-		y = pitch,
-		z = (math.cos(yaw) * v),
-	}
-
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
-	end
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
---[[
-______ _
-|  ___| |
-| |_  | |_   _
-|  _| | | | | |
-| |   | | |_| |
-\_|   |_|\__, |
-          __/ |
-         |___/
-]]--
-
--- move mob in facing direction
---this has been modified to be internal
---internal = lua (self.yaw)
---engine = c++ (self.object:get_yaw())
-mobs.set_fly_velocity = function(self, v)
-
-	local yaw = (self.yaw or 0)
-	local pitch = (self.pitch or 0)
-
-	if v == 0 then
-		pitch = 0
-	end
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = (math.sin(yaw) * -v),
-		y = pitch,
-		z = (math.cos(yaw) * v),
-	}
-
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
-	end
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
---a quick and simple pitch calculation between two vector positions
-mobs.calculate_pitch = function(pos1, pos2)
-
-	if pos1 == nil or pos2 == nil then
-		return false
-	end
-
-    return minetest_dir_to_yaw(vector.new(vector.distance(vector.new(pos1.x,0,pos1.z),vector.new(pos2.x,0,pos2.z)),0,pos1.y - pos2.y)) + HALF_PI
-end
-
---make mobs fly up or down based on their y difference
-mobs.set_pitch_while_attacking = function(self)
-	local pos1 = self.object:get_pos()
-	local pos2 = self.attacking:get_pos()
-
-	local pitch = mobs.calculate_pitch(pos2,pos1)
-
-	self.pitch = pitch
-end
-
-
-
---[[
-   ___
-  |_  |
-    | |_   _ _ __ ___  _ __
-    | | | | | '_ ` _ \| '_ \
-/\__/ / |_| | | | | | | |_) |
-\____/ \__,_|_| |_| |_| .__/
-                      | |
-                      |_|
-]]--
-
---special mob jump movement
-mobs.jump_move = function(self, velocity)
-
-    if self.object:get_velocity().y ~= 0 or not self.old_velocity or (self.old_velocity and self.old_velocity.y > 0) then
-        return
-    end
-
-	--make the mob stick for a split second
-	mobs.set_velocity(self,0)
-
-	--fallback velocity to allow modularity
-    local jump_height = DEFAULT_JUMP_HEIGHT
-
-	local yaw = (self.yaw or 0)
-
-	local current_velocity = self.object:get_velocity()
-
-	local goal_velocity = {
-		x = (math.sin(yaw) * -velocity),
-		y = jump_height,
-		z = (math.cos(yaw) * velocity),
-	}
-
-
-	local new_velocity_addition = vector.subtract(goal_velocity,current_velocity)
-
-	if vector.length(new_velocity_addition) > vector.length(goal_velocity) then
-		vector.multiply(new_velocity_addition, (vector.length(goal_velocity) / vector.length(new_velocity_addition)))
-	end
-
-	--smooths out mobs a bit
-	if vector.length(new_velocity_addition) >= 0.0001 then
-		self.object:add_velocity(new_velocity_addition)
-	end
-end
-
---make it so mobs do not glitch out and freak out
---when moving around over nodes
-mobs.swap_auto_step_height_adjust = function(self)
-	local y_vel = self.object:get_velocity().y
-
-	if y_vel == 0 and self.stepheight ~= self.stepheight_backup then
-		self.stepheight = self.stepheight_backup
-	elseif y_vel ~= 0 and self.stepheight ~= 0 then
-		self.stepheight = 0
-	end
-end

mods/ENTITIES/mcl_mobs/api/mob_functions/projectile_handling.lua

@@ -1,43 +0,0 @@
-local GRAVITY             = minetest.settings:get("movement_gravity")-- + 9.81
-
-mobs.shoot_projectile_handling = function(arrow_item, pos, dir, yaw, shooter, power, damage, is_critical, bow_stack, collectable, gravity)
-	local obj = minetest.add_entity({x=pos.x,y=pos.y,z=pos.z}, arrow_item.."_entity")
-	if power == nil then
-		power = 19
-	end
-	if damage == nil then
-		damage = 3
-	end
-
-    gravity = gravity or -GRAVITY
-
-	local knockback
-	if bow_stack then
-		local enchantments = mcl_enchanting.get_enchantments(bow_stack)
-		if enchantments.power then
-			damage = damage + (enchantments.power + 1) / 4
-		end
-		if enchantments.punch then
-			knockback = enchantments.punch * 3
-		end
-		if enchantments.flame then
-			mcl_burning.set_on_fire(obj, math.huge)
-		end
-	end
-	obj:set_velocity({x=dir.x*power, y=dir.y*power, z=dir.z*power})
-	obj:set_acceleration({x=0, y=gravity, z=0})
-	obj:set_yaw(yaw-math.pi/2)
-	local le = obj:get_luaentity()
-	le._shooter = shooter
-	le._damage = damage
-	le._is_critical = is_critical
-	le._startpos = pos
-	le._knockback = knockback
-	le._collectable = collectable
-
-    --play custom shoot sound
-    if shooter and shooter.shoot_sound then
-        minetest.sound_play(shooter.shoot_sound, {pos=pos, max_hear_distance=16}, true)
-    end
-	return obj
-end