Commit 114c3be64f97c2d51e02c7119b3161c42ce428bd - minetest-mod-mobs-redo

Update upstream source from tag 'upstream/20210923' Update to upstream version '20210923' with Debian dir ad375aa41d8cdf748f2d8b3afd04346a6c5d99e3 Julien Puydt 2 years ago

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

+2204

-1290

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 = "20210920",
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	_breed_countdown = nil,
	163	_cmi_is_mob = true
	164	}
	165
	166	local mob_class_meta = {__index = mob_class}
	167
80	168
81	169	-- play sound
82		local mob_sound = function(self, sound)
	170	function mob_class:mob_sound(sound)
	171
	172	local pitch = 1.0
	173
	174	-- higher pitch for a child
	175	if self.child then pitch = pitch * 1.5 end
	176
	177	-- a little random pitch to be different
	178	pitch = pitch + random(-10, 10) * 0.005
83	179
84	180	if sound then
85	181	minetest.sound_play(sound, {
86	182	object = self.object,
87	183	gain = 1.0,
88		max_hear_distance = self.sounds.distance
89		})
	184	max_hear_distance = self.sounds.distance,
	185	pitch = pitch
	186	}, true)
90	187	end
91	188	end
92	189
93	190
94	191	-- attack player/mob
95		local do_attack = function(self, player)
	192	function mob_class:do_attack(player)
96	193
97	194	if self.state == "attack" then
98	195	return

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

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

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

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

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

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

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

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

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

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

365	711	minsize = min_size,
366	712	maxsize = max_size,
367	713	texture = texture,
368		glow = glow,
	714	glow = glow
369	715	})
370	716	end
371	717
	718	function mobs:effect(pos, amount, texture, min_size, max_size,
	719	radius, gravity, glow, fall)
	720
	721	effect(pos, amount, texture, min_size, max_size, radius, gravity, glow, fall)
	722	end
	723
	724
	725	-- Thanks Wuzzy for the following editable settings
	726
	727	local HORNY_TIME = 30
	728	local HORNY_AGAIN_TIME = 60 * 5 -- 5 minutes
	729	local CHILD_GROW_TIME = 60 * 20 -- 20 minutes
	730
372	731
373	732	-- update nametag colour
374		local update_tag = function(self)
	733	function mob_class:update_tag()
375	734
376	735	local col = "#00FF00"
377	736	local qua = self.hp_max / 4

388	747	col = "#FF0000"
389	748	end
390	749
	750	local text = ""
	751
	752	if self.horny == true then
	753
	754	text = "\nLoving: " .. (self.hornytimer - (HORNY_TIME + HORNY_AGAIN_TIME))
	755
	756	elseif self.child == true then
	757
	758	text = "\nGrowing: " .. (self.hornytimer - CHILD_GROW_TIME)
	759
	760	elseif self._breed_countdown then
	761
	762	text = "\nBreeding: " .. self._breed_countdown
	763
	764	end
	765
	766	self.infotext = "Health: " .. self.health .. " / " .. self.hp_max
	767	.. "\n" .. "Owner: " .. self.owner
	768	.. text
	769
	770	-- set changes
391	771	self.object:set_properties({
392	772	nametag = self.nametag,
393		nametag_color = col
	773	nametag_color = col,
	774	infotext = self.infotext
394	775	})
395
396	776	end
397	777
398	778
399	779	-- drop items
400		local item_drop = function(self)
	780	function mob_class:item_drop()
	781
	782	-- no drops if disabled by setting or mob is child
	783	if not mobs_drop_items or self.child then return end
	784
	785	local pos = self.object:get_pos()
	786
	787	-- check for drops function
	788	self.drops = type(self.drops) == "function"
	789	and self.drops(pos) or self.drops
401	790
402	791	-- check for nil or no drops
403	792	if not self.drops or #self.drops == 0 then
404	793	return
405	794	end
406	795
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	796	-- 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
	797	local death_by_player = self.cause_of_death
	798	and self.cause_of_death.puncher
	799	and self.cause_of_death.puncher:is_player()
416	800
417	801	local obj, item, num
418		local pos = self.object:get_pos()
419	802
420	803	for n = 1, #self.drops do
421	804
422		if random(1, self.drops[n].chance) == 1 then
	805	if random(self.drops[n].chance) == 1 then
423	806
424	807	num = random(self.drops[n].min or 0, self.drops[n].max or 1)
425	808	item = self.drops[n].name

435	818	end
436	819	end
437	820
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
	821	-- only drop rare items (drops.min = 0) if killed by player
	822	if death_by_player or self.drops[n].min ~= 0 then
443	823	obj = minetest.add_item(pos, ItemStack(item .. " " .. num))
444	824	end
445	825

448	828	obj:set_velocity({
449	829	x = random(-10, 10) / 9,
450	830	y = 6,
451		z = random(-10, 10) / 9,
	831	z = random(-10, 10) / 9
452	832	})
453	833
454	834	elseif obj then

461	841	end
462	842
463	843
	844	-- remove mob and descrease counter
	845	local remove_mob = function(self, decrease)
	846
	847	self.object:remove()
	848
	849	if decrease and active_limit > 0 then
	850
	851	active_mobs = active_mobs - 1
	852
	853	if active_mobs < 0 then
	854	active_mobs = 0
	855	end
	856	end
	857	--print("-- active mobs: " .. active_mobs .. " / " .. active_limit)
	858	end
	859
	860	-- global function for removing mobs
	861	function mobs:remove(self, decrease)
	862	remove_mob(self, decrease)
	863	end
	864
	865
464	866	-- check if mob is dead or only hurt
465		local check_for_death = function(self, cmi_cause)
	867	function mob_class:check_for_death(cmi_cause)
	868
	869	-- We dead already
	870	if self.state == "die" then
	871	return true
	872	end
466	873
467	874	-- has health actually changed?
468	875	if self.health == self.old_health and self.health > 0 then
469		return
470		end
	876	return false
	877	end
	878
	879	local damaged = self.health < self.old_health
471	880
472	881	self.old_health = self.health
473	882
474	883	-- still got some health? play hurt sound
475	884	if self.health > 0 then
476	885
477		mob_sound(self, self.sounds.damage)
	886	-- only play hurt sound if damaged
	887	if damaged then
	888	self:mob_sound(self.sounds.damage)
	889	end
478	890
479	891	-- make sure health isn't higher than max
480	892	if self.health > self.hp_max then

482	894	end
483	895
484	896	-- 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
	897	-- if not self.nametag2 then
	898	-- self.nametag2 = self.nametag or ""
	899	-- end
	900
	901	-- if show_health
	902	-- and (cmi_cause and cmi_cause.type == "punch") then
	903
	904	-- self.htimer = 2
	905	-- self.nametag = "♥ " .. self.health .. " / " .. self.hp_max
	906	self:update_tag()
	907	-- end
497	908
498	909	return false
499	910	end

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

611	1074	end
612	1075
613	1076	-- 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()
	1077	-- if self.htimer < 1 and self.nametag2 then
	1078
	1079	-- self.nametag = self.nametag2
	1080	-- self.nametag2 = nil
	1081
	1082	self:update_tag()
	1083	-- end
	1084
	1085	local pos = self.object:get_pos() ; if not pos then return end
623	1086
624	1087	self.time_of_day = minetest.get_timeofday()
625	1088
626		-- remove mob if standing inside ignore node
	1089	-- halt mob if standing inside ignore node
627	1090	if self.standing_in == "ignore" then
628		self.object:remove()
629		return
	1091
	1092	self.object:set_velocity({x = 0, y = 0, z = 0})
	1093
	1094	return true
	1095	end
	1096
	1097	-- particle appears at random mob height
	1098	local py = {
	1099	x = pos.x,
	1100	y = pos.y + random(self.collisionbox[2], self.collisionbox[5]),
	1101	z = pos.z
	1102	}
	1103
	1104	local nodef = minetest.registered_nodes[self.standing_in]
	1105
	1106	-- water
	1107	if self.water_damage ~= 0 and nodef.groups.water then
	1108
	1109	self.health = self.health - self.water_damage
	1110
	1111	effect(py, 5, "bubble.png", nil, nil, 1, nil)
	1112
	1113	if self:check_for_death({type = "environment",
	1114	pos = pos, node = self.standing_in}) then
	1115	return true
	1116	end
	1117
	1118	-- lava damage
	1119	elseif self.lava_damage ~= 0 and nodef.groups.lava then
	1120
	1121	self.health = self.health - self.lava_damage
	1122
	1123	effect(py, 15, "fire_basic_flame.png", 1, 5, 1, 0.2, 15, true)
	1124
	1125	if self:check_for_death({type = "environment", pos = pos,
	1126	node = self.standing_in, hot = true}) then
	1127	return true
	1128	end
	1129
	1130	-- fire damage
	1131	elseif self.fire_damage ~= 0 and nodef.groups.fire then
	1132
	1133	self.health = self.health - self.fire_damage
	1134
	1135	effect(py, 15, "fire_basic_flame.png", 1, 5, 1, 0.2, 15, true)
	1136
	1137	if self:check_for_death({type = "environment", pos = pos,
	1138	node = self.standing_in, hot = true}) then
	1139	return true
	1140	end
	1141
	1142	-- damage_per_second node check (not fire and lava)
	1143	elseif nodef.damage_per_second ~= 0
	1144	and nodef.groups.lava == nil and nodef.groups.fire == nil then
	1145
	1146	self.health = self.health - nodef.damage_per_second
	1147
	1148	effect(py, 5, "tnt_smoke.png")
	1149
	1150	if self:check_for_death({type = "environment",
	1151	pos = pos, node = self.standing_in}) then
	1152	return true
	1153	end
	1154	end
	1155
	1156	-- air damage
	1157	if self.air_damage ~= 0 and self.standing_in == "air" then
	1158
	1159	self.health = self.health - self.air_damage
	1160
	1161	effect(py, 3, "bubble.png", 1, 1, 1, 0.2)
	1162
	1163	if self:check_for_death({type = "environment",
	1164	pos = pos, node = self.standing_in}) then
	1165	return true
	1166	end
630	1167	end
631	1168
632	1169	-- is mob light sensative, or scared of the dark :P

639	1176
640	1177	self.health = self.health - self.light_damage
641	1178
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		--[[
	1179	effect(py, 5, "tnt_smoke.png")
	1180
	1181	if self:check_for_death({type = "light"}) then
	1182	return true
	1183	end
	1184	end
	1185	end
	1186
694	1187	--- 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"})
	1188	if (self.suffocation and self.suffocation ~= 0)
	1189	and (nodef.walkable == nil or nodef.walkable == true)
	1190	and (nodef.collision_box == nil or nodef.collision_box.type == "regular")
	1191	and (nodef.node_box == nil or nodef.node_box.type == "regular")
	1192	and (nodef.groups.disable_suffocation ~= 1) then
	1193
	1194	local damage
	1195
	1196	if self.suffocation == true then
	1197	damage = 2
	1198	else
	1199	damage = (self.suffocation or 2)
	1200	end
	1201
	1202	self.health = self.health - damage
	1203
	1204	if self:check_for_death({type = "suffocation",
	1205	pos = pos, node = self.standing_in}) then
	1206	return true
	1207	end
	1208	end
	1209
	1210	return self:check_for_death({type = "unknown"})
707	1211	end
708	1212
709	1213
710	1214	-- jump if facing a solid node (not fences or gates)
711		local do_jump = function(self)
	1215	function mob_class:do_jump()
712	1216
713	1217	if not self.jump
714	1218	or self.jump_height == 0

722	1226
723	1227	-- something stopping us while moving?
724	1228	if self.state ~= "stand"
725		and get_velocity(self) > 0.5
	1229	and self:get_velocity() > 0.5
726	1230	and self.object:get_velocity().y ~= 0 then
727	1231	return false
728	1232	end

730	1234	local pos = self.object:get_pos()
731	1235	local yaw = self.object:get_yaw()
732	1236
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
	1237	-- sanity check
	1238	if not yaw then return false end
	1239
	1240	-- we can only jump if standing on solid node
	1241	if minetest.registered_nodes[self.standing_on].walkable == false then
741	1242	return false
742	1243	end
743	1244

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

813	1340	obj_pos = objs[n]:get_pos()
814	1341
815	1342	dist = get_distance(pos, obj_pos)
	1343
816	1344	if dist < 1 then dist = 1 end
817	1345
818	1346	local damage = floor((4 / dist) * radius)

827	1355	end
828	1356
829	1357
	1358	-- can mob see player
	1359	local is_invisible = function(self, player_name)
	1360
	1361	if mobs.invis[player_name] and not self.ignore_invisibility then
	1362	return true
	1363	end
	1364	end
	1365
	1366
830	1367	-- should mob follow what I'm holding ?
831		local follow_holding = function(self, clicker)
832
833		if mobs.invis[clicker:get_player_name()] then
	1368	function mob_class:follow_holding(clicker)
	1369
	1370	if is_invisible(self, clicker:get_player_name()) then
834	1371	return false
835	1372	end
836	1373
837	1374	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
	1375
	1376	-- are we holding an item mob can follow ?
	1377	if check_for(item:get_name(), self.follow) then
843	1378	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	1379	end
855	1380
856	1381	return false

858	1383
859	1384
860	1385	-- 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
	1386	function mob_class:breed()
	1387
	1388	-- child takes a long time before growing into adult
864	1389	if self.child == true then
865	1390
866	1391	self.hornytimer = self.hornytimer + 1
867	1392
868		if self.hornytimer > 240 then
	1393	if self.hornytimer > CHILD_GROW_TIME then
869	1394
870	1395	self.child = false
871	1396	self.hornytimer = 0

875	1400	mesh = self.base_mesh,
876	1401	visual_size = self.base_size,
877	1402	collisionbox = self.base_colbox,
878		selectionbox = self.base_selbox,
	1403	selectionbox = self.base_selbox
879	1404	})
880	1405
881	1406	-- custom function when child grows up
882	1407	if self.on_grown then
883	1408	self.on_grown(self)
884	1409	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		})
	1410	local pos = self.object:get_pos() ; if not pos then return end
	1411	local ent = self.object:get_luaentity()
	1412
	1413	pos.y = pos.y + (ent.collisionbox[2] * -1) - 0.4
	1414
	1415	self.object:set_pos(pos)
	1416
	1417	-- jump slightly when fully grown so as not to fall into ground
	1418	self.object:set_velocity({x = 0, y = 0.5, z = 0 })
