Improve danger avoidance code.

fix and optimize Fleckenstein
small code cleanups
2024-10-27 19:25:29 +01:00 · 2024-10-27 19:25:29 +01:00 · 2024-10-27 19:25:29 +01:00 · 2024-10-27 19:25:29 +01:00 · 2024-10-27 19:25:29 +01:00 · 2024-10-27 19:24:40 +01:00
21 changed files with 933 additions and 1886 deletions
--- a/mods/ENTITIES/mcl_mobs/api.lua
+++ b/mods/ENTITIES/mcl_mobs/api.lua
@ -1,29 +1,24 @@
 local mob_class = mcl_mobs.mob_class
 local mob_class_meta = {__index = mcl_mobs.mob_class}
 local math, vector, minetest, mcl_mobs = math, vector, minetest, mcl_mobs
-- API for Mobs Redo: VoxeLibre Edition

 local PATHFINDING = "gowp"
 local CRASH_WARN_FREQUENCY = 60
 local LIFETIMER_DISTANCE = 47
+local MAPGEN_LIMIT = mcl_vars.mapgen_limit
+local MAPGEN_MOB_LIMIT = MAPGEN_LIMIT - 90
+-- 30927 seems to be the edge of the world, so could be closer, but this is safer

-- Localize
 local S = minetest.get_translator("mcl_mobs")

-local DEVELOPMENT = minetest.settings:get_bool("mcl_development",false)
-
 -- Invisibility mod check
 mcl_mobs.invis = {}

 local remove_far = true

 local mobs_debug = minetest.settings:get_bool("mobs_debug", false) -- Shows helpful debug info above each mob
-local spawn_logging = minetest.settings:get_bool("mcl_logging_mobs_spawn", false)
-
-local MAPGEN_LIMIT = mcl_vars.mapgen_limit
-local MAPGEN_MOB_LIMIT = MAPGEN_LIMIT - 90
-- 30927 seems to be the edge of the world, so could be closer, but this is safer
-
+local spawn_logging = minetest.settings:get_bool("mcl_logging_mobs_spawn", true)
+local DEVELOPMENT = minetest.settings:get_bool("mcl_development", false)

 -- Peaceful mode message so players will know there are no monsters
 if minetest.settings:get_bool("only_peaceful_mobs", false) then
@ -36,10 +31,7 @@ end
 function mob_class:update_tag() --update nametag and/or the debug box
 	local tag
 	if mobs_debug then
-		local name = self.name
-		if self.nametag and self.nametag ~= "" then
-			name = self.nametag
-		end
+		local name = self.nametag ~= "" and self.nametag or self.name
 		tag = "name = '"..tostring(name).."'\n"..
 		"state = '"..tostring(self.state).."'\n"..
 		"order = '"..tostring(self.order).."'\n"..
@ -56,9 +48,7 @@ function mob_class:update_tag() --update nametag and/or the debug box
 	else
 		tag = self.nametag
 	end
-	self.object:set_properties({
-		nametag = tag,
-	})
+	self.object:set_properties({ nametag = tag })
 end

 function mob_class:jock_to(mob, reletive_pos, rot)
@ -74,19 +64,15 @@ function mob_class:jock_to(mob, reletive_pos, rot)
 end

 function mob_class:get_staticdata()
-
 	for _,p in pairs(minetest.get_connected_players()) do
 		self:remove_particlespawners(p:get_player_name())
 	end

 	-- remove mob when out of range unless tamed
-	if remove_far
-	and self:despawn_allowed()
-	and self.lifetimer <= 20 then
+	if remove_far and self:despawn_allowed() and self.lifetimer <= 20 then
 		if spawn_logging then
 			minetest.log("action", "[mcl_mobs] Mob "..tostring(self.name).." despawns at "..minetest.pos_to_string(vector.round(self.object:get_pos())) .. " - out of range")
 		end
-
 		return "remove"-- nil
 	end

@ -95,17 +81,9 @@ function mob_class:get_staticdata()
 	self.state = "stand"

 	local tmp = {}
-
 	for tag, stat in pairs(self) do
-
 		local t = type(stat)
-
-		if  t ~= "function"
-		and t ~= "nil"
-		and t ~= "userdata"
-		and tag ~= "_cmi_components" then
-			tmp[tag] = self[tag]
-		end
+		if  t ~= "function" and t ~= "nil" and t ~= "userdata" and tag ~= "_cmi_components" then tmp[tag] = self[tag] end
 	end

 	tmp._mcl_potions = self._mcl_potions
@ -120,10 +98,7 @@ function mob_class:get_staticdata()
 end

 local function valid_texture(self, def_textures)
-	if not self.base_texture then
-		return false
-	end
-
+	if not self.base_texture then return false end
 	if self.texture_selected then
 		if #def_textures < self.texture_selected then
 			self.texture_selected = nil
@ -148,32 +123,18 @@ function mob_class:mob_activate(staticdata, def, dtime)
 	end

 	local tmp = minetest.deserialize(staticdata)
-
 	if tmp then
 		-- Patch incorrectly converted mobs
-		if tmp.base_mesh ~= minetest.registered_entities[self.name].mesh then
-			mcl_mobs.strip_staticdata(tmp)
-		end
-
-		for _,stat in pairs(tmp) do
-			self[_] = stat
-		end
+		if tmp.base_mesh ~= minetest.registered_entities[self.name].mesh then mcl_mobs.strip_staticdata(tmp) end
+		for _, stat in pairs(tmp) do self[_] = stat end
 	end

 	--If textures in definition change, reload textures
 	if not valid_texture(self, def.textures) then
-
 		-- compatiblity with old simple mobs textures
-		if type(def.textures[1]) == "string" then
-			def.textures = {def.textures}
-		end
-
-		if not self.texture_selected then
-			local c = 1
-			if #def.textures > c then c = #def.textures end
-			self.texture_selected = math.random(c)
-		end
+		if type(def.textures[1]) == "string" then def.textures = {def.textures} end

