ComputerCraft Wiki - User contributions [en]

Peripheral.getMethods

2015-08-14T12:50:41Z

Smiley43210: Formatted example code

{{lowercase}}
{{Function
|name=peripheral.getMethods
|args= {{type|string}} side
|returns=A table with all available methods for the peripheral on ''side''.
|api=peripheral
|addon=ComputerCraft
|desc=Returns a table with all available methods for the peripheral on ''side''.
|examples=
{{Example
|desc=Prints all of the available methods for the peripheral on the right side of the computer/turtle.
|code= for i,v in ipairs(peripheral.getMethods("right"))
do print(i..". "..v)
end
|output=Depends on whatever is attached to the right hand side of the computer; there is a list on the page for the [[Peripheral (API)|peripheral API]].
}}

}}

[[Category:Lua_Core_Functions]]

Shell (API)

2015-08-14T12:31:19Z

Smiley43210: Changed variable names to maintain consistency

{{lowercase}}
The shell API allows you to interface with ComputerCraft's [http://en.wikipedia.org/wiki/Shell_%28computing%29 shell] - [[CraftOS]]. The shell API is only available when programs are ran from the shell or using [[shell.run]]/[[shell.openTab]].

Note that this "API" is not loaded into _G using [[os.loadAPI]]() - instead, it's loaded by [[shell|the shell script itself]] into a separate user environment, one which also holds [http://lua-users.org/wiki/ScopeTutorial global variables] for any other scripts the user executes. [[multishell (API)|The multishell API]] is handled in the same manner. They can thus be easily sandboxed (allowing for multiple shells to run on the same system at once - the APIs for each being able to return relevant results for each instance), though it does mean other APIs can't refer to these functions (as they lack access to the environment table dedicated to user scripts).

==API==

{{API table|shell|image=Grid disk.png|2=

{{API table/row
|[[shell.exit]]()
|{{type|nil}}
|Exits the current shell.
|odd}}

{{API table/row
|[[shell.dir]]()
|{{type|string}} directory
|Returns the path to the working directory.}}

{{API table/row
|[[shell.setDir]]({{type|string}} path)
|{{type|nil}}
|Sets the working directory.
|odd}}

{{API table/row
|[[shell.path]]()
|{{type|string}} path
|Returns the path.}}

{{API table/row
|[[shell.setPath]]({{type|string}} path)
|{{type|nil}}
|Sets the path.
|odd}}

{{API table/row
|[[shell.resolve]]({{type|string}} localPath)
|{{type|string}} absolutePath
|Resolves a local path to an absolute path.}}

{{API table/row
|[[shell.resolveProgram]]({{type|string}} name)
|{{type|string}} absolutePath
|Resolves the absolute path to the program whose name you provided.
|odd}}

{{API table/row
|[[shell.aliases]]()
|{{type|table}} aliases
|Returns aliases.}}

{{API table/row
|[[shell.setAlias]]({{type|string}} alias, {{type|string}} program)
|{{type|nil}}
|Sets an alias for ''program''.
|odd}}

{{API table/row
|[[shell.clearAlias]]({{type|string}} alias)
|{{type|nil}}
|Clears an alias.}}

{{API table/row
|[[shell.programs]]([<nowiki/>{{type|boolean}} showHidden])
|{{type|table}} programs
|Returns a table of files in the current directory and in all paths in [[shell.path]].
|odd}}

{{API table/row
|[[shell.getRunningProgram]]()
|{{type|string}} path
|Returns the absolute path to the currently-executing program.}}

{{API table/row
|[[shell.run]]({{type|string}} command [, {{type|string}} args1, {{type|string}} args2, ...])
|{{type|boolean}} success
|Runs a command (program).
|odd}}

{{API table/row
|[[shell.openTab]]({{type|string}} command [, {{type|string}} args1, {{type|string}} args2, ...])
|{{type|number}} tabID
|Runs a program in another [[multishell]] tab. ''Requires version 1.6 or newer and an advanced system.''}}

{{API table/row
|[[shell.switchTab]]({{type|number}} tabID)
|{{type|nil}}
|Switches the [[multishell]] tab to tab with the given ID. ''Requires version 1.6 or newer and an advanced system.''
|odd}}

{{API table/row
|[[shell.complete]]({{type|string}} prefix)
|{{type|table}} completionList
|Given a partial command line, returns a list of suffixes that could potentially be used to complete it. ''Requires version 1.74 or newer.''}}

{{API table/row
|[[shell.completeProgram]]({{type|string}} prefix)
|{{type|table}} completionList
|Given a partial script / directory path, returns a list of suffixes that could potentially be used to complete it, including [[shell.aliases|alias]] and [[shell.path|path]] matches. ''Requires version 1.74 or newer.''
|odd}}

{{API table/row
|[[shell.setCompletionFunction]]({{type|string}} path, {{type|function}} completionFunction)
|{{type|nil}}
|Registers a function that determines how [[shell.complete]]() handles completion behavior for a given script. ''Requires version 1.74 or newer.''}}

{{API table/row
|[[shell.getCompletionInfo]]()
|{{type|table}} completionFunctions
|Returns a pointer to the table containing functions registered by [[shell.setCompletionFunction]]() for use with [[shell.complete]](). ''Requires version 1.74 or newer.''
|odd}}

}}

Note that [[shell.run]] and [[shell.openTab]] concatenate any arguments they are given (with single space separator characters) before parsing the command, and as of ComputerCraft version 1.45, now also support a single string containing ''all'' parameters.

[[Category:APIs]]

Turtle.detectUp

2015-08-14T12:25:09Z

Smiley43210: Edited example description

{{lowercase}}
{{Function
|name=turtle.detectUp
|args=
|api=turtle
|returns={{type|boolean}} is there a block above the turtle?
|addon=ComputerCraft
|desc=Detects if there is a block above the turtle.
|examples=
{{Example
|desc=The turtle checks if there is a block above it, and if there is, it digs it.
|code= if '''turtle.detectUp()''' then
[[turtle.digUp]]()
end
}}
}}
==See also==
*[[turtle.detect]]
*[[turtle.detectDown]]

[[Category:Lua_Core_Functions]]

Commands.exec

2015-08-14T12:14:54Z

Smiley43210: Changed "MineCraft" to "Minecraft"

{{lowercase}}
{{Function
|name=commands.exec
|args={{type|string}} command
|returns={{type|boolean}} success, {{type|table}} output
|api=commands
|addon=ComputerCraft
|desc=Available only to [[Command Computer]]s, executes the specified [http://minecraft.gamepedia.com/Commands Minecraft command], [[os.pullEvent|yields]] until the result is determined, then returns it. If command executes successfully then it returns <var>true</var> + the output of the command as a numerically-indexed table, otherwise returns <var>false</var> + an error message as as a numerically-indexed table. Compare [[commands.execAsync]], which ignores the result and returns immediately, without yielding.
<br/>
In ComputerCraft 1.71+ instead of just returning a {{type|boolean}} and an optional error message ({{type|string}}) this function also returns the output of the command in a numerically-indexed table, where each line of the output is put in a separate index. This output is the same as if you would run the command in chat. See example below for an example of this table.<br/>
<br/>
As of ComputerCraft 1.71 this function is also available in the global environment ( <var>_G</var> ) as just <var>exec</var>.<br/>
<br/>
Most commands returned by [[commands.list]]() are also available as functions, such that ''commands.exec(command)'' could also be written as ''commands.command(par1, par2, ...)'' - eg, ''commands.exec("msg @p Hello world!")'' becomes ''commands.msg("@p Hello world!")''.
|examples=
{{Example
|desc=Says 'Hello' to the player, closest to the [[Command Computer]].
|code='''commands.exec( "say @p Hello" )'''
}}
{{Example
|desc=Checks if there are any players around the [[Command Computer]] in 2 block radius.
|code=local radius = 2
local arePlayersAround = '''commands.exec( "testfor @a[r=" .. radius .. "]")'''

if arePlayersAround then
[[print]]( "There is one or more players around me." )
else
[[print]]( "There are no players around me." )
end
}}
{{Example
|desc=Prints the output after running the command "help". ''Requires ComputerCraft 1.71+.''
|code=local success, output = '''commands.exec( "help" )'''

if success then
[[print]]( [[textutils.serialize]]( output ) )
end
|output=Example output:
{
"--- Showing help page 1 of 5 (/help <page>) ---",
"/achievement give <stat_name> [player]",
"/clear <player> [item] [data]",
"/defaultgamemode <mode>",
"/difficulty <new difficulty>",
"/effect <player> <effect> [seconds] [amplifier]",
"/enchant <player> <enchantment ID> [level]",
"Use /forge <subcommand>. Subcommands are tps, track",
}
 
}}
}}

{{CommandsAPIFunctions}}

[[Category:API_Functions]]

Commands.getBlockPosition

2015-08-14T12:14:41Z

Smiley43210: Changed "MineCraft" to "Minecraft"

{{lowercase}}
{{Function
|name=commands.getBlockPosition
|args=
|returns={{type|number}} x, {{type|number}} y, {{type|number}} z
|api=commands
|addon=ComputerCraft
|desc=Available only to [[Command Computer]]s, returns the Minecraft world co-ordinates of the computer running the command.
|examples=
{{Example
|desc=Prints the coordinates of the [[Command Computer]] running the function.
|code=local x, y, z = '''commands.getBlockPosition()'''

[[print]]( "Command Computer's position:" )
[[print]]("X: ", x)
[[print]]("Y: ", y)
[[print]]("Z: ", z)
}}
}}

{{CommandsAPIFunctions}}

[[Category:API_Functions]]

Commands.getBlockInfo

2015-08-14T12:14:28Z

Smiley43210: Changed "MineCraft" to "Minecraft"

{{lowercase}}
{{Function
|name=commands.getBlockInfo
|args={{type|number}} x, {{type|number}} y, {{type|number}} z
|returns={{type|table}} block info
|api=commands
|addon=ComputerCraft
|desc=Available only to [[Command Computer]]s, returns a table containing information on the block at the specified world co-ordinate, formatted as follows:

{
name = {{type|string}} block's name,
metadata = {{type|number}} block's metadata
}

The block inspected will be in the same dimension as the computer. This function yields until the data is available to be returned. If the queried block exists in an ungenerated chunk, this function will cause that chunk to be generated.

See also: [http://minecraft.gamepedia.com/Data_values Data Values @ Minecraft wiki]

|examples=
{{Example
|desc=Prints the [[Command Computer]]'s internal name and metadata value.
|code=local blockInfo = '''commands.getBlockInfo( [[commands.getBlockPosition]]() )'''

[[print]]( "Computer block's name: ", blockInfo.name )
[[print]]( "Computer block's metadata: ", blockInfo.metadata )
}}
{{Example
|desc=Prints the facing of the [[Command Computer]] running the script by inspecting its own metadata.
|code=local directions = {"unknown", "north", "south", "west", "east"}
local blockInfo = '''commands.getBlockInfo( [[commands.getBlockPosition]]() )'''

[[print]]( "My facing is ", directions[ blockInfo.metadata ], "." )
}}
}}

{{CommandsAPIFunctions}}

[[Category:API_Functions]]

Commands (API)

2015-08-14T12:14:11Z

Smiley43210: Changed "MineCraft" to "Minecraft"

Only available to the fabled [[Command Computer]] (itself only available to ops in creative mode, running CC 1.7 or later), the '''commands API''' allows your system to directly execute [http://minecraft.gamepedia.com/Commands Minecraft commands] and gather data from the results.

==API==
{{API table|commands|image=Grid_disk.png|2=

{{API table/row
|[[commands.exec]]({{type|string}} command)
|{{type|boolean}} success, {{type|table}} output
|Executes the specified command, yields until the result is determined, then returns it.
|odd}}

{{API table/row
|[[commands.execAsync]]({{type|string}} command)
|{{type|number}} taskID
|Executes the specified command, but doesn't yield. Queues a [[task_complete_(event)|"task_complete"]] event after the command is executed.
|}}

{{API table/row
|[[commands.list]]()
|{{type|table}} commands
|Returns a numerically indexed table filled with strings representing acceptable commands for [[commands.exec]]() / [[commands.execAsync]]().
|odd}}

{{API table/row
|[[commands.getBlockPosition]]()
|{{type|number}} x, {{type|number}} y, {{type|number}} z
|Returns the Minecraft world coordinates of the computer running the command.
|}}

{{API table/row
|[[commands.getBlockInfo]]({{type|number}} x, {{type|number}} y, {{type|number}} z)
|{{type|table}} block info
|Returns a table containing info about the block at the specified world location. Keys are "name" (a string) and "metadata" (a number).
|odd}}

}}

__TOC__

==commands.<command>()/commands.async.<command>()==
Every command returned by [[commands.list]]() is available as commands.''command'' and commands.async.''command''. For example, instead of writing this:

[[commands.exec]]("say Hi")

...you can write:

commands.say("Hi")

Same with async:

[[commands.execAsync]]("say Hi")
''-- same as:''
commands.async.say("Hi")

On top of that you can pass to them multiple parameters including strings, numbers, booleans and tables. All those parameters are [[textutils.serializeJSON|serialized]] if necessary (such as tables) and concatenated into one string. All these functions will run the same command with the same parameters:

[[commands.exec]]("tellraw @p {text:'Hello!',bold:true}")

commands.tellraw("@p {text:'Hello!',bold:true}") ''-- one or more parameters may be put into one string''

commands.tellraw("@p", "{text:'Hello!',bold:true}") ''-- or you can separate them to different parameters''

commands.tellraw("@p", {text="Hello!", bold=true}) ''-- you can also pass a {{type|table}} directly to it''

The same applies for commands.async.<command>().

All the commands inside commands.<command>()/commands.async.<command>() are also case insensitive. Running commands.TellRAW( ... ) is the same as running commands.tellraw( ... ).

==Notes==
*ComputerCraft enforces a limit of 1000 commands per server tick on Command Computers. Consider [[os.pullEvent|yielding]] manually every so often (eg, sleeping for a second) when making large amounts of [[commands.execAsync]] calls.

[[Category:APIs]]

Adventure

2015-08-14T12:12:00Z

Smiley43210: Changed "MineCraft" to "Minecraft"

[[image:2012-01-30 22.51.59.png|frame|right|Gameplay of Adventure.]]Adventure is one of the default programs in CraftOs. Adventure emulates a text adventure, but it takes place in Minecraft. Therefore, it is possible to play Minecraft, on a computer, in Minecraft, on a computer. This is referred to as "recursion". Also most LPs consist of LPers playing Adventure.

For more ingame info type: "help"

[[Category:Games]]

Redstone (API)

2015-08-14T12:11:34Z

Smiley43210: Changed "MineCraft" to "Minecraft"

The Redstone API contains methods to control attached redstone. All methods from the redstone API can also be called using "rs", which points to the same library. For example, instead of redstone.getSides(), rs.getSides() can be used.

In addition to regular redstone / RedPower cables for regular signals, [[Redstone_(API)#Bundled_Cables|bundled cables]] may be used to send/receive "combined" signals through the one face. The [[Colors (API)|Colors API]] offers functions that're helpful information in dealing with these.

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
Redstone (API)
</td></tr>

<tr><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getSides]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns a table of possible sides.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getInput]]({{type|string}} side)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the current redstone input signal state on ''side''.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.setOutput]]({{type|string}} side, {{type|boolean}} value)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sets or resets a redstone signal on ''side''.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getOutput]]({{type|string}} side)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the current redstone output signal on ''side''.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getAnalogInput]]({{type|string}} side)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">'''(Requires CC1.51 and above)''' Returns the current redstone input signal strength on ''side''. If no input is present, returns 0. If a redstone source (such as a redstone torch or block) is directly adjacent to the computer, returns 15.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.setAnalogOutput]]({{type|string}} side, {{type|number}} strength)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">'''(Requires CC1.51 and above)''' Sets or resets a redstone signal on ''side'' to ''strength'' (where ''strength'' is a positive integer).</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getAnalogOutput]]({{type|string}} side)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">'''(Requires CC1.51 and above)''' Returns the current redstone output signal strength on ''side''.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getBundledInput]]({{type|string}} side)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the state (as a number) of a [[Redstone_(API)#Bundled_Cables|bundled cable]] connected to ''side''.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getBundledOutput]]({{type|string}} side)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the set of wires in a [[Redstone_(API)#Bundled_Cables|bundled cable]] which are being activated by the terminal on ''side''.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.setBundledOutput]]({{type|string}} side, {{type|number}} colors)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sets one or multiple colored signals in a [[Redstone_(API)#Bundled_Cables|bundled cable]] attached to ''side''. ''colors'' will determine which signals are activated. In order to set multiple signals, [[colors.combine|add the color values of the colors]] you want to activate. To turn off all of the colors, use 0.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.testBundledInput]]({{type|string}} side, {{type|number}} color)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns true if ''color'' is active in a [[Redstone_(API)#Bundled_Cables|bundled cable]] attached to ''side''. Else, returns false.</td></tr>