891	1419	end
892	1420	end
893	1421
894	1422	return
895	1423	end
896	1424
897		-- horny animal can mate for 40 seconds,
898		-- afterwards horny animal cannot mate again for 200 seconds
	1425	-- horny animal can mate for HORNY_TIME seconds,
	1426	-- afterwards horny animal cannot mate again for HORNY_AGAIN_TIME seconds
899	1427	if self.horny == true
900		and self.hornytimer < 240 then
	1428	and self.hornytimer < HORNY_TIME + HORNY_AGAIN_TIME then
901	1429
902	1430	self.hornytimer = self.hornytimer + 1
903	1431
904		if self.hornytimer >= 240 then
	1432	if self.hornytimer >= HORNY_TIME + HORNY_AGAIN_TIME then
905	1433	self.hornytimer = 0
906	1434	self.horny = false
907	1435	end
	1436
	1437	self:update_tag()
908	1438	end
909	1439
910	1440	-- find another same animal who is also horny and mate if nearby
911	1441	if self.horny == true
912		and self.hornytimer <= 40 then
	1442	and self.hornytimer <= HORNY_TIME then
913	1443
914	1444	local pos = self.object:get_pos()
915	1445
916		effect({x = pos.x, y = pos.y + 1, z = pos.z}, 8, "heart.png", 3, 4, 1, 0.1)
	1446	effect({x = pos.x, y = pos.y + 1, z = pos.z}, 8,
	1447	"heart.png", 3, 4, 1, 0.1)
917	1448
918	1449	local objs = minetest.get_objects_inside_radius(pos, 3)
919		local num = 0
920		local ent = nil
	1450	local ent
921	1451
922	1452	for n = 1, #objs do
923	1453

931	1461	if ent.name == self.name then
932	1462	canmate = true
933	1463	else
934		local entname = string.split(ent.name,":")
935		local selfname = string.split(self.name,":")
	1464	local entname = ent.name:split(":")
	1465	local selfname = self.name:split(":")
936	1466
937	1467	if entname[1] == selfname[1] then
938		entname = string.split(entname[2],"_")
939		selfname = string.split(selfname[2],"_")
	1468	entname = entname[2]:split("_")
	1469	selfname = selfname[2]:split("_")
940	1470
941	1471	if entname[1] == selfname[1] then
942	1472	canmate = true

945	1475	end
946	1476	end
947	1477
948		if ent
	1478	-- found another similar horny animal that isn't self?
	1479	if ent and ent.object ~= self.object
949	1480	and canmate == true
950	1481	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
	1482	and ent.hornytimer <= HORNY_TIME then
	1483
	1484	local pos2 = ent.object:get_pos()
	1485
	1486	-- Have mobs face one another
	1487	yaw_to_pos(self, pos2)
	1488	yaw_to_pos(ent, self.object:get_pos())
	1489
	1490	self.hornytimer = HORNY_TIME + 1
	1491	ent.hornytimer = HORNY_TIME + 1
	1492
	1493	self:update_tag()
	1494
	1495	-- have we reached active mob limit
	1496	if active_limit > 0 and active_mobs >= active_limit then
	1497	minetest.chat_send_player(self.owner,
	1498	S("Active Mob Limit Reached!")
	1499	.. " (" .. active_mobs
	1500	.. " / " .. active_limit .. ")")
	1501	return
	1502	end
960	1503
961	1504	-- spawn baby
962	1505	minetest.after(5, function(self, ent)

969	1512	if self.on_breed then
970	1513
971	1514	-- when false skip going any further
972		if self.on_breed(self, ent) == false then
	1515	if self:on_breed(ent) == false then
973	1516	return
974	1517	end
975	1518	else
976	1519	effect(pos, 15, "tnt_smoke.png", 1, 2, 2, 15, 5)
977	1520	end
978	1521
	1522	pos.y = pos.y + 0.5 -- spawn child a little higher
	1523
979	1524	local mob = minetest.add_entity(pos, self.name)
980	1525	local ent2 = mob:get_luaentity()
981	1526	local textures = self.base_texture

990	1535	textures = textures,
991	1536	visual_size = {
992	1537	x = self.base_size.x * .5,
993		y = self.base_size.y * .5,
	1538	y = self.base_size.y * .5
994	1539	},
995	1540	collisionbox = {
996	1541	self.base_colbox[1] * .5,

998	1543	self.base_colbox[3] * .5,
999	1544	self.base_colbox[4] * .5,
1000	1545	self.base_colbox[5] * .5,
1001		self.base_colbox[6] * .5,
	1546	self.base_colbox[6] * .5
1002	1547	},
1003	1548	selectionbox = {
1004	1549	self.base_selbox[1] * .5,

1006	1551	self.base_selbox[3] * .5,
1007	1552	self.base_selbox[4] * .5,
1008	1553	self.base_selbox[5] * .5,
1009		self.base_selbox[6] * .5,
	1554	self.base_selbox[6] * .5
1010	1555	},
1011	1556	})
1012	1557	-- tamed and owned by parents' owner

1015	1560	ent2.owner = self.owner
1016	1561	end, self, ent)
1017	1562
1018		num = 0
1019
1020	1563	break
1021	1564	end
1022	1565	end

1025	1568
1026	1569
1027	1570	-- find and replace what mob is looking for (grass, wheat etc.)
1028		local replace = function(self, pos)
	1571	function mob_class:replace(pos)
	1572
	1573	local vel = self.object:get_velocity()
	1574	if not vel then return end
1029	1575
1030	1576	if not mobs_griefing
1031	1577	or not self.replace_rate
1032	1578	or not self.replace_what
1033	1579	or self.child == true
1034		or self.object:get_velocity().y ~= 0
1035		or random(1, self.replace_rate) > 1 then
	1580	or vel.y ~= 0
	1581	or random(self.replace_rate) > 1 then
1036	1582	return
1037	1583	end
1038	1584

1055	1601
1056	1602	if #minetest.find_nodes_in_area(pos, pos, what) > 0 then
1057	1603
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
	1604	-- print("replace node = ".. minetest.get_node(pos).name, pos.y)
1063	1605
1064	1606	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
	1607
	1608	local oldnode = what or ""
	1609	local newnode = with
	1610
	1611	-- pass actual node name when using table or groups
	1612	if type(oldnode) == "table"
	1613	or oldnode:find("group:") then
	1614	oldnode = minetest.get_node(pos).name
	1615	end
	1616
	1617	if self:on_replace(pos, oldnode, newnode) == false then
	1618	return
	1619	end
	1620	end
	1621
	1622	minetest.set_node(pos, {name = with})
1078	1623	end
1079	1624	end
1080	1625
1081	1626
1082	1627	-- check if daytime and also if mob is docile during daylight hours
1083		local day_docile = function(self)
	1628	function mob_class:day_docile()
1084	1629
1085	1630	if self.docile_by_day == false then
1086	1631

1097	1642
1098	1643	local los_switcher = false
1099	1644	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)
	1645	local can_dig_drop = function(pos)
	1646
	1647	if minetest.is_protected(pos, "") then
	1648	return false
	1649	end
	1650
	1651	local node = node_ok(pos, "air").name
	1652	local ndef = minetest.registered_nodes[node]
	1653
	1654	if node ~= "ignore"
	1655	and ndef
	1656	and ndef.drawtype ~= "airlike"
	1657	and not ndef.groups.level
	1658	and not ndef.groups.unbreakable
	1659	and not ndef.groups.liquid then
	1660
	1661	local drops = minetest.get_node_drops(node)
	1662
	1663	for _, item in ipairs(drops) do
	1664
	1665	minetest.add_item({
	1666	x = pos.x - 0.5 + random(),
	1667	y = pos.y - 0.5 + random(),
	1668	z = pos.z - 0.5 + random()
	1669	}, item)
	1670	end
	1671
	1672	minetest.remove_node(pos)
	1673
	1674	return true
	1675	end
	1676
	1677	return false
	1678	end
	1679
	1680
	1681	local pathfinder_mod = minetest.get_modpath("pathfinder")
	1682	-- path finding and smart mob routine by rnd,
	1683	-- line_of_sight and other edits by Elkien3
	1684	function mob_class:smart_mobs(s, p, dist, dtime)
1103	1685
1104	1686	local s1 = self.path.lastpos
1105
1106		local target_pos = self.attack:get_pos()
	1687	local target_pos = p
	1688
1107	1689
1108	1690	-- is it becoming stuck?
1109	1691	if abs(s1.x - s.x) + abs(s1.z - s.z) < .5 then

1176	1758	end, self)
1177	1759	end
1178	1760
1179		if abs(vector.subtract(s,target_pos).y) > self.stepheight then
	1761	if abs(vsubtract(s,target_pos).y) > self.stepheight then
1180	1762
1181	1763	if height_switcher then
1182	1764	use_pathfind = true

1189	1771	end
1190	1772	end
1191	1773
	1774	-- lets try find a path, first take care of positions
	1775	-- since pathfinder is very sensitive
