Skalistan

This is program for robot quarry. It uses a special pattern thanks to which it is up to 40% faster than the default dig.lua. The digging pattern also stretches into infinity, so if you equip the robot with a chunk loader upgrade you never have to worry about it again. The robot also remembers its position, so it the quarry can be easily resumed.

Source code and detailed explanation can be found on Gitlab: https://gitlab.com/vitSkalicky/oc-column-quarry

Usage

1. Assemble a robot (see Robot requirements below).
2. Set up power, tool supply, etc. (see Setup below).
3. Place the robot and turn it on.
4. Copy the minified program (squashed onto a single line).
5. In the robot type "edit column_quarry.lua" and paste the program (by clicking the mouse wheel or using a keybind).
6. Press ctrl+s to save the program and ctrl+w to exit editor.
7. Run the program by typing "column_quarry". See Program options below.

Robot requirements

Minimal

• Computer case tier 2
• CPU tier 1
• 2x memory tier 1
• EPPROM with Lua BIOS
• Hard disk tier 1 with OpenOS installed*
• Screen tier 1
• Keyboard
• Graphics card tier 1
• Inventory controller upgrade
• Inventory upgrade (more is better)
• Hover upgrade **

*use a computer to install OpenOS on the disk before assembling the robot, or add a disk drive to the robot (like in the screenshot).

**If you use Hover upgrade tier 1, you must start mining at y < 64, otherwise the robot will get stuck in the air. If you use tier 2 you can mine at any height.

Also note that the minimal requirements robot does not have a Chunk loader upgrade, therefore you have to load the chunks externally (by using ChickenChunks chunk loader for example)

Recommended

• Computer case tier 3
• CPU tier 1
• 2x memory tier 1
• EPPROM with Lua BIOS
• Hard disk tier 1 with OpenOS installed*
• Screen tier 1
• Keyboard
• Graphics card tier 1
• Inventory controller upgrade
• Chunkloader upgrade
• Battery upgrade
• Hover upgrade *
• Inventory upgrade (more is better)
• upgrade container for more inventory upgrades

*see Minimal requirements

Setup

Schema:

C R
  I P A A...

      
* R - Robot facing the top of schema
* C - Charger
* I - Items chest: the robot will put all mined blocks and resources here
* P - Pickaxes: robot will take fresh primary mining tools from here and will put used (almost broken) ones to a chest *on top of it*
* A - Additional tools: robot will take one tool from each chest in row. Almost broken ones will be put to a chest above. It will use these to try breaking blocks it cannot break with pickaxe (or the primary tool you supply it with). More on that later.
* The robot mines area to the top right of the schema

You can use any tool instead of pickaxe (such as a mining drill from IC2) and any inventory for items, not only chest. For example: the robot takes a charged mining drill from a batbox and it puts the discharged one into a hopper above the batbox, which pushes the discharged drill into the batbox for recharging.

The robot cannot mine cobwebs using a pickaxe (and other blocks from mods such as Magic bees hives). That's what additional tools are for. If a robot fails to mine a block using pickaxe, it will try to mine it using all the available additional tools.

The robot takes one additional tool from each chest to the right of the "pickaxe" chest. You can put as many chest you want - the robot counts how many chests there are.
 
Screenshot:

• The robot is facing away from the ender chest
• The charger is powered by a creative capacitor bank and is turned on by a lever. You can use almost any type of power, but for some you will need a power converter.
• Ender chest - mined resources will be put here
• Iron chest - robot will take fresh primary mining tools (pickaxes) from here
• Golden chest - used (almost broken) pickaxes will be put here
• Copper chests - robot will take one additional tool from each. There are three, but you can have more, less or even none.
• Diamond chest - used (almost broken) additional tools will be put here (to the one above the chest the tool was taken from)
• Red area will be mined (continues infinitely)

Mid-game setup on Direwolf 1.12.2

• I use diamond drill (IC2) instead of pickaxe, because it can be recharged.
• I also use a chainsaw (IC2)(rechargable too) for cobwebs and scoop for bee hives (Magic bees)
• Power is supplied using a geothermal generator with an ender tank hooked up to my lava pump in the nether.
• Ender chest sends mined items back to my base
• The robot will take a charged drill and chainsaw from the batbox and put the used one into the hopper which pushes the tool back to the batbox to recharge.
• The robot takes a charged drill first and then returns the used one, so I need two of them. One is being used by the robot and the other one is charging. (same for chainsaw)
• Scoops cannot be easily repaired, so I just have a ton of them.
• Don't forget to load the chunk with a spot loader and use a chunk loader upgrade in the robot.
• I use the `--alwaysChangeTool` flag so that the robot recharges the drill whenever it drops off item.

