game/technic.git

			@@ -1,27 +1,38 @@
			--load config
			local sepchar, baresepchar = nil, nil
			local digit_sep_esc
			do
			local sepcode = technic.config:get("thousand_separator")
			--default is SI style
			sepchar = sepcode and string.char(sepcode) or " "
			baresepchar = sepchar
			--handling if sepchar is magic...
			for magic in string.gmatch("().%+-*?[^$", ".") do
			if sepchar == magic then sepchar = "%"..sepchar end
			local sep = technic.config:get("digit_separator")
			sep = tonumber(sep) and string.char(sep) or sep or " "
			-- Escape for gsub
			for magic in ("().%+-*?[^$"):gmatch(".") do
			if sep == magic then
			sep = "%"..sep
			end
			end
			digit_sep_esc = sep
			end

			-- Only changes name, keeps other params

			function technic.pretty_num(num)
			local str, k = tostring(num), nil
			repeat
			str, k = str:gsub("^(-?%d+)(%d%d%d)", "%1"..digit_sep_esc.."%2")
			until k == 0
			return str
			end


			--- Same as minetest.swap_node, but only changes name
			-- and doesn't re-set if already set.
			function technic.swap_node(pos, name)
			local node = minetest.get_node(pos)
			if node.name ~= name then
			node.name = name
			minetest.swap_node(pos, node)
			end
			return node.name
			end

			-- Fully charge RE chargeable item.

			--- Fully charge RE chargeable item.
			-- Must be defined early to reference in item definitions.
			function technic.refill_RE_charge(stack)
			local max_charge = technic.power_tools[stack:get_name()]
			@@ -33,63 +44,148 @@
			return stack
			end

			local function resolve_name(function_name)
			local a = _G
			for key in string.gmatch(function_name, "([^%.]+)(%.?)") do
			if a[key] then
			a = a[key]
			else
			return nil
			end
			end
			return a
			end

			function technic.function_exists(function_name)
			return type(resolve_name(function_name)) == 'function'
			end

			-- if the node is loaded, returns it. If it isn't loaded, load it and return nil.
			-- If the node is loaded, returns it. If it isn't loaded, load it and return nil.
			function technic.get_or_load_node(pos)
			local node_or_nil = minetest.get_node_or_nil(pos)
			if node_or_nil then return node_or_nil end
			local node = minetest.get_node_or_nil(pos)
			if node then return node end
			local vm = VoxelManip()
			local MinEdge, MaxEdge = vm:read_from_map(pos, pos)
			return nil
			end

			function technic.format(str, ...)
			local arg={...}
			local param = nil
			local percent = false
			local res = ""

			technic.tube_inject_item = pipeworks.tube_inject_item or function(pos, start_pos, velocity, item)
			local tubed = pipeworks.tube_item(vector.new(pos), item)
			tubed:get_luaentity().start_pos = vector.new(start_pos)
			tubed:setvelocity(velocity)
			tubed:setacceleration(vector.new(0, 0, 0))
			end


			--- Iterates over the node positions along the specified ray.
			-- The returned positions will not include the starting position.
			function technic.trace_node_ray(pos, dir, range)
			local x_step = dir.x > 0 and 1 or -1
			local y_step = dir.y > 0 and 1 or -1
			local z_step = dir.z > 0 and 1 or -1

			local i = 1
			for c in str:gmatch"." do
			if percent then
			assert(c ~= "%") --syntax error
			if c == "e" then
			-- use enhanced number formatting
			-- only works for unsigned numbers
			local numstr = tostring(math.abs(arg[i]))
			local a, b, body, frac = numstr:find("^(%d+)([.]?.-)$")
			a = 1
			body = body..baresepchar
			while a ~= 0 do
			body, a = body:gsub("(%d)(%d%d%d)"..sepchar, "%1"..sepchar.."%2"..sepchar, 1)
			end
			body = body:gsub(sepchar.."$", "")
			res = res .. body .. frac
			else
			--use traditional string:format
			res = res .. (string.format(("%"..c), arg[i]))
			i = i + 1
			end
			percent = false
			elseif c == "%" then
			percent = true
			else
			res = res .. c
			return function(p)
			-- Approximation of where we should be if we weren't rounding
			-- to nodes. This moves forward a bit faster then we do.
			-- A correction is done below.
			local real_x = pos.x + (dir.x * i)
			local real_y = pos.y + (dir.y * i)
			local real_z = pos.z + (dir.z * i)

			-- How far off we've gotten from where we should be.
			local dx = math.abs(real_x - p.x)
			local dy = math.abs(real_y - p.y)
			local dz = math.abs(real_z - p.z)

			-- If the real position moves ahead too fast, stop it so we
			-- can catch up. If it gets too far ahead it will smooth
			-- out our movement too much and we won't turn fast enough.
			if dx + dy + dz < 2 then
			i = i + 1
			end
			end
			return res
			end

			-- Step in whichever direction we're most off course in.
			if dx > dy then
			if dx > dz then
			p.x = p.x + x_step
			else
			p.z = p.z + z_step
			end
			elseif dy > dz then
			p.y = p.y + y_step
			else
			p.z = p.z + z_step
			end
			if vector.distance(pos, p) > range then
			return nil
			end
			return p
			end, vector.round(pos)
			end


			--- Like trace_node_ray, but includes extra positions close to the ray.
			function technic.trace_node_ray_fat(pos, dir, range)
			local x_step = dir.x > 0 and 1 or -1
			local y_step = dir.y > 0 and 1 or -1
			local z_step = dir.z > 0 and 1 or -1

			local next_poses = {}

			local i = 1
			return function(p)
			local ni, np = next(next_poses)
			if np then
			next_poses[ni] = nil
			return np
			end

			-- Approximation of where we should be if we weren't rounding
			-- to nodes. This moves forward a bit faster then we do.
			-- A correction is done below.
			local real_x = pos.x + (dir.x * i)
			local real_y = pos.y + (dir.y * i)
			local real_z = pos.z + (dir.z * i)

			-- How far off we've gotten from where we should be.
			local dx = math.abs(real_x - p.x)
			local dy = math.abs(real_y - p.y)
			local dz = math.abs(real_z - p.z)

			-- If the real position moves ahead too fast, stop it so we
			-- can catch up. If it gets too far ahead it will smooth
			-- out our movement too much and we won't turn fast enough.
			if dx + dy + dz < 2 then
			i = i + 1
			end

			-- Step in whichever direction we're most off course in.
			local sx, sy, sz -- Whether we've already stepped along each axis
			if dx > dy then
			if dx > dz then
			sx = true
			p.x = p.x + x_step
			else
			sz = true
			p.z = p.z + z_step
			end
			elseif dy > dz then
			sy = true
			p.y = p.y + y_step
			else
			sz = true
			p.z = p.z + z_step
			end

			if vector.distance(pos, p) > range then
			return nil
			end

			-- Add other positions that we're significantly off on.
			-- We can just use fixed integer keys here because the
			-- table will be completely cleared before we reach this
			-- code block again.
			local dlen = math.sqrt(dxdx + dydy + dz*dz)
			-- Normalized axis deltas
			local dxn, dyn, dzn = dx / dlen, dy / dlen, dz / dlen
			if not sx and dxn > 0.5 then
			next_poses[1] = vector.new(p.x + x_step, p.y, p.z)
			end
			if not sy and dyn > 0.5 then
			next_poses[2] = vector.new(p.x, p.y + y_step, p.z)
			end
			if not sz and dzn > 0.5 then
			next_poses[3] = vector.new(p.x, p.y, p.z + z_step)
			end

			return p
			end, vector.round(pos)
			end