--------------------------------------------------------
-- Minetest :: Mobs Lite Mod (mobs)
--
-- See README.txt for licensing and release notes.
-- Copyright (c) 2016-2020, Leslie E. Krause
--
-- ./games/minetest_game/mods/mobs/init.lua
--------------------------------------------------------

mobs = { }

local registry = {
	players = { },
	avatars = { },
	objects = { },
	spawnitems = { },
}

local world_gravity = -10
local liquid_density = 0.5
local liquid_viscosity = 0.6

local next_noise_id = 1

--------------------

local random = math.random
local floor = math.floor
local min = math.min
local max = math.max
local sqrt = math.sqrt
local pow = math.pow
local abs = math.abs
local pi = math.pi
local atan2 = math.atan2
local sin = math.sin
local cos = math.cos

local rad_360 = 2 * pi
local rad_180 = pi
local rad_90 = pi / 2
local rad_60 = pi / 3
local rad_45 = pi / 4
local rad_30 = pi / 6
local rad_20 = pi / 9
local rad_10 = pi / 18
local rad_5 = pi / 36
local rad_0 = 0

--------------------

function Timekeeper( this )
	local timer_defs = { }
	local pending_timer_defs = { }
	local clock = 0.0
	local delay = 0.0
	local self = { }

	self.shift = function ( dtime )
		delay = delay + dtime
	end

	self.unshift = function ( )
		delay = 0.0
	end

	self.start = function ( period, name, func )
		timer_defs[ name ] = nil
		pending_timer_defs[ name ] = { cycles = 0, period = period, expiry = clock + delay + period, started = clock, func = func }
	end

	self.start_now = function ( period, name, func )
		timer_defs[ name ] = nil
		if not func( this, 0, period, 0.0, 0.0 ) then
			pending_timer_defs[ name ] = { cycles = 0, period = period, expiry = clock + period, started = clock, func = func }
		end
	end

	self.clear = function ( name )
		pending_timer_defs[ name ] = nil
		timer_defs[ name ] = nil
	end

	self.on_step = function ( dtime )
		clock = clock + dtime

		for k, v in pairs( pending_timer_defs ) do
			timer_defs[ k ] = v
			pending_timer_defs[ k ] = nil
		end

		local timers = { }
		for k, v in pairs( timer_defs ) do
			if clock >= v.expiry and clock > v.started then
				v.expiry = clock + v.period
				v.cycles = v.cycles + 1
				-- callback( this, cycles, period, elapsed, overrun )
				if v.func and v.func( this, v.cycles, v.period, clock - v.started, clock - v.expiry ) then
					self.clear( k )
				end
				timers[ k ] = v
			end
		end
		return timers
	end

	return self
end

--------------------

mobs.effect = function ( pos, amount, texture, min_size, max_size, radius, gravity )
	minetest.add_particlespawner({
		amount = amount,
		time = 0.5,
		minpos = { x = pos.x, y = pos.y, z = pos.z },
		maxpos = { x = pos.x, y = pos.y + 1.5, z = pos.z },
		minvel = {x = -radius, y = -radius, z = -radius},
		maxvel = {x = radius, y = radius, z = radius},
		minacc = {x = 0, y = gravity, z = 0},
		maxacc = {x = 0, y = gravity, z = 0},
		minexptime = 0.1,
		maxexptime = 1,
		minsize = min_size,
		maxsize = max_size,
		texture = texture,
	})
end

local function smoke_effect( pos )
	mobs.effect( pos, 8, "tnt_smoke.png", 1.4, 1.6, 2, 0 )
end

local function blood_effect( pos )
	mobs.effect( pos, 4, "mobs_blood.png", 1.2, 1.4, 2, -10 )
end

--------------------

mobs.iterate_registry = function ( source_pos, radius, height, classes )
	local length = radius * radius
	local class_id = next( classes )
	local key

	local function is_inside_area( obj )
		-- perform fast length-squared distance check
		local target_pos = obj:get_pos( )
		local a = source_pos.x - target_pos.x
		local b = source_pos.z - target_pos.z

		return a * a + b * b <= length and abs( source_pos.y - target_pos.y ) <= height
	end

	return function ( )
		while class_id and classes[ class_id ] do
			local obj

			key, obj = next( registry[ class_id ], key )
			if obj then
				if obj:get_hp( ) > 0 and is_inside_area( obj ) then
					return obj
				end
			else
				class_id = next( classes, class_id )
				key = nil
			end
		end

		return nil
	end
end

--------------------

local function node_locator( pos, size, time, color )
	if is_debug then
		minetest.add_particle( {
			pos = pos,
			velocity = { x=0, y=0, z=0 },
			acceleration = { x=0, y=0, z=0 },
			exptime = time + 4,
			size = size,
			collisiondetection = false,
			vertical = true,
			texture = "wool_" .. color .. ".png",
		})
	end
end

local function printf( ... )
	print( string.format( ... ) )
end

--------------------

local function to_vector3d( length, yaw, pitch )
	local y = sin( pitch ) * length
	local length2 = cos( pitch ) * length
	local x = -sin( yaw ) * length2
	local z = cos( yaw ) * length2

	return { x = x, y = y, z = z }, length2
end

local function normalize_angle( r )
	-- stackoverflow.com/questions/1878907/the-smallest-difference-between-2-angles
	return atan2( sin( r ), cos( r ) )
end

local function get_vector_angle( p1, p2 )
	return atan2( p2.z - p1.z, p2.x - p1.x )
end

local function get_vector_height( p1, p2 )      -- get altitude from p1 to p2
	return abs( p2.y - p1.y )
end

local function get_vector_length( p1, p2 )      -- get distance from p1 to p2
	return sqrt( pow( p2.x - p1.x, 2 ) + pow( p2.z - p1.z, 2 ) )
end

local function get_vector_incline( p1, p2 )
	local h = get_vector_length( p1, p2 )
	local v = p2.y - p1.y
	return v / h
end

local function ramp( f, cur_v, max_v )
	-- min function handles NaN, but let's err on the side of caution
	return max_v == 0 and f or f * min( 1, cur_v / max_v )
end

local function sign( v )
	return random( 2 ) == 1 and v or -v
end

local function lower_random( v_limit, v_ratio )
	return sign( v_ratio * random( ) * v_limit )
end

local function upper_random( v_limit, v_ratio )
	return sign( v_limit - v_ratio * random( ) * v_limit )
end

local function get_power_decrease( scale, power, value )
	return value <= 1 - scale and 1.0 or
		max( 1 - pow( ( scale + value - 1 ) / scale, 1 + power ), 0 )
end

local function get_power_increase( scale, power, value )
	return value >= scale and 1.0 or
		1 - pow( ( scale - value ) / scale, 1 + power )
