Commit 0ad16b255b86894f5779c5be51a9eda43ec4dcdf - minetest-mod-mobs-redo

New upstream version 20181016 Julien Puydt 4 years ago

44 changed file(s) with 10936 addition(s) and 0 deletion(s). Raw diff Collapse all Expand all

+3952

-0

api.lua less more

	0
	1	-- Intllib and CMI support check
	2	local MP = minetest.get_modpath(minetest.get_current_modname())
	3	local S, NS = dofile(MP .. "/intllib.lua")
	4	local use_cmi = minetest.global_exists("cmi")
	5
	6	mobs = {
	7	mod = "redo",
	8	version = "20181005",
	9	intllib = S,
	10	invis = minetest.global_exists("invisibility") and invisibility or {},
	11	}
	12
	13	-- creative check
	14	local creative_cache = minetest.settings:get_bool("creative_mode")
	15	function mobs.is_creative(name)
	16	return creative_cache or minetest.check_player_privs(name, {creative = true})
	17	end
	18
	19
	20	-- localize math functions
	21	local pi = math.pi
	22	local square = math.sqrt
	23	local sin = math.sin
	24	local cos = math.cos
	25	local abs = math.abs
	26	local min = math.min
	27	local max = math.max
	28	local atann = math.atan
	29	local random = math.random
	30	local floor = math.floor
	31	local atan = function(x)
	32	if not x or x ~= x then
	33	--error("atan bassed NaN")
	34	return 0
	35	else
	36	return atann(x)
	37	end
	38	end
	39
	40
	41	-- Load settings
	42	local damage_enabled = minetest.settings:get_bool("enable_damage")
	43	local mobs_spawn = minetest.settings:get_bool("mobs_spawn") ~= false
	44	local peaceful_only = minetest.settings:get_bool("only_peaceful_mobs")
	45	local disable_blood = minetest.settings:get_bool("mobs_disable_blood")
	46	local mobs_drop_items = minetest.settings:get_bool("mobs_drop_items") ~= false
	47	local mobs_griefing = minetest.settings:get_bool("mobs_griefing") ~= false
	48	local creative = minetest.settings:get_bool("creative_mode")
	49	local spawn_protected = minetest.settings:get_bool("mobs_spawn_protected") ~= false
	50	local remove_far = minetest.settings:get_bool("remove_far_mobs") ~= false
	51	local difficulty = tonumber(minetest.settings:get("mob_difficulty")) or 1.0
	52	local show_health = minetest.settings:get_bool("mob_show_health") ~= false
	53	local max_per_block = tonumber(minetest.settings:get("max_objects_per_block") or 99)
	54	local mob_chance_multiplier = tonumber(minetest.settings:get("mob_chance_multiplier") or 1)
	55
	56	-- Peaceful mode message so players will know there are no monsters
	57	if peaceful_only then
	58	minetest.register_on_joinplayer(function(player)
	59	minetest.chat_send_player(player:get_player_name(),
	60	S("** Peaceful Mode Active - No Monsters Will Spawn"))
	61	end)
	62	end
	63
	64	-- calculate aoc range for mob count
	65	local aoc_range = tonumber(minetest.settings:get("active_block_range")) * 16
	66
	67	-- pathfinding settings
	68	local enable_pathfinding = true
	69	local stuck_timeout = 3 -- how long before mob gets stuck in place and starts searching
	70	local stuck_path_timeout = 10 -- how long will mob follow path before giving up
	71
	72	-- default nodes
	73	local node_fire = "fire:basic_flame"
	74	local node_permanent_flame = "fire:permanent_flame"
	75	local node_ice = "default:ice"
	76	local node_snowblock = "default:snowblock"
	77	local node_snow = "default:snow"
	78	mobs.fallback_node = minetest.registered_aliases["mapgen_dirt"] or "default:dirt"
	79
	80
	81	-- play sound
	82	local mob_sound = function(self, sound)
	83
	84	if sound then
	85	minetest.sound_play(sound, {
	86	object = self.object,
	87	gain = 1.0,
	88	max_hear_distance = self.sounds.distance
	89	})
	90	end
	91	end
	92
	93
	94	-- attack player/mob
	95	local do_attack = function(self, player)
	96
	97	if self.state == "attack" then
	98	return
	99	end
	100
	101	self.attack = player
	102	self.state = "attack"
	103
	104	if random(0, 100) < 90 then
	105	mob_sound(self, self.sounds.war_cry)
	106	end
	107	end
	108
	109
	110	-- calculate distance
	111	local get_distance = function(a, b)
	112
	113	local x, y, z = a.x - b.x, a.y - b.y, a.z - b.z
	114
	115	return square(x * x + y * y + z * z)
	116	end
	117
	118
	119	-- collision function based on jordan4ibanez' open_ai mod
	120	local collision = function(self)
	121
	122	local pos = self.object:get_pos()
	123	local vel = self.object:get_velocity()
	124	local x, z = 0, 0
	125	local width = -self.collisionbox[1] + self.collisionbox[4] + 0.5
	126
	127	for _,object in ipairs(minetest.get_objects_inside_radius(pos, width)) do
	128
	129	if object:is_player()
	130	or (object:get_luaentity()._cmi_is_mob == true and object ~= self.object) then
	131
	132	local pos2 = object:get_pos()
	133	local vec = {x = pos.x - pos2.x, z = pos.z - pos2.z}
	134
	135	x = x + vec.x
	136	z = z + vec.z
	137	end
	138	end
	139
	140	return({x, z})
	141	end
	142
	143
	144	-- move mob in facing direction
	145	local set_velocity = function(self, v)
	146
	147	local c_x, c_y = 0, 0
	148
	149	-- can mob be pushed, if so calculate direction
	150	if self.pushable then
	151	c_x, c_y = unpack(collision(self))
	152	end
	153
	154	-- halt mob if it has been ordered to stay
	155	if self.order == "stand" then
	156	self.object:set_velocity({x = 0, y = 0, z = 0})
	157	return
	158	end
	159
	160	local yaw = (self.object:get_yaw() or 0) + self.rotate
	161
	162	self.object:set_velocity({
	163	x = (sin(yaw) * -v) + c_x,
	164	y = self.object:get_velocity().y,
	165	z = (cos(yaw) * v) + c_y,
	166	})
	167	end
	168
	169
	170	-- calculate mob velocity
	171	local get_velocity = function(self)
	172
	173	local v = self.object:get_velocity()
	174
	175	return (v.x * v.x + v.z * v.z) ^ 0.5
	176	end
	177
	178
	179	-- set and return valid yaw
	180	local set_yaw = function(self, yaw, delay)
	181
	182	if not yaw or yaw ~= yaw then
	183	yaw = 0
	184	end
	185
	186	delay = delay or 0
	187
	188	if delay == 0 then
	189	self.object:set_yaw(yaw)
	190	return yaw
	191	end
	192
	193	self.target_yaw = yaw
	194	self.delay = delay
	195
	196	return self.target_yaw
	197	end
	198
	199	-- global function to set mob yaw
	200	function mobs:yaw(self, yaw, delay)
	201	set_yaw(self, yaw, delay)
	202	end
	203
	204
	205	-- set defined animation
	206	local set_animation = function(self, anim)
	207
	208	if not self.animation
	209	or not anim then return end
	210
	211	self.animation.current = self.animation.current or ""
	212
	213	-- only set different animation for attacks when setting to same set
	214	if anim ~= "punch" and anim ~= "shoot"
	215	and string.find(self.animation.current, anim) then
	216	return
	217	end
	218
	219	-- check for more than one animation
	220	local num = 0
	221
	222	for n = 1, 4 do
	223
	224	if self.animation[anim .. n .. "_start"]
	225	and self.animation[anim .. n .. "_end"] then
	226	num = n
	227	end
	228	end
	229
	230	-- choose random animation from set
	231	if num > 0 then
	232	num = random(0, num)
	233	anim = anim .. (num ~= 0 and num or "")
	234	end
	235
	236	if anim == self.animation.current
	237	or not self.animation[anim .. "_start"]
	238	or not self.animation[anim .. "_end"] then
	239	return
	240	end
	241
	242	self.animation.current = anim
	243
	244	self.object:set_animation({
	245	x = self.animation[anim .. "_start"],
	246	y = self.animation[anim .. "_end"]},
	247	self.animation[anim .. "_speed"] or self.animation.speed_normal or 15,
	248	0, self.animation[anim .. "_loop"] ~= false)
	249	end
	250
	251	-- above function exported for mount.lua
	252	function mobs:set_animation(self, anim)
	253	set_animation(self, anim)
	254	end
	255
	256
	257	-- check line of sight (by BrunoMine, tweaked by Astrobe)
	258	local line_of_sight = function(self, pos1, pos2, stepsize)
	259
	260	if not pos1 or not pos2 then return end
	261
	262	stepsize = stepsize or 1
	263
	264	local stepv = vector.multiply(vector.direction(pos1, pos2), stepsize)
	265
	266	local s, pos = minetest.line_of_sight(pos1, pos2, stepsize)
	267
	268	-- normal walking and flying mobs can see you through air
	269	if s == true then return true end
	270
	271	-- New pos1 to be analyzed
	272	local npos1 = {x = pos1.x, y = pos1.y, z = pos1.z}
	273
	274	local r, pos = minetest.line_of_sight(npos1, pos2, stepsize)
	275
	276	-- Checks the return
	277	if r == true then return true end
	278
	279	-- Nodename found
	280	local nn = minetest.get_node(pos).name
	281
	282	-- It continues to advance in the line of sight in search of a real
	283	-- obstruction which counts as 'normal' nodebox.
	284	while minetest.registered_nodes[nn]
	285	and (minetest.registered_nodes[nn].walkable == false) do
	286	-- or minetest.registered_nodes[nn].drawtype == "nodebox") do
	287
	288	npos1 = vector.add(npos1, stepv)
	289
	290	if get_distance(npos1, pos2) < stepsize then return true end
	291
	292	-- scan again
	293	r, pos = minetest.line_of_sight(npos1, pos2, stepsize)
	294
	295	if r == true then return true end
	296
	297	-- New Nodename found
	298	nn = minetest.get_node(pos).name
	299	end
	300
	301	return false
	302	end
	303
	304	-- global function
	305	function mobs:line_of_sight(self, pos1, pos2, stepsize)
	306
	307	return line_of_sight(self, pos1, pos2, stepsize)
	308	end
	309
	310
	311	-- are we flying in what we are suppose to? (taikedz)
	312	local flight_check = function(self, pos_w)
	313
	314	local def = minetest.registered_nodes[self.standing_in]
	315
	316	if not def then return false end -- nil check
	317
	318	if type(self.fly_in) == "string"
	319	and self.standing_in == self.fly_in then
	320
	321	return true
	322
	323	elseif type(self.fly_in) == "table" then
	324
	325	for _,fly_in in pairs(self.fly_in) do
	326
	327	if self.standing_in == fly_in then
	328
	329	return true
	330	end
	331	end
	332	end
	333
	334	-- stops mobs getting stuck inside stairs and plantlike nodes
	335	if def.drawtype ~= "airlike"
	336	and def.drawtype ~= "liquid"
	337	and def.drawtype ~= "flowingliquid" then
	338	return true
	339	end
	340
	341	return false
	342	end
	343
	344
	345	-- custom particle effects
	346	local effect = function(pos, amount, texture, min_size, max_size, radius, gravity, glow)
	347
	348	radius = radius or 2
	349	min_size = min_size or 0.5
	350	max_size = max_size or 1
	351	gravity = gravity or -10
	352	glow = glow or 0
	353
	354	minetest.add_particlespawner({
	355	amount = amount,
	356	time = 0.25,
	357	minpos = pos,
	358	maxpos = pos,
	359	minvel = {x = -radius, y = -radius, z = -radius},
	360	maxvel = {x = radius, y = radius, z = radius},
	361	minacc = {x = 0, y = gravity, z = 0},
	362	maxacc = {x = 0, y = gravity, z = 0},
	363	minexptime = 0.1,
	364	maxexptime = 1,
	365	minsize = min_size,
	366	maxsize = max_size,
	367	texture = texture,
	368	glow = glow,
	369	})
	370	end
	371
	372
	373	-- update nametag colour
	374	local update_tag = function(self)
	375
	376	local col = "#00FF00"
	377	local qua = self.hp_max / 4
	378
	379	if self.health <= floor(qua * 3) then
	380	col = "#FFFF00"
	381	end
	382
	383	if self.health <= floor(qua * 2) then
	384	col = "#FF6600"
	385	end
	386
	387	if self.health <= floor(qua) then
	388	col = "#FF0000"
	389	end
	390
	391	self.object:set_properties({
	392	nametag = self.nametag,
	393	nametag_color = col
	394	})
	395
	396	end
	397
	398
	399	-- drop items
	400	local item_drop = function(self)
	401
	402	-- check for nil or no drops
	403	if not self.drops or #self.drops == 0 then
	404	return
	405	end
	406
	407	-- no drops if disabled by setting
	408	if not mobs_drop_items then return end
	409
	410	-- no drops for child mobs
	411	if self.child then return end
	412
	413	-- was mob killed by player?
	414	local death_by_player = self.cause_of_death and self.cause_of_death.puncher
	415	and self.cause_of_death.puncher:is_player() or nil
	416
	417	local obj, item, num
	418	local pos = self.object:get_pos()
	419
	420	for n = 1, #self.drops do
	421
	422	if random(1, self.drops[n].chance) == 1 then
	423
	424	num = random(self.drops[n].min or 0, self.drops[n].max or 1)
	425	item = self.drops[n].name
	426
	427	-- cook items on a hot death
	428	if self.cause_of_death.hot then
	429
	430	local output = minetest.get_craft_result({
	431	method = "cooking", width = 1, items = {item}})
	432
	433	if output and output.item and not output.item:is_empty() then
	434	item = output.item:get_name()
	435	end
	436	end
	437
	438	-- only drop rare items (drops.min=0) if killed by player
	439	if death_by_player then
	440	obj = minetest.add_item(pos, ItemStack(item .. " " .. num))
	441
	442	elseif self.drops[n].min ~= 0 then
	443	obj = minetest.add_item(pos, ItemStack(item .. " " .. num))
	444	end
	445
	446	if obj and obj:get_luaentity() then
	447
	448	obj:set_velocity({
	449	x = random(-10, 10) / 9,
	450	y = 6,
	451	z = random(-10, 10) / 9,
	452	})
	453
	454	elseif obj then
	455	obj:remove() -- item does not exist
	456	end
	457	end
	458	end
	459
	460	self.drops = {}
	461	end
	462
	463
	464	-- check if mob is dead or only hurt
	465	local check_for_death = function(self, cmi_cause)
	466
	467	-- has health actually changed?
	468	if self.health == self.old_health and self.health > 0 then
	469	return
	470	end
	471
	472	self.old_health = self.health
	473
	474	-- still got some health? play hurt sound
	475	if self.health > 0 then
	476
	477	mob_sound(self, self.sounds.damage)
	478
	479	-- make sure health isn't higher than max
	480	if self.health > self.hp_max then
	481	self.health = self.hp_max
	482	end
	483
	484	-- backup nametag so we can show health stats
	485	if not self.nametag2 then
	486	self.nametag2 = self.nametag or ""
	487	end
	488
	489	if show_health
	490	and (cmi_cause and cmi_cause.type == "punch") then
	491
	492	self.htimer = 2
	493	self.nametag = "♥ " .. self.health .. " / " .. self.hp_max
	494
	495	update_tag(self)
	496	end
	497
	498	return false
	499	end
	500
	501	self.cause_of_death = cmi_cause
	502
	503	-- drop items
	504	item_drop(self)
	505
	506	mob_sound(self, self.sounds.death)
	507
	508	local pos = self.object:get_pos()
	509
	510	-- execute custom death function
	511	if self.on_die then
	512
	513	self.on_die(self, pos)
	514
	515	if use_cmi then
	516	cmi.notify_die(self.object, cmi_cause)
	517	end
	518
	519	self.object:remove()
	520
	521	return true
	522	end
	523
	524	-- default death function and die animation (if defined)
	525	if self.animation
	526	and self.animation.die_start
	527	and self.animation.die_end then
	528
	529	local frames = self.animation.die_end - self.animation.die_start
	530	local speed = self.animation.die_speed or 15
	531	local length = max(frames / speed, 0)
	532
	533	self.attack = nil
	534	self.v_start = false
	535	self.timer = 0
	536	self.blinktimer = 0
	537	self.passive = true
	538	self.state = "die"
	539	set_velocity(self, 0)
	540	set_animation(self, "die")
	541
	542	minetest.after(length, function(self)
	543
	544	if use_cmi and self.object:get_luaentity() then
	545	cmi.notify_die(self.object, cmi_cause)
	546	end
	547
	548	self.object:remove()
	549	end, self)
	550	else
	551
	552	if use_cmi then
	553	cmi.notify_die(self.object, cmi_cause)
	554	end
	555
	556	self.object:remove()
	557	end
	558
	559	effect(pos, 20, "tnt_smoke.png")
	560
	561	return true
	562	end
	563
	564
	565	-- is mob facing a cliff
	566	local is_at_cliff = function(self)
	567
	568	if self.fear_height == 0 then -- 0 for no falling protection!
	569	return false
	570	end
	571
	572	local yaw = self.object:get_yaw()
	573	local dir_x = -sin(yaw) * (self.collisionbox[4] + 0.5)
	574	local dir_z = cos(yaw) * (self.collisionbox[4] + 0.5)
	575	local pos = self.object:get_pos()
	576	local ypos = pos.y + self.collisionbox[2] -- just above floor
	577
	578	if minetest.line_of_sight(
	579	{x = pos.x + dir_x, y = ypos, z = pos.z + dir_z},
	580	{x = pos.x + dir_x, y = ypos - self.fear_height, z = pos.z + dir_z}
	581	, 1) then
	582
	583	return true
	584	end
	585
	586	return false
	587	end
	588
	589
	590	-- get node but use fallback for nil or unknown
	591	local node_ok = function(pos, fallback)
	592
	593	fallback = fallback or mobs.fallback_node
	594
	595	local node = minetest.get_node_or_nil(pos)
	596
	597	if node and minetest.registered_nodes[node.name] then
	598	return node
	599	end
	600
	601	return minetest.registered_nodes[fallback]
	602	end
	603
	604
	605	-- environmental damage (water, lava, fire, light etc.)
	606	local do_env_damage = function(self)
	607
	608	-- feed/tame text timer (so mob 'full' messages dont spam chat)
	609	if self.htimer > 0 then
	610	self.htimer = self.htimer - 1
	611	end
	612
	613	-- reset nametag after showing health stats
	614	if self.htimer < 1 and self.nametag2 then
	615
	616	self.nametag = self.nametag2
	617	self.nametag2 = nil
	618
	619	update_tag(self)
	620	end
	621
	622	local pos = self.object:get_pos()
	623
	624	self.time_of_day = minetest.get_timeofday()
	625
	626	-- remove mob if standing inside ignore node
	627	if self.standing_in == "ignore" then
	628	self.object:remove()
	629	return
	630	end
	631
	632	-- is mob light sensative, or scared of the dark :P
	633	if self.light_damage ~= 0 then
	634
	635	local light = minetest.get_node_light(pos) or 0
	636
	637	if light >= self.light_damage_min
	638	and light <= self.light_damage_max then
	639
	640	self.health = self.health - self.light_damage
	641
	642	effect(pos, 5, "tnt_smoke.png")
	643
	644	if check_for_death(self, {type = "light"}) then return end
	645	end
	646	end
	647
	648	local nodef = minetest.registered_nodes[self.standing_in]
	649
	650	pos.y = pos.y + 1 -- for particle effect position
	651
	652	-- water
	653	if self.water_damage
	654	and nodef.groups.water then
	655
	656	if self.water_damage ~= 0 then
	657
	658	self.health = self.health - self.water_damage
	659
	660	effect(pos, 5, "bubble.png", nil, nil, 1, nil)
	661
	662	if check_for_death(self, {type = "environment",
	663	pos = pos, node = self.standing_in}) then return end
	664	end
	665
	666	-- lava or fire or ignition source
	667	elseif self.lava_damage
	668	and nodef.groups.igniter then
	669	-- and (nodef.groups.lava
	670	-- or self.standing_in == node_fire
	671	-- or self.standing_in == node_permanent_flame) then
	672
	673	if self.lava_damage ~= 0 then
	674
	675	self.health = self.health - self.lava_damage
	676
	677	effect(pos, 5, "fire_basic_flame.png", nil, nil, 1, nil)
	678
	679	if check_for_death(self, {type = "environment",
	680	pos = pos, node = self.standing_in, hot = true}) then return end
	681	end
	682
	683	-- damage_per_second node check
	684	elseif nodef.damage_per_second ~= 0 then
	685
	686	self.health = self.health - nodef.damage_per_second
	687
	688	effect(pos, 5, "tnt_smoke.png")
	689
	690	if check_for_death(self, {type = "environment",
	691	pos = pos, node = self.standing_in}) then return end
	692	end
	693	--[[
	694	--- suffocation inside solid node
	695	if self.suffocation ~= 0
	696	and nodef.walkable == true
	697	and nodef.groups.disable_suffocation ~= 1
	698	and nodef.drawtype == "normal" then
	699
	700	self.health = self.health - self.suffocation
	701
	702	if check_for_death(self, {type = "environment",
	703	pos = pos, node = self.standing_in}) then return end
	704	end
	705	]]
	706	check_for_death(self, {type = "unknown"})
	707	end
	708
	709
	710	-- jump if facing a solid node (not fences or gates)
	711	local do_jump = function(self)
	712
	713	if not self.jump
	714	or self.jump_height == 0
	715	or self.fly
	716	or self.child
	717	or self.order == "stand" then
	718	return false
	719	end
	720
	721	self.facing_fence = false
	722
	723	-- something stopping us while moving?
	724	if self.state ~= "stand"
	725	and get_velocity(self) > 0.5
	726	and self.object:get_velocity().y ~= 0 then
	727	return false
	728	end
	729
	730	local pos = self.object:get_pos()
	731	local yaw = self.object:get_yaw()
	732
	733	-- what is mob standing on?
	734	pos.y = pos.y + self.collisionbox[2] - 0.2
	735
	736	local nod = node_ok(pos)
	737
	738	--print ("standing on:", nod.name, pos.y)
	739
	740	if minetest.registered_nodes[nod.name].walkable == false then
	741	return false
	742	end
	743
	744	-- where is front
	745	local dir_x = -sin(yaw) * (self.collisionbox[4] + 0.5)
	746	local dir_z = cos(yaw) * (self.collisionbox[4] + 0.5)
	747
	748	-- what is in front of mob?
	749	local nod = node_ok({
	750	x = pos.x + dir_x,
	751	y = pos.y + 0.5,
	752	z = pos.z + dir_z
	753	})
	754
	755	-- thin blocks that do not need to be jumped
	756	if nod.name == node_snow then
	757	return false
	758	end
	759
	760	--print ("in front:", nod.name, pos.y + 0.5)
	761
	762	if self.walk_chance == 0
	763	or minetest.registered_items[nod.name].walkable then
	764
	765	if not nod.name:find("fence")
	766	and not nod.name:find("gate") then
	767
	768	local v = self.object:get_velocity()
	769
	770	v.y = self.jump_height
	771
	772	set_animation(self, "jump") -- only when defined
	773
	774	self.object:set_velocity(v)
	775
	776	-- when in air move forward
	777	minetest.after(0.3, function(self, v)
	778
	779	if self.object:get_luaentity() then
	780
	781	self.object:set_acceleration({
	782	x = v.x * 2,--1.5,
	783	y = 0,
	784	z = v.z * 2,--1.5
	785	})
	786	end
	787	end, self, v)
	788
	789	if get_velocity(self) > 0 then
	790	mob_sound(self, self.sounds.jump)
	791	end
	792	else
	793	self.facing_fence = true
	794	end
	795
	796	return true
	797	end
	798
	799	return false
	800	end
	801
	802
	803	-- blast damage to entities nearby (modified from TNT mod)
	804	local entity_physics = function(pos, radius)
	805
	806	radius = radius * 2
	807
	808	local objs = minetest.get_objects_inside_radius(pos, radius)
	809	local obj_pos, dist
	810
	811	for n = 1, #objs do
	812
	813	obj_pos = objs[n]:get_pos()
	814
	815	dist = get_distance(pos, obj_pos)
	816	if dist < 1 then dist = 1 end
	817
	818	local damage = floor((4 / dist) * radius)
	819	local ent = objs[n]:get_luaentity()
	820
	821	-- punches work on entities AND players
	822	objs[n]:punch(objs[n], 1.0, {
	823	full_punch_interval = 1.0,
	824	damage_groups = {fleshy = damage},
	825	}, pos)
	826	end
	827	end
	828
	829
	830	-- should mob follow what I'm holding ?
	831	local follow_holding = function(self, clicker)
	832
	833	if mobs.invis[clicker:get_player_name()] then
	834	return false
	835	end
	836
	837	local item = clicker:get_wielded_item()
	838	local t = type(self.follow)
	839
	840	-- single item
	841	if t == "string"
	842	and item:get_name() == self.follow then
	843	return true
	844
	845	-- multiple items
	846	elseif t == "table" then
	847
	848	for no = 1, #self.follow do
	849
	850	if self.follow[no] == item:get_name() then
	851	return true
	852	end
	853	end
	854	end
	855
	856	return false
	857	end
	858
	859
	860	-- find two animals of same type and breed if nearby and horny
	861	local breed = function(self)
	862
	863	-- child takes 240 seconds before growing into adult
	864	if self.child == true then
	865
	866	self.hornytimer = self.hornytimer + 1
	867
	868	if self.hornytimer > 240 then
	869
	870	self.child = false
	871	self.hornytimer = 0
	872
	873	self.object:set_properties({
	874	textures = self.base_texture,
	875	mesh = self.base_mesh,
	876	visual_size = self.base_size,
	877	collisionbox = self.base_colbox,
	878	selectionbox = self.base_selbox,
	879	})
	880
	881	-- custom function when child grows up
	882	if self.on_grown then
	883	self.on_grown(self)
	884	else
	885	-- jump when fully grown so as not to fall into ground
	886	self.object:set_velocity({
	887	x = 0,
	888	y = self.jump_height,
	889	z = 0
	890	})
	891	end
	892	end
	893
	894	return
	895	end
	896
	897	-- horny animal can mate for 40 seconds,
	898	-- afterwards horny animal cannot mate again for 200 seconds
	899	if self.horny == true
	900	and self.hornytimer < 240 then
	901
	902	self.hornytimer = self.hornytimer + 1
	903
	904	if self.hornytimer >= 240 then
	905	self.hornytimer = 0
	906	self.horny = false
	907	end
	908	end
	909
	910	-- find another same animal who is also horny and mate if nearby
	911	if self.horny == true
	912	and self.hornytimer <= 40 then
	913
	914	local pos = self.object:get_pos()
	915
	916	effect({x = pos.x, y = pos.y + 1, z = pos.z}, 8, "heart.png", 3, 4, 1, 0.1)
	917
	918	local objs = minetest.get_objects_inside_radius(pos, 3)
	919	local num = 0
	920	local ent = nil
	921
	922	for n = 1, #objs do
	923
	924	ent = objs[n]:get_luaentity()
	925
	926	-- check for same animal with different colour
	927	local canmate = false
	928
	929	if ent then
	930
	931	if ent.name == self.name then
	932	canmate = true
	933	else
	934	local entname = string.split(ent.name,":")
	935	local selfname = string.split(self.name,":")
	936
	937	if entname[1] == selfname[1] then
	938	entname = string.split(entname[2],"_")
	939	selfname = string.split(selfname[2],"_")
	940
	941	if entname[1] == selfname[1] then
	942	canmate = true
	943	end
	944	end
	945	end
	946	end
	947
	948	if ent
	949	and canmate == true
	950	and ent.horny == true
	951	and ent.hornytimer <= 40 then
	952	num = num + 1
	953	end
	954
	955	-- found your mate? then have a baby
	956	if num > 1 then
	957
	958	self.hornytimer = 41
	959	ent.hornytimer = 41
	960
	961	-- spawn baby
	962	minetest.after(5, function(self, ent)
	963
	964	if not self.object:get_luaentity() then
	965	return
	966	end
	967
	968	-- custom breed function
	969	if self.on_breed then
	970
	971	-- when false skip going any further
	972	if self.on_breed(self, ent) == false then
	973	return
	974	end
	975	else
	976	effect(pos, 15, "tnt_smoke.png", 1, 2, 2, 15, 5)
	977	end
	978
	979	local mob = minetest.add_entity(pos, self.name)
	980	local ent2 = mob:get_luaentity()
	981	local textures = self.base_texture
	982
	983	-- using specific child texture (if found)
	984	if self.child_texture then
	985	textures = self.child_texture[1]
	986	end
	987
	988	-- and resize to half height
	989	mob:set_properties({
	990	textures = textures,
	991	visual_size = {
	992	x = self.base_size.x * .5,
	993	y = self.base_size.y * .5,
	994	},
	995	collisionbox = {
	996	self.base_colbox[1] * .5,
	997	self.base_colbox[2] * .5,
	998	self.base_colbox[3] * .5,
	999	self.base_colbox[4] * .5,
	1000	self.base_colbox[5] * .5,
	1001	self.base_colbox[6] * .5,
	1002	},
	1003	selectionbox = {
	1004	self.base_selbox[1] * .5,
	1005	self.base_selbox[2] * .5,
	1006	self.base_selbox[3] * .5,
	1007	self.base_selbox[4] * .5,
	1008	self.base_selbox[5] * .5,
	1009	self.base_selbox[6] * .5,
	1010	},
	1011	})
	1012	-- tamed and owned by parents' owner
	1013	ent2.child = true
	1014	ent2.tamed = true
	1015	ent2.owner = self.owner
	1016	end, self, ent)
	1017
	1018	num = 0
	1019
	1020	break
	1021	end
	1022	end
	1023	end
	1024	end
	1025
	1026
	1027	-- find and replace what mob is looking for (grass, wheat etc.)
	1028	local replace = function(self, pos)
	1029
	1030	if not mobs_griefing
	1031	or not self.replace_rate
	1032	or not self.replace_what
	1033	or self.child == true
	1034	or self.object:get_velocity().y ~= 0
	1035	or random(1, self.replace_rate) > 1 then
	1036	return
	1037	end
	1038
	1039	local what, with, y_offset
	1040
	1041	if type(self.replace_what[1]) == "table" then
	1042
	1043	local num = random(#self.replace_what)
	1044
	1045	what = self.replace_what[num][1] or ""
	1046	with = self.replace_what[num][2] or ""
	1047	y_offset = self.replace_what[num][3] or 0
	1048	else
	1049	what = self.replace_what
	1050	with = self.replace_with or ""
	1051	y_offset = self.replace_offset or 0
	1052	end
	1053
	1054	pos.y = pos.y + y_offset
	1055
	1056	if #minetest.find_nodes_in_area(pos, pos, what) > 0 then
	1057
	1058	-- print ("replace node = ".. minetest.get_node(pos).name, pos.y)
	1059
	1060	local oldnode = {name = what}
	1061	local newnode = {name = with}
	1062	local on_replace_return
	1063
	1064	if self.on_replace then
	1065	on_replace_return = self.on_replace(self, pos, oldnode, newnode)
	1066	end
	1067
	1068	if on_replace_return ~= false then
	1069
	1070	minetest.set_node(pos, {name = with})
	1071
	1072	-- when cow/sheep eats grass, replace wool and milk
	1073	if self.gotten == true then
	1074	self.gotten = false
	1075	self.object:set_properties(self)
	1076	end
	1077	end
	1078	end
	1079	end
	1080
	1081
	1082	-- check if daytime and also if mob is docile during daylight hours
	1083	local day_docile = function(self)
	1084
	1085	if self.docile_by_day == false then
	1086
	1087	return false
	1088
	1089	elseif self.docile_by_day == true
	1090	and self.time_of_day > 0.2
	1091	and self.time_of_day < 0.8 then
	1092
	1093	return true
	1094	end
	1095	end
	1096
	1097
	1098	local los_switcher = false
	1099	local height_switcher = false
	1100
	1101	-- path finding and smart mob routine by rnd, line_of_sight and other edits by Elkien3
	1102	local smart_mobs = function(self, s, p, dist, dtime)
	1103
	1104	local s1 = self.path.lastpos
	1105
	1106	local target_pos = self.attack:get_pos()
	1107
	1108	-- is it becoming stuck?
	1109	if abs(s1.x - s.x) + abs(s1.z - s.z) < .5 then
	1110	self.path.stuck_timer = self.path.stuck_timer + dtime
	1111	else
	1112	self.path.stuck_timer = 0
	1113	end
	1114
	1115	self.path.lastpos = {x = s.x, y = s.y, z = s.z}
	1116
	1117	local use_pathfind = false
	1118	local has_lineofsight = minetest.line_of_sight(
	1119	{x = s.x, y = (s.y) + .5, z = s.z},
	1120	{x = target_pos.x, y = (target_pos.y) + 1.5, z = target_pos.z}, .2)
	1121
	1122	-- im stuck, search for path
	1123	if not has_lineofsight then
	1124
	1125	if los_switcher == true then
	1126	use_pathfind = true
	1127	los_switcher = false
	1128	end -- cannot see target!
	1129	else
	1130	if los_switcher == false then
	1131
	1132	los_switcher = true
	1133	use_pathfind = false
	1134
	1135	minetest.after(1, function(self)
	1136
	1137	if self.object:get_luaentity() then
	1138
	1139	if has_lineofsight then
	1140	self.path.following = false
	1141	end
	1142	end
	1143	end, self)
	1144	end -- can see target!
	1145	end
	1146
	1147	if (self.path.stuck_timer > stuck_timeout and not self.path.following) then
	1148
	1149	use_pathfind = true
	1150	self.path.stuck_timer = 0
	1151
	1152	minetest.after(1, function(self)
	1153
	1154	if self.object:get_luaentity() then
	1155
	1156	if has_lineofsight then
	1157	self.path.following = false
	1158	end
	1159	end
	1160	end, self)
	1161	end
	1162
	1163	if (self.path.stuck_timer > stuck_path_timeout and self.path.following) then
	1164
	1165	use_pathfind = true
	1166	self.path.stuck_timer = 0
	1167
	1168	minetest.after(1, function(self)
	1169
	1170	if self.object:get_luaentity() then
	1171
	1172	if has_lineofsight then
	1173	self.path.following = false
	1174	end
	1175	end
	1176	end, self)
	1177	end
	1178
	1179	if abs(vector.subtract(s,target_pos).y) > self.stepheight then
	1180
	1181	if height_switcher then
	1182	use_pathfind = true
	1183	height_switcher = false
	1184	end
	1185	else
	1186	if not height_switcher then
	1187	use_pathfind = false
	1188	height_switcher = true
	1189	end
	1190	end
	1191
	1192	if use_pathfind then
	1193	-- lets try find a path, first take care of positions
	1194	-- since pathfinder is very sensitive
	1195	local sheight = self.collisionbox[5] - self.collisionbox[2]
	1196
	1197	-- round position to center of node to avoid stuck in walls
	1198	-- also adjust height for player models!
	1199	s.x = floor(s.x + 0.5)
	1200	-- s.y = floor(s.y + 0.5) - sheight
	1201	s.z = floor(s.z + 0.5)
	1202
	1203	local ssight, sground = minetest.line_of_sight(s, {
	1204	x = s.x, y = s.y - 4, z = s.z}, 1)
	1205
	1206	-- determine node above ground
	1207	if not ssight then
	1208	s.y = sground.y + 1
	1209	end
	1210
	1211	local p1 = self.attack:get_pos()
	1212
	1213	p1.x = floor(p1.x + 0.5)
	1214	p1.y = floor(p1.y + 0.5)
	1215	p1.z = floor(p1.z + 0.5)
	1216
	1217	local dropheight = 6
	1218	if self.fear_height ~= 0 then dropheight = self.fear_height end
	1219
	1220	self.path.way = minetest.find_path(s, p1, 16, self.stepheight, dropheight, "Dijkstra")
	1221
	1222	--[[
	1223	-- show path using particles
	1224	if self.path.way and #self.path.way > 0 then
	1225	print ("-- path length:" .. tonumber(#self.path.way))
	1226	for _,pos in pairs(self.path.way) do
	1227	minetest.add_particle({
	1228	pos = pos,
	1229	velocity = {x=0, y=0, z=0},
	1230	acceleration = {x=0, y=0, z=0},
	1231	expirationtime = 1,
	1232	size = 4,
	1233	collisiondetection = false,
	1234	vertical = false,
	1235	texture = "heart.png",
	1236	})
	1237	end
	1238	end
	1239	]]
	1240
	1241	self.state = ""
	1242	do_attack(self, self.attack)
	1243
	1244	-- no path found, try something else
	1245	if not self.path.way then
	1246
	1247	self.path.following = false
	1248
	1249	-- lets make way by digging/building if not accessible
	1250	if self.pathfinding == 2 and mobs_griefing then
	1251
	1252	-- is player higher than mob?
	1253	if s.y < p1.y then
	1254
	1255	-- build upwards
	1256	if not minetest.is_protected(s, "") then
	1257
	1258	local ndef1 = minetest.registered_nodes[self.standing_in]
	1259
	1260	if ndef1 and (ndef1.buildable_to or ndef1.groups.liquid) then
	1261
	1262	minetest.set_node(s, {name = mobs.fallback_node})
	1263	end
	1264	end
	1265
	1266	local sheight = math.ceil(self.collisionbox[5]) + 1
	1267
	1268	-- assume mob is 2 blocks high so it digs above its head
	1269	s.y = s.y + sheight
	1270
	1271	-- remove one block above to make room to jump
	1272	if not minetest.is_protected(s, "") then
	1273
	1274	local node1 = node_ok(s, "air").name
	1275	local ndef1 = minetest.registered_nodes[node1]
	1276
	1277	if node1 ~= "air"
	1278	and node1 ~= "ignore"
	1279	and ndef1
	1280	and not ndef1.groups.level
	1281	and not ndef1.groups.unbreakable
	1282	and not ndef1.groups.liquid then
	1283
	1284	minetest.set_node(s, {name = "air"})
	1285	minetest.add_item(s, ItemStack(node1))
	1286
	1287	end
	1288	end
	1289
	1290	s.y = s.y - sheight
	1291	self.object:set_pos({x = s.x, y = s.y + 2, z = s.z})
	1292
	1293	else -- dig 2 blocks to make door toward player direction
	1294
	1295	local yaw1 = self.object:get_yaw() + pi / 2
	1296	local p1 = {
	1297	x = s.x + cos(yaw1),
	1298	y = s.y,
	1299	z = s.z + sin(yaw1)
	1300	}
	1301
	1302	if not minetest.is_protected(p1, "") then
	1303
	1304	local node1 = node_ok(p1, "air").name
	1305	local ndef1 = minetest.registered_nodes[node1]
	1306
	1307	if node1 ~= "air"
	1308	and node1 ~= "ignore"
	1309	and ndef1
	1310	and not ndef1.groups.level
	1311	and not ndef1.groups.unbreakable
	1312	and not ndef1.groups.liquid then
	1313
	1314	minetest.add_item(p1, ItemStack(node1))
	1315	minetest.set_node(p1, {name = "air"})
	1316	end
	1317
	1318	p1.y = p1.y + 1
	1319	node1 = node_ok(p1, "air").name
	1320	ndef1 = minetest.registered_nodes[node1]
	1321
	1322	if node1 ~= "air"
	1323	and node1 ~= "ignore"
	1324	and ndef1
	1325	and not ndef1.groups.level
	1326	and not ndef1.groups.unbreakable
	1327	and not ndef1.groups.liquid then
	1328
	1329	minetest.add_item(p1, ItemStack(node1))
	1330	minetest.set_node(p1, {name = "air"})
	1331	end
	1332
	1333	end
	1334	end
	1335	end
	1336
	1337	-- will try again in 2 second
	1338	self.path.stuck_timer = stuck_timeout - 2
	1339
	1340	-- frustration! cant find the damn path :(
	1341	mob_sound(self, self.sounds.random)
	1342	else
	1343	-- yay i found path
	1344	mob_sound(self, self.sounds.war_cry)
	1345	set_velocity(self, self.walk_velocity)
	1346
	1347	-- follow path now that it has it
	1348	self.path.following = true
	1349	end
	1350	end
	1351	end
	1352
	1353
	1354	-- specific attacks
	1355	local specific_attack = function(list, what)
	1356
	1357	-- no list so attack default (player, animals etc.)
	1358	if list == nil then
	1359	return true
	1360	end
	1361
	1362	-- found entity on list to attack?
	1363	for no = 1, #list do
	1364
	1365	if list[no] == what then
	1366	return true
	1367	end
	1368	end
	1369
	1370	return false
	1371	end
	1372
	1373
	1374	-- general attack function for all mobs ==========
	1375	local general_attack = function(self)
	1376
	1377	-- return if already attacking, passive or docile during day
	1378	if self.passive
	1379	or self.state == "attack"
	1380	or day_docile(self) then
	1381	return
	1382	end
	1383
	1384	local s = self.object:get_pos()
	1385	local objs = minetest.get_objects_inside_radius(s, self.view_range)
	1386
	1387	-- remove entities we aren't interested in
	1388	for n = 1, #objs do
	1389
	1390	local ent = objs[n]:get_luaentity()
	1391
	1392	-- are we a player?
	1393	if objs[n]:is_player() then
	1394
	1395	-- if player invisible or mob not setup to attack then remove from list
	1396	if self.attack_players == false
	1397	or (self.owner and self.type ~= "monster")
	1398	or mobs.invis[objs[n]:get_player_name()]
	1399	or not specific_attack(self.specific_attack, "player") then
	1400	objs[n] = nil
	1401	--print("- pla", n)
	1402	end
	1403
	1404	-- or are we a mob?
	1405	elseif ent and ent._cmi_is_mob then
	1406
	1407	-- remove mobs not to attack
	1408	if self.name == ent.name
	1409	or (not self.attack_animals and ent.type == "animal")
	1410	or (not self.attack_monsters and ent.type == "monster")
	1411	or (not self.attack_npcs and ent.type == "npc")
	1412	or not specific_attack(self.specific_attack, ent.name) then
	1413	objs[n] = nil
	1414	--print("- mob", n, self.name, ent.name)
	1415	end
	1416
	1417	-- remove all other entities
	1418	else
	1419	--print(" -obj", n)
	1420	objs[n] = nil
	1421	end
	1422	end
	1423
	1424	local p, sp, dist, min_player
	1425	local min_dist = self.view_range + 1
	1426
	1427	-- go through remaining entities and select closest
	1428	for _,player in pairs(objs) do
	1429
	1430	p = player:get_pos()
	1431	sp = s
	1432
	1433	dist = get_distance(p, s)
	1434
	1435	-- aim higher to make looking up hills more realistic
	1436	p.y = p.y + 1
	1437	sp.y = sp.y + 1
	1438
	1439	-- choose closest player to attack that isnt self
	1440	if dist ~= 0
	1441	and dist < min_dist
	1442	and line_of_sight(self, sp, p, 2) == true then
	1443	min_dist = dist
	1444	min_player = player
	1445	end
	1446	end
	1447
	1448	-- attack closest player or mob
	1449	if min_player and random(1, 100) > self.attack_chance then
	1450	do_attack(self, min_player)
	1451	end
	1452	end
	1453
	1454
	1455	-- specific runaway
	1456	local specific_runaway = function(list, what)
	1457
	1458	-- no list so do not run
	1459	if list == nil then
	1460	return false
	1461	end
	1462
	1463	-- found entity on list to attack?
	1464	for no = 1, #list do
	1465
	1466	if list[no] == what then
	1467	return true
	1468	end
	1469	end
	1470
	1471	return false
	1472	end
	1473
	1474
	1475	-- find someone to runaway from
	1476	local runaway_from = function(self)
	1477
	1478	if not self.runaway_from then
	1479	return
	1480	end
	1481
	1482	local s = self.object:get_pos()
	1483	local p, sp, dist, pname
	1484	local player, obj, min_player, name
	1485	local min_dist = self.view_range + 1
	1486	local objs = minetest.get_objects_inside_radius(s, self.view_range)
	1487
	1488	for n = 1, #objs do
	1489
	1490	if objs[n]:is_player() then
	1491
	1492	pname = objs[n]:get_player_name()
	1493
	1494	if mobs.invis[pname]
	1495	or self.owner == pname then
	1496
	1497	name = ""
	1498	else
	1499	player = objs[n]
	1500	name = "player"
	1501	end
	1502	else
	1503	obj = objs[n]:get_luaentity()
	1504
	1505	if obj then
	1506	player = obj.object
	1507	name = obj.name or ""
	1508	end
	1509	end
	1510
	1511	-- find specific mob to runaway from
	1512	if name ~= "" and name ~= self.name
	1513	and specific_runaway(self.runaway_from, name) then
	1514
	1515	p = player:get_pos()
	1516	sp = s
	1517
	1518	-- aim higher to make looking up hills more realistic
	1519	p.y = p.y + 1
	1520	sp.y = sp.y + 1
	1521
	1522	dist = get_distance(p, s)
	1523
	1524	-- choose closest player/mob to runaway from
	1525	if dist < min_dist
	1526	and line_of_sight(self, sp, p, 2) == true then
	1527	min_dist = dist
	1528	min_player = player
	1529	end
	1530	end
	1531	end
	1532
	1533	if min_player then
	1534
	1535	local lp = player:get_pos()
	1536	local vec = {
	1537	x = lp.x - s.x,
	1538	y = lp.y - s.y,
	1539	z = lp.z - s.z
	1540	}
	1541
	1542	local yaw = (atan(vec.z / vec.x) + 3 * pi / 2) - self.rotate
	1543
	1544	if lp.x > s.x then
	1545	yaw = yaw + pi
	1546	end
	1547
	1548	yaw = set_yaw(self, yaw, 4)
	1549	self.state = "runaway"
	1550	self.runaway_timer = 3
	1551	self.following = nil
	1552	end
	1553	end
	1554
	1555
	1556	-- follow player if owner or holding item, if fish outta water then flop
	1557	local follow_flop = function(self)
	1558
	1559	-- find player to follow
	1560	if (self.follow ~= ""
	1561	or self.order == "follow")
	1562	and not self.following
	1563	and self.state ~= "attack"
	1564	and self.state ~= "runaway" then
	1565
	1566	local s = self.object:get_pos()
	1567	local players = minetest.get_connected_players()
	1568
	1569	for n = 1, #players do
	1570
	1571	if get_distance(players[n]:get_pos(), s) < self.view_range
	1572	and not mobs.invis[ players[n]:get_player_name() ] then
	1573
	1574	self.following = players[n]
	1575
	1576	break
	1577	end
	1578	end
	1579	end
	1580
	1581	if self.type == "npc"
	1582	and self.order == "follow"
	1583	and self.state ~= "attack"
	1584	and self.owner ~= "" then
	1585
	1586	-- npc stop following player if not owner
	1587	if self.following
	1588	and self.owner
	1589	and self.owner ~= self.following:get_player_name() then
	1590	self.following = nil
	1591	end
	1592	else
	1593	-- stop following player if not holding specific item
	1594	if self.following
	1595	and self.following:is_player()
	1596	and follow_holding(self, self.following) == false then
	1597	self.following = nil
	1598	end
	1599
	1600	end
	1601
	1602	-- follow that thing
	1603	if self.following then
	1604
	1605	local s = self.object:get_pos()
	1606	local p
	1607
	1608	if self.following:is_player() then
	1609
	1610	p = self.following:get_pos()
	1611
	1612	elseif self.following.object then
	1613
	1614	p = self.following.object:get_pos()
	1615	end
	1616
	1617	if p then
	1618
	1619	local dist = get_distance(p, s)
	1620
	1621	-- dont follow if out of range
	1622	if dist > self.view_range then
	1623	self.following = nil
	1624	else
	1625	local vec = {
	1626	x = p.x - s.x,
	1627	z = p.z - s.z
	1628	}
	1629
	1630	local yaw = (atan(vec.z / vec.x) + pi / 2) - self.rotate
	1631
	1632	if p.x > s.x then yaw = yaw + pi end
	1633
	1634	yaw = set_yaw(self, yaw, 6)
	1635
	1636	-- anyone but standing npc's can move along
	1637	if dist > self.reach
	1638	and self.order ~= "stand" then
	1639
	1640	set_velocity(self, self.walk_velocity)
	1641
	1642	if self.walk_chance ~= 0 then
	1643	set_animation(self, "walk")
	1644	end
	1645	else
	1646	set_velocity(self, 0)
	1647	set_animation(self, "stand")
	1648	end
	1649
	1650	return
	1651	end
	1652	end
	1653	end
	1654
	1655	-- swimmers flop when out of their element, and swim again when back in
	1656	if self.fly then
	1657	local s = self.object:get_pos()
	1658	if not flight_check(self, s) then
	1659
	1660	self.state = "flop"
	1661	self.object:set_velocity({x = 0, y = -5, z = 0})
	1662
	1663	set_animation(self, "stand")
	1664
	1665	return
	1666	elseif self.state == "flop" then
	1667	self.state = "stand"
	1668	end
	1669	end
	1670	end
	1671
	1672
	1673	-- dogshoot attack switch and counter function
	1674	local dogswitch = function(self, dtime)
	1675
	1676	-- switch mode not activated
	1677	if not self.dogshoot_switch
	1678	or not dtime then
	1679	return 0
	1680	end
	1681
	1682	self.dogshoot_count = self.dogshoot_count + dtime
	1683
	1684	if (self.dogshoot_switch == 1
	1685	and self.dogshoot_count > self.dogshoot_count_max)
	1686	or (self.dogshoot_switch == 2
	1687	and self.dogshoot_count > self.dogshoot_count2_max) then
	1688
	1689	self.dogshoot_count = 0
	1690
	1691	if self.dogshoot_switch == 1 then
	1692	self.dogshoot_switch = 2
	1693	else
	1694	self.dogshoot_switch = 1
	1695	end
	1696	end
	1697
	1698	return self.dogshoot_switch
	1699	end
	1700
	1701
	1702	-- execute current state (stand, walk, run, attacks)
	1703	local do_states = function(self, dtime)
	1704
	1705	local yaw = self.object:get_yaw() or 0
	1706
	1707	if self.state == "stand" then
	1708
	1709	if random(1, 4) == 1 then
	1710
	1711	local lp = nil
	1712	local s = self.object:get_pos()
	1713	local objs = minetest.get_objects_inside_radius(s, 3)
	1714
	1715	for n = 1, #objs do
	1716
	1717	if objs[n]:is_player() then
	1718	lp = objs[n]:get_pos()
	1719	break
	1720	end
	1721	end
	1722
	1723	-- look at any players nearby, otherwise turn randomly
	1724	if lp then
	1725
	1726	local vec = {
	1727	x = lp.x - s.x,
	1728	z = lp.z - s.z
	1729	}
	1730
	1731	yaw = (atan(vec.z / vec.x) + pi / 2) - self.rotate
	1732
	1733	if lp.x > s.x then yaw = yaw + pi end
	1734	else
	1735	yaw = yaw + random(-0.5, 0.5)
	1736	end
	1737
	1738	yaw = set_yaw(self, yaw, 8)
	1739	end
	1740
	1741	set_velocity(self, 0)
	1742	set_animation(self, "stand")
	1743
	1744	-- mobs ordered to stand stay standing
	1745	if self.order ~= "stand"
	1746	and self.walk_chance ~= 0
	1747	and self.facing_fence ~= true
	1748	and random(1, 100) <= self.walk_chance
	1749	and is_at_cliff(self) == false then
	1750
	1751	set_velocity(self, self.walk_velocity)
	1752	self.state = "walk"
	1753	set_animation(self, "walk")
	1754	end
	1755
	1756	elseif self.state == "walk" then
	1757
	1758	local s = self.object:get_pos()
	1759	local lp = nil
	1760
	1761	-- is there something I need to avoid?
	1762	if self.water_damage > 0
	1763	and self.lava_damage > 0 then
	1764
	1765	lp = minetest.find_node_near(s, 1, {"group:water", "group:lava"})
	1766
	1767	elseif self.water_damage > 0 then
	1768
	1769	lp = minetest.find_node_near(s, 1, {"group:water"})
	1770
	1771	elseif self.lava_damage > 0 then
	1772
	1773	lp = minetest.find_node_near(s, 1, {"group:lava"})
	1774	end
	1775
	1776	if lp then
	1777
	1778	-- if mob in water or lava then look for land
	1779	if (self.lava_damage
	1780	and minetest.registered_nodes[self.standing_in].groups.lava)
	1781	or (self.water_damage
	1782	and minetest.registered_nodes[self.standing_in].groups.water) then
	1783
	1784	lp = minetest.find_node_near(s, 5, {"group:soil", "group:stone",
	1785	"group:sand", node_ice, node_snowblock})
	1786
	1787	-- did we find land?
	1788	if lp then
	1789
	1790	local vec = {
	1791	x = lp.x - s.x,
	1792	z = lp.z - s.z
	1793	}
	1794
	1795	yaw = (atan(vec.z / vec.x) + pi / 2) - self.rotate
	1796
	1797	if lp.x > s.x then yaw = yaw + pi end
	1798
	1799	-- look towards land and jump/move in that direction
	1800	yaw = set_yaw(self, yaw, 6)
	1801	do_jump(self)
	1802	set_velocity(self, self.walk_velocity)
	1803	else
	1804	yaw = yaw + random(-0.5, 0.5)
	1805	end
	1806
	1807	else
	1808
	1809	local vec = {
	1810	x = lp.x - s.x,
	1811	z = lp.z - s.z
	1812	}
	1813
	1814	yaw = (atan(vec.z / vec.x) + pi / 2) - self.rotate
	1815
	1816	if lp.x > s.x then yaw = yaw + pi end
	1817	end
	1818
	1819	yaw = set_yaw(self, yaw, 8)
	1820
	1821	-- otherwise randomly turn
	1822	elseif random(1, 100) <= 30 then
	1823
	1824	yaw = yaw + random(-0.5, 0.5)
	1825
	1826	yaw = set_yaw(self, yaw, 8)
	1827	end
	1828
	1829	-- stand for great fall in front
	1830	local temp_is_cliff = is_at_cliff(self)
	1831
	1832	if self.facing_fence == true
	1833	or temp_is_cliff
	1834	or random(1, 100) <= 30 then
	1835
	1836	set_velocity(self, 0)
	1837	self.state = "stand"
	1838	set_animation(self, "stand")
	1839	else
	1840	set_velocity(self, self.walk_velocity)
	1841
	1842	if flight_check(self)
	1843	and self.animation
	1844	and self.animation.fly_start
	1845	and self.animation.fly_end then
	1846	set_animation(self, "fly")
	1847	else
	1848	set_animation(self, "walk")
	1849	end
	1850	end
	1851
	1852	-- runaway when punched
	1853	elseif self.state == "runaway" then
	1854
	1855	self.runaway_timer = self.runaway_timer + 1
	1856
	1857	-- stop after 5 seconds or when at cliff
	1858	if self.runaway_timer > 5
	1859	or is_at_cliff(self)
	1860	or self.order == "stand" then
	1861	self.runaway_timer = 0
	1862	set_velocity(self, 0)
	1863	self.state = "stand"
	1864	set_animation(self, "stand")
	1865	else
	1866	set_velocity(self, self.run_velocity)
	1867	set_animation(self, "walk")
	1868	end
	1869
	1870	-- attack routines (explode, dogfight, shoot, dogshoot)
	1871	elseif self.state == "attack" then
	1872
	1873	-- calculate distance from mob and enemy
	1874	local s = self.object:get_pos()
	1875	local p = self.attack:get_pos() or s
	1876	local dist = get_distance(p, s)
	1877
	1878	-- stop attacking if player invisible or out of range
	1879	if dist > self.view_range
	1880	or not self.attack
	1881	or not self.attack:get_pos()
	1882	or self.attack:get_hp() <= 0
	1883	or (self.attack:is_player() and mobs.invis[ self.attack:get_player_name() ]) then
	1884
	1885	-- print(" stop attacking ", dist, self.view_range)
	1886	self.state = "stand"
	1887	set_velocity(self, 0)
	1888	set_animation(self, "stand")
	1889	self.attack = nil
	1890	self.v_start = false
	1891	self.timer = 0
	1892	self.blinktimer = 0
	1893	self.path.way = nil
	1894
	1895	return
	1896	end
	1897
	1898	if self.attack_type == "explode" then
	1899
	1900	local vec = {
	1901	x = p.x - s.x,
	1902	z = p.z - s.z
	1903	}
	1904
	1905	yaw = (atan(vec.z / vec.x) + pi / 2) - self.rotate
	1906
	1907	if p.x > s.x then yaw = yaw + pi end
	1908
	1909	yaw = set_yaw(self, yaw)
	1910
	1911	local node_break_radius = self.explosion_radius or 1
	1912	local entity_damage_radius = self.explosion_damage_radius
	1913	or (node_break_radius * 2)
	1914
	1915	-- start timer when in reach and line of sight
	1916	if not self.v_start
	1917	and dist <= self.reach
	1918	and line_of_sight(self, s, p, 2) then
	1919
	1920	self.v_start = true
	1921	self.timer = 0
	1922	self.blinktimer = 0
	1923	mob_sound(self, self.sounds.fuse)
	1924	-- print ("=== explosion timer started", self.explosion_timer)
	1925
	1926	-- stop timer if out of reach or direct line of sight
	1927	elseif self.allow_fuse_reset
	1928	and self.v_start
	1929	and (dist > self.reach
	1930	or not line_of_sight(self, s, p, 2)) then
	1931	self.v_start = false
	1932	self.timer = 0
	1933	self.blinktimer = 0
	1934	self.blinkstatus = false
	1935	self.object:settexturemod("")
	1936	end
	1937
	1938	-- walk right up to player unless the timer is active
	1939	if self.v_start and (self.stop_to_explode or dist < 1.5) then
	1940	set_velocity(self, 0)
	1941	else
	1942	set_velocity(self, self.run_velocity)
	1943	end
	1944
	1945	if self.animation and self.animation.run_start then
	1946	set_animation(self, "run")
	1947	else
	1948	set_animation(self, "walk")
	1949	end
	1950
	1951	if self.v_start then
	1952
	1953	self.timer = self.timer + dtime
	1954	self.blinktimer = (self.blinktimer or 0) + dtime
	1955
	1956	if self.blinktimer > 0.2 then
	1957
	1958	self.blinktimer = 0
	1959
	1960	if self.blinkstatus then
	1961	self.object:settexturemod("")
	1962	else
	1963	self.object:settexturemod("^[brighten")
	1964	end
	1965
	1966	self.blinkstatus = not self.blinkstatus
	1967	end
	1968
	1969	-- print ("=== explosion timer", self.timer)
	1970
	1971	if self.timer > self.explosion_timer then
	1972
	1973	local pos = self.object:get_pos()
	1974
	1975	-- dont damage anything if area protected or next to water
	1976	if minetest.find_node_near(pos, 1, {"group:water"})
	1977	or minetest.is_protected(pos, "") then
	1978
	1979	node_break_radius = 1
	1980	end
	1981
	1982	self.object:remove()
	1983
	1984	if minetest.get_modpath("tnt") and tnt and tnt.boom
	1985	and not minetest.is_protected(pos, "") then
	1986
	1987	tnt.boom(pos, {
	1988	radius = node_break_radius,
	1989	damage_radius = entity_damage_radius,
	1990	sound = self.sounds.explode,
	1991	})
	1992	else
	1993
	1994	minetest.sound_play(self.sounds.explode, {
	1995	pos = pos,
	1996	gain = 1.0,
	1997	max_hear_distance = self.sounds.distance or 32
	1998	})
	1999
	2000	entity_physics(pos, entity_damage_radius)
	2001	effect(pos, 32, "tnt_smoke.png", nil, nil, node_break_radius, 1, 0)
	2002	end
	2003
	2004	return
	2005	end
	2006	end
	2007
	2008	elseif self.attack_type == "dogfight"
	2009	or (self.attack_type == "dogshoot" and dogswitch(self, dtime) == 2)
	2010	or (self.attack_type == "dogshoot" and dist <= self.reach and dogswitch(self) == 0) then
	2011
	2012	if self.fly
	2013	and dist > self.reach then
	2014
	2015	local p1 = s
	2016	local me_y = floor(p1.y)
	2017	local p2 = p
	2018	local p_y = floor(p2.y + 1)
	2019	local v = self.object:get_velocity()
	2020
	2021	if flight_check(self, s) then
	2022
	2023	if me_y < p_y then
	2024
	2025	self.object:set_velocity({
	2026	x = v.x,
	2027	y = 1 * self.walk_velocity,
	2028	z = v.z
	2029	})
	2030
	2031	elseif me_y > p_y then
	2032
	2033	self.object:set_velocity({
	2034	x = v.x,
	2035	y = -1 * self.walk_velocity,
	2036	z = v.z
	2037	})
	2038	end
	2039	else
	2040	if me_y < p_y then
	2041
	2042	self.object:set_velocity({
	2043	x = v.x,
	2044	y = 0.01,
	2045	z = v.z
	2046	})
	2047
	2048	elseif me_y > p_y then
	2049
	2050	self.object:set_velocity({
	2051	x = v.x,
	2052	y = -0.01,
	2053	z = v.z
	2054	})
	2055	end
	2056	end
	2057
	2058	end
	2059
	2060	-- rnd: new movement direction
	2061	if self.path.following
	2062	and self.path.way
	2063	and self.attack_type ~= "dogshoot" then
	2064
	2065	-- no paths longer than 50
	2066	if #self.path.way > 50
	2067	or dist < self.reach then
	2068	self.path.following = false
	2069	return
	2070	end
	2071
	2072	local p1 = self.path.way[1]
	2073
	2074	if not p1 then
	2075	self.path.following = false
	2076	return
	2077	end
	2078
	2079	if abs(p1.x-s.x) + abs(p1.z - s.z) < 0.6 then
	2080	-- reached waypoint, remove it from queue
	2081	table.remove(self.path.way, 1)
	2082	end
	2083
	2084	-- set new temporary target
	2085	p = {x = p1.x, y = p1.y, z = p1.z}
	2086	end
	2087
	2088	local vec = {
	2089	x = p.x - s.x,
	2090	z = p.z - s.z
	2091	}
	2092
	2093	yaw = (atan(vec.z / vec.x) + pi / 2) - self.rotate
	2094
	2095	if p.x > s.x then yaw = yaw + pi end
	2096
	2097	yaw = set_yaw(self, yaw)
	2098
	2099	-- move towards enemy if beyond mob reach
	2100	if dist > self.reach then
	2101
	2102	-- path finding by rnd
	2103	if self.pathfinding -- only if mob has pathfinding enabled
	2104	and enable_pathfinding then
	2105
	2106	smart_mobs(self, s, p, dist, dtime)
	2107	end
	2108
	2109	if is_at_cliff(self) then
	2110
	2111	set_velocity(self, 0)
	2112	set_animation(self, "stand")
	2113	else
	2114
	2115	if self.path.stuck then
	2116	set_velocity(self, self.walk_velocity)
	2117	else
	2118	set_velocity(self, self.run_velocity)
	2119	end
	2120
	2121	if self.animation and self.animation.run_start then
	2122	set_animation(self, "run")
	2123	else
	2124	set_animation(self, "walk")
	2125	end
	2126	end
	2127
	2128	else -- rnd: if inside reach range
	2129
	2130	self.path.stuck = false
	2131	self.path.stuck_timer = 0
	2132	self.path.following = false -- not stuck anymore
	2133
	2134	set_velocity(self, 0)
	2135
	2136	if not self.custom_attack then
	2137
	2138	if self.timer > 1 then
	2139
	2140	self.timer = 0
	2141
	2142	-- if self.double_melee_attack
	2143	-- and random(1, 2) == 1 then
	2144	-- set_animation(self, "punch2")
	2145	-- else
	2146	set_animation(self, "punch")
	2147	-- end
	2148
	2149	local p2 = p
	2150	local s2 = s
	2151
	2152	p2.y = p2.y + .5
	2153	s2.y = s2.y + .5
	2154
	2155	if line_of_sight(self, p2, s2) == true then
	2156
	2157	-- play attack sound
	2158	mob_sound(self, self.sounds.attack)
	2159
	2160	-- punch player (or what player is attached to)
	2161	local attached = self.attack:get_attach()
	2162	if attached then
	2163	self.attack = attached
	2164	end
	2165	self.attack:punch(self.object, 1.0, {
	2166	full_punch_interval = 1.0,
	2167	damage_groups = {fleshy = self.damage}
	2168	}, nil)
	2169	end
	2170	end
	2171	else -- call custom attack every second
	2172	if self.custom_attack
	2173	and self.timer > 1 then
	2174
	2175	self.timer = 0
	2176
	2177	self.custom_attack(self, p)
	2178	end
	2179	end
	2180	end
	2181
	2182	elseif self.attack_type == "shoot"
	2183	or (self.attack_type == "dogshoot" and dogswitch(self, dtime) == 1)
	2184	or (self.attack_type == "dogshoot" and dist > self.reach and dogswitch(self) == 0) then
	2185
	2186	p.y = p.y - .5
	2187	s.y = s.y + .5
	2188
	2189	local dist = get_distance(p, s)
	2190	local vec = {
	2191	x = p.x - s.x,
	2192	y = p.y - s.y,
	2193	z = p.z - s.z
	2194	}
	2195
	2196	yaw = (atan(vec.z / vec.x) + pi / 2) - self.rotate
	2197
	2198	if p.x > s.x then yaw = yaw + pi end
	2199
	2200	yaw = set_yaw(self, yaw)
	2201
	2202	set_velocity(self, 0)
	2203
	2204	if self.shoot_interval
	2205	and self.timer > self.shoot_interval
	2206	and random(1, 100) <= 60 then
	2207
	2208	self.timer = 0
	2209	set_animation(self, "shoot")
	2210
	2211	-- play shoot attack sound
	2212	mob_sound(self, self.sounds.shoot_attack)
	2213
	2214	local p = self.object:get_pos()
	2215
	2216	p.y = p.y + (self.collisionbox[2] + self.collisionbox[5]) / 2
	2217
	2218	if minetest.registered_entities[self.arrow] then
	2219
	2220	local obj = minetest.add_entity(p, self.arrow)
	2221	local ent = obj:get_luaentity()
	2222	local amount = (vec.x * vec.x + vec.y * vec.y + vec.z * vec.z) ^ 0.5
	2223	local v = ent.velocity or 1 -- or set to default
	2224
	2225	ent.switch = 1
	2226	ent.owner_id = tostring(self.object) -- add unique owner id to arrow
	2227
	2228	-- offset makes shoot aim accurate
	2229	vec.y = vec.y + self.shoot_offset
	2230	vec.x = vec.x * (v / amount)
	2231	vec.y = vec.y * (v / amount)
	2232	vec.z = vec.z * (v / amount)
	2233
	2234	obj:set_velocity(vec)
	2235	end
	2236	end
	2237	end
	2238	end
	2239	end
	2240
	2241
	2242	-- falling and fall damage
	2243	local falling = function(self, pos)
	2244
	2245	if self.fly then
	2246	return
	2247	end
	2248
	2249	-- floating in water (or falling)
	2250	local v = self.object:get_velocity()
	2251
	2252	if v.y > 0 then
	2253
	2254	-- apply gravity when moving up
	2255	self.object:set_acceleration({
	2256	x = 0,
	2257	y = -10,
	2258	z = 0
	2259	})
	2260
	2261	elseif v.y <= 0 and v.y > self.fall_speed then
	2262
	2263	-- fall downwards at set speed
	2264	self.object:set_acceleration({
	2265	x = 0,
	2266	y = self.fall_speed,
	2267	z = 0
	2268	})
	2269	else
	2270	-- stop accelerating once max fall speed hit
	2271	self.object:set_acceleration({x = 0, y = 0, z = 0})
	2272	end
	2273
	2274	-- in water then float up
	2275	if self.standing_in
	2276	and minetest.registered_nodes[self.standing_in].groups.water then
	2277
	2278	if self.floats == 1 then
	2279
	2280	self.object:set_acceleration({
	2281	x = 0,
	2282	y = -self.fall_speed / (max(1, v.y) ^ 8), -- 8 was 2
	2283	z = 0
	2284	})
	2285	end
	2286	else
	2287
	2288	-- fall damage onto solid ground
	2289	if self.fall_damage == 1
	2290	and self.object:get_velocity().y == 0 then
	2291
	2292	local d = (self.old_y or 0) - self.object:get_pos().y
	2293
	2294	if d > 5 then
	2295
	2296	self.health = self.health - floor(d - 5)
	2297
	2298	effect(pos, 5, "tnt_smoke.png", 1, 2, 2, nil)
	2299
	2300	if check_for_death(self, {type = "fall"}) then
	2301	return
	2302	end
	2303	end
	2304
	2305	self.old_y = self.object:get_pos().y
	2306	end
	2307	end
	2308	end
	2309
	2310
	2311	-- is Took Ranks mod active?
	2312	local tr = minetest.get_modpath("toolranks")
	2313
	2314	-- deal damage and effects when mob punched
	2315	local mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
	2316
	2317	-- mob health check
	2318	if self.health <= 0 then
	2319	return
	2320	end
	2321
	2322	-- custom punch function
	2323	if self.do_punch
	2324	and self.do_punch(self, hitter, tflp, tool_capabilities, dir) == false then
	2325	return
	2326	end
	2327
	2328	-- error checking when mod profiling is enabled
	2329	if not tool_capabilities then
	2330	minetest.log("warning", "[mobs] Mod profiling enabled, damage not enabled")
	2331	return
	2332	end
	2333
	2334	-- is mob protected?
	2335	if self.protected and hitter:is_player()
	2336	and minetest.is_protected(self.object:get_pos(), hitter:get_player_name()) then
	2337	minetest.chat_send_player(hitter:get_player_name(), S("Mob has been protected!"))
	2338	return
	2339	end
	2340
	2341	local weapon = hitter:get_wielded_item()
	2342	local weapon_def = weapon:get_definition() or {}
	2343	local punch_interval = 1.4
	2344
	2345	-- calculate mob damage
	2346	local damage = 0
	2347	local armor = self.object:get_armor_groups() or {}
	2348	local tmp
	2349
	2350	-- quick error check incase it ends up 0 (serialize.h check test)
	2351	if tflp == 0 then
	2352	tflp = 0.2
	2353	end
	2354
	2355	if use_cmi then
	2356	damage = cmi.calculate_damage(self.object, hitter, tflp, tool_capabilities, dir)
	2357	else
	2358
	2359	for group,_ in pairs( (tool_capabilities.damage_groups or {}) ) do
	2360
	2361	tmp = tflp / (tool_capabilities.full_punch_interval or 1.4)
	2362
	2363	if tmp < 0 then
	2364	tmp = 0.0
	2365	elseif tmp > 1 then
	2366	tmp = 1.0
	2367	end
	2368
	2369	damage = damage + (tool_capabilities.damage_groups[group] or 0)
	2370	* tmp * ((armor[group] or 0) / 100.0)
	2371	end
	2372	end
	2373
	2374	-- check for tool immunity or special damage
	2375	for n = 1, #self.immune_to do
	2376
	2377	if self.immune_to[n][1] == weapon_def.name then
	2378
	2379	damage = self.immune_to[n][2] or 0
	2380	break
	2381
	2382	-- if "all" then no tool does damage unless it's specified in list
	2383	elseif self.immune_to[n][1] == "all" then
	2384	damage = self.immune_to[n][2] or 0
	2385	end
	2386	end
	2387
	2388	-- healing
	2389	if damage <= -1 then
	2390	self.health = self.health - floor(damage)
	2391	return
	2392	end
	2393
	2394	-- print ("Mob Damage is", damage)
	2395
	2396	if use_cmi
	2397	and cmi.notify_punch(self.object, hitter, tflp, tool_capabilities, dir, damage) then
	2398	return
	2399	end
	2400
	2401	-- add weapon wear
	2402	punch_interval = tool_capabilities.full_punch_interval or 1.4
	2403
	2404	-- toolrank support
	2405	local wear = floor((punch_interval / 75) * 9000)
	2406
	2407	if mobs.is_creative(hitter:get_player_name()) then
	2408
	2409	if tr then
	2410	wear = 1
	2411	else
	2412	wear = 0
	2413	end
	2414	end
	2415
	2416	if tr then
	2417	if weapon_def.original_description then
	2418	weapon:add_wear(toolranks.new_afteruse(weapon, hitter, nil, {wear = wear}))
	2419	end
	2420	else
	2421	weapon:add_wear(wear)
	2422	end
	2423
	2424	hitter:set_wielded_item(weapon)
	2425
	2426	-- only play hit sound and show blood effects if damage is 1 or over
	2427	if damage >= 1 then
	2428
	2429	-- weapon sounds
	2430	if weapon_def.sounds then
	2431
	2432	local s = random(0, #weapon_def.sounds)
	2433
	2434	minetest.sound_play(weapon_def.sounds[s], {
	2435	object = self.object,
	2436	max_hear_distance = 8
	2437	})
	2438	else
	2439	minetest.sound_play("default_punch", {
	2440	object = self.object,
	2441	max_hear_distance = 5
	2442	})
	2443	end
	2444
	2445	-- blood_particles
	2446	if not disable_blood and self.blood_amount > 0 then
	2447
	2448	local pos = self.object:get_pos()
	2449
	2450	pos.y = pos.y + (-self.collisionbox[2] + self.collisionbox[5]) * .5
	2451
	2452	-- do we have a single blood texture or multiple?
	2453	if type(self.blood_texture) == "table" then
	2454
	2455	local blood = self.blood_texture[random(1, #self.blood_texture)]
	2456
	2457	effect(pos, self.blood_amount, blood, nil, nil, 1, nil)
	2458	else
	2459	effect(pos, self.blood_amount, self.blood_texture, nil, nil, 1, nil)
	2460	end
	2461	end
	2462
	2463	-- do damage
	2464	self.health = self.health - floor(damage)
	2465
	2466	-- exit here if dead, check for tools with fire damage
	2467	local hot = tool_capabilities and tool_capabilities.damage_groups
	2468	and tool_capabilities.damage_groups.fire
	2469
	2470	if check_for_death(self, {type = "punch",
	2471	puncher = hitter, hot = hot}) then
	2472	return
	2473	end
	2474
	2475	--[[ add healthy afterglow when hit (can cause hit lag with larger textures)
	2476	minetest.after(0.1, function()
	2477
	2478	if not self.object:get_luaentity() then return end
	2479
	2480	self.object:settexturemod("^[colorize:#c9900070")
	2481
	2482	core.after(0.3, function()
	2483	self.object:settexturemod("")
	2484	end)
	2485	end) ]]
	2486
	2487	end -- END if damage
	2488
	2489	-- knock back effect (only on full punch)
	2490	if self.knock_back
	2491	and tflp >= punch_interval then
	2492
	2493	local v = self.object:get_velocity()
	2494	local kb = damage or 1
	2495	local up = 2
	2496
	2497	-- if already in air then dont go up anymore when hit
	2498	if v.y > 0
	2499	or self.fly then
	2500	up = 0
	2501	end
	2502
	2503	-- direction error check
	2504	dir = dir or {x = 0, y = 0, z = 0}
	2505
	2506	-- use tool knockback value or default
	2507	kb = tool_capabilities.damage_groups["knockback"] or (kb * 1.5)
	2508
	2509	self.object:set_velocity({
	2510	x = dir.x * kb,
	2511	y = up,
	2512	z = dir.z * kb
	2513	})
	2514
	2515	self.pause_timer = 0.25
	2516	end
	2517
	2518	-- if skittish then run away
	2519	if self.runaway == true
	2520	and self.order ~= "stand" then
	2521
	2522	local lp = hitter:get_pos()
	2523	local s = self.object:get_pos()
	2524	local vec = {
	2525	x = lp.x - s.x,
	2526	y = lp.y - s.y,
	2527	z = lp.z - s.z
	2528	}
	2529
	2530	local yaw = (atan(vec.z / vec.x) + 3 * pi / 2) - self.rotate
	2531
	2532	if lp.x > s.x then
	2533	yaw = yaw + pi
	2534	end
	2535
	2536	yaw = set_yaw(self, yaw, 6)
	2537	self.state = "runaway"
	2538	self.runaway_timer = 0
	2539	self.following = nil
	2540	end
	2541
	2542	local name = hitter:get_player_name() or ""
	2543
	2544	-- attack puncher and call other mobs for help
	2545	if self.passive == false
	2546	and self.state ~= "flop"
	2547	and self.child == false
	2548	and self.attack_players == true
	2549	and hitter:get_player_name() ~= self.owner
	2550	and not mobs.invis[ name ] then
	2551
	2552	-- attack whoever punched mob
	2553	self.state = ""
	2554	do_attack(self, hitter)
	2555
	2556	-- alert others to the attack
	2557	local objs = minetest.get_objects_inside_radius(hitter:get_pos(), self.view_range)
	2558	local obj = nil
	2559
	2560	for n = 1, #objs do
	2561
	2562	obj = objs[n]:get_luaentity()
	2563
	2564	if obj and obj._cmi_is_mob then
	2565
	2566	-- only alert members of same mob
	2567	if obj.group_attack == true
	2568	and obj.state ~= "attack"
	2569	and obj.owner ~= name
	2570	and obj.name == self.name then
	2571	do_attack(obj, hitter)
	2572	end
	2573
	2574	-- have owned mobs attack player threat
	2575	if obj.owner == name and obj.owner_loyal then
	2576	do_attack(obj, self.object)
	2577	end
	2578	end
	2579	end
	2580	end
	2581	end
	2582
	2583
	2584	-- get entity staticdata
	2585	local mob_staticdata = function(self)
	2586
	2587	-- remove mob when out of range unless tamed
	2588	if remove_far
	2589	and self.remove_ok
	2590	and self.type ~= "npc"
	2591	and self.state ~= "attack"
	2592	and not self.tamed
	2593	and self.lifetimer < 20000 then
	2594
	2595	--print ("REMOVED " .. self.name)
	2596
	2597	self.object:remove()
	2598
	2599	return ""-- nil
	2600	end
	2601
	2602	self.remove_ok = true
	2603	self.attack = nil
	2604	self.following = nil
	2605	self.state = "stand"
	2606
	2607	-- used to rotate older mobs
	2608	if self.drawtype
	2609	and self.drawtype == "side" then
	2610	self.rotate = math.rad(90)
	2611	end
	2612
	2613	if use_cmi then
	2614	self.serialized_cmi_components = cmi.serialize_components(self._cmi_components)
	2615	end
	2616
	2617	local tmp = {}
	2618
	2619	for _,stat in pairs(self) do
	2620
	2621	local t = type(stat)
	2622
	2623	if t ~= "function"
	2624	and t ~= "nil"
	2625	and t ~= "userdata"
	2626	and _ ~= "_cmi_components" then
	2627	tmp[_] = self[_]
	2628	end
	2629	end
	2630
	2631	--print('===== '..self.name..'\n'.. dump(tmp)..'\n=====\n')
	2632	return minetest.serialize(tmp)
	2633	end
	2634
	2635
	2636	-- activate mob and reload settings
	2637	local mob_activate = function(self, staticdata, def, dtime)
	2638
	2639	-- remove monsters in peaceful mode
	2640	if self.type == "monster"
	2641	and peaceful_only then
	2642
	2643	self.object:remove()
	2644
	2645	return
	2646	end
	2647
	2648	-- load entity variables
	2649	local tmp = minetest.deserialize(staticdata)
	2650
	2651	if tmp then
	2652	for _,stat in pairs(tmp) do
	2653	self[_] = stat
	2654	end
	2655	end
	2656
	2657	-- select random texture, set model and size
	2658	if not self.base_texture then
	2659
	2660	-- compatiblity with old simple mobs textures
	2661	if def.textures and type(def.textures[1]) == "string" then
	2662	def.textures = {def.textures}
	2663	end
	2664
	2665	self.base_texture = def.textures and def.textures[random(1, #def.textures)]
	2666	self.base_mesh = def.mesh
	2667	self.base_size = self.visual_size
	2668	self.base_colbox = self.collisionbox
	2669	self.base_selbox = self.selectionbox
	2670	end
	2671
	2672	-- for current mobs that dont have this set
	2673	if not self.base_selbox then
	2674	self.base_selbox = self.selectionbox or self.base_colbox
	2675	end
	2676
	2677	-- set texture, model and size
	2678	local textures = self.base_texture
	2679	local mesh = self.base_mesh
	2680	local vis_size = self.base_size
	2681	local colbox = self.base_colbox
	2682	local selbox = self.base_selbox
	2683
	2684	-- specific texture if gotten
	2685	if self.gotten == true
	2686	and def.gotten_texture then
	2687	textures = def.gotten_texture
	2688	end
	2689
	2690	-- specific mesh if gotten
	2691	if self.gotten == true
	2692	and def.gotten_mesh then
	2693	mesh = def.gotten_mesh
	2694	end
	2695
	2696	-- set child objects to half size
	2697	if self.child == true then
	2698
	2699	vis_size = {
	2700	x = self.base_size.x * .5,
	2701	y = self.base_size.y * .5,
	2702	}
	2703
	2704	if def.child_texture then
	2705	textures = def.child_texture[1]
	2706	end
	2707
	2708	colbox = {
	2709	self.base_colbox[1] * .5,
	2710	self.base_colbox[2] * .5,
	2711	self.base_colbox[3] * .5,
	2712	self.base_colbox[4] * .5,
	2713	self.base_colbox[5] * .5,
	2714	self.base_colbox[6] * .5
	2715	}
	2716	selbox = {
	2717	self.base_selbox[1] * .5,
	2718	self.base_selbox[2] * .5,
	2719	self.base_selbox[3] * .5,
	2720	self.base_selbox[4] * .5,
	2721	self.base_selbox[5] * .5,
	2722	self.base_selbox[6] * .5
	2723	}
	2724	end
	2725
	2726	if self.health == 0 then
	2727	self.health = random (self.hp_min, self.hp_max)
	2728	end
	2729
	2730	-- pathfinding init
	2731	self.path = {}
	2732	self.path.way = {} -- path to follow, table of positions
	2733	self.path.lastpos = {x = 0, y = 0, z = 0}
	2734	self.path.stuck = false
	2735	self.path.following = false -- currently following path?
	2736	self.path.stuck_timer = 0 -- if stuck for too long search for path
	2737
	2738	-- mob defaults
	2739	self.object:set_armor_groups({immortal = 1, fleshy = self.armor})
	2740	self.old_y = self.object:get_pos().y
	2741	self.old_health = self.health
	2742	self.sounds.distance = self.sounds.distance or 10
	2743	self.textures = textures
	2744	self.mesh = mesh
	2745	self.collisionbox = colbox
	2746	self.selectionbox = selbox
	2747	self.visual_size = vis_size
	2748	self.standing_in = "air"
	2749
	2750	-- check existing nametag
	2751	if not self.nametag then
	2752	self.nametag = def.nametag
	2753	end
	2754
	2755	-- set anything changed above
	2756	self.object:set_properties(self)
	2757	set_yaw(self, (random(0, 360) - 180) / 180 * pi, 6)
	2758	update_tag(self)
	2759	set_animation(self, "stand")
	2760
	2761	-- run on_spawn function if found
	2762	if self.on_spawn and not self.on_spawn_run then
	2763	if self.on_spawn(self) then
	2764	self.on_spawn_run = true -- if true, set flag to run once only
	2765	end
	2766	end
	2767
	2768	-- run after_activate
	2769	if def.after_activate then
	2770	def.after_activate(self, staticdata, def, dtime)
	2771	end
	2772
	2773	if use_cmi then
	2774	self._cmi_components = cmi.activate_components(self.serialized_cmi_components)
	2775	cmi.notify_activate(self.object, dtime)
	2776	end
	2777	end
	2778
	2779
	2780	-- handle mob lifetimer and expiration
	2781	local mob_expire = function(self, pos, dtime)
	2782
	2783	-- when lifetimer expires remove mob (except npc and tamed)
	2784	if self.type ~= "npc"
	2785	and not self.tamed
	2786	and self.state ~= "attack"
	2787	and remove_far ~= true
	2788	and self.lifetimer < 20000 then
	2789
	2790	self.lifetimer = self.lifetimer - dtime
	2791
	2792	if self.lifetimer <= 0 then
	2793
	2794	-- only despawn away from player
	2795	local objs = minetest.get_objects_inside_radius(pos, 15)
	2796
	2797	for n = 1, #objs do
	2798
	2799	if objs[n]:is_player() then
	2800
	2801	self.lifetimer = 20
	2802
	2803	return
	2804	end
	2805	end
	2806
	2807	-- minetest.log("action",
	2808	-- S("lifetimer expired, removed @1", self.name))
	2809
	2810	effect(pos, 15, "tnt_smoke.png", 2, 4, 2, 0)
	2811
	2812	self.object:remove()
	2813
	2814	return
	2815	end
	2816	end
	2817	end
	2818
	2819
	2820	-- main mob function
	2821	local mob_step = function(self, dtime)
	2822
	2823	if use_cmi then
	2824	cmi.notify_step(self.object, dtime)
	2825	end
	2826
	2827	local pos = self.object:get_pos()
	2828	local yaw = 0
	2829
	2830	-- get node at foot level every quarter second
	2831	self.node_timer = (self.node_timer or 0) + dtime
	2832
	2833	if self.node_timer > 0.25 then
	2834
	2835	self.node_timer = 0
	2836
	2837	local y_level = self.collisionbox[2]
	2838
	2839	if self.child then
	2840	y_level = self.collisionbox[2] * 0.5
	2841	end
	2842
	2843	-- what is mob standing in?
	2844	self.standing_in = node_ok({
	2845	x = pos.x, y = pos.y + y_level + 0.25, z = pos.z}, "air").name
	2846	-- print ("standing in " .. self.standing_in)
	2847
	2848	-- check for mob expiration (0.25 instead of dtime since were in a timer)
	2849	mob_expire(self, pos, 0.25)
	2850	end
	2851
	2852	-- check if falling, flying, floating
	2853	falling(self, pos)
	2854
	2855	-- smooth rotation by ThomasMonroe314
	2856
	2857	if self.delay and self.delay > 0 then
	2858
	2859	local yaw = self.object:get_yaw()
	2860
	2861	if self.delay == 1 then
	2862	yaw = self.target_yaw
	2863	else
	2864	local dif = abs(yaw - self.target_yaw)
	2865
	2866	if yaw > self.target_yaw then
	2867
	2868	if dif > pi then
	2869	dif = 2 * pi - dif -- need to add
	2870	yaw = yaw + dif / self.delay
	2871	else
	2872	yaw = yaw - dif / self.delay -- need to subtract
	2873	end
	2874
	2875	elseif yaw < self.target_yaw then
	2876
	2877	if dif > pi then
	2878	dif = 2 * pi - dif
	2879	yaw = yaw - dif / self.delay -- need to subtract
	2880	else
	2881	yaw = yaw + dif / self.delay -- need to add
	2882	end
	2883	end
	2884
	2885	if yaw > (pi * 2) then yaw = yaw - (pi * 2) end
	2886	if yaw < 0 then yaw = yaw + (pi * 2) end
	2887	end
	2888
	2889	self.delay = self.delay - 1
	2890	self.object:set_yaw(yaw)
	2891	end
	2892
	2893	-- end rotation
	2894
	2895	-- knockback timer
	2896	if self.pause_timer > 0 then
	2897
	2898	self.pause_timer = self.pause_timer - dtime
	2899
	2900	return
	2901	end
	2902
	2903	-- run custom function (defined in mob lua file)
	2904	if self.do_custom then
	2905
	2906	-- when false skip going any further
	2907	if self.do_custom(self, dtime) == false then
	2908	return
	2909	end
	2910	end
	2911
	2912	-- attack timer
	2913	self.timer = self.timer + dtime
	2914
	2915	if self.state ~= "attack" then
	2916
	2917	if self.timer < 1 then
	2918	return
	2919	end
	2920
	2921	self.timer = 0
	2922	end
	2923
	2924	-- never go over 100
	2925	if self.timer > 100 then
	2926	self.timer = 1
	2927	end
	2928
	2929	-- mob plays random sound at times
	2930	if random(1, 100) == 1 then
	2931	mob_sound(self, self.sounds.random)
	2932	end
	2933
	2934	-- environmental damage timer (every 1 second)
	2935	self.env_damage_timer = self.env_damage_timer + dtime
	2936
	2937	if (self.state == "attack" and self.env_damage_timer > 1)
	2938	or self.state ~= "attack" then
	2939
	2940	self.env_damage_timer = 0
	2941
	2942	-- check for environmental damage (water, fire, lava etc.)
	2943	do_env_damage(self)
	2944
	2945	-- node replace check (cow eats grass etc.)
	2946	replace(self, pos)
	2947	end
	2948
	2949	general_attack(self)
	2950
	2951	breed(self)
	2952
	2953	follow_flop(self)
	2954
	2955	do_states(self, dtime)
	2956
	2957	do_jump(self)
	2958
	2959	runaway_from(self)
	2960
	2961	end
	2962
	2963
	2964	-- default function when mobs are blown up with TNT
	2965	local do_tnt = function(obj, damage)
	2966
	2967	--print ("----- Damage", damage)
	2968
	2969	obj.object:punch(obj.object, 1.0, {
	2970	full_punch_interval = 1.0,
	2971	damage_groups = {fleshy = damage},
	2972	}, nil)
	2973
	2974	return false, true, {}
	2975	end
	2976
	2977
	2978	mobs.spawning_mobs = {}
	2979
	2980	-- register mob entity
	2981	function mobs:register_mob(name, def)
	2982
	2983	mobs.spawning_mobs[name] = true
	2984
	2985	minetest.register_entity(name, {
	2986
	2987	stepheight = def.stepheight or 1.1, -- was 0.6
	2988	name = name,
	2989	type = def.type,
	2990	attack_type = def.attack_type,
	2991	fly = def.fly,
	2992	fly_in = def.fly_in or "air",
	2993	owner = def.owner or "",
	2994	order = def.order or "",
	2995	on_die = def.on_die,
	2996	do_custom = def.do_custom,
	2997	jump_height = def.jump_height or 4, -- was 6
	2998	drawtype = def.drawtype, -- DEPRECATED, use rotate instead
	2999	rotate = math.rad(def.rotate or 0), -- 0=front, 90=side, 180=back, 270=side2
	3000	lifetimer = def.lifetimer or 180, -- 3 minutes
	3001	hp_min = max(1, (def.hp_min or 5) * difficulty),
	3002	hp_max = max(1, (def.hp_max or 10) * difficulty),
	3003	physical = true,
	3004	collisionbox = def.collisionbox or {-0.25, -0.25, -0.25, 0.25, 0.25, 0.25},
	3005	selectionbox = def.selectionbox or def.collisionbox,
	3006	visual = def.visual,
	3007	visual_size = def.visual_size or {x = 1, y = 1},
	3008	mesh = def.mesh,
	3009	makes_footstep_sound = def.makes_footstep_sound or false,
	3010	view_range = def.view_range or 5,
	3011	walk_velocity = def.walk_velocity or 1,
	3012	run_velocity = def.run_velocity or 2,
	3013	damage = max(0, (def.damage or 0) * difficulty),
	3014	light_damage = def.light_damage or 0,
	3015	light_damage_min = def.light_damage_min or 14,
	3016	light_damage_max = def.light_damage_max or 15,
	3017	water_damage = def.water_damage or 0,
	3018	lava_damage = def.lava_damage or 0,
	3019	suffocation = def.suffocation or 2,
	3020	fall_damage = def.fall_damage or 1,
	3021	fall_speed = def.fall_speed or -10, -- must be lower than -2 (default: -10)
	3022	drops = def.drops or {},
	3023	armor = def.armor or 100,
	3024	on_rightclick = def.on_rightclick,
	3025	arrow = def.arrow,
	3026	shoot_interval = def.shoot_interval,
	3027	sounds = def.sounds or {},
	3028	animation = def.animation,
	3029	follow = def.follow,
	3030	jump = def.jump ~= false,
	3031	walk_chance = def.walk_chance or 50,
	3032	attack_chance = def.attack_chance or 5,
	3033	passive = def.passive or false,
	3034	knock_back = def.knock_back ~= false,
	3035	blood_amount = def.blood_amount or 5,
	3036	blood_texture = def.blood_texture or "mobs_blood.png",
	3037	shoot_offset = def.shoot_offset or 0,
	3038	floats = def.floats or 1, -- floats in water by default
	3039	replace_rate = def.replace_rate,
	3040	replace_what = def.replace_what,
	3041	replace_with = def.replace_with,
	3042	replace_offset = def.replace_offset or 0,
	3043	on_replace = def.on_replace,
	3044	timer = 0,
	3045	env_damage_timer = 0, -- only used when state = "attack"
	3046	tamed = false,
	3047	pause_timer = 0,
	3048	horny = false,
	3049	hornytimer = 0,
	3050	child = false,
	3051	gotten = false,
	3052	health = 0,
	3053	reach = def.reach or 3,
	3054	htimer = 0,
	3055	texture_list = def.textures,
	3056	child_texture = def.child_texture,
	3057	docile_by_day = def.docile_by_day or false,
	3058	time_of_day = 0.5,
	3059	fear_height = def.fear_height or 0,
	3060	runaway = def.runaway,
	3061	runaway_timer = 0,
	3062	pathfinding = def.pathfinding,
	3063	immune_to = def.immune_to or {},
	3064	explosion_radius = def.explosion_radius,
	3065	explosion_damage_radius = def.explosion_damage_radius,
	3066	explosion_timer = def.explosion_timer or 3,
	3067	allow_fuse_reset = def.allow_fuse_reset ~= false,
	3068	stop_to_explode = def.stop_to_explode ~= false,
	3069	custom_attack = def.custom_attack,
	3070	double_melee_attack = def.double_melee_attack,
	3071	dogshoot_switch = def.dogshoot_switch,
	3072	dogshoot_count = 0,
	3073	dogshoot_count_max = def.dogshoot_count_max or 5,
	3074	dogshoot_count2_max = def.dogshoot_count2_max or (def.dogshoot_count_max or 5),
	3075	group_attack = def.group_attack or false,
	3076	attack_monsters = def.attacks_monsters or def.attack_monsters or false,
	3077	attack_animals = def.attack_animals or false,
	3078	attack_players = def.attack_players ~= false,
	3079	attack_npcs = def.attack_npcs ~= false,
	3080	specific_attack = def.specific_attack,
	3081	runaway_from = def.runaway_from,
	3082	owner_loyal = def.owner_loyal,
	3083	facing_fence = false,
	3084	pushable = def.pushable,
	3085	_cmi_is_mob = true,
	3086
	3087	on_spawn = def.on_spawn,
	3088
	3089	on_blast = def.on_blast or do_tnt,
	3090
	3091	on_step = mob_step,
	3092
	3093	do_punch = def.do_punch,
	3094
	3095	on_punch = mob_punch,
	3096
	3097	on_breed = def.on_breed,
	3098
	3099	on_grown = def.on_grown,
	3100
	3101	on_activate = function(self, staticdata, dtime)
	3102	return mob_activate(self, staticdata, def, dtime)
	3103	end,
	3104
	3105	get_staticdata = function(self)
	3106	return mob_staticdata(self)
	3107	end,
	3108
	3109	})
	3110
	3111	end -- END mobs:register_mob function
	3112
	3113
	3114	-- count how many mobs of one type are inside an area
	3115	local count_mobs = function(pos, type)
	3116
	3117	local total = 0
	3118	local objs = minetest.get_objects_inside_radius(pos, aoc_range * 2)
	3119	local ent
	3120
	3121	for n = 1, #objs do
	3122
	3123	if not objs[n]:is_player() then
	3124
	3125	ent = objs[n]:get_luaentity()
	3126
	3127	-- count mob type and add to total also
	3128	if ent and ent.name and ent.name == type then
	3129	total = total + 1
	3130	end
	3131	end
	3132	end
	3133
	3134	return total
	3135	end
	3136
	3137
	3138	-- global functions
	3139
	3140	function mobs:spawn_abm_check(pos, node, name)
	3141	-- global function to add additional spawn checks
	3142	-- return true to stop spawning mob
	3143	end
	3144
	3145
	3146	function mobs:spawn_specific(name, nodes, neighbors, min_light, max_light,
	3147	interval, chance, aoc, min_height, max_height, day_toggle, on_spawn)
	3148
	3149	-- Do mobs spawn at all?
	3150	if not mobs_spawn then
	3151	return
	3152	end
	3153
	3154	-- chance/spawn number override in minetest.conf for registered mob
	3155	local numbers = minetest.settings:get(name)
	3156
	3157	if numbers then
	3158	numbers = numbers:split(",")
	3159	chance = tonumber(numbers[1]) or chance
	3160	aoc = tonumber(numbers[2]) or aoc
	3161
	3162	if chance == 0 then
	3163	minetest.log("warning", string.format("[mobs] %s has spawning disabled", name))
	3164	return
	3165	end
	3166
	3167	minetest.log("action",
	3168	string.format("[mobs] Chance setting for %s changed to %s (total: %s)", name, chance, aoc))
	3169
	3170	end
	3171
	3172	minetest.register_abm({
	3173
	3174	label = name .. " spawning",
	3175	nodenames = nodes,
	3176	neighbors = neighbors,
	3177	interval = interval,
	3178	chance = max(1, (chance * mob_chance_multiplier)),
	3179	catch_up = false,
	3180
	3181	action = function(pos, node, active_object_count, active_object_count_wider)
	3182
	3183	-- is mob actually registered?
	3184	if not mobs.spawning_mobs[name]
	3185	or not minetest.registered_entities[name] then
	3186	--print ("--- mob doesn't exist", name)
	3187	return
	3188	end
	3189
	3190	-- additional custom checks for spawning mob
	3191	if mobs:spawn_abm_check(pos, node, name) == true then
	3192	return
	3193	end
	3194
	3195	-- do not spawn if too many entities in area
	3196	if active_object_count_wider >= max_per_block then
	3197	--print("--- too many entities in area", active_object_count_wider)
	3198	return
	3199	end
	3200
	3201	-- get total number of this mob in area
	3202	local num_mob = count_mobs(pos, name)
	3203
	3204	if num_mob >= aoc then
	3205	--print ("--- too many " .. name .. " in area", num_mob .. "/" .. aoc)
	3206	return
	3207	end
	3208
	3209	-- if toggle set to nil then ignore day/night check
	3210	if day_toggle ~= nil then
	3211