End-game setup on Direwolf20 1.12.2

• It is located in the Twilight forest dimension, because the y is lower in it (there is less stone to be mined before we get to the diamonds) and the solar cell works non-stop.
• I use EnderIO solar cell with a capacitor for power.
• There is another ender chest in my base which suck up items into my storage system and ore processing factory.
• The robot mines with an Efficiency V, Fortune III, Unbreaking III, Mending diamond pickaxe. I also use 2 additional tools: sword for cobwebs and scoop for bee hives (from Magic bees mod). Both have Mending on them as well.
• Tools are repaired in the EnderIO fluid tanks using liquid XP (tools have mending on them). I get the liquid XP from my mob farm by converting essence (Industrial foregoing) from mob crusher in fluid dictionary converter and pumping it through ender tank.
• There are always 2 identical tools of the same kind: one is being used by the robot and the other one is waiting repaired to be exchanged for the almost broken one.
• The robot takes a fresh tool from the fluid tank and puts the used tool into the hopper, which pushes it into the fluid tank, where it is repaired.

Program options

Usage

column_quarry [OPTIONS]...
column_quarry help

Arguments

• help - Displays help instead of starting the quarry.

Options

--continue

 Resumes the quarry progress on the last mined column. Useful for example if the robot got stuck and you had to break it. Just place the robot at the starting point, use this option and it will continue where it was.

--continue=n

Where *n* is the side of the already mined area. The robot will continue mining **roughly** at the end of the entered area. Useful if replacing a lost robot. If you want to replace a robot you did not lose, it is better copy the state file (see *State saving*)

--alwaysChangeTool

The robot will change its primary tool (pickaxe) every time it visits the start point, not only when it is almost broken. **Recommended when using a repairable tool** like in the example setups.

State saving

The robot saves its progress every time it finished mining a column into file named `column_quarry_state`. If you want to replace the robot, just copy the contents of this file onto the new robot and start the quarry on the new robot with the `--continue` option. I will continue, where the old robot finished.

Download and source code

Source code of this program along with more detailed description on how it works can be found here: https://gitlab.com/vitSkalicky/oc-column-quarry

PS: I'm reposting this, because the forum got reset reveral times after the first time I posted this here.

FullChest sorting storage system

This program uses a robot to sort items into simple storage system. I am using iron chests mod here. There is an input chest (golden), storage chests (iron), and an overflow chest (diamond). The robot is placed behind the input chest facing the chest and I recommend placing a charger next to it. Red blocks are always required, orange and yellow blocks are required depending on storage size (in this one, orange blocks are needed). I usually place them all to be sure. The storage chests must always be on the right from the input chest.

Each storage chest must have no empty slot! If you want a chest to contain certain items, put one of these items into a slot like this:

The robot then goes around in zig-zag pattern and tries to put each item into each chest. All chests have no empty slots, therefore only wanted items can be put into each chest - for all other items the chest is full.

If the robot is waiting on the start, it checks the input chest for new items every 10 seconds. If an item is found it will start sorting in 1 minute (except for the first check - then it si immidiet).

Program

also in attachments

robot = require("robot")
os = require("os")
computer = require("computer")

totalSlots = robot.inventorySize()

function dropAll(slots)
    for i = 1, slots, 1 do
        robot.select(i)
        robot.drop()
    end
    robot.select(1)
end

function suckAll()
    count = 0
    while robot.suck() do
        count = count + 1
    end
    return count
end

-- direction false - left
-- direction true - right
function next(direction)
    if not direction then
        robot.turnLeft()
    else
        robot.turnRight()
    end
    b = robot.forward()
    if not direction then
        robot.turnRight()
    else
        robot.turnLeft()
    end
    return b
end

while true do
    first = true
    while robot.suck() == false do
        print("check")
        first = false
        os.sleep(10)
    end
    robot.drop()
    print("Sorting is starting...")
    if not first then
        print("in 60 seconds...")
        os.sleep(60)
    end
    print("now!")
    usedSlots = suckAll()

    if usedSlots > totalSlots then
        usedSlots = totalSlots
    end

    direction = false

    robot.turnLeft()
    robot.forward()
    robot.forward()
    robot.turnRight()


    while true do
        dropAll(usedSlots)
        while next(direction) do
            dropAll(usedSlots)
        end
        print("end of row")
        if not robot.up() then
            -- last row
            print("end of sorting")
            robot.turnRight()
            while robot.forward() do end
            robot.turnLeft()
            dropAll(usedSlots)
            while robot.down() do end
            dropAll(totalSlots) -- just to be sure
            break
        end
        direction = not direction
    end
end

sorter.lua