From 9f9a522ec71f8891043c55022e159a38ccff418a Mon Sep 17 00:00:00 2001 From: tenplus1 Date: Tue, 26 Sep 2023 07:48:48 +0100 Subject: [PATCH] Revert initial_properties change, breaks too many routines --- api.lua | 138 +- api_WIP.lua | 4950 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 4997 insertions(+), 91 deletions(-) create mode 100644 api_WIP.lua diff --git a/api.lua b/api.lua index 52501dc..e41cd87 100644 --- a/api.lua +++ b/api.lua @@ -11,7 +11,7 @@ local use_mc2 = minetest.get_modpath("mcl_core") -- Global mobs = { mod = "redo", - version = "20230925", + version = "20230926", translate = S, invis = minetest.global_exists("invisibility") and invisibility or {}, node_snow = minetest.registered_aliases["mapgen_snow"] @@ -126,17 +126,17 @@ local creatura = minetest.get_modpath("creatura") and mobs.mob_class = { --- stepheight = 1.1, + stepheight = 1.1, fly_in = "air", owner = "", order = "", jump_height = 4, lifetimer = 180, -- 3 minutes --- physical = true, --- collisionbox = {-0.25, -0.25, -0.25, 0.25, 0.25, 0.25}, --- visual_size = {x = 1, y = 1}, + physical = true, + collisionbox = {-0.25, -0.25, -0.25, 0.25, 0.25, 0.25}, + visual_size = {x = 1, y = 1}, texture_mods = "", --- makes_footstep_sound = false, + makes_footstep_sound = false, view_range = 5, walk_velocity = 1, run_velocity = 2, @@ -733,20 +733,20 @@ local CHILD_GROW_TIME = 60 * 20 -- 20 minutes function mob_class:update_tag() local col - local qua = self.initial_properties.hp_max / 6 + local qua = self.hp_max / 6 if self.health <= qua then - col = "#FF0000" -- (255,0,0) + col = "#FF0000" elseif self.health <= (qua * 2) then - col = "#FF7A00" -- (255,122,0) + col = "#FF7A00" elseif self.health <= (qua * 3) then - col = "#FFB500" -- (255,181,0) + col = "#FFB500" elseif self.health <= (qua * 4) then - col = "#FFFF00" -- (255,255,0) + col = "#FFFF00" elseif self.health <= (qua * 5) then - col = "#B4FF00" -- (180,255,0) + col = "#B4FF00" elseif self.health > (qua * 5) then - col = "#00FF00" -- (0,255,0) + col = "#00FF00" end local text = "" @@ -767,16 +767,13 @@ function mob_class:update_tag() end end - self.infotext = "Health: " .. self.health .. " / " .. self.initial_properties.hp_max + self.infotext = "Health: " .. self.health .. " / " .. self.hp_max .. (self.owner == "" and "" or "\nOwner: " .. self.owner) .. text -- set changes self.object:set_properties({ - nametag = self.nametag, - nametag_color = col, - infotext = self.infotext - }) + nametag = self.nametag, nametag_color = col, infotext = self.infotext}) end @@ -906,8 +903,8 @@ function mob_class:check_for_death(cmi_cause) end -- make sure health isn't higher than max - if self.health > self.initial_properties.hp_max then - self.health = self.initial_properties.hp_max + if self.health > self.hp_max then + self.health = self.hp_max end self:update_tag() @@ -1746,7 +1743,7 @@ function mob_class:smart_mobs(s, p, dist, dtime) end, self) end - if abs(vsubtract(s, target_pos).y) > self.initial_properties.stepheight then + if abs(vsubtract(s, target_pos).y) > self.stepheight then if height_switcher then use_pathfind = true @@ -1792,7 +1789,7 @@ function mob_class:smart_mobs(s, p, dist, dtime) jumpheight = min(ceil( self.jump_height / pathfinding_max_jump), pathfinding_max_jump) - elseif self.initial_properties.stepheight > 0.5 then + elseif self.stepheight > 0.5 then jumpheight = 1 end @@ -2962,11 +2959,9 @@ function mob_class:on_punch(hitter, tflp, tool_capabilities, dir, damage) -- add healthy afterglow when hit (can cause lag with larger textures) if mob_hit_effect then - local _dtm = self.initial_properties.damage_texture_modifier - self.old_texture_mods = self.texture_mods - self.object:set_texture_mod(self.texture_mods .. _dtm) + self.object:set_texture_mod(self.texture_mods .. self.damage_texture_modifier) minetest.after(0.3, function() @@ -3214,12 +3209,11 @@ function mob_class:mob_activate(staticdata, def, dtime) def.textures = {def.textures} end - self.base_texture = def.textures - and def.textures[random(#def.textures)] + self.base_texture = def.textures and def.textures[random(#def.textures)] self.base_mesh = def.mesh - self.base_size = self.initial_properties.visual_size - self.base_colbox = self.initial_properties.collisionbox - self.base_selbox = self.initial_properties.selectionbox + self.base_size = self.visual_size + self.base_colbox = self.collisionbox + self.base_selbox = self.selectionbox end -- for current mobs that dont have this set @@ -3265,7 +3259,7 @@ function mob_class:mob_activate(staticdata, def, dtime) end if self.health == 0 then - self.health = random(self.hp_min, self.initial_properties.hp_max) + self.health = random(self.hp_min, self.hp_max) end -- pathfinding init @@ -3298,7 +3292,7 @@ function mob_class:mob_activate(staticdata, def, dtime) self.standing_on = "air" -- check for existing nametag - self.nametag = self.initial_properties.nametag or def.nametag + self.nametag = self.nametag or def.nametag -- set anything changed above self.object:set_properties(self) @@ -3599,44 +3593,7 @@ function mobs:register_mob(name, def) minetest.register_entity(":" .. name, setmetatable({ - initial_properties = { - - hp_max = max(1, (def.hp_max or 10) * difficulty), --- breath_max --- zoom_fov --- eye_height - physical = true, --- collide_with_objects - collisionbox = collisionbox, - selectionbox = def.selectionbox or collisionbox, --- pointable - visual = def.visual, - visual_size = def.visual_size or {x = 1, y = 1}, - mesh = def.mesh, - textures = nil, --- colors --- use_texture_alpha --- spritediv --- initial_sprite_basepos --- is_visible - make_footstep_sound = def.make_footstep_sound, --- automatic_rotate - stepheight = def.stepheight or 1.1, --- automatic_face_movement_dir --- automatic_face_movement_max_rotation_per_sec --- backface_culling - glow = def.glow, --- nametag --- nametag_color --- nametag_bgcolor --- infotext --- static_save - damage_texture_modifier = def.damage_texture_modifier or "^[colorize:#c9900070", --- shaded --- show_on_minimap - }, - --- stepheight = def.stepheight, + stepheight = def.stepheight, name = name, type = def.type, attack_type = def.attack_type, @@ -3645,29 +3602,26 @@ minetest.register_entity(":" .. name, setmetatable({ keep_flying = def.keep_flying, owner = def.owner, order = def.order, - on_die = def.on_die, - on_flop = def.on_flop, - do_custom = def.do_custom, jump_height = def.jump_height, can_leap = def.can_leap, drawtype = def.drawtype, -- DEPRECATED, use rotate instead rotate = rad(def.rotate or 0), -- 0=front 90=side 180=back 270=side2 --- glow = def.glow, + glow = def.glow, lifetimer = def.lifetimer, hp_min = max(1, (def.hp_min or 5) * difficulty), --- hp_max = max(1, (def.hp_max or 10) * difficulty), --- collisionbox = collisionbox, --- selectionbox = def.selectionbox or collisionbox, --- visual = def.visual, --- visual_size = def.visual_size, --- mesh = def.mesh, --- makes_footstep_sound = def.makes_footstep_sound, + hp_max = max(1, (def.hp_max or 10) * difficulty), + collisionbox = collisionbox, --def.collisionbox, + selectionbox = def.selectionbox or collisionbox, --def.collisionbox, + visual = def.visual, + visual_size = def.visual_size or {x = 1, y = 1}, + mesh = def.mesh, + makes_footstep_sound = def.makes_footstep_sound, view_range = def.view_range, walk_velocity = def.walk_velocity, run_velocity = def.run_velocity, damage = max(0, (def.damage or 0) * difficulty), damage_group = def.damage_group, --- damage_texture_modifier = def.damage_texture_modifier or "^[colorize:#c9900070", + damage_texture_modifier = def.damage_texture_modifier or "^[colorize:#c9900070", light_damage = def.light_damage, light_damage_min = def.light_damage_min, light_damage_max = def.light_damage_max, @@ -3734,9 +3688,13 @@ minetest.register_entity(":" .. name, setmetatable({ ignore_invisibility = def.ignore_invisibility, messages = def.messages, - custom_attack = def.custom_attack, - on_replace = def.on_replace, on_rightclick = def.on_rightclick, + on_die = def.on_die, + on_flop = def.on_flop, + do_custom = def.do_custom, + on_replace = def.on_replace, + custom_attack = def.custom_attack, + on_spawn = def.on_spawn, on_blast = def.on_blast, -- class redifinition do_punch = def.do_punch, @@ -3902,7 +3860,6 @@ function mobs:add_mob(pos, def) end -- and resize to half height (multiplication is faster than division) - mob:set_properties({ textures = textures, visual_size = { @@ -4097,13 +4054,12 @@ function mobs:spawn_specific(name, nodes, neighbors, min_light, max_light, inter end local ent = minetest.registered_entities[name] - local cbox = ent.initial_properties.collisionbox -- should we check mob area for obstructions ? if mob_area_spawn ~= true then -- do we have enough height clearance to spawn mob? - local height = max(0, cbox[5] - cbox[2]) + local height = max(0, ent.collisionbox[5] - ent.collisionbox[2]) for n = 0, floor(height) do @@ -4122,7 +4078,7 @@ function mobs:spawn_specific(name, nodes, neighbors, min_light, max_light, inter if pos then -- adjust for mob collision box - pos.y = pos.y + (cbox[2] * -1) - 0.4 + pos.y = pos.y + (ent.collisionbox[2] * -1) - 0.4 local mob = minetest.add_entity(pos, name) @@ -4727,9 +4683,9 @@ function mobs:feed_tame(self, clicker, feed_count, breed, tame) -- increase health self.health = self.health + 4 - if self.health >= self.initial_properties.hp_max then + if self.health >= self.hp_max then - self.health = self.initial_properties.hp_max + self.health = self.hp_max end self.object:set_hp(self.health) @@ -4888,7 +4844,7 @@ function mobs:alias_mob(old_name, new_name) initial_properties = { physical = false, - static_save = false + static_save = false, }, on_activate = function(self, staticdata) diff --git a/api_WIP.lua b/api_WIP.lua new file mode 100644 index 0000000..eacccbc --- /dev/null +++ b/api_WIP.lua @@ -0,0 +1,4950 @@ +-- Translation support +local S = minetest.get_translator("mobs") +local FS = function(...) return minetest.formspec_escape(S(...)) end + +-- CMI support check +local use_cmi = minetest.global_exists("cmi") + +-- MineClone2 check +local use_mc2 = minetest.get_modpath("mcl_core") + +-- Global +mobs = { + mod = "redo", + version = "20230925", + translate = S, + invis = minetest.global_exists("invisibility") and invisibility or {}, + node_snow = minetest.registered_aliases["mapgen_snow"] + or (use_mc2 and "mcl_core:snow") or "default:snow", + node_dirt = minetest.registered_aliases["mapgen_dirt"] + or (use_mc2 and "mcl_core:dirt") or "default:dirt" +} +mobs.fallback_node = mobs.node_dirt + +-- localize common functions +local pi = math.pi +local square = math.sqrt +local sin = math.sin +local cos = math.cos +local abs = math.abs +local min = math.min +local max = math.max +local random = math.random +local floor = math.floor +local ceil = math.ceil +local rad = math.rad +local deg = math.deg +local atann = math.atan +local atan = function(x) + if not x or x ~= x then + return 0 -- NaN + else + return atann(x) + end +end +local table_copy = table.copy +local table_remove = table.remove +local vdirection = vector.direction +local vmultiply = vector.multiply +local vsubtract = vector.subtract +local settings = minetest.settings + +-- creative check +local creative_cache = minetest.settings:get_bool("creative_mode") +function mobs.is_creative(name) + return creative_cache or minetest.check_player_privs(name, {creative = true}) +end + +-- Load settings +local damage_enabled = settings:get_bool("enable_damage") +local mobs_spawn = settings:get_bool("mobs_spawn") ~= false +local peaceful_only = settings:get_bool("only_peaceful_mobs") +local disable_blood = settings:get_bool("mobs_disable_blood") +local mob_hit_effect = settings:get_bool("mob_hit_effect") +local mobs_drop_items = settings:get_bool("mobs_drop_items") ~= false +local mobs_griefing = settings:get_bool("mobs_griefing") ~= false +local spawn_protected = settings:get_bool("mobs_spawn_protected") ~= false +local spawn_monster_protected = settings:get_bool("mobs_spawn_monster_protected") ~= false +local remove_far = settings:get_bool("remove_far_mobs") ~= false +local mob_area_spawn = settings:get_bool("mob_area_spawn") +local difficulty = tonumber(settings:get("mob_difficulty")) or 1.0 +local max_per_block = tonumber(settings:get("max_objects_per_block") or 99) +local mob_nospawn_range = tonumber(settings:get("mob_nospawn_range") or 12) +local active_limit = tonumber(settings:get("mob_active_limit") or 0) +local mob_chance_multiplier = tonumber(settings:get("mob_chance_multiplier") or 1) +local peaceful_player_enabled = settings:get_bool("enable_peaceful_player") +local mob_smooth_rotate = settings:get_bool("mob_smooth_rotate") ~= false +local mob_height_fix = settings:get_bool("mob_height_fix") ~= false +local mob_log_spawn = settings:get_bool("mob_log_spawn") == true +local active_mobs = 0 + +-- get loop timers for node and main functions +local node_timer_interval = tonumber(settings:get("mob_node_timer_interval") or 0.25) +local main_timer_interval = tonumber(settings:get("mob_main_timer_interval") or 1.0) + +-- pathfinding settings +local pathfinding_enable = settings:get_bool("mob_pathfinding_enable") or true +-- Use pathfinder mod if available +local pathfinder_enable = settings:get_bool("mob_pathfinder_enable") or true +-- how long before stuck mobs start searching +local pathfinding_stuck_timeout = tonumber( + settings:get("mob_pathfinding_stuck_timeout")) or 3.0 +-- how long will mob follow path before giving up +local pathfinding_stuck_path_timeout = tonumber(settings:get("mob_pathfinding_stuck_path_timeout")) or 5.0 +-- which algorithm to use, Dijkstra(default) or A*_noprefetch or A* +-- fix settings not allowing "*" +local pathfinding_algorithm = settings:get("mob_pathfinding_algorithm") or "Dijkstra" + +if pathfinding_algorithm == "AStar_noprefetch" then + pathfinding_algorithm = "A*_noprefetch" +elseif pathfinding_algorithm == "AStar" then + pathfinding_algorithm = "A*" +end + +-- max search distance from search positions (default 16) +local pathfinding_searchdistance = tonumber( + settings:get("mob_pathfinding_searchdistance") or 16) +-- max jump height (default 4) +local pathfinding_max_jump = tonumber(settings:get("mob_pathfinding_max_jump") or 4) +-- max drop height (default 6) +local pathfinding_max_drop = tonumber(settings:get("mob_pathfinding_max_drop") or 6) + +-- Peaceful mode message so players will know there are no monsters +if peaceful_only then + minetest.register_on_joinplayer(function(player) + minetest.chat_send_player(player:get_player_name(), + S("** Peaceful Mode Active - No Monsters Will Spawn")) + end) +end + +-- calculate aoc range for mob count +local aoc_range = tonumber(settings:get("active_block_range")) * 16 + +-- can we attack Creatura mobs ? +local creatura = minetest.get_modpath("creatura") and + settings:get_bool("mobs_attack_creatura") == true + + +mobs.mob_class = { +-- stepheight = 1.1, + fly_in = "air", + owner = "", + order = "", + jump_height = 4, + lifetimer = 180, -- 3 minutes +-- physical = true, +-- collisionbox = {-0.25, -0.25, -0.25, 0.25, 0.25, 0.25}, +-- visual_size = {x = 1, y = 1}, + texture_mods = "", +-- makes_footstep_sound = false, + view_range = 5, + walk_velocity = 1, + run_velocity = 2, + light_damage = 0, + light_damage_min = 14, + light_damage_max = 15, + water_damage = 0, + lava_damage = 4, + fire_damage = 4, + air_damage = 0, + suffocation = 2, + fall_damage = 1, + fall_speed = -10, -- must be lower than -2 (default: -10) + drops = {}, + armor = 100, + sounds = {}, + jump = true, + knock_back = true, + walk_chance = 50, + stand_chance = 30, + attack_chance = 5, + passive = false, + blood_amount = 5, + blood_texture = "mobs_blood.png", + shoot_offset = 0, + floats = 1, -- floats in water by default + replace_offset = 0, + timer = 0, + env_damage_timer = 0, + tamed = false, + pause_timer = 0, + horny = false, + hornytimer = 0, + child = false, + gotten = false, + health = 0, + reach = 3, + docile_by_day = false, + time_of_day = 0.5, + fear_height = 0, + runaway_timer = 0, + immune_to = {}, + explosion_timer = 3, + allow_fuse_reset = true, + stop_to_explode = true, + dogshoot_count = 0, + dogshoot_count_max = 5, + dogshoot_count2_max = 5, + group_attack = false, + attack_monsters = false, + attack_animals = false, + attack_players = true, + attack_npcs = true, + friendly_fire = true, + facing_fence = false, + _breed_countdown = nil, + _cmi_is_mob = true +} + +local mob_class = mobs.mob_class -- Compatibility +local mob_class_meta = {__index = mob_class} + + +-- play sound +function mob_class:mob_sound(sound) + + if sound then + + -- higher pitch for a child + local pitch = self.child and 1.5 or 1.0 + + -- a little random pitch to be different + pitch = pitch + random(-10, 10) * 0.005 + + minetest.sound_play(sound, { + object = self.object, + gain = 1.0, + max_hear_distance = self.sounds.distance, + pitch = pitch + }, true) + end +end + + +-- attack player/mob +function mob_class:do_attack(player) + + if self.state == "attack" then + return + end + + self.attack = player + self.state = "attack" + + if random(100) < 90 then + self:mob_sound(self.sounds.war_cry) + end +end + + +-- calculate distance +local get_distance = function(a, b) + + if not a or not b then return 50 end -- nil check and default distance + + local x, y, z = a.x - b.x, a.y - b.y, a.z - b.z + + return square(x * x + y * y + z * z) +end + + +-- are we a real player ? +local function is_player(player) + + if player and type(player) == "userdata" and minetest.is_player(player) then + return true + end +end + + +-- collision function based on jordan4ibanez' open_ai mod +function mob_class:collision() + + local pos = self.object:get_pos() ; if not pos then return {0, 0} end + local x, z = 0, 0 + local width = -self.collisionbox[1] + self.collisionbox[4] + 0.5 + + for _,object in ipairs(minetest.get_objects_inside_radius(pos, width)) do + + if is_player(object) then + + local pos2 = object:get_pos() + local vec = {x = pos.x - pos2.x, z = pos.z - pos2.z} + local force = (width + 0.5) - vector.distance( + {x = pos.x, y = 0, z = pos.z}, + {x = pos2.x, y = 0, z = pos2.z}) + + x = x + (vec.x * force) + z = z + (vec.z * force) + end + end + + return({x, z}) +end + + +-- check if string exists in another string or table +local function check_for(look_for, look_inside) + + if type(look_inside) == "string" and look_inside == look_for then + + return true + + elseif type(look_inside) == "table" then + + for _, str in pairs(look_inside) do + + if str == look_for then + return true + end + + if str and str:find("group:") then + + local group = str:split(":")[2] or "" + + if minetest.get_item_group(look_for, group) ~= 0 then + return true + end + end + end + end + + return false +end + + +-- move mob in facing direction +function mob_class:set_velocity(v) + + -- halt mob if it has been ordered to stay + if self.order == "stand" then + + local vel = self.object:get_velocity() or {y = 0} + + self.object:set_velocity({x = 0, y = vel.y, z = 0}) + + return + end + + local c_x, c_y = 0, 0 + + -- can mob be pushed, if so calculate direction + if self.pushable then + c_x, c_y = unpack(self:collision()) + end + + local yaw = (self.object:get_yaw() or 0) + (self.rotate or 0) + + -- nil check for velocity + v = v or 0.01 + + -- check if standing in liquid with max viscosity of 7 + local visc = min(minetest.registered_nodes[self.standing_in].liquid_viscosity, 7) + + -- only slow mob trying to move while inside a viscous fluid that + -- they aren't meant to be in (fish in water, spiders in cobweb etc) + if v > 0 and visc and visc > 0 and not check_for(self.standing_in, self.fly_in) then + v = v / (visc + 1) + end + + -- set velocity + local vel = self.object:get_velocity() or {x = 0, y = 0, z = 0} + + local new_vel = { + x = (sin(yaw) * -v) + c_x, + y = vel.y, + z = (cos(yaw) * v) + c_y} + + self.object:set_velocity(new_vel) +end + +-- global version of above function +function mobs:set_velocity(entity, v) + mob_class.set_velocity(entity, v) +end + + +-- calculate mob velocity +function mob_class:get_velocity() + + local v = self.object:get_velocity() + + if not v then return 0 end + + return (v.x * v.x + v.z * v.z) ^ 0.5 +end + + +-- set and return valid yaw +function mob_class:set_yaw(yaw, delay) + + if not yaw or yaw ~= yaw then + yaw = 0 + end + + delay = mob_smooth_rotate and delay or 0 + + -- simplified yaw clamp + if yaw > 6.283185 then + yaw = yaw - 6.283185 + elseif yaw < 0 then + yaw = 6.283185 + yaw + end + + if delay == 0 then + + self.object:set_yaw(yaw) + + return yaw + end + + self.target_yaw = yaw + self.delay = delay + + return self.target_yaw +end + +-- global function to set mob yaw +function mobs:yaw(entity, yaw, delay) + mob_class.set_yaw(entity, yaw, delay) +end + + +-- set defined animation +function mob_class:set_animation(anim, force) + + if not self.animation or not anim then return end + + self.animation.current = self.animation.current or "" + + -- only use different animation for attacks when using same set + if force ~= true and anim ~= "punch" and anim ~= "shoot" + and string.find(self.animation.current, anim) then + return + end + + local num = 0 + + -- check for more than one animation (max 4) + for n = 1, 4 do + + if self.animation[anim .. n .. "_start"] + and self.animation[anim .. n .. "_end"] then + num = n + end + end + + -- choose random animation from set + if num > 0 then + num = random(0, num) + anim = anim .. (num ~= 0 and num or "") + end + + if (anim == self.animation.current and force ~= true) + or not self.animation[anim .. "_start"] + or not self.animation[anim .. "_end"] then + return + end + + self.animation.current = anim + + self.object:set_animation({ + x = self.animation[anim .. "_start"], + y = self.animation[anim .. "_end"]}, + self.animation[anim .. "_speed"] or self.animation.speed_normal or 15, + 0, self.animation[anim .. "_loop"] ~= false) +end + +function mobs:set_animation(entity, anim) + entity.set_animation(entity, anim) +end + + +-- check line of sight (BrunoMine) +local function line_of_sight(self, pos1, pos2, stepsize) + + stepsize = stepsize or 1 + + local s = minetest.line_of_sight(pos1, pos2, stepsize) + + -- normal walking and flying mobs can see you through air + if s == true then + return true + end + + -- New pos1 to be analyzed + local npos1 = {x = pos1.x, y = pos1.y, z = pos1.z} + + local r, pos = minetest.line_of_sight(npos1, pos2, stepsize) + + -- Checks the return + if r == true then return true end + + -- Nodename found + local nn = minetest.get_node(pos).name + + -- Target Distance (td) to travel + local td = get_distance(pos1, pos2) + + -- Actual Distance (ad) traveled + local ad = 0 + + -- It continues to advance in the line of sight in search of a real + -- obstruction which counts as 'walkable' nodebox. + while minetest.registered_nodes[nn] + and minetest.registered_nodes[nn].walkable == false do + + -- Check if you can still move forward + if td < ad + stepsize then + return true -- Reached the target + end + + -- Moves the analyzed pos + local d = get_distance(pos1, pos2) + + npos1.x = ((pos2.x - pos1.x) / d * stepsize) + pos1.x + npos1.y = ((pos2.y - pos1.y) / d * stepsize) + pos1.y + npos1.z = ((pos2.z - pos1.z) / d * stepsize) + pos1.z + + -- NaN checks + if d == 0 + or npos1.x ~= npos1.x or npos1.y ~= npos1.y or npos1.z ~= npos1.z then + return false + end + + ad = ad + stepsize + + -- scan again + r, pos = minetest.line_of_sight(npos1, pos2, stepsize) + + if r == true then return true end + + -- New Nodename found + nn = minetest.get_node(pos).name + end + + return false +end + + +-- check line of sight using raycasting (thanks Astrobe) +local function ray_line_of_sight(self, pos1, pos2) + + local ray = minetest.raycast(pos1, pos2, true, false) + local thing = ray:next() + + while thing do -- thing.type, thing.ref + + if thing.type == "node" then + + local name = minetest.get_node(thing.under).name + + if minetest.registered_items[name] + and minetest.registered_items[name].walkable then + return false + end + end + + thing = ray:next() + end + + return true +end + + +function mob_class:line_of_sight(pos1, pos2, stepsize) + + if minetest.raycast then -- only use if minetest 5.0 is detected + return ray_line_of_sight(self, pos1, pos2) + end + + return line_of_sight(self, pos1, pos2, stepsize) +end + +-- global function +function mobs:line_of_sight(entity, pos1, pos2, stepsize) + return entity:line_of_sight(pos1, pos2, stepsize) +end + + +function mob_class:attempt_flight_correction(override) + + if self:flight_check() and override ~= true then return true end + + -- We are not flying in what we are supposed to. + -- See if we can find intended flight medium and return to it + local pos = self.object:get_pos() ; if not pos then return true end + local searchnodes = self.fly_in + + if type(searchnodes) == "string" then + searchnodes = {self.fly_in} + end + + local flyable_nodes = minetest.find_nodes_in_area( + {x = pos.x - 1, y = pos.y - 1, z = pos.z - 1}, + {x = pos.x + 1, y = pos.y + 2, z = pos.z + 1}, searchnodes) + + if #flyable_nodes < 1 then + return false + end + + local escape_target = flyable_nodes[random(#flyable_nodes)] + local escape_direction = vdirection(pos, escape_target) + + self.object:set_velocity(vmultiply(escape_direction, 1)) + + return true +end + + +-- are we flying in what we are suppose to? (taikedz) +function mob_class:flight_check() + + local def = minetest.registered_nodes[self.standing_in] + + if not def then return false end + + -- are we standing inside what we should be to fly/swim ? + if check_for(self.standing_in, self.fly_in) then + return true + end + + -- stops mobs getting stuck inside stairs and plantlike nodes + if def.drawtype ~= "airlike" + and def.drawtype ~= "liquid" + and def.drawtype ~= "flowingliquid" then + return true + end + + return false +end + + +-- turn mob to face position +local function yaw_to_pos(self, target, rot) + + rot = rot or 0 + + local pos = self.object:get_pos() + local vec = {x = target.x - pos.x, z = target.z - pos.z} + local yaw = (atan(vec.z / vec.x) + rot + pi / 2) - self.rotate + + if target.x > pos.x then + yaw = yaw + pi + end + + yaw = self:set_yaw(yaw, rot) + + return yaw +end + +function mobs:yaw_to_pos(self, target, rot) + return yaw_to_pos(self, target, rot) +end + + +-- if stay near set then periodically check for nodes and turn towards them +function mob_class:do_stay_near() + + if not self.stay_near then return false end + + local pos = self.object:get_pos() + local searchnodes = self.stay_near[1] + local chance = self.stay_near[2] or 10 + + if not pos or random(chance) > 1 then + return false + end + + if type(searchnodes) == "string" then + searchnodes = {self.stay_near[1]} + end + + local r = self.view_range + local nearby_nodes = minetest.find_nodes_in_area( + {x = pos.x - r, y = pos.y - 1, z = pos.z - r}, + {x = pos.x + r, y = pos.y + 1, z = pos.z + r}, searchnodes) + + if #nearby_nodes < 1 then + return false + end + + yaw_to_pos(self, nearby_nodes[random(#nearby_nodes)]) + + self:set_animation("walk") + + self:set_velocity(self.walk_velocity) + + return true +end + + +-- custom particle effects +local function effect( + pos, amount, texture, min_size, max_size, radius, gravity, glow, fall) + + radius = radius or 2 + min_size = min_size or 0.5 + max_size = max_size or 1 + gravity = gravity or -10 + glow = glow or 0 + + if fall == true then + fall = 0 + elseif fall == false then + fall = radius + else + fall = -radius + end + + minetest.add_particlespawner({ + amount = amount, + time = 0.25, + minpos = pos, + maxpos = pos, + minvel = {x = -radius, y = fall, z = -radius}, + maxvel = {x = radius, y = radius, z = radius}, + minacc = {x = 0, y = gravity, z = 0}, + maxacc = {x = 0, y = gravity, z = 0}, + minexptime = 0.1, + maxexptime = 1, + minsize = min_size, + maxsize = max_size, + texture = texture, + glow = glow + }) +end + +function mobs:effect( + pos, amount, texture, min_size, max_size, radius, gravity, glow, fall) + + effect(pos, amount, texture, min_size, max_size, radius, gravity, glow, fall) +end + + +-- Thanks Wuzzy for the following editable settings + +local HORNY_TIME = 30 +local HORNY_AGAIN_TIME = 60 * 5 -- 5 minutes +local CHILD_GROW_TIME = 60 * 20 -- 20 minutes + + +-- update nametag and infotext +function mob_class:update_tag() + + local col + local qua = self.initial_properties.hp_max / 6 + + if self.health <= qua then + col = "#FF0000" -- (255,0,0) + elseif self.health <= (qua * 2) then + col = "#FF7A00" -- (255,122,0) + elseif self.health <= (qua * 3) then + col = "#FFB500" -- (255,181,0) + elseif self.health <= (qua * 4) then + col = "#FFFF00" -- (255,255,0) + elseif self.health <= (qua * 5) then + col = "#B4FF00" -- (180,255,0) + elseif self.health > (qua * 5) then + col = "#00FF00" -- (0,255,0) + end + + local text = "" + + if self.horny == true then + text = "\nLoving: " .. (self.hornytimer - (HORNY_TIME + HORNY_AGAIN_TIME)) + elseif self.child == true then + text = "\nGrowing: " .. (self.hornytimer - CHILD_GROW_TIME) + elseif self._breed_countdown then + text = "\nBreeding: " .. self._breed_countdown + end + + if self.protected then + if self.protected == 2 then + text = text .. "\nProtection: Level 2" + else + text = text .. "\nProtection: Level 1" + end + end + + self.infotext = "Health: " .. self.health .. " / " .. self.initial_properties.hp_max + .. (self.owner == "" and "" or "\nOwner: " .. self.owner) + .. text + +self.nametag = self.nametag or self._nametag + + -- set changes + self.object:set_properties({ + nametag = self.nametag, + nametag_color = col, + infotext = self.infotext + }) +end + + +-- drop items +function mob_class:item_drop() + + -- no drops if disabled by setting or mob is child + if not mobs_drop_items or self.child then return end + + local pos = self.object:get_pos() + + -- check for drops function + self.drops = type(self.drops) == "function" and self.drops(pos) or self.drops + + -- check for nil or no drops + if not self.drops or #self.drops == 0 then + return + end + + -- was mob killed by player? + local death_by_player = self.cause_of_death + and self.cause_of_death.puncher + and is_player(self.cause_of_death.puncher) + + -- check for tool 'looting_level' under tool_capabilities as default, or use + -- meta string 'looting_level' if found (max looting level is 3). + local looting = 0 + + if death_by_player then + + local wield_stack = self.cause_of_death.puncher:get_wielded_item() + local wield_name = wield_stack:get_name() + local wield_stack_meta = wield_stack:get_meta() + local item_def = minetest.registered_items[wield_name] + local item_looting = item_def and item_def.tool_capabilities and + item_def.tool_capabilities.looting_level or 0 + + looting = tonumber(wield_stack_meta:get_string("looting_level")) or item_looting + looting = min(looting, 3) + end + +--print("--- looting level", looting) + + local obj, item, num + + for n = 1, #self.drops do + + if random(self.drops[n].chance) == 1 then + + num = random(self.drops[n].min or 0, self.drops[n].max or 1) + item = self.drops[n].name + + -- cook items on a hot death + if self.cause_of_death.hot then + + local output = minetest.get_craft_result({ + method = "cooking", width = 1, items = {item}}) + + if output and output.item and not output.item:is_empty() then + item = output.item:get_name() + end + end + + -- only drop rare items (drops.min = 0) if killed by player + if death_by_player or self.drops[n].min ~= 0 then + obj = minetest.add_item(pos, ItemStack(item .. " " .. (num + looting))) + end + + if obj and obj:get_luaentity() then + + obj:set_velocity({ + x = random(-10, 10) / 9, + y = 6, + z = random(-10, 10) / 9 + }) + + elseif obj then + obj:remove() -- item does not exist + end + end + end + + self.drops = {} +end + + +-- remove mob and descrease counter +local function remove_mob(self, decrease) + + self.object:remove() + + if decrease and active_limit > 1 then + active_mobs = active_mobs - 1 + end +--print("-- active mobs: " .. active_mobs .. " / " .. active_limit) +end + +-- global function for removing mobs +function mobs:remove(self, decrease) + remove_mob(self, decrease) +end + + +-- check if mob is dead or only hurt +function mob_class:check_for_death(cmi_cause) + + -- We dead already + if self.state == "die" then + return true + end + + -- has health actually changed? + if self.health == self.old_health and self.health > 0 then + return false + end + + local damaged = self.health < self.old_health + + self.old_health = self.health + + -- still got some health? play hurt sound + if self.health > 0 then + + -- only play hurt sound if damaged + if damaged then + self:mob_sound(self.sounds.damage) + end + + -- make sure health isn't higher than max + if self.health > self.initial_properties.hp_max then + self.health = self.initial_properties.hp_max + end + + self:update_tag() + + return false + end + + self.cause_of_death = cmi_cause + + -- drop items and play death sound + self:item_drop() + self:mob_sound(self.sounds.death) + + local pos = self.object:get_pos() + + -- execute custom death function + if pos and self.on_die then + + self:on_die(pos) + + if use_cmi then + cmi.notify_die(self.object, cmi_cause) + end + + remove_mob(self, true) + + return true + end + + -- reset vars and set state + self.attack = nil + self.following = nil + self.v_start = false + self.timer = 0 + self.blinktimer = 0 + self.passive = true + self.state = "die" + self.fly = false + + -- check for custom death function and die animation + if self.animation + and self.animation.die_start + and self.animation.die_end then + + local frames = self.animation.die_end - self.animation.die_start + local speed = self.animation.die_speed or 15 + local length = max((frames / speed), 0) + local rot = self.animation.die_rotate and 5 + + self.object:set_properties({ + pointable = false, collide_with_objects = false, + automatic_rotate = rot, static_save = false + }) + self:set_velocity(0) + self:set_animation("die") + + minetest.after(length, function(self) + + if self.object:get_luaentity() then + + if use_cmi then + cmi.notify_die(self.object, cmi_cause) + end + + remove_mob(self, true) + end + end, self) + + return true + + elseif pos then -- otherwise remove mob and show particle effect + + if use_cmi then + cmi.notify_die(self.object, cmi_cause) + end + + remove_mob(self, true) + + effect(pos, 20, "tnt_smoke.png") + end + + return true +end + + +-- get node but use fallback for nil or unknown +local function node_ok(pos, fallback) + + local node = minetest.get_node_or_nil(pos) + + if node and minetest.registered_nodes[node.name] then + return node + end + + return minetest.registered_nodes[(fallback or mobs.fallback_node)] +end + + +-- Returns true is node can deal damage to self +function mobs:is_node_dangerous(mob_object, nodename) + + if mob_object.water_damage > 0 + and minetest.get_item_group(nodename, "water") ~= 0 then + return true + end + + if mob_object.lava_damage > 0 + and minetest.get_item_group(nodename, "lava") ~= 0 then + return true + end + + if mob_object.fire_damage > 0 + and minetest.get_item_group(nodename, "fire") ~= 0 then + return true + end + + if minetest.registered_nodes[nodename].damage_per_second > 0 then + return true + end + + return false +end + +local function is_node_dangerous(mob_object, nodename) + return mobs:is_node_dangerous(mob_object, nodename) +end + + +-- is mob facing a cliff +function mob_class:is_at_cliff() + + if self.driver or self.fear_height == 0 then -- 0 for no falling protection! + return false + end + + -- get yaw but if nil returned object no longer exists + local yaw = self.object:get_yaw() + + if not yaw then return false end + + local dir_x = -sin(yaw) * (self.collisionbox[4] + 0.5) + local dir_z = cos(yaw) * (self.collisionbox[4] + 0.5) + local pos = self.object:get_pos() + local ypos = pos.y + self.collisionbox[2] -- just above floor + + local free_fall, blocker = minetest.line_of_sight( + {x = pos.x + dir_x, y = ypos, z = pos.z + dir_z}, + {x = pos.x + dir_x, y = ypos - self.fear_height, z = pos.z + dir_z}) + + -- check for straight drop + if free_fall then + return true + end + + local bnode = node_ok(blocker, "air") + + -- will we drop onto dangerous node? + if is_node_dangerous(self, bnode.name) then + return true + end + + local def = minetest.registered_nodes[bnode.name] + + return (not def and def.walkable) +end + + +-- environmental damage (water, lava, fire, light etc.) +function mob_class:do_env_damage() + + self:update_tag() + + local pos = self.object:get_pos() ; if not pos then return end + + self.time_of_day = minetest.get_timeofday() + + -- halt mob if standing inside ignore node + if self.standing_in == "ignore" then + + self.object:set_velocity({x = 0, y = 0, z = 0}) + + return true + end + + -- particle appears at random mob height + local py = { + x = pos.x, + y = pos.y + random(self.collisionbox[2], self.collisionbox[5]), + z = pos.z + } + + local nodef = minetest.registered_nodes[self.standing_in] + + -- water + if self.water_damage ~= 0 and nodef.groups.water then + + self.health = self.health - self.water_damage + + effect(py, 5, "bubble.png", nil, nil, 1, nil) + + if self:check_for_death({type = "environment", + pos = pos, node = self.standing_in}) then + return true + end + + -- lava damage + elseif self.lava_damage ~= 0 and nodef.groups.lava then + + self.health = self.health - self.lava_damage + + effect(py, 15, "fire_basic_flame.png", 1, 5, 1, 0.2, 15, true) + + if self:check_for_death({type = "environment", pos = pos, + node = self.standing_in, hot = true}) then + return true + end + + -- fire damage + elseif self.fire_damage ~= 0 and nodef.groups.fire then + + self.health = self.health - self.fire_damage + + effect(py, 15, "fire_basic_flame.png", 1, 5, 1, 0.2, 15, true) + + if self:check_for_death({type = "environment", pos = pos, + node = self.standing_in, hot = true}) then + return true + end + + -- damage_per_second node check (not fire and lava) + elseif nodef.damage_per_second and nodef.damage_per_second ~= 0 + and nodef.groups.lava == nil and nodef.groups.fire == nil then + + self.health = self.health - nodef.damage_per_second + + effect(py, 5, "tnt_smoke.png") + + if self:check_for_death({type = "environment", + pos = pos, node = self.standing_in}) then + return true + end + end + + -- air damage + if self.air_damage ~= 0 and self.standing_in == "air" then + + self.health = self.health - self.air_damage + + effect(py, 3, "bubble.png", 1, 1, 1, 0.2) + + if self:check_for_death({type = "environment", + pos = pos, node = self.standing_in}) then + return true + end + end + + -- is mob light sensitive, or scared of the dark :P + if self.light_damage ~= 0 then + + local light + + -- if max set to 16 then only kill mob with natural sunlight + if self.light_damage_max == 16 then + light = minetest.get_natural_light(pos) or 0 + else + light = minetest.get_node_light(pos) or 0 + end + + if light >= self.light_damage_min + and light <= self.light_damage_max then + + self.health = self.health - self.light_damage + + effect(py, 5, "tnt_smoke.png") + + if self:check_for_death({type = "light"}) then + return true + end + end + end + + --- suffocation inside solid node + if (self.suffocation and self.suffocation ~= 0) + and (nodef.walkable == nil or nodef.walkable == true) + and (nodef.collision_box == nil or nodef.collision_box.type == "regular") + and (nodef.node_box == nil or nodef.node_box.type == "regular") + and (nodef.groups.disable_suffocation ~= 1) then + + local damage + + if self.suffocation == true then + damage = 2 + else + damage = (self.suffocation or 2) + end + + self.health = self.health - damage + + if self:check_for_death({type = "suffocation", + pos = pos, node = self.standing_in}) then + return true + end + + -- try to jump out of block + self.object:set_velocity({x = 0, y = self.jump_height, z = 0}) + end + + return self:check_for_death({type = "unknown"}) +end + + +-- jump if facing a solid node (not fences or gates) +function mob_class:do_jump() + + local vel = self.object:get_velocity() ; if not vel then return false end + + -- don't jump if ordered to stand or already in mid-air or moving forwards + if self.state == "stand" or vel.y ~= 0 or self:get_velocity() > 0.2 then + return false + end + + -- we can only jump if standing on solid node + if minetest.registered_nodes[self.standing_on].walkable == false then + return false + end + + -- is there anything stopping us from jumping up onto a block? + local blocked = minetest.registered_nodes[self.looking_above].walkable + + -- if mob can leap then remove blockages and let them try + if self.can_leap == true then + blocked = false + self.facing_fence = false + end + + -- jump if possible + if self.jump and self.jump_height > 0 and not self.fly and not self.child + and self.order ~= "stand" + and (self.walk_chance == 0 or minetest.registered_items[self.looking_at].walkable) + and not blocked + and not self.facing_fence + and self.looking_at ~= mobs.node_snow then + + vel.y = self.jump_height + + self:set_animation("jump") -- only if defined + + self.object:set_velocity(vel) + + -- when in air move forward + minetest.after(0.3, function(self, vel) + + if self.object:get_luaentity() then + + self.object:set_acceleration({ + x = vel.x * 2, + y = 0, + z = vel.z * 2 + }) + end + end, self, vel) + + if self:get_velocity() > 0 then + self:mob_sound(self.sounds.jump) + end + + self.jump_count = 0 + + return true + end + + -- if blocked for 3 counts then turn + if not self.following and (self.facing_fence or blocked) then + + self.jump_count = (self.jump_count or 0) + 1 + + if self.jump_count > 2 then + + local yaw = self.object:get_yaw() or 0 + local turn = random(0, 2) + 1.35 + + self:set_yaw(yaw + turn, 12) + + self.jump_count = 0 + end + end + + return false +end + + +-- blast damage to entities nearby (modified from TNT mod) +local function entity_physics(pos, radius) + + radius = radius * 2 + + local objs = minetest.get_objects_inside_radius(pos, radius) + local obj_pos, dist + + for n = 1, #objs do + + obj_pos = objs[n]:get_pos() + + dist = get_distance(pos, obj_pos) + + if dist < 1 then dist = 1 end + + local damage = floor((4 / dist) * radius) + + -- punches work on entities AND players + objs[n]:punch(objs[n], 1.0, { + full_punch_interval = 1.0, + damage_groups = {fleshy = damage} + }, pos) + end +end + + +-- can mob see player +local function is_invisible(self, player_name) + + if mobs.invis[player_name] and not self.ignore_invisibility then + return true + end +end + + +-- should mob follow what I'm holding ? +function mob_class:follow_holding(clicker) + + if is_invisible(self, clicker:get_player_name()) then + return false + end + + local item = clicker:get_wielded_item() + + -- are we holding an item mob can follow ? + if check_for(item:get_name(), self.follow) then + return true + end + + return false +end + + +-- find two animals of same type and breed if nearby and horny +function mob_class:breed() + + -- child takes a long time before growing into adult + if self.child == true then + + self.hornytimer = self.hornytimer + 1 + + if self.hornytimer > CHILD_GROW_TIME then + + self.child = false + self.hornytimer = 0 + + -- replace child texture with adult one + if self.mommy_tex then + self.base_texture = self.mommy_tex + self.mommy_tex = nil + end + + self.object:set_properties({ + textures = self.base_texture, + mesh = self.base_mesh, + visual_size = self.base_size, + collisionbox = self.base_colbox, + selectionbox = self.base_selbox + }) + + -- custom function when child grows up + if self.on_grown then + self.on_grown(self) + else + local pos = self.object:get_pos() ; if not pos then return end + local ent = self.object:get_luaentity() + + pos.y = pos.y + (ent.collisionbox[2] * -1) + + self.object:set_pos(pos) + + -- jump slightly when fully grown so as not to fall into ground + self.object:set_velocity({x = 0, y = 2, z = 0 }) + end + end + + return + end + + -- horny animal can mate for HORNY_TIME seconds, + -- afterwards horny animal cannot mate again for HORNY_AGAIN_TIME seconds + if self.horny == true + and self.hornytimer < HORNY_TIME + HORNY_AGAIN_TIME then + + self.hornytimer = self.hornytimer + 1 + + if self.hornytimer >= HORNY_TIME + HORNY_AGAIN_TIME then + self.hornytimer = 0 + self.horny = false + end + + self:update_tag() + end + + -- find another same animal who is also horny and mate if nearby + if self.horny == true + and self.hornytimer <= HORNY_TIME then + + local pos = self.object:get_pos() + + effect({x = pos.x, y = pos.y + 1, z = pos.z}, 8, "heart.png", 3, 4, 1, 0.1) + + local objs = minetest.get_objects_inside_radius(pos, 3) + local ent + + for n = 1, #objs do + + ent = objs[n]:get_luaentity() + + -- check for same animal with different colour + local canmate = false + + if ent then + + if ent.name == self.name then + canmate = true + else + local entname = ent.name:split(":") + local selfname = self.name:split(":") + + if entname[1] == selfname[1] then + + entname = entname[2]:split("_") + selfname = selfname[2]:split("_") + + if entname[1] == selfname[1] then + canmate = true + end + end + end + end + + -- found another similar horny animal that isn't self? + if ent and ent.object ~= self.object + and canmate == true + and ent.horny == true + and ent.hornytimer <= HORNY_TIME then + + local pos2 = ent.object:get_pos() + + -- Have mobs face one another + yaw_to_pos(self, pos2) + yaw_to_pos(ent, self.object:get_pos()) + + self.hornytimer = HORNY_TIME + 1 + ent.hornytimer = HORNY_TIME + 1 + + self:update_tag() + + -- have we reached active mob limit + if active_limit > 0 and active_mobs >= active_limit then + minetest.chat_send_player(self.owner, + S("Active Mob Limit Reached!") + .. " (" .. active_mobs + .. " / " .. active_limit .. ")") + return + end + + -- spawn baby + minetest.after(5, function(self, ent) + + if not self.object:get_luaentity() then + return + end + + -- reset parent movement + self.follow_stop = false + ent.follow_stop = false + + -- custom breed function + if self.on_breed then + + -- when false skip going any further + if self:on_breed(ent) == false then + return + end + else + effect(pos, 15, "tnt_smoke.png", 1, 2, 2, 15, 5) + end + + pos.y = pos.y + 0.5 -- spawn child a little higher + + local mob = minetest.add_entity(pos, self.name) + local ent2 = mob:get_luaentity() + local textures = self.base_texture + + -- make sure baby is actually there + if ent2 then + + -- using specific child texture (if found) + if self.child_texture then + textures = self.child_texture[1] + ent2.mommy_tex = self.base_texture + end + + -- and resize to half height + mob:set_properties({ + textures = textures, + visual_size = { + x = self.base_size.x * .5, + y = self.base_size.y * .5 + }, + collisionbox = { + self.base_colbox[1] * .5, + self.base_colbox[2] * .5, + self.base_colbox[3] * .5, + self.base_colbox[4] * .5, + self.base_colbox[5] * .5, + self.base_colbox[6] * .5 + }, + selectionbox = { + self.base_selbox[1] * .5, + self.base_selbox[2] * .5, + self.base_selbox[3] * .5, + self.base_selbox[4] * .5, + self.base_selbox[5] * .5, + self.base_selbox[6] * .5 + } + }) + + -- tamed and owned by parents' owner + ent2.child = true + ent2.tamed = true + ent2.owner = self.owner + ent2.base_texture = textures + end + end, self, ent) + + break + end + end + end +end + + +-- find and replace what mob is looking for (grass, wheat etc.) +function mob_class:replace(pos) + + local vel = self.object:get_velocity() + if not vel then return end + + if not mobs_griefing + or not self.replace_rate + or not self.replace_what + or self.child == true + or vel.y ~= 0 + or random(self.replace_rate) > 1 then + return + end + + local what, with, y_offset + + if type(self.replace_what[1]) == "table" then + + local num = random(#self.replace_what) + + what = self.replace_what[num][1] or "" + with = self.replace_what[num][2] or "" + y_offset = self.replace_what[num][3] or 0 + else + what = self.replace_what + with = self.replace_with or "" + y_offset = self.replace_offset or 0 + end + + pos.y = pos.y + y_offset + + if #minetest.find_nodes_in_area(pos, pos, what) > 0 then + +-- print("replace node = ".. minetest.get_node(pos).name, pos.y) + + if self.on_replace then + + local oldnode = what or "" + local newnode = with + + -- pass actual node name when using table or groups + if type(oldnode) == "table" + or oldnode:find("group:") then + oldnode = minetest.get_node(pos).name + end + + if self:on_replace(pos, oldnode, newnode) == false then + return + end + end + + minetest.set_node(pos, {name = with}) + end +end + + +-- check if daytime and also if mob is docile during daylight hours +function mob_class:day_docile() + + if self.docile_by_day == false then + return false + elseif self.docile_by_day == true + and self.time_of_day > 0.2 + and self.time_of_day < 0.8 then + return true + end +end + + +local los_switcher = false +local height_switcher = false + +-- are we able to dig this node and add drops? +local function can_dig_drop(pos) + + if minetest.is_protected(pos, "") then + return false + end + + local node = node_ok(pos, "air").name + local ndef = minetest.registered_nodes[node] + + if node ~= "ignore" + and ndef + and ndef.drawtype ~= "airlike" + and not ndef.groups.level + and not ndef.groups.unbreakable + and not ndef.groups.liquid then + + local drops = minetest.get_node_drops(node) + + for _, item in ipairs(drops) do + + minetest.add_item({ + x = pos.x - 0.5 + random(), + y = pos.y - 0.5 + random(), + z = pos.z - 0.5 + random() + }, item) + end + + minetest.remove_node(pos) + + return true + end + + return false +end + + +local pathfinder_mod = minetest.get_modpath("pathfinder") + +-- path finding and smart mob routine by rnd, +-- line_of_sight and other edits by Elkien3 +function mob_class:smart_mobs(s, p, dist, dtime) + + local s1 = self.path.lastpos + local target_pos = p + + + -- is it becoming stuck? + if abs(s1.x - s.x) + abs(s1.z - s.z) < .5 then + self.path.stuck_timer = self.path.stuck_timer + dtime + else + self.path.stuck_timer = 0 + end + + self.path.lastpos = {x = s.x, y = s.y, z = s.z} + + local use_pathfind = false + local has_lineofsight = minetest.line_of_sight( + {x = s.x, y = (s.y) + .5, z = s.z}, + {x = target_pos.x, y = (target_pos.y) + 1.5, z = target_pos.z}, .2) + + -- im stuck, search for path + if not has_lineofsight then + + if los_switcher == true then + use_pathfind = true + los_switcher = false + end -- cannot see target! + else + if los_switcher == false then + + los_switcher = true + use_pathfind = false + + minetest.after(1, function(self) + + if self.object:get_luaentity() then + + if has_lineofsight then + self.path.following = false + end + end + end, self) + end -- can see target! + end + + if self.path.stuck_timer > pathfinding_stuck_timeout and not self.path.following then + + use_pathfind = true + self.path.stuck_timer = 0 + + minetest.after(1, function(self) + + if self.object:get_luaentity() then + + if has_lineofsight then + self.path.following = false + end + end + end, self) + end + + if self.path.stuck_timer > pathfinding_stuck_path_timeout and self.path.following then + + use_pathfind = true + self.path.stuck_timer = 0 + + minetest.after(1, function(self) + + if self.object:get_luaentity() then + + if has_lineofsight then + self.path.following = false + end + end + end, self) + end + + if abs(vsubtract(s, target_pos).y) > self.initial_properties.stepheight then + + if height_switcher then + use_pathfind = true + height_switcher = false + end + else + if not height_switcher then + use_pathfind = false + height_switcher = true + end + end + + -- lets try find a path, first take care of positions + -- since pathfinder is very sensitive + if use_pathfind then + + -- round position to center of node to avoid stuck in walls + -- also adjust height for player models! + s.x = floor(s.x + 0.5) + s.z = floor(s.z + 0.5) + + local ssight, sground = minetest.line_of_sight(s, { + x = s.x, y = s.y - 4, z = s.z}, 1) + + -- determine node above ground + if not ssight then + s.y = sground.y + 1 + end + + local p1 = self.attack:get_pos() + + p1.x = floor(p1.x + 0.5) + p1.y = floor(p1.y + 0.5) + p1.z = floor(p1.z + 0.5) + + local dropheight = pathfinding_max_drop + + if self.fear_height ~= 0 then dropheight = self.fear_height end + + local jumpheight = 0 + + if self.jump and self.jump_height >= pathfinding_max_jump then + jumpheight = min(ceil( + self.jump_height / pathfinding_max_jump), pathfinding_max_jump) + + elseif self.initial_properties.stepheight > 0.5 then + jumpheight = 1 + end + + if pathfinder_mod and pathfinder_enable then + self.path.way = pathfinder.find_path(s, p1, self, dtime) + else + self.path.way = minetest.find_path(s, p1, pathfinding_searchdistance, + jumpheight, dropheight, pathfinding_algorithm) + end +--[[ + -- show path using particles + if self.path.way and #self.path.way > 0 then + + print("-- path length:" .. tonumber(#self.path.way)) + + for _,pos in pairs(self.path.way) do + + minetest.add_particle({ + pos = pos, + velocity = {x=0, y=0, z=0}, + acceleration = {x=0, y=0, z=0}, + expirationtime = 1, + size = 4, + collisiondetection = false, + vertical = false, + texture = "heart.png", + }) + end + end +]] + + self.state = "" + + if self.attack then + self:do_attack(self.attack) + end + + -- no path found, try something else + if not self.path.way then + + self.path.following = false + + -- lets make way by digging/building if not accessible + if self.pathfinding == 2 and mobs_griefing then + + -- is player more than 1 block higher than mob? + if p1.y > (s.y + 1) then + + -- build upwards + if not minetest.is_protected(s, "") then + + local ndef1 = minetest.registered_nodes[self.standing_in] + + if ndef1 and (ndef1.buildable_to or ndef1.groups.liquid) then + minetest.set_node(s, {name = mobs.fallback_node}) + end + end + + local sheight = ceil(self.collisionbox[5]) + 1 + + -- assume mob is 2 blocks high so it digs above its head + s.y = s.y + sheight + + -- remove one block above to make room to jump + can_dig_drop(s) + + s.y = s.y - sheight + self.object:set_pos({x = s.x, y = s.y + 2, z = s.z}) + + -- is player more than 1 block lower than mob + elseif p1.y < (s.y - 1) then + + -- dig down + s.y = s.y - self.collisionbox[4] - 0.2 + + can_dig_drop(s) + + else -- dig 2 blocks to make door toward player direction + + local yaw1 = self.object:get_yaw() + pi / 2 + local p1 = { + x = s.x + cos(yaw1), + y = s.y, + z = s.z + sin(yaw1) + } + + -- dig bottom node first incase of door + can_dig_drop(p1) + + p1.y = p1.y + 1 + + can_dig_drop(p1) + end + end + + -- will try again in 2 second + self.path.stuck_timer = pathfinding_stuck_timeout - 2 + + elseif s.y < p1.y and (not self.fly) then + self:do_jump() --add jump to pathfinding + self.path.following = true + else + -- yay i found path + if self.attack then + self:mob_sound(self.sounds.war_cry) + else + self:mob_sound(self.sounds.random) + end + + self:set_velocity(self.walk_velocity) + + -- follow path now that it has it + self.path.following = true + end + end +end + + +-- peaceful player privilege support +local function is_peaceful_player(player) + + -- main setting enabled + if peaceful_player_enabled then + return true + end + + local player_name = player:get_player_name() + + -- player priv enabled + if player_name + and minetest.check_player_privs(player_name, "peaceful_player") then + return true + end + + return false +end + + +-- general attack function for all mobs +function mob_class:general_attack() + + -- return if already attacking, passive or docile during day + if self.passive + or self.state == "runaway" + or self.state == "attack" + or self:day_docile() then + return + end + + local s = self.object:get_pos() ; if not s then return end + local objs = minetest.get_objects_inside_radius(s, self.view_range) + + -- remove entities we aren't interested in + for n = 1, #objs do + + local ent = objs[n]:get_luaentity() + + -- are we a player? + if is_player(objs[n]) then + + -- if player invisible or mob cannot attack then remove from list + if not damage_enabled + or self.attack_players == false + or (self.owner and self.type ~= "monster") + or is_invisible(self, objs[n]:get_player_name()) + or (self.specific_attack + and not check_for("player", self.specific_attack)) then + objs[n] = nil +--print("- pla", n) + end + + -- are we a creatura mob? + elseif creatura and ent and ent._cmi_is_mob ~= true + and ent.hitbox and ent.stand_node then + + -- monsters attack all creatura mobs, npc and animals will only attack + -- if the animal owner is currently being attacked by creatura mob + if self.name == ent.name + or (self.type ~= "monster" + and self.owner ~= (ent._target and ent._target:get_player_name() or ".")) + or (self.specific_attack + and not check_for(ent.name, self.specific_attack)) then + + objs[n] = nil +--print("-- creatura", ent.name) + end + + -- or are we a mob? + elseif ent and ent._cmi_is_mob then + + -- remove mobs not to attack + if self.name == ent.name + or (not self.attack_animals and ent.type == "animal") + or (not self.attack_monsters and ent.type == "monster") + or (not self.attack_npcs and ent.type == "npc") + or (self.specific_attack + and not check_for(ent.name, self.specific_attack)) then + objs[n] = nil +--print("- mob", n, self.name, ent.name) + end + + -- remove all other entities + else +--print(" -obj", n) + objs[n] = nil + end + end + + local p, sp, dist, min_player + local min_dist = self.view_range + 1 + + -- go through remaining entities and select closest + for _,player in pairs(objs) do + + p = player:get_pos() + sp = s + + dist = get_distance(p, s) + + -- aim higher to make looking up hills more realistic + p.y = p.y + 1 + sp.y = sp.y + 1 + + -- choose closest player to attack that isnt self + if dist ~= 0 + and dist < min_dist + and self:line_of_sight(sp, p, 2) == true + and not is_peaceful_player(player) then + min_dist = dist + min_player = player + end + end + + -- attack closest player or mob + if min_player and random(100) > self.attack_chance then + self:do_attack(min_player) + end +end + + +-- find someone to runaway from +function mob_class:do_runaway_from() + + if not self.runaway_from then + return + end + + local s = self.object:get_pos() ; if not s then return end + local p, sp, dist, pname + local player, obj, min_player, name + local min_dist = self.view_range + 1 + local objs = minetest.get_objects_inside_radius(s, self.view_range) + + -- loop through entities surrounding mob + for n = 1, #objs do + + if is_player(objs[n]) then + + pname = objs[n]:get_player_name() + + if is_invisible(self, pname) + or self.owner == pname then + + name = "" + else + player = objs[n] + name = "player" + end + else + obj = objs[n]:get_luaentity() + + if obj then + player = obj.object + name = obj.name or "" + end + end + + -- find specific mob to runaway from + if name ~= "" and name ~= self.name + and (self.runaway_from and check_for(name, self.runaway_from)) then + + sp = s + p = player and player:get_pos() or s + + -- aim higher to make looking up hills more realistic + p.y = p.y + 1 + sp.y = sp.y + 1 + + dist = get_distance(p, s) + + -- choose closest player/mob to runaway from + if dist < min_dist and self:line_of_sight(sp, p, 2) == true then + min_dist = dist + min_player = player + end + end + end + + if min_player then + + yaw_to_pos(self, min_player:get_pos(), 3) + + self.state = "runaway" + self.runaway_timer = 3 + self.following = nil + + return + end + + -- check for nodes to runaway from + objs = minetest.find_node_near(s, self.view_range, self.runaway_from, true) + + if objs then + + yaw_to_pos(self, objs, 3) + + self.state = "runaway" + self.runaway_timer = 3 + self.following = nil + end +end + + +-- follow player if owner or holding item, if fish outta water then flop +function mob_class:follow_flop() + + -- find player to follow + if (self.follow ~= "" or self.order == "follow") + and not self.following + and self.state ~= "attack" + and self.state ~= "runaway" then + + local s = self.object:get_pos() ; if not s then return end + local players = minetest.get_connected_players() + + for n = 1, #players do + + if players[n] + and not is_invisible(self, players[n]:get_player_name()) + and get_distance(players[n]:get_pos(), s) < self.view_range then + + self.following = players[n] + + break + end + end + end + + if self.type == "npc" + and self.order == "follow" + and self.state ~= "attack" + and self.owner ~= "" then + + -- npc stop following player if not owner + if self.following + and self.owner and self.owner ~= self.following:get_player_name() then + self.following = nil + end + else + -- stop following player if not holding specific item or mob is horny + if self.following and is_player(self.following) + and (self:follow_holding(self.following) == false or self.horny) then + self.following = nil + end + + end + + -- follow that thing + if self.following then + + local s = self.object:get_pos() + local p + + if is_player(self.following) then + p = self.following:get_pos() + elseif self.following.object then + p = self.following.object:get_pos() + end + + if p then + + local dist = get_distance(p, s) + + -- dont follow if out of range + if dist > self.view_range then + self.following = nil + else + yaw_to_pos(self, p) + + -- anyone but standing npc's can move along + if dist >= self.reach + and self.order ~= "stand" then + + self:set_velocity(self.walk_velocity) + self.follow_stop = nil + + if self.walk_chance ~= 0 then + self:set_animation("walk") + end + else + self:set_velocity(0) + self:set_animation("stand") + self.follow_stop = true + end + + return + end + end + end + + -- swimmers flop when out of their element, and swim again when back in + if self.fly then + + if not self:attempt_flight_correction() then + + self.state = "flop" + + -- do we have a custom on_flop function? + if self.on_flop then + + if self:on_flop(self) then + return + end + end + + self.object:set_velocity({x = 0, y = -5, z = 0}) + + self:set_animation("stand") + + return + + elseif self.state == "flop" then + self.state = "stand" + end + end +end + + +-- dogshoot attack switch and counter function +function mob_class:dogswitch(dtime) + + -- switch mode not activated + if not self.dogshoot_switch or not dtime then + return 0 + end + + self.dogshoot_count = self.dogshoot_count + dtime + + if (self.dogshoot_switch == 1 and self.dogshoot_count > self.dogshoot_count_max) + or (self.dogshoot_switch == 2 and self.dogshoot_count > self.dogshoot_count2_max) then + + self.dogshoot_count = 0 + + if self.dogshoot_switch == 1 then + self.dogshoot_switch = 2 + else + self.dogshoot_switch = 1 + end + end + + return self.dogshoot_switch +end + + +-- execute current state (stand, walk, run, attacks) +function mob_class:do_states(dtime) + + local yaw = self.object:get_yaw() ; if not yaw then return end + + -- are we standing in something that hurts ? Try to get out + if is_node_dangerous(self, self.standing_in) then + + local s = self.object:get_pos() + local grps = {} + + if self.water_damage > 0 then table.insert(grps, "group:water") end + if self.fire_damage > 0 then table.insert(grps, "group:fire") end + if self.lava_damage > 0 then table.insert(grps, "group:lava") end + + local lp = minetest.find_node_near(s, 1, grps) + + if lp then + + if self.pause_timer <= 0 then + + lp = minetest.find_nodes_in_area_under_air( + {x = s.x - 5, y = s.y , z = s.z - 5}, + {x = s.x + 5, y = s.y + 2, z = s.z + 5}, + {"group:cracky", "group:crumbly", "group:choppy", "group:solid"}) + + -- did we find land? + if lp and #lp > 0 then + + -- select position of random block to climb onto + lp = lp[random(#lp)] + + yaw = yaw_to_pos(self, lp) + end + + self.pause_timer = 3 + self.following = nil + + self:set_velocity(self.run_velocity) + self:set_animation("walk") + + return + end + end + end + + if self.state == "stand" and not self.follow_stop then + + if self.randomly_turn and random(4) == 1 then + + local lp + local s = self.object:get_pos() + local objs = minetest.get_objects_inside_radius(s, 3) + + for n = 1, #objs do + + if is_player(objs[n]) then + lp = objs[n]:get_pos() + break + end + end + + -- look at any players nearby, otherwise turn randomly + if lp then + yaw = yaw_to_pos(self, lp) + else + yaw = yaw + random(-0.5, 0.5) + end + + self:set_yaw(yaw, 8) + end + + self:set_velocity(0) + self:set_animation("stand") + + -- mobs ordered to stand stay standing + if self.order ~= "stand" + and self.walk_chance ~= 0 + and self.facing_fence ~= true + and random(100) <= self.walk_chance + and self.at_cliff == false then + + self:set_velocity(self.walk_velocity) + self.state = "walk" + self:set_animation("walk") + end + + elseif self.state == "walk" then + + if self.randomly_turn and random(100) <= 30 then + + yaw = yaw + random(-0.5, 0.5) + + self:set_yaw(yaw, 8) + + -- for flying/swimming mobs randomly move up and down also + if self.fly_in and not self.following then + self:attempt_flight_correction(true) + end + end + + -- stand for great fall in front + if self.facing_fence == true + or self.at_cliff + or random(100) <= self.stand_chance then + + -- don't stand if mob flies and keep_flying set + if (self.fly and not self.keep_flying) or not self.fly then + + self:set_velocity(0) + self.state = "stand" + self:set_animation("stand", true) + end + else + self:set_velocity(self.walk_velocity) + + -- figure out which animation to use while in motion + if self:flight_check() + and self.animation + and self.animation.fly_start + and self.animation.fly_end then + + local on_ground = minetest.registered_nodes[self.standing_on].walkable + local in_water = minetest.registered_nodes[self.standing_in].groups.water + + if on_ground and in_water then + self:set_animation("fly") + elseif on_ground then + self:set_animation("walk") + else + self:set_animation("fly") + end + else + self:set_animation("walk") + end + end + + -- runaway when punched + elseif self.state == "runaway" then + + self.runaway_timer = self.runaway_timer + 1 + + -- stop after 5 seconds or when at cliff + if self.runaway_timer > 5 + or self.at_cliff + or self.order == "stand" then + self.runaway_timer = 0 + self:set_velocity(0) + self.state = "stand" + self:set_animation("stand") + else + self:set_velocity(self.run_velocity) + self:set_animation("walk") + end + + -- attack routines (explode, dogfight, shoot, dogshoot) + elseif self.state == "attack" then + + -- get mob and enemy positions and distance between + local s = self.object:get_pos() + local p = self.attack and self.attack:get_pos() + local dist = p and get_distance(p, s) or 500 + + -- stop attacking if player out of range or invisible + if dist > self.view_range + or not self.attack + or not self.attack:get_pos() + or self.attack:get_hp() <= 0 + or (is_player(self.attack) + and is_invisible(self, self.attack:get_player_name())) then + +--print(" ** stop attacking **", self.name, self.health, dist, self.view_range) + + self.attack = nil + self.following = nil + self.v_start = false + self.timer = 0 + self.blinktimer = 0 + self.path.way = nil + self:set_velocity(0) + self.state = "stand" + self:set_animation("stand", true) + + return + end + + if self.attack_type == "explode" then + + yaw_to_pos(self, p) + + local node_break_radius = self.explosion_radius or 1 + local entity_damage_radius = self.explosion_damage_radius + or (node_break_radius * 2) + + -- look a little higher to fix raycast + s.y = s.y + 0.5 ; p.y = p.y + 0.5 + + -- start timer when in reach and line of sight + if not self.v_start + and dist <= self.reach + and self:line_of_sight(s, p, 2) then + + self.v_start = true + self.timer = 0 + self.blinktimer = 0 + self:mob_sound(self.sounds.fuse) + +--print("=== explosion timer started", self.explosion_timer) + + -- stop timer if out of reach or direct line of sight + elseif self.allow_fuse_reset + and self.v_start + and (dist > self.reach or not self:line_of_sight(s, p, 2)) then + +--print("=== explosion timer stopped") + + self.v_start = false + self.timer = 0 + self.blinktimer = 0 + self.blinkstatus = false + self.object:set_texture_mod("") + end + + -- walk right up to player unless the timer is active + if self.v_start and (self.stop_to_explode or dist < 1.5) then + self:set_velocity(0) + else + self:set_velocity(self.run_velocity) + end + + if self.animation and self.animation.run_start then + self:set_animation("run") + else + self:set_animation("walk") + end + + if self.v_start then + + self.timer = self.timer + dtime + self.blinktimer = (self.blinktimer or 0) + dtime + + if self.blinktimer > 0.2 then + + self.blinktimer = 0 + + if self.blinkstatus then + + self.object:set_texture_mod(self.texture_mods) + else + + self.object:set_texture_mod(self.texture_mods .. "^[brighten") + end + + self.blinkstatus = not self.blinkstatus + end + +--print("=== explosion timer", self.timer) + + if self.timer > self.explosion_timer then + + local pos = self.object:get_pos() + + -- dont damage anything if area protected or next to waterpathfinding_max_jump + if minetest.find_node_near(pos, 1, {"group:water"}) + or minetest.is_protected(pos, "") then + + node_break_radius = 1 + end + + remove_mob(self, true) + + mobs:boom(self, pos, entity_damage_radius, node_break_radius) + + return true + end + end + + elseif self.attack_type == "dogfight" + or (self.attack_type == "dogshoot" and self:dogswitch(dtime) == 2) + or (self.attack_type == "dogshoot" and dist <= self.reach + and self:dogswitch() == 0) then + + if self.fly + and dist > self.reach then + + local p1 = s + local me_y = floor(p1.y) + local p2 = p + local p_y = floor(p2.y + 1) + local v = self.object:get_velocity() + + if self:flight_check() then + + if me_y < p_y then + + self.object:set_velocity({ + x = v.x, y = 1 * self.walk_velocity, z = v.z}) + + elseif me_y > p_y then + + self.object:set_velocity({ + x = v.x, y = -1 * self.walk_velocity, z = v.z}) + end + else + if me_y < p_y then + + self.object:set_velocity({x = v.x, y = 0.01, z = v.z}) + + elseif me_y > p_y then + + self.object:set_velocity({x = v.x, y = -0.01, z = v.z}) + end + end + end + + -- rnd: new movement direction + if self.path.following + and self.path.way + and self.attack_type ~= "dogshoot" then + + -- no paths longer than 50 + if #self.path.way > 50 or dist < self.reach then + self.path.following = false + return + end + + local p1 = self.path.way[1] + + if not p1 then + self.path.following = false + return + end + + if abs(p1.x - s.x) + abs(p1.z - s.z) < 0.6 then + -- reached waypoint, remove it from queue + table_remove(self.path.way, 1) + end + + -- set new temporary target + p = {x = p1.x, y = p1.y, z = p1.z} + end + + yaw_to_pos(self, p) + + -- move towards enemy if beyond mob reach + if dist > (self.reach + (self.reach_ext or 0)) then + + -- path finding by rnd (only when enabled in setting and mob) + if self.pathfinding and pathfinding_enable then + self:smart_mobs(s, p, dist, dtime) + end + + -- distance padding to stop spinning mob + local pad = abs(p.x - s.x) + abs(p.z - s.z) + + self.reach_ext = 0 -- extended ready off by default + + if self.at_cliff or pad < 0.2 then + + -- when on top of player extend reach slightly so player can + -- still be attacked. + self.reach_ext = 0.8 + self:set_velocity(0) + self:set_animation("stand") + else + + if self.path.stuck then + self:set_velocity(self.walk_velocity) + else + self:set_velocity(self.run_velocity) + end + + if self.animation and self.animation.run_start then + self:set_animation("run") + else + self:set_animation("walk") + end + end + else -- rnd: if inside reach range + + self.path.stuck = false + self.path.stuck_timer = 0 + self.path.following = false -- not stuck anymore + + self:set_velocity(0) + + if self.timer > 1 then + + -- no custom attack or custom attack returns true to continue + if not self.custom_attack + or self:custom_attack(self, p) == true then + + self.timer = 0 + self:set_animation("punch") + + local p2 = p + local s2 = s + + p2.y = p2.y + .5 + s2.y = s2.y + .5 + + if self:line_of_sight(p2, s2) == true then + + -- play attack sound + self:mob_sound(self.sounds.attack) + + -- punch player (or what player is attached to) + local attached = self.attack:get_attach() + + if attached then + self.attack = attached + end + + local dgroup = self.damage_group or "fleshy" + + self.attack:punch(self.object, 1.0, { + full_punch_interval = 1.0, + damage_groups = {[dgroup] = self.damage} + }, nil) + end + end + end + end + + elseif self.attack_type == "shoot" + or (self.attack_type == "dogshoot" and self:dogswitch(dtime) == 1) + or (self.attack_type == "dogshoot" and dist > self.reach and + self:dogswitch() == 0) then + + p.y = p.y - .5 + s.y = s.y + .5 + + local vec = {x = p.x - s.x, y = p.y - s.y, z = p.z - s.z} + + yaw_to_pos(self, p) + + self:set_velocity(0) + + if self.shoot_interval and self.timer > self.shoot_interval + and random(100) <= 60 then + + self.timer = 0 + self:set_animation("shoot") + + -- play shoot attack sound + self:mob_sound(self.sounds.shoot_attack) + + local p = self.object:get_pos() + + p.y = p.y + (self.collisionbox[2] + self.collisionbox[5]) / 2 + + if minetest.registered_entities[self.arrow] then + + local obj = minetest.add_entity(p, self.arrow) + local ent = obj:get_luaentity() + local amount = (vec.x * vec.x + vec.y * vec.y + vec.z * vec.z) ^ 0.5 + + -- check for custom override for arrow + if self.arrow_override then + self.arrow_override(ent) + end + + local v = ent.velocity or 1 -- or set to default + + ent.switch = 1 + ent.owner_id = tostring(self.object) -- add unique owner id to arrow + + -- offset makes shoot aim accurate + vec.y = vec.y + self.shoot_offset + vec.x = vec.x * (v / amount) + vec.y = vec.y * (v / amount) + vec.z = vec.z * (v / amount) + + obj:set_velocity(vec) + end + end + end + end +end + + +-- falling and fall damage +function mob_class:falling(pos) + + if self.fly or self.disable_falling then + return + end + + -- floating in water (or falling) + local v = self.object:get_velocity() + + -- sanity check + if not v then return end + + local fall_speed = self.fall_speed + + -- in water then use liquid viscosity for float/sink speed + if self.floats == 1 and self.standing_in + and minetest.registered_nodes[self.standing_in].groups.liquid then + + local visc = min( + minetest.registered_nodes[self.standing_in].liquid_viscosity, 7) + 1 + + self.object:set_velocity({x = v.x, y = 0.6, z = v.z}) + fall_speed = -1.2 / visc + else + + -- fall damage onto solid ground + if self.fall_damage == 1 + and self.object:get_velocity().y == 0 then + + local d = (self.old_y or 0) - self.object:get_pos().y + + if d > 5 then + + self.health = self.health - floor(d - 5) + + effect(pos, 5, "tnt_smoke.png", 1, 2, 2, nil) + + if self:check_for_death({type = "fall"}) then + return true + end + end + + self.old_y = self.object:get_pos().y + end + end + + -- fall at set speed + self.object:set_acceleration({x = 0, y = fall_speed, z = 0}) +end + + +-- is Took Ranks mod active? +local tr = minetest.get_modpath("toolranks") + +-- deal damage and effects when mob punched +function mob_class:on_punch(hitter, tflp, tool_capabilities, dir, damage) + + -- mob health check + if self.health <= 0 then + return true + end + + -- custom punch function (if false returned, do not continue and return true) + if self.do_punch and self:do_punch(hitter, tflp, tool_capabilities, dir) == false then + return true + end + + -- error checking when mod profiling is enabled + if not tool_capabilities then + minetest.log("warning", "[mobs] Mod profiling enabled, damage not enabled") + return true + end + + -- is mob protected + if self.protected then + + -- did player hit mob and if so is it in protected area + if is_player(hitter) then + + local player_name = hitter:get_player_name() + + if player_name ~= self.owner + and minetest.is_protected(self.object:get_pos(), player_name) then + + minetest.chat_send_player(hitter:get_player_name(), + S("Mob has been protected!")) + + return true + end + + -- if protection is on level 2 then dont let arrows harm mobs + elseif self.protected == 2 then + + local ent = hitter and hitter:get_luaentity() + + if ent and ent._is_arrow then + return true -- arrow entity + elseif not ent then + return true -- non entity + end + end + end + + local weapon = hitter:get_wielded_item() + local weapon_def = weapon:get_definition() or {} + + -- calculate mob damage + local damage = 0 + local armor = self.object:get_armor_groups() or {} + local tmp + + -- quick error check incase it ends up 0 (serialize.h check test) + if tflp == 0 then + tflp = 0.2 + end + + if use_cmi then + damage = cmi.calculate_damage(self.object, hitter, tflp, tool_capabilities, dir) + else + + for group,_ in pairs( (tool_capabilities.damage_groups or {}) ) do + + tmp = tflp / (tool_capabilities.full_punch_interval or 1.4) + + if tmp < 0 then + tmp = 0.0 + elseif tmp > 1 then + tmp = 1.0 + end + + damage = damage + (tool_capabilities.damage_groups[group] or 0) + * tmp * ((armor[group] or 0) / 100.0) + end + end + + -- check if hit by player item or entity + local hit_item = weapon_def.name + + if not is_player(hitter) then + hit_item = hitter:get_luaentity().name + end + + -- check for tool immunity or special damage + for n = 1, #self.immune_to do + + if self.immune_to[n][1] == hit_item then + + damage = self.immune_to[n][2] or 0 + + break + + -- if "all" then no tools deal damage unless it's specified in list + elseif self.immune_to[n][1] == "all" then + damage = self.immune_to[n][2] or 0 + end + end + +--print("Mob Damage is", damage) + + -- healing + if damage <= -1 then + + self.health = self.health - floor(damage) + + return true + end + + if use_cmi + and cmi.notify_punch(self.object, hitter, tflp, tool_capabilities, dir, damage) then + return true + end + + -- add weapon wear + local punch_interval = tool_capabilities.full_punch_interval or 1.4 + + -- toolrank support + local wear = floor((punch_interval / 75) * 9000) + + if mobs.is_creative(hitter:get_player_name()) then + wear = tr and 1 or 0 + end + + if tr and weapon_def.original_description then + toolranks.new_afteruse(weapon, hitter, nil, {wear = wear}) + else + weapon:add_wear(wear) + end + + hitter:set_wielded_item(weapon) + + -- only play hit sound and show blood effects if damage is 1 or over + if damage >= 1 then + + -- select tool use sound if found, or fallback to default + local snd = weapon_def.sound and weapon_def.sound.use or "mobs_punch" + + minetest.sound_play(snd, {object = self.object, max_hear_distance = 8}, true) + + -- blood_particles + if not disable_blood and self.blood_amount > 0 then + + local pos = self.object:get_pos() + local blood = self.blood_texture + local amount = self.blood_amount + + pos.y = pos.y + (-self.collisionbox[2] + self.collisionbox[5]) * .5 + + -- lots of damage = more blood :) + if damage > 10 then + amount = self.blood_amount * 2 + end + + -- do we have a single blood texture or multiple? + if type(self.blood_texture) == "table" then + blood = self.blood_texture[random(#self.blood_texture)] + end + + effect(pos, amount, blood, 1, 2, 1.75, nil, nil, true) + end + + -- add healthy afterglow when hit (can cause lag with larger textures) + if mob_hit_effect then + + local _dtm = self.initial_properties.damage_texture_modifier + + self.old_texture_mods = self.texture_mods + + self.object:set_texture_mod(self.texture_mods .. _dtm) + + minetest.after(0.3, function() + + if self and self.object and self.object:get_pos() then + + self.texture_mods = self.old_texture_mods + self.old_texture_mods = nil + self.object:set_texture_mod(self.texture_mods) + end + end) + end + + -- check for friendly fire (arrows from same mob) + if self.friendly_fire then + self.health = self.health - floor(damage) -- do damage regardless + else + local entity = hitter and hitter:get_luaentity() + + -- check if arrow from same mob, if so then do no damage + if (entity and entity.name ~= self.arrow) or is_player(hitter) then + self.health = self.health - floor(damage) + end + end + + -- exit here if dead, check for tools with fire damage + local hot = tool_capabilities and tool_capabilities.damage_groups + and tool_capabilities.damage_groups.fire + + if self:check_for_death({type = "punch", puncher = hitter, hot = hot}) then + return true + end + end + + -- knock back effect (only on full punch) + if self.knock_back and tflp >= punch_interval then + + local v = self.object:get_velocity() + + -- sanity check + if not v then return true end + + local kb = damage or 1 + local up = 2 + + -- if already in air then dont go up anymore when hit + if v.y > 0 or self.fly then + up = 0 + end + + -- direction error check + dir = dir or {x = 0, y = 0, z = 0} + + -- use tool knockback value or default + kb = tool_capabilities.damage_groups["knockback"] or kb + + self.object:set_velocity({x = dir.x * kb, y = up, z = dir.z * kb}) + + -- turn mob on knockback and play run/walk animation + self:set_yaw((random(0, 360) - 180) / 180 * pi, 12) + + if self.animation and self.animation.injured_end and damage >= 1 then + self:set_animation("injured") + else + self:set_animation("walk") + end + + self.pause_timer = 0.25 + end + + -- if skittish then run away + if self.runaway == true and self.order ~= "stand" then + + local lp = hitter:get_pos() + + yaw_to_pos(self, lp, 3) + + self.state = "runaway" + self.runaway_timer = 0 + self.following = nil + end + + local hitter_name = hitter:get_player_name() or "" + + -- attack puncher and call other mobs for help + if self.passive == false + and self.state ~= "flop" + and self.child == false + and self.attack_players == true + and not (is_player(hitter) and hitter_name == self.owner) + and not is_invisible(self, hitter_name) + and self.object ~= hitter then + + -- attack whoever punched mob + self.state = "" + self:do_attack(hitter) + + -- alert others to the attack + local objs = minetest.get_objects_inside_radius(hitter:get_pos(), self.view_range) + local ent + + for n = 1, #objs do + + ent = objs[n] and objs[n]:get_luaentity() + + if ent and ent._cmi_is_mob then + + -- only alert members of same mob and assigned helper + if ent.group_attack == true + and ent.state ~= "attack" + and not (is_player(hitter) and ent.owner == hitter_name) + and (ent.name == self.name or ent.name == self.group_helper) then + ent:do_attack(hitter) + end + + -- have owned mobs attack player threat + if is_player(hitter) and ent.owner == hitter_name and ent.owner_loyal then + ent:do_attack(self.object) + end + end + end + end + + return true +end + + +-- helper function to clean mob staticdata +local function clean_staticdata(self) + + local tmp, t = {} + + for _,stat in pairs(self) do + + t = type(stat) + + if t ~= "function" + and t ~= "nil" + and t ~= "userdata" + and _ ~= "object" + and _ ~= "_cmi_components" then + tmp[_] = self[_] + end + end + + return tmp +end + + +-- get entity staticdata +function mob_class:mob_staticdata() + + -- this handles mob count for mobs activated, unloaded, reloaded + if active_limit > 0 and self.active_toggle then + active_mobs = active_mobs + self.active_toggle + self.active_toggle = -self.active_toggle +--print("-- staticdata", active_mobs, active_limit, self.active_toggle) + end + + -- remove mob when out of range unless tamed + if remove_far + and self.remove_ok + and self.type ~= "npc" + and self.state ~= "attack" + and not self.tamed + and self.lifetimer < 20000 then + +--print("REMOVED " .. self.name) + + remove_mob(self, true) + + return minetest.serialize({remove_ok = true, static_save = true}) + end + + self.remove_ok = true + self.attack = nil + self.following = nil + self.state = "stand" + + -- used to rotate older mobs + if self.drawtype and self.drawtype == "side" then + self.rotate = rad(90) + end + + if use_cmi then + self.serialized_cmi_components = cmi.serialize_components(self._cmi_components) + end + + return minetest.serialize(clean_staticdata(self)) +end + + +-- activate mob and reload settings +function mob_class:mob_activate(staticdata, def, dtime) + + -- if dtime == 0 then entity has just been created + -- anything higher means it is respawning (thanks SorceryKid) + if dtime == 0 and active_limit > 0 then + self.active_toggle = 1 + end + + -- remove mob if not tamed and mob total reached + if active_limit > 0 and active_mobs >= active_limit and not self.tamed then + + remove_mob(self) +--print("-- mob limit reached, removing " .. self.name) + return + end + + -- remove monsters in peaceful mode + if self.type == "monster" and peaceful_only then + + remove_mob(self, true) + + return + end + + -- load entity variables from staticdata into self. + local tmp = minetest.deserialize(staticdata) + + if tmp then + + local t + + for _,stat in pairs(tmp) do + + t = type(stat) + + if t ~= "function" and t ~= "nil" and t ~= "userdata" then + self[_] = stat + end + end + end + + -- force current model into mob + self.mesh = def.mesh + self.base_mesh = def.mesh + self.collisionbox = def.collisionbox + self.selectionbox = def.selectionbox + + -- select random texture, set model and size + if not self.base_texture then + + -- compatiblity with old simple mobs textures + if def.textures and type(def.textures[1]) == "string" then + def.textures = {def.textures} + end + + self.base_texture = def.textures + and def.textures[random(#def.textures)] + self.base_mesh = def.mesh + self.base_size = self.initial_properties.visual_size + self.base_colbox = self.initial_properties.collisionbox + self.base_selbox = self.initial_properties.selectionbox + end + + -- for current mobs that dont have this set + if not self.base_selbox then + self.base_selbox = self.selectionbox or self.base_colbox + end + + -- set texture, model and size + local textures = self.base_texture + local mesh = self.base_mesh + local vis_size = self.base_size + local colbox = self.base_colbox + local selbox = self.base_selbox + + -- specific texture if gotten + if self.gotten == true and def.gotten_texture then + textures = def.gotten_texture + end + + -- specific mesh if gotten + if self.gotten == true and def.gotten_mesh then + mesh = def.gotten_mesh + end + + -- set child objects to half size + if self.child == true then + + vis_size = {x = self.base_size.x * .5, y = self.base_size.y * .5} + + if def.child_texture then + textures = def.child_texture[1] + end + + colbox = { + self.base_colbox[1] * .5, self.base_colbox[2] * .5, + self.base_colbox[3] * .5, self.base_colbox[4] * .5, + self.base_colbox[5] * .5, self.base_colbox[6] * .5} + + selbox = { + self.base_selbox[1] * .5, self.base_selbox[2] * .5, + self.base_selbox[3] * .5, self.base_selbox[4] * .5, + self.base_selbox[5] * .5, self.base_selbox[6] * .5} + end + + if self.health == 0 then + self.health = random(self.hp_min, self.initial_properties.hp_max) + end + + -- pathfinding init + self.path = {} + self.path.way = {} -- path to follow, table of positions + self.path.lastpos = {x = 0, y = 0, z = 0} + self.path.stuck = false + self.path.following = false -- currently following path? + self.path.stuck_timer = 0 -- if stuck for too long search for path + + -- Armor groups (immortal = 1 for custom damage handling) + local armor + if type(self.armor) == "table" then + armor = table_copy(self.armor) + else + armor = {fleshy = self.armor, immortal = 1} + end + self.object:set_armor_groups(armor) + + -- mob defaults + self.old_y = self.object:get_pos().y + self.old_health = self.health + self.sounds.distance = self.sounds.distance or 10 + self.textures = textures + self.mesh = mesh + self.collisionbox = colbox + self.selectionbox = selbox + self.visual_size = vis_size + self.standing_in = "air" + self.standing_on = "air" + + -- check for existing nametag + self.nametag = self.initial_properties.nametag or def.nametag + + -- set anything changed above + self.object:set_properties(self) + self:set_yaw((random(0, 360) - 180) / 180 * pi, 6) + self:update_tag() + self:set_animation("stand") + + -- apply any texture mods + self.object:set_texture_mod(self.texture_mods) + + -- set 5.x flag to remove monsters when map area unloaded + if remove_far and self.type == "monster" and not self.tamed then + self.static_save = false + end + + -- run on_spawn function if found + if self.on_spawn and not self.on_spawn_run and self.on_spawn(self) then + self.on_spawn_run = true -- if true, set flag to run once only + end + + -- run after_activate + if def.after_activate then + def.after_activate(self, staticdata, def, dtime) + end + + if use_cmi then + self._cmi_components = cmi.activate_components(self.serialized_cmi_components) + cmi.notify_activate(self.object, dtime) + end +end + + +-- handle mob lifetimer and expiration +function mob_class:mob_expire(pos, dtime) + + -- when lifetimer expires remove mob (except npc and tamed) + if self.type ~= "npc" + and not self.tamed + and self.state ~= "attack" + and remove_far ~= true + and self.lifetimer < 20000 then + + self.lifetimer = self.lifetimer - dtime + + if self.lifetimer <= 0 then + + -- only despawn away from player + local objs = minetest.get_objects_inside_radius(pos, 15) + + for n = 1, #objs do + + if is_player(objs[n]) then + + self.lifetimer = 20 + + return + end + end + +-- minetest.log("action", "lifetimer expired, removed " .. self.name) + + effect(pos, 15, "tnt_smoke.png", 2, 4, 2, 0) + + remove_mob(self, true) + + return + end + end +end + + +-- get nodes mob is standing on/in, facing/above +function mob_class:get_nodes() + + local pos = self.object:get_pos() + local yaw = self.object:get_yaw() + + -- child mobs have a lower y_level + local y_level = self.child and self.collisionbox[2] * 0.5 or self.collisionbox[2] + + self.standing_in = node_ok({ + x = pos.x, y = pos.y + y_level + 0.25, z = pos.z}, "air").name + + self.standing_on = node_ok({ + x = pos.x, y = pos.y + y_level - 0.25, z = pos.z}, "air").name + + -- find front position + local dir_x = -sin(yaw) * (self.collisionbox[4] + 0.5) + local dir_z = cos(yaw) * (self.collisionbox[4] + 0.5) + + -- nodes in front of mob and front/above + self.looking_at = node_ok({ + x = pos.x + dir_x, y = pos.y + y_level + 0.25, z = pos.z + dir_z}).name + + self.looking_above = node_ok({ + x = pos.x + dir_x, y = pos.y + y_level + 1.25, z = pos.z + dir_z}).name + + -- are we facing a fence or wall + if self.looking_at:find("fence") + or self.looking_at:find("gate") + or self.looking_at:find("wall") then + self.facing_fence = true + else + self.facing_fence = nil + end +--[[ +print("on: " .. self.standing_on + .. ", front: " .. self.looking_at + .. ", front above: " .. self.looking_above + .. ", fence: " .. (self.facing_fence and "yes" or "no") +) +]] +end + + +-- main mob function +function mob_class:on_step(dtime, moveresult) + + if self.state == "die" then return end + + if use_cmi then + cmi.notify_step(self.object, dtime) + end + + local pos = self.object:get_pos() + local yaw = self.object:get_yaw() + + -- early warning check, if no yaw then no entity, skip rest of function + if not yaw then return end + + self.node_timer = (self.node_timer or 0) + dtime + + -- get nodes every 1/4 second + if self.node_timer > node_timer_interval then + + -- get nodes above, below, in front and front-above + self:get_nodes() + + self.node_timer = 0 + + -- check and stop if standing at cliff and fear of heights + self.at_cliff = self:is_at_cliff() + + if self.pause_timer <= 0 and self.at_cliff then + self:set_velocity(0) + end + + -- has mob expired (0.25 instead of dtime since were in a timer) + self:mob_expire(pos, node_timer_interval) + + -- check if mob can jump or is blocked facing fence/gate etc. + self:do_jump() + end + + -- check if falling, flying, floating and return if player died + if self:falling(pos) then + return + end + + -- smooth rotation by ThomasMonroe314 + if self.delay and self.delay > 0 then + + if self.delay == 1 then + yaw = self.target_yaw + else + local dif = abs(yaw - self.target_yaw) + + if yaw > self.target_yaw then + + if dif > pi then + dif = 2 * pi - dif + yaw = yaw + dif / self.delay -- need to add + else + yaw = yaw - dif / self.delay -- need to subtract + end + + elseif yaw < self.target_yaw then + + if dif > pi then + dif = 2 * pi - dif + yaw = yaw - dif / self.delay -- need to subtract + else + yaw = yaw + dif / self.delay -- need to add + end + end + + if yaw > (pi * 2) then yaw = yaw - (pi * 2) end + if yaw < 0 then yaw = yaw + (pi * 2) end + end + + self.delay = self.delay - 1 + self.object:set_yaw(yaw) + end + + -- environmental damage timer (every 1 second) + self.env_damage_timer = self.env_damage_timer + dtime + + if self.env_damage_timer > 1 then + + self.env_damage_timer = 0 + + -- check for environmental damage (water, fire, lava etc.) + if self:do_env_damage() then return end + + -- node replace check (cow eats grass etc.) + self:replace(pos) + end + + -- knockback timer + if self.pause_timer > 0 then + + self.pause_timer = self.pause_timer - dtime + + if self.pause_timer <= 0 and self.order == "stand" then + + self.pause_timer = 0 + self:set_velocity(0) + self:set_animation("stand", true) + end + + return + end + + -- run custom function (defined in mob lua file) - when false skip going any further + if self.do_custom and self:do_custom(dtime, moveresult) == false then + return + end + + -- attack timer + self.timer = self.timer + dtime + + -- never go over 100 + if self.timer > 100 then + self.timer = 1 + end + + -- when attacking call do_states live (return if dead) + if self.state == "attack" then + if self:do_states(dtime) then return end + end + + -- one second timed calls + self.timer1 = (self.timer1 or 0) + dtime + + if self.timer1 >= main_timer_interval then + + -- mob plays random sound at times + if random(100) == 1 then + self:mob_sound(self.sounds.random) + end + + self:general_attack() + + self:breed() + + self:follow_flop() + + -- when not attacking call do_states every second (return if dead) + if self.state ~= "attack" then + if self:do_states(main_timer_interval) then return end + end + + self:do_runaway_from(self) + + self:do_stay_near() + + self.timer1 = 0 + end +end + + +-- default function when mobs are blown up with TNT +function mob_class:on_blast(damage) + +--print("-- blast damage", damage) + + self.object:punch(self.object, 1.0, { + full_punch_interval = 1.0, damage_groups = {fleshy = damage}}, nil) + + -- return no damage, no knockback, no item drops, mob api handles all + return false, false, {} +end + + +mobs.spawning_mobs = {} + +-- register mob entity +function mobs:register_mob(name, def) + + mobs.spawning_mobs[name] = {} + + local collisionbox = def.collisionbox or {-0.25, -0.25, -0.25, 0.25, 0.25, 0.25} + + -- quick fix to stop mobs glitching through nodes if too small + if mob_height_fix and -collisionbox[2] + collisionbox[5] < 1.01 then + collisionbox[5] = collisionbox[2] + 0.99 + end + +minetest.register_entity(":" .. name, setmetatable({ + + initial_properties = { + + hp_max = max(1, (def.hp_max or 10) * difficulty), +-- breath_max +-- zoom_fov +-- eye_height + physical = true, +-- collide_with_objects + collisionbox = collisionbox, + selectionbox = def.selectionbox or collisionbox, +-- pointable + visual = def.visual, + visual_size = def.visual_size or {x = 1, y = 1}, + mesh = def.mesh, + textures = nil, +-- colors +-- use_texture_alpha +-- spritediv +-- initial_sprite_basepos +-- is_visible + make_footstep_sound = def.make_footstep_sound, +-- automatic_rotate + stepheight = def.stepheight or 1.1, +-- automatic_face_movement_dir +-- automatic_face_movement_max_rotation_per_sec +-- backface_culling + glow = def.glow, +-- nametag +-- nametag_color +-- nametag_bgcolor +-- infotext +-- static_save + damage_texture_modifier = def.damage_texture_modifier or "^[colorize:#c9900070", +-- shaded +-- show_on_minimap + }, + +-- stepheight = def.stepheight, + name = name, + type = def.type, + attack_type = def.attack_type, + fly = def.fly, + fly_in = def.fly_in, + keep_flying = def.keep_flying, + owner = def.owner, + order = def.order, + on_die = def.on_die, + on_flop = def.on_flop, + do_custom = def.do_custom, + jump_height = def.jump_height, + can_leap = def.can_leap, + drawtype = def.drawtype, -- DEPRECATED, use rotate instead + rotate = rad(def.rotate or 0), -- 0=front 90=side 180=back 270=side2 +-- glow = def.glow, + lifetimer = def.lifetimer, + hp_min = max(1, (def.hp_min or 5) * difficulty), +-- hp_max = max(1, (def.hp_max or 10) * difficulty), +-- collisionbox = collisionbox, +-- selectionbox = def.selectionbox or collisionbox, +-- visual = def.visual, +-- visual_size = def.visual_size, +-- mesh = def.mesh, +-- makes_footstep_sound = def.makes_footstep_sound, + view_range = def.view_range, + walk_velocity = def.walk_velocity, + run_velocity = def.run_velocity, + damage = max(0, (def.damage or 0) * difficulty), + damage_group = def.damage_group, +-- damage_texture_modifier = def.damage_texture_modifier or "^[colorize:#c9900070", + light_damage = def.light_damage, + light_damage_min = def.light_damage_min, + light_damage_max = def.light_damage_max, + water_damage = def.water_damage, + lava_damage = def.lava_damage, + fire_damage = def.fire_damage, + air_damage = def.air_damage, + suffocation = def.suffocation, + fall_damage = def.fall_damage, + fall_speed = def.fall_speed, + drops = def.drops, + armor = def.armor, + arrow = def.arrow, + arrow_override = def.arrow_override, + shoot_interval = def.shoot_interval, + sounds = def.sounds, + animation = def.animation, + follow = def.follow, + jump = def.jump, + walk_chance = def.walk_chance, + stand_chance = def.stand_chance, + attack_chance = def.attack_chance, + passive = def.passive, + knock_back = def.knock_back, + blood_amount = def.blood_amount, + blood_texture = def.blood_texture, + shoot_offset = def.shoot_offset, + floats = def.floats, + replace_rate = def.replace_rate, + replace_what = def.replace_what, + replace_with = def.replace_with, + replace_offset = def.replace_offset, + reach = def.reach, + texture_list = def.textures, + texture_mods = def.texture_mods or "", + child_texture = def.child_texture, + docile_by_day = def.docile_by_day, + fear_height = def.fear_height, + runaway = def.runaway, + pathfinding = def.pathfinding, + immune_to = def.immune_to, + explosion_radius = def.explosion_radius, + explosion_damage_radius = def.explosion_damage_radius, + explosion_timer = def.explosion_timer, + allow_fuse_reset = def.allow_fuse_reset, + stop_to_explode = def.stop_to_explode, + double_melee_attack = def.double_melee_attack, + dogshoot_switch = def.dogshoot_switch, + dogshoot_count_max = def.dogshoot_count_max, + dogshoot_count2_max = def.dogshoot_count2_max or def.dogshoot_count_max, + group_attack = def.group_attack, + group_helper = def.group_helper, + attack_monsters = def.attacks_monsters or def.attack_monsters, + attack_animals = def.attack_animals, + attack_players = def.attack_players, + attack_npcs = def.attack_npcs, + specific_attack = def.specific_attack, + friendly_fire = def.friendly_fire, + runaway_from = def.runaway_from, + owner_loyal = def.owner_loyal, + pushable = def.pushable, + stay_near = def.stay_near, + randomly_turn = def.randomly_turn ~= false, + ignore_invisibility = def.ignore_invisibility, + messages = def.messages, + + custom_attack = def.custom_attack, + on_replace = def.on_replace, + on_rightclick = def.on_rightclick, + on_spawn = def.on_spawn, + on_blast = def.on_blast, -- class redifinition + do_punch = def.do_punch, + on_breed = def.on_breed, + on_grown = def.on_grown, + + on_activate = function(self, staticdata, dtime) + return self:mob_activate(staticdata, def, dtime) + end, + + get_staticdata = function(self) + return self:mob_staticdata(self) + end + +}, mob_class_meta)) + +end -- END mobs:register_mob function + + +-- count how many mobs of one type are inside an area +-- will also return true for second value if player is inside area +local function count_mobs(pos, type) + + local total = 0 + local objs = minetest.get_objects_inside_radius(pos, aoc_range * 2) + local ent + local players + + for n = 1, #objs do + + if not is_player(objs[n]) then + + ent = objs[n]:get_luaentity() + + -- count mob type and add to total also + if ent and ent.name and ent.name == type then + total = total + 1 + end + else + players = true + end + end + + return total, players +end + + +-- do we have enough space to spawn mob? (thanks wuzzy) +local function can_spawn(pos, name) + + local ent = minetest.registered_entities[name] + local width_x = max(1, ceil(ent.collisionbox[4] - ent.collisionbox[1])) + local min_x, max_x + + if width_x % 2 == 0 then + max_x = floor(width_x / 2) + min_x = -(max_x - 1) + else + max_x = floor(width_x / 2) + min_x = -max_x + end + + local width_z = max(1, ceil(ent.collisionbox[6] - ent.collisionbox[3])) + local min_z, max_z + + if width_z % 2 == 0 then + max_z = floor(width_z / 2) + min_z = -(max_z - 1) + else + max_z = floor(width_z / 2) + min_z = -max_z + end + + local max_y = max(0, ceil(ent.collisionbox[5] - ent.collisionbox[2]) - 1) + local pos2 + + for y = 0, max_y do + for x = min_x, max_x do + for z = min_z, max_z do + + pos2 = {x = pos.x + x, y = pos.y + y, z = pos.z + z} + + if minetest.registered_nodes[node_ok(pos2).name].walkable == true then + return nil + end + end + end + end + + -- tweak X/Z spawn pos + if width_x % 2 == 0 then + pos.x = pos.x + 0.5 + end + + if width_z % 2 == 0 then + pos.z = pos.z + 0.5 + end + + return pos +end + +function mobs:can_spawn(pos, name) + return can_spawn(pos, name) +end + + +-- global functions + +function mobs:add_mob(pos, def) + + -- nil check + if not pos or not def then +--print("--- no position or definition given") + return + end + + -- is mob actually registered? + if not mobs.spawning_mobs[def.name] + or not minetest.registered_entities[def.name] then +--print("--- mob doesn't exist", def.name) + return + end + + -- are we over active mob limit + if active_limit > 0 and active_mobs >= active_limit then +--print("--- active mob limit reached", active_mobs, active_limit) + return + end + + -- get total number of this mob in area + local num_mob, is_pla = count_mobs(pos, def.name) + + if not is_pla then +--print("--- no players within active area, will not spawn " .. def.name) + return + end + + local aoc = mobs.spawning_mobs[def.name] and mobs.spawning_mobs[def.name].aoc or 1 + + if def.ignore_count ~= true and num_mob >= aoc then +--print("--- too many " .. def.name .. " in area", num_mob .. "/" .. aoc) + return + end + + local mob = minetest.add_entity(pos, def.name) + +--print("[mobs] Spawned " .. def.name .. " at " .. minetest.pos_to_string(pos)) + + local ent = mob:get_luaentity() + + if not ent then +--print("[mobs] entity not found " .. def.name) + return false + end + + if def.child then + + local textures = ent.base_texture + + -- using specific child texture (if found) + if ent.child_texture then + textures = ent.child_texture[1] + end + + -- and resize to half height (multiplication is faster than division) + + mob:set_properties({ + textures = textures, + visual_size = { + x = ent.base_size.x * .5, + y = ent.base_size.y * .5 + }, + collisionbox = { + ent.base_colbox[1] * .5, + ent.base_colbox[2] * .5, + ent.base_colbox[3] * .5, + ent.base_colbox[4] * .5, + ent.base_colbox[5] * .5, + ent.base_colbox[6] * .5 + }, + selectionbox = { + ent.base_selbox[1] * .5, + ent.base_selbox[2] * .5, + ent.base_selbox[3] * .5, + ent.base_selbox[4] * .5, + ent.base_selbox[5] * .5, + ent.base_selbox[6] * .5 + } + }) + + ent.child = true + end + + if def.owner then + ent.tamed = true + ent.owner = def.owner + end + + if def.nametag then + + -- limit name entered to 64 characters long + if def.nametag:len() > 64 then + def.nametag = def.nametag:sub(1, 64) + end + + ent.nametag = def.nametag + + ent:update_tag() + end + + return ent +end + + +function mobs:spawn_abm_check(pos, node, name) + -- global function to add additional spawn checks + -- return true to stop spawning mob +end + + +function mobs:spawn_specific(name, nodes, neighbors, min_light, max_light, interval, + chance, aoc, min_height, max_height, day_toggle, on_spawn, map_load) + + -- Do mobs spawn at all? + if not mobs_spawn or not mobs.spawning_mobs[name] then +--print ("--- spawning not registered for " .. name) + return + end + + -- chance/spawn number override in minetest.conf for registered mob + local numbers = settings:get(name) + + if numbers then + + numbers = numbers:split(",") + chance = tonumber(numbers[1]) or chance + aoc = tonumber(numbers[2]) or aoc + + if chance == 0 then + + minetest.log("warning", + string.format("[mobs] %s has spawning disabled", name)) + return + end + + minetest.log("action", string.format( + "[mobs] Chance setting for %s changed to %s (total: %s)", + name, chance, aoc)) + end + + mobs.spawning_mobs[name].aoc = aoc + + local spawn_action = function( + pos, node, active_object_count, active_object_count_wider) + + -- use instead of abm's chance setting when using lbm + if map_load and random(max(1, (chance * mob_chance_multiplier))) > 1 then + return + end + + -- use instead of abm's neighbor setting when using lbm + if map_load and not minetest.find_node_near(pos, 1, neighbors) then +--print("--- lbm neighbors not found") + return + end + + -- is mob actually registered? + if not mobs.spawning_mobs[name] + or not minetest.registered_entities[name] then +--print("--- mob doesn't exist", name) + return + end + + -- are we over active mob limit + if active_limit > 0 and active_mobs >= active_limit then +--print("--- active mob limit reached", active_mobs, active_limit) + return + end + + -- additional custom checks for spawning mob + if mobs:spawn_abm_check(pos, node, name) == true then + return + end + + -- do not spawn if too many entities in area + if active_object_count_wider and active_object_count_wider >= max_per_block then +--print("--- too many entities in area", active_object_count_wider) + return + end + + -- get total number of this mob in area + local num_mob, is_pla = count_mobs(pos, name) + + if not is_pla then +--print("--- no players within active area, will not spawn " .. name) + return + end + + if num_mob >= aoc then +--print("--- too many " .. name .. " in area", num_mob .. "/" .. aoc) + return + end + + -- if toggle set to nil then ignore day/night check + if day_toggle ~= nil then + + local tod = (minetest.get_timeofday() or 0) * 24000 + + if tod > 4500 and tod < 19500 then + -- daylight, but mob wants night + if day_toggle == false then +--print("--- mob needs night", name) + return + end + else + -- night time but mob wants day + if day_toggle == true then +--print("--- mob needs day", name) + return + end + end + end + + -- spawn above node + pos.y = pos.y + 1 + + -- are we spawning within height limits? + if pos.y > max_height or pos.y < min_height then +--print("--- height limits not met", name, pos.y) + return + end + + -- are light levels ok? + local light = minetest.get_node_light(pos) + if not light or light > max_light or light < min_light then +--print("--- light limits not met", name, light) + return + end + + -- check if mob can spawn inside protected areas + if (spawn_protected == false + or (spawn_monster_protected == false + and minetest.registered_entities[name].type == "monster")) + and minetest.is_protected(pos, "") then +--print("--- inside protected area", name) + return + end + + -- only spawn a set distance away from player + local objs = minetest.get_objects_inside_radius(pos, mob_nospawn_range) + + for n = 1, #objs do + + if is_player(objs[n]) then +--print("--- player too close", name) + return + end + end + + local ent = minetest.registered_entities[name] + local cbox = ent.initial_properties.collisionbox + + -- should we check mob area for obstructions ? + if mob_area_spawn ~= true then + + -- do we have enough height clearance to spawn mob? + local height = max(0, cbox[5] - cbox[2]) + + for n = 0, floor(height) do + + local pos2 = {x = pos.x, y = pos.y + n, z = pos.z} + + if minetest.registered_nodes[node_ok(pos2).name].walkable == true then +--print ("--- inside block", name, node_ok(pos2).name) + return + end + end + else + -- returns position if we have enough space to spawn mob + pos = can_spawn(pos, name) + end + + if pos then + + -- adjust for mob collision box + pos.y = pos.y + (cbox[2] * -1) - 0.4 + + local mob = minetest.add_entity(pos, name) + +-- print("[mobs] Spawned " .. name .. " at " +-- .. minetest.pos_to_string(pos) .. " on " +-- .. node.name .. " near " .. neighbors[1]) + + if mob_log_spawn then + + minetest.log("[MOBS] Spawned " .. name .. " at " + .. minetest.pos_to_string(pos)) + end + + if on_spawn and mob then + on_spawn(mob:get_luaentity(), pos) + end + else +--print("--- not enough space to spawn", name) + end + end + + + -- are we registering an abm or lbm? + if map_load == true then + + minetest.register_lbm({ + name = name .. "_spawning", + label = name .. " spawning", + nodenames = nodes, + run_at_every_load = false, + + action = function(pos, node) + spawn_action(pos, node) + end + }) + else + minetest.register_abm({ + label = name .. " spawning", + nodenames = nodes, + neighbors = neighbors, + interval = interval, + chance = max(1, (chance * mob_chance_multiplier)), + catch_up = false, + + action = function(pos, node, active_object_count, active_object_count_wider) + spawn_action(pos, node, active_object_count, active_object_count_wider) + end + }) + end +end + + +-- compatibility with older mob registration +function mobs:register_spawn(name, nodes, max_light, min_light, chance, + active_object_count, max_height, day_toggle) + + mobs:spawn_specific(name, nodes, {"air"}, min_light, max_light, 30, + chance, active_object_count, -31000, max_height, day_toggle) +end + + +-- MarkBu's spawn function (USE this one please) +function mobs:spawn(def) + + mobs:spawn_specific( + def.name, + def.nodes or {"group:soil", "group:stone"}, + def.neighbors or {"air"}, + def.min_light or 0, + def.max_light or 15, + def.interval or 30, + def.chance or 5000, + def.active_object_count or 1, + def.min_height or -31000, + def.max_height or 31000, + def.day_toggle, + def.on_spawn, + def.on_map_load) +end + + +-- register arrow for shoot attack +function mobs:register_arrow(name, def) + + if not name or not def then return end -- errorcheck + + minetest.register_entity(":" .. name, { + + initial_properties = { + + physical = def.physical or false, + collide_with_objects = def.collide_with_objects or false, + static_save = false, + visual = def.visual, + visual_size = def.visual_size, + textures = def.textures, + collisionbox = def.collisionbox or {-.1, -.1, -.1, .1, .1, .1}, + glow = def.glow, + automatic_face_movement_dir = def.rotate and (def.rotate - (pi / 180)) or false, + }, + + velocity = def.velocity, + hit_player = def.hit_player, + hit_node = def.hit_node, + hit_mob = def.hit_mob, + hit_object = def.hit_object, + drop = def.drop or false, -- drops arrow as registered item when true + timer = 0, + lifetime = def.lifetime or 4.5, + switch = 0, + owner_id = def.owner_id, + rotate = def.rotate, + + on_activate = def.on_activate, + + on_punch = def.on_punch or function(self, hitter, tflp, tool_capabilities, dir) + end, + + on_step = def.on_step or function(self, dtime) + + self.timer = self.timer + dtime + + local pos = self.object:get_pos() + + if self.switch == 0 or self.timer > self.lifetime then + + self.object:remove() ; -- print("removed arrow") + + return + end + + -- does arrow have a tail (fireball) + if def.tail and def.tail == 1 and def.tail_texture then + + minetest.add_particle({ + pos = pos, + velocity = {x = 0, y = 0, z = 0}, + acceleration = {x = 0, y = 0, z = 0}, + expirationtime = def.expire or 0.25, + collisiondetection = false, + texture = def.tail_texture, + size = def.tail_size or 5, + glow = def.glow or 0 + }) + end + + if self.hit_node then + + local node = node_ok(pos).name + + if minetest.registered_nodes[node].walkable then + + self:hit_node(pos, node) + + if self.drop == true then + + pos.y = pos.y + 1 + + self.lastpos = (self.lastpos or pos) + + minetest.add_item(self.lastpos, self.object:get_luaentity().name) + end + + self.object:remove() ; -- print("hit node") + + return + end + end + + if self.hit_player or self.hit_mob or self.hit_object then + + for _,player in pairs(minetest.get_objects_inside_radius(pos, 1.0)) do + + if self.hit_player and is_player(player) then + + self:hit_player(player) + + self.object:remove() ; -- print("hit player") + + return + end + + local entity = player:get_luaentity() + + if entity + and self.hit_mob + and entity._cmi_is_mob == true + and tostring(player) ~= self.owner_id + and entity.name ~= self.object:get_luaentity().name then + + self:hit_mob(player) + + self.object:remove() ; -- print("hit mob") + + return + end + + if entity + and self.hit_object + and (not entity._cmi_is_mob) + and tostring(player) ~= self.owner_id + and entity.name ~= self.object:get_luaentity().name then + + self:hit_object(player) + + self.object:remove() ; -- print("hit object") + + return + end + end + end + + self.lastpos = pos + end + }) +end + + +-- compatibility function (deprecated) +function mobs:explosion(pos, radius) + mobs:boom({sounds = {explode = "tnt_explode"}}, pos, radius, radius, "tnt_smoke.png") +end + + +-- no damage to nodes explosion +function mobs:safe_boom(self, pos, radius, texture) + + minetest.sound_play(self.sounds and self.sounds.explode or "tnt_explode", { + pos = pos, + gain = 1.0, + max_hear_distance = self.sounds and self.sounds.distance or 32 + }, true) + + entity_physics(pos, radius) + + effect(pos, 32, texture, radius * 3, radius * 5, radius, 1, 0) +end + + +-- make explosion with protection and tnt mod check +function mobs:boom(self, pos, radius, damage_radius, texture) + + if mobs_griefing + and minetest.get_modpath("tnt") and tnt and tnt.boom + and not minetest.is_protected(pos, "") then + + tnt.boom(pos, { + radius = radius, + damage_radius = damage_radius, + sound = self.sounds and self.sounds.explode, + explode_center = true, + tiles = {(texture or "tnt_smoke.png")} + }) + else + mobs:safe_boom(self, pos, radius, texture) + end +end + + +-- Register spawn eggs + +-- Note: This also introduces the “spawn_egg” group: +-- * spawn_egg=1: Spawn egg (generic mob, no metadata) +-- * spawn_egg=2: Spawn egg (captured/tamed mob, metadata) +function mobs:register_egg(mob, desc, background, addegg, no_creative) + + local grp = {spawn_egg = 1} + + -- do NOT add this egg to creative inventory (e.g. dungeon master) + if no_creative == true then + grp.not_in_creative_inventory = 1 + end + + local invimg = background + + if addegg == 1 then + invimg = "mobs_chicken_egg.png^(" .. invimg .. + "^[mask:mobs_chicken_egg_overlay.png)" + end + + -- register new spawn egg containing mob information (cannot be stacked) + minetest.register_craftitem(mob .. "_set", { + + description = S("@1 (Tamed)", desc), + inventory_image = invimg, + groups = {spawn_egg = 2, not_in_creative_inventory = 1}, + stack_max = 1, + + on_place = function(itemstack, placer, pointed_thing) + + local pos = pointed_thing.above + + -- does existing on_rightclick function exist? + local under = minetest.get_node(pointed_thing.under) + local def = minetest.registered_nodes[under.name] + + if def and def.on_rightclick then + + return def.on_rightclick( + pointed_thing.under, under, placer, itemstack, pointed_thing) + end + + if pos + and not minetest.is_protected(pos, placer:get_player_name()) then + + if not minetest.registered_entities[mob] then + return + end + + pos.y = pos.y + 1 + + local data = itemstack:get_metadata() + local smob = minetest.add_entity(pos, mob, data) + local ent = smob and smob:get_luaentity() + + if not ent then return end -- sanity check + + -- set owner if not a monster + if ent.type ~= "monster" then + ent.owner = placer:get_player_name() + ent.tamed = true + end + + -- since mob is unique we remove egg once spawned + itemstack:take_item() + end + + return itemstack + end + }) + + + -- register old stackable mob egg + minetest.register_craftitem(mob, { + + description = desc, + inventory_image = invimg, + groups = grp, + + on_place = function(itemstack, placer, pointed_thing) + + local pos = pointed_thing.above + + -- does existing on_rightclick function exist? + local under = minetest.get_node(pointed_thing.under) + local def = minetest.registered_nodes[under.name] + + if def and def.on_rightclick then + + return def.on_rightclick( + pointed_thing.under, under, placer, itemstack, pointed_thing) + end + + if pos and not minetest.is_protected(pos, placer:get_player_name()) then + + if not minetest.registered_entities[mob] then + return + end + + -- have we reached active mob limit + if active_limit > 0 and active_mobs >= active_limit then + minetest.chat_send_player(placer:get_player_name(), + S("Active Mob Limit Reached!") + .. " (" .. active_mobs + .. " / " .. active_limit .. ")") + return + end + + pos.y = pos.y + 1 + + local smob = minetest.add_entity(pos, mob) + local ent = smob and smob:get_luaentity() + + if not ent then return end -- sanity check + + -- don't set owner if monster or sneak pressed + if ent.type ~= "monster" and not placer:get_player_control().sneak then + ent.owner = placer:get_player_name() + ent.tamed = true + end + + -- if not in creative then take item + if not mobs.is_creative(placer:get_player_name()) then + itemstack:take_item() + end + end + + return itemstack + end + }) +end + + +-- force capture a mob if space available in inventory, or drop as spawn egg +function mobs:force_capture(self, clicker) + + -- add special mob egg with all mob information + local new_stack = ItemStack(self.name .. "_set") + + local data_str = minetest.serialize(clean_staticdata(self)) + + new_stack:set_metadata(data_str) + + local inv = clicker:get_inventory() + + if inv:room_for_item("main", new_stack) then + inv:add_item("main", new_stack) + else + minetest.add_item(clicker:get_pos(), new_stack) + end + + self:mob_sound("default_place_node_hard") + + remove_mob(self, true) +end + + +-- capture critter (thanks to blert2112 for idea) +function mobs:capture_mob( + self, clicker, chance_hand, chance_net, chance_lasso, force_take, replacewith) + + if not self or not is_player(clicker) or not clicker:get_inventory() then + return false + end + + -- get name of clicked mob + local mobname = self.name + + -- if not nil change what will be added to inventory + if replacewith then + mobname = replacewith + end + + local name = clicker:get_player_name() + local tool = clicker:get_wielded_item() + + -- are we using hand, net or lasso to pick up mob? + if tool:get_name() ~= "" + and tool:get_name() ~= "mobs:net" + and tool:get_name() ~= "mobs:lasso" then + return false + end + + -- is mob tamed? + if self.tamed == false and force_take == false then + + minetest.chat_send_player(name, S("Not tamed!")) + + return false + end + + -- cannot pick up if not owner (unless player has protection_bypass priv) + if not minetest.check_player_privs(name, "protection_bypass") + and self.owner ~= name and force_take == false then + + minetest.chat_send_player(name, S("@1 is owner!", self.owner)) + + return false + end + + if clicker:get_inventory():room_for_item("main", mobname) then + + -- was mob clicked with hand, net, or lasso? + local chance = 0 + + if tool:get_name() == "" then + chance = chance_hand + + elseif tool:get_name() == "mobs:net" then + + chance = chance_net + + tool:add_wear(4000) -- 17 uses + + clicker:set_wielded_item(tool) + + elseif tool:get_name() == "mobs:lasso" then + + chance = chance_lasso + + tool:add_wear(650) -- 100 uses + + clicker:set_wielded_item(tool) + + end + + -- calculate chance.. add to inventory if successful? + if chance and chance > 0 and random(100) <= chance then + + -- default mob egg + local new_stack = ItemStack(mobname) + + -- add special mob egg with all mob information + -- unless 'replacewith' contains new item to use + if not replacewith then + + new_stack = ItemStack(mobname .. "_set") + + local data_str = minetest.serialize(clean_staticdata(self)) + + new_stack:set_metadata(data_str) + end + + local inv = clicker:get_inventory() + + if inv:room_for_item("main", new_stack) then + inv:add_item("main", new_stack) + else + minetest.add_item(clicker:get_pos(), new_stack) + end + + self:mob_sound("default_place_node_hard") + + remove_mob(self, true) + + return new_stack + + -- when chance above fails or set to 0, miss! + elseif chance and chance ~= 0 then + + minetest.chat_send_player(name, S("Missed!")) + + self:mob_sound("mobs_swing") + + return false + + -- when chance is nil always return a miss (used for npc walk/follow) + elseif not chance then + return false + end + end + + return true +end + + +-- protect tamed mob with rune item +function mobs:protect(self, clicker) + + local name = clicker:get_player_name() + local tool = clicker:get_wielded_item() + local tool_name = tool:get_name() + + if tool_name ~= "mobs:protector" and tool_name ~= "mobs:protector2" then + return false + end + + if not self.tamed then + minetest.chat_send_player(name, S("Not tamed!")) + return true + end + + if (self.protected and tool_name == "mobs:protector") + or (self.protected == 2 and tool_name == "mobs:protector2") then + minetest.chat_send_player(name, S("Already protected!")) + return true + end + + if not mobs.is_creative(clicker:get_player_name()) then + tool:take_item() -- take 1 protection rune + clicker:set_wielded_item(tool) + end + + -- set protection level + if tool_name == "mobs:protector" then + self.protected = true + else + self.protected = 2 ; self.fire_damage = 0 + end + + local pos = self.object:get_pos() + + pos.y = pos.y + self.collisionbox[2] + 0.5 + + effect(self.object:get_pos(), 25, "mobs_protect_particle.png", 0.5, 4, 2, 15) + + self:mob_sound("mobs_spell") + + return true +end + + +local mob_obj = {} +local mob_sta = {} + +-- feeding, taming and breeding (thanks blert2112) +function mobs:feed_tame(self, clicker, feed_count, breed, tame) + + -- can eat/tame with item in hand + if self.follow and self:follow_holding(clicker) then + + -- if not in creative then take item + if not mobs.is_creative(clicker:get_player_name()) then + + local item = clicker:get_wielded_item() + + item:take_item() + + clicker:set_wielded_item(item) + end + + -- increase health + self.health = self.health + 4 + + if self.health >= self.initial_properties.hp_max then + + self.health = self.initial_properties.hp_max + end + + self.object:set_hp(self.health) + + -- make children grow quicker + if self.child == true then + + -- deduct 10% of the time to adulthood + self.hornytimer = math.floor(self.hornytimer + ( + (CHILD_GROW_TIME - self.hornytimer) * 0.1)) +--print ("====", self.hornytimer) + return true + end + + -- feed and tame + self.food = (self.food or 0) + 1 + self._breed_countdown = feed_count - self.food + + if self.food >= feed_count then + + self.food = 0 + self._breed_countdown = nil + + if breed and self.hornytimer == 0 then + self.horny = true + end + + if tame then + + if self.tamed == false then + minetest.chat_send_player(clicker:get_player_name(), + S("@1 has been tamed!", + self.name:split(":")[2])) + end + + self.tamed = true + self.static_save = true + + if not self.owner or self.owner == "" then + self.owner = clicker:get_player_name() + end + end + + -- make sound when fed so many times + self:mob_sound(self.sounds.random) + end + + self:update_tag() + + return true + end + + local item = clicker:get_wielded_item() + local name = clicker:get_player_name() + + -- if mob has been tamed you can name it with a nametag + if item:get_name() == "mobs:nametag" + and (name == self.owner + or minetest.check_player_privs(name, "protection_bypass")) then + + -- store mob and nametag stack in external variables + mob_obj[name] = self + mob_sta[name] = item + + local tag = self.nametag or "" + local esc = minetest.formspec_escape + + minetest.show_formspec(name, "mobs_nametag", + "size[8,4]" .. + "field[0.5,1;7.5,0;name;" .. + esc(FS("Enter name:")) .. + ";" .. tag .. "]" .. + "button_exit[2.5,3.5;3,1;mob_rename;" .. + esc(FS("Rename")) .. "]") + + return true + end + + -- if mob follows items and user right clicks while holding sneak it shows info + if self.follow then + + if clicker:get_player_control().sneak then + + if type(self.follow) == "string" then + self.follow = {self.follow} + end + + minetest.chat_send_player(clicker:get_player_name(), + S("@1 follows:", + self.name:split(":")[2]) .. "\n" .. + table.concat(self.follow, "\n- ")) + end + end + + return false +end + + +-- inspired by blockmen's nametag mod +minetest.register_on_player_receive_fields(function(player, formname, fields) + + -- right-clicked with nametag and name entered? + if formname == "mobs_nametag" and fields.name and fields.name ~= "" then + + local name = player:get_player_name() + + if not mob_obj[name] or not mob_obj[name].object then + return + end + + -- make sure nametag is being used to name mob + local item = player:get_wielded_item() + + if item:get_name() ~= "mobs:nametag" then + return + end + + -- limit name entered to 64 characters long + if fields.name:len() > 64 then + fields.name = fields.name:sub(1, 64) + end + + -- update nametag + mob_obj[name].nametag = fields.name + + mob_obj[name]:update_tag() + + -- if not in creative then take item + if not mobs.is_creative(name) then + + mob_sta[name]:take_item() + + player:set_wielded_item(mob_sta[name]) + end + + -- reset external variables + mob_obj[name] = nil + mob_sta[name] = nil + end +end) + + +-- compatibility function for old mobs entities to new mobs_redo modpack +function mobs:alias_mob(old_name, new_name) + + -- check old_name entity doesnt already exist + if minetest.registered_entities[old_name] then + return + end + + -- spawn egg + minetest.register_alias(old_name, new_name) + + -- entity + minetest.register_entity(":" .. old_name, { + + initial_properties = { + physical = false, + static_save = false + }, + + on_activate = function(self, staticdata) + + if minetest.registered_entities[new_name] then + + minetest.add_entity(self.object:get_pos(), new_name, staticdata) + end + + remove_mob(self) + end, + + get_staticdata = function(self) + return minetest.serialize(clean_staticdata(self)) + end + }) +end + + +-- admin command to remove untamed mobs around players +minetest.register_chatcommand("clear_mobs", { + params = "", + description = "Remove untamed mobs from around players.", + privs = {server = true}, + + func = function (name, param) + + local count = 0 + + for _, player in pairs(minetest.get_connected_players()) do + + if player then + + local pos = player:get_pos() + local objs = minetest.get_objects_inside_radius(pos, 28) + + for _, obj in pairs(objs) do + + if obj then + + local ent = obj:get_luaentity() + + -- only remove mobs redo mobs that are not tamed + if ent and ent._cmi_is_mob and ent.tamed ~= true then + + remove_mob(ent, true) + + count = count + 1 + end + end + end + end + end + + minetest.chat_send_player(name, S("@1 mobs removed.", count)) + end +})