Add files via upload

camera.lua

@@ -0,0 +1,452 @@
+local utils = ...
+local S = utils.S
+
+
+
+if utils.digilines_supported then
+
+
+
+local function is_drop (obj)
+	if obj then
+		local entity = obj.get_luaentity and obj:get_luaentity ()
+
+		return (entity and entity.name and entity.name == "__builtin:item")
+	end
+
+	return false
+end
+
+
+
+local function get_entity_dims (obj)
+	local dims = { -0.5, 0, -0.5, 0.5, 2, 0.5 }
+	local found = false
+
+	if obj.get_luaentity then
+		local entity = obj:get_luaentity ()
+
+		if entity and entity.name then
+			local def = minetest.registered_entities[entity.name]
+
+			if def and type (def.collisionbox) == "table" then
+
+				dims = { def.collisionbox[1] or -0.5,
+							def.collisionbox[2] or -0.5,
+							def.collisionbox[3] or -0.5,
+							def.collisionbox[4] or 0.5,
+							def.collisionbox[5] or 0.5,
+							def.collisionbox[6] or 0.5 }
+
+				found = true
+			end
+		end
+	end
+
+	if not found then
+		local props = obj:get_properties ()
+		if props and props.collisionbox and type (props.collisionbox) == "table" then
+
+			dims = { props.collisionbox[1] or -0.5,
+						props.collisionbox[2] or -0.5,
+						props.collisionbox[3] or -0.5,
+						props.collisionbox[4] or 0.5,
+						props.collisionbox[5] or 0.5,
+						props.collisionbox[6] or 0.5 }
+		end
+	end
+
+	dims[1] = math.min (dims[1], dims[3])
+	dims[3] = dims[1]
+	dims[4] = math.max (dims[4], dims[6])
+	dims[6] = dims[4]
+
+	if (dims[3] - dims[1]) < 1 then
+		dims[1] = -0.5
+		dims[3] = -0.5
+		dims[4] = 0.5
+		dims[6] = 0.5
+	end
+
+	return dims
+end
+
+
+
+local function get_entity (pos)
+	local objects = minetest.get_objects_inside_radius (pos, 2.0)
+
+	if #objects > 0 then
+		for _, obj in ipairs (objects) do
+			if obj.get_pos then
+				if obj:is_player () then
+					local epos =  vector.round (obj:get_pos ())
+
+					if epos.x == pos.x and epos.z == pos.z and
+							(epos.y == pos.y or epos.y == pos.y - 1) then
+						return 1
+					end
+				end
+
+				if not is_drop (obj) then
+					local epos =  vector.new (obj:get_pos ())
+					local dims = get_entity_dims (obj)
+
+					if pos.x >= (epos.x + dims[1]) and pos.x <= (epos.x + dims[4]) and
+							pos.y >= (epos.y + dims[2]) and pos.y <= (epos.y + dims[5]) and
+							pos.z >= (epos.z + dims[3]) and pos.z <= (epos.z + dims[6]) then
+						return 2
+					end
+				end
+			end
+		end
+	end
+
+	return nil
+end
+
+
+
+local function camera_scan (pos, resolution, distance)
+	local node = utils.get_far_node (pos)
+	local image = { }
+
+	for y = 1, resolution, 1 do
+		image[y] = { }
+
+		for x = 1, resolution, 1 do
+			image[y][x] = "000000"
+		end
+	end
+
+	if node then
+		local dir = vector.multiply (minetest.facedir_to_dir (node.param2), -1)
+		local last_pos = nil
+		local last_color = "000000"
+		local view = (distance * 1.414213562) / resolution
+
+		for dist = distance, 1, -1 do
+			local scale = dist / distance
+
+			for y = 1, resolution, 1 do
+				for x = 1, resolution, 1 do
+					local horz = (x - (resolution / 2)) * scale * view
+					local vert = (y - (resolution / 2)) * scale * view
+
+					local tpos = nil
+					if dir.x ~= 0 then
+						tpos = vector.round ({ x = (dist * dir.x) + pos.x, y = pos.y - vert, z = horz + pos.z })
+					else
+						tpos = vector.round ({ x = horz + pos.x, y = pos.y - vert, z = (dist * dir.z) + pos.z })
+					end
+
+					if last_pos and vector.equals (last_pos, tpos) then
+						if last_color then
+							image[y][x] = last_color
+						end
+					else
+						local entity = get_entity (tpos)
+
+						if entity == 1 then
+							local color = (((distance - dist) / distance) * 98) + 30
+
+							last_color = string.format ("00%02X00", color)
+							image[y][x] = last_color
+						elseif entity == 2 then
+							local color = (((distance - dist) / distance) * 98) + 30
+
+							last_color = string.format ("0000%02X", color)
+							image[y][x] = last_color
+						else
+							local node = utils.get_far_node (tpos)
+
+							if node and node.name ~= "air" then
+								local color = (((distance - dist) / distance) * 98) + 30
+
+								last_color = string.format ("%02X%02X%02X", color, color, color)
+								image[y][x] = last_color
+							else
+								last_color = nil
+							end
+						end
+					end
+
+					last_pos = tpos
+				end
+			end
+		end
+	end
+
+	return image
+end
+
+
+
+local function send_scan (pos)
+	local meta = minetest.get_meta (pos)
+
+	if meta then
+		local channel = meta:get_string ("channel")
+
+		if channel:len () > 0 then
+			local image = camera_scan (pos,
+												tonumber (meta:get_string ("resolution")),
+												tonumber (meta:get_string ("distance")))
+
+			utils.digilines_receptor_send (pos,
+													 utils.digilines_default_rules,
+													 channel,
+													 image)
+		end
+	end
+end
+
+
+
+local function after_place_node (pos, placer, itemstack, pointed_thing)
+	local meta = minetest.get_meta (pos)
+	local spec =
+	"formspec_version[3]"..
+	"size[8.5,5.5;true]"..
+	"field[1.0,1.0;4.0,0.8;channel;Channel;${channel}]"..
+	"button[5.5,1.0;2.0,0.8;setchannel;Set]"..
+	"field[1.0,2.5;4.0,0.8;distance;Distance;${distance}]"..
+	"button[5.5,2.5;2.0,0.8;setdistance;Set]"..
+	"field[1.0,4.0;4.0,0.8;resolution;Resolution;${resolution}]"..
+	"button[5.5,4.0;2.0,0.8;setresolution;Set]"
+
+	meta:set_string ("formspec", spec)
+	meta:set_string ("distance", "5")
+	meta:set_string ("resolution", "16")
+
+	-- If return true no item is taken from itemstack
+	return false
+end
+
+
+
+local function after_place_node_locked (pos, placer, itemstack, pointed_thing)
+	after_place_node (pos, placer, itemstack, pointed_thing)
+
+	if placer and placer:is_player () then
+		local meta = minetest.get_meta (pos)
+
+		meta:set_string ("owner", placer:get_player_name ())
+		meta:set_string ("infotext", "Camera (owned by "..placer:get_player_name ()..")")
+	end
+
+	-- If return true no item is taken from itemstack
+	return false
+end
+
+
+
+local function on_receive_fields (pos, formname, fields, sender)
+	if not utils.can_interact_with_node (pos, sender) then
+		return
+	end
+
+	if fields.setchannel then
+		local meta = minetest.get_meta (pos)
+
+		if meta then
+			meta:set_string ("channel", fields.channel)
+		end
+	end
+
+	if fields.setdistance then
+		local meta = minetest.get_meta (pos)
+
+		if meta then
+			local distance = math.min (math.max (tonumber (fields.distance) or 1, 1), 16)
+			fields.distance = tostring (distance)
+
+			meta:set_string ("distance", tostring (distance))
+		end
+	end
+
+	if fields.setresolution then
+		local meta = minetest.get_meta (pos)
+
+		if meta then
+			local resolution = math.min (math.max (tonumber (fields.resolution) or 1, 1), 128)
+			fields.resolution = tostring (resolution)
+
+			meta:set_string ("resolution", tostring (resolution))
+		end
+	end
+end
+
+
+
+local function can_dig (pos, player)
+	if not utils.can_interact_with_node (pos, player) then
+		return false
+	end
+
+	return true
+end
+
+
+
+local function on_blast (pos, intensity)
+	local meta = minetest.get_meta (pos)
+
+	if meta then
+		if intensity >= 1.0 then
+			minetest.remove_node (pos)
+
+		else -- intensity < 1.0
+			local node = minetest.get_node_or_nil (pos)
+			if node then
+				local items = minetest.get_node_drops (node, nil)
+
+				if items and #items > 0 then
+					local stack = ItemStack (items[1])
+
+					if stack then
+						preserve_metadata (pos, node, meta, { stack })
+						utils.item_drop (stack, nil, pos)
+						minetest.remove_node (pos)
+					end
+				end
+			end
+		end
+	end
+end
+
+
+
+local function on_rightclick (pos, node, clicker, itemstack, pointed_thing)
+	if not utils.can_interact_with_node (pos, clicker) then
+		if clicker and clicker:is_player () then
+			local owner = "<unknown>"
+			local meta = minetest.get_meta (pos)
+
+			if meta then
+				owner = meta:get_string ("owner")
+			end
+
+			local spec =
+			"formspec_version[3]"..
+			"size[8.0,4.0,false]"..
+			"label[1.0,1.0;Owned by "..minetest.formspec_escape (owner).."]"..
+			"button_exit[3.0,2.0;2.0,1.0;close;Close]"
+
+			minetest.show_formspec (clicker:get_player_name (),
+											"lwcomponents:component_privately_owned",
+											spec)
+		end
+	end
+
+	return itemstack
+end
+
+
+
+local function digilines_support ()
+	if utils.digilines_supported then
+		return
+		{
+			wire =
+			{
+				rules = utils.digilines_default_rules,
+			},
+
+			effector =
+			{
+				action = function (pos, node, channel, msg)
+					local meta = minetest.get_meta(pos)
+
+					if meta then
+						local this_channel = meta:get_string ("channel")
+
+						if this_channel ~= "" and this_channel == channel and
+							type (msg) == "string" then
+
+							local m = { }
+							for w in string.gmatch(msg, "[^%s]+") do
+								m[#m + 1] = w
+							end
+
+							if m[1] == "scan" then
+								send_scan (pos)
+
+							elseif m[1] == "distance" then
+								local distance = math.min (math.max (tonumber (m[2] or 5) or 5, 1), 16)
+								meta:set_string ("distance", tostring (distance))
+
+							elseif m[1] == "resolution" then
+								local resolution = math.min (math.max (tonumber (m[2] or 16) or 16, 1), 128)
+								meta:set_string ("resolution", tostring (resolution))
+
+							end
+						end
+					end
+				end,
+			}
+		}
+	end
+
+	return nil
+end
+
+
+
+minetest.register_node("lwcomponents:camera", {
+	description = S("Camera"),
+	tiles = { "lwcamera.png", "lwcamera.png", "lwcamera.png",
+				 "lwcamera.png", "lwcamera.png", "lwcamera_lens.png"},
+	is_ground_content = false,
+	groups = { cracky = 3 },
+	sounds = default.node_sound_stone_defaults (),
+	paramtype = "none",
+	param1 = 0,
+	paramtype2 = "facedir",
+	param2 = 0,
+	floodable = false,
+	drop = "lwcomponents:camera",
+	_digistuff_channelcopier_fieldname = "channel",
+
+	digiline = digilines_support (),
+
+	on_receive_fields = on_receive_fields,
+	can_dig = can_dig,
+	after_place_node = after_place_node,
+	on_blast = on_blast,
+	on_rightclick = on_rightclick
+})
+
+
+
+minetest.register_node("lwcomponents:camera_locked", {
+	description = S("Camera (locked)"),
+	tiles = { "lwcamera.png", "lwcamera.png", "lwcamera.png",
+				 "lwcamera.png", "lwcamera.png", "lwcamera_lens.png"},
+	is_ground_content = false,
+	groups = { cracky = 3 },
+	sounds = default.node_sound_stone_defaults (),
+	paramtype = "none",
+	param1 = 0,
+	paramtype2 = "facedir",
+	param2 = 0,
+	floodable = false,
+	drop = "lwcomponents:camera_locked",
+	_digistuff_channelcopier_fieldname = "channel",
+
+	digiline = digilines_support (),
+
+	on_receive_fields = on_receive_fields,
+	can_dig = can_dig,
+	after_place_node = after_place_node_locked,
+	on_blast = on_blast,
+	on_rightclick = on_rightclick
+})
+
+
+
+end -- utils.digilines_supported
+
+
+
+--

change.log

@@ -91,3 +91,30 @@ v0.1.15
 
 v0.1.16
 *	Fixed piston interaction with non-walkable nodes.
+
+
+v0.1.17
+*	Fixed unintended global variable in pistons.lua.
+
+
+v0.1.18
+*	Added mesecons through wire.
+
+
+v0.1.19
+*	Added camera.
+
+
+v0.1.20
+*	Valid distance and resolution for camera set by digilines message.
+*	Imposed maximum resolution of 128 for cameras.
+
+
+v0.1.21
+*	Minor bug fix, movefloor global.
+*	Fixed movefloor so player doesn't fall through floor.
+*	Transfer timer in moved nodes for pistons.
+
+
+v0.1.22
+*	Added storage.

crafting.lua

@@ -23,6 +23,44 @@ minetest.register_craft( {
 })
 
 
+minetest.register_craft( {
+	output = "lwcomponents:storage_unit 2",
+	recipe = {
+		{ "default:steel_ingot", "group:wood", "group:wood" },
+		{ "group:wood", "", "group:wood" },
+		{ "group:wood", "group:wood", "default:chest" },
+	},
+})
+
+
+minetest.register_craft( {
+	output = "lwcomponents:storage_unit_locked 2",
+	recipe = {
+		{ "default:steel_ingot", "group:wood", "group:wood" },
+		{ "group:wood", "", "group:wood" },
+		{ "group:wood", "group:wood", "default:chest_locked" },
+	},
+})
+
+
+minetest.register_craft( {
+	output = "lwcomponents:storage_indexer",
+	recipe = {
+		{ "default:steel_ingot", "group:wood" },
+		{ "group:wood", "default:chest" }
+	},
+})
+
+
+minetest.register_craft( {
+	output = "lwcomponents:storage_indexer_locked",
+	recipe = {
+		{ "default:steel_ingot", "group:wood" },
+		{ "group:wood", "default:chest_locked" }
+	},
+})
+
+
 minetest.register_craft( {
 	output = "lwcomponents:cannon_shell 10",
 	recipe = {
@@ -49,7 +87,21 @@ minetest.register_craft( {
 		{ "default:iron_lump", "default:coalblock" },
 	},
 })
-end
+end -- minetest.global_exists ("fire")
+
+
+
+if utils.mesecon_supported then
+
+minetest.register_craft( {
+	output = "lwcomponents:through_wire_off 2",
+	recipe = {
+		{ "", "mesecons:wire_00000000_off" },
+		{ "mesecons:wire_00000000_off", "" },
+	},
+})
+
+end -- utils.mesecon_supported
 
 
 
@@ -281,6 +333,24 @@ minetest.register_craft( {
 	},
 })
 
+
+minetest.register_craft( {
+	output = "lwcomponents:camera",
+	recipe = {
+		{ "default:copper_ingot", "default:iron_lump" },
+		{ "default:chest", "default:stone" },
+	},
+})
+
+
+minetest.register_craft( {
+	output = "lwcomponents:camera_locked",
+	recipe = {
+		{ "default:copper_ingot", "default:iron_lump" },
+		{ "default:chest_locked", "default:stone" },
+	},
+})
+
 end -- utils.digilines_supported
 
 
@@ -300,7 +370,7 @@ end -- utils.digilines_supported and utils.digistuff_supported
 
 
 
-if utils.mesecon_supported and mesecon.mvps_push then
+if utils.mesecon_supported then
 
 minetest.register_craft ({
    output = "lwcomponents:movefloor",
@@ -311,7 +381,7 @@ minetest.register_craft ({
    }
 })
 
-end -- utils.mesecon_supported and mesecon.mvps_push
+end -- utils.mesecon_supported
 
 
 

detector.lua

@@ -130,7 +130,7 @@ end
 
 local function get_entity_height (objref)
 	if objref.get_luaentity then
-		entity = objref:get_luaentity ()
+		local entity = objref:get_luaentity ()
 
 		if entity and entity.name then
 			def = minetest.registered_entities[entity.name]
@@ -165,7 +165,7 @@ local function detect (pos)
 		local object = minetest.get_objects_inside_radius (pos, radius + 0.5)
 		local detected_list = { }
 
-		for i = 1, #object do
+		for i = 1, #object, 1 do
 			if object[i]:is_player () then
 
 				-- player

docs/camera.txt

@@ -0,0 +1,41 @@
+Camera
+------
+* This block is only available if digilines is loaded.
+
+Cameras take an image in the direction they are facing. The colors in the
+image represent what is being viewed. Nodes are gray, entities are blue and
+players are green. The closer they are to the camera the brighter the color.
+The viewing distance of the camera is 1 to 16 nodes. Also acts as a
+digilines conductor.
+
+Only the owner can dig or access the form of the locked version.
+
+UI
+
+Channel - digilines channel of camera.
+Distance - the viewing distance forward from the camera (1 to 16).
+Resolution - the image resolution (for both width and height, 1 to 128).
+
+Digilines messages
+
+"scan"
+	Sends a digilines message with the camera's channel and a table of the
+	image as the message (see below).
+
+"distance n"
+	Sets the viewing distance of the camera. Will be clipped between 1 and
+	16.
+
+"resolution n"
+	Sets the image resolution of the camera.
+
+The image is an indexed table of indexed tables. Each inner table is one
+line of the image ordered top to bottom. There are resolution number of
+lines. Each line has a string value for each pixel of that line left to
+right. The string is a hex color string eg. "00FF00". There are resolution
+number of pixels per line.
+
+The image format is compatible with digistuff's digiscreens and lwcomputers'
+digiscreens and digipanels. It is best to set the resolution of the camera
+to the resolution of the display, then the image from the camera can be sent
+straight to the display device.

docs/movefloor.txt

@@ -1,6 +1,6 @@
 MoveFloor
 ---------
-* This block is only available if mesecons and mesecons_mvps is loaded.
+* This block is only available if mesecons is loaded.
 
 The MoveFloor block responds to a mesecons power source in the 4 horizontal
 directions. If the power source is one higher the MoveFloor moves up to

docs/storage.txt

@@ -0,0 +1,99 @@
+Storage
+-------
+
+Storage is accommodated with two nodes, Storage Unit and Storage Indexer.
+Storage units can be interacted with like a basic chest, each with 32 slots,
+and visually join together when placed adjacent to each other. Units are
+generally accessed via indexers, which action all adjoining units as a
+single storage block. Multiple indexers can action a single storage block.
+
+Only the owner can dig or access the form of the locked versions.
+
+Unowned indexers can only access unowned units. Owned indexers can access
+units of the same owner or unowned units.
+
+UI
+Search - top left.
+List - left.
+Channel - digilines channel of indexer.
+Input - middle.
+Output - top right.
+Filter - center right.
+Player inventor - lower right.
+
+When the UI is accessed the storage is scanned, and its contents are
+displayed in the list. The list contains the following columns:
+Item button - pressing will place one of these items from storage into the
+				  output.
+10 button - pressing will place 10 of the item.
+<stack> button - pressing places a full stack.
+Count - the total number of this item in storage.
+Description - description of the item.
+
+Note that the 10 and stack buttons may vary in number or not appear
+depending on the requirements of that item.
+
+The form does not update while open. A request for more items than in
+storage will only deliver the amount in storage.
+
+Terms can be entered into the search field, and when enter is pressed or
+the Search button is pressed, only items whose description contains these
+terms are shown in the list. That is if they match any of the space
+separated terms.
+
+Any items placed into the input are placed into storage. If the filter
+is clear all items are accepted. If the filter contains items only these
+items will be accepted. Any items not accepted or that do not fit into
+storage are placed into the output.
+
+When items are placed into the filter a copy is used and the item returns
+to where it was taken from. When items are removed from the filter they
+are disposed of.
+
+Hoppers placed to the top or sides of an indexer will feed items into the
+input. Hoppers placed below an indexer will take items from the output.
+
+Every 20 inputs the storage is consolidated to minimize fragmentation.
+
+
+Digilines messages
+
+"output <item> <count>"
+or
+{
+	action = "output",
+	item = "<item>",
+	count = <count>
+}
+	Moves the item/s to the output. If count is omitted defaults to 1. If
+	the requested amount is greater than in storage, only the stored amount
+	is moved.
+
+
+"inventory"
+	Sends a digilines message with it's own channel in the following form:
+	{
+		action = "inventory",
+		inventory = {
+			<items>
+		}
+	}
+		The inventory key is an indexed list of items in storage. Each item
+		entry is a table with the following keys:
+		{
+			name -- string, the name of the item, as <mod>:<name>
+			description -- string, description of the item, same as in UI
+			count -- number, the total number of this item in storage
+			custom -- true if a custom item (has metadata), false if not
+			pallet_index -- string if the item has a pallet index, otherwise nil
+			id -- string, unique id of the item in storage
+		}
+			The description is derived in the following manner: from a custom
+			description in metadata; if none then the short description from
+			the item's definition; if none then the description from the item's
+			definition; if none then the item's name, as <mod>:<name>.
+
+Note: When sending output messages the simple item name, as <mod>:<name>,
+will work for most items, but not for custom items. With custom items, or
+to play it safe, use the table form of the output message and set the item
+field with the id field for the item from a returned inventory.

docs/through_wire.txt

@@ -0,0 +1,7 @@
+Mesecons Through Wire
+---------------------
+* This block is only available if mesecons is loaded.
+
+Will transmit mesecons power when placed one to two blocks apart opposing
+each other, through solid blocks or open space. Can also be used as a mesecons
+crossover.

init.lua

@@ -1,4 +1,4 @@
-local version = "0.1.16"
+local version = "0.1.22"
 local mod_storage = minetest.get_mod_storage ()
 
 
@@ -35,6 +35,9 @@ loadfile (modpath.."/conduit.lua") (utils, mod_storage)
 loadfile (modpath.."/cannon.lua") (utils)
 loadfile (modpath.."/cannon_shell.lua") (utils)
 loadfile (modpath.."/pistons.lua") (utils)
+loadfile (modpath.."/through_wire.lua") (utils)
+loadfile (modpath.."/camera.lua") (utils)
+loadfile (modpath.."/storage.lua") (utils)
 loadfile (modpath.."/extras.lua") (utils)
 loadfile (modpath.."/digiswitch.lua") (utils)
 loadfile (modpath.."/movefloor.lua") (utils)

license.txt

@@ -13,6 +13,8 @@ without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 See the GNU Lesser General Public License for more details:
 https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
 
+Mesecons through wire code was adapted from mesecons_receiver.
+
 
 
 lwsiren-buzz.ogg
@@ -59,6 +61,16 @@ https://creativecommons.org/licenses/by/4.0/
 
 
 
+lwmovefloor.ogg
+---------------
+https://www.freesoundslibrary.com/elevator-sound-effect-elevator-ride-doors-closing-and-opening/
+
+License: Attribution 4.0 International (CC BY 4.0). You are allowed to use
+sound effects free of charge and royalty free in your multimedia projects
+for commercial or non-commercial purposes.
+
+
+
 Media license
 -------------
 siren images derived from images from https://openclipart.org, which is
@@ -67,6 +79,12 @@ public domain.
 fan images derived from images from https://openclipart.org, which is
 public domain.
 
+camera lens images derived from images from https://openclipart.org, which
+is public domain.
+
+storage nodes images derived from images from https://openclipart.org, which
+is public domain.
+
 player button images derived from mesecons button image.
 
 cannon firing and explosion sound from tnt (TumeniNodes/steveygos93),

movefloor.lua

@@ -3,7 +3,7 @@ local S = utils.S
 
 
 
-if utils.mesecon_supported and mesecon.mvps_push then
+if utils.mesecon_supported then
 
 
 
@@ -21,14 +21,10 @@ local mesecon_rules =
 
 
 
--- use mesecons movestone settings
-local timer_interval = 1 / mesecon.setting ("movestone_speed", 3)
 local max_push = 3
-local max_pull = 3
 
 
 
--- helper functions:
 local function get_movefloor_direction (rulename)
 	if rulename.y > 0 then
 		return { x = 0, y = 1, z = 0 }
@@ -38,6 +34,7 @@ local function get_movefloor_direction (rulename)
 end
 
 
+
 local function add_movefloor_list (pos, list)
 	for i = 1, #list do
 		if list[i].x == pos.x and
@@ -76,10 +73,289 @@ end
 
 
 
--- copied from mesecons movestone
-local function movefloor_move (pos, node, rulename, is_sticky)
+local function get_node_height (node)
+	local height = 0
+	local def = minetest.registered_nodes[node.name]
+
+	if def and type (def.collision_box) == "table" then
+		if def.collision_box.type and def.collision_box.type == "regular" then
+			height = 1
+
+		else
+			for _, box in pairs (def.collision_box) do
+				if type (box) == "table" then
+					if type (box[5]) == "number" then
+						height = box[5]
+					else
+						for _, b in ipairs (box) do
+							if type (b[5]) == "number" and b[5] > height then
+								height = b[5]
+							end
+						end
+					end
+				end
+			end
+
+		end
+	end
+
+	return height
+end
+
+
+
+local function get_affected_nodes (floor_list)
+	local list = { }
+	local max_height = 0
+	local protected = false
+
+	for _, fpos in ipairs (floor_list) do
+		for y = 0, max_push, 1 do
+			local npos = vector.add (fpos, { x = 0, y = y, z = 0 })
+			local node = utils.get_far_node (npos)
+
+			if node and node.name ~= "air" then
+				local meta = minetest.get_meta (npos)
+				local timer = minetest.get_node_timer (npos)
+				local h = get_node_height (node) + npos.y - fpos.y - 0.5
+
+				list[#list + 1] =
+				{
+					pos = npos,
+					node = node,
+					meta = (meta and meta:to_table ()),
+					timeout = (timer and timer:get_timeout ()) or 0,
+					elapsed = (timer and timer:get_elapsed ()) or 0
+				}
+
+				if h > max_height then
+					max_height = h
+				end
+
+				if utils.is_protected (npos, nil) then
+					protected = true
+				end
+			end
+		end
+	end
+
+	return list, math.ceil (max_height), protected
+end
+
+
+
+local function get_entity_height (obj, base)
+	local height = 0
+
+	if obj.get_pos then
+		local pos = obj:get_pos ()
+
+		if obj.get_luaentity then
+			local entity = obj:get_luaentity ()
+
+			if entity and entity.name then
+				local def = minetest.registered_entities[entity.name]
+
+				if def and type (def.collisionbox) == "table" and
+					type (def.collisionbox[5]) == "number" then
+
+					height = def.collisionbox[5] + pos.y - base
+				end
+			end
+		end
+
+		local props = obj:get_properties ()
+		if props and props.collisionbox and type (props.collisionbox) == "table" and
+			type (props.collisionbox[5]) == "number" then
+
+			if props.collisionbox[5] > height then
+				height = props.collisionbox[5] + pos.y - base
+			end
+		end
+	end
+
+	return height
+end
+
+
+
+local function get_affected_entities (floor_list)
+	local list = { }
+	local max_height = 0
+
+	for _, fpos in pairs (floor_list) do
+		local min_pos = vector.subtract (fpos, { x = 0.4999, y = 0.4999, z = 0.4999 })
+		local max_pos = vector.add (fpos, { x = 0.4999, y = max_push + 0.4999, z = 0.4999 })
+
+		local objects = minetest.get_objects_in_area (min_pos, max_pos)
+
+		for _, obj in ipairs (objects) do
+			local h = get_entity_height (obj, fpos.y + 0.5)
+
+			list[#list + 1] =
+			{
+				pos = obj:get_pos (),
+				obj = obj
+			}
+
+			if h > max_height then
+				max_height = h
+			end
+		end
+	end
+
+	return list, math.ceil (max_height)
+end
+
+
+
+local function is_obstructed (floor_list, height)
+	for _, fpos in pairs (floor_list) do
+		local npos = vector.add (fpos, { x = 0, y = height, z = 0 })
+
+		if utils.is_protected (npos, nil) then
+			return true
+		end
+
+		local node = utils.get_far_node (npos)
+
+		if node and node.name ~= "air" then
+			local def = minetest.registered_nodes[node.name]
+
+			if not def or not def.buildable_to then
+				return true
+			end
+		end
+	end
+
+	return false
+end
+
+
+
+local function move_entities (list, move, players)
+	for _, entry in ipairs (list) do
+		if entry.obj then
+			if players or not entry.obj:is_player () then
+				local pos = nil
+
+				if entry.obj:is_player () then
+					pos = vector.add (entry.pos, { x = move.x, y = move.y + 0.1, z = move.z })
+				else
+					pos = vector.add (entry.pos, move)
+				end
+
+				if entry.obj.move_to then
+					entry.obj:move_to (pos)
+				elseif entry.set_pos then
+					entry.obj:set_pos (pos)
+				end
+			end
+		end
+	end
+end
+
+
+
+local function update_player_position (list)
+	for _, entry in ipairs (list) do
+		local player = minetest.get_player_by_name (entry.name)
+
+		if player then
+			local pos = player:get_pos ()
+
+			if pos.y < entry.pos.y then
+				pos.y = entry.pos.y + 0.1
+				player:set_pos (pos)
+			end
+		end
+	end
+end
+
+
+
+local function queue_player_update (list, move)
+	local players = { }
+
+	for _, entry in ipairs (list) do
+		if entry.obj and entry.obj:is_player () then
+			players[#players + 1] =
+			{
+				pos = vector.add (entry.pos, move),
+				name = entry.obj:get_player_name ()
+			}
+		end
+	end
+
+	if #players > 0 then
+		minetest.after(0.1, update_player_position, players)
+	end
+end
+
+
+
+local function move_nodes (list, move)
+	if move.y > 0 then
+		for i = #list, 1, -1 do
+			local pos = vector.add (list[i].pos, move)
+
+			minetest.remove_node (list[i].pos)
+			minetest.set_node (pos, list[i].node)
+
+			if list[i].meta then
+				local meta = minetest.get_meta (pos)
+
+				if meta then
+					meta:from_table (list[i].meta)
+				end
+			end
+
+			if list[i].timeout > 0 then
+				timer = minetest.get_node_timer (pos)
+
+				if timer then
+					timer:set (list[i].timeout, list[i].elapsed)
+				end
+			end
+		end
+	else
+		for i = 1, #list, 1 do
+			local pos = vector.add (list[i].pos, move)
+
+			minetest.remove_node (list[i].pos)
+			minetest.set_node (pos, list[i].node)
+
+			if list[i].meta then
+				local meta = minetest.get_meta (pos)
+
+				if meta then
+					meta:from_table (list[i].meta)
+				end
+			end
+
+			if list[i].timeout > 0 then
+				timer = minetest.get_node_timer (pos)
+
+				if timer then
+					timer:set (list[i].timeout, list[i].elapsed)
+				end
+			end
+		end
+	end
+end
+
+
+
+local function check_for_falling (list)
+	for _, pos in ipairs (list) do
+		minetest.check_for_falling (vector.add (pos, { x = 0, y = max_push + 1, z = 0 }))
+	end
+end
+
+
+
+local function movefloor_move (pos, node, rulename)
 	local direction = get_movefloor_direction (rulename)
-	local play_sound = false
 
 	local list =
 	{
@@ -88,68 +364,34 @@ local function movefloor_move (pos, node, rulename, is_sticky)
 
 	find_adjoining_movefloor (pos, list)
 
-	for i = 1, #list do
-		local frontpos = vector.add (list[i], direction)
-		local meta = minetest.get_meta (list[i])
-		local owner = meta:get_string ("owner")
-		local continue = true
+	local nodes, height, protected = get_affected_nodes (list)
 
-		-- ### Step 1: Push nodes in front ###
-		local success, stack, oldstack = mesecon.mvps_push (frontpos, direction, max_push, owner)
-		if not success then
-			if stack == "protected" then
-				meta:set_string ("infotext", "Can't move: protected area on the way")
-			else
-				minetest.get_node_timer (list[i]):start (timer_interval)
-				continue = false
-			end
-		end
-
-		if continue then
-			mesecon.mvps_move_objects (frontpos, direction, oldstack)
-
-			-- ### Step 2: Move the movestone ###
-			minetest.set_node (frontpos, node)
-			local meta2 = minetest.get_meta (frontpos)
-			meta2:set_string ("owner", owner)
-			minetest.remove_node (list[i])
-			mesecon.on_dignode (list[i], node)
-			mesecon.on_placenode (frontpos, node)
-			minetest.get_node_timer (frontpos):start (timer_interval)
-			play_sound = true
-
-			-- ### Step 3: If sticky, pull stack behind ###
-			if is_sticky and direction.y < 0 then
-				local backpos = vector.subtract (list[i], direction)
-				success, stack, oldstack = mesecon.mvps_pull_all (backpos, direction, max_pull, owner)
-				if success then
-					mesecon.mvps_move_objects (backpos, vector.multiply (direction, -1), oldstack, -1)
-				end
-			end
-
-			-- ### Step 4: Let things fall ###
-			minetest.check_for_falling (vector.add (list[i], { x = 0, y = 1, z = 0 }))
-		end
-	end
-
-	if play_sound then
-		minetest.sound_play("movestone", { pos = list[i], max_hear_distance = 20, gain = 0.5 }, true)
-	end
-
-end
-
-
-
-local function on_timer (pos, elapsed)
-	local sourcepos = mesecon.is_powered (pos)
-
-	if not sourcepos then
+	if protected then
 		return
 	end
 
-	local rulename = vector.subtract (sourcepos[1], pos)
+	local entities, h = get_affected_entities (list)
 
-	mesecon.activate (pos, minetest.get_node (pos), rulename, 0)
+	if h > height then
+		height = h
+	end
+
+	if is_obstructed (list, (direction.y > 0 and height + 1) or -1) then
+		return
+	end
+
+	if direction.y > 0 then
+		move_entities (entities, direction, true)
+		move_nodes (nodes, direction)
+		queue_player_update (entities, direction)
+	else
+		move_nodes (nodes, direction)
+		move_entities (entities, direction, false)
+		check_for_falling (list)
+		queue_player_update (entities, direction)
+	end
+
+	minetest.sound_play ("lwmovefloor", { pos = pos, max_hear_distance = 10, gain = 1.0 }, true)
 end
 
 
@@ -164,8 +406,8 @@ local function mesecon_support ()
 			action_on = function (pos, node, rulename)
 				-- do something to turn the effector on
 
-				if rulename and not minetest.get_node_timer (pos):is_started () then
-					movefloor_move (pos, node, rulename, true)
+				if rulename then
+					movefloor_move (pos, node, rulename)
 				end
 			end
 		}
@@ -190,8 +432,6 @@ minetest.register_node("lwcomponents:movefloor", {
 	groups = { cracky = 2 },
 	sounds = default.node_sound_wood_defaults (),
 	mesecons = mesecon_support (),
-
-	on_timer = on_timer,
 })
 
 

pistons.lua

@@ -52,7 +52,7 @@ local function push_entities (pos, vec)
 		if tnode.name == "air" then
 			can_move = true
 		else
-			tdef = utils.find_item_def (tnode.name)
+			local tdef = utils.find_item_def (tnode.name)
 
 			can_move = tdef and not tdef.walkable
 		end
@@ -120,6 +120,9 @@ local function push_nodes (pos, extent)
 			end
 
 			local tmeta = cmeta:to_table ()
+			local ctimer = minetest.get_node_timer (cpos)
+			local ctimeout = (ctimer and ctimer:get_timeout ()) or 0
+			local celapsed = (ctimer and ctimer:get_elapsed ()) or 0
 
 			push_entities (cpos, vec)
 
@@ -136,6 +139,14 @@ local function push_nodes (pos, extent)
 				cmeta:from_table (tmeta)
 			end
 
+			if ctimeout > 0 then
+				ctimer = minetest.get_node_timer (last)
+
+				if ctimer then
+					ctimer:set (ctimeout, celapsed)
+				end
+			end
+
 			last = cpos
 		end
 	end
@@ -161,6 +172,9 @@ local function pull_node (pos, extent)
 			if cmeta then
 				local tpos = vector.subtract (cpos, vec)
 				local tmeta = cmeta:to_table ()
+				local ctimer = minetest.get_node_timer (cpos)
+				local ctimeout = (ctimer and ctimer:get_timeout ()) or 0
+				local celapsed = (ctimer and ctimer:get_elapsed ()) or 0
 
 				minetest.remove_node (cpos)
 				minetest.set_node (tpos, cnode)
@@ -172,6 +186,14 @@ local function pull_node (pos, extent)
 						cmeta:from_table (tmeta)
 					end
 				end
+
+				if ctimeout > 0 then
+					ctimer = minetest.get_node_timer (tpos)
+
+					if ctimer then
+						ctimer:set (ctimeout, celapsed)
+					end
+				end
 			end
 		end
 	end

readme.txt

@@ -13,7 +13,7 @@ CC BY-SA 3.0
 
 Version
 =======
-0.1.16
+0.1.22
 
 
 Minetest Version
@@ -66,6 +66,9 @@ Various components for mesecons and digilines.
 *	Double (optionally single) reach pistons and sticky pistons.
 *	Digiswitch, digilines controlled mesecons power.
 *	Movefloor, similar to vertical mesecons movestone.
+*	Camera, takes a representative image.
+*	Storage, indexed storage units.
+*	Mesecons Through Wire, transmits through 1 to 2 solid blocks.
 *	Solid color conductor blocks, same as Solid Color Block but also mesecons
 	and digilines conductor.
 

settings.lua

@@ -10,7 +10,10 @@ utils.settings.alert_handler_errors =
 	minetest.settings:get_bool ("lwcomponents_alert_handler_errors", true)
 
 utils.settings.max_piston_nodes =
-	tonumber(minetest.settings:get("lwcomponents_max_piston_nodes") or 15)
+	tonumber (minetest.settings:get ("lwcomponents_max_piston_nodes") or 15)
+
+utils.settings.default_stack_max =
+	tonumber (minetest.settings:get ("default_stack_max")) or 99
 
 
 

through_wire.lua

@@ -0,0 +1,80 @@
+local utils = ...
+local S = utils.S
+
+
+
+if utils.mesecon_supported then
+
+
+
+local through_wire_get_rules = function (node)
+	local rules = { {x = -1, y = 0, z = 0},
+						 {x =  2, y = 0, z = 0},
+						 {x =  3, y = 0, z = 0} }
+
+	if node.param2 == 2 then
+		rules = mesecon.rotate_rules_left(rules)
+	elseif node.param2 == 3 then
+		rules = mesecon.rotate_rules_right(mesecon.rotate_rules_right(rules))
+	elseif node.param2 == 0 then
+		rules = mesecon.rotate_rules_right(rules)
+	end
+
+	return rules
+end
+
+
+
+mesecon.register_node ("lwcomponents:through_wire", {
+	description = S("Mesecons Through Wire"),
+	drawtype = "nodebox",
+	paramtype = "light",
+	paramtype2 = "facedir",
+	is_ground_content = false,
+	sunlight_propagates = true,
+	walkable = false,
+	on_rotate = false,
+	selection_box = {
+		type = "fixed",
+		fixed = { -3/16, -8/16, -8/16, 3/16, 3/16, 8/16 }
+	},
+	node_box = {
+		type = "fixed",
+		fixed = {
+			{ -3/16, -3/16, 13/32        , 3/16,  3/16  , 8/16        }, -- the smaller bump
+			{ -1/32, -1/32, 1/2          , 1/32,  1/32  , 3/2         }, -- the wire through the block
+			{ -2/32, -1/2 , 0.5002-3/32  , 2/32,  0     , 0.5         }, -- the vertical wire bit
+			{ -2/32, -1/2 , -16/32+0.001 , 2/32,  -14/32,  7/16+0.002 }  -- the horizontal wire
+		}
+	},
+	drop = "lwcomponents:through_wire_off",
+	sounds = default.node_sound_defaults(),
+}, {
+	tiles = { "mesecons_wire_off.png" },
+	groups = { dig_immediate = 3 },
+	mesecons = {
+		conductor = {
+			state = mesecon.state.off,
+			rules = through_wire_get_rules,
+			onstate = "lwcomponents:through_wire_on"
+		}
+	}
+}, {
+	tiles = { "mesecons_wire_on.png" },
+	groups = { dig_immediate = 3, not_in_creative_inventory = 1 },
+	mesecons = {
+		conductor = {
+			state = mesecon.state.on,
+			rules = through_wire_get_rules,
+			offstate = "lwcomponents:through_wire_off"
+		}
+	}
+})
+
+
+
+end -- utils.mesecon_supported
+
+
+
+--