1192	1776	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	1777
1197	1778	-- round position to center of node to avoid stuck in walls
1198	1779	-- also adjust height for player models!
1199	1780	s.x = floor(s.x + 0.5)
1200		-- s.y = floor(s.y + 0.5) - sheight
1201	1781	s.z = floor(s.z + 0.5)
1202	1782
1203	1783	local ssight, sground = minetest.line_of_sight(s, {

1215	1795	p1.z = floor(p1.z + 0.5)
1216	1796
1217	1797	local dropheight = 6
	1798
1218	1799	if self.fear_height ~= 0 then dropheight = self.fear_height end
1219	1800
1220		self.path.way = minetest.find_path(s, p1, 16, self.stepheight, dropheight, "Dijkstra")
1221
	1801	local jumpheight = 0
	1802
	1803	if self.jump and self.jump_height >= 4 then
	1804	jumpheight = min(ceil(self.jump_height / 4), 4)
	1805
	1806	elseif self.stepheight > 0.5 then
	1807	jumpheight = 1
	1808	end
	1809
	1810	if pathfinder_mod then
	1811	self.path.way = pathfinder.find_path(s, p1, self, dtime)
	1812	else
	1813	self.path.way = minetest.find_path(s, p1, 16, jumpheight,
	1814	dropheight, "Dijkstra")
	1815	end
1222	1816	--[[
1223	1817	-- show path using particles
1224	1818	if self.path.way and #self.path.way > 0 then
1225		print ("-- path length:" .. tonumber(#self.path.way))
	1819
	1820	print("-- path length:" .. tonumber(#self.path.way))
	1821
1226	1822	for _,pos in pairs(self.path.way) do
1227	1823	minetest.add_particle({
1228	1824	pos = pos,

1239	1835	]]
1240	1836
1241	1837	self.state = ""
1242		do_attack(self, self.attack)
	1838
	1839	if self.attack then
	1840	self:do_attack(self.attack)
	1841	end
1243	1842
1244	1843	-- no path found, try something else
1245	1844	if not self.path.way then

1249	1848	-- lets make way by digging/building if not accessible
1250	1849	if self.pathfinding == 2 and mobs_griefing then
1251	1850
1252		-- is player higher than mob?
1253		if s.y < p1.y then
	1851	-- is player more than 1 block higher than mob?
	1852	if p1.y > (s.y + 1) then
1254	1853
1255	1854	-- build upwards
1256	1855	if not minetest.is_protected(s, "") then

1258	1857	local ndef1 = minetest.registered_nodes[self.standing_in]
1259	1858
1260	1859	if ndef1 and (ndef1.buildable_to or ndef1.groups.liquid) then
1261
1262		minetest.set_node(s, {name = mobs.fallback_node})
	1860	minetest.set_node(s, {name = mobs.fallback_node})
1263	1861	end
1264	1862	end
1265	1863
1266		local sheight = math.ceil(self.collisionbox[5]) + 1
	1864	local sheight = ceil(self.collisionbox[5]) + 1
1267	1865
1268	1866	-- assume mob is 2 blocks high so it digs above its head
1269	1867	s.y = s.y + sheight
1270	1868
1271	1869	-- 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
	1870	can_dig_drop(s)
1289	1871
1290	1872	s.y = s.y - sheight
1291	1873	self.object:set_pos({x = s.x, y = s.y + 2, z = s.z})
	1874
	1875	-- is player more than 1 block lower than mob
	1876	elseif p1.y < (s.y - 1) then
	1877
	1878	-- dig down
	1879	s.y = s.y - self.collisionbox[4] - 0.2
	1880
	1881	can_dig_drop(s)
1292	1882
1293	1883	else -- dig 2 blocks to make door toward player direction
1294	1884

1299	1889	z = s.z + sin(yaw1)
1300	1890	}
1301	1891
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
	1892	-- dig bottom node first incase of door
	1893	can_dig_drop(p1)
	1894
	1895	p1.y = p1.y + 1
	1896
	1897	can_dig_drop(p1)
1334	1898	end
1335	1899	end
1336	1900
1337	1901	-- will try again in 2 second
1338	1902	self.path.stuck_timer = stuck_timeout - 2
1339	1903
1340		-- frustration! cant find the damn path :(
1341		mob_sound(self, self.sounds.random)
	1904	elseif s.y < p1.y and (not self.fly) then
	1905	self:do_jump() --add jump to pathfinding
	1906	self.path.following = true
1342	1907	else
1343	1908	-- yay i found path
1344		mob_sound(self, self.sounds.war_cry)
1345		set_velocity(self, self.walk_velocity)
	1909	if self.attack then
	1910	self:mob_sound(self.sounds.war_cry)
	1911	else
	1912	self:mob_sound(self.sounds.random)
	1913	end
	1914
	1915	self:set_velocity(self.walk_velocity)
1346	1916
1347	1917	-- follow path now that it has it
1348	1918	self.path.following = true

1351	1921	end
1352	1922
1353	1923
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
	1924	-- peaceful player privilege support
	1925	local function is_peaceful_player(player)
	1926
	1927	if peaceful_player_enabled then
	1928
	1929	local player_name = player:get_player_name()
	1930
	1931	if player_name
	1932	and minetest.check_player_privs(player_name, "peaceful_player") then
1366	1933	return true
1367	1934	end
1368	1935	end

1371	1938	end
1372	1939
1373	1940
1374		-- general attack function for all mobs ==========
1375		local general_attack = function(self)
	1941	-- general attack function for all mobs
	1942	function mob_class:general_attack()
1376	1943
1377	1944	-- return if already attacking, passive or docile during day
1378	1945	if self.passive
	1946	or self.state == "runaway"
1379	1947	or self.state == "attack"
1380		or day_docile(self) then
	1948	or self:day_docile() then
1381	1949	return
1382	1950	end
1383	1951
1384		local s = self.object:get_pos()
	1952	local s = self.object:get_pos() ; if not s then return end
1385	1953	local objs = minetest.get_objects_inside_radius(s, self.view_range)
1386	1954
1387	1955	-- remove entities we aren't interested in

1392	1960	-- are we a player?
1393	1961	if objs[n]:is_player() then
1394	1962
1395		-- if player invisible or mob not setup to attack then remove from list
1396		if self.attack_players == false
	1963	-- if player invisible or mob cannot attack then remove from list
	1964	if not damage_enabled
	1965	or self.attack_players == false
1397	1966	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
	1967	or is_invisible(self, objs[n]:get_player_name())
	1968	or (self.specific_attack
	1969	and not check_for("player", self.specific_attack)) then
1400	1970	objs[n] = nil
1401	1971	--print("- pla", n)
1402	1972	end

1409	1979	or (not self.attack_animals and ent.type == "animal")
1410	1980	or (not self.attack_monsters and ent.type == "monster")
1411	1981	or (not self.attack_npcs and ent.type == "npc")
1412		or not specific_attack(self.specific_attack, ent.name) then
	1982	or (self.specific_attack
	1983	and not check_for(ent.name, self.specific_attack)) then
1413	1984	objs[n] = nil
1414	1985	--print("- mob", n, self.name, ent.name)
1415	1986	end

1439	2010	-- choose closest player to attack that isnt self
1440	2011	if dist ~= 0
1441	2012	and dist < min_dist
1442		and line_of_sight(self, sp, p, 2) == true then
	2013	and self:line_of_sight(sp, p, 2) == true
	2014	and not is_peaceful_player(player) then
1443	2015	min_dist = dist
1444	2016	min_player = player
1445	2017	end
1446	2018	end
1447	2019
1448	2020	-- 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
	2021	if min_player and random(100) > self.attack_chance then
	2022	self:do_attack(min_player)
	2023	end
1472	2024	end
1473	2025
1474	2026
1475	2027	-- find someone to runaway from
1476		local runaway_from = function(self)
	2028	function mob_class:do_runaway_from()
1477	2029
1478	2030	if not self.runaway_from then
1479	2031	return
1480	2032	end
1481	2033
1482		local s = self.object:get_pos()
	2034	local s = self.object:get_pos() ; if not s then return end
1483	2035	local p, sp, dist, pname
1484	2036	local player, obj, min_player, name
1485	2037	local min_dist = self.view_range + 1

1491	2043
1492	2044	pname = objs[n]:get_player_name()
1493	2045
1494		if mobs.invis[pname]
	2046	if is_invisible(self, pname)
1495	2047	or self.owner == pname then
1496	2048
1497	2049	name = ""

1510	2062
1511	2063	-- find specific mob to runaway from
1512	2064	if name ~= "" and name ~= self.name
1513		and specific_runaway(self.runaway_from, name) then
1514
1515		p = player:get_pos()
	2065	and (self.runaway_from and check_for(name, self.runaway_from)) then
	2066
1516	2067	sp = s
	2068	p = player and player:get_pos() or s
1517	2069
1518	2070	-- aim higher to make looking up hills more realistic
1519	2071	p.y = p.y + 1

1523	2075
1524	2076	-- choose closest player/mob to runaway from
1525	2077	if dist < min_dist
1526		and line_of_sight(self, sp, p, 2) == true then
	2078	and self:line_of_sight(sp, p, 2) == true then
1527	2079	min_dist = dist
1528	2080	min_player = player
1529	2081	end

1532	2084
1533	2085	if min_player then
1534	2086
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)
	2087	yaw_to_pos(self, min_player:get_pos(), 3)
	2088
1549	2089	self.state = "runaway"
1550	2090	self.runaway_timer = 3
1551	2091	self.following = nil

1554	2094
1555	2095
1556	2096	-- follow player if owner or holding item, if fish outta water then flop
1557		local follow_flop = function(self)
	2097	function mob_class:follow_flop()
1558	2098
1559	2099	-- find player to follow
1560		if (self.follow ~= ""
1561		or self.order == "follow")
	2100	if (self.follow ~= "" or self.order == "follow")
1562	2101	and not self.following
1563	2102	and self.state ~= "attack"
1564	2103	and self.state ~= "runaway" then
1565	2104
1566		local s = self.object:get_pos()
	2105	local s = self.object:get_pos() ; if not s then return end
1567	2106	local players = minetest.get_connected_players()
1568	2107
1569	2108	for n = 1, #players do
1570	2109
1571	2110	if get_distance(players[n]:get_pos(), s) < self.view_range
1572		and not mobs.invis[ players[n]:get_player_name() ] then
	2111	and not is_invisible(self, players[n]:get_player_name()) then
1573	2112
1574	2113	self.following = players[n]
1575	2114

1590	2129	self.following = nil
1591	2130	end
1592	2131	else
1593		-- stop following player if not holding specific item
	2132	-- stop following player if not holding specific item or mob is horny
1594	2133	if self.following
1595	2134	and self.following:is_player()
1596		and follow_holding(self, self.following) == false then
	2135	and (self:follow_holding(self.following) == false
	2136	or self.horny) then
1597	2137	self.following = nil
1598	2138	end
1599	2139

1622	2162	if dist > self.view_range then
1623	2163	self.following = nil
1624	2164	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)
	2165	yaw_to_pos(self, p)
1635	2166
1636	2167	-- anyone but standing npc's can move along
1637	2168	if dist > self.reach
1638	2169	and self.order ~= "stand" then
1639	2170
1640		set_velocity(self, self.walk_velocity)
	2171	self:set_velocity(self.walk_velocity)
1641	2172
1642	2173	if self.walk_chance ~= 0 then
1643		set_animation(self, "walk")
	2174	self:set_animation("walk")
1644	2175	end
1645	2176	else
1646		set_velocity(self, 0)
1647		set_animation(self, "stand")
	2177	self:set_velocity(0)
	2178	self:set_animation("stand")
1648	2179	end
1649	2180
1650	2181	return

1654	2185
1655	2186	-- swimmers flop when out of their element, and swim again when back in
1656	2187	if self.fly then
1657		local s = self.object:get_pos()
1658		if not flight_check(self, s) then
	2188
	2189	if not self:attempt_flight_correction() then
1659	2190
1660	2191	self.state = "flop"
	2192
	2193	-- do we have a custom on_flop function?
	2194	if self.on_flop then
	2195
	2196	if self:on_flop(self) then
	2197	return
	2198	end
	2199	end
	2200
1661	2201	self.object:set_velocity({x = 0, y = -5, z = 0})
1662	2202
1663		set_animation(self, "stand")
	2203	self:set_animation("stand")
1664	2204
1665	2205	return
	2206
1666	2207	elseif self.state == "flop" then
1667	2208	self.state = "stand"
1668	2209	end

1671	2212
1672	2213
1673	2214	-- dogshoot attack switch and counter function
1674		local dogswitch = function(self, dtime)
	2215	function mob_class:dogswitch(dtime)
1675	2216
1676	2217	-- switch mode not activated
1677	2218	if not self.dogshoot_switch

1700	2241
1701	2242
1702	2243	-- execute current state (stand, walk, run, attacks)
1703		local do_states = function(self, dtime)
1704
1705		local yaw = self.object:get_yaw() or 0
	2244	function mob_class:do_states(dtime)
	2245
	2246	local yaw = self.object:get_yaw() ; if not yaw then return end
1706	2247
1707	2248	if self.state == "stand" then
1708	2249
1709		if random(1, 4) == 1 then
1710
1711		local lp = nil
	2250	if self.randomly_turn and random(4) == 1 then
	2251
	2252	local lp
1712	2253	local s = self.object:get_pos()
1713	2254	local objs = minetest.get_objects_inside_radius(s, 3)
1714	2255

1722	2263
1723	2264	-- look at any players nearby, otherwise turn randomly
1724	2265	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
	2266	yaw = yaw_to_pos(self, lp)
1734	2267	else
1735	2268	yaw = yaw + random(-0.5, 0.5)
1736	2269	end
1737	2270
1738		yaw = set_yaw(self, yaw, 8)
1739		end
1740
1741		set_velocity(self, 0)
1742		set_animation(self, "stand")
	2271	yaw = self:set_yaw(yaw, 8)
	2272	end
	2273
	2274	self:set_velocity(0)
	2275	self:set_animation("stand")
1743	2276
1744	2277	-- mobs ordered to stand stay standing
1745	2278	if self.order ~= "stand"
1746	2279	and self.walk_chance ~= 0
1747	2280	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)
	2281	and random(100) <= self.walk_chance
	2282	and self.at_cliff == false then
	2283
	2284	self:set_velocity(self.walk_velocity)
1752	2285	self.state = "walk"
1753		set_animation(self, "walk")
	2286	self:set_animation("walk")
1754	2287	end
1755	2288
1756	2289	elseif self.state == "walk" then
1757	2290
1758	2291	local s = self.object:get_pos()
1759		local lp = nil
	2292	local lp
1760	2293
1761	2294	-- is there something I need to avoid?
1762	2295	if self.water_damage > 0
1763	2296	and self.lava_damage > 0 then
1764	2297
1765		lp = minetest.find_node_near(s, 1, {"group:water", "group:lava"})
	2298	lp = minetest.find_node_near(s, 1, {"group:water", "group:igniter"})
1766	2299
1767	2300	elseif self.water_damage > 0 then
1768	2301

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

1856	2381
1857	2382	-- stop after 5 seconds or when at cliff
1858	2383	if self.runaway_timer > 5
1859		or is_at_cliff(self)
	2384	or self.at_cliff
1860	2385	or self.order == "stand" then
1861	2386	self.runaway_timer = 0
1862		set_velocity(self, 0)
	2387	self:set_velocity(0)
1863	2388	self.state = "stand"
1864		set_animation(self, "stand")
	2389	self:set_animation("stand")
1865	2390	else
1866		set_velocity(self, self.run_velocity)
1867		set_animation(self, "walk")
	2391	self:set_velocity(self.run_velocity)
	2392	self:set_animation("walk")
1868	2393	end
1869	2394
1870	2395	-- attack routines (explode, dogfight, shoot, dogshoot)
1871	2396	elseif self.state == "attack" then
1872	2397
1873		-- calculate distance from mob and enemy
	2398	-- get mob and enemy positions and distance between
1874	2399	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
	2400	local p = self.attack and self.attack:get_pos()
	2401	local dist = p and get_distance(p, s) or 500
	2402
	2403	-- stop attacking if player out of range or invisible
1879	2404	if dist > self.view_range
1880	2405	or not self.attack
1881	2406	or not self.attack:get_pos()
1882	2407	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)
	2408	or (self.attack:is_player()
	2409	and is_invisible(self, self.attack:get_player_name())) then
	2410
	2411	--print(" stop attacking ", dist, self.view_range)
	2412
1886	2413	self.state = "stand"
1887		set_velocity(self, 0)
1888		set_animation(self, "stand")
	2414	self:set_velocity(0)
	2415	self:set_animation("stand")
1889	2416	self.attack = nil
1890	2417	self.v_start = false
1891	2418	self.timer = 0

1897	2424
1898	2425	if self.attack_type == "explode" then
1899	2426
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)
	2427	yaw = yaw_to_pos(self, p)
1910	2428
1911	2429	local node_break_radius = self.explosion_radius or 1
1912	2430	local entity_damage_radius = self.explosion_damage_radius
1913	2431	or (node_break_radius * 2)
1914	2432
	2433	-- look a little higher to fix raycast
	2434	s.y = s.y + 0.5 ; p.y = p.y + 0.5
	2435
1915	2436	-- start timer when in reach and line of sight
1916	2437	if not self.v_start
1917	2438	and dist <= self.reach
1918		and line_of_sight(self, s, p, 2) then
	2439	and self:line_of_sight(s, p, 2) then
1919	2440
1920	2441	self.v_start = true
1921	2442	self.timer = 0
1922	2443	self.blinktimer = 0
1923		mob_sound(self, self.sounds.fuse)
1924		-- print ("=== explosion timer started", self.explosion_timer)
	2444	self:mob_sound(self.sounds.fuse)
	2445
	2446	--print("=== explosion timer started", self.explosion_timer)
1925	2447
1926	2448	-- stop timer if out of reach or direct line of sight
1927	2449	elseif self.allow_fuse_reset
1928	2450	and self.v_start
1929		and (dist > self.reach
1930		or not line_of_sight(self, s, p, 2)) then
	2451	and (dist > self.reach or not self:line_of_sight(s, p, 2)) then
	2452
	2453	--print("=== explosion timer stopped")
	2454
1931	2455	self.v_start = false
1932	2456	self.timer = 0
1933	2457	self.blinktimer = 0
1934	2458	self.blinkstatus = false
1935		self.object:settexturemod("")
	2459	self.object:set_texture_mod("")
1936	2460	end
1937	2461
1938	2462	-- walk right up to player unless the timer is active
1939	2463	if self.v_start and (self.stop_to_explode or dist < 1.5) then
1940		set_velocity(self, 0)
	2464	self:set_velocity(0)
1941	2465	else
1942		set_velocity(self, self.run_velocity)
	2466	self:set_velocity(self.run_velocity)
1943	2467	end
1944	2468
1945	2469	if self.animation and self.animation.run_start then
1946		set_animation(self, "run")
	2470	self:set_animation("run")
1947	2471	else
1948		set_animation(self, "walk")
	2472	self:set_animation("walk")
1949	2473	end
1950	2474
1951	2475	if self.v_start then

1958	2482	self.blinktimer = 0
1959	2483
1960	2484	if self.blinkstatus then
1961		self.object:settexturemod("")
	2485
	2486	self.object:set_texture_mod(self.texture_mods)
1962	2487	else
1963		self.object:settexturemod("^[brighten")
	2488
	2489	self.object:set_texture_mod(self.texture_mods
	2490	.. "^[brighten")
1964	2491	end
1965	2492
1966	2493	self.blinkstatus = not self.blinkstatus
1967	2494	end
1968	2495
1969		-- print ("=== explosion timer", self.timer)
	2496	--print("=== explosion timer", self.timer)
1970	2497
1971	2498	if self.timer > self.explosion_timer then
1972	2499

1979	2506	node_break_radius = 1
1980	2507	end
1981	2508
1982		self.object:remove()
	2509	remove_mob(self, true)
1983	2510
1984	2511	if minetest.get_modpath("tnt") and tnt and tnt.boom
1985	2512	and not minetest.is_protected(pos, "") then

1987	2514	tnt.boom(pos, {
1988	2515	radius = node_break_radius,
1989	2516	damage_radius = entity_damage_radius,
1990		sound = self.sounds.explode,
	2517	sound = self.sounds.explode
1991	2518	})
1992	2519	else
1993	2520

1998	2525	})
1999	2526
2000	2527	entity_physics(pos, entity_damage_radius)
2001		effect(pos, 32, "tnt_smoke.png", nil, nil, node_break_radius, 1, 0)
	2528
	2529	effect(pos, 32, "tnt_smoke.png", nil, nil,
	2530	node_break_radius, 1, 0)
2002	2531	end
2003	2532
2004		return
	2533	return true
2005	2534	end
2006	2535	end
2007	2536
2008	2537	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
	2538	or (self.attack_type == "dogshoot" and self:dogswitch(dtime) == 2)
	2539	or (self.attack_type == "dogshoot" and dist <= self.reach
	2540	and self:dogswitch() == 0) then
2011	2541
2012	2542	if self.fly
2013	2543	and dist > self.reach then

2018	2548	local p_y = floor(p2.y + 1)
2019	2549	local v = self.object:get_velocity()
2020	2550
2021		if flight_check(self, s) then
	2551	if self:flight_check() then
2022	2552
2023	2553	if me_y < p_y then
2024	2554

2054	2584	})
2055	2585	end
2056	2586	end
2057
2058	2587	end
2059	2588
2060	2589	-- rnd: new movement direction