</table>

:{|class="wikitable"
| ''[[Usage_of_the_bundled_cable_using_the_Redstone_API|Bundled cable code snippet. (You might want to take a look at this if you are doing bundledcable related things.)]]''
|}

== Data exchange ==
The redstone API can be used to exchange data between adjacent [[computer]]s and [[turtle]]s. Four bits of data can be transmitted and received with each use of redstone signals to send analog output and receive the input. One redstone signal can be sent at each tick [http://minecraft.gamepedia.com/Tick tick], and there are 20 ticks per second in Minecraft. This limits data transmission over redstone to a maximum of 80 bits per second (bps).

This makes large-scale data transmission over the redstone API exceedingly slow. For example, using the redstone API, transmitting a colored bitmap image for a maximum [[resolution]] computercraft monitor cluster (162x80 pixels) would require 10 minutes and 48 seconds (this would be a 6.48 kB image). For reference, there are 16 colors available for monitors and terminals in computercraft, so a single color for a pixel can be represented in a 4-bit signal.

Despite the slowness, the redstone API can be useful when other options are not available. For example, it can be used to allow [[turtle]]s to communicate with each other and coordinate their work even if they do not have [[Wireless Modem]]s. Exchanging instructions can be done with much less total data than exchanges of image files and the like.

==Bundled Cables==

A "bundled cable" contains multiple wires, one for each of the basic 16 dye colors present in Minecraft. Each acts as a redstone dust line, allowing multiple redstone signals to pass through a space without interfering with each other. They are extremely handy for building complex control mechanisms, and can be dealt with using the [[redstone.getBundledInput|rs.getBundledInput]], [[redstone.getBundledOutput|rs.getBundledOutput]], [[redstone.setBundledOutput|rs.setBundledOutput]] and [[redstone.testBundledInput|rs.testBundledInput]] functions.

ComputerCraft itself does not offer any form of bundled cable - rather, such 16-wire leads are provided by other mods, and they aren't always specifically called "bundled cables", either. Compatibility has changed over time.

ComputerCraft 1.1 (for Minecraft 1.0) through to 1.5 (for MC 1.4.7) users have access to [http://ftbwiki.org/Bundled_Cable bundled cables], provided by [http://www.eloraam.com RedPower/RedPower 2].

1.51 (for MC 1.5) through to 1.58 (for MC 1.6.4) users can switch to [http://ftbwiki.org/RedNet_Cable RedNet cables] (nothing to do with [[Rednet_(API)|ComputerCraft's Rednet]]!) from [http://www.minecraftforum.net/forums/mapping-and-modding/minecraft-mods/1292152-powercrystals-mods-minefactoryreloaded#mfr MineFactory Reloaded].

1.6 introduced an API allowing other mod authors to code support into their mods, while at the same time dropping in-built support for RedNet cables. No known leads are compatible with ComputerCraft 1.6 to 1.63 (for MC 1.6.4) - stick to 1.58 and its RedNet cable compatibility if you wish to use them under that build of Minecraft.

Under 1.64 through to the present 1.74 (all for MC 1.7.10), a number of cables are now available - [http://projectredwiki.com/wiki/Bundled_Cable bundled cables] from [http://projectredwiki.com/wiki/Main_Page Project Red], [http://wiki.enderio.com/Insulated_Redstone_Conduit Insulated Redstone Conduits] from [http://wiki.enderio.com/Main_Page Ender IO], and it's believed current versions of MineFactory Reloaded also work again via their RedNet cables. Others may be available too, so experiment with what you've got, and remember to try updating your mods if you're having trouble!

Mod authors wishing to make their cables compatible can inspect api/doc/index.html, within the ComputerCraft mod archive, for details.

[[Category:APIs]]

Rednet (API)

2015-08-14T12:10:47Z

Smiley43210: Changed "MineCraft" to "Minecraft"

''For a tutorial on how to use the API, visit [[Rednet Tutorial]].''

The Rednet API allows systems to communicate between each other without using redstone. It serves as a wrapper for the [[modem (API)|modem API]], offering ease of functionality (particularly in regards to [[Repeat|repeating signals]]) with some expense of fine control.

In order to send and receive data, a [[modem]] (either [[Wired Modem|wired]] or [[Wireless Modem|wireless]]) is required. The data reaches any possible destinations immediately after sending it, but is [[#Range|range limited]].

==API==
{{API table|rednet|image=Grid_disk.png|2=

{{API table/row
|[[rednet.open]]({{type|string}} side)
|{{type|nil}}
|Tells the computer that the side can be used for networking.}}

{{API table/row
|[[rednet.close]]({{type|string}} side)
|{{type|nil}}
|Tells the computer that the side can no longer be used for networking.
|odd}}

{{API table/row
|[[rednet.send]]({{type|number}} receiverID, {{type|any}} message, [<nowiki/>{{type|string}} protocol])
|{{type|nil}}
|Sends a message "intended" for another system with a specific ID, using the currently opened sides. The <var>receiverID</var> is the ID {{type|number}} (note - '''not''' a {{type|string}}) of the computer you're sending the message to. The [[Variables|types]] that can be sent as the message vary depending on the version of ComputerCraft in use.}}

{{API table/row
|[[rednet.broadcast]]({{type|any}} message, [<nowiki/>{{type|string}} protocol])
|{{type|nil}}
|Sends the message to ''all'' connected and open computers.
|odd}}

{{API table/row
|[[rednet.receive]]([<nowiki/> [<nowiki/>{{type|string}} protocolFilter, ] {{type|number}} timeout])
|{{type|number}} senderID, {{type|any}} message, {{type|number}} distance / {{type|string}} protocol
|Waits until a rednet message of the specified protocol has been received, or until <var>timeout</var> seconds have passed. Leave all arguments empty to wait for any message indefinitely. If only a single, numerical argument is passed, will wait that many seconds for a message of any protocol. Versions of ComputerCraft prior to 1.6 may return the distance to the transmitting computer - 1.6 or later returns message protocols instead, though distance can still be obtained via direct use of the [[Modem (API)|Modem API]].}}

{{API table/row
|[[rednet.isOpen]]({{type|string}} side)
|{{type|boolean}} isOpen
|Returns [[Boolean_(type)|true]] if the wireless modem is open.
|odd}}

{{API table/row
|[[rednet.host]]({{type|string}} protocol, {{type|string}} hostname)
|{{type|nil}}
|Registers <var>hostname</var> against <var>protocol</var> for the purposes of [[rednet.lookup]](). '''Only available in ComputerCraft 1.6 and above.'''}}

{{API table/row
|[[rednet.unhost]]({{type|string}} protocol, {{type|string}} hostname)
|{{type|nil}}
|Unregisters <var>hostname</var> from <var>protocol</var>. '''Only available in ComputerCraft 1.6 and above.'''
|odd}}

{{API table/row
|[[rednet.lookup]]({{type|string}} protocol, {{type|string}} hostname)
|{{type|number}} ID1, {{type|number}} ID2, ...
|Searches the local network for systems registered with a matching <var>hostname</var> and/or <var>protocol</var>, and returns matching IDs found. '''Only available in ComputerCraft 1.6 and above.'''
}}

{{API table/row
|[[rednet.run]]()
|{{type|nil}}
|Internal use function - runs automatically and does not need to be called directly. Waits for [[Modem_message_(event)|modem_message]] events to appear within the event queue and generates corresponding [[Rednet_message_(event)|rednet_message]] events for use with this API. Also responds to [[rednet.lookup]]() requests.
|odd}}

}}

==Events==
{{Event|name=[[rednet_message_(event)|rednet_message]]
|desc=Fired when a rednet message is received (can be pulled via [[os.pullEvent|os.pullEvent()]] directly as an alternative to using [[rednet.receive|rednet.receive()]]).
|return1={{type|number}} senderId
|return2={{type|any}} message
|return3={{type|number}} distance / {{type|string}} protocol
}}

==Range==
The range of a wireless network transmission can be determined via the following formula:

minRange + (position.yCoord - 96.0) * ((maxRange - minRange) / ((world.getHeight() - 1) - 96.0))

Where, by default:

minRange = 64 (or 16 in a storm)
maxRange = 384 (or 96 in a storm)
world.getHeight() = 256

Catch is, that formula is quite capable of returning values that are well below 0... More research is required, it seems. Anyway, min/max range figures can be altered in [[ComputerCraft.cfg]], and the maximum range of a system located at world height will generally be equal to the maxRange for the current weather.

Even for the purposes of two-way communications, only the system with the best range is checked - a system located at the bottom of the world may hence send to and receive from a system at the top. Range is calculated in three dimensions, so the area a given system can reach wirelessly is represented by a sphere.

For wired networks, range between devices is 256 blocks of [[Networking_Cable|network cable]] (unconfigurable). Either method of communication works regardless as to whether the intervening chunks are loaded or not.

As of ComputerCraft 1.6, a [[Repeat|repeater script]] is available to all systems by default.

==Protocols==
Introduced by ComputerCraft 1.6, "protocols" are simple string names indicating what [[rednet.send|sent messages]] are about. [[rednet.receive|Receiving systems]] may filter messages according to their protocols, thereby automatically ignoring incoming messages which don't specify an identical string. It's also possible to [[rednet.lookup|lookup]] which systems in the area are interested in certain protocols, hence making it easier to determine where given messages should be sent in the first place.

==History==
Before the creation of the in-game wireless networking API, the term "Rednet" referred to a system created by a ComputerCraft user based on bundled cables from the popular Minecraft mod [http://www.eloraam.com RedPower]. That also allowed communication between computers, but the data was transferred slowly - every bit was converted to redstone signal (using the [[redstone (API)|redstone API]]) that lasted about 0.05 seconds (the length of a Minecraft "tick"). That system was rendered redundant by the release of ComputerCraft 1.3, as this heralded the arrival of [[Wireless Modem|wireless networking]] to the mod and allowed instant communications between computers.

Later, ComputerCraft 1.51 brought forward [[Wired Modem]]s, which could not only be used for regular network communications, but to interact with [[peripheral]]s remotely.

==Security==
In current versions of ComputerCraft (1.5 or later), Rednet is not to be considered a "secure" method of communication. The identity data indicating who sent a given message is set ''by the sender'', and hence cannot be trusted. Messages intended for a given system may be received and read by any other system in range.

This is because Rednet is simply a convenience wrapper for the [[modem (API)|modem API]], and while it typically sends/receives using channel numbers matching the IDs of systems you control, the latter offers ''complete control'' over channel usage. Another user can hence easily task the modem API directly to sniff and find out what messages a computer is receiving if he knows (or can even guess) its ID, or pretend to send from any ID he wishes.

When using Rednet for anything with security implications, be sure to implement your own methods of protection.

==Deprecated Functions==
{{Deprecated
|plural=yes
|type=These functions
}}

{{API table|Deprecated Rednet Functions|image=Grid disk.png|2=

{{API table/row
|[[rednet.announce]]()
|{{type|nil}}
|Broadcasts an empty rednet message. Removed from ComputerCraft by version ''1.5'' in favor of [[rednet.broadcast]]()
|odd}}

}}

[[Category:APIs]]

Command Computer

2015-08-14T12:08:41Z

Smiley43210: Changed "MineCraft" to "Minecraft"

{{Block
|name=Command Computer
|image=Iso_Command_Computer.png
|id=ComputerCraft:command_computer
|damage-value=0
|is-peripheral=[[#Peripheral_Functions|Yes]]
}}
Introduced by ComputerCraft 1.7 (and therefore requiring Minecraft 1.7.10 or later), the Command Computer is a more powerful version of the [[Advanced Computer]], having direct access to [http://minecraft.gamepedia.com/Commands Minecraft commands]. They are therefore uncraftable, only available to op-status players via the creative inventory, and can only be directly interacted with by the same such players. For example, unlike other computers, they will not boot from an external [[Disk Drive]].

Although regular players cannot ''directly'' access these systems, it's quite possible to write scripts that allow them a controlled level of interaction via the touch-sensitive [[Advanced Monitor]] block, or via [[Rednet (API)|Rednet]], or via other [[peripheral]]s.

==Exclusive APIs==
*[[Commands (API)]]

==Exclusive Programs==
*[[commands]]
*[[exec]]

== Peripheral Functions ==
Supports all the methods available to a [[Computer]] or [[Turtle]].
*[[Computer (API)]]
<br/>

{{BlocksItemsList}}
[[Category:Blocks]][[Category:Consoles]]

Gps (API)

2015-08-14T12:07:25Z

Smiley43210: Changed "axises" to "axes", changed formatting

The GPS API provides a method for turtles and computers to retrieve their own locations.

It broadcasts a PING message over [[Rednet_(API)|rednet]] and wait for responses. In order for this system to work, there must be at least 4 computers used as gps ''hosts'' which will respond and allow [[Wikipedia:Trilateration|trilateration]]. Three of these hosts should be in a plane, and the fourth should be either above or below the other three. The three in a plane should not be in a line with each other. You can set up hosts using the [[Gps (program)|gps program]].

Note: When entering in the coordinates for the ''host'' you need to put in the x, y, and z coordinates of the '''computer''', not the modem, as all rednet distances are measured from the block the computer is in.

Also note that you may ''choose'' which axes x, y, or z refers to - so long as your systems have the same definition as any GPS servers that're in range, it works just the same. For example, you might build a GPS cluster according to [http://www.computercraft.info/forums2/index.php?/topic/3088-how-to-guide-gps-global-position-system/ this tutorial], using z to account for height, or you might use y to account for height in the way that Minecraft's debug screen displays.



{{API table|Gps|image=Grid_disk.png|2=

{{API table/row|gps.locate(<nowiki>[</nowiki>{{type|number}} timeout [, {{Type|boolean}} debug]])|({{Type|number}} x, {{Type|number}} y, {{Type|number}} z) or {{Type|nil}}|Tries to retrieve the computer or turtles own location. On success, returns the location of the turtle’s modem. On failure (if no responses are received for <var>timeout</var> seconds, by default 2), returns {{Type|nil}}. If <var>debug</var> is <code>true</code>, debug messages are printed.|odd}}

}}

== Example ==
print("Man I am so lost right now!")
local x, y, z = gps.locate(5)
if not x then --If gps.locate didn't work, it won't return anything. So check to see if it did.
print("Failed to get my location!")
else
print("I am at (" .. x .. ", " .. y .. ", " .. z .. ")") --This prints 'I am at (1, 2, 3)' or whatever your coordinates are
end

== Vector Example ==
GPS position and navigation can be handled more easily using a [[vector (API)|vector]].

local home = vector.new(45, 85, 20)
local position = vector.new(gps.locate(5))
local displacement = position - home

print("I am ", tostring(displacement), " away from home!!!")

[[Category:APIs]]

Gps (API)

2015-03-20T05:59:46Z

Smiley43210: Changed "MineCraft" to "Minecraft"

The GPS API provides a method for turtles and computers to retrieve their own locations.

It broadcasts a PING message over [[Rednet_(API)|rednet]] and wait for responses. In order for this system to work, there must be at least 4 computers used as gps ''hosts'' which will respond and allow [[Wikipedia:Trilateration|trilateration]]. Three of these hosts should be in a plane, and the fourth should be either above or below the other three. The three in a plane should not be in a line with each other. You can set up hosts using the [[Gps (program)|gps program]].

Note: When entering in the coordinates for the ''host'' you need to put in the x,y,z of the computer, not the modem, as all rednet distances are measured from the block the computer is in.

Also note that you may ''choose'' which axises x, y or z refers to - so long as your systems have the same definition as any GPS servers that're in range, it works just the same. For example, you might build a GPS cluster according to [http://www.computercraft.info/forums2/index.php?/topic/3088-how-to-guide-gps-global-position-system/ this tutorial], using z to account for height, or you might use y to account for height in the way that Minecraft's debug screen displays.



{{API table|Gps|image=Grid_disk.png|2=

{{API table/row|gps.locate(<nowiki>[</nowiki>{{type|number}} timeout [, {{Type|boolean}} debug]])|({{Type|number}} x, {{Type|number}} y, {{Type|number}} z) or {{Type|nil}}|Tries to retrieve the computer or turtles own location. On success, returns the location of the turtle’s modem. On failure (if no responses are received for <var>timeout</var> seconds, by default 2), returns {{Type|nil}}. If <var>debug</var> is <code>true</code>, debug messages are printed.|odd}}

}}

== Example ==
print("Man I am so lost right now!")
local x, y, z = gps.locate(5)
if not x then --If gps.locate didn't work, it won't return anything. So check to see if it did.
print("Failed to get my location!")
else
print("I am at (" .. x .. ", " .. y .. ", " .. z .. ")") --This prints 'I am at (1,2,3)' or whatever your coordinates are
end

== Vector Example ==
GPS position and navigation can be handled more easily using a [[vector (API)|vector]].

local home = vector.new(45, 85, 20)
local position = vector.new(gps.locate(5))
local displacement = position - home

print("I am ", tostring(displacement), " away from home!!!")

[[Category:APIs]]

Gps (API)

2015-03-20T04:22:36Z

Smiley43210: Changed to use API table template

The GPS API provides a method for turtles and computers to retrieve their own locations.

It broadcasts a PING message over [[Rednet_(API)|rednet]] and wait for responses. In order for this system to work, there must be at least 4 computers used as gps ''hosts'' which will respond and allow [[Wikipedia:Trilateration|trilateration]]. Three of these hosts should be in a plane, and the fourth should be either above or below the other three. The three in a plane should not be in a line with each other. You can set up hosts using the [[Gps (program)|gps program]].

Note: When entering in the coordinates for the ''host'' you need to put in the x,y,z of the computer, not the modem, as all rednet distances are measured from the block the computer is in.

Also note that you may ''choose'' which axises x, y or z refers to - so long as your systems have the same definition as any GPS servers that're in range, it works just the same. For example, you might build a GPS cluster according to [http://www.computercraft.info/forums2/index.php?/topic/3088-how-to-guide-gps-global-position-system/ this tutorial], using z to account for height, or you might use y to account for height in the way that MineCraft's debug screen displays.



{{API table|Gps|image=Grid_disk.png|2=

{{API table/row|gps.locate(<nowiki>[</nowiki>{{type|number}} timeout [, {{Type|boolean}} debug]])|({{Type|number}} x, {{Type|number}} y, {{Type|number}} z) or {{Type|nil}}|Tries to retrieve the computer or turtles own location. On success, returns the location of the turtle’s modem. On failure (if no responses are received for <var>timeout</var> seconds, by default 2), returns {{Type|nil}}. If <var>debug</var> is <code>true</code>, debug messages are printed.|odd}}

}}

== Example ==
print("Man I am so lost right now!")
local x, y, z = gps.locate(5)
if not x then --If gps.locate didn't work, it won't return anything. So check to see if it did.
print("Failed to get my location!")
else
print("I am at (" .. x .. ", " .. y .. ", " .. z .. ")") --This prints 'I am at (1,2,3)' or whatever your coordinates are
end

== Vector Example ==
GPS position and navigation can be handled more easily using a [[vector (API)|vector]].

local home = vector.new(45, 85, 20)
local position = vector.new(gps.locate(5))
local displacement = position - home

print("I am ", tostring(displacement), " away from home!!!")

[[Category:APIs]]

Disk (API)

2015-03-20T04:06:10Z

Smiley43210: Changed casing of return values

''If you were looking for the item, please see [[Floppy Disk]].''

The Disk API allows you to interact with disk drives. These functions can operate on locally attached or remote disk drives. To use a locally attached drive, specify “side” as one of the six sides (e.g. “left”); to use a remote disk drive, specify its name as printed when enabling its modem (e.g. “drive_0”).

{{API table|Disk|image=Grid_disk.png|2=

{{API table/row|[[disk.isPresent]]({{type|string}} side)|{{type|boolean}} present|Checks whether any item is in a disk drive.|odd}}
{{API table/row|[[disk.hasData]]({{type|string}} side)|{{type|boolean}} hasData|Checks whether a [[Floppy Disk]] is in a disk drive.|}}
{{API table/row|[[disk.getMountPath]]({{type|string}} side)|{{type|string}}/{{type|nil}} path|Gets the directory name where the contents of the floppy disk can be accessed.|odd}}
{{API table/row|[[disk.setLabel]]({{type|string}} side, {{type|string}} label)|{{type|nil}}|Sets the floppy disk's label.|}}
{{API table/row|[[disk.getLabel]]({{type|string}} side)|{{type|string}}/{{type|nil}} label|Gets the floppy disk's label.|odd}}
{{API table/row|[[disk.getID]]({{type|string}} side)|{{type|number}}/{{type|nil}} id|Gets the floppy disk's unique ID number.|}}
{{API table/row|[[disk.hasAudio]]({{type|string}} side)|{{type|boolean}} hasAudio|Checks whether a [http://www.minecraftwiki.net/wiki/Music_Discs music disk] is in the drive.|odd}}
{{API table/row|[[disk.getAudioTitle]]({{type|string}} side)|{{type|string}}/{{type|nil}} title|Gets the title of the music disc in the drive.|}}
{{API table/row|[[disk.playAudio]]({{type|string}} side)|{{type|nil}}|Starts playing the music disc in the drive.|odd}}
{{API table/row|[[disk.stopAudio]]({{type|string}} side)|{{type|nil}}|Stops playing the music disc in the drive.|}}
{{API table/row|[[disk.eject]]({{type|string}} side)|{{type|nil}}|Ejects any item currently in the drive, spilling it into the world as a loose item.|odd}}

}}

[[Category:APIs]]

Command Block (API)

2013-05-15T13:51:39Z

Smiley43210: Updated table to v2

The Command Block API allows you to run commands in a Command Block, using it as a peripheral.
(The peripheral can only be used if allowed in the config, which is default to false)

Functions exposed by the Command Block, where commandBlock is wrapped to a command block:

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
Command Block (API)
</td></tr>

<tr><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[commandBlock.getCommand]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns a string containing the command currently inside the Command Block.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[commandBlock.setCommand]]({{type|string}} command)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sets the command in the Command Block to ''command''. '''This does not run it.'''</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[commandBlock.runCommand]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Runs the command inside the Command Block previously set by manually editing it or by using [[commandBlock.setCommand]]()</td></tr>
</table>

==Note==
All Command Block functions are to be used ''after'' wrapping the block in a peripheral.
'''example''':
<span>
commandBlock = [[peripheral.wrap]]("left")
commandBlock.setCommand("time set 1000")
commandBlock.runCommand()
local currentCommand = commandBlock.getCommand()
</span>

[[Category:Peripheral APIs]]

Write

2013-05-15T13:38:11Z

Smiley43210: Made it more clear that arg doesn't have to be a string.

{{lowercase}}
{{Function
|name=write
|args= Mixed data
|api=
|addon=ComputerCraft
|desc=Writes characters to the terminal screen.
|examples=
{{Example
|desc=Writes Hello World! to the terminal screen.
|code=write ("Hello ")
write ("World!")
|output=Hello World! (in one line)
}}
|notes=*Starts writing where the last write stopped as opposed to [[print]]() which always prints in a new line.
*When used at the end of a program, the following prompt will be in the same line.
}}

[[Category:Lua_Core_Functions]]

Redstone.setBundledOutput

2013-05-06T00:11:26Z

Smiley43210: Changed to use type template

{{lowercase}}
{{Function
|name=redstone.setBundledOutput
|args={{type|string}} side, {{type|int}} colors
|api=redstone
|returns=?
|addon=ComputerCraft
|examples=
===Basic usage===
{{Example
|desc=Toggles between the black and white wires every two seconds
|code=while(true) do<br /> redstone.setBundledOutput("back", colors.black)<br /> sleep(2)<br /> redstone.setBundledOutput("back", colors.white)<br /> sleep(2)<br />end
|output=(nothing on the screen)
}}
===Combining outputs===
The value is passed as an integer, so sending multiple colors is as easy as adding them together:
{{Example
|desc=Toggles between the black/white and red/blue wires every two seconds
|code=while(true) do<br /> redstone.setBundledOutput("back", colors.black+colors.white)<br /> sleep(2)<br /> redstone.setBundledOutput("back", colors.red+colors.blue)<br /> sleep(2)<br />end
|output=(nothing on the screen)
}}
===Clearing the output===
{{Example
|desc=Unsets the output (removes all power)
|code=function unsetAll(sSide)<br /> redstone.setBundledOutput(sSide, 0)<br />end
|output=(nothing on the screen)
}}
}}

[[Category:Lua_Core_Functions]]

Redstone.setAnalogOutput

2013-05-06T00:10:29Z

Smiley43210: Created function page with example

{{lowercase}}
{{Function
|name=redstone.setAnalogOutput
|args={{type|string}} side, {{type|int}} strength
|desc=Sets the strength of redstone output to ''strength'' on ''side''. ''strength'' must be an integer between 0 and 15, 0 being off, and 15 being the strongest.
|api=redstone
|examples=
{{Example
|desc=Makes the computer output a redstone signal at various strengths
|code=redstone.setAnalogOutput("back", 15)
sleep(2)
redstone.setAnalogOutput("back", 10)
sleep(2)
redstone.setAnalogOutput("back", 5)
sleep(2)
redstone.setAnalogOutput("back", 0)
|output=A block at the back of the computer will receive a strong redstone signal at first, and that signal will slowly diminish.
}}
|notes=
* This function will throw an error if you give it an invalid side.
* List of possible sides: left, right, front, back, bottom, top
}}

[[Category:Lua_Core_Functions]]

Redstone.setOutput

2013-05-06T00:03:22Z

Smiley43210: Changed to use type template

{{lowercase}}
{{Function
|name=redstone.setOutput
|args={{type|string}} side, {{type|boolean}} state
|api=redstone
|examples=
{{Example
|desc=Makes the computer output a redstone signal for one second
|code=redstone.setOutput("back", true)
sleep(1)
redstone.setOutput("back", false)
|output=Redstone wire connected to the back of the computer will be powered for one second, then unpowered (unless it's powered by another source)
}}
|notes=
* This function will throw an error if you give it an invalid side.
* List of possible sides: left, right, front, back, bottom, top
}}

[[Category:Lua_Core_Functions]]

Turtle.detectUp

2013-05-06T00:01:46Z

Smiley43210: Corrected sentence casing (don't capitalize non-nouns in the middle of a sentence -_-), grammar

{{lowercase}}
{{Function
|name=turtle.detectUp
|args=
|api=turtle
|returns={{type|boolean}} If turtle has detected a block above it.
|addon=ComputerCraft
|desc=Detects if there is a block above the turtle.
|examples=
{{Example
|desc=Detects if there is a block above the turtle.
|code=turtle.detectUp()
}}
}}

[[Category:Lua_Core_Functions]]

Redstone.getOutput

2013-05-05T23:56:28Z

Smiley43210: Named the return value

{{lowercase}}
{{Function
|name=redstone.getOutput
|args={{type|string}} side
|returns={{type|boolean}} state
|api=redstone
|desc=Returns what was set with [[redstone.setOutput]]().
|examples=
{{Example
|desc=Sets the output of the left side to true, then prints the output of the left side.
|code=redstone.setOutput("left", true) -- Set the output on the left to true
print(redstone.getOutput("left")) --Print the output
}}
}}

[[Category:Lua_Core_Functions]]

Redstone.getOutput

2013-05-05T23:56:07Z

Smiley43210: Changed to use type template, does NOT return int, returns boolean, corrected example, cleared up description

{{lowercase}}
{{Function
|name=redstone.getOutput
|args={{type|string}} side
|returns={{type|boolean}}
|api=redstone
|desc=Returns what was set with [[redstone.setOutput]]().
|examples=
{{Example
|desc=Sets the output of the left side to true, then prints the output of the left side.
|code=redstone.setOutput("left", true) -- Set the output on the left to true
print(redstone.getOutput("left")) --Print the output
}}
}}

[[Category:Lua_Core_Functions]]

Redstone (API)

2013-05-05T23:53:46Z

Smiley43210: There is no 'number' type, changed to 'int'

The Redstone API contains methods to control attached RedPower cables/bundled cables and regular redstone. All methods from the redstone API can also be called using "rs", which points to the same library. For example, instead of redstone.getSides(), rs.getSides() can be used. Refer to the [[Colors]] API for more information on interacting with RedPower's bundled cables.

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
Redstone (API)
</td></tr>

<tr><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getSides]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns a table of possible sides.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getInput]]({{type|string}} side)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the current redstone input signal state on ''side''.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.setOutput]]({{type|string}} side, {{type|boolean}} value)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sets or resets a redstone signal on ''side''.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getOutput]]({{type|string}} side)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the current redstone output signal on ''side''.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getAnalogInput]]({{type|string}} side)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the current redstone input signal strength on ''side''. If no input is present, returns 0. If a redstone source (such as a redstone torch or block) is directly adjacent to the computer, returns 15.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.setAnalogOutput]]({{type|string}} side, {{type|int}} strength)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sets or resets a redstone signal on ''side'' to ''strength''.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getAnalogOutput]]({{type|string}} side)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the current redstone output signal strength on ''side''.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getBundledInput]]({{type|string}} side)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the state (as a number) of a RedPower bundled cable connected to ''side''.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.getBundledOutput]]({{type|string}} side)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the set of RedPower wires in the RedPower bundled cable which are being activated by the terminal on ''side''.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.setBundledOutput]]({{type|string}} side, {{type|int}} colors)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sets one or multiple colored signals in a RedPower bundled cable attached to ''side''. ''colors'' will determine which signals are activated. In order to set multiple signals, add the color values of the colors you want to activate. To turn off all of the colors, use 0.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[redstone.testBundledInput]]({{type|string}} side, {{type|int}} color)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns true if ''color'' is active in a RedPower bundled cable attached to ''side''. Else, returns false.</td></tr>

</table>

[[Category:APIs]]

Redstone.getAnalogOutput

2013-05-05T23:53:01Z

Smiley43210: Created function page with example

{{lowercase}}
{{Function
|name=redstone.getAnalogOutput
|args={{type|string}} side
|returns={{type|int}} strength
|desc=Returns what was set with [[redstone.setAnalogOutput]]().
|api=redstone
|examples=
{{Example
|desc=Sets the redstone output strength on the left to 7, then prints the output strength of the left side.
|code=redstone.setAnalogOutput("left", 7) -- Set the output strength on the left to 7
print(redstone.getOutput("left")) -- Print the output strength
|output=Prints the strength of the redstone output, so in this case, 7.
}}
}}

[[Category:Lua_Core_Functions]]

Redstone.getAnalogInput

2013-05-05T23:47:58Z

Smiley43210: Created function page with example

{{lowercase}}
{{Function
|name=redstone.getAnalogInput
|args={{type|string}} side
|returns={{type|int}} strength
|desc=Returns the strength of a redstone signal (0-15) on ''side''. If there is no redstone signal on ''side'', returns 0. If there is a redstone source (a redstone block or torch) on ''side'', returns 15.
|api=redstone
|examples=
{{Example
|desc=Prints the strength of a redstone signal on the left side
|code=[[print]]("Redstone strength on left: " .. redstone.getAnalogInput("left"))
|output=A number from 0-15 representing the redstone strength
}}
}}

[[Category:Lua_Core_Functions]]

Shell.run

2013-05-05T01:19:43Z

Smiley43210: Changed to use type template, italicized args in context

{{lowercase}}
{{Function
|name=shell.run
|args= {{type|string}} program [, {{type|string}} args]
|returns={{type|boolean}} success
|api=shell
|addon=ComputerCraft
|desc=Runs ''program'' with optional specified arguments
|examples=
{{Example
|desc=Runs the program "myprogram" with arguments "test" and "ing"
|code=shell.run("myprogram", "test", "ing")
|output=The program myprogram with the arguments "test" and "ing"
}}
}}

[[Category:API_Functions]]

Turtle (API)

2013-05-04T20:54:39Z

Smiley43210: Made it clear that arg is optional

The Turtle API is used to work with your [[Turtle|Turtles]].

===Key===
{| class="wikitable"
! Color !! Turtles that can perform this
|-
| White ||All
|-{{row-lightgreen}}
|Green || Crafty
|-{{row-lightyellow}}
| Yellow || Mining, Felling, Digging, Farming
|-{{row-lightred}}
| Red || Any tool
|}


===API===
{| class="wikitable"
! width="100px" | Return
! width="200px" | Method name
! Description
! Min version
|-{{row-lightgreen}}
|{{type|boolean}} success
|[[turtle.craft]]({{type|int}} quantity)
|Craft items using ingredients anywhere in the turtle's inventory and place results in the active slot. If a quantity is specified, it will craft only up to that many items, otherwise, it will craft as many of the items as possible.
|
|-
|{{type|boolean}} success
|[[turtle.forward]]()
|Try to move the turtle forward
|
|-
|{{type|boolean}} success
|[[turtle.back]]()
|Try to move the turtle backward
|
|-
|{{type|boolean}} success
|[[turtle.up]]()
|Try to move the turtle up
|
|-
|{{type|boolean}} success
|[[turtle.down]]()
|Try to move the turtle down
|
|-
|{{type|boolean}} success
|[[turtle.turnLeft]]()
|Turn the turtle left
|
|-
|{{type|boolean}} success
|[[turtle.turnRight]]()
|Turn the turtle right
|
|-
|{{type|boolean}} success
|[[turtle.select]]({{type|int}} slotNum)
|Make the turtle select slot ''slotNum'' (1 is top left, 16 (9 in 1.33 and earlier) is bottom right)
|
|-
|{{type|int}} count
|[[turtle.getItemCount]]({{type|int}} slotNum)
|Counts how many items are in slot ''slotNum''
|
|-
|{{type|int}} count
|[[turtle.getItemSpace]]({{type|int}} slotNum)
|Counts how many remaining items you need to fill the stack in slot ''slotNum''
|
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attack]]()
|Attacks in front of the turtle.
| 1.4
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attackUp]]()
|Attacks above the turtle.
| 1.4
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attackDown]]()
|Attacks under the turtle.
| 1.4
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.dig]]()
|Breaks the block in front. With hoe: tills the dirt in front of it.
|
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.digUp]]()
|Breaks the block above. With hoe: tills the dirt above it.
|
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.digDown]]()
|Breaks the block below. With hoe: tills the dirt below it.
|
|-
|{{type|boolean}} success
|[[turtle.place]]([<nowiki></nowiki>{{type|string}} signText])
|Places a block of the selected slot in front. Engrave ''signText'' on signs if provided.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.placeUp]]()
|Places a block of the selected slot above
|
|-
|{{type|boolean}} success
|[[turtle.placeDown]]()
|Places a block of the selected slot below
|
|-
|{{type|boolean}} result
|[[turtle.detect]]()
|Detects if there is a block in front. Does not detect mobs.
|
|-
|{{type|boolean}} result
|[[turtle.detectUp]]()
|Detects if there is a block above
|
|-
|{{type|boolean}} result
|[[turtle.detectDown]]()
|Detects if there is a block below
|
|-
|{{type|boolean}} result
|[[turtle.compare]]()
|Detects if the block in front is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareUp]]()
|Detects if the block above is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareDown]]()
|Detects if the block below is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareTo]]({{type|int}} slot)
|Compare the current selected slot and the given slot to see if the items are the same. Returns true if they are the same, false if not.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.drop]]([<nowiki></nowiki>{{type|int}} count])
|Drops all items in the selected slot, or specified, drops ''count'' items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e in front of the turtle) it will try to place into the inventory, returning false if the inventory is full.
|
|-
|{{type|boolean}} success
|[[turtle.drop|turtle.dropUp]]([<nowiki></nowiki>{{type|int}} count])
|Drops all items in the selected slot, or specified, drops ''count'' items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e above the turtle) it will try to place into the inventory, returning false if the inventory is full. If below a furnace, will place item in the bottom slot.
|
|-
|{{type|boolean}} success
|[[turtle.drop|turtle.dropDown]]([<nowiki></nowiki>{{type|int}} count])
|Drops all items in the selected slot, or specified, drops ''count'' items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e below the turtle) it will try to place into the inventory, returning false if the inventory is full. If above a furnace, will place item in the top slot.
|
|-
|{{type|boolean}} success
|[[turtle.suck]]()
|Picks up an item stack of any number, from the ground or an inventory in front of the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.suck|turtle.suckUp]]()
|Picks up an item stack of any number, from the ground or an inventory above the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.suck|turtle.suckDown]]()
|Picks up an item stack of any number, from the ground or an inventory below the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.refuel]]([<nowiki></nowiki>{{type|int}} quantity])
|If the current selected slot contains a fuel item, it will consume it to give the turtle the ability to move.<br />Added in 1.4 and is only needed in needfuel mode. If the current slot doesn't contain a fuel item, it returns false. Fuel values for different items can be found at [[Turtle.refuel#Fuel_Values]]. If a quantity is specified, it will refuel only up to that many items, otherwise, it will consume all the items in the slot.
| 1.4
|-
|{{type|int}} fuel
|[[turtle.getFuelLevel]]()
|Returns the current fuel level of the turtle, this is the number of blocks the turtle can move.<br />If turtleNeedFuel = 0 then it returns "unlimited".
| 1.4
|-
|{{type|boolean}} success
|[[turtle.transferTo]]({{type|int}} slot [, {{type|int}} quantity])
|Transfers ''quantity'' items from the selected slot to ''slot''. If ''quantity'' isn't specified, will attempt to transfer everything in the selected slot to ''slot''.
| 1.45
|}

