Commit 60c3e7a912cf3de1f5e92ceeb12d2142f7304c9a - minetest-mod-mobs-redo

Import upstream version 20181016+git20210722.1.9f46182 Debian Janitor 2 years ago

33 changed file(s) with 3480 addition(s) and 5623 deletion(s). Raw diff Collapse all Expand all

+2150

-1286

api.lua less more

0
1		-- Intllib and CMI support check
	0	-- Load support for intllib.
2	1	local MP = minetest.get_modpath(minetest.get_current_modname())
3		local S, NS = dofile(MP .. "/intllib.lua")
	2	local S = minetest.get_translator and minetest.get_translator("mobs_redo") or
	3	dofile(MP .. "/intllib.lua")
	4
	5	-- CMI support check
4	6	local use_cmi = minetest.global_exists("cmi")
5	7
6	8	mobs = {
7	9	mod = "redo",
8		version = "20181005",
	10	version = "20210722",
9	11	intllib = S,
10		invis = minetest.global_exists("invisibility") and invisibility or {},
	12	invis = minetest.global_exists("invisibility") and invisibility or {}
11	13	}
12	14
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
	15	-- localize common functions
21	16	local pi = math.pi
22	17	local square = math.sqrt
23	18	local sin = math.sin

25	20	local abs = math.abs
26	21	local min = math.min
27	22	local max = math.max
28		local atann = math.atan
29	23	local random = math.random
30	24	local floor = math.floor
	25	local ceil = math.ceil
	26	local rad = math.rad
	27	local atann = math.atan
31	28	local atan = function(x)
32	29	if not x or x ~= x then
33		--error("atan bassed NaN")
34		return 0
	30	return 0 -- NaN
35	31	else
36	32	return atann(x)
37	33	end
38	34	end
39
	35	local table_copy = table.copy
	36	local table_remove = table.remove
	37	local vadd = vector.add
	38	local vdirection = vector.direction
	39	local vmultiply = vector.multiply
	40	local vsubtract = vector.subtract
	41	local settings = minetest.settings
	42
	43	-- creative check
	44	local creative_cache = minetest.settings:get_bool("creative_mode")
	45	function mobs.is_creative(name)
	46	return creative_cache or minetest.check_player_privs(name,
	47	{creative = true})
	48	end
40	49
41	50	-- 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)
	51	local damage_enabled = settings:get_bool("enable_damage")
	52	local mobs_spawn = settings:get_bool("mobs_spawn") ~= false
	53	local peaceful_only = settings:get_bool("only_peaceful_mobs")
	54	local disable_blood = settings:get_bool("mobs_disable_blood")
	55	local mobs_drop_items = settings:get_bool("mobs_drop_items") ~= false
	56	local mobs_griefing = settings:get_bool("mobs_griefing") ~= false
	57	local spawn_protected = settings:get_bool("mobs_spawn_protected") ~= false
	58	local spawn_monster_protected = settings:get_bool("mobs_spawn_monster_protected") ~= false
	59	local remove_far = settings:get_bool("remove_far_mobs") ~= false
	60	local mob_area_spawn = settings:get_bool("mob_area_spawn")
	61	local difficulty = tonumber(settings:get("mob_difficulty")) or 1.0
	62	local show_health = settings:get_bool("mob_show_health") ~= false
	63	local max_per_block = tonumber(settings:get("max_objects_per_block") or 99)
	64	local mob_nospawn_range = tonumber(settings:get("mob_nospawn_range") or 12)
	65	local active_limit = tonumber(settings:get("mob_active_limit") or 0)
	66	local mob_chance_multiplier = tonumber(settings:get("mob_chance_multiplier") or 1)
	67	local peaceful_player_enabled = settings:get_bool("enable_peaceful_player")
	68	local mob_smooth_rotate = settings:get_bool("mob_smooth_rotate") ~= false
	69	local active_mobs = 0
55	70
56	71	-- Peaceful mode message so players will know there are no monsters
57	72	if peaceful_only then

62	77	end
63	78
64	79	-- calculate aoc range for mob count
65		local aoc_range = tonumber(minetest.settings:get("active_block_range")) * 16
	80	local aoc_range = tonumber(settings:get("active_block_range")) * 16
66	81
67	82	-- pathfinding settings
68	83	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
	84	local stuck_timeout = 3 -- how long before stuck mod starts searching
	85	local stuck_path_timeout = 5 -- how long will mob follow path before giving up
71	86
72	87	-- default nodes
73	88	local node_fire = "fire:basic_flame"

77	92	local node_snow = "default:snow"
78	93	mobs.fallback_node = minetest.registered_aliases["mapgen_dirt"] or "default:dirt"
79	94
	95	local mob_class = {
	96	stepheight = 1.1,
	97	fly_in = "air",
	98	owner = "",
	99	order = "",
	100	jump_height = 4,
	101	lifetimer = 180, -- 3 minutes
	102	physical = true,
	103	collisionbox = {-0.25, -0.25, -0.25, 0.25, 0.25, 0.25},
	104	visual_size = {x = 1, y = 1},
	105	texture_mods = "",
	106	makes_footstep_sound = false,
	107	view_range = 5,
	108	walk_velocity = 1,
	109	run_velocity = 2,
	110	light_damage = 0,
	111	light_damage_min = 14,
	112	light_damage_max = 15,
	113	water_damage = 0,
	114	lava_damage = 4,
	115	fire_damage = 4,
	116	air_damage = 0,
	117	suffocation = 2,
	118	fall_damage = 1,
	119	fall_speed = -10, -- must be lower than -2 (default: -10)
	120	drops = {},
	121	armor = 100,
	122	sounds = {},
	123	jump = true,
	124	knock_back = true,
	125	walk_chance = 50,
	126	stand_chance = 30,
	127	attack_chance = 5,
	128	passive = false,
	129	blood_amount = 5,
	130	blood_texture = "mobs_blood.png",
	131	shoot_offset = 0,
	132	floats = 1, -- floats in water by default
	133	replace_offset = 0,
	134	timer = 0,
	135	env_damage_timer = 0, -- only used when state = "attack"
	136	tamed = false,
	137	pause_timer = 0,
	138	horny = false,
	139	hornytimer = 0,
	140	child = false,
	141	gotten = false,
	142	health = 0,
	143	reach = 3,
	144	htimer = 0,
	145	docile_by_day = false,
	146	time_of_day = 0.5,
	147	fear_height = 0,
	148	runaway_timer = 0,
	149	immune_to = {},
	150	explosion_timer = 3,
	151	allow_fuse_reset = true,
	152	stop_to_explode = true,
	153	dogshoot_count = 0,
	154	dogshoot_count_max = 5,
	155	dogshoot_count2_max = 5,
	156	group_attack = false,
	157	attack_monsters = false,
	158	attack_animals = false,
	159	attack_players = true,
	160	attack_npcs = true,
	161	facing_fence = false,
	162	_cmi_is_mob = true
	163	}
	164
	165	local mob_class_meta = {__index = mob_class}
	166
80	167
81	168	-- play sound
82		local mob_sound = function(self, sound)
	169	function mob_class:mob_sound(sound)
	170
	171	local pitch = 1.0
	172
	173	-- higher pitch for a child
	174	if self.child then pitch = pitch * 1.5 end
	175
	176	-- a little random pitch to be different
	177	pitch = pitch + random(-10, 10) * 0.005
83	178
84	179	if sound then
85	180	minetest.sound_play(sound, {
86	181	object = self.object,
87	182	gain = 1.0,
88		max_hear_distance = self.sounds.distance
89		})
	183	max_hear_distance = self.sounds.distance,
	184	pitch = pitch
	185	}, true)
90	186	end
91	187	end
92	188
93	189
94	190	-- attack player/mob
95		local do_attack = function(self, player)
	191	function mob_class:do_attack(player)
96	192
97	193	if self.state == "attack" then
98	194	return

102	198	self.state = "attack"
103	199
104	200	if random(0, 100) < 90 then
105		mob_sound(self, self.sounds.war_cry)
	201	self:mob_sound(self.sounds.war_cry)
106	202	end
107	203	end
108	204

110	206	-- calculate distance
111	207	local get_distance = function(a, b)
112	208
	209	if not a or not b then return 50 end -- nil check
	210
113	211	local x, y, z = a.x - b.x, a.y - b.y, a.z - b.z
114	212
115	213	return square(x * x + y * y + z * z)

117	215
118	216
119	217	-- collision function based on jordan4ibanez' open_ai mod
120		local collision = function(self)
	218	function mob_class:collision()
121	219
122	220	local pos = self.object:get_pos()
123		local vel = self.object:get_velocity()
124	221	local x, z = 0, 0
125	222	local width = -self.collisionbox[1] + self.collisionbox[4] + 0.5
126	223
127	224	for _,object in ipairs(minetest.get_objects_inside_radius(pos, width)) do
128	225
129		if object:is_player()
130		or (object:get_luaentity()._cmi_is_mob == true and object ~= self.object) then
	226	if object:is_player() then
131	227
132	228	local pos2 = object:get_pos()
133	229	local vec = {x = pos.x - pos2.x, z = pos.z - pos2.z}

141	237	end
142	238
143	239
	240	-- check if string exists in another string or table
	241	local check_for = function(look_for, look_inside)
	242
	243	if type(look_inside) == "string" and look_inside == look_for then
	244
	245	return true
	246
	247	elseif type(look_inside) == "table" then
	248
	249	for _, str in pairs(look_inside) do
	250
	251	if str == look_for then
	252	return true
	253	end
	254
	255	if str:find("group:") then
	256
	257	local group = str:split(":")[2]
	258
	259	if minetest.get_item_group(look_for, group) ~= 0 then
	260	return true
	261	end
	262	end
	263	end
	264	end
	265
	266	return false
	267	end
	268
	269
144	270	-- move mob in facing direction
145		local set_velocity = function(self, v)
	271	function mob_class:set_velocity(v)
	272
	273	-- halt mob if it has been ordered to stay
	274	if self.order == "stand" then
	275
	276	local vel = self.object:get_velocity() or {y = 0}
	277
	278	self.object:set_velocity({x = 0, y = vel.y, z = 0})
	279
	280	return
	281	end
146	282
147	283	local c_x, c_y = 0, 0
148	284
149	285	-- can mob be pushed, if so calculate direction
150	286	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({
	287	c_x, c_y = unpack(self:collision())
	288	end
	289
	290	local yaw = (self.object:get_yaw() or 0) + (self.rotate or 0)
	291
	292	-- nil check for velocity
	293	v = v or 0.01
	294
	295	-- check if standing in liquid with max viscosity of 7
	296	local visc = min(minetest.registered_nodes[self.standing_in].liquid_viscosity, 7)
	297
	298	-- only slow mob trying to move while inside a viscous fluid that
	299	-- they aren't meant to be in (fish in water, spiders in cobweb etc)
	300	if v > 0 and visc and visc > 0
	301	and not check_for(self.standing_in, self.fly_in) then
	302	v = v / (visc + 1)
	303	end
	304
	305	-- set velocity
	306	local vel = self.object:get_velocity() or 0
	307
	308	local new_vel = {
163	309	x = (sin(yaw) * -v) + c_x,
164		y = self.object:get_velocity().y,
165		z = (cos(yaw) * v) + c_y,
166		})
	310	y = vel.y,
	311	z = (cos(yaw) * v) + c_y}
	312
	313	self.object:set_velocity(new_vel)
	314	end
	315
	316	-- global version of above function
	317	function mobs:set_velocity(entity, v)
	318	mob_class.set_velocity(entity, v)
167	319	end
168	320
169	321
170	322	-- calculate mob velocity
171		local get_velocity = function(self)
	323	function mob_class:get_velocity()
172	324
173	325	local v = self.object:get_velocity()
174	326
	327	if not v then return 0 end
	328
175	329	return (v.x * v.x + v.z * v.z) ^ 0.5
176	330	end
177	331
178	332
179	333	-- set and return valid yaw
180		local set_yaw = function(self, yaw, delay)
	334	function mob_class:set_yaw(yaw, delay)
181	335
182	336	if not yaw or yaw ~= yaw then
183	337	yaw = 0
184	338	end
185	339
186		delay = delay or 0
	340	delay = mob_smooth_rotate and (delay or 0) or 0
187	341
188	342	if delay == 0 then
	343
189	344	self.object:set_yaw(yaw)
	345
190	346	return yaw
191	347	end
192	348

197	353	end
198	354
199	355	-- global function to set mob yaw
200		function mobs:yaw(self, yaw, delay)
201		set_yaw(self, yaw, delay)
	356	function mobs:yaw(entity, yaw, delay)
	357	mob_class.set_yaw(entity, yaw, delay)
202	358	end
203	359
204	360
205	361	-- set defined animation
206		local set_animation = function(self, anim)
207
208		if not self.animation
209		or not anim then return end
	362	function mob_class:set_animation(anim, force)
	363
	364	if not self.animation or not anim then return end
210	365
211	366	self.animation.current = self.animation.current or ""
212	367
213		-- only set different animation for attacks when setting to same set
214		if anim ~= "punch" and anim ~= "shoot"
	368	-- only use different animation for attacks when using same set
	369	if force ~= true and anim ~= "punch" and anim ~= "shoot"
215	370	and string.find(self.animation.current, anim) then
216	371	return
217	372	end
218	373
219		-- check for more than one animation
220	374	local num = 0
221	375
	376	-- check for more than one animation (max 4)
222	377	for n = 1, 4 do
223	378
224	379	if self.animation[anim .. n .. "_start"]

244	399	self.object:set_animation({
245	400	x = self.animation[anim .. "_start"],
246	401	y = self.animation[anim .. "_end"]},
247		self.animation[anim .. "_speed"] or self.animation.speed_normal or 15,
	402	self.animation[anim .. "_speed"] or
	403	self.animation.speed_normal or 15,
248	404	0, self.animation[anim .. "_loop"] ~= false)
249	405	end
250	406
251		-- above function exported for mount.lua
252		function mobs:set_animation(self, anim)
253		set_animation(self, anim)
	407	function mobs:set_animation(entity, anim)
	408	entity.set_animation(entity, anim)
	409	end
	410
	411
	412	-- check line of sight (BrunoMine)
	413	local line_of_sight = function(self, pos1, pos2, stepsize)
	414
	415	stepsize = stepsize or 1
	416
	417	local s, pos = minetest.line_of_sight(pos1, pos2, stepsize)
	418
	419	-- normal walking and flying mobs can see you through air
	420	if s == true then
	421	return true
	422	end
	423
	424	-- New pos1 to be analyzed
	425	local npos1 = {x = pos1.x, y = pos1.y, z = pos1.z}
	426
	427	local r, pos = minetest.line_of_sight(npos1, pos2, stepsize)
	428
	429	-- Checks the return
	430	if r == true then return true end
	431
	432	-- Nodename found
	433	local nn = minetest.get_node(pos).name
	434
	435	-- Target Distance (td) to travel
	436	local td = get_distance(pos1, pos2)
	437
	438	-- Actual Distance (ad) traveled
	439	local ad = 0
	440
	441	-- It continues to advance in the line of sight in search of a real
	442	-- obstruction which counts as 'walkable' nodebox.
	443	while minetest.registered_nodes[nn]
	444	and (minetest.registered_nodes[nn].walkable == false) do
	445
	446	-- Check if you can still move forward
	447	if td < ad + stepsize then
	448	return true -- Reached the target
	449	end
	450
	451	-- Moves the analyzed pos
	452	local d = get_distance(pos1, pos2)
	453
	454	npos1.x = ((pos2.x - pos1.x) / d * stepsize) + pos1.x
	455	npos1.y = ((pos2.y - pos1.y) / d * stepsize) + pos1.y
	456	npos1.z = ((pos2.z - pos1.z) / d * stepsize) + pos1.z
	457
	458	-- NaN checks
	459	if d == 0
	460	or npos1.x ~= npos1.x
	461	or npos1.y ~= npos1.y
	462	or npos1.z ~= npos1.z then
	463	return false
	464	end
	465
	466	ad = ad + stepsize
	467
	468	-- scan again
	469	r, pos = minetest.line_of_sight(npos1, pos2, stepsize)
	470
	471	if r == true then return true end
	472
	473	-- New Nodename found
	474	nn = minetest.get_node(pos).name
	475	end
	476
	477	return false
254	478	end
255	479
256	480
257	481	-- check line of sight (by BrunoMine, tweaked by Astrobe)
258		local line_of_sight = function(self, pos1, pos2, stepsize)
	482	local new_line_of_sight = function(self, pos1, pos2, stepsize)
259	483
260	484	if not pos1 or not pos2 then return end
261	485
262	486	stepsize = stepsize or 1
263	487
264		local stepv = vector.multiply(vector.direction(pos1, pos2), stepsize)
	488	local stepv = vmultiply(vdirection(pos1, pos2), stepsize)
265	489
266	490	local s, pos = minetest.line_of_sight(pos1, pos2, stepsize)
267	491

280	504	local nn = minetest.get_node(pos).name
281	505
282	506	-- It continues to advance in the line of sight in search of a real
283		-- obstruction which counts as 'normal' nodebox.
	507	-- obstruction which counts as 'walkable' nodebox.
284	508	while minetest.registered_nodes[nn]
285	509	and (minetest.registered_nodes[nn].walkable == false) do
286		-- or minetest.registered_nodes[nn].drawtype == "nodebox") do
287
288		npos1 = vector.add(npos1, stepv)
	510
	511	npos1 = vadd(npos1, stepv)
289	512
290	513	if get_distance(npos1, pos2) < stepsize then return true end
291	514

301	524	return false
302	525	end
303	526
	527	-- check line of sight using raycasting (thanks Astrobe)
	528	local ray_line_of_sight = function(self, pos1, pos2)
	529
	530	local ray = minetest.raycast(pos1, pos2, true, false)
	531	local thing = ray:next()
	532
	533	while thing do -- thing.type, thing.ref
	534
	535	if thing.type == "node" then
	536
	537	local name = minetest.get_node(thing.under).name
	538
	539	if minetest.registered_items[name]
	540	and minetest.registered_items[name].walkable then
	541	return false
	542	end
	543	end
	544
	545	thing = ray:next()
	546	end
	547
	548	return true
	549	end
	550
	551
	552	function mob_class:line_of_sight(pos1, pos2, stepsize)
	553
	554	if minetest.raycast then -- only use if minetest 5.0 is detected
	555	return ray_line_of_sight(self, pos1, pos2)
	556	end
	557
	558	return line_of_sight(self, pos1, pos2, stepsize)
	559	end
	560