2076	2605	return
2077	2606	end
2078	2607
2079		if abs(p1.x-s.x) + abs(p1.z - s.z) < 0.6 then
	2608	if abs(p1.x - s.x) + abs(p1.z - s.z) < 0.6 then
2080	2609	-- reached waypoint, remove it from queue
2081		table.remove(self.path.way, 1)
	2610	table_remove(self.path.way, 1)
2082	2611	end
2083	2612
2084	2613	-- set new temporary target
2085	2614	p = {x = p1.x, y = p1.y, z = p1.z}
2086	2615	end
2087	2616
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)
	2617	yaw = yaw_to_pos(self, p)
2098	2618
2099	2619	-- move towards enemy if beyond mob reach
2100	2620	if dist > self.reach then

2103	2623	if self.pathfinding -- only if mob has pathfinding enabled
2104	2624	and enable_pathfinding then
2105	2625
2106		smart_mobs(self, s, p, dist, dtime)
	2626	self:smart_mobs(s, p, dist, dtime)
2107	2627	end
2108	2628
2109		if is_at_cliff(self) then
2110
2111		set_velocity(self, 0)
2112		set_animation(self, "stand")
	2629	-- distance padding to stop spinning mob
	2630	local pad = abs(p.x - s.x) + abs(p.z - s.z)
	2631
	2632	if self.at_cliff or pad < 0.2 then
	2633
	2634	self:set_velocity(0)
	2635	self:set_animation("stand")
2113	2636	else
2114	2637
2115	2638	if self.path.stuck then
2116		set_velocity(self, self.walk_velocity)
	2639	self:set_velocity(self.walk_velocity)
2117	2640	else
2118		set_velocity(self, self.run_velocity)
	2641	self:set_velocity(self.run_velocity)
2119	2642	end
2120	2643
2121	2644	if self.animation and self.animation.run_start then
2122		set_animation(self, "run")
	2645	self:set_animation("run")
2123	2646	else
2124		set_animation(self, "walk")
	2647	self:set_animation("walk")
2125	2648	end
2126	2649	end
2127
2128	2650	else -- rnd: if inside reach range
2129	2651
2130	2652	self.path.stuck = false
2131	2653	self.path.stuck_timer = 0
2132	2654	self.path.following = false -- not stuck anymore
2133	2655
2134		set_velocity(self, 0)
2135
2136		if not self.custom_attack then
2137
2138		if self.timer > 1 then
	2656	self:set_velocity(0)
	2657
	2658	if self.timer > 1 then
	2659
	2660	-- no custom attack or custom attack returns true to continue
	2661	if not self.custom_attack
	2662	or self:custom_attack(self, p) == true then
2139	2663
2140	2664	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
	2665	self:set_animation("punch")
2148	2666
2149	2667	local p2 = p
2150	2668	local s2 = s

2152	2670	p2.y = p2.y + .5
2153	2671	s2.y = s2.y + .5
2154	2672
2155		if line_of_sight(self, p2, s2) == true then
	2673	if self:line_of_sight(p2, s2) == true then
2156	2674
2157	2675	-- play attack sound
2158		mob_sound(self, self.sounds.attack)
	2676	self:mob_sound(self.sounds.attack)
2159	2677
2160	2678	-- punch player (or what player is attached to)
2161	2679	local attached = self.attack:get_attach()
	2680
2162	2681	if attached then
2163	2682	self.attack = attached
2164	2683	end
	2684
	2685	local dgroup = self.damage_group or "fleshy"
	2686
2165	2687	self.attack:punch(self.object, 1.0, {
2166	2688	full_punch_interval = 1.0,
2167		damage_groups = {fleshy = self.damage}
	2689	damage_groups = {[dgroup] = self.damage}
2168	2690	}, nil)
2169	2691	end
2170	2692	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	2693	end
2180	2694	end
2181	2695
2182	2696	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
	2697	or (self.attack_type == "dogshoot" and self:dogswitch(dtime) == 1)
	2698	or (self.attack_type == "dogshoot" and dist > self.reach and
	2699	self:dogswitch() == 0) then
2185	2700
2186	2701	p.y = p.y - .5
2187	2702	s.y = s.y + .5
2188	2703
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)
	2704	local vec = {x = p.x - s.x, y = p.y - s.y, z = p.z - s.z}
	2705
	2706	yaw = yaw_to_pos(self, p)
	2707
	2708	self:set_velocity(0)
2203	2709
2204	2710	if self.shoot_interval
2205	2711	and self.timer > self.shoot_interval
2206		and random(1, 100) <= 60 then
	2712	and random(100) <= 60 then
2207	2713
2208	2714	self.timer = 0
2209		set_animation(self, "shoot")
	2715	self:set_animation("shoot")
2210	2716
2211	2717	-- play shoot attack sound
2212		mob_sound(self, self.sounds.shoot_attack)
	2718	self:mob_sound(self.sounds.shoot_attack)
2213	2719
2214	2720	local p = self.object:get_pos()
2215	2721

2220	2726	local obj = minetest.add_entity(p, self.arrow)
2221	2727	local ent = obj:get_luaentity()
2222	2728	local amount = (vec.x * vec.x + vec.y * vec.y + vec.z * vec.z) ^ 0.5
	2729
	2730	-- check for custom override for arrow
	2731	if self.arrow_override then
	2732	self.arrow_override(ent)
	2733	end
	2734
2223	2735	local v = ent.velocity or 1 -- or set to default
2224	2736
2225	2737	ent.switch = 1

2240	2752
2241	2753
2242	2754	-- falling and fall damage
2243		local falling = function(self, pos)
2244
2245		if self.fly then
	2755	function mob_class:falling(pos)
	2756
	2757	if self.fly or self.disable_falling then
2246	2758	return
2247	2759	end
2248	2760
2249	2761	-- floating in water (or falling)
2250	2762	local v = self.object:get_velocity()
2251	2763
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
	2764	-- sanity check
	2765	if not v then return end
	2766
	2767	local fall_speed = self.fall_speed
	2768
	2769	-- in water then use liquid viscosity for float/sink speed
	2770	if self.floats == 1 and self.standing_in
	2771	and minetest.registered_nodes[self.standing_in].groups.liquid then
	2772
	2773	local visc = min(
	2774	minetest.registered_nodes[self.standing_in].liquid_viscosity, 7) + 1
	2775
	2776	self.object:set_velocity({x = v.x, y = 0.6, z = v.z})
	2777	fall_speed = -1.2 / visc
2286	2778	else
2287	2779
2288	2780	-- fall damage onto solid ground

2297	2789
2298	2790	effect(pos, 5, "tnt_smoke.png", 1, 2, 2, nil)
2299	2791
2300		if check_for_death(self, {type = "fall"}) then
2301		return
	2792	if self:check_for_death({type = "fall"}) then
	2793	return true
2302	2794	end
2303	2795	end
2304	2796
2305	2797	self.old_y = self.object:get_pos().y
2306	2798	end
2307	2799	end
	2800
	2801	-- fall at set speed
	2802	self.object:set_acceleration({x = 0, y = fall_speed, z = 0})
2308	2803	end
2309	2804
2310	2805

2312	2807	local tr = minetest.get_modpath("toolranks")
2313	2808
2314	2809	-- deal damage and effects when mob punched
2315		local mob_punch = function(self, hitter, tflp, tool_capabilities, dir)
	2810	function mob_class:on_punch(hitter, tflp, tool_capabilities, dir, damage)
2316	2811
2317	2812	-- mob health check
2318	2813	if self.health <= 0 then
2319		return
	2814	return true
2320	2815	end
2321	2816
2322	2817	-- custom punch function
2323	2818	if self.do_punch
2324		and self.do_punch(self, hitter, tflp, tool_capabilities, dir) == false then
2325		return
	2819	and self:do_punch(hitter, tflp, tool_capabilities, dir) == false then
	2820	return true
2326	2821	end
2327	2822
2328	2823	-- error checking when mod profiling is enabled
2329	2824	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
	2825
	2826	minetest.log("warning", "[mobs] Mod profiling enabled, damage not enabled")
	2827
	2828	return true
	2829	end
	2830
	2831	-- is mob protected
	2832	if self.protected then
	2833
	2834	-- did player hit mob and if so is it in protected area
	2835	if hitter:is_player() then
	2836
	2837	local player_name = hitter:get_player_name()
	2838
	2839	if player_name ~= self.owner
	2840	and minetest.is_protected(self.object:get_pos(), player_name) then
	2841
	2842	minetest.chat_send_player(hitter:get_player_name(),
	2843	S("Mob has been protected!"))
	2844
	2845	return true
	2846	end
	2847
	2848	-- if protection is on level 2 then dont let arrows harm mobs
	2849	elseif self.protected == 2 then
	2850
	2851	local ent = hitter and hitter:get_luaentity()
	2852
	2853	if ent and ent._is_arrow then
	2854
	2855	return true -- arrow entity
	2856
	2857	elseif not ent then
	2858
	2859	return true -- non entity
	2860	end
	2861	end
2339	2862	end
2340	2863
2341	2864	local weapon = hitter:get_wielded_item()

2367	2890	end
2368	2891
2369	2892	damage = damage + (tool_capabilities.damage_groups[group] or 0)
2370		* tmp * ((armor[group] or 0) / 100.0)
	2893	* tmp * ((armor[group] or 0) / 100.0)
2371	2894	end
2372	2895	end
2373	2896