Trivia:
During the 1.4 beta, turtle.getFuelLevel() in softcore(that is now turtleneedsfuel = 0) returned 9000.
[[Category:APIs]]

Turtle (API)

2013-05-04T20:50:36Z

Smiley43210: Clear up descriptions

The Turtle API is used to work with your [[Turtle|Turtles]].

===Key===
{| class="wikitable"
! Color !! Turtles that can perform this
|-
| White ||All
|-{{row-lightgreen}}
|Green || Crafty
|-{{row-lightyellow}}
| Yellow || Mining, Felling, Digging, Farming
|-{{row-lightred}}
| Red || Any tool
|}


===API===
{| class="wikitable"
! width="100px" | Return
! width="200px" | Method name
! Description
! Min version
|-{{row-lightgreen}}
|{{type|boolean}} success
|[[turtle.craft]]({{type|int}} quantity)
|Craft items using ingredients anywhere in the turtle's inventory and place results in the active slot. If a quantity is specified, it will craft only up to that many items, otherwise, it will craft as many of the items as possible.
|
|-
|{{type|boolean}} success
|[[turtle.forward]]()
|Try to move the turtle forward
|
|-
|{{type|boolean}} success
|[[turtle.back]]()
|Try to move the turtle backward
|
|-
|{{type|boolean}} success
|[[turtle.up]]()
|Try to move the turtle up
|
|-
|{{type|boolean}} success
|[[turtle.down]]()
|Try to move the turtle down
|
|-
|{{type|boolean}} success
|[[turtle.turnLeft]]()
|Turn the turtle left
|
|-
|{{type|boolean}} success
|[[turtle.turnRight]]()
|Turn the turtle right
|
|-
|{{type|boolean}} success
|[[turtle.select]]({{type|int}} slotNum)
|Make the turtle select slot ''slotNum'' (1 is top left, 16 (9 in 1.33 and earlier) is bottom right)
|
|-
|{{type|int}} count
|[[turtle.getItemCount]]({{type|int}} slotNum)
|Counts how many items are in slot ''slotNum''
|
|-
|{{type|int}} count
|[[turtle.getItemSpace]]({{type|int}} slotNum)
|Counts how many remaining items you need to fill the stack in slot ''slotNum''
|
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attack]]()
|Attacks in front of the turtle.
| 1.4
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attackUp]]()
|Attacks above the turtle.
| 1.4
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attackDown]]()
|Attacks under the turtle.
| 1.4
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.dig]]()
|Breaks the block in front. With hoe: tills the dirt in front of it.
|
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.digUp]]()
|Breaks the block above. With hoe: tills the dirt above it.
|
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.digDown]]()
|Breaks the block below. With hoe: tills the dirt below it.
|
|-
|{{type|boolean}} success
|[[turtle.place]]({{type|string}} signText)
|Places a block of the selected slot in front. Engrave ''signText'' on signs if provided.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.placeUp]]()
|Places a block of the selected slot above
|
|-
|{{type|boolean}} success
|[[turtle.placeDown]]()
|Places a block of the selected slot below
|
|-
|{{type|boolean}} result
|[[turtle.detect]]()
|Detects if there is a block in front. Does not detect mobs.
|
|-
|{{type|boolean}} result
|[[turtle.detectUp]]()
|Detects if there is a block above
|
|-
|{{type|boolean}} result
|[[turtle.detectDown]]()
|Detects if there is a block below
|
|-
|{{type|boolean}} result
|[[turtle.compare]]()
|Detects if the block in front is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareUp]]()
|Detects if the block above is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareDown]]()
|Detects if the block below is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareTo]]({{type|int}} slot)
|Compare the current selected slot and the given slot to see if the items are the same. Returns true if they are the same, false if not.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.drop]]([<nowiki></nowiki>{{type|int}} count])
|Drops all items in the selected slot, or specified, drops ''count'' items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e in front of the turtle) it will try to place into the inventory, returning false if the inventory is full.
|
|-
|{{type|boolean}} success
|[[turtle.drop|turtle.dropUp]]([<nowiki></nowiki>{{type|int}} count])
|Drops all items in the selected slot, or specified, drops ''count'' items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e above the turtle) it will try to place into the inventory, returning false if the inventory is full. If below a furnace, will place item in the bottom slot.
|
|-
|{{type|boolean}} success
|[[turtle.drop|turtle.dropDown]]([<nowiki></nowiki>{{type|int}} count])
|Drops all items in the selected slot, or specified, drops ''count'' items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e below the turtle) it will try to place into the inventory, returning false if the inventory is full. If above a furnace, will place item in the top slot.
|
|-
|{{type|boolean}} success
|[[turtle.suck]]()
|Picks up an item stack of any number, from the ground or an inventory in front of the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.suck|turtle.suckUp]]()
|Picks up an item stack of any number, from the ground or an inventory above the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.suck|turtle.suckDown]]()
|Picks up an item stack of any number, from the ground or an inventory below the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.refuel]]([<nowiki></nowiki>{{type|int}} quantity])
|If the current selected slot contains a fuel item, it will consume it to give the turtle the ability to move.<br />Added in 1.4 and is only needed in needfuel mode. If the current slot doesn't contain a fuel item, it returns false. Fuel values for different items can be found at [[Turtle.refuel#Fuel_Values]]. If a quantity is specified, it will refuel only up to that many items, otherwise, it will consume all the items in the slot.
| 1.4
|-
|{{type|int}} fuel
|[[turtle.getFuelLevel]]()
|Returns the current fuel level of the turtle, this is the number of blocks the turtle can move.<br />If turtleNeedFuel = 0 then it returns "unlimited".
| 1.4
|-
|{{type|boolean}} success
|[[turtle.transferTo]]({{type|int}} slot [, {{type|int}} quantity])
|Transfers ''quantity'' items from the selected slot to ''slot''. If ''quantity'' isn't specified, will attempt to transfer everything in the selected slot to ''slot''.
| 1.45
|}