end

local function check_limits( v, min_v, max_v )
	return v >= min_v and v <= max_v
end

local function random_range( min_v, max_v )
	return random( min_v * 100, max_v * 100 ) / 100
end

--------------------

minetest.register_on_leaveplayer( function( player, is_timeout )
	local name = player:get_player_name( )

	-- delete all target references (if applicable)
	for id, obj in pairs( registry.avatars ) do
		local this = obj:get_luaentity( )
		if this.target and this.target.obj == player then
			this:reset_alertness( "ignore" )
		end
	end
	registry.players[ name ] = nil
end )

minetest.register_on_joinplayer( function( player )
	local name = player:get_player_name( )
	registry.players[ name ] = player
end )

--------------------

local builtin_item = minetest.registered_entities[ "__builtin:item" ]

builtin_item.old_on_activate = builtin_item.on_activate
builtin_item.old_set_item = builtin_item.set_item

builtin_item.set_item = function ( self, itemstring )
	self:old_set_item( itemstring )
	self.item_name = ItemStack( self.itemstring ):get_name( )
end

builtin_item.on_activate = function ( self, staticdata, dtime, id )
	self:old_on_activate( staticdata, dtime )
	registry.spawnitems[ id ] = self.object
end

builtin_item.on_deactivate = function ( self, id )
	for id, obj in pairs( registry.avatars ) do
		local this = obj:get_luaentity( )
		if this.target and this.target.obj == self.object then
			this:reset_alertness( "ignore" )
		end
	end
	registry.spawnitems[ id ] = nil
end

--------------------

local globaltimer = Timekeeper( { } )

minetest.register_globalstep( function ( dtime )
	globaltimer.on_step( dtime )
end )

--------------------

minetest.register_entity( "mobs:gibbage", {
	physical = true,
	visual = "mesh",
	visual_size = { x = 1.0, y = 1.0 },
	collisionbox = { -0.2, -0.1, -0.2, 0.2, 0.1, 0.2 },
	motion_sounds = { },
	physics = {
		density = 0.5,
		elasticity = 0.2,
		resistance = 0.0,
		friction = 0.7,
	},

	on_activate = function ( self, staticdata, dtime )
		BasicPhysics( self )

		self.timekeeper = Timekeeper( self )
		self.timekeeper.start( math.random( 4, 8 ), "gibbage", function ( )
			self.object:remove( )
		end )

		if dtime > 0 then
			self.object:remove( )
			return
		end
	end,

	on_step = function ( self, dtime, pos )
		self.timekeeper.on_step( dtime )
	end,

	launch = function ( self, intensity, texture, piece, sound )
		local obj = self.object

		obj:set_properties( {
			mesh = "gib_" .. piece .. ".b3d",
			textures = { texture },
		} )
		local vel_horz = min( 4, intensity * 0.5 )
		local vel_vert = min( 4, intensity * 0.7 )
		obj:set_velocity( vector.new( random_range( -vel_horz, vel_horz ), vel_vert, random_range( -vel_horz, vel_horz ) ) )
		obj:set_animation( { x = 0, y = 120 }, random( 20, 40 ), 0, false )
		self.motion_sounds.bouncing = sound
	end,
} )

