https://wiki.multitheftauto.com/api.php?action=feedcontributions&feedformat=atom&user=NovoMulti Theft Auto: Wiki - User contributions [en]2026-04-27T10:46:36ZUser contributionsMediaWiki 1.39.3https://wiki.multitheftauto.com/index.php?title=User:Novo&diff=44023User:Novo2015-01-18T13:28:55Z<p>Novo: </p>
<hr />
<div>__NOTOC__<br />
== Contact me ==<br />
=== Forum ===<br />
* [http://forum.mtasa.com/memberlist.php?mode=viewprofile&u=53356 novo] - [http://forum.mtasa.com/ucp.php?i=pm&mode=compose&u=53356 PM]<br />
<br />
=== Skype ===<br />
* Adam James @adam.mta<br />
<br />
=== E-mail ===<br />
''<nowiki>(though Skype is preferred)</nowiki>''<br />
* Adam James - ''htx@hotmail.es''<br />
<br />
== Latest contributions ==<br />
{| class="wikitable" border="1"<br />
|'''Date'''<br />
|'''Title'''<br />
|'''Any extra information'''<br />
|-<br />
| 18 January 2015<br />
| [[OOP_in_Lua|OOP in Lua]]<br />
| ''Renamed from OOP Basis to OOP in Lua''<br />
|-</div>Novohttps://wiki.multitheftauto.com/index.php?title=User:Novo&diff=44022User:Novo2015-01-18T13:28:16Z<p>Novo: Created page with "__NOTOC__ == Contact me == === Forum === * [http://forum.mtasa.com/memberlist.php?mode=viewprofile&u=53356 novo] - [http://forum.mtasa.com/ucp.php?i=pm&mode=compose&u=53356 PM..."</p>
<hr />
<div>__NOTOC__<br />
== Contact me ==<br />
=== Forum ===<br />
* [http://forum.mtasa.com/memberlist.php?mode=viewprofile&u=53356 novo] - [http://forum.mtasa.com/ucp.php?i=pm&mode=compose&u=53356 PM]<br />
<br />
=== Skype ===<br />
* Adam James @adam.mta<br />
<br />
=== E-mail ===<br />
''(though Skype is preferred)''<br />
* Adam James - ''htx@hotmail.es''<br />
<br />
== Latest contributions ==<br />
{| class="wikitable" border="1"<br />
|'''Date'''<br />
|'''Title'''<br />
|'''Any extra information'''<br />
|-<br />
| 18 January 2015<br />
| [[OOP_in_Lua|OOP in Lua]]<br />
| ''Renamed from OOP Basis to OOP in Lua''<br />
|-</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44012OOP in Lua2015-01-18T03:46:45Z<p>Novo: </p>
<hr />
<div>__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua. Originally created by [http://forum.mtasa.com/memberlist.php?mode=viewprofile&u=53356 novo] @adam.mta. - [http://forum.mtasa.com/viewtopic.php?f=148&t=84365 Forum topic].<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Content's provenance: [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ NovaFusion]<br />
----<br />
Knowledge of how to use metatables will allow you to be much more powerful in your use of Lua. Every table can have a metatable attached to it. A metatable is a table which, with some certain keys set, can change the behaviour of the table it's attached to. Let's see an example.<br />
<syntaxhighlight lang="lua"><br />
t = {} -- our normal table<br />
mt = {} -- our metatable, which contains nothing right now<br />
setmetatable(t, mt) -- sets mt to be t's metatable<br />
getmetatable(t) -- this will return mt<br />
</syntaxhighlight><br />
<br />
As you can see, '''getmetatable''' and '''setmetatable''' are the main functions here; I think it's pretty obvious what they do. Of course, in this case we could contract the first three lines into this:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {})<br />
</syntaxhighlight><br />
'''setmetatable''' returns its first argument, therefore we can use this shorter form.<br />
<br />
Now, what do we put in these metatables? Metatables can contain anything, but they respond to certain keys (which are strings of course) which always start with __ (two underscores in a row), such as '''__index''' and '''__newindex'''. The values corresponding to these keys will usually be functions or other tables. An example:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__index = function(t, key)<br />
if key == "foo" then<br />
return 0<br />
else<br />
return table[key]<br />
end<br />
end<br />
})<br />
</syntaxhighlight><br />
So as you can see, we assign a function to the '''__index''' key. Now let's have a look at what this key is all about.<br />
<br />
=== __index ===<br />
<br />
The most used metatable key is most likely '''__index'''; it can contain either a function or table.<br />
<br />
When you look up a table with a key, regardless of what the key is (t[4], t.foo, and t["foo"], for example), and a value hasn't been assigned for that key, Lua will look for an '''__index''' key in the table's metatable (if it has a metatable). If '''__index''' contains a table, Lua will look up the key originally used in the table belonging to '''__index'''. This probably sounds confusing, so here's an example:<br />
<syntaxhighlight lang="lua"><br />
other = { foo = 3 }<br />
t = setmetatable({}, { __index = other })<br />
t.foo -- 3<br />
t.bar -- nil<br />
</syntaxhighlight><br />
<br />
If '''__index''' contains a function, then it's called, with the table that is being looked up and the key used as parameters. As we saw in the code example above the last one, this allows us to use conditionals on the key, and basically anything else that Lua code can do. Therefore, in that example, if the key was equal to the string "foo" we would return 0, otherwise we look up the '''table''' table with the key that was used; this makes '''t''' an alias of '''table''' that returns 0 when the key "foo" is used.<br />
<br />
You may be wondering why the table is passed as a first parameter to the '''__index''' function. This comes in handy if you use the same metatable for multiple tables, supporting code re-use and saving computer resources. We'll see an example of this when we take a look at the '''Vector''' class.<br />
<br />
=== __newindex ===<br />
<br />
Next in line is '''__newindex''', which is similar to '''__index'''. Like '''__index''', it can contain either a function or table.<br />
<br />
When you try to set a value in a table that is not already present, Lua will look for a '''__newindex''' key in the metatable. It's the same sort of situation as '''__index'''; if '''__newindex''' is a table, the key and value will be set in the table specified:<br />
<syntaxhighlight lang="lua"><br />
other = {}<br />
t = setmetatable({}, { __newindex = other })<br />
t.foo = 3<br />
other.foo -- 3<br />
t.foo -- nil<br />
</syntaxhighlight><br />
As would be expected, if '''__newindex''' is a function, it will be called with the table, key, and value passed as parameters:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__newindex = function(t, key, value)<br />
if type(value) == "number" then<br />
rawset(t, key, value * value)<br />
else<br />
rawset(t, key, value)<br />
end<br />
end<br />
})<br />
<br />
t.foo = "foo"<br />
t.bar = 4<br />
t.la = 10<br />
t.foo -- "foo"<br />
t.bar -- 16<br />
t.la -- 100<br />
</syntaxhighlight><br />
When creating a new key in '''t''', if the value is a number it will be squared, otherwise it will just be set anyway. This introduces us to our friends, '''rawget''' and '''rawset'''.<br />
<br />
=== rawget and rawset ===<br />
<br />
There are times when you need get and set a table's keys without having Lua do it's thing with metatables. As you might guess, [http://www.lua.org/manual/5.1/manual.html#pdf-rawget rawget] allows you to get the value of a key without Lua using '''__index''', and [http://www.lua.org/manual/5.1/manual.html#pdf-rawset rawset] allows you to set the value of a key without Lua using '''__newindex''' (no these don't provide a speed increase to conventional way of doing things). You'll need to use these when you would otherwise get stuck in an infinite loop. For example, in that last code example, the code '''t[key] = value * value''' would set off the same '''__newindex''' function again, which would get you stuck in an infinite loop. Using '''rawset(t, key, value * value)''' avoids this.<br />
<br />
As you probably can see, to use these functions, for parameters we must pass in the target table, the key, and if you're using '''rawset''', the value.<br />
<br />
=== Operators ===<br />
<br />
Many of the metatable keys available have to do with operators (as in, '''+''', '''-''', etc.), allowing you to make tables support the use of operators on them. For example, say we wanted a table to support the multiplication operator ('''*'''), this is how we would do it:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__mul = function(t, other)<br />
new = {}<br />
<br />
for i = 1, other do<br />
for _, v in ipairs(t) do table.insert(new, v) end<br />
end<br />
<br />
return new<br />
end<br />
})<br />
<br />
t = t * 2 -- { 1, 2, 3, 1, 2, 3 }<br />
</syntaxhighlight><br />
<br />
This allows us to create a new table with the original replicated a certain amount of times using the multiplication operator. As you can tell, the corresponding key for multiplication is '''__mul'''; unlike '''__index''' and '''__newindex''' the keys for operators can only contain functions. The first parameter these functions always receive is the target table, and then the value on the right hand side (except for the unary - which has the key of '''__unm'''). Here's a list of the supported operators:<br />
<br />
* __add: Addition (+)<br />
* __sub: Subtraction (-)<br />
* __mul: Multiplication (*)<br />
* __div: Division (/)<br />
* __mod: Modulos (%)<br />
* __unm: Unary -, used for negation on numbers<br />
* __concat: Concatenation (..)<br />
* __eq: Equality (==)<br />
* __lt: Less than (<)<br />
* __le: Less than or equal to (<=)<br />
<br />
(There's only '''==''', '''<''', '''<=''' because you can implement full support for the comparison operators with just those; in fact only '''==''' and '''<''' are needed.)<br />
<br />
=== __call ===<br />
<br />
Next comes the '''__call''' key, which allows you to call tables as functions. A code example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__call = function(t, a, b, c, whatever)<br />
return (a + b + c) * whatever<br />
end<br />
})<br />
<br />
t(1, 2, 3, 4) -- 24<br />
</syntaxhighlight><br />
<br />
The function in call is passed the target table as usual, followed by the parameters that we passed in. '''__call''' is very useful for many things. One common thing it's used for is forwarding a call on a table to a function inside that table.<br />
<br />
=== __tostring ===<br />
<br />
Last of all is '''__tostring'''. If implemented, it's used by [http://www.lua.org/manual/5.1/manual.html#pdf-tostring tostring] to convert a table into a string, most handy when using a function like [http://www.lua.org/manual/5.1/manual.html#pdf-print print]. Normally, when you try to convert a table to a string, you something in the format of "table: 0x<hex-code-here>", but you can change that using '''__tostring'''. An example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__tostring = function(t)<br />
sum = 0<br />
for _, v in pairs(t) do sum = sum + v end<br />
return "Sum: " .. sum<br />
end<br />
})<br />
<br />
print(t) -- prints out "Sum: 6"<br />
</syntaxhighlight><br />
<br />
=== Building the Vector Class ===<br />
<br />
To wrap everything up, we'll write a class encapsulating a 2D vector. It's too large to put here, but you can see the full code at [https://gist.github.com/1055480 gist #1055480]. I've positioned all the stuff to do with metatables first in the file, as that's the most important stuff. (Be warned, this may be a bit confusing if you've never encountered Object-Oriented Programming before.)<br />
<br />
<syntaxhighlight lang="lua"><br />
Vector = {}<br />
Vector.__index = Vector<br />
</syntaxhighlight><br />
<br />
This code sets up the table for the '''Vector''' class, and sets the '''__index''' key to point back at itself. Now, what's going on here? You've probably noticed that we've put all the metatable methods inside the '''Vector''' class. What you're seeing is the simplest way to achieve OOP (Object-Oriented Programming) in Lua. The '''Vector''' table represents the class, which contains all the functions that instances can use. '''Vector.new''' (shown below) creates a new instance of this class.<br />
<br />
<syntaxhighlight lang="lua"><br />
function Vector.new(x, y)<br />
return setmetatable({ x = x or 0, y = y or 0 }, Vector)<br />
end<br />
</syntaxhighlight><br />
<br />
It creates a new table with '''x''' and '''y''' properties, and then sets the metatable to the '''Vector''' class. As we know, '''Vector''' contains all the metamethods and especially the '''__index''' key. This means that we can use all the functions we define in '''Vector''' through this new table. We'll come back to this in a moment.<br />
<br />
Another important thing is the last line:<br />
<syntaxhighlight lang="lua"><br />
setmetatable(Vector, { __call = function(_, ...) return Vector.new(...) end })<br />
</syntaxhighlight><br />
<br />
This means that we can create a new '''Vector''' instance by either calling '''Vector.new''' or just '''Vector'''.<br />
<br />
The last important thing that you may not be aware of is the colon syntax. When we define a function with a colon, like this:<br />
<syntaxhighlight lang="lua"><br />
function t:method(a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
What we are really doing is defining this function:<br />
<syntaxhighlight lang="lua"><br />
function t.method(self, a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
<br />
This is syntactic sugar to help with OOP. We can then use the colon syntax when calling functions:<br />
<syntaxhighlight lang="lua"><br />
-- these are the same<br />
t:method(1, 2, 3)<br />
t.method(t, 1, 2, 3)<br />
</syntaxhighlight><br />
<br />
Now, how do we use this '''Vector''' class? Here's a final example:<br />
<syntaxhighlight lang="lua"><br />
a = Vector.new(10, 10)<br />
b = Vector(20, 11)<br />
c = a + b<br />
print(a:len()) -- 14.142135623731<br />
print(a) -- (10, 10)<br />
print(c) -- (30, 21)<br />
print(a < c) -- true<br />
print(a == b) -- false<br />
</syntaxhighlight><br />
<br />
Because of the '''__index''' in '''Vector''', we can use all the methods defined in the class through the instances.<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight><br />
<br />
<br />
== Latest modifications ==<br />
--[[User:Novo|Novo]] ([[User talk:Novo|talk]]) 03:43, 18 January 2015 (UTC) (Adam James @adam.mta)</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44011OOP in Lua2015-01-18T03:45:04Z<p>Novo: </p>
<hr />
<div>__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua. Originally created by [http://forum.mtasa.com/memberlist.php?mode=viewprofile&u=53356 Adam James] @adam.mta. - [http://forum.mtasa.com/viewtopic.php?f=148&t=84365 Forum topic].<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Content's provenance: [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ NovaFusion]<br />
----<br />
Knowledge of how to use metatables will allow you to be much more powerful in your use of Lua. Every table can have a metatable attached to it. A metatable is a table which, with some certain keys set, can change the behaviour of the table it's attached to. Let's see an example.<br />
<syntaxhighlight lang="lua"><br />
t = {} -- our normal table<br />
mt = {} -- our metatable, which contains nothing right now<br />
setmetatable(t, mt) -- sets mt to be t's metatable<br />
getmetatable(t) -- this will return mt<br />
</syntaxhighlight><br />
<br />
As you can see, '''getmetatable''' and '''setmetatable''' are the main functions here; I think it's pretty obvious what they do. Of course, in this case we could contract the first three lines into this:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {})<br />
</syntaxhighlight><br />
'''setmetatable''' returns its first argument, therefore we can use this shorter form.<br />
<br />
Now, what do we put in these metatables? Metatables can contain anything, but they respond to certain keys (which are strings of course) which always start with __ (two underscores in a row), such as '''__index''' and '''__newindex'''. The values corresponding to these keys will usually be functions or other tables. An example:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__index = function(t, key)<br />
if key == "foo" then<br />
return 0<br />
else<br />
return table[key]<br />
end<br />
end<br />
})<br />
</syntaxhighlight><br />
So as you can see, we assign a function to the '''__index''' key. Now let's have a look at what this key is all about.<br />
<br />
=== __index ===<br />
<br />
The most used metatable key is most likely '''__index'''; it can contain either a function or table.<br />
<br />
When you look up a table with a key, regardless of what the key is (t[4], t.foo, and t["foo"], for example), and a value hasn't been assigned for that key, Lua will look for an '''__index''' key in the table's metatable (if it has a metatable). If '''__index''' contains a table, Lua will look up the key originally used in the table belonging to '''__index'''. This probably sounds confusing, so here's an example:<br />
<syntaxhighlight lang="lua"><br />
other = { foo = 3 }<br />
t = setmetatable({}, { __index = other })<br />
t.foo -- 3<br />
t.bar -- nil<br />
</syntaxhighlight><br />
<br />
If '''__index''' contains a function, then it's called, with the table that is being looked up and the key used as parameters. As we saw in the code example above the last one, this allows us to use conditionals on the key, and basically anything else that Lua code can do. Therefore, in that example, if the key was equal to the string "foo" we would return 0, otherwise we look up the '''table''' table with the key that was used; this makes '''t''' an alias of '''table''' that returns 0 when the key "foo" is used.<br />
<br />
You may be wondering why the table is passed as a first parameter to the '''__index''' function. This comes in handy if you use the same metatable for multiple tables, supporting code re-use and saving computer resources. We'll see an example of this when we take a look at the '''Vector''' class.<br />
<br />
=== __newindex ===<br />
<br />
Next in line is '''__newindex''', which is similar to '''__index'''. Like '''__index''', it can contain either a function or table.<br />
<br />
When you try to set a value in a table that is not already present, Lua will look for a '''__newindex''' key in the metatable. It's the same sort of situation as '''__index'''; if '''__newindex''' is a table, the key and value will be set in the table specified:<br />
<syntaxhighlight lang="lua"><br />
other = {}<br />
t = setmetatable({}, { __newindex = other })<br />
t.foo = 3<br />
other.foo -- 3<br />
t.foo -- nil<br />
</syntaxhighlight><br />
As would be expected, if '''__newindex''' is a function, it will be called with the table, key, and value passed as parameters:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__newindex = function(t, key, value)<br />
if type(value) == "number" then<br />
rawset(t, key, value * value)<br />
else<br />
rawset(t, key, value)<br />
end<br />
end<br />
})<br />
<br />
t.foo = "foo"<br />
t.bar = 4<br />
t.la = 10<br />
t.foo -- "foo"<br />
t.bar -- 16<br />
t.la -- 100<br />
</syntaxhighlight><br />
When creating a new key in '''t''', if the value is a number it will be squared, otherwise it will just be set anyway. This introduces us to our friends, '''rawget''' and '''rawset'''.<br />
<br />
=== rawget and rawset ===<br />
<br />
There are times when you need get and set a table's keys without having Lua do it's thing with metatables. As you might guess, [http://www.lua.org/manual/5.1/manual.html#pdf-rawget rawget] allows you to get the value of a key without Lua using '''__index''', and [http://www.lua.org/manual/5.1/manual.html#pdf-rawset rawset] allows you to set the value of a key without Lua using '''__newindex''' (no these don't provide a speed increase to conventional way of doing things). You'll need to use these when you would otherwise get stuck in an infinite loop. For example, in that last code example, the code '''t[key] = value * value''' would set off the same '''__newindex''' function again, which would get you stuck in an infinite loop. Using '''rawset(t, key, value * value)''' avoids this.<br />
<br />
As you probably can see, to use these functions, for parameters we must pass in the target table, the key, and if you're using '''rawset''', the value.<br />
<br />
=== Operators ===<br />
<br />
Many of the metatable keys available have to do with operators (as in, '''+''', '''-''', etc.), allowing you to make tables support the use of operators on them. For example, say we wanted a table to support the multiplication operator ('''*'''), this is how we would do it:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__mul = function(t, other)<br />
new = {}<br />
<br />
for i = 1, other do<br />
for _, v in ipairs(t) do table.insert(new, v) end<br />
end<br />
<br />
return new<br />
end<br />
})<br />
<br />
t = t * 2 -- { 1, 2, 3, 1, 2, 3 }<br />
</syntaxhighlight><br />
<br />
This allows us to create a new table with the original replicated a certain amount of times using the multiplication operator. As you can tell, the corresponding key for multiplication is '''__mul'''; unlike '''__index''' and '''__newindex''' the keys for operators can only contain functions. The first parameter these functions always receive is the target table, and then the value on the right hand side (except for the unary - which has the key of '''__unm'''). Here's a list of the supported operators:<br />
<br />
* __add: Addition (+)<br />
* __sub: Subtraction (-)<br />
* __mul: Multiplication (*)<br />
* __div: Division (/)<br />
* __mod: Modulos (%)<br />
* __unm: Unary -, used for negation on numbers<br />
* __concat: Concatenation (..)<br />
* __eq: Equality (==)<br />
* __lt: Less than (<)<br />
* __le: Less than or equal to (<=)<br />
<br />
(There's only '''==''', '''<''', '''<=''' because you can implement full support for the comparison operators with just those; in fact only '''==''' and '''<''' are needed.)<br />
<br />
=== __call ===<br />
<br />
Next comes the '''__call''' key, which allows you to call tables as functions. A code example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__call = function(t, a, b, c, whatever)<br />
return (a + b + c) * whatever<br />
end<br />
})<br />
<br />
t(1, 2, 3, 4) -- 24<br />
</syntaxhighlight><br />
<br />
The function in call is passed the target table as usual, followed by the parameters that we passed in. '''__call''' is very useful for many things. One common thing it's used for is forwarding a call on a table to a function inside that table.<br />
<br />
=== __tostring ===<br />
<br />
Last of all is '''__tostring'''. If implemented, it's used by [http://www.lua.org/manual/5.1/manual.html#pdf-tostring tostring] to convert a table into a string, most handy when using a function like [http://www.lua.org/manual/5.1/manual.html#pdf-print print]. Normally, when you try to convert a table to a string, you something in the format of "table: 0x<hex-code-here>", but you can change that using '''__tostring'''. An example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__tostring = function(t)<br />
sum = 0<br />
for _, v in pairs(t) do sum = sum + v end<br />
return "Sum: " .. sum<br />
end<br />
})<br />
<br />
print(t) -- prints out "Sum: 6"<br />
</syntaxhighlight><br />
<br />
=== Building the Vector Class ===<br />
<br />
To wrap everything up, we'll write a class encapsulating a 2D vector. It's too large to put here, but you can see the full code at [https://gist.github.com/1055480 gist #1055480]. I've positioned all the stuff to do with metatables first in the file, as that's the most important stuff. (Be warned, this may be a bit confusing if you've never encountered Object-Oriented Programming before.)<br />
<br />
<syntaxhighlight lang="lua"><br />
Vector = {}<br />
Vector.__index = Vector<br />
</syntaxhighlight><br />
<br />
This code sets up the table for the '''Vector''' class, and sets the '''__index''' key to point back at itself. Now, what's going on here? You've probably noticed that we've put all the metatable methods inside the '''Vector''' class. What you're seeing is the simplest way to achieve OOP (Object-Oriented Programming) in Lua. The '''Vector''' table represents the class, which contains all the functions that instances can use. '''Vector.new''' (shown below) creates a new instance of this class.<br />
<br />
<syntaxhighlight lang="lua"><br />
function Vector.new(x, y)<br />
return setmetatable({ x = x or 0, y = y or 0 }, Vector)<br />
end<br />
</syntaxhighlight><br />
<br />
It creates a new table with '''x''' and '''y''' properties, and then sets the metatable to the '''Vector''' class. As we know, '''Vector''' contains all the metamethods and especially the '''__index''' key. This means that we can use all the functions we define in '''Vector''' through this new table. We'll come back to this in a moment.<br />
<br />
Another important thing is the last line:<br />
<syntaxhighlight lang="lua"><br />
setmetatable(Vector, { __call = function(_, ...) return Vector.new(...) end })<br />
</syntaxhighlight><br />
<br />
This means that we can create a new '''Vector''' instance by either calling '''Vector.new''' or just '''Vector'''.<br />
<br />
The last important thing that you may not be aware of is the colon syntax. When we define a function with a colon, like this:<br />
<syntaxhighlight lang="lua"><br />
function t:method(a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
What we are really doing is defining this function:<br />
<syntaxhighlight lang="lua"><br />
function t.method(self, a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
<br />
This is syntactic sugar to help with OOP. We can then use the colon syntax when calling functions:<br />
<syntaxhighlight lang="lua"><br />
-- these are the same<br />
t:method(1, 2, 3)<br />
t.method(t, 1, 2, 3)<br />
</syntaxhighlight><br />
<br />
Now, how do we use this '''Vector''' class? Here's a final example:<br />
<syntaxhighlight lang="lua"><br />
a = Vector.new(10, 10)<br />
b = Vector(20, 11)<br />
c = a + b<br />
print(a:len()) -- 14.142135623731<br />
print(a) -- (10, 10)<br />
print(c) -- (30, 21)<br />
print(a < c) -- true<br />
print(a == b) -- false<br />
</syntaxhighlight><br />
<br />
Because of the '''__index''' in '''Vector''', we can use all the methods defined in the class through the instances.<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight><br />
<br />
<br />
== Latest modifications ==<br />
--[[User:Novo|Novo]] ([[User talk:Novo|talk]]) 03:43, 18 January 2015 (UTC) (Adam James @adam.mta)</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44010OOP in Lua2015-01-18T03:44:38Z<p>Novo: </p>
<hr />
<div>__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua. Originally created by [http://forum.mtasa.com/memberlist.php?mode=viewprofile&u=53356 Adam James] @adam.mta.<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Content's provenance: [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ NovaFusion]<br />
----<br />
Knowledge of how to use metatables will allow you to be much more powerful in your use of Lua. Every table can have a metatable attached to it. A metatable is a table which, with some certain keys set, can change the behaviour of the table it's attached to. Let's see an example.<br />
<syntaxhighlight lang="lua"><br />
t = {} -- our normal table<br />
mt = {} -- our metatable, which contains nothing right now<br />
setmetatable(t, mt) -- sets mt to be t's metatable<br />
getmetatable(t) -- this will return mt<br />
</syntaxhighlight><br />
<br />
As you can see, '''getmetatable''' and '''setmetatable''' are the main functions here; I think it's pretty obvious what they do. Of course, in this case we could contract the first three lines into this:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {})<br />
</syntaxhighlight><br />
'''setmetatable''' returns its first argument, therefore we can use this shorter form.<br />
<br />
Now, what do we put in these metatables? Metatables can contain anything, but they respond to certain keys (which are strings of course) which always start with __ (two underscores in a row), such as '''__index''' and '''__newindex'''. The values corresponding to these keys will usually be functions or other tables. An example:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__index = function(t, key)<br />
if key == "foo" then<br />
return 0<br />
else<br />
return table[key]<br />
end<br />
end<br />
})<br />
</syntaxhighlight><br />
So as you can see, we assign a function to the '''__index''' key. Now let's have a look at what this key is all about.<br />
<br />
=== __index ===<br />
<br />
The most used metatable key is most likely '''__index'''; it can contain either a function or table.<br />
<br />
When you look up a table with a key, regardless of what the key is (t[4], t.foo, and t["foo"], for example), and a value hasn't been assigned for that key, Lua will look for an '''__index''' key in the table's metatable (if it has a metatable). If '''__index''' contains a table, Lua will look up the key originally used in the table belonging to '''__index'''. This probably sounds confusing, so here's an example:<br />
<syntaxhighlight lang="lua"><br />
other = { foo = 3 }<br />
t = setmetatable({}, { __index = other })<br />
t.foo -- 3<br />
t.bar -- nil<br />
</syntaxhighlight><br />
<br />
If '''__index''' contains a function, then it's called, with the table that is being looked up and the key used as parameters. As we saw in the code example above the last one, this allows us to use conditionals on the key, and basically anything else that Lua code can do. Therefore, in that example, if the key was equal to the string "foo" we would return 0, otherwise we look up the '''table''' table with the key that was used; this makes '''t''' an alias of '''table''' that returns 0 when the key "foo" is used.<br />
<br />
You may be wondering why the table is passed as a first parameter to the '''__index''' function. This comes in handy if you use the same metatable for multiple tables, supporting code re-use and saving computer resources. We'll see an example of this when we take a look at the '''Vector''' class.<br />
<br />
=== __newindex ===<br />
<br />
Next in line is '''__newindex''', which is similar to '''__index'''. Like '''__index''', it can contain either a function or table.<br />
<br />
When you try to set a value in a table that is not already present, Lua will look for a '''__newindex''' key in the metatable. It's the same sort of situation as '''__index'''; if '''__newindex''' is a table, the key and value will be set in the table specified:<br />
<syntaxhighlight lang="lua"><br />
other = {}<br />
t = setmetatable({}, { __newindex = other })<br />
t.foo = 3<br />
other.foo -- 3<br />
t.foo -- nil<br />
</syntaxhighlight><br />
As would be expected, if '''__newindex''' is a function, it will be called with the table, key, and value passed as parameters:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__newindex = function(t, key, value)<br />
if type(value) == "number" then<br />
rawset(t, key, value * value)<br />
else<br />
rawset(t, key, value)<br />
end<br />
end<br />
})<br />
<br />
t.foo = "foo"<br />
t.bar = 4<br />
t.la = 10<br />
t.foo -- "foo"<br />
t.bar -- 16<br />
t.la -- 100<br />
</syntaxhighlight><br />
When creating a new key in '''t''', if the value is a number it will be squared, otherwise it will just be set anyway. This introduces us to our friends, '''rawget''' and '''rawset'''.<br />
<br />
=== rawget and rawset ===<br />
<br />
There are times when you need get and set a table's keys without having Lua do it's thing with metatables. As you might guess, [http://www.lua.org/manual/5.1/manual.html#pdf-rawget rawget] allows you to get the value of a key without Lua using '''__index''', and [http://www.lua.org/manual/5.1/manual.html#pdf-rawset rawset] allows you to set the value of a key without Lua using '''__newindex''' (no these don't provide a speed increase to conventional way of doing things). You'll need to use these when you would otherwise get stuck in an infinite loop. For example, in that last code example, the code '''t[key] = value * value''' would set off the same '''__newindex''' function again, which would get you stuck in an infinite loop. Using '''rawset(t, key, value * value)''' avoids this.<br />
<br />
As you probably can see, to use these functions, for parameters we must pass in the target table, the key, and if you're using '''rawset''', the value.<br />
<br />
=== Operators ===<br />
<br />
Many of the metatable keys available have to do with operators (as in, '''+''', '''-''', etc.), allowing you to make tables support the use of operators on them. For example, say we wanted a table to support the multiplication operator ('''*'''), this is how we would do it:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__mul = function(t, other)<br />
new = {}<br />
<br />
for i = 1, other do<br />
for _, v in ipairs(t) do table.insert(new, v) end<br />
end<br />
<br />
return new<br />
end<br />
})<br />
<br />
t = t * 2 -- { 1, 2, 3, 1, 2, 3 }<br />
</syntaxhighlight><br />
<br />
This allows us to create a new table with the original replicated a certain amount of times using the multiplication operator. As you can tell, the corresponding key for multiplication is '''__mul'''; unlike '''__index''' and '''__newindex''' the keys for operators can only contain functions. The first parameter these functions always receive is the target table, and then the value on the right hand side (except for the unary - which has the key of '''__unm'''). Here's a list of the supported operators:<br />
<br />
* __add: Addition (+)<br />
* __sub: Subtraction (-)<br />
* __mul: Multiplication (*)<br />
* __div: Division (/)<br />
* __mod: Modulos (%)<br />
* __unm: Unary -, used for negation on numbers<br />
* __concat: Concatenation (..)<br />
* __eq: Equality (==)<br />
* __lt: Less than (<)<br />
* __le: Less than or equal to (<=)<br />
<br />
(There's only '''==''', '''<''', '''<=''' because you can implement full support for the comparison operators with just those; in fact only '''==''' and '''<''' are needed.)<br />
<br />
=== __call ===<br />
<br />
Next comes the '''__call''' key, which allows you to call tables as functions. A code example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__call = function(t, a, b, c, whatever)<br />
return (a + b + c) * whatever<br />
end<br />
})<br />
<br />
t(1, 2, 3, 4) -- 24<br />
</syntaxhighlight><br />
<br />
The function in call is passed the target table as usual, followed by the parameters that we passed in. '''__call''' is very useful for many things. One common thing it's used for is forwarding a call on a table to a function inside that table.<br />
<br />
=== __tostring ===<br />
<br />
Last of all is '''__tostring'''. If implemented, it's used by [http://www.lua.org/manual/5.1/manual.html#pdf-tostring tostring] to convert a table into a string, most handy when using a function like [http://www.lua.org/manual/5.1/manual.html#pdf-print print]. Normally, when you try to convert a table to a string, you something in the format of "table: 0x<hex-code-here>", but you can change that using '''__tostring'''. An example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__tostring = function(t)<br />
sum = 0<br />
for _, v in pairs(t) do sum = sum + v end<br />
return "Sum: " .. sum<br />
end<br />
})<br />
<br />
print(t) -- prints out "Sum: 6"<br />
</syntaxhighlight><br />
<br />
=== Building the Vector Class ===<br />
<br />
To wrap everything up, we'll write a class encapsulating a 2D vector. It's too large to put here, but you can see the full code at [https://gist.github.com/1055480 gist #1055480]. I've positioned all the stuff to do with metatables first in the file, as that's the most important stuff. (Be warned, this may be a bit confusing if you've never encountered Object-Oriented Programming before.)<br />
<br />
<syntaxhighlight lang="lua"><br />
Vector = {}<br />
Vector.__index = Vector<br />
</syntaxhighlight><br />
<br />
This code sets up the table for the '''Vector''' class, and sets the '''__index''' key to point back at itself. Now, what's going on here? You've probably noticed that we've put all the metatable methods inside the '''Vector''' class. What you're seeing is the simplest way to achieve OOP (Object-Oriented Programming) in Lua. The '''Vector''' table represents the class, which contains all the functions that instances can use. '''Vector.new''' (shown below) creates a new instance of this class.<br />
<br />
<syntaxhighlight lang="lua"><br />
function Vector.new(x, y)<br />
return setmetatable({ x = x or 0, y = y or 0 }, Vector)<br />
end<br />
</syntaxhighlight><br />
<br />
It creates a new table with '''x''' and '''y''' properties, and then sets the metatable to the '''Vector''' class. As we know, '''Vector''' contains all the metamethods and especially the '''__index''' key. This means that we can use all the functions we define in '''Vector''' through this new table. We'll come back to this in a moment.<br />
<br />
Another important thing is the last line:<br />
<syntaxhighlight lang="lua"><br />
setmetatable(Vector, { __call = function(_, ...) return Vector.new(...) end })<br />
</syntaxhighlight><br />
<br />
This means that we can create a new '''Vector''' instance by either calling '''Vector.new''' or just '''Vector'''.<br />
<br />
The last important thing that you may not be aware of is the colon syntax. When we define a function with a colon, like this:<br />
<syntaxhighlight lang="lua"><br />
function t:method(a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
What we are really doing is defining this function:<br />
<syntaxhighlight lang="lua"><br />
function t.method(self, a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
<br />
This is syntactic sugar to help with OOP. We can then use the colon syntax when calling functions:<br />
<syntaxhighlight lang="lua"><br />
-- these are the same<br />
t:method(1, 2, 3)<br />
t.method(t, 1, 2, 3)<br />
</syntaxhighlight><br />
<br />
Now, how do we use this '''Vector''' class? Here's a final example:<br />
<syntaxhighlight lang="lua"><br />
a = Vector.new(10, 10)<br />
b = Vector(20, 11)<br />
c = a + b<br />
print(a:len()) -- 14.142135623731<br />
print(a) -- (10, 10)<br />
print(c) -- (30, 21)<br />
print(a < c) -- true<br />
print(a == b) -- false<br />
</syntaxhighlight><br />
<br />
Because of the '''__index''' in '''Vector''', we can use all the methods defined in the class through the instances.<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight><br />
<br />
<br />
== Latest modifications ==<br />
--[[User:Novo|Novo]] ([[User talk:Novo|talk]]) 03:43, 18 January 2015 (UTC) (Adam James @adam.mta)</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44009OOP in Lua2015-01-18T03:43:52Z<p>Novo: </p>
<hr />
<div>__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua.<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Content's provenance: [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ NovaFusion]<br />
----<br />
Knowledge of how to use metatables will allow you to be much more powerful in your use of Lua. Every table can have a metatable attached to it. A metatable is a table which, with some certain keys set, can change the behaviour of the table it's attached to. Let's see an example.<br />
<syntaxhighlight lang="lua"><br />
t = {} -- our normal table<br />
mt = {} -- our metatable, which contains nothing right now<br />
setmetatable(t, mt) -- sets mt to be t's metatable<br />
getmetatable(t) -- this will return mt<br />
</syntaxhighlight><br />
<br />
As you can see, '''getmetatable''' and '''setmetatable''' are the main functions here; I think it's pretty obvious what they do. Of course, in this case we could contract the first three lines into this:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {})<br />
</syntaxhighlight><br />
'''setmetatable''' returns its first argument, therefore we can use this shorter form.<br />
<br />
Now, what do we put in these metatables? Metatables can contain anything, but they respond to certain keys (which are strings of course) which always start with __ (two underscores in a row), such as '''__index''' and '''__newindex'''. The values corresponding to these keys will usually be functions or other tables. An example:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__index = function(t, key)<br />
if key == "foo" then<br />
return 0<br />
else<br />
return table[key]<br />
end<br />
end<br />
})<br />
</syntaxhighlight><br />
So as you can see, we assign a function to the '''__index''' key. Now let's have a look at what this key is all about.<br />
<br />
=== __index ===<br />
<br />
The most used metatable key is most likely '''__index'''; it can contain either a function or table.<br />
<br />
When you look up a table with a key, regardless of what the key is (t[4], t.foo, and t["foo"], for example), and a value hasn't been assigned for that key, Lua will look for an '''__index''' key in the table's metatable (if it has a metatable). If '''__index''' contains a table, Lua will look up the key originally used in the table belonging to '''__index'''. This probably sounds confusing, so here's an example:<br />
<syntaxhighlight lang="lua"><br />
other = { foo = 3 }<br />
t = setmetatable({}, { __index = other })<br />
t.foo -- 3<br />
t.bar -- nil<br />
</syntaxhighlight><br />
<br />
If '''__index''' contains a function, then it's called, with the table that is being looked up and the key used as parameters. As we saw in the code example above the last one, this allows us to use conditionals on the key, and basically anything else that Lua code can do. Therefore, in that example, if the key was equal to the string "foo" we would return 0, otherwise we look up the '''table''' table with the key that was used; this makes '''t''' an alias of '''table''' that returns 0 when the key "foo" is used.<br />
<br />
You may be wondering why the table is passed as a first parameter to the '''__index''' function. This comes in handy if you use the same metatable for multiple tables, supporting code re-use and saving computer resources. We'll see an example of this when we take a look at the '''Vector''' class.<br />
<br />
=== __newindex ===<br />
<br />
Next in line is '''__newindex''', which is similar to '''__index'''. Like '''__index''', it can contain either a function or table.<br />
<br />
When you try to set a value in a table that is not already present, Lua will look for a '''__newindex''' key in the metatable. It's the same sort of situation as '''__index'''; if '''__newindex''' is a table, the key and value will be set in the table specified:<br />
<syntaxhighlight lang="lua"><br />
other = {}<br />
t = setmetatable({}, { __newindex = other })<br />
t.foo = 3<br />
other.foo -- 3<br />
t.foo -- nil<br />
</syntaxhighlight><br />
As would be expected, if '''__newindex''' is a function, it will be called with the table, key, and value passed as parameters:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__newindex = function(t, key, value)<br />
if type(value) == "number" then<br />
rawset(t, key, value * value)<br />
else<br />
rawset(t, key, value)<br />
end<br />
end<br />
})<br />
<br />
t.foo = "foo"<br />
t.bar = 4<br />
t.la = 10<br />
t.foo -- "foo"<br />
t.bar -- 16<br />
t.la -- 100<br />
</syntaxhighlight><br />
When creating a new key in '''t''', if the value is a number it will be squared, otherwise it will just be set anyway. This introduces us to our friends, '''rawget''' and '''rawset'''.<br />
<br />
=== rawget and rawset ===<br />
<br />
There are times when you need get and set a table's keys without having Lua do it's thing with metatables. As you might guess, [http://www.lua.org/manual/5.1/manual.html#pdf-rawget rawget] allows you to get the value of a key without Lua using '''__index''', and [http://www.lua.org/manual/5.1/manual.html#pdf-rawset rawset] allows you to set the value of a key without Lua using '''__newindex''' (no these don't provide a speed increase to conventional way of doing things). You'll need to use these when you would otherwise get stuck in an infinite loop. For example, in that last code example, the code '''t[key] = value * value''' would set off the same '''__newindex''' function again, which would get you stuck in an infinite loop. Using '''rawset(t, key, value * value)''' avoids this.<br />
<br />
As you probably can see, to use these functions, for parameters we must pass in the target table, the key, and if you're using '''rawset''', the value.<br />
<br />
=== Operators ===<br />
<br />
Many of the metatable keys available have to do with operators (as in, '''+''', '''-''', etc.), allowing you to make tables support the use of operators on them. For example, say we wanted a table to support the multiplication operator ('''*'''), this is how we would do it:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__mul = function(t, other)<br />
new = {}<br />
<br />
for i = 1, other do<br />
for _, v in ipairs(t) do table.insert(new, v) end<br />
end<br />
<br />
return new<br />
end<br />
})<br />
<br />
t = t * 2 -- { 1, 2, 3, 1, 2, 3 }<br />
</syntaxhighlight><br />
<br />
This allows us to create a new table with the original replicated a certain amount of times using the multiplication operator. As you can tell, the corresponding key for multiplication is '''__mul'''; unlike '''__index''' and '''__newindex''' the keys for operators can only contain functions. The first parameter these functions always receive is the target table, and then the value on the right hand side (except for the unary - which has the key of '''__unm'''). Here's a list of the supported operators:<br />
<br />
* __add: Addition (+)<br />
* __sub: Subtraction (-)<br />
* __mul: Multiplication (*)<br />
* __div: Division (/)<br />
* __mod: Modulos (%)<br />
* __unm: Unary -, used for negation on numbers<br />
* __concat: Concatenation (..)<br />
* __eq: Equality (==)<br />
* __lt: Less than (<)<br />
* __le: Less than or equal to (<=)<br />
<br />
(There's only '''==''', '''<''', '''<=''' because you can implement full support for the comparison operators with just those; in fact only '''==''' and '''<''' are needed.)<br />
<br />
=== __call ===<br />
<br />
Next comes the '''__call''' key, which allows you to call tables as functions. A code example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__call = function(t, a, b, c, whatever)<br />
return (a + b + c) * whatever<br />
end<br />
})<br />
<br />
t(1, 2, 3, 4) -- 24<br />
</syntaxhighlight><br />
<br />
The function in call is passed the target table as usual, followed by the parameters that we passed in. '''__call''' is very useful for many things. One common thing it's used for is forwarding a call on a table to a function inside that table.<br />
<br />
=== __tostring ===<br />
<br />
Last of all is '''__tostring'''. If implemented, it's used by [http://www.lua.org/manual/5.1/manual.html#pdf-tostring tostring] to convert a table into a string, most handy when using a function like [http://www.lua.org/manual/5.1/manual.html#pdf-print print]. Normally, when you try to convert a table to a string, you something in the format of "table: 0x<hex-code-here>", but you can change that using '''__tostring'''. An example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__tostring = function(t)<br />
sum = 0<br />
for _, v in pairs(t) do sum = sum + v end<br />
return "Sum: " .. sum<br />
end<br />
})<br />
<br />
print(t) -- prints out "Sum: 6"<br />
</syntaxhighlight><br />
<br />
=== Building the Vector Class ===<br />
<br />
To wrap everything up, we'll write a class encapsulating a 2D vector. It's too large to put here, but you can see the full code at [https://gist.github.com/1055480 gist #1055480]. I've positioned all the stuff to do with metatables first in the file, as that's the most important stuff. (Be warned, this may be a bit confusing if you've never encountered Object-Oriented Programming before.)<br />
<br />
<syntaxhighlight lang="lua"><br />
Vector = {}<br />
Vector.__index = Vector<br />
</syntaxhighlight><br />
<br />
This code sets up the table for the '''Vector''' class, and sets the '''__index''' key to point back at itself. Now, what's going on here? You've probably noticed that we've put all the metatable methods inside the '''Vector''' class. What you're seeing is the simplest way to achieve OOP (Object-Oriented Programming) in Lua. The '''Vector''' table represents the class, which contains all the functions that instances can use. '''Vector.new''' (shown below) creates a new instance of this class.<br />
<br />
<syntaxhighlight lang="lua"><br />
function Vector.new(x, y)<br />
return setmetatable({ x = x or 0, y = y or 0 }, Vector)<br />
end<br />
</syntaxhighlight><br />
<br />
It creates a new table with '''x''' and '''y''' properties, and then sets the metatable to the '''Vector''' class. As we know, '''Vector''' contains all the metamethods and especially the '''__index''' key. This means that we can use all the functions we define in '''Vector''' through this new table. We'll come back to this in a moment.<br />
<br />
Another important thing is the last line:<br />
<syntaxhighlight lang="lua"><br />
setmetatable(Vector, { __call = function(_, ...) return Vector.new(...) end })<br />
</syntaxhighlight><br />
<br />
This means that we can create a new '''Vector''' instance by either calling '''Vector.new''' or just '''Vector'''.<br />
<br />
The last important thing that you may not be aware of is the colon syntax. When we define a function with a colon, like this:<br />
<syntaxhighlight lang="lua"><br />
function t:method(a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
What we are really doing is defining this function:<br />
<syntaxhighlight lang="lua"><br />
function t.method(self, a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
<br />
This is syntactic sugar to help with OOP. We can then use the colon syntax when calling functions:<br />
<syntaxhighlight lang="lua"><br />
-- these are the same<br />
t:method(1, 2, 3)<br />
t.method(t, 1, 2, 3)<br />
</syntaxhighlight><br />
<br />
Now, how do we use this '''Vector''' class? Here's a final example:<br />
<syntaxhighlight lang="lua"><br />
a = Vector.new(10, 10)<br />
b = Vector(20, 11)<br />
c = a + b<br />
print(a:len()) -- 14.142135623731<br />
print(a) -- (10, 10)<br />
print(c) -- (30, 21)<br />
print(a < c) -- true<br />
print(a == b) -- false<br />
</syntaxhighlight><br />
<br />
Because of the '''__index''' in '''Vector''', we can use all the methods defined in the class through the instances.<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight><br />
<br />
<br />
== Latest modifications ==<br />
--[[User:Novo|Novo]] ([[User talk:Novo|talk]]) 03:43, 18 January 2015 (UTC) (Adam James @adam.mta)</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44008OOP in Lua2015-01-18T03:43:04Z<p>Novo: </p>
<hr />
<div>__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua.<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Content's provenance: [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ NovaFusion]<br />
----<br />
Knowledge of how to use metatables will allow you to be much more powerful in your use of Lua. Every table can have a metatable attached to it. A metatable is a table which, with some certain keys set, can change the behaviour of the table it's attached to. Let's see an example.<br />
<syntaxhighlight lang="lua"><br />
t = {} -- our normal table<br />
mt = {} -- our metatable, which contains nothing right now<br />
setmetatable(t, mt) -- sets mt to be t's metatable<br />
getmetatable(t) -- this will return mt<br />
</syntaxhighlight><br />
<br />
As you can see, '''getmetatable''' and '''setmetatable''' are the main functions here; I think it's pretty obvious what they do. Of course, in this case we could contract the first three lines into this:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {})<br />
</syntaxhighlight><br />
'''setmetatable''' returns its first argument, therefore we can use this shorter form.<br />
<br />
Now, what do we put in these metatables? Metatables can contain anything, but they respond to certain keys (which are strings of course) which always start with __ (two underscores in a row), such as '''__index''' and '''__newindex'''. The values corresponding to these keys will usually be functions or other tables. An example:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__index = function(t, key)<br />
if key == "foo" then<br />
return 0<br />
else<br />
return table[key]<br />
end<br />
end<br />
})<br />
</syntaxhighlight><br />
So as you can see, we assign a function to the '''__index''' key. Now let's have a look at what this key is all about.<br />
<br />
=== __index ===<br />
<br />
The most used metatable key is most likely '''__index'''; it can contain either a function or table.<br />
<br />
When you look up a table with a key, regardless of what the key is (t[4], t.foo, and t["foo"], for example), and a value hasn't been assigned for that key, Lua will look for an '''__index''' key in the table's metatable (if it has a metatable). If '''__index''' contains a table, Lua will look up the key originally used in the table belonging to '''__index'''. This probably sounds confusing, so here's an example:<br />
<syntaxhighlight lang="lua"><br />
other = { foo = 3 }<br />
t = setmetatable({}, { __index = other })<br />
t.foo -- 3<br />
t.bar -- nil<br />
</syntaxhighlight><br />
<br />
If '''__index''' contains a function, then it's called, with the table that is being looked up and the key used as parameters. As we saw in the code example above the last one, this allows us to use conditionals on the key, and basically anything else that Lua code can do. Therefore, in that example, if the key was equal to the string "foo" we would return 0, otherwise we look up the '''table''' table with the key that was used; this makes '''t''' an alias of '''table''' that returns 0 when the key "foo" is used.<br />
<br />
You may be wondering why the table is passed as a first parameter to the '''__index''' function. This comes in handy if you use the same metatable for multiple tables, supporting code re-use and saving computer resources. We'll see an example of this when we take a look at the '''Vector''' class.<br />
<br />
=== __newindex ===<br />
<br />
Next in line is '''__newindex''', which is similar to '''__index'''. Like '''__index''', it can contain either a function or table.<br />
<br />
When you try to set a value in a table that is not already present, Lua will look for a '''__newindex''' key in the metatable. It's the same sort of situation as '''__index'''; if '''__newindex''' is a table, the key and value will be set in the table specified:<br />
<syntaxhighlight lang="lua"><br />
other = {}<br />
t = setmetatable({}, { __newindex = other })<br />
t.foo = 3<br />
other.foo -- 3<br />
t.foo -- nil<br />
</syntaxhighlight><br />
As would be expected, if '''__newindex''' is a function, it will be called with the table, key, and value passed as parameters:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__newindex = function(t, key, value)<br />
if type(value) == "number" then<br />
rawset(t, key, value * value)<br />
else<br />
rawset(t, key, value)<br />
end<br />
end<br />
})<br />
<br />
t.foo = "foo"<br />
t.bar = 4<br />
t.la = 10<br />
t.foo -- "foo"<br />
t.bar -- 16<br />
t.la -- 100<br />
</syntaxhighlight><br />
When creating a new key in '''t''', if the value is a number it will be squared, otherwise it will just be set anyway. This introduces us to our friends, '''rawget''' and '''rawset'''.<br />
<br />
=== rawget and rawset ===<br />
<br />
There are times when you need get and set a table's keys without having Lua do it's thing with metatables. As you might guess, [http://www.lua.org/manual/5.1/manual.html#pdf-rawget rawget] allows you to get the value of a key without Lua using '''__index''', and [http://www.lua.org/manual/5.1/manual.html#pdf-rawset rawset] allows you to set the value of a key without Lua using '''__newindex''' (no these don't provide a speed increase to conventional way of doing things). You'll need to use these when you would otherwise get stuck in an infinite loop. For example, in that last code example, the code '''t[key] = value * value''' would set off the same '''__newindex''' function again, which would get you stuck in an infinite loop. Using '''rawset(t, key, value * value)''' avoids this.<br />
<br />
As you probably can see, to use these functions, for parameters we must pass in the target table, the key, and if you're using '''rawset''', the value.<br />
<br />
=== Operators ===<br />
<br />
Many of the metatable keys available have to do with operators (as in, '''+''', '''-''', etc.), allowing you to make tables support the use of operators on them. For example, say we wanted a table to support the multiplication operator ('''*'''), this is how we would do it:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__mul = function(t, other)<br />
new = {}<br />
<br />
for i = 1, other do<br />
for _, v in ipairs(t) do table.insert(new, v) end<br />
end<br />
<br />
return new<br />
end<br />
})<br />
<br />
t = t * 2 -- { 1, 2, 3, 1, 2, 3 }<br />
</syntaxhighlight><br />
<br />
This allows us to create a new table with the original replicated a certain amount of times using the multiplication operator. As you can tell, the corresponding key for multiplication is '''__mul'''; unlike '''__index''' and '''__newindex''' the keys for operators can only contain functions. The first parameter these functions always receive is the target table, and then the value on the right hand side (except for the unary - which has the key of '''__unm'''). Here's a list of the supported operators:<br />
<br />
* __add: Addition (+)<br />
* __sub: Subtraction (-)<br />
* __mul: Multiplication (*)<br />
* __div: Division (/)<br />
* __mod: Modulos (%)<br />
* __unm: Unary -, used for negation on numbers<br />
* __concat: Concatenation (..)<br />
* __eq: Equality (==)<br />
* __lt: Less than (<)<br />
* __le: Less than or equal to (<=)<br />
<br />
(There's only '''==''', '''<''', '''<=''' because you can implement full support for the comparison operators with just those; in fact only '''==''' and '''<''' are needed.)<br />
<br />
=== __call ===<br />
<br />
Next comes the '''__call''' key, which allows you to call tables as functions. A code example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__call = function(t, a, b, c, whatever)<br />
return (a + b + c) * whatever<br />
end<br />
})<br />
<br />
t(1, 2, 3, 4) -- 24<br />
</syntaxhighlight><br />
<br />
The function in call is passed the target table as usual, followed by the parameters that we passed in. '''__call''' is very useful for many things. One common thing it's used for is forwarding a call on a table to a function inside that table.<br />
<br />
=== __tostring ===<br />
<br />
Last of all is '''__tostring'''. If implemented, it's used by [http://www.lua.org/manual/5.1/manual.html#pdf-tostring tostring] to convert a table into a string, most handy when using a function like [http://www.lua.org/manual/5.1/manual.html#pdf-print print]. Normally, when you try to convert a table to a string, you something in the format of "table: 0x<hex-code-here>", but you can change that using '''__tostring'''. An example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__tostring = function(t)<br />
sum = 0<br />
for _, v in pairs(t) do sum = sum + v end<br />
return "Sum: " .. sum<br />
end<br />
})<br />
<br />
print(t) -- prints out "Sum: 6"<br />
</syntaxhighlight><br />
<br />
=== Building the Vector Class ===<br />
<br />
To wrap everything up, we'll write a class encapsulating a 2D vector. It's too large to put here, but you can see the full code at [https://gist.github.com/1055480 gist #1055480]. I've positioned all the stuff to do with metatables first in the file, as that's the most important stuff. (Be warned, this may be a bit confusing if you've never encountered Object-Oriented Programming before.)<br />
<br />
<syntaxhighlight lang="lua"><br />
Vector = {}<br />
Vector.__index = Vector<br />
</syntaxhighlight><br />
<br />
This code sets up the table for the '''Vector''' class, and sets the '''__index''' key to point back at itself. Now, what's going on here? You've probably noticed that we've put all the metatable methods inside the '''Vector''' class. What you're seeing is the simplest way to achieve OOP (Object-Oriented Programming) in Lua. The '''Vector''' table represents the class, which contains all the functions that instances can use. '''Vector.new''' (shown below) creates a new instance of this class.<br />
<br />
<syntaxhighlight lang="lua"><br />
function Vector.new(x, y)<br />
return setmetatable({ x = x or 0, y = y or 0 }, Vector)<br />
end<br />
</syntaxhighlight><br />
<br />
It creates a new table with '''x''' and '''y''' properties, and then sets the metatable to the '''Vector''' class. As we know, '''Vector''' contains all the metamethods and especially the '''__index''' key. This means that we can use all the functions we define in '''Vector''' through this new table. We'll come back to this in a moment.<br />
<br />
Another important thing is the last line:<br />
<syntaxhighlight lang="lua"><br />
setmetatable(Vector, { __call = function(_, ...) return Vector.new(...) end })<br />
</syntaxhighlight><br />
<br />
This means that we can create a new '''Vector''' instance by either calling '''Vector.new''' or just '''Vector'''.<br />
<br />
The last important thing that you may not be aware of is the colon syntax. When we define a function with a colon, like this:<br />
<syntaxhighlight lang="lua"><br />
function t:method(a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
What we are really doing is defining this function:<br />
<syntaxhighlight lang="lua"><br />
function t.method(self, a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
<br />
This is syntactic sugar to help with OOP. We can then use the colon syntax when calling functions:<br />
<syntaxhighlight lang="lua"><br />
-- these are the same<br />
t:method(1, 2, 3)<br />
t.method(t, 1, 2, 3)<br />
</syntaxhighlight><br />
<br />
Now, how do we use this '''Vector''' class? Here's a final example:<br />
<syntaxhighlight lang="lua"><br />
a = Vector.new(10, 10)<br />
b = Vector(20, 11)<br />
c = a + b<br />
print(a:len()) -- 14.142135623731<br />
print(a) -- (10, 10)<br />
print(c) -- (30, 21)<br />
print(a < c) -- true<br />
print(a == b) -- false<br />
</syntaxhighlight><br />
<br />
Because of the '''__index''' in '''Vector''', we can use all the methods defined in the class through the instances.<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight></div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44007OOP in Lua2015-01-18T03:41:35Z<p>Novo: </p>
<hr />
<div>{{Note_box|Any further questions can be discussed at the [http://forum.mtasa.com/viewtopic.php?f=148&t=84365 topic] dedicated to this tutorial.}}<br />
__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua.<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Content's provenance: [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ NovaFusion]<br />
----<br />
Knowledge of how to use metatables will allow you to be much more powerful in your use of Lua. Every table can have a metatable attached to it. A metatable is a table which, with some certain keys set, can change the behaviour of the table it's attached to. Let's see an example.<br />
<syntaxhighlight lang="lua"><br />
t = {} -- our normal table<br />
mt = {} -- our metatable, which contains nothing right now<br />
setmetatable(t, mt) -- sets mt to be t's metatable<br />
getmetatable(t) -- this will return mt<br />
</syntaxhighlight><br />
<br />
As you can see, '''getmetatable''' and '''setmetatable''' are the main functions here; I think it's pretty obvious what they do. Of course, in this case we could contract the first three lines into this:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {})<br />
</syntaxhighlight><br />
'''setmetatable''' returns its first argument, therefore we can use this shorter form.<br />
<br />
Now, what do we put in these metatables? Metatables can contain anything, but they respond to certain keys (which are strings of course) which always start with __ (two underscores in a row), such as '''__index''' and '''__newindex'''. The values corresponding to these keys will usually be functions or other tables. An example:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__index = function(t, key)<br />
if key == "foo" then<br />
return 0<br />
else<br />
return table[key]<br />
end<br />
end<br />
})<br />
</syntaxhighlight><br />
So as you can see, we assign a function to the '''__index''' key. Now let's have a look at what this key is all about.<br />
<br />
=== __index ===<br />
<br />
The most used metatable key is most likely '''__index'''; it can contain either a function or table.<br />
<br />
When you look up a table with a key, regardless of what the key is (t[4], t.foo, and t["foo"], for example), and a value hasn't been assigned for that key, Lua will look for an '''__index''' key in the table's metatable (if it has a metatable). If '''__index''' contains a table, Lua will look up the key originally used in the table belonging to '''__index'''. This probably sounds confusing, so here's an example:<br />
<syntaxhighlight lang="lua"><br />
other = { foo = 3 }<br />
t = setmetatable({}, { __index = other })<br />
t.foo -- 3<br />
t.bar -- nil<br />
</syntaxhighlight><br />
<br />
If '''__index''' contains a function, then it's called, with the table that is being looked up and the key used as parameters. As we saw in the code example above the last one, this allows us to use conditionals on the key, and basically anything else that Lua code can do. Therefore, in that example, if the key was equal to the string "foo" we would return 0, otherwise we look up the '''table''' table with the key that was used; this makes '''t''' an alias of '''table''' that returns 0 when the key "foo" is used.<br />
<br />
You may be wondering why the table is passed as a first parameter to the '''__index''' function. This comes in handy if you use the same metatable for multiple tables, supporting code re-use and saving computer resources. We'll see an example of this when we take a look at the '''Vector''' class.<br />
<br />
=== __newindex ===<br />
<br />
Next in line is '''__newindex''', which is similar to '''__index'''. Like '''__index''', it can contain either a function or table.<br />
<br />
When you try to set a value in a table that is not already present, Lua will look for a '''__newindex''' key in the metatable. It's the same sort of situation as '''__index'''; if '''__newindex''' is a table, the key and value will be set in the table specified:<br />
<syntaxhighlight lang="lua"><br />
other = {}<br />
t = setmetatable({}, { __newindex = other })<br />
t.foo = 3<br />
other.foo -- 3<br />
t.foo -- nil<br />
</syntaxhighlight><br />
As would be expected, if '''__newindex''' is a function, it will be called with the table, key, and value passed as parameters:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__newindex = function(t, key, value)<br />
if type(value) == "number" then<br />
rawset(t, key, value * value)<br />
else<br />
rawset(t, key, value)<br />
end<br />
end<br />
})<br />
<br />
t.foo = "foo"<br />
t.bar = 4<br />
t.la = 10<br />
t.foo -- "foo"<br />
t.bar -- 16<br />
t.la -- 100<br />
</syntaxhighlight><br />
When creating a new key in '''t''', if the value is a number it will be squared, otherwise it will just be set anyway. This introduces us to our friends, '''rawget''' and '''rawset'''.<br />
<br />
=== rawget and rawset ===<br />
<br />
There are times when you need get and set a table's keys without having Lua do it's thing with metatables. As you might guess, [http://www.lua.org/manual/5.1/manual.html#pdf-rawget rawget] allows you to get the value of a key without Lua using '''__index''', and [http://www.lua.org/manual/5.1/manual.html#pdf-rawset rawset] allows you to set the value of a key without Lua using '''__newindex''' (no these don't provide a speed increase to conventional way of doing things). You'll need to use these when you would otherwise get stuck in an infinite loop. For example, in that last code example, the code '''t[key] = value * value''' would set off the same '''__newindex''' function again, which would get you stuck in an infinite loop. Using '''rawset(t, key, value * value)''' avoids this.<br />
<br />
As you probably can see, to use these functions, for parameters we must pass in the target table, the key, and if you're using '''rawset''', the value.<br />
<br />
=== Operators ===<br />
<br />
Many of the metatable keys available have to do with operators (as in, '''+''', '''-''', etc.), allowing you to make tables support the use of operators on them. For example, say we wanted a table to support the multiplication operator ('''*'''), this is how we would do it:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__mul = function(t, other)<br />
new = {}<br />
<br />
for i = 1, other do<br />
for _, v in ipairs(t) do table.insert(new, v) end<br />
end<br />
<br />
return new<br />
end<br />
})<br />
<br />
t = t * 2 -- { 1, 2, 3, 1, 2, 3 }<br />
</syntaxhighlight><br />
<br />
This allows us to create a new table with the original replicated a certain amount of times using the multiplication operator. As you can tell, the corresponding key for multiplication is '''__mul'''; unlike '''__index''' and '''__newindex''' the keys for operators can only contain functions. The first parameter these functions always receive is the target table, and then the value on the right hand side (except for the unary - which has the key of '''__unm'''). Here's a list of the supported operators:<br />
<br />
* __add: Addition (+)<br />
* __sub: Subtraction (-)<br />
* __mul: Multiplication (*)<br />
* __div: Division (/)<br />
* __mod: Modulos (%)<br />
* __unm: Unary -, used for negation on numbers<br />
* __concat: Concatenation (..)<br />
* __eq: Equality (==)<br />
* __lt: Less than (<)<br />
* __le: Less than or equal to (<=)<br />
<br />
(There's only '''==''', '''<''', '''<=''' because you can implement full support for the comparison operators with just those; in fact only '''==''' and '''<''' are needed.)<br />
<br />
=== __call ===<br />
<br />
Next comes the '''__call''' key, which allows you to call tables as functions. A code example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__call = function(t, a, b, c, whatever)<br />
return (a + b + c) * whatever<br />
end<br />
})<br />
<br />
t(1, 2, 3, 4) -- 24<br />
</syntaxhighlight><br />
<br />
The function in call is passed the target table as usual, followed by the parameters that we passed in. '''__call''' is very useful for many things. One common thing it's used for is forwarding a call on a table to a function inside that table.<br />
<br />
=== __tostring ===<br />
<br />
Last of all is '''__tostring'''. If implemented, it's used by [http://www.lua.org/manual/5.1/manual.html#pdf-tostring tostring] to convert a table into a string, most handy when using a function like [http://www.lua.org/manual/5.1/manual.html#pdf-print print]. Normally, when you try to convert a table to a string, you something in the format of "table: 0x<hex-code-here>", but you can change that using '''__tostring'''. An example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__tostring = function(t)<br />
sum = 0<br />
for _, v in pairs(t) do sum = sum + v end<br />
return "Sum: " .. sum<br />
end<br />
})<br />
<br />
print(t) -- prints out "Sum: 6"<br />
</syntaxhighlight><br />
<br />
=== Building the Vector Class ===<br />
<br />
To wrap everything up, we'll write a class encapsulating a 2D vector. It's too large to put here, but you can see the full code at [https://gist.github.com/1055480 gist #1055480]. I've positioned all the stuff to do with metatables first in the file, as that's the most important stuff. (Be warned, this may be a bit confusing if you've never encountered Object-Oriented Programming before.)<br />
<br />
<syntaxhighlight lang="lua"><br />
Vector = {}<br />
Vector.__index = Vector<br />
</syntaxhighlight><br />
<br />
This code sets up the table for the '''Vector''' class, and sets the '''__index''' key to point back at itself. Now, what's going on here? You've probably noticed that we've put all the metatable methods inside the '''Vector''' class. What you're seeing is the simplest way to achieve OOP (Object-Oriented Programming) in Lua. The '''Vector''' table represents the class, which contains all the functions that instances can use. '''Vector.new''' (shown below) creates a new instance of this class.<br />
<br />
<syntaxhighlight lang="lua"><br />
function Vector.new(x, y)<br />
return setmetatable({ x = x or 0, y = y or 0 }, Vector)<br />
end<br />
</syntaxhighlight><br />
<br />
It creates a new table with '''x''' and '''y''' properties, and then sets the metatable to the '''Vector''' class. As we know, '''Vector''' contains all the metamethods and especially the '''__index''' key. This means that we can use all the functions we define in '''Vector''' through this new table. We'll come back to this in a moment.<br />
<br />
Another important thing is the last line:<br />
<syntaxhighlight lang="lua"><br />
setmetatable(Vector, { __call = function(_, ...) return Vector.new(...) end })<br />
</syntaxhighlight><br />
<br />
This means that we can create a new '''Vector''' instance by either calling '''Vector.new''' or just '''Vector'''.<br />
<br />
The last important thing that you may not be aware of is the colon syntax. When we define a function with a colon, like this:<br />
<syntaxhighlight lang="lua"><br />
function t:method(a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
What we are really doing is defining this function:<br />
<syntaxhighlight lang="lua"><br />
function t.method(self, a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
<br />
This is syntactic sugar to help with OOP. We can then use the colon syntax when calling functions:<br />
<syntaxhighlight lang="lua"><br />
-- these are the same<br />
t:method(1, 2, 3)<br />
t.method(t, 1, 2, 3)<br />
</syntaxhighlight><br />
<br />
Now, how do we use this '''Vector''' class? Here's a final example:<br />
<syntaxhighlight lang="lua"><br />
a = Vector.new(10, 10)<br />
b = Vector(20, 11)<br />
c = a + b<br />
print(a:len()) -- 14.142135623731<br />
print(a) -- (10, 10)<br />
print(c) -- (30, 21)<br />
print(a < c) -- true<br />
print(a == b) -- false<br />
</syntaxhighlight><br />
<br />
Because of the '''__index''' in '''Vector''', we can use all the methods defined in the class through the instances.<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight></div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44006OOP in Lua2015-01-18T03:34:03Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
{{Note_box|Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua.<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Content's provenance: [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ NovaFusion]<br />
----<br />
Knowledge of how to use metatables will allow you to be much more powerful in your use of Lua. Every table can have a metatable attached to it. A metatable is a table which, with some certain keys set, can change the behaviour of the table it's attached to. Let's see an example.<br />
<syntaxhighlight lang="lua"><br />
t = {} -- our normal table<br />
mt = {} -- our metatable, which contains nothing right now<br />
setmetatable(t, mt) -- sets mt to be t's metatable<br />
getmetatable(t) -- this will return mt<br />
</syntaxhighlight><br />
<br />
As you can see, '''getmetatable''' and '''setmetatable''' are the main functions here; I think it's pretty obvious what they do. Of course, in this case we could contract the first three lines into this:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {})<br />
</syntaxhighlight><br />
'''setmetatable''' returns its first argument, therefore we can use this shorter form.<br />
<br />
Now, what do we put in these metatables? Metatables can contain anything, but they respond to certain keys (which are strings of course) which always start with __ (two underscores in a row), such as '''__index''' and '''__newindex'''. The values corresponding to these keys will usually be functions or other tables. An example:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__index = function(t, key)<br />
if key == "foo" then<br />
return 0<br />
else<br />
return table[key]<br />
end<br />
end<br />
})<br />
</syntaxhighlight><br />
So as you can see, we assign a function to the '''__index''' key. Now let's have a look at what this key is all about.<br />
<br />
=== __index ===<br />
<br />
The most used metatable key is most likely '''__index'''; it can contain either a function or table.<br />
<br />
When you look up a table with a key, regardless of what the key is (t[4], t.foo, and t["foo"], for example), and a value hasn't been assigned for that key, Lua will look for an '''__index''' key in the table's metatable (if it has a metatable). If '''__index''' contains a table, Lua will look up the key originally used in the table belonging to '''__index'''. This probably sounds confusing, so here's an example:<br />
<syntaxhighlight lang="lua"><br />
other = { foo = 3 }<br />
t = setmetatable({}, { __index = other })<br />
t.foo -- 3<br />
t.bar -- nil<br />
</syntaxhighlight><br />
<br />
If '''__index''' contains a function, then it's called, with the table that is being looked up and the key used as parameters. As we saw in the code example above the last one, this allows us to use conditionals on the key, and basically anything else that Lua code can do. Therefore, in that example, if the key was equal to the string "foo" we would return 0, otherwise we look up the '''table''' table with the key that was used; this makes '''t''' an alias of '''table''' that returns 0 when the key "foo" is used.<br />
<br />
You may be wondering why the table is passed as a first parameter to the '''__index''' function. This comes in handy if you use the same metatable for multiple tables, supporting code re-use and saving computer resources. We'll see an example of this when we take a look at the '''Vector''' class.<br />
<br />
=== __newindex ===<br />
<br />
Next in line is '''__newindex''', which is similar to '''__index'''. Like '''__index''', it can contain either a function or table.<br />
<br />
When you try to set a value in a table that is not already present, Lua will look for a '''__newindex''' key in the metatable. It's the same sort of situation as '''__index'''; if '''__newindex''' is a table, the key and value will be set in the table specified:<br />
<syntaxhighlight lang="lua"><br />
other = {}<br />
t = setmetatable({}, { __newindex = other })<br />
t.foo = 3<br />
other.foo -- 3<br />
t.foo -- nil<br />
</syntaxhighlight><br />
As would be expected, if '''__newindex''' is a function, it will be called with the table, key, and value passed as parameters:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__newindex = function(t, key, value)<br />
if type(value) == "number" then<br />
rawset(t, key, value * value)<br />
else<br />
rawset(t, key, value)<br />
end<br />
end<br />
})<br />
<br />
t.foo = "foo"<br />
t.bar = 4<br />
t.la = 10<br />
t.foo -- "foo"<br />
t.bar -- 16<br />
t.la -- 100<br />
</syntaxhighlight><br />
When creating a new key in '''t''', if the value is a number it will be squared, otherwise it will just be set anyway. This introduces us to our friends, '''rawget''' and '''rawset'''.<br />
<br />
=== rawget and rawset ===<br />
<br />
There are times when you need get and set a table's keys without having Lua do it's thing with metatables. As you might guess, [http://www.lua.org/manual/5.1/manual.html#pdf-rawget rawget] allows you to get the value of a key without Lua using '''__index''', and [http://www.lua.org/manual/5.1/manual.html#pdf-rawset rawset] allows you to set the value of a key without Lua using '''__newindex''' (no these don't provide a speed increase to conventional way of doing things). You'll need to use these when you would otherwise get stuck in an infinite loop. For example, in that last code example, the code '''t[key] = value * value''' would set off the same '''__newindex''' function again, which would get you stuck in an infinite loop. Using '''rawset(t, key, value * value)''' avoids this.<br />
<br />
As you probably can see, to use these functions, for parameters we must pass in the target table, the key, and if you're using '''rawset''', the value.<br />
<br />
=== Operators ===<br />
<br />
Many of the metatable keys available have to do with operators (as in, '''+''', '''-''', etc.), allowing you to make tables support the use of operators on them. For example, say we wanted a table to support the multiplication operator ('''*'''), this is how we would do it:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__mul = function(t, other)<br />
new = {}<br />
<br />
for i = 1, other do<br />
for _, v in ipairs(t) do table.insert(new, v) end<br />
end<br />
<br />
return new<br />
end<br />
})<br />
<br />
t = t * 2 -- { 1, 2, 3, 1, 2, 3 }<br />
</syntaxhighlight><br />
<br />
This allows us to create a new table with the original replicated a certain amount of times using the multiplication operator. As you can tell, the corresponding key for multiplication is '''__mul'''; unlike '''__index''' and '''__newindex''' the keys for operators can only contain functions. The first parameter these functions always receive is the target table, and then the value on the right hand side (except for the unary - which has the key of '''__unm'''). Here's a list of the supported operators:<br />
<br />
* __add: Addition (+)<br />
* __sub: Subtraction (-)<br />
* __mul: Multiplication (*)<br />
* __div: Division (/)<br />
* __mod: Modulos (%)<br />
* __unm: Unary -, used for negation on numbers<br />
* __concat: Concatenation (..)<br />
* __eq: Equality (==)<br />
* __lt: Less than (<)<br />
* __le: Less than or equal to (<=)<br />
<br />
(There's only '''==''', '''<''', '''<=''' because you can implement full support for the comparison operators with just those; in fact only '''==''' and '''<''' are needed.)<br />
<br />
=== __call ===<br />
<br />
Next comes the '''__call''' key, which allows you to call tables as functions. A code example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__call = function(t, a, b, c, whatever)<br />
return (a + b + c) * whatever<br />
end<br />
})<br />
<br />
t(1, 2, 3, 4) -- 24<br />
</syntaxhighlight><br />
<br />
The function in call is passed the target table as usual, followed by the parameters that we passed in. '''__call''' is very useful for many things. One common thing it's used for is forwarding a call on a table to a function inside that table.<br />
<br />
=== __tostring ===<br />
<br />
Last of all is '''__tostring'''. If implemented, it's used by [http://www.lua.org/manual/5.1/manual.html#pdf-tostring tostring] to convert a table into a string, most handy when using a function like [http://www.lua.org/manual/5.1/manual.html#pdf-print print]. Normally, when you try to convert a table to a string, you something in the format of "table: 0x<hex-code-here>", but you can change that using '''__tostring'''. An example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__tostring = function(t)<br />
sum = 0<br />
for _, v in pairs(t) do sum = sum + v end<br />
return "Sum: " .. sum<br />
end<br />
})<br />
<br />
print(t) -- prints out "Sum: 6"<br />
</syntaxhighlight><br />
<br />
=== Building the Vector Class ===<br />
<br />
To wrap everything up, we'll write a class encapsulating a 2D vector. It's too large to put here, but you can see the full code at [https://gist.github.com/1055480 gist #1055480]. I've positioned all the stuff to do with metatables first in the file, as that's the most important stuff. (Be warned, this may be a bit confusing if you've never encountered Object-Oriented Programming before.)<br />
<br />
<syntaxhighlight lang="lua"><br />
Vector = {}<br />
Vector.__index = Vector<br />
</syntaxhighlight><br />
<br />
This code sets up the table for the '''Vector''' class, and sets the '''__index''' key to point back at itself. Now, what's going on here? You've probably noticed that we've put all the metatable methods inside the '''Vector''' class. What you're seeing is the simplest way to achieve OOP (Object-Oriented Programming) in Lua. The '''Vector''' table represents the class, which contains all the functions that instances can use. '''Vector.new''' (shown below) creates a new instance of this class.<br />
<br />
<syntaxhighlight lang="lua"><br />
function Vector.new(x, y)<br />
return setmetatable({ x = x or 0, y = y or 0 }, Vector)<br />
end<br />
</syntaxhighlight><br />
<br />
It creates a new table with '''x''' and '''y''' properties, and then sets the metatable to the '''Vector''' class. As we know, '''Vector''' contains all the metamethods and especially the '''__index''' key. This means that we can use all the functions we define in '''Vector''' through this new table. We'll come back to this in a moment.<br />
<br />
Another important thing is the last line:<br />
<syntaxhighlight lang="lua"><br />
setmetatable(Vector, { __call = function(_, ...) return Vector.new(...) end })<br />
</syntaxhighlight><br />
<br />
This means that we can create a new '''Vector''' instance by either calling '''Vector.new''' or just '''Vector'''.<br />
<br />
The last important thing that you may not be aware of is the colon syntax. When we define a function with a colon, like this:<br />
<syntaxhighlight lang="lua"><br />
function t:method(a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
What we are really doing is defining this function:<br />
<syntaxhighlight lang="lua"><br />
function t.method(self, a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
<br />
This is syntactic sugar to help with OOP. We can then use the colon syntax when calling functions:<br />
<syntaxhighlight lang="lua"><br />
-- these are the same<br />
t:method(1, 2, 3)<br />
t.method(t, 1, 2, 3)<br />
</syntaxhighlight><br />
<br />
Now, how do we use this '''Vector''' class? Here's a final example:<br />
<syntaxhighlight lang="lua"><br />
a = Vector.new(10, 10)<br />
b = Vector(20, 11)<br />
c = a + b<br />
print(a:len()) -- 14.142135623731<br />
print(a) -- (10, 10)<br />
print(c) -- (30, 21)<br />
print(a < c) -- true<br />
print(a == b) -- false<br />
</syntaxhighlight><br />
<br />
Because of the '''__index''' in '''Vector''', we can use all the methods defined in the class through the instances.<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight></div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44005OOP in Lua2015-01-18T03:33:26Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
{{Note_box|Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua.<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Content's provenance: [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ NovaFusion]<br />
----<br />
Knowledge of how to use metatables will allow you to be much more powerful in your use of Lua. Every table can have a metatable attached to it. A metatable is a table which, with some certain keys set, can change the behaviour of the table it's attached to. Let's see an example.<br />
<syntaxhighlight lang="lua"><br />
t = {} -- our normal table<br />
mt = {} -- our metatable, which contains nothing right now<br />
setmetatable(t, mt) -- sets mt to be t's metatable<br />
getmetatable(t) -- this will return mt<br />
</syntaxhighlight><br />
<br />
As you can see, '''getmetatable''' and '''setmetatable''' are the main functions here; I think it's pretty obvious what they do. Of course, in this case we could contract the first three lines into this:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {})<br />
</syntaxhighlight><br />
'''setmetatable''' returns its first argument, therefore we can use this shorter form.<br />
<br />
Now, what do we put in these metatables? Metatables can contain anything, but they respond to certain keys (which are strings of course) which always start with __ (two underscores in a row), such as '''__index''' and '''__newindex'''. The values corresponding to these keys will usually be functions or other tables. An example:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__index = function(t, key)<br />
if key == "foo" then<br />
return 0<br />
else<br />
return table[key]<br />
end<br />
end<br />
})<br />
</syntaxhighlight><br />
So as you can see, we assign a function to the '''__index''' key. Now let's have a look at what this key is all about.<br />
<br />
=== __index ===<br />
<br />
The most used metatable key is most likely '''__index'''; it can contain either a function or table.<br />
<br />
When you look up a table with a key, regardless of what the key is (t[4], t.foo, and t["foo"], for example), and a value hasn't been assigned for that key, Lua will look for an '''__index''' key in the table's metatable (if it has a metatable). If '''__index''' contains a table, Lua will look up the key originally used in the table belonging to '''__index'''. This probably sounds confusing, so here's an example:<br />
<syntaxhighlight lang="lua"><br />
other = { foo = 3 }<br />
t = setmetatable({}, { __index = other })<br />
t.foo -- 3<br />
t.bar -- nil<br />
</syntaxhighlight><br />
<br />
If '''__index''' contains a function, then it's called, with the table that is being looked up and the key used as parameters. As we saw in the code example above the last one, this allows us to use conditionals on the key, and basically anything else that Lua code can do. Therefore, in that example, if the key was equal to the string "foo" we would return 0, otherwise we look up the '''table''' table with the key that was used; this makes '''t''' an alias of '''table''' that returns 0 when the key "foo" is used.<br />
<br />
You may be wondering why the table is passed as a first parameter to the '''__index''' function. This comes in handy if you use the same metatable for multiple tables, supporting code re-use and saving computer resources. We'll see an example of this when we take a look at the '''Vector''' class.<br />
<br />
=== __newindex ===<br />
<br />
Next in line is '''__newindex''', which is similar to '''__index'''. Like '''__index''', it can contain either a function or table.<br />
<br />
When you try to set a value in a table that is not already present, Lua will look for a '''__newindex''' key in the metatable. It's the same sort of situation as '''__index'''; if '''__newindex''' is a table, the key and value will be set in the table specified:<br />
<syntaxhighlight lang="lua"><br />
other = {}<br />
t = setmetatable({}, { __newindex = other })<br />
t.foo = 3<br />
other.foo -- 3<br />
t.foo -- nil<br />
</syntaxhighlight><br />
As would be expected, if '''__newindex''' is a function, it will be called with the table, key, and value passed as parameters:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__newindex = function(t, key, value)<br />
if type(value) == "number" then<br />
rawset(t, key, value * value)<br />
else<br />
rawset(t, key, value)<br />
end<br />
end<br />
})<br />
<br />
t.foo = "foo"<br />
t.bar = 4<br />
t.la = 10<br />
t.foo -- "foo"<br />
t.bar -- 16<br />
t.la -- 100<br />
</syntaxhighlight><br />
When creating a new key in '''t''', if the value is a number it will be squared, otherwise it will just be set anyway. This introduces us to our friends, '''rawget''' and '''rawset'''.<br />
<br />
=== rawget and rawset ===<br />
<br />
There are times when you need get and set a table's keys without having Lua do it's thing with metatables. As you might guess, [http://www.lua.org/manual/5.1/manual.html#pdf-rawget rawget] allows you to get the value of a key without Lua using '''__index''', and [http://www.lua.org/manual/5.1/manual.html#pdf-rawset rawset] allows you to set the value of a key without Lua using '''__newindex''' (no these don't provide a speed increase to conventional way of doing things). You'll need to use these when you would otherwise get stuck in an infinite loop. For example, in that last code example, the code '''t[key] = value * value''' would set off the same '''__newindex''' function again, which would get you stuck in an infinite loop. Using '''rawset(t, key, value * value)''' avoids this.<br />
<br />
As you probably can see, to use these functions, for parameters we must pass in the target table, the key, and if you're using '''rawset''', the value.<br />
<br />
=== Operators ===<br />
<br />
Many of the metatable keys available have to do with operators (as in, '''+''', '''-''', etc.), allowing you to make tables support the use of operators on them. For example, say we wanted a table to support the multiplication operator ('''*'''), this is how we would do it:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__mul = function(t, other)<br />
new = {}<br />
<br />
for i = 1, other do<br />
for _, v in ipairs(t) do table.insert(new, v) end<br />
end<br />
<br />
return new<br />
end<br />
})<br />
<br />
t = t * 2 -- { 1, 2, 3, 1, 2, 3 }<br />
</syntaxhighlight><br />
<br />
This allows us to create a new table with the original replicated a certain amount of times using the multiplication operator. As you can tell, the corresponding key for multiplication is '''__mul'''; unlike '''__index''' and '''__newindex''' the keys for operators can only contain functions. The first parameter these functions always receive is the target table, and then the value on the right hand side (except for the unary - which has the key of '''__unm'''). Here's a list of the supported operators:<br />
<br />
* __add: Addition (+)<br />
* __sub: Subtraction (-)<br />
* __mul: Multiplication (*)<br />
* __div: Division (/)<br />
* __mod: Modulos (%)<br />
* __unm: Unary -, used for negation on numbers<br />
* __concat: Concatenation (..)<br />
* __eq: Equality (==)<br />
* __lt: Less than (<)<br />
* __le: Less than or equal to (<=)<br />
<br />
(There's only '''==''', '''<''', '''<=''' because you can implement full support for the comparison operators with just those; in fact only '''==''' and '''<''' are needed.)<br />
<br />
<br />
=== __call ===<br />
<br />
Next comes the '''__call''' key, which allows you to call tables as functions. A code example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__call = function(t, a, b, c, whatever)<br />
return (a + b + c) * whatever<br />
end<br />
})<br />
<br />
t(1, 2, 3, 4) -- 24<br />
</syntaxhighlight><br />
<br />
The function in call is passed the target table as usual, followed by the parameters that we passed in. '''__call''' is very useful for many things. One common thing it's used for is forwarding a call on a table to a function inside that table.<br />
<br />
=== __tostring ===<br />
<br />
Last of all is '''__tostring'''. If implemented, it's used by [http://www.lua.org/manual/5.1/manual.html#pdf-tostring tostring] to convert a table into a string, most handy when using a function like [http://www.lua.org/manual/5.1/manual.html#pdf-print print]. Normally, when you try to convert a table to a string, you something in the format of "table: 0x<hex-code-here>", but you can change that using '''__tostring'''. An example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__tostring = function(t)<br />
sum = 0<br />
for _, v in pairs(t) do sum = sum + v end<br />
return "Sum: " .. sum<br />
end<br />
})<br />
<br />
print(t) -- prints out "Sum: 6"<br />
</syntaxhighlight><br />
<br />
=== Building the Vector Class ===<br />
<br />
To wrap everything up, we'll write a class encapsulating a 2D vector. It's too large to put here, but you can see the full code at [https://gist.github.com/1055480 gist #1055480]. I've positioned all the stuff to do with metatables first in the file, as that's the most important stuff. (Be warned, this may be a bit confusing if you've never encountered Object-Oriented Programming before.)<br />
<br />
<syntaxhighlight lang="lua"><br />
Vector = {}<br />
Vector.__index = Vector<br />
</syntaxhighlight><br />
<br />
This code sets up the table for the '''Vector''' class, and sets the '''__index''' key to point back at itself. Now, what's going on here? You've probably noticed that we've put all the metatable methods inside the '''Vector''' class. What you're seeing is the simplest way to achieve OOP (Object-Oriented Programming) in Lua. The '''Vector''' table represents the class, which contains all the functions that instances can use. '''Vector.new''' (shown below) creates a new instance of this class.<br />
<br />
<syntaxhighlight lang="lua"><br />
function Vector.new(x, y)<br />
return setmetatable({ x = x or 0, y = y or 0 }, Vector)<br />
end<br />
</syntaxhighlight><br />
<br />
It creates a new table with '''x''' and '''y''' properties, and then sets the metatable to the '''Vector''' class. As we know, '''Vector''' contains all the metamethods and especially the '''__index''' key. This means that we can use all the functions we define in '''Vector''' through this new table. We'll come back to this in a moment.<br />
<br />
Another important thing is the last line:<br />
<syntaxhighlight lang="lua"><br />
setmetatable(Vector, { __call = function(_, ...) return Vector.new(...) end })<br />
</syntaxhighlight><br />
<br />
This means that we can create a new '''Vector''' instance by either calling '''Vector.new''' or just '''Vector'''.<br />
<br />
The last important thing that you may not be aware of is the colon syntax. When we define a function with a colon, like this:<br />
<syntaxhighlight lang="lua"><br />
function t:method(a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
What we are really doing is defining this function:<br />
<syntaxhighlight lang="lua"><br />
function t.method(self, a, b, c)<br />
-- ...<br />
end<br />
</syntaxhighlight><br />
<br />
This is syntactic sugar to help with OOP. We can then use the colon syntax when calling functions:<br />
<syntaxhighlight lang="lua"><br />
-- these are the same<br />
t:method(1, 2, 3)<br />
t.method(t, 1, 2, 3)<br />
</syntaxhighlight><br />
<br />
Now, how do we use this '''Vector''' class? Here's a final example:<br />
<syntaxhighlight lang="lua"><br />
a = Vector.new(10, 10)<br />
b = Vector(20, 11)<br />
c = a + b<br />
print(a:len()) -- 14.142135623731<br />
print(a) -- (10, 10)<br />
print(c) -- (30, 21)<br />
print(a < c) -- true<br />
print(a == b) -- false<br />
</syntaxhighlight><br />
<br />
Because of the '''__index''' in '''Vector''', we can use all the methods defined in the class through the instances.<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight></div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44004OOP in Lua2015-01-18T03:26:42Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
{{Note_box|Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua.<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Content's provenance: [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ NovaFusion]<br />
----<br />
Knowledge of how to use metatables will allow you to be much more powerful in your use of Lua. Every table can have a metatable attached to it. A metatable is a table which, with some certain keys set, can change the behaviour of the table it's attached to. Let's see an example.<br />
<syntaxhighlight lang="lua"><br />
t = {} -- our normal table<br />
mt = {} -- our metatable, which contains nothing right now<br />
setmetatable(t, mt) -- sets mt to be t's metatable<br />
getmetatable(t) -- this will return mt<br />
</syntaxhighlight><br />
<br />
As you can see, '''getmetatable''' and '''setmetatable''' are the main functions here; I think it's pretty obvious what they do. Of course, in this case we could contract the first three lines into this:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {})<br />
</syntaxhighlight><br />
'''setmetatable''' returns its first argument, therefore we can use this shorter form.<br />
<br />
Now, what do we put in these metatables? Metatables can contain anything, but they respond to certain keys (which are strings of course) which always start with __ (two underscores in a row), such as '''__index''' and '''__newindex'''. The values corresponding to these keys will usually be functions or other tables. An example:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__index = function(t, key)<br />
if key == "foo" then<br />
return 0<br />
else<br />
return table[key]<br />
end<br />
end<br />
})<br />
</syntaxhighlight><br />
So as you can see, we assign a function to the '''__index''' key. Now let's have a look at what this key is all about.<br />
<br />
=== __index ===<br />
<br />
The most used metatable key is most likely '''__index'''; it can contain either a function or table.<br />
<br />
When you look up a table with a key, regardless of what the key is (t[4], t.foo, and t["foo"], for example), and a value hasn't been assigned for that key, Lua will look for an '''__index''' key in the table's metatable (if it has a metatable). If '''__index''' contains a table, Lua will look up the key originally used in the table belonging to '''__index'''. This probably sounds confusing, so here's an example:<br />
<syntaxhighlight lang="lua"><br />
other = { foo = 3 }<br />
t = setmetatable({}, { __index = other })<br />
t.foo -- 3<br />
t.bar -- nil<br />
</syntaxhighlight><br />
<br />
If '''__index''' contains a function, then it's called, with the table that is being looked up and the key used as parameters. As we saw in the code example above the last one, this allows us to use conditionals on the key, and basically anything else that Lua code can do. Therefore, in that example, if the key was equal to the string "foo" we would return 0, otherwise we look up the '''table''' table with the key that was used; this makes '''t''' an alias of '''table''' that returns 0 when the key "foo" is used.<br />
<br />
You may be wondering why the table is passed as a first parameter to the '''__index''' function. This comes in handy if you use the same metatable for multiple tables, supporting code re-use and saving computer resources. We'll see an example of this when we take a look at the '''Vector''' class.<br />
<br />
=== __newindex ===<br />
<br />
Next in line is '''__newindex''', which is similar to '''__index'''. Like '''__index''', it can contain either a function or table.<br />
<br />
When you try to set a value in a table that is not already present, Lua will look for a '''__newindex''' key in the metatable. It's the same sort of situation as '''__index'''; if '''__newindex''' is a table, the key and value will be set in the table specified:<br />
<syntaxhighlight lang="lua"><br />
other = {}<br />
t = setmetatable({}, { __newindex = other })<br />
t.foo = 3<br />
other.foo -- 3<br />
t.foo -- nil<br />
</syntaxhighlight><br />
As would be expected, if '''__newindex''' is a function, it will be called with the table, key, and value passed as parameters:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__newindex = function(t, key, value)<br />
if type(value) == "number" then<br />
rawset(t, key, value * value)<br />
else<br />
rawset(t, key, value)<br />
end<br />
end<br />
})<br />
<br />
t.foo = "foo"<br />
t.bar = 4<br />
t.la = 10<br />
t.foo -- "foo"<br />
t.bar -- 16<br />
t.la -- 100<br />
</syntaxhighlight><br />
When creating a new key in '''t''', if the value is a number it will be squared, otherwise it will just be set anyway. This introduces us to our friends, '''rawget''' and '''rawset'''.<br />
<br />
=== rawget and rawset ===<br />
<br />
There are times when you need get and set a table's keys without having Lua do it's thing with metatables. As you might guess, [http://www.lua.org/manual/5.1/manual.html#pdf-rawget rawget] allows you to get the value of a key without Lua using '''__index''', and [http://www.lua.org/manual/5.1/manual.html#pdf-rawset rawset] allows you to set the value of a key without Lua using '''__newindex''' (no these don't provide a speed increase to conventional way of doing things). You'll need to use these when you would otherwise get stuck in an infinite loop. For example, in that last code example, the code '''t[key] = value * value''' would set off the same '''__newindex''' function again, which would get you stuck in an infinite loop. Using '''rawset(t, key, value * value)''' avoids this.<br />
<br />
As you probably can see, to use these functions, for parameters we must pass in the target table, the key, and if you're using '''rawset''', the value.<br />
<br />
=== Operators ===<br />
<br />
Many of the metatable keys available have to do with operators (as in, '''+''', '''-''', etc.), allowing you to make tables support the use of operators on them. For example, say we wanted a table to support the multiplication operator ('''*'''), this is how we would do it:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__mul = function(t, other)<br />
new = {}<br />
<br />
for i = 1, other do<br />
for _, v in ipairs(t) do table.insert(new, v) end<br />
end<br />
<br />
return new<br />
end<br />
})<br />
<br />
t = t * 2 -- { 1, 2, 3, 1, 2, 3 }<br />
</syntaxhighlight><br />
<br />
This allows us to create a new table with the original replicated a certain amount of times using the multiplication operator. As you can tell, the corresponding key for multiplication is '''__mul'''; unlike '''__index''' and '''__newindex''' the keys for operators can only contain functions. The first parameter these functions always receive is the target table, and then the value on the right hand side (except for the unary - which has the key of '''__unm'''). Here's a list of the supported operators:<br />
<br />
* __add: Addition (+)<br />
* __sub: Subtraction (-)<br />
* __mul: Multiplication (*)<br />
* __div: Division (/)<br />
* __mod: Modulos (%)<br />
* __unm: Unary -, used for negation on numbers<br />
* __concat: Concatenation (..)<br />
* __eq: Equality (==)<br />
* __lt: Less than (<)<br />
* __le: Less than or equal to (<=)<br />
<br />
(There's only '''==''', '''<''', '''<=''' because you can implement full support for the comparison operators with just those; in fact only '''==''' and '''<''' are needed.)<br />
<br />
<br />
=== __call ===<br />
<br />
Next comes the '''__call''' key, which allows you to call tables as functions. A code example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__call = function(t, a, b, c, whatever)<br />
return (a + b + c) * whatever<br />
end<br />
})<br />
<br />
t(1, 2, 3, 4) -- 24<br />
</syntaxhighlight><br />
<br />
The function in call is passed the target table as usual, followed by the parameters that we passed in. '''__call''' is very useful for many things. One common thing it's used for is forwarding a call on a table to a function inside that table.<br />
<br />
=== __tostring ===<br />
<br />
Last of all is '''__tostring'''. If implemented, it's used by [http://www.lua.org/manual/5.1/manual.html#pdf-tostring tostring] to convert a table into a string, most handy when using a function like [http://www.lua.org/manual/5.1/manual.html#pdf-print print]. Normally, when you try to convert a table to a string, you something in the format of "table: 0x<hex-code-here>", but you can change that using '''__tostring'''. An example:<br />
<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({ 1, 2, 3 }, {<br />
__tostring = function(t)<br />
sum = 0<br />
for _, v in pairs(t) do sum = sum + v end<br />
return "Sum: " .. sum<br />
end<br />
})<br />
<br />
print(t) -- prints out "Sum: 6"<br />
</syntaxhighlight><br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight></div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44003OOP in Lua2015-01-18T03:17:56Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
{{Note_box|Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua.<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Content's provenance: [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ NovaFusion]<br />
----<br />
Knowledge of how to use metatables will allow you to be much more powerful in your use of Lua. Every table can have a metatable attached to it. A metatable is a table which, with some certain keys set, can change the behaviour of the table it's attached to. Let's see an example.<br />
<syntaxhighlight lang="lua"><br />
t = {} -- our normal table<br />
mt = {} -- our metatable, which contains nothing right now<br />
setmetatable(t, mt) -- sets mt to be t's metatable<br />
getmetatable(t) -- this will return mt<br />
</syntaxhighlight><br />
<br />
As you can see, '''getmetatable''' and '''setmetatable''' are the main functions here; I think it's pretty obvious what they do. Of course, in this case we could contract the first three lines into this:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {})<br />
</syntaxhighlight><br />
'''setmetatable''' returns its first argument, therefore we can use this shorter form.<br />
<br />
Now, what do we put in these metatables? Metatables can contain anything, but they respond to certain keys (which are strings of course) which always start with __ (two underscores in a row), such as '''__index''' and '''__newindex'''. The values corresponding to these keys will usually be functions or other tables. An example:<br />
<syntaxhighlight lang="lua"><br />
t = setmetatable({}, {<br />
__index = function(t, key)<br />
if key == "foo" then<br />
return 0<br />
else<br />
return table[key]<br />
end<br />
end<br />
})<br />
</syntaxhighlight><br />
So as you can see, we assign a function to the '''__index''' key. Now let's have a look at what this key is all about.<br />
<br />
=== __index ===<br />
<br />
The most used metatable key is most likely '''__index'''; it can contain either a function or table.<br />
<br />
When you look up a table with a key, regardless of what the key is (t[4], t.foo, and t["foo"], for example), and a value hasn't been assigned for that key, Lua will look for an '''__index''' key in the table's metatable (if it has a metatable). If '''__index''' contains a table, Lua will look up the key originally used in the table belonging to '''__index'''. This probably sounds confusing, so here's an example:<br />
<syntaxhighlight lang="lua"><br />
other = { foo = 3 }<br />
t = setmetatable({}, { __index = other })<br />
t.foo -- 3<br />
t.bar -- nil<br />
</syntaxhighlight><br />
<br />
If '''__index''' contains a function, then it's called, with the table that is being looked up and the key used as parameters. As we saw in the code example above the last one, this allows us to use conditionals on the key, and basically anything else that Lua code can do. Therefore, in that example, if the key was equal to the string "foo" we would return 0, otherwise we look up the '''table''' table with the key that was used; this makes '''t''' an alias of '''table''' that returns 0 when the key "foo" is used.<br />
<br />
You may be wondering why the table is passed as a first parameter to the '''__index''' function. This comes in handy if you use the same metatable for multiple tables, supporting code re-use and saving computer resources. We'll see an example of this when we take a look at the '''Vector''' class.<br />
<br />
=== __newindex ===<br />
<br />
Next in line is '''__newindex''', which is similar to '''__index'''. Like '''__index''', it can contain either a function or table.<br />
<br />
When you try to set a value in a table that is not already present, Lua will look for a '''__newindex''' key in the metatable. It's the same sort of situation as '''__index'''; if '''__newindex''' is a table, the key and value will be set in the table specified:<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight></div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44002OOP in Lua2015-01-18T03:09:56Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
{{Note_box|Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua.<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
[http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ Source]<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight></div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44001OOP in Lua2015-01-18T03:09:15Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
{{Note_box|Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua.<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Everything you need to know about them is stupendously explained [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ here].<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight></div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=44000OOP in Lua2015-01-18T03:06:02Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
{{Note_box|Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
__TOC__<br />
== Introduction and other related pages ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua.<br />
* [[OOP_Introduction|OOP Introduction - MTA-related]] ''by qaisjp3''<br />
* [[OOP|OOP]]<br />
* [[OOP_client|MTA built-in client-sided OO functions]]<br />
* [[OOP_server|MTA built-in server-sided OO functions]]<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Everything you need to know about them is stupendously explained [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ here].<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight><br />
<br />
==See Also==<br />
* [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ Metatables tutorial].<br />
* [[OOP|MTA's built-in OO-system]].<br />
* [[OOP_client|MTA's built-in OO-functions]].</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43999OOP in Lua2015-01-18T03:00:52Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
{{Note_box|Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
__TOC__<br />
== Introduction and other related tutorials ==<br />
This is a scripting tutorial teaches you the basics about how to start using an Object-Oriented developing interface with Lua.<br />
<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Everything you need to know about them is stupendously explained [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ here].<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight><br />
<br />
==See Also==<br />
* [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ Metatables tutorial].<br />
* [[OOP|MTA's built-in OO-system]].<br />
* [[OOP_client|MTA's built-in OO-functions]].</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43996OOP in Lua2015-01-18T02:44:04Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
{{Note_box|<br />
Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
<br />
This is a scripting tutorial that teaches you how to start using an Object-Oriented developing interface with Lua.<br />
<br />
__TOC__<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
* self: predefined variable referring to the environment within which we are executing the code.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''[[#Glossary|self]]'''.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Everything you need to know about them is stupendously explained [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ here].<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight><br />
<br />
==See Also==<br />
* [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ Metatables tutorial].<br />
* [[OOP|MTA's built-in OO-system]].<br />
* [[OOP_client|MTA's built-in OO-functions]].</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43995OOP in Lua2015-01-18T02:42:01Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
{{Note_box|<br />
Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
<br />
This is a scripting tutorial that teaches you how to start using an Object-Oriented developing interface with Lua.<br />
<br />
__TOC__<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''self'''. Which refers to the environment within which we are executing a code.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Everything you need to know about them is stupendously explained [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ here].<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
A simple backpacks example:<br />
<syntaxhighlight lang="lua"><br />
local backpack = {list = {}}<br />
function backpack:create (owner, slots)<br />
if self.list[owner] then return end -- return false in case this player already owns a backpack<br />
local new = {<br />
items = {},<br />
slots = slots or 100,<br />
owner = owner<br />
}<br />
setmetatable(new.items, <br />
{<br />
__newindex = function(table, key, value) -- this is called once a new value/item is added into the player's table/backpack<br />
if #table >= new.slots then return end -- return false in case there isn't any free slot left<br />
return rawset(table, key, value)<br />
end<br />
}<br />
)<br />
self.list[owner] = new<br />
end<br />
<br />
function backpack:addItem (player, item, value)<br />
if not self.list[player] then return end<br />
self.list[player][item] = value<br />
end<br />
</syntaxhighlight><br />
<br />
==See Also==<br />
* [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ Metatables tutorial].<br />
* [[OOP|MTA's built-in OO-system]].<br />
* [[OOP_client|MTA's built-in OO-functions]].</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43994OOP in Lua2015-01-18T02:29:04Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
{{Note_box|<br />
Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
<br />
This is a scripting tutorial that teaches you how to start using an Object-Oriented developing interface with Lua.<br />
<br />
__TOC__<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''self'''. Which refers to the environment within which we are executing a code.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''. We can send the self value in case we want a function to override its self and, instead of working as if self was the environment within it's working, it will work over the environment we sent (example under [[#Advanced_examples|advanced examples]]).<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
<br />
array:getKey("text") -- returns "none"<br />
array:setKey("text", "something") -- sets "text"'s value to 'something'<br />
array:getKey("text") -- returns "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
== Metatables ==<br />
Everything you need to know about them is stupendously explained [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ here].<br />
<br />
== Advanced examples ==<br />
Overriding self's value:<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
local array2 = {text = "none2"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
array.getKey(array2, "text") -- returns "none2"<br />
array.setKey(array2, "text", "something2") -- sets array2's "text" value to 'something2'<br />
array.getKey(array2, "text") -- returns "something"<br />
array:getKey("text") -- returns "none"<br />
array.getKey(array, "text") -- same as above<br />
</syntaxhighlight><br />
<br />
==See Also==<br />
* [http://nova-fusion.com/2011/06/30/lua-metatables-tutorial/ Metatables tutorial].<br />
* [[OOP|MTA's built-in OO-system]].<br />
* [[OOP_client|MTA's built-in OO-functions]].</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43992OOP in Lua2015-01-18T02:07:56Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
{{Note_box|<br />
Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
<br />
This is a scripting tutorial that teaches you how to start using an Object-Oriented developing interface with Lua.<br />
<br />
__TOC__<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''self'''. Which refers to the environment within which we are executing a code.<br />
=== Our first environment ===<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it. Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''.<br />
<br />
=== Variables and further handling ===<br />
<syntaxhighlight lang="lua"><br />
local array = {text = "none"}<br />
function array:setKey (key, value)<br />
self[key] = value<br />
end<br />
function array:getKey (key)<br />
return self[key]<br />
end<br />
print(array:getKey("text")) -- "none"<br />
<br />
array:setKey("text", "something")<br />
<br />
print(array:getKey("text")) -- "something"<br />
</syntaxhighlight><br />
What we do here is retrieving and modifying '''text''''s value, which a variable inside array, recurring to functions inside the same environment as the variable is.<br />
<br />
<br />
==See Also==<br />
* [[OOP|MTA's built-in OO-system]].<br />
* [[OOP_client|MTA's built-in OO-functions]].</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43991OOP in Lua2015-01-18T01:58:39Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
== '''This content is not concluded yet.''' ==<br />
<br />
<br />
----<br />
{{Note_box|<br />
Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
<br />
This is a scripting tutorial that teaches you how to start using an Object-Oriented developing interface with Lua.<br />
<br />
__TOC__<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''self'''. Which refers to the environment within which we are executing a code.<br />
=== Our first environment ===<br />
<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it.<br />
<br />
Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''.<br />
<br />
<br />
<br />
<br />
<br />
==See Also==<br />
* [[OOP|MTA's built-in OO-system]].<br />
* [[OOP_client|MTA's built-in OO-functions]].</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43990OOP in Lua2015-01-18T01:52:16Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
== '''This content is not concluded yet.''' ==<br />
<br />
<br />
----<br />
{{Note_box|<br />
Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
<br />
This is a scripting tutorial that teaches you how to start using an Object-Oriented developing interface with Lua.<br />
<br />
__TOC__<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''self'''. Which refers to the environment within which we are executing a code.<br />
=== Our first environment ===<br />
<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it.<br />
<br />
Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function.<br />
<br />
Yes, that's right, and in case we use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''.</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43989OOP in Lua2015-01-18T01:51:49Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
== '''This content is not concluded yet.''' ==<br />
<br />
<br />
----<br />
{{Note_box|<br />
Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
<br />
This is a scripting tutorial that teaches you how to start using an Object-Oriented developing interface with Lua.<br />
<br />
__TOC__<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''self'''. Which refers to the environment within which we are executing a code.<br />
=== Our first environment ===<br />
<br />
<syntaxhighlight lang="lua"><br />
local array = {}<br />
function array:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it.<br />
<br />
Alright, so how should we proceed in order to call the mentioned function? As follows:<br />
<syntaxhighlight lang="lua"><br />
array:example()<br />
array.example(array, example)<br />
</syntaxhighlight><br />
As Lua is so cool, we're able to call a function using two methods: "''':'''" and "'''.'''". As you can see on the example above, if we use a dot we're supposed to send '''self's value''' to the function. Yes, that's right, and in case use a colon, self's value will be the environment within which we are executing a code, i.e. '''array'''.</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43988OOP in Lua2015-01-18T01:44:08Z<p>Novo: </p>
<hr />
<div><pageclass subcaption="Adam James @adam.mta"></pageclass><br />
== '''This content is not concluded yet.''' ==<br />
<br />
<br />
----<br />
{{Note_box|<br />
Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
<br />
This is a scripting tutorial that teaches you how to start using an Object-Oriented developing interface with Lua.<br />
<br />
__TOC__<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''self'''. Which refers to the environment within which we are executing a code.<br />
=== Our first environment ===<br />
<br />
<syntaxhighlight lang="lua"><br />
local environment = {}<br />
function environment:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it.</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43987OOP in Lua2015-01-18T01:38:52Z<p>Novo: </p>
<hr />
<div>== '''This content is not concluded yet.''' ==<br />
<br />
<br />
----<br />
{{Note_box|<br />
Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
<br />
This is a scripting tutorial that teaches you how to start using an Object-Oriented developing interface with Lua.<br />
<br />
__TOC__<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''self'''. Which refers to the environment within which we are executing a code.<br />
=== Our first environment ===<br />
<br />
<syntaxhighlight lang="lua"><br />
local environment = {}<br />
function environment:example (argument)<br />
return "Hello"<br />
end<br />
</syntaxhighlight><br />
What we do upon above is defining a ''local'' environment and then declaring the function '''example''' as part of it.</div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43986OOP in Lua2015-01-18T01:34:03Z<p>Novo: </p>
<hr />
<div>== '''This content is not concluded yet.''' ==<br />
<br />
<br />
----<br />
{{Note_box|<br />
Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
<br />
This is a scripting tutorial that teaches you how to start using an Object-Oriented developing interface with Lua.<br />
<br />
__TOC__<br />
== Glossary ==<br />
* environment: either a table or an array containing values.<br />
<br />
== Initialising ==<br />
There is a basic and simple predefined variables we should recognize and know: '''self'''. Which refers to the environment within which we are executing a code.<br />
<syntaxhighlight lang="lua"><br />
self -- <br />
</syntaxhighlight></div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43985OOP in Lua2015-01-18T01:17:59Z<p>Novo: </p>
<hr />
<div>== '''This content is not concluded yet.''' ==<br />
<br />
<br />
----<br />
{{Note_box|<br />
Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
<br />
This is a scripting tutorial that teaches you how to start using an Object-Oriented developing interface with Lua.<br />
<br />
__TOC__<br />
== Introduction ==<br />
There are few basic predefined variables we should recognize and know:<br />
<syntaxhighlight lang="lua"><br />
self -- refers to the environment within which we are executing a code<br />
</syntaxhighlight></div>Novohttps://wiki.multitheftauto.com/index.php?title=OOP_in_Lua&diff=43984OOP in Lua2015-01-18T01:16:24Z<p>Novo: Created page with "{{Note_box|Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}} This is a scripting tutorial that teaches you how to start us..."</p>
<hr />
<div>{{Note_box|Any further questions can be discussed at the [http://google.com topic] dedicated to this tutorial.}}<br />
<br />
This is a scripting tutorial that teaches you how to start using an Object-Oriented developing interface with Lua.<br />
<br />
__TOC__<br />
== Introduction ==<br />
There are few basic predefined variables we should recognize and know:<br />
<syntaxhighlight lang="lua"><br />
self -- refers to the environment within which we are executing a code<br />
</syntaxhighlight></div>Novo