Illuna-Minetest/mobs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Tidied code

Browse Source
This commit is contained in:
TenPlus1 2015-07-03 14:10:33 +01:00
parent c390fb0fe5
commit 7ed926a4c5
1 changed files with 93 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
api.lua
View File

@ -1,4 +1,4 @@
-- Mobs Api (1st July 2015) -- Mobs Api (3rd July 2015)
mobs = {} mobs = {}
mobs.mod = "redo" mobs.mod = "redo"
@ -27,7 +27,7 @@ function mobs:register_mob(name, def)
physical = true, physical = true,
collisionbox = def.collisionbox, collisionbox = def.collisionbox,
visual = def.visual, visual = def.visual,
visual_size = def.visual_size or {x=1, y=1}, visual_size = def.visual_size or {x = 1, y = 1},
mesh = def.mesh, mesh = def.mesh,
makes_footstep_sound = def.makes_footstep_sound or false, makes_footstep_sound = def.makes_footstep_sound or false,
view_range = def.view_range or 5, view_range = def.view_range or 5,
@ -97,12 +97,12 @@ function mobs:register_mob(name, def)
local yaw = self.object:getyaw() + self.rotate local yaw = self.object:getyaw() + self.rotate
local x = math.sin(yaw) * -v local x = math.sin(yaw) * -v
local z = math.cos(yaw) * v local z = math.cos(yaw) * v
self.object:setvelocity({x=x, y=self.object:getvelocity().y, z=z}) self.object:setvelocity({x = x, y = self.object:getvelocity().y, z = z})
end, end,
get_velocity = function(self) get_velocity = function(self)
local v = self.object:getvelocity() local v = self.object:getvelocity()
return (v.x^2 + v.z^2)^(0.5) return (v.x ^ 2 + v.z ^ 2) ^ (0.5)
end, end,
--[[ --[[
in_fov = function(self,pos) in_fov = function(self,pos)
@ -110,11 +110,10 @@ function mobs:register_mob(name, def)
local yaw = self.object:getyaw() + self.rotate local yaw = self.object:getyaw() + self.rotate
local vx = math.sin(yaw) local vx = math.sin(yaw)
local vz = math.cos(yaw) local vz = math.cos(yaw)
local ds = math.sqrt(vx^2 + vz^2) local ds = math.sqrt(vx ^ 2 + vz ^ 2)
local ps = math.sqrt(pos.x^2 + pos.z^2) local ps = math.sqrt(pos.x ^ 2 + pos.z ^ 2)
local d = { x = vx / ds, z = vz / ds } local d = { x = vx / ds, z = vz / ds }
local p = { x = pos.x / ps, z = pos.z / ps } local p = { x = pos.x / ps, z = pos.z / ps }
local an = ( d.x * p.x ) + ( d.z * p.z ) local an = ( d.x * p.x ) + ( d.z * p.z )
a = math.deg( math.acos( an ) ) a = math.deg( math.acos( an ) )
@ -135,26 +134,26 @@ function mobs:register_mob(name, def)
end end
if type == "stand" and self.animation.current ~= "stand" then if type == "stand" and self.animation.current ~= "stand" then
if self.animation.stand_start and self.animation.stand_end and self.animation.speed_normal then if self.animation.stand_start and self.animation.stand_end and self.animation.speed_normal then
self.object:set_animation({x=self.animation.stand_start, self.object:set_animation({x = self.animation.stand_start,
y=self.animation.stand_end},self.animation.speed_normal, 0) y = self.animation.stand_end}, self.animation.speed_normal, 0)
self.animation.current = "stand" self.animation.current = "stand"
end end
elseif type == "walk" and self.animation.current ~= "walk" then elseif type == "walk" and self.animation.current ~= "walk" then
if self.animation.walk_start and self.animation.walk_end and self.animation.speed_normal then if self.animation.walk_start and self.animation.walk_end and self.animation.speed_normal then
self.object:set_animation({x=self.animation.walk_start,y=self.animation.walk_end}, self.object:set_animation({x = self.animation.walk_start,
self.animation.speed_normal, 0) y = self.animation.walk_end}, self.animation.speed_normal, 0)
self.animation.current = "walk" self.animation.current = "walk"
end end
elseif type == "run" and self.animation.current ~= "run" then elseif type == "run" and self.animation.current ~= "run" then
if self.animation.run_start and self.animation.run_end and self.animation.speed_run then if self.animation.run_start and self.animation.run_end and self.animation.speed_run then
self.object:set_animation({x=self.animation.run_start,y=self.animation.run_end}, self.object:set_animation({x = self.animation.run_start,
self.animation.speed_run, 0) y = self.animation.run_end}, self.animation.speed_run, 0)
self.animation.current = "run" self.animation.current = "run"
end end
elseif type == "punch" and self.animation.current ~= "punch" then elseif type == "punch" and self.animation.current ~= "punch" then
if self.animation.punch_start and self.animation.punch_end and self.animation.speed_normal then if self.animation.punch_start and self.animation.punch_end and self.animation.speed_normal then
self.object:set_animation({x=self.animation.punch_start,y=self.animation.punch_end}, self.object:set_animation({x = self.animation.punch_start,
self.animation.speed_normal, 0) y = self.animation.punch_end}, self.animation.speed_normal, 0)
self.animation.current = "punch" self.animation.current = "punch"
end end
end end
@ -300,7 +299,11 @@ function mobs:register_mob(name, def)
or minetest.registered_nodes[nod.name].walkable == false then return end or minetest.registered_nodes[nod.name].walkable == false then return end
if self.direction then if self.direction then
pos.y = pos.y + 0.5 pos.y = pos.y + 0.5
local nod = minetest.get_node_or_nil({x=pos.x + self.direction.x,y=pos.y,z=pos.z + self.direction.z}) local nod = minetest.get_node_or_nil({
x = pos.x + self.direction.x,
y = pos.y,
z = pos.z + self.direction.z
})
--print ("in front:", nod.name, pos.y) --print ("in front:", nod.name, pos.y)
if nod and nod.name and (nod.name ~= "air" or self.walk_chance == 0) then if nod and nod.name and (nod.name ~= "air" or self.walk_chance == 0) then
local def = minetest.registered_items[nod.name] local def = minetest.registered_items[nod.name]
@ -362,11 +365,11 @@ function mobs:register_mob(name, def)
p = player:getpos() p = player:getpos()
sp = s sp = s
p.y = p.y + 1 p.y = p.y + 1
sp.y = sp.y + 1 -- aim higher to make looking up hills more realistic sp.y = sp.y + 1 -- aim higher to make looking up hills more realistic
dist = ((p.x-s.x)^2 + (p.y-s.y)^2 + (p.z-s.z)^2)^0.5 dist = ((p.x - s.x) ^ 2 + (p.y - s.y) ^ 2 + (p.z - s.z) ^ 2) ^ 0.5
if dist < self.view_range then -- and self.in_fov(self,p) then if dist < self.view_range then -- and self.in_fov(self,p) then
-- choose closest player to attack -- choose closest player to attack
if minetest.line_of_sight(sp,p,2) == true if minetest.line_of_sight(sp, p, 2) == true
and dist < min_dist then and dist < min_dist then
min_dist = dist min_dist = dist
min_player = player min_player = player
@ -392,7 +395,7 @@ function mobs:register_mob(name, def)
if obj and obj.type == "monster" then if obj and obj.type == "monster" then
-- attack monster -- attack monster
p = obj.object:getpos() p = obj.object:getpos()
dist = ((p.x-s.x)^2 + (p.y-s.y)^2 + (p.z-s.z)^2)^0.5 dist = ((p.x - s.x) ^ 2 + (p.y - s.y) ^ 2 + (p.z - s.z) ^ 2) ^ 0.5
if dist < min_dist then if dist < min_dist then
min_dist = dist min_dist = dist
min_player = obj.object min_player = obj.object
@ -422,7 +425,7 @@ function mobs:register_mob(name, def)
self.object:set_properties({ self.object:set_properties({
textures = self.base_texture, textures = self.base_texture,
mesh = self.base_mesh, mesh = self.base_mesh,
visual_size = {x=self.visual_size.x,y=self.visual_size.y}, visual_size = {x = self.visual_size.x, y = self.visual_size.y},
collisionbox = self.collisionbox, collisionbox = self.collisionbox,
}) })
end end
@ -431,7 +434,7 @@ function mobs:register_mob(name, def)
-- if animal is horny, find another same animal who is horny and mate -- if animal is horny, find another same animal who is horny and mate
if self.horny == true and self.hornytimer <= 40 then if self.horny == true and self.hornytimer <= 40 then
local pos = self.object:getpos() local pos = self.object:getpos()
effect({x=pos.x, y=pos.y+1, z=pos.z}, 4, "heart.png") effect({x = pos.x, y = pos.y + 1, z = pos.z}, 4, "heart.png")
local ents = minetest.get_objects_inside_radius(pos, self.view_range) local ents = minetest.get_objects_inside_radius(pos, self.view_range)
local num = 0 local num = 0
local ent = nil local ent = nil
@ -450,9 +453,11 @@ function mobs:register_mob(name, def)
end end
mob:set_properties({ mob:set_properties({
textures = textures, textures = textures,
visual_size = {x=self.visual_size.x/2,y=self.visual_size.y/2}, visual_size = {x = self.visual_size.x / 2, y = self.visual_size.y / 2},
collisionbox = {self.collisionbox[1]/2, self.collisionbox[2]/2, self.collisionbox[3]/2, collisionbox = {
self.collisionbox[4]/2, self.collisionbox[5]/2, self.collisionbox[6]/2}, self.collisionbox[1] / 2, self.collisionbox[2] / 2, self.collisionbox[3] / 2,
self.collisionbox[4] / 2, self.collisionbox[5] / 2, self.collisionbox[6] / 2
},
}) })
ent2.child = true ent2.child = true
ent2.tamed = true ent2.tamed = true
@ -470,7 +475,7 @@ function mobs:register_mob(name, def)
for _,player in pairs(minetest.get_connected_players()) do for _,player in pairs(minetest.get_connected_players()) do
s = self.object:getpos() s = self.object:getpos()
p = player:getpos() p = player:getpos()
dist = ((p.x-s.x)^2 + (p.y-s.y)^2 + (p.z-s.z)^2)^0.5 dist = ((p.x - s.x) ^ 2 + (p.y - s.y) ^ 2 + (p.z - s.z) ^ 2) ^ 0.5
if dist < self.view_range then if dist < self.view_range then
self.following = player self.following = player
break break
@ -507,14 +512,14 @@ function mobs:register_mob(name, def)
end end
if p then if p then
local dist = ((p.x-s.x)^2 + (p.y-s.y)^2 + (p.z-s.z)^2)^0.5 local dist = ((p.x - s.x) ^ 2 + (p.y - s.y) ^ 2 + (p.z - s.z) ^ 2) ^ 0.5
if dist > self.view_range then if dist > self.view_range then
self.following = nil self.following = nil
else else
local vec = {x=p.x-s.x, y=p.y-s.y, z=p.z-s.z} local vec = {x = p.x - s.x, y = p.y - s.y, z = p.z - s.z}
yaw = (math.atan(vec.z/vec.x)+math.pi/2) + self.rotate yaw = (math.atan(vec.z / vec.x) + math.pi / 2) + self.rotate
if p.x > s.x then if p.x > s.x then
yaw = yaw+math.pi yaw = yaw + math.pi
end end
self.object:setyaw(yaw) self.object:setyaw(yaw)
@ -522,7 +527,7 @@ function mobs:register_mob(name, def)
if dist > 2 and self.order ~= "stand" then if dist > 2 and self.order ~= "stand" then
if (self.jump and self.get_velocity(self) <= 0.5 and self.object:getvelocity().y == 0) if (self.jump and self.get_velocity(self) <= 0.5 and self.object:getvelocity().y == 0)
or (self.object:getvelocity().y == 0 and self.jump_chance > 0) then or (self.object:getvelocity().y == 0 and self.jump_chance > 0) then
self.direction = {x = math.sin(yaw)*-1, y = -20, z = math.cos(yaw)} self.direction = {x = math.sin(yaw) * -1, y = -20, z = math.cos(yaw)}
do_jump(self) do_jump(self)
end end
self.set_velocity(self, self.walk_velocity) self.set_velocity(self, self.walk_velocity)
@ -558,13 +563,13 @@ function mobs:register_mob(name, def)
end end
if lp ~= nil then if lp ~= nil then
local vec = {x=lp.x-s.x, y=lp.y-s.y, z=lp.z-s.z} local vec = {x = lp.x - s.x, y = lp.y - s.y, z = lp.z - s.z}
yaw = (math.atan(vec.z/vec.x)+math.pi/2) + self.rotate yaw = (math.atan(vec.z / vec.x) + math.pi / 2) + self.rotate
if lp.x > s.x then if lp.x > s.x then
yaw = yaw+math.pi yaw = yaw + math.pi
end end
else else
yaw = self.object:getyaw()+((math.random(0,360)-180)/180*math.pi) yaw = self.object:getyaw() + ((math.random(0, 360) - 180) / 180 * math.pi)
end end
self.object:setyaw(yaw) self.object:setyaw(yaw)
end end
@ -586,7 +591,7 @@ function mobs:register_mob(name, def)
-- jumping mobs only -- jumping mobs only
-- if self.jump and math.random(1, 100) <= self.jump_chance then -- if self.jump and math.random(1, 100) <= self.jump_chance then
-- self.direction = {x=0, y=0, z=0} -- self.direction = {x = 0, y = 0, z = 0}
-- do_jump(self) -- do_jump(self)
-- self.set_velocity(self, self.walk_velocity) -- self.set_velocity(self, self.walk_velocity)
-- end -- end
@ -606,19 +611,19 @@ if self.fly and self.fly_in == "default:water_source" and not lp then
end end
-- if water nearby then turn away -- if water nearby then turn away
if lp then if lp then
local vec = {x=lp.x-s.x, y=lp.y-s.y, z=lp.z-s.z} local vec = {x = lp.x - s.x, y = lp.y - s.y, z = lp.z - s.z}
yaw = math.atan(vec.z/vec.x) + 3*math.pi / 2 + self.rotate yaw = math.atan(vec.z / vec.x) + 3 * math.pi / 2 + self.rotate
if lp.x > s.x then if lp.x > s.x then
yaw = yaw+math.pi yaw = yaw + math.pi
end end
self.object:setyaw(yaw) self.object:setyaw(yaw)
-- otherwise randomly turn -- otherwise randomly turn
elseif math.random(1, 100) <= 30 then elseif math.random(1, 100) <= 30 then
self.object:setyaw(self.object:getyaw()+((math.random(0,360)-180)/180*math.pi)) self.object:setyaw(self.object:getyaw() + ((math.random(0, 360) - 180) / 180 * math.pi))
end end
if self.jump and self.get_velocity(self) <= 0.5 and self.object:getvelocity().y == 0 then if self.jump and self.get_velocity(self) <= 0.5 and self.object:getvelocity().y == 0 then
self.direction = {x = math.sin(yaw)*-1, y = -20, z = math.cos(yaw)} self.direction = {x = math.sin(yaw) * -1, y = -20, z = math.cos(yaw)}
do_jump(self) do_jump(self)
end end
@ -656,8 +661,8 @@ end
self.attack.dist = dist self.attack.dist = dist
end end
local vec = {x = p.x -s.x, y = p.y -s.y, z = p.z -s.z} local vec = {x = p.x - s.x, y = p.y - s.y, z = p.z - s.z}
yaw = math.atan(vec.z/vec.x)+math.pi/2 + self.rotate yaw = math.atan(vec.z / vec.x) + math.pi / 2 + self.rotate
if p.x > s.x then if p.x > s.x then
yaw = yaw+math.pi yaw = yaw+math.pi
end end
@ -724,7 +729,7 @@ end
end end
local s = self.object:getpos() local s = self.object:getpos()
local p = self.attack.player:getpos() local p = self.attack.player:getpos()
local dist = ((p.x-s.x)^2 + (p.y-s.y)^2 + (p.z-s.z)^2)^0.5 local dist = ((p.x - s.x) ^ 2 + (p.y - s.y) ^ 2 + (p.z - s.z) ^ 2) ^ 0.5
-- fly bit modified from BlockMens creatures mod -- fly bit modified from BlockMens creatures mod
if self.fly and dist > 2 then if self.fly and dist > 2 then
@ -733,19 +738,19 @@ end
local p1 = s local p1 = s
local me_y = math.floor(p1.y) local me_y = math.floor(p1.y)
local p2 = p local p2 = p
local p_y = math.floor(p2.y+1) local p_y = math.floor(p2.y + 1)
local v = self.object:getvelocity() local v = self.object:getvelocity()
if nod and nod.name == self.fly_in then if nod and nod.name == self.fly_in then
if me_y < p_y then if me_y < p_y then
self.object:setvelocity({x=v.x,y=1*self.walk_velocity,z=v.z}) self.object:setvelocity({x = v.x, y = 1 * self.walk_velocity, z = v.z})
elseif me_y > p_y then elseif me_y > p_y then
self.object:setvelocity({x=v.x,y=-1*self.walk_velocity,z=v.z}) self.object:setvelocity({x = v.x, y = -1 * self.walk_velocity, z = v.z})
end end
else else
if me_y < p_y then if me_y < p_y then
self.object:setvelocity({x=v.x,y=0.01,z=v.z}) self.object:setvelocity({x = v.x, y = 0.01,z = v.z})
elseif me_y > p_y then elseif me_y > p_y then
self.object:setvelocity({x=v.x,y=-0.01,z=v.z}) self.object:setvelocity({x = v.x, y = -0.01, z = v.z})
end end
end end
@ -762,18 +767,18 @@ end
self.attack.dist = dist self.attack.dist = dist
end end
local vec = {x=p.x-s.x, y=p.y-s.y, z=p.z-s.z} local vec = {x = p.x - s.x, y = p.y - s.y, z = p.z - s.z}
yaw = (math.atan(vec.z/vec.x)+math.pi/2) + self.rotate yaw = (math.atan(vec.z / vec.x) + math.pi / 2) + self.rotate
if p.x > s.x then if p.x > s.x then
yaw = yaw+math.pi yaw = yaw+math.pi
end end
self.object:setyaw(yaw) self.object:setyaw(yaw)
-- attack distance is 2 + half of mob width so the bigger mobs can attack (like slimes) -- attack distance is 2 + half of mob width so the bigger mobs can attack (like slimes)
if self.attack.dist > ((-self.collisionbox[1]+self.collisionbox[4])/2)+2 then if self.attack.dist > ((-self.collisionbox[1] + self.collisionbox[4]) / 2) + 2 then
-- jump attack -- jump attack
if (self.jump and self.get_velocity(self) <= 0.5 and self.object:getvelocity().y == 0) if (self.jump and self.get_velocity(self) <= 0.5 and self.object:getvelocity().y == 0)
or (self.object:getvelocity().y == 0 and self.jump_chance > 0) then or (self.object:getvelocity().y == 0 and self.jump_chance > 0) then
self.direction = {x = math.sin(yaw)*-1, y = -20, z = math.cos(yaw)} self.direction = {x = math.sin(yaw) * -1, y = -20, z = math.cos(yaw)}
do_jump(self) do_jump(self)
end end
self.set_velocity(self, self.run_velocity) self.set_velocity(self, self.run_velocity)
@ -787,7 +792,7 @@ end
local s2 = s local s2 = s
p2.y = p2.y + 1.5 p2.y = p2.y + 1.5
s2.y = s2.y + 1.5 s2.y = s2.y + 1.5
if minetest.line_of_sight(p2,s2) == true then if minetest.line_of_sight(p2, s2) == true then
if self.sounds.attack then if self.sounds.attack then
minetest.sound_play(self.sounds.attack, { minetest.sound_play(self.sounds.attack, {
object = self.object, object = self.object,
@ -812,7 +817,7 @@ end
local p = self.attack.player:getpos() local p = self.attack.player:getpos()
p.y = p.y - .5 p.y = p.y - .5
s.y = s.y + .5 s.y = s.y + .5
local dist = ((p.x-s.x)^2 + (p.y-s.y)^2 + (p.z-s.z)^2)^0.5 local dist = ((p.x - s.x) ^ 2 + (p.y - s.y) ^ 2 + (p.z - s.z) ^ 2) ^ 0.5
if dist > self.view_range or self.attack.player:get_hp() <= 0 then if dist > self.view_range or self.attack.player:get_hp() <= 0 then
self.state = "stand" self.state = "stand"
self.set_velocity(self, 0) self.set_velocity(self, 0)
@ -822,10 +827,10 @@ end
self.attack.dist = dist self.attack.dist = dist
end end
local vec = {x=p.x-s.x, y=p.y-s.y, z=p.z-s.z} local vec = {x = p.x - s.x, y = p.y - s.y, z = p.z - s.z}
yaw = (math.atan(vec.z/vec.x)+math.pi/2) + self.rotate yaw = (math.atan(vec.z/vec.x)+math.pi/2) + self.rotate
if p.x > s.x then if p.x > s.x then
yaw = yaw+math.pi yaw = yaw + math.pi
end end
self.object:setyaw(yaw) self.object:setyaw(yaw)
self.set_velocity(self, 0) self.set_velocity(self, 0)
@ -843,14 +848,14 @@ end
end end
local p = self.object:getpos() local p = self.object:getpos()
p.y = p.y + (self.collisionbox[2]+self.collisionbox[5])/2 p.y = p.y + (self.collisionbox[2] + self.collisionbox[5]) / 2
local obj = minetest.add_entity(p, self.arrow) local obj = minetest.add_entity(p, self.arrow)
local amount = (vec.x^2+vec.y^2+vec.z^2)^0.5 local amount = (vec.x ^ 2 + vec.y ^ 2 + vec.z ^ 2) ^ 0.5
local v = obj:get_luaentity().velocity local v = obj:get_luaentity().velocity
vec.y = vec.y + self.shoot_offset -- this makes shoot aim accurate vec.y = vec.y + self.shoot_offset -- this makes shoot aim accurate
vec.x = vec.x*v/amount vec.x = vec.x *v / amount
vec.y = vec.y*v/amount vec.y = vec.y *v / amount
vec.z = vec.z*v/amount vec.z = vec.z *v / amount
obj:setvelocity(vec) obj:setvelocity(vec)
end end
end end
@ -864,12 +869,12 @@ end
self.health = math.random (self.hp_min, self.hp_max) -- set initial HP self.health = math.random (self.hp_min, self.hp_max) -- set initial HP
self.object:set_hp( self.health ) self.object:set_hp( self.health )
self.health = self.object:get_hp() self.health = self.object:get_hp()
self.object:set_armor_groups({fleshy=self.armor}) self.object:set_armor_groups({fleshy = self.armor})
self.object:setacceleration({x=0, y= self.fall_speed, z=0}) self.object:setacceleration({x = 0, y = self.fall_speed, z = 0})
self.state = "stand" self.state = "stand"
self.object:setvelocity({x=0, y=self.object:getvelocity().y, z=0}) self.object:setvelocity({x = 0, y = self.object:getvelocity().y, z = 0})
self.old_y = self.object:getpos().y self.old_y = self.object:getpos().y
self.object:setyaw(math.random(1, 360)/180*math.pi) self.object:setyaw(math.random(1, 360) / 180 * math.pi)
if not self.sounds.distance then self.sounds.distance = 10 end if not self.sounds.distance then self.sounds.distance = 10 end
@ -920,7 +925,7 @@ end
get_staticdata = function(self) get_staticdata = function(self)
-- select random texture, set model -- select random texture, set model
if not self.base_texture then if not self.base_texture then
self.base_texture = def.textures[math.random(1,#def.textures)] self.base_texture = def.textures[math.random(1, #def.textures)]
self.base_mesh = def.mesh self.base_mesh = def.mesh
end end
-- set texture, model and size -- set texture, model and size
@ -938,12 +943,14 @@ end
end end
-- if object is child then set half size -- if object is child then set half size
if self.child == true then if self.child == true then
vis_size = {x=self.visual_size.x/2,y=self.visual_size.y/2} vis_size = {x = self.visual_size.x / 2, y = self.visual_size.y / 2}
if def.child_texture then if def.child_texture then
textures = def.child_texture[1] textures = def.child_texture[1]
end end
colbox = {self.collisionbox[1]/2, self.collisionbox[2]/2, self.collisionbox[3]/2, colbox = {
self.collisionbox[4]/2, self.collisionbox[5]/2, self.collisionbox[6]/2} self.collisionbox[1] / 2, self.collisionbox[2] / 2, self.collisionbox[3] / 2,
self.collisionbox[4] / 2, self.collisionbox[5] / 2, self.collisionbox[6] / 2
}
end end
-- remember settings -- remember settings
local tmp = { local tmp = {
@ -976,7 +983,7 @@ end
-- weapon sounds -- weapon sounds
if weapon:get_definition().sounds ~= nil then if weapon:get_definition().sounds ~= nil then
local s = math.random(0,#weapon:get_definition().sounds) local s = math.random(0, #weapon:get_definition().sounds)
minetest.sound_play(weapon:get_definition().sounds[s], { minetest.sound_play(weapon:get_definition().sounds[s], {
object=hitter, object=hitter,
max_hear_distance = 8 max_hear_distance = 8
@ -1005,21 +1012,21 @@ end
kb = kb * ( tflp / tool_capabilities.full_punch_interval ) kb = kb * ( tflp / tool_capabilities.full_punch_interval )
r = r * ( tflp / tool_capabilities.full_punch_interval ) r = r * ( tflp / tool_capabilities.full_punch_interval )
end end
self.object:setvelocity({x=dir.x*kb,y=0,z=dir.z*kb}) self.object:setvelocity({x = dir.x * kb,y = 0,z = dir.z * kb})
self.pause_timer = r self.pause_timer = r
-- attack puncher and call other mobs for help -- attack puncher and call other mobs for help
if self.passive == false and not self.tamed then if self.passive == false and not self.tamed then
if self.state ~= "attack" then if self.state ~= "attack" then
self.do_attack(self,hitter,1) self.do_attack(self, hitter, 1)
end end
-- alert others to the attack -- alert others to the attack
local obj = nil local obj = nil
for _, oir in pairs(minetest.get_objects_inside_radius(hitter:getpos(),5)) do for _, oir in pairs(minetest.get_objects_inside_radius(hitter:getpos(), 5)) do
obj = oir:get_luaentity() obj = oir:get_luaentity()
if obj then if obj then
if obj.group_attack == true and obj.state ~= "attack" then if obj.group_attack == true and obj.state ~= "attack" then
obj.do_attack(obj,hitter,1) obj.do_attack(obj, hitter, 1)
end end
end end
end end
@ -1094,10 +1101,10 @@ function effect(pos, amount, texture, max_size)
time = 0.25, time = 0.25,
minpos = pos, minpos = pos,
maxpos = pos, maxpos = pos,
minvel = {x=-0, y=-2, z=-0}, minvel = {x = -0, y = -2, z = -0},
maxvel = {x=2, y=2, z=2}, maxvel = {x = 2, y = 2, z = 2},
minacc = {x=-4, y=-4, z=-4}, minacc = {x = -4, y = -4, z = -4},
maxacc = {x=4, y=4, z=4}, maxacc = {x = 4, y = 4, z = 4},
minexptime = 0.1, minexptime = 0.1,
maxexptime = 1, maxexptime = 1,
minsize = 0.5, minsize = 0.5,
@ -1149,10 +1156,10 @@ function mobs:explosion(pos, radius, fire, smoke, sound)
local meta = minetest.get_meta(p) local meta = minetest.get_meta(p)
local inv = meta:get_inventory() local inv = meta:get_inventory()
for i = 1,32 do for i = 1,32 do
local m_stack = inv:get_stack("main",i) local m_stack = inv:get_stack("main", i)
local obj = minetest.add_item(pos,m_stack) local obj = minetest.add_item(pos, m_stack)
if obj then if obj then
obj:setvelocity({x=math.random(-2,2), y=7, z=math.random(-2,2)}) obj:setvelocity({x = math.random(-2, 2), y = 7, z = math.random(-2, 2)})
end end
end end
end end
@ -1193,7 +1200,7 @@ function check_for_death(self)
if math.random(1, drop.chance) == 1 then if math.random(1, drop.chance) == 1 then
obj = minetest.add_item(pos, ItemStack(drop.name.." "..math.random(drop.min, drop.max))) obj = minetest.add_item(pos, ItemStack(drop.name.." "..math.random(drop.min, drop.max)))
if obj then if obj then
obj:setvelocity({x=math.random(-1,1), y=5, z=math.random(-1,1)}) obj:setvelocity({x = math.random(-1, 1), y = 5, z = math.random(-1, 1)})
end end
end end
end end
@ -1251,7 +1258,7 @@ function mobs:register_arrow(name, def)
hit_node = def.hit_node, hit_node = def.hit_node,
hit_mob = def.hit_mob, hit_mob = def.hit_mob,
drop = def.drop or false, drop = def.drop or false,
collisionbox = {0,0,0,0,0,0}, -- remove box around arrows collisionbox = {0, 0, 0, 0, 0, 0}, -- remove box around arrows
on_step = function(self, dtime) on_step = function(self, dtime)
self.timer = (self.timer or 0) + 1 self.timer = (self.timer or 0) + 1
@ -1263,7 +1270,8 @@ function mobs:register_arrow(name, def)
if self.hit_node and node and minetest.registered_nodes[node] and minetest.registered_nodes[node].walkable then if self.hit_node and node and minetest.registered_nodes[node] and minetest.registered_nodes[node].walkable then
self.hit_node(self, pos, node) self.hit_node(self, pos, node)
if self.drop == true then if self.drop == true then
pos.y = pos.y + 1 ; self.lastpos = (self.lastpos or pos) pos.y = pos.y + 1
self.lastpos = (self.lastpos or pos)
minetest.add_item(self.lastpos, self.object:get_luaentity().name) minetest.add_item(self.lastpos, self.object:get_luaentity().name)
end end
self.object:remove() self.object:remove()