Server/TechWelt/RobotWorld

From Minetest Wiki
Jump to navigation Jump to search

This is part of TechWelt, a server showing technical mods for educational purposes.

Robots & Machines

  • Basic_robots - a mod about programmable robots that can do almost everything.
  • Basic_machines - a mod for automation and production.

The main focus here is on basic_robots, using only a few of the machine-parts (mostly the keypad).

Robots can also generate power and craft items, so almost everything machines can do,
can be done with robots too.

Activating a robot is the main exception,
we need the keypad, clock-generator and detector for that.

Other players can look at the code inside a robot
(as opposed to machines, where the settings are only visible to the owner),
so it is easier to understand how a robot works.

It is also possible to hide the code, but that requires extra effort.

Robots-Intro

The basic-robots use the concept of a spawner + worker.

The spawner is a block that needs to be put on the ground before using,
much like a chest.
The spawner contains the robot's inventory and the source-code, as well as buttons (START, STOP, SAVE, STORAGE, etc.)
When started, a worker-robot is created ('spawned') on the spot above the spawner.

This worker executes the instructions of the code and can move around, dig, build etc.
It disappears when the program ends.

Programs that don't need to move, can run without the worker,
eg. programs that only listen+talk via chat.

Robot standalone

To get a robot, enter the chat-command:

  • /giveme basic_robot:spawner

To use, set this robot-spawner on the ground.

You cannot do this if the area is owned by someone else.

To activate the robot, rightclick the spawner, and press the START-button.
Now the robot-worker will appear on top of the spawner,
but it will do nothing because there is no program, yet.

Rightclick the spawner again, and press the STOP-button.
Enter a short program into the edit-area, such as

turn.left()

Then press the SAVE-button, and the START-button again.
The robot-worker should appear again, and turn around.

Other buttons inside the robot:

  • Storage - opens the robot's inventory (same size as a chest)
picking up the robot-spawner is not possible with items in the inventory.
  • Library - opens the robot's library (same size as a bookshelf)
The robot can read & write books here, eg. with text and/or code.
By specifying a library-position, the robot can use the library of another robot.
  • Help - shows a page with the available commands.

...

Robot with remote

Without programming, a robot can be used with a remotecontrol.
How to get, via chat-commands:

  • /giveme basic_robot:spawner
  • /giveme basic_robot:control

To use, set the robot-spawner on the ground,
and put the remote on the hotbar.

To activate the robot, rightclick the spawner, and press the START-button.

The remote has two modes, "buttons" and "edit",
that can be accessed by rightclick and leftclick onto empty space.

The buttons of the button-mode allows the robot to move around, and dig.

The edit-mode shows a small input-field for setting the id,
a bigger input-field for entering a (short) program, and a SAVE-button.

id: You can have several remotes on the hotbar, each controlling a different robot.

Without the robot-priv, you can only run two robots at the same time.

edit: enter a short program, such as

say("Hi")

Then press the SAVE-button.

When the robot is active, the program in the edit-field is executed by the robot with a leftclick.

While the edit-field has text in it, the button-mode cannot be used.


Machines-Intro

Basic_machines - a mod for automation and production.
It is possible to build an automated Factory that produces diamonds,
or any other item that can be crafted.

Constructor
This is like a special crafting-table, used to create all the other basic_machines.

How to use

  • Place it on the ground,
  • Open it with rightclick,
  • Select the type of machine you want --> it shows the needed materials
  • Put in the needed materials (eg. a wooden plank and a stick)
  • Press the CRAFT-button
  • Take out your new machine (eg. a keypad)

Machines:

  • Light - a block that gives light, can be turned on and off
  • Keypad - a big button, that sends signals to turn machines on & off
and can do much more (see next chapter)
  • Detector - can detect light, players, blocks, etc.
it can then send a signal to activate machines, open doors, etc.
  • Distributor - sends an input-signal to several other machines (up to 10 spaces away)
As opposed to mesecons, there are no wires - just a table of coordinates
  • clock-generator - periodically activates the device on top, every 5 seconds.
eg. to keep a furnace running.
  • Generator - generates powercells, that can be used as fuel
with upgrades, it can produce the more powerful powerblocks and powerrods
  • Battery - uses powercells to power other machines
eg. a mover, a grinder or a furnace on top of the battery
  • Mover - can move everything
eg. it can move powercells from the generator to a battery,
it can harvest trees and wheat, move stuff from chest into machines, etc.
The mover can also act as a teleporter or elevator.
  • Grinder - grind materials to dusts, which doubles the output when smelted.
see Grinder recipes
  • AutoCrafter - automated crafting. Set up a recipe, then fill in raw materials.
  • Recycler - recyle machines (yields 75% of the building materials).
  • Ball-spawner - spawn an energy ball that can activate stuff
  • Environment - change physics settings (e.g. gravity) and the skybox

...

Lights & Keypad

The light is a simple block that gives light, and can be turned on and off (eg. with a keypad).

