microexpansion/modules/network/init.lua

local me       = microexpansion
me.networks    = {}
local networks = me.networks
local path     = microexpansion.get_module_path("network")
local storage  = minetest.get_mod_storage()

dofile(path.."/constants.lua")

--deprecated: use ItemStack(x) instead
--[[
local function split_stack_values(stack)
  if type(stack) == "string" then
    local split_string = stack:split(" ")
    if (#split_string < 1) then
      return "",0,0,nil
    end
    local stack_name = split_string[1]
    if (#split_string < 2) then
      return stack_name,1,0,nil
    end
    local stack_count = tonumber(split_string[2])
    if (#split_string < 3) then
      return stack_name,stack_count,0,nil
    end
    local stack_wear = tonumber(split_string[3])
    if (#split_string < 4) then
      return stack_name,stack_count,stack_wear,nil
    end
    return stack_name,stack_count,stack_wear,true
  else
    return stack:get_name(), stack:get_count(), stack:get_wear(), stack:get_meta()
  end
end
--]]

function me.insert_item(stack, inv, listname)
  if me.settings.huge_stacks == false then
    return inv:add_item(listname, stack)
  end
  local to_insert = type(stack) == "userdata" and stack or ItemStack(stack)
  local found = false
  for i = 0, inv:get_size(listname) do
    local inside = inv:get_stack(listname, i)
    if inside:get_name() == to_insert:get_name() and inside:get_wear() == to_insert:get_wear() then
      if inside:get_meta():equals(to_insert:get_meta()) then
        local total_count = inside:get_count() + to_insert:get_count()
        -- bigger item count is not possible, we only have unsigned 16 bit
        if total_count <= math.pow(2,16) then
          if not inside:set_count(total_count) then
            microexpansion.log("adding items to stack in microexpansion network failed","error")
            print("stack is now " .. inside:to_string())
          end
          inv:set_stack(listname, i, inside)
          found = true
          break;
        end
      end
    end
  end
  if not found then
    return inv:add_item(listname, stack)
  end
end

dofile(path.."/network.lua") -- Network Management

-- generate iterator to find all connected nodes
function me.connected_nodes(start_pos,include_ctrl)
	-- nodes to be checked
	local open_list = {{pos = start_pos}}
	-- nodes that were checked
	local closed_set = {}
	-- local connected nodes function to reduce table lookups
	local adjacent_connected_nodes = me.network.adjacent_connected_nodes
	-- return the generated iterator
	return function ()
		-- start looking for next pos
		local open = false
		-- pos to be checked
		local current
		-- find next unclosed
		while not open do
			-- get unchecked pos
			current = table.remove(open_list)
			-- none are left
			if current == nil then return end
			-- assume it's open
			open = true
			-- check the closed positions
			for _,closed in pairs(closed_set) do
				-- if current is unclosed
				if vector.equals(closed,current.pos) then
					--found one was closed
					open = false
				end
			end
		end
		-- get all connected nodes
		local nodes = adjacent_connected_nodes(current.pos,include_ctrl)
		-- iterate through them
		for _,n in pairs(nodes) do
			-- mark position to be checked
			table.insert(open_list,n)
		end
		-- add this one to the closed set
		table.insert(closed_set,current.pos)
		-- return the one to be checked
		return current.pos,current.name
	end
end

-- get network connected to position
function me.get_connected_network(start_pos)
	for npos,nn in me.connected_nodes(start_pos,true) do
		if nn == "microexpansion:ctrl" then
			local source = minetest.get_meta(npos):get_string("source")
			local network
			if source == "" then
				network = me.get_network(npos)
			else
				network = me.get_network(vector.from_string(source))
			end
			if network then
				return network,npos
			end
		end
	end
end

function me.promote_controller(start_pos,net)
	local promoted = false
	for npos,nn in me.connected_nodes(start_pos,true) do
		if nn == "microexpansion:ctrl" and npos ~= start_pos then
			if promoted then
				minetest.get_meta(npos):set_string("source", promoted)
			else
				promoted = vector.to_string(npos)
				minetest.get_meta(npos):set_string("source", "")
				net.controller_pos = npos
			end
		end
	end
	return promoted and true or false
end

function me.update_connected_machines(start_pos,event,include_start)
  microexpansion.log("updating connected machines","action")
  local ev = event or {type = "n/a"}
  local sn = microexpansion.get_node(start_pos)
  local sd = minetest.registered_nodes[sn.name]
  local sm = sd.machine or {}
  ev.origin = {
    pos = start_pos,
    name = sn.name,
    type = sm.type
  }
  --print(dump2(ev,"event"))
  for npos in me.connected_nodes(start_pos) do
    if include_start or not vector.equals(npos,start_pos) then
      me.update_node(npos,ev)
    end
	end
end

function me.send_event(spos,type,data)
  local d = data or {}
  local event = {
    type = type,
    net = d.net,
    payload = d.payload
  }
  me.update_connected_machines(spos,event,false)
end

function me.get_network(pos)
	for i,net in pairs(networks) do
		if net.controller_pos then
			if vector.equals(pos, net.controller_pos) then
				return net,i
			end
		end
	end
end

dofile(path.."/ctrl.lua") -- Controller/wires
dofile(path.."/security.lua") --Security Terminal

-- load networks
function me.load()
	local res = storage:get_string("networks")
	if res == "" then
		local f = io.open(me.worldpath.."/microexpansion_networks", "r")
		if f then
			me.log("loading network data from file","action")
			res = minetest.deserialize(f:read("*all"))
			f:close()
		else
			me.log("no network data loaded","action")
			return
		end
	else
		me.log("loading network data from mod storage","action")
		res = minetest.deserialize(res)
	end
	if type(res) == "table" then
		for _,n in pairs(res) do
		 local net = me.network.new(n)
		 net:load()
		 table.insert(me.networks,net)
		end
	else
		me.log("network data in unexpected format","error")
	end
end

-- load now
me.load()

-- save networks
function me.save()
  local data = {}
  for _,v in pairs(me.networks) do
    table.insert(data,v:serialize())
  end
	if storage then
		me.log("saving network data to mod storage","info")
		storage:set_string("networks", minetest.serialize(data))
	else
		me.log("saving network data to file","info")
		local f = io.open(me.worldpath.."/microexpansion_networks", "w")
		f:write(minetest.serialize(data))
		f:close()
	end
end

function me.do_autosave()
	me.last_autosave = -1
	minetest.after(1, function()
		--print("autosaving ME Networks")
		me.save()
		me.last_autosave = minetest.get_server_uptime()
	end)
end

function me.autosave()
	--TODO: make max autosave interval settable
	if not me.last_autosave then
		me.do_autosave()
	elseif me.last_autosave == -1 then
		return
	elseif minetest.get_server_uptime() - me.last_autosave >= 600 then
		me.do_autosave()
	end
end

-- save on server shutdown
minetest.register_on_shutdown(me.save)