Trivia:
During the 1.4 beta, turtle.getFuelLevel() in softcore(that is now turtleneedsfuel = 0) returned 9000.
[[Category:APIs]]

Turtle (API)

2013-05-04T20:48:50Z

Smiley43210: Correcter case ("Block" -> "block", "Turtle" -> "turtle"), changed descriptions to reference args, italicized args in context

The Turtle API is used to work with your [[Turtle|Turtles]].

===Key===
{| class="wikitable"
! Color !! Turtles that can perform this
|-
| White ||All
|-{{row-lightgreen}}
|Green || Crafty
|-{{row-lightyellow}}
| Yellow || Mining, Felling, Digging, Farming
|-{{row-lightred}}
| Red || Any tool
|}


===API===
{| class="wikitable"
! width="100px" | Return
! width="200px" | Method name
! Description
! Min version
|-{{row-lightgreen}}
|{{type|boolean}} success
|[[turtle.craft]]({{type|int}} quantity)
|Craft items using ingredients anywhere in the turtle's inventory and place results in the active slot. If a quantity is specified, it will craft only up to that many items, otherwise, it will craft as many of the items as possible.
|
|-
|{{type|boolean}} success
|[[turtle.forward]]()
|Let the turtle move forward
|
|-
|{{type|boolean}} success
|[[turtle.back]]()
|Let the turtle move back
|
|-
|{{type|boolean}} success
|[[turtle.up]]()
|Let the Turtle move up
|
|-
|{{type|boolean}} success
|[[turtle.down]]()
|Let the turtle move down
|
|-
|{{type|boolean}} success
|[[turtle.turnLeft]]()
|Let the turtle turn left
|
|-
|{{type|boolean}} success
|[[turtle.turnRight]]()
|Let the turtle turn right
|
|-
|{{type|boolean}} success
|[[turtle.select]]({{type|int}} slotNum)
|The turtle selects slot ''slotNum'' (1 is top left, 16 (9 in 1.33 and earlier) is bottom right)
|
|-
|{{type|int}} items
|[[turtle.getItemCount]]({{type|int}} slotNum)
|Counts how many items are in slot ''slotNum''
|
|-
|{{type|int}} items
|[[turtle.getItemSpace]]({{type|int}} slotNum)
|Counts how many remaining items you need to fill the stack in slot ''slotNum''
|
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attack]]()
|Attacks in front of the turtle.
| 1.4
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attackUp]]()
|Attacks above the turtle.
| 1.4
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attackDown]]()
|Attacks under the turtle.
| 1.4
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.dig]]()
|Breaks the block in front. With hoe: tills the dirt in front of it.
|
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.digUp]]()
|Breaks the block above. With hoe: tills the dirt above it.
|
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.digDown]]()
|Breaks the block below. With hoe: tills the dirt below it.
|
|-
|{{type|boolean}} success
|[[turtle.place]]({{type|string}} signText)
|Places a block of the selected slot in front. Engrave ''signText'' on signs if provided.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.placeUp]]()
|Places a block of the selected slot above
|
|-
|{{type|boolean}} success
|[[turtle.placeDown]]()
|Places a block of the selected slot below
|
|-
|{{type|boolean}} result
|[[turtle.detect]]()
|Detects if there is a block in front. Does not detect mobs.
|
|-
|{{type|boolean}} result
|[[turtle.detectUp]]()
|Detects if there is a block above
|
|-
|{{type|boolean}} result
|[[turtle.detectDown]]()
|Detects if there is a block below
|
|-
|{{type|boolean}} result
|[[turtle.compare]]()
|Detects if the block in front is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareUp]]()
|Detects if the block above is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareDown]]()
|Detects if the block below is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareTo]]({{type|int}} slot)
|Compare the current selected slot and the given slot to see if the items are the same. Returns true if they are the same, false if not.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.drop]]([<nowiki></nowiki>{{type|int}} count])
|Drops all items in the selected slot, or specified, drops ''count'' items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e in front of the turtle) it will try to place into the inventory, returning false if the inventory is full.
|
|-
|{{type|boolean}} success
|[[turtle.drop|turtle.dropUp]]([<nowiki></nowiki>{{type|int}} count])
|Drops all items in the selected slot, or specified, drops ''count'' items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e above the turtle) it will try to place into the inventory, returning false if the inventory is full. If below a furnace, will place item in the bottom slot.
|
|-
|{{type|boolean}} success
|[[turtle.drop|turtle.dropDown]]([<nowiki></nowiki>{{type|int}} count])
|Drops all items in the selected slot, or specified, drops ''count'' items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e below the turtle) it will try to place into the inventory, returning false if the inventory is full. If above a furnace, will place item in the top slot.
|
|-
|{{type|boolean}} success
|[[turtle.suck]]()
|Picks up an item stack of any number, from the ground or an inventory in front of the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.suck|turtle.suckUp]]()
|Picks up an item stack of any number, from the ground or an inventory above the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.suck|turtle.suckDown]]()
|Picks up an item stack of any number, from the ground or an inventory below the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.refuel]]([<nowiki></nowiki>{{type|int}} quantity])
|If the current selected slot contains a fuel item, it will consume it to give the turtle the ability to move.<br />Added in 1.4 and is only needed in needfuel mode. If the current slot doesn't contain a fuel item, it returns false. Fuel values for different items can be found at [[Turtle.refuel#Fuel_Values]]. If a quantity is specified, it will refuel only up to that many items, otherwise, it will consume all the items in the slot.
| 1.4
|-
|{{type|int}} fuel
|[[turtle.getFuelLevel]]()
|Returns the current fuel level of the turtle, this is the number of blocks the turtle can move.<br />If turtleNeedFuel = 0 then it returns "unlimited".
| 1.4
|-
|{{type|boolean}} success
|[[turtle.transferTo]]({{type|int}} slot [, {{type|int}} quantity])
|Transfers ''quantity'' items from the selected slot to ''slot''. If ''quantity'' isn't specified, will attempt to transfer everything in the selected slot to ''slot''.
| 1.45
|}