304	561	-- global function
305		function mobs:line_of_sight(self, pos1, pos2, stepsize)
306
307		return line_of_sight(self, pos1, pos2, stepsize)
	562	function mobs:line_of_sight(entity, pos1, pos2, stepsize)
	563	return entity:line_of_sight(pos1, pos2, stepsize)
	564	end
	565
	566
	567	function mob_class:attempt_flight_correction(override)
	568
	569	if self:flight_check() and override ~= true then return true end
	570
	571	-- We are not flying in what we are supposed to.
	572	-- See if we can find intended flight medium and return to it
	573	local pos = self.object:get_pos() ; if not pos then return true end
	574	local searchnodes = self.fly_in
	575
	576	if type(searchnodes) == "string" then
	577	searchnodes = {self.fly_in}
	578	end
	579
	580	local flyable_nodes = minetest.find_nodes_in_area(
	581	{x = pos.x - 1, y = pos.y - 1, z = pos.z - 1},
	582	{x = pos.x + 1, y = pos.y + 0, z = pos.z + 1}, searchnodes)
	583	-- pos.y + 0 hopefully fixes floating swimmers
	584
	585	if #flyable_nodes < 1 then
	586	return false
	587	end
	588
	589	local escape_target = flyable_nodes[random(#flyable_nodes)]
	590	local escape_direction = vdirection(pos, escape_target)
	591
	592	self.object:set_velocity(
	593	vmultiply(escape_direction, 1))
	594
	595	return true
308	596	end
309	597
310	598
311	599	-- are we flying in what we are suppose to? (taikedz)
312		local flight_check = function(self, pos_w)
	600	function mob_class:flight_check()
313	601
314	602	local def = minetest.registered_nodes[self.standing_in]
315	603
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
	604	if not def then return false end
	605
	606	-- are we standing inside what we should be to fly/swim ?
	607	if check_for(self.standing_in, self.fly_in) then
321	608	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	609	end
333	610
334	611	-- stops mobs getting stuck inside stairs and plantlike nodes

342	619	end
343	620
344	621
	622	-- turn mob to face position
	623	local yaw_to_pos = function(self, target, rot)
	624
	625	rot = rot or 0
	626
	627	local pos = self.object:get_pos()
	628	local vec = {x = target.x - pos.x, z = target.z - pos.z}
	629	local yaw = (atan(vec.z / vec.x) + rot + pi / 2) - self.rotate
	630
	631	if target.x > pos.x then
	632	yaw = yaw + pi
	633	end
	634
	635	yaw = self:set_yaw(yaw, rot)
	636
	637	return yaw
	638	end
	639
	640	function mobs:yaw_to_pos(self, target, rot)
	641	return yaw_to_pos(self, target, rot)
	642	end
	643
	644
	645	-- if stay near set then periodically check for nodes and turn towards them
	646	function mob_class:do_stay_near()
	647
	648	if not self.stay_near then return false end
	649
	650	local pos = self.object:get_pos()
	651	local searchnodes = self.stay_near[1]
	652	local chance = self.stay_near[2] or 10
	653
	654	if not pos or random(chance) > 1 then
	655	return false
	656	end
	657
	658	if type(searchnodes) == "string" then
	659	searchnodes = {self.stay_near[1]}
	660	end
	661
	662	local r = self.view_range
	663	local nearby_nodes = minetest.find_nodes_in_area(
	664	{x = pos.x - r, y = pos.y - 1, z = pos.z - r},
	665	{x = pos.x + r, y = pos.y + 1, z = pos.z + r}, searchnodes)
	666
	667	if #nearby_nodes < 1 then
	668	return false
	669	end
	670
	671	yaw_to_pos(self, nearby_nodes[random(#nearby_nodes)])
	672
	673	self:set_animation("walk")
	674
	675	self:set_velocity(self.walk_velocity)
	676
	677	return true
	678	end
	679
	680
345	681	-- custom particle effects
346		local effect = function(pos, amount, texture, min_size, max_size, radius, gravity, glow)
	682	local effect = function(pos, amount, texture, min_size, max_size,
	683	radius, gravity, glow, fall)
347	684
348	685	radius = radius or 2
349	686	min_size = min_size or 0.5

351	688	gravity = gravity or -10
352	689	glow = glow or 0
353	690
	691	if fall == true then
	692	fall = 0
	693	elseif fall == false then
	694	fall = radius
	695	else
	696	fall = -radius
	697	end
	698
354	699	minetest.add_particlespawner({
355	700	amount = amount,
356	701	time = 0.25,
357	702	minpos = pos,
358	703	maxpos = pos,
359		minvel = {x = -radius, y = -radius, z = -radius},
	704	minvel = {x = -radius, y = fall, z = -radius},
360	705	maxvel = {x = radius, y = radius, z = radius},
361	706	minacc = {x = 0, y = gravity, z = 0},
362	707	maxacc = {x = 0, y = gravity, z = 0},

365	710	minsize = min_size,
366	711	maxsize = max_size,
367	712	texture = texture,
368		glow = glow,
	713	glow = glow
369	714	})
370	715	end
371	716
	717	function mobs:effect(pos, amount, texture, min_size, max_size,
	718	radius, gravity, glow, fall)
	719
	720	effect(pos, amount, texture, min_size, max_size, radius, gravity, glow, fall)
	721	end
	722
372	723
373	724	-- update nametag colour
374		local update_tag = function(self)
	725	function mob_class:update_tag()
375	726
376	727	local col = "#00FF00"
377	728	local qua = self.hp_max / 4

388	739	col = "#FF0000"
389	740	end
390	741
	742	-- build infotext
	743	self.infotext = "Health: " .. self.health .. " / " .. self.hp_max
	744	.. "\n" .. "Owner: " .. self.owner
	745
	746	-- set changes
391	747	self.object:set_properties({
392	748	nametag = self.nametag,
393		nametag_color = col
	749	nametag_color = col,
	750	infotext = self.infotext
394	751	})
395
396	752	end
397	753
398	754
399	755	-- drop items
400		local item_drop = function(self)
	756	function mob_class:item_drop()
	757
	758	-- no drops if disabled by setting or mob is child
	759	if not mobs_drop_items or self.child then return end
	760
	761	local pos = self.object:get_pos()
	762
	763	-- check for drops function
	764	self.drops = type(self.drops) == "function"
	765	and self.drops(pos) or self.drops
401	766
402	767	-- check for nil or no drops
403	768	if not self.drops or #self.drops == 0 then
404	769	return
405	770	end
406	771
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	772	-- 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
	773	local death_by_player = self.cause_of_death
	774	and self.cause_of_death.puncher
	775	and self.cause_of_death.puncher:is_player()
416	776
417	777	local obj, item, num
418		local pos = self.object:get_pos()
419	778
420	779	for n = 1, #self.drops do
421	780
422		if random(1, self.drops[n].chance) == 1 then
	781	if random(self.drops[n].chance) == 1 then
423	782
424	783	num = random(self.drops[n].min or 0, self.drops[n].max or 1)
425	784	item = self.drops[n].name

435	794	end
436	795	end
437	796
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
	797	-- only drop rare items (drops.min = 0) if killed by player
	798	if death_by_player or self.drops[n].min ~= 0 then
443	799	obj = minetest.add_item(pos, ItemStack(item .. " " .. num))
444	800	end
445	801

448	804	obj:set_velocity({
449	805	x = random(-10, 10) / 9,
450	806	y = 6,
451		z = random(-10, 10) / 9,
	807	z = random(-10, 10) / 9
452	808	})
453	809
454	810	elseif obj then

461	817	end
462	818
463	819
	820	-- remove mob and descrease counter
	821	local remove_mob = function(self, decrease)
	822
	823	self.object:remove()
	824
	825	if decrease and active_limit > 0 then
	826
	827	active_mobs = active_mobs - 1
	828
	829	if active_mobs < 0 then
	830	active_mobs = 0
	831	end
	832	end
	833	--print("-- active mobs: " .. active_mobs .. " / " .. active_limit)
	834	end
	835
	836	-- global function for removing mobs
	837	function mobs:remove(self, decrease)
	838	remove_mob(self, decrease)
	839	end
	840
	841
464	842	-- check if mob is dead or only hurt
465		local check_for_death = function(self, cmi_cause)
	843	function mob_class:check_for_death(cmi_cause)
	844
	845	-- We dead already
	846	if self.state == "die" then
	847	return true
	848	end
466	849
467	850	-- has health actually changed?
468	851	if self.health == self.old_health and self.health > 0 then
469		return
470		end
	852	return false
	853	end
	854
	855	local damaged = self.health < self.old_health
471	856
472	857	self.old_health = self.health
473	858
474	859	-- still got some health? play hurt sound
475	860	if self.health > 0 then
476	861
477		mob_sound(self, self.sounds.damage)
	862	-- only play hurt sound if damaged
	863	if damaged then
	864	self:mob_sound(self.sounds.damage)
	865	end
478	866
479	867	-- make sure health isn't higher than max
480	868	if self.health > self.hp_max then

482	870	end
483	871
484	872	-- 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
	873	-- if not self.nametag2 then
	874	-- self.nametag2 = self.nametag or ""
	875	-- end
	876
	877	-- if show_health
	878	-- and (cmi_cause and cmi_cause.type == "punch") then
	879
	880	-- self.htimer = 2
	881	-- self.nametag = "♥ " .. self.health .. " / " .. self.hp_max
	882	self:update_tag()
	883	-- end
497	884
498	885	return false
499	886	end

501	888	self.cause_of_death = cmi_cause
502	889
503	890	-- drop items
504		item_drop(self)
505
506		mob_sound(self, self.sounds.death)
	891	self:item_drop()
	892
	893	self:mob_sound(self.sounds.death)
507	894
508	895	local pos = self.object:get_pos()
509	896
510	897	-- execute custom death function
511		if self.on_die then
512
513		self.on_die(self, pos)
	898	if pos and self.on_die then
	899
	900	self:on_die(pos)
514	901
515	902	if use_cmi then
516	903	cmi.notify_die(self.object, cmi_cause)
517	904	end
518	905
519		self.object:remove()
	906	remove_mob(self, true)
520	907
521	908	return true
522	909	end
523	910
524		-- default death function and die animation (if defined)
	911	-- check for custom death function and die animation
525	912	if self.animation
526	913	and self.animation.die_start
527	914	and self.animation.die_end then
528	915
529	916	local frames = self.animation.die_end - self.animation.die_start
530	917	local speed = self.animation.die_speed or 15
531		local length = max(frames / speed, 0)
	918	local length = max((frames / speed), 0)
	919	local rot = self.animation.die_rotate and 5
532	920
533	921	self.attack = nil
	922	self.following = nil
534	923	self.v_start = false
535	924	self.timer = 0
536	925	self.blinktimer = 0
537	926	self.passive = true
538	927	self.state = "die"
539		set_velocity(self, 0)
540		set_animation(self, "die")
	928	self.object:set_properties({
	929	pointable = false, collide_with_objects = false,
	930	automatic_rotate = rot, static_save = false
	931	})
	932	self:set_velocity(0)
	933	self:set_animation("die")
541	934
542	935	minetest.after(length, function(self)
543	936
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()
	937	if self.object:get_luaentity() then
	938
	939	if use_cmi then
	940	cmi.notify_die(self.object, cmi_cause)
	941	end
	942
	943	remove_mob(self, true)
	944	end
549	945	end, self)
550		else
	946
	947	return true
	948
	949	elseif pos then -- otherwise remove mod and show particle effect
551	950
552	951	if use_cmi then
553	952	cmi.notify_die(self.object, cmi_cause)
554	953	end
555	954
556		self.object:remove()
557		end
558
559		effect(pos, 20, "tnt_smoke.png")
	955	remove_mob(self, true)
	956
	957	effect(pos, 20, "tnt_smoke.png")
	958	end
560	959
561	960	return true
562	961	end
563	962
564	963
	964	-- get node but use fallback for nil or unknown
	965	local node_ok = function(pos, fallback)
	966
	967	fallback = fallback or mobs.fallback_node
	968
	969	local node = minetest.get_node_or_nil(pos)
	970
	971	if node and minetest.registered_nodes[node.name] then
	972	return node
	973	end
	974
	975	return minetest.registered_nodes[fallback]
	976	end
	977
	978
	979	-- Returns true is node can deal damage to self
	980	local is_node_dangerous = function(self, nodename)
	981
	982	if self.water_damage > 0
	983	and minetest.get_item_group(nodename, "water") ~= 0 then
	984	return true
	985	end
	986
	987	if self.lava_damage > 0
	988	and minetest.get_item_group(nodename, "lava") ~= 0 then
	989	return true
	990	end
	991
	992	if self.fire_damage > 0
	993	and minetest.get_item_group(nodename, "fire") ~= 0 then
	994	return true
	995	end
	996
	997	if minetest.registered_nodes[nodename].damage_per_second > 0 then
	998	return true
	999	end
	1000
	1001	return false
	1002	end
	1003
	1004
565	1005	-- is mob facing a cliff
566		local is_at_cliff = function(self)
	1006	function mob_class:is_at_cliff()
567	1007
568	1008	if self.fear_height == 0 then -- 0 for no falling protection!
569	1009	return false
570	1010	end
571	1011
	1012	-- get yaw but if nil returned object no longer exists
572	1013	local yaw = self.object:get_yaw()
	1014
	1015	if not yaw then return false end
	1016
573	1017	local dir_x = -sin(yaw) * (self.collisionbox[4] + 0.5)
574	1018	local dir_z = cos(yaw) * (self.collisionbox[4] + 0.5)
575	1019	local pos = self.object:get_pos()
576	1020	local ypos = pos.y + self.collisionbox[2] -- just above floor
577	1021
578		if minetest.line_of_sight(
	1022	local free_fall, blocker = minetest.line_of_sight(
579	1023	{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
	1024	{x = pos.x + dir_x, y = ypos - self.fear_height, z = pos.z + dir_z})
	1025
	1026	-- check for straight drop
	1027	if free_fall then
583	1028	return true
584	1029	end
585	1030
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]
	1031	local bnode = node_ok(blocker)
	1032
	1033	-- will we drop onto dangerous node?
	1034	if is_node_dangerous(self, bnode.name) then
	1035	return true
	1036	end
	1037
	1038	local def = minetest.registered_nodes[bnode.name]
	1039
	1040	return (not def and def.walkable)
602	1041	end
603	1042
604	1043
605	1044	-- environmental damage (water, lava, fire, light etc.)
606		local do_env_damage = function(self)
	1045	function mob_class:do_env_damage()
607	1046
608	1047	-- feed/tame text timer (so mob 'full' messages dont spam chat)
609	1048	if self.htimer > 0 then

611	1050	end
612	1051
613	1052	-- 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()
	1053	-- if self.htimer < 1 and self.nametag2 then
	1054
	1055	-- self.nametag = self.nametag2
	1056	-- self.nametag2 = nil
	1057
	1058	self:update_tag()
	1059	-- end
	1060
	1061	local pos = self.object:get_pos() ; if not pos then return end
623	1062
624	1063	self.time_of_day = minetest.get_timeofday()
625	1064
626		-- remove mob if standing inside ignore node
	1065	-- halt mob if standing inside ignore node
627	1066	if self.standing_in == "ignore" then
628		self.object:remove()
629		return
	1067
	1068	self.object:set_velocity({x = 0, y = 0, z = 0})
	1069
	1070	return true
	1071	end
	1072
	1073	-- particle appears at random mob height
	1074	local py = {
	1075	x = pos.x,
	1076	y = pos.y + random(self.collisionbox[2], self.collisionbox[5]),
	1077	z = pos.z
	1078	}
	1079
	1080	local nodef = minetest.registered_nodes[self.standing_in]
	1081
	1082	-- water
	1083	if self.water_damage ~= 0 and nodef.groups.water then
	1084
	1085	self.health = self.health - self.water_damage
	1086
	1087	effect(py, 5, "bubble.png", nil, nil, 1, nil)
	1088
	1089	if self:check_for_death({type = "environment",
	1090	pos = pos, node = self.standing_in}) then
	1091	return true
	1092	end
	1093
	1094	-- lava damage
	1095	elseif self.lava_damage ~= 0 and nodef.groups.lava then
	1096
	1097	self.health = self.health - self.lava_damage
	1098
	1099	effect(py, 15, "fire_basic_flame.png", 1, 5, 1, 0.2, 15, true)
	1100
	1101	if self:check_for_death({type = "environment", pos = pos,
	1102	node = self.standing_in, hot = true}) then
	1103	return true
	1104	end
	1105
	1106	-- fire damage
	1107	elseif self.fire_damage ~= 0 and nodef.groups.fire then
	1108
	1109	self.health = self.health - self.fire_damage
	1110
	1111	effect(py, 15, "fire_basic_flame.png", 1, 5, 1, 0.2, 15, true)
	1112
	1113	if self:check_for_death({type = "environment", pos = pos,
	1114	node = self.standing_in, hot = true}) then
	1115	return true
	1116	end
	1117
	1118	-- damage_per_second node check (not fire and lava)
	1119	elseif nodef.damage_per_second ~= 0
	1120	and nodef.groups.lava == nil and nodef.groups.fire == nil then
	1121
	1122	self.health = self.health - nodef.damage_per_second
	1123
	1124	effect(py, 5, "tnt_smoke.png")
	1125
	1126	if self:check_for_death({type = "environment",
	1127	pos = pos, node = self.standing_in}) then
	1128	return true
	1129	end
	1130	end
	1131
	1132	-- air damage
	1133	if self.air_damage ~= 0 and self.standing_in == "air" then
	1134
	1135	self.health = self.health - self.air_damage
	1136
	1137	effect(py, 3, "bubble.png", 1, 1, 1, 0.2)
	1138
	1139	if self:check_for_death({type = "environment",
	1140	pos = pos, node = self.standing_in}) then
	1141	return true
	1142	end
630	1143	end
631	1144
632	1145	-- is mob light sensative, or scared of the dark :P

639	1152
640	1153	self.health = self.health - self.light_damage
641	1154
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		--[[
	1155	effect(py, 5, "tnt_smoke.png")
	1156
	1157	if self:check_for_death({type = "light"}) then
	1158	return true
	1159	end
	1160	end
	1161	end
	1162
694	1163	--- 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"})
	1164	if (self.suffocation and self.suffocation ~= 0)
	1165	and (nodef.walkable == nil or nodef.walkable == true)
	1166	and (nodef.collision_box == nil or nodef.collision_box.type == "regular")
	1167	and (nodef.node_box == nil or nodef.node_box.type == "regular")
	1168	and (nodef.groups.disable_suffocation ~= 1) then
	1169
	1170	local damage
	1171
	1172	if self.suffocation == true then
	1173	damage = 2
	1174	else
	1175	damage = (self.suffocation or 2)
	1176	end
	1177
	1178	self.health = self.health - damage
	1179
	1180	if self:check_for_death({type = "suffocation",
	1181	pos = pos, node = self.standing_in}) then
	1182	return true
	1183	end
	1184	end
	1185
	1186	return self:check_for_death({type = "unknown"})
707	1187	end
708	1188
709	1189
710	1190	-- jump if facing a solid node (not fences or gates)
711		local do_jump = function(self)
	1191	function mob_class:do_jump()
712	1192
713	1193	if not self.jump
714	1194	or self.jump_height == 0

722	1202
723	1203	-- something stopping us while moving?
724	1204	if self.state ~= "stand"
725		and get_velocity(self) > 0.5
	1205	and self:get_velocity() > 0.5
726	1206	and self.object:get_velocity().y ~= 0 then
727	1207	return false
728	1208	end

730	1210	local pos = self.object:get_pos()
731	1211	local yaw = self.object:get_yaw()
732	1212
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
	1213	-- sanity check
	1214	if not yaw then return false end
	1215
	1216	-- we can only jump if standing on solid node
	1217	if minetest.registered_nodes[self.standing_on].walkable == false then
741	1218	return false
742	1219	end
743	1220

745	1222	local dir_x = -sin(yaw) * (self.collisionbox[4] + 0.5)
746	1223	local dir_z = cos(yaw) * (self.collisionbox[4] + 0.5)
747	1224
	1225	-- set y_pos to base of mob
	1226	pos.y = pos.y + self.collisionbox[2]
	1227
748	1228	-- what is in front of mob?
749	1229	local nod = node_ok({
750		x = pos.x + dir_x,
751		y = pos.y + 0.5,
752		z = pos.z + dir_z
	1230	x = pos.x + dir_x, y = pos.y + 0.5, z = pos.z + dir_z
753	1231	})
754	1232
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
	1233	-- what is above and in front?
	1234	local nodt = node_ok({
	1235	x = pos.x + dir_x, y = pos.y + 1.5, z = pos.z + dir_z
	1236	})
	1237
	1238	local blocked = minetest.registered_nodes[nodt.name].walkable
	1239
	1240	-- are we facing a fence or wall
	1241	if nod.name:find("fence") or nod.name:find("gate") or nod.name:find("wall") then
	1242	self.facing_fence = true
	1243	end
	1244	--[[
	1245	print("on: " .. self.standing_on
	1246	.. ", front: " .. nod.name
	1247	.. ", front above: " .. nodt.name
	1248	.. ", blocked: " .. (blocked and "yes" or "no")
	1249	.. ", fence: " .. (self.facing_fence and "yes" or "no")
	1250	)
	1251	]]
	1252	-- jump if standing on solid node (not snow) and not blocked
	1253	if (self.walk_chance == 0 or minetest.registered_items[nod.name].walkable)
	1254	and not blocked and not self.facing_fence and nod.name ~= node_snow then
	1255
	1256	local v = self.object:get_velocity()
	1257
	1258	v.y = self.jump_height
	1259
	1260	self:set_animation("jump") -- only when defined
	1261
	1262	self.object:set_velocity(v)
	1263
	1264	-- when in air move forward
	1265	minetest.after(0.3, function(self, v)
	1266
	1267	if self.object:get_luaentity() then
	1268
	1269	self.object:set_acceleration({
	1270	x = v.x * 2,
	1271	y = 0,
	1272	z = v.z * 2
	1273	})
	1274	end
	1275	end, self, v)
	1276
	1277	if self:get_velocity() > 0 then
	1278	self:mob_sound(self.sounds.jump)
	1279	end
	1280
	1281	self.jump_count = 0
795	1282
796	1283	return true
	1284	end
	1285
	1286	-- if blocked for 3 counts then turn
	1287	if not self.following and (self.facing_fence or blocked) then
	1288
	1289	self.jump_count = (self.jump_count or 0) + 1
	1290
	1291	if self.jump_count > 2 then
	1292
	1293	local yaw = self.object:get_yaw() or 0
	1294	local turn = random(0, 2) + 1.35
	1295
	1296	yaw = self:set_yaw(yaw + turn, 12)
	1297
	1298	self.jump_count = 0
	1299	end
797	1300	end
798	1301
799	1302	return false

813	1316	obj_pos = objs[n]:get_pos()
814	1317
815	1318	dist = get_distance(pos, obj_pos)
	1319
816	1320	if dist < 1 then dist = 1 end
817	1321
818	1322	local damage = floor((4 / dist) * radius)

827	1331	end
828	1332
829	1333
	1334	-- can mob see player
	1335	local is_invisible = function(self, player_name)
	1336
	1337	if mobs.invis[player_name] and not self.ignore_invisibility then
	1338	return true
	1339	end
	1340	end
	1341
	1342
830	1343	-- should mob follow what I'm holding ?
831		local follow_holding = function(self, clicker)
832
833		if mobs.invis[clicker:get_player_name()] then
	1344	function mob_class:follow_holding(clicker)
	1345
	1346	if is_invisible(self, clicker:get_player_name()) then
834	1347	return false
835	1348	end
836	1349
837	1350	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
	1351
	1352	-- are we holding an item mob can follow ?
	1353	if check_for(item:get_name(), self.follow) then
843	1354	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	1355	end
855	1356
856	1357	return false
857	1358	end
858	1359
	1360	-- Thanks Wuzzy for the following editable settings
	1361	local HORNY_TIME = 30
	1362	local HORNY_AGAIN_TIME = 60 * 5 -- 5 minutes
	1363	local CHILD_GROW_TIME = 60 * 20 -- 20 minutes
859	1364
860	1365	-- 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
	1366	function mob_class:breed()
	1367
	1368	-- child takes a long time before growing into adult
864	1369	if self.child == true then
865	1370
866	1371	self.hornytimer = self.hornytimer + 1
867	1372
868		if self.hornytimer > 240 then
	1373	if self.hornytimer > CHILD_GROW_TIME then
869	1374
870	1375	self.child = false
871	1376	self.hornytimer = 0

875	1380	mesh = self.base_mesh,
876	1381	visual_size = self.base_size,
877	1382	collisionbox = self.base_colbox,
878		selectionbox = self.base_selbox,
	1383	selectionbox = self.base_selbox
879	1384	})
880	1385
881	1386	-- custom function when child grows up
882	1387	if self.on_grown then
883	1388	self.on_grown(self)
884	1389	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		})
	1390	local pos = self.object:get_pos() ; if not pos then return end
	1391	local ent = self.object:get_luaentity()
	1392
	1393	pos.y = pos.y + (ent.collisionbox[2] * -1) - 0.4
	1394
	1395	self.object:set_pos(pos)
	1396
	1397	-- jump slightly when fully grown so as not to fall into ground
	1398	self.object:set_velocity({x = 0, y = 0.5, z = 0 })
891	1399	end
892	1400	end
893	1401
894	1402	return
895	1403	end
896	1404
897		-- horny animal can mate for 40 seconds,
898		-- afterwards horny animal cannot mate again for 200 seconds
	1405	-- horny animal can mate for HORNY_TIME seconds,
	1406	-- afterwards horny animal cannot mate again for HORNY_AGAIN_TIME seconds
899	1407	if self.horny == true
900		and self.hornytimer < 240 then
	1408	and self.hornytimer < HORNY_TIME + HORNY_AGAIN_TIME then
901	1409
902	1410	self.hornytimer = self.hornytimer + 1
903	1411
904		if self.hornytimer >= 240 then
	1412	if self.hornytimer >= HORNY_TIME + HORNY_AGAIN_TIME then
905	1413	self.hornytimer = 0
906	1414	self.horny = false
907	1415	end

909	1417
910	1418	-- find another same animal who is also horny and mate if nearby
911	1419	if self.horny == true
912		and self.hornytimer <= 40 then
	1420	and self.hornytimer <= HORNY_TIME then
913	1421
914	1422	local pos = self.object:get_pos()
915	1423
916		effect({x = pos.x, y = pos.y + 1, z = pos.z}, 8, "heart.png", 3, 4, 1, 0.1)
	1424	effect({x = pos.x, y = pos.y + 1, z = pos.z}, 8,
	1425	"heart.png", 3, 4, 1, 0.1)
917	1426
918	1427	local objs = minetest.get_objects_inside_radius(pos, 3)
919		local num = 0
920		local ent = nil
	1428	local ent
921	1429
922	1430	for n = 1, #objs do
923	1431

931	1439	if ent.name == self.name then
932	1440	canmate = true
933	1441	else
934		local entname = string.split(ent.name,":")
935		local selfname = string.split(self.name,":")
	1442	local entname = ent.name:split(":")
	1443	local selfname = self.name:split(":")
936	1444
937	1445	if entname[1] == selfname[1] then
938		entname = string.split(entname[2],"_")
939		selfname = string.split(selfname[2],"_")
	1446	entname = entname[2]:split("_")
	1447	selfname = selfname[2]:split("_")
940	1448
941	1449	if entname[1] == selfname[1] then
942	1450	canmate = true

945	1453	end
946	1454	end
947	1455
948		if ent
	1456	-- found another similar horny animal that isn't self?
	1457	if ent and ent.object ~= self.object
949	1458	and canmate == true
950	1459	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
	1460	and ent.hornytimer <= HORNY_TIME then
	1461
	1462	local pos2 = ent.object:get_pos()
	1463
	1464	-- Have mobs face one another
	1465	yaw_to_pos(self, pos2)
	1466	yaw_to_pos(ent, self.object:get_pos())
	1467
	1468	self.hornytimer = HORNY_TIME + 1
	1469	ent.hornytimer = HORNY_TIME + 1
	1470
	1471	-- have we reached active mob limit
	1472	if active_limit > 0 and active_mobs >= active_limit then
	1473	minetest.chat_send_player(self.owner,
	1474	S("Active Mob Limit Reached!")
	1475	.. " (" .. active_mobs
	1476	.. " / " .. active_limit .. ")")
	1477	return
	1478	end
960	1479
961	1480	-- spawn baby
962	1481	minetest.after(5, function(self, ent)

969	1488	if self.on_breed then
970	1489
971	1490	-- when false skip going any further
972		if self.on_breed(self, ent) == false then
	1491	if self:on_breed(ent) == false then
973	1492	return
974	1493	end
975	1494	else
976	1495	effect(pos, 15, "tnt_smoke.png", 1, 2, 2, 15, 5)
977	1496	end
978	1497
	1498	pos.y = pos.y + 0.5 -- spawn child a little higher
	1499
979	1500	local mob = minetest.add_entity(pos, self.name)
980	1501	local ent2 = mob:get_luaentity()
981	1502	local textures = self.base_texture

990	1511	textures = textures,
991	1512	visual_size = {
992	1513	x = self.base_size.x * .5,
993		y = self.base_size.y * .5,
	1514	y = self.base_size.y * .5
994	1515	},
995	1516	collisionbox = {
996	1517	self.base_colbox[1] * .5,

998	1519	self.base_colbox[3] * .5,
999	1520	self.base_colbox[4] * .5,
1000	1521	self.base_colbox[5] * .5,
1001		self.base_colbox[6] * .5,
	1522	self.base_colbox[6] * .5
1002	1523	},
1003	1524	selectionbox = {
1004	1525	self.base_selbox[1] * .5,

1006	1527	self.base_selbox[3] * .5,
1007	1528	self.base_selbox[4] * .5,
1008	1529	self.base_selbox[5] * .5,
1009		self.base_selbox[6] * .5,
	1530	self.base_selbox[6] * .5
1010	1531	},
1011	1532	})
1012	1533	-- tamed and owned by parents' owner

1015	1536	ent2.owner = self.owner
1016	1537	end, self, ent)
1017	1538
1018		num = 0
1019
1020	1539	break
1021	1540	end
1022	1541	end

1025	1544
1026	1545
1027	1546	-- find and replace what mob is looking for (grass, wheat etc.)
1028		local replace = function(self, pos)
	1547	function mob_class:replace(pos)
	1548
	1549	local vel = self.object:get_velocity()
	1550	if not vel then return end
1029	1551
1030	1552	if not mobs_griefing
1031	1553	or not self.replace_rate
1032	1554	or not self.replace_what
1033	1555	or self.child == true
1034		or self.object:get_velocity().y ~= 0
1035		or random(1, self.replace_rate) > 1 then
	1556	or vel.y ~= 0
	1557	or random(self.replace_rate) > 1 then
1036	1558	return
1037	1559	end
1038	1560

1055	1577
1056	1578	if #minetest.find_nodes_in_area(pos, pos, what) > 0 then
1057	1579
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
	1580	-- print("replace node = ".. minetest.get_node(pos).name, pos.y)
1063	1581
1064	1582	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
	1583
	1584	local oldnode = what or ""
	1585	local newnode = with
	1586
	1587	-- pass actual node name when using table or groups
	1588	if type(oldnode) == "table"
	1589	or oldnode:find("group:") then
	1590	oldnode = minetest.get_node(pos).name
	1591	end
	1592
	1593	if self:on_replace(pos, oldnode, newnode) == false then
	1594	return
	1595	end
	1596	end
	1597
	1598	minetest.set_node(pos, {name = with})
1078	1599	end
1079	1600	end
1080	1601
1081	1602
1082	1603	-- check if daytime and also if mob is docile during daylight hours
1083		local day_docile = function(self)
	1604	function mob_class:day_docile()
1084	1605
1085	1606	if self.docile_by_day == false then
1086	1607

1097	1618
1098	1619	local los_switcher = false
1099	1620	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)
	1621	local can_dig_drop = function(pos)
	1622
	1623	if minetest.is_protected(pos, "") then
	1624	return false
	1625	end
	1626
	1627	local node = node_ok(pos, "air").name
	1628	local ndef = minetest.registered_nodes[node]
	1629
	1630	if node ~= "ignore"
	1631	and ndef
	1632	and ndef.drawtype ~= "airlike"
	1633	and not ndef.groups.level
	1634	and not ndef.groups.unbreakable
	1635	and not ndef.groups.liquid then
	1636
	1637	local drops = minetest.get_node_drops(node)
	1638
	1639	for _, item in ipairs(drops) do
	1640
	1641	minetest.add_item({
	1642	x = pos.x - 0.5 + random(),
	1643	y = pos.y - 0.5 + random(),
	1644	z = pos.z - 0.5 + random()
	1645	}, item)
	1646	end
	1647
	1648	minetest.remove_node(pos)
	1649
	1650	return true
	1651	end
	1652
	1653	return false
	1654	end
	1655
	1656
	1657	local pathfinder_mod = minetest.get_modpath("pathfinder")
	1658	-- path finding and smart mob routine by rnd,
	1659	-- line_of_sight and other edits by Elkien3
	1660	function mob_class:smart_mobs(s, p, dist, dtime)
1103	1661
1104	1662	local s1 = self.path.lastpos
1105
1106		local target_pos = self.attack:get_pos()
	1663	local target_pos = p
	1664
1107	1665
1108	1666	-- is it becoming stuck?
1109	1667	if abs(s1.x - s.x) + abs(s1.z - s.z) < .5 then

1176	1734	end, self)
1177	1735	end
1178	1736
1179		if abs(vector.subtract(s,target_pos).y) > self.stepheight then
	1737	if abs(vsubtract(s,target_pos).y) > self.stepheight then
1180	1738
1181	1739	if height_switcher then
1182	1740	use_pathfind = true

1189	1747	end
1190	1748	end
1191	1749
	1750	-- lets try find a path, first take care of positions
	1751	-- since pathfinder is very sensitive
1192	1752	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	1753
1197	1754	-- round position to center of node to avoid stuck in walls
1198	1755	-- also adjust height for player models!
1199	1756	s.x = floor(s.x + 0.5)
1200		-- s.y = floor(s.y + 0.5) - sheight
1201	1757	s.z = floor(s.z + 0.5)
1202	1758
1203	1759	local ssight, sground = minetest.line_of_sight(s, {

1215	1771	p1.z = floor(p1.z + 0.5)
1216	1772
1217	1773	local dropheight = 6
	1774
1218	1775	if self.fear_height ~= 0 then dropheight = self.fear_height end
1219	1776
1220		self.path.way = minetest.find_path(s, p1, 16, self.stepheight, dropheight, "Dijkstra")
1221
	1777	local jumpheight = 0
	1778
	1779	if self.jump and self.jump_height >= 4 then
	1780	jumpheight = min(ceil(self.jump_height / 4), 4)
	1781
	1782	elseif self.stepheight > 0.5 then
	1783	jumpheight = 1
	1784	end
	1785
	1786	if pathfinder_mod then
	1787	self.path.way = pathfinder.find_path(s, p1, self, dtime)
	1788	else
	1789	self.path.way = minetest.find_path(s, p1, 16, jumpheight,
	1790	dropheight, "Dijkstra")
	1791	end
1222	1792	--[[
1223	1793	-- show path using particles
1224	1794	if self.path.way and #self.path.way > 0 then
1225		print ("-- path length:" .. tonumber(#self.path.way))
	1795
	1796	print("-- path length:" .. tonumber(#self.path.way))
	1797
1226	1798	for _,pos in pairs(self.path.way) do
1227	1799	minetest.add_particle({
1228	1800	pos = pos,

1239	1811	]]
1240	1812
1241	1813	self.state = ""
1242		do_attack(self, self.attack)
	1814
	1815	if self.attack then
	1816	self:do_attack(self.attack)
	1817	end
1243	1818
1244	1819	-- no path found, try something else
1245	1820	if not self.path.way then

1249	1824	-- lets make way by digging/building if not accessible
1250	1825	if self.pathfinding == 2 and mobs_griefing then
1251	1826
1252		-- is player higher than mob?
1253		if s.y < p1.y then
	1827	-- is player more than 1 block higher than mob?
	1828	if p1.y > (s.y + 1) then
1254	1829
1255	1830	-- build upwards
1256	1831	if not minetest.is_protected(s, "") then

1258	1833	local ndef1 = minetest.registered_nodes[self.standing_in]
1259	1834
1260	1835	if ndef1 and (ndef1.buildable_to or ndef1.groups.liquid) then
1261
1262		minetest.set_node(s, {name = mobs.fallback_node})
	1836	minetest.set_node(s, {name = mobs.fallback_node})
1263	1837	end
1264	1838	end
1265	1839
1266		local sheight = math.ceil(self.collisionbox[5]) + 1
	1840	local sheight = ceil(self.collisionbox[5]) + 1
1267	1841
1268	1842	-- assume mob is 2 blocks high so it digs above its head
1269	1843	s.y = s.y + sheight
1270	1844
1271	1845	-- 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
	1846	can_dig_drop(s)
1289	1847
1290	1848	s.y = s.y - sheight
1291	1849	self.object:set_pos({x = s.x, y = s.y + 2, z = s.z})
	1850
	1851	-- is player more than 1 block lower than mob
	1852	elseif p1.y < (s.y - 1) then
	1853
	1854	-- dig down
	1855	s.y = s.y - self.collisionbox[4] - 0.2
	1856
	1857	can_dig_drop(s)
1292	1858
1293	1859	else -- dig 2 blocks to make door toward player direction
1294	1860

1299	1865	z = s.z + sin(yaw1)
1300	1866	}
1301	1867
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
	1868	-- dig bottom node first incase of door
	1869	can_dig_drop(p1)
	1870
	1871	p1.y = p1.y + 1
	1872
	1873	can_dig_drop(p1)
1334	1874	end
1335	1875	end
1336	1876
1337	1877	-- will try again in 2 second
1338	1878	self.path.stuck_timer = stuck_timeout - 2
1339	1879
1340		-- frustration! cant find the damn path :(
1341		mob_sound(self, self.sounds.random)
	1880	elseif s.y < p1.y and (not self.fly) then
	1881	self:do_jump() --add jump to pathfinding
	1882	self.path.following = true
1342	1883	else
1343	1884	-- yay i found path
1344		mob_sound(self, self.sounds.war_cry)
1345		set_velocity(self, self.walk_velocity)
	1885	if self.attack then
	1886	self:mob_sound(self.sounds.war_cry)
	1887	else
	1888	self:mob_sound(self.sounds.random)
	1889	end
	1890
	1891	self:set_velocity(self.walk_velocity)
1346	1892
1347	1893	-- follow path now that it has it
1348	1894	self.path.following = true

1351	1897	end
1352	1898
1353	1899
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
	1900	-- peaceful player privilege support
	1901	local function is_peaceful_player(player)
	1902
	1903	if peaceful_player_enabled then
	1904
	1905	local player_name = player:get_player_name()
	1906
	1907	if player_name
	1908	and minetest.check_player_privs(player_name, "peaceful_player") then
1366	1909	return true
1367	1910	end
1368	1911	end

1371	1914	end
1372	1915
1373	1916
1374		-- general attack function for all mobs ==========
1375		local general_attack = function(self)
	1917	-- general attack function for all mobs
	1918	function mob_class:general_attack()
1376	1919
1377	1920	-- return if already attacking, passive or docile during day
1378	1921	if self.passive
	1922	or self.state == "runaway"
1379	1923	or self.state == "attack"
1380		or day_docile(self) then
	1924	or self:day_docile() then
1381	1925	return
1382	1926	end
1383	1927
1384		local s = self.object:get_pos()
	1928	local s = self.object:get_pos() ; if not s then return end
1385	1929	local objs = minetest.get_objects_inside_radius(s, self.view_range)
1386	1930
1387	1931	-- remove entities we aren't interested in

1392	1936	-- are we a player?
1393	1937	if objs[n]:is_player() then
1394	1938
1395		-- if player invisible or mob not setup to attack then remove from list
1396		if self.attack_players == false
	1939	-- if player invisible or mob cannot attack then remove from list
	1940	if not damage_enabled
	1941	or self.attack_players == false
1397	1942	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
	1943	or is_invisible(self, objs[n]:get_player_name())
	1944	or (self.specific_attack
	1945	and not check_for("player", self.specific_attack)) then
1400	1946	objs[n] = nil
1401	1947	--print("- pla", n)
1402	1948	end

1409	1955	or (not self.attack_animals and ent.type == "animal")
1410	1956	or (not self.attack_monsters and ent.type == "monster")
1411	1957	or (not self.attack_npcs and ent.type == "npc")
1412		or not specific_attack(self.specific_attack, ent.name) then
	1958	or (self.specific_attack
	1959	and not check_for(ent.name, self.specific_attack)) then
1413	1960	objs[n] = nil
1414	1961	--print("- mob", n, self.name, ent.name)
1415	1962	end

1439	1986	-- choose closest player to attack that isnt self
1440	1987	if dist ~= 0
1441	1988	and dist < min_dist
1442		and line_of_sight(self, sp, p, 2) == true then
	1989	and self:line_of_sight(sp, p, 2) == true
	1990	and not is_peaceful_player(player) then
1443	1991	min_dist = dist
1444	1992	min_player = player
1445	1993	end
1446	1994	end
1447	1995
1448	1996	-- 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
	1997	if min_player and random(100) > self.attack_chance then
	1998	self:do_attack(min_player)
	1999	end
1472	2000	end
1473	2001
1474	2002
1475	2003	-- find someone to runaway from
1476		local runaway_from = function(self)
	2004	function mob_class:do_runaway_from()
1477	2005
1478	2006	if not self.runaway_from then
1479	2007	return
1480	2008	end
1481	2009
1482		local s = self.object:get_pos()
	2010	local s = self.object:get_pos() ; if not s then return end
1483	2011	local p, sp, dist, pname
1484	2012	local player, obj, min_player, name
1485	2013	local min_dist = self.view_range + 1

1491	2019
1492	2020	pname = objs[n]:get_player_name()
1493	2021
1494		if mobs.invis[pname]
	2022	if is_invisible(self, pname)
1495	2023	or self.owner == pname then
1496	2024
1497	2025	name = ""

1510	2038
1511	2039	-- find specific mob to runaway from
1512	2040	if name ~= "" and name ~= self.name
1513		and specific_runaway(self.runaway_from, name) then
1514
1515		p = player:get_pos()
	2041	and (self.runaway_from and check_for(name, self.runaway_from)) then
	2042
1516	2043	sp = s
	2044	p = player and player:get_pos() or s
1517	2045
1518	2046	-- aim higher to make looking up hills more realistic
1519	2047	p.y = p.y + 1

1523	2051
1524	2052	-- choose closest player/mob to runaway from
1525	2053	if dist < min_dist
1526		and line_of_sight(self, sp, p, 2) == true then
	2054	and self:line_of_sight(sp, p, 2) == true then
1527	2055	min_dist = dist
1528	2056	min_player = player
1529	2057	end

1532	2060
1533	2061	if min_player then
1534	2062
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)
	2063	yaw_to_pos(self, min_player:get_pos(), 3)
	2064
1549	2065	self.state = "runaway"
1550	2066	self.runaway_timer = 3
1551	2067	self.following = nil

1554	2070
1555	2071
1556	2072	-- follow player if owner or holding item, if fish outta water then flop
1557		local follow_flop = function(self)
	2073	function mob_class:follow_flop()
1558	2074
1559	2075	-- find player to follow
1560		if (self.follow ~= ""
1561		or self.order == "follow")
	2076	if (self.follow ~= "" or self.order == "follow")
1562	2077	and not self.following
1563	2078	and self.state ~= "attack"
1564	2079	and self.state ~= "runaway" then
1565	2080
1566		local s = self.object:get_pos()
	2081	local s = self.object:get_pos() ; if not s then return end
1567	2082	local players = minetest.get_connected_players()
1568	2083
1569	2084	for n = 1, #players do
1570	2085
1571	2086	if get_distance(players[n]:get_pos(), s) < self.view_range
1572		and not mobs.invis[ players[n]:get_player_name() ] then
	2087	and not is_invisible(self, players[n]:get_player_name()) then
1573	2088
1574	2089	self.following = players[n]
1575	2090

1590	2105	self.following = nil
1591	2106	end
1592	2107	else
1593		-- stop following player if not holding specific item
	2108	-- stop following player if not holding specific item or mob is horny
1594	2109	if self.following
1595	2110	and self.following:is_player()
1596		and follow_holding(self, self.following) == false then
	2111	and (self:follow_holding(self.following) == false
	2112	or self.horny) then
1597	2113	self.following = nil
1598	2114	end
1599	2115

1622	2138	if dist > self.view_range then
1623	2139	self.following = nil
1624	2140	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)
	2141	yaw_to_pos(self, p)
1635	2142
1636	2143	-- anyone but standing npc's can move along
1637	2144	if dist > self.reach
1638	2145	and self.order ~= "stand" then
1639	2146
1640		set_velocity(self, self.walk_velocity)
	2147	self:set_velocity(self.walk_velocity)
1641	2148
1642	2149	if self.walk_chance ~= 0 then
1643		set_animation(self, "walk")
	2150	self:set_animation("walk")
1644	2151	end
1645	2152	else
1646		set_velocity(self, 0)
1647		set_animation(self, "stand")
	2153	self:set_velocity(0)
	2154	self:set_animation("stand")
1648	2155	end
1649	2156
1650	2157	return

1654	2161
1655	2162	-- swimmers flop when out of their element, and swim again when back in
1656	2163	if self.fly then
1657		local s = self.object:get_pos()
1658		if not flight_check(self, s) then
	2164
	2165	if not self:attempt_flight_correction() then
1659	2166
1660	2167	self.state = "flop"
	2168
	2169	-- do we have a custom on_flop function?
	2170	if self.on_flop then
	2171
	2172	if self:on_flop(self) then
	2173	return
	2174	end
	2175	end
	2176
1661	2177	self.object:set_velocity({x = 0, y = -5, z = 0})
1662	2178
1663		set_animation(self, "stand")
	2179	self:set_animation("stand")
1664	2180
1665	2181	return
	2182
1666	2183	elseif self.state == "flop" then
1667	2184	self.state = "stand"
1668	2185	end

1671	2188
1672	2189
1673	2190	-- dogshoot attack switch and counter function
1674		local dogswitch = function(self, dtime)
	2191	function mob_class:dogswitch(dtime)
1675	2192
1676	2193	-- switch mode not activated
1677	2194	if not self.dogshoot_switch

1700	2217
1701	2218
1702	2219	-- execute current state (stand, walk, run, attacks)
1703		local do_states = function(self, dtime)
1704
1705		local yaw = self.object:get_yaw() or 0
	2220	function mob_class:do_states(dtime)
	2221
	2222	local yaw = self.object:get_yaw() ; if not yaw then return end
1706	2223
1707	2224	if self.state == "stand" then
1708	2225
1709		if random(1, 4) == 1 then
1710
1711		local lp = nil
	2226	if self.randomly_turn and random(4) == 1 then
	2227
	2228	local lp
1712	2229	local s = self.object:get_pos()
1713	2230	local objs = minetest.get_objects_inside_radius(s, 3)
1714	2231

1722	2239
1723	2240	-- look at any players nearby, otherwise turn randomly
1724	2241	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
	2242	yaw = yaw_to_pos(self, lp)
1734	2243	else
1735	2244	yaw = yaw + random(-0.5, 0.5)
1736	2245	end
1737	2246
1738		yaw = set_yaw(self, yaw, 8)
1739		end
1740
1741		set_velocity(self, 0)
1742		set_animation(self, "stand")
	2247	yaw = self:set_yaw(yaw, 8)
	2248	end
	2249
	2250	self:set_velocity(0)
	2251	self:set_animation("stand")
1743	2252
1744	2253	-- mobs ordered to stand stay standing
1745	2254	if self.order ~= "stand"
1746	2255	and self.walk_chance ~= 0
1747	2256	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)
	2257	and random(100) <= self.walk_chance
	2258	and self.at_cliff == false then
	2259
	2260	self:set_velocity(self.walk_velocity)
1752	2261	self.state = "walk"
1753		set_animation(self, "walk")
	2262	self:set_animation("walk")
1754	2263	end
1755	2264
1756	2265	elseif self.state == "walk" then
1757	2266
1758	2267	local s = self.object:get_pos()
1759		local lp = nil
	2268	local lp
1760	2269
1761	2270	-- is there something I need to avoid?
1762	2271	if self.water_damage > 0
1763	2272	and self.lava_damage > 0 then
1764	2273
1765		lp = minetest.find_node_near(s, 1, {"group:water", "group:lava"})
	2274	lp = minetest.find_node_near(s, 1, {"group:water", "group:igniter"})
1766	2275
1767	2276	elseif self.water_damage > 0 then
1768	2277

1770	2279
1771	2280	elseif self.lava_damage > 0 then
1772	2281
1773		lp = minetest.find_node_near(s, 1, {"group:lava"})
	2282	lp = minetest.find_node_near(s, 1, {"group:igniter"})
1774	2283	end
1775	2284
1776	2285	if lp then
1777	2286
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})
	2287	-- if mob in dangerous node then look for land
	2288	if not is_node_dangerous(self, self.standing_in) then
	2289
	2290	lp = minetest.find_nodes_in_area_under_air(
	2291	{s.x - 5, s.y - 1, s.z - 5},
	2292	{s.x + 5, s.y + 2, s.z + 5},
	2293	{"group:soil", "group:stone", "group:sand",
	2294	node_ice, node_snowblock})
	2295
	2296	-- select position of random block to climb onto
	2297	lp = #lp > 0 and lp[random(#lp)]
1786	2298
1787	2299	-- did we find land?
1788	2300	if lp then
1789	2301
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)
	2302	yaw = yaw_to_pos(self, lp)
	2303
	2304	self:do_jump()
	2305	self:set_velocity(self.walk_velocity)
1803	2306	else
1804	2307	yaw = yaw + random(-0.5, 0.5)
1805	2308	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)
	2309	end
	2310
	2311	yaw = self:set_yaw(yaw, 8)
1820	2312
1821	2313	-- otherwise randomly turn
1822		elseif random(1, 100) <= 30 then
	2314	elseif self.randomly_turn and random(100) <= 30 then
1823	2315
1824	2316	yaw = yaw + random(-0.5, 0.5)
1825	2317
1826		yaw = set_yaw(self, yaw, 8)
	2318	yaw = self:set_yaw(yaw, 8)
	2319
	2320	-- for flying/swimming mobs randomly move up and down also
	2321	if self.fly_in
	2322	and not self.following then
	2323	self:attempt_flight_correction(true)
	2324	end
1827	2325	end
1828	2326
1829	2327	-- stand for great fall in front
1830		local temp_is_cliff = is_at_cliff(self)
1831
1832	2328	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")
	2329	or self.at_cliff
	2330	or random(100) <= self.stand_chance then
	2331
	2332	-- don't stand if mob flies and keep_flying set
	2333	if (self.fly and not self.keep_flying)
	2334	or not self.fly then
	2335
	2336	self:set_velocity(0)
	2337	self.state = "stand"
	2338	self:set_animation("stand", true)
	2339	end
1839	2340	else
1840		set_velocity(self, self.walk_velocity)
1841
1842		if flight_check(self)
	2341	self:set_velocity(self.walk_velocity)
	2342
	2343	if self:flight_check()
1843	2344	and self.animation
1844	2345	and self.animation.fly_start
1845	2346	and self.animation.fly_end then
1846		set_animation(self, "fly")
	2347	self:set_animation("fly")
1847	2348	else
1848		set_animation(self, "walk")
	2349	self:set_animation("walk")
1849	2350	end
1850	2351	end
1851	2352

1856	2357
1857	2358	-- stop after 5 seconds or when at cliff
1858	2359	if self.runaway_timer > 5
1859		or is_at_cliff(self)
	2360	or self.at_cliff
1860	2361	or self.order == "stand" then
1861	2362	self.runaway_timer = 0
1862		set_velocity(self, 0)
	2363	self:set_velocity(0)
1863	2364	self.state = "stand"
1864		set_animation(self, "stand")
	2365	self:set_animation("stand")
1865	2366	else
1866		set_velocity(self, self.run_velocity)
1867		set_animation(self, "walk")
	2367	self:set_velocity(self.run_velocity)
	2368	self:set_animation("walk")
1868	2369	end
1869	2370
1870	2371	-- attack routines (explode, dogfight, shoot, dogshoot)
1871	2372	elseif self.state == "attack" then
1872	2373
1873		-- calculate distance from mob and enemy
	2374	-- get mob and enemy positions and distance between
1874	2375	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
	2376	local p = self.attack and self.attack:get_pos()
	2377	local dist = p and get_distance(p, s) or 500
	2378
	2379	-- stop attacking if player out of range or invisible
1879	2380	if dist > self.view_range
1880	2381	or not self.attack
1881	2382	or not self.attack:get_pos()
1882	2383	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)
	2384	or (self.attack:is_player()
	2385	and is_invisible(self, self.attack:get_player_name())) then
	2386
	2387	--print(" stop attacking ", dist, self.view_range)
	2388
