ComputerCraft Wiki - User contributions [en]

Term (API)

2013-12-29T19:24:07Z

Immibis: fix getCursorPos return type

The Terminal API provides functions for writing text to the terminal and monitors, and drawing ASCII graphics.

Methods in ''italics'' are available only to [[Advanced Computer|Advanced Computers]] and [[Advanced Monitor|Advanced Monitors]].
Methods in '''bold''' are available only to [[Monitor|Monitors]].

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

{{API table/row|[[term.write]]({{type|string}} text)|{{type|nil}}
|Writes ''text'' to the screen.|odd}}

{{API table/row|[[term.clear]]()|{{type|nil}}
|Clears the entire screen}}

{{API table/row|[[term.clearLine]]()|{{type|nil}}
|Clears the line the cursor is on|odd}}

{{API table/row|[[term.getCursorPos]]()|{{type|number}} x, {{type|number}} y
|Returns two arguments containing the x and the y position of the cursor.}}

{{API table/row|[[term.setCursorPos]]({{type|number}} x, {{type|number}} y)|{{type|nil}}
|Sets the cursor's position.|odd}}

{{API table/row|[[term.setCursorBlink]]({{type|boolean}} bool)|{{type|nil}}
|Disables the blinking or turns it on.}}

{{API table/row|[[term.isColor]]()|{{type|boolean}}
|Returns if the computer supports color. (Used to determine whether or not an [[Advanced Computer]] is being used)|odd}}

{{API table/row|[[term.getSize]]()|{{type|number}} x, {{type|number}} y
|Returns two arguments containing the x and the y values stating the size of the screen. (Good for if you're making something to be compatible with both [[Turtle]]s and [[Computer]]s.)}}

{{API table/row|[[term.scroll]]({{type|number}} n)|{{type|nil}}
|Scrolls the terminal ''n'' lines.|odd}}

{{API table/row|[[term.redirect]](target)|{{type|nil}}
|Redirects terminal output to a monitor or other redirect target. (Use [[peripheral.wrap]] to acquire a monitor "object".)}}

{{API table/row|[[term.restore]]()|{{type|nil}}
|Restores terminal output to the previous target.|odd}}

{{API table/row|''[[term.setTextColor]]({{type|number}} [[Colors (API)|color]])''|{{type|nil}}
|Sets the text color of the terminal. Available only to [[Advanced Computer|Advanced Computers]] and [[Advanced Monitor]]s.}}

{{API table/row|''[[term.setBackgroundColor]]({{type|number}} [[Colors (API)#Colors|color]])''|{{type|nil}}
|Sets the background color of the terminal. Available only to [[Advanced Computer|Advanced Computers]] and [[Advanced Monitor]]s.|odd}}

{{API table/row|'''[[monitor.setTextScale]]({{type|number}} scale)'''|{{type|nil}}
|Sets the text scale on a [[Monitor]].}}

}}

[[Category:APIs]]

Parallel (API)

2013-09-14T21:50:03Z

Immibis: use API table template

Parallel is an API which allows you to multitask.

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

{{API table/row
|[[parallel.waitForAny]](function1, function2, ...)|{{type|nil}}
|Runs all the functions at the same time, and stops when any of them returns.
|odd}}

{{API table/row
|[[parallel.waitForAll]](function1, function2, ...)|{{type|nil}}
|Runs all the functions at the same time, and stops when all of them have returned.
|}}

}}

[[Category:APIs]]

Paintutils (API)

2013-09-14T21:48:49Z

Immibis: use API table template

Paintutils is a default API for advanced computers which can draw pixels and lines, and load and draw image files.

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

{{API table/row
|[[paintutils.loadImage]]({{type|string}} path)|{{type|table}} image
|Returns an image object from <var>path</var>.
|odd}}

{{API table/row
|[[paintutils.drawImage]]({{type|table}} image, {{type|number}} x, {{type|number}} y)|{{type|nil}}
|Draws an image at (<var>x</var>, <var>y</var>) where <var>image</var> is an image object.
|}}

{{API table/row
|[[paintutils.drawPixel]]({{type|number}} x, {{type|number}} y, {{type|number}} colour)|{{type|nil}}
|Draws a pixel at (<var>x</var>, <var>y</var>) in the specified <var>colour</var>.
|odd}}

{{API table/row
|[[paintutils.drawLine]]({{type|number}} startX, {{type|number}} startY, {{type|number}} endX, {{type|number}} endY, {{type|number}} color)|{{type|nil}}
|Draws a line from (<var>startX</var>, <var>startY</var>) to (<var>endX</var>, <var>endY</var>) in the specified <var>colour</var>.
|}}

}}

[[Category:APIs]]

OS (API)

2013-09-14T21:45:36Z

Immibis: fixed caps

The Operating System API allows for interfacing with the Lua based Operating System itself.

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

{{API table/row
|[[os.version]]()|{{type|string}} version
|Returns the version of the OS the computer is running, which (for CraftOS) also contains the version of ComputerCraft.
|odd}}

{{API table/row
|[[os.getComputerID]]()|{{type|number}} id
|Returns the unique ID of this computer. [[os.computerID]]() also behaves exactly the same as [[os.getComputerID]]().
|}}

{{API table/row
|[[os.getComputerLabel]]()|{{type|string}} label
|Returns the label of this computer. [[os.computerLabel]]() also behaves exactly the same as [[os.getComputerLabel]](). 
|odd}}

{{API table/row
|[[os.setComputerLabel]]({{type|string}} label)|{{type|nil}}
|Set the label of this computer.
|}}

{{API table/row
|[[os.run]]({{type|table}} environment, {{type|string}} program path [, {{type|string}} arguments])|{{type|nil}}
|An advanced way of starting programs. A started program will have a given <var>environment</var> table which determines what functions it has available, as well as any variables it will be able to access by default. You may prefer to use the [[Shell (API)]] unless you need to do something special.
|odd}}

{{API table/row
|[[#APIs|os.loadAPI]]({{type|string}} name)|{{type|nil}}
|Loads a Lua script as an API in its own namespace (see example). It will be available to '''all''' programs that run on the terminal.
|}}

{{API table/row
|[[#APIs|os.unloadAPI]]({{type|string}} name)|{{type|nil}}
|Unloads a previously loaded API.
|odd}}

{{API table/row
|[[Os.pullEvent|os.pullEvent]]({{type|string}}/{{type|nil}} target-event)|any
|Blocks until the computer receives an event, or if <var>target-event</var> is specified, will block until an instance of <var>target-event</var> occurs. [[Os.pullEvent|os.pullEvent]](target-event) returns the event and any parameters the event may have. If a <var>target-event</var> is specified, the computer will not break for any other events (except termination).
|}}

{{API table/row
|[[#pullEvent|os.pullEventRaw]]()|any
|Advanced version of pullEvent(). [[#pullEvent|os.pullEventRaw]]() will block until an event occurs, and then returns the event (any any parameters the event may have). Unlike [[Os.pullEvent|os.pullEvent]](target-event), this function will not raise an error if a 'terminate' event is received.
|odd}}

{{API table/row
|[[os.queueEvent]]({{type|string}} event, param1, param2, ...)|{{type|nil}}
|Adds an event to the event queue with the name <var>event</var> and the given parameters
|}}

{{API table/row
|[[os.clock]]()|{{type|number}} time
|Returns the amount of time since the computer was started.
|odd}}

{{API table/row
|[[os.startTimer]]({{Type|number}} timeout)|{{type|number}} timerID
|Queues an event to be triggered after a number of seconds (<var>timeout</var>). The ID of the timer is returned from this function to differentiate multiple timers. Timers are one-shot; once they have fired an event you will need to start another one if you need a recurring timer.
|}}

{{API table/row
|[[os.time]]()|{{type|number}} time
|Returns the current in-game time.
|odd}}

{{API table/row
|[[os.sleep]]({{Type|number}} time)|{{type|nil}}
|Makes the system wait a number of seconds before continuing in the program. [[os.sleep]](time) may also be used as simply "sleep(time)".
|}}

{{API table/row
|[[os.day]]()|{{type|number}} day
|Return the current in-game day (the number of days since the world was created).
|odd}}

{{API table/row
|[[os.setAlarm]]({{type|number}} time)|{{type|number}} alarmID
|Queues an event to be triggered at the specified in-game <var>time</var>.
|}}

{{API table/row
|[[os.shutdown]]()|{{type|nil}}
|Turns off the computer.
|odd}}

{{API table/row
|[[os.reboot]]()|{{type|nil}}
|Reboots the computer.
|}}

}}

[[Category:APIs]]

== APIs ==

APIs are Lua files which are loaded into the OS itself, and expose functions which other programs may use. The stock [[:Category:APIs|APIs]] that ship with ComputerCraft are loaded in this way, and may be replaced by a computer’s user or programs.

The following is an example of a valid implementation of an API, and its usage after being registered:
<code>
-- "apiTest" file
function foo(bar)
print(bar)
end

-- "program" file
os.loadAPI("apiTest")
apiTest.foo("this is a test")
</code>

== <div id="pullEvent">os.pullEvent()</div> ==

os.pullEvent() causes the current program to pause, retrieving the next event from the computer's queue of events. If there is no event to read, then the program will stall until such an event becomes available. Note that if a program has not attempted to pull an event in the past ten seconds, it will be forcefully terminated to prevent CPU waste in SMP environments.

os.pullEvent() returns the name of the event that was read, as well as up to five parameters:
<code>
local event, p1, p2, p3, p4, p5 = os.pullEvent()
</code>

os.pullEvent() is usually run inside a 'while true do' loop.

An advanced version of this method <code>os.pullEventRaw</code> bypasses the normal handling of events from the OS. You may use this to act on the "Terminate" event (triggered when holding Ctrl-T) for custom termination logic.

OS (API)

2013-09-14T21:45:08Z

Immibis: use API table template

The Operating System API allows for interfacing with the Lua based Operating System itself.

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

{{API table/row
|[[os.version]]()|{{type|string}} version
|Returns the version of the OS the computer is running, which (for CraftOS) also contains the version of ComputerCraft.
|odd}}

{{API table/row
|[[os.getComputerId]]()|{{type|number}} id
|Returns the unique ID of this computer. [[os.computerID]]() also behaves exactly the same as [[os.getComputerID]]().
|}}

{{API table/row
|[[os.getComputerLabel]]()|{{type|string}} label
|Returns the label of this computer. [[os.computerLabel]]() also behaves exactly the same as [[os.getComputerLabel]](). 
|odd}}

{{API table/row
|[[os.setComputerLabel]]({{type|string}} label)|{{type|nil}}
|Set the label of this computer.
|}}

{{API table/row
|[[os.run]]({{type|table}} environment, {{type|string}} program path [, {{type|string}} arguments])|{{type|nil}}
|An advanced way of starting programs. A started program will have a given <var>environment</var> table which determines what functions it has available, as well as any variables it will be able to access by default. You may prefer to use the [[Shell (API)]] unless you need to do something special.
|odd}}

{{API table/row
|[[#APIs|os.loadAPI]]({{type|string}} name)|{{type|nil}}
|Loads a Lua script as an API in its own namespace (see example). It will be available to '''all''' programs that run on the terminal.
|}}

{{API table/row
|[[#APIs|os.unloadAPI]]({{type|string}} name)|{{type|nil}}
|Unloads a previously loaded API.
|odd}}

{{API table/row
|[[Os.pullEvent|os.pullEvent]]({{type|string}}/{{type|nil}} target-event)|any
|Blocks until the computer receives an event, or if <var>target-event</var> is specified, will block until an instance of <var>target-event</var> occurs. [[Os.pullEvent|os.pullEvent]](target-event) returns the event and any parameters the event may have. If a <var>target-event</var> is specified, the computer will not break for any other events (except termination).
|}}

{{API table/row
|[[#pullEvent|os.pullEventRaw]]()|any
|Advanced version of pullEvent(). [[#pullEvent|os.pullEventRaw]]() will block until an event occurs, and then returns the event (any any parameters the event may have). Unlike [[Os.pullEvent|os.pullEvent]](target-event), this function will not raise an error if a 'terminate' event is received.
|odd}}

{{API table/row
|[[os.queueEvent]]({{type|string}} event, param1, param2, ...)|{{type|nil}}
|Adds an event to the event queue with the name <var>event</var> and the given parameters
|}}

{{API table/row
|[[os.clock]]()|{{type|number}} time
|Returns the amount of time since the computer was started.
|odd}}

{{API table/row
|[[os.startTimer]]({{Type|number}} timeout)|{{type|number}} timerID
|Queues an event to be triggered after a number of seconds (<var>timeout</var>). The ID of the timer is returned from this function to differentiate multiple timers. Timers are one-shot; once they have fired an event you will need to start another one if you need a recurring timer.
|}}

{{API table/row
|[[os.time]]()|{{type|number}} time
|Returns the current in-game time.
|odd}}

{{API table/row
|[[os.sleep]]({{Type|number}} time)|{{type|nil}}
|Makes the system wait a number of seconds before continuing in the program. [[os.sleep]](time) may also be used as simply "sleep(time)".
|}}

{{API table/row
|[[os.day]]()|{{type|number}} day
|Return the current in-game day (the number of days since the world was created).
|odd}}

{{API table/row
|[[os.setAlarm]]({{type|number}} time)|{{type|number}} alarmID
|Queues an event to be triggered at the specified in-game <var>time</var>.
|}}

{{API table/row
|[[os.shutdown]]()|{{type|nil}}
|Turns off the computer.
|odd}}

{{API table/row
|[[os.reboot]]()|{{type|nil}}
|Reboots the computer.
|}}

}}

[[Category:APIs]]

== APIs ==

APIs are Lua files which are loaded into the OS itself, and expose functions which other programs may use. The stock [[:Category:APIs|APIs]] that ship with ComputerCraft are loaded in this way, and may be replaced by a computer’s user or programs.

The following is an example of a valid implementation of an API, and its usage after being registered:
<code>
-- "apiTest" file
function foo(bar)
print(bar)
end

-- "program" file
os.loadAPI("apiTest")
apiTest.foo("this is a test")
</code>

== <div id="pullEvent">os.pullEvent()</div> ==

os.pullEvent() causes the current program to pause, retrieving the next event from the computer's queue of events. If there is no event to read, then the program will stall until such an event becomes available. Note that if a program has not attempted to pull an event in the past ten seconds, it will be forcefully terminated to prevent CPU waste in SMP environments.

os.pullEvent() returns the name of the event that was read, as well as up to five parameters:
<code>
local event, p1, p2, p3, p4, p5 = os.pullEvent()
</code>

os.pullEvent() is usually run inside a 'while true do' loop.

An advanced version of this method <code>os.pullEventRaw</code> bypasses the normal handling of events from the OS. You may use this to act on the "Terminate" event (triggered when holding Ctrl-T) for custom termination logic.

Keys (API)

2013-09-14T21:34:53Z

Immibis: use API table template

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

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

{{API table/row
|[[keys.getName]]({{Type|number}} code)|{{type|string}} keyName
|Translates a numerical key code to a human-readable name.
|odd}}

}}

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]]

Help (API)

2013-09-14T21:33:45Z

Immibis: use API table template

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

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

{{API table/row
|[[help.path]]()|{{Type|string}} path
|Returns the list of locations the API will look in for help files.
|odd}}

{{API table/row
|[[help.setPath]]({{type|string}} path)|{{Type|nil}}
|Sets the list of locations the API will look in for help files.
|}}

{{API table/row
|[[help.lookup]]({{Type|string}} topic)|{{Type|string}}/{{type|nil}} path
|Returns the path to the file containing the help page for <var>topic</var>, or {{type|nil}} if the topic cannot be found.
|odd}}

{{API table/row
|[[help.topics]]()|{{Type|table}} topics
|Returns a list of all available help topics.
|}}

}}

[[Category:APIs]]

Modem (API)

2013-09-10T03:58:45Z

Immibis:

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

As of ComputerCraft 1.5, channels have been added - channels are essentially networks which can be opened, closed and listened on by any computer within range, without need of independant computer IDs. To interact with channels, one must wrap or interact directly with the peripheral as opposed to the previous interaction with the Rednet API.

'''There is not an actual API called "modem". This is the API for wrapped modem peripherals.'''

<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>
{| class="wikitable" width="100%"
! colspan="1" | Event Name
! colspan="1" | Description
! colspan="1" | Parameters
|-
! scope="row" | modem_message
|Fired when a modem message is received.
|{{type|string}} modemSide, {{type|int}} senderChannel, {{type|int}} replyChannel, {{type|string}} message, {{type|number}} distance
|}

==Sending Messages==
Sending messages is simple and does not require that you open any channels. Simply use the transmit function like so:
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!")

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:
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.")

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.

== Modem Limitations ==
* You can only open 128 channels at any given time.
* The maximum channel you can open is 65535.
* You can listen on more than one channel at a time. For example, if the modem has channel 3 and channel 5 open, and somebody sends a message on channel 5, the modem will receive it. If a message is sent on channel 3, the modem will also receive the message.
* 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 using the Modem API, messages are still available to any computer listening on the sent channel.

[[Category:Peripheral APIs]]

Fs (API)

2013-08-25T03:39:02Z

Immibis: use template for API table.

The FS API allows you to mess around with the filesystem.

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

{{API table/row|[[fs.list]]({{Type|string}} path)|{{type|table}} files|Returns a list of all the files (including subdirectories but not their contents) contained in a directory, as a numerically indexed table.|odd}}

{{API table/row|[[fs.exists]]({{Type|string}} path)|{{Type|boolean}} exists|Checks if a path refers to an existing file or directory.|}}
{{API table/row|[[fs.isDir]]({{Type|string}} path)|{{Type|boolean}} isdir|Checks if a path refers to an existing directory.|odd}}
{{API table/row|[[fs.isReadOnly]]({{Type|string}} path)|{{Type|boolean}} readonly|Checks if a path is read-only (i.e. cannot be modified).|}}
{{API table/row|[[fs.getName]]({{type|string}} path)|{{type|string}} name|Gets the final component of a pathname.|odd}}
{{API table/row|[[fs.getDrive]]({{type|string}} path)|{{type|string}}/{{type|nil}} drive|Gets the storage medium holding a path, or [[nil]] if the path does not exist.|}}
{{API table/row|[[fs.getSize]]({{Type|string}} path)|{{type|number}} size|Gets the size of a file in bytes.|odd}}
{{API table/row|[[fs.getFreeSpace]]({{Type|string}} path)|{{type|number}} space|Gets the remaining space on the drive containing the given directory.|}}
{{API table/row|[[fs.makeDir]]({{Type|string}} path)|{{type|nil}}|Makes a directory.|odd}}
{{API table/row|[[fs.move]]({{Type|string}} fromPath, {{Type|string}} toPath)|{{type|nil}}|Moves a file or directory to a new location.|}}
{{API table/row|[[fs.copy]]({{Type|string}} fromPath, {{Type|string}} toPath)|{{type|nil}}|Copies a file or directory to a new location.|odd}}
{{API table/row|[[fs.delete]]({{Type|string}} path)|{{type|nil}}|Deletes a file or directory.|}}
{{API table/row|[[fs.combine]]({{Type|string}} basePath, {{Type|string}} localPath)|{{type|string}} path|Combines two path components, returning a path consisting of the local path nested inside the base path.|odd}}
{{API table/row|[[fs.open]]({{Type|string}} path, {{Type|string}} mode)|{{type|table}} handle|Opens a file so it can be read or written.|}}

}}

[[Category:APIs]]

==Path Names==
All of these functions except for [[fs.combine]] refer solely to <em>absolute paths</em>.<br />
This means that the current working directory, as set by the <code>cd</code> command or the [[shell.setDir]] function, is ignored. Each path name consists of a list of nonempty path components separated by forward slashes, and those path components are taken one by one with the first being contained in the root directory of the computer.

If you need to deal with paths provided by the user that may be absolute or may be relative to the current working directory, use [[shell.resolve]].

Unlike most real-world operating systems, ComputerCraft's absolute path name system does not need to be started with a forward slash ( / ), making the directory "a/b/c" the same as "/a/b/c". Leaving the slashes is just a matter of preference to the coder.

Disk (API)

2013-08-25T03:31:14Z

Immibis: use template for API table

''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]]

Coroutine (API)

2013-08-25T03:22:08Z

Immibis: use template for API table

:{| 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.

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

{{API table/row|[[coroutine.create]]({{type|function}} f)|{{type|coroutine}} coro|Creates a new coroutine.|odd}}
{{API table/row|[[coroutine.resume]]({{type|coroutine}} coro, ...)|any|Starts or resumes a coroutine.|}}
{{API table/row|[[coroutine.running]]()|{{type|coroutine}}|Returns the currently executing coroutine.|odd}}
{{API table/row|[[coroutine.status]]({{type|coroutine}} coro)|{{type|string}} status|Returns the status of a coroutine.|}}
{{API table/row|[[coroutine.wrap]]({{type|function}} f)|{{type|function}} wrapper|Creates a new coroutine and wraps it in a function.|odd}}
{{API table/row|[[coroutine.yield]](...)|any|Pauses the currently executing coroutine and passes control to its caller.|}}

}}

== 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 ==
The [[OS (API)#pullEvent|os.pullEventRaw]] (and therefore [[os.pullEvent]]) functions are built on top of coroutines: <code>os.pullEventRaw</code> actually just calls [[coroutine.yield]], passing the event type filter up to the parent coroutine. The parent coroutine is expected to wait until an event of the required type arrives, then use [[coroutine.resume]] to pass the event to the suspended coroutine (where it will be returned from <code>os.pullEventRaw</code>). If you use the [[Parallel (API)|parallel API]], this is exactly what [[parallel.waitForAny]] and [[parallel.waitForAll]] do: they pull events from the system event queue (or even from a higher invocation of <code>parallel.waitForAny</code> or <code>parallel.waitForAll</code>!) and deliver them to all nested coroutines. Therefore, the easiest way to use coroutines is the parallel API, if it works for your situation. However, in the event that you are not able to use the parallel API (e.g. if you need to add and remove coroutines from the executing set dynamically), you can build your own dispatcher that delivers events in the same way as the parallel API—looking at the source code to the parallel API may be useful here.

If you choose to use coroutines in a different way, then <code>os.pullEventRaw</code> and <code>os.pullEvent</code> will not work. This in turn will break any other API function which is written on top of <code>os.pullEvent</code>. As a guideline, nearly any API function that can possibly take time to complete will 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]].

Most of these can be worked around by using non-blocking equivalents that return immediately and then queue an event on completion (such as using [[http.request]]) or that deliver an event unconditionally (such as [[Char_(event)|char]] for keyboard input), then handling events in a way that is suitable for the application. However, if possible, it will often be easier to implement event dispatching instead, remembering that [[os.queueEvent]] can be used for inter-coroutine communication within an application. Another alternative, if you must use a custom protocol between your coroutines and dispatcher, might be to replace <code>os.pullEventRaw</code> with a new function that uses a mechanism appropriate to the application.

[[Category:APIs]]

Colors (API)

2013-08-25T03:16:57Z

Immibis: use template for API table

The Colors API allows you to manipulate sets of colors. This is useful in conjunction with Bundled Cables from the RedPower mod, RedNet Cables from the MineFactory Reloaded mod, and colors on [[Advanced Computer|Advanced Computers]] and [[Advanced Monitor|Advanced Monitors]].

For the non-American English version just replace 'colors' with 'colours' and it will use the other API, colours—which is exactly the same, except in non-American English (e.g. gray is spelt grey and lightGray is spelt lightGrey).

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

{{API table/row|[[colors.combine]]({{Type|number}} color1, {{Type|number}} color2, ...)|{{type|number}} value|
Combines a one or more colors (or sets of colors) into a larger set.
|odd}}

{{API table/row|[[colors.subtract]]({{Type|number}} colors, {{Type|number}} color1, {{Type|number}} color2, ...)|{{type|number}} value|
Removes one or more colors (or sets of colors) from an initial set.
|}}

{{API table/row|[[colors.test]]({{type|number}} colors, {{type|number}} color)|{{type|boolean}} contained|
Tests whether ''color'' is contained within '''colors'''.
|odd}}

}}

Note: Since the colors are just integers, the standard addition (+) and subtraction (-) operators may be used on colors instead of colors.combine and colors.subtract.

Furthermore, the [[Bit (API)]] may be used on sets of colors. For example,
<pre>
bCableLeft = rs.getBundledInput("left")
bCableRight = rs.getBundledInput("right")

-- Get a number representing colors on in both right and left bundled cables
commonColors = bit.band(bCableLeft, bCableRight)

-- Get all the colors active on either right or left
totalColors = bit.bor(bCableLeft, bCableRight)

-- Get the colors which are active on right, or left, but not both at the same time
exclusiveColors = bit.bxor(bCableLeft, bCableRight)

-- Get the colors that are not active on the left
offColorsA = bit.bnot(bCableLeft)
</pre>

==Colors==
Color constants include, in ascending bit order:

{| class="wikitable" width="200px"
! Color
! Decimal
! Hexadecimal
! Binary
|-
| colors.white
| align="right" | 1
| align="right" | 0x1
| align="right" | 0000000000000001
|-
| colors.orange
| align="right" | 2
| align="right" | 0x2
| align="right" | 0000000000000010
|-
| colors.magenta
| align="right" | 4
| align="right" | 0x4
| align="right" | 0000000000000100
|-
| colors.lightBlue
| align="right" | 8
| align="right" | 0x8
| align="right" | 0000000000001000
|-
| colors.yellow
| align="right" | 16
| align="right" | 0x10
| align="right" | 0000000000010000
|-
| colors.lime
| align="right" | 32
| align="right" | 0x20
| align="right" | 0000000000100000
|-
| colors.pink
| align="right" | 64
| align="right" | 0x40
| align="right" | 0000000001000000
|-
| colors.gray
| align="right" | 128
| align="right" | 0x80
| align="right" | 0000000010000000
|-
| colors.lightGray
| align="right" | 256
| align="right" | 0x100
| align="right" | 0000000100000000
|-
| colors.cyan
| align="right" | 512
| align="right" | 0x200
| align="right" | 0000001000000000
|-
| colors.purple
| align="right" | 1024
| align="right" | 0x400
| align="right" | 0000010000000000
|-
| colors.blue
| align="right" | 2048
| align="right" | 0x800
| align="right" | 0000100000000000
|-
| colors.brown
| align="right" | 4096
| align="right" | 0x1000
| align="right" | 0001000000000000
|-
| colors.green
| align="right" | 8192
| align="right" | 0x2000
| align="right" | 0010000000000000
|-
| colors.red
| align="right" | 16384
| align="right" | 0x4000
| align="right" | 0100000000000000
|-
| colors.black
| align="right" | 32768
| align="right" | 0x8000
| align="right" | 1000000000000000
|}
[[Category:APIs]]

Bit (API)

2013-08-25T03:08:51Z

Immibis: update deprecated API table too

Bit (API)

2013-08-25T03:07:20Z

Immibis:

The Bit API is for manipulating numbers using bitwise binary operations.

All of these functions treat the numbers as 32-bit integers, and will raise an error if an input number is greater than 4,294,967,295.

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

{{API table/row
|[[bit.blshift]]({{type|number}} n, {{type|number}} bits)|{{type|number}} value
|Shifts a number left by a specified number of bits.
|odd}}

{{API table/row
|[[bit.brshift]]({{type|number}} n, {{type|number}} bits)|{{type|number}} value
|Shifts a number right arithmetically by a specified number of bits.
|}}

{{API table/row
|[[bit.blogic_rshift]]({{type|number}} n, {{type|number}} bits)|{{type|number}} value
|Shifts a number right logically by a specified number of bits.
|odd}}

{{API table/row
|[[bit.bxor]]({{type|number}} m, {{type|number}} n)|{{type|number}} value
|Computes the bitwise exclusive OR of two numbers.
|}}

{{API table/row
|[[bit.bor]]({{type|number}} m, {{type|number}} n)|{{type|number}} value
|Computes the bitwise inclusive OR of two numbers.
|odd}}

{{API table/row
|[[bit.band]]({{type|number}} m, {{type|number}} n)|{{type|number}} value
|Computes the bitwise AND of two numbers.
|}}

{{API table/row
|[[bit.band]]({{type|number}} n)|{{type|number}} value
|Computes the bitwise NOT of a numbers.
|odd}}

}}

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

