2021-04-11 18:52:31 +02:00
-- API for Mobs Redo: MineClone 2 Delux 2.0 DRM Free Early Access Super Extreme Edition
-- current state of things: "why are these not in the same table as those?", and, "why are these not localized?"
-- lua locals
-- localize math functions
local math_pi = math.pi
local math_sin = math.sin
local math_cos = math.cos
local math_abs = math.abs
local math_min = math.min
local math_max = math.max
local math_atan = math.atan
local math_random = math.random
local math_floor = math.floor
2015-06-29 19:55:56 +02:00
mobs = { }
2017-01-16 17:40:08 +01:00
2018-02-04 07:11:44 +01:00
local MAX_MOB_NAME_LENGTH = 30
2021-04-12 14:11:55 +02:00
local BREED_TIME = 30
local BREED_TIME_AGAIN = 300
2020-12-05 01:26:30 +01:00
local CHILD_GROW_TIME = 60 * 20
2020-12-05 04:33:23 +01:00
local DEATH_DELAY = 0.5
2020-12-05 12:59:12 +01:00
local DEFAULT_FALL_SPEED = - 10
2020-12-05 14:14:16 +01:00
local FLOP_HEIGHT = 5.0
local FLOP_HOR_SPEED = 1.5
2017-05-25 10:33:19 +02:00
2020-04-11 02:46:03 +02:00
local MOB_CAP = { }
MOB_CAP.hostile = 70
MOB_CAP.passive = 10
MOB_CAP.ambient = 15
MOB_CAP.water = 15
2019-03-16 02:38:36 +01:00
-- Localize
2019-03-07 20:43:39 +01:00
local S = minetest.get_translator ( " mcl_mobs " )
2017-05-25 10:33:19 +02:00
2017-07-05 01:52:39 +02:00
-- CMI support check
local use_cmi = minetest.global_exists ( " cmi " )
2017-11-04 00:22:43 +01:00
2017-01-16 17:40:08 +01:00
-- Invisibility mod check
mobs.invis = { }
2017-11-04 00:22:43 +01:00
if minetest.global_exists ( " invisibility " ) then
2017-01-16 17:40:08 +01:00
mobs.invis = invisibility
end
2017-11-04 00:22:43 +01:00
-- creative check
function mobs . is_creative ( name )
2020-07-10 16:08:40 +02:00
return minetest.is_creative_enabled ( name )
2017-11-04 00:22:43 +01:00
end
2021-04-11 18:52:31 +02:00
2017-01-16 17:40:08 +01:00
local atan = function ( x )
2017-05-25 10:33:19 +02:00
if not x or x ~= x then
2017-01-16 17:40:08 +01:00
return 0
else
2021-04-11 18:52:31 +02:00
return math_atan ( x )
2017-01-16 17:40:08 +01:00
end
end
2017-05-25 10:33:19 +02:00
-- Load settings
2017-11-04 00:22:43 +01:00
local damage_enabled = minetest.settings : get_bool ( " enable_damage " )
local disable_blood = minetest.settings : get_bool ( " mobs_disable_blood " )
2018-01-26 18:06:32 +01:00
local mobs_drop_items = minetest.settings : get_bool ( " mobs_drop_items " ) ~= false
local mobs_griefing = minetest.settings : get_bool ( " mobs_griefing " ) ~= false
2017-11-04 00:22:43 +01:00
local spawn_protected = minetest.settings : get_bool ( " mobs_spawn_protected " ) ~= false
2020-12-17 16:22:34 +01:00
local remove_far = true
2017-11-04 00:22:43 +01:00
local difficulty = tonumber ( minetest.settings : get ( " mob_difficulty " ) ) or 1.0
2018-05-29 17:00:30 +02:00
local show_health = false
2020-04-11 01:14:14 +02:00
local max_per_block = tonumber ( minetest.settings : get ( " max_objects_per_block " ) or 64 )
2019-02-11 15:49:36 +01:00
local mobs_spawn_chance = tonumber ( minetest.settings : get ( " mobs_spawn_chance " ) or 2.5 )
2017-11-04 00:22:43 +01:00
2020-12-05 01:30:16 +01:00
-- Shows helpful debug info above each mob
local mobs_debug = minetest.settings : get_bool ( " mobs_debug " , false )
2017-11-04 00:22:43 +01:00
-- Peaceful mode message so players will know there are no monsters
2020-01-06 13:46:43 +01:00
if minetest.settings : get_bool ( " only_peaceful_mobs " , false ) then
2017-11-04 00:22:43 +01:00
minetest.register_on_joinplayer ( function ( player )
minetest.chat_send_player ( player : get_player_name ( ) ,
2019-03-07 20:43:39 +01:00
S ( " Peaceful mode active! No monsters will spawn. " ) )
2017-11-04 00:22:43 +01:00
end )
end
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- pathfinding settings
local enable_pathfinding = true
local stuck_timeout = 3 -- how long before mob gets stuck in place and starts searching
local stuck_path_timeout = 10 -- how long will mob follow path before giving up
2017-01-16 17:40:08 +01:00
2017-07-25 04:30:23 +02:00
-- default nodes
local node_ice = " mcl_core:ice "
local node_snowblock = " mcl_core:snowblock "
local node_snow = " mcl_core:snow "
mobs.fallback_node = minetest.registered_aliases [ " mapgen_dirt " ] or " mcl_core:dirt "
2017-01-16 17:40:08 +01:00
2018-05-31 02:47:37 +02:00
local mod_weather = minetest.get_modpath ( " mcl_weather " ) ~= nil
2020-05-02 18:50:25 +02:00
local mod_explosions = minetest.get_modpath ( " mcl_explosions " ) ~= nil
2018-05-31 02:47:37 +02:00
local mod_mobspawners = minetest.get_modpath ( " mcl_mobspawners " ) ~= nil
2019-02-28 16:43:52 +01:00
local mod_hunger = minetest.get_modpath ( " mcl_hunger " ) ~= nil
2020-01-30 01:11:02 +01:00
local mod_worlds = minetest.get_modpath ( " mcl_worlds " ) ~= nil
2020-02-18 18:12:51 +01:00
local mod_armor = minetest.get_modpath ( " mcl_armor " ) ~= nil
2020-12-05 01:49:15 +01:00
local mod_experience = minetest.get_modpath ( " mcl_experience " ) ~= nil
2020-12-03 17:37:44 +01:00
----For Water Flowing:
local enable_physics = function ( object , luaentity , ignore_check )
if luaentity.physical_state == false or ignore_check == true then
luaentity.physical_state = true
object : set_properties ( {
physical = true
} )
object : set_velocity ( { x = 0 , y = 0 , z = 0 } )
object : set_acceleration ( { x = 0 , y =- 9.81 , z = 0 } )
end
end
local disable_physics = function ( object , luaentity , ignore_check , reset_movement )
if luaentity.physical_state == true or ignore_check == true then
luaentity.physical_state = false
object : set_properties ( {
physical = false
} )
if reset_movement ~= false then
object : set_velocity ( { x = 0 , y = 0 , z = 0 } )
object : set_acceleration ( { x = 0 , y = 0 , z = 0 } )
end
end
end
2017-05-25 10:33:19 +02:00
-- play sound
2019-12-09 12:17:51 +01:00
local mob_sound = function ( self , soundname , is_opinion , fixed_pitch )
2017-05-25 10:33:19 +02:00
2019-12-09 12:17:51 +01:00
local soundinfo
if self.sounds_child and self.child then
soundinfo = self.sounds_child
elseif self.sounds then
soundinfo = self.sounds
end
if not soundinfo then
return
end
local sound = soundinfo [ soundname ]
2017-05-25 10:33:19 +02:00
if sound then
2019-01-31 06:31:04 +01:00
if is_opinion and self.opinion_sound_cooloff > 0 then
return
end
2019-03-08 23:11:44 +01:00
local pitch
2019-03-08 23:17:42 +01:00
if not fixed_pitch then
2019-12-09 12:17:51 +01:00
local base_pitch = soundinfo.base_pitch
2019-03-09 00:44:24 +01:00
if not base_pitch then
base_pitch = 1
end
2019-12-09 12:17:51 +01:00
if self.child and ( not self.sounds_child ) then
2019-03-09 00:44:24 +01:00
-- Children have higher pitch
pitch = base_pitch * 1.5
2019-03-08 23:17:42 +01:00
else
2019-03-09 00:44:24 +01:00
pitch = base_pitch
2019-03-08 23:17:42 +01:00
end
-- randomize the pitch a bit
2021-04-11 18:52:31 +02:00
pitch = pitch + math_random ( - 10 , 10 ) * 0.005
2019-03-08 23:11:44 +01:00
end
2017-05-25 10:33:19 +02:00
minetest.sound_play ( sound , {
object = self.object ,
gain = 1.0 ,
2019-03-08 23:11:44 +01:00
max_hear_distance = self.sounds . distance ,
pitch = pitch ,
2020-04-07 00:55:45 +02:00
} , true )
2019-01-31 06:31:04 +01:00
self.opinion_sound_cooloff = 1
2017-01-16 17:40:08 +01:00
end
end
2020-12-01 17:10:37 +01:00
-- Return true if object is in view_range
2020-02-18 18:12:51 +01:00
local function object_in_range ( self , object )
if not object then
return false
end
local factor
-- Apply view range reduction for special player armor
if object : is_player ( ) and mod_armor then
factor = armor : get_mob_view_range_factor ( object , self.name )
end
-- Distance check
local dist
if factor and factor == 0 then
return false
elseif factor then
dist = self.view_range * factor
else
dist = self.view_range
end
2020-12-01 17:10:37 +01:00
local p1 , p2 = self.object : get_pos ( ) , object : get_pos ( )
return p1 and p2 and ( vector.distance ( p1 , p2 ) <= dist )
2020-02-18 18:12:51 +01:00
end
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- attack player/mob
2017-07-05 01:52:39 +02:00
local do_attack = function ( self , player )
2017-05-25 10:33:19 +02:00
2020-12-05 13:51:29 +01:00
if self.state == " attack " or self.state == " die " then
2017-05-25 10:33:19 +02:00
return
end
self.attack = player
self.state = " attack "
2019-01-31 07:57:03 +01:00
-- TODO: Implement war_cry sound without being annoying
2021-04-11 18:52:31 +02:00
--if math_random(0, 100) < 90 then
2019-12-09 12:17:51 +01:00
--mob_sound(self, "war_cry", true)
2019-01-31 07:57:03 +01:00
--end
2017-05-25 10:33:19 +02:00
end
2021-04-11 17:58:33 +02:00
------------------------------------------------------------------------------------------------------------------------------------
2020-12-03 17:37:44 +01:00
-- collision function borrowed amended from jordan4ibanez open_ai mod
2021-04-11 17:58:33 +02:00
--[[
2020-12-03 17:37:44 +01:00
local collision = function ( self )
local pos = self.object : get_pos ( )
local vel = self.object : get_velocity ( )
local x = 0
local z = 0
local width = - self.collisionbox [ 1 ] + self.collisionbox [ 4 ] + 0.5
2021-03-16 17:35:46 +01:00
for _ , object in pairs ( minetest.get_objects_inside_radius ( pos , width ) ) do
2020-12-03 17:37:44 +01:00
if object : is_player ( )
or ( object : get_luaentity ( ) . _cmi_is_mob == true and object ~= self.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
2021-04-11 17:58:33 +02:00
] ] --
local collision = function ( self )
pos = self.object : get_pos ( )
--do collision detection from the base of the mob
collisionbox = self.object : get_properties ( ) . collisionbox
pos.y = pos.y + collisionbox [ 2 ]
collision_boundary = collisionbox [ 4 ]
radius = collision_boundary
if collisionbox [ 5 ] > collision_boundary then
radius = collisionbox [ 5 ]
end
collision_count = 0
for _ , object in ipairs ( minetest.get_objects_inside_radius ( pos , radius * 1.25 ) ) do
if object ~= self.object and ( object : is_player ( ) or object : get_luaentity ( ) . _cmi_is_mob == true ) and
--don't collide with rider, rider don't collide with thing
( not object : get_attach ( ) or ( object : get_attach ( ) and object : get_attach ( ) ~= self.object ) ) and
( not self.object : get_attach ( ) or ( self.object : get_attach ( ) and self.object : get_attach ( ) ~= object ) ) then
--stop infinite loop
collision_count = collision_count + 1
if collision_count > 100 then
break
end
pos2 = object : get_pos ( )
object_collisionbox = object : get_properties ( ) . collisionbox
pos2.y = pos2.y + object_collisionbox [ 2 ]
object_collision_boundary = object_collisionbox [ 4 ]
--this is checking the difference of the object collided with's possision
--if positive top of other object is inside (y axis) of current object
y_base_diff = ( pos2.y + object_collisionbox [ 5 ] ) - pos.y
y_top_diff = ( pos.y + collisionbox [ 5 ] ) - pos2.y
distance = vector.distance ( vector.new ( pos.x , 0 , pos.z ) , vector.new ( pos2.x , 0 , pos2.z ) )
if distance <= collision_boundary + object_collision_boundary and y_base_diff >= 0 and y_top_diff >= 0 then
dir = vector.direction ( pos , pos2 )
dir.y = 0
--eliminate mob being stuck in corners
if dir.x == 0 and dir.z == 0 then
2021-04-11 18:52:31 +02:00
dir = vector.new ( math_random ( - 1 , 1 ) * math_random ( ) , 0 , math_random ( - 1 , 1 ) * math_random ( ) )
2021-04-11 17:58:33 +02:00
end
local velocity = vector.multiply ( dir , 1.1 )
--local velocity = vector.normalize(dir)
vel1 = vector.multiply ( velocity , - 1 )
vel2 = velocity
self.object : add_velocity ( vel1 )
2021-04-11 20:47:56 +02:00
--reenable fire spreading eventually
2021-04-11 17:58:33 +02:00
if object : is_player ( ) then
object : add_player_velocity ( vel2 )
--if self.on_fire then
-- start_fire(object)
--end
--if is_player_on_fire(object) then
-- start_fire(self.object)
--end
else
object : add_velocity ( vel2 )
--if self.on_fire then
-- start_fire(object)
--end
--if object:get_luaentity().on_fire then
-- start_fire(self.object)
--end
end
end
end
end
end
------------------------------------------------------------------------------------------------------------------------------------
2020-12-03 17:37:44 +01:00
2017-05-25 10:33:19 +02:00
-- move mob in facing direction
2017-07-05 01:52:39 +02:00
local set_velocity = function ( self , v )
2020-12-03 17:37:44 +01:00
local c_x , c_y = 0 , 0
-- halt mob if it has been ordered to stay
2018-05-29 17:00:30 +02:00
if self.order == " stand " then
2019-03-06 04:38:57 +01:00
self.object : set_velocity ( { x = 0 , y = 0 , z = 0 } )
2018-05-29 17:00:30 +02:00
return
end
2017-11-04 00:22:43 +01:00
local yaw = ( self.object : get_yaw ( ) or 0 ) + self.rotate
2020-12-03 17:37:44 +01:00
2021-04-11 17:58:33 +02:00
self.object : add_velocity ( {
2021-04-11 18:52:31 +02:00
x = ( math_sin ( yaw ) * - v ) + c_x ,
2020-12-03 17:37:44 +01:00
y = self.object : get_velocity ( ) . y ,
2021-04-11 18:52:31 +02:00
z = ( math_cos ( yaw ) * v ) + c_y ,
2017-01-16 17:40:08 +01:00
} )
end
2017-05-25 10:33:19 +02:00
2020-12-03 17:37:44 +01:00
2017-11-04 00:22:43 +01:00
-- calculate mob velocity
2017-07-05 01:52:39 +02:00
local get_velocity = function ( self )
2017-01-16 17:40:08 +01:00
2019-03-06 04:38:57 +01:00
local v = self.object : get_velocity ( )
2021-01-05 20:30:59 +01:00
if v then
return ( v.x * v.x + v.z * v.z ) ^ 0.5
end
2017-01-16 17:40:08 +01:00
2021-01-05 20:30:59 +01:00
return 0
2017-01-16 17:40:08 +01:00
end
2021-03-25 09:24:38 +01:00
local function update_roll ( self )
local is_Fleckenstein = self.nametag == " Fleckenstein "
local was_Fleckenstein = false
local rot = self.object : get_rotation ( )
2021-04-11 18:52:31 +02:00
rot.z = is_Fleckenstein and math_pi or 0
2021-03-25 09:24:38 +01:00
self.object : set_rotation ( rot )
local cbox = table.copy ( self.collisionbox )
local acbox = self.object : get_properties ( ) . collisionbox
2021-04-11 18:52:31 +02:00
if math_abs ( cbox [ 2 ] - acbox [ 2 ] ) > 0.1 then
2021-03-25 09:24:38 +01:00
was_Fleckenstein = true
end
if is_Fleckenstein ~= was_Fleckenstein then
local pos = self.object : get_pos ( )
pos.y = pos.y + ( acbox [ 2 ] + acbox [ 5 ] )
self.object : set_pos ( pos )
end
if is_Fleckenstein then
cbox [ 2 ] , cbox [ 5 ] = - cbox [ 5 ] , - cbox [ 2 ]
end
self.object : set_properties ( { collisionbox = cbox } )
end
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
-- set and return valid yaw
2021-01-23 15:40:12 +01:00
local set_yaw = function ( self , yaw , delay , dtime )
2017-05-25 10:33:19 +02:00
if not yaw or yaw ~= yaw then
yaw = 0
2017-01-16 17:40:08 +01:00
end
2018-05-29 17:00:30 +02:00
delay = delay or 0
if delay == 0 then
2021-01-23 15:40:12 +01:00
if self.shaking and dtime then
2021-04-11 18:52:31 +02:00
yaw = yaw + ( math_random ( ) * 2 - 1 ) * 5 * dtime
2021-01-23 15:40:12 +01:00
end
2018-05-29 17:00:30 +02:00
self.object : set_yaw ( yaw )
2021-03-25 09:24:38 +01:00
update_roll ( self )
2018-05-29 17:00:30 +02:00
return yaw
end
self.target_yaw = yaw
self.delay = delay
2017-05-25 10:33:19 +02:00
2018-05-29 17:00:30 +02:00
return self.target_yaw
end
-- global function to set mob yaw
2021-01-23 15:40:12 +01:00
function mobs : yaw ( self , yaw , delay , dtime )
set_yaw ( self , yaw , delay , dtime )
2017-05-25 10:33:19 +02:00
end
2019-09-10 16:00:41 +02:00
local add_texture_mod = function ( self , mod )
local full_mod = " "
local already_added = false
for i = 1 , # self.texture_mods do
if mod == self.texture_mods [ i ] then
already_added = true
end
full_mod = full_mod .. self.texture_mods [ i ]
end
if not already_added then
full_mod = full_mod .. mod
table.insert ( self.texture_mods , mod )
end
self.object : set_texture_mod ( full_mod )
end
local remove_texture_mod = function ( self , mod )
local full_mod = " "
local remove = { }
for i = 1 , # self.texture_mods do
if self.texture_mods [ i ] ~= mod then
full_mod = full_mod .. self.texture_mods [ i ]
else
table.insert ( remove , i )
end
end
for i =# remove , 1 do
table.remove ( self.texture_mods , remove [ i ] )
end
self.object : set_texture_mod ( full_mod )
end
2017-05-25 10:33:19 +02:00
-- set defined animation
2020-12-05 04:33:23 +01:00
local set_animation = function ( self , anim , fixed_frame )
2020-12-05 12:59:12 +01:00
if not self.animation or not anim then
return
end
if self.state == " die " and anim ~= " die " and anim ~= " stand " then
return
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
self.animation . current = self.animation . current or " "
2020-12-05 12:59:12 +01:00
if ( anim == self.animation . current
2017-05-25 10:33:19 +02:00
or not self.animation [ anim .. " _start " ]
2020-12-05 12:59:12 +01:00
or not self.animation [ anim .. " _end " ] ) and self.state ~= " die " then
2017-05-25 10:33:19 +02:00
return
end
self.animation . current = anim
2017-01-16 17:40:08 +01:00
2020-12-05 04:33:23 +01:00
local a_start = self.animation [ anim .. " _start " ]
local a_end
if fixed_frame then
a_end = a_start
else
a_end = self.animation [ anim .. " _end " ]
end
2017-05-25 10:33:19 +02:00
self.object : set_animation ( {
2020-12-05 04:33:23 +01:00
x = a_start ,
y = a_end } ,
2017-07-05 01:52:39 +02:00
self.animation [ anim .. " _speed " ] or self.animation . speed_normal or 15 ,
0 , self.animation [ anim .. " _loop " ] ~= false )
end
2017-01-16 17:40:08 +01:00
2017-07-05 01:52:39 +02:00
-- above function exported for mount.lua
2017-07-26 16:55:36 +02:00
function mobs : set_animation ( self , anim )
2017-07-05 01:52:39 +02:00
set_animation ( self , anim )
2017-05-25 10:33:19 +02:00
end
2017-01-16 17:40:08 +01:00
2020-01-30 18:04:50 +01:00
-- Returns true is node can deal damage to self
local is_node_dangerous = function ( self , nodename )
local nn = nodename
if self.lava_damage > 0 then
if minetest.get_item_group ( nn , " lava " ) ~= 0 then
return true
end
end
if self.fire_damage > 0 then
if minetest.get_item_group ( nn , " fire " ) ~= 0 then
return true
end
end
2021-02-22 10:40:40 +01:00
if minetest.registered_nodes [ nn ] and minetest.registered_nodes [ nn ] . damage_per_second and minetest.registered_nodes [ nn ] . damage_per_second > 0 then
2020-07-25 04:15:40 +02:00
return true
end
return false
end
-- Returns true if node is a water hazard
local is_node_waterhazard = function ( self , nodename )
local nn = nodename
if self.water_damage > 0 then
if minetest.get_item_group ( nn , " water " ) ~= 0 then
return true
end
end
2020-12-13 00:09:32 +01:00
if minetest.registered_nodes [ nn ] and minetest.registered_nodes [ nn ] . drowning and minetest.registered_nodes [ nn ] . drowning > 0 then
2020-01-30 18:04:50 +01:00
if self.breath_max ~= - 1 then
2020-05-03 17:25:12 +02:00
-- check if the mob is water-breathing _and_ the block is water; only return true if neither is the case
-- this will prevent water-breathing mobs to classify water or e.g. sand below them as dangerous
if not self.breathes_in_water and minetest.get_item_group ( nn , " water " ) ~= 0 then
return true
end
2020-01-30 18:04:50 +01:00
end
end
return false
end
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- check line of sight (BrunoMine)
2017-07-05 01:52:39 +02:00
local line_of_sight = function ( self , pos1 , pos2 , stepsize )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
stepsize = stepsize or 1
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
local s , pos = minetest.line_of_sight ( pos1 , pos2 , stepsize )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- normal walking and flying mobs can see you through air
if s == true then
return true
end
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- New pos1 to be analyzed
local npos1 = { x = pos1.x , y = pos1.y , z = pos1.z }
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
local r , pos = minetest.line_of_sight ( npos1 , pos2 , stepsize )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- Checks the return
if r == true then return true end
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- Nodename found
local nn = minetest.get_node ( pos ) . name
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- Target Distance (td) to travel
2019-12-08 18:48:49 +01:00
local td = vector.distance ( pos1 , pos2 )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- Actual Distance (ad) traveled
local ad = 0
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- It continues to advance in the line of sight in search of a real
-- obstruction which counts as 'normal' nodebox.
while minetest.registered_nodes [ nn ]
2019-02-06 08:26:52 +01:00
and minetest.registered_nodes [ nn ] . walkable == false do
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- Check if you can still move forward
if td < ad + stepsize then
return true -- Reached the target
2017-01-16 17:40:08 +01:00
end
2017-05-25 10:33:19 +02:00
-- Moves the analyzed pos
2019-12-08 18:48:49 +01:00
local d = vector.distance ( pos1 , pos2 )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
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
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- NaN checks
if d == 0
or npos1.x ~= npos1.x
or npos1.y ~= npos1.y
or npos1.z ~= npos1.z then
return false
2017-01-16 17:40:08 +01:00
end
2017-05-25 10:33:19 +02:00
ad = ad + stepsize
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- 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
2017-01-16 17:40:08 +01:00
end
2017-05-25 10:33:19 +02:00
return false
end
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- are we flying in what we are suppose to? (taikedz)
2020-01-20 16:08:59 +01:00
local flight_check = function ( self )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
local nod = self.standing_in
2017-07-25 04:30:23 +02:00
local def = minetest.registered_nodes [ nod ]
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
if not def then return false end -- nil check
2020-01-30 16:52:07 +01:00
local fly_in
if type ( self.fly_in ) == " string " then
fly_in = { self.fly_in }
2017-05-25 10:33:19 +02:00
elseif type ( self.fly_in ) == " table " then
2020-01-30 16:52:07 +01:00
fly_in = self.fly_in
else
return false
2017-01-16 17:40:08 +01:00
end
2020-01-30 16:52:07 +01:00
for _ , checknode in pairs ( fly_in ) do
if nod == checknode then
return true
elseif checknode == " __airlike " and def.walkable == false and
( def.liquidtype == " none " or minetest.get_item_group ( nod , " fake_liquid " ) == 1 ) then
return true
end
2017-11-04 00:22:43 +01:00
end
2017-01-16 17:40:08 +01:00
return false
end
2017-05-25 10:33:19 +02:00
2017-11-04 00:22:43 +01:00
-- custom particle effects
2019-10-03 11:53:26 +02:00
local effect = function ( pos , amount , texture , min_size , max_size , radius , gravity , glow , go_down )
2017-01-16 17:40:08 +01:00
radius = radius or 2
min_size = min_size or 0.5
max_size = max_size or 1
gravity = gravity or - 10
2017-07-05 01:52:39 +02:00
glow = glow or 0
2019-10-03 11:53:26 +02:00
go_down = go_down or false
local ym
if go_down then
ym = 0
else
ym = - radius
end
2017-01-16 17:40:08 +01:00
minetest.add_particlespawner ( {
amount = amount ,
time = 0.25 ,
minpos = pos ,
maxpos = pos ,
2019-10-03 11:53:26 +02:00
minvel = { x = - radius , y = ym , z = - radius } ,
2017-01-16 17:40:08 +01:00
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 ,
2017-07-05 01:52:39 +02:00
glow = glow ,
2017-01-16 17:40:08 +01:00
} )
end
2019-10-03 11:53:26 +02:00
local damage_effect = function ( self , damage )
-- damage particles
if ( not disable_blood ) and damage > 0 then
2021-04-11 18:52:31 +02:00
local amount_large = math_floor ( damage / 2 )
2019-10-03 11:53:26 +02:00
local amount_small = damage % 2
local pos = self.object : get_pos ( )
pos.y = pos.y + ( self.collisionbox [ 5 ] - self.collisionbox [ 2 ] ) * .5
2019-10-03 12:03:36 +02:00
local texture = " mobs_blood.png "
2019-10-03 11:53:26 +02:00
-- full heart damage (one particle for each 2 HP damage)
if amount_large > 0 then
effect ( pos , amount_large , texture , 2 , 2 , 1.75 , 0 , nil , true )
end
-- half heart damage (one additional particle if damage is an odd number)
if amount_small > 0 then
-- TODO: Use "half heart"
effect ( pos , amount_small , texture , 1 , 1 , 1.75 , 0 , nil , true )
end
end
end
2017-05-25 10:33:19 +02:00
2020-12-05 14:42:03 +01:00
mobs.death_effect = function ( pos , yaw , collisionbox , rotate )
2020-08-19 18:31:45 +02:00
local min , max
if collisionbox then
min = { x = collisionbox [ 1 ] , y = collisionbox [ 2 ] , z = collisionbox [ 3 ] }
max = { x = collisionbox [ 4 ] , y = collisionbox [ 5 ] , z = collisionbox [ 6 ] }
else
min = { x = - 0.5 , y = 0 , z = - 0.5 }
max = { x = 0.5 , y = 0.5 , z = 0.5 }
end
2020-12-05 14:42:03 +01:00
if rotate then
2021-04-11 18:52:31 +02:00
min = vector.rotate ( min , { x = 0 , y = yaw , z = math_pi / 2 } )
max = vector.rotate ( max , { x = 0 , y = yaw , z = math_pi / 2 } )
2020-12-05 14:42:03 +01:00
min , max = vector.sort ( min , max )
min = vector.multiply ( min , 0.5 )
max = vector.multiply ( max , 0.5 )
end
2020-08-19 18:31:45 +02:00
minetest.add_particlespawner ( {
2020-12-05 05:11:06 +01:00
amount = 50 ,
time = 0.001 ,
2020-08-19 18:31:45 +02:00
minpos = vector.add ( pos , min ) ,
maxpos = vector.add ( pos , max ) ,
2020-12-05 05:11:06 +01:00
minvel = vector.new ( - 5 , - 5 , - 5 ) ,
maxvel = vector.new ( 5 , 5 , 5 ) ,
minexptime = 1.1 ,
2020-08-19 18:31:45 +02:00
maxexptime = 1.5 ,
2020-12-05 05:11:06 +01:00
minsize = 1 ,
maxsize = 2 ,
collisiondetection = false ,
vertical = false ,
texture = " mcl_particles_mob_death.png^[colorize:#000000:255 " ,
2020-08-19 18:31:45 +02:00
} )
2020-12-05 05:11:06 +01:00
minetest.sound_play ( " mcl_mobs_mob_poof " , {
pos = pos ,
gain = 1.0 ,
max_hear_distance = 8 ,
} , true )
2020-08-19 18:31:45 +02:00
end
2017-07-05 01:52:39 +02:00
local update_tag = function ( self )
2020-12-05 01:30:16 +01:00
local tag
if mobs_debug then
tag = " nametag = ' " .. tostring ( self.nametag ) .. " ' \n " ..
" state = ' " .. tostring ( self.state ) .. " ' \n " ..
2020-12-05 02:07:43 +01:00
" order = ' " .. tostring ( self.order ) .. " ' \n " ..
" attack = " .. tostring ( self.attack ) .. " \n " ..
2020-12-05 01:30:16 +01:00
" health = " .. tostring ( self.health ) .. " \n " ..
" breath = " .. tostring ( self.breath ) .. " \n " ..
" gotten = " .. tostring ( self.gotten ) .. " \n " ..
" tamed = " .. tostring ( self.tamed ) .. " \n " ..
" horny = " .. tostring ( self.horny ) .. " \n " ..
" hornytimer = " .. tostring ( self.hornytimer ) .. " \n " ..
2020-12-05 02:07:43 +01:00
" runaway_timer = " .. tostring ( self.runaway_timer ) .. " \n " ..
" following = " .. tostring ( self.following )
2020-12-05 01:30:16 +01:00
else
tag = self.nametag
end
2017-02-19 21:39:51 +01:00
self.object : set_properties ( {
2020-12-05 01:30:16 +01:00
nametag = tag ,
2017-02-19 21:39:51 +01:00
} )
2017-05-25 10:33:19 +02:00
2021-03-25 09:24:38 +01:00
update_roll ( self )
2017-02-19 21:39:51 +01:00
end
2017-07-05 01:52:39 +02:00
-- drop items
2020-12-23 17:41:42 +01:00
local item_drop = function ( self , cooked , looting_level )
2017-07-05 01:52:39 +02:00
2018-01-26 18:06:32 +01:00
-- no drops if disabled by setting
if not mobs_drop_items then return end
2021-01-03 15:10:50 +01:00
2020-12-23 17:41:42 +01:00
looting_level = looting_level or 0
2021-01-03 15:10:50 +01:00
2019-03-08 23:52:41 +01:00
-- no drops for child mobs (except monster)
if ( self.child and self.type ~= " monster " ) then
return
end
2017-07-05 01:52:39 +02:00
local obj , item , num
2017-11-04 00:22:43 +01:00
local pos = self.object : get_pos ( )
2017-07-05 01:52:39 +02:00
self.drops = self.drops or { } -- nil check
for n = 1 , # self.drops do
2020-12-23 17:41:42 +01:00
local dropdef = self.drops [ n ]
local chance = 1 / dropdef.chance
local looting_type = dropdef.looting
2021-01-02 21:42:07 +01:00
2020-12-23 17:41:42 +01:00
if looting_level > 0 then
local chance_function = dropdef.looting_chance_function
if chance_function then
chance = chance_function ( looting_level )
elseif looting_type == " rare " then
chance = chance + ( dropdef.looting_factor or 0.01 ) * looting_level
end
end
2021-01-02 21:42:07 +01:00
2020-12-23 17:41:42 +01:00
local num = 0
local do_common_looting = ( looting_level > 0 and looting_type == " common " )
2021-04-11 18:52:31 +02:00
if math_random ( ) < chance then
num = math_random ( dropdef.min or 1 , dropdef.max or 1 )
2020-12-23 17:41:42 +01:00
elseif not dropdef.looting_ignore_chance then
do_common_looting = false
end
2021-01-02 21:42:07 +01:00
2020-12-23 17:41:42 +01:00
if do_common_looting then
2021-04-11 18:52:31 +02:00
num = num + math_floor ( math_random ( 0 , looting_level ) + 0.5 )
2020-12-23 17:41:42 +01:00
end
2021-01-02 21:42:07 +01:00
2020-12-23 17:41:42 +01:00
if num > 0 then
item = dropdef.name
2017-07-05 01:52:39 +02:00
-- cook items when true
if cooked 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
-- add item if it exists
2021-04-01 23:12:07 +02:00
for x = 1 , num do
obj = minetest.add_item ( pos , ItemStack ( item .. " " .. 1 ) )
end
2017-07-05 01:52:39 +02:00
if obj and obj : get_luaentity ( ) then
2019-03-06 04:38:57 +01:00
obj : set_velocity ( {
2021-04-11 18:52:31 +02:00
x = math_random ( - 10 , 10 ) / 9 ,
2017-07-05 01:52:39 +02:00
y = 6 ,
2021-04-11 18:52:31 +02:00
z = math_random ( - 10 , 10 ) / 9 ,
2017-07-05 01:52:39 +02:00
} )
elseif obj then
obj : remove ( ) -- item does not exist
end
end
end
self.drops = { }
end
2017-01-16 17:40:08 +01:00
-- check if mob is dead or only hurt
2017-07-05 01:52:39 +02:00
local check_for_death = function ( self , cause , cmi_cause )
2017-01-16 17:40:08 +01:00
2020-12-05 04:33:23 +01:00
if self.state == " die " then
return true
end
2017-01-16 17:40:08 +01:00
-- has health actually changed?
2017-07-05 01:52:39 +02:00
if self.health == self.old_health and self.health > 0 then
2020-03-29 23:24:04 +02:00
return false
2017-01-16 17:40:08 +01:00
end
2018-09-18 20:08:03 +02:00
local damaged = self.health < self.old_health
2017-01-16 17:40:08 +01:00
self.old_health = self.health
2018-09-18 20:08:03 +02:00
-- still got some health?
2017-01-16 17:40:08 +01:00
if self.health > 0 then
-- make sure health isn't higher than max
if self.health > self.hp_max then
self.health = self.hp_max
end
2019-09-10 15:45:26 +02:00
-- play damage sound if health was reduced and make mob flash red.
2018-09-18 20:08:03 +02:00
if damaged then
2021-03-12 04:40:36 +01:00
add_texture_mod ( self , " ^[colorize:red:130 " )
2019-09-10 15:45:26 +02:00
minetest.after ( .2 , function ( self )
if self and self.object then
2021-03-12 04:40:36 +01:00
remove_texture_mod ( self , " ^[colorize:red:130 " )
2019-08-01 08:18:53 +02:00
end
2019-09-10 15:45:26 +02:00
end , self )
2019-12-09 12:17:51 +01:00
mob_sound ( self , " damage " )
2018-09-18 20:08:03 +02:00
end
2017-01-16 17:40:08 +01:00
-- backup nametag so we can show health stats
if not self.nametag2 then
self.nametag2 = self.nametag or " "
end
2018-01-08 02:03:31 +01:00
if show_health
and ( cmi_cause and cmi_cause.type == " punch " ) then
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
self.htimer = 2
self.nametag = " ♥ " .. self.health .. " / " .. self.hp_max
update_tag ( self )
end
2017-02-19 21:39:51 +01:00
2017-01-16 17:40:08 +01:00
return false
end
2019-12-09 12:17:51 +01:00
mob_sound ( self , " death " )
2017-01-16 17:40:08 +01:00
2020-12-05 04:33:23 +01:00
local function death_handle ( self )
-- dropped cooked item if mob died in fire or lava
if cause == " lava " or cause == " fire " then
2020-12-23 19:01:49 +01:00
item_drop ( self , true , 0 )
2020-12-05 04:33:23 +01:00
else
2021-01-01 19:25:47 +01:00
local wielditem = ItemStack ( )
2020-12-23 19:01:49 +01:00
if cause == " hit " then
local puncher = cmi_cause.puncher
if puncher then
2021-01-01 19:25:47 +01:00
wielditem = puncher : get_wielded_item ( )
2020-12-23 19:01:49 +01:00
end
end
2021-01-01 19:52:34 +01:00
local cooked = mcl_burning.is_burning ( self.object ) or mcl_enchanting.has_enchantment ( wielditem , " fire_aspect " )
2021-01-01 19:25:47 +01:00
local looting = mcl_enchanting.get_enchantment ( wielditem , " looting " )
2020-12-24 17:48:40 +01:00
item_drop ( self , cooked , looting )
2021-02-05 13:34:49 +01:00
if mod_experience and ( ( not self.child ) or self.type ~= " animal " ) and ( minetest.get_us_time ( ) - self.xp_timestamp <= 5000000 ) then
2021-04-11 18:52:31 +02:00
mcl_experience.throw_experience ( self.object : get_pos ( ) , math_random ( self.xp_min , self.xp_max ) )
2021-02-05 13:34:49 +01:00
end
2020-12-05 04:33:23 +01:00
end
2020-10-19 14:38:21 +02:00
end
2017-01-16 17:40:08 +01:00
-- execute custom death function
if self.on_die then
2020-12-05 04:33:23 +01:00
local pos = self.object : get_pos ( )
2021-01-05 17:52:27 +01:00
local on_die_exit = self.on_die ( self , pos , cmi_cause )
2020-12-05 05:11:06 +01:00
if on_die_exit ~= true then
death_handle ( self )
end
2017-07-05 01:52:39 +02:00
if use_cmi then
cmi.notify_die ( self.object , cmi_cause )
end
2020-12-05 04:33:23 +01:00
if on_die_exit == true then
2020-12-05 12:59:12 +01:00
self.state = " die "
2021-01-02 10:56:40 +01:00
mcl_burning.extinguish ( self.object )
2020-12-05 04:33:23 +01:00
self.object : remove ( )
return true
end
2017-01-16 17:40:08 +01:00
end
2020-08-19 18:31:45 +02:00
local collisionbox
if self.collisionbox then
collisionbox = table.copy ( self.collisionbox )
end
2020-12-05 12:59:12 +01:00
self.state = " die "
self.attack = nil
self.v_start = false
self.fall_speed = DEFAULT_FALL_SPEED
self.timer = 0
self.blinktimer = 0
remove_texture_mod ( self , " ^[colorize:#FF000040 " )
remove_texture_mod ( self , " ^[brighten " )
self.passive = true
2021-04-08 05:07:04 +02:00
2020-12-05 12:59:12 +01:00
self.object : set_properties ( {
pointable = false ,
collide_with_objects = false ,
} )
2021-04-08 05:07:04 +02:00
2020-12-05 12:59:12 +01:00
set_velocity ( self , 0 )
2020-12-05 13:51:29 +01:00
local acc = self.object : get_acceleration ( )
2020-12-05 14:42:03 +01:00
acc.x , acc.y , acc.z = 0 , DEFAULT_FALL_SPEED , 0
2020-12-05 13:51:29 +01:00
self.object : set_acceleration ( acc )
2020-12-05 12:59:12 +01:00
2020-12-05 14:42:03 +01:00
local length
2017-05-25 10:33:19 +02:00
-- default death function and die animation (if defined)
2020-12-05 14:42:03 +01:00
if self.instant_death then
length = 0
elseif self.animation
2017-05-25 10:33:19 +02:00
and self.animation . die_start
and self.animation . die_end then
2017-08-06 12:49:13 +02:00
local frames = self.animation . die_end - self.animation . die_start
local speed = self.animation . die_speed or 15
2020-12-05 04:33:23 +01:00
length = max ( frames / speed , 0 ) + DEATH_DELAY
2017-05-25 10:33:19 +02:00
set_animation ( self , " die " )
else
2020-12-05 04:33:23 +01:00
local rot = self.object : get_rotation ( )
2021-04-11 18:52:31 +02:00
rot.z = math_pi / 2
2020-12-05 04:33:23 +01:00
self.object : set_rotation ( rot )
length = 1 + DEATH_DELAY
set_animation ( self , " stand " , true )
end
2020-12-05 12:59:12 +01:00
2020-12-05 13:51:29 +01:00
-- Remove body after a few seconds and drop stuff
2020-12-05 14:42:03 +01:00
local kill = function ( self )
2020-12-05 04:33:23 +01:00
if not self.object : get_luaentity ( ) then
return
end
if use_cmi then
2017-07-05 01:52:39 +02:00
cmi.notify_die ( self.object , cmi_cause )
end
2020-12-05 04:33:23 +01:00
death_handle ( self )
local dpos = self.object : get_pos ( )
2020-12-05 05:11:06 +01:00
local cbox = self.collisionbox
local yaw = self.object : get_rotation ( ) . y
2021-01-02 10:56:40 +01:00
mcl_burning.extinguish ( self.object )
2017-05-25 10:33:19 +02:00
self.object : remove ( )
2020-12-05 14:42:03 +01:00
mobs.death_effect ( dpos , yaw , cbox , not self.instant_death )
end
if length <= 0 then
kill ( self )
else
minetest.after ( length , kill , self )
end
2017-01-16 17:40:08 +01:00
return true
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
-- check if within physical map limits (-30911 to 30927)
2020-12-01 17:10:37 +01:00
local within_limits , wmin , wmax = nil , - 30913 , 30928
within_limits = function ( pos , radius )
if mcl_vars then
if mcl_vars.mapgen_edge_min and mcl_vars.mapgen_edge_max then
wmin , wmax = mcl_vars.mapgen_edge_min , mcl_vars.mapgen_edge_max
within_limits = function ( pos , radius )
return pos
and ( pos.x - radius ) > wmin and ( pos.x + radius ) < wmax
and ( pos.y - radius ) > wmin and ( pos.y + radius ) < wmax
and ( pos.z - radius ) > wmin and ( pos.z + radius ) < wmax
end
end
2017-01-16 17:40:08 +01:00
end
2020-12-01 17:10:37 +01:00
return pos
and ( pos.x - radius ) > wmin and ( pos.x + radius ) < wmax
and ( pos.y - radius ) > wmin and ( pos.y + radius ) < wmax
and ( pos.z - radius ) > wmin and ( pos.z + radius ) < wmax
2017-01-16 17:40:08 +01:00
end
2017-05-25 10:33:19 +02:00
2020-01-30 18:04:50 +01:00
-- is mob facing a cliff or danger
local is_at_cliff_or_danger = function ( self )
2017-01-16 17:40:08 +01:00
if self.fear_height == 0 then -- 0 for no falling protection!
return false
end
2020-04-05 21:09:27 +02:00
if not self.object : get_luaentity ( ) then
return false
end
2017-11-04 00:22:43 +01:00
local yaw = self.object : get_yaw ( )
2021-04-11 18:52:31 +02:00
local dir_x = - math_sin ( yaw ) * ( self.collisionbox [ 4 ] + 0.5 )
local dir_z = math_cos ( yaw ) * ( self.collisionbox [ 4 ] + 0.5 )
2017-11-04 00:22:43 +01:00
local pos = self.object : get_pos ( )
2017-01-16 17:40:08 +01:00
local ypos = pos.y + self.collisionbox [ 2 ] -- just above floor
2020-01-30 18:04:50 +01:00
local free_fall , blocker = minetest.line_of_sight (
2017-01-16 17:40:08 +01:00
{ x = pos.x + dir_x , y = ypos , z = pos.z + dir_z } ,
2020-01-30 18:04:50 +01:00
{ x = pos.x + dir_x , y = ypos - self.fear_height , z = pos.z + dir_z } )
if free_fall then
2017-01-16 17:40:08 +01:00
return true
2020-01-30 18:04:50 +01:00
else
local bnode = minetest.get_node ( blocker )
local danger = is_node_dangerous ( self , bnode.name )
if danger then
return true
else
local def = minetest.registered_nodes [ bnode.name ]
2021-01-03 15:10:50 +01:00
if def and def.walkable then
2020-12-03 17:37:44 +01:00
return false
end
2020-01-30 18:04:50 +01:00
end
2017-01-16 17:40:08 +01:00
end
return false
end
2017-05-25 10:33:19 +02:00
2020-07-31 15:35:40 +02:00
-- copy the 'mob facing cliff_or_danger check' from above, and rework to avoid water
local is_at_water_danger = function ( self )
2021-01-03 15:10:50 +01:00
2020-07-31 15:35:40 +02:00
if not self.object : get_luaentity ( ) then
return false
end
local yaw = self.object : get_yaw ( )
2021-04-11 18:52:31 +02:00
local dir_x = - math_sin ( yaw ) * ( self.collisionbox [ 4 ] + 0.5 )
local dir_z = math_cos ( yaw ) * ( self.collisionbox [ 4 ] + 0.5 )
2020-07-31 15:35:40 +02:00
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 - 3 , z = pos.z + dir_z } )
if free_fall then
return true
else
local bnode = minetest.get_node ( blocker )
local waterdanger = is_node_waterhazard ( self , bnode.name )
if
waterdanger and ( is_node_waterhazard ( self , self.standing_in ) or is_node_waterhazard ( self , self.standing_on ) ) then
return false
elseif waterdanger and ( is_node_waterhazard ( self , self.standing_in ) or is_node_waterhazard ( self , self.standing_on ) ) == false then
return true
else
local def = minetest.registered_nodes [ bnode.name ]
2021-01-03 15:10:50 +01:00
if def and def.walkable then
2020-12-03 17:37:44 +01:00
return false
end
2020-07-31 15:35:40 +02:00
end
end
return false
end
2017-01-16 17:40:08 +01:00
-- get node but use fallback for nil or unknown
2017-07-05 01:52:39 +02:00
local node_ok = function ( pos , fallback )
2017-01-16 17:40:08 +01:00
2017-07-25 04:30:23 +02:00
fallback = fallback or mobs.fallback_node
2017-01-16 17:40:08 +01:00
local node = minetest.get_node_or_nil ( pos )
2017-07-05 01:52:39 +02:00
if node and minetest.registered_nodes [ node.name ] then
2017-01-16 17:40:08 +01:00
return node
end
2018-05-29 17:00:30 +02:00
return minetest.registered_nodes [ fallback ]
2017-01-16 17:40:08 +01:00
end
2017-05-25 10:33:19 +02:00
2017-07-05 01:52:39 +02:00
-- environmental damage (water, lava, fire, light etc.)
local do_env_damage = function ( self )
2017-01-16 17:40:08 +01:00
-- feed/tame text timer (so mob 'full' messages dont spam chat)
if self.htimer > 0 then
self.htimer = self.htimer - 1
end
-- reset nametag after showing health stats
if self.htimer < 1 and self.nametag2 then
self.nametag = self.nametag2
self.nametag2 = nil
2017-05-25 10:33:19 +02:00
update_tag ( self )
2017-01-16 17:40:08 +01:00
end
2017-11-04 00:22:43 +01:00
local pos = self.object : get_pos ( )
2017-01-16 17:40:08 +01:00
self.time_of_day = minetest.get_timeofday ( )
-- remove mob if beyond map limits
if not within_limits ( pos , 0 ) then
2021-01-02 10:56:40 +01:00
mcl_burning.extinguish ( self.object )
2017-01-16 17:40:08 +01:00
self.object : remove ( )
2020-03-29 23:24:04 +02:00
return true
2017-01-16 17:40:08 +01:00
end
2020-04-12 23:11:18 +02:00
-- Deal light damage to mob, returns true if mob died
2018-05-31 03:09:27 +02:00
local deal_light_damage = function ( self , pos , damage )
2018-05-31 02:47:37 +02:00
if not ( mod_weather and ( mcl_weather.rain . raining or mcl_weather.state == " snow " ) and mcl_weather.is_outdoor ( pos ) ) then
2018-05-31 03:09:27 +02:00
self.health = self.health - damage
2018-05-31 02:47:37 +02:00
2020-08-19 18:47:58 +02:00
effect ( pos , 5 , " mcl_particles_smoke.png " )
2017-07-05 01:52:39 +02:00
2020-03-29 23:24:04 +02:00
if check_for_death ( self , " light " , { type = " light " } ) then
return true
end
2018-05-31 02:47:37 +02:00
end
2017-07-05 01:52:39 +02:00
end
2021-03-17 09:09:13 +01:00
-- Use get_node_light for Minetest version 5.3 where get_natural_light
-- does not exist yet.
local get_light = minetest.get_natural_light or minetest.get_node_light
local sunlight = get_light ( pos , self.time_of_day )
2021-03-16 23:48:11 +01:00
2018-05-31 03:09:27 +02:00
-- bright light harms mob
2021-03-16 23:48:11 +01:00
if self.light_damage ~= 0 and ( sunlight or 0 ) > 12 then
2020-04-12 23:11:18 +02:00
if deal_light_damage ( self , pos , self.light_damage ) then
return true
end
2018-05-31 03:09:27 +02:00
end
2020-01-30 01:11:02 +01:00
local _ , dim = nil , " overworld "
if mod_worlds then
_ , dim = mcl_worlds.y_to_layer ( pos.y )
end
2021-03-16 23:48:11 +01:00
if ( self.sunlight_damage ~= 0 or self.ignited_by_sunlight ) and ( sunlight or 0 ) >= minetest.LIGHT_MAX and dim == " overworld " then
2021-01-02 12:43:50 +01:00
if self.ignited_by_sunlight then
2021-02-22 10:55:14 +01:00
mcl_burning.set_on_fire ( self.object , 10 )
2021-01-02 12:43:50 +01:00
else
deal_light_damage ( self , pos , self.sunlight_damage )
2020-04-12 23:11:18 +02:00
return true
end
2018-05-31 03:09:27 +02:00
end
2017-07-05 01:52:39 +02:00
local y_level = self.collisionbox [ 2 ]
if self.child then
y_level = self.collisionbox [ 2 ] * 0.5
2017-01-16 17:40:08 +01:00
end
-- what is mob standing in?
2017-07-05 01:52:39 +02:00
pos.y = pos.y + y_level + 0.25 -- foot level
2020-01-29 23:11:20 +01:00
local pos2 = { x = pos.x , y = pos.y - 1 , z = pos.z }
2017-01-16 17:40:08 +01:00
self.standing_in = node_ok ( pos , " air " ) . name
2020-01-29 23:11:20 +01:00
self.standing_on = node_ok ( pos2 , " air " ) . name
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- don't fall when on ignore, just stand still
if self.standing_in == " ignore " then
2019-03-06 04:38:57 +01:00
self.object : set_velocity ( { x = 0 , y = 0 , z = 0 } )
2017-05-25 10:33:19 +02:00
end
2017-07-05 01:52:39 +02:00
local nodef = minetest.registered_nodes [ self.standing_in ]
2017-01-16 17:40:08 +01:00
2018-05-30 12:01:53 +02:00
-- rain
2020-01-30 18:04:50 +01:00
if self.rain_damage > 0 and mod_weather then
2018-05-30 12:01:53 +02:00
if mcl_weather.rain . raining and mcl_weather.is_outdoor ( pos ) then
self.health = self.health - self.rain_damage
if check_for_death ( self , " rain " , { type = " environment " ,
2020-03-29 23:24:04 +02:00
pos = pos , node = self.standing_in } ) then
return true
end
2018-05-30 12:01:53 +02:00
end
end
2017-07-05 01:52:39 +02:00
pos.y = pos.y + 1 -- for particle effect position
2017-01-16 17:40:08 +01:00
2019-10-02 18:43:48 +02:00
-- water damage
2020-01-30 18:04:50 +01:00
if self.water_damage > 0
2017-07-05 01:52:39 +02:00
and nodef.groups . water then
2017-01-16 17:40:08 +01:00
2017-07-05 01:52:39 +02:00
if self.water_damage ~= 0 then
2017-01-16 17:40:08 +01:00
self.health = self.health - self.water_damage
2020-08-19 18:47:58 +02:00
effect ( pos , 5 , " mcl_particles_smoke.png " , nil , nil , 1 , nil )
2017-01-16 17:40:08 +01:00
2017-07-05 01:52:39 +02:00
if check_for_death ( self , " water " , { type = " environment " ,
2020-03-29 23:24:04 +02:00
pos = pos , node = self.standing_in } ) then
return true
end
2017-07-05 01:52:39 +02:00
end
2019-10-02 18:43:48 +02:00
-- lava damage
2020-01-30 18:04:50 +01:00
elseif self.lava_damage > 0
2019-10-02 18:28:28 +02:00
and ( nodef.groups . lava ) then
2017-07-05 01:52:39 +02:00
if self.lava_damage ~= 0 then
2017-01-16 17:40:08 +01:00
self.health = self.health - self.lava_damage
2017-05-25 10:33:19 +02:00
effect ( pos , 5 , " fire_basic_flame.png " , nil , nil , 1 , nil )
2017-07-05 01:52:39 +02:00
if check_for_death ( self , " lava " , { type = " environment " ,
2020-03-29 23:24:04 +02:00
pos = pos , node = self.standing_in } ) then
return true
end
2017-07-05 01:52:39 +02:00
end
2017-05-25 10:33:19 +02:00
2019-10-02 18:43:48 +02:00
-- fire damage
2020-01-30 18:04:50 +01:00
elseif self.fire_damage > 0
2019-10-02 18:43:48 +02:00
and ( nodef.groups . fire ) then
if self.fire_damage ~= 0 then
self.health = self.health - self.fire_damage
effect ( pos , 5 , " fire_basic_flame.png " , nil , nil , 1 , nil )
if check_for_death ( self , " fire " , { type = " environment " ,
2020-03-29 23:24:04 +02:00
pos = pos , node = self.standing_in } ) then
return true
end
2019-10-02 18:43:48 +02:00
end
2017-07-05 01:52:39 +02:00
-- damage_per_second node check
2021-01-06 13:31:51 +01:00
elseif nodef.damage_per_second ~= 0 and not nodef.groups . lava and not nodef.groups . fire then
2017-05-25 10:33:19 +02:00
2017-07-05 01:52:39 +02:00
self.health = self.health - nodef.damage_per_second
2017-05-25 10:33:19 +02:00
2020-08-19 18:47:58 +02:00
effect ( pos , 5 , " mcl_particles_smoke.png " )
2017-07-05 01:52:39 +02:00
if check_for_death ( self , " dps " , { type = " environment " ,
2020-03-29 23:24:04 +02:00
pos = pos , node = self.standing_in } ) then
return true
end
2017-07-05 01:52:39 +02:00
end
2019-10-02 18:28:28 +02:00
-- Drowning damage
if self.breath_max ~= - 1 then
local drowning = false
if self.breathes_in_water then
if minetest.get_item_group ( self.standing_in , " water " ) == 0 then
drowning = true
end
elseif nodef.drowning > 0 then
drowning = true
end
if drowning then
2021-04-11 18:52:31 +02:00
self.breath = math_max ( 0 , self.breath - 1 )
2019-10-02 18:28:28 +02:00
effect ( pos , 2 , " bubble.png " , nil , nil , 1 , nil )
if self.breath <= 0 then
2019-10-03 11:53:26 +02:00
local dmg
2019-10-02 18:28:28 +02:00
if nodef.drowning > 0 then
2019-10-03 11:53:26 +02:00
dmg = nodef.drowning
2019-10-02 18:28:28 +02:00
else
2019-10-03 11:53:26 +02:00
dmg = 4
2019-10-02 18:28:28 +02:00
end
2019-10-03 11:53:26 +02:00
damage_effect ( self , dmg )
self.health = self.health - dmg
2019-10-02 18:28:28 +02:00
end
if check_for_death ( self , " drowning " , { type = " environment " ,
2020-03-29 23:24:04 +02:00
pos = pos , node = self.standing_in } ) then
return true
end
2019-10-02 18:28:28 +02:00
else
2021-04-11 18:52:31 +02:00
self.breath = math_min ( self.breath_max , self.breath + 1 )
2019-10-02 18:28:28 +02:00
end
end
2019-01-31 07:23:35 +01:00
--- suffocation inside solid node
-- FIXME: Redundant with mcl_playerplus
if ( self.suffocation == true )
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 )
and ( nodef.groups . opaque == 1 ) then
2020-05-13 22:15:46 +02:00
-- Short grace period before starting to take suffocation damage.
-- This is different from players, who take damage instantly.
-- This has been done because mobs might briefly be inside solid nodes
-- when e.g. climbing up stairs.
-- This is a bit hacky because it assumes that do_env_damage
-- is called roughly every second only.
self.suffocation_timer = self.suffocation_timer + 1
if self.suffocation_timer >= 3 then
-- 2 damage per second
-- TODO: Deal this damage once every 1/2 second
self.health = self.health - 2
if check_for_death ( self , " suffocation " , { type = " environment " ,
pos = pos , node = self.standing_in } ) then
return true
end
2020-03-29 23:24:04 +02:00
end
2020-05-13 22:15:46 +02:00
else
self.suffocation_timer = 0
2017-01-16 17:40:08 +01:00
end
2019-01-31 07:23:35 +01:00
2020-03-30 16:52:36 +02:00
return check_for_death ( self , " " , { type = " unknown " } )
2017-01-16 17:40:08 +01:00
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
-- jump if facing a solid node (not fences or gates)
2017-07-05 01:52:39 +02:00
local do_jump = function ( self )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
if not self.jump
or self.jump_height == 0
or self.fly
2019-03-08 23:52:41 +01:00
or ( self.child and self.type ~= " monster " )
2018-05-29 17:00:30 +02:00
or self.order == " stand " then
2017-05-25 10:33:19 +02:00
return false
end
2017-11-04 00:22:43 +01:00
self.facing_fence = false
2017-05-25 10:33:19 +02:00
-- something stopping us while moving?
if self.state ~= " stand "
and get_velocity ( self ) > 0.5
2019-03-06 04:38:57 +01:00
and self.object : get_velocity ( ) . y ~= 0 then
2017-05-25 10:33:19 +02:00
return false
2017-01-16 17:40:08 +01:00
end
2017-11-04 00:22:43 +01:00
local pos = self.object : get_pos ( )
local yaw = self.object : get_yaw ( )
2017-01-16 17:40:08 +01:00
-- what is mob standing on?
pos.y = pos.y + self.collisionbox [ 2 ] - 0.2
local nod = node_ok ( pos )
if minetest.registered_nodes [ nod.name ] . walkable == false then
2017-05-25 10:33:19 +02:00
return false
2017-01-16 17:40:08 +01:00
end
-- where is front
2021-04-11 18:52:31 +02:00
local dir_x = - math_sin ( yaw ) * ( self.collisionbox [ 4 ] + 0.5 )
local dir_z = math_cos ( yaw ) * ( self.collisionbox [ 4 ] + 0.5 )
2017-01-16 17:40:08 +01:00
-- what is in front of mob?
2020-01-20 16:08:59 +01:00
nod = node_ok ( {
2017-01-16 17:40:08 +01:00
x = pos.x + dir_x ,
y = pos.y + 0.5 ,
z = pos.z + dir_z
} )
2019-08-30 04:31:14 +02:00
-- this is used to detect if there's a block on top of the block in front of the mob.
-- If there is, there is no point in jumping as we won't manage.
local nodTop = node_ok ( {
x = pos.x + dir_x ,
y = pos.y + 1.5 ,
z = pos.z + dir_z
2019-09-05 00:17:52 +02:00
} , " air " )
2019-08-30 04:31:14 +02:00
-- we don't attempt to jump if there's a stack of blocks blocking
2021-01-06 12:14:20 +01:00
if minetest.registered_nodes [ nodTop.name ] . walkable == true then
2019-08-30 04:31:14 +02:00
return false
end
2017-01-16 17:40:08 +01:00
-- thin blocks that do not need to be jumped
2017-07-25 04:30:23 +02:00
if nod.name == node_snow then
2017-05-25 10:33:19 +02:00
return false
2017-01-16 17:40:08 +01:00
end
2017-11-04 00:22:43 +01:00
if self.walk_chance == 0
or minetest.registered_items [ nod.name ] . walkable then
2021-01-06 12:04:02 +01:00
if minetest.get_item_group ( nod.name , " fence " ) == 0
2020-01-29 23:37:16 +01:00
and minetest.get_item_group ( nod.name , " fence_gate " ) == 0
and minetest.get_item_group ( nod.name , " wall " ) == 0 then
2017-01-16 17:40:08 +01:00
2021-01-06 12:04:02 +01:00
local v = self.object : get_velocity ( )
2017-11-04 00:22:43 +01:00
v.y = self.jump_height
2017-05-25 10:33:19 +02:00
2017-11-04 00:22:43 +01:00
set_animation ( self , " jump " ) -- only when defined
2017-01-16 17:40:08 +01:00
2019-03-06 04:38:57 +01:00
self.object : set_velocity ( v )
2017-01-16 17:40:08 +01:00
2018-05-29 17:00:30 +02:00
-- when in air move forward
minetest.after ( 0.3 , function ( self , v )
2020-12-05 13:51:29 +01:00
if ( not self.object ) or ( not self.object : get_luaentity ( ) ) or ( self.state == " die " ) then
2018-06-03 16:13:46 +02:00
return
end
2018-05-29 17:00:30 +02:00
self.object : set_acceleration ( {
2018-06-03 00:56:29 +02:00
x = v.x * 2 ,
2021-01-06 12:04:02 +01:00
y = - 10 ,
2018-06-03 00:56:29 +02:00
z = v.z * 2 ,
2018-05-29 17:00:30 +02:00
} )
end , self , v )
2019-03-09 00:24:53 +01:00
if self.jump_sound_cooloff <= 0 then
2019-12-09 12:17:51 +01:00
mob_sound ( self , " jump " )
2019-03-09 00:24:53 +01:00
self.jump_sound_cooloff = 0.5
2018-05-29 17:00:30 +02:00
end
2017-11-04 00:22:43 +01:00
else
self.facing_fence = true
end
2017-01-16 17:40:08 +01:00
2019-02-06 08:51:09 +01:00
-- if we jumped against a block/wall 4 times then turn
if self.object : get_velocity ( ) . x ~= 0
and self.object : get_velocity ( ) . z ~= 0 then
self.jump_count = ( self.jump_count or 0 ) + 1
if self.jump_count == 4 then
local yaw = self.object : get_yaw ( ) or 0
yaw = set_yaw ( self , yaw + 1.35 , 8 )
self.jump_count = 0
end
end
2017-05-25 10:33:19 +02:00
return true
2017-01-16 17:40:08 +01:00
end
2017-05-25 10:33:19 +02:00
return false
2017-01-16 17:40:08 +01:00
end
2017-05-25 10:33:19 +02:00
2020-07-16 20:26:41 +02:00
-- blast damage to entities nearby
2017-07-05 01:52:39 +02:00
local entity_physics = function ( pos , radius )
2017-01-16 17:40:08 +01:00
radius = radius * 2
local objs = minetest.get_objects_inside_radius ( pos , radius )
local obj_pos , dist
for n = 1 , # objs do
2017-11-04 00:22:43 +01:00
obj_pos = objs [ n ] : get_pos ( )
2017-01-16 17:40:08 +01:00
2019-12-08 18:48:49 +01:00
dist = vector.distance ( pos , obj_pos )
2017-01-16 17:40:08 +01:00
if dist < 1 then dist = 1 end
2021-04-11 18:52:31 +02:00
local damage = math_floor ( ( 4 / dist ) * radius )
2017-01-16 17:40:08 +01:00
local ent = objs [ n ] : get_luaentity ( )
2017-05-25 10:33:19 +02:00
-- punches work on entities AND players
objs [ n ] : punch ( objs [ n ] , 1.0 , {
full_punch_interval = 1.0 ,
damage_groups = { fleshy = damage } ,
2017-11-04 00:22:43 +01:00
} , pos )
2017-01-16 17:40:08 +01:00
end
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
-- should mob follow what I'm holding ?
2017-07-05 01:52:39 +02:00
local follow_holding = function ( self , clicker )
2017-01-16 17:40:08 +01:00
if mobs.invis [ clicker : get_player_name ( ) ] then
return false
end
local item = clicker : get_wielded_item ( )
local t = type ( self.follow )
-- single item
if t == " string "
and item : get_name ( ) == self.follow then
return true
-- multiple items
elseif t == " table " then
for no = 1 , # self.follow do
if self.follow [ no ] == item : get_name ( ) then
return true
end
end
end
return false
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
-- find two animals of same type and breed if nearby and horny
2017-07-05 01:52:39 +02:00
local breed = function ( self )
2017-01-16 17:40:08 +01:00
2020-12-05 01:26:30 +01:00
-- child takes a long time before growing into adult
2017-01-16 17:40:08 +01:00
if self.child == true then
2020-12-05 01:26:30 +01:00
-- When a child, hornytimer is used to count age until adulthood
2017-01-16 17:40:08 +01:00
self.hornytimer = self.hornytimer + 1
2020-12-05 01:26:30 +01:00
if self.hornytimer >= CHILD_GROW_TIME then
2017-01-16 17:40:08 +01:00
self.child = false
self.hornytimer = 0
self.object : set_properties ( {
textures = self.base_texture ,
mesh = self.base_mesh ,
visual_size = self.base_size ,
collisionbox = self.base_colbox ,
2018-01-08 02:03:31 +01:00
selectionbox = self.base_selbox ,
2017-01-16 17:40:08 +01:00
} )
2017-11-04 00:22:43 +01:00
-- custom function when child grows up
if self.on_grown then
self.on_grown ( self )
else
-- jump when fully grown so as not to fall into ground
2019-03-06 04:38:57 +01:00
self.object : set_velocity ( {
2017-11-04 00:22:43 +01:00
x = 0 ,
y = self.jump_height ,
z = 0
} )
end
2017-01-16 17:40:08 +01:00
end
return
end
2021-04-12 14:11:55 +02:00
-- horny animal can mate for BREED_TIME seconds,
-- afterwards horny animal cannot mate again for BREED_TIME_AGAIN seconds
2017-01-16 17:40:08 +01:00
if self.horny == true
2021-04-12 14:11:55 +02:00
and self.hornytimer < BREED_TIME + BREED_TIME_AGAIN then
2017-01-16 17:40:08 +01:00
self.hornytimer = self.hornytimer + 1
2021-04-12 14:11:55 +02:00
if self.hornytimer >= BREED_TIME + BREED_TIME_AGAIN then
2017-01-16 17:40:08 +01:00
self.hornytimer = 0
self.horny = false
end
end
2017-11-04 00:22:43 +01:00
-- find another same animal who is also horny and mate if nearby
2017-01-16 17:40:08 +01:00
if self.horny == true
2021-04-12 14:11:55 +02:00
and self.hornytimer <= BREED_TIME then
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
local pos = self.object : get_pos ( )
2017-01-16 17:40:08 +01:00
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 num = 0
local ent = nil
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 = string.split ( ent.name , " : " )
local selfname = string.split ( self.name , " : " )
if entname [ 1 ] == selfname [ 1 ] then
entname = string.split ( entname [ 2 ] , " _ " )
selfname = string.split ( selfname [ 2 ] , " _ " )
if entname [ 1 ] == selfname [ 1 ] then
canmate = true
end
end
end
end
if ent
and canmate == true
and ent.horny == true
2021-04-12 14:11:55 +02:00
and ent.hornytimer <= BREED_TIME then
2017-01-16 17:40:08 +01:00
num = num + 1
end
-- found your mate? then have a baby
if num > 1 then
2021-04-12 14:11:55 +02:00
self.hornytimer = BREED_TIME + 1
ent.hornytimer = BREED_TIME + 1
2017-01-16 17:40:08 +01:00
-- spawn baby
2018-06-03 16:13:46 +02:00
minetest.after ( 5 , function ( parent1 , parent2 , pos )
if not parent1.object : get_luaentity ( ) then
return
end
if not parent2.object : get_luaentity ( ) then
return
end
2017-01-16 17:40:08 +01:00
2020-12-05 01:49:15 +01:00
-- Give XP
if mod_experience then
2021-04-11 18:52:31 +02:00
mcl_experience.throw_experience ( pos , math_random ( 1 , 7 ) )
2020-12-05 01:49:15 +01:00
end
2017-11-04 00:22:43 +01:00
-- custom breed function
2018-06-03 16:13:46 +02:00
if parent1.on_breed then
-- when false, skip going any further
if parent1.on_breed ( parent1 , parent2 ) == false then
2018-05-30 12:56:39 +02:00
return
2017-11-04 00:22:43 +01:00
end
end
2018-06-03 16:13:46 +02:00
local child = mobs : spawn_child ( pos , parent1.name )
2017-01-16 17:40:08 +01:00
2018-05-30 12:56:39 +02:00
local ent_c = child : get_luaentity ( )
2017-01-16 17:40:08 +01:00
2018-05-31 04:38:37 +02:00
-- Use texture of one of the parents
2021-04-11 18:52:31 +02:00
local p = math_random ( 1 , 2 )
2018-05-31 04:38:37 +02:00
if p == 1 then
2018-06-03 16:13:46 +02:00
ent_c.base_texture = parent1.base_texture
2018-05-31 04:38:37 +02:00
else
2018-06-03 16:13:46 +02:00
ent_c.base_texture = parent2.base_texture
2018-05-31 04:38:37 +02:00
end
2018-05-30 12:56:39 +02:00
child : set_properties ( {
2018-05-31 04:38:37 +02:00
textures = ent_c.base_texture
2017-01-16 17:40:08 +01:00
} )
2018-05-30 12:56:39 +02:00
2017-11-04 00:22:43 +01:00
-- tamed and owned by parents' owner
2018-05-30 12:56:39 +02:00
ent_c.tamed = true
2018-06-03 16:13:46 +02:00
ent_c.owner = parent1.owner
end , self , ent , pos )
2017-01-16 17:40:08 +01:00
num = 0
break
end
end
end
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
-- find and replace what mob is looking for (grass, wheat etc.)
2017-07-05 01:52:39 +02:00
local replace = function ( self , pos )
2017-01-16 17:40:08 +01:00
2019-09-10 17:09:17 +02:00
if not self.replace_rate
2017-05-25 10:33:19 +02:00
or not self.replace_what
or self.child == true
2019-03-06 04:38:57 +01:00
or self.object : get_velocity ( ) . y ~= 0
2021-04-11 18:52:31 +02:00
or math_random ( 1 , self.replace_rate ) > 1 then
2017-05-25 10:33:19 +02:00
return
end
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
local what , with , y_offset
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
if type ( self.replace_what [ 1 ] ) == " table " then
2017-01-16 17:40:08 +01:00
2021-04-11 18:52:31 +02:00
local num = math_random ( # self.replace_what )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
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
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
pos.y = pos.y + y_offset
2017-01-16 17:40:08 +01:00
2020-12-09 22:10:42 +01:00
local node = minetest.get_node ( pos )
if node.name == what then
2017-05-25 10:33:19 +02:00
2020-12-09 22:10:42 +01:00
local oldnode = { name = what , param2 = node.param2 }
local newnode = { name = with , param2 = node.param2 }
2017-07-05 01:52:39 +02:00
local on_replace_return
2017-05-25 10:33:19 +02:00
2017-07-05 01:52:39 +02:00
if self.on_replace then
on_replace_return = self.on_replace ( self , pos , oldnode , newnode )
end
if on_replace_return ~= false then
2019-09-10 17:09:17 +02:00
if mobs_griefing then
2020-12-09 22:10:42 +01:00
minetest.set_node ( pos , newnode )
2019-09-10 17:09:17 +02:00
end
2017-07-05 01:52:39 +02:00
2017-01-16 17:40:08 +01:00
end
end
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
-- check if daytime and also if mob is docile during daylight hours
2017-07-05 01:52:39 +02:00
local day_docile = function ( self )
2017-01-16 17:40:08 +01:00
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
2017-05-25 10:33:19 +02:00
2018-05-29 17:00:30 +02:00
local los_switcher = false
local height_switcher = false
-- path finding and smart mob routine by rnd, line_of_sight and other edits by Elkien3
2017-07-05 01:52:39 +02:00
local smart_mobs = function ( self , s , p , dist , dtime )
2017-01-16 17:40:08 +01:00
local s1 = self.path . lastpos
2018-05-29 17:00:30 +02:00
local target_pos = self.attack : get_pos ( )
2017-01-16 17:40:08 +01:00
-- is it becoming stuck?
2021-04-11 18:52:31 +02:00
if math_abs ( s1.x - s.x ) + math_abs ( s1.z - s.z ) < .5 then
2017-01-16 17:40:08 +01:00
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 }
2018-05-29 17:00:30 +02:00
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 )
2017-01-16 17:40:08 +01:00
-- im stuck, search for path
2018-05-29 17:00:30 +02:00
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 )
2018-06-03 16:13:46 +02:00
if not self.object : get_luaentity ( ) then
return
end
2018-05-29 17:00:30 +02:00
if has_lineofsight then self.path . following = false end
end , self )
end -- can see target!
end
if ( self.path . stuck_timer > stuck_timeout and not self.path . following ) then
use_pathfind = true
self.path . stuck_timer = 0
minetest.after ( 1 , function ( self )
2018-06-03 16:13:46 +02:00
if not self.object : get_luaentity ( ) then
return
end
2018-05-29 17:00:30 +02:00
if has_lineofsight then self.path . following = false end
end , self )
end
2017-01-16 17:40:08 +01:00
2018-05-29 17:00:30 +02:00
if ( self.path . stuck_timer > stuck_path_timeout and self.path . following ) then
use_pathfind = true
2017-01-16 17:40:08 +01:00
self.path . stuck_timer = 0
2018-05-29 17:00:30 +02:00
minetest.after ( 1 , function ( self )
2018-06-03 16:13:46 +02:00
if not self.object : get_luaentity ( ) then
return
end
2018-05-29 17:00:30 +02:00
if has_lineofsight then self.path . following = false end
end , self )
end
2021-04-11 18:52:31 +02:00
if math_abs ( vector.subtract ( s , target_pos ) . y ) > self.stepheight then
2018-05-29 17:00:30 +02:00
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
if use_pathfind then
2017-01-16 17:40:08 +01:00
-- lets try find a path, first take care of positions
-- since pathfinder is very sensitive
local sheight = self.collisionbox [ 5 ] - self.collisionbox [ 2 ]
-- round position to center of node to avoid stuck in walls
-- also adjust height for player models!
2021-04-11 18:52:31 +02:00
s.x = math_floor ( s.x + 0.5 )
s.z = math_floor ( s.z + 0.5 )
2017-01-16 17:40:08 +01:00
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
2017-11-04 00:22:43 +01:00
local p1 = self.attack : get_pos ( )
2017-01-16 17:40:08 +01:00
2021-04-11 18:52:31 +02:00
p1.x = math_floor ( p1.x + 0.5 )
p1.y = math_floor ( p1.y + 0.5 )
p1.z = math_floor ( p1.z + 0.5 )
2017-01-16 17:40:08 +01:00
2020-01-30 01:36:08 +01:00
local dropheight = 12
2017-07-05 01:52:39 +02:00
if self.fear_height ~= 0 then dropheight = self.fear_height end
2020-01-30 01:36:08 +01:00
local jumpheight = 0
if self.jump and self.jump_height >= 4 then
jumpheight = math.min ( math.ceil ( self.jump_height / 4 ) , 4 )
elseif self.stepheight > 0.5 then
jumpheight = 1
end
self.path . way = minetest.find_path ( s , p1 , 16 , jumpheight , dropheight , " A*_noprefetch " )
2017-01-16 17:40:08 +01:00
self.state = " "
do_attack ( self , self.attack )
-- 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
2018-01-26 18:06:32 +01:00
if self.pathfinding == 2 and mobs_griefing then
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- is player higher than mob?
2017-01-16 17:40:08 +01:00
if s.y < p1.y then
2017-05-25 10:33:19 +02:00
-- build upwards
2017-01-16 17:40:08 +01:00
if not minetest.is_protected ( s , " " ) then
2017-05-25 10:33:19 +02:00
local ndef1 = minetest.registered_nodes [ self.standing_in ]
if ndef1 and ( ndef1.buildable_to or ndef1.groups . liquid ) then
2017-07-25 04:30:23 +02:00
minetest.set_node ( s , { name = mobs.fallback_node } )
2017-05-25 10:33:19 +02:00
end
2017-01-16 17:40:08 +01:00
end
local sheight = math.ceil ( self.collisionbox [ 5 ] ) + 1
-- assume mob is 2 blocks high so it digs above its head
s.y = s.y + sheight
2017-05-25 10:33:19 +02:00
-- remove one block above to make room to jump
2017-01-16 17:40:08 +01:00
if not minetest.is_protected ( s , " " ) then
2017-05-25 10:33:19 +02:00
local node1 = node_ok ( s , " air " ) . name
local ndef1 = minetest.registered_nodes [ node1 ]
2017-01-16 17:40:08 +01:00
if node1 ~= " air "
2017-05-25 10:33:19 +02:00
and node1 ~= " ignore "
and ndef1
and not ndef1.groups . level
2017-08-06 12:49:13 +02:00
and not ndef1.groups . unbreakable
and not ndef1.groups . liquid then
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
minetest.set_node ( s , { name = " air " } )
minetest.add_item ( s , ItemStack ( node1 ) )
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
end
end
s.y = s.y - sheight
2019-03-06 04:38:57 +01:00
self.object : set_pos ( { x = s.x , y = s.y + 2 , z = s.z } )
2017-01-16 17:40:08 +01:00
else -- dig 2 blocks to make door toward player direction
2021-04-11 18:52:31 +02:00
local yaw1 = self.object : get_yaw ( ) + math_pi / 2
2017-01-16 17:40:08 +01:00
local p1 = {
2021-04-11 18:52:31 +02:00
x = s.x + math_cos ( yaw1 ) ,
2017-01-16 17:40:08 +01:00
y = s.y ,
2021-04-11 18:52:31 +02:00
z = s.z + math_sin ( yaw1 )
2017-01-16 17:40:08 +01:00
}
if not minetest.is_protected ( p1 , " " ) then
2017-05-25 10:33:19 +02:00
local node1 = node_ok ( p1 , " air " ) . name
local ndef1 = minetest.registered_nodes [ node1 ]
2017-01-16 17:40:08 +01:00
if node1 ~= " air "
2018-05-29 17:00:30 +02:00
and node1 ~= " ignore "
and ndef1
and not ndef1.groups . level
and not ndef1.groups . unbreakable
and not ndef1.groups . liquid then
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
minetest.add_item ( p1 , ItemStack ( node1 ) )
minetest.set_node ( p1 , { name = " air " } )
end
p1.y = p1.y + 1
2017-05-25 10:33:19 +02:00
node1 = node_ok ( p1 , " air " ) . name
ndef1 = minetest.registered_nodes [ node1 ]
2017-01-16 17:40:08 +01:00
if node1 ~= " air "
2017-05-25 10:33:19 +02:00
and node1 ~= " ignore "
and ndef1
and not ndef1.groups . level
2017-08-06 12:49:13 +02:00
and not ndef1.groups . unbreakable
and not ndef1.groups . liquid then
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
minetest.add_item ( p1 , ItemStack ( node1 ) )
minetest.set_node ( p1 , { name = " air " } )
end
2015-06-29 19:55:56 +02:00
end
end
end
2017-01-16 17:40:08 +01:00
2020-01-06 14:46:10 +01:00
-- will try again in 2 seconds
2017-01-16 17:40:08 +01:00
self.path . stuck_timer = stuck_timeout - 2
2020-01-06 14:46:10 +01:00
elseif s.y < p1.y and ( not self.fly ) then
do_jump ( self ) --add jump to pathfinding
self.path . following = true
-- Yay, I found path!
2019-01-31 07:57:03 +01:00
-- TODO: Implement war_cry sound without being annoying
2019-12-09 12:17:51 +01:00
--mob_sound(self, "war_cry", true)
2020-01-06 14:46:10 +01:00
else
2017-05-25 10:33:19 +02:00
set_velocity ( self , self.walk_velocity )
2017-01-16 17:40:08 +01:00
-- follow path now that it has it
self.path . following = true
end
end
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
-- specific attacks
local specific_attack = function ( list , what )
-- no list so attack default (player, animals etc.)
if list == nil then
return true
end
2017-07-05 01:52:39 +02:00
-- found entity on list to attack?
2017-01-16 17:40:08 +01:00
for no = 1 , # list do
if list [ no ] == what then
return true
end
end
return false
end
-- monster find someone to attack
local monster_attack = function ( self )
if self.type ~= " monster "
or not damage_enabled
2020-07-10 16:08:40 +02:00
or minetest.is_creative_enabled ( " " )
2020-06-22 01:17:59 +02:00
or self.passive
2017-01-16 17:40:08 +01:00
or self.state == " attack "
or day_docile ( self ) then
return
end
2017-11-04 00:22:43 +01:00
local s = self.object : get_pos ( )
2017-01-16 17:40:08 +01:00
local p , sp , dist
local player , obj , min_player
local type , name = " " , " "
local min_dist = self.view_range + 1
local objs = minetest.get_objects_inside_radius ( s , self.view_range )
for n = 1 , # objs do
if objs [ n ] : is_player ( ) then
2020-02-18 18:12:51 +01:00
if mobs.invis [ objs [ n ] : get_player_name ( ) ] or ( not object_in_range ( self , objs [ n ] ) ) then
2017-01-16 17:40:08 +01:00
type = " "
2015-06-29 19:55:56 +02:00
else
2017-01-16 17:40:08 +01:00
player = objs [ n ]
type = " player "
name = " player "
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
else
obj = objs [ n ] : get_luaentity ( )
if obj then
player = obj.object
type = obj.type
name = obj.name or " "
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
end
-- find specific mob to attack, failing that attack player/npc/animal
if specific_attack ( self.specific_attack , name )
and ( type == " player " or type == " npc "
2017-05-25 10:33:19 +02:00
or ( type == " animal " and self.attack_animals == true ) ) then
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
p = player : get_pos ( )
2017-01-16 17:40:08 +01:00
sp = s
2019-12-08 18:48:49 +01:00
dist = vector.distance ( p , s )
2018-05-29 17:00:30 +02:00
2017-01-16 17:40:08 +01:00
-- aim higher to make looking up hills more realistic
p.y = p.y + 1
sp.y = sp.y + 1
2018-05-29 17:00:30 +02:00
-- choose closest player to attack
if dist < min_dist
and line_of_sight ( self , sp , p , 2 ) == true then
min_dist = dist
min_player = player
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
end
end
-- attack player
if min_player then
do_attack ( self , min_player )
end
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
-- npc, find closest monster to attack
local npc_attack = function ( self )
if self.type ~= " npc "
or not self.attacks_monsters
or self.state == " attack " then
return
end
2017-08-06 12:49:13 +02:00
local p , sp , obj , min_player
2017-11-04 00:22:43 +01:00
local s = self.object : get_pos ( )
2017-01-16 17:40:08 +01:00
local min_dist = self.view_range + 1
local objs = minetest.get_objects_inside_radius ( s , self.view_range )
for n = 1 , # objs do
obj = objs [ n ] : get_luaentity ( )
2017-05-25 10:33:19 +02:00
if obj and obj.type == " monster " then
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
p = obj.object : get_pos ( )
2018-05-29 17:00:30 +02:00
sp = s
2017-01-16 17:40:08 +01:00
2019-12-08 18:48:49 +01:00
local dist = vector.distance ( p , s )
2017-01-16 17:40:08 +01:00
2018-05-29 17:00:30 +02:00
-- aim higher to make looking up hills more realistic
p.y = p.y + 1
sp.y = sp.y + 1
if dist < min_dist
and line_of_sight ( self , sp , p , 2 ) == true then
2017-01-16 17:40:08 +01:00
min_dist = dist
min_player = obj.object
end
end
end
if min_player then
do_attack ( self , min_player )
end
end
2017-05-25 10:33:19 +02:00
2018-01-26 18:06:32 +01:00
-- specific runaway
local specific_runaway = function ( list , what )
-- no list so do not run
if list == nil then
return false
end
-- found entity on list to attack?
for no = 1 , # list do
2018-05-29 17:00:30 +02:00
if list [ no ] == what then
2018-01-26 18:06:32 +01:00
return true
end
end
return false
end
-- find someone to runaway from
local runaway_from = function ( self )
2020-12-05 14:16:07 +01:00
if not self.runaway_from and self.state ~= " flop " then
2018-01-26 18:06:32 +01:00
return
end
local s = self.object : get_pos ( )
local p , sp , dist
local player , obj , min_player
local type , name = " " , " "
local min_dist = self.view_range + 1
local objs = minetest.get_objects_inside_radius ( s , self.view_range )
for n = 1 , # objs do
if objs [ n ] : is_player ( ) then
2018-03-31 00:18:40 +02:00
if mobs.invis [ objs [ n ] : get_player_name ( ) ]
2020-02-18 18:12:51 +01:00
or self.owner == objs [ n ] : get_player_name ( )
or ( not object_in_range ( self , objs [ n ] ) ) then
2018-01-26 18:06:32 +01:00
type = " "
else
player = objs [ n ]
type = " player "
name = " player "
end
else
obj = objs [ n ] : get_luaentity ( )
if obj then
player = obj.object
type = obj.type
name = obj.name or " "
end
end
-- find specific mob to runaway from
if name ~= " " and name ~= self.name
and specific_runaway ( self.runaway_from , name ) then
p = player : get_pos ( )
sp = s
-- aim higher to make looking up hills more realistic
p.y = p.y + 1
sp.y = sp.y + 1
2019-12-08 18:48:49 +01:00
dist = vector.distance ( p , s )
2018-01-26 18:06:32 +01:00
2018-05-29 17:00:30 +02:00
-- choose closest player/mpb to runaway from
if dist < min_dist
and line_of_sight ( self , sp , p , 2 ) == true then
min_dist = dist
min_player = player
2018-01-26 18:06:32 +01:00
end
end
end
if min_player then
local lp = player : get_pos ( )
local vec = {
x = lp.x - s.x ,
y = lp.y - s.y ,
z = lp.z - s.z
}
2021-04-11 18:52:31 +02:00
local yaw = ( atan ( vec.z / vec.x ) + 3 * math_pi / 2 ) - self.rotate
2018-01-26 18:06:32 +01:00
if lp.x > s.x then
2021-04-11 18:52:31 +02:00
yaw = yaw + math_pi
2018-01-26 18:06:32 +01:00
end
2018-05-29 17:00:30 +02:00
yaw = set_yaw ( self , yaw , 4 )
2018-01-26 18:06:32 +01:00
self.state = " runaway "
2018-03-31 00:18:40 +02:00
self.runaway_timer = 3
2018-01-26 18:06:32 +01:00
self.following = nil
end
end
2017-01-16 17:40:08 +01:00
-- follow player if owner or holding item, if fish outta water then flop
local follow_flop = function ( self )
-- find player to follow
if ( self.follow ~= " "
or self.order == " follow " )
and not self.following
and self.state ~= " attack "
2020-12-22 15:29:24 +01:00
and self.order ~= " sit "
2017-01-16 17:40:08 +01:00
and self.state ~= " runaway " then
2017-11-04 00:22:43 +01:00
local s = self.object : get_pos ( )
2017-01-16 17:40:08 +01:00
local players = minetest.get_connected_players ( )
for n = 1 , # players do
2020-02-18 18:12:51 +01:00
if ( object_in_range ( self , players [ n ] ) )
2017-01-16 17:40:08 +01:00
and not mobs.invis [ players [ n ] : get_player_name ( ) ] then
self.following = players [ n ]
break
end
end
end
if self.type == " npc "
and self.order == " follow "
and self.state ~= " attack "
2020-12-22 15:29:24 +01:00
and self.order ~= " sit "
2017-01-16 17:40:08 +01:00
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
2020-12-05 02:07:43 +01:00
-- stop following player if not holding specific item,
-- mob is horny, fleeing or attacking
2017-01-16 17:40:08 +01:00
if self.following
and self.following : is_player ( )
2020-12-05 02:07:43 +01:00
and ( follow_holding ( self , self.following ) == false or
self.horny or self.state == " runaway " ) then
2017-01-16 17:40:08 +01:00
self.following = nil
end
end
-- follow that thing
if self.following then
2017-11-04 00:22:43 +01:00
local s = self.object : get_pos ( )
2017-01-16 17:40:08 +01:00
local p
if self.following : is_player ( ) then
2017-11-04 00:22:43 +01:00
p = self.following : get_pos ( )
2017-01-16 17:40:08 +01:00
elseif self.following . object then
2017-11-04 00:22:43 +01:00
p = self.following . object : get_pos ( )
2017-01-16 17:40:08 +01:00
end
if p then
2019-12-08 18:48:49 +01:00
local dist = vector.distance ( p , s )
2017-01-16 17:40:08 +01:00
-- dont follow if out of range
2020-02-18 18:12:51 +01:00
if ( not object_in_range ( self , self.following ) ) then
2017-01-16 17:40:08 +01:00
self.following = nil
else
local vec = {
x = p.x - s.x ,
z = p.z - s.z
}
2021-04-11 18:52:31 +02:00
local yaw = ( atan ( vec.z / vec.x ) + math_pi / 2 ) - self.rotate
2017-01-16 17:40:08 +01:00
2021-04-11 18:52:31 +02:00
if p.x > s.x then yaw = yaw + math_pi end
2017-01-16 17:40:08 +01:00
2020-08-03 15:37:58 +02:00
set_yaw ( self , yaw , 2.35 )
2017-01-16 17:40:08 +01:00
-- anyone but standing npc's can move along
2020-08-03 15:37:58 +02:00
if dist > 3
2017-01-16 17:40:08 +01:00
and self.order ~= " stand " then
2020-08-03 15:37:58 +02:00
set_velocity ( self , self.follow_velocity )
2017-01-16 17:40:08 +01:00
if self.walk_chance ~= 0 then
2020-08-03 15:37:58 +02:00
set_animation ( self , " run " )
2017-01-16 17:40:08 +01:00
end
else
set_velocity ( self , 0 )
set_animation ( self , " stand " )
end
2015-06-29 19:55:56 +02:00
return
end
2017-01-16 17:40:08 +01:00
end
end
2017-05-25 10:33:19 +02:00
-- swimmers flop when out of their element, and swim again when back in
if self.fly then
2017-11-04 00:22:43 +01:00
local s = self.object : get_pos ( )
2017-05-25 10:33:19 +02:00
if not flight_check ( self , s ) then
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
self.state = " flop "
2020-12-05 14:14:16 +01:00
self.object : set_acceleration ( { x = 0 , y = DEFAULT_FALL_SPEED , z = 0 } )
2017-01-16 17:40:08 +01:00
2020-12-05 14:14:16 +01:00
local sdef = minetest.registered_nodes [ self.standing_on ]
2020-12-05 21:33:37 +01:00
-- Flop on ground
2020-12-05 14:14:16 +01:00
if sdef and sdef.walkable then
2020-12-05 21:33:37 +01:00
mob_sound ( self , " flop " )
2020-12-05 14:14:16 +01:00
self.object : set_velocity ( {
2021-04-11 18:52:31 +02:00
x = math_random ( - FLOP_HOR_SPEED , FLOP_HOR_SPEED ) ,
2020-12-05 14:14:16 +01:00
y = FLOP_HEIGHT ,
2021-04-11 18:52:31 +02:00
z = math_random ( - FLOP_HOR_SPEED , FLOP_HOR_SPEED ) ,
2020-12-05 14:14:16 +01:00
} )
end
set_animation ( self , " stand " , true )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
return
elseif self.state == " flop " then
self.state = " stand "
2020-12-05 14:14:16 +01:00
self.object : set_acceleration ( { x = 0 , y = 0 , z = 0 } )
2020-12-05 14:20:58 +01:00
set_velocity ( self , 0 )
2017-05-25 10:33:19 +02:00
end
2017-01-16 17:40:08 +01:00
end
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
-- dogshoot attack switch and counter function
local dogswitch = function ( self , dtime )
-- switch mode not activated
if not self.dogshoot_switch
or not dtime then
return 0
end
self.dogshoot_count = self.dogshoot_count + dtime
2017-05-25 10:33:19 +02:00
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
2017-01-16 17:40:08 +01:00
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)
2020-04-08 15:03:03 +02:00
-- returns true if mob has died
2017-01-16 17:40:08 +01:00
local do_states = function ( self , dtime )
2017-08-06 12:49:13 +02:00
local yaw = self.object : get_yaw ( ) or 0
2017-01-16 17:40:08 +01:00
if self.state == " stand " then
2021-04-11 18:52:31 +02:00
if math_random ( 1 , 4 ) == 1 then
2017-01-16 17:40:08 +01:00
local lp = nil
2017-11-04 00:22:43 +01:00
local s = self.object : get_pos ( )
2017-05-25 10:33:19 +02:00
local objs = minetest.get_objects_inside_radius ( s , 3 )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
for n = 1 , # objs do
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
if objs [ n ] : is_player ( ) then
2017-11-04 00:22:43 +01:00
lp = objs [ n ] : get_pos ( )
2017-05-25 10:33:19 +02:00
break
2017-01-16 17:40:08 +01:00
end
end
-- look at any players nearby, otherwise turn randomly
if lp then
local vec = {
x = lp.x - s.x ,
z = lp.z - s.z
}
2021-04-11 18:52:31 +02:00
yaw = ( atan ( vec.z / vec.x ) + math_pi / 2 ) - self.rotate
2017-01-16 17:40:08 +01:00
2021-04-11 18:52:31 +02:00
if lp.x > s.x then yaw = yaw + math_pi end
2017-01-16 17:40:08 +01:00
else
2021-04-11 18:52:31 +02:00
yaw = yaw + math_random ( - 0.5 , 0.5 )
2017-01-16 17:40:08 +01:00
end
2018-05-29 17:00:30 +02:00
yaw = set_yaw ( self , yaw , 8 )
2017-01-16 17:40:08 +01:00
end
set_velocity ( self , 0 )
set_animation ( self , " stand " )
-- npc's ordered to stand stay standing
if self.type ~= " npc "
or self.order ~= " stand " then
if self.walk_chance ~= 0
2017-11-04 00:22:43 +01:00
and self.facing_fence ~= true
2021-04-11 18:52:31 +02:00
and math_random ( 1 , 100 ) <= self.walk_chance
2020-01-30 18:04:50 +01:00
and is_at_cliff_or_danger ( self ) == false then
2017-01-16 17:40:08 +01:00
set_velocity ( self , self.walk_velocity )
self.state = " walk "
set_animation ( self , " walk " )
end
end
elseif self.state == " walk " then
2017-11-04 00:22:43 +01:00
local s = self.object : get_pos ( )
2017-01-16 17:40:08 +01:00
local lp = nil
-- is there something I need to avoid?
2020-01-29 23:11:20 +01:00
if ( self.water_damage > 0
and self.lava_damage > 0 )
or self.breath_max ~= - 1 then
2017-01-16 17:40:08 +01:00
lp = minetest.find_node_near ( s , 1 , { " group:water " , " group:lava " } )
elseif self.water_damage > 0 then
lp = minetest.find_node_near ( s , 1 , { " group:water " } )
elseif self.lava_damage > 0 then
lp = minetest.find_node_near ( s , 1 , { " group:lava " } )
2020-01-29 23:11:20 +01:00
elseif self.fire_damage > 0 then
lp = minetest.find_node_near ( s , 1 , { " group:fire " } )
2017-01-16 17:40:08 +01:00
end
2020-01-30 18:04:50 +01:00
local is_in_danger = false
2017-01-16 17:40:08 +01:00
if lp then
2020-07-31 15:35:40 +02:00
-- If mob in or on dangerous block, look for land
if ( is_node_dangerous ( self , self.standing_in ) or
is_node_dangerous ( self , self.standing_on ) ) or ( is_node_waterhazard ( self , self.standing_in ) or is_node_waterhazard ( self , self.standing_on ) ) and ( not self.fly ) then
is_in_danger = true
2020-07-12 22:56:41 +02:00
2020-07-31 15:35:40 +02:00
-- If mob in or on dangerous block, look for land
if is_in_danger then
-- Better way to find shore - copied from upstream
lp = minetest.find_nodes_in_area_under_air (
{ x = s.x - 5 , y = s.y - 0.5 , z = s.z - 5 } ,
{ x = s.x + 5 , y = s.y + 1 , z = s.z + 5 } ,
2021-01-03 15:10:50 +01:00
{ " group:solid " } )
2020-05-03 17:25:12 +02:00
2021-04-11 18:52:31 +02:00
lp = # lp > 0 and lp [ math_random ( # lp ) ]
2021-01-03 15:10:50 +01:00
2020-07-31 15:35:40 +02:00
-- did we find land?
if lp then
2017-05-25 10:33:19 +02:00
2020-07-31 15:35:40 +02:00
local vec = {
x = lp.x - s.x ,
z = lp.z - s.z
}
2017-05-25 10:33:19 +02:00
2021-04-11 18:52:31 +02:00
yaw = ( atan ( vec.z / vec.x ) + math_pi / 2 ) - self.rotate
2017-05-25 10:33:19 +02:00
2021-04-11 18:52:31 +02:00
if lp.x > s.x then yaw = yaw + math_pi end
2017-05-25 10:33:19 +02:00
2020-07-31 15:35:40 +02:00
-- look towards land and move in that direction
yaw = set_yaw ( self , yaw , 6 )
set_velocity ( self , self.walk_velocity )
2017-05-25 10:33:19 +02:00
2020-07-31 15:35:40 +02:00
end
end
2017-05-25 10:33:19 +02:00
2020-01-29 23:11:20 +01:00
-- A danger is near but mob is not inside
2017-05-25 10:33:19 +02:00
else
2020-01-29 23:11:20 +01:00
-- Randomly turn
2021-04-11 18:52:31 +02:00
if math_random ( 1 , 100 ) <= 30 then
yaw = yaw + math_random ( - 0.5 , 0.5 )
2020-01-29 23:11:20 +01:00
yaw = set_yaw ( self , yaw , 8 )
end
2017-01-16 17:40:08 +01:00
end
2018-05-29 17:00:30 +02:00
yaw = set_yaw ( self , yaw , 8 )
2017-01-16 17:40:08 +01:00
-- otherwise randomly turn
2021-04-11 18:52:31 +02:00
elseif math_random ( 1 , 100 ) <= 30 then
2017-01-16 17:40:08 +01:00
2021-04-11 18:52:31 +02:00
yaw = yaw + math_random ( - 0.5 , 0.5 )
2018-05-29 17:00:30 +02:00
yaw = set_yaw ( self , yaw , 8 )
2017-01-16 17:40:08 +01:00
end
2020-01-30 18:04:50 +01:00
-- stand for great fall or danger or fence in front
local cliff_or_danger = false
if is_in_danger then
cliff_or_danger = is_at_cliff_or_danger ( self )
end
2017-11-04 00:22:43 +01:00
if self.facing_fence == true
2020-01-30 18:04:50 +01:00
or cliff_or_danger
2021-04-11 18:52:31 +02:00
or math_random ( 1 , 100 ) <= 30 then
2017-01-16 17:40:08 +01:00
set_velocity ( self , 0 )
self.state = " stand "
set_animation ( self , " stand " )
2020-12-22 15:29:24 +01:00
local yaw = self.object : get_yaw ( ) or 0
yaw = set_yaw ( self , yaw + 0.78 , 8 )
2017-01-16 17:40:08 +01:00
else
2020-01-29 23:11:20 +01:00
2017-01-16 17:40:08 +01:00
set_velocity ( self , self.walk_velocity )
2017-05-25 10:33:19 +02:00
if flight_check ( self )
and self.animation
and self.animation . fly_start
and self.animation . fly_end then
set_animation ( self , " fly " )
else
set_animation ( self , " walk " )
end
2017-01-16 17:40:08 +01:00
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
2020-01-30 18:04:50 +01:00
or is_at_cliff_or_danger ( self ) then
2017-01-16 17:40:08 +01:00
self.runaway_timer = 0
set_velocity ( self , 0 )
self.state = " stand "
set_animation ( self , " stand " )
2020-12-22 15:29:24 +01:00
local yaw = self.object : get_yaw ( ) or 0
yaw = set_yaw ( self , yaw + 0.78 , 8 )
2017-01-16 17:40:08 +01:00
else
set_velocity ( self , self.run_velocity )
2020-08-03 15:37:58 +02:00
set_animation ( self , " run " )
2017-01-16 17:40:08 +01:00
end
-- attack routines (explode, dogfight, shoot, dogshoot)
elseif self.state == " attack " then
2017-11-04 00:22:43 +01:00
local s = self.object : get_pos ( )
local p = self.attack : get_pos ( ) or s
2017-01-16 17:40:08 +01:00
2018-03-31 00:18:40 +02:00
-- stop attacking if player invisible or out of range
2020-02-25 16:09:26 +01:00
if not self.attack
2017-11-04 00:22:43 +01:00
or not self.attack : get_pos ( )
2020-02-25 16:09:26 +01:00
or not object_in_range ( self , self.attack )
2017-01-16 17:40:08 +01:00
or self.attack : get_hp ( ) <= 0
or ( self.attack : is_player ( ) and mobs.invis [ self.attack : get_player_name ( ) ] ) then
self.state = " stand "
set_velocity ( self , 0 )
set_animation ( self , " stand " )
self.attack = nil
self.v_start = false
self.timer = 0
self.blinktimer = 0
2018-05-29 17:00:30 +02:00
self.path . way = nil
2017-01-16 17:40:08 +01:00
return
end
2020-12-01 17:10:37 +01:00
-- calculate distance from mob and enemy
local dist = vector.distance ( p , s )
2017-01-16 17:40:08 +01:00
if self.attack_type == " explode " then
local vec = {
x = p.x - s.x ,
z = p.z - s.z
}
2021-04-11 18:52:31 +02:00
yaw = ( atan ( vec.z / vec.x ) + math_pi / 2 ) - self.rotate
2017-01-16 17:40:08 +01:00
2021-04-11 18:52:31 +02:00
if p.x > s.x then yaw = yaw + math_pi end
2017-01-16 17:40:08 +01:00
2021-01-23 15:40:12 +01:00
yaw = set_yaw ( self , yaw , 0 , dtime )
2017-01-16 17:40:08 +01:00
2018-03-31 00:18:40 +02:00
local node_break_radius = self.explosion_radius or 1
local entity_damage_radius = self.explosion_damage_radius
or ( node_break_radius * 2 )
-- start timer when in reach and line of sight
if not self.v_start
and dist <= self.reach
and line_of_sight ( self , s , p , 2 ) then
2017-11-04 00:22:43 +01:00
self.v_start = true
self.timer = 0
self.blinktimer = 0
2019-12-09 12:17:51 +01:00
mob_sound ( self , " fuse " , nil , false )
2018-03-31 00:18:40 +02:00
2018-03-31 03:51:49 +02:00
-- stop timer if out of reach or direct line of sight
2018-03-31 00:18:40 +02:00
elseif self.allow_fuse_reset
and self.v_start
2021-02-12 00:27:55 +01:00
and ( dist >= self.explosiontimer_reset_radius
2018-03-31 00:18:40 +02:00
or not line_of_sight ( self , s , p , 2 ) ) then
self.v_start = false
self.timer = 0
self.blinktimer = 0
self.blinkstatus = false
2019-09-10 16:00:41 +02:00
remove_texture_mod ( self , " ^[brighten " )
2017-11-04 00:22:43 +01:00
end
2017-01-16 17:40:08 +01:00
2018-03-31 00:18:40 +02:00
-- walk right up to player unless the timer is active
2021-02-12 00:27:55 +01:00
if self.v_start and ( self.stop_to_explode or dist < self.reach ) then
2017-11-04 00:22:43 +01:00
set_velocity ( self , 0 )
else
set_velocity ( self , self.run_velocity )
end
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
if self.animation and self.animation . run_start then
set_animation ( self , " run " )
2017-01-16 17:40:08 +01:00
else
2017-11-04 00:22:43 +01:00
set_animation ( self , " walk " )
end
if self.v_start then
2017-01-16 17:40:08 +01:00
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
2019-09-10 16:00:41 +02:00
remove_texture_mod ( self , " ^[brighten " )
2015-06-29 19:55:56 +02:00
else
2019-09-10 16:00:41 +02:00
add_texture_mod ( self , " ^[brighten " )
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
self.blinkstatus = not self.blinkstatus
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
if self.timer > self.explosion_timer then
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
local pos = self.object : get_pos ( )
2017-01-16 17:40:08 +01:00
2020-05-02 18:50:25 +02:00
if mod_explosions then
if mobs_griefing and not minetest.is_protected ( pos , " " ) then
2021-01-26 14:13:21 +01:00
mcl_explosions.explode ( mcl_util.get_object_center ( self.object ) , self.explosion_strength , { drop_chance = 1.0 } , self.object )
2017-07-25 04:30:23 +02:00
else
minetest.sound_play ( self.sounds . explode , {
pos = pos ,
gain = 1.0 ,
max_hear_distance = self.sounds . distance or 32
2020-04-07 00:55:45 +02:00
} , true )
2017-07-25 04:30:23 +02:00
2018-03-31 00:18:40 +02:00
entity_physics ( pos , entity_damage_radius )
2020-08-19 18:47:58 +02:00
effect ( pos , 32 , " mcl_particles_smoke.png " , nil , nil , node_break_radius , 1 , 0 )
2017-07-25 04:30:23 +02:00
end
2020-05-02 18:50:25 +02:00
end
2021-01-02 10:56:40 +01:00
mcl_burning.extinguish ( self.object )
2020-05-02 18:50:25 +02:00
self.object : remove ( )
2017-05-25 10:33:19 +02:00
2020-04-08 15:03:03 +02:00
return true
2015-06-29 19:55:56 +02:00
end
end
2017-01-16 17:40:08 +01:00
elseif self.attack_type == " dogfight "
or ( self.attack_type == " dogshoot " and dogswitch ( self , dtime ) == 2 )
or ( self.attack_type == " dogshoot " and dist <= self.reach and dogswitch ( self ) == 0 ) then
if self.fly
and dist > self.reach then
local p1 = s
2021-04-11 18:52:31 +02:00
local me_y = math_floor ( p1.y )
2017-01-16 17:40:08 +01:00
local p2 = p
2021-04-11 18:52:31 +02:00
local p_y = math_floor ( p2.y + 1 )
2019-03-06 04:38:57 +01:00
local v = self.object : get_velocity ( )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
if flight_check ( self , s ) then
2017-01-16 17:40:08 +01:00
if me_y < p_y then
2019-03-06 04:38:57 +01:00
self.object : set_velocity ( {
2017-01-16 17:40:08 +01:00
x = v.x ,
y = 1 * self.walk_velocity ,
z = v.z
} )
elseif me_y > p_y then
2019-03-06 04:38:57 +01:00
self.object : set_velocity ( {
2017-01-16 17:40:08 +01:00
x = v.x ,
y = - 1 * self.walk_velocity ,
z = v.z
} )
end
2015-06-29 19:55:56 +02:00
else
2017-01-16 17:40:08 +01:00
if me_y < p_y then
2019-03-06 04:38:57 +01:00
self.object : set_velocity ( {
2017-01-16 17:40:08 +01:00
x = v.x ,
y = 0.01 ,
z = v.z
} )
elseif me_y > p_y then
2019-03-06 04:38:57 +01:00
self.object : set_velocity ( {
2017-01-16 17:40:08 +01:00
x = v.x ,
y = - 0.01 ,
z = v.z
} )
end
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
-- 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
2021-04-11 18:52:31 +02:00
if math_abs ( p1.x - s.x ) + math_abs ( p1.z - s.z ) < 0.6 then
2017-01-16 17:40:08 +01:00
-- 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 }
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
local vec = {
x = p.x - s.x ,
z = p.z - s.z
}
2021-04-11 18:52:31 +02:00
yaw = ( atan ( vec.z / vec.x ) + math_pi / 2 ) - self.rotate
2017-01-16 17:40:08 +01:00
2021-04-11 18:52:31 +02:00
if p.x > s.x then yaw = yaw + math_pi end
2017-01-16 17:40:08 +01:00
2021-01-23 15:40:12 +01:00
yaw = set_yaw ( self , yaw , 0 , dtime )
2017-01-16 17:40:08 +01:00
-- move towards enemy if beyond mob reach
if dist > self.reach then
-- path finding by rnd
if self.pathfinding -- only if mob has pathfinding enabled
and enable_pathfinding then
smart_mobs ( self , s , p , dist , dtime )
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
2020-01-30 18:04:50 +01:00
if is_at_cliff_or_danger ( self ) then
2017-01-16 17:40:08 +01:00
set_velocity ( self , 0 )
set_animation ( self , " stand " )
2020-12-22 15:29:24 +01:00
local yaw = self.object : get_yaw ( ) or 0
yaw = set_yaw ( self , yaw + 0.78 , 8 )
2015-06-29 19:55:56 +02:00
else
2017-01-16 17:40:08 +01:00
if self.path . stuck then
set_velocity ( self , self.walk_velocity )
else
set_velocity ( self , self.run_velocity )
end
2017-07-29 13:34:27 +02:00
if self.animation and self.animation . run_start then
set_animation ( self , " run " )
else
set_animation ( self , " walk " )
end
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
else -- rnd: if inside reach range
self.path . stuck = false
self.path . stuck_timer = 0
self.path . following = false -- not stuck anymore
set_velocity ( self , 0 )
if not self.custom_attack then
if self.timer > 1 then
self.timer = 0
if self.double_melee_attack
2021-04-11 18:52:31 +02:00
and math_random ( 1 , 2 ) == 1 then
2017-01-16 17:40:08 +01:00
set_animation ( self , " punch2 " )
2015-06-29 19:55:56 +02:00
else
2017-01-16 17:40:08 +01:00
set_animation ( self , " punch " )
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
local p2 = p
local s2 = s
2017-05-25 10:33:19 +02:00
p2.y = p2.y + .5
s2.y = s2.y + .5
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
if line_of_sight ( self , p2 , s2 ) == true then
2017-01-16 17:40:08 +01:00
-- play attack sound
2019-12-09 12:17:51 +01:00
mob_sound ( self , " attack " )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- punch player (or what player is attached to)
local attached = self.attack : get_attach ( )
if attached then
self.attack = attached
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
self.attack : punch ( self.object , 1.0 , {
full_punch_interval = 1.0 ,
damage_groups = { fleshy = self.damage }
} , nil )
2015-06-29 19:55:56 +02:00
end
end
2017-01-16 17:40:08 +01:00
else -- call custom attack every second
if self.custom_attack
and self.timer > 1 then
self.timer = 0
self.custom_attack ( self , p )
2015-06-29 19:55:56 +02:00
end
end
end
2017-01-16 17:40:08 +01:00
elseif self.attack_type == " shoot "
or ( self.attack_type == " dogshoot " and dogswitch ( self , dtime ) == 1 )
or ( self.attack_type == " dogshoot " and dist > self.reach and dogswitch ( self ) == 0 ) then
p.y = p.y - .5
s.y = s.y + .5
2019-12-08 18:48:49 +01:00
local dist = vector.distance ( p , s )
2017-01-16 17:40:08 +01:00
local vec = {
x = p.x - s.x ,
y = p.y - s.y ,
z = p.z - s.z
}
2021-04-11 18:52:31 +02:00
yaw = ( atan ( vec.z / vec.x ) + math_pi / 2 ) - self.rotate
2017-01-16 17:40:08 +01:00
2021-04-11 18:52:31 +02:00
if p.x > s.x then yaw = yaw + math_pi end
2017-01-16 17:40:08 +01:00
2021-01-23 15:40:12 +01:00
yaw = set_yaw ( self , yaw , 0 , dtime )
2017-01-16 17:40:08 +01:00
set_velocity ( self , 0 )
2021-01-06 11:18:18 +01:00
local p = self.object : get_pos ( )
p.y = p.y + ( self.collisionbox [ 2 ] + self.collisionbox [ 5 ] ) / 2
2017-01-16 17:40:08 +01:00
if self.shoot_interval
and self.timer > self.shoot_interval
2021-01-06 11:18:18 +01:00
and not minetest.raycast ( p , self.attack : get_pos ( ) , false , false ) : next ( )
2021-04-11 18:52:31 +02:00
and math_random ( 1 , 100 ) <= 60 then
2017-01-16 17:40:08 +01:00
2015-06-29 19:55:56 +02:00
self.timer = 0
2017-01-16 17:40:08 +01:00
set_animation ( self , " shoot " )
-- play shoot attack sound
2019-12-09 12:17:51 +01:00
mob_sound ( self , " shoot_attack " )
2017-01-16 17:40:08 +01:00
2019-12-09 09:29:19 +01:00
-- Shoot arrow
2021-01-06 11:18:18 +01:00
if minetest.registered_entities [ self.arrow ] then
2017-05-25 10:33:19 +02:00
2019-12-09 09:29:19 +01:00
local arrow , ent
local v = 1
if not self.shoot_arrow then
2021-04-04 03:39:20 +02:00
self.firing = true
minetest.after ( 1 , function ( )
self.firing = false
end )
2019-12-09 09:29:19 +01:00
arrow = minetest.add_entity ( p , self.arrow )
ent = arrow : get_luaentity ( )
if ent.velocity then
v = ent.velocity
end
ent.switch = 1
ent.owner_id = tostring ( self.object ) -- add unique owner id to arrow
end
2017-05-25 10:33:19 +02:00
2019-12-09 09:29:19 +01:00
local amount = ( vec.x * vec.x + vec.y * vec.y + vec.z * vec.z ) ^ 0.5
-- offset makes shoot aim accurate
2017-05-25 10:33:19 +02:00
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 )
2019-12-09 09:29:19 +01:00
if self.shoot_arrow then
vec = vector.normalize ( vec )
self : shoot_arrow ( p , vec )
else
arrow : set_velocity ( vec )
end
2017-05-25 10:33:19 +02:00
end
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
end
end
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
-- falling and fall damage
2020-04-12 23:11:18 +02:00
-- returns true if mob died
2017-01-16 17:40:08 +01:00
local falling = function ( self , pos )
2020-12-05 04:33:23 +01:00
if self.fly and self.state ~= " die " then
2017-01-16 17:40:08 +01:00
return
end
2020-09-21 20:21:46 +02:00
if mcl_portals ~= nil then
2021-03-22 00:14:33 +01:00
if mcl_portals.nether_portal_cooloff ( self.object ) then
2020-09-21 20:21:46 +02:00
return false -- mob has teleported through Nether portal - it's 99% not falling
end
end
2017-01-16 17:40:08 +01:00
-- floating in water (or falling)
2019-03-06 04:38:57 +01:00
local v = self.object : get_velocity ( )
2017-01-16 17:40:08 +01:00
2017-07-05 01:52:39 +02:00
if v.y > 0 then
-- apply gravity when moving up
2019-03-06 04:38:57 +01:00
self.object : set_acceleration ( {
2017-07-05 01:52:39 +02:00
x = 0 ,
y = - 10 ,
z = 0
} )
elseif v.y <= 0 and v.y > self.fall_speed then
2017-01-16 17:40:08 +01:00
2017-07-05 01:52:39 +02:00
-- fall downwards at set speed
2019-03-06 04:38:57 +01:00
self.object : set_acceleration ( {
2017-01-16 17:40:08 +01:00
x = 0 ,
y = self.fall_speed ,
z = 0
} )
2017-07-05 01:52:39 +02:00
else
-- stop accelerating once max fall speed hit
2019-03-06 04:38:57 +01:00
self.object : set_acceleration ( { x = 0 , y = 0 , z = 0 } )
2017-01-16 17:40:08 +01:00
end
2021-03-22 01:53:57 +01:00
if minetest.registered_nodes [ node_ok ( pos ) . name ] . groups.lava then
if self.floats_on_lava == 1 then
self.object : set_acceleration ( {
x = 0 ,
y = - self.fall_speed / ( max ( 1 , v.y ) ^ 2 ) ,
z = 0
} )
end
end
2017-01-16 17:40:08 +01:00
-- in water then float up
2017-07-05 01:52:39 +02:00
if minetest.registered_nodes [ node_ok ( pos ) . name ] . groups.water then
2017-01-16 17:40:08 +01:00
if self.floats == 1 then
2019-03-06 04:38:57 +01:00
self.object : set_acceleration ( {
2017-01-16 17:40:08 +01:00
x = 0 ,
2021-04-11 18:52:31 +02:00
y = - self.fall_speed / ( math_max ( 1 , v.y ) ^ 2 ) ,
2017-01-16 17:40:08 +01:00
z = 0
} )
end
else
2017-07-05 01:52:39 +02:00
-- fall damage onto solid ground
2017-01-16 17:40:08 +01:00
if self.fall_damage == 1
2019-03-06 04:38:57 +01:00
and self.object : get_velocity ( ) . y == 0 then
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
local d = ( self.old_y or 0 ) - self.object : get_pos ( ) . y
2017-01-16 17:40:08 +01:00
if d > 5 then
2020-02-19 17:24:35 +01:00
local add = minetest.get_item_group ( self.standing_on , " fall_damage_add_percent " )
local damage = d - 5
if add ~= 0 then
damage = damage + damage * ( add / 100 )
end
2021-04-11 18:52:31 +02:00
damage = math_floor ( damage )
2020-02-19 17:24:35 +01:00
if damage > 0 then
self.health = self.health - damage
2017-01-16 17:40:08 +01:00
2020-08-19 18:47:58 +02:00
effect ( pos , 5 , " mcl_particles_smoke.png " , 1 , 2 , 2 , nil )
2017-01-16 17:40:08 +01:00
2020-02-19 17:24:35 +01:00
if check_for_death ( self , " fall " , { type = " fall " } ) then
2020-04-12 23:11:18 +02:00
return true
2020-02-19 17:24:35 +01:00
end
2017-01-16 17:40:08 +01:00
end
2015-06-29 19:55:56 +02:00
end
2017-11-04 00:22:43 +01:00
self.old_y = self.object : get_pos ( ) . y
2017-01-16 17:40:08 +01:00
end
end
end
2020-06-08 07:51:48 +02:00
local teleport = function ( self , target )
if self.do_teleport then
if self.do_teleport ( self , target ) == false then
return
end
end
end
2017-05-25 10:33:19 +02:00
-- deal damage and effects when mob punched
2017-01-16 17:40:08 +01:00
local mob_punch = function ( self , hitter , tflp , tool_capabilities , dir )
2017-11-04 00:22:43 +01:00
-- custom punch function
if self.do_punch then
-- when false skip going any further
2020-08-05 17:29:52 +02:00
if self.do_punch ( self , hitter , tflp , tool_capabilities , dir ) == false then
2017-11-04 00:22:43 +01:00
return
end
2017-05-25 10:33:19 +02:00
end
2017-01-16 17:40:08 +01:00
-- error checking when mod profiling is enabled
if not tool_capabilities then
2017-07-05 01:52:39 +02:00
minetest.log ( " warning " , " [mobs] Mod profiling enabled, damage not enabled " )
2017-01-16 17:40:08 +01:00
return
end
2021-02-05 13:34:49 +01:00
local is_player = hitter : is_player ( )
if is_player then
-- is mob protected?
if self.protected and minetest.is_protected ( self.object : get_pos ( ) , hitter : get_player_name ( ) ) then
return
end
-- set/update 'drop xp' timestamp if hitted by player
self.xp_timestamp = minetest.get_us_time ( )
2017-05-25 10:33:19 +02:00
end
2017-01-16 17:40:08 +01:00
2019-02-28 16:43:52 +01:00
-- punch interval
2017-01-16 17:40:08 +01:00
local weapon = hitter : get_wielded_item ( )
local punch_interval = 1.4
2019-02-28 16:43:52 +01:00
-- exhaust attacker
2021-02-05 13:34:49 +01:00
if mod_hunger and is_player then
2019-02-28 16:43:52 +01:00
mcl_hunger.exhaust ( hitter : get_player_name ( ) , mcl_hunger.EXHAUST_ATTACK )
end
2017-01-16 17:40:08 +01:00
-- 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
2017-07-05 01:52:39 +02:00
if use_cmi then
damage = cmi.calculate_damage ( self.object , hitter , tflp , tool_capabilities , dir )
else
2017-01-16 17:40:08 +01:00
2017-07-05 01:52:39 +02:00
for group , _ in pairs ( ( tool_capabilities.damage_groups or { } ) ) do
2017-01-16 17:40:08 +01:00
2017-07-05 01:52:39 +02:00
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
2017-01-16 17:40:08 +01:00
2017-07-05 01:52:39 +02:00
damage = damage + ( tool_capabilities.damage_groups [ group ] or 0 )
* tmp * ( ( armor [ group ] or 0 ) / 100.0 )
end
2017-01-16 17:40:08 +01:00
end
2021-01-02 21:42:07 +01:00
2021-01-01 19:59:34 +01:00
if weapon then
local fire_aspect_level = mcl_enchanting.get_enchantment ( weapon , " fire_aspect " )
if fire_aspect_level > 0 then
2021-02-22 10:55:14 +01:00
mcl_burning.set_on_fire ( self.object , fire_aspect_level * 4 )
2021-01-01 19:59:34 +01:00
end
end
2017-01-16 17:40:08 +01:00
-- check for tool immunity or special damage
for n = 1 , # self.immune_to do
if self.immune_to [ n ] [ 1 ] == weapon : get_name ( ) then
damage = self.immune_to [ n ] [ 2 ] or 0
break
end
end
-- healing
if damage <= - 1 then
2021-04-11 18:52:31 +02:00
self.health = self.health - math_floor ( damage )
2017-01-16 17:40:08 +01:00
return
end
2017-07-05 01:52:39 +02:00
if use_cmi then
local cancel = cmi.notify_punch ( self.object , hitter , tflp , tool_capabilities , dir , damage )
if cancel then return end
end
2017-01-16 17:40:08 +01:00
if tool_capabilities then
punch_interval = tool_capabilities.full_punch_interval or 1.4
end
2020-02-19 16:47:57 +01:00
-- add weapon wear manually
-- Required because we have custom health handling ("health" property)
2020-07-10 16:08:40 +02:00
if minetest.is_creative_enabled ( " " ) ~= true
2020-02-19 16:47:57 +01:00
and tool_capabilities then
if tool_capabilities.punch_attack_uses then
-- Without this delay, the wear does not work. Quite hacky ...
minetest.after ( 0 , function ( name )
local player = minetest.get_player_by_name ( name )
if not player then return end
local weapon = hitter : get_wielded_item ( player )
local def = weapon : get_definition ( )
if def.tool_capabilities and def.tool_capabilities . punch_attack_uses then
2021-04-11 18:52:31 +02:00
local wear = math_floor ( 65535 / tool_capabilities.punch_attack_uses )
2020-02-19 16:47:57 +01:00
weapon : add_wear ( wear )
hitter : set_wielded_item ( weapon )
end
end , hitter : get_player_name ( ) )
end
2017-01-16 17:40:08 +01:00
end
2019-03-09 01:57:51 +01:00
local die = false
2020-12-17 23:07:20 +01:00
-- only play hit sound and show blood effects if damage is 1 or over; lower to 0.1 to ensure armor works appropriately.
if damage >= 0.1 then
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- weapon sounds
if weapon : get_definition ( ) . sounds ~= nil then
2017-01-16 17:40:08 +01:00
2021-04-11 18:52:31 +02:00
local s = math_random ( 0 , # weapon : get_definition ( ) . sounds )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
minetest.sound_play ( weapon : get_definition ( ) . sounds [ s ] , {
2017-11-04 00:22:43 +01:00
object = self.object , --hitter,
2017-05-25 10:33:19 +02:00
max_hear_distance = 8
2020-04-07 00:55:45 +02:00
} , true )
2017-05-25 10:33:19 +02:00
else
minetest.sound_play ( " default_punch " , {
2020-12-06 15:46:42 +01:00
object = self.object ,
2017-05-25 10:33:19 +02:00
max_hear_distance = 5
2020-04-07 00:55:45 +02:00
} , true )
2017-05-25 10:33:19 +02:00
end
2017-01-16 17:40:08 +01:00
2019-10-03 11:53:26 +02:00
damage_effect ( self , damage )
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- do damage
2020-12-17 23:07:20 +01:00
self.health = self.health - damage
2017-01-16 17:40:08 +01:00
2019-03-09 01:57:51 +01:00
-- skip future functions if dead, except alerting others
if check_for_death ( self , " hit " , { type = " punch " , puncher = hitter } ) then
die = true
2017-05-25 10:33:19 +02:00
end
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- knock back effect (only on full punch)
2019-03-09 01:57:51 +01:00
if not die
and self.knock_back
2017-05-25 10:33:19 +02:00
and tflp >= punch_interval then
2017-01-16 17:40:08 +01:00
2019-03-06 04:38:57 +01:00
local v = self.object : get_velocity ( )
2021-04-11 18:52:31 +02:00
local r = 1.4 - math_min ( punch_interval , 1.4 )
2019-01-28 00:55:41 +01:00
local kb = r * 2.0
2017-05-25 10:33:19 +02:00
local up = 2
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- if already in air then dont go up anymore when hit
2021-02-12 00:27:55 +01:00
if v.y ~= 0
2017-05-25 10:33:19 +02:00
or self.fly then
up = 0
end
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
-- direction error check
dir = dir or { x = 0 , y = 0 , z = 0 }
2017-11-04 00:22:43 +01:00
-- check if tool already has specific knockback value
if tool_capabilities.damage_groups [ " knockback " ] then
kb = tool_capabilities.damage_groups [ " knockback " ]
else
kb = kb * 1.5
end
2021-01-11 16:38:05 +01:00
local luaentity
if hitter then
luaentity = hitter : get_luaentity ( )
end
2021-02-05 13:34:49 +01:00
if hitter and is_player then
2021-01-11 16:38:05 +01:00
local wielditem = hitter : get_wielded_item ( )
kb = kb + 3 * mcl_enchanting.get_enchantment ( wielditem , " knockback " )
elseif luaentity and luaentity._knockback then
kb = kb + luaentity._knockback
end
2019-03-06 04:38:57 +01:00
self.object : set_velocity ( {
2017-05-25 10:33:19 +02:00
x = dir.x * kb ,
2021-02-05 11:36:48 +01:00
y = dir.y * kb + up * 2 ,
2017-05-25 10:33:19 +02:00
z = dir.z * kb
} )
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
self.pause_timer = 0.25
2017-05-25 10:33:19 +02:00
end
end -- END if damage
2017-01-16 17:40:08 +01:00
-- if skittish then run away
2020-12-05 14:16:07 +01:00
if not die and self.runaway == true and self.state ~= " flop " then
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
local lp = hitter : get_pos ( )
local s = self.object : get_pos ( )
2017-01-16 17:40:08 +01:00
local vec = {
x = lp.x - s.x ,
y = lp.y - s.y ,
z = lp.z - s.z
}
2021-04-11 18:52:31 +02:00
local yaw = ( atan ( vec.z / vec.x ) + 3 * math_pi / 2 ) - self.rotate
2017-01-16 17:40:08 +01:00
if lp.x > s.x then
2021-04-11 18:52:31 +02:00
yaw = yaw + math_pi
2017-01-16 17:40:08 +01:00
end
2018-05-29 17:00:30 +02:00
yaw = set_yaw ( self , yaw , 6 )
2017-01-16 17:40:08 +01:00
self.state = " runaway "
self.runaway_timer = 0
self.following = nil
end
2017-05-25 10:33:19 +02:00
local name = hitter : get_player_name ( ) or " "
2017-01-16 17:40:08 +01:00
-- attack puncher and call other mobs for help
if self.passive == false
and self.state ~= " flop "
2019-03-08 23:52:41 +01:00
and ( self.child == false or self.type == " monster " )
2017-01-16 17:40:08 +01:00
and hitter : get_player_name ( ) ~= self.owner
2017-05-25 10:33:19 +02:00
and not mobs.invis [ name ] then
2017-01-16 17:40:08 +01:00
2019-03-09 01:57:51 +01:00
if not die then
-- attack whoever punched mob
self.state = " "
do_attack ( self , hitter )
end
2017-01-16 17:40:08 +01:00
-- alert others to the attack
2017-11-04 00:22:43 +01:00
local objs = minetest.get_objects_inside_radius ( hitter : get_pos ( ) , self.view_range )
2017-01-16 17:40:08 +01:00
local obj = nil
for n = 1 , # objs do
obj = objs [ n ] : get_luaentity ( )
if obj then
2019-03-09 01:50:00 +01:00
-- only alert members of same mob or friends
if obj.group_attack
2017-05-25 10:33:19 +02:00
and obj.state ~= " attack "
2019-03-09 01:50:00 +01:00
and obj.owner ~= name then
if obj.name == self.name then
do_attack ( obj , hitter )
elseif type ( obj.group_attack ) == " table " then
for i = 1 , # obj.group_attack do
if obj.name == obj.group_attack [ i ] then
do_attack ( obj , hitter )
break
end
end
end
2015-06-29 19:55:56 +02:00
end
2017-05-25 10:33:19 +02:00
-- have owned mobs attack player threat
if obj.owner == name and obj.owner_loyal then
do_attack ( obj , self.object )
end
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
end
end
end
2020-02-22 20:47:25 +01:00
local mob_detach_child = function ( self , child )
if self.driver == child then
self.driver = nil
end
end
2017-05-25 10:33:19 +02:00
-- get entity staticdata
local mob_staticdata = function ( self )
2020-12-17 16:22:34 +01:00
--[[
2017-05-25 10:33:19 +02:00
-- remove mob when out of range unless tamed
if remove_far
2018-09-14 14:48:48 +02:00
and self.can_despawn
2017-05-25 10:33:19 +02:00
and self.remove_ok
2018-09-14 14:48:48 +02:00
and ( ( not self.nametag ) or ( self.nametag == " " ) )
and self.lifetimer <= 20 then
2017-05-25 10:33:19 +02:00
2021-01-06 10:36:57 +01:00
minetest.log ( " action " , " Mob " .. name .. " despawns in mob_staticdata at " .. minetest.pos_to_string ( self.object . get_pos ( ) , 1 ) )
2021-01-02 10:56:40 +01:00
mcl_burning.extinguish ( self.object )
2017-05-25 10:33:19 +02:00
self.object : remove ( )
return " " -- nil
end
2020-12-17 16:22:34 +01:00
--]]
2017-05-25 10:33:19 +02:00
self.remove_ok = true
self.attack = nil
self.following = nil
self.state = " stand "
2017-07-05 01:52:39 +02:00
if use_cmi then
self.serialized_cmi_components = cmi.serialize_components ( self._cmi_components )
end
2017-05-25 10:33:19 +02:00
local tmp = { }
for _ , stat in pairs ( self ) do
local t = type ( stat )
if t ~= " function "
and t ~= " nil "
2017-07-05 01:52:39 +02:00
and t ~= " userdata "
and _ ~= " _cmi_components " then
2017-05-25 10:33:19 +02:00
tmp [ _ ] = self [ _ ]
end
end
return minetest.serialize ( tmp )
end
-- activate mob and reload settings
2017-07-05 01:52:39 +02:00
local mob_activate = function ( self , staticdata , def , dtime )
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
-- remove monsters in peaceful mode
if self.type == " monster "
2020-01-06 13:46:43 +01:00
and minetest.settings : get_bool ( " only_peaceful_mobs " , false ) then
2021-01-02 10:56:40 +01:00
mcl_burning.extinguish ( self.object )
2017-01-16 17:40:08 +01:00
self.object : remove ( )
return
end
-- load entity variables
local tmp = minetest.deserialize ( staticdata )
if tmp then
for _ , stat in pairs ( tmp ) do
self [ _ ] = stat
end
end
-- select random texture, set model and size
if not self.base_texture then
2017-05-25 10:33:19 +02:00
-- compatiblity with old simple mobs textures
if type ( def.textures [ 1 ] ) == " string " then
def.textures = { def.textures }
end
2021-04-11 18:52:31 +02:00
self.base_texture = def.textures [ math_random ( 1 , # def.textures ) ]
2017-01-16 17:40:08 +01:00
self.base_mesh = def.mesh
self.base_size = self.visual_size
self.base_colbox = self.collisionbox
2018-01-08 02:03:31 +01:00
self.base_selbox = self.selectionbox
2017-01-16 17:40:08 +01:00
end
2018-01-26 18:06:32 +01:00
-- for current mobs that dont have this set
if not self.base_selbox then
self.base_selbox = self.selectionbox or self.base_colbox
end
2017-01-16 17:40:08 +01:00
-- 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
2018-01-08 02:03:31 +01:00
local selbox = self.base_selbox
2017-01-16 17:40:08 +01:00
-- 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
}
2018-01-08 02:03:31 +01:00
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
}
2017-01-16 17:40:08 +01:00
end
if self.health == 0 then
2021-04-11 18:52:31 +02:00
self.health = math_random ( self.hp_min , self.hp_max )
2017-01-16 17:40:08 +01:00
end
2019-10-02 18:28:28 +02:00
if self.breath == nil then
self.breath = self.breath_max
end
2017-01-16 17:40:08 +01:00
2017-11-04 00:22:43 +01:00
-- pathfinding init
2017-01-16 17:40:08 +01:00
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
2020-02-19 16:47:57 +01:00
-- Armor groups
-- immortal=1 because we use custom health
-- handling (using "health" property)
2020-01-30 16:12:25 +01:00
local armor
if type ( self.armor ) == " table " then
armor = table.copy ( self.armor )
armor.immortal = 1
else
armor = { immortal = 1 , fleshy = self.armor }
end
self.object : set_armor_groups ( armor )
2017-11-04 00:22:43 +01:00
self.old_y = self.object : get_pos ( ) . y
2017-01-16 17:40:08 +01:00
self.old_health = self.health
self.sounds . distance = self.sounds . distance or 10
self.textures = textures
self.mesh = mesh
self.collisionbox = colbox
2018-01-08 02:03:31 +01:00
self.selectionbox = selbox
2017-01-16 17:40:08 +01:00
self.visual_size = vis_size
2020-01-29 23:11:20 +01:00
self.standing_in = " ignore "
self.standing_on = " ignore "
2019-01-31 02:44:05 +01:00
self.jump_sound_cooloff = 0 -- used to prevent jump sound from being played too often in short time
2019-01-31 06:31:04 +01:00
self.opinion_sound_cooloff = 0 -- used to prevent sound spam of particular sound types
2017-01-16 17:40:08 +01:00
2019-09-10 16:00:41 +02:00
self.texture_mods = { }
2020-01-06 17:28:08 +01:00
self.object : set_texture_mod ( " " )
self.v_start = false
self.timer = 0
self.blinktimer = 0
self.blinkstatus = false
2019-09-10 16:00:41 +02:00
2017-11-04 00:22:43 +01:00
-- check existing nametag
if not self.nametag then
self.nametag = def.nametag
end
2017-01-16 17:40:08 +01:00
-- set anything changed above
self.object : set_properties ( self )
2021-04-11 18:52:31 +02:00
set_yaw ( self , ( math_random ( 0 , 360 ) - 180 ) / 180 * math_pi , 6 )
2017-02-19 21:39:51 +01:00
update_tag ( self )
2017-07-26 16:55:36 +02:00
set_animation ( self , " stand " )
2017-07-05 01:52:39 +02:00
2017-11-04 00:22:43 +01:00
-- run on_spawn function if found
if self.on_spawn and not self.on_spawn_run then
if self.on_spawn ( self ) then
self.on_spawn_run = true -- if true, set flag to run once only
end
end
-- run after_activate
if def.after_activate then
def.after_activate ( self , staticdata , def , dtime )
end
2017-07-05 01:52:39 +02:00
if use_cmi then
self._cmi_components = cmi.activate_components ( self.serialized_cmi_components )
cmi.notify_activate ( self.object , dtime )
end
2017-01-16 17:40:08 +01:00
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
local mob_step = function ( self , dtime )
2021-01-02 21:42:07 +01:00
2021-04-11 20:47:56 +02:00
if not self or not self.object or not self.object : get_luaentity ( ) then
return false
end
-- can mob be pushed, if so calculate direction -- do this first to prevent issues
-- you can push mobs when they're in the dead state
if self.pushable then
collision ( self )
end
2020-12-24 17:48:40 +01:00
if not self.fire_resistant then
2020-12-29 22:08:38 +01:00
mcl_burning.tick ( self.object , dtime )
2020-12-24 17:48:40 +01:00
end
2021-01-02 21:42:07 +01:00
2017-07-05 01:52:39 +02:00
if use_cmi then
cmi.notify_step ( self.object , dtime )
end
2017-11-04 00:22:43 +01:00
local pos = self.object : get_pos ( )
2017-05-25 10:33:19 +02:00
local yaw = 0
2017-01-16 17:40:08 +01:00
2020-12-05 13:51:29 +01:00
if mobs_debug then
update_tag ( self )
end
if self.state == " die " then
return
2020-12-05 01:30:16 +01:00
end
2019-01-31 02:44:05 +01:00
if self.jump_sound_cooloff > 0 then
self.jump_sound_cooloff = self.jump_sound_cooloff - dtime
end
2021-04-11 20:47:56 +02:00
2019-01-31 06:31:04 +01:00
if self.opinion_sound_cooloff > 0 then
self.opinion_sound_cooloff = self.opinion_sound_cooloff - dtime
end
2021-04-11 20:47:56 +02:00
2020-04-12 23:11:18 +02:00
if falling ( self , pos ) then
-- Return if mob died after falling
return
end
2017-01-16 17:40:08 +01:00
2018-05-29 17:00:30 +02:00
-- smooth rotation by ThomasMonroe314
if self.delay and self.delay > 0 then
2020-04-05 21:09:27 +02:00
local yaw = self.object : get_yaw ( ) or 0
2018-05-29 17:00:30 +02:00
if self.delay == 1 then
yaw = self.target_yaw
else
2021-04-11 18:52:31 +02:00
local dif = math_abs ( yaw - self.target_yaw )
2018-05-29 17:00:30 +02:00
if yaw > self.target_yaw then
2021-04-11 18:52:31 +02:00
if dif > math_pi then
dif = 2 * math_pi - dif -- need to add
2018-05-29 17:00:30 +02:00
yaw = yaw + dif / self.delay
else
yaw = yaw - dif / self.delay -- need to subtract
end
elseif yaw < self.target_yaw then
2021-04-11 18:52:31 +02:00
if dif > math_pi then
dif = 2 * math_pi - dif
2018-05-29 17:00:30 +02:00
yaw = yaw - dif / self.delay -- need to subtract
else
yaw = yaw + dif / self.delay -- need to add
end
end
2021-04-11 18:52:31 +02:00
if yaw > ( math_pi * 2 ) then yaw = yaw - ( math_pi * 2 ) end
if yaw < 0 then yaw = yaw + ( math_pi * 2 ) end
2018-05-29 17:00:30 +02:00
end
self.delay = self.delay - 1
2021-01-23 15:40:12 +01:00
if self.shaking then
2021-04-11 18:52:31 +02:00
yaw = yaw + ( math_random ( ) * 2 - 1 ) * 5 * dtime
2021-01-23 15:40:12 +01:00
end
2018-05-29 17:00:30 +02:00
self.object : set_yaw ( yaw )
2021-03-25 09:24:38 +01:00
update_roll ( self )
2018-05-29 17:00:30 +02:00
end
-- end rotation
2017-01-16 17:40:08 +01:00
-- run custom function (defined in mob lua file)
if self.do_custom then
-- when false skip going any further
if self.do_custom ( self , dtime ) == false then
return
end
end
2021-04-06 14:50:34 +02:00
-- knockback timer
if self.pause_timer > 0 then
self.pause_timer = self.pause_timer - dtime
return
end
2017-01-16 17:40:08 +01:00
-- attack timer
self.timer = self.timer + dtime
2021-04-12 00:29:32 +02:00
--[[
2017-01-16 17:40:08 +01:00
if self.state ~= " attack " then
if self.timer < 1 then
2021-04-12 00:29:32 +02:00
print ( " returning>>error code 1 " )
2017-01-16 17:40:08 +01:00
return
end
self.timer = 0
end
2021-04-12 00:29:32 +02:00
] ] --
2017-01-16 17:40:08 +01:00
-- never go over 100
if self.timer > 100 then
self.timer = 1
end
-- mob plays random sound at times
2021-04-11 18:52:31 +02:00
if math_random ( 1 , 70 ) == 1 then
2019-12-09 12:17:51 +01:00
mob_sound ( self , " random " , true )
2017-01-16 17:40:08 +01:00
end
-- environmental damage timer (every 1 second)
self.env_damage_timer = self.env_damage_timer + dtime
if ( self.state == " attack " and self.env_damage_timer > 1 )
or self.state ~= " attack " then
self.env_damage_timer = 0
2018-05-29 17:00:30 +02:00
-- check for environmental damage (water, fire, lava etc.)
2020-03-29 23:24:04 +02:00
if do_env_damage ( self ) then
return
end
2018-05-29 17:00:30 +02:00
-- node replace check (cow eats grass etc.)
replace ( self , pos )
2017-01-16 17:40:08 +01:00
end
monster_attack ( self )
npc_attack ( self )
breed ( self )
2020-04-08 15:03:03 +02:00
if do_states ( self , dtime ) then
return
end
2017-01-16 17:40:08 +01:00
2017-05-25 10:33:19 +02:00
do_jump ( self )
2018-01-26 18:06:32 +01:00
runaway_from ( self )
2020-07-31 15:35:40 +02:00
if is_at_water_danger ( self ) and self.state ~= " attack " then
2021-04-11 18:52:31 +02:00
if math_random ( 1 , 10 ) <= 6 then
2020-07-31 15:35:40 +02:00
set_velocity ( self , 0 )
self.state = " stand "
set_animation ( self , " stand " )
2021-04-11 18:52:31 +02:00
yaw = yaw + math_random ( - 0.5 , 0.5 )
2020-07-31 15:35:40 +02:00
yaw = set_yaw ( self , yaw , 8 )
end
end
2021-04-11 20:21:19 +02:00
2020-12-03 17:37:44 +01:00
-- Add water flowing for mobs from mcl_item_entity
2020-12-03 20:48:26 +01:00
local p , node , nn , def
p = self.object : get_pos ( )
node = minetest.get_node_or_nil ( p )
if node then
nn = node.name
def = minetest.registered_nodes [ nn ]
end
2020-12-03 17:37:44 +01:00
-- Move item around on flowing liquids
if def and def.liquidtype == " flowing " then
2021-04-11 20:47:56 +02:00
2020-12-03 17:37:44 +01:00
--[[ Get flowing direction (function call from flowlib), if there's a liquid.
NOTE : According to Qwertymine , flowlib.quickflow is only reliable for liquids with a flowing distance of 7.
Luckily , this is exactly what we need if we only care about water , which has this flowing distance . ] ]
local vec = flowlib.quick_flow ( p , node )
-- Just to make sure we don't manipulate the speed for no reason
if vec.x ~= 0 or vec.y ~= 0 or vec.z ~= 0 then
-- Minecraft Wiki: Flowing speed is "about 1.39 meters per second"
local f = 1.39
-- Set new item moving speed into the direciton of the liquid
local newv = vector.multiply ( vec , f )
self.object : set_acceleration ( { x = 0 , y = 0 , z = 0 } )
self.object : set_velocity ( { x = newv.x , y = - 0.22 , z = newv.z } )
self.physical_state = true
self._flowing = true
self.object : set_properties ( {
physical = true
} )
return
end
elseif self._flowing == true then
-- Disable flowing physics if not on/in flowing liquid
self._flowing = false
enable_physics ( self.object , self , true )
return
end
--Mob following code.
2020-07-31 15:35:40 +02:00
follow_flop ( self )
2018-01-26 18:06:32 +01:00
2020-07-25 04:15:40 +02:00
if is_at_cliff_or_danger ( self ) then
set_velocity ( self , 0 )
self.state = " stand "
set_animation ( self , " stand " )
2020-12-22 15:29:24 +01:00
local yaw = self.object : get_yaw ( ) or 0
yaw = set_yaw ( self , yaw + 0.78 , 8 )
2020-07-25 04:15:40 +02:00
end
2020-12-17 16:22:34 +01:00
-- Despawning: when lifetimer expires, remove mob
if remove_far
and self.can_despawn == true
2021-01-25 00:47:28 +01:00
and ( ( not self.nametag ) or ( self.nametag == " " ) )
and self.state ~= " attack "
and self.following == nil then
2020-12-17 16:22:34 +01:00
self.lifetimer = self.lifetimer - dtime
2021-01-06 02:09:05 +01:00
if self.despawn_immediately or self.lifetimer <= 0 then
minetest.log ( " action " , " Mob " .. self.name .. " despawns in mob_step at " .. minetest.pos_to_string ( pos , 1 ) )
mcl_burning.extinguish ( self.object )
self.object : remove ( )
elseif self.lifetimer <= 10 then
2021-04-11 18:52:31 +02:00
if math_random ( 10 ) < 4 then
2021-01-06 02:09:05 +01:00
self.despawn_immediately = true
2021-01-04 16:40:18 +01:00
else
self.lifetimer = 20
2020-12-17 16:22:34 +01:00
end
end
end
2017-01-16 17:40:08 +01:00
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
-- default function when mobs are blown up with TNT
local do_tnt = function ( obj , damage )
obj.object : punch ( obj.object , 1.0 , {
full_punch_interval = 1.0 ,
damage_groups = { fleshy = damage } ,
} , nil )
return false , true , { }
end
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
mobs.spawning_mobs = { }
2018-05-30 11:34:17 +02:00
-- Code to execute before custom on_rightclick handling
local on_rightclick_prefix = function ( self , clicker )
local item = clicker : get_wielded_item ( )
-- Name mob with nametag
2018-05-31 18:32:26 +02:00
if not self.ignores_nametag and item : get_name ( ) == " mcl_mobs:nametag " then
2018-05-30 11:34:17 +02:00
local tag = item : get_meta ( ) : get_string ( " name " )
if tag ~= " " then
if string.len ( tag ) > MAX_MOB_NAME_LENGTH then
tag = string.sub ( tag , 1 , MAX_MOB_NAME_LENGTH )
end
self.nametag = tag
update_tag ( self )
2018-07-02 23:27:11 +02:00
if not mobs.is_creative ( clicker : get_player_name ( ) ) then
2018-05-30 11:34:17 +02:00
item : take_item ( )
2018-07-04 01:53:08 +02:00
clicker : set_wielded_item ( item )
2018-05-30 11:34:17 +02:00
end
return true
end
end
return false
end
local create_mob_on_rightclick = function ( on_rightclick )
return function ( self , clicker )
local stop = on_rightclick_prefix ( self , clicker )
if ( not stop ) and ( on_rightclick ) then
on_rightclick ( self , clicker )
end
end
end
2017-05-25 10:33:19 +02:00
-- register mob entity
2017-01-16 17:40:08 +01:00
function mobs : register_mob ( name , def )
mobs.spawning_mobs [ name ] = true
2018-09-14 14:48:48 +02:00
local can_despawn
if def.can_despawn ~= nil then
can_despawn = def.can_despawn
2021-04-03 19:12:24 +02:00
elseif def.spawn_class == " passive " then
can_despawn = false
2018-09-14 14:48:48 +02:00
else
2019-01-31 22:00:43 +01:00
can_despawn = true
2018-09-14 14:48:48 +02:00
end
2019-10-02 18:28:28 +02:00
local function scale_difficulty ( value , default , min , special )
if ( not value ) or ( value == default ) or ( value == special ) then
return default
else
2021-04-11 18:52:31 +02:00
return math_max ( min , value * difficulty )
2019-10-02 18:28:28 +02:00
end
end
2020-01-06 14:46:10 +01:00
local collisionbox = def.collisionbox or { - 0.25 , - 0.25 , - 0.25 , 0.25 , 0.25 , 0.25 }
-- Workaround for <https://github.com/minetest/minetest/issues/5966>:
-- Increase upper Y limit to avoid mobs glitching through solid nodes.
-- FIXME: Remove workaround if it's no longer needed.
if collisionbox [ 5 ] < 0.79 then
collisionbox [ 5 ] = 0.79
end
2017-01-16 17:40:08 +01:00
minetest.register_entity ( name , {
2021-02-22 02:10:04 +01:00
use_texture_alpha = def.use_texture_alpha ,
2020-01-06 14:46:10 +01:00
stepheight = def.stepheight or 0.6 ,
2017-01-16 17:40:08 +01:00
name = name ,
type = def.type ,
attack_type = def.attack_type ,
fly = def.fly ,
2020-01-30 16:52:07 +01:00
fly_in = def.fly_in or { " air " , " __airlike " } ,
2017-01-16 17:40:08 +01:00
owner = def.owner or " " ,
order = def.order or " " ,
on_die = def.on_die ,
2019-02-05 19:12:28 +01:00
spawn_small_alternative = def.spawn_small_alternative ,
2017-01-16 17:40:08 +01:00
do_custom = def.do_custom ,
2017-05-25 10:33:19 +02:00
jump_height = def.jump_height or 4 , -- was 6
2017-01-16 17:40:08 +01:00
rotate = math.rad ( def.rotate or 0 ) , -- 0=front, 90=side, 180=back, 270=side2
2018-09-14 14:48:48 +02:00
lifetimer = def.lifetimer or 57.73 ,
2019-10-02 18:28:28 +02:00
hp_min = scale_difficulty ( def.hp_min , 5 , 1 ) ,
hp_max = scale_difficulty ( def.hp_max , 10 , 1 ) ,
2020-12-06 15:46:42 +01:00
xp_min = def.xp_min or 0 ,
xp_max = def.xp_max or 0 ,
2021-02-05 13:34:49 +01:00
xp_timestamp = 0 ,
2019-10-03 12:12:50 +02:00
breath_max = def.breath_max or 15 ,
2019-10-02 18:28:28 +02:00
breathes_in_water = def.breathes_in_water or false ,
2017-01-16 17:40:08 +01:00
physical = true ,
2020-01-06 14:46:10 +01:00
collisionbox = collisionbox ,
2018-01-08 02:03:31 +01:00
selectionbox = def.selectionbox or def.collisionbox ,
2017-01-16 17:40:08 +01:00
visual = def.visual ,
visual_size = def.visual_size or { x = 1 , y = 1 } ,
mesh = def.mesh ,
makes_footstep_sound = def.makes_footstep_sound or false ,
2019-03-09 01:04:18 +01:00
view_range = def.view_range or 16 ,
2017-01-16 17:40:08 +01:00
walk_velocity = def.walk_velocity or 1 ,
run_velocity = def.run_velocity or 2 ,
2019-10-02 18:28:28 +02:00
damage = scale_difficulty ( def.damage , 0 , 0 ) ,
2017-01-16 17:40:08 +01:00
light_damage = def.light_damage or 0 ,
2018-05-31 03:09:27 +02:00
sunlight_damage = def.sunlight_damage or 0 ,
2017-01-16 17:40:08 +01:00
water_damage = def.water_damage or 0 ,
2019-10-02 18:28:28 +02:00
lava_damage = def.lava_damage or 8 ,
2019-10-02 18:43:48 +02:00
fire_damage = def.fire_damage or 1 ,
2019-01-31 07:23:35 +01:00
suffocation = def.suffocation or true ,
2017-01-16 17:40:08 +01:00
fall_damage = def.fall_damage or 1 ,
2020-12-05 12:59:12 +01:00
fall_speed = def.fall_speed or DEFAULT_FALL_SPEED , -- must be lower than -2
2017-01-16 17:40:08 +01:00
drops = def.drops or { } ,
armor = def.armor or 100 ,
2018-05-30 11:34:17 +02:00
on_rightclick = create_mob_on_rightclick ( def.on_rightclick ) ,
2017-01-16 17:40:08 +01:00
arrow = def.arrow ,
shoot_interval = def.shoot_interval ,
sounds = def.sounds or { } ,
animation = def.animation ,
follow = def.follow ,
2017-05-25 10:33:19 +02:00
jump = def.jump ~= false ,
2017-01-16 17:40:08 +01:00
walk_chance = def.walk_chance or 50 ,
attacks_monsters = def.attacks_monsters or false ,
group_attack = def.group_attack or false ,
passive = def.passive or false ,
2018-05-29 17:00:30 +02:00
knock_back = def.knock_back ~= false ,
2017-01-16 17:40:08 +01:00
shoot_offset = def.shoot_offset or 0 ,
floats = def.floats or 1 , -- floats in water by default
2021-03-22 01:53:57 +01:00
floats_on_lava = def.floats_on_lava or 0 ,
2017-01-16 17:40:08 +01:00
replace_rate = def.replace_rate ,
replace_what = def.replace_what ,
replace_with = def.replace_with ,
replace_offset = def.replace_offset or 0 ,
2017-07-05 01:52:39 +02:00
on_replace = def.on_replace ,
2017-01-16 17:40:08 +01:00
timer = 0 ,
2020-05-13 22:15:46 +02:00
env_damage_timer = 0 ,
2017-01-16 17:40:08 +01:00
tamed = false ,
pause_timer = 0 ,
horny = false ,
hornytimer = 0 ,
gotten = false ,
health = 0 ,
reach = def.reach or 3 ,
htimer = 0 ,
texture_list = def.textures ,
child_texture = def.child_texture ,
docile_by_day = def.docile_by_day or false ,
time_of_day = 0.5 ,
fear_height = def.fear_height or 0 ,
runaway = def.runaway ,
runaway_timer = 0 ,
pathfinding = def.pathfinding ,
immune_to = def.immune_to or { } ,
2020-05-02 18:50:25 +02:00
explosion_radius = def.explosion_radius , -- LEGACY
explosion_damage_radius = def.explosion_damage_radius , -- LEGACY
2021-02-12 00:27:55 +01:00
explosiontimer_reset_radius = def.explosiontimer_reset_radius ,
2017-11-04 00:22:43 +01:00
explosion_timer = def.explosion_timer or 3 ,
2018-03-31 00:18:40 +02:00
allow_fuse_reset = def.allow_fuse_reset ~= false ,
stop_to_explode = def.stop_to_explode ~= false ,
2017-01-16 17:40:08 +01:00
custom_attack = def.custom_attack ,
double_melee_attack = def.double_melee_attack ,
dogshoot_switch = def.dogshoot_switch ,
dogshoot_count = 0 ,
dogshoot_count_max = def.dogshoot_count_max or 5 ,
2017-05-25 10:33:19 +02:00
dogshoot_count2_max = def.dogshoot_count2_max or ( def.dogshoot_count_max or 5 ) ,
2017-01-16 17:40:08 +01:00
attack_animals = def.attack_animals or false ,
specific_attack = def.specific_attack ,
2018-01-26 18:06:32 +01:00
runaway_from = def.runaway_from ,
2017-05-25 10:33:19 +02:00
owner_loyal = def.owner_loyal ,
2017-11-04 00:22:43 +01:00
facing_fence = false ,
2017-07-05 01:52:39 +02:00
_cmi_is_mob = true ,
2020-12-03 17:37:44 +01:00
pushable = def.pushable or true ,
2017-01-16 17:40:08 +01:00
2018-05-30 11:34:17 +02:00
-- MCL2 extensions
2020-06-08 07:51:48 +02:00
teleport = teleport ,
do_teleport = def.do_teleport ,
2020-04-11 02:46:03 +02:00
spawn_class = def.spawn_class ,
2018-05-30 11:34:17 +02:00
ignores_nametag = def.ignores_nametag or false ,
2018-05-30 12:01:53 +02:00
rain_damage = def.rain_damage or 0 ,
2019-03-08 03:40:46 +01:00
glow = def.glow ,
2018-09-14 14:48:48 +02:00
can_despawn = can_despawn ,
2019-03-08 23:52:41 +01:00
child = def.child or false ,
2019-09-10 16:00:41 +02:00
texture_mods = { } ,
2019-12-09 09:29:19 +01:00
shoot_arrow = def.shoot_arrow ,
2019-12-09 12:17:51 +01:00
sounds_child = def.sounds_child ,
2020-05-02 18:50:25 +02:00
explosion_strength = def.explosion_strength ,
2020-05-13 22:15:46 +02:00
suffocation_timer = 0 ,
2020-08-03 15:37:58 +02:00
follow_velocity = def.follow_velocity or 2.4 ,
2020-12-05 14:42:03 +01:00
instant_death = def.instant_death or false ,
2020-12-24 17:48:40 +01:00
fire_resistant = def.fire_resistant or false ,
2020-12-29 22:08:38 +01:00
fire_damage_resistant = def.fire_damage_resistant or false ,
2021-01-02 12:43:50 +01:00
ignited_by_sunlight = def.ignited_by_sunlight or false ,
2019-03-08 23:52:41 +01:00
-- End of MCL2 extensions
2018-05-30 11:34:17 +02:00
2017-11-04 00:22:43 +01:00
on_spawn = def.on_spawn ,
2017-01-16 17:40:08 +01:00
on_blast = def.on_blast or do_tnt ,
on_step = mob_step ,
2017-11-04 00:22:43 +01:00
do_punch = def.do_punch ,
2017-01-16 17:40:08 +01:00
on_punch = mob_punch ,
2017-11-04 00:22:43 +01:00
on_breed = def.on_breed ,
on_grown = def.on_grown ,
2020-02-22 20:47:25 +01:00
on_detach_child = mob_detach_child ,
2017-07-05 01:52:39 +02:00
on_activate = function ( self , staticdata , dtime )
2021-04-08 05:07:04 +02:00
--this is a temporary hack so mobs stop
--glitching and acting really weird with the
--default built in engine collision detection
self.object : set_properties ( {
collide_with_objects = false ,
} )
2017-07-05 01:52:39 +02:00
return mob_activate ( self , staticdata , def , dtime )
2017-01-16 17:40:08 +01:00
end ,
get_staticdata = function ( self )
2017-05-25 10:33:19 +02:00
return mob_staticdata ( self )
2017-01-16 17:40:08 +01:00
end ,
2021-01-03 15:10:50 +01:00
2020-07-12 22:56:41 +02:00
harmed_by_heal = def.harmed_by_heal ,
2017-01-16 17:40:08 +01:00
} )
2019-01-28 00:04:12 +01:00
if minetest.get_modpath ( " doc_identifier " ) ~= nil then
doc.sub . identifier.register_object ( name , " basics " , " mobs " )
end
2017-01-16 17:40:08 +01:00
end -- END mobs:register_mob function
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
-- register arrow for shoot attack
2015-06-29 19:55:56 +02:00
function mobs : register_arrow ( name , def )
2017-01-16 17:40:08 +01:00
if not name or not def then return end -- errorcheck
2015-06-29 19:55:56 +02:00
minetest.register_entity ( name , {
2017-01-16 17:40:08 +01:00
2015-06-29 19:55:56 +02:00
physical = false ,
visual = def.visual ,
visual_size = def.visual_size ,
textures = def.textures ,
velocity = def.velocity ,
hit_player = def.hit_player ,
hit_node = def.hit_node ,
2017-01-16 17:40:08 +01:00
hit_mob = def.hit_mob ,
2020-01-30 23:11:16 +01:00
hit_object = def.hit_object ,
2017-01-16 17:40:08 +01:00
drop = def.drop or false , -- drops arrow as registered item when true
collisionbox = { 0 , 0 , 0 , 0 , 0 , 0 } , -- remove box around arrows
timer = 0 ,
switch = 0 ,
owner_id = def.owner_id ,
2017-05-25 10:33:19 +02:00
rotate = def.rotate ,
2021-04-04 03:07:51 +02:00
on_punch = function ( self )
local vel = self.object : get_velocity ( )
self.object : set_velocity ( { x = vel.x * - 1 , y = vel.y * - 1 , z = vel.z * - 1 } )
2017-11-04 00:22:43 +01:00
local pos = self.object : get_pos ( )
2017-01-16 17:40:08 +01:00
if self.switch == 0
or self.timer > 150
or not within_limits ( pos , 0 ) then
2021-01-02 10:56:40 +01:00
mcl_burning.extinguish ( self.object )
2018-06-03 00:56:29 +02:00
self.object : remove ( ) ;
2017-01-16 17:40:08 +01:00
2015-06-29 19:55:56 +02:00
return
end
2017-01-16 17:40:08 +01:00
-- does arrow have a tail (fireball)
if def.tail
and def.tail == 1
and def.tail_texture then
2017-05-25 10:33:19 +02:00
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 ,
2017-01-16 17:40:08 +01:00
texture = def.tail_texture ,
2017-05-25 10:33:19 +02:00
size = def.tail_size or 5 ,
glow = def.glow or 0 ,
2017-01-16 17:40:08 +01:00
} )
end
if self.hit_node then
local node = node_ok ( pos ) . name
if minetest.registered_nodes [ node ] . walkable then
self.hit_node ( self , 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
2018-06-03 00:56:29 +02:00
self.object : remove ( ) ;
2017-01-16 17:40:08 +01:00
2015-06-29 19:55:56 +02:00
return
end
end
2017-01-16 17:40:08 +01:00
2020-01-30 23:11:16 +01:00
if self.hit_player or self.hit_mob or self.hit_object then
2017-01-16 17:40:08 +01:00
2021-04-04 03:07:51 +02:00
for _ , player in pairs ( minetest.get_objects_inside_radius ( pos , 1.5 ) ) do
2017-01-16 17:40:08 +01:00
if self.hit_player
and player : is_player ( ) then
self.hit_player ( self , player )
2018-06-03 00:56:29 +02:00
self.object : remove ( ) ;
2017-01-16 17:40:08 +01:00
return
end
local entity = player : get_luaentity ( )
2017-07-25 04:30:23 +02:00
if entity
and self.hit_mob
and entity._cmi_is_mob == true
2017-01-16 17:40:08 +01:00
and tostring ( player ) ~= self.owner_id
2017-07-25 04:30:23 +02:00
and entity.name ~= self.object : get_luaentity ( ) . name then
2017-01-16 17:40:08 +01:00
self.hit_mob ( self , player )
2018-06-03 00:56:29 +02:00
self.object : remove ( ) ;
2020-01-30 23:11:16 +01:00
return
end
2017-01-16 17:40:08 +01:00
2020-01-30 23:11:16 +01:00
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 ( self , player )
self.object : remove ( ) ;
2017-01-16 17:40:08 +01:00
return
end
end
end
self.lastpos = pos
2015-06-29 19:55:56 +02:00
end
} )
end
2017-05-25 10:33:19 +02:00
2018-01-26 18:06:32 +01:00
-- no damage to nodes explosion
2020-05-02 19:05:56 +02:00
function mobs : safe_boom ( self , pos , strength )
2018-01-26 18:06:32 +01:00
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
2020-04-07 00:55:45 +02:00
} , true )
2020-07-16 20:26:41 +02:00
local radius = strength
2018-01-26 18:06:32 +01:00
entity_physics ( pos , radius )
2020-08-19 18:47:58 +02:00
effect ( pos , 32 , " mcl_particles_smoke.png " , radius * 3 , radius * 5 , radius , 1 , 0 )
2018-01-26 18:06:32 +01:00
end
2017-07-25 04:30:23 +02:00
-- make explosion with protection and tnt mod check
2020-05-02 19:05:56 +02:00
function mobs : boom ( self , pos , strength , fire )
2021-04-05 11:50:26 +02:00
self.object : remove ( )
2020-05-02 18:50:25 +02:00
if mod_explosions then
if mobs_griefing and not minetest.is_protected ( pos , " " ) then
2020-05-02 19:05:56 +02:00
mcl_explosions.explode ( pos , strength , { drop_chance = 1.0 , fire = fire } , self.object )
2020-05-02 18:50:25 +02:00
else
2020-05-02 19:05:56 +02:00
mobs : safe_boom ( self , pos , strength )
2020-05-02 18:50:25 +02:00
end
2017-07-25 04:30:23 +02:00
else
2020-07-16 20:26:41 +02:00
mobs : safe_boom ( self , pos , strength )
2017-07-25 04:30:23 +02:00
end
end
2017-07-05 01:52:39 +02:00
-- 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)
2017-01-16 17:40:08 +01:00
function mobs : register_egg ( mob , desc , background , addegg , no_creative )
2017-07-05 01:52:39 +02:00
local grp = { spawn_egg = 1 }
2017-01-16 17:40:08 +01:00
-- do NOT add this egg to creative inventory (e.g. dungeon master)
2020-07-10 16:46:47 +02:00
if no_creative == true then
2017-07-05 01:52:39 +02:00
grp.not_in_creative_inventory = 1
2017-01-16 17:40:08 +01:00
end
local invimg = background
if addegg == 1 then
invimg = " mobs_chicken_egg.png^( " .. invimg ..
" ^[mask:mobs_chicken_egg_overlay.png) "
end
2017-05-25 10:33:19 +02:00
-- register old stackable mob egg
minetest.register_craftitem ( mob , {
description = desc ,
inventory_image = invimg ,
groups = grp ,
2018-03-31 00:18:40 +02:00
2019-03-07 20:43:39 +01:00
_doc_items_longdesc = S ( " This allows you to place a single mob. " ) ,
_doc_items_usagehelp = S ( " Just place it where you want the mob to appear. Animals will spawn tamed, unless you hold down the sneak key while placing. If you place this on a mob spawner, you change the mob it spawns. " ) ,
2018-01-07 16:53:25 +01:00
2017-05-25 10:33:19 +02:00
on_place = function ( itemstack , placer , pointed_thing )
2017-01-16 17:40:08 +01:00
local pos = pointed_thing.above
2017-05-25 10:33:19 +02:00
-- am I clicking on something with existing on_rightclick function?
local under = minetest.get_node ( pointed_thing.under )
local def = minetest.registered_nodes [ under.name ]
2017-08-06 12:49:13 +02:00
if def and def.on_rightclick then
2017-05-25 10:33:19 +02:00
return def.on_rightclick ( pointed_thing.under , under , placer , itemstack )
end
2017-01-16 17:40:08 +01:00
if pos
and within_limits ( pos , 0 )
2017-08-06 12:49:13 +02:00
and not minetest.is_protected ( pos , placer : get_player_name ( ) ) then
2017-01-16 17:40:08 +01:00
2018-01-07 16:53:25 +01:00
local name = placer : get_player_name ( )
local privs = minetest.get_player_privs ( name )
2018-05-31 02:47:37 +02:00
if mod_mobspawners and under.name == " mcl_mobspawners:spawner " then
2019-02-08 22:17:51 +01:00
if minetest.is_protected ( pointed_thing.under , name ) then
minetest.record_protection_violation ( pointed_thing.under , name )
return itemstack
end
2019-02-08 17:55:14 +01:00
if not privs.maphack then
2019-03-07 20:43:39 +01:00
minetest.chat_send_player ( name , S ( " You need the “maphack” privilege to change the mob spawner. " ) )
2019-02-08 17:55:14 +01:00
return itemstack
end
2018-01-07 16:53:25 +01:00
mcl_mobspawners.setup_spawner ( pointed_thing.under , itemstack : get_name ( ) )
2020-07-10 16:08:40 +02:00
if not mobs.is_creative ( name ) then
2018-01-07 16:53:25 +01:00
itemstack : take_item ( )
end
return itemstack
end
2018-01-26 18:06:32 +01:00
if not minetest.registered_entities [ mob ] then
2018-05-29 17:00:30 +02:00
return itemstack
2018-01-26 18:06:32 +01:00
end
2020-01-06 13:46:43 +01:00
if minetest.settings : get_bool ( " only_peaceful_mobs " , false )
and minetest.registered_entities [ mob ] . type == " monster " then
minetest.chat_send_player ( name , S ( " Only peaceful mobs allowed! " ) )
return itemstack
end
2020-12-08 22:42:01 +01:00
pos.y = pos.y - 0.5
2017-01-16 17:40:08 +01:00
local mob = minetest.add_entity ( pos , mob )
2020-12-08 22:42:01 +01:00
minetest.log ( " action " , " Mob spawned: " .. name .. " at " .. minetest.pos_to_string ( pos ) )
2017-01-16 17:40:08 +01:00
local ent = mob : get_luaentity ( )
2017-11-04 00:22:43 +01:00
-- don't set owner if monster or sneak pressed
2017-07-05 01:52:39 +02:00
if ent.type ~= " monster "
2017-08-06 12:49:13 +02:00
and not placer : get_player_control ( ) . sneak then
2017-05-25 10:33:19 +02:00
ent.owner = placer : get_player_name ( )
ent.tamed = true
2017-01-16 17:40:08 +01:00
end
2018-05-29 17:00:30 +02:00
2018-02-04 07:11:44 +01:00
-- set nametag
local nametag = itemstack : get_meta ( ) : get_string ( " name " )
if nametag ~= " " then
if string.len ( nametag ) > MAX_MOB_NAME_LENGTH then
nametag = string.sub ( nametag , 1 , MAX_MOB_NAME_LENGTH )
end
ent.nametag = nametag
update_tag ( ent )
end
2017-01-16 17:40:08 +01:00
-- if not in creative then take item
2017-11-04 00:22:43 +01:00
if not mobs.is_creative ( placer : get_player_name ( ) ) then
2017-01-16 17:40:08 +01:00
itemstack : take_item ( )
end
end
return itemstack
end ,
} )
2017-05-25 10:33:19 +02:00
2017-01-16 17:40:08 +01:00
end
2017-05-25 10:33:19 +02:00
2018-05-31 17:54:35 +02:00
-- No-op in MCL2 (capturing mobs is not possible).
-- Provided for compability with Mobs Redo
2017-01-16 17:40:08 +01:00
function mobs : capture_mob ( self , clicker , chance_hand , chance_net , chance_lasso , force_take , replacewith )
2018-02-02 22:13:02 +01:00
return false
2017-05-25 10:33:19 +02:00
end
2019-03-08 23:17:42 +01:00
-- No-op in MCL2 (protecting mobs is not possible).
2017-05-25 10:33:19 +02:00
function mobs : protect ( self , clicker )
2019-03-08 23:17:42 +01:00
return false
2015-06-29 19:55:56 +02:00
end
2018-03-31 00:18:40 +02:00
2017-01-16 17:40:08 +01:00
-- feeding, taming and breeding (thanks blert2112)
function mobs : feed_tame ( self , clicker , feed_count , breed , tame )
if not self.follow then
return false
2015-06-29 19:55:56 +02:00
end
2017-01-16 17:40:08 +01:00
-- can eat/tame with item in hand
if follow_holding ( self , clicker ) then
-- if not in creative then take item
2017-11-04 00:22:43 +01:00
if not mobs.is_creative ( clicker : get_player_name ( ) ) then
2017-01-16 17:40:08 +01:00
local item = clicker : get_wielded_item ( )
item : take_item ( )
clicker : set_wielded_item ( item )
end
2020-12-05 23:37:12 +01:00
mob_sound ( self , " eat " , nil , true )
2017-01-16 17:40:08 +01:00
-- increase health
self.health = self.health + 4
if self.health >= self.hp_max then
self.health = self.hp_max
if self.htimer < 1 then
self.htimer = 5
end
end
self.object : set_hp ( self.health )
2017-02-19 21:39:51 +01:00
update_tag ( self )
2017-01-16 17:40:08 +01:00
-- make children grow quicker
if self.child == true then
2020-12-05 01:26:30 +01:00
-- deduct 10% of the time to adulthood
self.hornytimer = self.hornytimer + ( ( CHILD_GROW_TIME - self.hornytimer ) * 0.1 )
2017-01-16 17:40:08 +01:00
return true
end
-- feed and tame
self.food = ( self.food or 0 ) + 1
if self.food >= feed_count then
self.food = 0
if breed and self.hornytimer == 0 then
self.horny = true
end
if tame then
self.tamed = true
if not self.owner or self.owner == " " then
self.owner = clicker : get_player_name ( )
end
end
-- make sound when fed so many times
2019-12-09 12:17:51 +01:00
mob_sound ( self , " random " , true )
2017-01-16 17:40:08 +01:00
end
return true
end
2018-02-02 17:33:52 +01:00
return false
end
2017-05-25 10:33:19 +02:00
2018-05-30 12:56:39 +02:00
-- Spawn a child
function mobs : spawn_child ( pos , mob_type )
local child = minetest.add_entity ( pos , mob_type )
if not child then
return
end
local ent = child : get_luaentity ( )
2020-08-19 18:47:58 +02:00
effect ( pos , 15 , " mcl_particles_smoke.png " , 1 , 2 , 2 , 15 , 5 )
2018-05-30 12:56:39 +02:00
ent.child = true
local textures
-- using specific child texture (if found)
if ent.child_texture then
textures = ent.child_texture [ 1 ]
end
-- and resize to half height
child : 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 ,
} ,
} )
return child
end
2018-05-29 17:00:30 +02:00
2017-01-16 17:40:08 +01:00
-- compatibility function for old entities to new modpack entities
function mobs : alias_mob ( old_name , new_name )
-- spawn egg
minetest.register_alias ( old_name , new_name )
-- entity
minetest.register_entity ( " : " .. old_name , {
physical = false ,
on_step = function ( self )
2017-11-04 00:22:43 +01:00
if minetest.registered_entities [ new_name ] then
2018-05-29 17:00:30 +02:00
minetest.add_entity ( self.object : get_pos ( ) , new_name )
2017-11-04 00:22:43 +01:00
end
2017-01-16 17:40:08 +01:00
self.object : remove ( )
end
} )
2019-01-28 00:04:12 +01:00
2017-01-16 17:40:08 +01:00
end
2021-01-04 16:40:18 +01:00
2021-04-06 16:40:16 +02:00
--[[
2021-01-06 02:09:05 +01:00
local timer = 0
minetest.register_globalstep ( function ( dtime )
timer = timer + dtime
if timer < 1 then return end
2021-03-16 17:35:46 +01:00
for _ , player in pairs ( minetest.get_connected_players ( ) ) do
2021-01-04 16:40:18 +01:00
local pos = player : get_pos ( )
2021-03-16 17:35:46 +01:00
for _ , obj in pairs ( minetest.get_objects_inside_radius ( pos , 47 ) ) do
2021-01-04 16:40:18 +01:00
local lua = obj : get_luaentity ( )
if lua and lua._cmi_is_mob then
2021-01-06 02:09:05 +01:00
lua.lifetimer = math.max ( 20 , lua.lifetimer )
2021-01-04 16:40:18 +01:00
lua.despawn_immediately = false
end
end
end
2021-01-06 02:09:05 +01:00
timer = 0
2021-01-04 16:40:18 +01:00
end )
2021-04-06 16:40:16 +02:00
] ] --