2377	2900	if self.immune_to[n][1] == weapon_def.name then
2378	2901
2379	2902	damage = self.immune_to[n][2] or 0
	2903
2380	2904	break
2381	2905
2382		-- if "all" then no tool does damage unless it's specified in list
	2906	-- if "all" then no tools deal damage unless it's specified in list
2383	2907	elseif self.immune_to[n][1] == "all" then
2384	2908	damage = self.immune_to[n][2] or 0
2385	2909	end
2386	2910	end
2387	2911
	2912	--print("Mob Damage is", damage)
	2913
2388	2914	-- healing
2389	2915	if damage <= -1 then
	2916
2390	2917	self.health = self.health - floor(damage)
2391		return
2392		end
2393
2394		-- print ("Mob Damage is", damage)
	2918
	2919	return true
	2920	end
2395	2921
2396	2922	if use_cmi
2397	2923	and cmi.notify_punch(self.object, hitter, tflp, tool_capabilities, dir, damage) then
2398		return
	2924	return true
2399	2925	end
2400	2926
2401	2927	-- add weapon wear

2413	2939	end
2414	2940	end
2415	2941
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
	2942	if tr and weapon_def.original_description then
	2943	toolranks.new_afteruse(weapon, hitter, nil, {wear = wear})
2420	2944	else
2421	2945	weapon:add_wear(wear)
2422	2946	end

2426	2950	-- only play hit sound and show blood effects if damage is 1 or over
2427	2951	if damage >= 1 then
2428	2952
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
	2953	-- select tool use sound if found, or fallback to default
	2954	local snd = weapon_def.sound and weapon_def.sound.use
	2955	or "default_punch"
	2956
	2957	minetest.sound_play(snd, {object = self.object, max_hear_distance = 8}, true)
2444	2958
2445	2959	-- blood_particles
2446	2960	if not disable_blood and self.blood_amount > 0 then
2447	2961
2448	2962	local pos = self.object:get_pos()
	2963	local blood = self.blood_texture
	2964	local amount = self.blood_amount
2449	2965
2450	2966	pos.y = pos.y + (-self.collisionbox[2] + self.collisionbox[5]) * .5
	2967
	2968	-- lots of damage = more blood :)
	2969	if damage > 10 then
	2970	amount = self.blood_amount * 2
	2971	end
2451	2972
2452	2973	-- do we have a single blood texture or multiple?
2453	2974	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
	2975	blood = self.blood_texture[random(#self.blood_texture)]
	2976	end
	2977
	2978	effect(pos, amount, blood, 1, 2, 1.75, nil, nil, true)
2461	2979	end
2462	2980
2463	2981	-- do damage

2467	2985	local hot = tool_capabilities and tool_capabilities.damage_groups
2468	2986	and tool_capabilities.damage_groups.fire
2469	2987
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
	2988	if self:check_for_death({type = "punch", puncher = hitter, hot = hot}) then
	2989	return true
	2990	end
2487	2991	end -- END if damage
2488	2992
2489	2993	-- knock back effect (only on full punch)
2490		if self.knock_back
2491		and tflp >= punch_interval then
	2994	if self.knock_back and tflp >= punch_interval then
2492	2995
2493	2996	local v = self.object:get_velocity()
	2997
	2998	-- sanity check
	2999	if not v then return true end
	3000
2494	3001	local kb = damage or 1
2495	3002	local up = 2
2496	3003

2504	3011	dir = dir or {x = 0, y = 0, z = 0}
2505	3012
2506	3013	-- 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		})
	3014	kb = tool_capabilities.damage_groups["knockback"] or kb
	3015
	3016	self.object:set_velocity({x = dir.x * kb, y = up, z = dir.z * kb})
2514	3017
2515	3018	self.pause_timer = 0.25
2516	3019	end

2520	3023	and self.order ~= "stand" then
2521	3024
2522	3025	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)
	3026	local yaw = yaw_to_pos(self, lp, 3)
	3027
2537	3028	self.state = "runaway"
2538	3029	self.runaway_timer = 0
2539	3030	self.following = nil

2547	3038	and self.child == false
2548	3039	and self.attack_players == true
2549	3040	and hitter:get_player_name() ~= self.owner
2550		and not mobs.invis[ name ] then
	3041	and not is_invisible(self, name)
	3042	and self.object ~= hitter then
2551	3043
2552	3044	-- attack whoever punched mob
2553	3045	self.state = ""
2554		do_attack(self, hitter)
	3046	self:do_attack(hitter)
2555	3047
2556	3048	-- alert others to the attack
2557		local objs = minetest.get_objects_inside_radius(hitter:get_pos(), self.view_range)
2558		local obj = nil
	3049	local objs = minetest.get_objects_inside_radius(
	3050	hitter:get_pos(), self.view_range)
	3051	local obj
2559	3052
2560	3053	for n = 1, #objs do
2561	3054

2563	3056
2564	3057	if obj and obj._cmi_is_mob then
2565	3058
2566		-- only alert members of same mob
	3059	-- only alert members of same mob and assigned helper
2567	3060	if obj.group_attack == true
2568	3061	and obj.state ~= "attack"
2569	3062	and obj.owner ~= name
2570		and obj.name == self.name then
2571		do_attack(obj, hitter)
	3063	and (obj.name == self.name
	3064	or obj.name == self.group_helper) then
	3065
	3066	obj:do_attack(hitter)
2572	3067	end
2573	3068
2574	3069	-- have owned mobs attack player threat
2575	3070	if obj.owner == name and obj.owner_loyal then
2576		do_attack(obj, self.object)
	3071	obj:do_attack(self.object)
2577	3072	end
2578	3073	end
2579	3074	end

2582	3077
2583	3078
2584	3079	-- get entity staticdata
2585		local mob_staticdata = function(self)
	3080	function mob_class:mob_staticdata()
	3081
	3082	-- this handles mob count for mobs activated, unloaded, reloaded
	3083	if active_limit > 0 and self.active_toggle then
	3084	active_mobs = active_mobs + self.active_toggle
	3085	self.active_toggle = -self.active_toggle
	3086	--print("-- staticdata", active_mobs, active_limit, self.active_toggle)
	3087	end
2586	3088
2587	3089	-- remove mob when out of range unless tamed
2588	3090	if remove_far

2592	3094	and not self.tamed
2593	3095	and self.lifetimer < 20000 then
2594	3096
2595		--print ("REMOVED " .. self.name)
2596
2597		self.object:remove()
2598
2599		return ""-- nil
	3097	--print("REMOVED " .. self.name)
	3098
	3099	remove_mob(self, true)
	3100
	3101	return minetest.serialize({remove_ok = true, static_save = true})
2600	3102	end
2601	3103
2602	3104	self.remove_ok = true

2605	3107	self.state = "stand"
2606	3108
2607	3109	-- used to rotate older mobs
2608		if self.drawtype
2609		and self.drawtype == "side" then
2610		self.rotate = math.rad(90)
	3110	if self.drawtype and self.drawtype == "side" then
	3111	self.rotate = rad(90)
2611	3112	end
2612	3113
2613	3114	if use_cmi then
2614		self.serialized_cmi_components = cmi.serialize_components(self._cmi_components)
2615		end
2616
2617		local tmp = {}
	3115	self.serialized_cmi_components = cmi.serialize_components(
	3116	self._cmi_components)
	3117	end
	3118
	3119	local tmp, t = {}
2618	3120
2619	3121	for _,stat in pairs(self) do
2620	3122
2621		local t = type(stat)
	3123	t = type(stat)
2622	3124
2623	3125	if t ~= "function"
2624	3126	and t ~= "nil"
2625	3127	and t ~= "userdata"
	3128	and _ ~= "object"
2626	3129	and _ ~= "_cmi_components" then
2627	3130	tmp[_] = self[_]
2628	3131	end
2629	3132	end
2630	3133
2631		--print('===== '..self.name..'\n'.. dump(tmp)..'\n=====\n')
	3134	--print('===== '..self.name..'\n'.. dump(tmp)..'\n=====\n')
	3135
2632	3136	return minetest.serialize(tmp)
2633	3137	end
2634	3138
2635	3139
2636	3140	-- activate mob and reload settings
2637		local mob_activate = function(self, staticdata, def, dtime)
	3141	function mob_class:mob_activate(staticdata, def, dtime)
	3142
	3143	-- if dtime == 0 then entity has just been created
	3144	-- anything higher means it is respawning (thanks SorceryKid)
	3145	if dtime == 0 and active_limit > 0 then
	3146	self.active_toggle = 1
	3147	end
	3148
	3149	-- remove mob if not tamed and mob total reached
	3150	if active_limit > 0 and active_mobs >= active_limit and not self.tamed then
	3151
	3152	remove_mob(self)
	3153	--print("-- mob limit reached, removing " .. self.name)
	3154	return
	3155	end
2638	3156
2639	3157	-- remove monsters in peaceful mode
2640		if self.type == "monster"
2641		and peaceful_only then
2642
2643		self.object:remove()
	3158	if self.type == "monster" and peaceful_only then
	3159
	3160	remove_mob(self, true)
2644	3161
2645	3162	return
2646	3163	end

2649	3166	local tmp = minetest.deserialize(staticdata)
2650	3167
2651	3168	if tmp then
	3169
	3170	local t
	3171
2652	3172	for _,stat in pairs(tmp) do
2653		self[_] = stat
2654		end
2655		end
	3173
	3174	t = type(stat)
	3175
	3176	if t ~= "function"
	3177	and t ~= "nil"
	3178	and t ~= "userdata" then
	3179	self[_] = stat
	3180	end
	3181	end
	3182	end
	3183
	3184	-- force current model into mob
	3185	self.mesh = def.mesh
	3186	self.base_mesh = def.mesh
	3187	self.collisionbox = def.collisionbox
	3188	self.selectionbox = def.selectionbox
2656	3189
2657	3190	-- select random texture, set model and size
2658	3191	if not self.base_texture then

2662	3195	def.textures = {def.textures}
2663	3196	end
2664	3197
2665		self.base_texture = def.textures and def.textures[random(1, #def.textures)]
	3198	self.base_texture = def.textures and def.textures[random(#def.textures)]
2666	3199	self.base_mesh = def.mesh
2667	3200	self.base_size = self.visual_size
2668	3201	self.base_colbox = self.collisionbox

2682	3215	local selbox = self.base_selbox
2683	3216
2684	3217	-- specific texture if gotten
2685		if self.gotten == true
2686		and def.gotten_texture then
	3218	if self.gotten == true and def.gotten_texture then
2687	3219	textures = def.gotten_texture
2688	3220	end
2689	3221
2690	3222	-- specific mesh if gotten
2691		if self.gotten == true
2692		and def.gotten_mesh then
	3223	if self.gotten == true and def.gotten_mesh then
2693	3224	mesh = def.gotten_mesh
2694	3225	end
2695	3226
2696	3227	-- set child objects to half size
2697	3228	if self.child == true then
2698	3229
2699		vis_size = {
2700		x = self.base_size.x * .5,
2701		y = self.base_size.y * .5,
2702		}
	3230	vis_size = {x = self.base_size.x * .5, y = self.base_size.y * .5}
2703	3231
2704	3232	if def.child_texture then
2705	3233	textures = def.child_texture[1]
2706	3234	end
2707	3235
2708	3236	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		}
	3237	self.base_colbox[1] * .5, self.base_colbox[2] * .5,
	3238	self.base_colbox[3] * .5, self.base_colbox[4] * .5,
	3239	self.base_colbox[5] * .5, self.base_colbox[6] * .5}
	3240
2716	3241	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		}
	3242	self.base_selbox[1] * .5, self.base_selbox[2] * .5,
	3243	self.base_selbox[3] * .5, self.base_selbox[4] * .5,
	3244	self.base_selbox[5] * .5, self.base_selbox[6] * .5}
2724	3245	end
2725	3246
2726	3247	if self.health == 0 then
2727		self.health = random (self.hp_min, self.hp_max)
	3248	self.health = random(self.hp_min, self.hp_max)
2728	3249	end
2729	3250
2730	3251	-- pathfinding init

2735	3256	self.path.following = false -- currently following path?
2736	3257	self.path.stuck_timer = 0 -- if stuck for too long search for path
2737	3258
	3259	-- Armor groups (immortal = 1 for custom damage handling)
	3260	local armor
	3261	if type(self.armor) == "table" then
	3262	armor = table_copy(self.armor)
	3263	else
	3264	armor = {fleshy = self.armor} -- immortal = 1
	3265	end
	3266	self.object:set_armor_groups(armor)
	3267
2738	3268	-- mob defaults
2739		self.object:set_armor_groups({immortal = 1, fleshy = self.armor})
2740	3269	self.old_y = self.object:get_pos().y
2741	3270	self.old_health = self.health
2742	3271	self.sounds.distance = self.sounds.distance or 10

2746	3275	self.selectionbox = selbox
2747	3276	self.visual_size = vis_size
2748	3277	self.standing_in = "air"
	3278	self.standing_on = "air"
2749	3279
2750	3280	-- check existing nametag
2751	3281	if not self.nametag then

2754	3284
2755	3285	-- set anything changed above
2756	3286	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")
	3287	self:set_yaw((random(0, 360) - 180) / 180 * pi, 6)
	3288	self:update_tag()
	3289	self:set_animation("stand")
	3290
	3291	-- apply any texture mods
	3292	self.object:set_texture_mod(self.texture_mods)
	3293
	3294	-- set 5.x flag to remove monsters when map area unloaded
	3295	if remove_far and self.type == "monster" and not self.tamed then
	3296	self.static_save = false
	3297	end