1886	2389	self.state = "stand"
1887		set_velocity(self, 0)
1888		set_animation(self, "stand")
	2390	self:set_velocity(0)
	2391	self:set_animation("stand")
1889	2392	self.attack = nil
1890	2393	self.v_start = false
1891	2394	self.timer = 0

1897	2400
1898	2401	if self.attack_type == "explode" then
1899	2402
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)
	2403	yaw = yaw_to_pos(self, p)
1910	2404
1911	2405	local node_break_radius = self.explosion_radius or 1
1912	2406	local entity_damage_radius = self.explosion_damage_radius
1913	2407	or (node_break_radius * 2)
1914	2408
	2409	-- look a little higher to fix raycast
	2410	s.y = s.y + 0.5 ; p.y = p.y + 0.5
	2411
1915	2412	-- start timer when in reach and line of sight
1916	2413	if not self.v_start
1917	2414	and dist <= self.reach
1918		and line_of_sight(self, s, p, 2) then
	2415	and self:line_of_sight(s, p, 2) then
1919	2416
1920	2417	self.v_start = true
1921	2418	self.timer = 0
1922	2419	self.blinktimer = 0
1923		mob_sound(self, self.sounds.fuse)
1924		-- print ("=== explosion timer started", self.explosion_timer)
	2420	self:mob_sound(self.sounds.fuse)
	2421
	2422	--print("=== explosion timer started", self.explosion_timer)
1925	2423
1926	2424	-- stop timer if out of reach or direct line of sight
1927	2425	elseif self.allow_fuse_reset
1928	2426	and self.v_start
1929		and (dist > self.reach
1930		or not line_of_sight(self, s, p, 2)) then
	2427	and (dist > self.reach or not self:line_of_sight(s, p, 2)) then
	2428
	2429	--print("=== explosion timer stopped")
	2430
1931	2431	self.v_start = false
1932	2432	self.timer = 0
1933	2433	self.blinktimer = 0
1934	2434	self.blinkstatus = false
1935		self.object:settexturemod("")
	2435	self.object:set_texture_mod("")
1936	2436	end
1937	2437
1938	2438	-- walk right up to player unless the timer is active
1939	2439	if self.v_start and (self.stop_to_explode or dist < 1.5) then
1940		set_velocity(self, 0)
	2440	self:set_velocity(0)
1941	2441	else
1942		set_velocity(self, self.run_velocity)
	2442	self:set_velocity(self.run_velocity)
1943	2443	end
1944	2444
1945	2445	if self.animation and self.animation.run_start then
1946		set_animation(self, "run")
	2446	self:set_animation("run")
1947	2447	else
1948		set_animation(self, "walk")
	2448	self:set_animation("walk")
1949	2449	end
1950	2450
1951	2451	if self.v_start then

1958	2458	self.blinktimer = 0
1959	2459
1960	2460	if self.blinkstatus then
1961		self.object:settexturemod("")
	2461
	2462	self.object:set_texture_mod(self.texture_mods)
1962	2463	else
1963		self.object:settexturemod("^[brighten")
	2464
	2465	self.object:set_texture_mod(self.texture_mods
	2466	.. "^[brighten")
1964	2467	end
1965	2468
1966	2469	self.blinkstatus = not self.blinkstatus
1967	2470	end
1968	2471
1969		-- print ("=== explosion timer", self.timer)
	2472	--print("=== explosion timer", self.timer)
1970	2473
1971	2474	if self.timer > self.explosion_timer then
1972	2475

1979	2482	node_break_radius = 1
1980	2483	end
1981	2484
1982		self.object:remove()
	2485	remove_mob(self, true)
1983	2486
1984	2487	if minetest.get_modpath("tnt") and tnt and tnt.boom
1985	2488	and not minetest.is_protected(pos, "") then

1987	2490	tnt.boom(pos, {
1988	2491	radius = node_break_radius,
1989	2492	damage_radius = entity_damage_radius,
1990		sound = self.sounds.explode,
	2493	sound = self.sounds.explode
1991	2494	})
1992	2495	else
1993	2496

1998	2501	})
1999	2502
2000	2503	entity_physics(pos, entity_damage_radius)
2001		effect(pos, 32, "tnt_smoke.png", nil, nil, node_break_radius, 1, 0)
	2504
	2505	effect(pos, 32, "tnt_smoke.png", nil, nil,
	2506	node_break_radius, 1, 0)
2002	2507	end
2003	2508
2004		return
	2509	return true
2005	2510	end
2006	2511	end
2007	2512
2008	2513	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
	2514	or (self.attack_type == "dogshoot" and self:dogswitch(dtime) == 2)
	2515	or (self.attack_type == "dogshoot" and dist <= self.reach
	2516	and self:dogswitch() == 0) then
2011	2517
2012	2518	if self.fly
2013	2519	and dist > self.reach then

2018	2524	local p_y = floor(p2.y + 1)
2019	2525	local v = self.object:get_velocity()
2020	2526
2021		if flight_check(self, s) then
	2527	if self:flight_check() then
2022	2528
2023	2529	if me_y < p_y then
2024	2530

2054	2560	})
2055	2561	end
2056	2562	end
2057
2058	2563	end
2059	2564
2060	2565	-- rnd: new movement direction

2076	2581	return
2077	2582	end
2078	2583
2079		if abs(p1.x-s.x) + abs(p1.z - s.z) < 0.6 then
	2584	if abs(p1.x - s.x) + abs(p1.z - s.z) < 0.6 then
2080	2585	-- reached waypoint, remove it from queue
2081		table.remove(self.path.way, 1)
	2586	table_remove(self.path.way, 1)
2082	2587	end
2083	2588
2084	2589	-- set new temporary target
2085	2590	p = {x = p1.x, y = p1.y, z = p1.z}
2086	2591	end
2087	2592
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)
	2593	yaw = yaw_to_pos(self, p)
2098	2594
2099	2595	-- move towards enemy if beyond mob reach
2100	2596	if dist > self.reach then

2103	2599	if self.pathfinding -- only if mob has pathfinding enabled
2104	2600	and enable_pathfinding then
2105	2601
2106		smart_mobs(self, s, p, dist, dtime)
	2602	self:smart_mobs(s, p, dist, dtime)
2107	2603	end
2108	2604
2109		if is_at_cliff(self) then
2110
2111		set_velocity(self, 0)
2112		set_animation(self, "stand")
	2605	-- distance padding to stop spinning mob
	2606	local pad = abs(p.x - s.x) + abs(p.z - s.z)
	2607
	2608	if self.at_cliff or pad < 0.2 then
	2609
	2610	self:set_velocity(0)
	2611	self:set_animation("stand")
2113	2612	else
2114	2613
2115	2614	if self.path.stuck then
2116		set_velocity(self, self.walk_velocity)
	2615	self:set_velocity(self.walk_velocity)
2117	2616	else
2118		set_velocity(self, self.run_velocity)
	2617	self:set_velocity(self.run_velocity)
2119	2618	end
2120	2619
2121	2620	if self.animation and self.animation.run_start then
2122		set_animation(self, "run")
	2621	self:set_animation("run")
2123	2622	else
2124		set_animation(self, "walk")
	2623	self:set_animation("walk")
2125	2624	end
2126	2625	end
2127
2128	2626	else -- rnd: if inside reach range
2129	2627
2130	2628	self.path.stuck = false
2131	2629	self.path.stuck_timer = 0
2132	2630	self.path.following = false -- not stuck anymore
2133	2631
2134		set_velocity(self, 0)
2135
2136		if not self.custom_attack then
2137
2138		if self.timer > 1 then
	2632	self:set_velocity(0)
	2633
	2634	if self.timer > 1 then
	2635
	2636	-- no custom attack or custom attack returns true to continue
	2637	if not self.custom_attack
	2638	or self:custom_attack(self, p) == true then
2139	2639
2140	2640	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
	2641	self:set_animation("punch")
2148	2642
2149	2643	local p2 = p
2150	2644	local s2 = s

2152	2646	p2.y = p2.y + .5
2153	2647	s2.y = s2.y + .5
2154	2648
2155		if line_of_sight(self, p2, s2) == true then
	2649	if self:line_of_sight(p2, s2) == true then
2156	2650
2157	2651	-- play attack sound
2158		mob_sound(self, self.sounds.attack)
	2652	self:mob_sound(self.sounds.attack)
2159	2653
2160	2654	-- punch player (or what player is attached to)
2161	2655	local attached = self.attack:get_attach()
	2656
2162	2657	if attached then
2163	2658	self.attack = attached
2164	2659	end
	2660
	2661	local dgroup = self.damage_group or "fleshy"
	2662
2165	2663	self.attack:punch(self.object, 1.0, {
2166	2664	full_punch_interval = 1.0,
2167		damage_groups = {fleshy = self.damage}
	2665	damage_groups = {[dgroup] = self.damage}
2168	2666	}, nil)
2169	2667	end
2170	2668	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	2669	end
2180	2670	end
2181	2671
2182	2672	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
	2673	or (self.attack_type == "dogshoot" and self:dogswitch(dtime) == 1)
	2674	or (self.attack_type == "dogshoot" and dist > self.reach and
	2675	self:dogswitch() == 0) then
2185	2676
2186	2677	p.y = p.y - .5
2187	2678	s.y = s.y + .5
2188	2679
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)
	2680	local vec = {x = p.x - s.x, y = p.y - s.y, z = p.z - s.z}
	2681
	2682	yaw = yaw_to_pos(self, p)
	2683
	2684	self:set_velocity(0)
2203	2685
2204	2686	if self.shoot_interval
2205	2687	and self.timer > self.shoot_interval
2206		and random(1, 100) <= 60 then
	2688	and random(100) <= 60 then
2207	2689
2208	2690	self.timer = 0
2209		set_animation(self, "shoot")
	2691	self:set_animation("shoot")
2210	2692
2211	2693	-- play shoot attack sound
2212		mob_sound(self, self.sounds.shoot_attack)
	2694	self:mob_sound(self.sounds.shoot_attack)
2213	2695
2214	2696	local p = self.object:get_pos()
2215	2697

2240	2722
2241	2723
2242	2724	-- falling and fall damage
2243		local falling = function(self, pos)
2244
2245		if self.fly then
	2725	function mob_class:falling(pos)
	2726
	2727	if self.fly or self.disable_falling then
2246	2728	return
2247	2729	end
2248	2730
2249	2731	-- floating in water (or falling)
2250	2732	local v = self.object:get_velocity()
2251	2733
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
	2734	-- sanity check
	2735	if not v then return end
	2736
	2737	local fall_speed = self.fall_speed
	2738
	2739	-- in water then use liquid viscosity for float/sink speed
	2740	if self.floats == 1 and self.standing_in
	2741	and minetest.registered_nodes[self.standing_in].groups.liquid then
	2742
	2743	local visc = min(
	2744	minetest.registered_nodes[self.standing_in].liquid_viscosity, 7) + 1
	2745
	2746	self.object:set_velocity({x = v.x, y = 0.6, z = v.z})
	2747	fall_speed = -1.2 / visc
2286	2748	else
2287	2749
2288	2750	-- fall damage onto solid ground

2297	2759
2298	2760	effect(pos, 5, "tnt_smoke.png", 1, 2, 2, nil)
2299	2761
2300		if check_for_death(self, {type = "fall"}) then
2301		return
	2762	if self:check_for_death({type = "fall"}) then
	2763	return true
2302	2764	end
2303	2765	end
2304	2766
2305	2767	self.old_y = self.object:get_pos().y
2306	2768	end
2307	2769	end
	2770
	2771	-- fall at set speed
	2772	self.object:set_acceleration({x = 0, y = fall_speed, z = 0})
2308	2773	end
2309	2774
2310	2775

2312	2777	local tr = minetest.get_modpath("toolranks")
2313	2778
2314	2779	-- deal damage and effects when mob punched
2315		local mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
	2780	function mob_class:on_punch(hitter, tflp, tool_capabilities, dir, damage)
2316	2781
2317	2782	-- mob health check
2318	2783	if self.health <= 0 then
2319		return
	2784	return true
2320	2785	end
2321	2786
2322	2787	-- custom punch function
2323	2788	if self.do_punch
2324		and self.do_punch(self, hitter, tflp, tool_capabilities, dir) == false then
2325		return
	2789	and self:do_punch(hitter, tflp, tool_capabilities, dir) == false then
	2790	return true
2326	2791	end
2327	2792
2328	2793	-- error checking when mod profiling is enabled
2329	2794	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
	2795
	2796	minetest.log("warning", "[mobs] Mod profiling enabled, damage not enabled")
	2797
	2798	return true
	2799	end
	2800
	2801	-- is mob protected
	2802	if self.protected then
	2803
	2804	-- did player hit mob and if so is it in protected area
	2805	if hitter:is_player() then
	2806
	2807	local player_name = hitter:get_player_name()
	2808
	2809	if player_name ~= self.owner
	2810	and minetest.is_protected(self.object:get_pos(), player_name) then
	2811
	2812	minetest.chat_send_player(hitter:get_player_name(),
	2813	S("Mob has been protected!"))
	2814
	2815	return true
	2816	end
	2817
	2818	-- if protection is on level 2 then dont let arrows harm mobs
	2819	elseif self.protected == 2 then
	2820
	2821	local ent = hitter and hitter:get_luaentity()
	2822
	2823	if ent and ent._is_arrow then
	2824
	2825	return true -- arrow entity
	2826
	2827	elseif not ent then
	2828
	2829	return true -- non entity
	2830	end
	2831	end
2339	2832	end
2340	2833
2341	2834	local weapon = hitter:get_wielded_item()

2367	2860	end
2368	2861
2369	2862	damage = damage + (tool_capabilities.damage_groups[group] or 0)
2370		* tmp * ((armor[group] or 0) / 100.0)
	2863	* tmp * ((armor[group] or 0) / 100.0)
2371	2864	end
2372	2865	end
2373	2866

2377	2870	if self.immune_to[n][1] == weapon_def.name then
2378	2871
2379	2872	damage = self.immune_to[n][2] or 0
	2873
2380	2874	break
2381	2875
2382		-- if "all" then no tool does damage unless it's specified in list
	2876	-- if "all" then no tools deal damage unless it's specified in list
2383	2877	elseif self.immune_to[n][1] == "all" then
2384	2878	damage = self.immune_to[n][2] or 0
2385	2879	end
2386	2880	end
2387	2881
	2882	--print("Mob Damage is", damage)
	2883
2388	2884	-- healing
2389	2885	if damage <= -1 then
	2886
2390	2887	self.health = self.health - floor(damage)
2391		return
2392		end
2393
2394		-- print ("Mob Damage is", damage)
	2888
	2889	return true
	2890	end
2395	2891
2396	2892	if use_cmi
2397	2893	and cmi.notify_punch(self.object, hitter, tflp, tool_capabilities, dir, damage) then
2398		return
	2894	return true
2399	2895	end
2400	2896
2401	2897	-- add weapon wear

2413	2909	end
2414	2910	end
2415	2911
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
	2912	if tr and weapon_def.original_description then
	2913	toolranks.new_afteruse(weapon, hitter, nil, {wear = wear})
2420	2914	else
2421	2915	weapon:add_wear(wear)
2422	2916	end

2426	2920	-- only play hit sound and show blood effects if damage is 1 or over
2427	2921	if damage >= 1 then
2428	2922
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
	2923	-- select tool use sound if found, or fallback to default
	2924	local snd = weapon_def.sound and weapon_def.sound.use
	2925	or "default_punch"
	2926
	2927	minetest.sound_play(snd, {object = self.object, max_hear_distance = 8}, true)
2444	2928
2445	2929	-- blood_particles
2446	2930	if not disable_blood and self.blood_amount > 0 then
2447	2931
2448	2932	local pos = self.object:get_pos()
	2933	local blood = self.blood_texture
	2934	local amount = self.blood_amount
2449	2935
2450	2936	pos.y = pos.y + (-self.collisionbox[2] + self.collisionbox[5]) * .5
	2937
	2938	-- lots of damage = more blood :)
	2939	if damage > 10 then
	2940	amount = self.blood_amount * 2
	2941	end
2451	2942
2452	2943	-- do we have a single blood texture or multiple?
2453	2944	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
	2945	blood = self.blood_texture[random(#self.blood_texture)]
	2946	end
	2947
	2948	effect(pos, amount, blood, 1, 2, 1.75, nil, nil, true)
2461	2949	end
2462	2950
2463	2951	-- do damage

2467	2955	local hot = tool_capabilities and tool_capabilities.damage_groups
2468	2956	and tool_capabilities.damage_groups.fire
2469	2957
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
	2958	if self:check_for_death({type = "punch", puncher = hitter, hot = hot}) then
	2959	return true
	2960	end
2487	2961	end -- END if damage
2488	2962
2489	2963	-- knock back effect (only on full punch)
2490		if self.knock_back
2491		and tflp >= punch_interval then
	2964	if self.knock_back and tflp >= punch_interval then
2492	2965
2493	2966	local v = self.object:get_velocity()
	2967
	2968	-- sanity check
	2969	if not v then return true end
	2970
2494	2971	local kb = damage or 1
2495	2972	local up = 2
2496	2973

2504	2981	dir = dir or {x = 0, y = 0, z = 0}
2505	2982
2506	2983	-- 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		})
	2984	kb = tool_capabilities.damage_groups["knockback"] or kb
	2985
	2986	self.object:set_velocity({x = dir.x * kb, y = up, z = dir.z * kb})
2514	2987
2515	2988	self.pause_timer = 0.25
2516	2989	end

2520	2993	and self.order ~= "stand" then
2521	2994
2522	2995	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)
	2996	local yaw = yaw_to_pos(self, lp, 3)
	2997
2537	2998	self.state = "runaway"
2538	2999	self.runaway_timer = 0
2539	3000	self.following = nil

2547	3008	and self.child == false
2548	3009	and self.attack_players == true
2549	3010	and hitter:get_player_name() ~= self.owner
2550		and not mobs.invis[ name ] then
	3011	and not is_invisible(self, name)
	3012	and self.object ~= hitter then
2551	3013
2552	3014	-- attack whoever punched mob
2553	3015	self.state = ""
2554		do_attack(self, hitter)
	3016	self:do_attack(hitter)
2555	3017
2556	3018	-- alert others to the attack
2557		local objs = minetest.get_objects_inside_radius(hitter:get_pos(), self.view_range)
2558		local obj = nil
	3019	local objs = minetest.get_objects_inside_radius(
	3020	hitter:get_pos(), self.view_range)
	3021	local obj
2559	3022
2560	3023	for n = 1, #objs do
2561	3024

2563	3026
2564	3027	if obj and obj._cmi_is_mob then
2565	3028
2566		-- only alert members of same mob
	3029	-- only alert members of same mob and assigned helper
2567	3030	if obj.group_attack == true
2568	3031	and obj.state ~= "attack"
2569	3032	and obj.owner ~= name
2570		and obj.name == self.name then
2571		do_attack(obj, hitter)
	3033	and (obj.name == self.name
	3034	or obj.name == self.group_helper) then
	3035
	3036	obj:do_attack(hitter)
2572	3037	end
2573	3038
2574	3039	-- have owned mobs attack player threat
2575	3040	if obj.owner == name and obj.owner_loyal then
2576		do_attack(obj, self.object)
	3041	obj:do_attack(self.object)
2577	3042	end
2578	3043	end
2579	3044	end

2582	3047
2583	3048
2584	3049	-- get entity staticdata
2585		local mob_staticdata = function(self)
	3050	function mob_class:mob_staticdata()
	3051
	3052	-- this handles mob count for mobs activated, unloaded, reloaded
	3053	if active_limit > 0 and self.active_toggle then
	3054	active_mobs = active_mobs + self.active_toggle
	3055	self.active_toggle = -self.active_toggle
	3056	--print("-- staticdata", active_mobs, active_limit, self.active_toggle)
	3057	end
2586	3058
2587	3059	-- remove mob when out of range unless tamed
2588	3060	if remove_far

2592	3064	and not self.tamed
2593	3065	and self.lifetimer < 20000 then
2594	3066
2595		--print ("REMOVED " .. self.name)
2596
2597		self.object:remove()
2598
2599		return ""-- nil
	3067	--print("REMOVED " .. self.name)
	3068
	3069	remove_mob(self, true)
	3070
	3071	return minetest.serialize({remove_ok = true, static_save = true})
2600	3072	end
2601	3073
2602	3074	self.remove_ok = true

2605	3077	self.state = "stand"
2606	3078
2607	3079	-- used to rotate older mobs
2608		if self.drawtype
2609		and self.drawtype == "side" then
2610		self.rotate = math.rad(90)
	3080	if self.drawtype and self.drawtype == "side" then
	3081	self.rotate = rad(90)
2611	3082	end
2612	3083
2613	3084	if use_cmi then
2614		self.serialized_cmi_components = cmi.serialize_components(self._cmi_components)
2615		end
2616
2617		local tmp = {}
	3085	self.serialized_cmi_components = cmi.serialize_components(
	3086	self._cmi_components)
	3087	end
	3088
	3089	local tmp, t = {}
2618	3090
2619	3091	for _,stat in pairs(self) do
2620	3092
2621		local t = type(stat)
	3093	t = type(stat)
2622	3094
2623	3095	if t ~= "function"
2624	3096	and t ~= "nil"
2625	3097	and t ~= "userdata"
	3098	and _ ~= "object"
2626	3099	and _ ~= "_cmi_components" then
2627	3100	tmp[_] = self[_]
2628	3101	end
2629	3102	end
2630	3103
2631		--print('===== '..self.name..'\n'.. dump(tmp)..'\n=====\n')
	3104	--print('===== '..self.name..'\n'.. dump(tmp)..'\n=====\n')
	3105
2632	3106	return minetest.serialize(tmp)
2633	3107	end
2634	3108
2635	3109
2636	3110	-- activate mob and reload settings
2637		local mob_activate = function(self, staticdata, def, dtime)
	3111	function mob_class:mob_activate(staticdata, def, dtime)
	3112
	3113	-- if dtime == 0 then entity has just been created
	3114	-- anything higher means it is respawning (thanks SorceryKid)
	3115	if dtime == 0 and active_limit > 0 then
	3116	self.active_toggle = 1
	3117	end
	3118
	3119	-- remove mob if not tamed and mob total reached
	3120	if active_limit > 0 and active_mobs >= active_limit and not self.tamed then
	3121
	3122	remove_mob(self)
	3123	--print("-- mob limit reached, removing " .. self.name)
	3124	return
	3125	end
2638	3126
2639	3127	-- remove monsters in peaceful mode
2640		if self.type == "monster"
2641		and peaceful_only then
2642
2643		self.object:remove()
	3128	if self.type == "monster" and peaceful_only then
	3129
	3130	remove_mob(self, true)
2644	3131
2645	3132	return
2646	3133	end

2649	3136	local tmp = minetest.deserialize(staticdata)
2650	3137
2651	3138	if tmp then
	3139
	3140	local t
	3141
