LÖVE

ivan wrote:That would be the fastest way to evoke functions, but clunky and slower to allocate (looks a little bit like mixins). In short, have to manually move data around when you don't use metatables.

local function Guy (name)
    return {
        name = name,
        say = say,
    }
end

local function Dog (t)
    t = t or {}
    t.name = t.name or "a dog"
    t.say = bark
    
    return t
end

local function Guard (t) t.patrol = patrol; return t end
local function Guide (t) t.lead = lead; return t end

local function GuardDog (t) return Guard(Dog(t)) end
local function GuideDog (t) return Guide(Dog(t)) end
local function GuardGuy (t) return Guard(Guy(t)) end
local function GuideGuy (t) return Guide(Guy(t)) end

Positive07 wrote:As airstruck and I previously said, if you do MANY simple assignments then metatable is better, but if you need a few (should benchmark) then what you lost by assignment you gain it by the fact than indexing a metatable is slower.

ivan wrote:Don't forget that without metatables you are basically making a copy/reference of every function so the memory usage would be higher too.

• Check how much time it takes to create the functions, done once, around 10 functions should be pretty similar to a real use case
• Check how much time it takes to allocate N objects where N is at least 300
• Check how much time it takes to call all methods, in a loop M times, where M is at least 1000
• Check how much memory each method consumes

Sorry for the topic hijack, noway!

These are not mistakes, but it just looks like you're coming from a language other than Lua:

you really want to make sure your tutorial code is so simple
that everybody reading it will say "yes, this is clearly the easiest way to make breakout".
That's why I recommend avoiding OOP altogether.

Note that setfenv is not commonly used (at least I don't see it that often)
except for peculiar things like loading Lua code from untrusted locations.
I understand it can be used to make modules too...
IMO it's just not necessary to use 'setfenv' in this case.

Code: Select all

local Gamestate = require "gamestate"
menu = {} -- you can safely delete this
game = {} -- and this line
local menu = require "menu"
local game = require "game"

Or better yet:

Code: Select all

function Ball:draw()
   love.graphics.circle( 'line', self.position.x, self.position.y, self.radius, 16)
end

These are not mistakes, but it just looks like you're coming from a language other than Lua:

Code: Select all

function Ball:draw()
   local segments_in_circle = 16
   love.graphics.circle( 'line', self.position.x, self.position.y, self.radius, segments_in_circle )
end

Can become:

Code: Select all

local segments_in_circle = 16
function Ball:draw()
   love.graphics.circle( 'line', self.position.x, self.position.y, self.radius, segments_in_circle)
end

If you decide to stick with Vrld's libraries (which are very good) then...

Code: Select all

vector( platform_starting_x_pos + o.separation_from_platform_center.x,
          platform_starting_y_pos + o.separation_from_platform_c

enter.y )

...you might as well go crazy with the vector operators:

Code: Select all

local platform_starting_pos = vector(500, 500)
....
o.position = o.position or (platform_starting_pos + o.separation_from_platform_center)

noway wrote:I've picked it from Programming in Lua ( 3rd ed. , sec. 15.3; relevant excerpt )
In short, this allows to avoid declaring all functions local, or prefixing them with the module name (in the case of classes, the latter is unavoidable though) .

noway wrote:If this is for perfomance/memory reasons, I would prefer to avoid such optimization tweaks, and leave them
to more advanced tutorial.

love.graphics.circle( 'line', self.position.x, self.position.y, self.radius, 16) -- where 16 is the number of vertices in the circle

It first appears in the part 16. I'm surprised, that someone got this far

I understand, all I'm saying is that setfenv/_ENV is not the 'typical' way that most Lua modules are written. The majority of the lib/modules you'll find in the wild are composed of a table with some functions. Take a look the HC code, for example. The Lua manual changes and seems to be more about exploring different techniques. So there is certainly a discrepancy between common practice and the examples from the manual.

The majority of the lib/modules you'll find in the wild are composed of a table with some functions.