|
|
(13 intermediate revisions by the same user not shown) |
Line 1: |
Line 1: |
| {| style="{{border-radius|4px}}; background-color: #ffdddd; border: dashed 2px #aa0000; border-top-color: #ff0000; border-left-color: #ff0000; margin: auto 10px; padding: 2px; display: block" | | {{User:Merlin11188/Templates/NoEdit}} |
| |{{ImageLink|image=ArrowSquare.png|link=User:Tomtomn00/Sandbox/NoEditTemplate}}
| |
| |<big>'''Do not edit!'''</big><br><small>The creator of this subpage does not want it to be edited without permission.</small>
| |
| |}
| |
| | |
| ==Hello World==
| |
| | |
| The language I'm teaching you is called ''Lua''. A tradition of programming languages is to start off the learner with a ''Hello World'' program. So what is a ''Hello World'' program? It is a program that writes the words "Hello World" to the [[Output|output]]. Here it is in Lua:
| |
| {{Example|{{Code and output|code=
| |
| print("Hello World")
| |
| |output=
| |
| Hello World
| |
| |fit=output}}}}
| |
| | |
| Ta-da! For now and the rest of the tutorial, that box on the left is the output. Keep that in mind. [[Function_Dump/Core_Functions#print_.28.C2.B7.C2.B7.C2.B7.29|Print]] is our function for writing to the output. When we want to print string literals (words, like ''Hello World'') to the output, we '''must''' put them in quotes. Here's another example:
| |
| | |
| {{Example|{{Code and output|code=
| |
| print("Hi Newcomer!")
| |
| |output=
| |
| Hi Newcomer!
| |
| |fit=output}}}}
| |
|
| |
|
|
| |
|
| | {{Stub}} |
| | {| |
| | |[[File:Home_Subpage.png|frame|A picture of the 'Home' tab on the submenu in 'My ROBLOX'.]] <br/> |
| | |} |
| __TOC__ | | __TOC__ |
|
| |
|
|
| |
|
| ==Beginning== | | ===Character and Notifications=== |
| ===Terminology===
| | {| |
| | |On the far left of the page there is a picture of [[My_Character|your character]]. Underneath, there is a link to your system notifications. |
| | |[[File:Avatar_Notifications.png|frame|A picture of [[My_Character|your character]] with system notifications beneath it.]] |
| | |} |
|
| |
|
| There are three terms I want you to know before we continue:
| | ===Best Friends=== |
| *{{`|code}} refers to '''anything''' written in Lua.
| | {| |
| *{{`|chunk}} refers to '''one''' line of {{`|code}} in Lua.
| | |Underneath of your avatar and notification box is your [[Friends#Best_Friends|best friends]] list. Here you can see what your best friends are doing (from their [[My_Home#Status_Update|shout box]]) and whether or not they're online. |
| *{{`|script}} refers to '''multiple''' {{`|chunk}}s that accomplish a specific task in Lua.
| | |[[File:Best_Friends.png|frame|This a list of your [[Friends#Best_Friends|best friends]] and their most recent shouts!]] |
| *{{`|character}} refers to any of the [http://wiki.roblox.com/index.php/File:Ascii_Table.png ASCII Values] (numbers, letters, spaces, enter key, down arrow, etc.)
| | |} |
|
| |
|
| ===[[Comments_(Scripting)|Comments]]=== | | ===Status Update=== |
| | {| |
| | |You can use this so that people who visit your profile can see what you're up to. |
| | |[[File:Status Update.png|frame|This is the status update bar. People who have you as their [[Friends#Best_Friends|best friend]] will see it on their [[My_Home|home]]!]] |
| | |} |
|
| |
|
| Before I start explaining the stuff you can do in Lua to you, there is something I need to explain to you that I'm going to use a lot in this tutorial: ''Commenting''. Comments are things that are '''not''' executed by Lua. A comment can contain any characters because it doesn't need to be read.
| | ===Feed=== |
| | {| |
| | |Your feed is in the center of the page, just beneath your status update box. Your feed is a way to keep you updated with all of your groups. Every time someone uses the shout box in one of your [[groups]], you're updated here! |
| | |[[File:Feed bar.png|frame|This is for your feed—all of your [[groups]]' shouts go here.]] |
| | |} |
|
| |
|
| ====[[Comments_(Scripting)#Single-line_Comments|One-Line Comments]]==== | | ===Recently Played Games=== |
| | {| |
| | |On the far right is the 'Recently Played Games' box. Your most recently played games can be seen here. If you want a larger list, you can click the '''See More''' button. |
| | |[[File:Recently_Played_Games.png|frame|This is a list of your most recently played [[game]]s.]] |
| | |} |
|
| |
|
| A one-line comment is made with {{`|--}}. It lasts for the rest of the line. Here are some examples:
| | ===Facebook Connect=== |
| {{Example|{{Code and output|code=
| | {| |
| print("Hello world") -- This will print Hello world to the output!
| | |On the far right, underneath of the 'Recently Played Games' box is the Facebook connect box. If you have a Facebook account, you can link it to your ROBLOX account! See [[connecting your account to Facebook]] for more info. |
| -- I'm invisible! print("Hi"). Hi won't be printed to the output!
| | |[[File:FacebookConnect_Unconnected.png|frame|Facebook connect. You can use this to link your Facebook account to your [[Roblox|ROBLOX]] account! Your personal info will '''not''' be shared with other users!]] |
| |output=
| | |} |
| Hello world
| |
| |fit=output}}}}
| |
| | |
| ====[[Comments_(Scripting)#Block_Comments|Multi-Line Comments]]====
| |
| | |
| A multi-line comment starts with {{`|<nowiki>--[[</nowiki>}} and ends with {{`|<nowiki>]]</nowiki>}}. Everything between the opening and the closing is treated as a comment, even if the comment is only in the middle of the line.
| |
| {{Example|{{Code and output|code=
| |
| print("Hello World")--[[
| |
| I'm a very long comment.
| |
| In fact, I last multiple lines.
| |
| Should I be discovered, I must… but that won't happen.
| |
| ]]|output=
| |
| Hello World
| |
| |fit=output}}}}
| |
| | |
| ''A multi-line comment '''cannot''' be placed inside of a string literal (inside of quotation marks)!'' You must put it elsewhere. Here are more examples:
| |
| {{Example|{{Code and output|code=
| |
| print("Hello M--[[I'll never be found!]]y Friend!")
| |
| --[[They'll never catch me!]]print("HI")
| |
| |output=
| |
| Hello M--[[I'll never be found!]]y Friend!
| |
| HI
| |
| }}}}
| |
| | |
| There are also [[Comments_(Scripting)#Leveled_Comments|leveled comments]], but I won't go into those. They're just like multi-line comments, except they have different levels. I never use them.
| |
| | |
| ===[[Variable|Variables]]===
| |
| | |
| A [[Variable|variable]] is just a container. It holds a value. For a good understanding, please read the [[Variable|page on variables]] from sections [[Variable#Assignment|1]] to [[Variable#Swapping|3.1]], ignoring the section on Scope. We'll get to that later. Here are just some examples of variables:
| |
| | |
| {{Example|<code lua>
| |
| x = 3
| |
| y = 4
| |
| aVariable = 6
| |
| iHave134141NumbersInMyNameAndABooleanValue = true
| |
| </code>}}
| |
| | |
| Remember that saying {{`|<nowiki>variable = someValue</nowiki>}} is called ''declaring a variable''.
| |
| | |
| ==Types and Values==
| |
| ===[[Nil]]===
| |
| | |
| For our intents and purposes, [[Nil|''nil'']] means nothing. If you '''really''' want an in-depth guide, read [[Nil|the page on nil]]. Here are some examples:
| |
| {{Example|{{Code and output|code=
| |
| x1 = nil
| |
| x2 = nil
| |
| x3 = nil
| |
| x4 = nil
| |
| -- Yeah. Boring =P
| |
| print(x4) -- Want to print the value of a variable? print(VARIABLE NAME HERE)
| |
| |output=
| |
| nil
| |
| |fit=output}}}}
| |
| | |
| ===[[Boolean|Booleans]]===
| |
| | |
| A [[boolean]] is a simple data type. It is either '''true''' or '''false'''—always. There are no exceptions. Here are some examples:
| |
| {{Example|{{Code and output|code=
| |
| bool = true
| |
| thisGuideIsntAwesome = false
| |
| thisGuideRocks = true
| |
| print(thisGuideRocks)
| |
| print(thisGuideIsntAwesome)
| |
| |output=
| |
| true
| |
| false
| |
| |fit=output}}}}
| |
| | |
| ===[[Number|Numbers]]===
| |
| | |
| A [[number]] is a data type that can hold a number. In Lua, unlike other languages, a number can transfer between any of the following types of numbers without any special functions:
| |
| *[[Integer]] (no decimal point: {{`|32}}
| |
| *Floating-point (have a decimal point: {{`|32.4}}
| |
| *[[Hexadecimal]] (I wouldn't recommend using that if you don't know what it does. Example: {{`|0xFFA3}}
| |
| Here are some examples:
| |
| {{Example|{{Code and output|code=
| |
| num1 = 9123
| |
| num2 = 1234122.1234
| |
| num3 = 0xAFB2
| |
| print(num1)
| |
| print(num2)
| |
| print(num3)
| |
| |output=
| |
| 9123
| |
| 1234122.1234
| |
| 44978
| |
| |fit=output}}}}
| |
| | |
| ===[[String|Strings]]===
| |
| | |
| A [[string]] is a data type that holds '''any''' {{`|characters}], with one exception: a single-line quote. Before we begin, a ''string literal'' is any string placed inside of what I will refer to as ''string marks'' in the following sections. When declaring a variable as a string, you will most likely declare it as a string literal.
| |
| | |
| ====One-Line Strings====
| |
| | |
| The ''string marks'' for a one-line string are quotation marks ({{`|" "}} or {{`|' '}}. Please use the double quotes, not the single quotes for strings. Here are some examples:
| |
| {{Example|{{Code and output|code=
| |
| name = "Merlin11188"
| |
| dateWhenWritten = "1/22/2012"
| |
| greeting = "Hi! How are you?"
| |
| print(name)
| |
| print(dateWhenWritten)
| |
| print(greeting)
| |
| |output=
| |
| Merlin11188
| |
| 1/22/2012
| |
| Hi! How are you?
| |
| |fit=output}}}}
| |
| | |
| ====Multi-Line Strings====
| |
| | |
| The ''string marks'' for a multi-line string are brackets ({{`|[[<--start. end -->]]}}). They can contain '''any and all''' {{`|characters}} Please ignore the syntax highlighting (color of the text) in the following example; it's inaccurate.
| |
| {{Example|{{Code and output|code=
| |
| longString = [[I'm a very
| |
| long string that
| |
| has multiple
| |
| lines and takes up
| |
| a lot of
| |
| space.
| |
| ]]
| |
| otherLongString = [[I'm multiple lines,
| |
| but still relatively short!]]
| |
| print(longString)
| |
| print(otherLongString)
| |
| |output=
| |
| I'm a very
| |
| long string that
| |
| has multiple
| |
| lines and takes up
| |
| a lot of
| |
| space.
| |
| | |
| I'm multiple lines,
| |
| but still relatively short!
| |
| |fit=output}}}}
| |
| | |
| Much like [[Comments#Leveled_Comments|leveled comments]], you may also have leveled strings. They work in the exact same way, except they don't start with {{`|--}}.
| |
| | |
| ===Objects===
| |
| | |
| Objects are more advanced data types, such as:
| |
| *Tables
| |
| *Functions
| |
| *Threads
| |
| *Userdatas
| |
| I'll go into those later.
| |
| | |
| ==Expressions==
| |
| | |
| An expression is a chunk in Lua that manipulations a value through the use of [[Operator|operators]].
| |
| | |
| ===[[Operator|Operators]]===
| |
| | |
| An ''[[operator]]'' allows you to manipulate the value of a variable. Some examples of manipulation are addition, subtraction, and combining two strings. Yay! Useful things!
| |
| | |
| ====[[Arithmetic_Operators|Arithmetic]]====
| |
| | |
| The mathematical operators are:
| |
| *{{`|+}}; to add two numbers
| |
| *{{`|-}}; to subtract two numbers (or to get the opposite of a number)
| |
| *{{`|*}}; to multiply two numbers
| |
| *{{`|/}}; to divide two numbers
| |
| *{{`|^}}; to raise a number to an exponent
| |
| *{{`|%}}; for the modulus of one number by another number
| |
| | |
| The modulus operator returns the remainder of division. So, {{`|7 % 3}} equals 1 because {{`|<nowiki>7/3 = 2 r1</nowiki>}}. Here are some examples:
| |
| {{Example|{{Code and output|code=
| |
| x = 4
| |
| x = x*2
| |
| print(x)
| |
| x = x + 6
| |
| print(x)
| |
| x = x - 2
| |
| print(x)
| |
| x = x/3
| |
| print(x)
| |
| x = x^2
| |
| print(x)
| |
| x = x%5
| |
| print(x)
| |
| x = x/2
| |
| print(x)
| |
| |output=
| |
| 8
| |
| 14
| |
| 12
| |
| 4
| |
| 16
| |
| 1
| |
| 0.5
| |
| |fit=output}}}}
| |
| | |
| ====[[Operator#Comparative|Relational]]====
| |
| | |
| [[Operator#Comparative|Relational operators]] '''always''' return a ''[[boolean]]'', '''true''' or '''false'''. There are six relational operators:
| |
| *{{`|<nowiki>></nowiki>}}; greater than
| |
| *{{`|<nowiki><</nowiki>}}; less than
| |
| *{{`|<nowiki>>=</nowiki>}}; greater than or equal to
| |
| *{{`|<nowiki><=</nowiki>}}; less than or equal to
| |
| *{{`|<nowiki>==</nowiki>}}; equal to
| |
| *{{`|<nowiki>~=</nowiki>}}; not equal to
| |
| | |
| Remember from math class what those things do? No? Fine, then. Here are examples:
| |
| {{Example|{{Code and output|code=
| |
| w, x, y, z = 3, 4, 5, 3
| |
| print(w > x)
| |
| print(x < y)
| |
| print(y <= z)
| |
| print(w >= z)
| |
| |output=
| |
| false
| |
| true
| |
| false
| |
| true
| |
| |fit=output}}}}
| |
| | |
| ====[[Operator#Logical|Logical]]====
| |
| | |
| All [[Operator#Logical|logical operators]] consider false and nil as false and anything else as true. There are three logical operators in Lua:
| |
| *[[And_operator|{{`|and}}]]
| |
| *[[Or_operator|{{`|or}}]]
| |
| *[[Not_operator|{{`|not}}]]
| |
| | |
| =====[[And_operator|And]]=====
| |
| | |
| The [[And_operator|{{`|and}} operator]] checks its first operand (the thing that comes before it); if its first operand is false or nil, {{`|and}} returns that operand's value. If its first operand is not false nor nil, then it returns the second operand's value (the value of the thing that comes after it). Here are some examples:
| |
| | |
| {{Example|{{Code and output|code=
| |
| a, b, c, d = 1, true, false, "Hi"
| |
| print(a and b)
| |
| print(a and d)
| |
| print(b and c)
| |
| print(c and a)
| |
| print(b and d)
| |
| |output=
| |
| true
| |
| Hi
| |
| false
| |
| false
| |
| Hi
| |
| |fit=output}}}}
| |
| | |
| =====[[Or_operator|Or]]=====
| |
| The [[Or_operator|{{`|or}} operator]] checks if its first operand is not nil nor false; if it's not nil nor false then it returns that operand's value. Otherwise, it returns the second operand's value. Here are some examples:
| |
| | |
| {{Example|{{Code and output|code=
| |
| a, b, c, d = 1, true, false, "Hi"
| |
| print(a or b)
| |
| print(a or c)
| |
| print(a or d)
| |
| print(b or c)
| |
| print(b or d)
| |
| print(c or d)
| |
| print(c or a)
| |
| print(d or c)
| |
| print(c or c)
| |
| |output=
| |
| 1
| |
| 1
| |
| 1
| |
| true
| |
| true
| |
| Hi
| |
| 1
| |
| Hi
| |
| false
| |
| |fit=output}}}}
| |
| | |
| =====Not=====
| |
| | |
| The [[Not_operator|{{`|not}} operator]], unlike the other [[Operator#Logical|logical operators]] '''always''' returns a [[boolean]], '''true''' or '''false'''. if its ''only'' operand is nil or false, then true is returned. If its only operand is not nil nor false, then false is returned. Here are some examples:
| |
| {{Example|{{Code and output|code=
| |
| a, b, c, d = 1, true, false, "Hi"
| |
| print(not a)
| |
| print(not b)
| |
| print(not c)
| |
| print(not d)
| |
| |output=
| |
| false
| |
| false
| |
| true
| |
| false
| |
| |fit=output}}}}
| |
| | |
| ====[[Concatenation]]====
| |
| | |
| The [[Concatenation|concatenation operator]] ({{`|..}}) appends one string onto another. In the case of one of the operands being a number, converts it to a string first. Here are some examples:
| |
| | |
| {{Example|{{Code and output|code=
| |
| x, y, z = "He", "llo ", "there."
| |
| print(x .. y)
| |
| print(x .. z)
| |
| print(y .. x)
| |
| print(x .. " who is happy is rich.")
| |
| print(z .. " he is!")
| |
| print(z .. 35)
| |
| print(35 .. 35)
| |
| |output=
| |
| Hello
| |
| Hethere.
| |
| llo He
| |
| He who is happy is rich.
| |
| there. he is!
| |
| there.35
| |
| 3535
| |
| |fit = output}}}}
| |
| | |
| ===[[Precedence]]===
| |
| [[Precedence]] refers to the order in which operators are executed. When you have a math equation, like this:
| |
| <pre>
| |
| 3*4 + 2*9 - 7/9 % 3 + 4 * 5
| |
| </pre>
| |
| what order does Lua do that in? Does it work it from right to left? (Hint: The answer is 49.222222222222.) No. Lua doesn't. That's where precedence comes into play. Which one is evaluated first? Why, the operators are evaluated in the order from top to bottom of this chart:
| |
| <pre>
| |
| ^
| |
| not - (unary)
| |
| * / %
| |
| + -
| |
| ..
| |
| < > <= >= ~= ==
| |
| and
| |
| or
| |
| </pre>
| |
| '''Note:''' Things inside of parentheses are evaluated first. (7 + 3)*2 will be 20, whereas 7 + 3*2 will be 13.
| |
| Operators with the same precedence are evaluated from left to right. So, in the above equation, the first things to be evaluated is the 3*4, then the 2*9, then the 7/9, then the (7/9)%3, then the 4*5, and so on. As with all operators, you can put strings of operators together. Here are some examples:
| |
|
| |
|
| {{Example|{{Code and output|code= | | <!-- |
| print(3*4 + 9/3 - 6%2^3/3 + 9 - 8 .. " is a number.")
| | {| class="wikitable" style="border-spacing: 0px; padding: 0px;" |
| print(6^3*3-48 .. " is a multiple of 100 and is equal to " .. 3 .. "*" .. 4 .. "*" .. 50 .. ".")
| | |- |
| |output= | | |[[File:Avatar + Notifications]] |
| 14 is a number.
| | |[[File:Status_Update.png]] |
| 600 is a multiple of 100 and is equal to 3*4*50.
| | |[[File:Recently_Played_Games.png|287px]] |
| |fit=code}}}} | | |- |
| | |[[File:Best_Friends.png]] |
| | |<div style="top:0px;">[[File:Feed_bar.png]]</div> |
| | |[[File:FacebookConnect_Unconnected.png]] |
| | |}--> |