The keypad is a big button that can send a signal to another block.
It is very versatile, as it can be used to enter text, enter passwords,
write text on blocks (eg. on signs or chests), repeat a signal several times, play sounds, etc.

In combination with robots, the main use of keypads is to allow other players to activate a robot.

Normally, only the owner can start a robot.

...

Robot-Tutorial - Overview

## Title command introduced
01 Hallo say(), turn.DIR(), --
where DIR is one of left, right, angle
02 Hallo2 self.remove(), var
03 robots-version ..
04 more-output self.label(), self.display_text(), if, \n
05 TimeDate os.date(), write_text.DIR()
where DIR is one of forward, backward, up, down, left, right, forward_down ...
06 Greeter find_player()
07 look-around read_node.DIR()
08 chest-inventory for, check_inventory.DIR()
check_inventory can also use the DIRection 'self', to look are the robot's inventory
09 furnace-feeder1 take.DIR(), insert.DIR()
10 pickup() self.display_text()
11 Teleporter puzzle, find_player()
12 Keyboard-button-maker keyboard.set()
13 dig self.reset()
14 dig & place function()
15 mini-farmer function()
16 x y
  • #16 - chat-listener / self.listen()
  • #17 - Builder /
  • #18 - Demolisher / {} table of functions
  • #19 - move-demo / string.find()
  • #20 - Color-Tower
  • ...

Robot #01 - Hello

The robot outputs the text "Hallo" via chat, and turns on the spot.
This repeats until it is turned off, or another robot with the same id is started.

-- #1 Hallo --

-- Programm wird jede Sekunde neu ausgefuehrt
-- daher wiederholt sich die Ausgabe, und Robot dreht sich.

say("Hallo")

turn.left()
  • Text after -- is a comment, and is ignored.
  • The command say() is for text-output (like 'print()' in other languages)
  • turn.left() lets the robot-worker turn by 90 degree.

Robot #02 - Hello2

This program uses a string-variable for the output,
and adds a command to stop the execution.

-- #2 Hallo2 --

-- Programm wird jede Sekunde neu ausgefuehrt

msg="Hallo"
say(msg)

say("und Tschüss !")
self.remove()  -- stop
-- aber hier ist gleich nach dem ersten Durchlauf Schluss
  • The command self.remove() removes the worker, and stops the program.
see also 'self.spam()', below

Robot #03 - robot-version

This shows the installed version of the basic_robots - mod.

-- #3 robot-version --

v=robot_version()
say("robot version="..v)  -- .. verbindet strings
self.remove()
  • robot_version() is a built-in function, that returns a string with the version-number.
  • v is a variable, that gets assigned the result of the function robot_version().
in lua, each variable can contain everything (number, text, table ...)
  • '..' is an operation used to concatenate two strings.

Robot #04 - more output

This demonstrates some more ways a robot can show output.

-- #4 more-output --

if not i then i=0  -- nur einmal
  turn.left()     -- face to user
  say("Hallo")
end

-- ab hier werden die Befehle wiederholt:

i=i+1
self.label(i)  -- Anzeige in gruen, ueber dem Robot

if i==4 then 
  msg="ab jetzt  vorn mit  Text-\nAnzeige"  -- \n : newline
          --123456789+123456789+
  say(msg)
  self.display_text(msg,10,1)  -- Text-Anzeige anstelle des 'Gesicht'
end

--if i>6 and i<15 then  turn.right() end

if i>20 then 
  say("Stop")
  self.remove() 
end
  • if -- compare values, then depending on the outcome, execute some code
  • self.label(i) -- show that number i as a text floating above the robot
  • self.display_text(msg,10,1) -- show the text from variable msg on the 'face' of the robot
10 is the lenght of each line on that display
1 is the size for the display - 1 is normal, 2 means 'double size'.

Robot #05 - TimeDate

Shows the current time and date, and writes text on other blocks.

-- #5 TimeDate --

self.label("TimeDate")  -- program runs too short for this to be visible
 
td = os.date("%Y-%m-%d  %H:%M:%S")
msg = "Time and date"
say(msg..": "..td)
 
ok=write_text.up(msg)  -- label the button above the robot
ok=write_text.down("This robot was last run: "..td)  -- write text on cpu-box
 
self.remove()  -- stop program

To see the text written on the blocks, point at it with the crosshair (just like signs).

  • os.date() -- call the operating-system, to return a number that represents the time & date
the string inside the brackets specifies how you want to format that information,
e.g. "YEAR-MONTH-DAY HOUR:MINUTE:SECOND"
  • write_text.up() -- write text on the block above the robot
  • write_text.down() -- write text on the block below the robot

Robot #06 - Greeter

This gets the names of all nearby player, and greets them via chat.

-- #6 Greeter --

if not pn then pn="Greeter" 
  p=find_player(5)
  if p==nil then say("Hallo, niemand da?"); self.remove() end

  n=#p; --say(n)
  msg="Hi "