2652	3142	for _,stat in pairs(tmp) do
2653		self[_] = stat
2654		end
2655		end
	3143
	3144	t = type(stat)
	3145
	3146	if t ~= "function"
	3147	and t ~= "nil"
	3148	and t ~= "userdata" then
	3149	self[_] = stat
	3150	end
	3151	end
	3152	end
	3153
	3154	-- force current model into mob
	3155	self.mesh = def.mesh
	3156	self.base_mesh = def.mesh
	3157	self.collisionbox = def.collisionbox
	3158	self.selectionbox = def.selectionbox
2656	3159
2657	3160	-- select random texture, set model and size
2658	3161	if not self.base_texture then

2662	3165	def.textures = {def.textures}
2663	3166	end
2664	3167
2665		self.base_texture = def.textures and def.textures[random(1, #def.textures)]
	3168	self.base_texture = def.textures and def.textures[random(#def.textures)]
2666	3169	self.base_mesh = def.mesh
2667	3170	self.base_size = self.visual_size
2668	3171	self.base_colbox = self.collisionbox

2682	3185	local selbox = self.base_selbox
2683	3186
2684	3187	-- specific texture if gotten
2685		if self.gotten == true
2686		and def.gotten_texture then
	3188	if self.gotten == true and def.gotten_texture then
2687	3189	textures = def.gotten_texture
2688	3190	end
2689	3191
2690	3192	-- specific mesh if gotten
2691		if self.gotten == true
2692		and def.gotten_mesh then
	3193	if self.gotten == true and def.gotten_mesh then
2693	3194	mesh = def.gotten_mesh
2694	3195	end
2695	3196
2696	3197	-- set child objects to half size
2697	3198	if self.child == true then
2698	3199
2699		vis_size = {
2700		x = self.base_size.x * .5,
2701		y = self.base_size.y * .5,
2702		}
	3200	vis_size = {x = self.base_size.x * .5, y = self.base_size.y * .5}
2703	3201
2704	3202	if def.child_texture then
2705	3203	textures = def.child_texture[1]
2706	3204	end
2707	3205
2708	3206	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		}
	3207	self.base_colbox[1] * .5, self.base_colbox[2] * .5,
	3208	self.base_colbox[3] * .5, self.base_colbox[4] * .5,
	3209	self.base_colbox[5] * .5, self.base_colbox[6] * .5}
	3210
2716	3211	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		}
	3212	self.base_selbox[1] * .5, self.base_selbox[2] * .5,
	3213	self.base_selbox[3] * .5, self.base_selbox[4] * .5,
	3214	self.base_selbox[5] * .5, self.base_selbox[6] * .5}
2724	3215	end
2725	3216
2726	3217	if self.health == 0 then
2727		self.health = random (self.hp_min, self.hp_max)
	3218	self.health = random(self.hp_min, self.hp_max)
2728	3219	end
2729	3220
2730	3221	-- pathfinding init

2735	3226	self.path.following = false -- currently following path?
2736	3227	self.path.stuck_timer = 0 -- if stuck for too long search for path
2737	3228
	3229	-- Armor groups (immortal = 1 for custom damage handling)
	3230	local armor
	3231	if type(self.armor) == "table" then
	3232	armor = table_copy(self.armor)
	3233	else
	3234	armor = {fleshy = self.armor} -- immortal = 1
	3235	end
	3236	self.object:set_armor_groups(armor)
	3237
2738	3238	-- mob defaults
2739		self.object:set_armor_groups({immortal = 1, fleshy = self.armor})
2740	3239	self.old_y = self.object:get_pos().y
2741	3240	self.old_health = self.health
2742	3241	self.sounds.distance = self.sounds.distance or 10

2746	3245	self.selectionbox = selbox
2747	3246	self.visual_size = vis_size
2748	3247	self.standing_in = "air"
	3248	self.standing_on = "air"
2749	3249
2750	3250	-- check existing nametag
2751	3251	if not self.nametag then

2754	3254
2755	3255	-- set anything changed above
2756	3256	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")
	3257	self:set_yaw((random(0, 360) - 180) / 180 * pi, 6)
	3258	self:update_tag()
	3259	self:set_animation("stand")
	3260
	3261	-- apply any texture mods
	3262	self.object:set_texture_mod(self.texture_mods)
	3263
	3264	-- set 5.x flag to remove monsters when map area unloaded
	3265	if remove_far and self.type == "monster" then
	3266	self.static_save = false
	3267	end
2760	3268
2761	3269	-- run on_spawn function if found
2762	3270	if self.on_spawn and not self.on_spawn_run then
2763	3271	if self.on_spawn(self) then
2764		self.on_spawn_run = true -- if true, set flag to run once only
	3272	self.on_spawn_run = true -- if true, set flag to run once only
2765	3273	end
2766	3274	end
2767	3275

2771	3279	end
2772	3280
2773	3281	if use_cmi then
2774		self._cmi_components = cmi.activate_components(self.serialized_cmi_components)
	3282	self._cmi_components = cmi.activate_components(
	3283	self.serialized_cmi_components)
2775	3284	cmi.notify_activate(self.object, dtime)
2776	3285	end
2777	3286	end
2778	3287
2779	3288
2780	3289	-- handle mob lifetimer and expiration
2781		local mob_expire = function(self, pos, dtime)
	3290	function mob_class:mob_expire(pos, dtime)
2782	3291
2783	3292	-- when lifetimer expires remove mob (except npc and tamed)
2784	3293	if self.type ~= "npc"

2809	3318
2810	3319	effect(pos, 15, "tnt_smoke.png", 2, 4, 2, 0)
2811	3320
2812		self.object:remove()
	3321	remove_mob(self, true)
2813	3322
2814	3323	return
2815	3324	end

2818	3327
2819	3328
2820	3329	-- main mob function
2821		local mob_step = function(self, dtime)
	3330	function mob_class:on_step(dtime, moveresult)
	3331
	3332	if self.state == "die" then return end
2822	3333
2823	3334	if use_cmi then
2824	3335	cmi.notify_step(self.object, dtime)
2825	3336	end
2826	3337
2827	3338	local pos = self.object:get_pos()
2828		local yaw = 0
	3339	local yaw = self.object:get_yaw()
	3340
	3341	-- early warning check, if no yaw then no entity, skip rest of function
	3342	if not yaw then return end
2829	3343
2830	3344	-- get node at foot level every quarter second
2831	3345	self.node_timer = (self.node_timer or 0) + dtime

2843	3357	-- what is mob standing in?
2844	3358	self.standing_in = node_ok({
2845	3359	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)
	3360
	3361	self.standing_on = node_ok({
	3362	x = pos.x, y = pos.y + y_level - 0.25, z = pos.z}, "air").name
	3363
	3364	--print("standing in " .. self.standing_in)
	3365
	3366	-- if standing inside solid block then jump to escape
	3367	if minetest.registered_nodes[self.standing_in].walkable
	3368	and minetest.registered_nodes[self.standing_in].drawtype
	3369	== "normal" then
	3370
	3371	self.object:set_velocity({
	3372	x = 0,
	3373	y = self.jump_height,
	3374	z = 0
	3375	})
	3376	end
	3377
	3378	-- check and stop if standing at cliff and fear of heights
	3379	self.at_cliff = self:is_at_cliff()
	3380
	3381	if self.at_cliff then
	3382	self:set_velocity(0)
	3383	end
	3384
	3385	-- has mob expired (0.25 instead of dtime since were in a timer)
	3386	self:mob_expire(pos, 0.25)
	3387	end
	3388
	3389	-- check if falling, flying, floating and return if player died
	3390	if self:falling(pos) then
	3391	return
	3392	end
2854	3393
2855	3394	-- smooth rotation by ThomasMonroe314
2856
2857	3395	if self.delay and self.delay > 0 then
2858
2859		local yaw = self.object:get_yaw()
2860	3396
2861	3397	if self.delay == 1 then
2862	3398	yaw = self.target_yaw

2890	3426	self.object:set_yaw(yaw)
2891	3427	end
2892	3428
2893		-- end rotation
2894
2895	3429	-- knockback timer
2896	3430	if self.pause_timer > 0 then
2897	3431

2904	3438	if self.do_custom then
2905	3439
2906	3440	-- when false skip going any further
2907		if self.do_custom(self, dtime) == false then
	3441	if self:do_custom(dtime) == false then
2908	3442	return
2909	3443	end
2910	3444	end

2927	3461	end
2928	3462
2929	3463	-- mob plays random sound at times
2930		if random(1, 100) == 1 then
2931		mob_sound(self, self.sounds.random)
	3464	if random(100) == 1 then
	3465	self:mob_sound(self.sounds.random)
2932	3466	end
2933	3467
2934	3468	-- environmental damage timer (every 1 second)

2940	3474	self.env_damage_timer = 0
2941	3475
2942	3476	-- check for environmental damage (water, fire, lava etc.)
2943		do_env_damage(self)
	3477	if self:do_env_damage() then return end
2944	3478
2945	3479	-- 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
	3480	self:replace(pos)
	3481	end
	3482
	3483	self:general_attack()
	3484
	3485	self:breed()
	3486
	3487	self:follow_flop()
	3488
	3489	if self:do_states(dtime) then return end
	3490
	3491	self:do_jump()
	3492
	3493	self:do_runaway_from(self)
	3494
	3495	self:do_stay_near()
2961	3496	end
2962	3497
2963	3498
2964	3499	-- 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, {
	3500	function mob_class:on_blast(damage)
	3501
	3502	--print("-- blast damage", damage)
	3503
	3504	self.object:punch(self.object, 1.0, {
2970	3505	full_punch_interval = 1.0,
2971	3506	damage_groups = {fleshy = damage},
2972	3507	}, nil)
2973	3508
2974		return false, true, {}
	3509	-- return no damage, no knockback, no item drops, mob api handles all
	3510	return false, false, {}
2975	3511	end
2976	3512
2977	3513

2980	3516	-- register mob entity
2981	3517	function mobs:register_mob(name, def)
2982	3518
2983		mobs.spawning_mobs[name] = true
2984
2985		minetest.register_entity(name, {
2986
2987		stepheight = def.stepheight or 1.1, -- was 0.6
	3519	mobs.spawning_mobs[name] = {}
	3520
	3521	local collisionbox = def.collisionbox or {-0.25, -0.25, -0.25, 0.25, 0.25, 0.25}
	3522
	3523	-- quick fix to stop mobs glitching through nodes if too small
	3524	if -collisionbox[2] + collisionbox[5] < 1.01 then
	3525	collisionbox[5] = collisionbox[2] + 0.99
	3526	end
	3527
	3528	minetest.register_entity(name, setmetatable({
	3529
	3530	stepheight = def.stepheight,
2988	3531	name = name,
2989	3532	type = def.type,
2990	3533	attack_type = def.attack_type,
2991	3534	fly = def.fly,
2992		fly_in = def.fly_in or "air",
2993		owner = def.owner or "",
2994		order = def.order or "",
	3535	fly_in = def.fly_in,
	3536	keep_flying = def.keep_flying,
	3537	owner = def.owner,
	3538	order = def.order,
2995	3539	on_die = def.on_die,
	3540	on_flop = def.on_flop,
2996	3541	do_custom = def.do_custom,
2997		jump_height = def.jump_height or 4, -- was 6
	3542	jump_height = def.jump_height,
2998	3543	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
	3544	rotate = rad(def.rotate or 0), -- 0=front 90=side 180=back 270=side2
	3545	glow = def.glow,
	3546	lifetimer = def.lifetimer,
3001	3547	hp_min = max(1, (def.hp_min or 5) * difficulty),
3002	3548	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,
	3549	collisionbox = collisionbox, --def.collisionbox,
	3550	selectionbox = def.selectionbox or collisionbox, --def.collisionbox,
3006	3551	visual = def.visual,
3007		visual_size = def.visual_size or {x = 1, y = 1},
	3552	visual_size = def.visual_size,
3008	3553	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,
	3554	makes_footstep_sound = def.makes_footstep_sound,
	3555	view_range = def.view_range,
	3556	walk_velocity = def.walk_velocity,
	3557	run_velocity = def.run_velocity,
3013	3558	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,
	3559	damage_group = def.damage_group,
	3560	damage_texture_modifier = def.damage_texture_modifier,
	3561	light_damage = def.light_damage,
	3562	light_damage_min = def.light_damage_min,
	3563	light_damage_max = def.light_damage_max,
	3564	water_damage = def.water_damage,
	3565	lava_damage = def.lava_damage,
	3566	fire_damage = def.fire_damage,
	3567	air_damage = def.air_damage,
	3568	suffocation = def.suffocation,
	3569	fall_damage = def.fall_damage,
	3570	fall_speed = def.fall_speed,
	3571	drops = def.drops,
	3572	armor = def.armor,
3024	3573	on_rightclick = def.on_rightclick,
3025	3574	arrow = def.arrow,
3026	3575	shoot_interval = def.shoot_interval,
3027		sounds = def.sounds or {},
	3576	sounds = def.sounds,
3028	3577	animation = def.animation,
3029	3578	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
	3579	jump = def.jump,
	3580	walk_chance = def.walk_chance,
	3581	stand_chance = def.stand_chance,
	3582	attack_chance = def.attack_chance,
	3583	passive = def.passive,
	3584	knock_back = def.knock_back,
	3585	blood_amount = def.blood_amount,
	3586	blood_texture = def.blood_texture,
	3587	shoot_offset = def.shoot_offset,
	3588	floats = def.floats,
3039	3589	replace_rate = def.replace_rate,
3040	3590	replace_what = def.replace_what,
3041	3591	replace_with = def.replace_with,
3042		replace_offset = def.replace_offset or 0,
	3592	replace_offset = def.replace_offset,
3043	3593	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,
	3594	reach = def.reach,
3055	3595	texture_list = def.textures,
	3596	texture_mods = def.texture_mods or "",
3056	3597	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,
	3598	docile_by_day = def.docile_by_day,
	3599	fear_height = def.fear_height,
3060	3600	runaway = def.runaway,
3061		runaway_timer = 0,
3062	3601	pathfinding = def.pathfinding,
3063		immune_to = def.immune_to or {},
	3602	immune_to = def.immune_to,
3064	3603	explosion_radius = def.explosion_radius,
3065	3604	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,
	3605	explosion_timer = def.explosion_timer,
	3606	allow_fuse_reset = def.allow_fuse_reset,
	3607	stop_to_explode = def.stop_to_explode,
3069	3608	custom_attack = def.custom_attack,
3070	3609	double_melee_attack = def.double_melee_attack,
3071	3610	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,
	3611	dogshoot_count_max = def.dogshoot_count_max,
	3612	dogshoot_count2_max = def.dogshoot_count2_max or def.dogshoot_count_max,
	3613	group_attack = def.group_attack,
	3614	group_helper = def.group_helper,
	3615	attack_monsters = def.attacks_monsters or def.attack_monsters,
	3616	attack_animals = def.attack_animals,
	3617	attack_players = def.attack_players,
	3618	attack_npcs = def.attack_npcs,
3080	3619	specific_attack = def.specific_attack,
3081	3620	runaway_from = def.runaway_from,
3082	3621	owner_loyal = def.owner_loyal,
3083		facing_fence = false,
3084	3622	pushable = def.pushable,
3085		_cmi_is_mob = true,
	3623	stay_near = def.stay_near,
	3624	randomly_turn = def.randomly_turn ~= false,
	3625	ignore_invisibility = def.ignore_invisibility,
3086	3626
3087	3627	on_spawn = def.on_spawn,
3088	3628
3089		on_blast = def.on_blast or do_tnt,
3090
3091		on_step = mob_step,
	3629	on_blast = def.on_blast, -- class redifinition
3092	3630
3093	3631	do_punch = def.do_punch,
3094	3632
3095		on_punch = mob_punch,
3096
3097	3633	on_breed = def.on_breed,
3098	3634
3099	3635	on_grown = def.on_grown,
3100	3636
3101	3637	on_activate = function(self, staticdata, dtime)
3102		return mob_activate(self, staticdata, def, dtime)
	3638	return self:mob_activate(staticdata, def, dtime)
3103	3639	end,
3104	3640
3105	3641	get_staticdata = function(self)
3106		return mob_staticdata(self)
	3642	return self:mob_staticdata(self)
3107	3643	end,
3108	3644
3109		})
	3645	}, mob_class_meta))
3110	3646
3111	3647	end -- END mobs:register_mob function
3112	3648
3113	3649
3114	3650	-- count how many mobs of one type are inside an area
	3651	-- will also return true for second value if player is inside area
3115	3652	local count_mobs = function(pos, type)
3116	3653
3117	3654	local total = 0
3118	3655	local objs = minetest.get_objects_inside_radius(pos, aoc_range * 2)
3119	3656	local ent
	3657	local players
3120	3658
3121	3659	for n = 1, #objs do
3122	3660

3128	3666	if ent and ent.name and ent.name == type then
3129	3667	total = total + 1
3130	3668	end
3131		end
3132		end
3133
3134		return total
	3669	else
	3670	players = true
	3671	end
	3672	end
	3673
	3674	return total, players
	3675	end
	3676
	3677
	3678	-- do we have enough space to spawn mob? (thanks wuzzy)
	3679	local can_spawn = function(pos, name)
	3680
	3681	local ent = minetest.registered_entities[name]
	3682	local width_x = max(1, ceil(ent.collisionbox[4] - ent.collisionbox[1]))
	3683	local min_x, max_x
	3684
	3685	if width_x % 2 == 0 then
	3686	max_x = floor(width_x / 2)
	3687	min_x = -(max_x - 1)
	3688	else
	3689	max_x = floor(width_x / 2)
	3690	min_x = -max_x
	3691	end
	3692
	3693	local width_z = max(1, ceil(ent.collisionbox[6] - ent.collisionbox[3]))
	3694	local min_z, max_z
	3695
	3696	if width_z % 2 == 0 then
	3697	max_z = floor(width_z / 2)
	3698	min_z = -(max_z - 1)
	3699	else
	3700	max_z = floor(width_z / 2)
	3701	min_z = -max_z
	3702	end
	3703
	3704	local max_y = max(0, ceil(ent.collisionbox[5] - ent.collisionbox[2]) - 1)
	3705	local pos2
	3706
	3707	for y = 0, max_y do
	3708	for x = min_x, max_x do
	3709	for z = min_z, max_z do
	3710
	3711	pos2 = {x = pos.x + x, y = pos.y + y, z = pos.z + z}
	3712
	3713	if minetest.registered_nodes[node_ok(pos2).name].walkable == true then
	3714	return nil
	3715	end
	3716	end
	3717	end
	3718	end
	3719
	3720	-- tweak X/Z spawn pos
	3721	if width_x % 2 == 0 then
	3722	pos.x = pos.x + 0.5
	3723	end
	3724
	3725	if width_z % 2 == 0 then
	3726	pos.z = pos.z + 0.5
	3727	end
	3728
	3729	return pos
	3730	end
	3731
	3732	function mobs:can_spawn(pos, name)
	3733	return can_spawn(pos, name)
3135	3734	end
3136	3735
3137	3736
3138	3737	-- global functions
	3738
	3739	function mobs:add_mob(pos, def)
	3740
	3741	-- is mob actually registered?
	3742	if not mobs.spawning_mobs[def.name]
	3743	or not minetest.registered_entities[def.name] then
	3744	--print("--- mob doesn't exist", def.name)
	3745	return
	3746	end
	3747
	3748	-- are we over active mob limit
	3749	if active_limit > 0 and active_mobs >= active_limit then
	3750	--print("--- active mob limit reached", active_mobs, active_limit)
	3751	return
	3752	end
	3753
	3754	-- get total number of this mob in area
	3755	local num_mob, is_pla = count_mobs(pos, def.name)
	3756
	3757	if not is_pla then
	3758	--print("--- no players within active area, will not spawn " .. def.name)
	3759	return
	3760	end
	3761
	3762	local aoc = mobs.spawning_mobs[def.name]
	3763	and mobs.spawning_mobs[def.name].aoc or 1
	3764
	3765	if def.ignore_count ~= true and num_mob >= aoc then
	3766	--print("--- too many " .. def.name .. " in area", num_mob .. "/" .. aoc)
	3767	return
	3768	end
	3769
	3770	local mob = minetest.add_entity(pos, def.name)
	3771
	3772	--print("[mobs] Spawned " .. def.name .. " at " .. minetest.pos_to_string(pos))
	3773
	3774	local ent = mob:get_luaentity()
	3775
	3776	if not ent then
	3777	--print("[mobs] entity not found " .. def.name)
	3778	return false
	3779	end
	3780
	3781	if def.child then
	3782
	3783	local textures = ent.base_texture
	3784
	3785	-- using specific child texture (if found)
	3786	if ent.child_texture then
	3787	textures = ent.child_texture[1]
	3788	end
	3789
	3790	-- and resize to half height
	3791	mob:set_properties({
	3792	textures = textures,
	3793	visual_size = {
	3794	x = ent.base_size.x * .5,
	3795	y = ent.base_size.y * .5
	3796	},
	3797	collisionbox = {
	3798	ent.base_colbox[1] * .5,
	3799	ent.base_colbox[2] * .5,
	3800	ent.base_colbox[3] * .5,
	3801	ent.base_colbox[4] * .5,
	3802	ent.base_colbox[5] * .5,
	3803	ent.base_colbox[6] * .5
	3804	},
	3805	selectionbox = {
	3806	ent.base_selbox[1] * .5,
	3807	ent.base_selbox[2] * .5,
	3808	ent.base_selbox[3] * .5,
	3809	ent.base_selbox[4] * .5,
	3810	ent.base_selbox[5] * .5,
	3811	ent.base_selbox[6] * .5
	3812	},
	3813	})
	3814
	3815	ent.child = true
	3816	end
	3817
	3818	if def.owner then
	3819	ent.tamed = true
	3820	ent.owner = def.owner
	3821	end
	3822
	3823	if def.nametag then
	3824
	3825	-- limit name entered to 64 characters long
	3826	if def.nametag:len() > 64 then
	3827	def.nametag = def.nametag:sub(1, 64)
	3828	end
	3829
	3830	ent.nametag = def.nametag
	3831
	3832	ent:update_tag()
	3833	end
	3834
	3835	return ent
	3836	end
	3837
3139	3838
3140	3839	function mobs:spawn_abm_check(pos, node, name)
3141	3840	-- global function to add additional spawn checks

3143	3842	end
3144	3843
3145	3844
3146		function mobs:spawn_specific(name, nodes, neighbors, min_light, max_light,
3147		interval, chance, aoc, min_height, max_height, day_toggle, on_spawn)
	3845	function mobs:spawn_specific(name, nodes, neighbors, min_light, max_light, interval,
	3846	chance, aoc, min_height, max_height, day_toggle, on_spawn, map_load)
3148	3847
3149	3848	-- Do mobs spawn at all?
3150		if not mobs_spawn then
	3849	if not mobs_spawn or not mobs.spawning_mobs[name] then
	3850	--print ("--- spawning not registered for " .. name)
3151	3851	return
3152	3852	end
3153	3853
3154	3854	-- chance/spawn number override in minetest.conf for registered mob
3155		local numbers = minetest.settings:get(name)
	3855	local numbers = settings:get(name)
3156	3856
3157	3857	if numbers then
	3858
3158	3859	numbers = numbers:split(",")
3159	3860	chance = tonumber(numbers[1]) or chance
3160	3861	aoc = tonumber(numbers[2]) or aoc
3161	3862
3162	3863	if chance == 0 then
3163		minetest.log("warning", string.format("[mobs] %s has spawning disabled", name))
	3864
	3865	minetest.log("warning",
	3866	string.format("[mobs] %s has spawning disabled", name))
3164	3867	return
3165	3868	end
3166	3869
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
	3870	minetest.log("action", string.format(
	3871	"[mobs] Chance setting for %s changed to %s (total: %s)",
	3872	name, chance, aoc))
	3873	end
	3874
	3875	mobs.spawning_mobs[name].aoc = aoc
	3876
	3877	local spawn_action = function(pos, node, active_object_count,
	3878	active_object_count_wider)
	3879
	3880	-- use instead of abm's chance setting when using lbm
	3881	if map_load and random(max(1, (chance * mob_chance_multiplier))) > 1 then
	3882	return
	3883	end
	3884
	3885	-- use instead of abm's neighbor setting when using lbm
	3886	if map_load and not minetest.find_node_near(pos, 1, neighbors) then
	3887	--print("--- lbm neighbors not found")
	3888	return
	3889	end
	3890
	3891	-- is mob actually registered?
	3892	if not mobs.spawning_mobs[name]
	3893	or not minetest.registered_entities[name] then
	3894	--print("--- mob doesn't exist", name)
	3895	return
	3896	end
	3897
	3898	-- are we over active mob limit
	3899	if active_limit > 0 and active_mobs >= active_limit then
	3900	--print("--- active mob limit reached", active_mobs, active_limit)
	3901	return
	3902	end
	3903
	3904	-- additional custom checks for spawning mob
	3905	if mobs:spawn_abm_check(pos, node, name) == true then
	3906	return
	3907	end
	3908
	3909	-- do not spawn if too many entities in area
	3910	if active_object_count_wider
	3911	and active_object_count_wider >= max_per_block then
3197	3912	--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
	3913	return
	3914	end
	3915
	3916	-- get total number of this mob in area
	3917	local num_mob, is_pla = count_mobs(pos, name)
	3918
	3919	if not is_pla then
	3920	--print("--- no players within active area, will not spawn " .. name)
	3921	return
	3922	end
	3923
	3924	if num_mob >= aoc then
	3925	--print("--- too many " .. name .. " in area", num_mob .. "/" .. aoc)
	3926	return
	3927	end
3208	3928
3209	3929	-- if toggle set to nil then ignore day/night check
3210		if day_toggle ~= nil then
3211
3212		local tod = (minetest.get_timeofday() or 0) * 24000
3213
3214		if tod > 4500 and tod < 19500 then
3215		-- daylight, but mob wants night
3216		if day_toggle == false then
3217		--print ("--- mob needs night", name)
3218		return
3219		end
3220		else
3221		-- night time but mob wants day
3222		if day_toggle == true then
3223		--print ("--- mob needs day", name)
3224		return
3225		end
3226		end
3227		end
3228
3229		-- spawn above node
3230		pos.y = pos.y + 1
3231
3232		-- are we spawning within height limits?
3233		if pos.y > max_height
3234		or pos.y < min_height then
3235		--print ("--- height limits not met", name, pos.y)
3236		return
3237		end
3238
3239		-- are light levels ok?
3240		local light = minetest.get_node_light(pos)
3241		if not light
3242		or light > max_light
3243		or light < min_light then
3244		--print ("--- light limits not met", name, light)
3245		return
3246		end
3247
3248		-- only spawn away from player
3249		local objs = minetest.get_objects_inside_radius(pos, 10)
3250
3251		for n = 1, #objs do
3252
3253		if objs[n]:is_player() then
3254		--print ("--- player too close", name)
	3930	if day_toggle ~= nil then
	3931
	3932	local tod = (minetest.get_timeofday() or 0) * 24000
	3933
	3934	if tod > 4500 and tod < 19500 then
	3935	-- daylight, but mob wants night
	3936	if day_toggle == false then
	3937	--print("--- mob needs night", name)
3255	3938	return
3256	3939	end
3257		end
	3940	else
	3941	-- night time but mob wants day
	3942	if day_toggle == true then
	3943	--print("--- mob needs day", name)
	3944	return
	3945	end
	3946	end
	3947	end
	3948
	3949	-- spawn above node
	3950	pos.y = pos.y + 1
	3951
	3952	-- are we spawning within height limits?
	3953	if pos.y > max_height
	3954	or pos.y < min_height then
	3955	--print("--- height limits not met", name, pos.y)
	3956	return
	3957	end
	3958
	3959	-- are light levels ok?
	3960	local light = minetest.get_node_light(pos)
	3961	if not light
	3962	or light > max_light
	3963	or light < min_light then
	3964	--print("--- light limits not met", name, light)
	3965	return
	3966	end
	3967
	3968	-- check if mob can spawn inside protected areas
	3969	if (spawn_protected == false
	3970	or (spawn_monster_protected == false
	3971	and minetest.registered_entities[name].type == "monster"))
	3972	and minetest.is_protected(pos, "") then
	3973	--print("--- inside protected area", name)
	3974	return
	3975	end
	3976
	3977	-- only spawn a set distance away from player
	3978	local objs = minetest.get_objects_inside_radius(pos, mob_nospawn_range)
	3979
	3980	for n = 1, #objs do
	3981
	3982	if objs[n]:is_player() then
	3983	--print("--- player too close", name)
	3984	return
	3985	end
	3986	end
	3987
	3988	local ent = minetest.registered_entities[name]
	3989
	3990	-- should we check mob area for obstructions ?
	3991	if mob_area_spawn ~= true then
3258	3992
3259	3993	-- do we have enough height clearance to spawn mob?
3260		local ent = minetest.registered_entities[name]
3261		local height = max(1, math.ceil(
3262		(ent.collisionbox[5] or 0.25) -
3263		(ent.collisionbox[2] or -0.25) - 1))
3264
3265		for n = 0, height do
	3994	local height = max(0, ent.collisionbox[5] - ent.collisionbox[2])
	3995
	3996	for n = 0, floor(height) do
3266	3997
3267	3998	local pos2 = {x = pos.x, y = pos.y + n, z = pos.z}
3268	3999

3271	4002	return
3272	4003	end
3273	4004	end
3274
3275		-- mobs cannot spawn in protected areas when enabled
3276		if not spawn_protected
3277		and minetest.is_protected(pos, "") then
3278		--print ("--- inside protected area", name)
3279		return
3280		end
3281
3282		-- spawn mob half block higher than ground
3283		pos.y = pos.y + 0.5
	4005	else
	4006	-- returns position if we have enough space to spawn mob
	4007	pos = can_spawn(pos, name)
	4008	end
	4009
	4010	if pos then
	4011
	4012	-- adjust for mob collision box
	4013	pos.y = pos.y + (ent.collisionbox[2] * -1) - 0.4
3284	4014
3285	4015	local mob = minetest.add_entity(pos, name)
3286		--[[
3287		print ("[mobs] Spawned " .. name .. " at "
3288		.. minetest.pos_to_string(pos) .. " on "
3289		.. node.name .. " near " .. neighbors[1])
3290		]]
	4016
	4017	-- print("[mobs] Spawned " .. name .. " at "
	4018	-- .. minetest.pos_to_string(pos) .. " on "
	4019	-- .. node.name .. " near " .. neighbors[1])
	4020
3291	4021	if on_spawn then
3292
3293		local ent = mob:get_luaentity()
3294
3295		on_spawn(ent, pos)
3296		end
3297		end
3298		})
	4022	on_spawn(mob:get_luaentity(), pos)
	4023	end
	4024	else
	4025	--print("--- not enough space to spawn", name)
	4026	end
	4027	end
	4028
	4029
	4030	-- are we registering an abm or lbm?
	4031	if map_load == true then
	4032
	4033	minetest.register_lbm({
	4034	name = name .. "_spawning",
	4035	label = name .. " spawning",
	4036	nodenames = nodes,
	4037	run_at_every_load = false,
	4038
	4039	action = function(pos, node)
	4040	spawn_action(pos, node)
	4041	end
	4042	})
	4043
	4044	else
	4045
	4046	minetest.register_abm({
	4047	label = name .. " spawning",
	4048	nodenames = nodes,
	4049	neighbors = neighbors,
	4050	interval = interval,
	4051	chance = max(1, (chance * mob_chance_multiplier)),
	4052	catch_up = false,
	4053
	4054	action = function(pos, node, active_object_count, active_object_count_wider)
	4055	spawn_action(pos, node, active_object_count, active_object_count_wider)
	4056	end
	4057	})
	4058	end