2760	3298
2761	3299	-- run on_spawn function if found
2762	3300	if self.on_spawn and not self.on_spawn_run then
2763	3301	if self.on_spawn(self) then
2764		self.on_spawn_run = true -- if true, set flag to run once only
	3302	self.on_spawn_run = true -- if true, set flag to run once only
2765	3303	end
2766	3304	end
2767	3305

2771	3309	end
2772	3310
2773	3311	if use_cmi then
2774		self._cmi_components = cmi.activate_components(self.serialized_cmi_components)
	3312	self._cmi_components = cmi.activate_components(
	3313	self.serialized_cmi_components)
2775	3314	cmi.notify_activate(self.object, dtime)
2776	3315	end
2777	3316	end
2778	3317
2779	3318
2780	3319	-- handle mob lifetimer and expiration
2781		local mob_expire = function(self, pos, dtime)
	3320	function mob_class:mob_expire(pos, dtime)
2782	3321
2783	3322	-- when lifetimer expires remove mob (except npc and tamed)
2784	3323	if self.type ~= "npc"

2809	3348
2810	3349	effect(pos, 15, "tnt_smoke.png", 2, 4, 2, 0)
2811	3350
2812		self.object:remove()
	3351	remove_mob(self, true)
2813	3352
2814	3353	return
2815	3354	end

2818	3357
2819	3358
2820	3359	-- main mob function
2821		local mob_step = function(self, dtime)
	3360	function mob_class:on_step(dtime, moveresult)
	3361
	3362	if self.state == "die" then return end
2822	3363
2823	3364	if use_cmi then
2824	3365	cmi.notify_step(self.object, dtime)
2825	3366	end
2826	3367
2827	3368	local pos = self.object:get_pos()
2828		local yaw = 0
	3369	local yaw = self.object:get_yaw()
	3370
	3371	-- early warning check, if no yaw then no entity, skip rest of function
	3372	if not yaw then return end
2829	3373
2830	3374	-- get node at foot level every quarter second
2831	3375	self.node_timer = (self.node_timer or 0) + dtime

2843	3387	-- what is mob standing in?
2844	3388	self.standing_in = node_ok({
2845	3389	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)
	3390
	3391	self.standing_on = node_ok({
	3392	x = pos.x, y = pos.y + y_level - 0.25, z = pos.z}, "air").name
	3393
	3394	--print("standing in " .. self.standing_in)
	3395
	3396	-- if standing inside solid block then jump to escape
	3397	if minetest.registered_nodes[self.standing_in].walkable
	3398	and minetest.registered_nodes[self.standing_in].drawtype
	3399	== "normal" then
	3400
	3401	self.object:set_velocity({
	3402	x = 0,
	3403	y = self.jump_height,
	3404	z = 0
	3405	})
	3406	end
	3407
	3408	-- check and stop if standing at cliff and fear of heights
	3409	self.at_cliff = self:is_at_cliff()
	3410
	3411	if self.at_cliff then
	3412	self:set_velocity(0)
	3413	end
	3414
	3415	-- has mob expired (0.25 instead of dtime since were in a timer)
	3416	self:mob_expire(pos, 0.25)
	3417	end
	3418
	3419	-- check if falling, flying, floating and return if player died
	3420	if self:falling(pos) then
	3421	return
	3422	end
2854	3423
2855	3424	-- smooth rotation by ThomasMonroe314
2856
2857	3425	if self.delay and self.delay > 0 then
2858
2859		local yaw = self.object:get_yaw()
2860	3426
2861	3427	if self.delay == 1 then
2862	3428	yaw = self.target_yaw

2890	3456	self.object:set_yaw(yaw)
2891	3457	end
2892	3458
2893		-- end rotation
2894
2895	3459	-- knockback timer
2896	3460	if self.pause_timer > 0 then
2897	3461

2904	3468	if self.do_custom then
2905	3469
2906	3470	-- when false skip going any further
2907		if self.do_custom(self, dtime) == false then
	3471	if self:do_custom(dtime) == false then
2908	3472	return
2909	3473	end
2910	3474	end

2927	3491	end
2928	3492
2929	3493	-- mob plays random sound at times
2930		if random(1, 100) == 1 then
2931		mob_sound(self, self.sounds.random)
	3494	if random(100) == 1 then
	3495	self:mob_sound(self.sounds.random)
2932	3496	end
2933	3497
2934	3498	-- environmental damage timer (every 1 second)

2940	3504	self.env_damage_timer = 0
2941	3505
2942	3506	-- check for environmental damage (water, fire, lava etc.)
2943		do_env_damage(self)
	3507	if self:do_env_damage() then return end
2944	3508
2945	3509	-- 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
	3510	self:replace(pos)
	3511	end
	3512
	3513	self:general_attack()
	3514
	3515	self:breed()
	3516
	3517	self:follow_flop()
	3518
	3519	if self:do_states(dtime) then return end
	3520
	3521	self:do_jump()
	3522
	3523	self:do_runaway_from(self)
	3524
	3525	self:do_stay_near()
2961	3526	end
2962	3527
2963	3528
2964	3529	-- 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, {
	3530	function mob_class:on_blast(damage)
	3531
	3532	--print("-- blast damage", damage)
	3533
	3534	self.object:punch(self.object, 1.0, {
2970	3535	full_punch_interval = 1.0,
2971	3536	damage_groups = {fleshy = damage},
2972	3537	}, nil)
2973	3538
2974		return false, true, {}
	3539	-- return no damage, no knockback, no item drops, mob api handles all
	3540	return false, false, {}
2975	3541	end
2976	3542
2977	3543

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

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

3143	3873	end
3144	3874
3145	3875
3146		function mobs:spawn_specific(name, nodes, neighbors, min_light, max_light,
3147		interval, chance, aoc, min_height, max_height, day_toggle, on_spawn)
	3876	function mobs:spawn_specific(name, nodes, neighbors, min_light, max_light, interval,
	3877	chance, aoc, min_height, max_height, day_toggle, on_spawn, map_load)
3148	3878
3149	3879	-- Do mobs spawn at all?
3150		if not mobs_spawn then
	3880	if not mobs_spawn or not mobs.spawning_mobs[name] then
	3881	--print ("--- spawning not registered for " .. name)
3151	3882	return
3152	3883	end
3153	3884
3154	3885	-- chance/spawn number override in minetest.conf for registered mob
3155		local numbers = minetest.settings:get(name)
	3886	local numbers = settings:get(name)
3156	3887
3157	3888	if numbers then
	3889
3158	3890	numbers = numbers:split(",")
3159	3891	chance = tonumber(numbers[1]) or chance
3160	3892	aoc = tonumber(numbers[2]) or aoc
3161	3893
3162	3894	if chance == 0 then
3163		minetest.log("warning", string.format("[mobs] %s has spawning disabled", name))
	3895
	3896	minetest.log("warning",
	3897	string.format("[mobs] %s has spawning disabled", name))
3164	3898	return
3165	3899	end
3166	3900
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
	3901	minetest.log("action", string.format(
	3902	"[mobs] Chance setting for %s changed to %s (total: %s)",
	3903	name, chance, aoc))
	3904	end
	3905
	3906	mobs.spawning_mobs[name].aoc = aoc
	3907
	3908	local spawn_action = function(pos, node, active_object_count,
	3909	active_object_count_wider)
	3910
	3911	-- use instead of abm's chance setting when using lbm
	3912	if map_load and random(max(1, (chance * mob_chance_multiplier))) > 1 then
	3913	return
	3914	end
	3915
	3916	-- use instead of abm's neighbor setting when using lbm
	3917	if map_load and not minetest.find_node_near(pos, 1, neighbors) then
	3918	--print("--- lbm neighbors not found")
	3919	return
	3920	end
	3921
	3922	-- is mob actually registered?
	3923	if not mobs.spawning_mobs[name]
	3924	or not minetest.registered_entities[name] then
	3925	--print("--- mob doesn't exist", name)
	3926	return
	3927	end
	3928
	3929	-- are we over active mob limit
	3930	if active_limit > 0 and active_mobs >= active_limit then
	3931	--print("--- active mob limit reached", active_mobs, active_limit)
	3932	return
	3933	end
	3934
	3935	-- additional custom checks for spawning mob
	3936	if mobs:spawn_abm_check(pos, node, name) == true then
	3937	return
	3938	end
	3939
	3940	-- do not spawn if too many entities in area
	3941	if active_object_count_wider
	3942	and active_object_count_wider >= max_per_block then
3197	3943	--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
	3944	return
	3945	end
	3946
	3947	-- get total number of this mob in area
	3948	local num_mob, is_pla = count_mobs(pos, name)
	3949
	3950	if not is_pla then
	3951	--print("--- no players within active area, will not spawn " .. name)
	3952	return
	3953	end
	3954
	3955	if num_mob >= aoc then
	3956	--print("--- too many " .. name .. " in area", num_mob .. "/" .. aoc)
	3957	return
	3958	end
3208	3959
3209	3960	-- 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)
	3961	if day_toggle ~= nil then
	3962
	3963	local tod = (minetest.get_timeofday() or 0) * 24000
	3964
	3965	if tod > 4500 and tod < 19500 then
	3966	-- daylight, but mob wants night
	3967	if day_toggle == false then
	3968	--print("--- mob needs night", name)
3255	3969	return
3256	3970	end
3257		end
	3971	else
	3972	-- night time but mob wants day
	3973	if day_toggle == true then
	3974	--print("--- mob needs day", name)
	3975	return
	3976	end
	3977	end
	3978	end
	3979
	3980	-- spawn above node
	3981	pos.y = pos.y + 1
	3982
	3983	-- are we spawning within height limits?
	3984	if pos.y > max_height
	3985	or pos.y < min_height then
	3986	--print("--- height limits not met", name, pos.y)
	3987	return
	3988	end
	3989
	3990	-- are light levels ok?
	3991	local light = minetest.get_node_light(pos)
	3992	if not light
	3993	or light > max_light
	3994	or light < min_light then
	3995	--print("--- light limits not met", name, light)
	3996	return
	3997	end
	3998
	3999	-- check if mob can spawn inside protected areas
	4000	if (spawn_protected == false
	4001	or (spawn_monster_protected == false
	4002	and minetest.registered_entities[name].type == "monster"))
	4003	and minetest.is_protected(pos, "") then
	4004	--print("--- inside protected area", name)
	4005	return
	4006	end
	4007
	4008	-- only spawn a set distance away from player
	4009	local objs = minetest.get_objects_inside_radius(pos, mob_nospawn_range)
	4010
	4011	for n = 1, #objs do
	4012
	4013	if objs[n]:is_player() then
	4014	--print("--- player too close", name)
	4015	return
	4016	end
	4017	end
	4018
	4019	local ent = minetest.registered_entities[name]
	4020
	4021	-- should we check mob area for obstructions ?
	4022	if mob_area_spawn ~= true then
3258	4023
3259	4024	-- 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
	4025	local height = max(0, ent.collisionbox[5] - ent.collisionbox[2])
	4026
	4027	for n = 0, floor(height) do
3266	4028
3267	4029	local pos2 = {x = pos.x, y = pos.y + n, z = pos.z}
3268	4030

3271	4033	return
3272	4034	end
3273	4035	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
	4036	else
	4037	-- returns position if we have enough space to spawn mob
	4038	pos = can_spawn(pos, name)
	4039	end
	4040
	4041	if pos then
	4042
	4043	-- adjust for mob collision box
	4044	pos.y = pos.y + (ent.collisionbox[2] * -1) - 0.4
3284	4045
3285	4046	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		]]
	4047
	4048	-- print("[mobs] Spawned " .. name .. " at "
	4049	-- .. minetest.pos_to_string(pos) .. " on "
	4050	-- .. node.name .. " near " .. neighbors[1])
	4051
3291	4052	if on_spawn then
3292
3293		local ent = mob:get_luaentity()
3294
3295		on_spawn(ent, pos)
3296		end
3297		end
3298		})
	4053	on_spawn(mob:get_luaentity(), pos)
	4054	end
	4055	else
	4056	--print("--- not enough space to spawn", name)
	4057	end
	4058	end
	4059
	4060
	4061	-- are we registering an abm or lbm?
	4062	if map_load == true then
	4063
	4064	minetest.register_lbm({
	4065	name = name .. "_spawning",
	4066	label = name .. " spawning",
	4067	nodenames = nodes,
	4068	run_at_every_load = false,
	4069
	4070	action = function(pos, node)
	4071	spawn_action(pos, node)
	4072	end
	4073	})
	4074
	4075	else
	4076
	4077	minetest.register_abm({
	4078	label = name .. " spawning",
	4079	nodenames = nodes,
	4080	neighbors = neighbors,
	4081	interval = interval,
	4082	chance = max(1, (chance * mob_chance_multiplier)),
	4083	catch_up = false,
	4084
	4085	action = function(pos, node, active_object_count, active_object_count_wider)
	4086	spawn_action(pos, node, active_object_count, active_object_count_wider)
	4087	end
	4088	})
	4089	end
3299	4090	end
3300	4091
3301	4092

3308	4099	end
3309	4100
3310	4101
3311		-- MarkBu's spawn function
	4102	-- MarkBu's spawn function (USE this one please)
3312	4103	function mobs:spawn(def)
3313	4104
3314	4105	mobs:spawn_specific(

3323	4114	def.min_height or -31000,
3324	4115	def.max_height or 31000,
3325	4116	def.day_toggle,
3326		def.on_spawn
3327		)
	4117	def.on_spawn,
	4118	def.on_map_load)
3328	4119	end
3329	4120
3330	4121

