function default.node_sound_defaults(table)
table = table or {}
table.footstep = table.footstep or
- {name="", gain=1.0}
+ {name = "", gain = 1.0}
table.dug = table.dug or
- {name="default_dug_node", gain=0.25}
+ {name = "default_dug_node", gain = 0.25}
table.place = table.place or
- {name="default_place_node_hard", gain=1.0}
+ {name = "default_place_node_hard", gain = 1.0}
return table
end
function default.node_sound_stone_defaults(table)
table = table or {}
table.footstep = table.footstep or
- {name="default_hard_footstep", gain=0.5}
+ {name = "default_hard_footstep", gain = 0.5}
table.dug = table.dug or
- {name="default_hard_footstep", gain=1.0}
+ {name = "default_hard_footstep", gain = 1.0}
default.node_sound_defaults(table)
return table
end
function default.node_sound_dirt_defaults(table)
table = table or {}
table.footstep = table.footstep or
- {name="default_dirt_footstep", gain=1.0}
+ {name = "default_dirt_footstep", gain = 1.0}
table.dug = table.dug or
- {name="default_dirt_footstep", gain=1.5}
+ {name = "default_dirt_footstep", gain = 1.5}
table.place = table.place or
- {name="default_place_node", gain=1.0}
+ {name = "default_place_node", gain = 1.0}
default.node_sound_defaults(table)
return table
end
function default.node_sound_sand_defaults(table)
table = table or {}
table.footstep = table.footstep or
- {name="default_sand_footstep", gain=0.5}
+ {name = "default_sand_footstep", gain = 0.12}
table.dug = table.dug or
- {name="default_sand_footstep", gain=1.0}
+ {name = "default_sand_footstep", gain = 0.24}
table.place = table.place or
- {name="default_place_node", gain=1.0}
+ {name = "default_place_node", gain = 1.0}
+ default.node_sound_defaults(table)
+ return table
+end
+
+function default.node_sound_gravel_defaults(table)
+ table = table or {}
+ table.footstep = table.footstep or
+ {name = "default_gravel_footstep", gain = 0.5}
+ table.dug = table.dug or
+ {name = "default_gravel_footstep", gain = 1.0}
+ table.place = table.place or
+ {name = "default_place_node", gain = 1.0}
default.node_sound_defaults(table)
return table
end
function default.node_sound_wood_defaults(table)
table = table or {}
table.footstep = table.footstep or
- {name="default_wood_footstep", gain=0.5}
+ {name = "default_wood_footstep", gain = 0.5}
table.dug = table.dug or
- {name="default_wood_footstep", gain=1.0}
+ {name = "default_wood_footstep", gain = 1.0}
default.node_sound_defaults(table)
return table
end
function default.node_sound_leaves_defaults(table)
table = table or {}
table.footstep = table.footstep or
- {name="default_grass_footstep", gain=0.35}
+ {name = "default_grass_footstep", gain = 0.35}
table.dug = table.dug or
- {name="default_grass_footstep", gain=0.85}
+ {name = "default_grass_footstep", gain = 0.7}
table.dig = table.dig or
- {name="default_dig_crumbly", gain=0.4}
+ {name = "default_dig_crumbly", gain = 0.4}
table.place = table.place or
- {name="default_place_node", gain=1.0}
+ {name = "default_place_node", gain = 1.0}
default.node_sound_defaults(table)
return table
end
function default.node_sound_glass_defaults(table)
table = table or {}
table.footstep = table.footstep or
- {name="default_glass_footstep", gain=0.5}
+ {name = "default_glass_footstep", gain = 0.5}
table.dug = table.dug or
- {name="default_break_glass", gain=1.0}
+ {name = "default_break_glass", gain = 1.0}
default.node_sound_defaults(table)
return table
end
---
--- Legacy
---
-
-function default.spawn_falling_node(p, nodename)
- spawn_falling_node(p, nodename)
-end
-
--- Horrible crap to support old code
--- Don't use this and never do what this does, it's completely wrong!
--- (More specifically, the client and the C++ code doesn't get the group)
-function default.register_falling_node(nodename, texture)
- minetest.log("error", debug.traceback())
- minetest.log('error', "WARNING: default.register_falling_node is deprecated")
- if minetest.registered_nodes[nodename] then
- minetest.registered_nodes[nodename].groups.falling_node = 1
- end
-end
-
---
--- Global callbacks
---
-
--- Global environment step function
-function on_step(dtime)
- -- print("on_step")
-end
-minetest.register_globalstep(on_step)
-
-function on_placenode(p, node)
- --print("on_placenode")
-end
-minetest.register_on_placenode(on_placenode)
-
-function on_dignode(p, node)
- --print("on_dignode")
-end
-minetest.register_on_dignode(on_dignode)
-
-function on_punchnode(p, node)
-end
-minetest.register_on_punchnode(on_punchnode)
--
-- Lavacooling
--
-default.cool_lava_source = function(pos)
- minetest.set_node(pos, {name="default:obsidian"})
-end
-
-default.cool_lava_flowing = function(pos)
- minetest.set_node(pos, {name="default:stone"})
+default.cool_lava = function(pos, node)
+ if node.name == "default:lava_source" then
+ minetest.set_node(pos, {name = "default:obsidian"})
+ else -- Lava flowing
+ minetest.set_node(pos, {name = "default:stone"})
+ end
+ minetest.sound_play("default_cool_lava",
+ {pos = pos, max_hear_distance = 16, gain = 0.25})
end
minetest.register_abm({
- nodenames = {"default:lava_flowing"},
+ nodenames = {"default:lava_source", "default:lava_flowing"},
neighbors = {"group:water"},
interval = 1,
chance = 1,
- action = function(pos, node, active_object_count, active_object_count_wider)
- default.cool_lava_flowing(pos, node, active_object_count, active_object_count_wider)
+ catch_up = false,
+ action = function(...)
+ default.cool_lava(...)
end,
})
-minetest.register_abm({
- nodenames = {"default:lava_source"},
- neighbors = {"group:water"},
- interval = 1,
- chance = 1,
- action = function(pos, node, active_object_count, active_object_count_wider)
- default.cool_lava_source(pos, node, active_object_count, active_object_count_wider)
- end,
-})
+
+--
+-- optimized helper to put all items in an inventory into a drops list
+--
+function default.get_inventory_drops(pos, inventory, drops)
+ local inv = minetest.get_meta(pos):get_inventory()
+ local n = #drops
+ for i = 1, inv:get_size(inventory) do
+ local stack = inv:get_stack(inventory, i)
+ if stack:get_count() > 0 then
+ drops[n+1] = stack:to_table()
+ n = n + 1
+ end
+ end
+end
--
-- Papyrus and cactus growing
--
+-- wrapping the functions in abm action is necessary to make overriding them possible
+
+function default.grow_cactus(pos, node)
+ if node.param2 >= 4 then
+ return
+ end
+ pos.y = pos.y - 1
+ if minetest.get_item_group(minetest.get_node(pos).name, "sand") == 0 then
+ return
+ end
+ pos.y = pos.y + 1
+ local height = 0
+ while node.name == "default:cactus" and height < 4 do
+ height = height + 1
+ pos.y = pos.y + 1
+ node = minetest.get_node(pos)
+ end
+ if height == 4 or node.name ~= "air" then
+ return
+ end
+ minetest.set_node(pos, {name = "default:cactus"})
+ return true
+end
+
+function default.grow_papyrus(pos, node)
+ pos.y = pos.y - 1
+ local name = minetest.get_node(pos).name
+ if name ~= "default:dirt_with_grass" and name ~= "default:dirt" then
+ return
+ end
+ if not minetest.find_node_near(pos, 3, {"group:water"}) then
+ return
+ end
+ pos.y = pos.y + 1
+ local height = 0
+ while node.name == "default:papyrus" and height < 4 do
+ height = height + 1
+ pos.y = pos.y + 1
+ node = minetest.get_node(pos)
+ end
+ if height == 4 or node.name ~= "air" then
+ return
+ end
+ minetest.set_node(pos, {name = "default:papyrus"})
+ return true
+end
+
minetest.register_abm({
nodenames = {"default:cactus"},
neighbors = {"group:sand"},
- interval = 50,
- chance = 20,
- action = function(pos, node)
- pos.y = pos.y-1
- local name = minetest.get_node(pos).name
- if minetest.get_item_group(name, "sand") ~= 0 then
- pos.y = pos.y+1
- local height = 0
- while minetest.get_node(pos).name == "default:cactus" and height < 4 do
- height = height+1
- pos.y = pos.y+1
- end
- if height < 4 then
- if minetest.get_node(pos).name == "air" then
- minetest.set_node(pos, {name="default:cactus"})
- end
- end
- end
- end,
+ interval = 12,
+ chance = 83,
+ action = function(...)
+ default.grow_cactus(...)
+ end
})
minetest.register_abm({
nodenames = {"default:papyrus"},
neighbors = {"default:dirt", "default:dirt_with_grass"},
- interval = 50,
- chance = 20,
- action = function(pos, node)
- pos.y = pos.y-1
- local name = minetest.get_node(pos).name
- if name == "default:dirt" or name == "default:dirt_with_grass" then
- if minetest.find_node_near(pos, 3, {"group:water"}) == nil then
- return
- end
- pos.y = pos.y+1
- local height = 0
- while minetest.get_node(pos).name == "default:papyrus" and height < 4 do
- height = height+1
- pos.y = pos.y+1
- end
- if height < 4 then
- if minetest.get_node(pos).name == "air" then
- minetest.set_node(pos, {name="default:papyrus"})
- end
- end
- end
- end,
+ interval = 14,
+ chance = 71,
+ action = function(...)
+ default.grow_papyrus(...)
+ end
})
+
--
--- Leafdecay
+-- dig upwards
--
--- To enable leaf decay for a node, add it to the "leafdecay" group.
+function default.dig_up(pos, node, digger)
+ if digger == nil then return end
+ local np = {x = pos.x, y = pos.y + 1, z = pos.z}
+ local nn = minetest.get_node(np)
+ if nn.name == node.name then
+ minetest.node_dig(np, nn, digger)
+ end
+end
+
+
--
--- The rating of the group determines how far from a node in the group "tree"
--- the node can be without decaying.
+-- Fence registration helper
+--
+function default.register_fence(name, def)
+ minetest.register_craft({
+ output = name .. " 4",
+ recipe = {
+ { def.material, 'group:stick', def.material },
+ { def.material, 'group:stick', def.material },
+ }
+ })
+
+ local fence_texture = "default_fence_overlay.png^" .. def.texture ..
+ "^default_fence_overlay.png^[makealpha:255,126,126"
+ -- Allow almost everything to be overridden
+ local default_fields = {
+ paramtype = "light",
+ drawtype = "nodebox",
+ node_box = {
+ type = "connected",
+ fixed = {{-1/8, -1/2, -1/8, 1/8, 1/2, 1/8}},
+ -- connect_top =
+ -- connect_bottom =
+ connect_front = {{-1/16,3/16,-1/2,1/16,5/16,-1/8},
+ {-1/16,-5/16,-1/2,1/16,-3/16,-1/8}},
+ connect_left = {{-1/2,3/16,-1/16,-1/8,5/16,1/16},
+ {-1/2,-5/16,-1/16,-1/8,-3/16,1/16}},
+ connect_back = {{-1/16,3/16,1/8,1/16,5/16,1/2},
+ {-1/16,-5/16,1/8,1/16,-3/16,1/2}},
+ connect_right = {{1/8,3/16,-1/16,1/2,5/16,1/16},
+ {1/8,-5/16,-1/16,1/2,-3/16,1/16}},
+ },
+ connects_to = {"group:fence", "group:wood", "group:tree"},
+ inventory_image = fence_texture,
+ wield_image = fence_texture,
+ tiles = {def.texture},
+ sunlight_propagates = true,
+ is_ground_content = false,
+ groups = {},
+ }
+ for k, v in pairs(default_fields) do
+ if not def[k] then
+ def[k] = v
+ end
+ end
+
+ -- Always add to the fence group, even if no group provided
+ def.groups.fence = 1
+
+ def.texture = nil
+ def.material = nil
+
+ minetest.register_node(name, def)
+end
+
+
--
--- If param2 of the node is ~= 0, the node will always be preserved. Thus, if
--- the player places a node of that kind, you will want to set param2=1 or so.
+-- Leafdecay
--
--- If the node is in the leafdecay_drop group then the it will always be dropped
--- as an item
default.leafdecay_trunk_cache = {}
default.leafdecay_enable_cache = true
math.floor(dtime * finds_per_second)
end)
+default.after_place_leaves = function(pos, placer, itemstack, pointed_thing)
+ if placer and not placer:get_player_control().sneak then
+ local node = minetest.get_node(pos)
+ node.param2 = 1
+ minetest.set_node(pos, node)
+ end
+end
+
minetest.register_abm({
nodenames = {"group:leafdecay"},
neighbors = {"air", "group:liquid"},
if trunkp then
local n = minetest.get_node(trunkp)
local reg = minetest.registered_nodes[n.name]
- -- Assume ignore is a trunk, to make the thing work at the border of the active area
- if n.name == "ignore" or (reg and reg.groups.tree and reg.groups.tree ~= 0) then
+ -- Assume ignore is a trunk, to make the thing
+ -- work at the border of the active area
+ if n.name == "ignore" or (reg and reg.groups.tree and
+ reg.groups.tree ~= 0) then
--print("cached trunk still exists")
return
end
end
default.leafdecay_trunk_find_allow_accumulator =
default.leafdecay_trunk_find_allow_accumulator - 1
- -- Assume ignore is a trunk, to make the thing work at the border of the active area
+ -- Assume ignore is a trunk, to make the thing
+ -- work at the border of the active area
local p1 = minetest.find_node_near(p0, d, {"ignore", "group:tree"})
if p1 then
do_preserve = true
end
if not do_preserve then
-- Drop stuff other than the node itself
- itemstacks = minetest.get_node_drops(n0.name)
+ local itemstacks = minetest.get_node_drops(n0.name)
for _, itemname in ipairs(itemstacks) do
if minetest.get_item_group(n0.name, "leafdecay_drop") ~= 0 or
itemname ~= n0.name then
end
end
})
+
+
+--
+-- Convert dirt to something that fits the environment
+--
+
+minetest.register_abm({
+ nodenames = {"default:dirt"},
+ neighbors = {
+ "default:dirt_with_grass",
+ "default:dirt_with_dry_grass",
+ "default:dirt_with_snow",
+ "group:grass",
+ "group:dry_grass",
+ "default:snow",
+ },
+ interval = 6,
+ chance = 67,
+ catch_up = false,
+ action = function(pos, node)
+ -- Most likely case, half the time it's too dark for this.
+ local above = {x = pos.x, y = pos.y + 1, z = pos.z}
+ if (minetest.get_node_light(above) or 0) < 13 then
+ return
+ end
+
+ -- Look for likely neighbors.
+ local p2 = minetest.find_node_near(pos, 1, {"default:dirt_with_grass",
+ "default:dirt_with_dry_grass", "default:dirt_with_snow"})
+ if p2 then
+ -- But the node needs to be under air in this case.
+ local n2 = minetest.get_node(above)
+ if n2 and n2.name == "air" then
+ local n3 = minetest.get_node(p2)
+ minetest.set_node(pos, {name = n3.name})
+ return
+ end
+ end
+
+ -- Anything on top?
+ local n2 = minetest.get_node(above)
+ if not n2 then
+ return
+ end
+
+ local name = n2.name
+ -- Snow check is cheapest, so comes first.
+ if name == "default:snow" then
+ minetest.set_node(pos, {name = "default:dirt_with_snow"})
+ -- Most likely case first.
+ elseif minetest.get_item_group(name, "grass") ~= 0 then
+ minetest.set_node(pos, {name = "default:dirt_with_grass"})
+ elseif minetest.get_item_group(name, "dry_grass") ~= 0 then
+ minetest.set_node(pos, {name = "default:dirt_with_dry_grass"})
+ end
+ end
+})
+
+--
+-- Grass and dry grass removed in darkness
+--
+
+minetest.register_abm({
+ nodenames = {
+ "default:dirt_with_grass",
+ "default:dirt_with_dry_grass",
+ "default:dirt_with_snow",
+ },
+ interval = 8,
+ chance = 50,
+ catch_up = false,
+ action = function(pos, node)
+ local above = {x = pos.x, y = pos.y + 1, z = pos.z}
+ local name = minetest.get_node(above).name
+ local nodedef = minetest.registered_nodes[name]
+ if name ~= "ignore" and nodedef and not ((nodedef.sunlight_propagates or
+ nodedef.paramtype == "light") and
+ nodedef.liquidtype == "none") then
+ minetest.set_node(pos, {name = "default:dirt"})
+ end
+ end
+})
+
+
+--
+-- Moss growth on cobble near water
+--
+
+minetest.register_abm({
+ nodenames = {"default:cobble", "stairs:slab_cobble", "stairs:stair_cobble"},
+ neighbors = {"group:water"},
+ interval = 16,
+ chance = 200,
+ catch_up = false,
+ action = function(pos, node)
+ if node.name == "default:cobble" then
+ minetest.set_node(pos, {name = "default:mossycobble"})
+ elseif node.name == "stairs:slab_cobble" then
+ minetest.set_node(pos, {name = "stairs:slab_mossycobble", param2 = node.param2})
+ elseif node.name == "stairs:stair_cobble" then
+ minetest.set_node(pos, {name = "stairs:stair_mossycobble", param2 = node.param2})
+ end
+ end
+})
+
+
+--
+-- Checks if specified volume intersects a protected volume
+--
+
+function default.intersects_protection(minp, maxp, player_name, interval)
+ -- 'interval' is the largest allowed interval for the 3D lattice of checks
+
+ -- Compute the optimal float step 'd' for each axis so that all corners and
+ -- borders are checked. 'd' will be smaller or equal to 'interval'.
+ -- Subtracting 1e-4 ensures that the max co-ordinate will be reached by the
+ -- for loop (which might otherwise not be the case due to rounding errors).
+ local d = {}
+ for _, c in pairs({"x", "y", "z"}) do
+ if maxp[c] > minp[c] then
+ d[c] = (maxp[c] - minp[c]) / math.ceil((maxp[c] - minp[c]) / interval) - 1e-4
+ elseif maxp[c] == minp[c] then
+ d[c] = 1 -- Any value larger than 0 to avoid division by zero
+ else -- maxp[c] < minp[c], print error and treat as protection intersected
+ minetest.log("error", "maxp < minp in 'default.intersects_protection()'")
+ return true
+ end
+ end
+
+ for zf = minp.z, maxp.z, d.z do
+ local z = math.floor(zf + 0.5)
+ for yf = minp.y, maxp.y, d.y do
+ local y = math.floor(yf + 0.5)
+ for xf = minp.x, maxp.x, d.x do
+ local x = math.floor(xf + 0.5)
+ if minetest.is_protected({x = x, y = y, z = z}, player_name) then
+ return true
+ end
+ end
+ end
+ end
+
+ return false
+end
projects / oweals / minetest_game.git / blobdiff