The actual engine is written in C, but the development environment is all in Lua. I came into Lua cold in November (from C++ and java) and estimate it took me five weeks or so to grok Lua and maybe another couple of months to have the paradigms for the Tome Engine mostly down. The T-Engine implementation of Lua treats it like an object oriented language, with inheritance and so on. The two fundamental first-class composite types that you need to mess with are functions and tables (tables consist of an array-like indexable section plus a hash table spliced together). Everything is effectively passed by value, but 'table and function variables are references' (as Lua folk seem to like saying). The variable actually behaves as if it contained a pointer, but treated it as a value, so that if you pass a table/function/table-but-pretending-its-an-object to a function it will modify the original, but if you re-assign it won't overwrite the original. That is to say:
Code:
local x = 0 - primitives are passed by value
local foo = {bar = "baz"} -- make a hash table with key["bar"] containing value "baz", this will be passed 'by value' but the 'value' is actually a pointer (ish)
function wipeFoo(x, foo)
x = 1
foo.bar = 10
foo = {}
end
wipeFoo(x, foo)
print(x) -- spits out 0, the local x from the function is out of scope now
print(foo.bar) -- spits out 10, because the function modified a value inside the table.
-- The locally-assigned empty table from the function is out of scope, but the original table wasn't overwritten by foo = {}
-- instead, a new empty table was instantiated, and its pointer was assigned to the local variable foo inside the function
-- leaving the original table alone (and effectively out of scope of the function at that point)
Login
Register
FAQ
Search