3335	4126
3336	4127	minetest.register_entity(name, {
3337	4128
3338		physical = false,
	4129	physical = def.physical or false,
	4130	collide_with_objects = def.collide_with_objects or false,
	4131	static_save = false,
	4132
3339	4133	visual = def.visual,
3340	4134	visual_size = def.visual_size,
3341	4135	textures = def.textures,

3343	4137	hit_player = def.hit_player,
3344	4138	hit_node = def.hit_node,
3345	4139	hit_mob = def.hit_mob,
	4140	hit_object = def.hit_object,
3346	4141	drop = def.drop or false, -- drops arrow as registered item when true
3347		collisionbox = def.collisionbox or {0, 0, 0, 0, 0, 0},
	4142	collisionbox = def.collisionbox or {-.1, -.1, -.1, .1, .1, .1},
3348	4143	timer = 0,
	4144	lifetime = def.lifetime or 4.5,
3349	4145	switch = 0,
3350	4146	owner_id = def.owner_id,
3351	4147	rotate = def.rotate,

3354	4150
3355	4151	on_activate = def.on_activate,
3356	4152
3357		on_punch = def.on_punch or function(self, hitter, tflp, tool_capabilities, dir)
	4153	on_punch = def.on_punch or function(
	4154	self, hitter, tflp, tool_capabilities, dir)
3358	4155	end,
3359	4156
3360	4157	on_step = def.on_step or function(self, dtime)
3361	4158
3362		self.timer = self.timer + 1
	4159	self.timer = self.timer + dtime
3363	4160
3364	4161	local pos = self.object:get_pos()
3365	4162
3366		if self.switch == 0
3367		or self.timer > 150 then
3368
3369		self.object:remove() ; -- print ("removed arrow")
	4163	if self.switch == 0 or self.timer > self.lifetime then
	4164
	4165	self.object:remove() ; -- print("removed arrow")
3370	4166
3371	4167	return
3372	4168	end
3373	4169
3374	4170	-- does arrow have a tail (fireball)
3375		if def.tail
3376		and def.tail == 1
3377		and def.tail_texture then
	4171	if def.tail and def.tail == 1 and def.tail_texture then
3378	4172
3379	4173	minetest.add_particle({
3380	4174	pos = pos,

3384	4178	collisiondetection = false,
3385	4179	texture = def.tail_texture,
3386	4180	size = def.tail_size or 5,
3387		glow = def.glow or 0,
	4181	glow = def.glow or 0
3388	4182	})
3389	4183	end
3390	4184

3394	4188
3395	4189	if minetest.registered_nodes[node].walkable then
3396	4190
3397		self.hit_node(self, pos, node)
	4191	self:hit_node(pos, node)
3398	4192
3399	4193	if self.drop == true then
3400	4194

3402	4196
3403	4197	self.lastpos = (self.lastpos or pos)
3404	4198
3405		minetest.add_item(self.lastpos, self.object:get_luaentity().name)
	4199	minetest.add_item(self.lastpos,
	4200	self.object:get_luaentity().name)
3406	4201	end
3407	4202
3408		self.object:remove() ; -- print ("hit node")
	4203	self.object:remove() ; -- print("hit node")
3409	4204
3410	4205	return
3411	4206	end
3412	4207	end
3413	4208
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")
	4209	if self.hit_player or self.hit_mob or self.hit_object then
	4210
	4211	for _,player in pairs(
	4212	minetest.get_objects_inside_radius(pos, 1.0)) do
	4213
	4214	if self.hit_player and player:is_player() then
	4215
	4216	self:hit_player(player)
	4217
	4218	self.object:remove() ; -- print("hit player")
	4219
3423	4220	return
3424	4221	end
3425	4222

3431	4228	and tostring(player) ~= self.owner_id
3432	4229	and entity.name ~= self.object:get_luaentity().name then
3433	4230
3434		self.hit_mob(self, player)
3435
3436		self.object:remove() ; --print ("hit mob")
	4231	self:hit_mob(player)
	4232
	4233	self.object:remove() ; --print("hit mob")
	4234
	4235	return
	4236	end
	4237
	4238	if entity
	4239	and self.hit_object
	4240	and (not entity._cmi_is_mob)
	4241	and tostring(player) ~= self.owner_id
	4242	and entity.name ~= self.object:get_luaentity().name then
	4243
	4244	self:hit_object(player)
	4245
	4246	self.object:remove() ; -- print("hit object")
3437	4247
3438	4248	return
3439	4249	end

3448	4258
3449	4259	-- compatibility function
3450	4260	function mobs:explosion(pos, radius)
3451
3452		local self = {sounds = {explode = "tnt_explode"}}
3453
3454		mobs:boom(self, pos, radius)
	4261	mobs:boom({sounds = {explode = "tnt_explode"}}, pos, radius)
3455	4262	end
3456	4263
3457	4264

3462	4269	pos = pos,
3463	4270	gain = 1.0,
3464	4271	max_hear_distance = self.sounds and self.sounds.distance or 32
3465		})
	4272	}, true)
3466	4273
3467	4274	entity_physics(pos, radius)
3468	4275

3481	4288	radius = radius,
3482	4289	damage_radius = radius,
3483	4290	sound = self.sounds and self.sounds.explode,
3484		explode_center = true,
	4291	explode_center = true
3485	4292	})
3486	4293	else
3487	4294	mobs:safe_boom(self, pos, radius)

3499	4306	local grp = {spawn_egg = 1}
3500	4307
3501	4308	-- do NOT add this egg to creative inventory (e.g. dungeon master)
3502		if creative and no_creative == true then
	4309	if no_creative == true then
3503	4310	grp.not_in_creative_inventory = 1
3504	4311	end
3505	4312

3522	4329
3523	4330	local pos = pointed_thing.above
3524	4331
3525		-- am I clicking on something with existing on_rightclick function?
	4332	-- does existing on_rightclick function exist?
3526	4333	local under = minetest.get_node(pointed_thing.under)
3527	4334	local def = minetest.registered_nodes[under.name]
	4335
3528	4336	if def and def.on_rightclick then
3529		return def.on_rightclick(pointed_thing.under, under, placer, itemstack)
	4337
	4338	return def.on_rightclick(
	4339	pointed_thing.under, under, placer, itemstack)
3530	4340	end
3531	4341
3532	4342	if pos

3539	4349	pos.y = pos.y + 1
3540	4350
3541	4351	local data = itemstack:get_metadata()
3542		local mob = minetest.add_entity(pos, mob, data)
3543		local ent = mob:get_luaentity()
	4352	local smob = minetest.add_entity(pos, mob, data)
	4353	local ent = smob and smob:get_luaentity()
	4354
	4355	if not ent then return end -- sanity check
3544	4356
3545	4357	-- set owner if not a monster
3546	4358	if ent.type ~= "monster" then

3568	4380
3569	4381	local pos = pointed_thing.above
3570	4382
3571		-- am I clicking on something with existing on_rightclick function?
	4383	-- does existing on_rightclick function exist?
3572	4384	local under = minetest.get_node(pointed_thing.under)
3573	4385	local def = minetest.registered_nodes[under.name]
	4386
3574	4387	if def and def.on_rightclick then
3575		return def.on_rightclick(pointed_thing.under, under, placer, itemstack)
	4388
	4389	return def.on_rightclick(
	4390	pointed_thing.under, under, placer, itemstack)
3576	4391	end
3577	4392
3578	4393	if pos

3582	4397	return
3583	4398	end
3584	4399
	4400	-- have we reached active mob limit
	4401	if active_limit > 0 and active_mobs >= active_limit then
	4402	minetest.chat_send_player(placer:get_player_name(),
	4403	S("Active Mob Limit Reached!")
	4404	.. " (" .. active_mobs
	4405	.. " / " .. active_limit .. ")")
	4406	return
	4407	end
	4408
3585	4409	pos.y = pos.y + 1
3586	4410
3587		local mob = minetest.add_entity(pos, mob)
3588		local ent = mob:get_luaentity()
	4411	local smob = minetest.add_entity(pos, mob)
	4412	local ent = smob and smob:get_luaentity()
	4413
	4414	if not ent then return end -- sanity check
3589	4415
3590	4416	-- don't set owner if monster or sneak pressed
3591	4417	if ent.type ~= "monster"

3603	4429	return itemstack
3604	4430	end,
3605	4431	})
3606
	4432	end
	4433
	4434
	4435	-- force capture a mob if space available in inventory, or drop as spawn egg
	4436	function mobs:force_capture(self, clicker)
	4437
	4438	-- add special mob egg with all mob information
	4439	local new_stack = ItemStack(self.name .. "_set")
	4440
	4441	local tmp, t = {}
	4442
	4443	for _,stat in pairs(self) do
	4444
	4445	t = type(stat)
	4446
	4447	if t ~= "function"
	4448	and t ~= "nil"
	4449	and t ~= "userdata" then
	4450	tmp[_] = self[_]
	4451	end
	4452	end
	4453
	4454	local data_str = minetest.serialize(tmp)
	4455
	4456	new_stack:set_metadata(data_str)
	4457
	4458	local inv = clicker:get_inventory()
	4459
	4460	if inv:room_for_item("main", new_stack) then
	4461	inv:add_item("main", new_stack)
	4462	else
	4463	minetest.add_item(clicker:get_pos(), new_stack)
	4464	end
	4465
	4466	self:mob_sound("default_place_node_hard")
	4467
	4468	remove_mob(self, true)
3607	4469	end
3608	4470
3609	4471
3610	4472	-- capture critter (thanks to blert2112 for idea)
3611		function mobs:capture_mob(self, clicker, chance_hand, chance_net, chance_lasso,
3612		force_take, replacewith)
3613
3614		if self.child
	4473	function mobs:capture_mob(self, clicker, chance_hand, chance_net,
	4474	chance_lasso, force_take, replacewith)
	4475
	4476	if not self --self.child
3615	4477	or not clicker:is_player()
3616	4478	or not clicker:get_inventory() then
3617	4479	return false

3636	4498	end
3637	4499
3638	4500	-- is mob tamed?
3639		if self.tamed == false
3640		and force_take == false then
	4501	if self.tamed == false and force_take == false then
3641	4502
3642	4503	minetest.chat_send_player(name, S("Not tamed!"))
3643	4504
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
	4505	return false
	4506	end
	4507
	4508	-- cannot pick up if not owner (unless player has protection_bypass priv)
	4509	if not minetest.check_player_privs(name, "protection_bypass")
	4510	and self.owner ~= name and force_take == false then
3650	4511
3651	4512	minetest.chat_send_player(name, S("@1 is owner!", self.owner))
3652	4513
3653		return true -- false
	4514	return false
3654	4515	end
3655	4516
3656	4517	if clicker:get_inventory():room_for_item("main", mobname) then

3680	4541	end
3681	4542
3682	4543	-- calculate chance.. add to inventory if successful?
3683		if chance > 0 and random(1, 100) <= chance then
	4544	if chance and chance > 0 and random(100) <= chance then
3684	4545
3685	4546	-- default mob egg
3686	4547	local new_stack = ItemStack(mobname)

3691	4552
3692	4553	new_stack = ItemStack(mobname .. "_set")
3693	4554
3694		local tmp = {}
	4555	local tmp, t = {}
3695	4556
3696	4557	for _,stat in pairs(self) do
3697		local t = type(stat)
	4558
	4559	t = type(stat)
	4560
3698	4561	if t ~= "function"
3699	4562	and t ~= "nil"
3700	4563	and t ~= "userdata" then

3715	4578	minetest.add_item(clicker:get_pos(), new_stack)
3716	4579	end
3717	4580
3718		self.object:remove()
3719
3720		mob_sound(self, "default_place_node_hard")
3721
3722		elseif chance ~= 0 then
	4581	self:mob_sound("default_place_node_hard")
	4582
	4583	remove_mob(self, true)
	4584
	4585	return new_stack
	4586
	4587	-- when chance above fails or set to 0, miss!
	4588	elseif chance and chance ~= 0 then
	4589
3723	4590	minetest.chat_send_player(name, S("Missed!"))
3724	4591
3725		mob_sound(self, "mobs_swing")
	4592	self:mob_sound("mobs_swing")
	4593
	4594	return false
	4595
	4596	-- when chance is nil always return a miss (used for npc walk/follow)
	4597	elseif not chance then
	4598	return false
3726	4599	end
3727	4600	end
3728	4601

3735	4608
3736	4609	local name = clicker:get_player_name()
3737	4610	local tool = clicker:get_wielded_item()
3738
3739		if tool:get_name() ~= "mobs:protector" then
	4611	local tool_name = tool:get_name()
	4612
	4613	if tool_name ~= "mobs:protector"
	4614	and tool_name ~= "mobs:protector2" then
3740	4615	return false
3741	4616	end
3742	4617
3743		if self.tamed == false then
	4618	if not self.tamed then
3744	4619	minetest.chat_send_player(name, S("Not tamed!"))
3745		return true -- false
3746		end
3747
3748		if self.protected == true then
	4620	return true
	4621	end
	4622
	4623	if (self.protected and tool_name == "mobs:protector")
	4624	or (self.protected == 2 and tool_name == "mobs:protector2") then
3749	4625	minetest.chat_send_player(name, S("Already protected!"))
3750		return true -- false
	4626	return true
3751	4627	end
3752	4628
3753	4629	if not mobs.is_creative(clicker:get_player_name()) then

3755	4631	clicker:set_wielded_item(tool)
3756	4632	end
3757	4633
3758		self.protected = true
	4634	-- set protection level
	4635	if tool_name == "mobs:protector" then
	4636	self.protected = true
	4637	else
	4638	self.protected = 2 ; self.fire_damage = 0
	4639	end
