@jwalker: Wow, didn't know that! I'll do some research about that. Is that function available in apilevel 1 and 2? That would be a nice option to kinda use the file system!

Here is an example : http://ourl.ca/10565/242834

Q1: This is more of a confirmation. Does self refers to the classname itself? So self.x would refer to Coyote.x in this case? Likewise for the others?

The real meaning of "self" is the first argument passed to the function. When using ":" instead of "." (i.e : foo:bar() ) the object (here "foo") is passed as frst parameter :
foo:bar() === foo.bar(foo)
Thus, it refers to the instance of the object using that function, but it can be used for other purposes, such as using a "static" method of the class (I may be unclear on that ... sorry) :
Foo = class()
function Foo:init()
  self.i = 69
end
function Foo:bar(i)
  print(i, self.i)
  self.i = i
end
foo = Foo()
foo:bar(42) -- calls Foo.bar(foo, 42) ; prints 42 69
foo:bar(42) -- prints 42 42
print(Foo.i)  -- nil
Foo:bar(42) -- calls Foo.bar(Foo, 42) ; prints 42 nil
print(Foo.i) -- prints 42

Q2: What does . refer to? From what I gather it would mean it would add it to a list/table so that if Coyote was called up, you'd get Coyote == {"x"==x, "y"==y, "tiles"=={} etc...}. Is this right?

Basic : classes in Lua are reprensented as tables.
"." let you access to one element (defined of not) of a table. In Lua tables are associatives using all sort of hash key (you can use functions or tables as hash key). In general you access an element using its key with [ and ] such as :
t = {foo=bar1, ["foo with spaces"]=bar2}
t["foo"] -- bar1
t["foo with spaces"] -- bar2
t.foo -- bar1As you can see, since "foo" is a valid identifier, it can be used with the "." convention.

There are multiple ways to add an element in the table, and it depends if you're seeing the table as a contiguous array (such as in C) or associatives ones.
It depends when you're using #t or ipairs/pairs(t). For example IIRC you cannot use #t or table.getn(t) on tables you filled with . or [] although you can iterate through using ipairs/pairs.

So, as you may understood, this :
t = {}
t.x = 1
t.y = 2

t.x = t.x + 2

for k, v in pairs(t) do
  print(k, v) -- will print x 3 \n y 2
end
adds to t two elements, modify one and prints keys and values of each rows.

Q3: How does or affect the variable assigning? in self.controls = options.controls or {up = "up", down = "down", left = "left", right = "right"}, does that mean self.controls becomes both possible values? This is one I'm stumped on

"or" and "and" are used as shortcut to if statements.
The equivalent or the line you quoted is :
if not options.controls then
  self.controls = {up = "up",
                        down = "down",
                        left = "left",
                        right = "right"}
else
  self.controls = options.controls
end

Another example :

a = 1
b = nil
c = 3

d = c and a or b -- d = 1
d = a and b or c -- d = 3
d = b and a or c -- d = 3



Q4: Also another one, I've never been very confident in what return means (even though I've encountered it in several languages such as JavaScript. I've known it to return a value if it refers to a variable but it seems that elsewhere in the code it can represent some other things too? Clarification?

The main difference between return in Lua and return in Javascript is that in Lua's return, you can return multiple values (known as "tuple")
x, y = 42, 69
function getCoords()
  return x, y
end

function setCoords(xx, yy)
  x, y = xx + 1, yy + 1
end

x, y = getCoords()
print(getCoords())  -- prints 42 and 69
setCoords(getCoords())
print(getCoords())  -- prints 43 and 70



Q5: Generally I don't understand classes enough, I don't think I finished reading through the inspired lua tutorial though. Might go back and read it

Classes in Lua are based on metatables that can be a nightmare if you don't understand their concept. Maybe you can read for that.
If you still don't understand metatable (I was not able to understand them at the beginning, but understood classes) think of classes in other languages.
The main difference is that you don't have virtual method walkthrough since when you inherit from another class all the references are copied and the one you override overrides the references in the metatable losing the reference to the parent class. The only way to use a parent class is either by modifying the class() function, or by knowning the name of the parent class and using Parent.method(child, args) bootstraping the ":" notation.

Yes, I only used the gtk to extract boot2.img to boot2.raw but apparently that doesn't work anymore with 3.x
The recommended tool of TI-Planet "imgmanip" I can't use because I don't know how to C++ 

You can also use polydumper in order to dump the boot2.raw from the calc.

There's a libndls function to refresh the document screen called refresh_osscr()

Also notice that this function is time critical if the user has a lot of documents.
In other words, it is as slow as doing Home+2

in case you replace the file and the download link gives a 404 on TI-Planet.

I don't understand your remark ?
You can update the archive details such as reupload the file on TI-Planet ... where is the problem ?

In case you didn't know, Grammer is not a compiled language

Where have I said that ?

Granted, Grammer uses tokens rather than individual characters for its commands

It's exactly what I said.

Else it's like if in a math class you asked help to the teacher and he started yelling at you (he would lose his job fast) about how retarded you are for not being able to solve the problem yourself. Plus it might make some people label you as a troll.

I am a bit concerned about what you said here... because it is exactly how I was thaught either maths or programming.
Okay, it was not "yelling", but kinda the same using french tournures. So maybe it's only a French aspect, or maybe it's only a matter of environnement where I live... but the fact is that it's a really motivating way to learn by yourself : Hard but Sucessful (see Adriweb comment).

As for what I sae in the comment I quoted, it seemed like you were trying to make Matrefeytontias feel or look stupid in front of other people. The way it was worded (or Google-translated?) and punctuated implied it at least. To avoid it in the future, you should probably say "Like nSDL?" Instead of "Like.. nSDL?", but also only ask it once instead of twice (just reply to both quotes at once).

As I said, it's maybe a language barrier, but I can't see any harmful part. The "..." are indeed here to mark a pause like "Are you kidding me ?", but not a "you are stupid ...".

May we close this debate then ?