function main(cmds)

  local routines = {}
  local eventdata = {}
  local filter = {}
  local status
  local n

  routines[1] = coroutine.create(go)
  routines[2] = coroutine.create(fuelManager)

  while true do
	for i,r in ipairs(routines) do
	  if filter[r] == nil or filter[r] == eventdata[1] or eventdata[1] == "terminate" then
		status, param = coroutine.resume(r, unpack(eventdata))
		assert(status,paraam)
		filter[r] = param
		if coroutine.status(r) == "dead" then
		  return i
		end
	  end
	end

	for i,r in ipairs(routines) do
	  if coroutine.status(r) == "dead" then
		return i
	  end
	end

	os.queueEvent("docmds", unpack(cmds))
	eventdata = { coroutine.yield() }
  end

end

function go()
  local tcmds = { }
  tcmds = { coroutine.yield("docmds") }
  local eventID = tcmds[1]
  table.remove(tcmds,1)
  if eventID == "docmds" then
	for i,v in ipairs(tcmds) do
	   print(v)
	   sleep(1)
	end
  end
end

function fuelManager()
  FuelOnHand = 40
  while FuelOnHand > 10 do
	FuelOnHand = FuelOnHand - 5
	print("Fuel: " .. FuelOnHand)
	sleep(1)
  end
end

local targs = { ... }
local func = ""
local i = 0
local func = main(targs)

if func == 1 then
  print("Commands Completed")
elseif func == 2 then
  print("Out of Gas")
else
  print("Not sure what happened ... " .. func)
end

function main(cmds)

  local routines = {}
  local eventdata = {}
  local filter = {}
  local status
  local n

  routines[1] = coroutine.create(go)
  routines[2] = coroutine.create(fuelManager)

  while true do
    for i=1,#routines do
      r = routines[i]
      if filter[r] == nil or filter[r] == eventdata[1] or eventdata[1] == "terminate" then
        status, param = coroutine.resume(r, unpack(eventdata))
        assert(status,param)
        if coroutine.status(r) == "dead" then
          return i
        end
        filter[r] = param
      end
    end

    for i=1,#routines do
      r = routines[i]
      if coroutine.status(r) == "dead" then
        return i
      end
    end

    os.queueEvent("docmds",unpack(cmds))
    eventdata = { coroutine.yield() }
  end

end

function go()
  local tcmds = { }
  local eventID, cmds = coroutine.yield("docmds")
  tcmds = tablify(cmds)
  print("event: " .. eventID)
  -- its hanging here - not sure why.
  for i=1,#tcmds do
    print(i .. ". " .. tcmds[i])
  end
  if eventID == "docmds" then
    for i=1,#cmds do
      print(cmds[i])
      sleep(1)
    end
  end
end

function fuelManager()
  FuelOnHand = 40
  while FuelOnHand > 10 do
    sleep(1)
    FuelOnHand = FuelOnHand - 5
  end
end

function tablify(strSeq)
  local retValue = {}
  local nCurrMatchPos = 0
  local nLastMatchPos = 0
  while true do
   nCurrMatchPos = string.find(strSeq, " ", nLastMatchPos + 1)
   if nCurrMatchPos then
     s = string.sub(strSeq,nLastMatchPos+1,nCurrMatchPos-1)
     if s ~= "" then
       table.insert(retValue,s)
       nLastMatchPos = nCurrMatchPos
     end     
   else
     break
   end
  end
  return retValue
end

local targs = { ... }
local func = ""
local i = 0
local func = main(targs)

if func == 1 then
  print("Commands Completed")
elseif func == 2 then
  print("Out of Gas")
else
  print("Not sure what happened ... " .. func)
end

function count(eventID, StartingValue, IterateAmount, IterateCount )
  local currentValue = StartingValue
  local iterations = 0
  while true do
	if eventID == "terminate" then
	  break
	end
	if eventID="iterate" then
	  currentValue = currentValue + IterateAmount
	  iterations = iterations + 1
	  if iterations => IterateCount then
		return
	  end
	  coroutine.yield(eventID, currentValue)
	end
  end
end

