Trains

A computer next to a Create Train Station knows which train stands at the platform, which one is coming, and where it could go from there. It renames trains, reads and writes their schedules, and assembles or takes them apart. Train Signals and Train Observers tell it what happens along the line. With them, a program runs a depot, a passenger board or a whole timetable.

local st = peripheral.find("station")
if st.train_present() then
  print(st.train_name() .. " stands at " .. st.name())
end

#Setting up

Three blocks. The Train Station is a peripheral of type station, the Train Signal of type signal, the Train Observer of type track_observer. Put one against a face of the computer, or against a Data Cable of its network (Minicomputer and newer, named like station@120,64,-35), then wrap it: peripheral.wrap("left"), or peripheral.find("station"). See Peripherals.

On a track. A station or a signal only works once it is placed against a track, the way Create places it (right-click the track with it first). Otherwise the station stops the program with station is not connected to a track, and the signal with no signal: place it against a track.

Trains are shared. A train belongs to the whole server: a name or a schedule a program changes is seen at once by every player and every other station.

The train at the platform. Many methods work on the train standing at the station. When there is none, they stop the program with there is no train present: ask train_present() first.

No events: ask in a loop. Create's own ComputerCraft peripherals send events (train_arrival, train_passing...). Brass has no peripheral events: a program asks again and again, with a short sleep between two questions. Half a second is plenty for trains.

local st = peripheral.find("station")
while not st.train_present() do
  sleep(0.5)
end
print(st.train_name() .. " has arrived")

To do other work meanwhile, see the main loop. When a block is broken, its methods stop the program with station removed, signal removed or track observer removed, and with peripheral is not loaded when its chunk is not loaded.

#The station

local st = peripheral.find("station")
print("Welcome to " .. st.name())

local st = peripheral.find("station")
while true do
  rs.set("top", st.train_imminent())  -- a lamp above the computer
  sleep(0.5)
end

local st = peripheral.find("station")
if st.train_present() then
  st.set_train_name("Iron Express")
end

#Schedules

A train follows its schedule, the one written in a Train Schedule: a list of stops, each with the conditions to wait for before leaving. A program reads it as a table, and gives a new one to the train at the platform. The table has the shape of Create's own schedule data, with its keys in snake_case (the same shape as Create's ComputerCraft peripheral):

local schedule = {
  cyclic = true,
  entries = {
    {
      instruction = {id = "create:destination", data = {text = "Iron Mine"}},
      conditions = {
        { {id = "create:delay", data = {value = 20, time_unit = 1}} },
      },
    },
    {
      instruction = {id = "create:destination", data = {text = "Smeltery"}},
      conditions = {
        { {id = "create:idle", data = {value = 5, time_unit = 1}} },
      },
    },
  },
}

• cyclic: true starts again from the first entry after the last one; false stops the train after it.
• entries: the steps, in order. Each one has an instruction, {id =, data =}.
• conditions, for a destination: a list of groups of conditions. The train leaves as soon as one group is complete, and a group is complete when its conditions are met, one after the other. Create's screen shows each group as a column. Even a single condition sits in its own group: { {condition} }. A stop without any condition keeps the train there for good.

The usual instructions and conditions:

For any other, set it up in a Train Schedule in game, give it to a train, and look at what schedule() returns.

local st = peripheral.find("station")
if st.train_present() and not st.has_schedule() then
  print(st.train_name() .. " has no schedule")
end

local st = peripheral.find("station")
local s = st.schedule()
for i, entry in ipairs(s.entries) do
  if entry.instruction.id == "create:destination" then
    print(i .. ". " .. entry.instruction.data.text)
  end
end

local st = peripheral.find("station")
local s = st.schedule()
s.cyclic = false  -- one more trip, then stop
st.set_schedule(s)

#Where can the train go?

Before sending a train, a program can ask whether it can get there at all: a station renamed, a track broken or a signal missing is enough to cut a line. These two methods look at every station of the train's track network whose name matches a filter:

• * stands for any text, none included: "Mine*" matches Mine, Mine 2 and Mine North;
• ? stands for exactly one character: "Platform ?" matches Platform 1 to Platform 9, not Platform 10;
• everything else must be exactly the same, capitals included. A filter has 64 characters at most.

Both answer for the train standing at the platform (there is no train present otherwise), the way Create's navigation would drive it: a train that can only go forwards may not reach a station that another train could. The search through the network is what makes them costly.

local st = peripheral.find("station")
if st.can_reach("Iron Mine") then
  print("the line to the mine is open")
else
  print("no way to the mine from here")