<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]]  Bit (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|table}} bit_tbl</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[bit.tobits]]({{Type|number}} n)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Converts a number to an array (numerically-indexed table) containing the corresponding binary bit values.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">{{Type|number}} value</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">[[bit.tonumb]]({{Type|table}} bit_tbl)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Converts an array (numerically-indexed table) of 0 and 1 values representing a number in binary into that number.</td></tr>
</table>

[[Category:APIs]]

Template:API table

2013-08-25T03:01:03Z

Immibis:

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><th colspan="3" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px; text-align: left">
[[File:{{{image}}}|24px]]  {{{1}}} (API)</th></tr>
<tr>
<td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Function</td>
<td style="width: 150px; background: #E0E0E0; padding: .4em; font-weight:bold;">Return values</td>
<td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>
{{{2}}}
</table>
<noinclude>{{Template:API table/doc}}</noinclude>

Template:API table/doc

2013-08-25T03:00:56Z

Immibis: Created page with "== Example API table == This code: <pre> <nowiki> {{API table|Term|image=Grid disk.png|2= {{API table/row|term.write({{type|string}} text)|{{type|nil}}|Writes ''text'' ..."

== Example API table ==

This code:

<pre>
<nowiki>
{{API table|Term|image=Grid disk.png|2=

{{API table/row|[[term.write]]({{type|string}} text)|{{type|nil}}|Writes ''text'' to the screen.|odd}}

{{API table/row|[[term.clear]]()|{{type|nil}}|Clears the entire screen}}

}}
</nowiki>
</pre>

