Modules

require "modules_example.flying"

function init(self)
        fly_randomly()
end

function on_message(self, message_id, message, sender)
        if message_id == hash("fly_randomly_done") then
                fly_randomly()
        end
end

-- 원래 위치를 저장해야함
local origin

-- 원본 위치에서 "radius" 거리만큼 랜덤한 위치로 날려보냄
-- 날려 보낸 후 "fly_randomly_done" 메세지를 되돌려 보냄
function fly_randomly(radius)
        -- radius 를 지정하지 않았으면 100으로 셋팅
        radius = radius or 100
        local go_id = go.get_id()
        -- 원래 위치 저장
        if origin == nil then
                origin = go.get_world_position(go_id)
        end

        -- 원래 위치에서 "radius" 까지의 최대 거리의 랜덤 위치 알아내기
        local rand_angle = math.random(0, 3.141592 * 2)
        local rand_radius = math.random(radius)
        local offset = vmath.rotate(vmath.quat_rotation_z(rand_angle),
                                    vmath.vector3(rand_radius, 0, 0))
        local rand_pos = origin + offset
        -- 너무 빠른 애니메이션을 방지하기 위해 radius에 대해 스케일된 랜덤 재생시간(duration)을 셋팅함
        local rand_duration = math.random(radius) / 100 + (radius / 200)
        -- 애니메이션 처리, 완료 후에 메세지를 돌려보냄
        go.animate(".", "position", go.PLAYBACK_ONCE_FORWARD,
                rand_pos, go.EASING_INOUTSINE, rand_duration, 0.0,
                function ()
                        msg.post("#", "fly_randomly_done")
                end)
end

require "modules_example.flying"

function init(self)
        -- 노란 나비는 더 넓은 비행 반경을 가짐
        fly_randomly(200)
end

function on_message(self, message_id, message, sender)
        if message_id == hash("fly_randomly_done") then
                fly_randomly(200)
        end
end

-- 원래 위치를 저장해야함
local origin

        -- "origin"을 동일한 컨텍스트에서 누가 이미 셋팅했다면 또 셋팅할 필요 없음
        if origin == nil then
                origin = go.get_world_position(go_id)
        end

local flying_origin

function flying_fly_randomly(radius)
        ...

-- "M" 테이블에 모듈을 포함시킴
local M = {}

-- 테이블을 원래 위치를 저장하도록 사용함
-- 모듈이 모든 게임 오브젝트의 공유된 Lua context의 일부분이 되므로 origin 변수를 직접적으로 저장할 수 없음, 하나 이상의 GO가 이 모듈을 사용하면 덮어 씌워짐
M.origins = {}

-- 원본 위치에서 "radius" 거리만큼 랜덤한 위치로 날려보냄
-- 날려 보낸 후 "fly_randomly_done" 메세지를 되돌려 보냄
function M.fly_randomly(radius)
        -- radius 를 지정하지 않았으면 100으로 셋팅
        radius = radius or 100
        -- 원래 위치를 인덱싱하는 현재 오브젝트의 id가 필요함
        -- "."을 사용할 수 없음
        local go_id = go.get_id()
        -- 저장된적이 없으면 현재 위치를 origins에 저장함
        if flying.origins[go_id] == nil then
                flying.origins[go_id] = go.get_world_position(go_id)
        end

        -- 원래 위치에서 "radius" 까지의 최대 거리의 랜덤 위치 알아내기
        local rand_angle = math.random(0, 3.141592 * 2)
        local rand_radius = math.random(radius)
        local offset = vmath.rotate(vmath.quat_rotation_z(rand_angle),
                                    vmath.vector3(rand_radius, 0, 0))
        local rand_pos = flying.origins[go_id] + offset
        -- 너무 빠른 애니메이션을 방지하기 위해 radius에 대해 스케일된 랜덤 재생시간(duration)을 셋팅함
        local rand_duration = math.random(radius) / 100 + (radius / 200)
        -- 애니메이션 처리, 완료 후에 메세지를 돌려보냄
        go.animate(".", "position", go.PLAYBACK_ONCE_FORWARD,
                rand_pos, go.EASING_INOUTSINE, rand_duration, 0.0,
                function ()
                        msg.post("#", "fly_randomly_done")
                end)