Trivia:
During the 1.4 beta, turtle.getFuelLevel() in softcore(that is now turtleneedsfuel = 0) returned 9000.
[[Category:APIs]]

Turtle (API)

2013-05-04T20:45:11Z

Smiley43210: Made it clear that arg is optional, cleared up descriptions for turtle.drop(), .dropUp(), .dropDown()

The Turtle API is used to work with your [[Turtle|Turtles]].

===Key===
{| class="wikitable"
! Color !! Turtles that can perform this
|-
| White ||All
|-{{row-lightgreen}}
|Green || Crafty
|-{{row-lightyellow}}
| Yellow || Mining, Felling, Digging, Farming
|-{{row-lightred}}
| Red || Any tool
|}


===API===
{| class="wikitable"
! width="100px" | Return
! width="200px" | Method name
! Description
! Min version
|-{{row-lightgreen}}
|{{type|boolean}} success
|[[turtle.craft]]({{type|int}} quantity)
|Craft items using ingredients anywhere in the Turtle's inventory and place results in the active slot. If a quantity is specified, it will craft only up to that many items, otherwise, it will craft as many of the items as possible.
|
|-
|{{type|boolean}} success
|[[turtle.forward]]()
|Let the Turtle move forward
|
|-
|{{type|boolean}} success
|[[turtle.back]]()
|Let the Turtle move back
|
|-
|{{type|boolean}} success
|[[turtle.up]]()
|Let the Turtle move up
|
|-
|{{type|boolean}} success
|[[turtle.down]]()
|Let the Turtle move down
|
|-
|{{type|boolean}} success
|[[turtle.turnLeft]]()
|Let the Turtle turn left
|
|-
|{{type|boolean}} success
|[[turtle.turnRight]]()
|Let the Turtle turn right
|
|-
|{{type|boolean}} success
|[[turtle.select]]({{type|int}} slotNum)
|The Turtle selects the given Slot (1 is top left, 16 (9 in 1.33 and earlier) is bottom right)
|
|-
|{{type|int}} items
|[[turtle.getItemCount]]({{type|int}} slotNum)
|Counts how many items are in the given Slot
|
|-
|{{type|int}} items
|[[turtle.getItemSpace]]({{type|int}} slotNum)
|Counts how many remaining items you need to fill the stack in the given Slot
|
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attack]]()
|Attacks in front of the turtle.
| 1.4
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attackUp]]()
|Attacks over the turtle.
| 1.4
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attackDown]]()
|Attacks under the turtle.
| 1.4
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.dig]]()
|Breaks the Block in front. With hoe: tills the dirt in front of it.
|
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.digUp]]()
|Breaks the Block above. With hoe: tills the dirt above it.
|
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.digDown]]()
|Breaks the Block below. With hoe: tills the dirt below it.
|
|-
|{{type|boolean}} success
|[[turtle.place]]({{type|string}} signText)
|Places a Block of the selected slot in front. Engrave ''signText'' on signs if provided.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.placeUp]]()
|Places a Block of the selected slot above
|
|-
|{{type|boolean}} success
|[[turtle.placeDown]]()
|Places a Block of the selected slot below
|
|-
|{{type|boolean}} result
|[[turtle.detect]]()
|Detects if there is a Block in front. Does not detect mobs.
|
|-
|{{type|boolean}} result
|[[turtle.detectUp]]()
|Detects if there is a Block above
|
|-
|{{type|boolean}} result
|[[turtle.detectDown]]()
|Detects if there is a Block below
|
|-
|{{type|boolean}} result
|[[turtle.compare]]()
|Detects if the block in front is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareUp]]()
|Detects if the block above is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareDown]]()
|Detects if the block below is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareTo]]({{type|int}} slot)
|Compare the current selected slot and the given slot to see if the items are the same. Returns true if they are the same, false if not.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.drop]]([<nowiki></nowiki>{{type|int}} count])
|Drops all items in the selected slot, or specified, drops ''count'' items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e in front of the turtle) it will try to place into the inventory, returning false if the inventory is full.
|
|-
|{{type|boolean}} success
|[[turtle.drop|turtle.dropUp]]([<nowiki></nowiki>{{type|int}} count])
|Drops all items in the selected slot, or specified, drops ''count'' items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e above the turtle) it will try to place into the inventory, returning false if the inventory is full. If below a furnace, will place item in the bottom slot.
|
|-
|{{type|boolean}} success
|[[turtle.drop|turtle.dropDown]]([<nowiki></nowiki>{{type|int}} count])
|Drops all items in the selected slot, or specified, drops ''count'' items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e below the turtle) it will try to place into the inventory, returning false if the inventory is full. If above a furnace, will place item in the top slot.
|
|-
|{{type|boolean}} success
|[[turtle.suck]]()
|Picks up an item stack of any number, from the ground or an inventory in front of the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.suck|turtle.suckUp]]()
|Picks up an item stack of any number, from the ground or an inventory above the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.suck|turtle.suckDown]]()
|Picks up an item stack of any number, from the ground or an inventory below the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.refuel]]([<nowiki></nowiki>{{type|int}} quantity])
|If the current selected slot contains a fuel item, it will consume it to give the turtle the ability to move.<br />Added in 1.4 and is only needed in needfuel mode. If the current slot doesn't contain a fuel item, it returns false. Fuel values for different items can be found at [[Turtle.refuel#Fuel_Values]]. If a quantity is specified, it will refuel only up to that many items, otherwise, it will consume all the items in the slot.
| 1.4
|-
|{{type|int}} fuel
|[[turtle.getFuelLevel]]()
|Returns the current fuel level of the turtle, this is the number of blocks the turtle can move.<br />If turtleNeedFuel = 0 then it returns "unlimited".
| 1.4
|-
|{{type|boolean}} success
|[[turtle.transferTo]]({{type|int}} slot [, {{type|int}} quantity])
|Transfers ''quantity'' items from the selected slot to ''slot''. If ''quantity'' isn't specified, will attempt to transfer everything in the selected slot to ''slot''.
| 1.45
|}

Trivia:
During the 1.4 beta, turtle.getFuelLevel() in softcore(that is now turtleneedsfuel = 0) returned 9000.
[[Category:APIs]]

Turtle.drop

2013-05-04T20:31:48Z

Smiley43210: Made it clear that arg is optional, added types, italicized args in context

{{lowercase}}
{{Function
|name=turtle.drop
|args=[<nowiki></nowiki>{{type|int}} count]
|returns={{type|boolean}} true if an item was dropped; false otherwise.
|api=turtle
|addon=ComputerCraft
|desc=Drops all items in the selected slot, or if ''count'' is specified, drops that many items.
If the space in front of the turtle does not contain a chest, the items are dropped into that space.
If the space in front of the turtle contains a chest, the items are dropped into that chest.
The items will be placed in the first available slot, starting at the top left, moving right and then down.

turtle.dropUp and turtle.dropDown are also available, and useful for loading furnaces; dropUp when below a furnace will load the items as fuel in the furnace's bottom slot, while dropDown when above the furnace will load the top slot for smelting.
|examples=
{{Example
|desc=Drops all items in the first available slot.
|code=turtle.drop()
}}
}}

[[Category:Lua_Core_Functions]]

Turtle (API)

2013-05-04T20:28:25Z

Smiley43210: Made it clear that arg is optional, added typles, "yields" -> "returns", changed description for turtle.transferTo()

The Turtle API is used to work with your [[Turtle|Turtles]].

===Key===
{| class="wikitable"
! Color !! Turtles that can perform this
|-
| White ||All
|-{{row-lightgreen}}
|Green || Crafty
|-{{row-lightyellow}}
| Yellow || Mining, Felling, Digging, Farming
|-{{row-lightred}}
| Red || Any tool
|}


