View difference between Paste ID: mzAa07Wn and J3i3TrjU

 ----------------------------------------------------------------------
 --                              Master API                          --
 ----------------------------------------------------------------------
-
+
--- Version 0.1
+-- Version 0.1(481): 1.481-compatible
-
+
 -- Master is an API that controls modules that use my module API.
 -- Master should have:
 --  1) fuel chest in the first slot.
 --  2) stuff chest in the second slot
 --  3) wireless mining turtle in the third slot
 --  4) Any number of fuel/stuff chests and wireless mining turtles in its inventory
 --  5) Note, that Master keeps at least one of each of those items in it's inventory.
 -- Master's job is to listen to requests and send responses.
 -- Usage:
 --  1) For each type of the module you use, make a function which returns a response which will determine what module will do.
 --     This function recieves the ID of that module as an argument
 --     Of course, your module should know about that response and have that in its task table.
 --     You can use master.makeTask(taskName, coordinates, additionalData) function to generate a task response.
 --     additionalData parameter is optional, and if you don't want to send any coordinates, pass an empty table as coordinates.
 --     There is a master.makeReturnTask() function added for convinience - it just makes a task that returns module to the Master
 --  2) Use master.setType(Type, taskFunction) function to associate that function with the type of the module
 --     you might want to change the state of the module in your taskFunction. Use master.getState(ID) and master.setState(ID, state)
 --     functions to do that. Initial state of each module is "Waiting"
 --  4) Set navigation zones for modules using the master.setNavigation(x, z, height) function
 --     Please notice that x, z are 2D coordinates and height is the height of the plane where all the navigation is done
---  5) Initialize the master by running master.init(filename, ID, mainChannel, moduleCount) function
+--  5) Initialize the master by running master.init(filename, ID, moduleCount) function
 --     Master should have module API on its disk and a script for modules (that's the filename argument)
---     mainChannel is the channel on which master listens, and the moduleCount is the required amount of modules
+--     moduleCount is the required amount of modules
 --     ID is a new ID of the Master
 --  6) make a stateFunction() that determines whether master should stop the operation. It should return false if it should stop
 --     and return true if it shouldn't. State function can do other things, such as reinitialization to a new module script and so on
 --     but it shouldn't take too much time to execute. Use master.reinit(filename, moduleCount) function to change the module script, if you want to.
 --  7) Run master.operate(stateFunction) to start.
 
 -- Some basic variables:
 -- MasterID is the unique identifier of master. Default is 100
 local MasterID = 100
 
--- Channel is the channel Master listens.
+
-local channel
+
 -- New placed modules will request "Position" to know where they are.
 local modPosition = {x = 1, y = 0, z = 0, f = 0}
 
 -- naviZones is used by modules to navigate and not interlock themselves
 local naviZones = {x = 0, z = 0, height = 0}
 function setNavigation (x, z, height)
 	naviZones = {x = x, z = z, height = height}
 end
-    naviZones = {x = x, z = z, height = height}
+
 --[[
 *********************************************************************************************
 *                                    Communication Part                                     *
 *********************************************************************************************
 ]]--
 
 rednet.open ("right")
 
--- We need a modem to communicate.
+
-local modem = peripheral.wrap ("right")
+
 -- Message should be a table with fields
 --  1) Protocol - must be equal to "KuuNet"
 --  2) ID - that's a sender ID
 --  3) Master - that must be equal to MasterID variable.
 --  4) Type - the type of the module. Used to know how to handle its task requests
 --  Some other fields
 function isValid (message)
 	if message ~= nil then
 		if message.Protocol ~= "KuuNet" then
 			return false
-    if message ~= nil then
+		end
-        if message.Protocol ~= "KuuNet" then
+		if message.ID == nil then
-            return false
+			return false
-        end
+		end
-        if message.ID == nil then
+		if message.Master ~= MasterID then
-            return false
+			return false
-        end
+		end
-        if message.Master ~= MasterID then
+		return true
-            return false
+	else
-        end
+		return false
-        return true
+	end
-    else
+
-        return false
+
-    end
+
 function listen ()
 	while true do
 		local event, sndID, text_msg, senderDistance = os.pullEvent("rednet_message")
 		local msg = textutils.unserialize (text_msg)