3299	4059	end
3300	4060
3301	4061

3308	4068	end
3309	4069
3310	4070
3311		-- MarkBu's spawn function
	4071	-- MarkBu's spawn function (USE this one please)
3312	4072	function mobs:spawn(def)
3313	4073
3314	4074	mobs:spawn_specific(

3323	4083	def.min_height or -31000,
3324	4084	def.max_height or 31000,
3325	4085	def.day_toggle,
3326		def.on_spawn
3327		)
	4086	def.on_spawn,
	4087	def.on_map_load)
3328	4088	end
3329	4089
3330	4090

3335	4095
3336	4096	minetest.register_entity(name, {
3337	4097
3338		physical = false,
	4098	physical = def.physical or false,
	4099	collide_with_objects = def.collide_with_objects or false,
	4100	static_save = false,
	4101
3339	4102	visual = def.visual,
3340	4103	visual_size = def.visual_size,
3341	4104	textures = def.textures,

3343	4106	hit_player = def.hit_player,
3344	4107	hit_node = def.hit_node,
3345	4108	hit_mob = def.hit_mob,
	4109	hit_object = def.hit_object,
3346	4110	drop = def.drop or false, -- drops arrow as registered item when true
3347		collisionbox = def.collisionbox or {0, 0, 0, 0, 0, 0},
	4111	collisionbox = def.collisionbox or {-.1, -.1, -.1, .1, .1, .1},
3348	4112	timer = 0,
	4113	lifetime = def.lifetime or 4.5,
3349	4114	switch = 0,
3350	4115	owner_id = def.owner_id,
3351	4116	rotate = def.rotate,

3354	4119
3355	4120	on_activate = def.on_activate,
3356	4121
3357		on_punch = def.on_punch or function(self, hitter, tflp, tool_capabilities, dir)
	4122	on_punch = def.on_punch or function(
	4123	self, hitter, tflp, tool_capabilities, dir)
3358	4124	end,
3359	4125
3360	4126	on_step = def.on_step or function(self, dtime)
3361	4127
3362		self.timer = self.timer + 1
	4128	self.timer = self.timer + dtime
3363	4129
3364	4130	local pos = self.object:get_pos()
3365	4131
3366		if self.switch == 0
3367		or self.timer > 150 then
3368
3369		self.object:remove() ; -- print ("removed arrow")
	4132	if self.switch == 0 or self.timer > self.lifetime then
	4133
	4134	self.object:remove() ; -- print("removed arrow")
3370	4135
3371	4136	return
3372	4137	end
3373	4138
3374	4139	-- does arrow have a tail (fireball)
3375		if def.tail
3376		and def.tail == 1
3377		and def.tail_texture then
	4140	if def.tail and def.tail == 1 and def.tail_texture then
3378	4141
3379	4142	minetest.add_particle({
3380	4143	pos = pos,

3384	4147	collisiondetection = false,
3385	4148	texture = def.tail_texture,
3386	4149	size = def.tail_size or 5,
3387		glow = def.glow or 0,
	4150	glow = def.glow or 0
3388	4151	})
3389	4152	end
3390	4153

3394	4157
3395	4158	if minetest.registered_nodes[node].walkable then
3396	4159
3397		self.hit_node(self, pos, node)
	4160	self:hit_node(pos, node)
3398	4161
3399	4162	if self.drop == true then
3400	4163

3402	4165
3403	4166	self.lastpos = (self.lastpos or pos)
3404	4167
3405		minetest.add_item(self.lastpos, self.object:get_luaentity().name)
	4168	minetest.add_item(self.lastpos,
	4169	self.object:get_luaentity().name)
3406	4170	end
3407	4171
3408		self.object:remove() ; -- print ("hit node")
	4172	self.object:remove() ; -- print("hit node")
3409	4173
3410	4174	return
3411	4175	end
3412	4176	end
3413	4177
3414		if self.hit_player or self.hit_mob then
3415
3416		for _,player in pairs(minetest.get_objects_inside_radius(pos, 1.0)) do
3417
3418		if self.hit_player
3419		and player:is_player() then
3420
3421		self.hit_player(self, player)
3422		self.object:remove() ; -- print ("hit player")
	4178	if self.hit_player or self.hit_mob or self.hit_object then
	4179
	4180	for _,player in pairs(
	4181	minetest.get_objects_inside_radius(pos, 1.0)) do
	4182
	4183	if self.hit_player and player:is_player() then
	4184
	4185	self:hit_player(player)
	4186
	4187	self.object:remove() ; -- print("hit player")
	4188
3423	4189	return
3424	4190	end
3425	4191

3431	4197	and tostring(player) ~= self.owner_id
3432	4198	and entity.name ~= self.object:get_luaentity().name then
3433	4199
3434		self.hit_mob(self, player)
3435
3436		self.object:remove() ; --print ("hit mob")
	4200	self:hit_mob(player)
	4201
	4202	self.object:remove() ; --print("hit mob")
	4203
	4204	return
	4205	end
	4206
	4207	if entity
	4208	and self.hit_object
	4209	and (not entity._cmi_is_mob)
	4210	and tostring(player) ~= self.owner_id
	4211	and entity.name ~= self.object:get_luaentity().name then
	4212
	4213	self:hit_object(player)
	4214
	4215	self.object:remove() ; -- print("hit object")
3437	4216
3438	4217	return
3439	4218	end

3448	4227
3449	4228	-- compatibility function
3450	4229	function mobs:explosion(pos, radius)
3451
3452		local self = {sounds = {explode = "tnt_explode"}}
3453
3454		mobs:boom(self, pos, radius)
	4230	mobs:boom({sounds = {explode = "tnt_explode"}}, pos, radius)
3455	4231	end
3456	4232
3457	4233

3462	4238	pos = pos,
3463	4239	gain = 1.0,
3464	4240	max_hear_distance = self.sounds and self.sounds.distance or 32
3465		})
	4241	}, true)
3466	4242
3467	4243	entity_physics(pos, radius)
3468	4244

3481	4257	radius = radius,
3482	4258	damage_radius = radius,
3483	4259	sound = self.sounds and self.sounds.explode,
3484		explode_center = true,
	4260	explode_center = true
3485	4261	})
3486	4262	else
3487	4263	mobs:safe_boom(self, pos, radius)

3499	4275	local grp = {spawn_egg = 1}
3500	4276
3501	4277	-- do NOT add this egg to creative inventory (e.g. dungeon master)
3502		if creative and no_creative == true then
	4278	if no_creative == true then
3503	4279	grp.not_in_creative_inventory = 1
3504	4280	end
3505	4281

3522	4298
3523	4299	local pos = pointed_thing.above
3524	4300
3525		-- am I clicking on something with existing on_rightclick function?
	4301	-- does existing on_rightclick function exist?
3526	4302	local under = minetest.get_node(pointed_thing.under)
3527	4303	local def = minetest.registered_nodes[under.name]
	4304
3528	4305	if def and def.on_rightclick then
3529		return def.on_rightclick(pointed_thing.under, under, placer, itemstack)
	4306
	4307	return def.on_rightclick(
	4308	pointed_thing.under, under, placer, itemstack)
3530	4309	end
3531	4310
3532	4311	if pos

3539	4318	pos.y = pos.y + 1
3540	4319
3541	4320	local data = itemstack:get_metadata()
3542		local mob = minetest.add_entity(pos, mob, data)
3543		local ent = mob:get_luaentity()
	4321	local smob = minetest.add_entity(pos, mob, data)
	4322	local ent = smob and smob:get_luaentity()
	4323
	4324	if not ent then return end -- sanity check
3544	4325
3545	4326	-- set owner if not a monster
3546	4327	if ent.type ~= "monster" then

3568	4349
3569	4350	local pos = pointed_thing.above
3570	4351
3571		-- am I clicking on something with existing on_rightclick function?
	4352	-- does existing on_rightclick function exist?
3572	4353	local under = minetest.get_node(pointed_thing.under)
3573	4354	local def = minetest.registered_nodes[under.name]
	4355
3574	4356	if def and def.on_rightclick then
3575		return def.on_rightclick(pointed_thing.under, under, placer, itemstack)
	4357
	4358	return def.on_rightclick(
	4359	pointed_thing.under, under, placer, itemstack)
3576	4360	end
3577	4361
3578	4362	if pos

3582	4366	return
3583	4367	end
3584	4368
	4369	-- have we reached active mob limit
	4370	if active_limit > 0 and active_mobs >= active_limit then
	4371	minetest.chat_send_player(placer:get_player_name(),
	4372	S("Active Mob Limit Reached!")
	4373	.. " (" .. active_mobs
	4374	.. " / " .. active_limit .. ")")
	4375	return
	4376	end
	4377
3585	4378	pos.y = pos.y + 1
3586	4379
3587		local mob = minetest.add_entity(pos, mob)
3588		local ent = mob:get_luaentity()
	4380	local smob = minetest.add_entity(pos, mob)
	4381	local ent = smob and smob:get_luaentity()
	4382
	4383	if not ent then return end -- sanity check
3589	4384
3590	4385	-- don't set owner if monster or sneak pressed
3591	4386	if ent.type ~= "monster"

3603	4398	return itemstack
3604	4399	end,
3605	4400	})
3606
	4401	end
	4402
	4403
	4404	-- force capture a mob if space available in inventory, or drop as spawn egg
	4405	function mobs:force_capture(self, clicker)
	4406
	4407	-- add special mob egg with all mob information
	4408	local new_stack = ItemStack(self.name .. "_set")
	4409
	4410	local tmp, t = {}
	4411
	4412	for _,stat in pairs(self) do
	4413
	4414	t = type(stat)
	4415
	4416	if t ~= "function"
	4417	and t ~= "nil"
	4418	and t ~= "userdata" then
	4419	tmp[_] = self[_]
	4420	end
	4421	end
	4422
	4423	local data_str = minetest.serialize(tmp)
	4424
	4425	new_stack:set_metadata(data_str)
	4426
	4427	local inv = clicker:get_inventory()
	4428
	4429	if inv:room_for_item("main", new_stack) then
	4430	inv:add_item("main", new_stack)
	4431	else
	4432	minetest.add_item(clicker:get_pos(), new_stack)
	4433	end
	4434
	4435	self:mob_sound("default_place_node_hard")
	4436
	4437	remove_mob(self, true)
3607	4438	end
3608	4439
3609	4440
3610	4441	-- capture critter (thanks to blert2112 for idea)
3611		function mobs:capture_mob(self, clicker, chance_hand, chance_net, chance_lasso,
3612		force_take, replacewith)
	4442	function mobs:capture_mob(self, clicker, chance_hand, chance_net,
	4443	chance_lasso, force_take, replacewith)
3613	4444
3614	4445	if self.child
3615	4446	or not clicker:is_player()

3636	4467	end
3637	4468
3638	4469	-- is mob tamed?
3639		if self.tamed == false
3640		and force_take == false then
	4470	if self.tamed == false and force_take == false then
3641	4471
3642	4472	minetest.chat_send_player(name, S("Not tamed!"))
3643	4473
3644		return true -- false
3645		end
3646
3647		-- cannot pick up if not owner
3648		if self.owner ~= name
3649		and force_take == false then
	4474	return false
	4475	end
	4476
	4477	-- cannot pick up if not owner (unless player has protection_bypass priv)
	4478	if not minetest.check_player_privs(name, "protection_bypass")
	4479	and self.owner ~= name and force_take == false then
3650	4480
3651	4481	minetest.chat_send_player(name, S("@1 is owner!", self.owner))
3652	4482
3653		return true -- false
	4483	return false
3654	4484	end
3655	4485
3656	4486	if clicker:get_inventory():room_for_item("main", mobname) then

3680	4510	end
3681	4511
3682	4512	-- calculate chance.. add to inventory if successful?
3683		if chance > 0 and random(1, 100) <= chance then
	4513	if chance and chance > 0 and random(100) <= chance then
3684	4514
3685	4515	-- default mob egg
3686	4516	local new_stack = ItemStack(mobname)

3691	4521
3692	4522	new_stack = ItemStack(mobname .. "_set")
3693	4523
3694		local tmp = {}
	4524	local tmp, t = {}
3695	4525
3696	4526	for _,stat in pairs(self) do
3697		local t = type(stat)
	4527
	4528	t = type(stat)
	4529
3698	4530	if t ~= "function"
3699	4531	and t ~= "nil"
3700	4532	and t ~= "userdata" then

3715	4547	minetest.add_item(clicker:get_pos(), new_stack)
3716	4548	end
3717	4549
3718		self.object:remove()
3719
3720		mob_sound(self, "default_place_node_hard")
3721
3722		elseif chance ~= 0 then
	4550	self:mob_sound("default_place_node_hard")
	4551
	4552	remove_mob(self, true)
	4553
	4554	return new_stack
	4555
	4556	-- when chance above fails or set to 0, miss!
	4557	elseif chance and chance ~= 0 then
	4558
3723	4559	minetest.chat_send_player(name, S("Missed!"))
3724	4560
3725		mob_sound(self, "mobs_swing")
	4561	self:mob_sound("mobs_swing")
	4562
	4563	return false
	4564
	4565	-- when chance is nil always return a miss (used for npc walk/follow)
	4566	elseif not chance then
	4567	return false
3726	4568	end
3727	4569	end
3728	4570

3735	4577
3736	4578	local name = clicker:get_player_name()
3737	4579	local tool = clicker:get_wielded_item()
3738
3739		if tool:get_name() ~= "mobs:protector" then
	4580	local tool_name = tool:get_name()
	4581
	4582	if tool_name ~= "mobs:protector"
	4583	and tool_name ~= "mobs:protector2" then
3740	4584	return false
3741	4585	end
3742	4586
3743		if self.tamed == false then
	4587	if not self.tamed then
3744	4588	minetest.chat_send_player(name, S("Not tamed!"))
3745		return true -- false
3746		end
3747
3748		if self.protected == true then
	4589	return true
	4590	end
	4591
	4592	if (self.protected and tool_name == "mobs:protector")
	4593	or (self.protected == 2 and tool_name == "mobs:protector2") then
3749	4594	minetest.chat_send_player(name, S("Already protected!"))
3750		return true -- false
	4595	return true
3751	4596	end
3752	4597
3753	4598	if not mobs.is_creative(clicker:get_player_name()) then

3755	4600	clicker:set_wielded_item(tool)
3756	4601	end
3757	4602
3758		self.protected = true
	4603	-- set protection level
	4604	if tool_name == "mobs:protector" then
	4605	self.protected = true
	4606	else
	4607	self.protected = 2 ; self.fire_damage = 0
	4608	end
3759	4609
3760	4610	local pos = self.object:get_pos()
	4611
3761	4612	pos.y = pos.y + self.collisionbox[2] + 0.5
3762	4613
3763		effect(self.object:get_pos(), 25, "mobs_protect_particle.png", 0.5, 4, 2, 15)
3764
3765		mob_sound(self, "mobs_spell")
	4614	effect(self.object:get_pos(), 25, "mobs_protect_particle.png",
	4615	0.5, 4, 2, 15)
	4616
	4617	self:mob_sound("mobs_spell")
3766	4618
3767	4619	return true
3768	4620	end

3774	4626	-- feeding, taming and breeding (thanks blert2112)
3775	4627	function mobs:feed_tame(self, clicker, feed_count, breed, tame)
3776	4628
3777		if not self.follow then
3778		return false
3779		end
3780
3781	4629	-- can eat/tame with item in hand
3782		if follow_holding(self, clicker) then
	4630	if self.follow
	4631	and self:follow_holding(clicker) then
3783	4632
3784	4633	-- if not in creative then take item
3785	4634	if not mobs.is_creative(clicker:get_player_name()) then

3798	4647
3799	4648	self.health = self.hp_max
3800	4649
3801		if self.htimer < 1 then
3802
3803		minetest.chat_send_player(clicker:get_player_name(),
3804		S("@1 at full health (@2)",
3805		self.name:split(":")[2], tostring(self.health)))
3806
3807		self.htimer = 5
3808		end
	4650	-- if self.htimer < 1 then
	4651
	4652	-- minetest.chat_send_player(clicker:get_player_name(),
	4653	-- S("@1 at full health (@2)",
	4654	-- self.name:split(":")[2], tostring(self.health)))
	4655
	4656	-- self.htimer = 5
	4657	-- end
3809	4658	end
3810	4659
3811	4660	self.object:set_hp(self.health)
3812	4661
3813		update_tag(self)
	4662	self:update_tag()
3814	4663
3815	4664	-- make children grow quicker
3816	4665	if self.child == true then
3817	4666
3818		self.hornytimer = self.hornytimer + 20
3819
	4667	-- self.hornytimer = self.hornytimer + 20
	4668	-- deduct 10% of the time to adulthood
	4669	self.hornytimer = self.hornytimer + (
	4670	(CHILD_GROW_TIME - self.hornytimer) * 0.1)
	4671	--print ("====", self.hornytimer)
3820	4672	return true
3821	4673	end
3822	4674
3823	4675	-- feed and tame
3824	4676	self.food = (self.food or 0) + 1
	4677
3825	4678	if self.food >= feed_count then
3826	4679
3827	4680	self.food = 0

3829	4682	if breed and self.hornytimer == 0 then
3830	4683	self.horny = true
3831	4684	end
3832
3833		self.gotten = false
3834	4685
3835	4686	if tame then
3836	4687

3848	4699	end
3849	4700
3850	4701	-- make sound when fed so many times
3851		mob_sound(self, self.sounds.random)
	4702	self:mob_sound(self.sounds.random)
3852	4703	end
3853	4704
3854	4705	return true
3855	4706	end
3856	4707
3857	4708	local item = clicker:get_wielded_item()
	4709	local name = clicker:get_player_name()
3858	4710
3859	4711	-- if mob has been tamed you can name it with a nametag
3860	4712	if item:get_name() == "mobs:nametag"
3861		and clicker:get_player_name() == self.owner then
3862
3863		local name = clicker:get_player_name()
	4713	and (name == self.owner
	4714	or minetest.check_player_privs(name, "protection_bypass")) then
3864	4715
3865	4716	-- store mob and nametag stack in external variables
3866	4717	mob_obj[name] = self
3867	4718	mob_sta[name] = item
3868	4719
3869	4720	local tag = self.nametag or ""
3870
3871		minetest.show_formspec(name, "mobs_nametag", "size[8,4]"
3872		.. default.gui_bg
3873		.. default.gui_bg_img
3874		.. "field[0.5,1;7.5,0;name;"
3875		.. minetest.formspec_escape(S("Enter name:")) .. ";" .. tag .. "]"
3876		.. "button_exit[2.5,3.5;3,1;mob_rename;"
3877		.. minetest.formspec_escape(S("Rename")) .. "]")
	4721	local esc = minetest.formspec_escape
	4722
	4723	minetest.show_formspec(name, "mobs_nametag",
	4724	"size[8,4]" ..
	4725	"field[0.5,1;7.5,0;name;" ..
	4726	esc(S("Enter name:")) ..
	4727	";" .. tag .. "]" ..
	4728	"button_exit[2.5,3.5;3,1;mob_rename;" ..
	4729	esc(S("Rename")) .. "]")
	4730
	4731	return true
3878	4732	end
3879	4733
3880	4734	return false

3904	4758	end
3905	4759
3906	4760	-- limit name entered to 64 characters long
3907		if string.len(fields.name) > 64 then
3908		fields.name = string.sub(fields.name, 1, 64)
	4761	if fields.name:len() > 64 then
	4762	fields.name = fields.name:sub(1, 64)
3909	4763	end
3910	4764
3911	4765	-- update nametag
3912	4766	mob_obj[name].nametag = fields.name
3913	4767
3914		update_tag(mob_obj[name])
	4768	mob_obj[name]:update_tag()
3915	4769
3916	4770	-- if not in creative then take item
3917	4771	if not mobs.is_creative(name) then

3931	4785	-- compatibility function for old entities to new modpack entities
3932	4786	function mobs:alias_mob(old_name, new_name)
3933	4787
	4788	-- check old_name entity doesnt already exist
	4789	if minetest.registered_entities[old_name] then
	4790	return
	4791	end
	4792
3934	4793	-- spawn egg
3935	4794	minetest.register_alias(old_name, new_name)
3936	4795
3937	4796	-- entity
3938	4797	minetest.register_entity(":" .. old_name, {
3939	4798
3940		physical = false,
3941
3942		on_activate = function(self)
	4799	physical = false, static_save = false,
	4800
	4801	on_activate = function(self, staticdata)
3943	4802
3944	4803	if minetest.registered_entities[new_name] then
3945		minetest.add_entity(self.object:get_pos(), new_name)
3946		end
3947
3948		self.object:remove()
	4804
	4805	minetest.add_entity(self.object:get_pos(), new_name, staticdata)
	4806	end
	4807
	4808	remove_mob(self)
	4809	end,
	4810
	4811	get_staticdata = function(self)
	4812	return self
3949	4813	end
3950	4814	})
3951	4815	end

-3985

~~api.lua_testspawn~~ less more

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

+166

-40

api.txt less more

30	30	'hp_max' has the maximum health value the mob can spawn with.
31	31	'armor' holds strength of mob, 100 is normal, lower is more powerful
32	32	and needs more hits and better weapons to kill.
33		'passive' when true allows animals to defend themselves when hit,
	33	'passive' when false allows animals to defend themselves when hit,
34	34	otherwise they amble onwards.
35	35	'walk_velocity' is the speed that your mob can walk around.
36	36	'run_velocity' is the speed your mob can run with, usually when attacking.
	37	'stand_chance' has a 0-100 chance value your mob will stand from walking.
37	38	'walk_chance' has a 0-100 chance value your mob will walk from standing,
38	39	set to 0 for jumping mobs only.
	40	'randomly_turn' if set to false then mob will not turn to face player or
	41	randomly turn while walking or standing.
39	42	'jump' when true allows your mob to jump updwards.
40	43	'jump_height' holds the height your mob can jump, 0 to disable jumping.
41	44	'stepheight' height of a block that your mob can easily walk up onto,

43	46	'fly' when true allows your mob to fly around instead of walking.
44	47	'fly_in' holds the node name that the mob flies (or swims) around
45	48	in e.g. "air" or "default:water_source".
	49	'keep_flying' when true mobs like birds no longer stop and stand.
	50	'stay_near' when set allows mobs the chance to stay around certain nodes.
	51	'nodes' string or table of nodes to stay nearby e.g. "farming:straw"
	52	'chance' chance of searching for above node(s), default is 10.
46	53	'runaway' if true causes animals to turn and run away when hit.
47	54	'pushable' when true mobs can be pushed by player or other mobs.
48	55	'view_range' how many nodes in distance the mob can see a player.
49	56	'damage' how many health points the mob does to a player or another
50	57	mob when melee attacking.
	58	'damage_group' group in which damage is dealt, dedaults to "fleshy".
	59	'damage_texture_modifier' applies texture modifier on hit e.g "^[brighten"
51	60	'knock_back' when true has mobs falling backwards when hit, the greater
52	61	the damage the more they move back.
53	62	'fear_height' is how high a cliff or edge has to be before the mob stops

56	65	'fall_damage' when true causes falling to inflict damage.
57	66	'water_damage' holds the damage per second infliced to mobs when standing in
58	67	water.
	68	'air_damage' holds damage per second inflicted to mob when standing in air.
59	69	'lava_damage' holds the damage per second inflicted to mobs when standing
60		in lava or fire or an ignition source.
	70	in lava.
	71	'fire_damage' holds the damage per second inflicted to mobs when standing
	72	in fire.
	73
61	74	'light_damage' holds the damage per second inflicted to mobs when light
62	75	level is between the min and max values below
63	76	'light_damage_min' minimum light value when mob is affected (default: 14)
64	77	'light_damage_max' maximum light value when mob is affected (default: 15)
65		'suffocation' when true causes mobs to suffocate inside solid blocks.
	78	'suffocation' when > 0 mobs will suffocate inside solid blocks and will be
	79	hurt by the value given every second (0 to disable).
66	80	'floats' when set to 1 mob will float in water, 0 has them sink.
67	81	'follow' mobs follow player when holding any of the items which appear
68	82	on this table, the same items can be fed to a mob to tame or
69		breed e.g. {"farming:wheat", "default:apple"}
	83	breed e.g. {"farming:wheat", "default:apple", "group:fish"}
70	84
71	85	'reach' is how far the mob can attack player when standing
72	86	nearby, default is 3 nodes.

82	96	punches when nearby.
83	97	'group_attack' when true has same mob type grouping together to attack
84	98	offender.
	99	'group_helper' string containing mob name that attacks alongside
	100	current mob when group attacking.
	101	mob is attacking in groups.
85	102	'attack_type' tells the api what a mob does when attacking the player
86	103	or another mob:
87	104	'dogfight' is a melee attack when player is within mob reach.

118	135	e.g. {"player", "mobs_animal:chicken"}.
119	136	'runaway_from' contains a table with mob names to run away from, add
120	137	"player" to list to runaway from player also.
	138	'ignore_invisibility' When true mob will still be able to see and attack
	139	player even if invisible (invisibility mod only).
121	140	'blood_amount' contains the number of blood droplets to appear when
122	141	mob is hit.
123	142	'blood_texture' has the texture name to use for droplets e.g.

125	144	'pathfinding' set to 1 for mobs to use pathfinder feature to locate
126	145	player, set to 2 so they can build/break also (only
127	146	works with dogfight attack and when 'mobs_griefing'
128		in minetest.conf is not false).
	147	in minetest.conf is not false). Adding {unbreakable=1}
	148	to node groups stops them being broken by mobs.
129	149	'immune_to' is a table that holds specific damage when being hit by
130	150	certain items e.g.
131	151	{"default:sword_wood", 0} -- causes no damage.

152	172	'min' minimum number of items dropped, set to 0 for rare drops.
153	173	'max' maximum number of items dropped.
154	174	Note: If weapon has {fire=1} damage group set then cooked items will drop.
	175	Note2: A function can now be passed which can also return drops table, e.g.
	176	drops = function(pos)
	177	-- do something
	178	return { {name = "farming:bread"}, {name = "default:dirt", chance = 2} }
	179	end
155	180
156	181	'visual' holds the look of the mob you wish to create:
157	182	'cube' looks like a normal node

169	194	'child_texture' holds the texture table for when baby mobs are used.
170	195	'gotten_texture' holds the texture table for when self.gotten value is
171	196	true, used for milking cows or shearing sheep.
	197	'texture_mods' holds a string which overlays a texture on top of the
	198	mob texture e.g. "^saddle.png"
172	199	'mesh' holds the name of the external object used for mob model
173	200	e.g. "mobs_cow.b3d"
174	201	'gotten_mesh" holds the name of the external object used for when
175	202	self.gotten is true for mobs.
176	203	'rotate' custom model rotation, 0 = front, 90 = side, 180 = back,
177	204	270 = other side.
	205	'glow' has mob glow without light source, 0 to 15 or nil to disable
178	206	'double_melee_attack' when true has the api choose between 'punch' and
179	207	'punch2' animations. [DEPRECATED]
180	208
181		'animation' holds a table containing animation names and settings for use with mesh models:
	209	'animation' holds a table containing animation names and settings for use with
	210	mesh models:
182	211	'stand_start' start frame for when mob stands still.
183	212	'stand_end' end frame of stand animation.
184	213	'stand_speed' speed of animation in frames per second.

204	233	'die_end'
205	234	'die_speed'
206	235	'die_loop' when set to false stops the animation looping.
	236	'die_rotate' if true mob spins during death animation.
207	237
208	238	Using '_loop = false' setting will stop any of the above animations from
209	239	looping.

243	273	If false is returned, the mob will not replace the node.
244	274
245	275	By default, replacing sets self.gotten to true and resets the object
246		properties.
	276	properties. (DEPRECATED, use on_replace to make changes).
247	277
248	278
249	279	Custom Definition Functions

272	302	time_from_last_punch, tool_capabilities, direction), return
273	303	false to stop punch damage and knockback from taking place.
274	304	'custom_attack' when set this function is called instead of the normal mob
275		melee attack, parameters are (self, to_attack).
276		'on_die' a function that is called when mob is killed (self, pos)
	305	melee attack, parameters are (self, to_attack) and if true
	306	is returned normal attack function continued.
	307	'on_die' a function that is called when mob is killed (self, pos), also
	308	has access to self.cause_of_death table.
	309	'on_flop' function called when flying or swimmimng mob is no longer in
	310	air/water, (self) paramater and return true to skip the built
	311	in api flop feature.