===API===
{| class="wikitable"
! width="100px" | Return
! width="200px" | Method name
! Description
! Min version
|-{{row-lightgreen}}
|{{type|boolean}} success
|[[turtle.craft]]({{type|int}} quantity)
|Craft items using ingredients anywhere in the Turtle's inventory and place results in the active slot. If a quantity is specified, it will craft only up to that many items, otherwise, it will craft as many of the items as possible.
|
|-
|{{type|boolean}} success
|[[turtle.forward]]()
|Let the Turtle move forward
|
|-
|{{type|boolean}} success
|[[turtle.back]]()
|Let the Turtle move back
|
|-
|{{type|boolean}} success
|[[turtle.up]]()
|Let the Turtle move up
|
|-
|{{type|boolean}} success
|[[turtle.down]]()
|Let the Turtle move down
|
|-
|{{type|boolean}} success
|[[turtle.turnLeft]]()
|Let the Turtle turn left
|
|-
|{{type|boolean}} success
|[[turtle.turnRight]]()
|Let the Turtle turn right
|
|-
|{{type|boolean}} success
|[[turtle.select]]({{type|int}} slotNum)
|The Turtle selects the given Slot (1 is top left, 16 (9 in 1.33 and earlier) is bottom right)
|
|-
|{{type|int}} items
|[[turtle.getItemCount]]({{type|int}} slotNum)
|Counts how many items are in the given Slot
|
|-
|{{type|int}} items
|[[turtle.getItemSpace]]({{type|int}} slotNum)
|Counts how many remaining items you need to fill the stack in the given Slot
|
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attack]]()
|Attacks in front of the turtle.
| 1.4
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attackUp]]()
|Attacks over the turtle.
| 1.4
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attackDown]]()
|Attacks under the turtle.
| 1.4
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.dig]]()
|Breaks the Block in front. With hoe: tills the dirt in front of it.
|
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.digUp]]()
|Breaks the Block above. With hoe: tills the dirt above it.
|
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.digDown]]()
|Breaks the Block below. With hoe: tills the dirt below it.
|
|-
|{{type|boolean}} success
|[[turtle.place]]({{type|string}} signText)
|Places a Block of the selected slot in front. Engrave ''signText'' on signs if provided.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.placeUp]]()
|Places a Block of the selected slot above
|
|-
|{{type|boolean}} success
|[[turtle.placeDown]]()
|Places a Block of the selected slot below
|
|-
|{{type|boolean}} result
|[[turtle.detect]]()
|Detects if there is a Block in front. Does not detect mobs.
|
|-
|{{type|boolean}} result
|[[turtle.detectUp]]()
|Detects if there is a Block above
|
|-
|{{type|boolean}} result
|[[turtle.detectDown]]()
|Detects if there is a Block below
|
|-
|{{type|boolean}} result
|[[turtle.compare]]()
|Detects if the block in front is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareUp]]()
|Detects if the block above is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareDown]]()
|Detects if the block below is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareTo]]({{type|int}} slot)
|Compare the current selected slot and the given slot to see if the items are the same. Returns true if they are the same, false if not.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.drop]]({{type|int}} count)
|Drops all items in the selected slot, or if count is specified, drops that many items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e in front of the turtle) it will try to place into the inventory, returning false if the inventory is full.
|
|-
|{{type|boolean}} success
|[[turtle.drop|turtle.dropUp]]({{type|int}} count)
|Drops all items in the selected slot, or if count is specified, drops that many items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e above the turtle) it will try to place into the inventory, returning false if the inventory is full. If below a furnace, will place item in the bottom slot.
|
|-
|{{type|boolean}} success
|[[turtle.drop|turtle.dropDown]]({{type|int}} count)
|Drops all items in the selected slot, or if count is specified, drops that many items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e below the turtle) it will try to place into the inventory, returning false if the inventory is full. If above a furnace, will place item in the top slot.
|
|-
|{{type|boolean}} success
|[[turtle.suck]]()
|Picks up an item stack of any number, from the ground or an inventory in front of the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.suck|turtle.suckUp]]()
|Picks up an item stack of any number, from the ground or an inventory above the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.suck|turtle.suckDown]]()
|Picks up an item stack of any number, from the ground or an inventory below the turtle. If the turtle can't pick up the item, the function returns false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.refuel]]([<nowiki></nowiki>{{type|int}} quantity])
|If the current selected slot contains a fuel item, it will consume it to give the turtle the ability to move.<br />Added in 1.4 and is only needed in needfuel mode. If the current slot doesn't contain a fuel item, it returns false. Fuel values for different items can be found at [[Turtle.refuel#Fuel_Values]]. If a quantity is specified, it will refuel only up to that many items, otherwise, it will consume all the items in the slot.
| 1.4
|-
|{{type|int}} fuel
|[[turtle.getFuelLevel]]()
|Returns the current fuel level of the turtle, this is the number of blocks the turtle can move.<br />If turtleNeedFuel = 0 then it returns "unlimited".
| 1.4
|-
|{{type|boolean}} success
|[[turtle.transferTo]]({{type|int}} slot [, {{type|int}} quantity])
|Transfers ''quantity'' items from the selected slot to ''slot''. If ''quantity'' isn't specified, will attempt to transfer everything in the selected slot to ''slot''.
| 1.45
|}

Trivia:
During the 1.4 beta, turtle.getFuelLevel() in softcore(that is now turtleneedsfuel = 0) returned 9000.
[[Category:APIs]]

Turtle.transferTo

2013-05-04T20:23:42Z

Smiley43210: Made it clear that arg is optional, converted to type templates, corrected grammar, italicized arguments in context

{{lowercase}}
{{Function
|name=turtle.transferTo
|args={{type|int}} slot [, {{type|int}} quantity]
|returns={{type|boolean}} success
|api=turtle
|addon=ComputerCraft
|desc=Transfers ''quantity'' items from the selected slot to ''slot''. If the ''quantity'' argument is omitted, tries to transfer all the items from the selected slot. If the destination slot already has items of a different type, returns false (does not try to fill the next slot, like suck() would). If there are fewer than ''quantity'' items in the selected slot or only room for fewer items in the destination slot, transfers as many as possible and returns true. If none can be transferred, returns false.
|examples=
{{Example
|desc=Transfers 32 items from the selected slot to slot 6.
|code=turtle.transferTo(6, 32)
}}
}}
This function became available in version 1.45

[[Category:Lua_Core_Functions]]

Turtle (API)

2013-05-04T20:17:44Z

Smiley43210: Added types

The Turtle API is used to work with your [[Turtle|Turtles]].

===Key===
{| class="wikitable"
! Color !! Turtles that can perform this
|-
| White ||All
|-{{row-lightgreen}}
|Green || Crafty
|-{{row-lightyellow}}
| Yellow || Mining, Felling, Digging, Farming
|-{{row-lightred}}
| Red || Any tool
|}


===API===
{| class="wikitable"
! width="100px" | Return
! width="200px" | Method name
! Description
! Min version
|-{{row-lightgreen}}
|{{type|boolean}} success
|[[turtle.craft]]({{type|int}} quantity)
|Craft items using ingredients anywhere in the Turtle's inventory and place results in the active slot. If a quantity is specified, it will craft only up to that many items, otherwise, it will craft as many of the items as possible.
|
|-
|{{type|boolean}} success
|[[turtle.forward]]()
|Let the Turtle move forward
|
|-
|{{type|boolean}} success
|[[turtle.back]]()
|Let the Turtle move back
|
|-
|{{type|boolean}} success
|[[turtle.up]]()
|Let the Turtle move up
|
|-
|{{type|boolean}} success
|[[turtle.down]]()
|Let the Turtle move down
|
|-
|{{type|boolean}} success
|[[turtle.turnLeft]]()
|Let the Turtle turn left
|
|-
|{{type|boolean}} success
|[[turtle.turnRight]]()
|Let the Turtle turn right
|
|-
|{{type|boolean}} success
|[[turtle.select]]({{type|int}} slotNum)
|The Turtle selects the given Slot (1 is top left, 16 (9 in 1.33 and earlier) is bottom right)
|
|-
|{{type|int}} result
|[[turtle.getItemCount]]({{type|int}} slotNum)
|Counts how many items are in the given Slot
|
|-
|{{type|int}} result
|[[turtle.getItemSpace]]({{type|int}} slotNum)
|Counts how many remaining items you need to fill the stack in the given Slot
|
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attack]]()
|Attacks in front of the turtle.
| 1.4
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attackUp]]()
|Attacks over the turtle.
| 1.4
|-{{row-lightred}}
|{{type|boolean}} success
|[[turtle.attackDown]]()
|Attacks under the turtle.
| 1.4
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.dig]]()
|Breaks the Block in front. With hoe: tills the dirt in front of it.
|
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.digUp]]()
|Breaks the Block above. With hoe: tills the dirt above it.
|
|-{{row-lightyellow}}
|{{type|boolean}} success
|[[turtle.digDown]]()
|Breaks the Block below. With hoe: tills the dirt below it.
|
|-
|{{type|boolean}} success
|[[turtle.place]]({{type|string}} signText)
|Places a Block of the selected slot in front. Engrave signText on signs if provided.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.placeUp]]()
|Places a Block of the selected slot above
|
|-
|{{type|boolean}} success
|[[turtle.placeDown]]()
|Places a Block of the selected slot below
|
|-
|{{type|boolean}} result
|[[turtle.detect]]()
|Detects if there is a Block in front. Does not detect mobs.
|
|-
|{{type|boolean}} result
|[[turtle.detectUp]]()
|Detects if there is a Block above
|
|-
|{{type|boolean}} result
|[[turtle.detectDown]]()
|Detects if there is a Block below
|
|-
|{{type|boolean}} result
|[[turtle.compare]]()
|Detects if the block in front is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareUp]]()
|Detects if the block above is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareDown]]()
|Detects if the block below is the same as the one in the currently selected slot
|
|-
|{{type|boolean}} result
|[[turtle.compareTo]]({{type|int}} slot)
|Compare the current selected slot and the given slot to see if the items are the same, yields true if they are the same, and false if not.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.drop]]({{type|int}} count)
|Drops all items in the selected slot, or if count is specified, drops that many items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e in front of the turtle) it will try to place into the inventory, returning false if the inventory is full.
|
|-
|{{type|boolean}} success
|[[turtle.drop|turtle.dropUp]]({{type|int}} count)
|Drops all items in the selected slot, or if count is specified, drops that many items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e above the turtle) it will try to place into the inventory, returning false if the inventory is full. If below a furnace, will place item in the bottom slot.
|
|-
|{{type|boolean}} success
|[[turtle.drop|turtle.dropDown]]({{type|int}} count)
|Drops all items in the selected slot, or if count is specified, drops that many items.<br />[>= 1.4 only:] If there is a inventory on the side (i.e below the turtle) it will try to place into the inventory, returning false if the inventory is full. If above a furnace, will place item in the top slot.
|
|-
|{{type|boolean}} success
|[[turtle.suck]]()
|Picks up an item stack of any number, from the ground or an inventory in front of the turtle. If the turtle can't pick up the item, the function yields false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.suck|turtle.suckUp]]()
|Picks up an item stack of any number, from the ground or an inventory above the turtle. If the turtle can't pick up the item, the function yields false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.suck|turtle.suckDown]]()
|Picks up an item stack of any number, from the ground or an inventory below the turtle. If the turtle can't pick up the item, the function yields false.
| 1.4
|-
|{{type|boolean}} success
|[[turtle.refuel]]({{type|int}} quantity)
|If the current selected slot contains a fuel item, it will consume it to give the turtle the ability to move.<br />Added in 1.4 and is only needed in needfuel mode. If the current slot doesn't contain a fuel item, it yields false. Fuel values for different items can be found at [[Turtle.refuel#Fuel_Values]]. If a quantity is specified, it will refuel only up to that many items, otherwise, it will consume all the items in the slot.
| 1.4
|-
|{{type|int}} fuel
|[[turtle.getFuelLevel]]()
|Returns the current fuel level of the turtle, this is the number of blocks the turtle can move.<br />If turtleNeedFuel = 0 then it yields "unlimited".
| 1.4
|-
|{{type|boolean}} success
|[[turtle.transferTo]]({{type|int}} slot, {{type|int}} quantity)
|Transfers items from the selected slot to the specified slot in the [quantity] inputted.
| 1.45
|}

Trivia:
During the 1.4 beta, turtle.getFuelLevel() in softcore(that is now turtleneedsfuel = 0) returned 9000.
[[Category:APIs]]

Turtle.detectDown

2013-05-04T20:15:56Z

Smiley43210: Corrected sentence casing (don't capitalize non-nouns in the middle of a sentence -_-)

{{lowercase}}
{{Function
|name=turtle.detectDown
|args=
|api=turtle
|returns={{type|boolean}} If turtle has detected a block below.
|addon=ComputerCraft
|desc=Detects if there is a Block Below.
|examples=
{{Example
|desc=Displays whether or not there is a block under the turtle.
|code=if turtle.detectDown() then
print("There is a block under me!")
else
print("There isn't a block under me!")
end
|output=A message on the turtle screen telling if a block is under the turtle.
}}
}}

[[Category:Lua_Core_Functions]]

Turtle.detectDown

2013-05-04T20:14:49Z

Smiley43210: Expanded the existing example

{{lowercase}}
{{Function
|name=turtle.detectDown
|args=
|api=turtle
|returns={{type|boolean}} If turtle has Detected a Block Below.
|addon=ComputerCraft
|desc=Detects if there is a Block Below.
|examples=
{{Example
|desc=Displays whether or not there is a block under the turtle.
|code=if turtle.detectDown() then
print("There is a block under me!")
else
print("There isn't a block under me!")
end
|output=A message on the turtle screen telling if a block is under the turtle.
}}
}}

[[Category:Lua_Core_Functions]]

Printer.getPageSize

2013-05-03T16:06:42Z

Smiley43210: Changed parent api

{{lowercase}}
{{Function
|name=printer.getPageSize
|returns=Width and Height of the Page in the Printer
|api=printer
|addon=ComputerCraft
|desc=Returns the size of the page.
|examples=
{{Example
|desc=Prints the size of a page.
|code=local x, y = printer.getPageSize()<br/>print(x ..", ".. y)
|output=<width>, <height>
}}
}}

[[Category:Lua_Core_Functions]]

Printer (API)

2013-05-03T16:06:14Z

Smiley43210: Add Method Name and Description row to table

The Printer API allows you to interact with printers.

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
Printer (API)
</td></tr>

<tr><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.getPaperLevel]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the amount of paper available in the paper tray.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.newPage]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Starts a new page. Returns true if page got started, false if not.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.endPage]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Ends the page and prints the page to the output tray. Returns true if page was ended, false if not.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.write]]([[string]] text)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Writes text to the paper, works the same way as [[term.write|term.write()]]</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.setPageTitle]]([[string]] title)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sets the title of the page.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.getInkLevel]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the amount of ink in the ink slot.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.getCursorPos]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the coordinates of the cursor on the paper, works the same way as [[term.getCursorPos|term.getCursorPos()]]</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.setCursorPos]]([[int (type)|int]] x, [[int (type)|int]] y)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sets the cursor pos, works the same way as [[term.setCursorPos|term.setCursorPos()]]</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.getPageSize]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the size of the paper, works the same way as [[term.getSize|term.getSize()]]</td></tr>
</table>

==Note==
All printer functions are to be used ''after'' wrapping the printer in a peripheral.
'''example''': printer = peripheral.wrap("left")

[[Category:Peripheral APIs]]

Printer

2013-05-03T14:31:45Z

Smiley43210: Add Method Name and Description row to table

{{NeedsWork|Printer methods are not documented on this page.}}
{{Block
|name=Printer
|image=Iso_Printer.png
|id=4094
|damage-value=Un-used.
|is-peripheral=Yes
|peripheral-api=Printer (API)
}}
The printer was added in the [[ComputerCraft]] 1.42 update. The printer is placed next to a computer, and allows for printing text onto paper with any color of ink.

== Recipes ==
{{Crafting grid
|A1=stone |B1=stone |C1=stone
|A2=stone |B2=Redstone |C2=stone
|A3=stone |B3=Ink_Sac |C3=stone
|Output=printer}}{{Crafting grid
|A1=Page |B1=Page |C1=Page
|A2=String |B2=Leather
|Output=printed_book_
}}
== Usage ==
To use a printer, place it adjacently but not diagonally next to a computer (left, right, top, bottom, front, or back side). Place any color ink in the single left slot, and paper in any of the top slots.

If you are using blocks to pull/insert items from the printer the different slots are available from these sides:
Paper tray is accessible from the top, output paper tray is accessible from the front or bottom, and the ink slot is accessible from the back or sides.

[[File:PrinterGUI.png|thumb|256px|GUI of the Printer]]

== Printer API ==
The printer API allows programs to interact in various ways with the printer. In order for these functions to become available, you must first wrap the printer as a peripheral using [[peripheral.wrap]]().
<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
Printer API
</td></tr>