-    while true do
+		if isValid(msg) then
-        local event, modemSide, sndChan, rplyChan, text_msg, senderDistance = os.pullEvent("modem_message")
+			return msg
-        local msg = textutils.unserialize (text_msg)
+		end
-        if isValid(msg) then
+	end
-            return msg
+
-        end
+
-    end
+
 function response (ID, message)
 	message.Protocol = "KuuNet"
 	message.ID = ID
-function response (ID, chan, message)
+	message.Master = MasterID
-    message.Protocol = "KuuNet"
+	rednet.broadcast (textutils.serialize(message))
-    message.ID = ID
+
-    message.Master = MasterID
+
-    modem.transmit (chan+1, chan, textutils.serialize(message))
+
 *********************************************************************************************
 *                                   Module Placement Part                                   *
 *********************************************************************************************
 ]]--
 -- moduleCount is the number of active modules
 -- needModules is the number of modules required
 -- modulesAvailable is the number of available modules
 local moduleCount = 0
 local needModules = 0
 local modAvailable = nil
 -- This function searches the turtle inventory for same item
 -- as in the given slot, or selects that slot if there are more than one item
 function searchItem (slot)
 	turtle.select (slot)
 	local found = 0
 	for i=1,16 do
-    turtle.select (slot)
+		if i ~= slot then
-    local found = 0
+			if turtle.getItemCount (i) > 0 then
-    for i=1,16 do
+				if turtle.compareTo (i) then
-        if i ~= slot then
+					found = i
-            if turtle.getItemCount (i) > 0 then
+				end
-                if turtle.compareTo (i) then
+			end
-                    found = i
+		end
-                end
+	end
-            end
+	if found == 0 then
-        end
+		if turtle.getItemCount (slot) > 1 then
-    end
+			found = slot
-    if found == 0 then
+		else
-        if turtle.getItemCount (slot) > 1 then
+			turtle.select(1)
-            found = slot
+			return false
-        else
+		end
-            turtle.select(1)
+	end
-            return false
+	turtle.select (found)
-        end
+	return true
-    end
+
-    turtle.select (found)
+
-    return true
+
 	turtle.select (slot)
 	local count = 0
 	for i = 1,16 do
-    turtle.select (slot)
+		if turtle.compareTo(i) then
-    local count = 0
+			count = count + turtle.getItemCount(i)
-    for i = 1,16 do
+		end
-        if turtle.compareTo(i) then
+	end
-            count = count + turtle.getItemCount(i)
+	return count
-        end
+
-    end
+
-    return count
+
 -- The counting takes some time, so there is a variable to speed up the process
 function availableModules ()
 	if modAvailable == nil then
 		local minimum = 1024
 		for i = 1, 3 do
-    if modAvailable == nil then
+			local quantity = countBySample(i) - 1
-        local minimum = 1024
+			if minimum > quantity then
-        for i = 1, 3 do
+				minimum = quantity
-            local quantity = countBySample(i) - 1
+			end
-            if minimum > quantity then
+		end
-                minimum = quantity
+		modAvailable = minimum
-            end
+	end
-        end
+	return modAvailable
-        modAvailable = minimum
+
-    end
+
-    return modAvailable
+
 	searchItem (3)   -- search for a module
 	if turtle.place () then  -- put it down
 		searchItem (1)
-    searchItem (3)   -- search for a module
+		turtle.drop (1)  -- Add a fuel chest
-    if turtle.place () then  -- put it down
+		searchItem (2)
-        searchItem (1)
+		turtle.drop (1)  -- And a stuff chest
-        turtle.drop (1)  -- Add a fuel chest
+		turtle.select (1)-- select first slot to make things look good :)
-        searchItem (2)
+		peripheral.call ("front", "turnOn")    -- Turn on the module
-        turtle.drop (1)  -- And a stuff chest
+		modAvailable = modAvailable - 1
-        turtle.select (1)-- select first slot to make things look good :)
+	end
-        peripheral.call ("front", "turnOn")    -- Turn on the module
+
-        modAvailable = modAvailable - 1
+
-    end
+
 *********************************************************************************************
 *                                       Operation Part                                      *
 *********************************************************************************************
 ]]--
 
 -- This is a table that contains all the states of the modules.
 -- Indexes of that table are ID's and values are tables with following fields
 --  1) Type - type of the module. Each Type has it's own task table
 --  2) State - the state of the module. List of states is unique for each module type, but there are some common states: "Waiting" and "Returning"
 tStates = {}
 
 -- There is a function that searches for a free ID. Let's limit the maximun number of IDs to 1024
 function freeID ()