local coIter = courtine.create(count)
local eventdata = {}
os.queueEvent("iterate",10,5,5)
while true do
  if (filter == nil) or (filter == eventdata[1]) or (eventdata[1] == "terminate") then
  status, value = coroutine.resume(coIter, eventdata)
  assert(status,value)
  filter = value
  if coroutine.status == "dead" then
	break
  end
  eventdata = { os.pullEventRaw() }
end

function A(MyArg)
  for i=1,5 do
	coroutine.yield(i .. ". " .. MyArg)
  end
end

local coA = coroutine.create(A)

while true do
  status, value = coroutine.resume(coA,"Test")
  if not status then
	break
  end
  if coroutine.status(coA) == "dead" then
	break
  end
  print(value)
end

1. Test
2. Test
3. Test
4. Test
5. Test

  function A(MyArg)
	for i=1,5 do
	  coroutine.yield(i .. ". " .. MyArg)
	  os.sleep(1)
	end
  end

if value == "timer" then
  // Pass on the Timer value somehow to computercraft
end

JokerRH, on 09 April 2013 - 08:53 AM, said:

-- Best report his even though it may correct itself in half a second
print(string.upper(sOperation) .. " returned error")
sleep(0.5)

-- Start/Resume our Go coroutine
yy = coroutine.resume(coGo,cmds)

function A()
  print("Hello")
  sleep(5)
  print("World")
end

function B()
  sleep(3)
  print("Cruel")
  sleep(5)
end

local coA = coroutine.create(A)
local coB = coroutine.create(B)/>

while true do
  coroutine.resume(coA)
  coroutine.resume(coB)
  if coroutine.status(coA) == "dead" or coroutine.status(coB) == "dead" then
	break
  end
end

• it would create the two coroutines .. with coroutine.create
  
• it would resume (or start) the first coroutine (-A-). .. and print "Hello", then going to sleep
  
• When A sleeps, the Sleep() function would yield, passing control back to the main function
  
• it would resume (or start) the second coroutine (-B-)
  
• when B sleeps, the Sleep() function would yield, passing control back to the main function.
  
• The while loop repeats again and again.
  
• Eventually coroutine B's sleep() would finish first (only 3 seconds) .. and print "Cruel" ... then sleep
  
• Finally, the sleep routine from coroutine A would hit 5 seconds - print "World" and then terminate ..
  
• .. thus ending the program.

PixelToast, on 09 April 2013 - 05:43 AM, said:

-- 'Calls itself recursively, with each invocation returning one more coroutine than the last'
-- 'When the end is reached, it returns nil'
local function create( first, ... )
  if first ~= nil then
	return coroutine.create(first), create( ... )
  end
  return nil
end

-- 'Not fully sure ..'
local function runUntilLimit( _routines, _limit )
  local count = #_routines
  local living = count
  local tFilters = {}
  local eventData = {}
  while true do

	for n=1,count do
	  local r = _routines[n]
	  if r then
	   -- 'Not sure what we are checking here:'
		if tFilters[r] == nil or tFilters[r] == eventData[1] or eventData[1] == "terminate" then
		  -- 'The yield from r will return two parameters (ok, parm).'
		  -- 'I am guessing OK is an indicator if the coroutine exited fine.'
		  -- 'not sure what param is'
		  local ok, param = coroutine.resume( r, unpack(eventData) )  -- 'unpack() converts the eventData array into individual arguments'
		  if not ok then
			error( param )  -- returns an error if not OK.
							-- 'from my reading on error() it seems this is the same as: assert(ok,param)'
		  else
			tFilters[r] = param  -- 'not sure - need to know what param is to understand what tFilters is.'
		  end
		  -- 'if the coroutine has exited on its own .. then neutralize the coroutine from the coroutine array'
		  -- 'Reduce the counter variable for the number of active coroutines ..'
		  -- 'If we hit our limit then return which coroutine index stopped'
		  if coroutine.status( r ) == "dead" then
			_routines[n] = nil
			living = living - 1
			if living <= _limit then
			  return n
			end
		  end
		end
	  end
	end

	-- 'looks like this runs through all the coroutines and cleans them up if they are dead.'
	for n=1,count do
	  local r = _routines[n]
	  if r and coroutine.status( r ) == "dead" then
		_routines[n] = nil
		living = living - 1
		if living <= _limit then
		  return n
		end
	  end
	end

	-- 'No idea what this does.'
	eventData = { os.pullEventRaw() }
  end
