milan/minetest-mm
1
0
Fork 0
Code Issues 3 Pull requests Releases Wiki Activity

update

Browse source
This commit is contained in:
root 2021-02-25 20:49:03 +01:00
parent 42a97930ec
commit 829ac8a390
24 changed files with 1363 additions and 497 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
mods/advtrains/advtrains/crafting.lua
View file

@ -20,6 +20,32 @@ minetest.register_craft({
{'', '', 'default:steel_ingot'},
},
})
--Wallmounted Signal
minetest.register_craft({
output = 'advtrains:signal_wall_r_off 2',
recipe = {
{'dye:red', 'default:steel_ingot', 'default:steel_ingot'},
{'', 'default:steel_ingot', ''},
{'dye:dark_green', 'default:steel_ingot', 'default:steel_ingot'},
},
})
--Wallmounted Signals can be converted into every orientation by shapeless crafting
minetest.register_craft({
output = 'advtrains:signal_wall_l_off',
type = "shapeless",
recipe = {'advtrains:signal_wall_r_off'},
})
minetest.register_craft({
output = 'advtrains:signal_wall_t_off',
type = "shapeless",
recipe = {'advtrains:signal_wall_l_off'},
})
minetest.register_craft({
output = 'advtrains:signal_wall_r_off',
type = "shapeless",
recipe = {'advtrains:signal_wall_t_off'},
})
--trackworker
minetest.register_craft({

10
mods/advtrains/advtrains_interlocking/tcb_ts_ui.lua
View file

@ -118,6 +118,16 @@ minetest.register_node("advtrains_interlocking:tcb_node", {
end,
})
-- Crafting
minetest.register_craft({
output = 'advtrains_interlocking:tcb_node 4',
recipe = {
{'mesecons:wire_00000000_off', 'basic_materials:ic', 'mesecons:wire_00000000_off'},
},
})
minetest.register_on_punchnode(function(pos, node, player, pointed_thing)
local pname = player:get_player_name()
if not minetest.check_player_privs(pname, "interlocking") then

10
mods/advtrains/advtrains_interlocking/tsr_rail.lua
View file

@ -23,6 +23,16 @@ local adefunc = function(def, preset, suffix, rotation)
advtrains.interlocking.npr_rails[pe] = nil
end,
on_receive_fields = function(pos, formname, fields, player)
local pname = player:get_player_name()
if not minetest.check_player_privs(pname, {interlocking=true}) then
minetest.chat_send_player(pname, "Interlocking privilege required!")
return
end
if minetest.is_protected(pos, pname) then
minetest.chat_send_player(pname, "This rail is protected!")
minetest.record_protection_violation(pos, pname)
return
end
if fields.npr then
local pe = advtrains.encode_pos(pos)
advtrains.interlocking.npr_rails[pe] = tonumber(fields.npr)

39
mods/advtrains/advtrains_signals_ks/init.lua
View file

@ -199,7 +199,7 @@ for _, rtab in ipairs({
save_in_at_nodedb = 1,
not_in_creative_inventory = (rtab.ici and prts.ici) and 0 or 1,
},
drop = "advtrains_signals_ks:sign_e_0",
drop = "advtrains_signals_ks:sign_8_0",
inventory_image = "advtrains_signals_ks_sign_8.png",
sounds = default.node_sound_stone_defaults(),
advtrains = {
@ -241,3 +241,40 @@ for _, rtab in ipairs({
advtrains.trackplacer.add_worked("advtrains_signals_ks:mast","mast", "_"..rot)
end
-- Crafting
minetest.register_craft({
output = "advtrains_signals_ks:hs_danger_0 2",
recipe = {
{'default:steel_ingot', 'dye:red', 'default:steel_ingot'},
{'dye:yellow', 'default:steel_ingot', 'dye:dark_green'},
{'default:steel_ingot', 'advtrains_signals_ks:mast_mast_0', 'default:steel_ingot'},
},
})
minetest.register_craft({
output = "advtrains_signals_ks:mast_mast_0 10",
recipe = {
{'default:steel_ingot'},
{'dye:cyan'},
{'default:steel_ingot'},
},
})
minetest.register_craft({
output = "advtrains_signals_ks:ra_danger_0 2",
recipe = {
{'dye:red', 'dye:white', 'dye:red'},
{'dye:white', 'default:steel_ingot', 'default:steel_ingot'},
{'default:steel_ingot', 'advtrains_signals_ks:mast_mast_0', 'default:steel_ingot'},
},
})
minetest.register_craft({
output = "advtrains_signals_ks:sign_8_0 2",
recipe = {
{'basic_materials:plastic_sheet', 'dye:black'},
{'default:stick', ''},
{'default:stick', ''},
},
})

42
mods/advtrains/advtrains_train_industrial/init.lua
View file

@ -105,3 +105,45 @@ advtrains.register_wagon("wagon_wood", {
box=8*3,
},
}, S("Industrial wood wagon"), "advtrains_wagon_wood_inv.png")
-- Craftings
minetest.register_craft({
output = 'advtrains:engine_industrial',
recipe = {
{'default:steelblock', 'default:steelblock', 'default:steelblock'},
{'advtrains:driver_cab', 'default:steelblock', 'default:steelblock'},
{'advtrains:wheel', '', 'advtrains:wheel'},
},
})
--Engine Industrial Big
minetest.register_craft({
output = 'advtrains:engine_industrial_big',
recipe = {
{'default:glass', 'default:steelblock', 'default:steelblock'},
{'advtrains:driver_cab', 'default:steelblock', 'default:steelblock'},
{'advtrains:wheel', 'advtrains:wheel', 'advtrains:wheel'},
},
})
--Industrial tank wagon
minetest.register_craft({
output = 'advtrains:wagon_tank',
recipe = {
{'default:steelblock', 'default:steel_ingot', 'default:steelblock'},
{'advtrains:steelblock', '', 'default:steelblock'},
{'advtrains:wheel', 'default:steelblock', 'advtrains:wheel'},
},
})
--Industrial wood wagon
minetest.register_craft({
output = 'advtrains:wagon_wood',
recipe = {
{'default:steel_ingot', '', 'default:steel_ingot'},
{'advtrains:steelblock', 'default:steelblock', 'default:steelblock'},
{'advtrains:wheel', '', 'advtrains:wheel'},
},
})

22
mods/advtrains/advtrains_train_japan/init.lua
View file

@ -138,3 +138,25 @@ advtrains.register_wagon("wagon_japan", {
drops={"default:steelblock 4"},
}, S("Japanese Train Wagon"), "advtrains_wagon_japan_inv.png")
-- Crafting
minetest.register_craft({
output = 'advtrains:engine_japan',
recipe = {
{'default:steelblock', 'default:steelblock', ''},
{'xpanes:pane_flat', 'default:steelblock', 'xpanes:pane_flat'},
{'advtrains:wheel', 'advtrains:wheel', 'advtrains:wheel'},
},
})
minetest.register_craft({
output = 'advtrains:wagon_japan',
recipe = {
{'default:steelblock', 'default:steelblock', 'default:steelblock'},
{'xpanes:pane_flat', 'default:steelblock', 'xpanes:pane_flat'},
{'advtrains:wheel', '', 'advtrains:wheel'},
},
})

23
mods/advtrains/advtrains_train_track/init.lua
View file

@ -298,6 +298,29 @@ advtrains.register_tracks("default", {
end
}, advtrains.trackpresets.t_30deg_straightonly)
minetest.register_craft({
type="shapeless",
output = 'advtrains:dtrack_load_placer',
recipe = {
"advtrains:dtrack_placer",
"basic_materials:ic",
"default:chest"
},
})
minetest.register_craft({
type="shapeless",
output = 'advtrains:dtrack_unload_placer',
recipe = {
"advtrains:dtrack_load_placer",
},
})
minetest.register_craft({
type="shapeless",
output = 'advtrains:dtrack_load_placer',
recipe = {
"advtrains:dtrack_unload_placer",
},
})
if mesecon then

2
mods/ambience/init.lua
View file

@ -125,7 +125,7 @@ local get_ambience = function(player, tod, name)
-- get foot and head level nodes at player position
local pos = player:get_pos()
local pos = player:get_pos() ; if not pos then return end
pos.y = pos.y + 1.4 -- head level

18
mods/bonemeal/init.lua
View file

@ -63,24 +63,22 @@ local dry_grass = {
"default:dry_grass_5", "", ""
}
-- add all in-game flowers except waterlily
-- loads mods then add all in-game flowers except waterlily
local flowers = {}
minetest.after(0.1, function()
for node, def in pairs(minetest.registered_nodes) do
if def.groups.flower and not node:find("waterlily") then
if def.groups
and def.groups.flower
and not node:find("waterlily")
and not node:find("xdecor:potted_") then
flowers[#flowers + 1] = node
end
end
end)
-- add additional bakedclay flowers if enabled
if minetest.get_modpath("bakedclay") then
flowers[#flowers + 1] = "bakedclay:delphinium"
flowers[#flowers + 1] = "bakedclay:thistle"
flowers[#flowers + 1] = "bakedclay:lazarus"
flowers[#flowers + 1] = "bakedclay:mannagrass"
flowers[#flowers + 1] = ""
end
-- default biomes deco
local deco = {

392
mods/builtin_item/init.lua
View file

@ -22,28 +22,30 @@ end
-- If item_entity_ttl is not set, enity will have default life time
-- Setting it to -1 disables the feature
local time_to_live = tonumber(core.settings:get("item_entity_ttl")) or 900
local gravity = tonumber(core.settings:get("movement_gravity")) or 9.81
local destroy_item = core.settings:get_bool("destroy_item") ~= false
-- water flow functions by QwertyMine3, edited by TenPlus1
local inv_roots = {
[0] = 1
}
-- localize some math functions
local abs = math.abs
local sqrt = math.sqrt
-- water flow functions by QwertyMine3, edited by TenPlus1 and Gustavo6046
local inv_roots = {[0] = 1}
local function to_unit_vector(dir_vector)
local sum = dir_vector.x * dir_vector.x + dir_vector.z * dir_vector.z
local invr_sum = 0
local invr_sum
-- find inverse square root if possible
if inv_roots[sum] ~= nil then
invr_sum = inv_roots[sum]
else
-- not found, compute and save the inverse square root
invr_sum = 1.0 / math.sqrt(sum)
invr_sum = 1.0 / sqrt(sum)
inv_roots[sum] = invr_sum
end
@ -104,9 +106,6 @@ local function quick_flow_logic(node, pos_testing, direction)
end
-- reciprocal of the length of an unit square's diagonal
local DIAG_WEIGHT = 2 / math.sqrt(2)
local function quick_flow(pos, node)
local x, z = 0.0, 0.0
@ -118,7 +117,6 @@ local function quick_flow(pos, node)
return to_unit_vector({x = x, y = 0, z = z})
end
-- END water flow functions
-- particle effects for when item is destroyed
@ -141,10 +139,19 @@ local function add_effects(pos)
})
end
-- print vector, helpful when debugging
local function vec_print(head, vec)
print(head, vec.x, vec.y, vec.z)
end
local water_force = tonumber(minetest.settings:get("builtin_item.waterflow_force") or 1.6)
local water_drag = tonumber(minetest.settings:get("builtin_item.waterflow_drag") or 0.8)
local dry_friction = tonumber(minetest.settings:get("builtin_item.friction_dry") or 2.5)
local air_drag = tonumber(minetest.settings:get("builtin_item.air_drag") or 0.4)
local items_collect_on_slippery = tonumber(
minetest.settings:get("builtin_item.items_collect_on_slippery") or 1) ~= 0
local water_force = 0.8
local water_friction = 0.8
local dry_friction = 2.5
core.register_entity(":__builtin:item", {
@ -159,14 +166,17 @@ core.register_entity(":__builtin:item", {
spritediv = {x = 1, y = 1},
initial_sprite_basepos = {x = 0, y = 0},
is_visible = false,
infotext = "",
infotext = ""
},
itemstring = "",
moving_state = true,
falling_state = true,
slippery_state = false,
waterflow_state = false,
age = 0,
accel = {x = 0, y = 0, z = 0},
set_item = function(self, item)
local stack = ItemStack(item or self.itemstring)
@ -200,11 +210,14 @@ core.register_entity(":__builtin:item", {
name = name1
end
-- small random size bias to counter Z-fighting
local bias = math.random() * 1e-3
self.object:set_properties({
is_visible = true,
visual = "wielditem",
textures = {itemname},
visual_size = {x = size, y = size},
visual_size = {x = size + bias, y = size + bias, z = size + bias},
collisionbox = {-size, -col_height, -size, size, col_height, size},
selectionbox = {-size, -size, -size, size, size, size},
automatic_rotate = 0.314 / size,
@ -217,11 +230,13 @@ core.register_entity(":__builtin:item", {
get_staticdata = function(self)
return core.serialize({
local data = {
itemstring = self.itemstring,
age = self.age,
dropped_by = self.dropped_by
})
}
return core.serialize(data)
end,
on_activate = function(self, staticdata, dtime_s)
@ -240,8 +255,6 @@ core.register_entity(":__builtin:item", {
end
self.object:set_armor_groups({immortal = 1})
self.object:set_velocity({x = 0, y = 2, z = 0})
self.object:set_acceleration({x = 0, y = -gravity, z = 0})
self:set_item()
end,
@ -271,11 +284,23 @@ core.register_entity(":__builtin:item", {
-- Merge the remote stack into this one
local pos = object:get_pos()
pos.y = pos.y + ((total_count - count) / max_count) * 0.15
self.object:move_to(pos)
self.age = 0 -- Handle as new entity
-- Merge velocities
local vel_a = self.object:get_velocity()
local vel_b = object:get_velocity()
self.object:set_velocity({
x = (vel_a.x + vel_b.x) / 2,
y = (vel_a.y + vel_b.y) / 2,
z = (vel_a.z + vel_b.z) / 2
})
-- Merge stacks
own_stack:set_count(total_count)
self:set_item(own_stack)
@ -285,22 +310,10 @@ core.register_entity(":__builtin:item", {
return true
end,
on_step = function(self, dtime, moveresult)
step_update_node_state = function(self, moveresult, dtime)
local pos = self.object:get_pos()
self.age = self.age + dtime
if time_to_live > 0 and self.age > time_to_live then
self.itemstring = ""
self.object:remove()
add_effects(pos)
return
end
-- get nodes every 1/4 second
self.timer = (self.timer or 0) + dtime
@ -312,6 +325,7 @@ core.register_entity(":__builtin:item", {
-- get ground node for collision
self.node_under = nil
self.falling_state = true
if moveresult.touching_ground then
@ -320,6 +334,7 @@ core.register_entity(":__builtin:item", {
if info.axis == "y" then
self.node_under = core.get_node(info.node_pos)
self.falling_state = false
break
end
@ -331,8 +346,13 @@ core.register_entity(":__builtin:item", {
self.timer = 0
end
end,
step_node_inside_checks = function(self)
local pos = self.object:get_pos()
local node = self.node_inside
local def = self.def_inside
-- Delete in 'ignore' nodes
if node and node.name == "ignore" then
@ -340,23 +360,22 @@ core.register_entity(":__builtin:item", {
self.itemstring = ""
self.object:remove()
return
return true
end
-- do custom step function
local name = ItemStack(self.itemstring):get_name() or ""
local custom = core.registered_items[name]
and core.registered_items[name].dropped_step
-- item inside block, move to vacant space
if def and (def.walkable == nil or def.walkable == true)
and (def.collision_box == nil or def.collision_box.type == "regular")
and (def.node_box == nil or def.node_box.type == "regular") then
if custom and custom(self, pos, dtime) == false then
return -- skip further checks if false
local npos = minetest.find_node_near(pos, 1, "air")
if npos then
self.object:move_to(npos)
end
local vel = self.object:get_velocity()
local def = self.def_inside
local is_slippery = false
local is_moving = (def and not def.walkable) or
vel.x ~= 0 or vel.y ~= 0 or vel.z ~= 0
self.node_inside = nil -- force get_node
end
-- destroy item when dropped into lava (if enabled)
if destroy_item and def and def.groups and def.groups.lava then
@ -372,125 +391,156 @@ core.register_entity(":__builtin:item", {
add_effects(pos)
return true
end
return false
end,
step_check_slippery = function(self)
-- don't check for slippery ground if we're not on
-- any ground to begin with
local node = self.node_under
local def = self.def_under
if self.falling_state or not node then
self.slippery_state = false
return
end
-- water flowing
if def and def.liquidtype == "flowing" then
-- force applies on acceleration over time, thus multiply
local force = water_force * dtime
-- friction applies on velocity over time, thus exponentiate
local friction = (1.0 + water_friction) ^ dtime
-- get flow velocity and current vel/acc state
local vec = quick_flow(pos, node)
local a = self.object:get_acceleration()
self.object:set_acceleration({
x = a.x + vec.x * force,
y = a.y,
z = a.z + vec.z * force
})
-- apply friction to prevent items going too fast, and also to make
-- water flow override previous horizontal momentum more quickly
local v = self.object:get_velocity()
-- adjust friction for going against the current
local v_horz = { x = v.x, y = 0, z = v.z }
local v_dir = to_unit_vector(v_horz)
local flow_dot = v_dir.x * vec.x + v_dir.y * vec.y
-- also maps flow_dot from [-1,0] to [0.5,2.5]
friction = 1.0 + ((friction - 1.0) * (flow_dot + 1.5))
self.object:set_velocity({
x = v.x / friction,
y = v.y / friction,
z = v.z / friction
})
return
end
-- item inside block, move to vacant space
if def and (def.walkable == nil or def.walkable == true)
and (def.collision_box == nil or def.collision_box.type == "regular")
and (def.node_box == nil or def.node_box.type == "regular") then
local npos = minetest.find_node_near(pos, 1, "air")
if npos then
self.object:move_to(npos)
end
self.node_inside = nil -- force get_node
return
end
-- Switch locals to node under
node = self.node_under
def = self.def_under
-- Slippery node check
if def and def.walkable then
if node and def and def.walkable then
local slippery = core.get_item_group(node.name, "slippery")
is_slippery = slippery ~= 0
self.slippery_state = slippery ~= 0
end
end,
if is_slippery and (math.abs(vel.x) > 0.2 or math.abs(vel.z) > 0.2) then
step_water_physics = function(self)
-- Horizontal deceleration
local pos = self.object:get_pos()
local vel = self.object:get_velocity()
local node = self.node_inside
local def = self.def_inside
self.waterflow_state = def and def.liquidtype == "flowing"
if self.waterflow_state then
-- get flow velocity
local flow_vel = quick_flow(pos, node)
-- calculate flow force and drag
local flow_force_x = flow_vel.x * water_force
local flow_force_z = flow_vel.z * water_force
local flow_drag_x = (flow_force_x - vel.x) * water_drag
local flow_drag_z = (flow_force_z - vel.z) * water_drag
-- apply water force and friction
self.accel.x = self.accel.x + flow_force_x + flow_drag_x
self.accel.z = self.accel.z + flow_force_z + flow_drag_z
end
end,
step_air_drag_physics = function(self)
local vel = self.object:get_velocity()
-- apply air drag
if self.falling_state or (self.slippery_state and not self.waterflow_state) then
self.accel.x = self.accel.x - vel.x * air_drag
self.accel.z = self.accel.z - vel.z * air_drag
end
end,
step_gravity = function(self)
if self.falling_state then
self.accel.y = self.accel.y - gravity
end
end,
step_ground_friction = function(self)
-- don't apply ground friction when falling!
if self.falling_state then
return
end
local vel = self.object:get_velocity()
if self.slippery_state then
local node = self.node_under
-- apply slip factor (tiny friction that depends on the actual block type)
if (abs(vel.x) > 0.2 or abs(vel.z) > 0.2) then
local slippery = core.get_item_group(node.name, "slippery")
local slip_factor = 4.0 / (slippery + 4)
self.object:set_acceleration({
x = -vel.x * slip_factor,
y = 0,
z = -vel.z * slip_factor
})
elseif vel.y == 0 then
is_moving = false
end
self.accel.x = self.accel.x - vel.x * slip_factor
self.accel.z = self.accel.z - vel.z * slip_factor
end
if self.moving_state == is_moving
and self.slippery_state == is_slippery then
return -- No further updates until moving state changes
end
self.moving_state = is_moving
self.slippery_state = is_slippery
local a_curr = self.object:get_acceleration()
local v_curr = self.object:get_velocity()
if is_moving then
self.object:set_acceleration({
x = a_curr.x,
y = a_curr.y - gravity,
z = a_curr.z
})
else
self.object:set_acceleration({x = 0, y = 0, z = 0})
self.accel.x = self.accel.x - vel.x * dry_friction
self.accel.z = self.accel.z - vel.z * dry_friction
end
end,
-- preserve *some* velocity so items don't get stuck on the very ledges
-- of nodes once they move just enough to leave the hitbox of flowing water
self.object:set_velocity({
x = v_curr.x / dry_friction,
y = v_curr.y / dry_friction,
z = v_curr.z / dry_friction
})
step_apply_forces = function(self)
self.object:set_acceleration(self.accel)
end,
step_check_timeout = function(self, dtime)
local pos = self.object:get_pos()
self.age = self.age + dtime
if time_to_live > 0 and self.age > time_to_live then
self.itemstring = ""
self.object:remove()
add_effects(pos)
return true
end
--Only collect items if not moving
if is_moving then
return false
end,
step_check_custom_step = function(self, dtime, moveresult)
local pos = self.object:get_pos()
-- do custom step function
local name = ItemStack(self.itemstring):get_name() or ""
local custom = core.registered_items[name]
and core.registered_items[name].dropped_step
if custom and custom(self, pos, dtime, moveresult) == false then
return true -- skip further checks if false
end
return false
end,
step_try_collect = function(self)
local self_pos = self.object:get_pos()
-- Don't collect items if falling
if self.falling_state then
return
end
-- Check if we should collect items while sliding
if self.slippery_state and not items_collect_on_slippery then
return
end
@ -501,16 +551,19 @@ core.register_entity(":__builtin:item", {
return
end
local objects = core.get_objects_inside_radius(pos, 1.0)
local objects = core.get_objects_inside_radius(self_pos, 1.0)
for k, obj in pairs(objects) do
for _, obj in pairs(objects) do
local entity = obj:get_luaentity()
if entity and entity.name == "__builtin:item" then
if entity and entity.name == "__builtin:item" and not entity.is_falling then
if self:try_merge_with(own_stack, obj, entity) then
-- item will be moved up due to try_merge_with
self.falling_state = true
own_stack = ItemStack(self.itemstring)
if own_stack:get_free_space() == 0 then
@ -521,6 +574,41 @@ core.register_entity(":__builtin:item", {
end
end,
on_step = function(self, dtime, moveresult)
-- reset acceleration
self.accel = {x = 0, y = 0, z = 0}
-- check item timeout
if self:step_check_timeout(dtime) then
return -- deleted, stop here
end
-- check custom step function
if self:step_check_custom_step(dtime, moveresult) then
return -- overriden
end
-- do general checks
self:step_update_node_state(moveresult, dtime)
if self:step_node_inside_checks() then
return -- destroyed
end
self:step_check_slippery()
-- do physics checks, then apply
self:step_water_physics()
self:step_ground_friction()
self:step_gravity()
self:step_apply_forces()
-- do item checks
self:step_try_collect()
end,
on_punch = function(self, hitter)
local inv = hitter:get_inventory()

541
mods/builtin_item/init.lua_ Normal file
View file

@ -0,0 +1,541 @@
-- Minetest: builtin/item_entity.lua
-- override ice to make slippery for 0.4.16
if not minetest.raycast then
minetest.override_item("default:ice", {
groups = {cracky = 3, puts_out_fire = 1, cools_lava = 1, slippery = 3}})
end
function core.spawn_item(pos, item)
local stack = ItemStack(item)
local obj = core.add_entity(pos, "__builtin:item")
if obj then
obj:get_luaentity():set_item(stack:to_string())
end
return obj
end
-- If item_entity_ttl is not set, enity will have default life time
-- Setting it to -1 disables the feature
local time_to_live = tonumber(core.settings:get("item_entity_ttl")) or 900
local gravity = tonumber(core.settings:get("movement_gravity")) or 9.81
local destroy_item = core.settings:get_bool("destroy_item") ~= false
-- water flow functions by QwertyMine3, edited by TenPlus1
local inv_roots = {
[0] = 1
}
local function to_unit_vector(dir_vector)
local sum = dir_vector.x * dir_vector.x + dir_vector.z * dir_vector.z
local invr_sum = 0
-- find inverse square root if possible
if inv_roots[sum] ~= nil then
invr_sum = inv_roots[sum]
else
-- not found, compute and save the inverse square root
invr_sum = 1.0 / math.sqrt(sum)
inv_roots[sum] = invr_sum
end
return {
x = dir_vector.x * invr_sum,
y = dir_vector.y,
z = dir_vector.z * invr_sum
}
end
local function node_ok(pos)
local node = minetest.get_node_or_nil(pos)
if node and minetest.registered_nodes[node.name] then
return node
end
return minetest.registered_nodes["default:dirt"]
end
local function quick_flow_logic(node, pos_testing, direction)
local node_testing = node_ok(pos_testing)
local param2 = node.param2
if not minetest.registered_nodes[node.name].groups.liquid then
param2 = 0
end
if minetest.registered_nodes[node_testing.name].liquidtype ~= "flowing"
and minetest.registered_nodes[node_testing.name].liquidtype ~= "source" then
return 0
end
local param2_testing = node_testing.param2
if param2_testing < param2 then
if (param2 - param2_testing) > 6 then
return -direction
else
return direction
end
elseif param2_testing > param2 then
if (param2_testing - param2) > 6 then
return direction
else
return -direction
end
end
return 0
end
-- reciprocal of the length of an unit square's diagonal
local DIAG_WEIGHT = 2 / math.sqrt(2)
local function quick_flow(pos, node)
local x, z = 0.0, 0.0
x = x + quick_flow_logic(node, {x = pos.x - 1, y = pos.y, z = pos.z},-1)
x = x + quick_flow_logic(node, {x = pos.x + 1, y = pos.y, z = pos.z}, 1)
z = z + quick_flow_logic(node, {x = pos.x, y = pos.y, z = pos.z - 1},-1)
z = z + quick_flow_logic(node, {x = pos.x, y = pos.y, z = pos.z + 1}, 1)
return to_unit_vector({x = x, y = 0, z = z})
end
-- END water flow functions
-- particle effects for when item is destroyed
local function add_effects(pos)
minetest.add_particlespawner({
amount = 1,
time = 0.25,
minpos = pos,
maxpos = pos,
minvel = {x = -1, y = 2, z = -1},
maxvel = {x = 1, y = 4, z = 1},
minacc = {x = 0, y = 0, z = 0},
maxacc = {x = 0, y = 0, z = 0},
minexptime = 1,
maxexptime = 3,
minsize = 1,
maxsize = 4,
texture = "tnt_smoke.png",
})
end
local water_force = 0.8
local water_friction = 0.8
local dry_friction = 2.5
core.register_entity(":__builtin:item", {
initial_properties = {
hp_max = 1,
physical = true,
collide_with_objects = false,
collisionbox = {-0.3, -0.3, -0.3, 0.3, 0.3, 0.3},
visual = "wielditem",
visual_size = {x = 0.4, y = 0.4},
textures = {""},
spritediv = {x = 1, y = 1},
initial_sprite_basepos = {x = 0, y = 0},
is_visible = false,
infotext = "",
},
itemstring = "",
moving_state = true,
slippery_state = false,
age = 0,
set_item = function(self, item)
local stack = ItemStack(item or self.itemstring)
self.itemstring = stack:to_string()
if self.itemstring == "" then
return
end
local itemname = stack:is_known() and stack:get_name() or "unknown"
local max_count = stack:get_stack_max()
local count = math.min(stack:get_count(), max_count)
local size = 0.2 + 0.1 * (count / max_count) ^ (1 / 3)
local col_height = size * 0.75
local def = core.registered_nodes[itemname]
local glow = def and def.light_source
local c1, c2 = "",""
if not(stack:get_count() == 1) then
c1 = " x"..tostring(stack:get_count())
c2 = " "..tostring(stack:get_count())
end
local name1 = stack:get_meta():get_string("description")
local name
if name1 == "" then
name = core.registered_items[itemname].description
else
name = name1
end
self.object:set_properties({
is_visible = true,
visual = "wielditem",
textures = {itemname},
visual_size = {x = size, y = size},
collisionbox = {-size, -col_height, -size, size, col_height, size},
selectionbox = {-size, -size, -size, size, size, size},
automatic_rotate = 0.314 / size,
wield_item = self.itemstring,
glow = glow,
infotext = name .. c1 .. "\n(" .. itemname .. c2 .. ")"
})
end,
get_staticdata = function(self)
return core.serialize({
itemstring = self.itemstring,
age = self.age,
dropped_by = self.dropped_by
})
end,
on_activate = function(self, staticdata, dtime_s)
if string.sub(staticdata, 1, string.len("return")) == "return" then
local data = core.deserialize(staticdata)
if data and type(data) == "table" then
self.itemstring = data.itemstring
self.age = (data.age or 0) + dtime_s
self.dropped_by = data.dropped_by
end
else
self.itemstring = staticdata
end
self.object:set_armor_groups({immortal = 1})
self.object:set_velocity({x = 0, y = 2, z = 0})
self.object:set_acceleration({x = 0, y = -gravity, z = 0})
self:set_item()
end,
try_merge_with = function(self, own_stack, object, entity)
if self.age == entity.age then
return false -- Can not merge with itself
end
local stack = ItemStack(entity.itemstring)
local name = stack:get_name()
if own_stack:get_name() ~= name
or own_stack:get_meta() ~= stack:get_meta()
or own_stack:get_wear() ~= stack:get_wear()
or own_stack:get_free_space() == 0 then
return false -- Can not merge different or full stack
end
local count = own_stack:get_count()
local total_count = stack:get_count() + count
local max_count = stack:get_stack_max()
if total_count > max_count then
return false
end
-- Merge the remote stack into this one
local pos = object:get_pos()
pos.y = pos.y + ((total_count - count) / max_count) * 0.15
self.object:move_to(pos)
self.age = 0 -- Handle as new entity
own_stack:set_count(total_count)
self:set_item(own_stack)
entity.itemstring = ""
object:remove()
return true
end,
on_step = function(self, dtime, moveresult)
local pos = self.object:get_pos()
self.age = self.age + dtime
if time_to_live > 0 and self.age > time_to_live then
self.itemstring = ""
self.object:remove()
add_effects(pos)
return
end
-- get nodes every 1/4 second
self.timer = (self.timer or 0) + dtime
if self.timer > 0.25 or not self.node_inside then
self.node_inside = minetest.get_node_or_nil(pos)
self.def_inside = self.node_inside
and core.registered_nodes[self.node_inside.name]
-- get ground node for collision
self.node_under = nil
if moveresult.touching_ground then
for _, info in ipairs(moveresult.collisions) do
if info.axis == "y" then
self.node_under = core.get_node(info.node_pos)
break
end
end
end
self.def_under = self.node_under
and core.registered_nodes[self.node_under.name]
self.timer = 0
end
local node = self.node_inside
-- Delete in 'ignore' nodes
if node and node.name == "ignore" then
self.itemstring = ""
self.object:remove()
return
end
-- do custom step function
local name = ItemStack(self.itemstring):get_name() or ""
local custom = core.registered_items[name]
and core.registered_items[name].dropped_step
if custom and custom(self, pos, dtime) == false then
return -- skip further checks if false
end
local vel = self.object:get_velocity()
local def = self.def_inside
local is_slippery = false
local is_moving = (def and not def.walkable) or
vel.x ~= 0 or vel.y ~= 0 or vel.z ~= 0
-- destroy item when dropped into lava (if enabled)
if destroy_item and def and def.groups and def.groups.lava then
minetest.sound_play("builtin_item_lava", {
pos = pos,
max_hear_distance = 6,
gain = 0.5
})
self.itemstring = ""
self.object:remove()
add_effects(pos)
return
end
-- water flowing
if def and def.liquidtype == "flowing" then
-- force applies on acceleration over time, thus multiply
local force = water_force * dtime
-- friction applies on velocity over time, thus exponentiate
local friction = (1.0 + water_friction) ^ dtime
-- get flow velocity and current vel/acc state
local vec = quick_flow(pos, node)
local a = self.object:get_acceleration()
self.object:set_acceleration({
x = a.x + vec.x * force,
y = a.y,
z = a.z + vec.z * force
})
-- apply friction to prevent items going too fast, and also to make
-- water flow override previous horizontal momentum more quickly
local v = self.object:get_velocity()
-- adjust friction for going against the current
local v_horz = { x = v.x, y = 0, z = v.z }
local v_dir = to_unit_vector(v_horz)
local flow_dot = v_dir.x * vec.x + v_dir.y * vec.y
-- also maps flow_dot from [-1,0] to [0.5,2.5]
friction = 1.0 + ((friction - 1.0) * (flow_dot + 1.5))
self.object:set_velocity({
x = v.x / friction,
y = v.y / friction,
z = v.z / friction
})
return
end
-- item inside block, move to vacant space
if def and (def.walkable == nil or def.walkable == true)
and (def.collision_box == nil or def.collision_box.type == "regular")
and (def.node_box == nil or def.node_box.type == "regular") then
local npos = minetest.find_node_near(pos, 1, "air")
if npos then
self.object:move_to(npos)
end
self.node_inside = nil -- force get_node
return
end
-- Switch locals to node under
node = self.node_under
def = self.def_under
-- Slippery node check
if def and def.walkable then
local slippery = core.get_item_group(node.name, "slippery")
is_slippery = slippery ~= 0
if is_slippery and (math.abs(vel.x) > 0.2 or math.abs(vel.z) > 0.2) then
-- Horizontal deceleration
local slip_factor = 4.0 / (slippery + 4)
self.object:set_acceleration({
x = -vel.x * slip_factor,
y = 0,
z = -vel.z * slip_factor
})
elseif vel.y == 0 then
is_moving = false
end
end
if self.moving_state == is_moving
and self.slippery_state == is_slippery then
return -- No further updates until moving state changes
end
self.moving_state = is_moving
self.slippery_state = is_slippery
local a_curr = self.object:get_acceleration()
local v_curr = self.object:get_velocity()
if is_moving then
self.object:set_acceleration({
x = a_curr.x,
y = a_curr.y - gravity,
z = a_curr.z
})
else
self.object:set_acceleration({x = 0, y = 0, z = 0})
-- preserve *some* velocity so items don't get stuck on the very ledges
-- of nodes once they move just enough to leave the hitbox of flowing water
self.object:set_velocity({
x = v_curr.x / dry_friction,
y = v_curr.y / dry_friction,
z = v_curr.z / dry_friction
})
end
--Only collect items if not moving
if is_moving then
return
end
-- Collect the items around to merge with
local own_stack = ItemStack(self.itemstring)
if own_stack:get_free_space() == 0 then
return
end
local objects = core.get_objects_inside_radius(pos, 1.0)
for k, obj in pairs(objects) do
local entity = obj:get_luaentity()
if entity and entity.name == "__builtin:item" then
if self:try_merge_with(own_stack, obj, entity) then
own_stack = ItemStack(self.itemstring)
if own_stack:get_free_space() == 0 then
return
end
end
end
end
end,
on_punch = function(self, hitter)
local inv = hitter:get_inventory()
if inv and self.itemstring ~= "" then
local left = inv:add_item("main", self.itemstring)
if left and not left:is_empty() then
self:set_item(left)
return
end
end
self.itemstring = ""
self.object:remove()
end,
})

40
mods/builtin_item/settingtypes.txt Normal file
View file

@ -0,0 +1,40 @@
# Controls how much force should be exerted on
# dropped items when they are pushed by flowing water.
#
# The larger this number, the faster items become when
# carried by water.
waterflow_force (Force of water flow on dropped items) float 1.6
# Controls how much drag force should be exerted on
# dropped items when they are submerged in flowing water
# but have a different momentum vector than the flow velocity.
#
# The larger this number, the larger the resistance of water
# to the push of an item. In other words, items thrown at
# flowing water in a direction opposite that of the flow will
# be pushed more quickly in the other direction with higher drag,
# even if the actual flow force remains the same.
waterflow_drag (Drag of water flow on dropped items) float 0.8
# Controls how much friction force should be exerted on
# dropped items when they move horizontally on the
# ground.
#
# The larger this number, the quickier items will come to
# a halt horizontally after falling on the floor.
friction_dry (Friction of dry ground on dropped items) float 2.5
# Controls how much horizontal drag force should be exerted on
# dropped items when they move horizontally in air.
#
# The larger this number, the quickier horizontal velocity tends
# toward zero.
air_drag (Horizontal drag of air on falling items) float 0.4
# Allow items on the floor to collect even on slippery floors.
#
# Dropped items can 'collect', that is, to have their
# stacks merged if they're close enough and are of the same item
# type. By default they can do this even on a slippery floor, like
# ice, but this setting allows disabling that.
builtin_item.items_collect_on_slippery (Collect items on slippery ground) bool true

6
mods/cottages/nodes_anvil.lua
View file

@ -229,9 +229,9 @@ minetest.register_node("cottages:anvil", {
end
minetest.after(2, function()
if( puncher ) then
puncher:hud_remove(hud1);
puncher:hud_remove(hud2);
puncher:hud_remove(hud3);
if(hud1) then puncher:hud_remove(hud1); end
if(hud2) then puncher:hud_remove(hud2); end
if(hud3) then puncher:hud_remove(hud3); end
end
end)

14
mods/cottages/nodes_straw.lua
View file

@ -333,13 +333,13 @@ minetest.register_node("cottages:threshing_floor", {
minetest.after(2, function()
if( puncher ) then
puncher:hud_remove(hud1);
puncher:hud_remove(hud2);
puncher:hud_remove(hud3);
puncher:hud_remove(hud4);
puncher:hud_remove(hud5);
puncher:hud_remove(hud6);
puncher:hud_remove(hud0);
if(hud1) then puncher:hud_remove(hud1); end
if(hud2) then puncher:hud_remove(hud2); end
if(hud3) then puncher:hud_remove(hud3); end
if(hud4) then puncher:hud_remove(hud4); end
if(hud5) then puncher:hud_remove(hud5); end
if(hud6) then puncher:hud_remove(hud6); end
if(hud0) then puncher:hud_remove(hud0); end
end
end)
end,

8
mods/farming/food.lua
View file

@ -348,7 +348,6 @@ minetest.register_craftitem("farming:pasta", {
groups = {food_pasta = 1}
})
if minetest.get_modpath("mobs_animal") or minetest.get_modpath("xanadu")then
minetest.register_craft({
output = "farming:pasta",
type = "shapeless",
@ -358,7 +357,7 @@ minetest.register_craft({
},
replacements = {{"group:food_mixing_bowl", "farming:mixing_bowl"}}
})
else
minetest.register_craft({
output = "farming:pasta",
type = "shapeless",
@ -371,7 +370,6 @@ minetest.register_craft({
{"group:food_oil", "vessels:glass_bottle"}
}
})
end
-- Spaghetti
@ -399,7 +397,6 @@ minetest.register_craftitem("farming:bibimbap", {
on_use = minetest.item_eat(8, "farming:bowl")
})
if minetest.get_modpath("mobs_animal") or minetest.get_modpath("xanadu")then
minetest.register_craft({
output = "farming:bibimbap",
type = "shapeless",
@ -410,7 +407,7 @@ minetest.register_craft({
},
replacements = {{"group:food_skillet", "farming:skillet"}}
})
else
minetest.register_craft({
output = "farming:bibimbap",
type = "shapeless",
@ -421,7 +418,6 @@ minetest.register_craft({
},
replacements = {{"group:food_skillet", "farming:skillet"}}
})
end
-- Burger

2
mods/farming/locale/zh_CN.txt
View file

@ -59,7 +59,7 @@ Cornstarch=玉米淀粉
Bottle of Ethanol=一瓶乙醇
Cotton Seed=棉籽
Cotton=棉花
String=字符串
String=线
Cucumber=黄瓜
Garlic clove=蒜瓣
Garlic=大蒜

2
mods/farming/soil.lua
View file

@ -148,7 +148,7 @@ minetest.register_abm({
if minetest.registered_nodes[nn]
and minetest.registered_nodes[nn].walkable
and minetest.get_item_group(nn, "plant") == 0 then
minetest.set_node(pos, {name = "default:dirt"})
minetest.set_node(pos, {name = ndef.soil.base})
return
end

2
mods/homedecor_modpack/homedecor_books/init.lua
View file

@ -27,7 +27,7 @@ for _, c in ipairs(bookcolors) do
local color, hue = unpack(c)
local function book_dig(pos, node, digger)
if minetest.is_protected(pos, digger:get_player_name()) then return end
if not digger or minetest.is_protected(pos, digger:get_player_name()) then return end
local meta = minetest.get_meta(pos)
local data = minetest.serialize({
title = meta:get_string("title") or "",

5
mods/homedecor_modpack/homedecor_lighting/init.lua
View file

@ -162,7 +162,10 @@ if minetest.get_modpath("digilines") then
if puncher:get_player_control().sneak then
local name = puncher:get_player_name()
player_last_clicked[name] = pos
local form = "field[channel;Channel;]"
local form = "formspec_version[4]"..
"size[8,4]"..
"button_exit[3,2.5;2,0.5;proceed;Proceed]"..
"field[1.75,1.5;4.5,0.5;channel;Channel;]"
minetest.show_formspec(name, "homedecor:lamp_set_channel", form)
end
end

5
mods/ilights/init.lua
View file

@ -141,7 +141,10 @@ if minetest.get_modpath("digilines") then
local name = puncher:get_player_name()
player_last_clicked[name] = pos
local meta = minetest.get_meta(pos)
local form = "field[channel;Channel;]"
local form = "formspec_version[4]"..
"size[8,4]"..
"button_exit[3,2.5;2,0.5;proceed;Proceed]"..
"field[1.75,1.5;4.5,0.5;channel;Channel;]"
minetest.show_formspec(name, "ilights:set_channel", form)
end
end

3
mods/intllib/init.lua
View file

@ -201,7 +201,8 @@ function intllib.get_strings(modname, langcode)
local modpath = minetest.get_modpath(modname)
msgstr = { }
for _, l in ipairs(get_locales(langcode)) do
local t = intllib.load_strings(modpath.."/locale/"..l..".txt") or { }
local t = intllib.load_strings(modpath.."/locale/"..modname.."."..l..".tr")
or intllib.load_strings(modpath.."/locale/"..l..".txt") or { }
for k, v in pairs(t) do
msgstr[k] = msgstr[k] or v
end

3
mods/skinsdb/meta/character_1950.txt Normal file
View file

@ -0,0 +1,3 @@
Effy
aonymous
CC BY-SA 3.0

BIN
mods/skinsdb/textures/character_1950.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 10 KiB

211
mods/stamina/init.lua
View file

@ -31,7 +31,7 @@ SPRINT_DRAIN = 0.35 -- how fast to drain satation while sprinting (0-1)
local function get_int_attribute(player)
-- pipeworks fake player check
if not player.get_attribute then
if not player or not player.get_attribute then
return nil
end
@ -204,27 +204,14 @@ local function set_sprinting(name, sprinting)
end
-- Time based stamina functions
local stamina_timer, health_timer, action_timer, poison_timer, drunk_timer = 0,0,0,0,0
local function drunk_tick()
local function stamina_globaltimer(dtime)
stamina_timer = stamina_timer + dtime
health_timer = health_timer + dtime
action_timer = action_timer + dtime
poison_timer = poison_timer + dtime
drunk_timer = drunk_timer + dtime
local players = minetest.get_connected_players()
-- simulate drunk walking (thanks LumberJ)
if drunk_timer > 1.0 then
for _,player in pairs(players) do
for _,player in ipairs(minetest.get_connected_players()) do
local name = player:get_player_name()
if stamina.players[name]
if name
and stamina.players[name]
and stamina.players[name].drunk then
-- play burp sound every 20 seconds when drunk
@ -242,66 +229,63 @@ local function stamina_globaltimer(dtime)
stamina.players[name].drunk = nil
stamina.players[name].units = 0
if not stamina.players[name].poisoned then
player:hud_change(stamina.players[name].hud_id,
"text", "stamina_hud_fg.png")
end
end
-- effect only works when not riding boat/cart/horse etc.
if not player:get_attach() then
local yaw = player:get_look_horizontal()
yaw = yaw + math.random(-0.5, 0.5)
local yaw = player:get_look_horizontal() + math.random(-0.5, 0.5)
player:set_look_horizontal(yaw)
end
end
drunk_timer = 0
end
end
-- hurt player when poisoned
if poison_timer > STAMINA_POISON_TICK then
local function health_tick()
for _,player in pairs(players) do
for _,player in ipairs(minetest.get_connected_players()) do
local air = player:get_breath() or 0
local hp = player:get_hp()
local h = get_int_attribute(player)
local name = player:get_player_name()
if stamina.players[name]
and stamina.players[name].poisoned
and stamina.players[name].poisoned > 0 then
if name then
stamina.players[name].poisoned =
stamina.players[name].poisoned - 1
local hp = player:get_hp() - 1
if hp > 0 then
player:set_hp(hp, {poison = true})
-- damage player by 1 hp if saturation is < 2
if h and h < STAMINA_STARVE_LVL
and hp > 0 then
player:set_hp(hp - STAMINA_STARVE, {hunger = true})
end
elseif stamina.players[name]
and stamina.players[name].poisoned then
-- don't heal if drowning or dead or poisoned
if h and h >= STAMINA_HEAL_LVL
and h >= hp
and hp > 0
and air > 0
and not stamina.players[name].poisoned then
player:hud_change(stamina.players[name].hud_id,
"text", "stamina_hud_fg.png")
player:set_hp(hp + STAMINA_HEAL)
stamina.players[name].poisoned = nil
stamina_update_level(player, h - 1)
end
end
poison_timer = 0
end
end
-- sprint control and particle animation
if action_timer > STAMINA_MOVE_TICK then
local function action_tick()
for _,player in pairs(players) do
for _,player in ipairs(minetest.get_connected_players()) do
local controls = player:get_player_control()
local controls = player and player:get_player_control()
-- Determine if the player is walking or jumping
if controls then
@ -320,10 +304,11 @@ local function stamina_globaltimer(dtime)
--- START sprint
if enable_sprint then
local name = player:get_player_name()
local name = player and player:get_player_name()
-- check if player can sprint (stamina must be over 6 points)
if stamina.players[name]
if name
and stamina.players[name]
and not stamina.players[name].poisoned
and not stamina.players[name].drunk
and controls and controls.aux1 and controls.up
@ -337,7 +322,10 @@ local function stamina_globaltimer(dtime)
local pos = player:get_pos()
local node = minetest.get_node({
x = pos.x, y = pos.y - 1, z = pos.z})
x = pos.x,
y = pos.y - 1,
z = pos.z
})
if node.name ~= "air" then
@ -367,65 +355,100 @@ local function stamina_globaltimer(dtime)
stamina_update_level(player,
level - (SPRINT_DRAIN * STAMINA_MOVE_TICK))
else
elseif name then
set_sprinting(name, false)
end
end
-- END sprint
action_timer = 0
end
end
local function poison_tick()
for _,player in ipairs(minetest.get_connected_players()) do
local name = player and player:get_player_name()
if name
and stamina.players[name]
and stamina.players[name].poisoned
and stamina.players[name].poisoned > 0 then
stamina.players[name].poisoned =
stamina.players[name].poisoned - 1
local hp = player:get_hp() - 1
if hp > 0 then
player:set_hp(hp, {poison = true})
end
elseif name
and stamina.players[name]
and stamina.players[name].poisoned then
if not stamina.players[name].drunk then
player:hud_change(stamina.players[name].hud_id,
"text", "stamina_hud_fg.png")
end
stamina.players[name].poisoned = nil
end
end
end
local function stamina_tick()
for _,player in ipairs(minetest.get_connected_players()) do
local h = get_int_attribute(player)
if h and h > STAMINA_TICK_MIN then
stamina_update_level(player, h - 1)
end
end
end
-- Time based stamina functions
local stamina_timer, health_timer, action_timer, poison_timer, drunk_timer = 0,0,0,0,0
local function stamina_globaltimer(dtime)
stamina_timer = stamina_timer + dtime
health_timer = health_timer + dtime
action_timer = action_timer + dtime
poison_timer = poison_timer + dtime
drunk_timer = drunk_timer + dtime
-- simulate drunk walking (thanks LumberJ)
if drunk_timer > 1.0 then
drunk_tick() ; drunk_timer = 0
end
-- hurt player when poisoned
if poison_timer > STAMINA_POISON_TICK then
poison_tick() ; poison_timer = 0
end
-- sprint control and particle animation
if action_timer > STAMINA_MOVE_TICK then
action_tick() ; action_timer = 0
end
-- lower saturation by 1 point after STAMINA_TICK
if stamina_timer > STAMINA_TICK then
for _,player in pairs(players) do
local h = get_int_attribute(player)
if h > STAMINA_TICK_MIN then
stamina_update_level(player, h - 1)
stamina_tick() ; stamina_timer = 0
end
stamina_timer = 0
end
end
-- heal or damage player, depending on saturation
if health_timer > STAMINA_HEALTH_TICK then
for _,player in pairs(players) do
local air = player:get_breath() or 0
local hp = player:get_hp()
local h = get_int_attribute(player)
local name = player:get_player_name()
-- damage player by 1 hp if saturation is < 2 (of 30)
if h and h < STAMINA_STARVE_LVL
and hp > 0 then
player:set_hp(hp - STAMINA_STARVE, {hunger = true})
health_tick() ; health_timer = 0
end
-- don't heal if drowning or dead or poisoned
if h and h >= STAMINA_HEAL_LVL
and h >= hp
and hp > 0
and air > 0
and not stamina.players[name].poisoned then
player:set_hp(hp + STAMINA_HEAL)
stamina_update_level(player, h - 1)
end
health_timer = 0
end
end
end