mobs.register_mob = function ( name, def )
	minetest.register_entity( name, {
		type = def.type,
		hp_max = def.hp_max,
		hp_low = def.hp_low,
		physical = true,
		mesh = def.mesh,
		collisionbox = def.collisionbox,
		visual = def.visual,
		visual_size = def.visual_size,
		height = def.height,
		y_offset = def.y_offset,
		gravity = def.gravity or world_gravity,
		density = def.density or 0.5,
		textures = def.textures,
		makes_footstep_sound = def.makes_footstep_sound,
		makes_bloodshed_effect = def.makes_bloodshed_effect,
		gibbage_params = def.gibbage_params,
		receptrons = def.receptrons,
		death_message = def.death_message,
		alertness_states = def.alertness_states,
		awareness_stages = def.awareness_stages,
		sensitivity = def.sensitivity or 0.0,
		certainty = def.certainty or 1.0,
		attack_range = def.attack_range,
		escape_range = def.escape_range,
		follow_range = def.follow_range,
		search_range = def.search_range,
		pickup_range = def.pickup_range,
		sneak_velocity = def.sneak_velocity,
		walk_velocity = def.walk_velocity,
		run_velocity = def.run_velocity,
		stray_velocity = def.stray_velocity,
		recoil_velocity = def.recoil_velocity,
		standoff = def.standoff or 5,
		damage = def.damage,
		light_damage = def.light_damage or 0,
		water_damage = def.water_damage or 0,
		lava_damage = def.lava_damage or 0,
		enable_fall_damage = def.enable_fall_damage,
		drops = def.drops,
		armor = def.armor,
		yaw_origin = def.drawtype == "front" and 0 or -rad_90,
		drawtype = def.drawtype,
		on_rightclick = def.on_rightclick,
		attack_type = def.attack_type,
		projectile = def.projectile,
		shoot_period = def.shoot_period,
		shoot_chance = def.shoot_chance,
		weapon_params = def.weapon_params,
		watch_wielditems = def.watch_wielditems or { },
		watch_spawnitems = def.watch_spawnitems or { },
		watch_players = def.watch_players or { },
		sounds = def.sounds,
		animation = def.animation,
		fear_factor = def.fear_factor,
		flee_factor = def.flee_factor,
		can_jump = def.can_jump or false,
		can_fly = def.can_fly or false,
		can_walk = def.can_walk or false,
		enable_climbing = true,
		enable_swimming = true,
		shoot_count = 0,
		timeout = def.timeout,
		neutral_state = "ignore",
		offense_state = def.offense_state or def.type == "monster" and "attack" or "ignore",
		defense_state = def.defense_state or def.type == "monster" and "attack" or "escape",
		retreat_state = def.retreat_state or "escape",
		is_tamed = false,
		description = def.description,
		after_activate = def.after_activate,
		before_deactivate = def.before_deactivate,
		before_state_change = def.before_state_change,
		before_punch = def.before_punch,

		-- prepare noise generator with seed, octaves, persistence, spread
		hunger_noise = PerlinNoise( random( 1000 ), 1, 0, def.hunger_params.spread ),
		hunger_offset = def.hunger_params.offset,

		-- primitive movement functions --

		set_speed = function( self, speed )
			self.speed = speed
			self.object:set_speed( speed )
		end,

		set_speed_lateral = function( self, speed_x, speed_y )
			self.speed = speed_y
			self.object:set_speed_lateral( speed_x, speed_y )
		end,

		set_velocity_vert = function ( self, vel_y )
			self.object:set_velocity_vert( vel_y )
			self.object:set_acceleration_vert( self.gravity )
		end,

		set_acceleration_vert = function ( self, acc_y )
			self.object:set_acceleration_vert( acc_y )
		end,

		set_yaw = function ( self, yaw )
			self.object:set_yaw( yaw )
		end,

		turn_to = function ( self, yaw, period )
			local yaw_delta = normalize_angle( yaw - self.yaw )
			self.object:turn_by( yaw_delta, period / 10 )
		end,

		turn_by = function ( self, yaw_delta, period )
			self.object:turn_by( yaw_delta, period / 10 )
		end,

		move_by = function ( self, pos_delta, period )
			self.object:move_by( pos_delta, period / 10 )
		end,

		get_random_yaw = function ( self, r_limit, r_ratio )
			return self.yaw + upper_random( r_limit, r_ratio or 1 )
		end,

		get_direct_yaw = function ( self, pos )
			-- convert to world coordinate system
			return get_vector_angle( self.pos, pos ) - rad_90 - self.yaw_origin
		end,

		get_direct_yaw_delta = function ( self, pos )
			local yaw = self:get_direct_yaw( pos )
			return abs( normalize_angle( yaw - self.yaw ) )
		end,

		get_target_yaw = function ( self, r_limit, r_ratio )
			return self:get_direct_yaw( self.target.pos ) + upper_random( r_limit, r_ratio or 1 )
		end,

		get_target_yaw_delta = function ( self )
			local yaw = self:get_direct_yaw( self.target.pos )
			return abs( normalize_angle( yaw - self.yaw ) )
		end,

		get_target_distance = function ( self )
			return vector.distance( self.pos, self.target.pos )
		end,

		-- collision processing --

		get_pos_ahead = function ( self, outset, angle )
			-- convert from world coordinate system
			local rot = angle + self.yaw_origin
			return vector.round( {
				x = self.pos.x - sin( self.yaw + rot ) * ( self.collisionbox[ 4 ] + outset ),
				y = self.pos.y,
				z = self.pos.z + cos( self.yaw + rot ) * ( self.collisionbox[ 4 ] + outset )
			} )
		end,

		can_walk_ahead = function ( self, outset, angle )
			local fpos = self:get_pos_ahead( outset, angle )
			local unknown_ndef = { groups = { }, walkable = false }

			if self.height < 2 then
				local node = minetest.get_node( fpos )
				local ndef = core.registered_nodes[ node.name ] or unknown_ndef     -- account for unknown nodes
				local is_airlike = not ndef.walkable

				--node_locator( vector.offset_y( fpos ), 4.5, 1.0, is_airlike and "green" or angle == 0 and "white" or "red" )
				return is_airlike
			else
				local node_below = minetest.get_node( fpos )
				local node_above = minetest.get_node_above( fpos )
				local ndef_below = core.registered_nodes[ node_below.name ] or unknown_ndef     -- account for unknown nodes
				local ndef_above = core.registered_nodes[ node_above.name ] or unknown_ndef
				local is_airlike = not ndef_below.walkable and not ndef_above.walkable

				--node_locator( vector.offset_y( fpos ), 4.5, 1.0, is_airlike and "green" or angle == 0 and "white" or "red" )
				return is_airlike
			end
		end,			

		-- utility functions --

		is_starving = function ( self )
			local hunger = self.hunger_noise:get2d( { x = self.timeout, y = 0 } )

			-- offset of -1 is never hungry, offset of 1 is always hungry
			return hunger > -self.hunger_offset
		end,

		play_sound = function ( self, name )
			minetest.sound_play( name, { object = self.object, loop = false } )
		end,

		play_sound_repeat = function ( self, name )
			return minetest.sound_play( name, { object = self.object, loop = true } )
		end,

		make_noise = function ( self, radius, group, intensity )
			axon.generate_radial_stimulus( self.pos, radius, 0.0, 0.0, 1, { [group] = intensity }, { avatars = true } )
		end,

		make_noise_repeat = function ( self, radius, interval, duration, group, intensity )
			self.timekeeper.start_now( interval, "noise" .. next_noise_id, function ( this, cycles, period, elapsed )
				if elapsed >= duration then return true end  -- we're finished, so cancel timer

				axon.generate_radial_stimulus( self.pos, radius, 0.0, 0.0, 1, { [group] = intensity }, { avatars = true } )
			end )
			next_noise_id = next_noise_id + 1
		end,

		-- sensory processing --

		check_suspect = function ( self, target_obj, clarity, elapsed )
			-- default to defense or neutral state if not in any watch list
			local suspect = random( 10 ) <= self.fear_factor and self.offense_state or self.neutral_state
			local entity = target_obj:get_luaentity( )

			if not entity then
				local player_name = target_obj:get_player_name( )
				local item_name = target_obj:get_wielded_item( ):get_name( )
				suspect = self.watch_players[ player_name ] or self.watch_wielditems[ item_name ] or suspect
			elseif entity.name == "__builtin:item" then
				suspect = self.watch_spawnitems[ entity.item_name ] or suspect
			end

			if type( suspect ) == "function" then
				return suspect( self, target_obj, clarity, elapsed or 0.0 )  -- must always return a valid state
			else
				return suspect
			end
		end,

		get_visibility = function ( self, target_pos )
			local length = get_vector_length( self.pos, target_pos )
			local height = get_vector_height( self.pos, target_pos )
			local this = self.alertness

			if not this or length > 48 or height > 48 then  -- immediately eliminate far objects
				return 0.0, false, false

			else
				local view_range = this.view_radius + this.view_offset
				local view_pos = this.view_offset == 0.0 and self.pos or vector.new(
					self.pos.x - sin( self.yaw + self.yaw_origin ) * this.view_offset,
					self.pos.y,
					self.pos.z + cos( self.yaw + self.yaw_origin ) * this.view_offset
				)

				local radius = get_vector_length( view_pos, target_pos )
				local clarity = get_power_decrease( 1.0, this.view_acuity, length / view_range )

				-- certainty factor ranges from 0 (target never evident) to 1 (target always evident)
				-- sensitivity threshold ranges from 0 (full perception) to 1 (no perception)

				--node_locator( vector.offset_y( view_pos ), 4.5, 1.0, "yellow" )
				--printf( "is_paranoid(%s):\n[%s] radius <= view_radius\n[%s] height <= view_height\n%0.2f = clarity (%0.2f = sensitivity, %$

				local is_visible = radius <= this.view_radius and height <= this.view_height
				local is_evident = clarity > self.sensitivity and clarity * self.certainty > random( )

				return clarity, is_visible, is_evident
			end
		end,

		-- target functions --

		create_target = function ( self, obj )
			local pos = obj:get_pos( )
			local clarity, is_visible, is_evident = self:get_visibility( pos )
			local alertness = self.alertness_states[ self.state ]

			-- when creating target it must be visible and evident!
			if is_visible and is_evident then
				if alertness and alertness.view_filter then
					return alertness.view_filter( self, obj, clarity, 0.0 ), { obj = obj, pos = pos }
				elseif clarity > 0.0 then
					return self:check_suspect( obj, clarity, 0.0 ), { obj = obj, pos = pos }
				end
			else
				return self.state, self.target
			end
		end,

		verify_target = function ( self, elapsed )
			if self.target.obj then
				local target_pos = self.target.obj:get_pos( )  -- check target's new position
				local clarity, is_visible, is_evident = self:get_visibility( target_pos )
				local alertness = self.alertness_states[ self.state ]

				-- update last-known target position only if visible and evident
				if is_visible and is_evident then
					self.target.pos = target_pos
				else
					clarity = 0.0
				end

				if alertness and alertness.view_filter then
					return alertness.view_filter( self, self.target.obj, clarity, elapsed )
				elseif clarity > 0.0 then
					return self.awareness.pass_state or self:check_suspect( self.target.obj, clarity, elapsed )
				else
					return self.awareness.fail_state or self.neutral_state
				end
			end

			return self.state
		end,

		locate_target = function ( self )
			if self.sounds and self.sounds.random and random( 35 ) == 1 then
				minetest.sound_play( self.sounds.random, { object = self.object } )
			end

			-- when not upset, seek out food or prey at random intervals
			for obj in mobs.iterate_registry( self.pos, 30, 30, { players = true, spawnitems = true } ) do

				if random( 10 ) <= self.fear_factor and not obj:get_attach( ) then
					local state, target = self:create_target( obj )
					if state ~= self.state then
						self:reset_alertness( state, target )
						return
					end
				end
			end
		end,

		-- alertness and awareness functions --

		start_awareness = function ( self )
			self.awareness = self.awareness_stages[ self.state ] or { }

			if self.awareness.decay and self.awareness.decay > 0 then
				self.timekeeper.start( self.awareness.decay, "awareness", function ( )
					self:reset_alertness( self.awareness.wait_state, self.target )
				end )
			else
				self.timekeeper.clear( "awareness" )
			end
		end,

		reset_alertness = function ( self, state, target )
			if state == self.state then return end

			if self.before_state_change then
				self:before_state_change( self.state, state )
			end

			self.state = state
			self.target = target
			self.alertness = self.alertness_states[ state ]

			self:start_awareness( )
			self.action_funcs[ state ]( self )
		end,

		-- action hooks --

		start_ignore_action = function ( self )
			self.target = nil  -- forget any target

			if not self.move_result.is_standing then
				-- always stand when in mid-air
				self:set_speed( 0 )
				self:set_animation( self.can_fly and "swim" or "stand" )
			elseif self:is_starving( ) then
				self:set_speed( self.walk_velocity )
				self:set_animation( "walk" )
			else
				self:set_speed( 0 )
				self:set_animation( "stand" )
			end

			self.timekeeper.start( 1.0, "hunger", self.locate_target )
			self.timekeeper.start( 1.0, "action", self.on_ignore_action )
		end,

		on_ignore_action = function ( self, cycles )
			-- handle standing and walking motion
			if self.speed == 0 then
				if random( 3 ) == 1 then
					-- turn randomly, because we're bored
					self:turn_to( self:get_random_yaw( rad_180 ), random( 2 ) == 1 and 10 or 20 )
				end

				-- don't stand still when hungry
				if self:is_starving( ) then
					if self.can_fly and random( 2 ) == 1 then
						self:set_speed( self.run_velocity )
						self:set_velocity_vert( self.run_velocity )
						self:set_animation( "swim" )
					else
						self:set_speed( self.walk_velocity )
						self:set_animation( "walk" )
					end

				elseif self.can_walk and self.move_result.is_standing then
					self:set_animation( "stand" )

				elseif self.can_fly then
					local is_above = minetest.line_of_sight( self.pos,
						{ x = self.pos.x, y = self.pos.y - self.standoff, z = self.pos.z }, 1 )

					if self.can_walk then
						-- slowly descend until reaching ground
						self.object:set_velocity_vert( -self.walk_velocity )
					elseif is_above then
						self.object:set_velocity_vert( random_range( -self.sneak_velocity, 0 ) )
					else
						self.object:set_velocity_vert( random_range( 0, self.sneak_velocity ) )
					end
					self:set_animation( "swim" )
				end

			else
				if not self:can_walk_ahead( 1.0, 0 ) then
					if self:can_walk_ahead( 0.8, rad_90 ) then
						self:turn_by( rad_60, 5 )
					elseif self:can_walk_ahead( 0.8, -rad_90 ) then
						self:turn_by( -rad_60, 5 )
					else
						self:turn_by( rad_180, 20 )
					end

				elseif random( 3 ) == 1 then
					-- otherwise occasionally change direction
					self:turn_to( self:get_random_yaw( rad_60 ), 20 )
				end


				if self.move_result.is_standing then
					if self.can_jump and random( 10 ) == 1 then
						-- random jump
						self.object:set_velocity_vert( 5 )
					end

					if not self:is_starving( ) then
						self:set_speed( 0 )
						self:set_animation( "stand" )
					else
						self:set_animation( "walk" )
					end

				elseif self.can_fly then
					-- random vertical flight pattern, keeping clear of ground obstacles
					local is_above = minetest.line_of_sight( self.pos,
						{ x = self.pos.x, y = self.pos.y - self.standoff, z = self.pos.z }, 1 )

					if not self:is_starving( ) then
						self:set_speed( 0 )
						self.object:set_velocity_vert( is_above and -self.walk_velocity )
					elseif is_above then
						self.object:set_velocity_vert( random_range( -self.sneak_velocity, self.sneak_velocity ) )
					else
						self.object:set_velocity_vert( self.walk_velocity )
					end

					self:set_animation( "swim" )
				end
			end
		end,

		start_follow_action = function ( self )
			assert( self.target.pos )  -- sanity check

			self:turn_to( self:get_target_yaw( rad_20 ), 10 )
			self:set_speed( self.recoil_velocity )
			self:set_animation( "walk" )

			self.timekeeper.clear( "hunger" )
			self.timekeeper.start( 0.5, "action", self.on_follow_action )
		end,

		on_follow_action = function ( self, cycles, period, elapsed )
			if cycles % 2 == 0 then  -- validate target every 1.0 seconds
				local goal_state = self:verify_target( )
				if goal_state ~= self.state then
					self:reset_alertness( goal_state, self.target )
					return
				end
			end

			local target_pos = self.target.pos
			local dist = self:get_target_distance( )

			if cycles % 2 == 0 then
				if self:get_target_yaw_delta( ) > rad_45 or random( 3 ) == 1 then
					self:turn_to( self:get_target_yaw( rad_20 ), 15 )
				end
			end

			if dist <= self.follow_range then
				if self.speed > 0 then
					self:set_speed( 0 )
					self:set_animation( "stand" )
				end
			else
				if self.speed == 0 then
					self:set_speed( self.walk_velocity )
					self:set_animation( "walk" )

				else
					if self.can_fly then
						-- descend or ascend to slightly above player altitude, but prevent incessant bobbing
						local v = 0
						if target_pos.y + 2.5 > self.pos.y then
							v = self.walk_velocity
						elseif target_pos.y + 0.5 < self.pos.y then
							v = -self.walk_velocity
						end
						self:set_velocity_vert( v )

					elseif self.can_jump and self.move_result.is_standing then
						if self.yield_level < 3 and self.move_result.collides_xz then
							self.yield_level = self.yield_level + 1
							self.object:set_velocity_vert( 5 )
						elseif random( 5 ) == 1 then
							self.object:set_velocity_vert( 5 )
						end
					end
				end
			end
		end,

		start_search_action = function ( self )
			assert( self.target.pos )  -- sanity check

			local dist = self:get_target_distance( )

			self:turn_to( self:get_target_yaw( rad_0 ), 20 )
			if self:get_target_yaw_delta( ) > rad_10 or dist <= self.search_range then
				self:set_speed( 0 )
				self:set_animation( "stand" )
			else
				self:set_speed( self.sneak_velocity )
				self:set_animation( "walk" )
			end

			self.timekeeper.clear( "hunger" )
			self.timekeeper.start( 0.5, "action", self.on_search_action )
		end,

		on_search_action = function ( self, cycles, period, elapsed )
			if cycles % 2 == 0 then  -- validate target every 1.0 seconds
				local goal_state = self:verify_target( )
				if goal_state ~= self.state then
					self:reset_alertness( goal_state, self.target )
					return
				end
			end

			local target_pos = self.target.pos
			local dist = self:get_target_distance( )

			-- go to last known position of target and look around
			if dist <= self.search_range then
				if self.speed > 0 then
					self:set_speed( 0 )
					self:set_animation( "stand" )
				end

				if random( 4 ) == 1 then
					self:turn_to( self:get_random_yaw( rad_180 ), 10 )
				end
			else
				-- wait at least 2 seconds after turning to start walking
				if self.speed == 0 and cycles >= 4 and random( 3 ) == 1 then
					self:set_speed( self.sneak_velocity )
					self:set_animation( "walk" )
				end

				if self.can_fly then
					-- descend or ascend to slightly above player altitude, but prevent incessant bobbing
					local v = 0
					if target_pos.y + 2.5 > self.pos.y then
						v = self.walk_velocity
					elseif target_pos.y + 0.5 < self.pos.y then
						v = -self.walk_velocity
					end
					self:set_velocity_vert( v )

				elseif self.can_jump and self.move_result.is_standing then
					if self.yield_level < 3 and self.move_result.collides_xz then
						self.yield_level = self.yield_level + 1
						self.object:set_velocity_vert( 5 )
					end
				end
			end
		end,

		start_escape_action = function ( self )
			assert( self.target.pos )  -- sanity check

			local dist = self:get_target_distance( )
			if self:get_target_yaw_delta( ) < rad_60 and dist <= self.escape_range then
				-- recoil if facing intruder
				self:set_speed( -self.recoil_velocity )
			else
				-- otherwise run in current direction
				self:set_speed( self.run_velocity )
			end
			if self.can_fly then
				self:set_velocity_vert( self.walk_velocity )
				self:set_animation( "swim" )
			else
				self:set_animation( "walk" )
			end

			if self.target.obj and self.target.obj:is_player( ) then
				-- this is a bad player, so keep watch
				self.watch_players[ self.target.obj:get_player_name( ) ] = "escape"
			end

			if self.sounds and self.sounds.escape and random( 2 ) == 1  then
				minetest.sound_play( self.sounds.escape, { object = self.object } )
			end

			self.timekeeper.clear( "hunger" )
			self.timekeeper.start( 0.5, "action", self.on_escape_action )
		end,

		on_escape_action = function ( self, cycles, period, elapsed )
			if cycles % 2 == 0 then
				local goal_state = self:verify_target( )
				if goal_state ~= self.state or random( 10 ) > self.flee_factor then
					self:reset_alertness( goal_state, self.target )
					return
				end
			end

			local target_pos = self.target.pos
			local dist = self:get_target_distance( )

			if dist <= self.escape_range then
				-- if close, keep backtracking
				if cycles % 2 == 0 then
					-- turn every 1.0 seconds (2 cycles)
					self:turn_to( self:get_target_yaw( rad_20 ), 10 )
				end
				if self.speed > 0 then
					self:set_speed( -self.recoil_velocity )
					self:set_animation( self.can_fly and "swim" or "walk" )
				end
			else
				-- otherwise turn and run away
				if cycles % 4 == 0 and self:get_target_yaw_delta( ) < rad_60 then
					-- turn immediately if facing target
					self:turn_to( self:get_target_yaw( rad_60 ) + rad_180, 20 )
				elseif cycles % 2 == 0 then
					-- otherwise turn every 1.0 seconds (2 cycles)
					self:turn_to( self:get_target_yaw( rad_30 ) + rad_180, 10 )
				end
				if self.speed <= 0 then
					self:set_speed( self.run_velocity )
					self:set_animation( self.can_fly and "swim" or "run" )
				end
			end

			if self.can_fly then
				local is_above = minetest.line_of_sight( self.pos,
					{ x = self.pos.x, y = self.pos.y - self.standoff, z = self.pos.z }, 1 )

				if is_above then
					self.object:set_velocity_vert( random_range( -self.stray_velocity, self.stray_velocity ) )
				else
					self.object:set_velocity_vert( random_range( self.walk_velocity, self.run_velocity ) )
				end

			elseif self.can_jump and self.move_result.is_standing then
				if self.yield_level < 3 and self.move_result.collides_xz then
					self.yield_level = self.yield_level + 1
					self:set_velocity_vert( 5 )
				end
			end
		end,

		start_attack_action = function ( self )
			assert( self.target.pos and self.target.obj )  -- sanity check

			self:set_speed( self.run_velocity )
			self:set_animation( "run" )
			self:turn_to( self:get_target_yaw( rad_90 ), 10 )

			if self.sounds and self.sounds.attack and random( 2 ) == 1  then
				minetest.sound_play( self.sounds.attack, { object = self.object } )
			end

			self.timekeeper.clear( "hunger" )
			self.timekeeper.start( 0.2, "action", self.on_attack_action )
		end,

		on_attack_action = function ( self, cycles, period, elapsed )
			if self.target.obj:get_hp( ) == 0 or self.target.obj:get_attach( ) then
				self:reset_alertness( "ignore" )
				return
			end

			if cycles % 5 == 0 then  -- validate target once per second
				local goal_state = self:verify_target( )
				if goal_state ~= self.state then
					self:reset_alertness( goal_state, self.target )
					return
				end
			end

			local target_pos = self.target.pos
			local dist = self:get_target_distance( )

			self:turn_to( self:get_target_yaw( rad_0 ), 5 )

			if dist <= self.attack_range then
				if self.attack_type == "shoot" and self.fire_weapon then
					if cycles % ( self.shoot_period * 5 ) == 0 and random( self.shoot_chance ) == 1 then
						if self.sounds and self.sounds.attack and random( 2 ) == 1 then
							minetest.sound_play( self.sounds.attack, { object = self.object } )
						end
						self:fire_weapon( target_pos )
						self:set_animation( "punch" )
					else
						self:set_animation( self.can_fly and "swim" or "walk" )
					end

				elseif self.attack_type == "melee" then
					if cycles % 5 == 0 then
						if self.sounds and self.sounds.attack and random( 3 ) == 1  then
							minetest.sound_play( self.sounds.attack, { object = self.object } )
						end
					--      if minetest.line_of_sight( pos, target_pos, 0.5 ) then  -- do not hit player through walls!
							self.target.obj:punch( self.object, 1.0,  {
								full_punch_interval = 1.0,
								damage_groups = { fleshy=self.damage }
							}, vector.direction( self.pos, target_pos ) )
					--      end
						self:set_animation( "punch" )
					else
						self:set_animation( self.can_fly and "swim" or "walk" )
					end
				end

				if self.can_fly and cycles % 2 == 0 then
					local v = self.new_vel.y
					if target_pos.y + 0.5 > self.pos.y then
						v = self.stray_velocity
					elseif target_pos.y + 2.5 < self.pos.y then
						v = -self.stray_velocity
					elseif dist < 1.0 then
						v = self.stray_velocity
					else
						v = random_range( -self.stray_velocity, self.stray_velocity )
					end
					self:set_velocity_vert( v )
				end

				if random( 5 ) == 1 then	-- dodge player by sidestepping at random intervals
					self:set_speed_lateral( random( -self.stray_velocity, self.stray_velocity ), 0 )
				end

			else
				if self.can_fly and cycles % 2 == 0 then
					local v = self.new_vel.y
					-- descend or ascend to slightly above player altitude, but prevent incessant bobbing
					if target_pos.y + 0.5 > self.pos.y then
						v = target_pos.y - self.pos.y > self.standoff and self.run_velocity or self.stray_velocity
					elseif target_pos.y + 2.5 < self.pos.y then
						v = target_pos.y - self.pos.y < -self.standoff and -self.run_velocity or -self.stray_velocity
					elseif dist > self.attack_range * 2 then
						v = self.stray_velocity
					elseif random( 10 ) == 1 then
						v = random_range( -self.stray_velocity, self.stray_velocity )
					end
					self:set_velocity_vert( v )

				elseif self.can_jump and self.move_result.is_standing and
						self.yield_level < 3 and self.move_result.collides_xz then
					self.yield_level = self.yield_level + 1
					self:set_velocity_vert( 5 )
				end

				if self:get_target_yaw_delta( ) > rad_30 then
					-- defend from turn-strafing
					if random( 15 ) == 1 then
						self:set_speed( 0 )
					end
					self:set_animation( "walk" )
				elseif self.speed <= 0 then
					self:set_speed( self.run_velocity )
					self:set_animation( "run" )
				end
			end
		end,

		-- animation handler --

		set_animation = function ( self, type )
			if not self.animation or self.cur_animation == type then
				return
			end

			if type == "stand" then
				if self.animation.stand_start and self.animation.stand_end and self.animation.speed_normal then
					self.object:set_animation(
						{ x = self.animation.stand_start, y = self.animation.stand_end },
						self.animation.speed_normal, 0
					)
				end
			elseif type == "walk" then
				if self.animation.walk_start and self.animation.walk_end and self.animation.speed_normal then
					self.object:set_animation(
						{ x = self.animation.walk_start, y = self.animation.walk_end },
						self.animation.speed_normal, 0
					)
				end
			elseif type == "run" then
				if self.animation.run_start and self.animation.run_end and self.animation.speed_run then
					self.object:set_animation(
						{ x = self.animation.run_start, y = self.animation.run_end },
						self.animation.speed_run, 0
					)
				end
			elseif type == "swim" then
				if self.animation.swim_start and self.animation.swim_end and self.animation.speed_swim then
					self.object:set_animation(
						{ x = self.animation.swim_start, y = self.animation.swim_end },
						self.animation.speed_swim, 0
					)
				end
			elseif type == "punch" then
				if self.animation.punch_start and self.animation.punch_end and self.animation.speed_normal then
					self.object:set_animation(
						{ x = self.animation.punch_start, y = self.animation.punch_end },
						self.animation.speed_normal, 0
					)
				end
			else
				return  -- not a valid animation type, so abort
			end

			self.cur_animation = type
		end,

		-- damage handler --

		handle_damage = function ( self )
			-- handle environmental damage (light, water, and lava)
			local hp = self.object:get_hp( )
			local node = minetest.get_node_above( self.pos, 0.5 )
			local time_of_day = minetest.get_timeofday( )

			if node.name == "ignore" then return end  -- mapblock is not loaded, so abort!
				
			if self.light_damage and self.light_damage > 0 and self.pos.y > 0 and
					minetest.get_node_light( self.pos ) > 4 and check_limits( time_of_day, 0.2, 0.8 ) then
				hp = hp - self.light_damage
				self.object:set_hp( hp )
				if hp <= 0 then
					smoke_effect( self.pos )
					self.object:remove( )
				end
			end
				
			if self.water_damage and self.water_damage > 0 and minetest.get_item_group( node.name, "water" ) ~= 0 then
				hp = hp - self.water_damage
				self.object:set_hp( hp )
				if hp <= 0 then
					smoke_effect( self.pos )
					self.object:remove( )
				end
			end
				
			if self.lava_damage and self.lava_damage > 0 and minetest.get_item_group( node.name, "lava" ) ~= 0 then
				hp = hp - self.lava_damage
				self.object:set_hp( hp )
					if hp <= 0 then
					smoke_effect( self.pos )
					self.object:remove( )
				end
			end
		end,

		-- generic callbacks --
		
		on_step = function( self, dtime, pos, rot, new_vel, old_vel, move_result )
			self.pos = pos
			self.yaw = rot.y
			self.new_vel = new_vel
			self.move_result = move_result

			local hp = self.object:get_hp( )
		
			if hp == 0 then
				self.object:remove( )
				return
			end
			
			self.timeout = self.timeout - dtime
			if self.timeout <= 0 and not self.tamed then
				smoke_effect( pos )
				self.object:remove( )
				return
			end

			if self.enable_fall_damage and move_result.collides_y and old_vel.y < -5 then
				local damage = floor( -old_vel.y - 5 ) + 0.5
				self.object:set_hp( hp - damage )
				if hp - damage <= 0.0 then
					smoke_effect( pos )
					self.object:remove( )
					return
				end
			end

			if move_result.is_swimming then
				local drag = -new_vel.y * liquid_viscosity * 1.5
				local buoyancy = self.density - liquid_density
				self.object:set_acceleration_vert( world_gravity * buoyancy + drag )

			elseif self.is_swimming then
				self.object:set_acceleration_vert( ramp( world_gravity, new_vel.y, 2.0 ) )   -- hack to reduce oscilations
			end
			self.is_swimming = move_result.is_swimming

			if self.yield_level > 0 and not move_result.collides_xz then
				self.yield_level = 0
			end

			self.timekeeper.on_step( dtime )  -- run timer callbacks
		end,

		on_activate = function ( self, staticdata, dtime_s, id )
			registry.avatars[ id ] = self.object

			if self.receptrons then
				AxonObject( self, { fleshy = self.armor } )  -- only inherit from superclass if receptrons exist
			end
			if self.weapon_params then
				TurretShooter( self )  -- only inherit from supereclass if weapon params exist
			end

			self:set_acceleration_vert( self.gravity )
			self:set_velocity_vert( 0 )
			self:set_yaw( random( ) * rad_360 )

			self.yield_level = 0
			self.move_result = { collides_xz = false, collides_y = true, is_standing = true }
			self.pos = self.object:get_pos( )

			self.action_funcs = {
				ignore = self.start_ignore_action,
				remark = self.start_remark_action,
				search = self.start_search_action,
				follow = self.start_follow_action,
				escape = self.start_escape_action,
				attack = self.start_attack_action,
			}

			self.watch_players = table.copy( self.watch_players )
			self.watch_spawnitems = table.copy( self.watch_spawnitems )
			self.watch_wielditems = table.copy( self.watch_wielditems )

			if staticdata then
				local tmp = minetest.deserialize( staticdata )
				if tmp and tmp.lifetimer then
					self.timeout = tmp.lifetimer - dtime_s
				end
				if tmp and tmp.tamed then
					self.tamed = tmp.tamed
				end
			end

			self.timeout = self.timeout - dtime_s
			if self.timeout <= 0 and not self.is_tamed then
				self.object:remove( )
				return
			end

			self.timekeeper = Timekeeper( self )
			self.timekeeper.start( 1.5, "damage", self.handle_damage )

			if self.after_activate then
				self.after_activate( self, id )
			end

			self:reset_alertness( self.neutral_state )
		end,

		on_deactivate = function ( self, id )
			if self.before_deactivate then
				self.before_deactivate( self, id )
			end

			registry.avatars[ id ] = nil
		end,
		
		get_staticdata = function ( self )
			return minetest.serialize( {
				lifetimer = self.timeout,
				is_tamed = self.is_tamed,
			} )
		end,

		on_punch = function ( self, hitter, time_from_last_punch, tool_capabilities, direction, damage )
			local hp = self.object:get_hp( )
			local pos = self.pos
			local tool = hitter:get_wielded_item( )

			if self.before_punch then
				if not self.before_punch( self, hitter, tool, hp, damage ) then return end
			end

			if damage == 0 then return end

			if hp - damage <= 0 and self.gibbage_params then
				local params = self.gibbage_params
				local intensity = 0
				for k, v in pairs( tool_capabilities.damage_groups ) do
					if params.damage_groups[ k ] and v >= params.damage_groups[ k ] then
						intensity = max( intensity, v )  -- get maximum intensity among all damage groups
					end
				end
				if intensity > 0 then
					for i = 1, #params.pieces do
						local obj = minetest.add_entity( vector.offset_y( self.pos, 1.5 ), "mobs:gibbage" )
						obj:get_luaentity( ):launch(
							intensity, params.textures[ random( #params.textures ) ], params.pieces[ i ], params.sound )
					end
				else
					blood_effect( pos )
				end
			elseif self.makes_bloodshed_effect and random( 2 ) == 2 then
				blood_effect( pos )
			end

			if self.sounds and self.sounds.damage_hand and self.sounds.damage_tool then
				self:play_sound( minetest.registered_tools[ tool:get_name( ) ] and
					self.sounds.damage_tool or self.sounds.damage_hand )
			else
				self:play_sound( "mobs_damage" )
			end

			if hitter:is_player( ) then
				if tool then
					tool:add_wear( 100 )
					hitter:set_wielded_item( tool )
				end

				if hp - damage <= self.hp_low then
					self:reset_alertness( self.retreat_state, { obj = hitter, pos = hitter:get_pos( ) } )
				else
					self:reset_alertness( self.defense_state, { obj = hitter, pos = hitter:get_pos( ) } )
				end
			end
		end,

		on_death = function( self, killer )
			for _, drop in ipairs( self.drops ) do
				if random( drop.chance ) == 1 then
					minetest.spawn_item( self.pos, drop.name .. " " .. random( drop.min, drop.max ), 1, 5 )
				end
			end
			if not self.makes_bloodshed_effect then
				smoke_effect( self.pos )
			end

			if self.sounds and self.sounds.death then
				self:play_sound( self.sounds.death )
			end

			if killer:is_player( ) then
				if self.death_message then
					minetest.chat_send_all( string.format( self.death_message, killer:get_player_name( ), self.description ) )
				end
				minetest.log( "action", name .. " killed by " .. killer:get_player_name( ) )
			end
		end,		
	} )
end

mobs.register_spawn = function ( name, def )
	local max_object_count = def.max_object_count
	local min_height = def.min_height
	local max_height = def.max_height
	local min_light = def.min_light
	local max_light = def.max_light
	local can_spawn = def.can_spawn

	minetest.register_abm( {
		nodenames = def.nodenames,
		neighbors = { "air" },
		interval = 10,
		chance = def.chance,
		action = function( pos, node, active_object_count, active_object_count_wider )
			if active_object_count_wider > max_object_count then
				return
			end

			local pos2 = vector.offset_y( pos )
			if minetest.get_node( pos2 ).name ~= "air" or minetest.get_node_above( pos2 ).name ~= "air" then
				return
			elseif not check_limits( minetest.get_node_light( pos2 ), min_light, max_light ) then
				return
			elseif not check_limits( pos2.y, min_height, max_height ) then
				return
			elseif can_spawn and not can_spawn( pos2 ) then
				return
			end
			
			minetest.log( "action", "Adding mob " .. name .. " on ".. node.name .." at " .. minetest.pos_to_string( pos ) )
			minetest.add_entity( pos2, name )
		end
	} )
end

mobs.register_spawn_near = function ( name, def )
	local nodenames = def.nodenames
	local max_light = def.max_light
	local min_light = def.min_light
	local chance = def.chance
	local vert_shift = def.vert_shift
	local is_area_safe = def.is_area_safe
	local safe_area = VoxelArea:new( { MinEdge = def.safe_edge1, MaxEdge = def.safe_edge2 } )
	local can_spawn = def.can_spawn

	globaltimer.shift( 0.5 )
	globaltimer.start( 10, name, function ( )
		for player_name, player in pairs( registry.players ) do
			local player_pos = player:get_pos( )

			if random( chance ) == 1 and is_area_safe == safe_area:containsp( player_pos ) then
				local positions = minetest.find_nodes_in_area_under_air(
					vector.offset( player_pos, -10, vert_shift - 5, -10 ),
					vector.offset( player_pos, 10, vert_shift + 5, 10 ),
					nodenames )

				if #positions > 0 then
					local y_offset = minetest.registered_entities[ name ].y_offset
					local pos = positions[ random( #positions ) ]
					local pos2 = vector.offset_y( pos, 2 )

					if minetest.get_node( pos2 ).name == "air" and minetest.get_node_above( pos2 ).name == "air" and
							check_limits( minetest.get_node_light( pos2 ), min_light, max_light ) and
							( not can_spawn or can_spawn( pos2 ) ) then

						minetest.log( "action", "Adding mob " .. name .. " near player " ..
							player_name .. " at " .. minetest.pos_to_string( pos2 ) )
						minetest.add_entity( vector.offset_y( pos2, y_offset ), name )
					end
				end
			end
		end
	end )
end

mobs.register_spawner_node = function ( name, def )
	local chance = def.chance
	local min_light = def.min_light
	local max_light = def.max_light
	local mob_name = def.mob_name

	def.on_timer = function ( pos, elapsed )
		local y_offset = minetest.registered_entities[ mob_name ].y_offset
		local pos2 = vector.offset_y( pos )

		if random( chance ) == 1 and check_limits( minetest.get_node_light( pos2 ), min_light, max_light ) and
				minetest.get_node( pos2 ).name == "air" and minetest.get_node_above( pos2 ).name == "air" then

			minetest.add_entity( vector.offset_y( pos2, y_offset ), mob_name )
			minetest.log( "action", "Adding mob " .. mob_name .. " on " .. name .. " at " .. minetest.pos_to_string( pos ) )
		end

		return true
	end

	def.after_place_node = function ( pos, player, itemstack )
		minetest.get_node_timer( pos ):start( 10 )
	end

	minetest.register_node( name, def )
end

--------------------

mobs.play_sound = function ( pos, name )
	minetest.sound_play( name, { loop = false }, true )
end

mobs.make_noise = function ( pos, radius, group, intensity )
	axon.generate_radial_stimulus( pos, radius, 0.0, 0.0, { [group] = intensity }, { avatars = true } )
end

mobs.make_noise_repeat = function ( pos, radius, interval, duration, group, intensity )
	globaltimer.start_now( interval, "noise" .. next_noise_id, function ( this, cycles, period, elapsed )
		if elapsed >= duration then return true end  -- we're finished, so cancel timer
		axon.generate_radial_stimulus( pos, radius, 0.0, 0.0, { [group] = intensity }, { avatars = true } )
	end )
	next_noise_id = next_noise_id + 1
end

mobs.insert_object = function ( id, obj )
	registry.objects[ id ] = obj
end

mobs.remove_object = function ( id )
	registry.objects[ id ] = nil
end

--------------------

mobs.presets = {
	grab_handout = function ( def )
		local grab_chance = def.grab_chance
		local wait_chance = def.wait_chance
		local can_eat = def.can_eat

		return function ( self, target_obj, elapsed )

			if random( grab_chance ) == 1 then
				local target_pos = vector.offset_y( target_obj:get_pos( ) )
				local dist = vector.distance( self.pos, target_pos )

				if self:get_direct_yaw_delta( target_pos ) < rad_30 and dist <= self.pickup_range then
					if target_obj:is_player( ) then
						target_obj:get_wielded_item( ):take_item( )
						target_obj:set_wielded_item( "" )
					elseif target_obj:get_entity_name( ) == "__builtin:item" then
						target_obj:remove( )
					end
					if can_eat then
					--	minetest.sound_play( "hbhunger_eat_generic", {
					--		object = self.object,
					--		max_hear_distance = 10,
					--		gain = 1.0
					--	} )
						minetest.add_particle( {
							pos = vector.offset_y( self.pos, 0.5 ),
							velocity = { x = 0, y = 0.8, z = 0 },
							acceleration = { x = 0, y = 0, z = 0 },
							exptime = 4.0,
							size = 3,
							collisiondetection = false,
							vertical = true,
							texture = "heart.png",
						} )
					end
					return self.neutral_state
				end
			end

			return random( wait_chance ) == 1 and "follow" or self.offense_state
		end
	end,
}

--------------------

local emit_defs = { "mobs:griefer_ghost" }

minetest.register_chatcommand( "mobs", {
	description = "Spawn random mobs in the area (for testing purposes or just plain fun).",
	privs = { server = true },
	func = function( player_name, param )
		local pos = minetest.get_player_by_name( player_name ):getpos( )
		local total = param ~= "" and tonumber( param ) or 10

		for count = 1, total do
			local index = math.random( #emit_defs )
			local y = pos.y + minetest.registered_entities[ emit_defs[ index ] ].y_offset + 2
			local x = pos.x + math.random( -5, 5 )
			local z = pos.z + math.random( -5, 5 )

			minetest.add_entity( { x = x, y = y, z = z }, emit_defs[ index ] )
		end
	end
} )

--------------------

dofile( minetest.get_modpath( "mobs" ) .. "/extras.lua" )
dofile( minetest.get_modpath( "mobs" ) .. "/monsters.lua" )
dofile( minetest.get_modpath( "mobs" ) .. "/animals.lua" )

-- compatibility for Minetest S3 engine

if not vector.origin then
	dofile( minetest.get_modpath( "mobs" ) .. "/compatibility.lua" )
end