end

return M

flying = require "modules_example.flying"

function init(self)
        flying.fly_randomly()
end

function on_message(self, message_id, message, sender)
        if message_id == hash("fly_randomly_done") then
                flying.fly_randomly()
        end
end

flying = require "modules_example.flying"

banana = require "modules_example.flying"

function init(self)
        banana.fly_randomly()
end

function on_message(self, message_id, message, sender)
        if message_id == hash("fly_randomly_done") then
                banana.fly_randomly()
        end
end

--- 모듈 설명
-- @module foobar
local M = {}

--- bar 상수값 설명
-- @field BAR
local M.BAR = "bar"

local function private_function()
end

-- 모듈이 싱글턴이 아닌 상태(non-singleton)를 유지 해야 하는 경우, 현 상태의 "인스턴스"를 리턴하는 함수를 생성해야 함. 그 다음 이 인스턴스는 모듈 함수로 넘겨짐
-- @foobar의 인스턴스를 리턴
function M.create()
        local foobar = {
                foo = "foo"
        }
        return foobar
end

--- 이 함수에서는 뭔가 작업합니다...
-- @function do_something
-- @param foobar
-- @return foo
function M.do_something(foobar)
        return foobar.foo
end

--- 이 함수에서도 뭔가 작업합니다...
-- @function do_something_else
-- @param foobar
-- @return foobar
function M.do_something_else(foobar)
        return M.do_something(foobar) + M.BAR
end

return M

-- mymodule.lua
local M = {}

M.foo = function()
  print('이것은 public 모듈 함수이다.')
end

setmetatable(M, {
  __newindex = function(m, t)
    error('유저가 ' .. t .. ' 속성을 모듈에 추가하려고 시도했다!')
  end
})

return M

local M = {}

local function sum(a, b)
    return a + b
end

local function mult(a, b)
    local result = 0
    for i=1,b do
        result = sum(result, a)
    end
    return result
end

M.sum = sum
M.mult = mult

return M

local summult = require("summult")
summult.sum = function(a,b) return 1 end
print(summult.mult(5,2))

-- 새 인덱스로부터 테이블을 보호하기 위한 모듈. 일반적으로 global scope를 보호하는데 사용됨
-- https://gist.github.com/britzl/546d2a7e32a3d75bab45 에서 최신 버전 가져오기
-- @module superstrict
-- @usage
--
--  -- Defold 사용 예제
--  -- gameobject와 gui script의 라이프사이클 함수들을 허용함
--  -- 또한 데스크탑에서 더미 구현을 위해 facebook과 iap 모듈 할당을 허용함
--  -- whitelist가 패턴이 일치하는지를 다루고 이 예제에서 '__' 접두어가 있는 모든 함수 또한 전역 범위(global scope)에서 허용 됨
--  local superstrict = require("superstrict")
--  superstrict.lock(_G, { "go", "gui", "msg", "url", "sys", "render", "factory", "particlefx", "physics", "sound", "sprite", "image", "tilemap", "vmath", "matrix4", "vector3", "vector4", "quat", "hash", "hash_to_hex", "hashmd5", "pprint", "iap", "facebook", "push", "http", "json", "spine", "zlib", "init", "final", "update", "on_input", "on_message", "on_reload", "__*" })
--
--  -- 허용됨
--  __allowed = "abc"
--
--  -- 허용됨
--  facebook = dummy_fb
--
--  -- 허용됨
--  function init(self)
--  end
--
--  -- 에러 발생함
--  if foo == "bar" then
--  end
--
--  -- 에러 발생함
--  function global_function_meant_to_be_local()
--  end
--
local M = {}

-- 테이블과 whitelist 이름을 매핑함
local whitelisted_names = {}

-- 잠겨진 테이블에 허용되지 않는 액세스를 할 필요가 있으므로 누구도 에러 함수로 엉망으로 만들지 않도록 확인할 것
local _error = error


