diff --git a/mods/ENTITIES/mcl_mobs/backup_code_api.lua b/mods/ENTITIES/mcl_mobs/backup_code_api.lua
index ba4b8452a..85cf0db5f 100644
--- a/mods/ENTITIES/mcl_mobs/backup_code_api.lua
+++ b/mods/ENTITIES/mcl_mobs/backup_code_api.lua
@@ -1464,3 +1464,1133 @@ local remove_texture_mod = function(self, mod)
 	end
 	self.object:set_texture_mod(full_mod)
 end
+
+
+-- Return true if object is in view_range
+local function object_in_range(self, object)
+	if not object then
+		return false
+	end
+	local factor
+	-- Apply view range reduction for special player armor
+	if object:is_player() and mod_armor then
+		factor = armor:get_mob_view_range_factor(object, self.name)
+	end
+	-- Distance check
+	local dist
+	if factor and factor == 0 then
+		return false
+	elseif factor then
+		dist = self.view_range * factor
+	else
+		dist = self.view_range
+	end
+
+	local p1, p2 = self.object:get_pos(), object:get_pos()
+	return p1 and p2 and (vector.distance(p1, p2) <= dist)
+end
+
+-- attack player/mob
+local do_attack = function(self, player)
+
+	if self.state == "attack" or self.state == "die" then
+		return
+	end
+
+	self.attack = player
+	self.state = "attack"
+
+	-- TODO: Implement war_cry sound without being annoying
+	--if math_random(0, 100) < 90 then
+		--mob_sound(self, "war_cry", true)
+	--end
+end
+
+
+-- play sound
+local mob_sound = function(self, soundname, is_opinion, fixed_pitch)
+	local soundinfo
+	if self.sounds_child and self.child then
+		soundinfo = self.sounds_child
+	elseif self.sounds then
+		soundinfo = self.sounds
+	end
+	if not soundinfo then
+		return
+	end
+	local sound = soundinfo[soundname]
+	if sound then
+		if is_opinion and self.opinion_sound_cooloff > 0 then
+			return
+		end
+		local pitch
+		if not fixed_pitch then
+			local base_pitch = soundinfo.base_pitch
+			if not base_pitch then
+				base_pitch = 1
+			end
+			if self.child and (not self.sounds_child) then
+				-- Children have higher pitch
+				pitch = base_pitch * 1.5
+			else
+				pitch = base_pitch
+			end
+			-- randomize the pitch a bit
+			pitch = pitch + math_random(-10, 10) * 0.005
+		end
+		minetest_sound_play(sound, {
+			object = self.object,
+			gain = 1.0,
+			max_hear_distance = self.sounds.distance,
+			pitch = pitch,
+		}, true)
+		self.opinion_sound_cooloff = 1
+	end
+end
+
+
+local function update_roll(self)
+	local is_Fleckenstein = self.nametag == "Fleckenstein"
+	local was_Fleckenstein = false
+
+	local rot = self.object:get_rotation()
+	rot.z = is_Fleckenstein and math_pi or 0
+	self.object:set_rotation(rot)
+
+	local cbox = table.copy(self.collisionbox)
+	local acbox = self.object:get_properties().collisionbox
+
+	if math_abs(cbox[2] - acbox[2]) > 0.1 then
+		was_Fleckenstein = true
+	end
+
+	if is_Fleckenstein ~= was_Fleckenstein then
+		local pos = self.object:get_pos()
+		pos.y = pos.y + (acbox[2] + acbox[5])
+		self.object:set_pos(pos)
+	end
+
+	if is_Fleckenstein then
+		cbox[2], cbox[5] = -cbox[5], -cbox[2]
+	end
+
+	self.object:set_properties({collisionbox = cbox})
+end
+
+-- check if within physical map limits (-30911 to 30927)
+local within_limits, wmin, wmax = nil, -30913, 30928
+within_limits = function(pos, radius)
+	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
+			within_limits = function(pos, radius)
+				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
+		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
+
+-- is mob facing a cliff or danger
+local is_at_cliff_or_danger = function(self)
+
+	if self.fear_height == 0 then -- 0 for no falling protection!
+		return false
+	end
+
+	if not self.object:get_luaentity() then
+		return false
+	end
+	local yaw = self.object:get_yaw()
+	local dir_x = -math_sin(yaw) * (self.collisionbox[4] + 0.5)
+	local dir_z = math_cos(yaw) * (self.collisionbox[4] + 0.5)
+	local pos = self.object:get_pos()
+	local ypos = pos.y + self.collisionbox[2] -- just above floor
+
+	local free_fall, blocker = minetest_line_of_sight(
+		{x = pos.x + dir_x, y = ypos, z = pos.z + dir_z},
+		{x = pos.x + dir_x, y = ypos - self.fear_height, z = pos.z + dir_z})
+	if free_fall then
+		return true
+	else
+		local bnode = minetest_get_node(blocker)
+		local danger = is_node_dangerous(self, bnode.name)
+		if danger then
+			return true
+		else
+			local def = minetest_registered_nodes[bnode.name]
+			if def and def.walkable then
+				return false
+			end
+		end
+	end
+
+	return false
+end
+
+
+-- copy the 'mob facing cliff_or_danger check' from above, and rework to avoid water
+local is_at_water_danger = function(self)
+
+
+	if not self.object:get_luaentity() then
+		return false
+	end
+	local yaw = self.object:get_yaw()
+	local dir_x = -math_sin(yaw) * (self.collisionbox[4] + 0.5)
+	local dir_z = math_cos(yaw) * (self.collisionbox[4] + 0.5)
+	local pos = self.object:get_pos()
+	local ypos = pos.y + self.collisionbox[2] -- just above floor
+
+	local free_fall, blocker = minetest_line_of_sight(
+		{x = pos.x + dir_x, y = ypos, z = pos.z + dir_z},
+		{x = pos.x + dir_x, y = ypos - 3, z = pos.z + dir_z})
+	if free_fall then
+		return true
+	else
+		local bnode = minetest_get_node(blocker)
+		local waterdanger = is_node_waterhazard(self, bnode.name)
+		if
+			waterdanger and (is_node_waterhazard(self, self.standing_in) or is_node_waterhazard(self, self.standing_on)) then
+			return false
+		elseif waterdanger and (is_node_waterhazard(self, self.standing_in) or is_node_waterhazard(self, self.standing_on)) == false then
+			return true
+		else
+			local def = minetest_registered_nodes[bnode.name]
+			if def and def.walkable then
+				return false
+			end
+		end
+	end
+
+	return false
+end
+
+
+-- get node but use fallback for nil or unknown
+local 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
+
+
+-- environmental damage (water, lava, fire, light etc.)
+local do_env_damage = function(self)
+
+	-- feed/tame text timer (so mob 'full' messages dont spam chat)
+	if self.htimer > 0 then
+		self.htimer = self.htimer - 1
+	end
+
+	-- reset nametag after showing health stats
+	if self.htimer < 1 and self.nametag2 then
+
+		self.nametag = self.nametag2
+		self.nametag2 = nil
+
+		update_tag(self)
+	end
+
+	local pos = self.object:get_pos()
+
+	self.time_of_day = minetest.get_timeofday()
+
+	-- remove mob if beyond map limits
+	if not within_limits(pos, 0) then
+		mcl_burning.extinguish(self.object)
+		self.object:remove()
+		return true
+	end
+
+
+	-- Deal light damage to mob, returns true if mob died
+	local deal_light_damage = function(self, pos, damage)
+		if not (mod_weather and (mcl_weather.rain.raining or mcl_weather.state == "snow") and mcl_weather.is_outdoor(pos)) then
+			self.health = self.health - damage
+
+			effect(pos, 5, "mcl_particles_smoke.png")
+
+			if check_for_death(self, "light", {type = "light"}) then
+				return true
+			end
+		end
+	end
+
+	-- Use get_node_light for Minetest version 5.3 where get_natural_light
+	-- does not exist yet.
+	local get_light = minetest_get_natural_light or minetest_get_node_light
+	local sunlight = get_light(pos, self.time_of_day)
+
+	-- bright light harms mob
+	if self.light_damage ~= 0 and (sunlight or 0) > 12 then
+		if deal_light_damage(self, pos, self.light_damage) then
+			return true
+		end
+	end
+	local _, dim = nil, "overworld"
+	if mod_worlds then
+		_, dim = mcl_worlds.y_to_layer(pos.y)
+	end
+	if (self.sunlight_damage ~= 0 or self.ignited_by_sunlight) and (sunlight or 0) >= minetest.LIGHT_MAX and dim == "overworld" then
+		if self.ignited_by_sunlight then
+			mcl_burning.set_on_fire(self.object, 10)
+		else
+			deal_light_damage(self, pos, self.sunlight_damage)
+			return true
+		end
+	end
+
+	local y_level = self.collisionbox[2]
+
+	if self.child then
+		y_level = self.collisionbox[2] * 0.5
+	end
+
+	-- what is mob standing in?
+	pos.y = pos.y + y_level + 0.25 -- foot level
+	local pos2 = {x=pos.x, y=pos.y-1, z=pos.z}
+	self.standing_in = node_ok(pos, "air").name
+	self.standing_on = node_ok(pos2, "air").name
+
+	-- don't fall when on ignore, just stand still
+	if self.standing_in == "ignore" then
+		self.object:set_velocity({x = 0, y = 0, z = 0})
+	end
+
+	local nodef = minetest_registered_nodes[self.standing_in]
+
+	-- rain
+	if self.rain_damage > 0 and mod_weather then
+		if mcl_weather.rain.raining and mcl_weather.is_outdoor(pos) then
+
+			self.health = self.health - self.rain_damage
+
+			if check_for_death(self, "rain", {type = "environment",
+					pos = pos, node = self.standing_in}) then
+				return true
+			end
+		end
+	end
+
+	pos.y = pos.y + 1 -- for particle effect position
+
+	-- water damage
+	if self.water_damage > 0
+	and nodef.groups.water then
+
+		if self.water_damage ~= 0 then
+
+			self.health = self.health - self.water_damage
+
+			effect(pos, 5, "mcl_particles_smoke.png", nil, nil, 1, nil)
+
+			if check_for_death(self, "water", {type = "environment",
+					pos = pos, node = self.standing_in}) then
+				return true
+			end
+		end
+
+	-- lava damage
+	elseif self.lava_damage > 0
+	and (nodef.groups.lava) then
+
+		if self.lava_damage ~= 0 then
+
+			self.health = self.health - self.lava_damage
+
+			effect(pos, 5, "fire_basic_flame.png", nil, nil, 1, nil)
+
+			if check_for_death(self, "lava", {type = "environment",
+					pos = pos, node = self.standing_in}) then
+				return true
+			end
+		end
+
+	-- fire damage
+	elseif self.fire_damage > 0
+	and (nodef.groups.fire) then
+
+		if self.fire_damage ~= 0 then
+
+			self.health = self.health - self.fire_damage
+
+			effect(pos, 5, "fire_basic_flame.png", nil, nil, 1, nil)
+
+			if check_for_death(self, "fire", {type = "environment",
+					pos = pos, node = self.standing_in}) then
+				return true
+			end
+		end
+
+	-- damage_per_second node check
+	elseif nodef.damage_per_second ~= 0 and not nodef.groups.lava and not nodef.groups.fire then
+
+		self.health = self.health - nodef.damage_per_second
+
+		effect(pos, 5, "mcl_particles_smoke.png")
+
+		if check_for_death(self, "dps", {type = "environment",
+				pos = pos, node = self.standing_in}) then
+			return true
+		end
+	end
+
+	-- Drowning damage
+	if self.breath_max ~= -1 then
+		local drowning = false
+		if self.breathes_in_water then
+			if minetest_get_item_group(self.standing_in, "water") == 0 then
+				drowning = true
+			end
+		elseif nodef.drowning > 0 then
+			drowning = true
+		end
+		if drowning then
+
+			self.breath = math_max(0, self.breath - 1)
+
+			effect(pos, 2, "bubble.png", nil, nil, 1, nil)
+			if self.breath <= 0 then
+				local dmg
+				if nodef.drowning > 0 then
+					dmg = nodef.drowning
+				else
+					dmg = 4
+				end
+				damage_effect(self, dmg)
+				self.health = self.health - dmg
+			end
+			if check_for_death(self, "drowning", {type = "environment",
+					pos = pos, node = self.standing_in}) then
+				return true
+			end
+		else
+			self.breath = math_min(self.breath_max, self.breath + 1)
+		end
+	end
+
+	--- suffocation inside solid node
+	-- FIXME: Redundant with mcl_playerplus
+	if (self.suffocation == true)
+	and (nodef.walkable == nil or nodef.walkable == true)
+	and (nodef.collision_box == nil or nodef.collision_box.type == "regular")
+	and (nodef.node_box == nil or nodef.node_box.type == "regular")
+	and (nodef.groups.disable_suffocation ~= 1)
+	and (nodef.groups.opaque == 1) then
+
+		-- Short grace period before starting to take suffocation damage.
+		-- This is different from players, who take damage instantly.
+		-- This has been done because mobs might briefly be inside solid nodes
+		-- when e.g. climbing up stairs.
+		-- This is a bit hacky because it assumes that do_env_damage
+		-- is called roughly every second only.
+		self.suffocation_timer = self.suffocation_timer + 1
+		if self.suffocation_timer >= 3 then
+			-- 2 damage per second
+			-- TODO: Deal this damage once every 1/2 second
+			self.health = self.health - 2
+
+			if check_for_death(self, "suffocation", {type = "environment",
+					pos = pos, node = self.standing_in}) then
+				return true
+			end
+		end
+	else
+		self.suffocation_timer = 0
+	end
+
+	return check_for_death(self, "", {type = "unknown"})
+end
+
+
+-- jump if facing a solid node (not fences or gates)
+local do_jump = function(self)
+
+	if not self.jump
+	or self.jump_height == 0
+	or self.fly
+	or (self.child and self.type ~= "monster")
+	or self.order == "stand" then
+		return false
+	end
+
+	self.facing_fence = false
+
+	-- something stopping us while moving?
+	if self.state ~= "stand"
+	and get_velocity(self) > 0.5
+	and self.object:get_velocity().y ~= 0 then
+		return false
+	end
+
+	local pos = self.object:get_pos()
+	local yaw = self.object:get_yaw()
+
+	-- what is mob standing on?
+	pos.y = pos.y + self.collisionbox[2] - 0.2
+
+	local nod = node_ok(pos)
+
+	if minetest_registered_nodes[nod.name].walkable == false then
+		return false
+	end
+
+	-- where is front
+	local dir_x = -math_sin(yaw) * (self.collisionbox[4] + 0.5)
+	local dir_z = math_cos(yaw) * (self.collisionbox[4] + 0.5)
+
+	-- what is in front of mob?
+	nod = node_ok({
+		x = pos.x + dir_x,
+		y = pos.y + 0.5,
+		z = pos.z + dir_z
+	})
+
+	-- this is used to detect if there's a block on top of the block in front of the mob.
+	-- If there is, there is no point in jumping as we won't manage.
+	local nodTop = node_ok({
+		x = pos.x + dir_x,
+		y = pos.y + 1.5,
+		z = pos.z + dir_z
+	}, "air")
+
+	-- we don't attempt to jump if there's a stack of blocks blocking
+	if minetest_registered_nodes[nodTop.name].walkable == true then
+		return false
+	end
+
+	-- thin blocks that do not need to be jumped
+	if nod.name == node_snow then
+		return false
+	end
+
+	if self.walk_chance == 0
+	or minetest_registered_items[nod.name].walkable then
+
+		if minetest_get_item_group(nod.name, "fence") == 0
+		and minetest_get_item_group(nod.name, "fence_gate") == 0
+		and minetest_get_item_group(nod.name, "wall") == 0 then
+
+			local v = self.object:get_velocity()
+
+			v.y = self.jump_height
+
+			set_animation(self, "jump") -- only when defined
+
+			self.object:set_velocity(v)
+
+			-- when in air move forward
+			minetest_after(0.3, function(self, v)
+				if (not self.object) or (not self.object:get_luaentity()) or (self.state == "die") then
+					return
+				end
+				self.object:set_acceleration({
+					x = v.x * 2,
+					y = -10,
+					z = v.z * 2,
+				})
+			end, self, v)
+
+			if self.jump_sound_cooloff <= 0 then
+				mob_sound(self, "jump")
+				self.jump_sound_cooloff = 0.5
+			end
+		else
+			self.facing_fence = true
+		end
+
+		-- if we jumped against a block/wall 4 times then turn
+		if self.object:get_velocity().x ~= 0
+		and self.object:get_velocity().z ~= 0 then
+
+			self.jump_count = (self.jump_count or 0) + 1
+
+			if self.jump_count == 4 then
+
+				local yaw = self.object:get_yaw() or 0
+
+				yaw = set_yaw(self, yaw + 1.35, 8)
+
+				self.jump_count = 0
+			end
+		end
+
+		return true
+	end
+
+	return false
+end
+
+
+-- blast damage to entities nearby
+local entity_physics = function(pos, radius)
+
+	radius = radius * 2
+
+	local objs = minetest_get_objects_inside_radius(pos, radius)
+	local obj_pos, dist
+
+	for n = 1, #objs do
+
+		obj_pos = objs[n]:get_pos()
+
+		dist = vector.distance(pos, obj_pos)
+		if dist < 1 then dist = 1 end
+
+		local damage = math_floor((4 / dist) * radius)
+		local ent = objs[n]:get_luaentity()
+
+		-- punches work on entities AND players
+		objs[n]:punch(objs[n], 1.0, {
+			full_punch_interval = 1.0,
+			damage_groups = {fleshy = damage},
+		}, pos)
+	end
+end
+
+
+-- should mob follow what I'm holding ?
+local follow_holding = function(self, clicker)
+
+	if mobs.invis[clicker:get_player_name()] then
+		return false
+	end
+
+	local item = clicker:get_wielded_item()
+	local t = type(self.follow)
+
+	-- single item
+	if t == "string"
+	and item:get_name() == self.follow then
+		return true
+
+	-- multiple items
+	elseif t == "table" then
+
+		for no = 1, #self.follow do
+
+			if self.follow[no] == item:get_name() then
+				return true
+			end
+		end
+	end
+
+	return false
+end
+
+
+-- find two animals of same type and breed if nearby and horny
+local breed = function(self)
+
+	-- child takes a long time before growing into adult
+	if self.child == true then
+
+		-- When a child, hornytimer is used to count age until adulthood
+		self.hornytimer = self.hornytimer + 1
+
+		if self.hornytimer >= CHILD_GROW_TIME then
+
+			self.child = false
+			self.hornytimer = 0
+
+			self.object:set_properties({
+				textures = self.base_texture,
+				mesh = self.base_mesh,
+				visual_size = self.base_size,
+				collisionbox = self.base_colbox,
+				selectionbox = self.base_selbox,
+			})
+
+			-- custom function when child grows up
+			if self.on_grown then
+				self.on_grown(self)
+			else
+				-- jump when fully grown so as not to fall into ground
+				self.object:set_velocity({
+					x = 0,
+					y = self.jump_height,
+					z = 0
+				})
+			end
+		end
+
+		return
+	end
+
+	-- horny animal can mate for BREED_TIME seconds,
+	-- afterwards horny animal cannot mate again for BREED_TIME_AGAIN seconds
+	if self.horny == true
+	and self.hornytimer < BREED_TIME + BREED_TIME_AGAIN then
+
+		self.hornytimer = self.hornytimer + 1
+
+		if self.hornytimer >= BREED_TIME + BREED_TIME_AGAIN then
+			self.hornytimer = 0
+			self.horny = false
+		end
+	end
+
+	-- find another same animal who is also horny and mate if nearby
+	if self.horny == true
+	and self.hornytimer <= BREED_TIME then
+
+		local pos = self.object:get_pos()
+
+		effect({x = pos.x, y = pos.y + 1, z = pos.z}, 8, "heart.png", 3, 4, 1, 0.1)
+
+		local objs = minetest_get_objects_inside_radius(pos, 3)
+		local num = 0
+		local ent = nil
+
+		for n = 1, #objs do
+
+			ent = objs[n]:get_luaentity()
+
+			-- check for same animal with different colour
+			local canmate = false
+
+			if ent then
+
+				if ent.name == self.name then
+					canmate = true
+				else
+					local entname = string.split(ent.name,":")
+					local selfname = string.split(self.name,":")
+
+					if entname[1] == selfname[1] then
+						entname = string.split(entname[2],"_")
+						selfname = string.split(selfname[2],"_")
+
+						if entname[1] == selfname[1] then
+							canmate = true
+						end
+					end
+				end
+			end
+
+			if ent
+			and canmate == true
+			and ent.horny == true
+			and ent.hornytimer <= BREED_TIME then
+				num = num + 1
+			end
+
+			-- found your mate? then have a baby
+			if num > 1 then
+
+				self.hornytimer = BREED_TIME + 1
+				ent.hornytimer = BREED_TIME + 1
+
+				-- spawn baby
+				minetest_after(5, function(parent1, parent2, pos)
+					if not parent1.object:get_luaentity() then
+						return
+					end
+					if not parent2.object:get_luaentity() then
+						return
+					end
+
+					-- Give XP
+					if mod_experience then
+						mcl_experience.throw_experience(pos, math_random(1, 7))
+					end
+
+					-- custom breed function
+					if parent1.on_breed then
+						-- when false, skip going any further
+						if parent1.on_breed(parent1, parent2) == false then
+							return
+						end
+					end
+
+					local child = mobs:spawn_child(pos, parent1.name)
+
+					local ent_c = child:get_luaentity()
+
+
+					-- Use texture of one of the parents
+					local p = math_random(1, 2)
+					if p == 1 then
+						ent_c.base_texture = parent1.base_texture
+					else
+						ent_c.base_texture = parent2.base_texture
+					end
+					child:set_properties({
+						textures = ent_c.base_texture
+					})
+
+					-- tamed and owned by parents' owner
+					ent_c.tamed = true
+					ent_c.owner = parent1.owner
+				end, self, ent, pos)
+
+				num = 0
+
+				break
+			end
+		end
+	end
+end
+
+-- find and replace what mob is looking for (grass, wheat etc.)
+local replace = function(self, pos)
+
+	if not self.replace_rate
+	or not self.replace_what
+	or self.child == true
+	or self.object:get_velocity().y ~= 0
+	or math_random(1, self.replace_rate) > 1 then
+		return
+	end
+
+	local what, with, y_offset
+
+	if type(self.replace_what[1]) == "table" then
+
+		local num = math_random(#self.replace_what)
+
+		what = self.replace_what[num][1] or ""
+		with = self.replace_what[num][2] or ""
+		y_offset = self.replace_what[num][3] or 0
+	else
+		what = self.replace_what
+		with = self.replace_with or ""
+		y_offset = self.replace_offset or 0
+	end
+
+	pos.y = pos.y + y_offset
+
+	local node = minetest_get_node(pos)
+	if node.name == what then
+
+		local oldnode = {name = what, param2 = node.param2}
+		local newnode = {name = with, param2 = node.param2}
+		local on_replace_return
+
+		if self.on_replace then
+			on_replace_return = self.on_replace(self, pos, oldnode, newnode)
+		end
+
+		if on_replace_return ~= false then
+
+			if mobs_griefing then
+				minetest_set_node(pos, newnode)
+			end
+
+		end
+	end
+end
+
+
+-- check if daytime and also if mob is docile during daylight hours
+local day_docile = function(self)
+
+	if self.docile_by_day == false then
+
+		return false
+
+	elseif self.docile_by_day == true
+	and self.time_of_day > 0.2
+	and self.time_of_day < 0.8 then
+
+		return true
+	end
+end
+
+
+-- deal damage and effects when mob punched
+local mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
+
+	-- 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
+
+	-- error checking when mod profiling is enabled
+	if not tool_capabilities then
+		minetest.log("warning", "[mobs] Mod profiling enabled, damage not enabled")
+		return
+	end
+
+	local is_player = hitter:is_player()
+
+	if is_player then
+		-- is mob protected?
+		if self.protected and minetest_is_protected(self.object:get_pos(), hitter:get_player_name()) then
+			return
+		end
+
+		-- set/update 'drop xp' timestamp if hitted by player
+		self.xp_timestamp = minetest_get_us_time()
+	end
+
+
+	-- 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 {}
+	local tmp
+
+	-- quick error check incase it ends up 0 (serialize.h check test)
+	if tflp == 0 then
+		tflp = 0.2
+	end
+
+	if use_cmi then
+		damage = cmi.calculate_damage(self.object, hitter, tflp, tool_capabilities, dir)
+	else
+
+		for group,_ in pairs( (tool_capabilities.damage_groups or {}) ) do
+
+			tmp = tflp / (tool_capabilities.full_punch_interval or 1.4)
+
+			if tmp < 0 then
+				tmp = 0.0
+			elseif tmp > 1 then
+				tmp = 1.0
+			end
+
+			damage = damage + (tool_capabilities.damage_groups[group] or 0)
+				* tmp * ((armor[group] or 0) / 100.0)
+		end
+	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 use_cmi then
+
+		local cancel =  cmi.notify_punch(self.object, hitter, tflp, tool_capabilities, dir, damage)
+
+		if cancel then return end
+	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)
+	if minetest_is_creative_enabled("") ~= true
+	and 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
+
+	local die = false
+
+	-- 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
+
+		-- weapon sounds
+		if weapon:get_definition().sounds ~= nil then
+
+			local s = math_random(0, #weapon:get_definition().sounds)
+
+			minetest_sound_play(weapon:get_definition().sounds[s], {
+				object = self.object, --hitter,
+				max_hear_distance = 8
+			}, true)
+		else
+			minetest_sound_play("default_punch", {
+				object = self.object,
+				max_hear_distance = 5
+			}, true)
+		end
+
+		damage_effect(self, damage)
+
+		-- do damage
+		self.health = self.health - damage
+
+		-- skip future functions if dead, except alerting others
+		if check_for_death(self, "hit", {type = "punch", puncher = hitter}) then
+			die = true
+		end
+
+		-- knock back effect (only on full punch)
+		if not die
+		and self.knock_back
+		and tflp >= punch_interval then
+
+			local v = self.object:get_velocity()
+			local r = 1.4 - math_min(punch_interval, 1.4)
+			local kb = r * 2.0
+			local up = 2
+
+			-- if already in air then dont go up anymore when hit
+			if v.y ~= 0
+			or self.fly then
+				up = 0
+			end
+
+			-- direction error check
+			dir = dir or {x = 0, y = 0, z = 0}
+
+			-- check if tool already has specific knockback value
+			if tool_capabilities.damage_groups["knockback"] then
+				kb = tool_capabilities.damage_groups["knockback"]
+			else
+				kb = kb * 1.5
+			end
+
+
+			local luaentity
+			if hitter then
+				luaentity = hitter:get_luaentity()
+			end
+			if hitter and is_player then
+				local wielditem = hitter:get_wielded_item()
+				kb = kb + 3 * mcl_enchanting.get_enchantment(wielditem, "knockback")
+			elseif luaentity and luaentity._knockback then
+				kb = kb + luaentity._knockback
+			end
+
+			self.object:set_velocity({
+				x = dir.x * kb,
+				y = dir.y * kb + up * 2,
+				z = dir.z * kb
+			})
+
+			self.pause_timer = 0.25
+		end
+	end -- END if damage
+
+	-- if skittish then run away
+	if not die and self.runaway == true and self.state ~= "flop" then
+
+		local lp = hitter:get_pos()
+		local s = self.object:get_pos()
+		local vec = {
+			x = lp.x - s.x,
+			y = lp.y - s.y,
+			z = lp.z - s.z
+		}
+
+		local yaw = (atan(vec.z / vec.x) + 3 * math_pi / 2) - self.rotate
+
+		if lp.x > s.x then
+			yaw = yaw + math_pi
+		end
+
+		yaw = set_yaw(self, yaw, 6)
+		self.state = "runaway"
+		self.runaway_timer = 0
+		self.following = nil
+	end
+
+	local name = hitter:get_player_name() or ""
+
+	-- attack puncher and call other mobs for help
+	if self.passive == false
+	and self.state ~= "flop"
+	and (self.child == false or self.type == "monster")
+	and hitter:get_player_name() ~= self.owner
+	and not mobs.invis[ name ] then
+
+		if not die then
+			-- attack whoever punched mob
+			self.state = ""
+			do_attack(self, hitter)
+		end
+
+		-- alert others to the attack
+		local objs = minetest_get_objects_inside_radius(hitter:get_pos(), self.view_range)
+		local obj = nil
+
+		for n = 1, #objs do
+
+			obj = objs[n]:get_luaentity()
+
+			if obj then
+
+				-- only alert members of same mob or friends
+				if obj.group_attack
+				and obj.state ~= "attack"
+				and obj.owner ~= name then
+					if obj.name == self.name then
+						do_attack(obj, hitter)
+					elseif type(obj.group_attack) == "table" then
+						for i=1, #obj.group_attack do
+							if obj.name == obj.group_attack[i] then
+								do_attack(obj, hitter)
+								break
+							end
+						end
+					end
+				end
+
+				-- have owned mobs attack player threat
+				if obj.owner == name and obj.owner_loyal then
+					do_attack(obj, self.object)
+				end
+			end
+		end
+	end
+end
+
+local mob_detach_child = function(self, child)
+
+	if self.driver == child then
+		self.driver = nil
+	end
+
+end
\ No newline at end of file