write something there

mods/builtin_item/.gitignore

@@ -0,0 +1,4 @@
+## Generic ignorable patterns and files
+*~
+.*.swp
+debug.txt

mods/builtin_item/README.md

@@ -0,0 +1,116 @@
+item_entity.lua replacement
+
+edited by TenPlus1
+
+Features:
+- Items are destroyed by lava
+- Items are pushed along by flowing water (thanks to QwertyMine3 and Gustavo6046)
+- Items are removed after 900 seconds or the time that is specified by
+   remove_items in minetest.conf (-1 disables it)
+- Particle effects added
+- Dropped items slide on nodes with {slippery} groups
+- Items stuck inside solid nodes move to nearest empty space
+- Can use new on_pickup() function if available
+- Added 'dropped_step(self, pos, dtime, moveresult)' custom on_step for dropped items
+   'self.node_inside' contains node table that item is inside
+   'self.def_inside' contains node definition for above
+   'self.node_under' contains node table that is below item
+   'self.def_under' contains node definition for above
+   'self.age' holds age of dropped item in seconds
+   'self.itemstring' contains itemstring e.g. "default:dirt", "default:ice 20"
+   'self.is_moving' true if dropped item is moving
+   'pos' holds position of dropped item
+   'dtime' used for timers
+   'moveresult' table containing collision info
+
+   return false to skip further checks by builtin_item
+
+License: LGPLv2.1+
+
+
+dropped_step() examples:
+
+-- if gunpowder dropped on burning tnt or gunpowder then remove
+
+if minetest.registered_items["tnt:gunpowder"] then
+
+	minetest.override_item("tnt:gunpowder", {
+
+		dropped_step = function(self, pos)
+
+			if (self.node_inside
+			and self.node_inside.name == "tnt:gunpowder_burning")
+			or (self.node_under
+			and self.node_under.name == "tnt:tnt_burning") then
+
+				minetest.sound_play("builtin_item_lava", {
+					pos = pos,
+					max_hear_distance = 6,
+					gain = 0.5
+				})
+
+				self.itemstring = ""
+				self.object:remove()
+
+				return false -- return with no further action
+			end
+		end
+	})
+end
+
+
+-- if 2x mese crystal and 2x crystal spike dropped in pool of water_source
+-- then merge into a single crystal_ingot.
+
+if minetest.registered_items["ethereal:crystal_spike"] then
+
+	minetest.override_item("ethereal:crystal_spike", {
+
+		dropped_step = function(self, pos, dtime)
+
+			self.ctimer = (self.ctimer or 0) + dtime
+			if self.ctimer < 5.0 then return end
+			self.ctimer = 0
+
+			if self.node_inside
+			and self.node_inside.name ~= "default:water_source" then
+				return
+			end
+
+			local objs = core.get_objects_inside_radius(pos, 0.8)
+
+			if not objs or #objs ~= 2 then return end
+
+			local crystal, mese, ent = nil, nil, nil
+
+			for k, obj in pairs(objs) do
+
+				ent = obj:get_luaentity()
+
+				if ent and ent.name == "__builtin:item" then
+
+					if ent.itemstring == "default:mese_crystal 2"
+					and not mese then
+
+						mese = obj
+
+					elseif ent.itemstring == "ethereal:crystal_spike 2"
+					and not crystal then
+
+						crystal = obj
+					end
+				end
+			end
+
+			if mese and crystal then
+
+				mese:remove()
+				crystal:remove()
+
+				core.add_item(pos, "ethereal:crystal_ingot")
+
+				return false -- return with no further action
+			end
+		end
+	})
+end

mods/builtin_item/init.lua