-
+	for i = 1, 1024 do
 		if tStates [i] == nil then
 			return i
-    for i = 1, 1024 do
+		end
-        if tStates [i] == nil then
+	end
-            return i
+
-        end
+
-    end
+
 tTasks = {}
 
 -- Here is the table used to handle the requests.
 tRequests = {
 	-- "Master" is the request sent by new modules. We should assign a new ID to it and remember that ID in tStates table
 	Master = function (request)
 		local ID = freeID ()
-    -- "Master" is the request sent by new modules. We should assign a new ID to it and remember that ID in tStates table
+		response (request.ID, {NewID = ID})
-    Master = function (request)
+		tStates[ID] = {State = "Waiting", Type = request.Type}
-        local ID = freeID ()
+		moduleCount = moduleCount + 1
-        response (request.ID, channel, {NewID = ID})
+	end,
-        tStates[ID] = {State = "Waiting", Type = request.Type}
+	-- Task is the request used to reques the next thing module should do
-        moduleCount = moduleCount + 1
+	-- It uses the tTasks table. There is a function for each module type which returns a response
-    end,
+	-- Response may contain coordinate of the next place and id should contain "Task" field
-    -- Task is the request used to reques the next thing module should do
+	-- This function may do something else, change the state of module and so on.
-    -- It uses the tTasks table. There is a function for each module type which returns a response
+	-- To associate it with the module, sender ID is passed to that function
-    -- Response may contain coordinate of the next place and id should contain "Task" field
+	-- tTasks table should be filled by user of this API
-    -- This function may do something else, change the state of module and so on.
+	Task = function (request)
-    -- To associate it with the module, sender ID is passed to that function
+		response (request.ID, tTasks[request.Type](request.ID))
-    -- tTasks table should be filled by user of this API
+	end,
-    Task = function (request)
+	-- "Returned" is the request sent by module that has returned to Master and waiting there until Master collects it
-        response (request.ID, channel, tTasks[request.Type](request.ID))
+	Returned = function (request)
-    end,
+		while turtle.suck () do end -- Get all the items that module had
-    -- "Returned" is the request sent by module that has returned to Master and waiting there until Master collects it
+		turtle.dig ()               -- And get the module back
-    Returned = function (request)
+		tStates[request.ID] = nil -- delete that module from our state table
-        while turtle.suck () do end -- Get all the items that module had
+		moduleCount = moduleCount - 1 -- and decrease the counter
-        turtle.dig ()               -- And get the module back
+		modAvailable = modAvailable + 1
-        tStates[request.ID] = nil -- delete that module from our state table
+	end
-        moduleCount = moduleCount - 1 -- and decrease the counter
+
-        modAvailable = modAvailable + 1
+
-    end
+-- This is the variable used to determine whether the master should place modules
 local isPlacing = false
 
--- This is the variable used to determine whether the master should place modules
+
 -- It automatically stops placing modules when there is enough modules
 function moduleManager ()
 	while true do
 		if isPlacing then
 			if moduleCount == needModules or availableModules() == 0 then
-    while true do
+				isPlacing = false
-        if isPlacing then
+			else
-            if moduleCount == needModules or availableModules() == 0 then
+				addModule ()
-                isPlacing = false
+			end
-            else
+		end
-                addModule ()
+		sleep (6)
-            end
+	end
-        end
+
-        sleep (6)
+
-    end
+
 -- stateFunction is the function used to determine when master should stop.
 -- Master stops when there are to active modules and stateFunction returns false.
 -- State function can do other things, such as reinitialization to a new module script and so on, but it shouldn't take too much time to execute
 function operate (stateFunction)
 	local server = function ()
 		while stateFunction() or moduleCount > 0 do
 			local request = listen ()
-    local server = function ()
+			tRequests[request.Request](request) -- Just execute the request handler.
-        while stateFunction() or moduleCount > 0 do
+		end
-            local request = listen ()
+	end
-            tRequests[request.Request](request) -- Just execute the request handler.
+	parallel.waitForAny (server, moduleManager)
-        end
+	rednet.close ("right")
-    end
+
-    parallel.waitForAny (server, moduleManager)
+
-    modem.closeAll ()
+
 *********************************************************************************************
 *                                    Initialization Part                                    *
 *********************************************************************************************
 ]]--
 
 -- Some basic movement and refueling
 -- Refuel assumes that Master has a bunch of fuel chests in slot 1 and slot 16 is empty
 function refuel (amount)
 	if turtle.getFuelLevel () > amount then
 		return true
 	else