--  if p==nil then s="Hello !" else s="Hello "..p[1].." !"  end
  for i=1, n do
    msg=msg..p[i].." "
  end
    msg=msg.."!"
  say(msg)

end
--
self.remove()
  • find_player(5) -- returns a table of playernames
  • nil -- a special value for 'nothing'
  • #p -- the length of the table p (= how many entries the table has)
  • for i=1, n do -- a loop that runs for all values from 1 to n
that is, once for every player that was detected

Robot #07 - look around

This robot turns around, looks at the surrounding blocks, and outputs their names.
It also counts the (quarter-)turns and stops after 4 have been done.

-- #7 look around --

if not i then i=0 end

n=read_node.forward()
say(i..": "..n)

i=i+1
if i>=4 then self.remove() end

turn.left()
  • say()
  • read_node.forward()

Robot #08 - list chest-inventory

Lists the items in the first 5 slots of the chest.

list only 5 items, so the chat-text doesn't scroll off
-- #8 list chest-inventory --

if not i then i=0 
  say("Inhalt der Kiste:")  -- "Contents of chest:"
end

for i=1,5 do
  m = check_inventory.forward("","main",i)
  say(i..": "..m)
end

self.remove()
  • check_inventory -- look at the "main"-inventory inside the block in front of the robot
and return the name from the item contained in slot number i
  • for i=1,5 do -- loop that repeats with i set to the values 1, 2, 3, 4, 5.

Robot #09 - furnace-feeder

The robot takes cobblestones and coal from the chest,
puts them into the furnace
and activates the furnace so it starts to burn.

A lump of coal burns long enough to turn 13 cobble into stone.

-- #9 furnace-feeder --

m="default:cobble 13"
ok = check_inventory.forward_down(m,"main")
if ok then
  take.forward_down(m)
  insert.backward(m,"src")
else
  say("no "..m);  self.remove()
end

m="default:coal_lump"
ok = check_inventory.forward_down(m,"main")
if ok then
  take.forward_down(m)
  insert.backward(m,"fuel")
else
  say("no "..m);  self.remove()
end

activate.backward(1)
say("Furnace activated")
self.remove()
  • take.DIR()
  • insert.DIR()
  • activate.DIR()
  • DIR

The furnace has 3 different inventories:

  • src - "source" : for input-material (eg. cobble, ore, flour)
  • dst - "destination" : for the output (eg. stone, ingots, etc.)
  • fuel - for fuel (eg. wood, coal, etc.)

Robot #10 - Pickup

Collecting loose stuff, such as saplings that drop from trees,
or eggs dropped by chicken.

-- #10 pickup --

if not pn then pn="Pickup" 
  self.spam(1)  -- allow more than 1 output via say()
  p=0  -- counter
  turn.left();
  self.display_text(pn,10,1)
end

m=pickup(8) -- range 8, if successful returns a table of the items picked up
if m then 
  --say( serialize(m) )  -- easy way to output any datatype
  for i=1,#m do 
    say( "picked up: "..m[i] ) 
  end
  p=p+1
end

self.label(p)
  • self.spam() -- allow more than 1 output via say() to be seen by other players
  • pickup() -- picks up 'loose items', eg. saplings that drop when harvesting a tree
  • m -- the table returned by pickup()
  • #m -- length of table m
  • m[i] -- the element of the table m, at position i
  • serialize(m) -- returns a representation of m, as a printable string

Robot #11 - Teleporter

Teleport a player.
This robot needs the puzzle-priv.

-- #11 Teleporter--

--puzzle.get_player('hajo'):move_to({x=-23,y=26,z=-990})
--    1,2,33    Starter-Bay
--    0,3,75    House
--    4,26,-994 Robot&Machines
-- 1755,45,699  Mese-Welt

if not pn then pn="Teleporter" 
  p=find_player(4)
  if p==nil then say("Come closer!"); self.remove() 
  else
    n=p[1];   --say(n)
    puzzle.get_player(n):move_to( {x=-23,y=26,z=-990} )
  end
end

self.remove()

Short version:

puzzle.get_player('hajo'):move_to({x=-23,y=26,z=-990})
  • pn -- short for program_name
  • find_player(4) -- returns table of player-names within range 4
  • p[1] -- first element of table p --> name of first player found within range
  • puzzle.get_player(n):move_to() -- gets a handle to the player with name n, then moves /teleports him to the target-location
  • {x=-23,y=26,z=-990} -- a table with elements x,y,z, designating the target-location.

Robot #12 - Buttonmaker1

Create a single keyboard-button.
See also robot #13.

-- #12 simple Buttonmaker--

-- make 1 button at the position of the robot-worker
p = self.pos();
c = 3  -- 1=white 2=grey 3=red 4=green 5=blue 6=yellow 7-16="0"-"9" 17=black

keyboard.set(p,c)
--
self.remove()
  • self.pos() -- returns the position of the robot-worker
At the start of the program, this is the space above the spawner
  • keyboard.set(position,color) -- create a keyboard-button