277	312	'do_custom' a custom function that is called every tick while mob is
278	313	active and which has access to all of the self.* variables
279	314	e.g. (self.health for health or self.standing_in for node

305	340	'self.order' set to "follow" or "stand" so that npc will follow owner
306	341	or stand it's ground
307	342	'self.nametag' contains the name of the mob which it can show above
	343	'self.state' Current mob state.
	344	"stand": no movement (except turning around)
	345	"walk": walk or move around aimlessly
	346	"attack": chase and attack enemy
	347	"runaway": flee from target
	348	"flop": bounce around aimlessly
	349	(for swimming mobs that have stranded)
	350	"die": during death
	351
	352
	353	Adding Mobs in World
	354	--------------------
	355
	356	mobs:add_mob(pos, {
	357	name = "mobs_animal:chicken",
	358	child = true,
	359	owner = "singleplayer",
	360	nametag = "Bessy",
	361	ignore_count = true -- ignores mob count per map area
	362	})
	363
	364	Returns false if mob could not be added, returns mob object if spawned ok.
	365
	366
	367	Removing Mob from World
	368	-----------------------
	369
	370	mobs:remove(self, decrease)
	371
	372	Removes mob 'self' from the world and if 'decrease' is true then the mob counter
	373	will also be decreased by one.
308	374
309	375
310	376	Spawning Mobs in World
311	377	----------------------
312	378
313		mobs:register_spawn(name, nodes, max_light, min_light, chance,
314		active_object_count, max_height, day_toggle)
315
316		mobs:spawn_specfic(name, nodes, neighbors, min_light, max_light, interval,
317		chance, active_object_count, min_height, max_height, day_toggle, on_spawn)
318
319		These functions register a spawn algorithm for the mob. Without this function
320		the call the mobs won't spawn.
	379	mobs:spawn({
	380	name = "mobs_monster:tree_monster",
	381	nodes = {"group:leaves"},
	382	max_light = 7,
	383	})
	384
	385	Spawn functions require the following settings, some of which already have a
	386	default setting and can be omitted:
321	387
322	388	'name' is the name of the animal/monster
323	389	'nodes' is a list of nodenames on that the animal/monster can
324		spawn on top of
	390	spawn on top of (defaults to {"group:dirt", "group:stone"}
325	391	'neighbors' is a list of nodenames on that the animal/monster will
326		spawn beside (default is {"air"} for
327		mobs:register_spawn)
328		'max_light' is the maximum of light
329		'min_light' is the minimum of light
330		'interval' is same as in register_abm() (default is 30 for
331		mobs:register_spawn)
332		'chance' is same as in register_abm()
	392	spawn beside (default is {"air"})
	393	'interval' is same as in register_abm() (default is 30)
	394	'chance' is same as in register_abm() (default is 5000)
	395	'min_light' is the minimum light level (default is 0)
	396	'max_light' is the maximum light (default is 15)
	397	'min_height' is the minimum height a mob can spawn (default: -31000)
	398	'max_height' is the maximum height a mob can spawn (default is 31000)
333	399	'active_object_count' number of this type of mob to spawn at one time inside
334		map area
335		'min_height' is the minimum height the mob can spawn
336		'max_height' is the maximum height the mob can spawn
	400	map area (default is 1)
337	401	'day_toggle' true for day spawning, false for night or nil for
338	402	anytime
339	403	'on_spawn' is a custom function which runs after mob has spawned
340	404	and gives self and pos values.
	405	'on_map_load' when true mobs will have a chance of spawning only
	406	when new areas of map are loaded, interval will not be
	407	used.
	408
	409	The older spawn functions are still active and working but have no defaults like
	410	the mobs:spawn, so it is recommended to use the above instead.
	411
	412	mobs:register_spawn(name, nodes, max_light, min_light, chance,
	413	active_object_count, max_height, day_toggle)
	414
	415	mobs:spawn_specfic(name, nodes, neighbors, min_light, max_light, interval,
	416	chance, active_object_count, min_height, max_height, day_toggle, on_spawn)
341	417
342	418	A simpler way to handle mob spawns has been added with the mobs:spawn(def)
343	419	command which uses above names to make settings clearer:
344
345		mobs:spawn({name = "mobs_monster:tree_monster",
346		nodes = {"group:leaves"},
347		max_light = 7,
348		})
349	420
350	421
351	422	For each mob that spawns with this function is a field in mobs.spawning_mobs.

363	434	'pos' holds the position of the spawning mob
364	435	'node' contains the node the mob is spawning on top of
365	436	'name' is the name of the animal/monster
	437
	438
	439	Particle Effects
	440	----------------
	441
	442	mobs:effect(pos, amount, texture, min_size, max_size, radius, gravity, glow, fall)
	443
	444	This function provides a quick way to spawn particles as an effect.
	445
	446	'pos' center position of particle effect.
	447	'amount' how many particles.
	448	'texture' texture filename to use for effect.
	449	'min_size' smallest particle size.
	450	'max_size' largest particle size.
	451	'radius' how far particles spread outward from center.
	452	'gravity' gravity applied to particles once they spawn.
	453	'glow' number between 1 and 15 for glowing particles.
	454	'fall' when true particles fall, false has them rising, nil has them scatter.
366	455
367	456
368	457	Making Arrows

377	466	'visual' same is in minetest.register_entity()
378	467	'visual_size' same is in minetest.register_entity()
379	468	'textures' same is in minetest.register_entity()
	469	'physical' same is in minetest.register_entity() [default: false]
	470	'collide_with_objects' same as above
380	471	'velocity' the velocity of the arrow
381	472	'drop' if set to true any arrows hitting a node will drop as item
382	473	'hit_player' a function that is called when the arrow hits a player;

385	476	'hit_mob' a function that is called when the arrow hits a mob;
386	477	this function should hurt the mob, the parameters are
387	478	(self, player)
	479	'hit_object' a function that is called when the arrow hits an object;
	480	this function parameters are (self, player)
388	481	'hit_node' a function that is called when the arrow hits a node, the
389	482	parameters are (self, pos, node)
390	483	'tail' when set to 1 adds a trail or tail to mob arrows

398	491	'on_step' is a custom function when arrow is active, nil for
399	492	default.
400	493	'on_punch' is a custom function when arrow is punched, nil by default
401		'collisionbox' is hitbox table for arrow, {0,0,0,0,0,0} by default.
	494	'collisionbox' is hitbox table for arrow, {-.1,-.1,-.1,.1,.1,.1} by default.
	495	'lifetime' contains float value for how many seconds arrow exists in
	496	world before being removed (default is 4.5 seconds).
402	497
403	498
404	499	Spawn Eggs

406	501
407	502	mobs:register_egg(name, description, background, addegg, no_creative)
408	503
409		This function registers a spawn egg which can be used by admin to properly spawn in a mob.
	504	This function registers a spawn egg which can be used to properly spawn in a mob.
	505	Animals are spawned as tamed unless sneak/shift is held while spawning.
410	506
411	507	'name' this is the name of your new mob to spawn e.g. "mob:sheep"
412	508	'description' the name of the new egg you are creating e.g. "Spawn Sheep"

452	548	'force_take' take mob by force, even if tamed (true or false)
453	549	'replacewith' once captured replace mob with this item instead (overrides
454	550	new mob eggs with saved information)
	551
	552	mobs:force_capture(self, clicker)
	553
	554	Same as above but does no checks, it simply captures any and all mobs and places
	555	inside a spawn egg containing all of the mob information.
455	556
456	557
457	558	Feeding and Taming/Breeding

565	666	'self.driver_scale' sets driver scale for mobs larger than {x=1, y=1}
566	667
567	668
568		mobs:line_of_sight(self, pos1, pos2, stepsize)
	669	mobs:line_of_sight(self, pos1, pos2, stepsize) [DEPRECATED]
569	670
570	671	This function is for use within the mobs definition for special use cases and
571	672	returns true if a mob can see the player or victim.

574	675	'pos1' position of mob
575	676	'pos2' position of vistim or player
576	677	'stepsize' usually set to 1
	678
	679	Use this instead:
	680
	681	mob_class:line_of_sight(pos1, pos2, stepsize)
	682
	683
	684	mobs:can_spawn(pos, name)
	685
	686	This function checks the surrounding area at [pos] to see if there is enough empty
	687	space to spawn mob [name], if so then a new position is returned for use,
	688	otherwise nil is returned.
577	689
578	690
579	691	External Settings for "minetest.conf"

586	698	is false)
587	699	'mobs_spawn_protected' if set to false then mobs will not spawn in protected
588	700	areas (default is true)
	701	'mobs_spawn_monster_protected' if set to false then monsters will not spawn in
	702	protected areas (default is true)
589	703	'remove_far_mobs' if true then untamed mobs that are outside players
590	704	visual range will be removed (default is true)
591	705	'mobname' can change specific mob chance rate (0 to disable) and

604	718	'mobs_griefing' when false mobs cannot break blocks when using either
605	719	pathfinding level 2, replace functions or mobs:boom
606	720	function.
	721	'mob_nospawn_range' Minimum range a mob can spawn near player (def: 12)
	722	'mob_active_limit' Number of active mobs in game, 0 for unlimited
	723	'mob_area_spawn' When true will check surrounding area the size of the
	724	mob for obstructions before spawning, otherwise it
	725	defaults to checking the height of the mob only.
	726	'mob_smooth_rotate' Enables smooth rotation when mobs turn by default.
607	727
608	728	Players can override the spawn chance for each mob registered by adding a line
609	729	to their minetest.conf file with a new value, the lower the value the more each
610	730	mob will spawn e.g.
611	731
612		mobs_animal:sheep_chance 11000
613		mobs_monster:sand_monster_chance 100
	732	mobs_animal:sheep 11000
	733	mobs_monster:sand_monster 100
	734
	735	...you can also change how many of a certain mob appear in an active mapblock by
	736	adding a comma and then a new value e.g.
	737
	738	mobs_animal:cow = 8000,4 <-- 4 cows per mapblock at 8000 spawn chance
	739	mobs_monster:dirt_monster = ,20 <-- 20 dirt monsters per mapblock
614	740
615	741
616	742	Rideable Horse Example Mob

622	748	visual_size = {x = 1.20, y = 1.20},
623	749	mesh = "mobs_horse.x",
624	750	collisionbox = {-0.4, -0.01, -0.4, 0.4, 1.25, 0.4},
625		animation = {
	751	animation = {
626	752	speed_normal = 15,
627	753	speed_run = 30,
628	754	stand_start = 25,

721	847	if inv:room_for_item("main", "mobs:saddle") then
722	848	inv:add_item("main", "mobs:saddle")
723	849	else
724		minetest.add_item(clicker.getpos(), "mobs:saddle")
	850	minetest.add_item(clicker.get_pos(), "mobs:saddle")
725	851	end
726	852
727	853	-- attach player to horse

+214

-60

crafts.lua less more

4	4	minetest.register_craftitem("mobs:nametag", {
5	5	description = S("Name Tag"),
6	6	inventory_image = "mobs_nametag.png",
7		groups = {flammable = 2},
	7	groups = {flammable = 2, nametag = 1}
8	8	})
9	9
10	10	if minetest.get_modpath("dye") and minetest.get_modpath("farming") then
11	11	minetest.register_craft({
12		type = "shapeless",
13	12	output = "mobs:nametag",
14		recipe = {"default:paper", "dye:black", "farming:string"},
	13	recipe = {{"default:paper", "dye:black", "farming:string"}}
15	14	})
16	15	end
17	16

19	18	minetest.register_craftitem("mobs:leather", {
20	19	description = S("Leather"),
21	20	inventory_image = "mobs_leather.png",
22		groups = {flammable = 2},
	21	groups = {flammable = 2, leather = 1}
23	22	})
24	23
25	24	-- raw meat

27	26	description = S("Raw Meat"),
28	27	inventory_image = "mobs_meat_raw.png",
29	28	on_use = minetest.item_eat(3),
30		groups = {food_meat_raw = 1, flammable = 2},
	29	groups = {food_meat_raw = 1, flammable = 2}
31	30	})
32	31
33	32	-- cooked meat

35	34	description = S("Meat"),
36	35	inventory_image = "mobs_meat.png",
37	36	on_use = minetest.item_eat(8),
38		groups = {food_meat = 1, flammable = 2},
	37	groups = {food_meat = 1, flammable = 2}
39	38	})
40	39
41	40	minetest.register_craft({
42	41	type = "cooking",
43	42	output = "mobs:meat",
44	43	recipe = "mobs:meat_raw",
45		cooktime = 5,
	44	cooktime = 5
46	45	})
47	46
48	47	-- lasso
49	48	minetest.register_tool("mobs:lasso", {
50	49	description = S("Lasso (right-click animal to put in inventory)"),
51	50	inventory_image = "mobs_magic_lasso.png",
52		groups = {flammable = 2},
	51	groups = {flammable = 2}
53	52	})
54	53
55	54	if minetest.get_modpath("farming") then

58	57	recipe = {
59	58	{"farming:string", "", "farming:string"},
60	59	{"", "default:diamond", ""},
61		{"farming:string", "", "farming:string"},
	60	{"farming:string", "", "farming:string"}
62	61	}
63	62	})
64	63	end

69	68	minetest.register_tool("mobs:net", {
70	69	description = S("Net (right-click animal to put in inventory)"),
71	70	inventory_image = "mobs_net.png",
72		groups = {flammable = 2},
	71	groups = {flammable = 2}
73	72	})
74	73
75	74	if minetest.get_modpath("farming") then

78	77	recipe = {
79	78	{"group:stick", "", "group:stick"},
80	79	{"group:stick", "", "group:stick"},
81		{"farming:string", "group:stick", "farming:string"},
	80	{"farming:string", "group:stick", "farming:string"}
82	81	}
83	82	})
84	83	end

87	86	minetest.register_tool("mobs:shears", {
88	87	description = S("Steel Shears (right-click to shear)"),
89	88	inventory_image = "mobs_shears.png",
90		groups = {flammable = 2},
91		})
92
93		minetest.register_craft({
94		output = 'mobs:shears',
95		recipe = {
96		{'', 'default:steel_ingot', ''},
97		{'', 'group:stick', 'default:steel_ingot'},
	89	groups = {flammable = 2}
	90	})
	91
	92	minetest.register_craft({
	93	output = "mobs:shears",
	94	recipe = {
	95	{"", "default:steel_ingot", ""},
	96	{"", "group:stick", "default:steel_ingot"}
98	97	}
99	98	})
100	99

102	101	minetest.register_craftitem("mobs:protector", {
103	102	description = S("Mob Protection Rune"),
104	103	inventory_image = "mobs_protector.png",
105		groups = {flammable = 2},
	104	groups = {flammable = 2}
106	105	})
107	106
108	107	minetest.register_craft({

110	109	recipe = {
111	110	{"default:stone", "default:stone", "default:stone"},
112	111	{"default:stone", "default:goldblock", "default:stone"},
113		{"default:stone", "default:stone", "default:stone"},
	112	{"default:stone", "default:stone", "default:stone"}
	113	}
	114	})
	115
	116	-- level 2 protection rune
	117	minetest.register_craftitem("mobs:protector2", {
	118	description = S("Mob Protection Rune (Level 2)"),
	119	inventory_image = "mobs_protector2.png",
	120	groups = {flammable = 2}
	121	})
	122
	123	minetest.register_craft({
	124	output = "mobs:protector2",
	125	recipe = {
	126	{"mobs:protector", "default:mese_crystal", "mobs:protector"},
	127	{"default:mese_crystal", "default:diamondblock", "default:mese_crystal"},
	128	{"mobs:protector", "default:mese_crystal", "mobs:protector"}
114	129	}
115	130	})
116	131

118	133	minetest.register_craftitem("mobs:saddle", {
119	134	description = S("Saddle"),
120	135	inventory_image = "mobs_saddle.png",
121		groups = {flammable = 2},
	136	groups = {flammable = 2, saddle = 1}
122	137	})
123	138
124	139	minetest.register_craft({

126	141	recipe = {
127	142	{"mobs:leather", "mobs:leather", "mobs:leather"},
128	143	{"mobs:leather", "default:steel_ingot", "mobs:leather"},
129		{"mobs:leather", "default:steel_ingot", "mobs:leather"},
130		}
131		})
	144	{"mobs:leather", "default:steel_ingot", "mobs:leather"}
	145	}
	146	})
	147
	148
	149	-- make sure we can register fences
	150	if minetest.get_modpath("default") and default.register_fence then
132	151
133	152	-- mob fence (looks like normal fence but collision is 2 high)
134	153	default.register_fence("mobs:fence_wood", {

141	160	type = "fixed",
142	161	fixed = {
143	162	{-0.5, -0.5, -0.5, 0.5, 1.9, 0.5},
144		},
	163	}
	164	}
	165	})
	166	end
	167
	168	-- mob fence top (has enlarged collisionbox to stop mobs getting over)
	169	minetest.register_node("mobs:fence_top", {
	170	description = S("Mob Fence Top"),
	171	drawtype = "nodebox",
	172	tiles = {"default_wood.png"},
	173	paramtype = "light",
	174	is_ground_content = false,
	175	groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 2},
	176	sounds = default.node_sound_wood_defaults(),
	177	node_box = {
	178	type = "fixed",
	179	fixed = {-0.2, -0.5, -0.2, 0.2, 0, 0.2}
145	180	},
146		})
147
148		-- mob fence top (has enlarged collisionbox to stop mobs getting over)
149		minetest.register_node("mobs:fence_top", {
150		description = S("Mob Fence Top"),
151		drawtype = "nodebox",
152		tiles = {"default_wood.png"},
153		paramtype = "light",
154		is_ground_content = false,
155		groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 2},
156		sounds = default.node_sound_wood_defaults(),
157		node_box = {
158		type = "fixed",
159		fixed = {-0.2, -0.5, -0.2, 0.2, 0, 0.2},
160		},
161		collision_box = {
162		type = "fixed",
163		fixed = {-0.4, -1.5, -0.4, 0.4, 0, 0.4},
164		},
165		selection_box = {
166		type = "fixed",
167		fixed = {-0.4, -1.5, -0.4, 0.4, 0, 0.4},
168		},
	181	collision_box = {
	182	type = "fixed",
	183	fixed = {-0.4, -1.5, -0.4, 0.4, 0, 0.4}
	184	},
	185	selection_box = {
	186	type = "fixed",
	187	fixed = {-0.4, -1.5, -0.4, 0.4, 0, 0.4}
	188	}
169	189	})
170	190
171	191	minetest.register_craft({
172	192	output = "mobs:fence_top 12",
173	193	recipe = {
174	194	{"group:wood", "group:wood", "group:wood"},
175		{"", "default:fence_wood", ""},
176		}
177		})
	195	{"", "default:fence_wood", ""}
	196	}
	197	})
	198
178	199
179	200	-- items that can be used as fuel
180	201	minetest.register_craft({
181	202	type = "fuel",
182	203	recipe = "mobs:nametag",
183		burntime = 3,
	204	burntime = 3
184	205	})
185	206
186	207	minetest.register_craft({
187	208	type = "fuel",
188	209	recipe = "mobs:lasso",
189		burntime = 7,
	210	burntime = 7
190	211	})
191	212
192	213	minetest.register_craft({
193	214	type = "fuel",
194	215	recipe = "mobs:net",
195		burntime = 8,
	216	burntime = 8
196	217	})
197	218
198	219	minetest.register_craft({
199	220	type = "fuel",
200	221	recipe = "mobs:leather",
201		burntime = 4,
	222	burntime = 4
202	223	})
203	224
204	225	minetest.register_craft({
205	226	type = "fuel",
206	227	recipe = "mobs:saddle",
207		burntime = 7,
	228	burntime = 7
208	229	})
209	230
210	231	minetest.register_craft({
211	232	type = "fuel",
212	233	recipe = "mobs:fence_wood",
213		burntime = 7,
	234	burntime = 7
214	235	})
215	236
216	237	minetest.register_craft({
217	238	type = "fuel",
218	239	recipe = "mobs:fence_top",
219		burntime = 2,
220		})
	240	burntime = 2
	241	})
	242
	243
	244	-- this tool spawns same mob and adds owner, protected, nametag info
	245	-- then removes original entity, this is used for fixing any issues.
	246
	247	local tex_obj
	248
	249	minetest.register_tool(":mobs:mob_reset_stick", {
	250	description = S("Mob Reset Stick"),
	251	inventory_image = "default_stick.png^[colorize:#ff000050",
	252	stack_max = 1,
	253	groups = {not_in_creative_inventory = 1},
	254
	255	on_use = function(itemstack, user, pointed_thing)
	256
	257	if pointed_thing.type ~= "object" then
	258	return
	259	end
	260
	261	local obj = pointed_thing.ref
	262
	263	local control = user:get_player_control()
	264	local sneak = control and control.sneak
	265
	266	-- spawn same mob with saved stats, with random texture
	267	if obj and not sneak then
	268
	269	local self = obj:get_luaentity()
	270	local obj2 = minetest.add_entity(obj:get_pos(), self.name)
	271
	272	if obj2 then
	273
	274	local ent2 = obj2:get_luaentity()
	275
	276	ent2.protected = self.protected
	277	ent2.owner = self.owner
	278	ent2.nametag = self.nametag
	279	ent2.gotten = self.gotten
	280	ent2.tamed = self.tamed
	281	ent2.health = self.health
	282	ent2.order = self.order
	283
	284	if self.child then
	285	obj2:set_velocity({x = 0, y = self.jump_height, z = 0})
	286	end
	287
	288	obj2:set_properties({nametag = self.nametag})
	289
	290	obj:remove()
	291	end
	292	end
	293
	294	-- display form to enter texture name ending in .png
	295	if obj and sneak then
	296
	297	tex_obj = obj
	298
	299	-- get base texture
	300	local bt = tex_obj:get_luaentity().base_texture[1]
	301
	302	if type(bt) ~= "string" then
	303	bt = ""
	304	end
	305
	306	local name = user:get_player_name()
	307
	308	minetest.show_formspec(name, "mobs_texture", "size[8,4]"
	309	.. "field[0.5,1;7.5,0;name;"
	310	.. minetest.formspec_escape(S("Enter texture:")) .. ";" .. bt .. "]"
	311	.. "button_exit[2.5,3.5;3,1;mob_texture_change;"
	312	.. minetest.formspec_escape(S("Change")) .. "]")
	313	end
	314	end
	315	})
	316
	317	minetest.register_on_player_receive_fields(function(player, formname, fields)
	318
	319	-- right-clicked with nametag and name entered?
	320	if formname == "mobs_texture"
	321	and fields.name
	322	and fields.name ~= "" then
	323
	324	-- does mob still exist?
	325	if not tex_obj
	326	or not tex_obj:get_luaentity() then
	327	return
	328	end
	329
	330	-- make sure nametag is being used to name mob
	331	local item = player:get_wielded_item()
	332
	333	if item:get_name() ~= "mobs:mob_reset_stick" then
	334	return
	335	end
	336
	337	-- limit name entered to 64 characters long
	338	if fields.name:len() > 64 then
	339	fields.name = fields.name:sub(1, 64)
	340	end
	341
	342	-- update texture
	343	local self = tex_obj:get_luaentity()
	344
	345	self.base_texture = {fields.name}
	346
	347	tex_obj:set_properties({textures = {fields.name}})
	348
	349	-- reset external variable
	350	tex_obj = nil
	351	end
	352	end)
	353
	354
	355	-- Meat Block (thanks to painterlypack.net for allowing me to use these textures)
	356	minetest.register_node("mobs:meatblock", {
	357	description = S("Meat Block"),
	358	tiles = {"mobs_meat_top.png", "mobs_meat_bottom.png", "mobs_meat_side.png"},
	359	paramtype2 = "facedir",
	360	groups = {choppy = 1, oddly_breakable_by_hand = 1, flammable = 2},
	361	sounds = default and default.node_sound_leaves_defaults(),
	362	on_place = minetest.rotate_node,
	363	on_use = minetest.item_eat(20)
	364	})
	365
	366	minetest.register_craft({
	367	output = "mobs:meatblock",
	368	-- type = "shapeless",
	369	recipe = {
	370	{"group:food_meat", "group:food_meat", "group:food_meat"},
	371	{"group:food_meat", "group:food_meat", "group:food_meat"},
	372	{"group:food_meat", "group:food_meat", "group:food_meat"}
	373	}
	374	})

-1

depends.txt less more

0		default
	0	default?
1	1	tnt?
2	2	dye?
3	3	farming?

6	6	lucky_block?
7	7	cmi?
8	8	toolranks?
	9	pathfinder?

-0

init.lua less more

0	0
1	1	local path = minetest.get_modpath("mobs")
	2
	3	-- Peaceful player privilege
	4	minetest.register_privilege("peaceful_player", {
	5	description = "Prevents Mobs Redo mobs from attacking player",
	6	give_to_singleplayer = false
	7	})
2	8
3	9	-- Mob API
4	10	dofile(path .. "/api.lua")

-44

intllib.lua less more

	0	-- Support for the old multi-load method
	1	dofile(minetest.get_modpath("intllib").."/init.lua")
0	2
1		-- Fallback functions for when `intllib` is not installed.
2		-- Code released under Unlicense <http://unlicense.org>.
3
4		-- Get the latest version of this file at:
5		-- https://raw.githubusercontent.com/minetest-mods/intllib/master/lib/intllib.lua
6
7		local function format(str, ...)
8		local args = { ... }
9		local function repl(escape, open, num, close)
10		if escape == "" then
11		local replacement = tostring(args[tonumber(num)])
12		if open == "" then
13		replacement = replacement..close
14		end
15		return replacement
16		else
17		return "@"..open..num..close
18		end
19		end
20		return (str:gsub("(@?)@(%(?)(%d+)(%)?)", repl))
21		end
22
23		local gettext, ngettext
24		if minetest.get_modpath("intllib") then
25		if intllib.make_gettext_pair then
26		-- New method using gettext.
27		gettext, ngettext = intllib.make_gettext_pair()
28		else
29		-- Old method using text files.
30		gettext = intllib.Getter()
31		end
32		end
33
34		-- Fill in missing functions.
35
36		gettext = gettext or function(msgid, ...)
37		return format(msgid, ...)
38		end
39
40		ngettext = ngettext or function(msgid, msgid_plural, n, ...)
41		return format(n==1 and msgid or msgid_plural, ...)
42		end
43
44		return gettext, ngettext

+15

-8

locale/fr.po less more

2	2	# This file is distributed under the same license as the PACKAGE package.
3	3	# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
4	4	#
	5	#, fuzzy
5	6	msgid ""
6	7	msgstr ""
7	8	"Project-Id-Version: \n"
8	9	"Report-Msgid-Bugs-To: \n"
9	10	"POT-Creation-Date: 2017-07-29 09:13+0200\n"
10		"PO-Revision-Date: 2017-07-29 09:20+0200\n"
	11	"PO-Revision-Date: 2020-08-13 21:20+0500\n"
	12	"Last-Translator: Olivier Dragon <odragon@protonmail.com>\n"
11	13	"Language-Team: \n"
	14	"Language: fr\n"
12	15	"MIME-Version: 1.0\n"
13	16	"Content-Type: text/plain; charset=UTF-8\n"
14	17	"Content-Transfer-Encoding: 8bit\n"
15		"X-Generator: Poedit 1.8.12\n"
16		"Last-Translator: fat115 <fat115@framasoft.org>\n"
17		"Plural-Forms: nplurals=2; plural=(n > 1);\n"
18		"Language: fr\n"
19	18
20	19	#: api.lua
21	20	msgid "** Peaceful Mode Active - No Monsters Will Spawn"

63	62
64	63	#: crafts.lua
65	64	msgid "Name Tag"
66		msgstr "Étiquette pour collier"
	65	msgstr "Étiquette de collier"
67	66
68	67	#: crafts.lua
69	68	msgid "Leather"

101	100	msgid "Mob Fence"
102	101	msgstr "Clôture à animaux"
103	102
	103	#: crafts.lua
	104	msgid "Mob Fence Top"
	105	msgstr "Haut de clôture à animaux"
	106
104	107	#: spawner.lua
105	108	msgid "Mob Spawner"
106	109	msgstr "Générateur de mob"
107	110
108	111	#: spawner.lua
109		msgid "Mob MinLight MaxLight Amount PlayerDist"
110		msgstr "Mob MinLumière MaxLumière Quantité DistanceJoueur"
	112	msgid "(mob name) (min light) (max light) (amount) (player distance) (Y offset)"
	113	msgstr "(Nom) (MinLumière) (MaxLumière) (Quantité) (Distance du Joueur) (Décalage en Y)"
111	114
112	115	#: spawner.lua
113	116	msgid "Spawner Not Active (enter settings)"
114	117	msgstr "Générateur non actif (entrez les paramètres)"
	118
	119	#: spawner.lua
	120	msgid "Command:"
	121	msgstr "Commande:"
115	122
116	123	#: spawner.lua
117	124	msgid "Spawner Active (@1)"

+13

-13

locale/it.po less more

7	7	"Project-Id-Version: Italian locale file for the Mobs Redo module\n"
8	8	"Report-Msgid-Bugs-To: \n"
9	9	"POT-Creation-Date: 2017-07-02 16:48+0200\n"
10		"PO-Revision-Date: 2017-08-18 12:18+0100\n"
11		"Last-Translator: H4mlet <h4mlet@riseup.net>\n"
	10	"PO-Revision-Date: 2020-05-11 13:33+0200\n"
	11	"Last-Translator: Hamlet <hamlatgitlab@riseup.net>\n"
12	12	"Language-Team: \n"
13	13	"Language: it\n"
14	14	"MIME-Version: 1.0\n"
15	15	"Content-Type: text/plain; charset=UTF-8\n"
16	16	"Content-Transfer-Encoding: 8bit\n"
17	17	"Plural-Forms: nplurals=2; plural=(n != 1);\n"
18		"X-Generator: Poedit 1.6.10\n"
	18	"X-Generator: Poedit 2.2.1\n"
19	19
20	20	#: api.lua
21	21	msgid "** Peaceful Mode Active - No Monsters Will Spawn"
22		msgstr ""
	22	msgstr "** Modalità pacifica attiva - non comparirà nessun mostro"
23	23
24	24	#: api.lua
25	25	msgid "Mob has been protected!"

27	27
28	28	#: api.lua
29	29	msgid "@1 (Tamed)"
30		msgstr "@1 (Addomesticat*)"
	30	msgstr "@1 (Addomesticato)"
31	31
32	32	#: api.lua
33	33	msgid "Not tamed!"
34		msgstr "Non addomesticat*!"
	34	msgstr "Non addomesticato!"
35	35
36	36	#: api.lua
37	37	msgid "@1 is owner!"
38		msgstr "Proprietari* @1!"
	38	msgstr "Il padrone è @1!"
39	39
40	40	#: api.lua
41	41	msgid "Missed!"
42		msgstr "Mancat*!"
	42	msgstr "Mancato!"
43	43
44	44	#: api.lua
45	45	msgid "Already protected!"
46		msgstr "Già protett*!"
	46	msgstr "Già protetto!"
47	47
48	48	#: api.lua
49	49	msgid "@1 at full health (@2)"

51	51
52	52	#: api.lua
53	53	msgid "@1 has been tamed!"
54		msgstr "@1 è stat* addomesticat*!"
	54	msgstr "@1 è stato addomesticato!"
55	55
56	56	#: api.lua
57	57	msgid "Enter name:"

59	59
60	60	#: api.lua
61	61	msgid "Rename"
62		msgstr "Rinominare"
	62	msgstr "Rinomina"
63	63
64	64	#: crafts.lua
65	65	msgid "Name Tag"

99	99
100	100	#: crafts.lua
101	101	msgid "Mob Fence"
102		msgstr ""
	102	msgstr "Recinzione per mob"
103	103
104	104	#: spawner.lua
105	105	msgid "Mob Spawner"

127	127	"distance[1-20] y_offset[-10 to 10]”"
128	128	msgstr ""
129	129	"Sintassi: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 per "
130		"disabilitare] distance[1-20] y_offset[-10 to 10]”"
	130	"disabilitare] distance[1-20] y_offset[-10 fino a 10]”"

+34

-0

locale/mobs.de_DE.tr less more

	0	# textdomain:mobs
	1	#** Peaceful Mode Active - No Monsters Will Spawn=
	2	@1 (Tamed)=@1 (Gezähmt)
	3	@1 at full health (@2)=@1 bei voller Gesundheit (@2)
	4	@1 has been tamed!=@1 wurde gezähmt!
	5	@1 is owner!=@1 ist der Besitzer!
	6	#Active Mob Limit Reached!=
	7	Already protected!=Bereits geschützt!
	8	#Change=
	9	#Command:=
	10	Enter name:=Namen eingeben:
	11	#Enter texture:=
	12	Lasso (right-click animal to put in inventory)=Lasso (Rechtsklick auf Tier, um es zu nehmen)
	13	Leather=Leder
	14	Meat=Fleisch
	15	Missed!=Daneben!
	16	Mob Fence=Kreaturen Zaun
	17	#Mob Fence Top=
	18	Mob Protection Rune=Kreaturschutzrune
	19	#Mob Reset Stick=
	20	#Mob Spawner=
	21	Mob Spawner settings failed!=Kreaturenspawner-Einstellungen gescheitert!
	22	Mob has been protected!=Kreatur wurde geschützt!
	23	Name Tag=Namensschild
	24	Net (right-click animal to put in inventory)=Netz (Rechtsklick auf Tier, um es zu nehmen)
	25	Not tamed!=Nicht gezähmt!
	26	Raw Meat=Rohes Fleisch
	27	Rename=Umbenennen
	28	Saddle=Sattel
	29	Spawner Active (@1)=Spawner aktiv (@1)
	30	Spawner Not Active (enter settings)=Nicht aktiv (Einstellungen eingeben)
	31	Steel Shears (right-click to shear)=Stahlschere (Rechtsklick zum Scheren)
	32	#Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] player_distance[1-20] y_offset[-10 to 10]”=
	33	#lifetimer expired, removed @1=

+34

-0

