Create machines

Some of Create's blocks do more for a computer than turn. A Creative Motor and a Rotation Speed Controller take a new speed, the Speedometer and the Stressometer hand over their readings, a Sequenced Gearshift turns by the angle the program asks for, and a Sticker comes out or goes back in. Each one has a peripheral type of its own:

local motor = peripheral.find("creative_motor")
motor.set_generated_speed(128)

#Setting up

Reaching them. Like every device, a block against the computer is called by its side ("left", "back"...), and a block against a Data Cable (Minicomputer and newer) gets a name such as sequenced_gearshift@120,64,-35. The easiest is peripheral.find with the type of the table. See Peripherals.

They turn, too. Every block of this page except the Sticker is also a Create kinetic block, with speed(), stress(), capacity() and overstressed() on top of its own methods. Its type, and its name on a cable, stays the one of the table.

Changes at the end of the tick. A new speed for a motor or a controller, or a new move for a gearshift, rebuilds Create's kinetic network. The computer does not do it on the spot: it notes the request and applies it at the end of the program's tick, once per block, with the last value asked. A loop that calls set_generated_speed a thousand times in one tick costs the world a single update. Two things follow:

• reading right after, in the same tick, still gives the old value: sleep(0.05) waits one tick;
• two moves asked of a gearshift in the same tick do not add up: only the last one runs.

The Sticker is the exception: it moves at once.

When it fails. When the block is broken or replaced, its methods stop the program with creative motor removed (speed controller removed, sequenced gearshift removed...). When its chunk is not loaded: peripheral is not loaded.

#Rotation

local motor = peripheral.wrap("back")
print("motor set to " .. motor.generated_speed() .. " RPM")

local motor = peripheral.find("creative_motor")
for rpm = 16, 256, 16 do
  motor.set_generated_speed(rpm)
  print(rpm .. " RPM")
  sleep(2)
end
motor.set_generated_speed(0)

local ctrl = peripheral.wrap("right")
print("target: " .. ctrl.target_speed() .. " RPM")

local ctrl = peripheral.wrap("right")
while true do
  local rpm = math.round(rs.get("left") / 15 * 128)
  if rpm ~= ctrl.target_speed() then
    ctrl.set_target_speed(rpm)
  end
  sleep(0.5)
end

#Gauges

A Speedometer and a Stressometer show their readings on a dial; the computer gets the same numbers.

local speedo = peripheral.find("speedometer")
rs.set("top", math.abs(speedo.speed()) < 32)   -- a lamp when the line runs slow

local gauge = peripheral.find("stressometer")
local cap = gauge.capacity()
if cap > 0 then
  print(string.format("load %d %%", math.floor(gauge.stress() / cap * 100)))
else
  print("nothing drives this network")
end

#Sequenced Gearshift

In Create, a Sequenced Gearshift runs a list of instructions set in its screen each time it gets a redstone pulse (Redstone and Create links). A program gives it one move at a time instead, with the angle or the distance it wants, then waits for the end.

Between two moves the output stands still, like a gearshift at the end of its list. The input shaft must turn: the gearshift passes its rotation to the output just long enough to cover the angle or the distance.

local gear = peripheral.find("sequenced_gearshift")
gear.rotate(90)        -- a quarter turn

local gear = peripheral.find("sequenced_gearshift")
gear.move(4)          -- the piston pushes the wall out by 4 blocks
sleep(10)
gear.move(4, -1)      -- and pulls it back

local gear = peripheral.find("sequenced_gearshift")
gear.rotate(180)
sleep(0.05)              -- the move starts at the end of the tick
while gear.running() do
  sleep(0.1)
end
print("half a turn done")

#Sticker

A Sticker glues the block in front of it while it is out. On a moving contraption (a piston, a bearing, a gantry), that block then travels with it, and stays behind once the Sticker is back in. A redstone pulse toggles it in Create; a program uses the methods below, which act at once, not at the end of the tick.

local sticker = peripheral.find("sticker")
print(sticker.extended())

local sticker = peripheral.find("sticker")
sticker.extend()
if not sticker.attached() then
  print("nothing to pick up")
end

#Examples

#A line that eases off before overstress

A Rotation Speed Controller drives a row of Mechanical Presses, and a Stressometer sits on the same network. When the load passes 90 %, the program slows the line by 16 RPM; below 70 %, it speeds it back up, up to 128 RPM. The presses never stop on an overstress, they just run a little slower when the network is busy.

local ctrl = peripheral.find("speed_controller")
local gauge = peripheral.find("stressometer")
local MAX = 128
local rpm = MAX
ctrl.set_target_speed(rpm)
while true do
  local cap = gauge.capacity()
  if cap > 0 then
    local load = gauge.stress() / cap
    if load > 0.9 and rpm > 16 then
      rpm = rpm - 16
    elseif load < 0.7 and rpm < MAX then
      rpm = rpm + 16
    end
    ctrl.set_target_speed(rpm)
    print(string.format("load %d %%, presses at %d RPM", math.floor(load * 100), rpm))
  end
  sleep(2)
end

The Overstress guard recipe protects a whole factory with the generic Create kinetic blocks methods.

#Fetching a block with a Sticker

A Sticky Mechanical Piston carries a Sticker on its head and is driven by a Sequenced Gearshift. A Data Cable runs along the piston's path, so that the computer reaches the Sticker wherever it stops (its name changes with its position, so the program finds it again each time). The piston goes out 3 blocks, the Sticker grabs the block it meets, and the piston brings it back.

local gear = peripheral.find("sequenced_gearshift")

local function wait_for_piston()
  sleep(0.05)
  while gear.running() do
    sleep(0.1)
  end
  sleep(0.5)   -- the piston sets its blocks down
end

gear.move(3)
wait_for_piston()
local sticker = peripheral.find("sticker")
sticker.extend()
if sticker.attached() then
  gear.move(3, -1)
  wait_for_piston()
  peripheral.find("sticker").retract()
  print("block delivered")
else
  sticker.retract()
  print("nothing to fetch")
end

wait_for_piston can use gear because gear is a local of the chunk, not of another function.