LÖVE

Code: Select all

local a,b,c = 1,2,3 -- a,b,c are local
local a = 1 b = 2 c = 3 -- a is local, b and c are global

Code: Select all

local a = 1
b = 2
c = 3

Code: Select all

do -- wrapCall
	
local function wrapCallGraphics(name1, name2)
  local func = love[name1][name2]
  love[name1][name2] = function (...)
    -- your code !!!
    return func(...)
  end
end

-- examples
wrapCallGraphics("graphics", "draw");
wrapCallGraphics("graphics", "drawq");
wrapCallGraphics("graphics", "print1");
wrapCallGraphics("graphics", "printf1");
wrapCallGraphics("graphics", "rectangle");
wrapCallGraphics("graphics", "arc");
wrapCallGraphics("graphics", "circle");
wrapCallGraphics("graphics", "point");
wrapCallGraphics("graphics", "polygon");
wrapCallGraphics("graphics", "triangle");
wrapCallGraphics("graphics", "line");
wrapCallGraphics("graphics", "quad");

end

Code: Select all

function love.load()
  -- (arg[1] = path to main.lua) 
  -- game.love - the game name 
  path = string.gsub(arg[1], "game.love", "")           -- (game run in *.love file)
  path = arg[1]            		                 -- (game run not in *.love file)
end

Code: Select all

-- In this style, assume that we're loading modules that return a table of functions,
-- and we will put them in the global state rather than locally to every where they're needed.
-- Because of dependencies, ordering is important and we can't use a regular table.
-- Each subtable is { global name, module filename }
game_libraries = {
  { "Graphics", "lib.graphics" },
  { "Audio", "lib.audio" },
  { "Sprite", "lib.sprite" },
  { "Game", "lib.game" },
}

function load_libraries()
  for _, v in ipairs(game_libraries) do
    local global = v[1]
    package.loaded[global] = nil
    _G[global] = nil
  end
  garbagecollect("collect") -- give all finalizers a chance to run
  for _, v in ipairs(game_libraries) do
    local global, filename = v[1], v[2]
    _G[global] = require(filename)
  end
end

function love.load()
  load_libraries()
  Graphics.init()
  Audio.init()
  Game.init()
end

Code: Select all

print(arg[1]) -- "/tmp/game.love/game.love"
print(path) -- "/tmp//"
print(arg[1]) -- "/tmp/somegame.love/game.love"
print(path) -- "/tmp/some/"
print(arg[1]) -- "/tmp/gameXlove/game.love"
print(path) -- "/tmp//"
print(arg[1]) -- "/tmp/other.love" --hey, our user can rename a .love!
print(path) -- "/tmp/other.love"
print(arg[1]) -- "/tmp/game.lovegame.love"
print(path) -- "/tmp/"

Code: Select all

path = arg[1]:match('.+[/\\]')

Code: Select all

return function(timestep,maxBuffer)
	local stepBuffer = 0
	timestep  = timestep or 1/60 -- 60 updates per second
	maxBuffer = maxBuffer or 1/10
	assert(maxBuffer >= timestep, 'Max time step must be greater than or equal to desired time step')
	return function(dt,func)
		stepBuffer = stepBuffer + dt
		stepBuffer = stepBuffer > maxBuffer and maxBuffer or stepBuffer
		
		while stepBuffer >= timestep do
			stepBuffer = stepBuffer-timestep
			func(timestep)
		end
	end
end

Code: Select all

-- LOVE only
local lfs = love.filesystem

local requireAll = function(dir,moduleTable)
	moduleTable     = moduleTable or {}
	local filelist  = lfs.enumerate(dir)
	for i = 1,#filelist do
		local filepath = dir .. '/' .. filelist[i]
		if lfs.isFile(filepath) then
			local moduleName = filepath:match'(%a+)%.lua$'
			if moduleName then
				moduleTable[moduleName] = require(dir .. '/' .. moduleName)
			end
		elseif lfs.isDirectory(filepath) then
			local folder        = filelist[i]
			moduleTable[folder] = {}
			requireAll(filepath,moduleTable)
		end
	end
	return moduleTable
end

return requireAll

Code: Select all

require(dir .. '/' .. moduleName)

Code: Select all

require(dir .. '.' .. moduleName)

Code: Select all

require 'require'

local foo = require 'foo' -- require works as before

local bar = require.tree('bar') -- if bar is a folder, require everything inside bar, recursively (bar/one.lua becomes bar.one, and so on)
local baz = require.relative(..., 'baz') -- baz.lua is 'in the same folder' as the current file. The ... param is mandatory.