-    if turtle.getFuelLevel () > amount then
+		turtle.select (1)
-        return true
+		turtle.placeUp ()
-    else
+		turtle.select (16)
-        turtle.select (1)
+			turtle.suckUp ()
-        turtle.placeUp ()
+			while turtle.refuel (1) do
-        turtle.select (16)
+				if turtle.getFuelLevel() >= amount then
-            turtle.suckUp ()
+					turtle.dropUp ()
-            while turtle.refuel (1) do
+					turtle.select (1)
-                if turtle.getFuelLevel() >= amount then
+					turtle.digUp ()
-                    turtle.dropUp ()
+					return true
-                    turtle.select (1)
+				end
-                    turtle.digUp ()
+				if turtle.getItemCount (1) == 0 then
-                    return true
+					turtle.suckUp ()
-                end
+				end
-                if turtle.getItemCount (1) == 0 then
+			end
-                    turtle.suckUp ()
+		end
-                end
+	turtle.dropUp ()
-            end
+	turtle.select (1)
-        end
+	turtle.digUp ()
-    turtle.dropUp ()
+	return false
-    turtle.select (1)
+
-    turtle.digUp ()
+
-    return false
+
 	forward = turtle.forward,
 	back = turtle.back
 }
-    forward = turtle.forward,
+
-    back = turtle.back
+	refuel (1)
 	while not tMoves[direction]() do
 		print "Movement obstructed. Waiting"
-    refuel (1)
+		sleep (1)
-    while not tMoves[direction]() do
+	end
-        print "Movement obstructed. Waiting"
+
-        sleep (1)
+
-    end
+
 function setType (Type, taskFunction)
 	tTasks[Type] = taskFunction
 end
 
-    tTasks[Type] = taskFunction
+
 -- Filename is the name of module's script. It will be copied on the disk drive
 function init (filename, ID, moduleCount)
 	-- Set the ID of the Master
 	MasterID = ID
-function init (filename, ID, mainChannel, moduleCount)
+
-    -- Set the ID of the Master
+	-- Next, we need to know the position of the master.
-    MasterID = ID
+	-- If gps is not found, use relative coordinates
-    -- Set the main channel and listen on said channel
+	local gpsPresent = true
-    channel = mainChannel
+	local x, y, z = gps.locate(5)
-    modem.open (channel)
+	if x == nil then
-
+		x, y, z = 0, 0, 0
-    -- Next, we need to know the position of the master.
+		gpsPresent = false
-    -- If gps is not found, use relative coordinates
+	end
-    modem.open(gps.CHANNEL_GPS)
+
-    local gpsPresent = true
+	-- Now we need to move forward to copy files on disk and determine our f
-    local x, y, z = gps.locate(5)
+	forceMove ("forward")
-    if x == nil then
+	local newX, newZ = 1, 0 -- if there is no gps, assume that master is facing positive x
-        x, y, z = 0, 0, 0
+	if gpsPresent then
-        gpsPresent = false
+		newX, __, newZ = gps.locate (5)
-    end
+	end
 	-- Determine f by the difference of coordinates.