<tr><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.getPaperLevel]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the amount of paper available in the paper tray.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.newPage]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Starts a new page. Returns true if page got started, false if not.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.endPage]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Ends the page and prints the page to the output tray. Returns true if page was ended, false if not.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.write]]([[string]] text)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Writes text to the paper, works the same way as [[term.write|term.write()]]</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.setPageTitle]]([[string]] title)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sets the title of the page.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.getInkLevel]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the amount of ink in the ink slot.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.getCursorPos]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the coordinates of the cursor on the paper, works the same way as [[term.getCursorPos|term.getCursorPos()]]</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.setCursorPos]]([[int (type)|int]] x, [[int (type)|int]] y)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sets the cursor pos, works the same way as [[term.setCursorPos|term.setCursorPos()]]</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[printer.getPageSize]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the size of the paper, works the same way as [[term.getSize|term.getSize()]]</td></tr>
</table>

[[Category:Blocks]]

Coroutine (API)

2013-05-03T14:14:13Z

Smiley43210: Added types

:{| border="1" class="wikitable"
| '''Bug'''
'''From ComputerCraft 1.3''' this API suffers from the problem of potentially spawning Java threads that live forever therefore, use of coroutines should be minimized. This is '''fixed in ComputerCraft 1.32+''', though.
|}

''This is for the Coroutine API. For the Coroutine Object, visit [[Coroutine (type)]].''

Coroutine is a default Lua 5.1 API defined [http://www.lua.org/manual/5.1/manual.html#5.2 here]. Please list any non-working functions on this page.

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="3" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
Coroutine (API)
</td></tr>

<tr><td style="width: 100px; background: #E0E0E0; padding: .4em; font-weight:bold;">Return</td><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">{{Type|coroutine}} coro</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[coroutine.create]]({{Type|function}} f)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Creates a new coroutine.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">{{Type|boolean}} success, …</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[coroutine.resume]]({{Type|coroutine}} coro, [var1], [var2], ...)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Starts or resumes an existing coroutine.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">{{Type|coroutine}} coro</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[coroutine.running]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the currently executing coroutine.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">{{Type|string}} status</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[coroutine.status]]({{type|coroutine}} coroutine)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the status of the given coroutine.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">{{Type|function}} coroutine wrapper</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[coroutine.wrap]]({{type|function}} function)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Creates a new coroutine and wraps it in a function.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[var3], [var4], …</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[coroutine.yield]]([var1], [var2], …)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Pauses the currently executing coroutine and passes control to its caller.</td></tr>
</table>

== Coroutine States and Ancestry ==
Every coroutine is in one of four states:
* A ''suspended'' coroutine is one that has not yet been started or that has yielded. A suspended coroutine can become running if it is passed to [[coroutine.resume]].
* A ''running'' coroutine is one that is currently executing code. Only one coroutine can be running at a time on a particular computer. A running coroutine can become suspended if it [[coroutine.yield]], normal if it calls [[coroutine.resume]] on another coroutine, or dead by if it returns from its body function.
* A ''normal'' coroutine is one that, while running, resumed another coroutine (the ''child coroutine''). A normal coroutine can become running if its child calls [[coroutine.yield]] or returns from its function body.
* A ''dead'' coroutine is one that, while running, returned from its function body. A dead coroutine can never change state.

While suspended and dead coroutines simply sit loose with no connections to other coroutines, normal and running coroutines have an ancestry relationship between them. Exactly one coroutine is running at any given time, and the running coroutine has no children. Every running or normal coroutine except the top-level BIOS coroutine has a parent, and this relationship forms a chain with one end (the furthest ancestor) being the top-level BIOS coroutine and the other end (the furthest descendant) being the running coroutine. Remember that only the running coroutine can actually execute code, so any functions invoked must be invoked by that coroutine. Then, calling [[coroutine.resume]] makes the chain longer by taking a previously suspended coroutine, hanging it underneath the current coroutine as a new child, and making the current coroutine normal and the new child running. Meanwhile, calling [[coroutine.yield]] makes the chain shorter by turning the currently executing coroutine into a suspended coroutine, detaching it from the chain, and letting its former parent become running.

It is important not to confuse this coroutine chain with the function call stack. Each individual coroutine contains a complete function call stack of its own, rooted at the coroutine’s body function, whether the coroutine is running, normal, or suspended; the chain described in the previous paragraph refers to how entire coroutines are connected together.

== Examples ==
As the coroutine API is very tightly coupled and many of its function must be used to get any interesting results, examples are shown here instead of on the individual function pages.

=== Using the Basic Coroutine Functions ===
This example demonstrates using the basic coroutine functions to pass control and data between coroutines. This example prints the numbers 1 through 17 in order, showing how control flow moves through the main program coroutine and the two created coroutines, while using assertions to show how data flows through the program:

-- These variables will hold the coroutine objects.
local c1 = nil
local c2 = nil

-- This function will be the body of the first coroutine.
local function f1(x)
-- The main code, below, starts c1 first, passing 1.
-- Thus c1 should be running, c2 should be suspended (not started yet), and x should receive the value from main, 1.
-- STEP 2: Check these assumptions.
print(2)
assert(coroutine.status(c1) == "running")
assert(coroutine.status(c2) == "suspended")
assert(x == 1)
-- STEP 3: Run c2 until it yields, start it off with the value 2.
print(3)
success, value = coroutine.resume(c2, 2)
assert(success)
-- In step 6, c2 yields and passes back the value 3.
-- Then c2, having yielded, should be suspended, and c1 should be running again.
-- STEP 7: Check all that.
print(7)
assert(coroutine.status(c1) == "running")
assert(coroutine.status(c2) == "suspended")
assert(value == 3)
-- STEP 8: Run c2 again, passing it the value 4.
-- Since c2 has already run before, this time the 4 will come out of the yield() instead of appear as a function parameter.
print(8)
success, value = coroutine.resume(c2, 4)
-- In step 10, c2 yields and passes back the value 5.
-- Then c2, having yielded, should be suspended, and c1 should be running again.
-- STEP 11: Check all that.
print(11)
assert(coroutine.status(c1) == "running")
assert(coroutine.status(c2) == "suspended")
assert(value == 5)
-- STEP 12: Yield, turning c1 back into a suspended coroutine and continuing execution of the main program, passing back value 6.
print(12)
value = coroutine.yield(6)
end

-- This function will be the body of the second coroutine.
local function f2(x)
-- The first time c2 is run, it is run from f1, which passes 2.
-- Thus c1 should be normal (as we are nested inside it), c2 should be running, and x should receive the value from f1, 2.
-- STEP 4: Check these assumptions.
print(4)
assert(coroutine.status(c1) == "normal")
assert(coroutine.status(c2) == "running")
assert(x == 2)
-- Because c1 is not suspended, we should not be able to resume it.
-- STEP 5: Check this is correct.
print(5)
success, value = coroutine.resume(c1)
assert(not success)
assert(value == "cannot resume normal coroutine")
-- STEP 6: Yield, turning c2 back into a suspended coroutine and continuing execution of c1, passing back value 3.
print(6)
value = coroutine.yield(3)
-- In step 8, c1 resumed c2 again and passed the value 4.
-- c2 should now be running again, and c1 normal again.
-- STEP 9: Check all that.
print(9)
assert(coroutine.status(c1) == "normal")
assert(coroutine.status(c2) == "running")
assert(value == 4)
-- STEP 10: Yield, turning c2 back into a suspended coroutine and continuing execution of c1, passing back value 5.
print(10)
value = coroutine.yield(5)
-- In step 14, the main program resumed c2 directly and passed the value 7, bypassing c1.
-- So c2 should be running and c1 should be suspended.
-- STEP 15: Check all that.
print(15)
assert(coroutine.status(c1) == "suspended")
assert(coroutine.status(c2) == "running")
assert(value == 7)
-- STEP 16: Now die, returning value 8 to the main program.
print(16)
return 8
end

-- Construct the two coroutines.
c1 = coroutine.create(f1)
c2 = coroutine.create(f2)

-- Newly constructed coroutines are always suspended.
assert(coroutine.status(c1) == "suspended")
assert(coroutine.status(c2) == "suspended")

-- STEP 1: Run c1 until it yields, starting it off with the value 1.
print(1)
success, value = coroutine.resume(c1, 1)
assert(success)

-- In step 12, c1 should have yielded and returned the value 6.
-- So now c1 and c2 should both be suspended.
-- STEP 13: Check all that.
print(13)
assert(coroutine.status(c1) == "suspended")
assert(coroutine.status(c2) == "suspended")
assert(value == 6)

-- STEP 14: Run c2 directly, NOT nested inside c1 this time, passing it the value 7.
print(14)
success, value = coroutine.resume(c2, 7)
assert(success)

-- c2 should have exited normally, returning the value 8.
-- Therefore c1 should still be suspended, but c2 should be dead.
-- STEP 17: Check all that.
print(17)
assert(coroutine.status(c1) == "suspended")
assert(coroutine.status(c2) == "dead")
assert(value == 8)

=== Using Coroutine Wrapper Functions ===
This second example is virtually identical, but shows using [[coroutine.wrap]] and wrapper functions instead of the basic coroutine functions (checks of [[coroutine.status]] have been removed as the raw coroutine objects are not available):

-- These variables will hold the coroutine wrapper functions.
local cw1 = nil
local cw2 = nil

-- This function will be the body of the first coroutine.
local function f1(x)
-- The main code, below, starts c1 first, passing 1.
-- Thus c1 should be running, c2 should be suspended (not started yet), and x should receive the value from main, 1.
-- STEP 2: Check these assumptions.
print(2)
assert(x == 1)
-- STEP 3: Run c2 until it yields, start it off with the value 2.
print(3)
value = cw2(2)
-- In step 6, c2 yields and passes back the value 3.
-- Then c2, having yielded, should be suspended, and c1 should be running again.
-- STEP 7: Check all that.
print(7)
assert(value == 3)
-- STEP 8: Run c2 again, passing it the value 4.
-- Since c2 has already run before, this time the 4 will come out of the yield() instead of appear as a function parameter.
print(8)
value = cw2(4)
-- In step 10, c2 yields and passes back the value 5.
-- Then c2, having yielded, should be suspended, and c1 should be running again.
-- STEP 11: Check all that.
print(11)
assert(value == 5)
-- STEP 12: Yield, turning c1 back into a suspended coroutine and continuing execution of the main program, passing back value 6.
print(12)
value = coroutine.yield(6)
end

-- This function will be the body of the second coroutine.
local function f2(x)
-- The first time c2 is run, it is run from f1, which passes 2.
-- Thus c1 should be normal (as we are nested inside it), c2 should be running, and x should receive the value from f1, 2.
-- STEP 4: Check these assumptions.
print(4)
assert(x == 2)
-- Because c1 is not suspended, we should not be able to resume it.
-- STEP 5: Check this is correct (we must use pcall because an error will be raised).
print(5)
success, value = pcall(cw1)
assert(not success)
-- STEP 6: Yield, turning c2 back into a suspended coroutine and continuing execution of c1, passing back value 3.
print(6)
value = coroutine.yield(3)
-- In step 8, c1 resumed c2 again and passed the value 4.
-- c2 should now be running again, and c1 normal again.
-- STEP 9: Check all that.
print(9)
assert(value == 4)
-- STEP 10: Yield, turning c2 back into a suspended coroutine and continuing execution of c1, passing back value 5.
print(10)
value = coroutine.yield(5)
-- In step 14, the main program resumed c2 directly and passed the value 7, bypassing c1.
-- So c2 should be running and c1 should be suspended.
-- STEP 15: Check all that.
print(15)
assert(value == 7)
-- STEP 16: Now die, returning value 8 to the main program.
print(16)
return 8
end

-- Construct the two coroutine wrappers.
cw1 = coroutine.wrap(f1)
cw2 = coroutine.wrap(f2)

-- STEP 1: Run cw1 until it yields, starting it off with the value 1.
print(1)
value = cw1(1)

-- In step 12, c1 should have yielded and returned the value 6.
-- So now c1 and c2 should both be suspended.
-- STEP 13: Check all that.
print(13)
assert(value == 6)

-- STEP 14: Run c2 directly, NOT nested inside c1 this time, passing it the value 7.
print(14)
value = cw2(7)

-- c2 should have exited normally, returning the value 8.
-- Therefore c1 should still be suspended, but c2 should be dead.
-- STEP 17: Check all that.
print(17)
assert(value == 8)

== Interaction with Other APIs ==
Raw coroutines are not always safe to use with other API functions. The reason is that [[os.pullEventRaw]] (and therefore [[os.pullEvent]], which calls it) are themselves built using coroutines: <code>os.pullEventRaw</code> actually invokes [[coroutine.yield]], passing the event type filter up to what it expects is the [[Parallel (API)|parallel API]], which would resume the coroutine once a matching event arrives. This is how the parallel API allows other code to run while one function is blocking waiting for an event. However, it means if you call <code>os.pullEventRaw</code> ''or any other function that uses it'' while managing coroutines yourself, you will see a coroutine unexpectedly yield, with the parent [[coroutine.resume]] being passed as a return value the filter string passed to <code>os.pullEventRaw</code>.

In this situation, it is essential that a developer carefully audit any APIs (s)he may wish to use to verify whether they could possibly block—many APIs, even those one might not expect, fall into this category. Some examples are:
* [[rednet.receive]] blocks until either a [[Rednet message (event)|rednet_message event]] or (if a timeout was requested) a matching [[Timer (event)|timer event]] occurs.
* [[Gps (API)|gps.locate]] blocks until either a number of [[Modem message (event)|modem_message events]] or (if a timeout was requested) a matching [[Timer (event)|timer event]] occurs.
* [[http.get]] blocks until an [[Http success (event)|HTTP success event]] or [[Http failure (event)|HTTP failure event]] occurs.
* [[IO (API)|io.read]] and the built-in [[read]] functions block waiting for, presumably, either [[Char (event)|char events]] or [[Key (event)|key events]].
* [[os.sleep]] blocks until a matching [[Timer (event)|timer event]] occurs.
* [[textutils.slowPrint]] calls [[os.sleep]].
* [[textutils.pagedPrint]] blocks until a [[Key (event)|key event]] occurs for each page.
* Most of the functions in the [[Turtle (API)|turtle API]] (with the exception of [[turtle.getItemCount]], [[turtle.getItemSpace]], and [[turtle.getFuelLevel]]) block waiting for a [[Turtle response (event)|turtle response event]].

Although it is not always practical to do so, in some situations, the [[Parallel (API)|parallel API]] may be preferable to using coroutines directly, as it handles event dispatching properly. However, it does not allow chaining coroutine invocations, nor does it allow adding coroutines to the parallel set after parallel execution has started. If coroutines are to be used directly, an application may either ensure it avoids any blocking API calls, or may arrange to handle event dispatch the same way that the parallel API does so that the blocking functions work properly. For example, one might arrange the convention that the top-level coroutine in the application will call [[os.pullEvent]] and deliver any returned events to sub-coroutines, the same way that the parallel API does, thus allowing those sub-coroutines to themselves call [[os.pullEvent]], while insisting on a convention that more deeply nested coroutines never call [[os.pullEvent]] at all.

[[Category:APIs]]

Vector (API)

2013-05-03T14:11:50Z

