520 lines
15 KiB
Lua
520 lines
15 KiB
Lua
-- Gets total armor level from 3d armor
|
|
local function get_3d_armor_armor(player)
|
|
local armor_total = 0
|
|
|
|
if not player:is_player() or not minetest.get_modpath('3d_armor') or not armor.def[player:get_player_name()] then
|
|
return armor_total
|
|
end
|
|
|
|
armor_total = armor.def[player:get_player_name()].level
|
|
|
|
return armor_total
|
|
end
|
|
|
|
-- Limits number `x` between `min` and `max` values
|
|
local function limit(x, min, max)
|
|
return math.min(math.max(x, min), max)
|
|
end
|
|
|
|
-- Gets `ObjectRef` collision box
|
|
local function get_obj_box(obj)
|
|
local box
|
|
|
|
if obj:is_player() then
|
|
box = obj:get_properties().collisionbox or {-0.5, 0.0, -0.5, 0.5, 1.0, 0.5}
|
|
else
|
|
box = obj:get_luaentity().collisionbox or {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5}
|
|
end
|
|
|
|
return box
|
|
end
|
|
|
|
-- Poison Arrow Effects
|
|
function x_bows.poison_effect(tick, time, time_left, arrow_obj, target_obj, old_damage_texture_modifier, punch_def)
|
|
if not arrow_obj or target_obj:get_hp() <= 0 then
|
|
return
|
|
end
|
|
|
|
target_obj:set_properties({damage_texture_modifier = '^[colorize:#00FF0050'})
|
|
|
|
time_left = time_left + tick
|
|
|
|
if time_left <= time then
|
|
minetest.after(tick, x_bows.poison_effect, tick, time, time_left, arrow_obj, target_obj, old_damage_texture_modifier, punch_def)
|
|
elseif target_obj:is_player() then
|
|
if x_bows.hbhunger then
|
|
-- Reset HUD bar color
|
|
hb.change_hudbar(target_obj, 'health', nil, nil, 'hudbars_icon_health.png', nil, 'hudbars_bar_health.png')
|
|
end
|
|
|
|
if old_damage_texture_modifier then
|
|
target_obj:set_properties({damage_texture_modifier = old_damage_texture_modifier})
|
|
end
|
|
|
|
-- return
|
|
else
|
|
-- local lua_ent = target_obj:get_luaentity()
|
|
|
|
-- if not lua_ent then
|
|
-- return
|
|
-- end
|
|
|
|
-- lua_ent[arrow_obj.arrow .. '_active'] = false
|
|
|
|
|
|
if old_damage_texture_modifier then
|
|
target_obj:set_properties({damage_texture_modifier = old_damage_texture_modifier})
|
|
end
|
|
-- return
|
|
end
|
|
|
|
local _damage = punch_def.tool_capabilities.damage_groups.fleshy
|
|
if target_obj:get_hp() - _damage > 0 then
|
|
target_obj:punch(
|
|
punch_def.puncher,
|
|
punch_def.time_from_last_punch,
|
|
punch_def.tool_capabilities
|
|
)
|
|
|
|
local target_obj_pos = target_obj:get_pos()
|
|
|
|
if target_obj_pos then
|
|
x_bows.particle_effect(target_obj_pos, 'arrow_tipped')
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Main Arrow Entity
|
|
minetest.register_entity('x_bows:arrow_entity', {
|
|
initial_properties = {
|
|
visual = 'wielditem',
|
|
visual_size = {x = 0.2, y = 0.2, z = 0.3},
|
|
collisionbox = {0, 0, 0, 0, 0, 0},
|
|
selectionbox = {0, 0, 0, 0, 0, 0},
|
|
physical = false,
|
|
textures = {'air'},
|
|
hp_max = 0.5
|
|
},
|
|
|
|
on_activate = function(self, staticdata)
|
|
if not self or not staticdata or staticdata == '' then
|
|
self.object:remove()
|
|
return
|
|
end
|
|
|
|
local _staticdata = minetest.deserialize(staticdata)
|
|
|
|
-- set/reset - do not inherit from previous entity table
|
|
self._velocity = {x = 0, y = 0, z = 0}
|
|
self._old_pos = nil
|
|
self._attached = false
|
|
self._attached_to = {
|
|
type = '',
|
|
pos = nil
|
|
}
|
|
self._has_particles = false
|
|
self._lifetimer = 60
|
|
self._nodechecktimer = 0.5
|
|
self._is_drowning = false
|
|
self._in_liquid = false
|
|
self._poison_arrow = false
|
|
self._shot_from_pos = self.object:get_pos()
|
|
self.arrow = _staticdata.arrow
|
|
self.user = minetest.get_player_by_name(_staticdata.user_name)
|
|
self._tflp = _staticdata._tflp
|
|
self._tool_capabilities = _staticdata._tool_capabilities
|
|
self._is_critical_hit = _staticdata.is_critical_hit
|
|
|
|
if self.arrow == 'x_bows:arrow_diamond_tipped_poison' then
|
|
self._poison_arrow = true
|
|
end
|
|
|
|
self.object:set_properties({
|
|
textures = {'x_bows:arrow_node'},
|
|
infotext = self.arrow
|
|
})
|
|
end,
|
|
|
|
on_death = function(self, killer)
|
|
if not self._old_pos then
|
|
self.object:remove()
|
|
return
|
|
end
|
|
|
|
minetest.item_drop(ItemStack(self.arrow), nil, vector.round(self._old_pos))
|
|
end,
|
|
|
|
on_step = function(self, dtime)
|
|
local pos = self.object:get_pos()
|
|
self._old_pos = self._old_pos or pos
|
|
local ray = minetest.raycast(self._old_pos, pos, true, true)
|
|
local pointed_thing = ray:next()
|
|
|
|
self._lifetimer = self._lifetimer - dtime
|
|
self._nodechecktimer = self._nodechecktimer - dtime
|
|
|
|
-- adjust pitch when flying
|
|
if not self._attached then
|
|
local velocity = self.object:get_velocity()
|
|
local v_rotation = self.object:get_rotation()
|
|
local pitch = math.atan2(velocity.y, math.sqrt(velocity.x^2 + velocity.z^2))
|
|
|
|
self.object:set_rotation({
|
|
x = pitch,
|
|
y = v_rotation.y,
|
|
z = v_rotation.z
|
|
})
|
|
end
|
|
|
|
-- remove attached arrows after lifetime
|
|
if self._lifetimer <= 0 then
|
|
self.object:remove()
|
|
return
|
|
end
|
|
|
|
-- add particles only when not attached
|
|
if not self._attached and not self._in_liquid then
|
|
self._has_particles = true
|
|
|
|
if self._tflp >= self._tool_capabilities.full_punch_interval then
|
|
if self._is_critical_hit then
|
|
x_bows.particle_effect(self._old_pos, 'arrow_crit')
|
|
else
|
|
x_bows.particle_effect(self._old_pos, 'arrow')
|
|
end
|
|
end
|
|
end
|
|
|
|
-- remove attached arrows after object dies
|
|
if not self.object:get_attach() and self._attached_to.type == 'object' then
|
|
self.object:remove()
|
|
return
|
|
end
|
|
|
|
-- arrow falls down when not attached to node any more
|
|
if self._attached_to.type == 'node' and self._attached and self._nodechecktimer <= 0 then
|
|
local node = minetest.get_node(self._attached_to.pos)
|
|
self._nodechecktimer = 0.5
|
|
|
|
if not node then
|
|
return
|
|
end
|
|
|
|
if node.name == 'air' then
|
|
self.object:set_velocity({x = 0, y = -3, z = 0})
|
|
self.object:set_acceleration({x = 0, y = -3, z = 0})
|
|
-- reset values
|
|
self._attached = false
|
|
self._attached_to.type = ''
|
|
self._attached_to.pos = nil
|
|
self.object:set_properties({collisionbox = {0, 0, 0, 0, 0, 0}})
|
|
|
|
return
|
|
end
|
|
end
|
|
|
|
while pointed_thing do
|
|
local ip_pos = pointed_thing.intersection_point
|
|
local in_pos = pointed_thing.intersection_normal
|
|
self.pointed_thing = pointed_thing
|
|
|
|
if pointed_thing.type == 'object'
|
|
and pointed_thing.ref ~= self.object
|
|
and pointed_thing.ref:get_hp() > 0
|
|
and ((pointed_thing.ref:is_player() and pointed_thing.ref:get_player_name() ~= self.user:get_player_name()) or (pointed_thing.ref:get_luaentity() and pointed_thing.ref:get_luaentity().physical and pointed_thing.ref:get_luaentity().name ~= '__builtin:item'))
|
|
and self.object:get_attach() == nil
|
|
then
|
|
if pointed_thing.ref:is_player() then
|
|
minetest.sound_play('x_bows_arrow_successful_hit', {
|
|
to_player = self.user:get_player_name(),
|
|
gain = 0.3
|
|
})
|
|
else
|
|
minetest.sound_play('x_bows_arrow_hit', {
|
|
to_player = self.user:get_player_name(),
|
|
gain = 0.6
|
|
})
|
|
end
|
|
|
|
-- store these here before punching in case pointed_thing.ref dies
|
|
local collisionbox = get_obj_box(pointed_thing.ref)
|
|
local xmin = collisionbox[1] * 100
|
|
local ymin = collisionbox[2] * 100
|
|
local zmin = collisionbox[3] * 100
|
|
local xmax = collisionbox[4] * 100
|
|
local ymax = collisionbox[5] * 100
|
|
local zmax = collisionbox[6] * 100
|
|
|
|
self.object:set_velocity({x = 0, y = 0, z = 0})
|
|
self.object:set_acceleration({x = 0, y = 0, z = 0})
|
|
|
|
-- calculate damage
|
|
local target_armor_groups = pointed_thing.ref:get_armor_groups()
|
|
local _damage = 0
|
|
for group, base_damage in pairs(self._tool_capabilities.damage_groups) do
|
|
_damage = _damage
|
|
+ base_damage
|
|
* limit(self._tflp / self._tool_capabilities.full_punch_interval, 0.0, 1.0)
|
|
* ((target_armor_groups[group] or 0) + get_3d_armor_armor(pointed_thing.ref)) / 100.0
|
|
end
|
|
|
|
-- crits
|
|
if self._is_critical_hit then
|
|
_damage = _damage * 2
|
|
end
|
|
|
|
-- knockback
|
|
local dir = vector.normalize(vector.subtract(self._shot_from_pos, ip_pos))
|
|
local distance = vector.distance(self._shot_from_pos, ip_pos)
|
|
local knockback = minetest.calculate_knockback(
|
|
pointed_thing.ref,
|
|
self.object,
|
|
self._tflp,
|
|
{
|
|
full_punch_interval = self._tool_capabilities.full_punch_interval,
|
|
damage_groups = {fleshy = _damage},
|
|
},
|
|
dir,
|
|
distance,
|
|
_damage
|
|
)
|
|
|
|
pointed_thing.ref:add_velocity({
|
|
x = dir.x * knockback * -1,
|
|
y = 7,
|
|
z = dir.z * knockback * -1
|
|
})
|
|
|
|
pointed_thing.ref:punch(
|
|
self.object,
|
|
self._tflp,
|
|
{
|
|
full_punch_interval = self._tool_capabilities.full_punch_interval,
|
|
damage_groups = {fleshy = _damage, knockback = knockback}
|
|
},
|
|
{
|
|
x = dir.x * -1,
|
|
y = 7,
|
|
z = dir.z * -1
|
|
}
|
|
)
|
|
|
|
-- already dead (entity)
|
|
if not pointed_thing.ref:get_luaentity() and not pointed_thing.ref:is_player() then
|
|
self.object:remove()
|
|
return
|
|
end
|
|
|
|
-- already dead (player)
|
|
if pointed_thing.ref:get_hp() <= 0 then
|
|
if x_bows.hbhunger then
|
|
-- Reset HUD bar color
|
|
hb.change_hudbar(pointed_thing.ref, 'health', nil, nil, 'hudbars_icon_health.png', nil, 'hudbars_bar_health.png')
|
|
end
|
|
self.object:remove()
|
|
return
|
|
end
|
|
|
|
-- attach arrow prepare
|
|
local rotation = {x = 0, y = 0, z = 0}
|
|
local position = {x = 0, y = 0, z = 0}
|
|
|
|
if in_pos.x == 1 then
|
|
-- x = 0
|
|
-- y = -90
|
|
-- z = 0
|
|
rotation.x = math.random(-10, 10)
|
|
rotation.y = math.random(-100, -80)
|
|
rotation.z = math.random(-10, 10)
|
|
|
|
position.x = xmax / 10
|
|
position.y = math.random(ymin, ymax) / 10
|
|
position.z = math.random(zmin, zmax) / 10
|
|
elseif in_pos.x == -1 then
|
|
-- x = 0
|
|
-- y = 90
|
|
-- z = 0
|
|
rotation.x = math.random(-10, 10)
|
|
rotation.y = math.random(80, 100)
|
|
rotation.z = math.random(-10, 10)
|
|
|
|
position.x = xmin / 10
|
|
position.y = math.random(ymin, ymax) / 10
|
|
position.z = math.random(zmin, zmax) / 10
|
|
elseif in_pos.y == 1 then
|
|
-- x = -90
|
|
-- y = 0
|
|
-- z = -180
|
|
rotation.x = math.random(-100, -80)
|
|
rotation.y = math.random(-10, 10)
|
|
rotation.z = math.random(-190, -170)
|
|
|
|
position.x = math.random(xmin, xmax) / 10
|
|
position.y = ymax / 10
|
|
position.z = math.random(zmin, zmax) / 10
|
|
elseif in_pos.y == -1 then
|
|
-- x = 90
|
|
-- y = 0
|
|
-- z = 180
|
|
rotation.x = math.random(80, 100)
|
|
rotation.y = math.random(-10, 10)
|
|
rotation.z = math.random(170, 190)
|
|
|
|
position.x = math.random(xmin, xmax) / 10
|
|
position.y = ymin / 10
|
|
position.z = math.random(zmin, zmax) / 10
|
|
elseif in_pos.z == 1 then
|
|
-- x = 180
|
|
-- y = 0
|
|
-- z = 180
|
|
rotation.x = math.random(170, 190)
|
|
rotation.y = math.random(-10, 10)
|
|
rotation.z = math.random(170, 190)
|
|
|
|
position.x = math.random(xmin, xmax) / 10
|
|
position.y = math.random(ymin, ymax) / 10
|
|
position.z = zmax / 10
|
|
elseif in_pos.z == -1 then
|
|
-- x = -180
|
|
-- y = 180
|
|
-- z = -180
|
|
rotation.x = math.random(-190, -170)
|
|
rotation.y = math.random(170, 190)
|
|
rotation.z = math.random(-190, -170)
|
|
|
|
position.x = math.random(xmin, xmax) / 10
|
|
position.y = math.random(ymin, ymax) / 10
|
|
position.z = zmin / 10
|
|
end
|
|
|
|
-- poison arrow
|
|
if self._poison_arrow then
|
|
local old_damage_texture_modifier = pointed_thing.ref:get_properties().damage_texture_modifier
|
|
local punch_def = {}
|
|
punch_def.puncher = self.object
|
|
punch_def.time_from_last_punch = self._tflp
|
|
punch_def.tool_capabilities = {
|
|
full_punch_interval = self._tool_capabilities.full_punch_interval,
|
|
damage_groups = {fleshy = _damage, knockback = knockback}
|
|
}
|
|
|
|
if pointed_thing.ref:is_player() then
|
|
-- @TODO missing `active` posion arrow check for player (see lua_ent below)
|
|
if x_bows.hbhunger then
|
|
-- Set poison bar
|
|
hb.change_hudbar(pointed_thing.ref, 'health', nil, nil, 'hbhunger_icon_health_poison.png', nil, 'hbhunger_bar_health_poison.png')
|
|
end
|
|
|
|
x_bows.poison_effect(1, 5, 0, self, pointed_thing.ref, old_damage_texture_modifier, punch_def)
|
|
else
|
|
local lua_ent = pointed_thing.ref:get_luaentity()
|
|
-- if not lua_ent[self.arrow .. '_active'] or lua_ent[self.arrow .. '_active'] == 'false' then
|
|
-- lua_ent[self.arrow .. '_active'] = true
|
|
x_bows.poison_effect(1, 5, 0, self, pointed_thing.ref, old_damage_texture_modifier, punch_def)
|
|
-- end
|
|
end
|
|
end
|
|
|
|
if not x_bows.settings.x_bows_attach_arrows_to_entities and not pointed_thing.ref:is_player() then
|
|
self.object:remove()
|
|
return
|
|
end
|
|
|
|
-- attach arrow
|
|
self.object:set_attach(
|
|
pointed_thing.ref,
|
|
'',
|
|
position,
|
|
rotation,
|
|
true
|
|
)
|
|
self._attached = true
|
|
self._attached_to.type = pointed_thing.type
|
|
self._attached_to.pos = position
|
|
|
|
local children = pointed_thing.ref:get_children()
|
|
|
|
-- remove last arrow when too many already attached
|
|
if #children >= 5 then
|
|
children[1]:remove()
|
|
end
|
|
|
|
return
|
|
|
|
elseif pointed_thing.type == 'node' and not self._attached then
|
|
local node = minetest.get_node(pointed_thing.under)
|
|
local node_def = minetest.registered_nodes[node.name]
|
|
|
|
if not node_def then
|
|
return
|
|
end
|
|
|
|
self._velocity = self.object:get_velocity()
|
|
|
|
if node_def.drawtype == 'liquid' and not self._is_drowning then
|
|
self._is_drowning = true
|
|
self._in_liquid = true
|
|
local drag = 1 / (node_def.liquid_viscosity * 6)
|
|
self.object:set_velocity(vector.multiply(self._velocity, drag))
|
|
self.object:set_acceleration({x = 0, y = -1.0, z = 0})
|
|
|
|
x_bows.particle_effect(self._old_pos, 'bubble')
|
|
elseif self._is_drowning then
|
|
self._is_drowning = false
|
|
|
|
if self._velocity then
|
|
self.object:set_velocity(self._velocity)
|
|
end
|
|
|
|
self.object:set_acceleration({x = 0, y = -9.81, z = 0})
|
|
end
|
|
|
|
if x_bows.mesecons and node.name == 'x_bows:target' then
|
|
local distance = vector.distance(pointed_thing.under, ip_pos)
|
|
distance = math.floor(distance * 100) / 100
|
|
|
|
-- only close to the center of the target will trigger signal
|
|
if distance < 0.54 then
|
|
mesecon.receptor_on(pointed_thing.under)
|
|
minetest.get_node_timer(pointed_thing.under):start(2)
|
|
end
|
|
end
|
|
|
|
if node_def.walkable then
|
|
self.object:set_velocity({x=0, y=0, z=0})
|
|
self.object:set_acceleration({x=0, y=0, z=0})
|
|
self.object:set_pos(ip_pos)
|
|
self.object:set_rotation(self.object:get_rotation())
|
|
self._attached = true
|
|
self._attached_to.type = pointed_thing.type
|
|
self._attached_to.pos = pointed_thing.under
|
|
self.object:set_properties({collisionbox = {-0.2, -0.2, -0.2, 0.2, 0.2, 0.2}})
|
|
|
|
-- remove last arrow when too many already attached
|
|
local children = {}
|
|
|
|
for k, object in ipairs(minetest.get_objects_inside_radius(pointed_thing.under, 1)) do
|
|
if not object:is_player() and object:get_luaentity() and object:get_luaentity().name == 'x_bows:arrow_entity' then
|
|
table.insert(children ,object)
|
|
end
|
|
end
|
|
|
|
if #children >= 5 then
|
|
children[#children]:remove()
|
|
end
|
|
|
|
minetest.sound_play('x_bows_arrow_hit', {
|
|
pos = pointed_thing.under,
|
|
gain = 0.6,
|
|
max_hear_distance = 16
|
|
})
|
|
|
|
return
|
|
end
|
|
end
|
|
pointed_thing = ray:next()
|
|
end
|
|
|
|
self._old_pos = pos
|
|
end,
|
|
}) |