-    -- Now we need to move forward to copy files on disk and determine our f
+	local xDiff = newX - x
-    forceMove ("forward")
+	local zDiff = newZ - z
-    local newX, newZ = 1, 0 -- if there is no gps, assume that master is facing positive x
+	if xDiff ~= 0 then
-    if gpsPresent then
+		if xDiff > 0 then
-        newX, __, newZ = gps.locate (5)
+			f = 0     -- Positive x
-    end
+		else
-    modem.close(gps.CHANNEL_GPS)
+			f = 2     -- Negative x
-    -- Determine f by the difference of coordinates.
+		end
-    local xDiff = newX - x
+	else
-    local zDiff = newZ - z
+		if zDiff > 0 then
-    if xDiff ~= 0 then
+			f = 1     -- Positive z
-        if xDiff > 0 then
+		else
-            f = 0     -- Positive x
+			f = 3     -- Negative z
-        else
+		end
-            f = 2     -- Negative x
+	end
-        end
+	-- And set the position and modPosition variables.
-    else
+	Position = {x = x, y = y, z = z, f = f}
-        if zDiff > 0 then
+	modPosition = {x = newX, y = y, z = newZ, f = f}
-            f = 1     -- Positive z
+
-        else
+	-- Copy all the required files on the disk
-            f = 3     -- Negative z
+	if fs.exists ("/disk/module") then
-        end
+		fs.delete ("/disk/module")
-    end
+	end
-    -- And set the position and modPosition variables.
+	fs.copy ("module", "/disk/module")
-    Position = {x = x, y = y, z = z, f = f}
+	if fs.exists ("/disk/"..filename) then
-    modPosition = {x = newX, y = y, z = newZ, f = f}
+		fs.delete ("/disk/"..filename)
 	end