produces this table:

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

{{API table/row|[[term.write]]({{type|string}} text)|{{type|nil}}|Writes ''text'' to the screen.|odd}}

{{API table/row|[[term.clear]]()|{{type|nil}}|Clears the entire screen}}

}}

Peripheral (API)

2013-08-25T02:55:31Z

Immibis: You don't need to do this!

Peripheral (API)

2013-08-25T02:51:25Z

Immibis: Forgot capitalization

__TOC__
The Peripheral API is for interacting with [[peripheral]]s connected to the computer, such as the [[Disk Drive]], the [[Advanced Monitor]] and [[Monitor]]. (More peripherals can be found under [[:Category:Peripherals|here]]).

Each peripheral block has a name, or ''side''. Although peripherals can now be attached to a computer using networking cables, the word ''side'' is a holdover from when peripherals needed to be directly next to the computer.

If the peripheral is next to the computer, its side is either "front", "back", "left", "right", "top" or "bottom". If the peripheral is attached by a cable, its side will follow the format "''type''_''id''", for example "printer_0".

Peripheral functions are called '''methods''', a term borrowed from Java.

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

{{API table/row|[[peripheral.isPresent]]({{type|string}} side)|{{type|boolean}}|
Returns '''true''' if a peripheral is connected on ''side''.
|odd}}