locale/mobs.en.tr less more

	0	# textdomain:mobs
	1	#** Peaceful Mode Active - No Monsters Will Spawn=
	2	#@1 (Tamed)=
	3	#@1 at full health (@2)=
	4	#@1 has been tamed!=
	5	#@1 is owner!=
	6	#Active Mob Limit Reached!=
	7	#Already protected!=
	8	#Change=
	9	#Command:=
	10	#Enter name:=
	11	#Enter texture:=
	12	#Lasso (right-click animal to put in inventory)=
	13	#Leather=
	14	#Meat=
	15	#Missed!=
	16	#Mob Fence=
	17	#Mob Fence Top=
	18	#Mob Protection Rune=
	19	#Mob Reset Stick=
	20	#Mob Spawner=
	21	#Mob Spawner settings failed!=
	22	#Mob has been protected!=
	23	#Name Tag=
	24	#Net (right-click animal to put in inventory)=
	25	#Not tamed!=
	26	#Raw Meat=
	27	#Rename=
	28	#Saddle=
	29	#Spawner Active (@1)=
	30	#Spawner Not Active (enter settings)=
	31	#Steel Shears (right-click to shear)=
	32	#Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] player_distance[1-20] y_offset[-10 to 10]”=
	33	#lifetimer expired, removed @1=

+34

-0

locale/mobs.es.tr less more

	0	# textdomain:mobs
	1	#** Peaceful Mode Active - No Monsters Will Spawn=
	2	@1 (Tamed)=@1 (Domesticado)
	3	@1 at full health (@2)=@1 con salud llena (@2)
	4	@1 has been tamed!=@1 ha sido domesticado!
	5	@1 is owner!=@1 es el dueño!
	6	#Active Mob Limit Reached!=
	7	Already protected!=Ya está protegido!
	8	#Change=
	9	#Command:=
	10	Enter name:=Ingrese nombre:
	11	#Enter texture:=
	12	Lasso (right-click animal to put in inventory)=Lazo (click derecho en animal para colocar en inventario)
	13	Leather=Cuero
	14	Meat=Carne
	15	Missed!=Perdido!
	16	#Mob Fence=
	17	#Mob Fence Top=
	18	Mob Protection Rune=Runa de protección de Mob
	19	#Mob Reset Stick=
	20	#Mob Spawner=
	21	Mob Spawner settings failed!=Configuracion de generador de Mob falló!
	22	Mob has been protected!=El mob ha sido protegido!
	23	Name Tag=Nombrar etiqueta
	24	Net (right-click animal to put in inventory)=Red (click derecho en animal para colocar en inventario)
	25	Not tamed!=No domesticado!
	26	Raw Meat=Carne cruda
	27	Rename=Renombrar
	28	Saddle=Montura
	29	Spawner Active (@1)=Generador activo (@1)
	30	Spawner Not Active (enter settings)=Generador no activo (ingrese config)
	31	Steel Shears (right-click to shear)=Tijera de acero (click derecho para esquilar)
	32	#Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] player_distance[1-20] y_offset[-10 to 10]”=
	33	#lifetimer expired, removed @1=

+34

-0

locale/mobs.fr.tr less more

	0	# textdomain:mobs
	1	Peaceful Mode Active - No Monsters Will Spawn= Mode pacifique activé - aucun monstre ne sera généré
	2	@1 (Tamed)=@1 (apprivoisé)
	3	@1 at full health (@2)=@1 est en pleine forme (@2)
	4	@1 has been tamed!=@1 a été apprivoisé !
	5	@1 is owner!=Appartient à @1 !
	6	Active Mob Limit Reached!=Limite atteinte du nombre des êtres vivants actifs !
	7	Already protected!=Déjà protégé !
	8	Change=Changer
	9	Command:=Commande :
	10	Enter name:=Saisissez un nom :
	11	Enter texture:=Saisissez une texture :
	12	Lasso (right-click animal to put in inventory)=Lasso (clic droit sur l'animal pour le mettre dans l'inventaire)
	13	Leather=Cuir
	14	Meat=Viande
	15	Missed!=Raté !
	16	Mob Fence= Clôture à animaux
	17	Mob Fence Top=Haut de clôture à animaux
	18	Mob Protection Rune=Rune de protection des animaux
	19	Mob Reset Stick=Baguette de réinitialisation des êtres vivants
	20	Mob Spawner=Créateur d'êtres vivants
	21	Mob Spawner settings failed!=Échec des paramètres du créateur d'être vivants !
	22	Mob has been protected!=L'animal a été protégé !
	23	Name Tag=Étiquette de collier
	24	Net (right-click animal to put in inventory)=Filet (clic droit sur l'animal pour le mettre dans l'inventaire)
	25	Not tamed!=Non-apprivoisé !
	26	Raw Meat=Viande crue
	27	Rename=Renommer
	28	Saddle=Selle
	29	Spawner Active (@1)=Créateur actif (@1)
	30	Spawner Not Active (enter settings)=Créateur non actif (entrez les paramètres)
	31	Steel Shears (right-click to shear)=Ciseaux à laine (clic droit pour tondre)
	32	Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] player_distance[1-20] y_offset[-10 to 10]”=Syntaxe : «name min_lumière[0-14] max_lumière[0-14] max_être_vivant_dans_région[0 pour désactiver] distance_joueur[1-20] décalage_y[-10 to 10]»
	33	lifetimer expired, removed @1=Être immortel expiré ; @1 retiré

+34

-0

locale/mobs.it.tr less more

	0	# textdomain:mobs
	1	Peaceful Mode Active - No Monsters Will Spawn= Modalità pacifica attiva - non comparirà nessun mostro
	2	@1 (Tamed)=@1 (Addomesticato)
	3	@1 at full health (@2)=@1 in piena salute (@2)
	4	@1 has been tamed!=@1 è stato addomesticato!
	5	@1 is owner!=Il padrone è @1!
	6	#Active Mob Limit Reached!=
	7	Already protected!=Già protetto!
	8	#Change=
	9	#Command:=
	10	Enter name:=Inserire il nome:
	11	#Enter texture:=
	12	Lasso (right-click animal to put in inventory)=Lazo (click di destro per mettere l'animale nell'inventario)
	13	Leather=Pelle
	14	Meat=Carne
	15	Missed!=Mancato!
	16	Mob Fence=Recinzione per mob
	17	#Mob Fence Top=
	18	Mob Protection Rune=Runa di protezione per mob
	19	#Mob Reset Stick=
	20	#Mob Spawner=
	21	Mob Spawner settings failed!=Impostazioni del generatore di mob fallite!
	22	Mob has been protected!=Il mob è stato protetto!
	23	Name Tag=Targhetta
	24	Net (right-click animal to put in inventory)=Rete (click destro per mettere l'animale nell'inventario)
	25	Not tamed!=Non addomesticato!
	26	Raw Meat=Carne cruda
	27	Rename=Rinomina
	28	Saddle=Sella
	29	Spawner Active (@1)=Generatore attivo (@1)
	30	Spawner Not Active (enter settings)=Generatore inattivo (inserire le impostazioni)
	31	Steel Shears (right-click to shear)=Cesoie d'acciaio (click destro per tosare)
	32	#Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] player_distance[1-20] y_offset[-10 to 10]”=
	33	#lifetimer expired, removed @1=

+34

-0

locale/mobs.ms.tr less more

	0	# textdomain:mobs
	1	Peaceful Mode Active - No Monsters Will Spawn= Mod Aman Diaktifkan - Tiada Raksasa Akan Muncul
	2	@1 (Tamed)=@1 (Jinak)
	3	@1 at full health (@2)=Mata kesihatan @1 telah penuh (@2)
	4	@1 has been tamed!=@1 telah dijinakkan!
	5	@1 is owner!=Ini hak milik @1!
	6	#Active Mob Limit Reached!=
	7	Already protected!=Telah dilindungi!
	8	#Change=
	9	#Command:=
	10	Enter name:=Masukkan nama:
	11	#Enter texture:=
	12	Lasso (right-click animal to put in inventory)=Tanjul (klik-kanan haiwan untuk masukkan ke inventori)
	13	Leather=Kulit
	14	Meat=Daging Bakar
	15	Missed!=Terlepas!
	16	Mob Fence=Pagar Mob
	17	#Mob Fence Top=
	18	Mob Protection Rune=Rune Perlindungan Mob
	19	#Mob Reset Stick=
	20	#Mob Spawner=
	21	Mob Spawner settings failed!=Penetapan Pewujud Mob gagal!
	22	Mob has been protected!=Mob telah pun dilindungi!
	23	Name Tag=Tanda Nama
	24	Net (right-click animal to put in inventory)=Jaring (klik-kanan haiwan untuk masukkan ke inventori)
	25	Not tamed!=Belum dijinakkan!
	26	Raw Meat=Daging Mentah
	27	Rename=Namakan semula
	28	Saddle=Pelana
	29	Spawner Active (@1)=Pewujud Mob Aktif (@1)
	30	Spawner Not Active (enter settings)=Pewujud Mob Tidak Aktif (masukkan tetapan)
	31	Steel Shears (right-click to shear)=Ketam Keluli (klik-kanan untuk mengetam bulu biri-biri)
	32	#Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] player_distance[1-20] y_offset[-10 to 10]”=
	33	#lifetimer expired, removed @1=

+34

-0

locale/mobs.pt.tr less more

	0	# textdomain:mobs
	1	#** Peaceful Mode Active - No Monsters Will Spawn=
	2	#@1 (Tamed)=
	3	@1 at full health (@2)=@1 em plena saude (@2)
	4	@1 has been tamed!=@1 foi domesticado!
	5	@1 is owner!=Dono @1!
	6	#Active Mob Limit Reached!=
	7	#Already protected!=
	8	#Change=
	9	#Command:=
	10	Enter name:=Insira um nome:
	11	#Enter texture:=
	12	Lasso (right-click animal to put in inventory)=Laço (clique-direito no animal para por no inventario)
	13	Leather=Couro
	14	Meat=Carne
	15	Missed!=Faltou!
	16	#Mob Fence=
	17	#Mob Fence Top=
	18	#Mob Protection Rune=
	19	#Mob Reset Stick=
	20	#Mob Spawner=
	21	Mob Spawner settings failed!=Configuraçao de Spawnador do Mob falhou!
	22	#Mob has been protected!=
	23	Name Tag=Etiqueta
	24	Net (right-click animal to put in inventory)=Net (clique-direito no animal para por no inventario)
	25	Not tamed!=Indomesticado!
	26	Raw Meat=Carne crua
	27	Rename=Renomear
	28	#Saddle=
	29	Spawner Active (@1)=Spawnador Ativo (@1)
	30	Spawner Not Active (enter settings)=Spawnador Inativo (configurar)
	31	Steel Shears (right-click to shear)=Tesoura de Aço (clique-direito para tosquiar)
	32	#Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] player_distance[1-20] y_offset[-10 to 10]”=
	33	#lifetimer expired, removed @1=

+34

-0

locale/mobs.ru.tr less more

	0	# textdomain:mobs
	1	Peaceful Mode Active - No Monsters Will Spawn= Мирный модус активирован - монстры не спаунятся
	2	@1 (Tamed)=@1 (Прирученный)
	3	@1 at full health (@2)=@1 при полном здоровье (@2)
	4	@1 has been tamed!=@1 приручен
	5	@1 is owner!=@1 владелец
	6	#Active Mob Limit Reached!=
	7	Already protected!=Уже защищен!
	8	#Change=
	9	#Command:=
	10	Enter name:=Введите имя:
	11	#Enter texture:=
	12	Lasso (right-click animal to put in inventory)=Лассо (Правый клик - положить животное в инвентарь)
	13	Leather=Кожа
	14	Meat=Мясо
	15	Missed!=Промазал!
	16	Mob Fence=Забор от мобов
	17	#Mob Fence Top=
	18	Mob Protection Rune=Защитная руна мобов
	19	#Mob Reset Stick=
	20	#Mob Spawner=
	21	Mob Spawner settings failed!=Настройки спаунера моба провалились
	22	Mob has been protected!=Моб защищен!
	23	Name Tag=Новый тэг
	24	Net (right-click animal to put in inventory)=Сеть (Правый клик - положить животное в инвентарь)
	25	Not tamed!=Не прирученный
	26	Raw Meat=Сырое мясо
	27	Rename=Переименовать
	28	Saddle=Седло
	29	Spawner Active (@1)=Активные спаунер (@1)
	30	Spawner Not Active (enter settings)=Спаунер не активен (введите настройки)
	31	Steel Shears (right-click to shear)=Ножницы (Правый клик - подстричь)
	32	#Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] player_distance[1-20] y_offset[-10 to 10]”=
	33	#lifetimer expired, removed @1=

+34

-0

locale/mobs.tr.tr less more

	0	# textdomain:mobs
	1	#** Peaceful Mode Active - No Monsters Will Spawn=
	2	#@1 (Tamed)=
	3	@1 at full health (@2)=@1 tam canında (@2)
	4	@1 has been tamed!=@1 tamamen evcilleştirilmiştir!
	5	@1 is owner!=Sahibi @1!
	6	#Active Mob Limit Reached!=
	7	#Already protected!=
	8	#Change=
	9	#Command:=
	10	Enter name:=İsim gir:
	11	#Enter texture:=
	12	Lasso (right-click animal to put in inventory)=Kement (hayvana sağ tıklayarak envantere koy)
	13	Leather=Deri
	14	Meat=Et
	15	Missed!=Kaçırdın!
	16	Mob Fence=Canavar Yaratıcı
	17	#Mob Fence Top=
	18	#Mob Protection Rune=
	19	#Mob Reset Stick=
	20	#Mob Spawner=
	21	Mob Spawner settings failed!=Yaratıcı ayarları uygulanamadı.
	22	#Mob has been protected!=
	23	Name Tag=İsim etiketi
	24	Net (right-click animal to put in inventory)=Ağ (hayvana sağ tıklayarak envantere koy)
	25	Not tamed!=Evcil değil!
	26	Raw Meat=Çiğ et
	27	Rename=Yeniden adlandır
	28	#Saddle=
	29	Spawner Active (@1)=Yaratıcı aktif (@1)
	30	Spawner Not Active (enter settings)=Yaratıcı aktif değil (ayarlara gir)
	31	Steel Shears (right-click to shear)=Çelik makas (sağ tıklayarak kes)
	32	#Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] player_distance[1-20] y_offset[-10 to 10]”=
	33	#lifetimer expired, removed @1=

+34

-0

locale/mobs.zh_CN.tr less more

	0	# textdomain:mobs
	1	Peaceful Mode Active - No Monsters Will Spawn= 和平模式已激活——没有怪物会产生
	2	@1 (Tamed)=@1（已驯服）
	3	@1 at full health (@2)=@1已经满血（@2）
	4	@1 has been tamed!=@1已经被驯服！
	5	@1 is owner!=@1 是主人
	6	#Active Mob Limit Reached!=
	7	Already protected!=已经被保护！
	8	#Change=
	9	#Command:=
	10	Enter name:=输入名称：
	11	#Enter texture:=
	12	Lasso (right-click animal to put in inventory)=套索（右键单击动物以放入物品栏）
	13	Leather=皮革
	14	Meat=肉
	15	Missed!=没抓住！
	16	Mob Fence=Mob 栅栏
	17	#Mob Fence Top=
	18	Mob Protection Rune=Mob 保护符文
	19	#Mob Reset Stick=
	20	#Mob Spawner=
	21	Mob Spawner settings failed!=Mob 孵化器设置失败！
	22	Mob has been protected!=Mob 已经被保护了！
	23	Name Tag=名称标签
	24	Net (right-click animal to put in inventory)=网（右键单击动物以放入物品栏）
	25	Not tamed!=没有驯服！
	26	Raw Meat=生肉
	27	Rename=重新命名
	28	Saddle=鞍
	29	Spawner Active (@1)=孵化器正在运转（@1）
	30	Spawner Not Active (enter settings)=孵化器未使用（输入设置）
	31	Steel Shears (right-click to shear)=钢剪（右键单击以剪切）
	32	#Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] player_distance[1-20] y_offset[-10 to 10]”=
	33	#lifetimer expired, removed @1=

+34

-0

locale/mobs.zh_TW.tr less more

	0	# textdomain:mobs
	1	Peaceful Mode Active - No Monsters Will Spawn= 和平模式已激活——沒有怪物會產生
	2	@1 (Tamed)=@1（已馴服）
	3	@1 at full health (@2)=@1已經滿血（@2）
	4	@1 has been tamed!=@1已經被馴服！
	5	@1 is owner!=@1 是主人
	6	#Active Mob Limit Reached!=
	7	Already protected!=已經被保護！
	8	#Change=
	9	#Command:=
	10	Enter name:=輸入名稱：
	11	#Enter texture:=
	12	Lasso (right-click animal to put in inventory)=套索（右鍵單擊動物以放入物品欄）
	13	Leather=皮革
	14	Meat=肉
	15	Missed!=沒抓住！
	16	Mob Fence=Mob 柵欄
	17	#Mob Fence Top=
	18	Mob Protection Rune=Mob 保護符文
	19	#Mob Reset Stick=
	20	#Mob Spawner=
	21	Mob Spawner settings failed!=Mob 孵化器設置失敗！
	22	Mob has been protected!=Mob 已經被保護了！
	23	Name Tag=名稱標籤
	24	Net (right-click animal to put in inventory)=網（右鍵單擊動物以放入物品欄）
	25	Not tamed!=沒有馴服！
	26	Raw Meat=生肉
	27	Rename=重新命名
	28	Saddle=鞍
	29	Spawner Active (@1)=孵化器正在運轉（@1）
	30	Spawner Not Active (enter settings)=孵化器未使用（輸入設置）
	31	Steel Shears (right-click to shear)=鋼剪（右鍵單擊以剪切）
	32	#Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] player_distance[1-20] y_offset[-10 to 10]”=
	33	#lifetimer expired, removed @1=

-1

locale/template.pot less more

100	100	msgid "Mob Fence"
101	101	msgstr ""
102	102
	103	#: crafts.lua
	104	msgid "Mob Fence Top"
	105	msgstr ""
	106
103	107	#: spawner.lua
104	108	msgid "Mob Spawner"
105	109	msgstr ""
106	110
107	111	#: spawner.lua
108		msgid "Mob MinLight MaxLight Amount PlayerDist"
	112	msgid "(mob name) (min light) (max light) (amount) (player distance) (Y offset)"
109	113	msgstr ""
110	114
111	115	#: spawner.lua
112	116	msgid "Spawner Not Active (enter settings)"
	117	msgstr ""
	118
	119	#@ spawner.lua
	120	msgid "Command:"
113	121	msgstr ""
114	122
115	123	#: spawner.lua

+130

-0

locale/zh_CN.po less more

	0	# SOME DESCRIPTIVE TITLE.
	1	# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
	2	# This file is distributed under the same license as the PACKAGE package.
	3	# IFRFSX<1079092922@qq.com>, 2020.
	4	#
	5	#, fuzzy
	6	msgid ""
	7	msgstr ""
	8	"Project-Id-Version: PACKAGE VERSION\n"
	9	"Report-Msgid-Bugs-To: \n"
	10	"POT-Creation-Date: 2017-07-02 16:48+0200\n"
	11	"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
	12	"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
	13	"Language-Team: LANGUAGE <LL@li.org>\n"
	14	"Language: \n"
	15	"MIME-Version: 1.0\n"
	16	"Content-Type: text/plain; charset=UTF-8\n"
	17	"Content-Transfer-Encoding: 8bit\n"
	18
	19	#: api.lua
	20	msgid "** Peaceful Mode Active - No Monsters Will Spawn"
	21	msgstr "** 和平模式已激活——没有怪物会产生"
	22
	23	#: api.lua
	24	msgid "Mob has been protected!"
	25	msgstr "Mob 已经被保护了！"
	26
	27	#: api.lua
	28	msgid "@1 (Tamed)"
	29	msgstr "@1（已驯服）"
	30
	31	#: api.lua
	32	msgid "Not tamed!"
	33	msgstr "没有驯服！"
	34
	35	#: api.lua
	36	msgid "@1 is owner!"
	37	msgstr "@1 是主人"
	38
	39	#: api.lua
	40	msgid "Missed!"
	41	msgstr "没抓住！"
	42
	43	#: api.lua
	44	msgid "Already protected!"
	45	msgstr "已经被保护！"
	46
	47	#: api.lua
	48	msgid "@1 at full health (@2)"
	49	msgstr "@1已经满血（@2）"
	50
	51	#: api.lua
	52	msgid "@1 has been tamed!"
	53	msgstr "@1已经被驯服！"
	54
	55	#: api.lua
	56	msgid "Enter name:"
	57	msgstr "输入名称："
	58
	59	#: api.lua
	60	msgid "Rename"
	61	msgstr "重新命名"
	62
	63	#: crafts.lua
	64	msgid "Name Tag"
	65	msgstr "名称标签"
	66
	67	#: crafts.lua
	68	msgid "Leather"
	69	msgstr "皮革"
	70
	71	#: crafts.lua
	72	msgid "Raw Meat"
	73	msgstr "生肉"
	74
	75	#: crafts.lua
	76	msgid "Meat"
	77	msgstr "肉"
	78
	79	#: crafts.lua
	80	msgid "Lasso (right-click animal to put in inventory)"
	81	msgstr "套索（右键单击动物以放入物品栏）"
	82
	83	#: crafts.lua
	84	msgid "Net (right-click animal to put in inventory)"
	85	msgstr "网（右键单击动物以放入物品栏）"
	86
	87	#: crafts.lua
	88	msgid "Steel Shears (right-click to shear)"
	89	msgstr "钢剪（右键单击以剪切）"
	90
	91	#: crafts.lua
	92	msgid "Mob Protection Rune"
	93	msgstr "Mob 保护符文"
	94
	95	#: crafts.lua
	96	msgid "Saddle"
	97	msgstr "鞍"
	98
	99	#: crafts.lua
	100	msgid "Mob Fence"
	101	msgstr "Mob 栅栏"
	102
	103	#: spawner.lua
	104	msgid "Mob Spawner"
	105	msgstr "Mob 孵化器"
	106
	107	#: spawner.lua
	108	msgid "Mob MinLight MaxLight Amount PlayerDist"
	109	msgstr "Mob/最小光量/最大光量/玩家距离"
	110
	111	#: spawner.lua
	112	msgid "Spawner Not Active (enter settings)"
	113	msgstr "孵化器未使用（输入设置）"
	114
	115	#: spawner.lua
	116	msgid "Spawner Active (@1)"
	117	msgstr "孵化器正在运转（@1）"
	118
	119	#: spawner.lua
	120	msgid "Mob Spawner settings failed!"
	121	msgstr "Mob 孵化器设置失败！"
	122
	123	#: spawner.lua
	124	msgid ""
	125	"Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] "
	126	"distance[1-20] y_offset[-10 to 10]”"
	127	msgstr ""
	128	"语法: “物品名称最小光亮[0-14] 最大光亮[0-14] 范围内的最大Mob数量[0 to disable] "
	129	"距离[1-20] y_offset[-10 to 10]”"

+130

-0

locale/zh_TW.po less more

	0	# SOME DESCRIPTIVE TITLE.
	1	# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
	2	# This file is distributed under the same license as the PACKAGE package.
	3	# IFRFSX<1079092922@qq.com>, 2020.
	4	#
	5	#, fuzzy
	6	msgid ""
	7	msgstr ""
	8	"Project-Id-Version: PACKAGE VERSION\n"
	9	"Report-Msgid-Bugs-To: \n"
	10	"POT-Creation-Date: 2017-07-02 16:48+0200\n"
	11	"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
	12	"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
	13	"Language-Team: LANGUAGE <LL@li.org>\n"
	14	"Language: \n"
	15	"MIME-Version: 1.0\n"
	16	"Content-Type: text/plain; charset=UTF-8\n"
	17	"Content-Transfer-Encoding: 8bit\n"
	18
	19	#: api.lua
	20	msgid "** Peaceful Mode Active - No Monsters Will Spawn"
	21	msgstr "** 和平模式已激活——沒有怪物會產生"
	22
	23	#: api.lua
	24	msgid "Mob has been protected!"
	25	msgstr "Mob 已經被保護了！"
	26
	27	#: api.lua
	28	msgid "@1 (Tamed)"
	29	msgstr "@1（已馴服）"
	30
	31	#: api.lua
	32	msgid "Not tamed!"
	33	msgstr "沒有馴服！"
	34
	35	#: api.lua
	36	msgid "@1 is owner!"
	37	msgstr "@1 是主人"
	38
	39	#: api.lua
	40	msgid "Missed!"
	41	msgstr "沒抓住！"
	42
	43	#: api.lua
	44	msgid "Already protected!"
	45	msgstr "已經被保護！"
	46
	47	#: api.lua
	48	msgid "@1 at full health (@2)"
	49	msgstr "@1已經滿血（@2）"
	50
	51	#: api.lua
	52	msgid "@1 has been tamed!"
	53	msgstr "@1已經被馴服！"
	54
	55	#: api.lua
	56	msgid "Enter name:"
	57	msgstr "輸入名稱："
	58
	59	#: api.lua
	60	msgid "Rename"
	61	msgstr "重新命名"
	62
	63	#: crafts.lua
	64	msgid "Name Tag"
	65	msgstr "名稱標籤"
	66
	67	#: crafts.lua
	68	msgid "Leather"
	69	msgstr "皮革"
	70
	71	#: crafts.lua
	72	msgid "Raw Meat"
	73	msgstr "生肉"
	74
	75	#: crafts.lua
	76	msgid "Meat"
	77	msgstr "肉"
	78
	79	#: crafts.lua
	80	msgid "Lasso (right-click animal to put in inventory)"
	81	msgstr "套索（右鍵單擊動物以放入物品欄）"
	82
	83	#: crafts.lua
	84	msgid "Net (right-click animal to put in inventory)"
	85	msgstr "網（右鍵單擊動物以放入物品欄）"
	86
	87	#: crafts.lua
	88	msgid "Steel Shears (right-click to shear)"
	89	msgstr "鋼剪（右鍵單擊以剪切）"
	90
	91	#: crafts.lua
	92	msgid "Mob Protection Rune"
	93	msgstr "Mob 保護符文"
	94
	95	#: crafts.lua
	96	msgid "Saddle"
	97	msgstr "鞍"
	98
	99	#: crafts.lua
	100	msgid "Mob Fence"
	101	msgstr "Mob 柵欄"
	102
	103	#: spawner.lua
	104	msgid "Mob Spawner"
	105	msgstr "Mob 孵化器"
	106
	107	#: spawner.lua
	108	msgid "Mob MinLight MaxLight Amount PlayerDist"
	109	msgstr "Mob/最小光量/最大光量/玩家距離"
	110
	111	#: spawner.lua
	112	msgid "Spawner Not Active (enter settings)"
	113	msgstr "孵化器未使用（輸入設置）"
	114
	115	#: spawner.lua
	116	msgid "Spawner Active (@1)"
	117	msgstr "孵化器正在運轉（@1）"
	118
	119	#: spawner.lua
	120	msgid "Mob Spawner settings failed!"
	121	msgstr "Mob 孵化器設置失敗！"
	122
	123	#: spawner.lua
	124	msgid ""
	125	"Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] "
	126	"distance[1-20] y_offset[-10 to 10]”"
	127	msgstr ""
	128	"語法: “物品名稱最小光亮[0-14] 最大光亮[0-14] 範圍內的最大Mob數量[0 to disable] "
	129	"距離[1-20] y_offset[-10 to 10]”"

-1

lucky_block.lua less more

12	12	{"dro", {"mobs:protector"}, 1},
13	13	{"dro", {"mobs:fence_wood"}, 10},
14	14	{"dro", {"mobs:fence_top"}, 12},
15		{"lig"},
	15	{"lig"}
16	16	})
17	17	end

-0

mod.conf less more

0	0	name = mobs
	1	depends =
	2	optional_depends = default, tnt, dye, farming, invisibility, intllib, lucky_block, cmi, toolranks, pathfinder
	3	description = Adds a mob api for mods to add animals or monsters etc.

+128

-85

mount.lua less more

0
1	0	-- lib_mount by Blert2112 (edited by TenPlus1)
2	1
3		local enable_crash = false
4		local crash_threshold = 6.5 -- ignored if enable_crash=false
5
	2	local abs, cos, floor, sin, sqrt, pi =
	3	math.abs, math.cos, math.floor, math.sin, math.sqrt, math.pi
6	4	------------------------------------------------------------------------------
7	5
8	6	--

10	8	--
11	9
12	10	local node_ok = function(pos, fallback)
13
14	11	fallback = fallback or mobs.fallback_node
15	12
16	13	local node = minetest.get_node_or_nil(pos)

48	45
49	46
50	47	local function get_sign(i)
51
52	48	i = i or 0
53	49
54	50	if i == 0 then
55	51	return 0
56	52	else
57		return i / math.abs(i)
	53	return i / abs(i)
58	54	end
59	55	end
60	56
61	57
62	58	local function get_velocity(v, yaw, y)
63
64		local x = -math.sin(yaw) * v
65		local z = math.cos(yaw) * v
	59	local x = -sin(yaw) * v
	60	local z = cos(yaw) * v
66	61
67	62	return {x = x, y = y, z = z}
68	63	end
69	64
70	65
71	66	local function get_v(v)
72		return math.sqrt(v.x * v.x + v.z * v.z)
	67	return sqrt(v.x * v.x + v.z * v.z)
73	68	end
74	69
75	70

83	78
84	79	local entity = attached_to:get_luaentity()
85	80
86		if entity.driver
	81	if entity and entity.driver
87	82	and entity.driver == player then
88
89	83	entity.driver = nil
90	84	end
91	85
92	86	player:set_detach()
93		default.player_attached[player:get_player_name()] = false
	87	player_api.player_attached[player:get_player_name()] = false
94	88	player:set_eye_offset({x = 0, y = 0, z = 0}, {x = 0, y = 0, z = 0})
95		default.player_set_animation(player, "stand" , 30)
96		player:set_properties({visual_size = {x = 1, y = 1} })
	89	player_api.set_animation(player, "stand", 30)
	90	player:set_properties({visual_size = {x = 1, y = 1}})