end

local st = peripheral.find("station")
local d = st.distance_to("Quarry*")
if d then
  print("nearest quarry: " .. math.floor(d) .. " blocks")
end

#Assembling trains

In assembly mode, a station turns the bogeys and glued blocks standing on its track into a train, and takes a train apart into blocks again. These methods do what the buttons of the station's screen do.

Like a player clicking those buttons, a station changes once per tick at most: a second set_assembly_mode, assemble or disassemble on the same station in the same tick stops the program with the station already changed this tick: sleep(0) waits for the next. Put a sleep(0) between two of them.

local st = peripheral.find("station")
if not st.assembling() then
  st.set_assembly_mode(true)
  sleep(0)   -- one change per tick
end
st.assemble()
print(st.train_name() .. " is ready")

#Train Signal

A Train Signal splits the track into sections, and lets a train into the section after it only when that section is free. A program reads its light, sees which trains hold the section, and can keep it at red.

local sig = peripheral.find("signal")
if sig.state() == "red" then
  print("the section ahead is taken")
end

local sig = peripheral.find("signal")
sig.set_forced_red(true)   -- works on the line
sleep(120)
sig.set_forced_red(false)

local sig = peripheral.find("signal")
for _, name in ipairs(sig.blocking_trains()) do
  print(name .. " is in the way")
end

#Train Observer

A Train Observer watches one point of the track and gives a redstone signal while a train goes past. When an item is set in its filter, only trains carrying that cargo count.

local obs = peripheral.find("track_observer")
local count = 0
local was = false
while true do
  local now = obs.train_passing()
  if now and not was then
    count = count + 1
    print(count .. ": " .. (obs.passing_train() or "a train"))
  end
  was = now
  sleep(0.2)
end

#Examples

#An arrivals board

A computer on the platform, with no monitor: its own screen announces each train. The time comes from the world's clock (os.day_time()).

local st = peripheral.find("station")
local last_train = "The train"

local function clock()
  local t = (os.day_time() + 6000) % 24000
  return string.format("%02d:%02d", t // 1000, t % 1000 * 60 // 1000)
end

local function situation()
  if st.train_present() then return "present" end
  if st.train_imminent() then return "imminent" end
  if st.train_enroute() then return "enroute" end
  return "empty"
end

term.clear()
term.set_cursor(1, 1)
print(st.name())
local was = "empty"
while true do
  local now = situation()
  if now ~= was then
    if was == "present" then
      print(clock() .. "  " .. last_train .. " has left")
    end
    if now == "present" then
      last_train = st.train_name()
      print(clock() .. "  " .. last_train .. " at the platform")
    elseif now == "imminent" then
      print(clock() .. "  arriving: stand back")
    elseif now == "enroute" then
      print(clock() .. "  a train is on its way")
    end
    was = now
  end
  sleep(0.5)
end

The name of the train is kept in last_train while it stands at the platform: once it has left, train_name() would stop the program.

#A depot that only sends trains where they can go

Each train that stops at the depot gets a new schedule: one trip to the next mine in turn, then back to the depot. A mine whose line is cut is skipped, and when no mine can be reached, the train waits at the depot until one can.

local st = peripheral.find("station")
local DEPOT = st.name()
local MINES = {"Iron Mine", "Coal Mine", "Quarry*"}
local turn = 1

-- one stop: go to a station, wait there some seconds
local function stop(station, seconds)
  return {
    instruction = {id = "create:destination", data = {text = station}},
    conditions = {
      { {id = "create:delay", data = {value = seconds, time_unit = 1}} },
    },
  }
end

-- the next mine the train at the platform can reach, or nil
local function next_mine()
  for i = 1, #MINES do
    local mine = MINES[turn]
    turn = turn % #MINES + 1
    if st.can_reach(mine) then
      return mine
    end
  end
  return nil
end

local served = false
while true do
  if not st.train_present() then
    served = false
  elseif not served then
    local mine = next_mine()
    if mine then
      local blocks = math.floor(st.distance_to(mine))
      st.set_schedule({cyclic = false, entries = {stop(mine, 30), stop(DEPOT, 5)}})
      print(st.train_name() .. " leaves for " .. mine .. ", " .. blocks .. " blocks")
      served = true
    end
  end
  sleep(2)
end

served remembers that the train at the platform has its orders, so it gets them once. When it comes back from the mine, it stops at the depot again and the program sends it to the next mine. A train with no mine in reach is asked again every two seconds: a can_reach costs 64 instructions, a third of a tick of a Tube Computer, so do not ask at every tick.