{{API table/row|[[peripheral.getType]]({{type|string}} side)|{{type|string}}/{{type|nil}}|
Returns the type of peripheral connected on ''side'', as a string.
If no peripheral is connected, returns nil.
}}

{{API table/row|[[peripheral.getMethods]]({{type|string}} side)|{{type|table}}/{{type|nil}}|
Returns a list of the names of all the methods of the peripheral connected on ''side''.
If no peripheral is connected, returns nil.
|odd}}

{{API table/row|[[peripheral.call]]({{type|string}} side, {{type|string}} method, ...)|any|
Calls a method on a peripheral. The arguments (apart from ''side'' and ''method'') and the return values depend on the method being called.
If no peripheral is connected, returns nil.
}}

{{API table/row|[[peripheral.wrap]]({{type|string}} side)|{{type|table}}/{{type|nil}}|
Returns a table of functions, allowing you to call peripheral methods as if they were normal Lua functions.
If no peripheral is connected, returns nil.
|odd}}

}}

==Remote Peripherals using Networking Cables==
Using Networking Cables, you can attach and use peripherals without having them directly touching the computer. To connect a peripheral in this way, place a Wired Modem on any side of your computer, as you would a [[Wireless Modem]], as well as all the peripherals you wish to connect, connecting all of them with Networking Cables. Then right click each of the wired modems. You should receive messages in your chat bar informing you of a successful connection. Don't forget to connect the [[Computer|computer]] too!

Finally, you need to wrap the wired modem on your [[Computer|computer]] using the methods above. As well as those outlined on the [[Modem_(API)| Modem API]] page, the following additional functions will then become available to you, where ''p'' is the variable the modem is wrapped to:

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<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;">p.getNamesRemote()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the names of all connected peripherals. Peripheral names are the type of peripheral followed by an underscore and a unique number, e.g. ''"disk_0"''.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">p.isPresentRemote(peripheral name)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns '''true''' if the specified peripheral is connected; '''false''' otherwise. </td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">p.getTypeRemote(peripheral name)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the type of the specified peripheral.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">p.getMethodsRemote(peripheral name)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns a table of all the methods for the specified peripheral. </td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">p.callRemote(peripheral name, peripheral method)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Calls the specified method for the specified peripheral.</td></tr>
</table>