Smiley43210: Changed to use type template, italicized variables

The vector API provides methods to create and manipulate vectors.

An introduction to vectors can be found on [[Wikipedia:Euclidean_vector|Wikipedia]].

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
Vector (API)
</td></tr>

<tr><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vector.new]]({{type|float}} x, {{type|float}} y, {{type|float}} z)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Creates a vector.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:add]]([[Vector (API)|vector]] vectorB)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Adds ''vectorB'' to ''vectorA'' and returns the resulting vector. Can also be used by writing vectorA + vectorB.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:sub]]([[Vector (API)|vector]] vectorB)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Subtracts ''vectorB'' from ''vectorA'' and returns the resulting vector. Can also be used by writing vectorA - vectorB.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:mul]]({{type|float}} n)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Scalar multiplies ''vectorA'' with ''n'' and returns the resulting vector. Can also be used by writing vectorA * n.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:dot]]([[Vector (API)|vector]] vectorB)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the dot product of ''vectorA'' and ''vectorB''.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:cross]]([[Vector (API)|vector]] vectorB)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the vector which resulted in the cross product of ''vectorA'' and ''vectorB''.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:length]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the vector's length.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:normalize]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Normalizes the vector and returns the result as a new vector.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:round]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Rounds the vector coordinates to the nearest integers and returns the result as a new vector.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:tostring]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns a string representation of the vector in the form of "x,y,z".</td></tr>
</table>

[[Category:APIs]]

Vectors act much like tables, storing the coordinate data with labels "x", "y" and "z". However, it can be worthwhile to use vectors instead of tables in certain situations.

Among other things, vectors can be useful to aid in creating navigation algorithms using GPS coordinates.

To transform GPS quickly into vector format, simply use:
local a = vector.new(gps.locate())

Then, getting the displacements between a turtle position and a desired location becomes:
local b = vector.new(20, 85, 40)
local c = a - b
--displacement in the x direction: c.x
--displacement in the y direction: c.y
--displacement in the z direction: c.z

By making use of vectors, code can be cleaner and easier to follow.

Vector (API)

2013-05-03T14:09:26Z

Smiley43210: Changed to use type template

The vector API provides methods to create and manipulate vectors.

An introduction to vectors can be found on [[Wikipedia:Euclidean_vector|Wikipedia]].

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
Vector (API)
</td></tr>

<tr><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vector.new]]({{type|float}} x, {{type|float}} y, {{type|float}} z)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Creates a vector.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:add]]([[Vector (API)|vector]] vectorB)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Adds vectorB to vectorA and returns the resulting vector. Can also be used by writing vectorA + vectorB.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:sub]]([[Vector (API)|vector]] vectorB)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Subtracts vectorB from vectorA and returns the resulting vector. Can also be used by writing vectorA - vectorB.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:mul]]([[float (type)|float]] n)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Scalar multiplies vectorA with n and returns the resulting vector. Can also be used by writing vectorA * n.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:dot]]([[Vector (API)|vector]] vectorB)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the dot product of vectorA and vectorB.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:cross]]([[Vector (API)|vector]] vectorB)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the vector which resulted in the cross product of vectorA and vectorB.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:length]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the vector's length.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:normalize]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Normalizes the vector and returns the result as a new vector.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:round]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Rounds the vector coordinates to the nearest integers and returns the result as a new vector.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[vectorA:tostring]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns a string representation of the vector in the form of "x,y,z".</td></tr>
</table>

[[Category:APIs]]

Vectors act much like tables, storing the coordinate data with labels "x", "y" and "z". However, it can be worthwhile to use vectors instead of tables in certain situations.

Among other things, vectors can be useful to aid in creating navigation algorithms using GPS coordinates.

To transform GPS quickly into vector format, simply use:
local a = vector.new(gps.locate())

Then, getting the displacements between a turtle position and a desired location becomes:
local b = vector.new(20, 85, 40)
local c = a - b
--displacement in the x direction: c.x
--displacement in the y direction: c.y
--displacement in the z direction: c.z

By making use of vectors, code can be cleaner and easier to follow.

HTTP (API)

2013-05-03T14:07:46Z

Smiley43210: Added types

:{|class="wikitable"
| '''The HTTP API must be enabled in mod_ComputerCraft.cfg before being used. To enable it open .minecraft/config/ComputerCraft.cfg and change enableAPI_http=false to enableAPI_http=true.'''
|}

The HTTP API allows interfacing with websites and downloading from them.

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
HTTP (API)
</td></tr>

<tr><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[http.request]]( {{type|string}} url, {{type|string}} *postData )</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sends a HTTP request to a website.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[http.get]]( {{type|string}} url )</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sends a HTTP GET request to a website.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[http.post]]( {{type|string}} url, {{type|string}} postData )</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sends a HTTP POST request to a website.</td></tr>
</table>

A period of time after a http.request() call is made, a "http_success" or "http_failure" event will be raised to os.pullEvent(). Arguments are the URL and a file handle if successful. http.get() blocks until this event is fired.

[[Category:APIs]]

Help.topics

2013-05-02T15:56:53Z

Smiley43210: Corrected grammar

{{lowercase}}
{{Function
|name=help.topics
|api=help
|returns={{Type|table}} of all valid topics
|addon=ComputerCraft
|desc=Returns a list of all available help topics. This is all files found in the directories in the search path returned by [[help.path]]. The returned table is sorted.
|examples=
{{Example
|desc=Lists all valid help topics.
|code=for _, v in ipairs(help.topics()) do
print(v)
end
|output=List of all valid help topics
}}
}}

[[Category:API_Functions]]

Help (API)

2013-05-02T15:53:36Z

Smiley43210: Removed unnecessary duplicate table code on bottom

The Help API allows you to mess around with the help files.

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="3" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
Help (API)
</td></tr>

<tr><td style="width: 100px; background: #E0E0E0; padding: .4em; font-weight:bold;">Return</td><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">{{Type|string}} path</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[help.path]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the list of locations the API will look in for help files.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[nil]]</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[help.setPath]]({{Type|string}} path)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Sets the list of locations the API will look in for help files.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">{{Type|string}} path, or [[nil]]</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[help.lookup]]({{Type|string}} topic)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the path to the file containing the help page for <var>topic</var>, or [[nil]] if the topic cannot be found.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">{{Type|table}} topics</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[help.topics]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns a list of all available help topics.</td></tr>

</table>

[[Category:APIs]]

Keys (API)

2013-05-02T15:50:57Z

Smiley43210: Added type

The Keys API provides a table of numerical codes corresponding to keyboard keys, suitable for decoding [[Key (event)|key events]].

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
keys (API)
</td></tr>

<tr><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[keys.getName]]({{type|int}} code)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Translates a numerical key code to a human-readable name.</td></tr>

</table>

Although this API contains only one method, it also contains a vast number of constants, one per key, containing the numerical key codes for those keys. As of ComputerCraft 1.52, the following constants are defined:
* a
* b
* c
* d
* e
* f
* g
* h
* i
* j
* k
* l
* m
* n
* o
* p
* q
* r
* s
* t
* u
* v
* w
* x
* y
* z
* one
* two
* three
* four
* five
* six
* seven
* eight
* nine
* zero
* minus
* equals
* backspace
* tab
* leftBracket
* rightBracket
* enter
* leftCtrl
* semiColon
* apostrophe
* grave
* leftShift
* backslash
* comma
* period
* slash
* rightShift
* multiply
* leftAlt
* space
* capsLock
* f1
* f2
* f3
* f4
* f5
* f6
* f7
* f8
* f9
* f10
* numLock
* scollLock
* numPad7
* numPad8
* numPad9
* numPadSubtract
* numPad4
* numPad5
* numPad6
* numPadAdd
* numPad1
* numPad2
* numPad3
* numPad0
* numPadDecimal
* f11
* f12
* f13
* f14
* f15
* kana
* convert
* noconvert
* yen
* numPadEquals
* cimcumflex
* at
* colon
* underscore
* kanji
* stop
* ax
* numPadEnter
* rightCtrl
* numPadComma
* numPadDivide
* rightAlt
* pause
* home
* up
* pageUp
* left
* right
* end
* down
* pageDown
* insert
* delete

[[Category:APIs]]

Gps (API)

2013-05-02T15:50:11Z

Smiley43210: Simplified source, properly closed <td> and <tr> tags

The GPS API provides a method for turtles and computers to retrieve their own locations.

It broadcasts a PING message over [[Rednet_(API)|rednet]] and wait for responses. In order for this system to work, there must be at least 4 computers used as gps ''hosts'' which will respond and allow [[Wikipedia:Trilateration|trilateration]]. Three of these hosts should be in a plane, and the fourth should be either above or below the other three. You can set up hosts using the [[Gps (program)|gps program]].

Note: When entering in the coordinates for the ''host'' you need to put in the x,y,z of the computer, not the modem, as all rednet distances are measured from the block the computer is in.


<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="3" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
Gps (API)
</td></tr>

<tr><td style="width: 100px; background: #E0E0E0; padding: .4em; font-weight:bold;">Return</td><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">({{Type|int}} x, {{Type|int}} y, {{Type|int}} z), or [[nil]]</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">gps.locate([<nowiki></nowiki>{{Type|float}} timeout [, {{Type|boolean}} debug]])</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Tries to retrieve the computer or turtles own location. On success, returns the location of the turtle’s modem. On failure (if no responses are received for <var>timeout</var> seconds, by default 2), returns [[nil]]. If <var>debug</var> is <code>true</code>, debug messages are printed.</td></tr></table>

== Example ==
print("Man I am so lost right now!")
local x, y, z = gps.locate(5)
if x == nil then
print("Nope, still lost :(")
else
print("I am at ",x," ",y," ",z)
end

== Vector Example ==
GPS position and navigation can be handled more easily using a [[vector (API)|vector]].

local home = vector.new(45, 85, 20)
local position = vector.new(gps.locate(5))
local displacement = position - home

print("I am ", displacement.tostring(), " away from home!!!")

code>true

[[Category:APIs]]

Textutils (API)

2013-05-02T15:41:34Z

Smiley43210: Changed to use type template

{{NeedsWork|Needs <s>5</s> 3 function pages, 1 function descriptions. ''[[User:AfterLifeLochie|AfterLifeLochie]] 02:40, 29 November 2012 (MSK)''}}
The Textutils API is used to format and manipulate strings easily.

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
Textutils (API)
</td></tr>

<tr><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[textutils.slowPrint]]({{type|string}} text, {{type|int}} rate)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Slowly prints the text. Only difference is, it leaves a new-line after it.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[textutils.slowWrite]]({{type|string}} text, {{type|int}} rate)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Slowly writes the text.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[textutils.formatTime]]({{type|int}} time, {{type|boolean}} TwentyFourHour)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Put a time into it, and it spews it out in a different format. Example: print(textutils.formatTime(os.time(), false))</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[textutils.tabulate]]({{type|table}} table, {{type|table}} table2, ...)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Prints tables in an ordered form. Each table is a row, the column(s)' width is auto-adjusted.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[textutils.pagedTabulate]]({{type|table}} table, {{type|table}} table2, ...)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Prints tables in an ordered form, like [[textutils.tabulate]]. However, it waits for confirmation before scrolling down..</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[textutils.pagedPrint]]({{type|string}} text, {{type|string}} confirmation_lines)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Prints string ''text'' onto the screen, but waits for confirmation before scrolling down.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[textutils.serialize]]({{type|table}} table)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns a string representation of the table ''table'' for storage or transmission.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[textutils.unserialize]]({{type|string}} text)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns a table reassembled from the string ''text''.</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[textutils.urlEncode]]({{type|string}} text)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Makes a string safe to encode into a url. Spaces are replaced with +s. Unsafe characters such as '\', '£' and '}' are translated into ASCII code and preceded with a % for transmission. For reference visit: [http://www.blooberry.com/indexdot/html/topics/urlencoding.htm].</td></tr>
</table>

[[Category:APIs]]

Modem (API)

2013-05-02T15:34:39Z

Smiley43210: Change to use newer table style.

:''This page is for the modem API. For the blocks, see [[Modem]].''

With the advent of ComputerCraft 1.5, the behavior of modems has changed somewhat drastically. Although the Rednet API still has the same functionality, it is really just a wrapper for what is a completely different system underneath.

The major change introduced to modems in this version of ComputerCraft is channels: Channels are essentially open networks which can be opened, closed, and listened on by any computer within range. To interact with channels, one must wrap/interact directly with the peripheral as opposed to the previous interaction with the rednet API.

Here is a list of functions available from modems:

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px;">
[[File:Grid_disk.png|24px]]  
Modem (API)
</td></tr>

<tr><td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Method Name</td><td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[modem.isOpen]]({{type|int}} channel)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Checks to see if ''channel'' is open</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[modem.open]]({{type|int}} channel)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Opens ''channel'' to allow for listening. The channel specified must be larger than 0 and less than 65535</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[modem.close]]({{type|int}} channel)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Closes an open channel to disallow listening</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[modem.closeAll]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Closes all open channels</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[modem.transmit]]({{type|int}} channel, {{type|int}} replyChannel, {{type|string}} message)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Transmits a message on the specified channel</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[modem.isWireless]]()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns true if the modem is wireless; false if it is wired</td></tr>
</table>

==Sending Messages==
Sending messages is simple and does not require that you open any channels. Simply use the transmit function like so:
<span>
local modem = peripheral.wrap("right") --Wraps the modem on the right side.
modem.transmit(3, 1, "Hello world!")
peripheral.call("right", "transmit", 3, 1, "This will also work!")
</span>

What did that do? First I wrapped the peripheral in order to interact with it. Second, I used modem.transmit(channel, replyChannel, message) in order to send my message. In case you were wondering, the reply channel is captured by the listening computer and suggests which channel they should reply on.

==Receiving Messages==
Receiving messages requires that you be familiar with events. As of this moment, there is no api which cuts out events from the process. Here is an example of how to receive messages:
<span>
local modem = peripheral.wrap("left")
modem.open(3)--Open channel 3 so that we can listen on it
local event, modemSide, senderChannel,
replyChannel, message, senderDistance = os.pullEvent("modem_message")
print("I just received a message from: "..senderChannel)
print("I should apparently reply on: "..replyChannel)
print("The modem receiving this is located on the "..modemSide.." side")
print("The message was: "..message)
print("The sender is: "..senderDistance.." blocks away from me.")
</span>
So what did I do? Quite simply, I called os.pullEvent() with the string argument "modem_message", which blocks all other events from being returned. When the "modem_message" event is captured, it returns the arguments: event, modemSide, senderChannel, replyChannel, message, senderDistance. I captured these and then printed them out.

==Keep in Mind...==
* You can only open 128 channels at any given time.
* The max channel you can open is 65535.
* You can listen on more than one channel at a time. For example, if I have channel 3 and channel 5 open and somebody sends a message on channel 5, I will still receive it. If they send a message on channel 3, I will receive that.
* Sending messages does not require you to open any channels prior to sending it.
* If you aren't receiving a message when you think you should, check to make sure that you have opened the channel first!
* Modems and channels are not secure! If you are sending a message over rednet, it is available to any computer listening on the sent channel.

[[Category:Peripheral APIs]]