3759	4640
3760	4641	local pos = self.object:get_pos()
	4642
3761	4643	pos.y = pos.y + self.collisionbox[2] + 0.5
3762	4644
3763		effect(self.object:get_pos(), 25, "mobs_protect_particle.png", 0.5, 4, 2, 15)
3764
3765		mob_sound(self, "mobs_spell")
	4645	effect(self.object:get_pos(), 25, "mobs_protect_particle.png",
	4646	0.5, 4, 2, 15)
	4647
	4648	self:mob_sound("mobs_spell")
3766	4649
3767	4650	return true
3768	4651	end

3774	4657	-- feeding, taming and breeding (thanks blert2112)
3775	4658	function mobs:feed_tame(self, clicker, feed_count, breed, tame)
3776	4659
3777		if not self.follow then
3778		return false
3779		end
3780
3781	4660	-- can eat/tame with item in hand
3782		if follow_holding(self, clicker) then
	4661	if self.follow
	4662	and self:follow_holding(clicker) then
3783	4663
3784	4664	-- if not in creative then take item
3785	4665	if not mobs.is_creative(clicker:get_player_name()) then

3798	4678
3799	4679	self.health = self.hp_max
3800	4680
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
	4681	-- if self.htimer < 1 then
	4682
	4683	-- minetest.chat_send_player(clicker:get_player_name(),
	4684	-- S("@1 at full health (@2)",
	4685	-- self.name:split(":")[2], tostring(self.health)))
	4686
	4687	-- self.htimer = 5
	4688	-- end
3809	4689	end
3810	4690
3811	4691	self.object:set_hp(self.health)
3812
3813		update_tag(self)
3814	4692
3815	4693	-- make children grow quicker
3816	4694	if self.child == true then
3817	4695
3818		self.hornytimer = self.hornytimer + 20
3819
	4696	-- self.hornytimer = self.hornytimer + 20
	4697	-- deduct 10% of the time to adulthood
	4698	self.hornytimer = math.floor(self.hornytimer + (
	4699	(CHILD_GROW_TIME - self.hornytimer) * 0.1))
	4700	--print ("====", self.hornytimer)
3820	4701	return true
3821	4702	end
3822	4703
3823	4704	-- feed and tame
3824	4705	self.food = (self.food or 0) + 1
	4706	self._breed_countdown = feed_count - self.food
	4707
3825	4708	if self.food >= feed_count then
3826	4709
3827	4710	self.food = 0
	4711	self._breed_countdown = nil
3828	4712
3829	4713	if breed and self.hornytimer == 0 then
3830	4714	self.horny = true
3831	4715	end
3832
3833		self.gotten = false
3834	4716
3835	4717	if tame then
3836	4718

3841	4723	end
3842	4724
3843	4725	self.tamed = true
	4726	self.static_save = true
3844	4727
3845	4728	if not self.owner or self.owner == "" then
3846	4729	self.owner = clicker:get_player_name()

3848	4731	end
3849	4732
3850	4733	-- make sound when fed so many times
3851		mob_sound(self, self.sounds.random)
3852		end
	4734	self:mob_sound(self.sounds.random)
	4735	end
	4736
	4737	self:update_tag()
3853	4738
3854	4739	return true
3855	4740	end
3856	4741
3857	4742	local item = clicker:get_wielded_item()
	4743	local name = clicker:get_player_name()
3858	4744
3859	4745	-- if mob has been tamed you can name it with a nametag
3860	4746	if item:get_name() == "mobs:nametag"
3861		and clicker:get_player_name() == self.owner then
3862
3863		local name = clicker:get_player_name()
	4747	and (name == self.owner
	4748	or minetest.check_player_privs(name, "protection_bypass")) then
3864	4749
3865	4750	-- store mob and nametag stack in external variables
3866	4751	mob_obj[name] = self
3867	4752	mob_sta[name] = item
3868	4753
3869	4754	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")) .. "]")
	4755	local esc = minetest.formspec_escape
	4756
	4757	minetest.show_formspec(name, "mobs_nametag",
	4758	"size[8,4]" ..
	4759	"field[0.5,1;7.5,0;name;" ..
	4760	esc(S("Enter name:")) ..
	4761	";" .. tag .. "]" ..
	4762	"button_exit[2.5,3.5;3,1;mob_rename;" ..
	4763	esc(S("Rename")) .. "]")
	4764
	4765	return true
	4766	end
	4767
	4768	-- if mob follows items and user right clicks while holding sneak it shows info
	4769	if self.follow then
	4770
	4771	if clicker:get_player_control().sneak then
	4772
	4773	if type(self.follow) == "string" then
	4774	self.follow = {self.follow}
	4775	end
	4776
	4777	minetest.chat_send_player(clicker:get_player_name(),
	4778	S("@1 follows:\n- @2",
	4779	self.name:split(":")[2],
	4780	table.concat(self.follow, "\n- ")))
	4781	end
3878	4782	end
3879	4783
3880	4784	return false

3904	4808	end
3905	4809
3906	4810	-- limit name entered to 64 characters long
3907		if string.len(fields.name) > 64 then
3908		fields.name = string.sub(fields.name, 1, 64)
	4811	if fields.name:len() > 64 then
	4812	fields.name = fields.name:sub(1, 64)
3909	4813	end
3910	4814
3911	4815	-- update nametag
3912	4816	mob_obj[name].nametag = fields.name
3913	4817
3914		update_tag(mob_obj[name])
	4818	mob_obj[name]:update_tag()
3915	4819
3916	4820	-- if not in creative then take item
3917	4821	if not mobs.is_creative(name) then

3931	4835	-- compatibility function for old entities to new modpack entities
3932	4836	function mobs:alias_mob(old_name, new_name)
3933	4837
	4838	-- check old_name entity doesnt already exist
	4839	if minetest.registered_entities[old_name] then
	4840	return
	4841	end
	4842
3934	4843	-- spawn egg
3935	4844	minetest.register_alias(old_name, new_name)
3936	4845
3937	4846	-- entity
3938	4847	minetest.register_entity(":" .. old_name, {
3939	4848
3940		physical = false,
3941
3942		on_activate = function(self)
	4849	physical = false, static_save = false,
	4850
	4851	on_activate = function(self, staticdata)
3943	4852
3944	4853	if minetest.registered_entities[new_name] then
3945		minetest.add_entity(self.object:get_pos(), new_name)
3946		end
3947
3948		self.object:remove()
	4854
	4855	minetest.add_entity(self.object:get_pos(), new_name, staticdata)
	4856	end
	4857
	4858	remove_mob(self)
	4859	end,
	4860
	4861	get_staticdata = function(self)
	4862	return self
3949	4863	end
3950	4864	})
3951	4865	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

+168

-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.

105	122	continue chasing.
106	123	'arrow' holds the pre-defined arrow object to shoot when
107	124	attacking.
	125	'arrow_override' function that allows tweaking of arrow entity from
	126	inside mob definition (self) passed to function.
108	127	'dogshoot_switch' allows switching between attack types by using timers
109	128	(1 for shoot, 2 for dogfight)
110	129	'dogshoot_count_max' contains how many seconds before switching from

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

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

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

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

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

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

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

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

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

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

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

398	493	'on_step' is a custom function when arrow is active, nil for
399	494	default.
400	495	'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.
	496	'collisionbox' is hitbox table for arrow, {-.1,-.1,-.1,.1,.1,.1} by default.
	497	'lifetime' contains float value for how many seconds arrow exists in
	498	world before being removed (default is 4.5 seconds).
402	499
403	500
404	501	Spawn Eggs

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

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

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

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

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

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

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

721	849	if inv:room_for_item("main", "mobs:saddle") then
722	850	inv:add_item("main", "mobs:saddle")
723	851	else
724		minetest.add_item(clicker.getpos(), "mobs:saddle")
	852	minetest.add_item(clicker.get_pos(), "mobs:saddle")
725	853	end
726	854
727	855	-- 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

+93

-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.56 - Added arrow_override function to mob definition to tweak arrow entity settings, tamed monsters no longer despawn when outside loaded map area.
	26	- 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
	27	- 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.
	28	- 1.53 - Added 'on_map_load' settings to mobs:spawn so that mobs will only spawn when new areas of map are loaded.
	29	- 1.52 - Added 'mob_active_limit' in settings to set number of mobs in game,
	30	(default is 0 for unlimited), removed {immortal} from mob armor, fluid viscocity slows mobs
	31	- 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
	32	- 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
	33	- 1.49- Added mobs:force_capture(self, player) function, api functions now use metatables thanks to bell07
	34	- 1.48- Add mobs:set_velocity(self, velocity) global function
	35	- 1.47- Mob damage changes, min and max light level for damage added, ignition sources checked for lava damage
	36	- 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
	37	- 1.45- Added Fence Top to add on top of any fence to stop mobs escaping, new line_of_sight tweaked by Astrobe
	38	- 1.44- Added ToolRanks support for swords when attacking mobs
	39	- 1.43- Better 0.4.16 compatibility, added general attack function and settings
	40	- 1.42- Added "all" option to immune_to table, tidied floating mobs to be less intensive
	41	- 1.41- Mob pathfinding has been updated thanks to Elkien3
	42	- 1.40- Updated to use newer functions, requires Minetest 0.4.16+ to work.
	43	- 1.39- Added 'on_breed', 'on_grown' and 'do_punch' custom functions per mob
	44	- 1.38- Better entity checking, nametag setting and on_spawn function added to mob registry, tweaked light damage
	45	- 1.37- Added support for Raymoo's CMI (common mob interface) mod: https://forum.minetest.net/viewtopic.php?f=9&t=15448
	46	- 1.36- Death check added, if mob dies in fire/lava/with lava pick then drops are cooked
	47	- 1.35- Added owner_loyal flag for owned mobs to attack player enemies, also fixed group_attack
	48	- 1.34- Added function to fly mob using directional movement (thanks D00Med for flying code)
	49	- 1.33- Added functions to mount ride mobs (mobs.attach, mobs.detach, mobs.drive) many thanks to Blert2112
	50	- 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
	51	- 1.31- Added 'attack_animals' and 'specific_attack' flags for custom monster attacks, also 'mob_difficulty' .conf setting to make mobs harder.
	52	- 1.30- Added support for invisibility mod (mobs cant attack what they cant see), tweaked and tidied code
	53	- 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
	54	- 1.28- New damage system added with ability for mob to be immune to weapons or healed by them :)
	55	- 1.27- Added new sheep, lava flan and spawn egg textures. New Lava Pick tool smelts what you dig. New atan checking function.
	56	- 1.26- Pathfinding feature added thanks to rnd, when monsters attack they become scary smart in finding you :) also, beehive produces honey now :)
	57	- 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.
	58	- 1.24- Added feature where certain animals run away when punched (runaway = true in mob definition)
	59	- 1.23- Added mob spawner block for admin to setup spawners in-game (place and right click to enter settings)
	60	- 1.22- Added ability to name tamed animals and npc using nametags, also npc will attack anyone who punches them apart from owner
	61	- 1.21- Added some more error checking to reduce serialize.h error and added height checks for falling off cliffs (thanks cmdskp)
	62	- 1.20- Error checking added to remove bad mobs, out of map limit mobs and stop serialize.h error
	63	- 1.19- Chickens now drop egg items instead of placing the egg, also throwing eggs result in 1/8 chance of spawning chick
	64	- 1.18- Added docile_by_day flag so that monsters will not attack automatically during daylight hours unless hit first
	65	- 1.17- Added 'dogshoot' attack type, shoots when out of reach, melee attack when in reach, also api tweaks and self.reach added
	66	- 1.16- Mobs follow multiple items now, Npc's can breed
	67	- 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.
	68	- 1.14- All .self variables saved in staticdata, Fixed self.health bug
	69	- 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
	70	- 1.12- Added animal ownership so that players cannot steal your tamed animals
	71	- 1.11- Added flying mobs (and swimming), fly=true and fly_in="air" or "deafult:water_source" for fishy
	72	- 1,10- Footstep removed (use replace), explosion routine added for exploding mobs.
	73	- 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
	74	- 1.08- Mob throwing attack has been rehauled so that they can damage one another, also drops and on_die function added
	75	- 1.07- Npc's can now be set to follow player or stand by using self.order and self.owner variables
	76	- beta- Npc mob added, kills monsters, attacks player when punched, right click with food to heal or gold lump for drop
	77	- 1.06- Changed recovery times after breeding, and time taken to grow up (can be sped up by feeding baby animal)
	78	- 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
	79	- 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 :)
	80	- 1.03- Added mob drop/replace feature so that chickens can drop eggs, cow/sheep can eat grass/wheat etc.
	81	- 1.02- Sheared sheep are remembered and spawn shaven, Warthogs will attack when threatened, Api additions
	82	- 1.01- Mobs that suffer fall damage or die in water/lava/sunlight will now drop items
	83	- 1.0 - more work on Api so that certain mobs can float in water while some sink like a brick :)
	84	- 0.9 - Spawn eggs added for all mobs (admin only, cannot be placed in protected areas)... Api tweaked
	85	- 0.8 - Added sounds to monster mobs (thanks Cyberpangolin for the sfx) and also chicken sound
	86	- 0.7 - mobs.protected switch added to api.lua, when set to 1 mobs no longer spawn in protected areas, also bug fixes
	87	- 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
	88	- 0.5 - Mobs now float in water, die from falling, and some code improvements
	89	- 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 :)
	90	- 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 :)
	91	- 0.2 - Cooking bucket of milk into cheese now returns empty bucket
	92	- 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