==Monitor==
[[Monitor#Peripheral_Functions|Monitor Peripheral functions]] have been moved to the [[Monitor]] page.
In addition, the [[Advanced_Monitor#Peripheral_Functions|Advanced Monitor Peripheral functions]] have been moved to the [[Advanced Monitor]] page.

==Printer==
[[Printer#Peripheral_Functions|Printer Peripheral functions]] have been moved to the [[Printer]] page.

==Computers==
[[Computer#Peripheral_Functions|Computer Peripheral functions]] have been moved to the [[Computer]] page.
In addition, the [[Advanced_Computer#Peripheral_Functions|Advanced Computer Peripheral functions]] have been moved to the [[Advanced Computer]] page.

[[Category:APIs]]

Peripheral (API)

2013-08-25T02:51:08Z

Immibis: Rewrote API function table, using Template:API_table

__TOC__
The Peripheral API is for interacting with [[peripheral]]s connected to the computer, such as the [[Disk Drive]], the [[Advanced Monitor]] and [[Monitor]]. (More peripherals can be found under [[:Category:Peripherals|here]]).

Each peripheral block has a name, or ''side''. Although peripherals can now be attached to a computer using networking cables, the word ''side'' is a holdover from when peripherals needed to be directly next to the computer.

If the peripheral is next to the computer, its side is either "front", "back", "left", "right", "top" or "bottom". If the peripheral is attached by a cable, its side will follow the format "''type''_''id''", for example "printer_0".

Peripheral functions are called '''methods''', a term borrowed from Java.

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

{{API table/row|[[peripheral.isPresent]]({{type|string}} side)|{{type|boolean}}|
Returns '''true''' if a peripheral is connected on ''side''.
|odd}}

{{API table/row|[[peripheral.getType]]({{type|string}} side)|{{type|string}}/{{type|nil}}|
Returns the type of peripheral connected on ''side'', as a string.
If no peripheral is connected, returns nil.
}}

{{API table/row|[[peripheral.getMethods]]({{type|string}} side)|{{type|table}}/{{type|nil}}|
Returns a list of the names of all the methods of the peripheral connected on ''side''.
If no peripheral is connected, returns nil.
|odd}}

{{API table/row|[[peripheral.call]]({{type|string}} side, {{type|string}} method, ...)|any|
Calls a method on a peripheral. The arguments (apart from ''side'' and ''method'') and the return values depend on the method being called.
If no peripheral is connected, returns nil.
}}

{{API table/row|[[peripheral.wrap]]({{type|string}} side)|{{type|table}}/{{type|nil}}|
Returns a table of functions, allowing you to call peripheral methods as if they were normal Lua functions.
If no peripheral is connected, returns nil.
|odd}}

}}

==Remote Peripherals using Networking Cables==
Using Networking Cables, you can attach and use peripherals without having them directly touching the computer. To connect a peripheral in this way, place a Wired Modem on any side of your computer, as you would a [[Wireless Modem]], as well as all the peripherals you wish to connect, connecting all of them with Networking Cables. Then right click each of the wired modems. You should receive messages in your chat bar informing you of a successful connection. Don't forget to connect the [[Computer|computer]] too!

Finally, you need to wrap the wired modem on your [[Computer|computer]] using the methods above. As well as those outlined on the [[Modem_(API)| Modem API]] page, the following additional functions will then become available to you, where ''p'' is the variable the modem is wrapped to:

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<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;">p.getNamesRemote()</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the names of all connected peripherals. Peripheral names are the type of peripheral followed by an underscore and a unique number, e.g. ''"disk_0"''.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">p.isPresentRemote(peripheral name)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns '''true''' if the specified peripheral is connected; '''false''' otherwise. </td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">p.getTypeRemote(peripheral name)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns the type of the specified peripheral.</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">p.getMethodsRemote(peripheral name)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Returns a table of all the methods for the specified peripheral. </td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-top: solid #C9C9C9 1px; padding: .4em;">p.callRemote(peripheral name, peripheral method)</td>
<td style="border-top: solid #C9C9C9 1px; padding: .4em;">Calls the specified method for the specified peripheral.</td></tr>
</table>

==Monitor==
[[Monitor#Peripheral_Functions|Monitor Peripheral functions]] have been moved to the [[Monitor]] page.
In addition, the [[Advanced_Monitor#Peripheral_Functions|Advanced Monitor Peripheral functions]] have been moved to the [[Advanced Monitor]] page.

==Printer==
[[Printer#Peripheral_Functions|Printer Peripheral functions]] have been moved to the [[Printer]] page.

==Computers==
[[Computer#Peripheral_Functions|Computer Peripheral functions]] have been moved to the [[Computer]] page.
In addition, the [[Advanced_Computer#Peripheral_Functions|Advanced Computer Peripheral functions]] have been moved to the [[Advanced Computer]] page.

[[Category:APIs]]

Template:API table

2013-08-25T02:43:39Z

Immibis: shrink return value column

Term (API)

2013-08-25T02:43:14Z

Immibis: Added return types

The Terminal API provides functions for writing text to the terminal and monitors, and drawing ASCII graphics.

Methods in ''italics'' are available only to [[Advanced Computer|Advanced Computers]] and [[Advanced Monitor|Advanced Monitors]].
Methods in '''bold''' are available only to [[Monitor|Monitors]].

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

{{API table/row|[[term.write]]({{type|string}} text)|{{type|nil}}
|Writes ''text'' to the screen.|odd}}

{{API table/row|[[term.clear]]()|{{type|nil}}
|Clears the entire screen}}

{{API table/row|[[term.clearLine]]()|{{type|nil}}
|Clears the line the cursor is on|odd}}

{{API table/row|[[term.getCursorPos]]()|{{type|nil}}
|Returns two arguments containing the x and the y position of the cursor.}}

{{API table/row|[[term.setCursorPos]]({{type|number}} x, {{type|number}} y)|{{type|nil}}
|Sets the cursor's position.|odd}}

{{API table/row|[[term.setCursorBlink]]({{type|boolean}} bool)|{{type|nil}}
|Disables the blinking or turns it on.}}

{{API table/row|[[term.isColor]]()|{{type|boolean}}
|Returns if the computer supports color. (Used to determine whether or not an [[Advanced Computer]] is being used)|odd}}

{{API table/row|[[term.getSize]]()|{{type|number}} x, {{type|number}} y
|Returns two arguments containing the x and the y values stating the size of the screen. (Good for if you're making something to be compatible with both [[Turtle]]s and [[Computer]]s.)}}

{{API table/row|[[term.scroll]]({{type|number}} n)|{{type|nil}}
|Scrolls the terminal ''n'' lines.|odd}}

{{API table/row|[[term.redirect]](target)|{{type|nil}}
|Redirects terminal output to a monitor or other redirect target. (Use [[peripheral.wrap]] to acquire a monitor "object".)}}

{{API table/row|[[term.restore]]()|{{type|nil}}
|Restores terminal output to the previous target.|odd}}

{{API table/row|''[[term.setTextColor]]({{type|number}} [[Colors (API)|color]])''|{{type|nil}}
|Sets the text color of the terminal. Available only to [[Advanced Computer|Advanced Computers]] and [[Advanced Monitor]]s.}}

{{API table/row|''[[term.setBackgroundColor]]({{type|number}} [[Colors (API)#Colors|color]])''|{{type|nil}}
|Sets the background color of the terminal. Available only to [[Advanced Computer|Advanced Computers]] and [[Advanced Monitor]]s.|odd}}

{{API table/row|'''[[monitor.setTextScale]]({{type|number}} scale)'''|{{type|nil}}
|Sets the text scale on a [[Monitor]].}}

}}

[[Category:APIs]]

Template:API table/row

2013-08-25T02:41:18Z

Immibis: fixed previous edit

Template:API table/row

2013-08-25T02:40:33Z

Immibis: added return value column

Template:API table

2013-08-25T02:39:58Z

Immibis: added return value column

<table style="width: 100%; border: solid 1px black; margin: 2px; border-spacing: 0px;">
<tr><th colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid #C9C9C9 1px; background: #D3FFC2; line-height:28px; text-align: left">
[[File:{{{image}}}|24px]]  {{{1}}} (API)</th></tr>
<tr>
<td style="width: 350px; background: #E0E0E0; padding: .4em; font-weight:bold;">Function</td>
<td style="width: 250px; background: #E0E0E0; padding: .4em; font-weight:bold;">Return values</td>
<td style="background: #E0E0E0; padding: .4em; font-weight:bold;">Description</td></tr>
{{{2}}}
</table>

Peripheral

2013-08-25T02:19:03Z

Immibis: Created page with "A '''peripheral''' is a Minecraft block which can be controlled using the peripheral API. Sometimes this is the main purpose of the block, e.g. for monito..."

A '''peripheral''' is a Minecraft block which can be controlled using the [[Peripheral (API)|peripheral API]].
Sometimes this is the main purpose of the block, e.g. for monitors and printers.
Other times, it is merely incidental to the block's main purpose.

== Built-in peripherals ==
ComputerCraft itself includes some peripherals. Specifically:
* [[Monitor]]s and [[Advanced Monitor|advanced monitor]]s allow computers to display text in the world.
* [[Printer]]s allow computers to print text on paper.
* [[Disk Drive|Disk drive]]s allow computers to access floppy disks.
* [[Wireless Modem|Wireless]] and [[Wired Modem|wired]] modems allow computers to send messages to each other.
* [[Computer]]s, [[Advanced Computer|advanced computer]]s, [[turtle]]s and [[Advanced Turtle|advanced turtle]]s can be turned on and off using the peripheral API.

== Mod peripherals ==
Many mods add blocks which are peripherals. If this is the main purpose of the mod, it is often called a '''peripheral mod'''. Confusingly, this is sometimes shortened to '''peripheral'''.

Some mods, notably [[OpenPeripherals]], add a peripheral ability to blocks which don't normally have it (such as chests).

See [[:Category:User Created Peripherals]].

Turtle.refuel

2013-02-04T12:03:03Z

Immibis:

{{lowercase}}
{{Function
|name=turtle.refuel
|args=count
|api=turtle
|returns=[[boolean_(type)|boolean]] true if fuel, else false.
|addon=ComputerCraft
|desc=Fills the turtle with fuel.
|examples=
{{Example
|desc=Fills the turtle with fuel
|code=turtle.refuel( 4 )
|output=Tries to refuel with up to 4 items, returns true if it is a fuel and false if not.
}}
}}

== Fuel Values ==
Fuel values for different items.

{| class="wikitable sortable"
! Item
! Movement gained
! Added by
|-
| Biofuel Can
| 520
| IndustrialCraft
|-
| Scrap
| 15
| IndustrialCraft
|-
| Coalfuel Can
| 1520
| IndustrialCraft
|-
| Wooden Scaffolding
| 15
| IndustrialCraft
|-
| Peat
| 80
| Forestry
|-
| Sugar Cane
| 0
| Vanilla
|-
| Wooden Tools
| 10
| Vanilla
|-
| Lava
| 1000
| Vanilla
|-
| Blaze Rod
| 120
| Vanilla
|-
| Wood Blocks
| 15
| Vanilla
|-
| Sticks
| 5
| Vanilla
|-
| Coal/Charcoal
| 80
| Vanilla
|-
| Mushroom Blocks
| 15
| Vanilla
|-
| Coal Coke
| 320
| Railcraft
|}

1.41:

The formula for calculating the movement gain from a fuel is "((fuel / 100) * 6)".
Where fuel is the items burn time in ticks in a regular furnace and "/" is integer division.

1.42+:

Formula changed to ((fuel * 6) / 100).
This will give more accurate movement values.

1.48:

Formula changed to ((fuel * 5) / 100)
== Trivia ==

[[Category:Lua_Core_Functions]]

Monitor

2013-01-09T18:27:40Z

Immibis: I think this is what "damage value: un-used" actually means.

{{Block
|name=Monitor
|image=Iso_Monitor.png
|id=4094
|damage-value=0
|is-peripheral=Yes
}}
The '''Monitor''' is a block that can display text on its front side. When several screen blocks are placed on the same plane, it will form a single monitor. It is useful for displaying information at a server spawn, showing a program on the monitor, and even showing the status of an IC2 reactor! (provided you have [[CcSensors]] installed)

==Recipe==
{{Crafting grid
|A1=stone |B1=stone |C1=stone
|A2=stone |B2=glass_pane |C2=stone
|A3=stone |B3=stone |C3=stone
|Output=Monitor
}}
[[Category:Blocks]]

==Using the Monitor==
[[File:Computer_w_DiskDrive_w_Monitor.png|frame|428x241px|right|A 2x2 [[Monitor]], connected to a [[Computer]], with a [[Disk Drive]] connected.]]
The command used to control a monitor: monitor [top, bottom, left, right, front or back] [the name of the command to display]

So, in this case, if you typed "hello" in the name of the program part, the monitor would display "Hello World!".

==Using the Monitor within the Lua interface==
The monitor can be summoned through a command or through coding with the Lua command.

The command used to control a monitor within the Lua interface: shell.run("monitor" "[top, bottom, left, right, front or back]" "[the name of the command to display]")

For example, here is a way of summoning the monitor through a command:

<tt>[[print]]("Hello Monitor!")

[[Shell (API)|shell]].[[Shell.run|run]]("monitor", "right", "hello")</tt>

== Peripheral Functions ==
'''''monitor'' stands for the variable you wrapped the monitor to.'''
''Example:'' monitor = peripheral.wrap( "top" )

Methods in ''italic'' are available on [[Advanced Monitor|Advanced Monitors]] only.

{| class="wikitable"
!style="background:#EEE" width="210px"|Method name
!style="background:#EEE" width="*"|Description
|-
|[[term.write|monitor.write]]()
|Write to the Monitor's screen.
|-
|[[term.scroll|monitor.scroll]](n)
|Scrolls the monitor screen.
|-
|[[term.setCursorPos|monitor.setCursorPos]](x, y)
|Sets the cursor position on the Monitor.
|-
|[[term.setCursorBlink|monitor.setCursorBlink]](b)
|Enables or disables cursor blinking.
|-
|[[term.getCursorPos|monitor.getCursorPos]]()
|Returns two arguments containing the x and the y position of the cursor on the Monitor.
|-
|[[term.getSize|monitor.getSize]]()
|Returns two arguments containing the x and the y values stating the size of the Monitor.
|-
|[[term.clear|monitor.clear]]()
|Clears the Monitor.
|-
|[[term.clearLine|monitor.clearLine]]()
|Clears the line the cursor is on.
|-
|[[monitor.setTextScale|monitor.setTextScale]](scale)
|Sets the size of the text on the Monitor. Textscale can be between 0.5 and 5.0, with increments of 0.5
|-
|''[[term.setTextColor|monitor.setTextColor]]([[colors (API)#colors|color]])''
|Sets the text-color of the [[Advanced Monitor]]. Available only to [[Advanced Monitor|Advanced Monitors]]
|-
|''[[term.setBackgroundColor|monitor.setBackgroundColor]]([[colors (API)#colors|color]])''
|Sets the background-color of the [[Advanced Monitor]]. Available only to [[Advanced Monitor|Advanced Monitors]]
|}

[[Category:Blocks]][[Category:Peripherals]]

User:Immibis/Sandbox

2013-01-07T18:48:09Z

Immibis:

<includeonly>
<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: #DBE5FF; line-height:28px;">[[File:Grid_Redstone.png|24px]]  Function {{{name}}}</td></tr>

<tr style="background-color: #FFFFFF;"><td colspan="2" style="padding: .4em; padding-bottom: .8em;">{{{desc|No description provided.}}}</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; border-right: solid #C9C9C9 1px; padding: .4em; width: 10%; font-weight: bold;">Syntax</td>
<td style="border-top: solid #C9C9C9 1px; border-color: #C9C9C9; padding: .4em; padding-left: .8em;">{{{name}}}({{{args|}}})</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-right: solid #C9C9C9 1px; padding: .4em; width: 10%; font-weight: bold;">Returns</td>
<td style="border-color: #C9C9C9; padding: .4em; padding-left: .8em;">{{{returns|[[nil]]}}}</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-right: solid #C9C9C9 1px; padding: .4em; width: 10%; font-weight: bold;">Part of</td>
<td style="border-color: #C9C9C9; padding: .4em; padding-left: .8em;">[[{{{addon|ComputerCraft}}}]]</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-right: solid #C9C9C9 1px; padding: .4em; width: 10%; font-weight: bold;">API</td>
<td style="border-color: #C9C9C9; padding: .4em; padding-left: .8em;">{{#if: {{{api}}} | [[{{{api}}} (API)|{{{api}}}]] | none }}</td></tr>

</table>{{#if:{{{examples|}}}|

<h2><span class="mw-headline">Examples</span></h2>
{{{examples|}}}
|}}{{#if:{{{notes|}}}|

<h2><span class="mw-headline">Additional Notes</span></h2>
{{{notes}}}
|}} test
</includeonly>
<noinclude>
__NOTOC__
== Wiki code ==
<nowiki>{{Function
|name=redstone.setOutput
|args=[[string]] side, [[boolean]] value
|api=redstone
|returns=[[nil]]
|addon=ComputerCraft
|desc=Sets a redstone output
|examples=Examples go here (use [[Template:Example]])
|notes=
* Note 1
* Note 2
}}</nowiki>

Note that ''args'', ''returns'', ''addon'', ''examples'' and ''notes'' are optional.

== Result ==
{{:User:Immibis/Sandbox
|name=redstone.setOutput
|args=[[string_(type)|string]] side, [[boolean_(type)|boolean]] value
|api=redstone
|returns=[[nil]]
|addon=ComputerCraft
|desc=Sets a redstone output
|examples=Examples go here (use [[Template:Example]])
|notes=
* Note 1
* Note 2
}}
[[Category:Templates]]
</noinclude>

User:Immibis/Sandbox

2013-01-07T18:47:53Z

Immibis: Created page with "<includeonly> <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-..."

<includeonly>
<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: #DBE5FF; line-height:28px;">[[File:Grid_Redstone.png|24px]]  Function {{{name}}}</td></tr>

<tr style="background-color: #FFFFFF;"><td colspan="2" style="padding: .4em; padding-bottom: .8em;">{{{desc|No description provided.}}}</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-top: solid #C9C9C9 1px; border-right: solid #C9C9C9 1px; padding: .4em; width: 10%; font-weight: bold;">Syntax</td>
<td style="border-top: solid #C9C9C9 1px; border-color: #C9C9C9; padding: .4em; padding-left: .8em;">{{{name}}}({{{args|}}})</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-right: solid #C9C9C9 1px; padding: .4em; width: 10%; font-weight: bold;">Returns</td>
<td style="border-color: #C9C9C9; padding: .4em; padding-left: .8em;">{{{returns|[[nil]]}}}</td></tr>

<tr style="background-color: #E8E8E8;"><td style="border-right: solid #C9C9C9 1px; padding: .4em; width: 10%; font-weight: bold;">Part of</td>
<td style="border-color: #C9C9C9; padding: .4em; padding-left: .8em;">[[{{{addon|ComputerCraft}}}]]</td></tr>

<tr style="background-color: #FFFFFF;"><td style="border-right: solid #C9C9C9 1px; padding: .4em; width: 10%; font-weight: bold;">API</td>
<td style="border-color: #C9C9C9; padding: .4em; padding-left: .8em;">{{#if: {{{api}}} | [[{{{api}}} (API)|{{{api}}}]] | none }}</td></tr>

</table>{{#if:{{{examples|}}}|

<h2><span class="mw-headline">Examples</span></h2>
{{{examples|}}}
|}}{{#if:{{{notes|}}}|

<h2><span class="mw-headline">Additional Notes</span></h2>
{{{notes}}}
|}} test
</includeonly>
<noinclude>
__NOTOC__
== Wiki code ==
<nowiki>{{Function
|name=redstone.setOutput
|args=[[string]] side, [[boolean]] value
|api=redstone
|returns=[[nil]]
|addon=ComputerCraft
|desc=Sets a redstone output
|examples=Examples go here (use [[Template:Example]])
|notes=
* Note 1
* Note 2
}}</nowiki>

Note that ''args'', ''returns'', ''addon'', ''examples'' and ''notes'' are optional.

== Result ==
{{User:Immibis/Sandbox
|name=redstone.setOutput
|args=[[string_(type)|string]] side, [[boolean_(type)|boolean]] value
|api=redstone
|returns=[[nil]]
|addon=ComputerCraft
|desc=Sets a redstone output
|examples=Examples go here (use [[Template:Example]])
|notes=
* Note 1
* Note 2
}}
[[Category:Templates]]
</noinclude>

Os.pullEvent

2013-01-07T17:08:01Z

Immibis: Expanded/rewrote "how it works" more like a tutorial, moved "common syntax" above "how it works", added a note about multiple return values, added a note to events that won't normally be seen by programs

{{lowercase}}
{{Function
|name=os.pullEvent
|args=([[string]]) filter
|api=OS
|returns=(string)event, variable parameters(see table below)
|addon=ComputerCraft
|desc=Waits (yields) until an event occurs
|examples=
{{Example
|desc=The program requires to wait for a keypress to do something:
|code=[[Function (type)|function]] clear()
[[term.clear]]()
[[term.setCursorPos]] (1,1)
end
while true do
clear()
[[print]] ("Press E to do something.")
local event, param1 = os.pullEvent ("char") -- limit os.pullEvent to the char event
if param1 == "e" then -- if the returned value was 'e'
clear()
[[write]] ("Name: ")
local name = [[read]]()
[[print]] (name)
break
else
clear()
[[print]] ("Wrong button!")
[[os.sleep|sleep]] (1.5) -- I don't like a whole 2 seconds but 1 second is too short
end
end
}}
}}

=== Common syntax ===

event, param1, param2, param3 = os.pullEvent()

Note: This is one of the most commonly used functions that can return multiple values.
It works like any other function call (such as "input = read()") except that you can get more than one piece of information back.

== How it works ==
When os.pullEvent() is called, the computer waits until an event occurs.
Events can be triggered by several different things, such as a key being pressed or a redstone input changing.
They are usually triggered by ComputerCraft itself, when it needs to notify the computer that something happened.
They can also be triggered by peripherals, or by your program calling [[os.queueEvent]].

More complicated input, such as "the user typing a line of text," does ''not'' correspond to an event.
[[read]] handles this inside itself by waiting for the user to press a key, then updating the screen, moving the cursor, etc.

Events have a type (which is a string) and 0-5 parameters (which are often but not always strings).
No built-in events use more than 3 parameters.

When an event occurs, the event type, followed by the parameters, will be returned. If you have:

event, button, x, y = os.pullEvent()

and the user clicks the mouse at coordinates 5,4 then:
* event will be set to "mouse_click" (the event type)
* button will be set to 0 (the first parameter)
* x will be set to 5 (the second parameter)
* y will be set to 4 (the third parameter)

Note that in this example, we didn't specify a filter. If you specify a filter, then all events of different types will be ignored.
If the user inserts a disk, instead of clicking the mouse, then event will be "disk", button will be the side the disk drive is on, and x and y will be nil.

If we wanted to only wait for mouse clicks we could use:

event, button, x, y = os.pullEvent("mouse_click")

which will ignore any events that are not mouse clicks.

If you assign more variables than necessary, the extra ones will be set to nil.
If you assign less variables than necessary, the extra parameters will be discarded.

==Event types==
{| class="wikitable" width="100%"
! rowspan="2" | Name
! rowspan="2" | Description
! colspan="3" | Parameters
|-
! 1
! 2
! 3
|-
![[char (event)|char]]
|Fired when text is typed on the keyboard
|(string)the letter typed
|
|
|-
![[key (event)|key]]
|Fired when a key is pressed on the keyboard
|(number)numerical keycode
|
|
|-
![[timer (event)|timer]]
|Fired when a timeout started by [[os.startTimer]]() completes
|(number)Value of the timer as returned by os.startTimer()
|
|
|-
![[alarm (event)|alarm]]
|Fired when a time passed to [[os.setAlarm]]() is reached
|(number)Value of the alarm as returned by os.setAlarm()
|
|
|-
![[redstone (event)|redstone]]
|Fired when the state of any of the redstone inputs change
|
|
|
|-
![[terminate (event)|terminate]]
|Fired when a combination of keys CTRL and T is pressed and held for three seconds.
You will not normally see this event, as it is handled inside os.pullEvent.
|
|
|
|-
![[disk (event)|disk]]
|Fired when a disk is inserted into an adjacent disk drive
|(string)side
|
|
|-
![[disk_eject (event)|disk_eject]]
|Fired when a disk is removed from an adjacent disk drive
|(string)side
|
|
|-
![[peripheral (event)|peripheral]]
|Fired when peripheral is attached
|(string)side
|
|
|-
![[peripheral_detach (event)| peripheral_detach]]
|Fired when peripheral is removed
|(string)side
|
|
|-
![[rednet_message (event)|rednet_message]]
|Fired when a rednet message is received from the [[Rednet_(API)|rednet API]]
|(number)senderID
|(string)message
|(number)distance travelled
|-
![[http_success (event)|http_success]]
|Fired when an attempt to receive text from / post text on a website is successful.
You will not normally see this event as it is handled inside http.get.
|(string)url of the site
|(table)text on the site
|
|-
![[http_failure (event)|http_failure]]
|Fired when an attempt to receive text from / post text on a website is unsuccessful
You will not normally see this event as it is handled inside http.get.
|(string)url of the site
|
|
|-
![[mouse_click (event)|mouse_click]]
|Fired when a mouse button is pressed
|(number)mouse button
|(number)x coordinate
|(number)y coordinate
|-
![[mouse_scroll (event)|mouse_scroll]]
|Fired when a mousewheel is scrolled.
|(number)scroll direction (-1 for up, 1 for down)
|(number)x coordinate(in screen chars)
|(number)y coordinate(in screen chars)
|-
![[mouse_drag (event)|mouse_drag]]
|Fired when the mouse is moved after clicking.
|(number)mouse button
|(number)x coordinate(in screen chars)
|(number)y coordinate(in screen chars)
|}

== Guides ==
[http://www.computercraft.info/forums2/index.php?/topic/1516-ospullevent-what-is-it-and-how-is-it-useful/page__view__findpost__p__11156 ''Onionnion's Guide on os.pullEvent()'']

[[Category:Lua_Core_Functions]]

Fs.open

2013-01-03T14:17:56Z

Immibis:

{{lowercase}}
{{Function
|name=fs.open
|args=[[string (type)|string]] path, [[string (type)|string]]
mode
|api=fs
|returns=[[Table_(type)|Table]] the file handle, or <code>nil</code> if the mode was read-only and the file did not exist
|desc=Opens a file; <var>mode</var> consists of a first character which is one of
"r" to open the file read-only,

"w" to open it for writing and remove any existing data, or

"a" to open for writing but keep existing data and append any writes to the end of the file, plus optionally the second character

"b" to open the file for binary access instead of text access
(text mode will perform end-of-line conversions necessary to move text files between Windows, Linux, and Mac OS systems; binary files should not have these conversions applied as they will be corrupted)
|examples=
{{Example
|desc=Creates the file "abcd" and holds a file handle to it
|code=h = fs.open("abcd", "w")
}}
}}

== File Handles ==

A file handle allows access to a file. A file handle is a table; the functions within the table are accessed with the dot operator (<em>not</em> the colon operator, as may be more intuitive!). The examples below assume a file has already been opened and the handle stored in the variable <var>h</var>.

=== Files opened in text read mode ===

A file opened in mode "r" (text read mode) exposes the following functions.

{{Function
|name=<var>h</var>.readLine
|api=fs
|returns=[[string]] the next line read from the file, with the end-of-line character stripped; or nil if there are no more lines in the file
|desc=Reads the next line from the file
}}
{{Function
|name=<var>h</var>.readAll
|api=fs
|returns=[[string]] the entire rest of the file, with the end-of-line character on the very last line (if present) stripped
|desc=Reads the rest of the text in the file
}}
{{Function
|name=<var>h</var>.close
|api=fs
|desc=Closes the file handle, after which it can no longer be used
}}

=== Files opened in text write/append mode ===

A file opened in mode "w" (text write mode) or "a" (text append mode) exposes the following functions:

{{Function
|name=<var>h</var>.write
|args=[[string (type)|string]] data
|api=fs
|desc=Writes a string of characters to the file exactly as they appear in the string <var>data</var>
}}
{{Function
|name=<var>h</var>.writeLine
|args=[[string (type)|string]] data
|api=fs
|desc=Writes a string of characters to the file, then appends an end-of-line character
}}
{{Function
|name=<var>h</var>.close
|api=fs
|desc=Closes the file handle, after which it can no longer be used
}}

=== Files opened in binary read mode ===

A file opened in mode "rb" (binary read mode) exposes the following functions:

{{Function
|name=<var>h</var>.read
|api=fs
|returns=[[int (type)|int]] the byte read from the file, or <code>nil</code> if there are no more bytes
|desc=Reads a single byte from the file and returns it
}}
{{Function
|name=<var>h</var>.close
|api=fs
|desc=Closes the file handle, after which it can no longer be used
}}

=== Files opened in binary write/append mode ===

A file opened in mode "wb" (binary write mode) or "ab" (binary append mode) exposes the following functions:

{{Function
|name=<var>h</var>.write
|args=[[int (type)|int]] byte
|api=fs
|desc=Writes a single byte into the file
}}
{{Function
|name=<var>h</var>.close
|api=fs
|desc=Closes the file handle, after which it can no longer be used
}}

[[Category:Lua_Core_Functions]]

Download

2012-12-07T02:05:03Z

Immibis: Undo revision 4697 by 50.201.57.183 (talk)

=== You can download the latest version of ComputerCraft [http://www.minecraftforum.net/topic/892282- here]. ===

==Changelog:==

{{Changelog}}

[[Category:Lists]]

String (API)

2012-12-07T00:45:49Z

Immibis: Undo revision 4692 by 165.30.102.113 (talk)

The string API is a default Lua 5.1 API as defined [http://www.lua.org/manual/5.1/manual.html#5.4 here]. Please list any non-working functions below.

==Non-Working Functions==

===string.gmatch(string, pattern)===

Using any quantifier other than + will cause it to hang if that quantifier applies to the whole pattern and that pattern does not match the whole string.

Examples:
<pre>
"abcdef":gmatch("%a*") -- Works
"abc=def":gmatch("%a*") -- Hang
"abc=def":gmatch("%a.*") -- Works
"abc=def":gmatch("[%a.]*") -- Hang
"abc=def":gmatch("[^=]*") -- Hang
"abc=def":gmatch("([^=]*)=?") -- Works (Note: This produces the same result as the above pattern should)
"abcdef":gmatch("[^=]*") -- Works
"abc=def":gmatch("[^=]*=") -- Works
</pre>

===string.sub / string.find ===

Both string.sub and string.find work on their own, but calling string.find on a string returned by string.sub will return the index of the character in the original string, not the sub string you are referencing.

Example:
<pre>
local testString = "This is a sample string";
local testSubString = string.sub(testString,5);

local indexOfSample = string.find(testSubString,"sample");
</pre>

indexOfSample is returned 11 instead of the expected 7

Concatenating a blank string onto the end of the string causes new memory to be allocated and works properly again

<pre>
local testString = "This is a sample string";
local testSubString = string.sub(testString,5);

local indexOfSample = string.find(testSubString.."","sample");
</pre>

This is also a problem with using string.find on command line arguments, as this returns the index in the full command path instead of the specific argument.

[[Category:APIs]]

Parallel (API)

2012-10-06T23:48:58Z

Immibis:

Parallel is an API which allows you to multitask.
{| border="1" cellpadding="2" cellspacing="0"
!style="background:#EEE" width="200px"|Method name
!style="background:#EEE" width="*"|Description
|-
|[[parallel.waitForAny]]( function1, function2, so on)
|Runs all the functions at the same time, and stops when any of them returns.
|-
|[[parallel.waitForAll]]( function1, function2, so on)
|Runs all the functions at the same time, and stops when all of them have returned.
|}
[[Category:APIs]]

Turtle.back

2012-03-02T09:03:12Z

Immibis: Created page with "{{lowercase}} {{Function |name=turtle.back |args= |api=turtle |returns=boolean whether the turtle succeeded in moving backwards |addon=ComputerCraft |desc=Attempts to move..."

{{lowercase}}
{{Function
|name=turtle.back
|args=
|api=turtle
|returns=[[boolean]] whether the turtle succeeded in moving backwards
|addon=ComputerCraft
|desc=Attempts to move the turtle backwards.
|examples=
{{Example
|desc=Moves the turtle backwards
|code=print(turtle.back())
|output=true if the turtle could move backwards, false if there was something in the way
}}
}}

Template:Function

2012-03-02T09:02:01Z

Immibis: fixed typo

<includeonly>
<table style="width: 70%; border: solid 2px black; margin: 2px; padding: .3em; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid black 1px;">Function {{{name}}}</td></tr>
<tr style="background-color: #E8E8E8;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">Syntax</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">{{{name}}}({{{args|}}})</td></tr>
<tr style="background-color: #FFFFFF;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">Returns</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">{{{returns|[[nil]]}}}</td></tr>
<tr style="background-color: #E8E8E8;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">Part of</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">[[{{{addon|ComputerCraft}}}]]</td></tr>
<tr style="background-color: #FFFFFF;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">API</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">[[{{{api}}} (API)|{{{api}}}]]</td></tr>
<tr style="background-color: #E8E8E8;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">Description</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">{{{desc|No description provided.}}}</td></tr>
</table>

== Examples ==
{{{examples|There are no examples for this function.}}}

{{#if:{{{notes|}}}|
== Additional Notes ==
{{{notes}}}
|}}
[[Category:{{{category|Methods}}}]]
</includeonly>
<noinclude>
__NOTOC__
== Wiki code ==
<nowiki>{{Function
|name=redstone.setOutput
|args=[[string]] side, [[boolean]] value
|api=redstone
|returns=[[nil]]
|addon=ComputerCraft
|desc=Sets a redstone output
|examples=Examples go here
|notes=
* Note 1
* Note 2
}}</nowiki>

Note that ''returns'', ''addon'', ''examples'' and ''notes'' are optional.

== Result ==
{{Function
|name=redstone.setOutput
|args=[[string]] side, [[boolean]] value
|api=redstone
|returns=[[nil]]
|addon=ComputerCraft
|desc=Sets a redstone output
|examples=Examples go here
|notes=
* Note 1
* Note 2
}}
</noinclude>

Template:Function

2012-03-02T09:01:18Z

Immibis: moved description field

<includeonly>
<table style="width: 70%; border: solid 2px black; margin: 2px; padding: .3em; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid black 1px;">Function {{{name}}}</td></tr>
<tr style="background-color: #E8E8E8;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">Syntax</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">{{{name}}}({{{args|}}})</td></tr>
<tr style="background-color: #FFFFFF;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">Returns</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">{{{returns|[[nil]]}}}</td></tr>
<tr style="background-color: #E8E8E8;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">Part of</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">[[{{{addon|ComputerCraft}}}]]</td></tr>
<tr style="background-color: #FFFFFF;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">API</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">[[{{{api}}} (API)|{{{api}}}]]</td></tr>
<tr style="background-color: #E8E8E8;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">Description</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">{{desc|No description provided.}}</td></tr>
</table>

== Examples ==
{{{examples|There are no examples for this function.}}}

{{#if:{{{notes|}}}|
== Additional Notes ==
{{{notes}}}
|}}
[[Category:{{{category|Methods}}}]]
</includeonly>
<noinclude>
__NOTOC__
== Wiki code ==
<nowiki>{{Function
|name=redstone.setOutput
|args=[[string]] side, [[boolean]] value
|api=redstone
|returns=[[nil]]
|addon=ComputerCraft
|desc=Sets a redstone output
|examples=Examples go here
|notes=
* Note 1
* Note 2
}}</nowiki>

Note that ''returns'', ''addon'', ''examples'' and ''notes'' are optional.

== Result ==
{{Function
|name=redstone.setOutput
|args=[[string]] side, [[boolean]] value
|api=redstone
|returns=[[nil]]
|addon=ComputerCraft
|desc=Sets a redstone output
|examples=Examples go here
|notes=
* Note 1
* Note 2
}}
</noinclude>

Template:Function

2012-03-02T08:58:19Z

Immibis: added description field

<includeonly>
<table style="width: 70%; border: solid 2px black; margin: 2px; padding: .3em; border-spacing: 0px;">
<tr><td colspan="2" style="font-weight: bold; font-size: large; padding-bottom: .3em; border-bottom: solid black 1px;">Function {{{name}}}</td></tr>
<tr style="background-color: #E8E8E8;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">Syntax</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">{{{name}}}({{{args|}}})</td></tr>
<tr style="background-color: #FFFFFF;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">Returns</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">{{{returns|[[nil]]}}}</td></tr>
<tr style="background-color: #E8E8E8;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">Part of</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">[[{{{addon|ComputerCraft}}}]]</td></tr>
<tr style="background-color: #FFFFFF;"><td style="border-right: solid black 1px; padding: .2em; width: 10%; font-weight: bold;">API</td>
<td style="border-color: black; padding: .2em; padding-left: .4em;">[[{{{api}}} (API)|{{{api}}}]]</td></tr>
</table>

{{{desc|}}}

== Examples ==
{{{examples|There are no examples for this function.}}}

{{#if:{{{notes|}}}|
== Additional Notes ==
{{{notes}}}
|}}
[[Category:{{{category|Methods}}}]]
</includeonly>
<noinclude>
__NOTOC__
== Wiki code ==
<nowiki>{{Function
|name=redstone.setOutput
|args=[[string]] side, [[boolean]] value
|api=redstone
|returns=[[nil]]
|addon=ComputerCraft
|desc=Sets a redstone output
|examples=Examples go here
|notes=
* Note 1
* Note 2
}}</nowiki>

Note that ''returns'', ''addon'', ''examples'' and ''notes'' are optional.

== Result ==
{{Function
|name=redstone.setOutput
|args=[[string]] side, [[boolean]] value
|api=redstone
|returns=[[nil]]
|addon=ComputerCraft
|desc=Sets a redstone output
|examples=Examples go here
|notes=
* Note 1
* Note 2
}}
</noinclude>

User talk:Immibis

2012-03-02T08:55:04Z

Immibis:

Welcome to the wiki. I see you've found templates are all sorts of weirded out. :P {{User:Scarfacial/Signature|03:42 - 26 February 2012}}
:Lol. As it turns out, it was because I thought parser functions were enabled when they weren't, and was using the wrong syntax for them, and then had all sorts of problems when every #if acted as if it was true. [[User:Immibis|Immibis]] 10:11, 28 February 2012 (UTC)
::Yeah. No clue how you fixed them (I assume it was you from your summary comments :P), but thanks :3 {{User:Scarfacial/Signature|17:22 - 28 February 2012}}
:::I got Casper to enable them, in IRC. That's how. [[User:Immibis|Immibis]] 08:55, 2 March 2012 (UTC)

User talk:Immibis

2012-02-28T10:11:55Z

Immibis:

Fs.list

2012-02-26T21:30:05Z

Immibis:

{{Function
|name=fs.list
|args=[[string (type)|string]] path
|api=fs
|returns=[[table (type)|table]] list of files and folders in that path
|examples=
{{Example
|desc=Displays a list of all files and folders in the root directory of a computer
|code=for k,v in ipairs(fs.list("/")) do
print(v)
end
|output=A list of all files and folders in /
}}
}}

Fs.list

2012-02-26T21:29:28Z

Immibis: Created page with "{{Function |name=fs.list |args=string path |api=fs |examples= {{Example |desc=Displays a list of all files and folders in the root directory of a computer |c..."

{{Function
|name=fs.list
|args=[[string (type)|string]] path
|api=fs
|examples=
{{Example
|desc=Displays a list of all files and folders in the root directory of a computer
|code=for k,v in ipairs(fs.list("/")) do
print(v)
end
|output=A list of all files and folders in /
}}
}}

Fs (API)

2012-02-26T21:26:59Z

Immibis:

The FS API allows you to mess around with the filesystem.
{| border="1" cellpadding="2" cellspacing="0"
!style="background:#EEE" width="200px"|Method name
!style="background:#EEE" width="*"|Description
|-
|[[fs.list]]( path )
|<no description given>
|-
|[[fs.exists]]( path )
|Checks if the given path exists
|-
|[[fs.isDir]]( path )
|Checks if the given path is a directory.
|-
|[[fs.isReadOnly]]( path )
|Checks if you can only read to a directory.
|-
|[[fs.getName]]( path )
|<no description given>
|-
|[[fs.getDrive]]( path )
|<no description given>
|-
|[[fs.makeDir]]( path )
|Makes a directory.
|-
|[[fs.move]]( path, path )
|Moves path 1 to path 2.
|-
|[[fs.copy]]( path, path )
|Copies path 1 to path 2.
|-
|[[fs.delete]]( path )
|Deletes the given path.
|-
|[[fs.combine]]( path, localpath )
|Adds the given path and the local path together to make a new path. Like if localpath is C\ and path is programs\, it will make C\programs\ and return it.
|-
|[[fs.open]]( path, mode )
|Opens the given path. Modes: "r", "w", "a", "rb", "wb", "ab". Meaning: <no description given>
|}
[[Category:APIs]]

Color (API)

2012-02-26T21:25:33Z

Immibis: added function links

The Colors API allows you to mess with colors. For the British just replace 'color' with 'colour' and it will use the other API, colours, which is just a British version.

Its functions are:
{| border="1" cellpadding="2" cellspacing="0"
!style="background:#EEE" width="200px"|Method name
!style="background:#EEE" width="*"|Description
|-
|[[colors.combine]]( color1, color2, color3, so on)
|combines the colors
|-
|[[colors.subtract]]( colors, color1, color2, so on)
|subtracts the given colors
|-
|[[colors.test]]( colors, color )
|<no description given>
|}

Color constants include, in ascending bit order:

* colors.white
* colors.orange
* colors.magenta
* colors.lightBlue
* colors.yellow
* colors.lime
* colors.pink
* colors.gray
* colors.lightGray
* colors.cyan
* colors.purple
* colors.blue
* colors.brown
* colors.green
* colors.red
* colors.black
[[Category:APIs]]

Bit (API)

2012-02-26T21:24:33Z

Immibis: added function links

The Bit API is for manipulating bits of variables.

A list of functions:
{| border="1" cellpadding="2" cellspacing="0"
!style="background:#EEE" width="200px"|Method name
!style="background:#EEE" width="*"|Description
|-
|[[bit.tobits]](n)
|<no description given>
|-
|[[bit.blshift]](n, bits)
|<no description given>
|-
|[[bit.brshift]](n, bits)
|<no description given>
|-
|[[bit.bxor]](m, n)
|<no description given>
|-
|[[bit.bor]](m, n)
|<no description given>
|-
|[[bit.band]](m, n)
|<no description given>
|-
|[[bit.bnot]](n)
|<no description given>
|-
|[[bit.tonumb]](bit_tbl)
|<no description given>
|}

[[Category:APIs]]

Turtle (API)

2012-02-26T21:23:05Z

Immibis: add function links

The Turtle API is used to Work with your Turtles.
{| border="1" cellpadding="2" cellspacing="0"
!style="background:#EEE" width="200px"|Method name
!style="background:#EEE" width="*"|Description
|-
|[[turtle.forward]]()
|Let the Turtle move forward
|-
|[[turtle.back]]()
|Let the Turtle move back
|-
|[[turtle.up]]()
|Let the Turtle move up
|-
|[[turtle.down]]()
|Let the Turtle move down
|-
|[[turtle.turnLeft]]()
|The Turtle turns left
|-
|[[turtle.turnRight]]()
|The Turtle turns right
|-
|[[turtle.select]]( slotNum )
|The Turtle selects the given Slot (1 is top left, 9 is bottom right)
|-
|[[turtle.getItemCount]]( slotNum )
|Counts how many items are in the given Slot
|-
|[[turtle.getItemSpace]]( slotNum )
|Counts how many items you need to fill the stack in the given Slot
|-
|[[turtle.dig]]()
|Breaks the Block in front
|-
|[[turtle.digUp]]()
|Breaks the Block above
|-
|[[turtle.digDown]]()
|Breaks the Block below
|-
|[[turtle.place]]()
|Places a Block of the selected Slot in front
|-
|[[turtle.placeUp]]()
|Places a Block of the selected Slot above
|-
|[[turtle.placeDown]]()
|Places a Block of the selected Slot below
|-
|[[turtle.detect]]()
|Detects if there is a Block in front
|-
|[[turtle.detectUp]]()
|Detects if there is a Block above
|-
|[[turtle.detectDown]]()
|Detects if there is a Block below
|-
|[[turtle.drop]]()
|Drops everything of the selected Slot
|}
[[Category:APIs]]

Redstone.getBundledInput

2012-02-26T04:19:46Z

Immibis:

{{Function
|name=redstone.getBundledInput
|args=[[string]] side
|api=redstone
|returns=[[colors (type)|colors]] the colours that are activated on that side
|addon=ComputerCraft
|examples=
{{Example
|desc=Checks whether the blue part of the back input is active
|code=print(colors.test(redstone.getBundledInput("back"), colors.blue))
|output=true if the blue part of the back input is active, otherwise false
}}
}}

Redstone.getBundledInput

2012-02-26T04:19:25Z

Immibis: Created page with "{{Function |name=redstone.getBundledInput |args=string side |api=redstone |returns=colors the colours that are activated on that side |addon=ComputerCraft |examples= {..."

{{Function
|name=redstone.getBundledInput
|args=[[string]] side
|api=redstone
|returns=[[colors]] the colours that are activated on that side
|addon=ComputerCraft
|examples=
{{Example
|desc=Checks whether the blue part of the back input is active
|code=print(colors.test(redstone.getBundledInput("back"), colors.blue))
|output=true if the blue part of the back input is active, otherwise false
}}
}}

Redstone (API)

2012-02-26T04:02:02Z

Immibis: fixed link, added types

== Description ==

The redstone API contains methods to control attached RedPower cables/bundled cables

== Methods ==

{| border="1" cellpadding="2" cellspacing="0"
!style="background:#EEE" width="200px"|Method name
!style="background:#EEE" width="*"|Description
|-
|[[redstone.getBundledInput|getBundledInput]]([[string]] side)
|Returns the state of a redpower wire inside a bundle connected to ''side''
|-
|[[redstone.getBundledOutput|getBundledOutput]]([[string]] side)
|Returns the set of redpower wires inside a bundle on ''side'' that are being driven high by the local console (not those that are driven high by another device on the bundle but not driven high by the local console)
|-
|[[redstone.setBundledOutput|setBundledOutput]]([[string]] side, [[int]] colors)
|Sets one or multiple colored signals in a redpower bundled wire connected to ''Side''
|-
|[[redstone.testBundledInput|testBundledInput]]([[string]] side, [[int]] color)
|Returns true or false whether or not a colored signal is active in a redpower bundled wire connected to ''Side''
|-
|[[redstone.getInput|getInput]]([[string]] side)
|Returns the current redstone signal state on ''side''
|-
|[[redstone.getSides|getSides]]()
|Returns an array of possible sides
|-
|[[redstone.setOutput|setOutput]]([[string]] side, [[boolean]] value)
|Set or reset a redstone signal on ''side''
|}

[[Category:APIs]]

Redstone.getSides

2012-02-26T03:59:29Z

Immibis: Created page with "{{lowercase}} {{Function |name=redstone.getSides |args= |returns=table list of valid sides |api=redstone |examples= {{Example |desc=Prints all valid sides |code=for k,v in..."

{{lowercase}}
{{Function
|name=redstone.getSides
|args=
|returns=[[table]] list of valid sides
|api=redstone
|examples=
{{Example
|desc=Prints all valid sides
|code=for k,v in ipairs(redstone.getSides()) do
print(v)
end
|output=A list of all valid sides (top, bottom, left, right, front and back)
}}
}}