97	91
98	92	end
99	93
100	94	-------------------------------------------------------------------------------
101
102	95
103	96	minetest.register_on_leaveplayer(function(player)
104	97	force_detach(player)
105	98	end)
106	99
107	100	minetest.register_on_shutdown(function()
	101
108	102	local players = minetest.get_connected_players()
	103
109	104	for i = 1, #players do
110	105	force_detach(players[i])
111	106	end

118	113
119	114	-------------------------------------------------------------------------------
120	115
	116	-- Just for correct detaching
	117	local function find_free_pos(pos)
	118
	119	local check = {
	120	{x = 1, y = 0, z = 0},
	121	{x = 1, y = 1, z = 0},
	122	{x = -1, y = 0, z = 0},
	123	{x = -1, y = 1, z = 0},
	124	{x = 0, y = 0, z = 1},
	125	{x = 0, y = 1, z = 1},
	126	{x = 0, y = 0, z = -1},
	127	{x = 0, y = 1, z = -1}
	128	}
	129
	130	for _, c in pairs(check) do
	131
	132	local npos = {x = pos.x + c.x, y = pos.y + c.y, z = pos.z + c.z}
	133	local node = minetest.get_node_or_nil(npos)
	134
	135	if node and node.name then
	136
	137	local def = minetest.registered_nodes[node.name]
	138
	139	if def and not def.walkable and
	140	def.liquidtype == "none" then
	141	return npos
	142	end
	143	end
	144	end
	145
	146	return pos
	147	end
	148
	149	-------------------------------------------------------------------------------
	150
121	151	function mobs.attach(entity, player)
122
123		local attach_at, eye_offset = {}, {}
124	152
125	153	entity.player_rotation = entity.player_rotation or {x = 0, y = 0, z = 0}
126	154	entity.driver_attach_at = entity.driver_attach_at or {x = 0, y = 0, z = 0}

130	158	local rot_view = 0
131	159
132	160	if entity.player_rotation.y == 90 then
133		rot_view = math.pi/2
134		end
135
136		attach_at = entity.driver_attach_at
137		eye_offset = entity.driver_eye_offset
	161	rot_view = pi / 2
	162	end
	163
	164	local attach_at = entity.driver_attach_at
	165	local eye_offset = entity.driver_eye_offset
	166
138	167	entity.driver = player
139	168
140	169	force_detach(player)
141	170
142	171	player:set_attach(entity.object, "", attach_at, entity.player_rotation)
143		default.player_attached[player:get_player_name()] = true
	172	player_api.player_attached[player:get_player_name()] = true
144	173	player:set_eye_offset(eye_offset, {x = 0, y = 0, z = 0})
145	174
146	175	player:set_properties({

151	180	})
152	181
153	182	minetest.after(0.2, function()
154		default.player_set_animation(player, "sit" , 30)
	183
	184	if player and player:is_player() then
	185	player_api.set_animation(player, "sit", 30)
	186	end
155	187	end)
156	188
157		--player:set_look_yaw(entity.object:get_yaw() - rot_view)
158	189	player:set_look_horizontal(entity.object:get_yaw() - rot_view)
159	190	end
160	191
161	192
162		function mobs.detach(player, offset)
163
	193	function mobs.detach(player)
164	194	force_detach(player)
165	195
166		default.player_set_animation(player, "stand" , 30)
167
168		local pos = player:get_pos()
169
170		pos = {x = pos.x + offset.x, y = pos.y + 0.2 + offset.y, z = pos.z + offset.z}
171
172	196	minetest.after(0.1, function()
173		player:set_pos(pos)
	197
	198	if player and player:is_player() then
	199
	200	local pos = find_free_pos(player:get_pos())
	201
	202	pos.y = pos.y + 0.5
	203
	204	player:set_pos(pos)
	205	end
174	206	end)
175	207	end
176	208
177	209
178	210	function mobs.drive(entity, moving_anim, stand_anim, can_fly, dtime)
179	211
180		local rot_steer, rot_view = math.pi/2, 0
	212	local yaw = entity.object:get_yaw() or 0
	213	local rot_view = 0
181	214
182	215	if entity.player_rotation.y == 90 then
183		rot_steer, rot_view = 0, math.pi/2
	216	rot_view = pi / 2
184	217	end
185	218
186	219	local acce_y = 0

191	224	-- process controls
192	225	if entity.driver then
193	226
194		--print ("---velo", get_v(velo))
195
196	227	local ctrl = entity.driver:get_player_control()
197	228
198	229	-- move forwards

210	241	entity.v = entity.v - entity.accel / 10
211	242	end
212	243
213		-- fix mob rotation
214		entity.object:set_yaw(entity.driver:get_look_horizontal() - entity.rotate)
	244	-- mob rotation
	245	local horz
	246
	247	if entity.alt_turn == true then
	248
	249	horz = yaw
	250
	251	if ctrl.left then
	252	horz = horz + 0.05
	253
	254	elseif ctrl.right then
	255	horz = horz - 0.05
	256	end
	257	else
	258	horz = entity.driver:get_look_horizontal() or 0
	259	end
	260
	261	entity.object:set_yaw(horz - entity.rotate)
215	262
216	263	if can_fly then
217
218	264	-- fly up
219	265	if ctrl.jump then
	266
220	267	velo.y = velo.y + 1
	268
221	269	if velo.y > entity.accel then velo.y = entity.accel end
222	270
223	271	elseif velo.y > 0 then
	272
224	273	velo.y = velo.y - 0.1
	274
225	275	if velo.y < 0 then velo.y = 0 end
226	276	end
227	277
228	278	-- fly down
229	279	if ctrl.sneak then
	280
230	281	velo.y = velo.y - 1
	282
231	283	if velo.y < -entity.accel then velo.y = -entity.accel end
232	284
233	285	elseif velo.y < 0 then
	286
234	287	velo.y = velo.y + 0.1
	288
235	289	if velo.y > 0 then velo.y = 0 end
236	290	end
237
238	291	else
239
240	292	-- jump
241	293	if ctrl.jump then
242	294

245	297	acce_y = acce_y + (acce_y * 3) + 1
246	298	end
247	299	end
248
249	300	end
250	301	end
251	302

258	309
259	310	return
260	311	end
261
	312
262	313	-- set moving animation
263	314	if moving_anim then
264	315	mobs:set_animation(entity, moving_anim)

273	324
274	325	entity.object:set_velocity({x = 0, y = 0, z = 0})
275	326	entity.v = 0
	327
276	328	return
277	329	end
278	330

283	335	max_spd = entity.max_speed_forward
284	336	end
285	337
286		if math.abs(entity.v) > max_spd then
	338	if abs(entity.v) > max_spd then
287	339	entity.v = entity.v - get_sign(entity.v)
288	340	end
289	341
290	342	-- Set position, velocity and acceleration
291	343	local p = entity.object:get_pos()
292		local new_velo = {x = 0, y = 0, z = 0}
293		local new_acce = {x = 0, y = -9.8, z = 0}
	344
	345	if not p then return end
	346
	347	local new_acce = {x = 0, y = -9.81, z = 0}
294	348
295	349	p.y = p.y - 0.5
296	350

314	368	minetest.sound_play("default_punch", {
315	369	object = entity.object,
316	370	max_hear_distance = 5
317		})
	371	}, true)
318	372
319	373	entity.object:punch(entity.object, 1.0, {
320	374	full_punch_interval = 1.0,

325	379	end
326	380	end
327	381
328		if entity.terrain_type == 2
329		or entity.terrain_type == 3 then
	382	local terrain_type = entity.terrain_type
	383
	384	if terrain_type == 2 or terrain_type == 3 then
330	385
331	386	new_acce.y = 0
332	387	p.y = p.y + 1

341	396	new_acce.y = 5
342	397	end
343	398	else
344		if math.abs(velo.y) < 1 then
	399	if abs(velo.y) < 1 then
	400
345	401	local pos = entity.object:get_pos()
346		pos.y = math.floor(pos.y) + 0.5
	402
	403	if not pos then return end
	404
	405	pos.y = floor(pos.y) + 0.5
347	406	entity.object:set_pos(pos)
348	407	velo.y = 0
349	408	end

353	412	end
354	413	end
355	414
356		new_velo = get_velocity(v, entity.object:get_yaw() - rot_view, velo.y)
	415	local new_velo = get_velocity(v, yaw - rot_view, velo.y)
	416
357	417	new_acce.y = new_acce.y + acce_y
358	418
359	419	entity.object:set_velocity(new_velo)
360	420	entity.object:set_acceleration(new_acce)
361	421
362		-- CRASH!
363		if enable_crash then
364
365		local intensity = entity.v2 - v
366
367		if intensity >= crash_threshold then
368
369		--print("----------- crash", intensity)
370
371		entity.object:punch(entity.object, 1.0, {
372		full_punch_interval = 1.0,
373		damage_groups = {fleshy = intensity}
374		}, nil)
375
376		end
377		end
378
379	422	entity.v2 = v
380	423	end
381	424
382	425
383	426	-- directional flying routine by D00Med (edited by TenPlus1)
384
385		function mobs.fly(entity, dtime, speed, shoots, arrow, moving_anim, stand_anim)
	427	function mobs.fly(entity, _, speed, shoots, arrow, moving_anim, stand_anim)
386	428
387	429	local ctrl = entity.driver:get_player_control()
388	430	local velo = entity.object:get_velocity()
389	431	local dir = entity.driver:get_look_dir()
390	432	local yaw = entity.driver:get_look_horizontal() + 1.57 -- offset fix between old and new commands
391		local rot_steer, rot_view = math.pi / 2, 0
392
393		if entity.player_rotation.y == 90 then
394		rot_steer, rot_view = 0, math.pi / 2
395		end
	433
	434	if not ctrl or not velo then return end
396	435
397	436	if ctrl.up then
398	437	entity.object:set_velocity({

402	441	})
403	442
404	443	elseif ctrl.down then
	444
405	445	entity.object:set_velocity({
406	446	x = -dir.x * speed,
407		y = dir.y * speed + 2,
	447	y = dir.y * speed + 2,
408	448	z = -dir.z * speed
409	449	})
410	450

412	452	entity.object:set_velocity({x = 0, y = -2, z = 0})
413	453	end
414	454
415		entity.object:set_yaw(yaw + math.pi + math.pi / 2 - entity.rotate)
	455	entity.object:set_yaw(yaw + pi + pi / 2 - entity.rotate)
416	456
417	457	-- firing arrows
418	458	if ctrl.LMB and ctrl.sneak and shoots then

424	464	z = pos.z + 0 + dir.z * 2.5}, arrow)
425	465
426	466	local ent = obj:get_luaentity()
	467
427	468	if ent then
	469
428	470	ent.switch = 1 -- for mob specific arrows
429	471	ent.owner_id = tostring(entity.object) -- so arrows dont hurt entity you are riding
430	472	local vec = {x = dir.x * 6, y = dir.y * 6, z = dir.z * 6}
431		local yaw = entity.driver:get_look_horizontal()
432		obj:set_yaw(yaw + math.pi / 2)
	473
	474	yaw = entity.driver:get_look_horizontal()
	475
	476	obj:set_yaw(yaw + pi / 2)
433	477	obj:set_velocity(vec)
434	478	else
435	479	obj:remove()

438	482
439	483	-- change animation if stopped
440	484	if velo.x == 0 and velo.y == 0 and velo.z == 0 then
441
442	485	mobs:set_animation(entity, stand_anim)
443	486	else
444	487	-- moving animation

+92

-83

readme.MD less more

0
1		MOBS REDO for MINETEST
2
3		Built from PilzAdam's original Simple Mobs with additional mobs by KrupnoPavel, Zeg9, ExeterDad and AspireMint.
4
5
6		This mod contains the API only for adding your own mobs into the world, so please use the additional modpacks to add animals, monsters etc.
7
8
9		https://forum.minetest.net/viewtopic.php?f=11&t=9917
10
11
12		Crafts:
13
14		- Nametag (paper, black dye, string) can be used right-click on a tamed mob to give them a name.
15		- Nets can be used to right-click tamed mobs to pick them up and place inside inventory as a spawn egg.
16		- Magic Lasso is similar to nets but with a better chance of picking up larger mobs.
17		- Shears are used to right-click sheep and return 1-3 wool.
18		- Protection Rune lets you protect tamed mobs from harm by other players
19		- Mob Fence and Fence Top (to stop mobs escaping/glitching through fences)
20
21		Lucky Blocks: 9
22
23
24		Changelog:
25		- 1.47- Mob damage changes, min and max light level for damage added, ignition sources checked for lava damage
26		- 1.46- Mobs only drop rare items when killed by player (drops.min = 0 makes them rare), code tweak, pathfinding no longer sees through walkable nodes
27		- 1.45- Added Fence Top to add on top of any fence to stop mobs escaping, new line_of_sight tweaked by Astrobe
28		- 1.44- Added ToolRanks support for swords when attacking mobs
29		- 1.43- Better 0.4.16 compatibility, added general attack function and settings
30		- 1.42- Added "all" option to immune_to table, tidied floating mobs to be less intensive
31		- 1.41- Mob pathfinding has been updated thanks to Elkien3
32		- 1.40- Updated to use newer functions, requires Minetest 0.4.16+ to work.
33		- 1.39- Added 'on_breed', 'on_grown' and 'do_punch' custom functions per mob
34		- 1.38- Better entity checking, nametag setting and on_spawn function added to mob registry, tweaked light damage
35		- 1.37- Added support for Raymoo's CMI (common mob interface) mod: https://forum.minetest.net/viewtopic.php?f=9&t=15448
36		- 1.36- Death check added, if mob dies in fire/lava/with lava pick then drops are cooked
37		- 1.35- Added owner_loyal flag for owned mobs to attack player enemies, also fixed group_attack
38		- 1.34- Added function to fly mob using directional movement (thanks D00Med for flying code)
39		- 1.33- Added functions to mount ride mobs (mobs.attach, mobs.detach, mobs.drive) many thanks to Blert2112
40		- 1.32- Added new spawn check to count specific mobs AND new minetest.conf setting to chance spawn chance and numbers, added ability to protect tamed mobs
41		- 1.31- Added 'attack_animals' and 'specific_attack' flags for custom monster attacks, also 'mob_difficulty' .conf setting to make mobs harder.
42		- 1.30- Added support for invisibility mod (mobs cant attack what they cant see), tweaked and tidied code
43		- 1.29- Split original Mobs Redo into a modpack to make it easier to disable mob sets (animal, monster, npc) or simply use the Api itself for your own mod
44		- 1.28- New damage system added with ability for mob to be immune to weapons or healed by them :)
45		- 1.27- Added new sheep, lava flan and spawn egg textures. New Lava Pick tool smelts what you dig. New atan checking function.
46		- 1.26- Pathfinding feature added thanks to rnd, when monsters attack they become scary smart in finding you :) also, beehive produces honey now :)
47		- 1.25- Mobs no longer spawn within 12 blocks of player or despawn within same range, spawners now have player detection, Code tidy and tweak.
48		- 1.24- Added feature where certain animals run away when punched (runaway = true in mob definition)
49		- 1.23- Added mob spawner block for admin to setup spawners in-game (place and right click to enter settings)
50		- 1.22- Added ability to name tamed animals and npc using nametags, also npc will attack anyone who punches them apart from owner
51		- 1.21- Added some more error checking to reduce serialize.h error and added height checks for falling off cliffs (thanks cmdskp)
52		- 1.20- Error checking added to remove bad mobs, out of map limit mobs and stop serialize.h error
53		- 1.19- Chickens now drop egg items instead of placing the egg, also throwing eggs result in 1/8 chance of spawning chick
54		- 1.18- Added docile_by_day flag so that monsters will not attack automatically during daylight hours unless hit first
55		- 1.17- Added 'dogshoot' attack type, shoots when out of reach, melee attack when in reach, also api tweaks and self.reach added
56		- 1.16- Mobs follow multiple items now, Npc's can breed
57		- 1.15- Added Feeding/Taming/Breeding function, right-click to pick up any sheep with X mark on them and replace with new one to fix compatibility.
58		- 1.14- All .self variables saved in staticdata, Fixed self.health bug
59		- 1.13- Added capture function (thanks blert2112) chance of picking up mob with hand; net; magic lasso, replaced some .x models with newer .b3d one's
60		- 1.12- Added animal ownership so that players cannot steal your tamed animals
61		- 1.11- Added flying mobs (and swimming), fly=true and fly_in="air" or "deafult:water_source" for fishy
62		- 1,10- Footstep removed (use replace), explosion routine added for exploding mobs.
63		- 1.09- reworked breeding routine, added mob rotation value, added footstep feature, added jumping mobs with sounds feature, added magic lasso for picking up animals
64		- 1.08- Mob throwing attack has been rehauled so that they can damage one another, also drops and on_die function added
65		- 1.07- Npc's can now be set to follow player or stand by using self.order and self.owner variables
66		- beta- Npc mob added, kills monsters, attacks player when punched, right click with food to heal or gold lump for drop
67		- 1.06- Changed recovery times after breeding, and time taken to grow up (can be sped up by feeding baby animal)
68		- 1.05- Added ExeterDad's bunny's which can be picked up and tamed with 4 carrots from farming redo or farming_plus, also shears added to get wool from sheep and lastly Jordach/BSD's kitten
69		- 1.04- Added mating for sheep, cows and hogs... feed animals to make horny and hope for a baby which is half size, will grow up quick though :)
70		- 1.03- Added mob drop/replace feature so that chickens can drop eggs, cow/sheep can eat grass/wheat etc.
71		- 1.02- Sheared sheep are remembered and spawn shaven, Warthogs will attack when threatened, Api additions
72		- 1.01- Mobs that suffer fall damage or die in water/lava/sunlight will now drop items
73		- 1.0 - more work on Api so that certain mobs can float in water while some sink like a brick :)
74		- 0.9 - Spawn eggs added for all mobs (admin only, cannot be placed in protected areas)... Api tweaked
75		- 0.8 - Added sounds to monster mobs (thanks Cyberpangolin for the sfx) and also chicken sound
76		- 0.7 - mobs.protected switch added to api.lua, when set to 1 mobs no longer spawn in protected areas, also bug fixes
77		- 0.6 - Api now supports multi-textured mobs, e.g oerkki, dungeon master, rats and chickens have random skins when spawning (sheep fix TODO), also new Honey block
78		- 0.5 - Mobs now float in water, die from falling, and some code improvements
79		- 0.4 - Dungeon Masters and Mese Monsters have much better aim due to shoot_offset, also they can both shoot through nodes that aren't walkable (flowers, grass etc) plus new sheep sound :)
80		- 0.3 - Added LOTT's Spider mob, made Cobwebs, added KPavel's Bee with Honey and Beehives (made texture), Warthogs now have sound and can be tamed, taming of shaved sheep or milked cow with 8 wheat so it will not despawn, many bug fixes :)
81		- 0.2 - Cooking bucket of milk into cheese now returns empty bucket
82		- 0.1 - Initial Release
	0
	1	MOBS REDO for MINETEST
	2
	3	Built from PilzAdam's original Simple Mobs with additional mobs by KrupnoPavel, Zeg9, ExeterDad and AspireMint.
	4
	5
	6	This mod contains the API only for adding your own mobs into the world, so please use the additional modpacks to add animals, monsters etc.
	7
	8
	9	https://forum.minetest.net/viewtopic.php?f=11&t=9917
	10
	11
	12	Crafts:
	13
	14	- Nametag (paper, black dye, string) can be used right-click on a tamed mob to give them a name.
	15	- Nets can be used to right-click tamed mobs to pick them up and place inside inventory as a spawn egg.
	16	- Magic Lasso is similar to nets but with a better chance of picking up larger mobs.
	17	- Shears are used to right-click sheep and return 1-3 wool.
	18	- Protection Rune lets you protect tamed mobs from harm by other players
	19	- Mob Fence and Fence Top (to stop mobs escaping/glitching through fences)
	20
	21	Lucky Blocks: 9
	22
	23
	24	Changelog:
	25	- 1.55 - Add 'peaceful_player' privelage and setting so mobs don't attack specific players (thanks sfence), add support for MarkBu's pathfinder mod, remove need for default mod
	26	- 1.54 - Simplified animal breeding function, added editable settings (thanks Wuzzy), Child mobs now take 20 mins to grow up, reverted to simple mob spawning with setting to use area checks, on_flop added, air_damage added.
	27	- 1.53 - Added 'on_map_load' settings to mobs:spawn so that mobs will only spawn when new areas of map are loaded.
	28	- 1.52 - Added 'mob_active_limit' in settings to set number of mobs in game,
	29	(default is 0 for unlimited), removed {immortal} from mob armor, fluid viscocity slows mobs
	30	- 1.51 - Added some node checks for dangerous nodes, jumping and falling tweaks, spawn area check (thx for idea wuzzy), re-enabled mob suffocation, add 'mob_nospawn_range' setting
	31	- 1.50 - Added new line_of_sight function that uses raycasting if mt5.0 is found, (thanks Astrobe), dont spawn mobs if world anchor nearby (technic or simple_anchor mods), chinese local added
	32	- 1.49- Added mobs:force_capture(self, player) function, api functions now use metatables thanks to bell07
	33	- 1.48- Add mobs:set_velocity(self, velocity) global function
	34	- 1.47- Mob damage changes, min and max light level for damage added, ignition sources checked for lava damage
	35	- 1.46- Mobs only drop rare items when killed by player (drops.min = 0 makes them rare), code tweak, pathfinding no longer sees through walkable nodes
	36	- 1.45- Added Fence Top to add on top of any fence to stop mobs escaping, new line_of_sight tweaked by Astrobe
	37	- 1.44- Added ToolRanks support for swords when attacking mobs
	38	- 1.43- Better 0.4.16 compatibility, added general attack function and settings
	39	- 1.42- Added "all" option to immune_to table, tidied floating mobs to be less intensive
	40	- 1.41- Mob pathfinding has been updated thanks to Elkien3
	41	- 1.40- Updated to use newer functions, requires Minetest 0.4.16+ to work.
	42	- 1.39- Added 'on_breed', 'on_grown' and 'do_punch' custom functions per mob
	43	- 1.38- Better entity checking, nametag setting and on_spawn function added to mob registry, tweaked light damage
	44	- 1.37- Added support for Raymoo's CMI (common mob interface) mod: https://forum.minetest.net/viewtopic.php?f=9&t=15448
	45	- 1.36- Death check added, if mob dies in fire/lava/with lava pick then drops are cooked
	46	- 1.35- Added owner_loyal flag for owned mobs to attack player enemies, also fixed group_attack
	47	- 1.34- Added function to fly mob using directional movement (thanks D00Med for flying code)
	48	- 1.33- Added functions to mount ride mobs (mobs.attach, mobs.detach, mobs.drive) many thanks to Blert2112
	49	- 1.32- Added new spawn check to count specific mobs AND new minetest.conf setting to chance spawn chance and numbers, added ability to protect tamed mobs
	50	- 1.31- Added 'attack_animals' and 'specific_attack' flags for custom monster attacks, also 'mob_difficulty' .conf setting to make mobs harder.
	51	- 1.30- Added support for invisibility mod (mobs cant attack what they cant see), tweaked and tidied code
	52	- 1.29- Split original Mobs Redo into a modpack to make it easier to disable mob sets (animal, monster, npc) or simply use the Api itself for your own mod
	53	- 1.28- New damage system added with ability for mob to be immune to weapons or healed by them :)
	54	- 1.27- Added new sheep, lava flan and spawn egg textures. New Lava Pick tool smelts what you dig. New atan checking function.
	55	- 1.26- Pathfinding feature added thanks to rnd, when monsters attack they become scary smart in finding you :) also, beehive produces honey now :)
	56	- 1.25- Mobs no longer spawn within 12 blocks of player or despawn within same range, spawners now have player detection, Code tidy and tweak.
	57	- 1.24- Added feature where certain animals run away when punched (runaway = true in mob definition)
	58	- 1.23- Added mob spawner block for admin to setup spawners in-game (place and right click to enter settings)
	59	- 1.22- Added ability to name tamed animals and npc using nametags, also npc will attack anyone who punches them apart from owner
	60	- 1.21- Added some more error checking to reduce serialize.h error and added height checks for falling off cliffs (thanks cmdskp)
	61	- 1.20- Error checking added to remove bad mobs, out of map limit mobs and stop serialize.h error
	62	- 1.19- Chickens now drop egg items instead of placing the egg, also throwing eggs result in 1/8 chance of spawning chick
	63	- 1.18- Added docile_by_day flag so that monsters will not attack automatically during daylight hours unless hit first
	64	- 1.17- Added 'dogshoot' attack type, shoots when out of reach, melee attack when in reach, also api tweaks and self.reach added
	65	- 1.16- Mobs follow multiple items now, Npc's can breed
	66	- 1.15- Added Feeding/Taming/Breeding function, right-click to pick up any sheep with X mark on them and replace with new one to fix compatibility.
	67	- 1.14- All .self variables saved in staticdata, Fixed self.health bug
	68	- 1.13- Added capture function (thanks blert2112) chance of picking up mob with hand; net; magic lasso, replaced some .x models with newer .b3d one's
	69	- 1.12- Added animal ownership so that players cannot steal your tamed animals
	70	- 1.11- Added flying mobs (and swimming), fly=true and fly_in="air" or "deafult:water_source" for fishy
	71	- 1,10- Footstep removed (use replace), explosion routine added for exploding mobs.
	72	- 1.09- reworked breeding routine, added mob rotation value, added footstep feature, added jumping mobs with sounds feature, added magic lasso for picking up animals
	73	- 1.08- Mob throwing attack has been rehauled so that they can damage one another, also drops and on_die function added
	74	- 1.07- Npc's can now be set to follow player or stand by using self.order and self.owner variables
	75	- beta- Npc mob added, kills monsters, attacks player when punched, right click with food to heal or gold lump for drop
	76	- 1.06- Changed recovery times after breeding, and time taken to grow up (can be sped up by feeding baby animal)
	77	- 1.05- Added ExeterDad's bunny's which can be picked up and tamed with 4 carrots from farming redo or farming_plus, also shears added to get wool from sheep and lastly Jordach/BSD's kitten
	78	- 1.04- Added mating for sheep, cows and hogs... feed animals to make horny and hope for a baby which is half size, will grow up quick though :)
	79	- 1.03- Added mob drop/replace feature so that chickens can drop eggs, cow/sheep can eat grass/wheat etc.
	80	- 1.02- Sheared sheep are remembered and spawn shaven, Warthogs will attack when threatened, Api additions
	81	- 1.01- Mobs that suffer fall damage or die in water/lava/sunlight will now drop items
	82	- 1.0 - more work on Api so that certain mobs can float in water while some sink like a brick :)
	83	- 0.9 - Spawn eggs added for all mobs (admin only, cannot be placed in protected areas)... Api tweaked
	84	- 0.8 - Added sounds to monster mobs (thanks Cyberpangolin for the sfx) and also chicken sound
	85	- 0.7 - mobs.protected switch added to api.lua, when set to 1 mobs no longer spawn in protected areas, also bug fixes
	86	- 0.6 - Api now supports multi-textured mobs, e.g oerkki, dungeon master, rats and chickens have random skins when spawning (sheep fix TODO), also new Honey block
	87	- 0.5 - Mobs now float in water, die from falling, and some code improvements
	88	- 0.4 - Dungeon Masters and Mese Monsters have much better aim due to shoot_offset, also they can both shoot through nodes that aren't walkable (flowers, grass etc) plus new sheep sound :)
	89	- 0.3 - Added LOTT's Spider mob, made Cobwebs, added KPavel's Bee with Honey and Beehives (made texture), Warthogs now have sound and can be tamed, taming of shaved sheep or milked cow with 8 wheat so it will not despawn, many bug fixes :)
	90	- 0.2 - Cooking bucket of milk into cheese now returns empty bucket
	91	- 0.1 - Initial Release

+18

-0

settingtypes.txt less more

12	12	# If false then Mobs no longer spawn inside player protected areas
13	13	mobs_spawn_protected (Spawn Mobs in protected areas) bool true
14	14
	15	# If false then Monsters no longer spawn inside player protected areas
	16	mobs_spawn_monster_protected (Spawn Monsters in protected areas) bool true
	17
15	18	# If true Mobs will be removed once a map chunk is out of view
16	19	remove_far_mobs (Remove far Mobs) bool true
17	20

26	29
27	30	# When false Mob no longer drop items when killed
28	31	mobs_drop_items (Mob drops) bool true
	32
	33	# Sets minimum distance around player that mobs cannot spawn
	34	mob_nospawn_range (Mob no-spawn range) float 12.0
	35
	36	# Sets maximum number of active mobs in game (0 for unlimited)
	37	mob_active_limit (Mob Active Limit) float 0
	38
	39	# Enables area check when spawning mobs
	40	mob_area_spawn (Mob Area Spawn) bool false
	41
	42	# Enable peaceful player attack prevention
	43	enable_peaceful_player (Mobs do not attack peaceful player without reason) bool false
	44
	45	# Enable mobs smooth rotation
	46	mob_smooth_rotate (Smooth rotation for mobs) bool true

+27

-16

spawner.lua less more

0	0
1		-- intllib
2		local MP = minetest.get_modpath(minetest.get_current_modname())
3		local S, NS = dofile(MP .. "/intllib.lua")
	1	local S = mobs.intllib
4	2
5	3	-- mob spawner
6	4
7		local spawner_default = "mobs_animal:pumba 10 15 0 0"
	5	local spawner_default = "mobs_animal:pumba 10 15 0 0 0"
8	6
9	7	minetest.register_node("mobs:spawner", {
10	8	tiles = {"mob_spawner.png"},

18	16
19	17	local meta = minetest.get_meta(pos)
20	18
	19	-- setup formspec
	20	local head = S("(mob name) (min light) (max light) (amount)"
	21	.. " (player distance) (Y offset)")
	22
21	23	-- text entry formspec
22	24	meta:set_string("formspec",
23		"field[text;" .. S("Mob MinLight MaxLight Amount PlayerDist") .. ";${command}]")
	25	"size[10,3.5]"
	26	.. "label[0.15,0.5;" .. minetest.formspec_escape(head) .. "]"
	27	.. "field[1,2.5;8.5,0.8;text;" .. S("Command:")
	28	.. ";${command}]")
	29
24	30	meta:set_string("infotext", S("Spawner Not Active (enter settings)"))
25	31	meta:set_string("command", spawner_default)
26	32	end,

54	60	local pla = tonumber(comm[5]) -- player distance (0 to disable)
55	61	local yof = tonumber(comm[6]) or 0 -- Y offset to spawn mob
56	62
57		if mob and mob ~= "" and mobs.spawning_mobs[mob] == true
	63	if mob and mob ~= "" and mobs.spawning_mobs[mob]
58	64	and num and num >= 0 and num <= 10
59	65	and mlig and mlig >= 0 and mlig <= 15
60	66	and xlig and xlig >= 0 and xlig <= 15
61		and pla and pla >=0 and pla <= 20
	67	and pla and pla >= 0 and pla <= 20
62	68	and yof and yof > -10 and yof < 10 then
63	69
64	70	meta:set_string("command", fields.text)

67	73	else
68	74	minetest.chat_send_player(name, S("Mob Spawner settings failed!"))
69	75	minetest.chat_send_player(name,
70		S("Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] distance[1-20] y_offset[-10 to 10]”"))
	76	S("Syntax: “name min_light[0-14] max_light[0-14] max_mobs_in_area[0 to disable] player_distance[1-20] y_offset[-10 to 10]”"))
71	77	end
72		end,
	78	end
73	79	})
74	80
75	81

116	122	-- check objects inside 9x9 area around spawner
117	123	local objs = minetest.get_objects_inside_radius(pos, 9)
118	124	local count = 0
119		local ent = nil
	125	local ent
120	126
121	127	-- count mob objects of same type in area
122		for k, obj in ipairs(objs) do
	128	for _, obj in ipairs(objs) do
123	129
124	130	ent = obj:get_luaentity()
125	131

137	143	if pla > 0 then
138	144
139	145	local in_range = 0
140		local objs = minetest.get_objects_inside_radius(pos, pla)
	146	local objsp = minetest.get_objects_inside_radius(pos, pla)
141	147
142		for _,oir in pairs(objs) do
	148	for _, oir in pairs(objsp) do
143	149
144	150	if oir:is_player() then
145	151

155	161	end
156	162	end
157	163
	164	-- set medium mob usually spawns in (defaults to air)
	165	local reg = minetest.registered_entities[mob].fly_in
	166
	167	if not reg or type(reg) == "string" then
	168	reg = {(reg or "air")}
	169	end
	170
158	171	-- find air blocks within 5 nodes of spawner
159	172	local air = minetest.find_nodes_in_area(
160	173	{x = pos.x - 5, y = pos.y + yof, z = pos.z - 5},
161		{x = pos.x + 5, y = pos.y + yof, z = pos.z + 5},
162		{"air"})
	174	{x = pos.x + 5, y = pos.y + yof, z = pos.z + 5}, reg)
163	175
164	176	-- spawn in random air block
165	177	if air and #air > 0 then

175	187	minetest.add_entity(pos2, mob)
176	188	end
177	189	end
178
179	190	end
180	191	})

textures/mobs_meat_bottom.png less more

Binary diff not shown

textures/mobs_meat_side.png less more

Binary diff not shown

textures/mobs_meat_top.png less more

Binary diff not shown

textures/mobs_protector2.png less more

Binary diff not shown