end

-- 'Uses the create() function recursively to build an array of coroutines.'
-- 'It then runs the coroutines until any one of them terminates.'
function waitForAny( ... )
  local routines = { create( ... ) }  
  return runUntilLimit( routines, #routines - 1 )
end

-- 'Uses the create() function recursively to build an array of coroutines.'
-- 'It then runs the coroutines until all terminate.'
function waitForAll( ... )
  local routines = { create( ... ) }
  runUntilLimit( routines, 0 )
end

local fuelMatchSlot=16  -- Slot holding Fuel
local fuelMin = 10	  -- Fuel leverl to trigger refuel
local fuelRefill = 50   -- Refuel to this amount
local seedMatchSlot=15  -- Slot holding Seed to plant

-- Determine Mode and start coroutines
function main( tArgs )
  local fHandler
  local cmds = ""
  local coGo
  local coFuel
  local status
  local yy

  -- Verify Command Line Arguments were correct
  if #tArgs < 1 then
	print( "Usage: work <routefile>	 -or-" )
	print( "	   work <command> <command> ... etc	-or-")
	print( "	   work program")
	return false
  end

  if #tArgs == 2 and tArgs[1] == "program" then
	interactiveMode(tArgs[2])
	return
  end
	-- test if we have a filename or a command
  if fs.exists(tArgs[1]) then
	fileOrCmds = "file"
  else
	fileOrCmds = "cmds"
  end

  -- Read in our command list from the file
  if fileOrCmds == "file" then
	if fs.exists(tArgs[1]) then
	  fHandler = fs.open(tArgs[1],"r")
	  if fHandler then
		cmds = fHandler.readAll
	  end
	end
  else -- Read in our commands from the command line
	-- Convert from a table into a space separated list
	for i,v in ipairs(tArgs) do
	  if cmds == "" then
		cmds = v
	  else
		cmds = cmds .. " " .. v
	  end
	end
  end

  -- Create our Coroutines
  coGo = coroutine.create(go)
  coFuel = coroutine.create(fuelManager)

  -- Continuously resume coroutines in sequence as they yield
  while true do

	-- Start/Resume our Go coroutine
	yy = coroutine.resume(coGo,cmds)
	if yy == false then
	  print("Coroutine Go Reports error")
	  print("Status: " .. coroutine.status(coGo))
	end
	-- If the coroutine has terminated, then exit our loop
	if coroutine.status(coGo) == "dead" then
	  break
	end

	-- Start/Resume our Fuel coroutine
	yy = coroutine.resume(coFuel)
	if yy == false then
	  print("Coroutine Fuel Reports error")
	  print("Status: " .. coroutine.status(coFuel))
	end
	-- If the coroutine has terminated, then exit our loop
	if coroutine.status(coFuel) == "dead" then
	  print("Out of Fuel")
	  break
	end
  end
  return true
end

-- Interactive Mode
function interactiveMode(saveFile)
  term.clear()
  print("Welcome to Interactive Mode")
  print("Instructions enter one command per line, followed by the enter key.")
  print("The turtle will execute the instructions and the instructions will")
  print("be recorded to the file '" .. saveFile .. "'.")
  print("")
  print("Enter the command 'end' to stop")
  print("")
  local fHandler = fs.open(saveFile,"a")
  while true do
	write("Command: ")
	cmd = io.read()
	if go(cmd) then
	  if string.lower(cmd) == "end" then
		break
	  end
	  fHandler.writeLine(cmd)
	end
  end
  fHandler.close()
end

-- Checks fuel status on predictable intervals
function fuelManager()
  local currentFuelLevel = 0
  local avgFuelConsumptionPerSecond = 1
  local estFuelLife = 0

  --- Keep this function active continously
  while true do
	--- Assess current Fuel Level
	currentFuelLevel = turtle.getFuelLevel()
	---   If fuel near Min level, then we need to refuel up to refuel level
	if currentFuelLevel <= fuelMin then
	  return false
	end
	--- Calculate approximate time until earliest fuel low warning
	estFuelLife = (currentFuelLevel * avgFuelConsumptionPerSecond)
	--- Sleep for half that time (coroutine should yield here)
	os.sleep(math.floor(estFuelLife/2))
  end -- endless loop
end

-- Processes a series of instructions
function go(cmds)
  local tArgs = { }
  local cmd = ""
  local nPos = 1
  local nCmd = 1
  local c = ""

  -- Convert List of cmds into a table
  while nPos < #cmds do
	c = string.sub(cmds,nPos,nPos)
	if c == " " then
	  if cmd ~= "" then
		tArgs[nCmd] = cmd
		cmd = ""
		nCmd = nCmd + 1
	  end
	else
	  cmd = cmd .. c
	end
	nPos = nPos + 1
  end
  if cmd ~= "" then
	tArgs[nCmd] = cmd
  end

  -- If no commands were found in the table then exit
  if #tArgs < 1 then
	print("No arguments given to go")
	return false
  end

  -- These are our defined handlers.   Each handler is defined with a condition and an action.
  -- before an action is executed, a condition must be met
  -- successful actions, will deducated distance values.  
  -- Failed conditions or actions will set distance to 0
  local tHandlers = {
		-- Forward, Back, Up, Down
		["F"] = { condition=function() return true end, action=turtle.forward },
		["B"] = { condition=function() return true end, action=turtle.back },
		["U"] = { condition=function() return true end, action=turtle.up },
		["D"] = { condition=function() return true end, action=turtle.down },
		-- Left, Right
		["L"] = { condition=function() return true end, action=turtle.turnLeft },
		["R"] = { condition=function() return true end, action=turtle.turnRight },
		-- Dig Over, Dig uNder
		["O"] = { condition=turtle.detect, action=turtle.digUp },
		["N"] = { condition=turtle.detect, action=turtle.digDown },
		-- Plant, Eject
		["P"] = { condition=function() return not(turtle.detectDown()) end, action=plantSeed },
		["E"] = { condition=function() return true end, action=dropExtras }
	  }

  -- Iterate for each command present
  local nArg = 1
  local sCmd = ""
  for nArg,sCmd in ipairs(tArgs) do
	local nDistance = 1
	-- Determine the Distance for the command
	if #sCmd > 1 then
	  local num = tonumber(string.sub(sCmd, 2))
	  if num then
		nDistance = num
	  else
		nDistance = 1
	  end
	else
	  nDistance = 1
	end
	sOperation = string.sub(sCmd,1,1)

	-- Use the function handler that corresponds with the command
	local fnHandler = tHandlers[string.upper(sOperation)]
	if fnHandler then
	  -- Set our condition and action functions
	  local condition = fnHandler["condition"]
	  local action = fnHandler["action"]
	  -- Repeat based on distance
	  while nDistance > 0 do
		local status = false  -- whether condition and action both returned true
		if condition() then
		  if action() then
			status = true
		  end
		else
		  status = true
		end
		-- If the action did not succeed, lets check some common reasons
		if status == false then
		  -- Out of Fuel?
		  if turtle.getFuelLevel() == 0 then
			print( "Out of fuel" )
			return false
		  else
			-- Best report his even though it may correct itself in half a second
			print(string.upper(sOperation) .. " returned error")
			sleep(0.5)
		  end
		else  -- action DID succeed, so lets reduce distance
		  nDistance = nDistance - 1
		end
	  end  -- while distance > 0
	else  -- if there was no valid function handler found ...
	  print( "No such Handler: " .. string.upper(sOperation) )
	  return false
	end
  end -- Process Next Command
  return true
end

-- Finds a seed in our inventory and plants it
-- Should be clear that there needs to be an empty block below in order to properly plant
function plantSeed()
  local slotNumber = 0
  local itemCount = 0
  local attempt = 0
  local seedItem = false

  for slotNumber=1,16 do
	-- There is a goto command in the new beta Lua .. cannot wait
	local skipIt = false
	while skipIt == false do
	  skipIt = true
	  if (slotNumber ~= fuelMatchSlot) and (slotNumber ~= seedMatchSlot) then
		-- See if there is any items in the slot
		itemCount = turtle.getItemCount(slotNumber)
		if itemCount == 0 then
		  -- goto skipIt
		  break
		end

		-- Select the Slot
		while turtle.select(slotNumber) == false do
		  attempt = attempt + 1
		  if attempt == 3 then
			print("Unable to Select Slot#" .. slotNumber)
			return false
		  end
		  -- Lets wait - maybe it will clear up
		  -- We will only make 3 attemps though
		  sleep(5)
		end

		-- Compare it to our seed slot
		seedItem = turtle.compareTo(seedMatchSlot)
		if not seedItem then
		  -- goto skipIt
		  break
		end

		-- We found a seed item - lets plant it
		if not turtle.placeDown() then
		  print("Could not place seed")
		  return false
		end
	  end  -- slot <> seedslot condition
	end -- while
	-- ::skipit::
  end  -- next slot number
  return true
end

-- Drops all items that are "extra"
-- at the time of writing, that means anything not fuel or seed
function dropExtras()
  local slotNumber = 0
  local keepItem = false
  local itemCount = 0
  local attempt = 0

  -- iterate through our slots
  for slotNumber=1,16 do
	-- Can remove these two lines when LUA gets a GOTO statement
	local skipIt = false
	while skipIt == false do
	  if (slotNumber ~= fuelMatchSlot) and (slotNumber ~= seedMatchSlot) then
		-- See if there is any items in the slot	
		itemCount = turtle.getItemCount(slotNumber)
		if itemCount == 0 then
		  -- goto skipIt
		  break
		end

		-- Select the Slot, give up after 3 attempts
		while turtle.select(slotNumber) == false do
		attempt = attempt + 1
		  if attempt == 3 then
			print("Unable to Select Slot#" .. slotNumber)
			return false
		  end
		  sleep(5)
		end  

		-- Is it an extra?
		keepItem = (turtle.compareTo(fuelMatchSlot) or turtle.compareTo(seedMatchSlot))
		if keepItem then
		  -- goto skipIt
		  break
		end

		-- We found an extra item - lets drop it
		turtle.dropDown()
	  end  -- valid slot check
	end  -- while loop
	-- :: skipIt ::
  end  -- next slot number
  return true
end

function reFuel()
  local slotNumber = 0
  local fuelItem = false
  local itemCount = 0
  local attempt = 0

  for slotNumber=1,16 do
	-- Remove these two lines when LUA gets a goto statement
	local skipIt = false
	while skipIt == false do
	  skipIt = true
	  if not (slotNumber == fuelMatchSlot) then

		-- See if there is any items in the slot	
		itemCount = turtle.getItemCount(slotNumber)
		if itemCount == 0 then
		  -- goto skipIt
		  break
		end

		-- Select the Slot
		while turtle.select(slotNumber) == false do
		  attempt = attempt + 1
		  if attempt == 3 then
			print("Unable to Select Slot#" .. slotNumber)
			return false
		  end
		 sleep(5)
		end

		-- Compare it to our fuel slot
		fuelItem = turtle.compareTo(fuelMatchSlot)
		if not fuelItem then
		  break
		end

		-- We found a fuel item - lets refuel to the refuel limit
		while turtle.getFuelLevel() < fuelRefill do
		  -- Attempt to Refuel with one unit
		  attempt = 0
		  while turtle.refuel(1) == false do
			attempt = attempt + 1
			if attempt == 1 then
			  print("Unable to refuel from slot #" .. slotNumber)
			end
			if attempt == 3 then
			  break   -- give up on this slot
			end
			os.sleep(1)
		  end

		  -- If this slot does not appear to refilling then skip the slot
		  if attempt == 3 then
			break
		  end

		  -- Keep refueling until we reach our refill level
		end  -- While Refueling
	  end  -- slot <> fuelslot condition
	  -- if we have refueled sufficiently, lets stop checking slots
	  if turtle.getFuelLevel() >= fuelRefill then
		break
	  end
	end  -- end while loop
  end  -- next slot number

  -- Return Refuel success
  if turtle.getFuelLevel() < fuelRefill then
	return false
  else
	return true
  end
end

local tArgs = { ... }

main(tArgs)

print("Finished")