-    -- Copy all the required files on the disk
+	fs.copy (filename, "/disk/"..filename)
-    if fs.exists ("/disk/module") then
+	-- Make a startup file for modules
-        fs.delete ("/disk/module")
+	local file = fs.open ("/disk/startup", "w")
-    end
+	file.writeLine ("shell.run(\"copy\", \"/disk/module\", \"/module\")")
-    fs.copy ("module", "/disk/module")
+	file.writeLine ("shell.run(\"copy\", \"/disk/"..filename.."\", \"/startup\")")
-    if fs.exists ("/disk/"..filename) then
+	file.writeLine ("shell.run(\"startup\")")
-        fs.delete ("/disk/"..filename)
+	file.close()
-    end
+
-    fs.copy (filename, "/disk/"..filename)
+	-- Now, make a file with the data modules need
-    -- Make a startup file for modules
+	file = fs.open ("/disk/initdata", "w")
-    local file = fs.open ("/disk/startup", "w")
+	-- Communication data: master ID and communication channel
-    file.writeLine ("shell.run(\"copy\", \"/disk/module\", \"/module\")")
+	file.writeLine (textutils.serialize ({MasterID = MasterID, channel = channel}) )
-    file.writeLine ("shell.run(\"copy\", \"/disk/"..filename.."\", \"/startup\")")
+	-- Location data:
-    file.writeLine ("shell.run(\"startup\")")
+	file.writeLine (textutils.serialize (modPosition))
-    file.close()
+	-- Navigation data:
-
+	file.writeLine (textutils.serialize (naviZones))
-    -- Now, make a file with the data modules need
+	file.close()
-    file = fs.open ("/disk/initdata", "w")
+
-    -- Communication data: master ID and communication channel
+	-- And go back to initial location
-    file.writeLine (textutils.serialize ({MasterID = MasterID, channel = channel}) )
+	forceMove ("back")
-    -- Location data:
+
-    file.writeLine (textutils.serialize (modPosition))
+	-- Set the amount of modules needed. I use "+" because one can run init again to add a different type of module to the operation
-    -- Navigation data:
+	needModules = needModules + moduleCount
-    file.writeLine (textutils.serialize (naviZones))
+	-- And start placing them
-    file.close()
+	isPlacing = true
-
+
-    -- And go back to initial location
+
-    forceMove ("back")
+
 --[[
-    -- Set the amount of modules needed. I use "+" because one can run init again to add a different type of module to the operation
+
-    needModules = needModules + moduleCount
+
-    -- And start placing them
+
-    isPlacing = true
+
 
-
+
-
+
 	-- return position is two block away of Master. So, let's calculate it.
 	local tShifts = {
 		[0] = { 1,  0},
 		[1] = { 0,  1},
 		[2] = {-1,  0},
 		[3] = { 0, -1},
 	}
 	local xShift, zShift = unpack (tShifts[modPosition.f])
-    -- return position is two block away of Master. So, let's calculate it.
+	returnX = modPosition.x + xShift
-    local tShifts = {
+	returnZ = modPosition.z + zShift
-        [0] = { 1,  0},
+	return {   Task = "Return",
-        [1] = { 0,  1},
+		x = returnX,
-        [2] = {-1,  0},
+		y = modPosition.y,
-        [3] = { 0, -1},
+		z = returnZ,
-    }
+		f = (modPosition.f+2)%4, -- basically, reverse direction
-    local xShift, zShift = unpack (tShifts[modPosition.f])
+	}
-    returnX = modPosition.x + xShift
+
-    returnZ = modPosition.z + zShift
+
-    return {   Task = "Return",
+
-        x = returnX,
+
-        y = modPosition.y,
+
-        z = returnZ,
+	local newTask = {Task = taskName}
-        f = (modPosition.f+2)%4, -- basically, reverse direction
+	for key, value in pairs (coordinates) do
-    }
+		newTask[key] = value
 	end
-
+	if additionalData ~= nil then
 		for key, value in pairs (additionalData) do
 			newTask[key] = value
 		end
-    local newTask = {Task = taskName}
+	end
-    for key, value in pairs (coordinates) do
+	return newTask
-        newTask[key] = value
+
-    end
+
-    if additionalData ~= nil then
+
-        for key, value in pairs (additionalData) do
+	return tStates[ID].State
-            newTask[key] = value
+
-        end
+
-    end
+
-    return newTask
+	tStates[ID].State = newState
 end
-
+
 -- reinit function is just a simplified init, that doesn't update channel, MasterID and Master's position. Use it to change the modules script
-    return tStates[ID].State
+
 	forceMove ("forward")
-
+	-- Copy all the required files on the disk
 	if fs.exists ("/disk/module") then
-    tStates[ID].State = newState
+		fs.delete ("/disk/module")
 	end
 	fs.copy ("module", "/disk/module")
 	if fs.exists ("/disk/"..filename) then
 		fs.delete ("/disk/"..filename)
-    forceMove ("forward")
+	end
-    -- Copy all the required files on the disk
+	fs.copy (filename, "/disk/"..filename)
-    if fs.exists ("/disk/module") then
+	-- Make a startup file for modules
-        fs.delete ("/disk/module")
+	local file = fs.open ("/disk/startup", "w")
-    end
+	file.writeLine ("shell.run(\"copy\", \"/disk/module\", \"/module\")")
-    fs.copy ("module", "/disk/module")
+	file.writeLine ("shell.run(\"copy\", \"/disk/"..filename.."\", \"/startup\")")
-    if fs.exists ("/disk/"..filename) then
+	file.writeLine ("shell.run(\"startup\")")
-        fs.delete ("/disk/"..filename)
+	file.close()
-    end
+
-    fs.copy (filename, "/disk/"..filename)
+	-- Now, make a file with the data modules need
-    -- Make a startup file for modules
+	file = fs.open ("/disk/initdata", "w")
-    local file = fs.open ("/disk/startup", "w")
+	-- Communication data: master ID
-    file.writeLine ("shell.run(\"copy\", \"/disk/module\", \"/module\")")
+	file.writeLine (textutils.serialize ({MasterID = MasterID}) )
-    file.writeLine ("shell.run(\"copy\", \"/disk/"..filename.."\", \"/startup\")")
+	-- Location data:
-    file.writeLine ("shell.run(\"startup\")")
+	file.writeLine (textutils.serialize (modPosition))
-    file.close()
+	-- Navigation data:
-
+	file.writeLine (textutils.serialize (naviZones))
-    -- Now, make a file with the data modules need
+	file.close()
-    file = fs.open ("/disk/initdata", "w")
+
-    -- Communication data: master ID and communication channel
+	-- And go back to initial location
-    file.writeLine (textutils.serialize ({MasterID = MasterID, channel = channel}) )
+	forceMove ("back")
-    -- Location data:
+
-    file.writeLine (textutils.serialize (modPosition))
+	-- Set the amount of modules needed. I use "+" because one can run init again to add a different type of module to the operation
-    -- Navigation data:
+	needModules = needModules + moduleCount
-    file.writeLine (textutils.serialize (naviZones))
+	-- And start placing them
-    file.close()
+	isPlacing = true
-
+