LÖVE

Code: Select all

brickTable = {}
brick = {
	xBrick = 200,
	yBrick = 200,
	imgBrick = love.graphics.newImage("brick.png"),
	draw = doDraw(imgBrick, xBrick, yBrick)
}

brickTable[1] = brick

for i, v in ipairs(brickTable) do
brickTable[i].doDraw()
end

Code: Select all

someTable = {}
someTable.value = 3
function someTable:someFunction() --this is the same as someTable.someFunction(self) (difference is : )
    self.value = 20
end
someTable:someFunction()
--someTable.value is now 20, without the function ever knowing it's name, so if it was located in another table it would've set the variable in that table.

Code: Select all

bricks = {}

function bricks:new( x, y, image )
      local brickImage = love.graphics.newImage( imgage )
      local newBrick = { image = brickImage, x = x, y = y }
      table.insert( bricks, newBrick )
end

function bricks:draw()
     table.foreach (bricks , drawBricks)
end

local function drawBricks( _index )
     love.graphics.draw( bricks[_index].image, bricks[_index].x, bricks[_index].y )
end

Code: Select all

function load()
     -- Add a brick with
     bricks:new( 200, 200, "brick.png")
end


function draw()
     -- Draw all bricks in the draw function
     bricks:draw()
end

Code: Select all

--MIT licensed to me (didn't want to fill up this space with the license)
local class_mt = {}

function class_mt:__index(key)
	return self.__baseclass[key]
end     

class = setmetatable({}, class_mt)

function class:new(...)
	local c = {}
	c.__baseclass = self
	setmetatable(c, getmetatable(self))
	if c.init then
		c:init(...)
	end
	return c
end

Code: Select all

love.filesystem.require("class.lua") --or whatever you do to load it
myclass = class:new()
myclass.value = 13
function myclass:setvalue(v)
    self.value = v
end
object = myclass:new()
object:setvalue(128)
--myclass.value is still 13 and object.value is now 128
anotherObject = object:new()
--anotherObject.value is 128

Code: Select all

function class(base,ctor)
    local c = {}     -- a new class instance
    if not ctor and type(base) == 'function' then
        ctor = base
        base = nil
    elseif type(base) == 'table' then
        -- our new class is a shallow copy of the base class!
        for i,v in pairs(base) do
            c[i] = v
        end
    end
    -- the class will be the metatable for all its objects,
    -- and they will look up their methods in it.
    c.__index = c

    -- expose a ctor which can be called by <classname>(<args>)
    local mt = {}
    mt.__call = function(class_tbl,...)
        local obj = {}
        setmetatable(obj,c)
        if ctor then
            ctor(obj,...)
        else 
            -- make sure that any stuff from the base class is initialized!
            if base and base.init then
                base.init(obj,...)
            end
        end
        return obj
    end
    c.init = ctor
    setmetatable(c,mt)
    return c
end

Code: Select all

Button = {}
Button.__index = Button

function Button.new(name, text, width, height, x, y, bgcolor, fgcolor, hcolor, func)
   local bn = {}
   setmetatable(bn, Button)

   bn.name = name
   bn.text = text
   bn.width = width
   bn.height = height
   bn.x = x + (height / 2)
   bn.y = y + (width / 2)
   bn.bgcolor = bgcolor
   bn.fgcolor = fgcolor
   bn.hcolor = hcolor
   bn.func = func
   bn.hover = false
   bn.top = y
   bn.left = x
   bn.visible = true

   return bn
end

function Button:draw()
--reference members here with 'self'
end

Code: Select all

bnvar = button.new(args)
bnvar:draw()