The position must be within range 10 of the spawner

Originally, these keyboard-buttons were designed as an input-device,
that the robot can monitor for keypresses.

But keyboard-buttons can also be used as a cheap building material.

Robot #13 - dig

Dig the keyboard-button created by robot #12, and puts it into the chest above the worker.

-- #13 dig--

move.forward()

ok=dig.forward()
if ok then say("ok") else say("fail") end
--say( serialize(ok) )

self.reset()
m = check_inventory.self("","main",1);  -- say(m)
insert.up(m)

self.remove()
--
  • dig.DIR() --
  • self.reset() -- moves the worker back to its position when the program started
  • check_inventory.self() -- check the robot's own inventory
  • insert.DIR() -- put stuff into a container

Note: the robot can dig only one item per turn, and digging stone might also need energy.

Note: the robot can dig its own spawner, thereby destroying it. AVOID THIS !

Robot #14 - dig & place

This robot digs the block of cobblestone at one side,
and places the same block on the other side of the spawner.

This will not work with some types of blocks:

  • stone - digging stone can be configured to require energy, and the robot has none, yet.
  • clay - digging a block of clay turns it into 4 clay-lumps.
  • liquids - the robot cannot dig water or lava.
  • mobs - mobs are no blocks, but entities - so digging is not possible.
-- #14 --
-- !! Don't use stone, or clay for this demo !!

function t2()  -- a simple function
  turn.left(); turn.left();
end

if not i then i=0 
  say("dig & place")
end

n=read_node.forward();  say(n)
if n~="air" then
  dig.forward()
  t2()
  place.forward(n)
end

i=i+1
t2()

if i>1 then
  self.remove()
end
--
  • ~= -- compare for 'not-equeal'
comparison-operators are ==, ~=, <, >, <=, >=
  • place.DIR(m) -- build a block of material m in direction DIR
  • function t2() -- defines a function, here without parameters, and without return-value.
This is just to show how a simple function is used.

Robot #15 - mini-farmer

Wheat grows from wheat-seeds planted on soil, and needs water nearby.

Here, we have one space with a watersource, and
4 spaces around that for planting and harvesting wheat,

-- #15 --
if not pn then pn="mini-farmer"; 

  function fwd(c9)
    for i=1,c9 do
      ok=move.forward()
    end
    return ok
  end

  function init() -- needs to be defined before first call
    say(pn)
    t=0
    air ="air"
    soil="farming:soil_wet"
    seed="farming:seed_wheat"
    ripe="farming:wheat_8"
    crop="farming:wheat"

    turn.left()
    _=fwd(3)   -- here, we don't need the result. 
  end

  init()
end
 
function work()
  pickup(8)

  nd=read_node.forward_down()
  nf=read_node.forward(); 
  say(t.." work: " .. nf.." - "..nd)

  if nf==ripe then  say("harvesting")
    dig.forward()
    return  -- done for now
  end
  if nf==air and nd==soil then  say("planting")
    place.forward(seed)
    return
  end

  turn.right(); t=t+1
--return 
end

work()
if t>=4 then say("stop"); self.remove() end

The robot moves to the space over the watersource,
then turns around to reach the 4 spaces growing wheat.

Soil is made from dirt with a hoe near water,
this must be done by the player.

In this example, we don't need the return-values of the functions.
So we use a dummy-variable _.

Robot #16 - chat-listener

This robot listens to the chat, and report who said what.
If someone says 'stop', the program ends.

if not pn then pn="chat-listener"; say(pn)
   self.listen(1)
   self.spam(1)
end

speaker, msg = self.listen_msg()
if msg then 
  say( "["..speaker.."] said >>"..msg.."<<")
end

if msg=="stop" then
  say("Bye !")
  self.remove()
end
--
  • the function self.listen_msg() returns a result that consists of 2 values
the name of the player that speaks, and his text

Robot #17 - Builder