+		self.texture_selected = self.texture_selected or math.random(#def.textures)
 		self.base_texture = def.textures[self.texture_selected]
 		self.base_mesh = def.mesh
 		self.base_size = self.visual_size
@ -181,9 +142,7 @@ function mob_class:mob_activate(staticdata, def, dtime)
 		self.base_selbox = self.selectionbox
 	end

-	if not self.base_selbox then
-		self.base_selbox = self.selectionbox or self.base_colbox
-	end
+	self.base_selbox = self.base_selbox or self.selectionbox or self.base_colbox

 	local textures = self.base_texture
 	local mesh = self.base_mesh
@ -191,26 +150,11 @@ function mob_class:mob_activate(staticdata, def, dtime)
 	local colbox = self.base_colbox
 	local selbox = self.base_selbox

-	if self.gotten == true
-	and def.gotten_texture then
-		textures = def.gotten_texture
-	end
-
-	if self.gotten == true
-	and def.gotten_mesh then
-		mesh = def.gotten_mesh
-	end
-
+	if self.gotten == true and def.gotten_texture then textures = def.gotten_texture end
+	if self.gotten == true and def.gotten_mesh then mesh = def.gotten_mesh end
 	if self.child == true then
-
-		vis_size = {
-			x = self.base_size.x * .5,
-			y = self.base_size.y * .5,
-		}
-
-		if def.child_texture then
-			textures = def.child_texture[1]
-		end
+		vis_size = { x = self.base_size.x * .5, y = self.base_size.y * .5 }
+		if def.child_texture then textures = def.child_texture[1] end

 		colbox = {
 			self.base_colbox[1] * .5,
@ -230,16 +174,12 @@ function mob_class:mob_activate(staticdata, def, dtime)
 		}
 	end

-	if self.health == 0 then
-		self.health = math.random (self.hp_min, self.hp_max)
-	end
-	if self.breath == nil then
-		self.breath = self.breath_max
-	end
+	if self.health == 0 then self.health = math.random(self.hp_min, self.hp_max) end
+	if self.breath == nil then self.breath = self.breath_max end

 	self.path = {}
 	self.path.way = {} -- path to follow, table of positions
-	self.path.lastpos = {x = 0, y = 0, z = 0}
+	self.path.lastpos = vector.zero()
 	self.path.stuck = false
 	self.path.following = false -- currently following path?
 	self.path.stuck_timer = 0 -- if stuck for too long search for path
@ -276,42 +216,22 @@ function mob_class:mob_activate(staticdata, def, dtime)
 	self.blinktimer = 0
 	self.blinkstatus = false

-	if not self.nametag then
-		self.nametag = def.nametag
-	end
-	if not self.custom_visual_size then
-		self.visual_size = nil
-		self.base_size = self.visual_size
-		if self.child then
-			self.visual_size = {
-				x = self.visual_size.x * 0.5,
-				y = self.visual_size.y * 0.5,
-			}
-		end
-	end
+	self.nametag = self.nametag or def.nametag

 	self.object:set_properties(self)
-	self:set_yaw( (math.random(0, 360) - 180) / 180 * math.pi, 6)
+	self:set_yaw(math.random() * math.pi * 2, 6)
 	self:update_tag()
 	self._current_animation = nil
-	self:set_animation( "stand")
+	self:set_animation("stand")

-
-	if self.riden_by_jock then --- Keep this function before self.on_spawn() is run.
+	if self.riden_by_jock then --- Keep this function before self:on_spawn()
 		self.object:remove()
 		return
 	end

+	if self.on_spawn and not self.on_spawn_run and self:on_spawn() then self.on_spawn_run = true end

-	if self.on_spawn and not self.on_spawn_run then
-		if self.on_spawn(self) then
-			self.on_spawn_run = true
-		end
-	end
-
-	if not self.wears_armor and self.armor_list then
-		self.armor_list = nil
-	end
+	if not self.wears_armor and self.armor_list then self.armor_list = nil end

 	if not self._run_armor_init and self.wears_armor then
 		self.armor_list={helmet="",chestplate="",boots="",leggings=""}
@ -319,15 +239,10 @@ function mob_class:mob_activate(staticdata, def, dtime)
 		self._run_armor_init = true
 	end

-	if not self._mcl_potions then
-		self._mcl_potions = {}
-	end
+	if not self._mcl_potions then self._mcl_potions = {} end
 	mcl_potions._load_entity_effects(self)

-
-	if def.after_activate then
-		def.after_activate(self, staticdata, def, dtime)
-	end
+	if def.after_activate then def.after_activate(self, staticdata, def, dtime) end
 end

 -- execute current state (stand, walk, run, attacks)
@ -346,9 +261,7 @@ function mob_class:do_states(dtime, player_in_active_range)
 	if self.state == PATHFINDING then
 		self:check_gowp(dtime)
 	elseif self.state == "attack" then
-		if self:do_states_attack(dtime) then
-			return true
-		end
+		if self:do_states_attack(dtime) then return true end
 	else
 		if mcl_util.check_dtime_timer(self, dtime, "onstep_dostates", 1) then
 			if self.state == "stand" then
@ -364,34 +277,28 @@ end

 function mob_class:outside_limits()
 	local pos = self.object:get_pos()
-	if pos then
-		local posx = math.abs(pos.x)
-		local posy = math.abs(pos.y)
-		local posz = math.abs(pos.z)
-		if posx > MAPGEN_MOB_LIMIT or posy > MAPGEN_MOB_LIMIT or posz > MAPGEN_MOB_LIMIT then
-			--minetest.log("action", "Getting close to limits of worldgen: " .. minetest.pos_to_string(pos))
-			if posx > MAPGEN_LIMIT or posy > MAPGEN_LIMIT or posz > MAPGEN_LIMIT then
-				minetest.log("action", "Warning mob past limits of worldgen: " .. minetest.pos_to_string(pos))
-			else
-				if self.state ~= "stand" then
-					minetest.log("action", "Warning mob close to limits of worldgen: " .. minetest.pos_to_string(pos))
-					self.state = "stand"
-					self:set_animation("stand")
-					self.object:set_acceleration(vector.zero())
-					self.object:set_velocity(vector.zero())
-				end
+	if not pos then return end
+	local posx, posy, posz = math.abs(pos.x), math.abs(pos.y), math.abs(pos.z)
+	if posx > MAPGEN_MOB_LIMIT or posy > MAPGEN_MOB_LIMIT or posz > MAPGEN_MOB_LIMIT then
+		--minetest.log("action", "Getting close to limits of worldgen: " .. minetest.pos_to_string(pos))
+		if posx > MAPGEN_LIMIT or posy > MAPGEN_LIMIT or posz > MAPGEN_LIMIT then
+			minetest.log("action", "Warning mob past limits of worldgen: " .. minetest.pos_to_string(pos))
+		else
+			if self.state ~= "stand" then
+				minetest.log("action", "Warning mob close to limits of worldgen: " .. minetest.pos_to_string(pos))
+				self.state = "stand"
+				self:set_animation("stand")
+				self.object:set_acceleration(vector.zero())
+				self.object:set_velocity(vector.zero())
 			end
-			return true
 		end
+		return true
 	end
 end

-
-
 local function on_step_work(self, dtime, moveresult)
 	local pos = self.object:get_pos()
 	if not pos then return end
-
 	if self:check_despawn(pos, dtime) then return true end
 	if self:outside_limits() then return end

@ -403,29 +310,20 @@ local function on_step_work(self, dtime, moveresult)
 	end

 	if self:falling(pos, moveresult) then return end
-	if self:step_damage (dtime, pos) then return end
+	if self:step_damage(dtime, pos) then return end

 	if self.state == "die" then return end
 	-- End: Death/damage processing

 	local player_in_active_range = self:player_in_active_range()
 	self:check_suspend(player_in_active_range)
-
 	self:check_water_flow()
-
-	if not self._jumping_cliff then
-		self._can_jump_cliff = self:can_jump_cliff()
-	else
-		self._can_jump_cliff = false
-	end
-
+	self._can_jump_cliff = not self._jumping_cliff and self:can_jump_cliff()
 	self:flop()
-
 	self:check_smooth_rotation(dtime)

 	if player_in_active_range then
 		self:set_animation_speed() -- set animation speed relative to velocity
-
 		self:check_head_swivel(dtime)

 		if mcl_util.check_dtime_timer(self, dtime, "onstep_engage", 0.2) then
@ -442,91 +340,68 @@ local function on_step_work(self, dtime, moveresult)
 	end

 	if mcl_util.check_dtime_timer(self, dtime, "onstep_occassional", 1) then
-
 		if player_in_active_range then
 			self:check_item_pickup()
 			self:set_armor_texture()
 			self:step_opinion_sound(dtime)
 		end
-
 		self:check_breeding()
 	end

 	self:check_aggro(dtime)
-
 	self:check_particlespawners(dtime)
-
 	if self.do_custom and self.do_custom(self, dtime) == false then return end
-
 	if self:do_states(dtime, player_in_active_range) then return end
-
 	if mobs_debug then self:update_tag() end
-
-	if not self.object:get_luaentity() then
-		return false
-	end
+	if not self.object:get_luaentity() then return false end
 end

 local last_crash_warn_time = 0

-local function log_error (stack_trace, info, info2)
+local function log_error(stack_trace, info, info2)
 	minetest.log("action", "--- Bug report start (please provide a few lines before this also for context) ---")
 	minetest.log("action", "Error: " .. stack_trace)
 	minetest.log("action", "Bug info: " .. info)
-	if info2 then
-		minetest.log("action", "Bug info additional: " .. info2)
-	end
+	if info2 then minetest.log("action", "Bug info additional: " .. info2) end
 	minetest.log("action", "--- Bug report end ---")
 end

 local function warn_user_error ()
 	local current_time = os.time()
 	local time_since_warning = current_time - last_crash_warn_time
-
 	--minetest.log("previous_crash_time: " .. current_time)
 	--minetest.log("last_crash_time: " .. last_crash_warn_time)
 	--minetest.log("time_since_warning: " .. time_since_warning)
-
 	if time_since_warning > CRASH_WARN_FREQUENCY then
 		last_crash_warn_time = current_time
 		minetest.log("A game crashing bug was prevented. Please provide debug.log information to VoxeLibre dev team for investigation. (Search for: --- Bug report start)")
 	end
 end

-local on_step_error_handler = function ()
-	warn_user_error ()
+local on_step_error_handler = function()
+	warn_user_error()
 	local info = debug.getinfo(1, "SnlufL")
 	log_error(tostring(debug.traceback()), dump(info))
 end

-
-
 -- main mob function
 function mob_class:on_step(dtime, moveresult)
-	if not DEVELOPMENT then
-		-- Removed as bundled Lua (5.1 doesn't support xpcall)
-		--local status, retVal = xpcall(on_step_work, on_step_error_handler, self, dtime)
-		local status, retVal = pcall(on_step_work, self, dtime, moveresult)
-		if status then
-			return retVal
-		else
-			warn_user_error ()
-			local pos = self.object:get_pos()
-			if pos then
-				local node = minetest.get_node(pos)
-				if node and node.name == "ignore" then
-					minetest.log("warning", "Pos is ignored: " .. dump(pos))
-				end
-			end
-			log_error (dump(retVal), dump(pos), dump(self))
-		end
-	else
-		return on_step_work (self, dtime, moveresult)
+	-- allow crash in development mode
+	if DEVELOPMENT then return on_step_work(self, dtime, moveresult) end
+	-- Removed as bundled Lua (5.1 doesn't support xpcall)
+	--local status, retVal = xpcall(on_step_work, on_step_error_handler, self, dtime)
+	local status, retVal = pcall(on_step_work, self, dtime, moveresult)
+	if status then return retVal end
+	warn_user_error()
+	local pos = self.object:get_pos()
+	if pos then
+		local node = minetest.get_node(pos)
+		if node and node.name == "ignore" then minetest.log("warning", "Pos is ignored: " .. dump(pos)) end
 	end
+	log_error(dump(retVal), dump(pos), dump(self))
 end

 local timer = 0
-
 local function update_lifetimer(dtime)
 	timer = timer + dtime
 	if timer < 1 then return end
@ -547,7 +422,6 @@ minetest.register_globalstep(function(dtime)
 	update_lifetimer(dtime)
 end)

-
 minetest.register_chatcommand("clearmobs", {
 	privs = { maphack = true },
 	params = "[all|monster|passive|<mob name> [<range>|nametagged|tamed]]",
@ -560,11 +434,7 @@ minetest.register_chatcommand("clearmobs", {
 					S("Default usage. Clearing hostile mobs. For more options please type: /help clearmobs"))
 		end
 		local mob, unsafe = param:match("^([%w]+)[ ]?([%w%d]*)$")
-
-		local all = false
-		local nametagged = false
-		local tamed = false
-
+		local all, nametagged, tamed = false, false, false
 		local mob_name, mob_type, range

 		-- Param 1 resolve
@ -578,12 +448,7 @@ minetest.register_chatcommand("clearmobs", {
 			end
 			--minetest.log ("mob: [" .. mob .. "]")
 		else
-			--minetest.log("No valid first param")
-			if default then
-				--minetest.log("Use default")
-				mob_type = "monster"
-			end
-			--return
+			if default then mob_type = "monster" end
 		end

 		-- Param 2 resolve
@ -600,7 +465,6 @@ minetest.register_chatcommand("clearmobs", {
 		end

 		local p = minetest.get_player_by_name(player)
-
 		for _,o in pairs(minetest.luaentities) do
 			if o and o.is_mob then
 				local mob_match = false
@ -609,7 +473,6 @@ minetest.register_chatcommand("clearmobs", {
 					--minetest.log("Match - All mobs specified")
 					mob_match = true
 				elseif mob_type then
-
 					--minetest.log("Match - o.type: ".. tostring(o.type))
 					--minetest.log("mob_type: ".. tostring(mob_type))
 					if mob_type == "monster" and o.type == mob_type then
@ -621,7 +484,6 @@ minetest.register_chatcommand("clearmobs", {
 					else
 						--minetest.log("No match for type.")
 					end
-
 				elseif mob_name and (o.name == mob_name or string.find(o.name, mob_name)) then
 					--minetest.log("Match - mob_name = ".. tostring(o.name))
 					mob_match = true
@ -632,35 +494,16 @@ minetest.register_chatcommand("clearmobs", {
 				end

 				if mob_match then
-					local in_range = true
-					if (not range or range <= 0 ) then
-						in_range = true
-					else
-						if ( vector.distance(p:get_pos(),o.object:get_pos()) <= range ) then
-							in_range = true
-						else
-							--minetest.log("Out of range")
-							in_range = false
-						end
-					end
-
-					--minetest.log("o.nametag: ".. tostring(o.nametag))
-
+					local in_range = (not range or range <= 0) or vector.distance(p:get_pos(), o.object:get_pos()) <= range
 					if nametagged then
-						if o.nametag then
-							--minetest.log("Namedtagged and it has a name tag. Kill it")
-							o.object:remove()
-						end
+						if o.nametag then o.object:remove() end
 					elseif tamed then
-						if o.tamed then
-							--minetest.log("Tamed. Kill it")
-							o.object:remove()
-						end
+						if o.tamed then o.object:remove() end
 					elseif in_range and (not o.nametag or o.nametag == "") and not o.tamed then
-						--minetest.log("No nametag or tamed. Kill it")
 						o.object:remove()
 					end
 				end
 			end
 		end
-end})
+	end
+})
--- a/mods/ENTITIES/mcl_mobs/breeding.lua
+++ b/mods/ENTITIES/mcl_mobs/breeding.lua
@ -105,7 +105,7 @@ end

 -- Spawn a child
 function mcl_mobs.spawn_child(pos, mob_type)
-	local child = mcl_mobs.spawn(pos, mob_type)
+	local child = minetest.add_entity(pos, mob_type)
 	if not child then
 		return
 	end
--- a/mods/ENTITIES/mcl_mobs/combat.lua
+++ b/mods/ENTITIES/mcl_mobs/combat.lua
@ -11,39 +11,30 @@ local stuck_path_timeout = 10 -- how long will mob follow path before giving up
 local enable_pathfinding = true

 local TIME_TO_FORGET_TARGET = 15
-
-local atann = math.atan
-local function atan(x)
-	if not x or x ~= x then
-		return 0
-	else
-		return atann(x)
-	end
-end
-
+local PI = math.pi
+local HALFPI = PI * 0.5
+local random = math.random
+local min = math.min
+local floor = math.floor
+local ceil = math.ceil
+local abs = math.abs
+local cos = math.cos
+local sin = math.sin
+local atan2 = math.atan2
+local vector_offset = vector.offset
+local vector_new = vector.new
+local vector_copy = vector.copy
+local vector_distance = vector.distance

 -- check if daytime and also if mob is docile during daylight hours
 function mob_class:day_docile()
-	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
+	return self.docile_by_day == true and self.time_of_day > 0.2 and self.time_of_day < 0.8
 end

 -- get this mob to attack the object
 function mob_class:do_attack(object)
-
-	if self.state == "attack" or self.state == "die" then
-		return
-	end
-
-
-	if object:is_player() and not minetest.settings:get_bool("enable_damage") then
-		return
-	end
+	if self.state == "attack" or self.state == "die" then return end
+	if object:is_player() and not minetest.settings:get_bool("enable_damage") then return end

 	self.attack = object
 	self.state = "attack"
@ -55,21 +46,18 @@ function mob_class:do_attack(object)
 end

 -- blast damage to entities nearby
-local function entity_physics(pos,radius)
-
+local function entity_physics(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)
+		dist = vector_distance(pos, obj_pos)
 		if dist < 1 then dist = 1 end

-		local damage = math.floor((4 / dist) * radius)
+		local damage = floor((4 / dist) * radius)
 		local ent = objs[n]:get_luaentity()

 		-- punches work on entities AND players
@ -87,75 +75,57 @@ local height_switcher = false

 -- path finding and smart mob routine by rnd, line_of_sight and other edits by Elkien3
 function mob_class:smart_mobs(s, p, dist, dtime)
-
 	local s1 = self.path.lastpos
-
 	local target_pos = self.attack:get_pos()

 	-- is it becoming stuck?
-	if math.abs(s1.x - s.x) + math.abs(s1.z - s.z) < .5 then
+	if abs(s1.x - s.x) + abs(s1.z - s.z) < .5 then
 		self.path.stuck_timer = self.path.stuck_timer + dtime
 	else
 		self.path.stuck_timer = 0
 	end

-	self.path.lastpos = {x = s.x, y = s.y, z = s.z}
+	self.path.lastpos = vector_copy(s)

 	local use_pathfind = false
-	local has_lineofsight = minetest.line_of_sight(
-		{x = s.x, y = (s.y) + .5, z = s.z},
-		{x = target_pos.x, y = (target_pos.y) + 1.5, z = target_pos.z}, .2)
+	local has_lineofsight = minetest.line_of_sight(vector_offset(s, 0, .5, 0), vector_offset(target_pos, 0, 1.5, 0), .2)

 	-- im stuck, search for path
 	if not has_lineofsight then
-
 		if los_switcher == true then
 			use_pathfind = true
 			los_switcher = false
 		end -- cannot see target!
 	else
 		if los_switcher == false then
-
 			los_switcher = true
 			use_pathfind = false
-
 			minetest.after(1, function(self)
-				if not self.object:get_luaentity() then
-					return
-				end
+				if not self.object:get_luaentity() then return end
 				if has_lineofsight then self.path.following = false end
 			end, self)
 		end -- can see target!
 	end

 	if (self.path.stuck_timer > stuck_timeout and not self.path.following) then
-
 		use_pathfind = true
 		self.path.stuck_timer = 0
-
 		minetest.after(1, function(self)
-			if not self.object:get_luaentity() then
-				return
-			end
+			if not self.object:get_luaentity() then return end
 			if has_lineofsight then self.path.following = false end
 		end, self)
 	end

 	if (self.path.stuck_timer > stuck_path_timeout and self.path.following) then
-
 		use_pathfind = true
 		self.path.stuck_timer = 0
-
 		minetest.after(1, function(self)
-			if not self.object:get_luaentity() then
-				return
-			end
+			if not self.object:get_luaentity() then return end
 			if has_lineofsight then self.path.following = false end
 		end, self)
 	end

-	if math.abs(vector.subtract(s,target_pos).y) > self.stepheight then
-
+	if abs(s.y - target_pos.y) > self.stepheight then
 		if height_switcher then
 			use_pathfind = true
 			height_switcher = false
@ -174,28 +144,21 @@ function mob_class:smart_mobs(s, p, dist, dtime)

 		-- round position to center of node to avoid stuck in walls
 		-- also adjust height for player models!
-		s.x = math.floor(s.x + 0.5)
-		s.z = math.floor(s.z + 0.5)
+		s.x, s.z = floor(s.x + 0.5), floor(s.z + 0.5)

-		local ssight, sground = minetest.line_of_sight(s, {
-			x = s.x, y = s.y - 4, z = s.z}, 1)
+		local ssight, sground = minetest.line_of_sight(s, vector_offset(s, 0, -4, 0), 1)

 		-- determine node above ground
-		if not ssight then
-			s.y = sground.y + 1
-		end
+		if not ssight then s.y = sground.y + 1 end

 		local p1 = self.attack:get_pos()
-
-		p1.x = math.floor(p1.x + 0.5)
-		p1.y = math.floor(p1.y + 0.5)
-		p1.z = math.floor(p1.z + 0.5)
+		p1 = vector_new(floor(p1.x + 0.5), floor(p1.y + 0.5), floor(p1.z + 0.5))

 		local dropheight = 12
 		if self.fear_height ~= 0 then dropheight = self.fear_height end
 		local jumpheight = 0
 		if self.jump and self.jump_height >= 4 then
-			jumpheight = math.min(math.ceil(self.jump_height / 4), 4)
+			jumpheight = min(ceil(self.jump_height * 0.25), 4)
 		elseif self.stepheight > 0.5 then
 			jumpheight = 1
 		end
@ -206,34 +169,27 @@ function mob_class:smart_mobs(s, p, dist, dtime)

 		-- no path found, try something else
 		if not self.path.way then
-
 			self.path.following = false

 			 -- lets make way by digging/building if not accessible
 			if self.pathfinding == 2 and mobs_griefing then
-
 				-- is player higher than mob?
 				if s.y < p1.y then
-
 					-- build upwards
 					if not minetest.is_protected(s, "") then
-
 						local ndef1 = minetest.registered_nodes[self.standing_in]
-
 						if ndef1 and (ndef1.buildable_to or ndef1.groups.liquid) then
-
 								minetest.set_node(s, {name = mcl_mobs.fallback_node})
 						end
 					end

-					local sheight = math.ceil(self.collisionbox[5]) + 1
+					local sheight = ceil(self.collisionbox[5]) + 1

 					-- assume mob is 2 blocks high so it digs above its head
 					s.y = s.y + sheight

 					-- remove one block above to make room to jump
 					if not minetest.is_protected(s, "") then
-
 						local node1 = node_ok(s, "air").name
 						local ndef1 = minetest.registered_nodes[node1]

@ -243,32 +199,21 @@ function mob_class:smart_mobs(s, p, dist, dtime)
 						and not ndef1.groups.level
 						and not ndef1.groups.unbreakable
 						and not ndef1.groups.liquid then
-
 							minetest.set_node(s, {name = "air"})
 							minetest.add_item(s, ItemStack(node1))
-
 						end
 					end

 					s.y = s.y - sheight
-					self.object:set_pos({x = s.x, y = s.y + 2, z = s.z})
-
+					self.object:set_pos(vector_offset(s, 0, 2, 0))
 				else -- dig 2 blocks to make door toward player direction
-
-					local yaw1 = self.object:get_yaw() + math.pi / 2
-					local p1 = {
-						x = s.x + math.cos(yaw1),
-						y = s.y,
-						z = s.z + math.sin(yaw1)
-					}
+					local yaw1 = self.object:get_yaw() + HALFPI
+					local p1 = vector_offset(s, cos(yaw1), 0, sin(yaw1))

 					if not minetest.is_protected(p1, "") then
-
 						local node1 = node_ok(p1, "air").name
 						local ndef1 = minetest.registered_nodes[node1]
-
-						if node1 ~= "air"
-							and node1 ~= "ignore"
+						if node1 ~= "air" and node1 ~= "ignore"
 							and ndef1
 							and not ndef1.groups.level
 							and not ndef1.groups.unbreakable
@ -282,8 +227,7 @@ function mob_class:smart_mobs(s, p, dist, dtime)
 						node1 = node_ok(p1, "air").name
 						ndef1 = minetest.registered_nodes[node1]

-						if node1 ~= "air"
-						and node1 ~= "ignore"
+						if node1 ~= "air" and node1 ~= "ignore"
 						and ndef1
 						and not ndef1.groups.level
 						and not ndef1.groups.unbreakable
@ -317,28 +261,19 @@ end

 -- specific attacks
 local specific_attack = function(list, what)
-
 	-- no list so attack default (player, animals etc.)
-	if list == nil then
-		return true
-	end
+	if list == nil then return true end

 	-- found entity on list to attack?
 	for no = 1, #list do
-
-		if list[no] == what then
-			return true
-		end
+		if list[no] == what then return true end
 	end
-
 	return false
 end

 -- find someone to attack
 function mob_class:monster_attack()
-	if not damage_enabled or self.passive ~= false or self.state == "attack" or self:day_docile() then
-		return
-	end
+	if not damage_enabled or self.passive ~= false or self.state == "attack" or self:day_docile() then return end

 	local s = self.object:get_pos()
 	local p, sp, dist
@ -392,7 +327,7 @@ function mob_class:monster_attack()
 			p = player:get_pos()
 			sp = s

-			dist = vector.distance(p, s)
+			dist = vector_distance(p, s)

 			-- aim higher to make looking up hills more realistic
 			p.y = p.y + 1
@ -414,7 +349,7 @@ function mob_class:monster_attack()
 		end
 	end
 	if not min_player and #blacklist_attack > 0 then
-		min_player=blacklist_attack[math.random(#blacklist_attack)]
+		min_player=blacklist_attack[random(#blacklist_attack)]
 	end
 	-- attack player
 	if min_player then
@ -425,7 +360,6 @@ end

 -- npc, find closest monster to attack
 function mob_class:npc_attack()
-
 	if self.type ~= "npc"
 	or not self.attacks_monsters
 	or self.state == "attack" then
@ -444,7 +378,7 @@ function mob_class:npc_attack()
 			p = obj.object:get_pos()
 			sp = s

-			local dist = vector.distance(p, s)
+			local dist = vector_distance(p, s)

 			-- aim higher to make looking up hills more realistic
 			p.y = p.y + 1
@ -466,19 +400,13 @@ end

 -- dogshoot attack switch and counter function
 function mob_class:dogswitch(dtime)
-
 	-- switch mode not activated
-	if not self.dogshoot_switch
-	or not dtime then
-		return 0
-	end
+	if not self.dogshoot_switch or not dtime then return 0 end

 	self.dogshoot_count = self.dogshoot_count + dtime

-	if (self.dogshoot_switch == 1
-	and self.dogshoot_count > self.dogshoot_count_max)
-	or (self.dogshoot_switch == 2
-	and self.dogshoot_count > self.dogshoot_count2_max) then
+	if (self.dogshoot_switch == 1 and self.dogshoot_count > self.dogshoot_count_max)
+	or (self.dogshoot_switch == 2 and self.dogshoot_count > self.dogshoot_count2_max) then

 		self.dogshoot_count = 0

@ -525,13 +453,9 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)

 	if is_player then
 		-- is mob out of reach?
-		if vector.distance(mob_pos, player_pos) > 3 then
-			return
-		end
+		if vector_distance(mob_pos, player_pos) > 3 then return end
 		-- is mob protected?
-		if self.protected and minetest.is_protected(mob_pos, hitter:get_player_name()) then
-			return
-		end
+		if self.protected and minetest.is_protected(mob_pos, hitter:get_player_name()) then return end

 		mcl_potions.update_haste_and_fatigue(hitter)
 	end
@ -540,13 +464,10 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)
 	local time_diff = time_now - self.invul_timestamp

 	-- check for invulnerability time in microseconds (0.5 second)
-	if time_diff <= 500000 and time_diff >= 0 then
-		return
-	end
+	if time_diff <= 500000 and time_diff >= 0 then return 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
@ -562,15 +483,11 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)
 	local time_now = minetest.get_us_time()

 	if is_player then
-		if minetest.is_creative_enabled(hitter:get_player_name()) then
-			self.health = 0
-		end
-
+		if minetest.is_creative_enabled(hitter:get_player_name()) then self.health = 0 end
 		-- set/update 'drop xp' timestamp if hitted by player
 		self.xp_timestamp = time_now
 	end

-
 	-- punch interval
 	local weapon = hitter:get_wielded_item()
 	local punch_interval = 1.4
@ -591,18 +508,10 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)
 	end


-	for group,_ in pairs( (tool_capabilities.damage_groups or {}) ) do
-
+	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)
+		tmp = tmp < 0 and 0 or (tmp > 1 and 1 or tmp)
+		damage = damage + (tool_capabilities.damage_groups[group] or 0) * tmp * ((armor[group] or 0) / 100.0)
 	end

 	-- strength and weakness effects
@ -621,9 +530,7 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)

 	-- 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
@ -631,7 +538,7 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)

 	-- healing
 	if damage <= -1 then
-		self.health = self.health - math.floor(damage)
+		self.health = self.health - floor(damage)
 		return
 	end

@ -651,7 +558,7 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)
 				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)
+					local wear = floor(65535/tool_capabilities.punch_attack_uses)
 					weapon:add_wear(wear)
 					tt.reload_itemstack_description(weapon) -- update tooltip
 					hitter:set_wielded_item(weapon)
@ -662,14 +569,12 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)

 	local die = false

-
 	if damage >= 0 then
 		-- 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)
+				local s = random(0, #weapon:get_definition().sounds)

 				minetest.sound_play(weapon:get_definition().sounds[s], {
 					object = self.object, --hitter,
@ -696,27 +601,20 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)
 			end
 		end
 		-- knock back effect (only on full punch)
-		if self.knock_back
-		and tflp >= punch_interval then
+		if self.knock_back and tflp >= punch_interval then
 			-- direction error check
-			dir = dir or {x = 0, y = 0, z = 0}
+			dir = dir or vector_zero()

 			local v = self.object:get_velocity()
 			if not v then return end
-			local r = 1.4 - math.min(punch_interval, 1.4)
-			local kb = r * (math.abs(v.x)+math.abs(v.z))
+			local r = 1.4 - min(punch_interval, 1.4)
+			local kb = r * (abs(v.x)+abs(v.z))
 			local up = 2.625

-			if die==true then
-				kb=kb*1.25
-			end
+			if die then kb = kb * 1.25 end

 			-- if already in air then dont go up anymore when hit
-			if math.abs(v.y) > 0.1
-			or self.fly then
-				up = 0
-			end
-
+			if abs(v.y) > 0.1 or self.fly then up = 0 end

 			-- check if tool already has specific knockback value
 			if tool_capabilities.damage_groups["knockback"] then
@ -725,21 +623,17 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)
 				kb = kb * 1.25
 			end

-
-			local luaentity
-			if hitter then
-				luaentity = hitter:get_luaentity()
-			end
+			local luaentity = hitter and hitter:get_luaentity()
 			if hitter and is_player then
 				local wielditem = hitter:get_wielded_item()
 				kb = kb + 9 * mcl_enchanting.get_enchantment(wielditem, "knockback")
 				-- add player velocity to mob knockback
 				local hv = hitter:get_velocity()
 				local dir_dot = (hv.x * dir.x) + (hv.z * dir.z)
-				local player_mag = math.sqrt((hv.x * hv.x) + (hv.z * hv.z))
-				local mob_mag = math.sqrt((v.x * v.x) + (v.z * v.z))
+				local player_mag = ((hv.x * hv.x) + (hv.z * hv.z))^0.5
+				local mob_mag = ((v.x * v.x) + (v.z * v.z))^0.5
 				if dir_dot > 0 and mob_mag <= player_mag * 0.625 then
-					kb = kb + ((math.abs(hv.x) + math.abs(hv.z)) * r)
+					kb = kb + (abs(hv.x) + abs(hv.z)) * r
 				end
 			elseif luaentity and luaentity._knockback and die == false then
 				kb = kb + luaentity._knockback
@ -747,12 +641,12 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)
 				kb = kb + luaentity._knockback * 0.25
 			end
 			self._kb_turn = true
-			self._turn_to=self.object:get_yaw()-1.57
+			self:turn_by(HALFPI, .1) -- knockback turn
 			self.frame_speed_multiplier=2.3
 			if self.animation.run_end then
-				self:set_animation( "run")
+				self:set_animation("run")
 			elseif self.animation.walk_end then
-				self:set_animation( "walk")
+				self:set_animation("walk")
 			end
 			minetest.after(0.2, function()
 				if self and self.object then
@ -760,11 +654,7 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)
 					self._kb_turn = false
 				end
 			end)
-			self.object:add_velocity({
-				x = dir.x * kb,
-				y = up*2,
-				z = dir.z * kb
-			})
+			self.object:add_velocity(vector_new(dir.x * kb, up*2, dir.z * kb ))

 			self.pause_timer = 0.25
 		end
@ -772,12 +662,15 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)

 	-- if skittish then run away
 	if hitter and is_player and hitter:get_pos() and not die and self.runaway == true and self.state ~= "flop" then
-
-		local yaw = self:set_yaw( minetest.dir_to_yaw(vector.direction(hitter:get_pos(), self.object:get_pos())))
+		local hp, sp = hitter:get_pos(), self.object:get_pos()
+		self:turn_in_direction(sp.x - hp.x, sp.z - hp.z, 1)
 		minetest.after(0.2,function()
-			if self and self.object and self.object:get_pos() and hitter and is_player and hitter:get_pos() then
-				yaw = self:set_yaw( minetest.dir_to_yaw(vector.direction(hitter:get_pos(), self.object:get_pos())))
-				self:set_velocity( self.run_velocity)
+			if self and self.object and hitter and is_player then
+				local hp, sp = hitter:get_pos(), self.object:get_pos()
+				if hp and sp then
+					self:turn_in_direction(sp.x - hp.x, sp.z - hp.z, 1)
+					self:set_velocity(self.run_velocity)
+				end
 			end
 		end)
 		self.state = "runaway"
@ -808,7 +701,6 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir)
 		local obj = nil

 		for n = 1, #objs do
-
 			obj = objs[n]:get_luaentity()

 			if obj then
@ -840,11 +732,7 @@ end

 function mob_class:check_aggro(dtime)
 	if not self._aggro or not self.attack then return end
-
-	if not self._check_aggro_timer then
-		self._check_aggro_timer = 0
-	end
-
+	if not self._check_aggro_timer then self._check_aggro_timer = 0 end
 	if self._check_aggro_timer > 5 then
 		self._check_aggro_timer = 0

@ -852,7 +740,7 @@ function mob_class:check_aggro(dtime)
 			-- TODO consider removing this in favour of what is done in do_states_attack
 			-- Attack is dropped in do_states_attack if out of range, so won't even trigger here
 			-- I do not think this code does anything. Are mobs still loaded in at 128?
-			if not self.attack:get_pos() or vector.distance(self.attack:get_pos(),self.object:get_pos()) > 128 then
+			if not self.attack:get_pos() or vector_distance(self.attack:get_pos(),self.object:get_pos()) > 128 then
 				self._aggro = nil
 				self.attack = nil
 				self.state = "stand"
@ -878,17 +766,14 @@ local function clear_aggro(self)
 	self.path.way = nil
 end

-function mob_class:do_states_attack (dtime)
+function mob_class:do_states_attack(dtime)
 	self.timer = self.timer + dtime
-	if self.timer > 100 then
-		self.timer = 1
-	end
+	if self.timer > 100 then self.timer = 1 end

 	local s = self.object:get_pos()
 	if not s then return end

 	local p = self.attack:get_pos() or s
-
 	local yaw = self.object:get_yaw() or 0

 	-- stop attacking if player invisible or out of range
@ -920,20 +805,15 @@ function mob_class:do_states_attack (dtime)
 	end

 	-- calculate distance from mob and enemy
-	local dist = vector.distance(p, s)
+	local dist = vector_distance(p, s)

 	if self.attack_type == "explode" then
-
 		if target_line_of_sight then
-			local vec = { x = p.x - s.x, z = p.z - s.z }
-			yaw = (atan(vec.z / vec.x) +math.pi/ 2) - self.rotate
-			if p.x > s.x then yaw = yaw +math.pi end
-			yaw = self:set_yaw( yaw, 0, dtime)
+			self:turn_in_direction(p.x - s.x, p.z - s.z, 1)
 		end

 		local node_break_radius = self.explosion_radius or 1
-		local entity_damage_radius = self.explosion_damage_radius
-				or (node_break_radius * 2)
+		local entity_damage_radius = self.explosion_damage_radius or (node_break_radius * 2)

 		-- start timer when in reach and line of sight
 		if not self.v_start and dist <= self.reach and target_line_of_sight then
@ -960,9 +840,9 @@ function mob_class:do_states_attack (dtime)
 		end

 		if self.animation and self.animation.run_start then
-			self:set_animation( "run")
+			self:set_animation("run")
 		else
-			self:set_animation( "walk")
+			self:set_animation("walk")
 		end

 		if self.v_start then
@ -1005,92 +885,50 @@ function mob_class:do_states_attack (dtime)
 			or (self.attack_type == "dogshoot" and self:dogswitch(dtime) == 2) and (dist >= self.avoid_distance or not self.shooter_avoid_enemy)
 			or (self.attack_type == "dogshoot" and dist <= self.reach and self:dogswitch() == 0) then

-		if self.fly
-				and dist > self.reach then
-
-			local p1 = s
-			local me_y = math.floor(p1.y)
-			local p2 = p
-			local p_y = math.floor(p2.y + 1)
+		if self.fly and dist > self.reach then
+			local p1, p2 = s, p
+			local me_y, p_y = floor(p1.y), floor(p2.y + 1)
 			local v = self.object:get_velocity()

 			if self:flight_check( s) then
-
 				if me_y < p_y then
-
-					self.object:set_velocity({
-						x = v.x,
-						y = 1 * self.walk_velocity,
-						z = v.z
-					})
-
+					self.object:set_velocity(vector_new(v.x,  1 * self.walk_velocity, v.z))
 				elseif me_y > p_y then
-
-					self.object:set_velocity({
-						x = v.x,
-						y = -1 * self.walk_velocity,
-						z = v.z
-					})
+					self.object:set_velocity(vector_new(v.x, -1 * self.walk_velocity, v.z))
 				end
 			else
 				if me_y < p_y then
-
-					self.object:set_velocity({
-						x = v.x,
-						y = 0.01,
-						z = v.z
-					})
-
+					self.object:set_velocity(vector_new(v.x,  0.01, v.z))
 				elseif me_y > p_y then
-
-					self.object:set_velocity({
-						x = v.x,
-						y = -0.01,
-						z = v.z
-					})
+					self.object:set_velocity(vector_new(v.x, -0.01, v.z))
 				end
 			end
-
 		end

 		-- rnd: new movement direction
-		if self.path.following
-				and self.path.way
-				and self.attack_type ~= "dogshoot" then
-
+		if self.path.following and self.path.way and self.attack_type ~= "dogshoot" then
 			-- no paths longer than 50
-			if #self.path.way > 50
-					or dist < self.reach then
+			if #self.path.way > 50 or dist < self.reach then
 				self.path.following = false
 				return
 			end

 			local p1 = self.path.way[1]
-
 			if not p1 then
 				self.path.following = false
 				return
 			end

-			if math.abs(p1.x-s.x) + math.abs(p1.z - s.z) < 0.6 then
+			if abs(p1.x - s.x) + abs(p1.z - s.z) < 0.6 then
 				-- reached waypoint, remove it from queue
 				table.remove(self.path.way, 1)
 			end

 			-- set new temporary target
-			p = {x = p1.x, y = p1.y, z = p1.z}
+			p = vector_copy(p1)
 		end

-		local vec = {
-			x = p.x - s.x,
-			z = p.z - s.z
-		}
-
-		yaw = (atan(vec.z / vec.x) + math.pi / 2) - self.rotate
-
-		if p.x > s.x then yaw = yaw + math.pi end
-
-		yaw = self:set_yaw( yaw, 0, dtime)
+		self:turn_in_direction(p.x - s.x, p.z - s.z, 1)

 		-- move towards enemy if beyond mob reach
 		if dist > self.reach then
@ -1100,10 +938,9 @@ function mob_class:do_states_attack (dtime)
 			end

 			if self:is_at_cliff_or_danger() then
-				self:set_velocity( 0)
-				self:set_animation( "stand")
-				local yaw = self.object:get_yaw() or 0
-				yaw = self:set_yaw( yaw + 0.78, 8)
+				self:set_velocity(0)
+				self:set_animation("stand")
+				self:turn_by(PI * (random() - 0.5), 10)
 			else
 				if self.path.stuck then
 					self:set_velocity(self.walk_velocity)
@ -1129,19 +966,13 @@ function mob_class:do_states_attack (dtime)
 				self.timer = 0

 				if not self.custom_attack then
-					if self.double_melee_attack and math.random(1, 2) == 1 then
+					if self.double_melee_attack and random(1, 2) == 1 then
 						self:set_animation("punch2")
 					else
 						self:set_animation("punch")
 					end

-					local p2 = p
-					local s2 = s
-
-					p2.y = p2.y + .5
-					s2.y = s2.y + .5
-
-					if self:line_of_sight( p2, s2) == true then
+					if self:line_of_sight(vector_offset(p, 0, .5, 0), vector_offset(s, 0, .5, 0)) == true then
 						self:mob_sound("attack")

 						-- punch player (or what player is attached to)
@ -1167,59 +998,30 @@ function mob_class:do_states_attack (dtime)
 	elseif self.attack_type == "shoot"
 			or (self.attack_type == "dogshoot" and self:dogswitch(dtime) == 1)
 			or (self.attack_type == "dogshoot" and (dist > self.reach or dist < self.avoid_distance and self.shooter_avoid_enemy) and self:dogswitch() == 0) then
-
-		p.y = p.y - .5
-		s.y = s.y + .5
-
-		local dist = vector.distance(p, s)
-		local vec = {
-			x = p.x - s.x,
-			y = p.y - s.y,
-			z = p.z - s.z
-		}
-
-		yaw = (atan(vec.z / vec.x) +math.pi/ 2) - self.rotate
-
-		if p.x > s.x then yaw = yaw +math.pi end
-
-		yaw = self:set_yaw( yaw, 0, dtime)
-
-		local stay_away_from_player = vector.zero()
-
-		--strafe back and fourth
-
-		--stay away from player so as to shoot them
-		if dist < self.avoid_distance and self.shooter_avoid_enemy then
-			self:set_animation( "shoot")
-			stay_away_from_player=vector.multiply(vector.direction(p, s), 0.33)
-		end
+		local vec = vector_new(p.x - s.x, p.y - s.y - 1, p.z - s.z)
+		local dist = (vec.x*vec.x + vec.y*vec.y + vec.z*vec.z)^0.5
+		self:turn_in_direction(vec.x, vec.z, 1)

 		if self.strafes then
-			if not self.strafe_direction then
-				self.strafe_direction = 1.57
-			end
-			if math.random(40) == 1 then
-				self.strafe_direction = self.strafe_direction*-1
-			end
+			if not self.strafe_direction then self.strafe_direction = HALFPI end
+			if random(40) == 1 then self.strafe_direction = self.strafe_direction * -1 end

-			local dir = vector.rotate_around_axis(vector.direction(s, p), vector.new(0,1,0), self.strafe_direction)
-			local dir2 = vector.multiply(dir, 0.3 * self.walk_velocity)
-
-			if dir2 and stay_away_from_player then
-				self.acc = vector.add(dir2, stay_away_from_player)
+			local dir = -atan2(p.x - s.x, p.z - s.z)
+			self.acc = vector_new(-sin(dir + self.strafe_direction) * 0.8, 0, cos(dir + self.strafe_direction) * 0.8)
+			--stay away from player so as to shoot them
+			if self.avoid_distance and dist < self.avoid_distance and self.shooter_avoid_enemy then
+				local f = 0.3 * (self.avoid_distance - dist) / self.avoid_distance
+				self.acc.x, self.acc.z = self.acc.x - sin(dir) * f, self.acc.z + cos(dir) * f
 			end
 		else
-			self:set_velocity( 0)
+			self:set_velocity(0)
 		end

 		local p = self.object:get_pos()
-		p.y = p.y + (self.collisionbox[2] + self.collisionbox[5]) / 2
-
-		if self.shoot_interval
-				and self.timer > self.shoot_interval
-				and not minetest.raycast(vector.add(p, vector.new(0,self.shoot_offset,0)), vector.add(self.attack:get_pos(), vector.new(0,1.5,0)), false, false):next()
-				and math.random(1, 100) <= 60 then
+		p.y = p.y + (self.collisionbox[2] + self.collisionbox[5]) * 0.5

+		if self.shoot_interval and self.timer > self.shoot_interval and random(1, 100) <= 60
+				and not minetest.raycast(vector_offset(p, 0, self.shoot_offset, 0), vector_offset(self.attack:get_pos(), 0, 1.5, 0), false, false):next() then
 			self.timer = 0
 			self:set_animation( "shoot")

@ -1228,7 +1030,6 @@ function mob_class:do_states_attack (dtime)

 			-- Shoot arrow
 			if minetest.registered_entities[self.arrow] then
-
 				local arrow, ent
 				local v = 1
 				if not self.shoot_arrow then
@ -1238,9 +1039,7 @@ function mob_class:do_states_attack (dtime)
 					end)
 					arrow = minetest.add_entity(p, self.arrow)
 					ent = arrow:get_luaentity()
-					if ent.velocity then
-						v = ent.velocity
-					end
+					v = ent.velocity or v
 					ent.switch = 1
 					ent.owner_id = tostring(self.object) -- add unique owner id to arrow

@ -1252,12 +1051,9 @@ function mob_class:do_states_attack (dtime)
 					end
 				end

-				local amount = (vec.x * vec.x + vec.y * vec.y + vec.z * vec.z) ^ 0.5
 				-- offset makes shoot aim accurate
 				vec.y = vec.y + self.shoot_offset
-				vec.x = vec.x * (v / amount)
-				vec.y = vec.y * (v / amount)
-				vec.z = vec.z * (v / amount)
+				vec.x, vec.y, vec.z = vec.x * (v / dist), vec.y * (v / dist), vec.z * (v / dist)
 				if self.shoot_arrow then
 					vec = vector.normalize(vec)
 					self:shoot_arrow(p, vec)
@ -1266,13 +1062,9 @@ function mob_class:do_states_attack (dtime)
 				end
 			end
 		end
-
 	elseif self.attack_type == "custom" and self.attack_state then
 		self.attack_state(self, dtime)
 	end

-	if self.on_attack then
-		self.on_attack(self, dtime)
-	end
-
+	if self.on_attack then self.on_attack(self, dtime) end
 end
--- a/mods/ENTITIES/mcl_mobs/effects.lua
+++ b/mods/ENTITIES/mcl_mobs/effects.lua
@ -5,6 +5,7 @@ local validate_vector = mcl_util.validate_vector
 local active_particlespawners = {}
 local disable_blood = minetest.settings:get_bool("mobs_disable_blood")
 local DEFAULT_FALL_SPEED = -9.81*1.5
+local PI_THIRD = math.pi / 3 -- 60 degrees

 local PATHFINDING = "gowp"

@ -245,9 +246,7 @@ end

 -- set defined animation
 function mob_class:set_animation(anim, fixed_frame)
-	if not self.animation or not anim then
-		return
-	end
+	if not self.animation or not anim then return end

 	if self.jockey and self.object:get_attach() then
 		anim = "jockey"
@ -255,11 +254,7 @@ function mob_class:set_animation(anim, fixed_frame)
 		self.jockey = nil
 	end
 	
-	if self.state == "die" and anim ~= "die" and anim ~= "stand" then
-		return
-	end
-
-
+	if self.state == "die" and anim ~= "die" and anim ~= "stand" then return end

 	if self.fly and self:flight_check() and anim == "walk" then anim = "fly" end

@ -274,12 +269,7 @@ function mob_class:set_animation(anim, fixed_frame)
 	self._current_animation = anim

 	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
+	local a_end = fixed_frame and a_start or self.animation[anim .. "_end"]
 	if a_start and a_end then
 		self.object:set_animation({
 			x = a_start,
@ -289,91 +279,66 @@ function mob_class:set_animation(anim, fixed_frame)
 		end
 end

-- above function exported for mount.lua
-function mcl_mobs:set_animation(self, anim)
-	self:set_animation(anim)
-end
-
-local function dir_to_pitch(dir)
-	--local dir2 = vector.normalize(dir)
-	local xz = math.abs(dir.x) + math.abs(dir.z)
-	return -math.atan2(-dir.y, xz)
-end
-
 local function who_are_you_looking_at (self, dtime)
-	local pos = self.object:get_pos()
+	if self.order == "sleep" then
+		self._locked_object = nil
+		return
+	end

-	local stop_look_at_player_chance = math.random(833/self.curiosity)
 	-- was 10000 - div by 12 for avg entities as outside loop
-
-	local stop_look_at_player = stop_look_at_player_chance == 1
+	local stop_look_at_player = math.random() * 833 <= self.curiosity

 	if self.attack then
-		if not self.target_time_lost then
-			self._locked_object = self.attack
-		else
-			self._locked_object = nil
-		end
+		self._locked_object = not self.target_time_lost and self.attack or nil
 	elseif self.following then
 		self._locked_object = self.following
 	elseif self._locked_object then
-		if stop_look_at_player then
-			--minetest.log("Stop look: ".. self.name)
-			self._locked_object = nil
-		end
+		if stop_look_at_player then self._locked_object = nil end
 	elseif not self._locked_object then
 		if mcl_util.check_dtime_timer(self, dtime, "step_look_for_someone", 0.2) then
-			--minetest.log("Change look check: ".. self.name)
-
-			-- For the wither this was 20/60=0.33, so probably need to rebalance and divide rates.
-			-- but frequency of check isn't good as it is costly. Making others too infrequent requires testing
-			local chance = 150/self.curiosity
-
-			if chance < 1 then chance = 1 end
-			local look_at_player_chance = math.random(chance)
-
-			-- was 5000 but called in loop based on entities. so div by 12 as estimate avg of entities found,
-			-- then div by 20 as less freq lookup
-
-			local look_at_player = look_at_player_chance == 1
-
+			local pos = self.object:get_pos()
 			for _, obj in pairs(minetest.get_objects_inside_radius(pos, 8)) do
-				if obj:is_player() and vector.distance(pos,obj:get_pos()) < 4 then
-					--minetest.log("Change look to player: ".. self.name)
+				if obj:is_player() and vector.distance(pos, obj:get_pos()) < 4 then
 					self._locked_object = obj
 					break
-				elseif obj:is_player() or (obj:get_luaentity() and obj:get_luaentity().name == self.name and self ~= obj:get_luaentity()) then
-					if look_at_player then
-						--minetest.log("Change look to mob: ".. self.name)
+				elseif obj:is_player() or (obj:get_luaentity() and self ~= obj:get_luaentity() and obj:get_luaentity().name == self.name) then
+					-- For the wither this was 20/60=0.33, so probably need to rebalance and divide rates.
+					-- but frequency of check isn't good as it is costly. Making others too infrequent requires testing
+					-- was 5000 but called in loop based on entities. so div by 12 as estimate avg of entities found,
+					-- then div by 20 as less freq lookup
+					if math.random() * 150 <= self.curiosity then
 						self._locked_object = obj
 						break
 					end
 				end
 			end
 		end
-
 	end
 end

 function mob_class:check_head_swivel(dtime)
 	if not self.head_swivel or type(self.head_swivel) ~= "string" then return end

+	who_are_you_looking_at(self, dtime)

-	who_are_you_looking_at (self, dtime)
+	local newr, oldp, oldr = vector.zero(), nil, nil
+	if self.object.get_bone_override then -- minetest >= 5.9
+		local ov = self.object:get_bone_override(self.head_swivel)
+		oldp, oldr = ov.position.vec, ov.rotation.vec
+	else -- minetest < 5.9
+		oldp, oldr = self.object:get_bone_position(self.head_swivel)
+		oldr = vector.apply(oldr, math.rad) -- old API uses radians
+	end

-	local final_rotation = vector.zero()
-	local oldp,oldr = self.object:get_bone_position(self.head_swivel)
-
-	if self._locked_object and (self._locked_object:is_player() or self._locked_object:get_luaentity()) and self._locked_object:get_hp() > 0 then
+	local locked_object = self._locked_object
+	if locked_object and (locked_object:is_player() or locked_object:get_luaentity()) and locked_object:get_hp() > 0 then
 		local _locked_object_eye_height = 1.5
-		if self._locked_object:get_luaentity() then
-			_locked_object_eye_height = self._locked_object:get_luaentity().head_eye_height
-		end
-		if self._locked_object:is_player() then
-			_locked_object_eye_height = self._locked_object:get_properties().eye_height
+		if locked_object:is_player() then
+			_locked_object_eye_height = locked_object:get_properties().eye_height
+		elseif locked_object:get_luaentity() then
+			_locked_object_eye_height = locked_object:get_luaentity().head_eye_height
 		end
 		if _locked_object_eye_height then
-
 			local self_rot = self.object:get_rotation()
 			-- If a mob is attached, should we really be messing with what they are looking at?
 			-- Should this be excluded?
@ -381,40 +346,48 @@ function mob_class:check_head_swivel(dtime)
 				self_rot = self.object:get_attach():get_rotation()
 			end

-			local player_pos = self._locked_object:get_pos()
-			local direction_player = vector.direction(vector.add(self.object:get_pos(), vector.new(0, self.head_eye_height*.7, 0)), vector.add(player_pos, vector.new(0, _locked_object_eye_height, 0)))
-			local mob_yaw = math.deg(-(-(self_rot.y)-(-minetest.dir_to_yaw(direction_player))))+self.head_yaw_offset
-			local mob_pitch = math.deg(-dir_to_pitch(direction_player))*self.head_pitch_multiplier
+			local ps = self.object:get_pos()
+			ps.y = ps.y + self.head_eye_height * .7
+			local pt = locked_object:get_pos()
+			pt.y = pt.y + _locked_object_eye_height
+			local dir = vector.direction(ps, pt)
+			local mob_yaw = self_rot.y + math.atan2(dir.x, dir.z) + self.head_yaw_offset
+			local mob_pitch = math.asin(-dir.y) * self.head_pitch_multiplier

-			if (mob_yaw < -60 or mob_yaw > 60) and not (self.attack and self.state == "attack" and not self.runaway) then
-				final_rotation = vector.multiply(oldr, 0.9)
+			if (mob_yaw < -PI_THIRD or mob_yaw > PI_THIRD) and not (self.attack and self.state == "attack" and not self.runaway) then
+				newr = vector.multiply(oldr, 0.9)
 			elseif self.attack and self.state == "attack" and not self.runaway then
 				if self.head_yaw == "y" then
-					final_rotation = vector.new(mob_pitch, mob_yaw, 0)
+					newr = vector.new(mob_pitch, mob_yaw, 0)
 				elseif self.head_yaw == "z" then
-					final_rotation = vector.new(mob_pitch, 0, -mob_yaw)
+					newr = vector.new(mob_pitch, 0, -mob_yaw)
 				end
-
 			else
-
 				if self.head_yaw == "y" then
-					final_rotation = vector.new(((mob_pitch-oldr.x)*.3)+oldr.x, ((mob_yaw-oldr.y)*.3)+oldr.y, 0)
+					newr = vector.new((mob_pitch-oldr.x)*.3+oldr.x, (mob_yaw-oldr.y)*.3+oldr.y, 0)
 				elseif self.head_yaw == "z" then
-					final_rotation = vector.new(((mob_pitch-oldr.x)*.3)+oldr.x, 0, -(((mob_yaw-oldr.y)*.3)+oldr.y)*3)
+					newr = vector.new((mob_pitch-oldr.x)*.3+oldr.x, 0, ((mob_yaw-oldr.y)*.3+oldr.y)*-3)
 				end
 			end
 		end
-	elseif not self._locked_object and math.abs(oldr.y) > 3 and math.abs(oldr.x) < 3 then
-		final_rotation = vector.multiply(oldr, 0.9)
-	else
-		--final_rotation = vector.new(0,0,0)
+	elseif not locked_object and math.abs(oldr.y) > 0.05 and math.abs(oldr.x) < 0.05 then
+		newr = vector.multiply(oldr, 0.9)
+	end
+	
+	-- 0.02 is about 1.14 degrees tolerance, to update less often
+	local newp = vector.new(0, self.bone_eye_height, self.horizontal_head_height)
+	if math.abs(oldr.x-newr.x) + math.abs(oldr.y-newr.y) + math.abs(oldr.z-newr.z) < 0.02 and vector.equals(oldp, newp) then return end
+	if self.object.get_bone_override then -- minetest >= 5.9
+		self.object:set_bone_override(self.head_swivel, {
+			position = { vec = newp, absolute = true },
+			rotation = { vec = newr, absolute = true } })
+	else -- minetest < 5.9
+		-- old API uses degrees not radians
+		self.object:set_bone_position(self.head_swivel, newp, vector.apply(newr, math.deg))
 	end
-
-	mcl_util.set_bone_position(self.object,self.head_swivel, vector.new(0,self.bone_eye_height,self.horizontal_head_height), final_rotation)
 end


-
 function mob_class:set_animation_speed()
 	local v = self.object:get_velocity()
 	if v then
--- a/mods/ENTITIES/mcl_mobs/init.lua
+++ b/mods/ENTITIES/mcl_mobs/init.lua
@ -6,6 +6,19 @@ local modname = minetest.get_current_modname()
 local path = minetest.get_modpath(modname)
 local S = minetest.get_translator(modname)
 mcl_mobs.fallback_node = minetest.registered_aliases["mapgen_dirt"] or "mcl_core:dirt"
+
+-- used by the libaries below.
+-- get node but use fallback for nil or unknown
+local node_ok = function(pos, fallback)
+	fallback = fallback or mcl_mobs.fallback_node
+	local node = minetest.get_node_or_nil(pos)
+	if node and minetest.registered_nodes[node.name] then
+		return node
+	end
+	return minetest.registered_nodes[fallback]
+end
+mcl_mobs.node_ok = node_ok
+
 --api and helpers
 -- effects: sounds and particles mostly
 dofile(path .. "/effects.lua")
@ -19,10 +32,9 @@ dofile(path .. "/items.lua")
 dofile(path .. "/pathfinding.lua")
 -- combat: attack logic
 dofile(path .. "/combat.lua")
-- the enity functions themselves
+-- the entity functions themselves
 dofile(path .. "/api.lua")

-
 --utility functions
 dofile(path .. "/breeding.lua")
 dofile(path .. "/spawning.lua")
@ -37,16 +49,6 @@ local old_spawn_icons = minetest.settings:get_bool("mcl_old_spawn_icons",false)
 local extended_pet_control = minetest.settings:get_bool("mcl_extended_pet_control",true)
 local difficulty = tonumber(minetest.settings:get("mob_difficulty")) or 1.0

-- get node but use fallback for nil or unknown
-local node_ok = function(pos, fallback)
-	fallback = fallback or mcl_mobs.fallback_node
-	local node = minetest.get_node_or_nil(pos)
-	if node and minetest.registered_nodes[node.name] then
-		return node
-	end
-	return minetest.registered_nodes[fallback]
-end
-
 --#### REGISTER FUNCS

 -- Code to execute before custom on_rightclick handling
@ -114,14 +116,8 @@ function mcl_mobs.register_mob(name, def)
 	mcl_mobs.spawning_mobs[name] = true
 	mcl_mobs.registered_mobs[name] = def

-	local can_despawn
-	if def.can_despawn ~= nil then
-		can_despawn = def.can_despawn
-	elseif def.spawn_class == "passive" then
-		can_despawn = false
-	else
-		can_despawn = true
-	end
+	local can_despawn = def.can_despawn
+	if def.can_despawn == nil then can_despawn = def.spawn_class ~= "passive" end

 	local function scale_difficulty(value, default, min, special)
 		if (not value) or (value == default) or (value == special) then
@ -141,7 +137,7 @@ function mcl_mobs.register_mob(name, def)
 	local final_def = {
 		use_texture_alpha = def.use_texture_alpha,
 		head_swivel = def.head_swivel or nil, -- bool to activate this function
-		head_yaw_offset = def.head_yaw_offset or 0, -- for wonkey model bones
+		head_yaw_offset = math.rad(def.head_yaw_offset or 0), -- for wonkey model bones
 		head_pitch_multiplier = def.head_pitch_multiplier or 1, --for inverted pitch
 		bone_eye_height = def.bone_eye_height or 1.4, -- head bone offset
 		head_eye_height = def.head_eye_height or def.bone_eye_height or 0, -- how hight aproximatly the mobs head is fromm the ground to tell the mob how high to look up at the player
@ -615,7 +611,7 @@ function mcl_mobs.register_egg(mob_id, desc, background_color, overlay_color, ad

 				pos.y = pos.y - 1
 				local mob = mcl_mobs.spawn(pos, mob_name)
-				if not object then
+				if not mob then
 					pos.y = pos.y + 1
 					mob = mcl_mobs.spawn(pos, mob_name)
 					if not mob then return end
--- a/mods/ENTITIES/mcl_mobs/mod.conf
+++ b/mods/ENTITIES/mcl_mobs/mod.conf
@ -1,5 +1,5 @@
 name = mcl_mobs
-author = PilzAdam
+author = PilzAdam, kno10
 description = Adds a mob API for mods to add animals or monsters, etc.
 depends = mcl_particles, mcl_luck
 optional_depends = mcl_weather, mcl_explosions, mcl_hunger, mcl_worlds, invisibility, lucky_block, cmi, doc_identifier, mcl_armor, mcl_portals, mcl_experience, mcl_sculk
--- a/mods/ENTITIES/mcl_mobs/mount.lua
+++ b/mods/ENTITIES/mcl_mobs/mount.lua
@ -1,110 +1,41 @@
 local math, vector, minetest, mcl_mobs = math, vector, minetest, mcl_mobs
 local mob_class = mcl_mobs.mob_class
-- lib_mount by Blert2112 (edited by TenPlus1)
+-- based on lib_mount by Blert2112 (edited by TenPlus1)

 local enable_crash = false
 local crash_threshold = 6.5 -- ignored if enable_crash=false
+local GRAVITY = -9.8

------------------------------------------------------------------------------
-
--
-- Helper functions
--
-
-local node_ok = function(pos, fallback)
-
-	fallback = fallback or mcl_mobs.fallback_node
-
-	local node = minetest.get_node_or_nil(pos)
-
-	if node and minetest.registered_nodes[node.name] then
-		return node
-	end
-
-	return {name = fallback}
-end
-
+local node_ok = mcl_mobs.node_ok
+local sign = math.sign -- minetest extension

 local function node_is(pos)
-
 	local node = node_ok(pos)
-
-	if node.name == "air" then
-		return "air"
-	end
-
-	if minetest.get_item_group(node.name, "lava") ~= 0 then
-		return "lava"
-	end
-
-	if minetest.get_item_group(node.name, "liquid") ~= 0 then
-		return "liquid"
-	end
-
-	if minetest.registered_nodes[node.name].walkable == true then
-		return "walkable"
-	end
-
+	if node.name == "air" then return "air" end
+	local ndef = minetest.registered_nodes[node.name]
+	if not ndef then return "other" end -- unknown/ignore
+	if ndef.groups.lava then return "lava" end
+	if ndef.groups.liquid then return "liquid" end
+	if ndef.walkable then return "walkable" end
 	return "other"
 end


-local function get_sign(i)
-
-	i = i or 0
-
-	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}
-end
-
-
-local function get_v(v)
-	return math.sqrt(v.x * v.x + v.z * v.z)
-end
-
-
 local function force_detach(player)
-
 	local attached_to = player:get_attach()
-
-	if not attached_to then
-		return
-	end
+	if not attached_to then return end

 	local entity = attached_to:get_luaentity()
-
-	if entity.driver
-	and entity.driver == player then
-
-		entity.driver = nil
-	end
+	if entity.driver and entity.driver == player then entity.driver = nil end

 	player:set_detach()
 	mcl_player.player_attached[player:get_player_name()] = false
-	player:set_eye_offset({x = 0, y = 0, z = 0}, {x = 0, y = 0, z = 0})
+	player:set_eye_offset(vector.zero(), vector.zero())
 	mcl_player.player_set_animation(player, "stand" , 30)
 	player:set_properties({visual_size = {x = 1, y = 1} })
-
 end

-------------------------------------------------------------------------------
-
-
-minetest.register_on_leaveplayer(function(player)
-	force_detach(player)
-end)
+minetest.register_on_leaveplayer(force_detach)

 minetest.register_on_shutdown(function()
 	local players = minetest.get_connected_players()
@ -118,39 +49,24 @@ minetest.register_on_dieplayer(function(player)
 	return true
 end)

-------------------------------------------------------------------------------
-
 function mcl_mobs.attach(entity, player)
-
-	local attach_at, eye_offset
-
-	entity.player_rotation = entity.player_rotation or {x = 0, y = 0, z = 0}
-	entity.driver_attach_at = entity.driver_attach_at or {x = 0, y = 0, z = 0}
-	entity.driver_eye_offset = entity.driver_eye_offset or {x = 0, y = 0, z = 0}
+	entity.player_rotation = entity.player_rotation or vector.zero()
+	entity.driver_attach_at = entity.driver_attach_at or vector.zero()
+	entity.driver_eye_offset = entity.driver_eye_offset or vector.zero()
 	entity.driver_scale = entity.driver_scale or {x = 1, y = 1}

-	local rot_view = 0
-
-	if entity.player_rotation.y == 90 then
-		rot_view = math.pi/2
-	end
-
-	attach_at = entity.driver_attach_at
-	eye_offset = entity.driver_eye_offset
+	local rot_view = entity.player_rotation.y == 90 and math.pi/2 or 0
+	local attach_at = entity.driver_attach_at
+	local eye_offset = entity.driver_eye_offset
 	entity.driver = player

 	force_detach(player)

 	player:set_attach(entity.object, "", attach_at, entity.player_rotation)
 	mcl_player.player_attached[player:get_player_name()] = true
-	player:set_eye_offset(eye_offset, {x = 0, y = 0, z = 0})
+	player:set_eye_offset(eye_offset, vector.zero())

-	player:set_properties({
-		visual_size = {
-			x = entity.driver_scale.x,
-			y = entity.driver_scale.y
-		}
-	})
+	player:set_properties({ visual_size = entity.driver_scale })

 	minetest.after(0.2, function(name)
 		local player = minetest.get_player_by_name(name)
@ -164,162 +80,88 @@ end


 function mcl_mobs.detach(player, offset)
-
 	force_detach(player)
-
 	mcl_player.player_set_animation(player, "stand" , 30)
-
-	--local pos = player:get_pos()
-
-	--pos = {x = pos.x + offset.x, y = pos.y + 0.2 + offset.y, z = pos.z + offset.z}
-
-	player:add_velocity(vector.new(math.random(-6,6),math.random(5,8),math.random(-6,6))) --throw the rider off
-
-	--[[
-	minetest.after(0.1, function(name, pos)
-		local player = minetest.get_player_by_name(name)
-		if player then
-			player:set_pos(pos)
-		end
-	end, player:get_player_name(), pos)
-	]]--
+	player:add_velocity(vector.new(math.random()*12-6,math.random()*3+5,math.random()*12-6)) --throw the rider off
 end


 function mcl_mobs.drive(entity, moving_anim, stand_anim, can_fly, dtime)
-
-	local rot_view = 0
-
-	if entity.player_rotation.y == 90 then
-		rot_view = math.pi/2
-	end
-
-	local acce_y = 0
 	local velo = entity.object:get_velocity()
-
-	entity.v = get_v(velo) * get_sign(entity.v)
+	local v = math.sqrt(velo.x * velo.x + velo.y * velo.y)
+	local acce_y = GRAVITY

 	-- process controls
 	if entity.driver then
-
 		local ctrl = entity.driver:get_player_control()
-
-		-- move forwards
-		if ctrl.up then
-
-			entity.v = entity.v + entity.accel / 10 * entity.run_velocity / 2.6
-
-		-- move backwards
-		elseif ctrl.down then
-
-			if entity.max_speed_reverse == 0 and entity.v == 0 then
-				return
-			end
-
-			entity.v = entity.v - entity.accel / 10
+		if ctrl.up then -- forward
+			v = v + entity.accel * 0.1 * entity.run_velocity * 0.385
+		elseif ctrl.down then -- backwards
+			if entity.max_speed_reverse == 0 and v == 0 then return end
+			v = v - entity.accel * 0.1 * entity.run_velocity * 0.385
 		end

-		-- fix mob rotation
-		entity.object:set_yaw(entity.driver:get_look_horizontal() - entity.rotate)
+		entity:set_yaw(entity.driver:get_look_horizontal() - entity.rotate, 2)

 		if can_fly then
-
+			-- FIXME: use acce_y instead?
 			-- fly up
 			if ctrl.jump then
-				velo.y = velo.y + 1
-				if velo.y > entity.accel then velo.y = entity.accel end
-
-			elseif velo.y > 0 then
+				velo.y = math.min(velo.y + 1, entity.accel)
+			elseif velo.y > 0.1 then
 				velo.y = velo.y - 0.1
-				if velo.y < 0 then velo.y = 0 end
+			elseif velo.y > 0 then
+				velo.y = 0
 			end

 			-- fly down
 			if ctrl.sneak then
-				velo.y = velo.y - 1
-				if velo.y < -entity.accel then velo.y = -entity.accel end
-
-			elseif velo.y < 0 then
+				velo.y = math.max(velo.y - 1, -entity.accel)
+			elseif velo.y < -0.1 then
 				velo.y = velo.y + 0.1
-				if velo.y > 0 then velo.y = 0 end
+			elseif velo.y < 0 then
+				velo.y = 0
 			end
-
 		else
-
 			-- jump
 			if ctrl.jump then
-
 				if velo.y == 0 then
 					velo.y = velo.y + entity.jump_height
-					acce_y = acce_y + (acce_y * 3) + 1
+					acce_y = acce_y + 1
 				end
 			end
-
 		end
 	end

-	-- Stop!
-	local s = get_sign(entity.v)
-
-	entity.v = entity.v - 0.02 * s
-
-	if s ~= get_sign(entity.v) then
-
-		entity.object:set_velocity({x = 0, y = 0, z = 0})
-		entity.v = 0
-		return
+	if math.abs(v) < 0.02 then -- stop
+		entity.object:set_velocity(vector.zero())
+		v = 0
+	else
+		v = v - 0.02 * sign(v) -- slow down
 	end

 	-- if not moving then set animation and return
-	if entity.v == 0 and velo.x == 0 and velo.y == 0 and velo.z == 0 then
-
-		if stand_anim then
-			mcl_mobs:set_animation(entity, stand_anim)
-		end
-
+	if v == 0 and velo.x == 0 and velo.y == 0 and velo.z == 0 then
+		entity:set_animation(stand_anim)
 		return
-	end
-
-	-- set moving animation
-	if moving_anim then
-		mcl_mobs:set_animation(entity, moving_anim)
+	else
+		entity:set_animation(moving_anim)
 	end

 	-- enforce speed limit forward and reverse
-	local max_spd = entity.max_speed_reverse
-
-	if get_sign(entity.v) >= 0 then
-		max_spd = entity.max_speed_forward
-	end
-
-	if math.abs(entity.v) > max_spd then
-		entity.v = entity.v - get_sign(entity.v)
-	end
+	v = math.max(-entity.max_speed_reverse, math.min(v, entity.max_speed_forward))

 	-- Set position, velocity and acceleration
 	local p = entity.object:get_pos()
-	local new_velo
-	local new_acce = {x = 0, y = -9.8, z = 0}
-
 	p.y = p.y - 0.5

 	local ni = node_is(p)
-	local v = entity.v
-
 	if ni == "air" then
-
-		if can_fly == true then
-			new_acce.y = 0
-		end
-
+		if can_fly then acce_y = acce_y - GRAVITY end
 	elseif ni == "liquid" or ni == "lava" then
-
 		if ni == "lava" and entity.lava_damage ~= 0 then
-
 			entity.lava_counter = (entity.lava_counter or 0) + dtime
-
 			if entity.lava_counter > 1 then
-
 				minetest.sound_play("default_punch", {
 					object = entity.object,
 					max_hear_distance = 5
@ -336,18 +178,15 @@ function mcl_mobs.drive(entity, moving_anim, stand_anim, can_fly, dtime)

 		if entity.terrain_type == 2
 		or entity.terrain_type == 3 then
-
-			new_acce.y = 0
+			acce_y = 0
 			p.y = p.y + 1
-
 			if node_is(p) == "liquid" then
-
 				if velo.y >= 5 then
 					velo.y = 5
 				elseif velo.y < 0 then
-					new_acce.y = 20
+					acce_y = 20
 				else
-					new_acce.y = 5
+					acce_y = 5
 				end
 			else
 				if math.abs(velo.y) < 1 then
@ -362,75 +201,51 @@ function mcl_mobs.drive(entity, moving_anim, stand_anim, can_fly, dtime)
 		end
 	end

-	new_velo = get_velocity(v, entity.object:get_yaw() - rot_view, velo.y)
-	new_acce.y = new_acce.y + acce_y
+	local rot_view = entity.player_rotation.y == 90 and math.pi/2 or 0
+	local new_yaw = entity.object:get_yaw() - rot_view
+	local new_velo = vector.new(-math.sin(new_yaw) * v, velo.y, math.cos(new_yaw) * v)

 	entity.object:set_velocity(new_velo)
-	entity.object:set_acceleration(new_acce)
+	entity.object:set_acceleration(vector.new(0, acce_y, 0))

-	-- CRASH!
 	if enable_crash then
-
-		local intensity = entity.v2 - v
-
-		if intensity >= crash_threshold then
-
+		if v >= crash_threshold then
 			entity.object:punch(entity.object, 1.0, {
 				full_punch_interval = 1.0,
-				damage_groups = {fleshy = intensity}
+				damage_groups = {fleshy = v}
 			}, nil)
-
 		end
 	end
-
-	entity.v2 = v
 end

 -- directional flying routine by D00Med (edited by TenPlus1)
-
 function mcl_mobs.fly(entity, dtime, speed, shoots, arrow, moving_anim, stand_anim)
-
 	local ctrl = entity.driver:get_player_control()
 	local velo = entity.object:get_velocity()
 	local dir = entity.driver:get_look_dir()
-	local yaw = entity.driver:get_look_horizontal() + 1.57 -- offset fix between old and new commands
+	local yaw = entity.driver:get_look_horizontal()

 	if ctrl.up then
-		entity.object:set_velocity({
-			x = dir.x * speed,
-			y = dir.y * speed + 2,
-			z = dir.z * speed
-		})
-
+		entity.object:set_velocity(vector.new(dir.x * speed, dir.y * speed + 2, dir.z * speed))
 	elseif ctrl.down then
-		entity.object:set_velocity({
-			x = -dir.x * speed,
-			y = dir.y * speed + 2,
-			z = -dir.z * speed
-		})
-
+		entity.object:set_velocity(vector.new(-dir.x * speed, dir.y * speed + 2, -dir.z * speed))
 	elseif not ctrl.down or ctrl.up or ctrl.jump then
-		entity.object:set_velocity({x = 0, y = -2, z = 0})
+		entity.object:set_velocity(vector.new(0, -2, 0))
 	end

-	entity.object:set_yaw(yaw + math.pi + math.pi / 2 - entity.rotate)
+	entity:set_yaw(yaw - entity.rotate, 2)

 	-- firing arrows
 	if ctrl.LMB and ctrl.sneak and shoots then
-
 		local pos = entity.object:get_pos()
-		local obj = minetest.add_entity({
-			x = pos.x + 0 + dir.x * 2.5,
-			y = pos.y + 1.5 + dir.y,
-			z = pos.z + 0 + dir.z * 2.5}, arrow)
-
+		local obj = minetest.add_entity(vector.offset(pos, dir.x * 2.5, 1.5 + dir.y, dir.z * 2.5), arrow)
 		local ent = obj:get_luaentity()
 		if ent then
 			ent.switch = 1 -- for mob specific arrows
 			ent.owner_id = tostring(entity.object) -- so arrows dont hurt entity you are riding
-			local vec = {x = dir.x * 6, y = dir.y * 6, z = dir.z * 6}
+			local vec = vector.new(dir.x * 6, dir.y * 6, dir.z * 6)
 			local yaw = entity.driver:get_look_horizontal()
-			obj:set_yaw(yaw + math.pi / 2)
+			obj:set_yaw(yaw)
 			obj:set_velocity(vec)
 		else
 			obj:remove()
@ -439,11 +254,9 @@ function mcl_mobs.fly(entity, dtime, speed, shoots, arrow, moving_anim, stand_an

 	-- change animation if stopped
 	if velo.x == 0 and velo.y == 0 and velo.z == 0 then
-
-		mcl_mobs:set_animation(entity, stand_anim)
+		entity:set_animation(stand_anim)
 	else
-		-- moving animation
-		mcl_mobs:set_animation(entity, moving_anim)
+		entity:set_animation(moving_anim)
 	end
 end

@ -452,12 +265,7 @@ mcl_mobs.mob_class.fly = mcl_mobs.fly
 mcl_mobs.mob_class.attach = mcl_mobs.attach

 function mob_class:on_detach_child(child)
-	if self.detach_child then
-		if self.detach_child(self, child) then
-			return
-		end
-	end
-	if self.driver == child then
-		self.driver = nil
-	end
+	if self.detach_child and self.detach_child(self, child) then return end
+	if self.driver == child then self.driver = nil end
 end
+
--- a/mods/ENTITIES/mcl_mobs/movement.lua
+++ b/mods/ENTITIES/mcl_mobs/movement.lua
--- a/mods/ENTITIES/mcl_mobs/pathfinding.lua
+++ b/mods/ENTITIES/mcl_mobs/pathfinding.lua
@ -42,8 +42,8 @@ function append_paths (wp1, wp2)
 		mcl_log("Cannot append wp's")
 		return
 	end
-	output_table(wp1)
-	output_table(wp2)
+	--output_table(wp1)
+	--output_table(wp2)
 	for _,a in pairs (wp2) do
 		table.insert(wp1, a)
 	end
@ -51,18 +51,13 @@ function append_paths (wp1, wp2)
 end

 local function output_enriched (wp_out)
-	mcl_log("Output enriched path")
+	--mcl_log("Output enriched path")
 	local i = 0
 	for _,outy in pairs (wp_out) do
 		i = i + 1
-		mcl_log("Pos ".. i ..":" .. minetest.pos_to_string(outy["pos"]))
-
 		local action =  outy["action"]
 		if action then
-			--mcl_log("Pos ".. i ..":" .. minetest.pos_to_string(outy["pos"]))
-			mcl_log("type: " .. action["type"])
-			mcl_log("action: " .. action["action"])
-			mcl_log("target: " .. minetest.pos_to_string(action["target"]))
+			mcl_log("Pos ".. i ..":" .. minetest.pos_to_string(outy["pos"])..", type: " .. action["type"]..", action: " .. action["action"]..", target: " .. minetest.pos_to_string(action["target"]))
 		end
 		--mcl_log("failed attempts: " .. outy["failed_attempts"])
 	end
@ -113,17 +108,17 @@ end
 local last_pathing_time = os.time()

 function mob_class:ready_to_path(prioritised)
-	mcl_log("Check ready to path")
+	-- mcl_log("Check ready to path")
 	if self._pf_last_failed and (os.time() - self._pf_last_failed) < PATHFINDING_FAIL_WAIT then
-		mcl_log("Not ready to path as last fail is less than threshold: " .. (os.time() - self._pf_last_failed))
+		-- mcl_log("Not ready to path as last fail is less than threshold: " .. (os.time() - self._pf_last_failed))
 		return false
 	else
 		local time_since_path_start = os.time() - last_pathing_time
-		mcl_log("time_since_path_start: " .. tostring(time_since_path_start))
 		if prioritised or (time_since_path_start) > PATHING_START_DELAY then
-			mcl_log("We are ready to pathfind, no previous fail or we are past threshold")
+			mcl_log("We are ready to pathfind, no previous fail or we are past threshold: "..tostring(time_since_path_start))
 			return true
 		end
+		mcl_log("time_since_path_start: " .. tostring(time_since_path_start))
 	end
 end

@ -272,13 +267,7 @@ function mob_class:gopath(target, callback_arrived, prioritised)
 		--output_table(wp)
 		self._target = t
 		self.callback_arrived = callback_arrived
-		local current_location = table.remove(wp,1)
-		if current_location and current_location["pos"] then
-			mcl_log("Removing first co-ord? " .. tostring(current_location["pos"]))
-		else
-			mcl_log("Nil pos")
-		end
-		self.current_target = current_location
+		self.current_target = table.remove(wp,1)
 		self.waypoints = wp
 		self.state = PATHFINDING
 		return true
@ -300,19 +289,17 @@ function mob_class:interact_with_door(action, target)

 		local n = minetest.get_node(target)
 		if n.name:find("_b_") or n.name:find("_t_") then
-			mcl_log("Door")
 			local def = minetest.registered_nodes[n.name]
-			local closed = n.name:find("_b_1") or n.name:find("_t_1")
-			--if self.state == PATHFINDING then
-				if closed and action == "open" and def.on_rightclick then
-					mcl_log("Open door")
-					def.on_rightclick(target,n,self)
-				end
-				if not closed and action == "close" and def.on_rightclick then
-					mcl_log("Close door")
-					def.on_rightclick(target,n,self)
-				end
-			--else
+			local meta = minetest.get_meta(target)
+			local closed = meta:get_int("is_open") == 0
+			if closed and action == "open" and def.on_rightclick then
+				mcl_log("Open door")
+				def.on_rightclick(target,n,self)
+			end
+			if not closed and action == "close" and def.on_rightclick then
+				mcl_log("Close door")
+				def.on_rightclick(target,n,self)
+			end
 		else
 			mcl_log("Not door")
 		end
@ -333,6 +320,7 @@ function mob_class:do_pathfind_action(action)
 		end
 		if type and type == "door" then
 			mcl_log("Type is door")
+			self.object:set_velocity(vector.zero())
 			self:interact_with_door(action_val, target)
 		end
 	end
@ -343,8 +331,7 @@ function mob_class:check_gowp(dtime)

 	-- no destination
 	if not p or not self._target then
-		mcl_log("p: ".. tostring(p))
-		mcl_log("self._target: ".. tostring(self._target))
+		mcl_log("p: ".. tostring(p)..", self._target: ".. tostring(self._target))
 		return
 	end

@ -358,8 +345,8 @@ function mob_class:check_gowp(dtime)
 		self.current_target = nil
 		self.state = "stand"
 		self.order = "stand"
-		self.object:set_velocity({x = 0, y = 0, z = 0})
-		self.object:set_acceleration({x = 0, y = 0, z = 0})
+		self.object:set_velocity(vector.zero())
+		self.object:set_acceleration(vector.zero())
 		if self.callback_arrived then return self.callback_arrived(self) end
 		return true
 	elseif not self.current_target then
@ -369,13 +356,27 @@ function mob_class:check_gowp(dtime)
 	-- More pathing to be done
 	local distance_to_current_target = 50
 	if self.current_target and self.current_target["pos"] then
-		distance_to_current_target = vector.distance(p,self.current_target["pos"])
+		local dx, dy, dz = self.current_target["pos"].x-p.x, self.current_target["pos"].y-p.y, self.current_target["pos"].z-p.z
+		distance_to_current_target = (dx*dx+dy*dy*0.25+dz*dz)^0.5 -- reduced weight on y
+		--distance_to_current_target = vector.distance(p,self.current_target["pos"])
+	end
+	-- also check next target, maybe we were too fast
+	local next_target = #self.waypoints > 1 and self.waypoints[1]
+	if not self.current_target["action"] and next_target and next_target["pos"] and distance_to_current_target < 1.5 then
+		local dx, dy, dz = next_target["pos"].x-p.x, next_target["pos"].y-p.y, next_target["pos"].z-p.z
+		local distance_to_next_target = (dx*dx+dy*dy*0.25+dz*dz)^0.5 -- reduced weight on y
+		if distance_to_next_target < distance_to_current_target then
+			mcl_log("Skipped one waypoint.")
+			self.current_target = table.remove(self.waypoints, 1) -- pop waypoint already
+			distance_to_current_target = distance_to_next_target
+		end
 	end

 	-- 0.6 is working but too sensitive. sends villager back too frequently. 0.7 is quite good, but not with heights
 	-- 0.8 is optimal for 0.025 frequency checks and also 1... Actually. 0.8 is winning
 	-- 0.9 and 1.0 is also good. Stick with unless door open or closing issues
-	if self.waypoints and #self.waypoints > 0 and ( not self.current_target or not self.current_target["pos"] or distance_to_current_target < 0.9 ) then
+	local threshold = self.current_target["action"] and 0.8 or 1.2
+	if self.waypoints and #self.waypoints > 0 and ( not self.current_target or not self.current_target["pos"] or distance_to_current_target < threshold ) then
 		-- We have waypoints, and are at current_target or have no current target. We need a new current_target.
 		self:do_pathfind_action (self.current_target["action"])

@ -383,7 +384,16 @@ function mob_class:check_gowp(dtime)
 		mcl_log("There after " .. failed_attempts .. " failed attempts. current target:".. minetest.pos_to_string(self.current_target["pos"]) .. ". Distance: " ..  distance_to_current_target)

 		self.current_target = table.remove(self.waypoints, 1)
+		-- use smoothing
+		--[[if #self.waypoints > 0 and not self.current_target["action"] then
+			local curwp, nextwp = self.current_target["pos"], self.waypoints[1]["pos"]
+			self:go_to_pos(vector.new(curwp.x*0.7+nextwp.x*0.3,curwp.y,curwp.z*0.7+nextwp.z*0.3))
+			return
+		end]]--
 		self:go_to_pos(self.current_target["pos"])
+		if self.current_target["action"] then
+			self:set_velocity(self.walk_velocity * 0.25)
+		end
 		return
 	elseif self.current_target and self.current_target["pos"] then
 		-- No waypoints left, but have current target and not close enough. Potentially last waypoint to go to.
@ -391,19 +401,20 @@ function mob_class:check_gowp(dtime)
 		self.current_target["failed_attempts"] = self.current_target["failed_attempts"] + 1
 		local failed_attempts = self.current_target["failed_attempts"]
 		if failed_attempts >= PATHFINDING_FAIL_THRESHOLD then
-			mcl_log("Failed to reach position (" .. minetest.pos_to_string(self.current_target["pos"]) .. ") too many times. Abandon route. Times tried: " .. failed_attempts)
+			mcl_log("Failed to reach position " .. minetest.pos_to_string(self.current_target["pos"]) .. " too many times. At: "..minetest.pos_to_string(p).." Abandon route. Times tried: " .. failed_attempts .. " current distance "..distance_to_current_target)
 			self.state = "stand"
 			self.current_target = nil
 			self.waypoints = nil
 			self._target = nil
 			self._pf_last_failed = os.time()
-			self.object:set_velocity({x = 0, y = 0, z = 0})
-			self.object:set_acceleration({x = 0, y = 0, z = 0})
+			self.object:set_velocity(vector.zero())
+			self.object:set_acceleration(vector.zero())
 			return
 		end

 		--mcl_log("Not at pos with failed attempts ".. failed_attempts ..": ".. minetest.pos_to_string(p) .. "self.current_target: ".. minetest.pos_to_string(self.current_target["pos"]) .. ". Distance: ".. distance_to_current_target)
 		self:go_to_pos(self.current_target["pos"])
+		self:turn_by((math.random() - 0.5), 2) -- but try turning left or right
 		-- Do i just delete current_target, and return so we can find final path.
 	else
 		-- Not at target, no current waypoints or current_target. Through the door and should be able to path to target.
@ -444,7 +455,7 @@ function mob_class:check_gowp(dtime)
 		mcl_log("Current p: ".. minetest.pos_to_string(updated_p))

 		-- 1.6 is good. is 1.9 better? It could fail less, but will it path to door when it isn't after door
-		if distance_to_cur_targ > 1.9 then
+		if distance_to_cur_targ > 1.6 then
 			mcl_log("not close to current target: ".. minetest.pos_to_string(self.current_target["pos"]))
 			self:go_to_pos(self._current_target)
 		else
--- a/mods/ENTITIES/mcl_mobs/physics.lua
+++ b/mods/ENTITIES/mcl_mobs/physics.lua
@ -6,6 +6,18 @@ local ENTITY_CRAMMING_MAX = 24
 local CRAMMING_DAMAGE = 3
 local DEATH_DELAY = 0.5
 local DEFAULT_FALL_SPEED = -9.81*1.5
+local PI = math.pi
+local HALFPI = 0.5 * PI
+local TWOPI = 2 * PI -- aka tau, but not very common
+local random = math.random
+local min = math.min
+local max = math.max
+local floor = math.floor
+local abs = math.abs
+local atan2 = math.atan2
+local sin = math.sin
+local cos = math.cos
+local node_ok = mcl_mobs.node_ok

 local PATHFINDING = "gowp"
 local mobs_debug = minetest.settings:get_bool("mobs_debug", false)
@ -13,20 +25,6 @@ local mobs_drop_items = minetest.settings:get_bool("mobs_drop_items") ~= false
 local mob_active_range = tonumber(minetest.settings:get("mcl_mob_active_range")) or 48
 local show_health = false

-- get node but use fallback for nil or unknown
-local node_ok = function(pos, fallback)
-
-	fallback = fallback or mcl_mobs.fallback_node
-
-	local node = minetest.get_node_or_nil(pos)
-
-	if node and minetest.registered_nodes[node.name] then
-		return node
-	end
-
-	return minetest.registered_nodes[fallback]
-end
-
 -- check if within physical map limits (-30911 to 30927)
 local function within_limits(pos, radius)
 	local wmin, wmax = -30912, 30928
@ -56,9 +54,7 @@ end

 -- Return true if object is in view_range
 function mob_class:object_in_range(object)
-	if not object then
-		return false
-	end
+	if not object then return false end
 	local factor
 	-- Apply view range reduction for special player armor
 	if object:is_player() then
@ -110,24 +106,21 @@ function mob_class:item_drop(cooked, looting_level)

 		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)
+		if random() < chance then
+			num = 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)
+			num = num + floor(random(0, looting_level) + 0.5)
 		end

 		if num > 0 then
 			item = dropdef.name

 			if cooked then
-
-				local output = minetest.get_craft_result({
-					method = "cooking", width = 1, items = {item}})
-
+				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
@ -135,17 +128,12 @@ function mob_class:item_drop(cooked, looting_level)

 			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
+				if obj and obj:get_luaentity() then
+					obj:set_velocity(vector.new((random() - 0.5) * 1.5, 6, (random() - 0.5) * 1.5))
+				elseif obj then
+					obj:remove() -- item does not exist
+				end
 			end
 		end
 	end
@ -156,32 +144,29 @@ end
 -- collision function borrowed amended from jordan4ibanez open_ai mod
 function mob_class:collision()
 	local pos = self.object:get_pos()
-	if not pos then return {0,0} end
+	if not pos then return 0,0 end
 	local vel = self.object:get_velocity()
-	local x = 0
-	local z = 0
+	local x, z = 0, 0
 	local width = -self.collisionbox[1] + self.collisionbox[4] + 0.5
 	for _,object in pairs(minetest.get_objects_inside_radius(pos, width)) do
-
 		local ent = object:get_luaentity()
 		if object:is_player() or (ent and ent.is_mob and object ~= self.object) then
-
 			if object:is_player() and mcl_burning.is_burning(self.object) then
 				mcl_burning.set_on_fire(object, 4)
 			end

 			local pos2 = object:get_pos()
-			local vec  = {x = pos.x - pos2.x, z = pos.z - pos2.z}
-			local force = (width + 0.5) - vector.distance(
-				{x = pos.x, y = 0, z = pos.z},
-				{x = pos2.x, y = 0, z = pos2.z})
-
-			x = x + (vec.x * force)
-			z = z + (vec.z * force)
+			local vx, vz  = pos.x - pos2.x, pos.z - pos2.z
+			local force = width - (vx*vx+vz*vz)^0.5
+			if force > 0 then
+				force = force * force * (object:is_player() and 2 or 1) -- players push more
+				-- minetest.log("mob push force "..force.." "..tostring(self.name).." by "..tostring(ent and ent.name or "player"))
+				x = x + vx * force
+				z = z + vz * force
+			end
 		end
 	end
-
-	return({x,z})
+	return x, z
 end

 function mob_class:check_death_and_slow_mob()
@ -192,196 +177,113 @@ function mob_class:check_death_and_slow_mob()
 	local v = self.object:get_velocity()
 	if v then
 		--diffuse object velocity
-		self.object:set_velocity({x = v.x*d, y = v.y, z = v.z*d})
+		self.object:set_velocity(vector.new(v.x*d, v.y, v.z*d))
 	end
 	return dying
 end

 -- move mob in facing direction
 function mob_class:set_velocity(v)
-	if not v then return end
-
-	local c_x, c_y = 0, 0
-
+	local c_x, c_z = 0, 0
 	-- can mob be pushed, if so calculate direction
 	if self.pushable then
-		c_x, c_y = unpack(self:collision())
+		c_x, c_z = self:collision()
 	end
-
-	-- halt mob if it has been ordered to stay
-	if self.order == "stand" or self.order == "sit" then
-		self.acc = vector.zero()
-		return
-	end
-
-	local yaw = (self.object:get_yaw() or 0) + self.rotate
-	local vv = self.object:get_velocity()
-
-	if vv and yaw then
-		self.acc = vector.new(((math.sin(yaw) * -v) + c_x) * .4, 0, ((math.cos(yaw) * v) + c_y) * .4)
+	if v > 0 then
+		local yaw = (self.object:get_yaw() or 0) + self.rotate
+		local x = ((-sin(yaw) * v) + c_x) * .4
+		local z = (( cos(yaw) * v) + c_z) * .4
+		if not self.acc then
+			self.acc = vector.new(x, 0, z)
+		else
+			self.acc.x, self.acc.y, self.acc.z = x, 0, z
+		end
+	else -- allow standing mobs to be pushed
+		if not self.acc then
+			self.acc = vector.new(c_x * .2, 0, c_z * .2)
+		else
+			self.acc.x, self.acc.y, self.acc.z = c_x * .2, 0, c_z * .2
+		end
 	end
 end

-- calculate mob velocity
+-- calculate mob velocity (2d)
 function mob_class:get_velocity()
 	local v = self.object:get_velocity()
-	if v then
-		return (v.x * v.x + v.z * v.z) ^ 0.5
-	end
-
-	return 0
+	if not v then return 0 end
+	return (v.x*v.x + v.z*v.z)^0.5
 end

 function mob_class:update_roll()
 	local is_Fleckenstein = self.nametag == "Fleckenstein"
-	local was_Fleckenstein = false
+	if not is_Fleckenstein and not self.is_Fleckenstein then return end

 	local rot = self.object:get_rotation()
-	rot.z = is_Fleckenstein and pi or 0
+	rot.z = is_Fleckenstein and 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
+	if is_Fleckenstein ~= self.is_Fleckenstein then
 		local pos = self.object:get_pos()
-		pos.y = pos.y + (acbox[2] + acbox[5])
+		local cbox = is_Fleckenstein and table.copy(self.collisionbox) or self.object:get_properties().collisionbox
+		pos.y = pos.y + (cbox[2] + cbox[5])
+		cbox[2], cbox[5] = -cbox[5], -cbox[2]
+		-- This leads to child mobs having the wrong collisionbox
+		-- and seeing as it seems to be nothing but an easter egg
+		-- i've put it inside the if. Which just makes it be upside
+		-- down lol.
+		self.object:set_properties({collisionbox = cbox})
 		self.object:set_pos(pos)
 	end
-
-	if is_Fleckenstein then
-		cbox[2], cbox[5] = -cbox[5], -cbox[2]
-		self.object:set_properties({collisionbox = cbox})
-	-- This leads to child mobs having the wrong collisionbox
-	-- and seeing as it seems to be nothing but an easter egg
-	-- i've put it inside the if. Which just makes it be upside
-	-- down lol.
-	end
-
+	self.is_Fleckenstein = is_Fleckenstein
 end

-local function shortest_term_of_yaw_rotation(self, rot_origin, rot_target, nums)
-
-	if not rot_origin or not rot_target then
-		return
-	end
-
-	rot_origin = math.deg(rot_origin)
-	rot_target = math.deg(rot_target)
-
-	if rot_origin < rot_target then
-		if math.abs(rot_origin-rot_target)<180 then
-			if nums then
-				return rot_target-rot_origin
-			else
-				return 1
-			end
-		else
-			if nums then
-				return -(rot_origin-(rot_target-360))
-			else
-				return -1
-			end
-		end
-	else
-		if math.abs(rot_origin-rot_target)<180 then
-			if nums then
-				return rot_target-rot_origin
-			else
-				return -1
-			end
-		else
-			if nums then
-				return (rot_target-(rot_origin-360))
-			else
-				return 1
-			end
-		end
-	end
-
+-- Relative turn, primarily for random turning
+-- @param dtime deprecated: ignored now, because of smooth rotations
+function mob_class:turn_by(angle, delay, dtime)
+	return self:set_yaw((self.object:get_yaw() or 0) + angle, delay, dtime)
+end
+-- Turn into a direction (e.g., to the player, or away)
+-- @param dtime deprecated: ignored now, because of smooth rotations
+function mob_class:turn_in_direction(dx, dz, delay, dtime)
+	if abs(dx) == 0 and abs(dz) == 0 then return self.object:get_yaw() + self.rotate end
+	return self:set_yaw(-atan2(dx, dz) - self.rotate, delay, dtime)
 end
-
-
-
 -- set and return valid yaw
+-- @param dtime deprecated: ignored now, because of smooth rotations
 function mob_class:set_yaw(yaw, delay, dtime)
 	if self.noyaw then return end
-
+	if self._kb_turn then return yaw end -- knockback in effect
 	if not self.object:get_yaw() or not self.object:get_pos() then return end
-
-	if self.state ~= PATHFINDING then
-		self._turn_to = yaw
-	end
-
-	--mcl_log("Yaw is: \t\t" .. tostring(math.deg(yaw)))
-	--mcl_log("self.object:get_yaw() is: \t" .. tostring(math.deg(self.object:get_yaw())))
-
-	--clamp our yaw to a 360 range
-	if math.deg(self.object:get_yaw()) > 360 then
-		self.object:set_yaw(math.rad(0))
-	elseif math.deg(self.object:get_yaw()) < 0 then
-		self.object:set_yaw(math.rad(360))
-	end
-
-	if math.deg(yaw) > 360 then
-		yaw=math.rad(math.deg(yaw)%360)
-	elseif math.deg(yaw) < 0 then
-		yaw=math.rad(((360*5)-math.deg(yaw))%360)
-	end
-
-	--calculate the shortest way to turn to find our target
-	local target_shortest_path = shortest_term_of_yaw_rotation(self, self.object:get_yaw(), yaw, false)
-	local target_shortest_path_nums = shortest_term_of_yaw_rotation(self, self.object:get_yaw(), yaw, true)
-
-	--turn in the shortest path possible toward our target. if we are attacking, don't dance.
-	if (math.abs(target_shortest_path) > 50 and not self._kb_turn) and (self.attack and self.attack:get_pos() or self.following and self.following:get_pos()) then
-		if self.following then
-			target_shortest_path = shortest_term_of_yaw_rotation(self, self.object:get_yaw(), minetest.dir_to_yaw(vector.direction(self.object:get_pos(), self.following:get_pos())), true)
-			target_shortest_path_nums = shortest_term_of_yaw_rotation(self, self.object:get_yaw(), minetest.dir_to_yaw(vector.direction(self.object:get_pos(), self.following:get_pos())), false)
-		else
-			target_shortest_path = shortest_term_of_yaw_rotation(self, self.object:get_yaw(), minetest.dir_to_yaw(vector.direction(self.object:get_pos(), self.attack:get_pos())), true)
-			target_shortest_path_nums = shortest_term_of_yaw_rotation(self, self.object:get_yaw(), minetest.dir_to_yaw(vector.direction(self.object:get_pos(), self.attack:get_pos())), false)
-		end
-	end
-
-	local ddtime = 0.05 --set_tick_rate
-
-	if dtime then
-		ddtime = dtime
-	end
-
-	if math.abs(target_shortest_path_nums) > 10 then
-		self.object:set_yaw(self.object:get_yaw()+(target_shortest_path*(3.6*ddtime)))
-		if validate_vector(self.acc) then
-			self.acc=vector.rotate_around_axis(self.acc,vector.new(0,1,0), target_shortest_path*(3.6*ddtime))
-		end
-	end
-
-	delay = delay or 0
-
-	yaw = self.object:get_yaw()
-
-	if delay == 0 then
-		if self.shaking and dtime then
-			yaw = yaw + (math.random() * 2 - 1) * 5 * dtime
-		end
-		--self:update_roll()
-		return yaw
-	end
-
-	self.target_yaw = yaw
-	self.delay = delay
-
+	self.delay = delay or 0
+	self.target_yaw = yaw % TWOPI
 	return self.target_yaw
 end

-- global function to set mob yaw
-function mcl_mobs.yaw(self, yaw, delay, dtime)
-	return mob_class.set_yaw(self, yaw, delay, dtime)
+-- improved smooth rotation
+function mob_class:check_smooth_rotation(dtime)
+	if not self.target_yaw then return end
+
+	local delay = self.delay
+	local initial_yaw = self.object:get_yaw() or 0
+	local yaw -- resulting yaw for this tick
+	if delay and delay > 1 then
+		local dif = (self.target_yaw - initial_yaw + PI) % TWOPI - PI
+		yaw = (initial_yaw + dif / delay) % TWOPI
+		self.delay = delay - 1
+	else
+		yaw = self.target_yaw
+	end
+
+	if self.shaking then
+		yaw = yaw + (random() * 2 - 1) / 72 * dtime
+	end
+	--[[ needed? if self.acc then
+		local change = yaw - initial_yaw
+		local si, co = sin(change), cos(change)
+		self.acc.x, self.acc.y = co * self.acc.x - si * self.acc.y, si * self.acc.x + co * self.acc.y
+	end ]]--
+	self.object:set_yaw(yaw)
+	self:update_roll()
 end

 -- are we flying in what we are suppose to? (taikedz)
@ -489,7 +391,7 @@ function mob_class:check_for_death(cause, cmi_cause)

 			if ((not self.child) or self.type ~= "animal") and (minetest.get_us_time() - self.xp_timestamp <= math.huge) then
 				local pos = self.object:get_pos()
-				local xp_amount = math.random(self.xp_min, self.xp_max)
+				local xp_amount = random(self.xp_min, self.xp_max)

 				if not mcl_sculk.handle_death(pos, xp_amount) then
 					--minetest.log("Xp not thrown")
@ -562,7 +464,7 @@ function mob_class:check_for_death(cause, cmi_cause)
 	elseif self.animation and self.animation.die_start and self.animation.die_end then
 		local frames = self.animation.die_end - self.animation.die_start
 		local speed = self.animation.die_speed or 15
-		length = math.max(frames / speed, 0) + DEATH_DELAY
+		length = max(frames / speed, 0) + DEATH_DELAY
 		self:set_animation( "die")
 	else
 		length = 1 + DEATH_DELAY
@ -672,7 +574,7 @@ function mob_class:do_env_damage()

 	-- 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}
+	local pos2 = vector.new(pos.x, pos.y-1, pos.z)
 	self.standing_in = node_ok(pos, "air").name
 	self.standing_on = node_ok(pos2, "air").name

@ -681,7 +583,7 @@ function mob_class:do_env_damage()

 	-- 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})
+		self.object:set_velocity(vector.zero())
 	-- wither rose effect
 	elseif self.standing_in == "mcl_flowers:wither_rose" then
 		mcl_potions.give_effect_by_level("withering", self.object, 2, 2)
@ -799,7 +701,7 @@ function mob_class:do_env_damage()
 		end

 		if drowning then
-			self.breath = math.max(0, self.breath - 1)
+			self.breath = max(0, self.breath - 1)
 			mcl_mobs.effect(pos, 2, "bubble.png", nil, nil, 1, nil)
 			if self.breath <= 0 then
 				local dmg
@ -816,7 +718,7 @@ function mob_class:do_env_damage()
 				return true
 			end
 		else
-			self.breath = math.min(self.breath_max, self.breath + 1)
+			self.breath = min(self.breath_max, self.breath + 1)
 		end
 	end

@ -882,7 +784,7 @@ end

 function mob_class:damage_mob(reason,damage)
 	if not self.health then return end
-	damage = math.floor(damage)
+	damage = floor(damage)
 	if damage > 0 then
 		self.health = self.health - damage

@ -928,53 +830,45 @@ end
 -- falling and fall damage
 -- returns true if mob died
 function mob_class:falling(pos, moveresult)
-	if moveresult and moveresult.touching_ground then return false end
-
-	if self.fly and self.state ~= "die" then
-		return
-	end
-
+	if self.fly and self.state ~= "die" then return end
 	if not self.fall_speed then self.fall_speed = DEFAULT_FALL_SPEED end

+	-- Gravity
+	local v = self.object:get_velocity()
+	if v then
+		if v.y > 0 or (v.y <= 0 and v.y > self.fall_speed) then
+			-- fall downwards at set speed
+			if moveresult and moveresult.touching_ground then
+				-- when touching ground, retain a minimal gravity to keep the touching_ground flag
+				-- but also to not get upwards acceleration with large dtime when on bouncy ground
+				self.object:set_acceleration(vector.new(0, self.fall_speed * 0.01, 0))
+			else
+				self.object:set_acceleration(vector.new(0, self.fall_speed, 0))
+			end
+		else
+			-- stop accelerating once max fall speed hit
+			self.object:set_acceleration(vector.zero())
+		end
+	end
+
 	if mcl_portals ~= nil then
 		if mcl_portals.nether_portal_cooloff(self.object) then
 			return false -- mob has teleported through Nether portal - it's 99% not falling
 		end
 	end

-	-- floating in water (or falling)
-	local v = self.object:get_velocity()
-	if v then
-		local new_acceleration
-
-		if v.y > 0 then
-			-- apply gravity when moving up
-			new_acceleration = vector.new(0, DEFAULT_FALL_SPEED, 0)
-		elseif v.y <= 0 and v.y > self.fall_speed then
-			-- fall downwards at set speed
-			new_acceleration = vector.new(0, self.fall_speed, 0)
-		else
-			-- stop accelerating once max fall speed hit
-			new_acceleration =vector.zero()
-		end
-
-		self.object:set_acceleration(new_acceleration)
-	end
-
-	local acc = self.object:get_acceleration()
-
 	local registered_node = minetest.registered_nodes[node_ok(pos).name]

 	if registered_node.groups.lava then
-		if acc and self.floats_on_lava == 1 then
-			self.object:set_acceleration(vector.new(0, -self.fall_speed / (math.max(1, v.y) ^ 2), 0))
+		if self.floats_on_lava == 1 then
+			self.object:set_acceleration(vector.new(0, -self.fall_speed / max(1, v.y^2), 0))
 		end
 	end

 	-- in water then float up
 	if registered_node.groups.water then
-		if acc and self.floats == 1 and minetest.registered_nodes[node_ok(vector.offset(pos,0,self.collisionbox[5] -0.25,0)).name].groups.water then
-			self.object:set_acceleration(vector.new(0, -self.fall_speed / (math.max(1, v.y) ^ 2), 0))
+		if self.floats == 1 and minetest.registered_nodes[node_ok(vector.offset(pos,0,self.collisionbox[5] -0.25,0)).name].groups.water then
+			self.object:set_acceleration(vector.new(0, -self.fall_speed / max(1, v.y^2), 0))
 		end
 	else
 		-- fall damage onto solid ground
@ -998,13 +892,9 @@ end

 function mob_class:check_water_flow()
 	-- Add water flowing for mobs from mcl_item_entity
-	local p, node, nn, def
-	p = self.object:get_pos()
-	node = minetest.get_node_or_nil(p)
-	if node then
-		nn = node.name
-		def = minetest.registered_nodes[nn]
-	end
+	local p = self.object:get_pos()
+	local node = minetest.get_node_or_nil(p)
+	local def = node and minetest.registered_nodes[node.name]

 	-- Move item around on flowing liquids
 	if def and def.liquidtype == "flowing" then
@ -1019,14 +909,12 @@ function mob_class:check_water_flow()
 			local f = 1.39
 			-- Set new item moving speed into the direciton of the liquid
 			local newv = vector.multiply(vec, f)
-			self.object:set_acceleration({x = 0, y = 0, z = 0})
-			self.object:set_velocity({x = newv.x, y = -0.22, z = newv.z})
+			self.object:set_acceleration(vector.zero())
+			self.object:set_velocity(vector.new(newv.x, -0.22, newv.z))

 			self.physical_state = true
 			self._flowing = true
-			self.object:set_properties({
-				physical = true
-			})
+			self.object:set_properties({ physical = true })
 			return
 		end
 	elseif self._flowing == true then
@ -1040,7 +928,7 @@ function mob_class:check_dying()
 	if ((self.state and self.state=="die") or self:check_for_death()) and not self.animation.die_end then
 		local rot = self.object:get_rotation()
 		if rot then
-			rot.z = ((math.pi/2-rot.z)*.2)+rot.z
+			rot.z = ((HALFPI - rot.z) * .2) + rot.z
 			self.object:set_rotation(rot)
 		end
 		return true
--- a/mods/ENTITIES/mobs_mc/axolotl.lua
+++ b/mods/ENTITIES/mobs_mc/axolotl.lua
@ -72,18 +72,24 @@ local axolotl = {
 	fly = true,
 	fly_in = { "mcl_core:water_source", "mclx_core:river_water_source" },
 	breathes_in_water = true,
-	jump = true,
+	jump = false, -- would get them out of the water too often
 	damage = 2,
 	reach = 2,
 	attack_type = "dogfight",
 	attack_animals = true,
 	specific_attack = {
-		"extra_mobs_cod",
-		"extra_mobs_glow_squid",
-		"extra_mobs_salmon",
-		"extra_mobs_tropical_fish",
-		"mobs_mc_squid"
-		 },
+		"mobs_mc:cod",
+		"mobs_mc:glow_squid",
+		"mobs_mc:salmon",
+		"mobs_mc:tropical_fish",
+		"mobs_mc:squid",
+		"mobs_mc:zombie", -- todo: only drowned?
+		"mobs_mc:baby_zombie",
+		"mobs_mc:husk",
+		"mobs_mc:baby_husk",
+		"mobs_mc:guardian_elder",
+		"mobs_mc:guardian",
+	},
 	runaway = true,
 }

--- a/mods/ENTITIES/mobs_mc/shulker.lua
+++ b/mods/ENTITIES/mobs_mc/shulker.lua
@ -83,7 +83,6 @@ mcl_mobs.register_mob("mobs_mc:shulker", {
 		local pos = self.object:get_pos()
 		if math.floor(self.object:get_yaw()) ~=0 then
 			self.object:set_yaw(0)
-			mcl_mobs:yaw(self, 0, 0, dtime)
 		end
 		if self.state == "attack" then
 			self:set_animation("run")
--- a/mods/ENVIRONMENT/mcl_weather/rain.lua
+++ b/mods/ENVIRONMENT/mcl_weather/rain.lua
@ -157,6 +157,7 @@ function mcl_weather.rain.clear()
 		mcl_weather.rain.remove_sound(player)
 		mcl_weather.rain.remove_player(player)
 		mcl_weather.remove_spawners_player(player)
+		player:set_clouds({color="#FFF0EF"})
 	end
 end

--- a/mods/ENVIRONMENT/mcl_weather/skycolor.lua
+++ b/mods/ENVIRONMENT/mcl_weather/skycolor.lua
@ -2,6 +2,7 @@
 local modname = minetest.get_current_modname()
 local modpath = minetest.get_modpath(modname)
 local NIGHT_VISION_RATIO = 0.45
+local DEBUG = false

 -- Settings
 local minimum_update_interval = { 250e3 }
@ -190,8 +191,8 @@ end

 function skycolor_utils.convert_to_rgb(minval, maxval, current_val, colors)
 	-- Clamp current_val to valid range
-	current_val = math.min(minval, current_val)
-	current_val = math.max(maxval, current_val)
+	current_val = math.max(minval, current_val)
+	current_val = math.min(maxval, current_val)

 	-- Rescale current_val from a number between minval and maxval to a number between 1 and #colors
 	local scaled_value = (current_val - minval) / (maxval - minval) * (#colors - 1) + 1.0
@ -199,7 +200,7 @@ function skycolor_utils.convert_to_rgb(minval, maxval, current_val, colors)
 	-- Get the first color's values
 	local index1 = math.floor(scaled_value)
 	local color1 = colors[index1]
-	local frac1 = scaled_value - index1
+	local frac1 = 1.0 - (scaled_value - index1)

 	-- Get the second color's values
 	local index2 = math.min(index1 + 1, #colors) -- clamp to maximum color index (will occur if index1 == #colors)
@ -207,11 +208,32 @@ function skycolor_utils.convert_to_rgb(minval, maxval, current_val, colors)
 	local color2 = colors[index2]

 	-- Interpolate between color1 and color2
-	return {
+	local res = {
 		r = math.floor(frac1 * color1.r + frac2 * color2.r),
 		g = math.floor(frac1 * color1.g + frac2 * color2.g),
 		b = math.floor(frac1 * color1.b + frac2 * color2.b),
 	}
+
+	if DEBUG then
+		minetest.log(dump({
+			minval = minval,
+			maxval = maxval,
+			current_val = current_val,
+			colors = colors,
+			res = res,
+			scaled_value = scaled_value,
+
+			frac1 = frac1,
+			index1 = index1,
+			color1 = color1,
+
+			frac2 = frac2,
+			index2 = index2,
+			color2 = color2,
+		}))
+	end
+
+	return res
 end

 -- Simple getter. Either returns user given players list or get all connected players if none provided
--- a/mods/ENVIRONMENT/mcl_weather/skycolor/dimensions.lua
+++ b/mods/ENVIRONMENT/mcl_weather/skycolor/dimensions.lua
@ -40,18 +40,21 @@ function dimension_handlers.overworld(player, sky_data)
 	end

 	-- Use overworld defaults
-	local day_color = mcl_weather.skycolor.get_sky_layer_color(0.15)
+	local day_color = mcl_weather.skycolor.get_sky_layer_color(0.5)
 	local dawn_color = mcl_weather.skycolor.get_sky_layer_color(0.27)
 	local night_color = mcl_weather.skycolor.get_sky_layer_color(0.1)
 	sky_data.sky = {
 		type = "regular",
 		sky_color = {
-			day_sky = day_color,
-			day_horizon = day_color,
-			dawn_sky = dawn_color,
-			dawn_horizon = dawn_color,
-			night_sky = night_color,
-			night_horizon = night_color,
+			day_sky = day_color or "#7BA4FF",
+			day_horizon = day_color or "#C0D8FF",
+			dawn_sky = dawn_color or "7BA4FF",
+			dawn_horizon = dawn_color or "#C0D8FF",
+			night_sky = night_color or "000000",
+			night_horizon = night_color or "4A6790",
+			fog_sun_tint = "#ff5f33",
+			fog_moon_tint = nil,
+			fog_tint_type = "custom",
 		},
 		clouds = true,
 	}
@ -75,18 +78,15 @@ function dimension_handlers.overworld(player, sky_data)
 		local day_color = mcl_weather.skycolor.get_sky_layer_color(0.5)
 		local dawn_color = mcl_weather.skycolor.get_sky_layer_color(0.75)
 		local night_color = mcl_weather.skycolor.get_sky_layer_color(0)
-		sky_data.sky = {
-			type = "regular",
-			sky_color = {
-				day_sky = day_color,
-				day_horizon = day_color,
-				dawn_sky = dawn_color,
-				dawn_horizon = dawn_color,
-				night_sky = night_color,
-				night_horizon = night_color,
-			},
-			clouds = true,
-		}
+		table.update(sky_data.sky.sky_color,{
+			day_sky = day_color or "#7BA4FF",
+			day_horizon = day_color or "#C0D8FF",
+			dawn_sky = dawn_color or "7BA4FF",
+			dawn_horizon = dawn_color or "#C0D8FF",
+			night_sky = night_color or "000000",
+			night_horizon = night_color or "4A6790",
+			fog_tint_type = "default",
+		})
 		sky_data.sun = {visible = false, sunrise_visible = false}
 		sky_data.moon = {visible = false}
 		sky_data.stars = {visible = false}
@ -164,7 +164,8 @@ function dimension_handlers.nether(player, sky_data)
 end

 function dimension_handlers.void(player, sky_data)
-	sky_data.sky = { type = "plain",
+	sky_data.sky = {
+		type = "plain",
 		base_color = "#000000",
 		clouds = false,
 	}
--- a/mods/ENVIRONMENT/mcl_weather/snow.lua
+++ b/mods/ENVIRONMENT/mcl_weather/snow.lua
@ -75,13 +75,15 @@ function mcl_weather.has_snow(pos)
 end

 function mcl_weather.snow.set_sky_box()
-	mcl_weather.skycolor.add_layer(
-		"weather-pack-snow-sky",
-		{{r=0, g=0, b=0},
-		{r=85, g=86, b=86},
-		{r=135, g=135, b=135},
-		{r=85, g=86, b=86},
-		{r=0, g=0, b=0}})
+	if mcl_weather.skycolor.current_layer_name() ~= "weather-pack-snow-sky" then
+		mcl_weather.skycolor.add_layer(
+			"weather-pack-snow-sky",
+			{{r=0, g=0, b=0},
+			{r=85, g=86, b=86},
+			{r=135, g=135, b=135},
+			{r=85, g=86, b=86},
+			{r=0, g=0, b=0}})
+	end
 	mcl_weather.skycolor.active = true
 	for _, player in pairs(get_connected_players()) do
 		player:set_clouds({color="#ADADADE8"})
--- a/mods/ENVIRONMENT/mcl_weather/thunder.lua
+++ b/mods/ENVIRONMENT/mcl_weather/thunder.lua
@ -23,13 +23,15 @@ minetest.register_globalstep(function(dtime)
 	mcl_weather.rain.make_weather()

 	if mcl_weather.thunder.init_done == false then
-		mcl_weather.skycolor.add_layer("weather-pack-thunder-sky", {
-			{r=0, g=0, b=0},
-			{r=40, g=40, b=40},
-			{r=85, g=86, b=86},
-			{r=40, g=40, b=40},
-			{r=0, g=0, b=0},
-		})
+		if mcl_weather.skycolor.current_layer_name() ~= "weather-pack-thunder-sky" then
+			mcl_weather.skycolor.add_layer("weather-pack-thunder-sky", {
+				{r=0, g=0, b=0},
+				{r=40, g=40, b=40},
+				{r=85, g=86, b=86},
+				{r=40, g=40, b=40},
+				{r=0, g=0, b=0},
+			})
+		end
 		mcl_weather.skycolor.active = true
 		for _, player in pairs(get_connected_players()) do
 			player:set_clouds({color="#3D3D3FE8"})
--- a/mods/ITEMS/mcl_bamboo/bamboo_base.lua
+++ b/mods/ITEMS/mcl_bamboo/bamboo_base.lua
@ -5,9 +5,6 @@
 --- Copyright (C) 2022 - 2023, Michieal. See License.txt

 -- CONSTS
-local DOUBLE_DROP_CHANCE = 8
-- Used everywhere. Often this is just the name, but it makes sense to me as BAMBOO, because that's how I think of it...
-- "BAMBOO" goes here.
 local BAMBOO = "mcl_bamboo:bamboo"
 local BAMBOO_ENDCAP_NAME = "mcl_bamboo:bamboo_endcap"
 local BAMBOO_PLANK = BAMBOO .. "_plank"
@ -16,7 +13,7 @@ local BAMBOO_PLANK = BAMBOO .. "_plank"
 local modname = minetest.get_current_modname()
 local S = minetest.get_translator(modname)
 local node_sound = mcl_sounds.node_sound_wood_defaults()
-local pr = PseudoRandom((os.time() + 15766) * 12) -- switched from math.random() to PseudoRandom because the random wasn't very random.
+local pr = PseudoRandom((os.time() + 15766) * 12)

 local on_rotate
 if minetest.get_modpath("screwdriver") then
@ -31,33 +28,7 @@ local bamboo_def = {
 	paramtype = "light",
 	groups = {handy = 1, axey = 1, choppy = 1, dig_by_piston = 1, plant = 1, non_mycelium_plant = 1, flammable = 3},
 	sounds = node_sound,
-
-	drop = {
-		max_items = 1,
-		-- From the API:
-		-- max_items: Maximum number of item lists to drop.
-		-- The entries in 'items' are processed in order. For each:
-		-- Item filtering is applied, chance of drop is applied, if both are
-		-- successful the entire item list is dropped.
-		-- Entry processing continues until the number of dropped item lists
-		-- equals 'max_items'.
-		-- Therefore, entries should progress from low to high drop chance.
-		items = {
-			-- Examples:
-			{
-				-- 1 in DOUBLE_DROP_CHANCE chance of dropping.
-				-- Default rarity is '1'.
-				rarity = DOUBLE_DROP_CHANCE,
-				items = {BAMBOO .. " 2"},
-			},
-			{
-				-- 1 in 1 chance of dropping. (Note: this means that it will drop 100% of the time.)
-				-- Default rarity is '1'.
-				rarity = 1,
-				items = {BAMBOO},
-			},
-		},
-	},
+	drop = BAMBOO,

 	inventory_image = "mcl_bamboo_bamboo_shoot.png",
 	wield_image = "mcl_bamboo_bamboo_shoot.png",
@ -86,7 +57,6 @@ local bamboo_def = {
 	on_rotate = on_rotate,

 	on_place = function(itemstack, placer, pointed_thing)
-
 		if not pointed_thing then
 			return itemstack
 		end
@ -241,9 +211,6 @@ local bamboo_def = {
 		if node_above and ((bamboo_node and bamboo_node > 0) or node_above.name == BAMBOO_ENDCAP_NAME) then
 			minetest.remove_node(new_pos)
 			minetest.sound_play(node_sound.dug, sound_params, true)
-			if pr:next(1, DOUBLE_DROP_CHANCE) == 1 then
-				minetest.add_item(new_pos, istack)
-			end
 			minetest.add_item(new_pos, istack)
 		end
 	end,
--- a/mods/ITEMS/mcl_bamboo/bamboo_items.lua
+++ b/mods/ITEMS/mcl_bamboo/bamboo_items.lua
@ -9,8 +9,6 @@ local SIDE_SCAFFOLDING = false
 local SIDE_SCAFFOLD_NAME = "mcl_bamboo:scaffolding_horizontal"
 -- ---------------------------------------------------------------------------
 local SCAFFOLDING_NAME = "mcl_bamboo:scaffolding"
-- Used everywhere. Often this is just the name, but it makes sense to me as BAMBOO, because that's how I think of it...
-- "BAMBOO" goes here.
 local BAMBOO = "mcl_bamboo:bamboo"
 local BAMBOO_PLANK = BAMBOO .. "_plank"

--- a/mods/ITEMS/mcl_bamboo/init.lua
+++ b/mods/ITEMS/mcl_bamboo/init.lua
@ -7,8 +7,6 @@

 -- LOCALS
 local modname = minetest.get_current_modname()
-- Used everywhere. Often this is just the name, but it makes sense to me as BAMBOO, because that's how I think of it...
-- "BAMBOO" goes here.
 local BAMBOO = "mcl_bamboo:bamboo"

 mcl_bamboo = {}
--- a/mods/ITEMS/mcl_bamboo/recipes.lua
+++ b/mods/ITEMS/mcl_bamboo/recipes.lua
@ -5,8 +5,6 @@
 --- These are all of the fuel recipes and all of the crafting recipes, consolidated into one place.
 --- Copyright (C) 2022 - 2023, Michieal. See License.txt

-- Used everywhere. Often this is just the name, but it makes sense to me as BAMBOO, because that's how I think of it...
-- "BAMBOO" goes here.
 local BAMBOO = "mcl_bamboo:bamboo"
 local BAMBOO_PLANK = BAMBOO .. "_plank"
 -- Craftings
Author	SHA1	Message	Date
kno10	a94b3a8d4a	Improve danger avoidance code.	2024-10-27 19:25:29 +01:00
kno10	8fce90111b	fix and optimize Fleckenstein	2024-10-27 19:25:29 +01:00
kno10	645f884e7f	small code cleanups	2024-10-27 19:25:29 +01:00
kno10	46f7c29451	also cleanup mount.lua	2024-10-27 19:25:29 +01:00
kno10	ddd180f5be	some more cleanups, from code review	2024-10-27 19:25:29 +01:00
kno10	b473d55644	code cleanups	2024-10-27 19:24:40 +01:00
kno10	265dce301b	movement improvements, door opening	2024-10-27 19:23:00 +01:00
kno10	3538efbf52	further movement tweaks	2024-10-27 19:21:36 +01:00
kno10	ab673cdf8b	Movement and path finding improvements.	2024-10-27 19:21:36 +01:00
kno10	455353de27	Mob pushing improvements	2024-10-27 19:21:36 +01:00
kno10	b99e1a4b08	add and use turn_by/turn_in_direction methods	2024-10-27 19:21:36 +01:00
kno10	0730cce236	reduce code duplication, add mob:stand()	2024-10-27 19:21:36 +01:00
kno10	98f899fd67	cleanups	2024-10-27 19:21:36 +01:00
kno10	4b9e8aabb2	fix delay=0 in combat code, tune turning parameters	2024-10-27 19:21:35 +01:00
kno10	936e47e5f9	More help getting out of water	2024-10-27 19:21:35 +01:00
kno10	46b5416359	More movement code cleanups. Closes #4506 #4502	2024-10-27 19:21:35 +01:00
kno10	72f825ade3	More cleanup and improvements to movement code	2024-10-27 19:21:35 +01:00
kno10	ec7e7c14bc	More movement code improvements.	2024-10-27 19:21:35 +01:00
kno10	f8a6da10cb	Try to reduce how much mobs fall off cliffs. See #4464 and many more.	2024-10-27 19:21:35 +01:00
kno10	2e5b0bb3c7	Improve head swivel code.	2024-10-27 19:20:58 +01:00
Mikita Wiśniewski	41b188caea	Remove "double drop" mechanics for bamboo (fixes #4514 ) (#4642 ) Reviewed-on: VoxeLibre/VoxeLibre#4642 Reviewed-by: the-real-herowl <the-real-herowl@noreply.git.minetest.land> Co-authored-by: Mikita Wiśniewski <rudzik8@protonmail.com> Co-committed-by: Mikita Wiśniewski <rudzik8@protonmail.com>	2024-10-27 14:16:06 +01:00
kno10	ae7995d195	Fix axolotl attacking water mobs (#4675 ) Also avoid jumping out of the water closes #4644 Reviewed-on: VoxeLibre/VoxeLibre#4675 Reviewed-by: the-real-herowl <the-real-herowl@noreply.git.minetest.land> Co-authored-by: kno10 <kno10@noreply.git.minetest.land> Co-committed-by: kno10 <kno10@noreply.git.minetest.land>	2024-10-27 14:10:11 +01:00
kno10	e293cbe631	Better handling of touching_ground for bouncing on beds (#4689 ) Reviewed-on: VoxeLibre/VoxeLibre#4689 Reviewed-by: the-real-herowl <the-real-herowl@noreply.git.minetest.land> Co-authored-by: kno10 <erich.schubert@gmail.com> Co-committed-by: kno10 <erich.schubert@gmail.com>	2024-10-27 14:03:50 +01:00
the-real-herowl	fd6cac5f0c	Merge pull request 'Fix fog tint in overworld, apply memory leak fix, fix rain->clear clouds' (#4669 ) from weather-fixes into master Reviewed-on: VoxeLibre/VoxeLibre#4669 Reviewed-by: kno10 <kno10@noreply.git.minetest.land>	2024-10-11 07:14:01 +02:00
teknomunk	e864cc19ed	Make fog_tint_type = "default" when weather is present to match behavior at 0.87.2	2024-10-09 01:05:20 +02:00
teknomunk	66c3c014a1	Make sure fog tints are preserved during weather is present	2024-10-09 01:05:20 +02:00
teknomunk	7807093b50	Another correction to color interpolation, change day color from layer position 0.15 to 0.50	2024-10-09 01:05:20 +02:00
teknomunk	f6c3f4bd16	Correct value clamping	2024-10-09 01:05:20 +02:00
teknomunk	96a03b1923	Remove posibility of nil sky colors in overworld, add line break	2024-10-09 01:05:20 +02:00
teknomunk	2145470f63	Fix clouds during rain->clear weather transition	2024-10-09 01:05:20 +02:00
teknomunk	2ca0ccd8fe	Fix fog tint in overworld, apply memory leak fix from rain.lua to snow.lua and thunder.lua	2024-10-09 01:05:20 +02:00
teknomunk	614518c6cd	Revert minetest.add_entity() -> mcl_mobs.spawn() from #4445 (#4679 ) Reviewed-on: VoxeLibre/VoxeLibre#4679 Reviewed-by: kno10 <kno10@noreply.git.minetest.land> Co-authored-by: teknomunk <teknomunk@protonmail.com> Co-committed-by: teknomunk <teknomunk@protonmail.com>	2024-10-08 15:34:30 +02:00
kno10	253a06fa08	Fix mob egg double-spawns (#4657 ) If you spawn a mob clicking on a wall, two mobs will be spawned. To reproduce: face a stack of stones, with a spawn egg click on the side of a stone. It does not happen when you click the top of a node, because spawning below fails and only the second one succeeds. Reviewed-on: VoxeLibre/VoxeLibre#4657 Reviewed-by: the-real-herowl <the-real-herowl@noreply.git.minetest.land> Co-authored-by: kno10 <kno10@noreply.git.minetest.land> Co-committed-by: kno10 <kno10@noreply.git.minetest.land>	2024-09-30 19:21:40 +02:00