--- 테이블의 키가 whitelist에 있는지 없는지 체크
-- @param t whitelist 이름을 체크하려는 테이블
-- @param n 체크하려는 변수의 이름
-- @return true n이 t의 whitelist에 포함되어 있다면
local function is_whitelisted(t, n)
    for _,whitelisted_name in pairs(whitelisted_names[t] or {}) do
        if n:find(whitelisted_name) then
            return true
        end
    end
    return false
end

--- 보호된 새 인덱스
-- 지정된 이름이 whitelist 테이블에 있는지 체크함.
-- 없으면 에러 발생시킴
-- @param t 새 인덱스가 셋팅된 테이블
-- @param n 테이블에 셋팅된 변수 이름
-- @param v 셋팅된 값
local function lock_newindex(t, n, v)
    if is_whitelisted(t, n) then
        rawset(t, n, v)
        return
    end

    _error("테이블 [" .. tostring(t) .. "] 은 잠겼습니다. '" .. n .. "'에 값을 쓰려고 시도중입니다. 당신은 whitelist에 추가하거나 local로 '" .. n .. "' 을 선언해야 합니다.", 2)
end

--- 보호된 __index
-- 정의되지 않은 값을 읽으려 하면 에러 발생
-- @param t 새 인덱스가 셋팅된 테이블
-- @param n 테이블에 셋팅된 변수 이름
local function lock_index(t, n)
    if is_whitelisted(t, n) then
        return rawget(t, n)
    end

    _error("테이블 [" .. tostring(t) .. "] 은 잠겼습니다. 정의되지 않은 값 '" .. n .. "'을 읽으려 시도중입니다.", 2)
end

--- 테이블 잠그기. 테이블에 새 값(함수 및 변수)이 할당되는 것을 방지함
-- 일반적인 용도로는 global scope를 실수로 할당하지 못하게 lock(_G) 를 호출해 보호하는 것임
-- @param t 잠그려는 테이블
-- @param whitelist 테이블에 허용된 이름의 목록
function M.lock(t, whitelist)
    assert(t, "잠그려면 테이블을 넘겨야 함")
    whitelisted_names[t] = whitelist or {}
    local mt = getmetatable(t) or {}
    mt.__newindex = lock_newindex
    mt.__index = lock_index
    setmetatable(t, mt)
end

---
-- 테이블 언락하기
-- @param t 언락하려는 테이블
function M.unlock(t)
    assert(t, "언락하려면 테이블을 넘겨야 함")
    local mt = getmetatable(t) or {}
    mt.__newindex = rawset
    mt.__index = rawget
    setmetatable(t, mt)
end

return M

local M = {}

-- 모듈의 모든 사용자가 이 테이블을 공유함
local state = {}

function M.do_something(foobar)
    table.insert(state, foobar)
end

return M

local M = {}

local function private_function(self, bar)
    return self.public_variable .. bar
end

function M.public_function(self, bar)
    return private_function(self, bar)
end

function M.new(foo)
    local instance = {
        public_variable = foo
    }
    return instance
end

return M

local foobar = require(“foobar”)
local fb = foobar.new(“foo”)
print(fb.public_variable)
print(foobar.public_function(fb, “bar”))

local M = {}

local function private_function(self, bar)
    return self.public_variable .. bar
end

function M:public_function(bar)
    return private_function(self, bar)
end

function M.new(foo)
    local instance = {
        public_variable = foo
    }
    return setmetatable(instance, { __index = M })
end

return M

local foobar = require(“foobar”)
local fb = foobar.new(“foo”)
print(fb.public_variable)
print(fb:public_function(“bar”))

local M = {}

function M.new(foo)
    local instance = {
        public_variable = foo
    }

    local private_variable = ""

    local private_function = function(bar)
        return instance.public_variable .. private_variable .. bar
    end

    instance.public_function = function(bar)
        return private_function(bar)
    end

    return instance
end

return M

local foobar = require(“foobar”)
local fb = foobar.new(“foo”)
print(fb.public_variable)
print(fb.public_function(“bar”))