This robot builds a small, phonebooth-sized house around the spawner.
It needs the building-materials in its inventory (but doesn't check).

 if not pn then pn="Instant shelter v1.7"  say(pn)
   pickup(8)
   i=0
   m0="default:dirt"  m1="default:glass" m2="default:cobble"
   m8="default:sand"  m9="default:torch"  
   mS=m0  mC=m2   -- material for sides and corners
 end
 
  i=i+1; say(i)
  if i<100 then
    dig.forward(); move.forward()
    place.right(mC)
    move.backward()
    place.forward(mS)  
    turn.left()
  end
 
  if i== 4 then move.up()  place.down(m8)  mS=m1 end
  if i== 8 then move.up()  place.down(m8)  mS=m0 end
  if i==12 then 
    place.up(m1); 
    i=100
  end
  if i==101 then 
    dig.down(); move.down()
    place.up(m9); 
  end
  if i>=102 then
    dig.down(); 
    say(pn .." done.");  self.remove()  
  end
--

As shown above, the robot uses cobble for the corners and dirt for the sides of the house.
The center of the sides are built with a block of glass.
Also, a single block of glass is placed as a roof, with a torch beneath.
The robot uses sand as filler, so it can move up more than one space above the ground.

The player can stand on the spawner before starting the program.
To get out, simply dig the glass and dirt from one of the sides.

Robot #18 - Demolition

This is a turtle-bot, with a script for digging the building made by robot #17.

--
if not pn then pn="DemoliTurtle v1b"
 s = "-f<->>-<"
 s3=s..s..s
 script = "i@"..">ff"..s3 .."@>uff-"..s3  -- demolish levels 0 & 1

 cmds = {
  ["f"] = function() move.forward()  end,
  ["b"] = function() move.backward() end,
  ["l"] = function() move.left()  end,
  ["r"] = function() move.right() end,
  ["u"] = function() move.up()   end,
  ["d"] = function() move.down() end,
  ["<"] = function() turn.left()  end,
  [">"] = function() turn.right() end,
 
  ["-"] = function() dig.forward() end,
  ["_"] = function() dig.forward_down() end,
  ["^"] = function() dig.up() end,
  ["v"] = function() dig.down() end,
 
  ["@"] = function() self.reset(); pickup(8) end,
  ["i"] = function() say(pn) end,
  ["!"] = function() say("Hello") end,
 }
 n=string.len(script)
 i=0; 
end
 
if i>=n then say("done."); self.remove()
else i=i+1 end
 
c=string.sub(script,i,i);   say(i.." --> "..c)
cmds[c]();
--

A turtle-bot get its instructions from a script.
Each character represents one operation, such as ">" for 'turn.right()'.

Robot #19 - move-demo

Location -6 26 -1000

This robot looks at the floor below to decide what to do.
It moves along the trench behind the spawner,
and finally activates the switch for the light.

-- #19 move-demo --

n=read_node.down()
if string.find(n,"dirt") then n="DIRT" end
say(n)

if n=="basic_robot:spawner" then   
   turn.right();   turn.right();
   move.forward() 
end

if n=="air"  then   move.down()    end
if n=="DIRT" then   move.forward() end

if n=="default:cobble" then 
  turn.right() 
  move.forward() 
end

if n=="default:stone" then 
  move.up()
  turn.right()
  move.forward() 
end

if n=="default:gravel" then 
  move.up()
  turn.right()
  activate.forward()
  self.remove() 
end
--
  • string.find(n,"dirt") -- string-operation: return the position of "dirt" within string n
see also paver-robot

Robot #20 - Color-Tower

This robot builds a tower made of keyboard-blocks, of max. height 10.
The color for each level can be specified by textinput via keypad.
Eg. entering "RGBg" means red, green, blue, gray.

--#22--
function keytype(k) 
  -- 0=air 1=white 2=grey 3=red 4=green 5=blue 6=yellow 7="0" 17=black
  return string.find("wgRGBY0123456789k",k) or 0
end

function lv(h,c)  -- build one level of the tower, at height h, in color c
  if c=="" then return end
  kt=keytype(c); --say(h..":"..c.."->"..kt)
    --sides:
    keyboard.set({x=pos.x+1,y=pos.y+h,z=pos.z  },kt)
    keyboard.set({x=pos.x-1,y=pos.y+h,z=pos.z  },kt)
    keyboard.set({x=pos.x,  y=pos.y+h,z=pos.z+1},kt)
    keyboard.set({x=pos.x,  y=pos.y+h,z=pos.z-1},kt)
    --corners:
    keyboard.set({x=pos.x+1,y=pos.y+h,z=pos.z+1},kt)
    keyboard.set({x=pos.x+1,y=pos.y+h,z=pos.z-1},kt)
    keyboard.set({x=pos.x-1,y=pos.y+h,z=pos.z+1},kt)
    keyboard.set({x=pos.x-1,y=pos.y+h,z=pos.z-1},kt)
    --center
   if h>0 then keyboard.set({x=pos.x+0,y=pos.y+h,z=pos.z  }, 0) end
end

if not pn then pn="ColorTowerBuilder"; v="0.5b";  say(pn.." "..v) -- 2018-01-13
  i=0
  pos = self.spawnpos();

  --read text from robot-spawner / written by keypad:
  b=read_text.down(); s=string.sub(b,1,8)
  if s=="overheat" then b="kgwRYGBk20" end
  if s=="overheat" then b="kgwR22B" end

  say("Buildplan:"..b)
end

i=i+1
t=string.sub(b,i,i)
lv(i, t)

--dig passages into the sides of the two bottom tower-levels:
dig.forward(); turn.right()
if i==4 then move.up() end

if i>9 then 
  say(pn.." done: "..b);
  self.remove()
end
  • string.sub(b,1,8) -- returns the substring from b, from position 1 to 8.

Robot #21 - Countdown

This program mainly just counts down, then stops.

Greeting the player, and picking up loose stuff are extras.

But the robot-spawner sits in a pit deep enough so that a player without help cannot get out.
While the program is running, the player can jump onto the robot-worker, and get out of the pit.

if not pn then pn="Countdown";  --say(pn)
  p=pickup(8)
  if p then say(pn.." pickup:"..p[1]) end

  p=find_player(2)
  if p then say("Hello "..p[1])
  else       say(pn..": no player nearby"); self.remove() end
 
  i=11
end

i=i-1
self.label(i)

if i<0 then self.remove() end
  • ...

Robot #22 - X

--todo
  • ...

Useful Robots

Some robots that might be useful in a normal game, or useful for the admin.

This would include some of the tutorial-robots too, such as the teleporter.

BigDisplay

This shows a welcome-message on a big display, plays a sound, and ends the program after a countdown.

if not pn then pn="BigDisplay"
 
  spin=function()  -- turn robot until something other than air is at its back
   for i=1,4 do
      n=read_node.backward(); --say(n)
      if n~="air" then return end
      turn.right()
    end
  end
 
  spin()
--msg="\n* Hello *"
--self.display_text(msg,9,1)

  msg="\n Willkommen\n".."    auf\n".." TechWelt !\n"
  msg=msg.."\n- -- ** -- -\n"
  msg=msg.." Welcome\n".."    on\n".." TechWelt !\n"
  self.display_text(msg,12,1)  -- 1: normal-size

  i=10
end
 
self.label(i)
i=i-1;

if i==8 then
  self.sound("dingdong",1)
  self.display_text(msg,12,2)  -- 2: double-size
end

if i==3 then
  self.sound("dingdong",1)
  self.display_text(msg,12,3)  -- 3: triple-size
end
if i<0 then self.remove() end
--
  • spin=function() -- this is another variant how to define a function
There is a torch behind the robot.
This is used to turn the robot with its display towards the player.

Mailbox

Location: 6 26 -983

This shows a dialog/formspec to the player,
for writing a message to the owner of the robot.

The messages are written into books in the robot's library.

-- from https://wiki.minetest.net/Mods/basic_robot/Programs#Mailbox
-- mail & feedback using formspec, based on rnd's mailrobot

if not pn then pn="Mailbox"  -- hajo 2017-03-07
  s=0
  daynr=os.date("%w")  -- %w : weekday [0-6 = Sunday-Saturday]
  booknr=tonumber(daynr);  -- say(daynr.."/"..booknr)
  msgsize = 2500;
  _,text = book.read(booknr); text = text or "";
 
	write_msg = function(sender,msg)
		local newsize = string.len(text)+string.len(msg);
		if newsize>msgsize then return "messages space exceeded" end
		text = text .. "\n"..os.date("%Y-%m-%d %H:%M") .. " " .. sender .. ": " .. msg; 
		book.write(booknr,"messages #"..booknr, text)
	end
 
end
 
--textarea[X,Y;W,H;name;label;default]
--button[X,Y;W,H;name;label]
if s == 0 then
	players = find_player(4);
	if players and players[1] then
		s=1
		local form = "size[8,4.5]" ..
		"textarea[0,0;9,4.5;msg;YOUR FEEDBACK-MESSAGE;]"..
		"button_exit[-0.5,4.15;2,1;send;send]"
		self.show_form(players[1],form)
	end
elseif s==1 then
	sender,fields = self.read_form();
	if sender then
		if fields.send then
			msg = fields.msg;
			if msg and msg~="" then
				write_msg(sender,msg); -- activate.up(1)
				--_G.minetest.chat_send_player(sender,"#mailbot: your message has been stored")
				say("#mailbot: your message has been stored")
			end
		end
		self.remove()
	end
end
--

Paver

Location: 5 25 -995, sunk into the road

Pave a road with gravel.
The robot needs enough gravel in its inventory.

Moves straight ahead, and replaces all kinds of dirt with gravel on the ground below the robot.
Stops when movement is blocked, when it finds something other then dirt or gravel, or when it runs out of gravel for paving.

-- hajo, 2017-12-31
if not progname then progname=" paver" 
  self.spam(1)
  say("# "..progname.." started #")
  m="default:gravel"
end

ok=move.forward()
if not ok then
  say("blocked")
  self.remove()
end

n=read_node.down();  --say(n)
if n=="default:dirt"                        then n="DIRT" end
if n=="default:dirt_with_snow"              then n="DIRT" end
if n=="default:dirt_with_grass"             then n="DIRT" end
if n=="default:dirt_with_dry_grass"         then n="DIRT" end
if n=="default:dirt_with_rainforest_litter" then n="DIRT" end
say(n)

if n=="DIRT" then
  dig.down()
  ok=place.down(m)
  say("ok=".. serialize(ok) )
  if not ok then  say("empty"); self.remove()  end
elseif n==m then
  -- already done
else
  say("stop");  self.remove()
end
--
  • self.spam(1) -- allow more then one output from say() to other players
  • if .. elseif
  • ok=place.down(m) -- returns true if successful
  • serialize(ok)

Brickmaker

This is an extended version of robot #12 'simple brickmaker':
It makes a set of keyboard-buttons (all colors, all numbers), and puts them into the chest.

-- Brickmaker--

if not pn then pn="Keyboard-button-maker" 
  c=1  -- 1=white 2=grey 3=red 4=green 5=blue 6=yellow 7-16="0"-"9" 17=black
  p0 = self.spawnpos();
--turn.left();   turn.left();
end

  keyboard.set( {x=p0.x, y=p0.y+2, z=p0.z}, c)

  dig.up()
  m = check_inventory.self("","main",1);  -- say(m)
  self.label(c.."-->"..m) 
--say(c.."-->"..m) 
  insert.forward(m)

--c=99  -- uncomment this to stop after making the first button
  c=c+1;
  if c>17 then
    c=1    -- repeat, make another set of buttons
    say(pn.." done.");  self.remove()  -- uncomment this to stop after first set
  end
--
  • self.spawnpos() -- returns the position of the robot-spawner, as a table
  • {x=p0.x, y=p0.y+2, z=p0.z} -- specifies a new table, with elements from table p0
y+2 means '2 spaces above the spawner'
  • check_inventory.self("","main",1) -- returns the name of the item in slot 1 of the robot's inventory

After the button is created, the robot digs it.
The button goes into slot 1 of the robot's inventory,
and is put into the chest in front of the robot.

New chest

This program 'cleans' the chest with all the generated buttons.

if not pn then pn="chest-renewer"; say(pn)
  turn.left();   turn.left();  -- turn worker towards chest
  m="default:chest"
end

dig.forward()      -- !! this destroys the chest-contents !!
place.forward(m)

say(pn.." done.")
self.remove()

It simply digs the chest (thereby destroying the contents),
and places a new chest at the same location.

Buttonmaker2

This is an extended version of robot #12 'simple brickmaker':
It makes a set of keyboard-buttons for use as turtle-commands, and puts them into the chest.

--todo
if not pn then pn="Buttonmaker2"; say(pn)
  c=1  -- 1=white 2=grey 3=red 4=green 5=blue 6=yellow 7-16="0"-"9" 17=black
  p0 = self.spawnpos();
--turn.left();   turn.left();
end

  keyboard.set( {x=p0.x, y=p0.y+2, z=p0.z}, c)

  dig.up()
  m = check_inventory.self("","main",1);  -- say(m)
  self.label(c.."-->"..m) 
--say(c.."-->"..m) 
  insert.forward(m)

--c=99  -- uncomment this to stop after making the first button
  c=c+1;
  if c>17 then
    c=1    -- repeat, make another set of buttons
    say(pn.." done.");  self.remove()  -- uncomment this to stop after first set
  end
--
say(pn.." done.")
self.remove()

Math-Quiz

Math-Quiz, using chat.

It asks questions like WHAT is 12*13 ?,
and listens to the chat for players to answer.
Puts reward for correct answer into chest.

It doesn't check who gives an answer, and who takes the rewards from the chest.
-- from https://wiki.minetest.net/Basic_robot/Tutorial#Math_quiz2

-- QUIZ: asks math question, like ""WHAT IS 12*13 ?"
if not state then 
state = 1;
a=0; b=0; question = "";
function generate_question()
  a = math.random(12)+10;
  b = math.random(12)+10;
  t=0
  question = "WHAT IS " .. a .."*".. b .. " ? ";
  say(question)
end

generate_question()
self.listen(1)
end
 
speaker, msg = self.listen_msg()
msg = tonumber(msg)
if msg then 
 if msg == a*b then
   say(speaker .. " ANSWERED CORRECTLY!  You get reward in chest")
   insert.up("default:apple")
   insert.up("default:pine_tree")
   generate_question()
 else
   say("WRONG! " .. question)
 end
end

turn.left(); 
t=t+1; self.label(t)
if t>30 then self.remove() end
--
  • speaker,msg=self.listen_msg() -- the function returns 2 results: the speaker, and his text
  • tonumber(msg) -- tries to convert a text to a number
only numbers are considered as answers to the quiz, other text is ignored

The robot stops if there is no answer within 30 seconds.

Simple Shop

Shop - Robot sells 1 Keypad for 2 Steel-ingots.

To use, the player must put the payment into the chest, then press the keypad-button.

-- from https://wiki.minetest.net/Mods/basic_robot#Simple_Shop

 --say("Shop out of order ... check back soon !"); self.remove()
 --
 if not pn then pn="SimpleShop v0.2" -- Hajo, 2017-03-03+
  say(pn)
  p=find_player(4)
  if p==nil then s="Hello !" else s="Hello "..p[1].." !" end
  say(s)
  --
  -- m1="default:torch";  m2="default:dirt" --Test
 
  --m1="default:sword_steel"  -- Example 1: sell 1 sword for 1 gold
  --m2="default:gold_ingot"
 
  m1="basic_machines:keypad"  -- Example 2: sell 1 keypad for 2 steel
  m2="default:steel_ingot 2"
 
  ok1 = check_inventory.self(m1,"main") -- look at robot's inventory
  if not ok1 then say("Out of stock: "..m1); self.remove() end
 
  ok2 = check_inventory.up(m2,"main")   -- look at chest above robot
  if not ok2 then say("No payment in chest ("..m2..")"); self.remove() end
 
  say("Selling "..m1.." for "..m2) 
  take.up(m2)
  insert.up(m1)
  say("Thanks for your purchase !");
 end

The robot first checks his inventory if there still are items to sell.
Then it checks the chest for payment.
If both are ok, it takes the payment from the chest, and puts the goods into the chest.

Note: another player could try to steal the payment or the sold item from the chest.

Multi-language sign

Location: -33,26,-973

Shows some text like the program 'BigDisplay' above,
but also listens to chat to switch the text.

-- 2018-02-02, hajo

function sign(msg)
  self.display_text(msg,24,2)
  self.label("")
end

if not pn then pn="Multilanguage-sign v1.1"; --say(pn)
--self.spam(1)
  msg="Select via chat:\n\n"
  msg=msg.."EN: to show english text"
--msg=msg.."DE: für deutschen Text\n"  -- Umlaute !!
  msg=msg.."DE: deutschen Text anzeigen\n"
  sign(msg)

  self.listen(1)
--say("I',m listening...")
end

speaker, inp = self.listen_msg()
--if inp then  say( "player ["..speaker.."] said >>"..inp.."<<") end

if inp=="DE" then  sign("Deutscher Text.\n") end

if inp=="EN" then msg="english text\n....+....1....+....2...\n"
  msg=msg.."3\n4\n5\n6\n7\n8\n9\n10\n"
  msg=msg.."11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22"
  sign(msg)
end

if inp=="#" or inp=="stop" then  -- cannot use . or /
  say("Bye !")
  pickup(8)
  self.remove()
end

This program could be extended, eg. to listen only to nearby players,
and to get the texts to display from books stored in the robots library.

Outfitter

--todo

Robo-Farm

This is a much extended version of the mini-farmer, robot #15.

Wheat grows on soil, and needs water within 2 spaces.
Here, we have set up a 5x5 wheat-field around a 3x3 pont with a fountain in the center.

The robot drives around this field, harvests ripe wheat, and plants new seeds.
The robot normally drives forward, and turns right when it hits an obstacle.
There are some trapdoors at the corners of the field that act as an obstacle/free space depending on their open/closed state.
They can be switched by the robot with activate().
This is used to 'switch lanes' while moving around the field.

There is a chest at the border of the field, where the robot unloads some wheat whenever it reaches that location.

Also on the border are some bee-hives that produce honey,
and the robot takes some of that honey out when it drives by.

Finally, the robot picks up 'loose items' and announces what was found.

Eg. eggs from chickens, or raw meat that drops when animal-mobs drown in the central pont.
-- robot-farmer --
-- !! the field must be prepared first, by hand / hoe !!

if not pn then pn="robo-farmer v1"; say(pn)
  seed="farming:seed_wheat"
  ripe="farming:wheat_8"
  crop="farming:wheat"
  self.spam(1)
end

m=pickup(8)  -- collect meat, eggs, saplings etc.
if m then say(pn..": pickup "..m[1]) end

n=read_node.forward(); 
if n=="default:chest" then   n=""
--say(pn..": unload")
  insert.forward(crop.." 16")
end

if n=="xdecor:hive" then   n=""
--say(pn..": get honey")
  take.forward("xdecor:honey".." 2","honey")
end

if n==ripe then  n=""
  dig.forward()
  place.forward(seed)
end

--if n~="" then say(n) end -- debug

activate.forward(1)  -- trapdoor
ok=move.forward()
if not ok then turn.right() end
--

Ideas & Homework:

  • Detect spaces without planted seed, and spaces without soil (eg. holes, or plain dirt).
  • Check if the robot has seeds in its inventory.
  • Extend this program to unload different types of collected stuff into different chests.
  • replace the wheat-chest with another robot, and activate it after unloading
  • let this 2nd robot process the wheat into flour, and bake that into bread (see robot #8)
  • move the finished bread to a shop-robot
  • Same for eggs and meat that was picked up from animals.
  • Extend this program to also plant & harvest cotton, and make wool.
  • Install farming-redo, and also farm the other plants (pumpkin, blueberry, etc),
    and make other products from that mod (donuts, blueberry-pie, pumpkin-bread, etc.)

Demos: Robots&Machines

Machines&Robots working together.

Street-lanterns

Keypad, Distributor, Lights

There are several street-lanterns that can be switched on and off with a keypad.
A distributor is used to transmit the signal from the keypad to the lights.

Production-Demo

Generator, Battery, Furnace, Robots

A generator produces powercells, a battery powers a furnace, robots move powercells around, and craft items.

...