@@ -0,0 +1,676 @@
+-- Minetest: builtin/item_entity.lua
+
+function core.spawn_item(pos, item)
+
+	local obj = core.add_entity(pos, "__builtin:item")
+
+	if obj then
+		obj:get_luaentity():set_item(ItemStack(item):to_string())
+	end
+
+	return obj
+end
+
+
+-- If item_entity_ttl is not set, entity 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
+local source_flow = core.settings:get_bool("builtin_item.source_flow")
+
+
+-- localize some math functions
+local math_abs, math_sqrt = math.abs, math.sqrt
+local math_random, math_min = math.random, math.min
+
+
+-- 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
+
+	-- 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" 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
+
+
+local function quick_flow(pos, node)
+
+	local x, z = 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
+
+
+-- 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 = 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.6)
+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
+
+
+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 = "",
+	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)
+
+		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 = ""
+
+		if not(stack:get_count() == 1) then
+			c1 = " × " .. 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
+
+		-- 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 + 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,
+			wield_item = self.itemstring,
+			glow = glow,
+			infotext = name .. c1 .. "\n(" .. itemname .. ")"
+		})
+	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, 6) == "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: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()
+		local self_pos = self.object:get_pos()
+		local x_diff = (self_pos.x - pos.x) / 2
+		local z_diff = (self_pos.z - pos.z) / 2
+		local new_pos = vector.offset(pos, x_diff, 0, z_diff)
+
+		self.object:move_to(new_pos)
+		self.age = 0 -- Reset age
+
+		-- 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)
+
+		entity.itemstring = ""
+		object:remove()
+
+		return true
+	end,
+
+	step_update_node_state = function(self, moveresult, dtime)
+
+		local pos = self.object:get_pos()
+
+		-- get nodes every 1/4 second
+		self.timer = (self.timer or 0) + dtime
+
+		if self.timer < 0.25 and self.node_inside then
+			return
+		end
+
+		self.timer = 0
+
+		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
+		self.falling_state = true
+
+		--[[ new ground check (glitchy)
+		if moveresult and moveresult.touching_ground then
+
+			for _, info in ipairs(moveresult.collisions) do
+
+				if info.axis == "y" then
+
+					self.node_under = core.get_node_or_nil(info.node_pos)
+					self.falling_state = false
+
+					break
+				end
+			end
+		end]]
+
+		-- old ground check (stable)
+		self.node_under = minetest.get_node_or_nil({
+			x = pos.x,
+			y = pos.y + self.object:get_properties().collisionbox[2] - 0.05,
+			z = pos.z
+		})
+
+		self.def_under = self.node_under
+				and core.registered_nodes[self.node_under.name]
+
+		-- part of old ground check
+		if self.def_under and self.def_under.walkable then
+			self.falling_state = false
+		end
+	end,
+
+	step_node_inside_checks = function(self)
+
+		local pos = self.object:get_pos()
+
+		-- Delete in 'ignore' nodes
+		if (self.node_inside and self.node_inside.name == "ignore")
+		or self.itemstring == "" then
+
+			self.itemstring = ""
+			self.object:remove()
+
+			return true
+		end
+
+		local def = self.def_inside
+
+		-- 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
+		end
+
+		-- 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
+			}, true)
+
+			self.itemstring = ""
+			self.object:remove()
+
+			add_effects(pos)
+
+			return true
+		end
+
+		return false
+	end,
+
+	step_check_slippery = function(self)
+
+		-- don't check for slippery if we're not on the ground
+		if self.falling_state or not self.node_under then
+
+			self.slippery_state = false
+
+			return
+		end
+
+		if self.node_under and self.def_under and self.def_under.walkable then
+
+			local slippery = core.get_item_group(self.node_under.name, "slippery")
+
+			self.slippery_state = slippery ~= 0
+		end
+	end,
+
+	step_water_physics = function(self)
+
+		self.waterflow_state = self.def_inside and
+				(self.def_inside.liquidtype == "flowing" or (source_flow and
+				self.def_inside.liquidtype == "source"))
+
+		if self.waterflow_state then
+
+			local pos = self.object:get_pos()
+			local vel = self.object:get_velocity()
+
+			-- get flow velocity
+			local flow_vel = quick_flow(pos, self.node_inside)
+
+			-- 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_gravity = function(self)
+
+		local vel = self.object:get_velocity()
+
+		-- apply gravity if falling or Y velocity not 0 (just incase)
+		if self.falling_state or (vel and vel.y ~= 0) 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()
+
+		-- this stops the entity drift glitch by re-setting entity pos when not moving
+		if vel.x == 0 and vel.y == 0 and vel.z == 0 then
+
+			if self.is_moving == true then
+
+				self.is_moving = false
+
+				local pos = self.object:get_pos()
+
+				self.object:set_pos(pos)
+			end
+		else
+			self.is_moving = true
+		end
+
+		local this_dry_friction = dry_friction
+
+		if self.slippery_state then
+
+			-- apply slip factor (tiny friction that depends on the actual block type)
+			if math_abs(vel.x) > 0.2 or math_abs(vel.z) > 0.2 then
+
+				local slippery = core.get_item_group(self.node_under.name, "slippery")
+				local slip_factor = 4.0 / (slippery + 4)
+
+				this_dry_friction = slip_factor
+			end
+		end
+
+		self.accel.x = self.accel.x - vel.x * this_dry_friction
+		self.accel.z = self.accel.z - vel.z * this_dry_friction
+	end,
+
+	step_apply_forces = function(self)
+		self.object:set_acceleration(self.accel)
+	end,
+
+	-- let items die out after enough time
+	step_check_timeout = function(self, dtime)
+
+		self.age = self.age + dtime
+
+		if time_to_live > 0 and self.age > time_to_live then
+
+			add_effects(self.object:get_pos())
+
+			self.itemstring = ""
+			self.object:remove()
+
+			return true
+		end
+
+		return false
+	end,
+
+	step_check_custom_step = function(self, dtime, moveresult)
+
+		-- 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, self.object:get_pos(), dtime, moveresult) == false then
+			return true -- skip further checks if false
+		end
+
+		return false
+	end,
+
+	step_try_collect = function(self)
+
+		-- 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
+
+		-- Collect the items around to merge with
+		local own_stack = ItemStack(self.itemstring)
+
+		if own_stack:get_free_space() == 0 then
+			return
+		end
+
+		local self_pos = self.object:get_pos()
+		local objects = core.get_objects_inside_radius(self_pos, 1.0)
+
+		for _, obj in pairs(objects) do
+
+			local entity = obj:get_luaentity()
+
+			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
+						return
+					end
+				end
+			end
+		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,
+
+	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
+
+		-- do physics checks, then apply
+		self:step_water_physics()
+		self:step_check_slippery()
+		self:step_ground_friction()
+		self:step_air_drag_physics()
+		self:step_gravity()
+
+		self:step_apply_forces()
+
+		self:step_try_collect() -- merge
+	end,
+
+	on_punch = function(self, hitter, ...)
+
+		if self.itemstring == "" then
+
+			self.object:remove()
+
+			return
+		end
+
+		if core.item_pickup then
+
+			-- Call on_pickup callback in item definition.
+			local itemstack = ItemStack(self.itemstring)
+			local callback = itemstack:get_definition().on_pickup
+			local ret = callback(itemstack, hitter,
+					{type = "object", ref = self.object}, ...)
+
+			if not ret then
+				-- Don't modify (and don't reset rotation)
+				return
+			end
+
+			itemstack = ItemStack(ret)
+
+			-- Handle the leftover itemstack
+			if itemstack:is_empty() then
+				self.itemstring = ""
+				self.object:remove()
+			else
+				self:set_item(itemstack)
+			end
+		else
+			-- old method of pickup for backwards compatibility
+			local inv = hitter:get_inventory()
+
+			if inv 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
+	end
+})
+
+
+print("[MOD] Built-in Item loaded")

mods/builtin_item/license.txt

@@ -0,0 +1,5 @@
+CC0 1.0 Universal (CC0 1.0) Public Domain Dedication for audio files (found in sounds folder)
+
+LGPLv2.1+ license for original code with changes by TenPlus1
+
+CC BY-SA 3.0 license for textures

mods/builtin_item/mod.conf

@@ -0,0 +1,4 @@
+name = builtin_item
+description = Dropped items can now be pushed by water, slide on ice and have their own custom functions.
+depends = default
+min_minetest_version = 5.0

mods/builtin_item/settingtypes.txt

@@ -0,0 +1,44 @@
+# 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
+
+# Allow dropped items to be pushed when inside of source nodes,
+# False by default but can be enabled.
+builtin_item.source_flow (Allow water source to push items) bool false