블로그 이미지
개발자로서 현장에서 일하면서 새로 접하는 기술들이나 알게된 정보 등을 정리하기 위한 블로그입니다. 운 좋게 미국에서 큰 회사들의 프로젝트에서 컬설턴트로 일하고 있어서 새로운 기술들을 접할 기회가 많이 있습니다. 미국의 IT 프로젝트에서 사용되는 툴들에 대해 많은 분들과 정보를 공유하고 싶습니다.
솔웅

최근에 받은 트랙백

글 보관함

calendar

    1 2 3 4 5
6 7 8 9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31    


Posted on . Written by

 

Building on What’s There

 

이제 여러분의 함수가 API 에 있게 됐고 동작도 잘 되고 있습니다. 이제 코딩을 하면서 그 함수를 call 할 수 있는데요, API 의 새로운 기능을 알게 되는 건 기쁜 일이죠.

이제 기존에 string 라이브러리 함수들 중에 약간 문제 있는 것을 한번 살펴 볼까요. gsub() 함수는 개발자에게 쌈박한 기능을 제공하죠. documentation 페이지를 한번 보세요. 아마 이 함수는 기본적으로 search and replace 기능을 제공하는 함수라는 것을 아실 수 있으실 겁니다.

 

local str = "Hello banana"
print( string.gsub( str, "banana", "Corona user" ) )
--Outputs: Hello Corona user

 

이 함수의 한계는 key/value 를 테이블에 담아서 사용하게끔 기능을 제공하지는 않습니다. 아래처럼 말이죠.

local searchreplace = {
   Hello = "Success",
   banana = "Corona user"
}

 

이 기능을 가능하도록 하려면 테이블 내의 entry들에 대해 iterate 하기 위해 루프롤 돌려야 합니다. 그리고 각 entry 마다 gsub() 함수를 부르면 되죠.

local str = "Hello banana"
for k,v in pairs( searchreplace ) do
   str = string.gsub( str, k, v )
end

print( str )
--Outputs: Success Corona user

pairs() 함수는 searchreplace table에 있는 각각의 인덱스들을 identify 하고 그 이름과 값을 return 하는 함수입니다. Lua table 을 사전처럼 다룰 때 아주 유용하게 사용할 수 있겠죠. 루프 안의 내용들은 생각하지 마시고 이제 string replacement 를 어느곳에서나 사용할 수 있는 훌륭한 함수를 하나 만드신 것만 생각하세요.


이제 함수 안에 루프를 넣어 볼까요.

local function gsubEx( str, searchreplace )
   for k,v in pairs( searchreplace ) do
      str = string.gsub( str, k, v )
   end
   return str
end

이 함수는 string-replaceing 루프를 어느곳에서나 재사용할 수 있도록 해 줍니다.

gsubEx( str, searchreplace )
--Outputs: Success Corona user

아주 쉽죠?

 

Improving What’s There


이제 이것들을 다 같이 함치고 gsub() 함수에 override 해 보죠. 우선 gsub() 함수를 변수에 넣어야 합니다. 아까 보았듯이 Lua 에서는 아래와 같이 함수를 변수에 넣는 것을 지원해 주죠.

local gsub = string.gsub

이렇게 하면 이제 gsub 변수를 사용해서 gsub() 함수를 call 할 수 있게 된 거죠. 이제 함수를 저장했으니 우리가 만든 함수를 이 변수에 replace 해서 gsub 함수를 overwrite 하기만 하면 됩니다. 이 방법은 이미 다뤘었죠. 실제 gsub() 함수가 사용하는 같은 함수 파라미터들을 사용할 겁니다.

string.gsub = function( s, pattern, repl, n )
end


이 단 두 줄로 우리가 한 것은 gsub() 함수의 copy 를 가지게 된 것이구요 그리고 우리가 만든 함수로 이것을 replace 시킨 겁니다. 이제 여기에 마음대로 로직을 넣을 수 있습니다. 아래 로직으로 패턴 파라미터가 string 일 때와 table 일 때를 체크하게 됩니다.

if ( type(pattern) == "string" ) then
   --do something
else
   --do something else
end

string.gsub() documentation을 잠깐 보시면 이 패턴 파라미터가 항상 string 인 것만 보실 수 있을 겁니다.

패턴 파라미터가 string 이면 original 함수를 call 하면 됩니다.


if ( type( pattern ) == "string" ) then
   return gsub( s, pattern, repl, n )  --call the original function and return whatever it returns
else
   --do something else
end

패턴 파라미터가 string 이 아니면 즉 table 이라서 key/value 의 쌍을 이루는 값들이라면 아래와 같이 간단한 루프를 돌립니다. 이 루프는 else 구문 안에 만들어야 겠죠.

else
   --do something else (loop over the keys and replace them in the input string 's')
   for k,v in pairs( pattern ) do
      s = gsub( s, k, v )
   end
   return s
end

우리의 new parameter 이름과 패턴을 사용하기 위해 루프를 살짝 바꿔줬습니다.

 

 


Putting it Together

이제 이것들을 모두 다 합쳐 보죠. 우리가 override 한것과 new gsub() 함수는 아래와 같습니다.

local gsub = string.gsub
string.gsub = function( s, pattern, repl, n )

   if ( type(pattern) == "string" ) then
      return gsub( s, pattern, repl, n )
   else
      for k,v in pairs( pattern ) do
         s = string.gsub( s, k, v )
      end
      return s
   end
end

이 코드의 결과는 string.gsub() 함수가 우리가 만든 로직으로 replace 되게된 겁니다. 우리가 만든 로직은 파라미터가 일반적인 거면 original 함수를 call 하고 테이블이면 우리가 만든 로직을 사용하는 거죠. 짠! 이제 우리는 코로나에 우리만의 라이브러리를 추가했습니다.

print( string.gsub( "Hello banana", { Hello="Success", banana="Corona user" } )
--Outputs: Success Corona user

이렇게 하면 코로나에서 제공되는 어떤 API 라이브러리에도 여러분이 원하는 기능을 추가하실 수 있습니다.

 

Warning!

아마 이것 저것 하고 싶은 것들이 많이 떠오르시죠? 새로운 기능을 추가하실 때는 아래 내용들을 유념하세요.

 original 함수 변수에 저장하는 것을 잊지 마세요.
 함수 내에서 그 함수를 call 하지 마세요. 그러면 무한 루프에 빠지게 됩니다.
 여러분이 만든 함수 내에서 original 함수를 call 하는 조건을 반드시 넣어 주세요.

이건 약간 advanced topic 입니다. 그러니 여러번 직접 해 보시고 이 사용법이 익숙해 지도록 하세요. 직접 production-ready 코드에 넣어서 사용하는 것은 위험합니다. 충분히 테스트 하고 완전 숙지 한 다음에 사용하세요. 여기에는 많은 smoke 와 mirror들이 있습니다. 잘 못 하면 쉽게 좋은 기능을 잃어버릴 수 있습니다.

 


Examples

여기 여러분들이 흥미로워 하실 만한 유용한 내용들 몇개 소개해 드립니다.

1. “math” library — adding a function to calculate length:

--returns the distance between points a and b
math.lengthOf = function( a, b )
   local width, height = b.x-a.x, b.y-a.y
   return ( width*width + height*height ) ^ 0.5  --math.sqrt( width*width + height*height )
end

 

2. “math” library — adding a function to clamp values:

--returns a value clamped between a range
math.clamp = function( val, low, high )
   if ( val < low ) then return low end
   if ( val > high ) then return high end
   return val
end

 

3. print() function — overriding print() to not print when running on a device:

--override print() function to improve performance when running on device
if ( system.getInfo("environment") == "device" ) then
   print = function() end
end

 

4. “math” library — adding a function to calculate nearest multiples:

--rounds up to the nearest multiple
math.nearest = function( number, multiple )
   return math.round( (number / multiple) ) * multiple
end

 

References

    Variable number of arguments: http://www.lua.org/pil/5.2.html
    Lua closures: http://www.lua.org/pil/6.1.html
    First class values: http://www.lua.org/manual/5.2/manual.html
    Functions: http://www.lua.org/pil/6.html
    String trim() function: http://lua-users.org/wiki/StringTrim
    String recipes: http://lua-users.org/wiki/StringRecipes
    Author’s blog: http://springboardpillow.blogspot.co.uk/2012/04/sample-code.html 

저작자 표시 비영리 동일 조건 변경 허락
신고


Posted on . Written by




오늘의 guest tutorial 은 Matt Webster 가 제공해 드립니다. Corona SDK 로 모바일 앱을 개발하는 개발자가 되고 싶어하는 친구 입니다. 그는 여러해 동안 닷넷 기반의 웹사이트 프로젝트에 참여했었고 현재는 런던에서 모바일 앱 관련된 웹 서비스를 manage 하고 있습니다. 그는 physics 에 대해 관심이 많고 관련 글들 과 code sample 들을 Corona Code Share 에 올려 공유했었습니다. 그리고 그의 블로그 blog 에도 공유를  하고 있구요. 여기로 가시면 Matt 의 트위터here에 follow 하실 수 있습니다.

Corona SDK 는 간단하고 강력하면서 아주 많은 유용한 API 들이 있습니다. 여러분들이 바라는 특별한 그 무엇이 있기도 하지요. 이 튜토리얼에서는 아래와 같은 것들이 다뤄 질 겁니다.

    1. 기존의 라이브러리에 새로운 기능 추가하기
    2. 기존의 기능을 확장하기

   


Corona API Libraries

Corona SDK 의 주요 기능들은 API 라이브러리를 통해서 제공됩니다. 아래 링크로 가시면 관련 문서를 보실 수 있습니다.

http://docs.coronalabs.com/api/index.html

string 라이브러리를 보면 다음과 같은 기능들을 보실 수 있습니다.

    string.byte()
    string.char()
    string.find()
    string.format()
    etc…


이 기능들은 Lua 에 있지는 않습니다. Objective-C (iOS) 나 Java (Android)에 있는 기본적인 기능들을 hooks 한 거지요.  math, graphics 나 다른 라이브러리들도 마찬가지 입니다.

어떤 라이브러리들은 완전히 Lua 만을 사용하기도 하죠. 예를 들어 코로나의 widget 라이브러리를 들 수 있습니다. Corona Labs는 original source code 도 가능하도록 기능을 제공합니다. Lua 의 룰에 따르기만 하면 개발자들이 그들만의 코드를 implement 할 수 있습니다. 사실  string  라이브러리를 포함한 모든 라이브러리는 Lua 테이블 입니다. (String 은 테이블입니다. 그리고 각 기능들은 그 테이블의 멤버들이죠.)

그렇기 때문에 쉽게 어떤 필요한 것들을 할 수가 있는 겁니다.


A Useful Custom Function


첫번째로 우리가 배울 것은 어떻게 우리가 만든 기능들을 코로나의 APO 라이브러리에 추가하느냐 입니다. 왜 이게 필요할까요? 예를 들어 string으로부터 space를 없애는 아주 유용한 기능을 가지고 있다고 합시다. 대부분의 프로그래밍 언어에서는 이를 위해 trim() 를 사용합니다.



local function trim( str )
   return ( str:gsub("^%s*(.-)%s*$", "%1") )
end



이 함수 내의 내용에 대해 아실려고 할 필요는 없습니다. 그냥 여러분이 이걸 만들었다고 생각합시다. 아주 훌륭한 코드 입니다. 그리고 시작과 끝에 필요없는 space들을 가지고 있는 string에서 그 space들을 없애는 일을 아주 훌륭히 해 냅니다.



print( trim( " Hello World! " ) )
--Outputs: Hello World!



코로나 개발자들이 흔히 자주 하는 일들 중 하나인데요.  이 trim() 함수를 custom Lua module 에 넣는 일이죠. utils.lua 같이요. 그 방법도 괜찮습니다. 그런데 더 기억하기 쉽고 category 에 맞게 이 일을 진행할 수 있습니다. 이 함수는 string 함수입니다. 이 함수를 built in string 함수처럼 접근하도록 하면 어떨까요?


Adding to Corona’s APIs

이 custom trim() 함수가 utils.lua 파일에 들어 있다고 합시다. 모든 동작이 이 파일 안에서 이뤄지기를 원합니다.  이를 위해 utils.lua는 standard require() call 이 사용되는 메모리 안에 있어야 합니다.

require("utils")

utils.lua 에 있는 함수는 아래와 같을 겁니다.



local function trim( str )
   return ( str:gsub("^%s*(.-)%s*$", "%1") )
end



이제 이 함수를 코로나의 string library 에 추가해 봅시다. 그냥 standard table value assignment 를 따르기만 하면 됩니다.


string.trim = trim



이게 다 입니다. 이제 여러분 코드 어디에서든지 이 함수를 call 하시면 됩니다.



string.trim(" Hello World! ")
--Outputs: Hello World!




The Beauty of Libraries



아래와 같이 스트링을 정의했습니다.



local str = " Hello World! "



string 라이브러리에 trim() 함수를 갖고 있을 때의 이점은 이제 우리는 이 함수를 어떤 스트링의 멤버로서 call 할 수 있다는 겁니다.



print( str:trim() )
--Outputs: Hello World!




스트링 라이브러리가 일반적으로 스트링 변수를 다루는 방법이죠.


Lua 101 (Sort of)



Note: Skip to the end of this tutorial for links to some more advanced topics in the Lua language.

Programming in Lua  웹사이트의 Section 6에서는 함수를 “first-class values with proper lexical scoping.” 로 묘사하고 있습니다. 도대체 이게 무슨 소리인지 더 궁금해 질 것 같군요.


간단히 말하면 Lua 에서 함수를 정의할 때 변수처럼 그 이름을 pass 하실 수 있습니다. 여러분들은 함수에 argument로서 이것을 pass 할 수도 있죠. 혹은 나중에 사용하기 위해 변수에 저장할 수도 있구요. 이런 작업은 아마 수도 없이 해 보셨을 겁니다.

어떤 value 로서 함수를 pass 하는 일반적인 instance는 timer.performWithDelay() 함수와 같이 쓰는 방법입니다.



local function HelloWorld()
   print( "Hello!" )
end

timer.performWithDelay( 1000, HelloWorld, 10 )




이 코드는 10번 Hello를 print 하는데 1초에 한번씩 print 할 겁니다. 그 과정을 풀어서 쓴다면.

    1. low-level timer 함수는 1000 밀리세컨드(1초)를 기다립니다.
    2. 이 timer 함수는 HellowWorld() 함수를 call 합니다.
    3. 이 timer 함수는 count 10 에서 1을 뺍니다. 그리고 다시 처음부터 시작합니다.

   


   
Storing Functions in Variables



다른 함수에 파라미터로서 함수를 pass 할 수 있는 것처럼 우리는 함수를 변수 안에 저장할 수도 있습니다. 이렇게 되면 변수를 그 함수처럼 사용하게 되는 거죠.



local helloFunc = HelloWorld
helloFunc()



위의 코드는

    1. helloFunc 라는 변수를 선언한다.
    2. HelloWorld() 함수를 helloFunc 변수의 값으로 할당한다.
    3.  함수처럼 해당 변수를 call 한다.

이런 과정을 거쳐 아래와 같은 글자를 프린트 할 겁니다.

Hello!



Using Functions as First Class Values



이제 우리는 아래 방법들을 알았습니다.

   -  코로나 API 에 함수 추가하기
   -  변수에 함수 저장하기
   -  parameter처럼 함수 pass 하기

코로나의 기능을 더욱 확장하기 위해 이 세가지의 Lua 기능들을 사용할 겁니다.

저작자 표시 비영리 동일 조건 변경 허락
신고


오랜만에 코로나 튜토리얼을 번역해 봅니다.

거르지 않고 꼬박꼬박 해 오다가 이번 TDD 프로젝트에 참여하면서 두달넘게 공부를 하지 못했네요.

오랫동안 모바일 앱을 만들지 못했는데... 이제 모바일 앱 하나 만들고 싶습니다.

 

----------------------------------------------------

 

Posted on . Written by

 

지난주의 "Goodbye Globals!" 튜토리얼에 이어서 오늘은 non-global 메소드 안에서 scene들 사이에서 오디오 파일들을 어떻게 관리할지에 대해 얘기 나누도록 하겠습니다. 대부분의 앱에서 특정 오디오 파일들은 전체 앱내에서 필요로 하는 경우들이 많습니다. 그리고 어떤 오디오 파일은 특정 scene 에서만 필요로 하는 경우도 있구요. 특정 scene에서 오디오 파일이 로드 돼서 다른 scene 에서도 overlap 되는 상황도 필요할 때가 있습니다. 이런 경우 scene 내의 객체들을 cleanup 하는 것과 별도로 오디오 파일을 관리해야 해서 좀 복잡하게 됩니다.

 

이런 경우 어떻게 관리 해야 할까요? main.lua 에서 common sound를 로드하고 그 사운드들에 global 로 처리하도록 할 겁니다. 그러면 어떤 scene 에서도 해당 사운드를 플레이 할 수 있죠. 그런데 왠만하면 이 global 한 객체들을 사용하지 않는게 좋습니다. 그리고 실제로는 글로벌이 아니면서 여러분만의 global space를 생성하는 방법을 알려 드린 지난주 튜토리얼을 이런 경우에도 활용할 수 있습니다.

 

 

 

Creating the “sfx.lua” Module

 

첫번째로 할 일은 오디오를 처리할 모둘 이름을 sfx.lua 로 해서 만듭니다. 처음 시작하는 몇 라인은 아주 기본적인 겁니다. 약간의 세팅과 데이터가 들어있는 myData.lua 모듈을 사용합니다. 이 내용은 지난주에 자세히 다뤘었습니다. 그리고 나서 변수들을 담을 namespace를 생성합니다. 

 

local myData = require( "mydata" )
local sfx = {}  --create the main Sound Effects (sfx) table.
return sfx

 

루아의 required 는 처음에 한번만 실행된다는 것을 기억해 두세요. 처음 시작할 때 어떤 세팅이나 configure를 core code 에서 할 수 있다는 얘기입니다.

 

예를 들어

 

sfx.boomSound = audio.loadSound( "audio/explosion2.wav" )
sfx.bigBoomSound = audio.loadSound( "audio/explosion.wav" )
sfx.killMeSound = audio.loadSound( "audio/idied.wav" )
sfx.missileSound = audio.loadSound( "audio/missile.wav" )
sfx.blasterSound = audio.loadSound( "audio/scifi048.wav" )
sfx.bossSound = audio.loadSound( "audio/scifi026.wav" )
sfx.shieldsSound = audio.loadSound( "audio/shields.wav" )


이제 간단하게 sound에 대해 처리 하는 부분을 만들겁니다. 그리고 오디오 API 에게 각각의 사운드를 로드하도록 합니다. 그리고 그 handle 을 sfx 테이블에 저장합니다. 루아에서는 이 테이블을 dot 이나 bracket syntax로 구현할 수 있도록 제공합니다. sfx.boomSound 나 sfx["boomSound"] 이렇게 두가지 방법으로 처리할 수 있습니다. 이렇게 하면 나중에 sound를 참조할 handle name을 사용할 수 있습니다. 예를 들어 어떤 scene에서 sfx.lua 가 필요하면 아래와 같이 해당 오디오 파일을 플레이 시키면 됩니다.

 

audio.play( sfx.boomSound )

 

더 나아가서 이 메소드를 extend 해서 추가적인 기능을 부여할 수도 있습니다. 아래와 같이 추가적으로 오디오 파라미터들을 셋업 할 수 있는거죠.

 

audio.reserveChannels( 5 )
masterVolume = audio.getVolume()
audio.setVolume( 0.80, { channel = 1 } )  --music track
audio.setVolume( 0.66, { channel = 2 } )  --boss sound
audio.setVolume( 1.0,  { channel = 3 } )  --voice overs
audio.setVolume( 1.0,  { channel = 4 } )  --alien voice
audio.setVolume( 0.25, { channel = 5 } )  --weak explosion

 

sfx 테이블에서 call 할 수 있는 init 함수를 간단히 생성할 수 있습니다.

 

sfx.init = function()
   audio.reserveChannels(5)
   sfx.masterVolume = audio.getVolume()  --print( "volume "..masterVolume )
   audio.setVolume( 0.80, { channel = 1 } )  --music track
   audio.setVolume( 0.66, { channel = 2 } )  --boss sound
   audio.setVolume( 1.0,  { channel = 3 } )  --voice overs
   audio.setVolume( 1.0,  { channel = 4 } )  --alien voice
   audio.setVolume( 0.25, { channel = 5 } )  --weak explosion
end

 

이제 masterVolume sfx 테이블에 저장됐습니다. 그리고 나중에 이런 다른 action들이 필요 하면 그에 맞는 액션을 사용할 수 있습니다.
그리고 다른 trick으로는 여러분 앱의 sound on/off 세팅을 담당할 audio.play 의 버전을 만들 수 있다는 겁니다. 예를 들어 아래와 같이 필요한 사운드를 필요할 때 사용할 수 있습니다.

 

if ( settings.soundOn ) then
   audio.play( "beep" )
end

 

sfx.play 라는 함수를 생성해서 audio.play 와 비슷하게 작동하도록 할 수 있습니다. 이  방법을 사용하면 sound setting을 좀 더 편하게 할 수 있습니다.

 

sfx.play = function( handle, options )

   if ( myData.settings and myData.settings.soundOn == false ) then
      --your settings dictate NOT to play this sound
      return false
   end

   --otherwise, one of three things is true:
   --1. myData.settings is nil. You haven't set up control, so play the sound.
   --2. myData.settings.soundOn is nil. You have settings, but not a soundOn flag.
   --   So, play the sound since you haven't set up control.
   --3. soundOn is true, which means you want to play the sound. So, play it!
   audio.play( handle, options )

end

Loading Scene-Specific Sounds

Storyboard 와 함께 오디오를 사용할 때 만날 수 있는 어려움들에는 아래와 같은 것들이 있습니다.


• 해당 scene의 main chunk에서 사운드를 로딩하면 문제가 발생할 수 있습니다.왜냐하면 reload를 하려면 scene을 remove 한 다음에 recreate을 시켜야 하기 때문이죠.


createScene 이벤트는 scene이 로드될 때마다 로드될 필요가 없습니다. 그리고 큰 사운드가 로드되면 transition이 delay 되게 될 겁니다.


enterScene 이벤트는 매번 fire 됩니다. 하지만 스크린에 해당 scene이 완전히 로드되기 이전에는 사운드가 로드되지 않는다는 특징이 있습니다.

 

위의 enterSceneexitScene은 한 쌍으로 발생됩니다. enterScene은 scene-specific sound를 로드할 최적의 장소일 것입니다. 그리고 나서 exitScene 이벤트에서 audio.dispose()를 사용해서 그것들을 처리하면 됩니다. (이 때 객체를 nil 처리하는 것을 잊지 마세요.)

 

그런데 만약에 앱이 새로운 scene으로 갈 때 sound 가 갑자기 끊기지 않고 계속 play 되어야 하는 상황이면 어떨까요? 다음 scene에서는 이 audio handle에 접근할 수 있는 방법이 더 이상 없습니다. 이 문제점을 해결 하려면 sfx테이블로 sound 를 로딩하시면 됩니다. 그리고 onComplete phase에서 anonymous 함수를 사용해서 dispose 시키면 됩니다.

 

아래 코드를 보세요.

 

local sfx = require( "sfx" )

-- forward declare the handle
sfx.longsound = nil

function scene:createScene( event )
   local group = self.view

   local background = display.newRect( 0, 0, display.contentWidth, display.contentHeight )
   background.x = display.contentCenterX
   background.y = display.contentCenterY
   group:insert( background )

   local function leaveScene(event)
      if ( event.phase == "ended" ) then
         storyboard.gotoScene( "b" )
      end
   end

   local button = display.newRect( 100,100,100,100 )
   group:insert( button )
   button:setFillColor( 255,0,255 )
   button:addEventListener( "touch", leaveScene )

end

function scene:enterScene( event )
    sfx.longsound = audio.loadSound("audio/mirv_missiles_online.wav")
audio.play( sfx.longsound, { onComplete = function()
                                      audio.dispose( sfx.longsound )
                                      end } )

 

end 

 

루아에서는 onComplete 이벤트가 call 할 수 있는 anonymous 함수를 사용할 수 있도록 제공합니다. 여러분은 이 메소드를 오디오 파일이 끝났을 때 dispose 하도록 할 때 사용하실 수 있습니다. sound 가 실제로 사용되기 전에 sfx table에서 sound handle 하도록 미리 선언해둬야 한다는 것을 잊지 마세요.

 

여러분은 모듈에서 오디오를 처리하는 것의 장점을 아실 겁니다. 특히 Storyboard나 다른 scene manager utility를 사용할 때 말이죠. 오디오는 조심스럽게 그리고 제대로 관리 되어야 한다는 사실을 명심 하셔야 합니다. 물론 그 오디오 파일을 dispose 시키는 것도 말이죠. 그렇게 함으로서 메모리 누수를 방지하고 다른 이상한 문제점들을 방지할 수 있습니다.

 

저작자 표시 비영리 동일 조건 변경 허락
신고



Posted on . Written by



9. Pre-create Physics Bodies



만약 여러분 시나리오에서 여러 physics body 들을 사용하려고 한다면 그 physics body 들을 non-time-critical code 에서 미리 생성해 두는 것이 좋습니다. 어딘가 스크린 밖에 inactive 상태로 두던가 invisible display group 으로 두었다가 필요하면 active 상태로 바꾸면 되거든요.

그냥 physics body 들 몇개를 time-critical code 내에서 생성하는게 그다지 큰 문제가 되지는 않습니다 단지 한 game 사이클에서 10~20 개의 physics body 들을 한꺼번에 생성하는 것을 피하기 위해서입니다. 이렇게 한꺼번에 생성하면 인식할 수 있을 정도로 frame rate 이 skip 이 일어날 겁니다.

그리고 이 방법은 어떤 면에서는 balancing act 라고 얘기할 수도 있습니다. 200개의 physics body 들을 사전에 생성해서 deactivate 시키게 되면 Box2D 세계에서 이것들을 remove하게 됩니다. 하지만 Corona의 메모리에서 remove되는 것은 아닙니다. 그래서 이렇게 극단적으로 많이 사용할 경우에는 그렇게 효과가 크지 않을 수도 있습니다.


10. Utilize Audio “Best Practices”



앱에서 사용하는 음향효과는 항상 non-time-critical code 에서 pre-load 되어야 합니다. 예를 들어 scene 이나 level 이 시작(begins) 되기 전에 말이죠. 또한 이러한 사운드들을 사용 가능한한 범위 내에서 용량을 최대한 줄여야 합니다. 11khz mono (not stereo)는 대부분의 경우에 acceptable 합니다. 유저가 폰이나 태블릿 스피커 혹은 여러 이어폰을 통해서 들을 수 있는 범위에 속하죠. 그리고 간단하게 그리고  WAV 같은 cross-platform 포맷을 사용하세요. 그래서 CPU를 너무 무리하게 일을 시키지 마세요.

그리고 음향효과들은 아래처럼 테이블로 관리하기를 권장합니다. 쉽게 참조할 수 있고 더 이상 필요 없으면 쉽게 처분할 수 있도록 말이죠.



--load these sounds during NON-time-critical code
local soundTable = {
   mySound1 = audio.loadSound( "a.wav" ),
   mySound2 = audio.loadSound( "b.wav" ),
   mySound3 = audio.loadSound( "c.wav" ),
   mySound4 = audio.loadSound( "d.wav" ),
   mySound5 = audio.loadSound( "e.wav" ),
   mySound6 = audio.loadSound( "f.wav" ),
   mySound7 = audio.loadSound( "g.wav" ),
   mySound8 = audio.loadSound( "h.wav" ),
}


위와 같은 구조라면은 playback 은 다음과 같이 간단하게 사용하실 수 있습니다.


local mySound = audio.play( soundTable["mySound1"] )


항상 그렇듯이 특정 음향효과가 더이상 필요하지 않다면 깨끗하게 정리하는 걸 잊지 마세요. 그리고 이 테이블에서도 reference를 깨끗하게 처리하세요.


local ST = soundTable
for s,v in pairs(ST) do
   audio.dispose( ST[s] ) ; ST[s] = nil
end


여기까지가 퍼포먼스 최적화와 관련된 내용입니다. 개발자로서 이 퍼포먼스 최적화(performance optimization) 은 끝없이 꾸준히 해야 될 일입니다. 그리고 항상 best practice를 해야 합니다. 아무쪼록 이 글에서 다룬 몇가지 팁들이 여러분 앱의 퍼포먼스를 boosting 시키는데 조금이라도 도움이 됐으면 합니다. 질문이나 댓글은 언제든지 환영합니다.



이로써 퍼포먼스 최적화 관련 글을 4번에 걸쳐 다 한글로 옮겨 놨습니다.

항상 코딩하면서 적용해보고 적용해보고 이렇게 반복 연습해서 몸에 익혀 둬야할 내용들 같습니다.


저작자 표시 비영리 동일 조건 변경 허락
신고



Posted on . Written by


6. Avoid “ipairs()”

테이블을 iterating 할 때 Lua ipaires() 함수를 너무 과도하게 사용하는 것은 올바른 방법이 아닙니다. 특히 같은 일을 Lua construct 를 사용해서 처리할 수 있을 때는 말이죠.


ipairs() — Discouraged


local t1 = {}
local t2 = {}
local t3 = {}
local t4 = {}
local a = { t1, t2, t3, t4 }

for i,v in ipairs( a ) do
   print( i,v )
end



Lua Construct — Recommended


local t1 = {}
local t2 = {}
local t3 = {}
local t4 = {}
local a = { t1, t2, t3, t4 }

for i = 1,#a do
   print( a[i] )
end


7. Math Performance Comparisons


다양한 수학 함수들이나 프로세스들은 다른 것들보다 빠릅니다. 그리고 되도록 그 방법을 사용하는 것이 좋습니다.



Avoid “math.fmod()” for Positive Numbers
(양수에는 “math.fmod()” 를 피하세요.)


--math.fmod method (discouraged)
local fmod = math.fmod
for i = 1,100 do
   if ( fmod( i,30 ) < 1 ) then
      local x = 1
   end
end

--modulus operator method (recommended)
for i = 1,100 do
   if ( ( i%30 ) < 1 ) then
      local x = 1
   end
end



Multiplication is Faster Than Division
(나누기보다 곱하기가 빠릅니다.)


x * 0.5 ; x * 0.125  --recommended
x/2 ; x/8            --discouraged



Multiplication is Faster Than Exponentiation
(곱하기가 승수계산보다 빠릅니다.)


x * x * x  --recommended
x^3        --discouraged


8. Conserve Texture Memory


Texture memory는 “critical mass”에 도달할 때까지 자주 무시됩니다. 그래서 art assets 들에 어떤 변화를 요구하도록 하는 작업은 어려우면서도 시간이 많이 소요되는 작업입니다.


Texture memory 에는 8비트나 24비트 PNG 이미지들이 있습니다. 이것들은 alpha channel 이 있는 32비트 이미지로 unpack 됩니다. 여기에는 각 이미지들 마다 픽셀들의 rectangular 배열이 있고 색에 대한 4 color 배열 (channels) 가 있습니다. (빨강, 녹색, 파랑 그리고 alpha(RGB+A).


OpenGL 에서 texture들은 (single 이미지이거나 image sheet들 모두 - Power of 2 (PoT) rule 을 따릅니다. 이 의미는 어떤 texture 이든지 next highest Power of 2 로 반올림 된다는 의미 입니다. (2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, …) 그러면 그 만큼 메모리를 차지한다는 의미 입니다. 그러므로 320x480 크기의 이미지와 260x400 크기의 이미지는 모두 512x512 만큼 texture memory를 차지합니다.

이게 딱 보면 뭐 별로 크게 와 닿지는 않을텐데요 실제 메모리 소비량을 한번 계산해 볼까요. 꼭 제곱근(PoT)만이 아니라 4 color channel들도 같이 생각해 봅시다. 이 의미는 texture 배열에 있는 각각의 픽셀은 4 byte 를 필요로 한다는 겁니다. 그리고 이것은 여러분이 생각하는 것보다 훨씬 더 빠르게 추가됩니다.

Image(sheet) sized 350×500:

512×512 (pixels) × 4 (bytes) = 1,048,576 bytes = 1 MB


Image(sheet) sized 514×1024:

1024×1024 (pixels) × 4 (bytes) = 4,194,304 bytes = 4 MB



이 다음 제곱근(PoT)는 어떻게 되죠? texture memory 가 4배가 될 겁니다. 이건 여러분이 일반적인 디바이스와 Retina/HD 디바이스용으로 개발할 때 더 많이 신경 쓰셔야 할 부분입니다. 이 두 디바이스 간의 이미지가 두배의 크기 차이가 있다면 (iPad 와 Retina iPad 같이) 여러분의 모든 이미지들은 두 기기에서 보두 깔끔하고 쌈박하게 유지하기 위해 원본 이미지와 이보다 두배 큰 이미지를 사용해야 합니다. 이 사이즈 크기가 두배라는 것은 texture 메모리가 더블 이상이 된다는 것을 의미하죠. (위의 경우에는 4배), 그리고 일반적으로 Retina/HD 디바이스들은 이전 버전과 비교해서 4배의 메모리가 있는 것이 아닙니다.

그렇다고 여러분 패닉에 빠지지 마시구요. texture memory 가 관리하는데 또 그렇게 생각보다 엄청난 노력이 필요한 것만은 아닙니다. 아래 팁들을 잘 기억해 두세요.

  1.  texture 가 필요하지 않을 때(display stage 에서 사라질 때)는 항상 unload 를 하세요.
  2. 526x600인(screen size) background texture 가 있다면 기 비율에 맞게 448x512 이미지로 만들어서 사용하세요. 512 PoT(제곱근)을 넘지 않도록요. 그리고 코드에서 그 이미지의 width와 height를 원하는 비율로 살짝 scaling 해 주세요. 유저 입장에서는 약간의 크기 변화가 있어도 그렇게 크게 지정을 주지는 않을 겁니다. 특히 작은 디바이스들에서는요.
  3.  가능하면 texture들을 재사용하세요. 그리고 setFillColor() API를 사용해서 tinting을 하세요. 만약에 빨간 사과와 녹색 사과가 있다면 grayscale image로 사과를 만든 다음에 red와 green tint 를 적용하셔서 사용하실 수 있습니다.
  4.  image sheets를 사용한다면 TexturePacker 같은 tool을 사용하세요. 그래서 가장 작은 PoT configuration으로 pack 하셔서 사용하시면 아주 도움이 될 겁니다.



저작자 표시 비영리 동일 조건 변경 허락
신고


Posted on . Written by



2. Avoid Functions as Arguments for Other Functions

루프나 time-critical code 에서 함수를 localize 하는 것은 아주 중요합니다. 그러면 다른 함수들에 파라미터로 사용됩니다. 아래 두 경우를 보세요:



Defined as an Argument of Another Function — Discouraged

local func1 = function(a,b,func) 
   return func(a+b) 
end

for i = 1,100 do
   local x = func1( 1, 2, function(a) return a*2 end )
   print( x )
end


Localized — Recommended

local func1 = function( a, b, func )
   return func( a+b )
end
local func2 = function( c )
   return c*2
end

for i = 1,100 do
   local x = func1( 1, 2, func2 )
   print( x )
end



3. Avoid “table.insert()”

아래 네 경우를 비교해 보죠. 4개 모두 결과는 같습니다. 테이블에 값을 insert 하는 일반적인 방법들입니다. 이 4가지 중 Lua 의 table.insert 함수를 사용하는것은 별로 좋지 않은 방법입니다.



table.insert() — Discouraged

local a = {}
local table_insert = table.insert

for i = 1,100 do
   table_insert( a, i )
end



Loop Index Method — Recommended

local a = {}

for i = 1,100 do
   a[i] = i
end



Table Size Method — Recommended

local a = {}

for i = 1,100 do
   a[#a+1] = i
end



Counter Method — Recommended

local a = {}
local index = 1

for i = 1,100 do
   a[index] = i
   index = index+1
end



4. Minimize use of “unpack()”


Lua unpack() function 도 퍼포먼스 측면에서 그렇게 좋은 하수가 아닙니다. 다행히 같은 결과를 내기 위해 간단하고 빠르게 loop 를 사용할 수 있습니다.



Lua “unpack()” method — Discouraged

local a = { 100, 200, 300, 400 }

for i = 1,100 do
   print( unpack(a) )
end



Loop Method — Recommended

local a = { 100, 200, 300, 400 }

for i = 1,100 do
   print( a[1],a[2],a[3],a[4] )
end




5. Cache Table Item Access

테이블 아이템들을 캐싱하는 것. 특히 루프 내에서. 이 방법을 사용하면 퍼포먼스를 향상시키고 time-critical code를 만들 수 있습니다.





Non-Cached — Acceptable

for i = 1,100 do
   for n = 1,100 do
      a[n].x = a[n].x + 1
      print( a[n].x )
   end
end



Cached — Recommended

for i = 1,100 do
   for n = 1,100 do
      local y = a[n]
      y.x = y.x + 1
      print( y.x )
   end
end




저작자 표시 비영리 동일 조건 변경 허락
신고


이번주 튜토리얼은 Performance Optimizations 에 관한 내용입니다.

개발 할 때 항상 중요하게 생각해야 할 내용들이죠.


Coronasdk 에서 제공하는 글에서 여러번 강조된 내용이기도 합니다.

계속 강조하는 이유는 그만큼 중요하기 때문이겠죠.


10가지의 팁을 제공하고 있는데요.

시간 나는대로 정리해서 올릴께요.


몇번에 나눠서 글이 정리될지 모르겠네요.

제가 참여하는 프로젝트가 이번달 말로 끝나거든요.

다른 position 을 찾아봐야 되서 그렇게 여유가 없네요.



Posted on . Written by




오늘의 튜토리얼은 퍼포먼스 최적화와 관련된 내용입니다. 모든 개발자들이 항상 신경써야 할 주제죠. 이 중 어떤 팁들은 뻔한 내용일 수 있습니다. 프로그래밍을 하면서 코드를 최적화 하는 작업은 소요되는 시간그로 인해 얻는 이익을 저울질 해서 처리해야 할 문제 입니다.

어떤 최적화가 구식 디바이스에서 2%의 퍼포먼스 개선을 불러올 수 있는데 그 일을 하려면 50시간을 투자해야 한다면 그 작업을 해야 될 필요가 없을 수도 있습니다. 그리고 어떤 최적화는 10시간 정도 소요되는데 아주 많은 디바이스들에서 큰 성능 개선이 일어날 수 있다면 그 최적화는 10시간을 들이더라도 반드시 해야 되겠죠.

새로운 프로젝트들을 시작할 때 퍼포먼스가 크게 개선되고 앱 코드와 동작이 깨끗해지고 그래서 모든 디바이스들에서 user experience 가 아주 개선 된다면 그런 결과를 유도할 수 있는 performance trick들은 많이 사용하면 사용할 수록 좋을 겁니다.



“Time-Critical” Routines


대부분의 performance trick 들은 주로 “time-critical” routines 들을 위한 방법들이 제공될 겁니다. 앱이 버벅거려서 유저들이 사용하는데 불편을 느끼거나 하면 안되니까요. 예를 들어 액션게임을 하는데 new scene 이 로딩되는 시간이 너무 길거나 하면 불편해서 유저들이 잘 사용하지 않을 겁니다.


1. Localize, Localize


이것은 몇번을 강조해도 부족하지 않은 내용입니다. 글로벌 변수나 글로벌 함수를 가급적 사용하지 않는 것이 성능 향상에 아주 도움이 됩니다. 로컬 변수와 로컬 함수에 접근하는 것이 훨씬 빠르니까요. 특히 time-critical routines 에서는요.



이 이미지는 이 글 내용과 거의 관계가 없네요. ;; 왜 이 이미지가눈에 띄었을까?


Non-Local — Discouraged

CCX = display.contentCenterX  --global variable
for i = 1,100 do
   local image = display.newImage( "myImage" )
   image.x = CCX
end


Local — Recommended

local CCX = display.contentCenterX  --local variable
for i = 1,100 do
   local image = display.newImage( "myImage" )
   image.x = CCX
end


또한 이것은 math library 같은 core Lua 라이브러리에 적용됩니다. time-critical routines 에서 여러분은 항상 라이브러리 함수들을 localize 해야 합니다.


Non-Local — Discouraged

local function foo( x )
   for i = 1,100 do
      x = x + math.sin(i)
   end
   return x
end


“External” Local — Recommended

local sin = math.sin  --local reference to math.sin
local function foo(x)
   for i = 1,100 do
      x = x + sin(i)
   end
   return x
end

마지막으로 함수들은 가능하면 항상 localize 되어야 한다는 것을 기억하고 계세요. 물론 scoping 을 제대로 해야 하겠죠. 만약 Lua 초보자이시라면 링크 Understanding Scope for Beginners 를 참조하세요.


Non-Local — Discouraged

function func1()
   func2( "myValue" )
end

function func2( y )
   print( y )
end

func1()


Local — Recommended

--"func2" properly scoped above "func1" 
local function func2( y )
   print( y )
end

local function func1()
   func2( "myValue" ) 
end

func1()


오늘은 시간 관계상 1번 팁만 소개해 드립니다.

다음 글에선 좀 더 많은 팁들을 올릴께요.

원문은 저 위의 제목을 클릭하면 보실 수 있으니까 관심 있는 분들은 저 위의 제목을 클릭해서 보세요.


저작자 표시 비영리 동일 조건 변경 허락
신고


Posted on . Written by




Wind Tunnel / Vents


Runtime 이벤트에서 Physics sensor와 :applyForce() function 을 사용하게 되면 wind tunnel 지역이나 객체들을 날려버리는 통풍구들을 만들기가 쉽습니다. 이 작업을 하기 위해 통풍구(vent)들과 각 객체들에 모두 두가지 프로퍼티들을 할당할 겁니다. 이 프로퍼티들을 xFyF로 명명하겠습니다. 객체들과 관련된 xy 의 force를 나타낼 겁니다.

실제 vent들은 사각형의 센서들이 될 겁니다. 이 센서들은 원하는 각도로 rotate 될거구요. 이 각도에 맞게 바람이 뿜어져 나와서 객체들을 위로 보내서 땅에 떨어지지 않도록 할 겁니다. 이 예제에서 떠 다니는 물체들은 나뭇잎들로 할겁니다.


각각의 잎들도 Runtime 이벤트 동안 적용될 force 를 나타내는 xFyF force 프로퍼티를 갖고 있습니다. 이 값들은 이 나뭇잎이 vent 지역을 들어오고 나갈때마다 새로 계산될 겁니다. 그리고 vector force 값들이 두개 이상의 통풍구 바람이 다른 방향으로 영향을 미칠 때 적용될 요소가 될 겁니다. 여러분이 원하신다면 휘어진 통풍구도 만들 수 있습니다.



Configuring Vents


vent 는 여느 physics body와 마찬가지로 셋업 하시면 됩니다. 센서로 세팅할 것이고 isVent 프로퍼티도 넣어서 collision handler 에서 다른 객체들이 vent로 처리되지 않도록 할 겁니다. 네번째 줄에서는 xFyF 값을 얻게 됩니다. 여기서 getVentVals() 함수는 바로 다음에서 다루게 될 겁니다.


local vent1 = display.newRect( 0, 0, 80, 300 )
physics.addBody(vent1, "kinematic", { isSensor=true } )
vent1.isVent = true ; vent1.rotation = 14 ; vent1.x = 432 ; vent1.y = 660
vent1.xF, vent1.yF = getVentVals( vent1.rotation, 160 )



Retrieve Vent Force Values


아래 함수는 두개의 파라미터를 전달 받습니다. vent의 각도와 power 입니다. 이 값들로 계산해서 xFyF force 값을 리턴하게 되죠. 이 값들이 떠다니는 객체들이 영역으로 들어왔을 때 불어 올리는 동작을 할 수 있도록 해 줍니다.


function getVentVals( angle, power )
   local xF = math.cos( (angle-90)*(math.pi/180) ) * power
   local yF = math.sin( (angle-90)*(math.pi/180) ) * power
   return xF,yF
end



Vent Collision Handler


collision handler 는 collision의 beganended phases 에 어떤 처리를 하게 됩니다. began phase에서는 vent의 xFyF 요소들을 떠다니는 객체들의 해당 프로퍼티 값에 더해 주게 됩니다. 그리고 ended phase에서는 그 값을 빼주게 되죠.

예를 들어 한 vent에는 xFyF 값이 02 이고 위로 불어 올리고 있고  다른 vent는 이보다 약간 더 센 power를 가지고 아래로 내리고 있다고 칩시다. (0하고 3.5 정도). 이 두 vent의 영향을 한꺼번에 받는다면 떠다니는 객체는 1.5(-2+3.5)만큼 아래로 가게 되겠죠. 


function ventCollide( self,event )

   local vent = event.other
   if ( event.phase == "began" and vent.isVent == true ) then
      self.xF = self.xF+vent.xF ; self.yF = self.yF+vent.yF
   elseif ( event.phase == "ended" and vent.isVent == true ) then
      self.xF = self.xF-vent.xF ; self.yF = self.yF-vent.yF
   end
end
leaf1.collision = ventCollide ; leaf1:addEventListener( "collision", leaf1 )



Runtime Force Application


마지막으로 각 나뭇잎들에 실제 force를 적용할 필요가 있습니다. 이 작업은 Runtime event 동안에 하게 됩니다. (이 force value들은 계속 누적 될 겁니다.) 그러면 나뭇잎이 오래 떠 다닐수록 더 큰 force 가 적용된다는 얘기가 되겠죠.

실제 함수는 아주 간단합니다. 특정 잎의 xFyF 값이 0이 아니면 특정 force가 게임 중에 적용이 되게 됩니다.


function constantForce()
   if not ( leaf1.xF == 0 and leaf1.yF == 0 ) then
      leaf1:applyForce( leaf1.xF, leaf1.yF, leaf1.x, leaf1.y )
   end
end

Runtime:addEventListener( "enterFrame", constantForce )



눈치 빠르신 분들은 알아차리셨겠죠? 객체가 통풍구에서 멀어질 수록 적은 영향을 받게 됩니다. 이 값이 true 일 경우에 객체들은 vent 의 범위 안에 있는 것이고 그러면 그 force 의 영향을 받게 됩니다.

windtunnel.zip


여기까지가 기본 사항입니다. 예제에 있는 여러 값들을 바꿔가면서 테스트 해 보세요.


In Summary…


세 가지 예제를 모두 보시려면 여기 sample projects 에서 다운 받아서 보세요. 그리고 궁금하신 점이나 의견이 있으시면 댓글에 남겨 주세요.

저작자 표시 비영리 동일 조건 변경 허락
신고


Posted on . Written by



Sticky Projectiles


끈적한 포탄들을 코로나로 구현하는 방법은 아주 간단합니다. 이 장에서는 아래와 같은 내용들을 다룰 겁니다.



1. 포탄이 벽에 붙을 수 있는 충분한 속도가 됐는지 여부를 체크하기 위한 directional velocity 를 어떻게 detect 하는지에 대한 방법
2. weld joint 를 사용해서 포탄을 다른 객체에 붙이는 방법


포탄을 만들고 launching하는 것은 큰 주제 입니다. 그래서 그에 대해서는 깊게 들어가지 않겠습니다. 이 게임을 만들 때 생각해야 할 것은 위 두 경우를 다룰 collision handler 함수 입니다.


우리가 할 첫번째 일은 포탄의 방향과 속도를 감지하는 것입니다. 우선 피타고라스 이론(Pythagorean theorem)을 사용해서 속도를 계산해야 합니다. 그리고 나서 그 값으로 다음의 둘 중 하나를 구현할 수 있습니다.  만약 속도가 충분하다면 포탄과 벽에 weld joint 를 생성할 겁니다. 속도가 충분하지 않으면 아무 joint 도 만들지 않을 겁니다. 그러면 포탄은 땅에 떨어지겠죠.


Detect Directional Velocity


우선 포탄의 vx vy linear velocities 를 가져옵니다. 그리고나서 그 값을 공식에 대입시키죠. 그러면 우리가 원하는 속도를 얻을 수 있습니다.


local vx,vy = self:getLinearVelocity()
local dirVel = math.sqrt( (vx*vx)+(vy*vy) )


Make Joint — or Don’t!

포탄의 속도에 따라 위에서 언급한 둘 중 한가지를 적용하게 될 겁니다. 속도가 여러분이 원하는 만큼 충분하다면 포탄이 다른곳에 붙을 수 있도록 만듭니다.


if ( dirVel > 330 ) then
   self:setLinearVelocity( 0,0 )
   timer.performWithDelay( 10, resolveColl, 1 )
end


Box2D 에서는 어떤 action들은 같은 time step 에 한꺼번에 실행되지 않는 것들이 있습니다. 왜냐하면 Box2D 엔진이 내부적으로 계산을 하고 있는 상황이기 때문이죠. 우리는 10 밀리세컨드의 timer 가 작동된 후에 joint 를 생성할 겁니다.


function resolveColl()
   local weldJoint = physics.newJoint( "weld", self, event.other, self.x, self.y )
end


여기까지 하시면 sticky 포탄 시나리오의 아주 기본적인 사항들은 완료 된 겁니다. 예제에 있는 여러 setting 들을 바꿔가면서 이것저것 많이 시도해 보세요.

StickyProjectiles.zip


참고로 전체 소스는 아래와 같습니다.


local physics = require("physics") ; physics.start() ; physics.setGravity( 0.0,9.8 ) ; physics.setDrawMode( "normal" )
physics.setPositionIterations( 16 ) ; physics.setVelocityIterations( 6 )
display.setStatusBar( display.HiddenStatusBar )

--set up some references and other variables
local ox, oy = math.abs(display.screenOriginX), math.abs(display.screenOriginY)
local cw, ch = display.contentWidth, display.contentHeight
local stage = display.getCurrentStage()

--set up terrain and background
local back = display.newImageRect( "sky.jpg", 1024, 768 ) ; back.x = cw/2 ; back.y = ch/2
local wallL = display.newRect( -ox, -oy, 40, ch+oy+oy )
physics.addBody(wallL, "static", { bounce=0.6, friction=1.0 } )
local wallR = display.newRect( cw-40+ox, -oy, 40, ch+oy+oy )
physics.addBody(wallR, "static", { bounce=0.6, friction=1.0 } )
local wallB = display.newRect( -ox, ch-40+oy, cw+ox+ox, 40 )
physics.addBody(wallB, "static", { bounce=0.6, friction=1.0 } )
local wallT = display.newRect( -ox, -oy, cw+ox+ox, 40 )
physics.addBody(wallT, "static", { bounce=0.6, friction=1.0 } )
local text = display.newText( "Tap screen to launch projectiles", 0, 0, "Times", 44 ) ; text:setTextColor(0,0,0,160) ; text.y = 140 ; text.x = cw/2

--set up boolean for projectile firing
local projFiring = false

--set up projectile sheet
local proj
local options = { width=40, height=40, numFrames=2, sheetContentWidth=80, sheetContentHeight=40 }
local projSheet = graphics.newImageSheet( "projspike.png", options )
local seq = { name = "main", frames = {1,2} }

--function to create new projectiles
local function newProj()

    proj = display.newSprite( projSheet, seq ) ; proj.x = 150 ; proj.y = 600
    physics.addBody( proj, "dynamic", { density=15.0, friction=0.8, bounce=0.3, radius=16 } )
    proj.gravityScale = 0
    projFiring = false
    proj.isBodyActive = false
end

--collision handler
local function projCollide( self,event )

    if ( event.phase == "began" ) then

        --get world coordinates of projectile for joint reference   
        self:removeEventListener( "collision", self ) ; self.collision = nil
       
        --delay function to resolve collision
        local function resolveColl( timerRef )
            if ( timerRef.source.action == "makeJoint" ) then
                local weldJoint = physics.newJoint( "weld", self, event.other, self.x, self.y )
            end
            newProj()
        end

        --check if velocity of projectile is sufficient to "stick"
        local vx,vy = self:getLinearVelocity()
        local dirVel = math.sqrt( (vx*vx)+(vy*vy) )

        if ( dirVel > 330 ) then  --if sufficient, stop velocity and trigger joint creation
            self:setLinearVelocity( 0,0 )
            local t = timer.performWithDelay( 10, resolveColl, 1 ) ; t.action = "makeJoint"
        else  --if not sufficient, "break" projectile and create new
            self:setFrame(2)
            local t = timer.performWithDelay( 10, resolveColl, 1 ) ; t.action = "none"
        end

    end
end

--screen touch handler
local function touchAction(event)

    if ( event.phase == "began" and projFiring == false ) then
       
        projFiring = true
        proj.isBodyActive = true
        local px,py = event.x-proj.x, event.y-proj.y

        proj:applyLinearImpulse( px/2, py/2, proj.x, proj.y )
        proj:applyTorque( 1200 )
        proj.gravityScale = 1.0
        proj.collision = projCollide ; proj:addEventListener( "collision", proj )
    end
end
stage:addEventListener( "touch", touchAction )

newProj()



저작자 표시 비영리 동일 조건 변경 허락
신고


이번에 다룰 튜토리얼은 아주 유용한 예제 3개 입니다.

이 3개를 따로 따로 정리해서 글을 올릴 계획입니다.


Posted on . Written by



오늘의 튜토리얼에서는 몇가지 유용한 physics methods 를 소개해 드리겠습니다. 이 튜토리얼에서 우리는 "내가 점프할 수 있을까" 를 2D side-view 게임으로 만드는 과제를 풀어갈 겁니다. 그리고 sticky projectiles와 기본 wind tunnel befavior 를 다루는 방법도 다룰께요.

이 모든 method들은 다운로드 받을 수 있는 프로젝트 안에 포함돼 있습니다. 이 튜토리얼 마지막 부분에 있는 링크를 클릭해서 다운받아 보실 수 있습니다.


Can I Jump?


등장 캐릭터가 점프할 수 있는 2D 게임을 만들 때 아마 어떤 물체가 점프를 할 경우 ground 에서 점프해서 ground 로 떨어지도록 만들어야 할 겁니다. 이걸 구현하라고 하면 아마 개발자마다 자기만의 방법으로 구현할 수 있을 겁니다. 방법은 여러가지가 있을 수 있지만 두가지 정도는 지켜야 합니다. 일단 물체가 ground 에 있을 때는 verticla 속도는 없을 겁니다. 그리고 점프를 한 다음에는 짧은 timer를 사용하고 또 boolean flag를 사용해서 그 물체가 땅에 떨어지기 전에는 다시 점프를 할 수 없도록 해야 할 겁니다. 이것을 구현해 놓으면 그 다음에 또 다른 구현해야할 기능들이 눈에 보이겠죠.


일단 이 물체의 physics body 에 두번째 element로 “foot sensor”를 달면 쉽게 접근할 수 있습니다. 이 센서는 그 물체의 base에서 약간 의 곤간을 차지하게 될 겁니다. 이 센서가 ground와 겹쳐지면 우리는 이 물체가 ground 위에 붙어 있다고 가정할 수 있습니다. 그러면 jump를 할 수 있는 상태가 되는 거죠. 그리고 이 센서는 그 물체의 width 보다 약간 좁게 만들겁니다. 화면 끝에 가서 부딪힌 다음 다시 돌아와야 되는데 그 물체보다 넓으면 벽에 부딪히기도 전에 튀어나올 수 있으니까요.




Constructing Terrain


코로나에서 지형을 만드는 방법은 아주 간단합니다. 아래에 우리는 모든 ground 객체들에 objType 프로퍼티를 추가할 겁니다. 그래서 물체가 이 ground에서만 반응해서 점프할 수 있도록 할 겁니다. 


local cw, ch = display.contentWidth, display.contentHeight local ground = display.newRect( 0, ch-64, cw, 64 ) ground.objType = "ground" physics.addBody( ground, "static", { bounce=0.0, friction=0.3 } )


Declaring Character Body


이 물체는 두개의 body elements로 구성될 수 있습니다. 두번째 body element 는 sensor 라는 것을 기억해 두세요. 이것은 polygonal shape 를 사용해서 정의 될 겁니다. 그리고 센서는 두번째에 정의 된다는 것도 기억해 두시구요. 이 센서가 ground 에 닺았는지의 여부를 체크할 때 두번째 element를 사용해서 체크할 거거든요.

그리고 이 물체가 점프할 수 있는 상황인지를 알기 위해 canJump counter 도 추가합니다. 이 counter 는 다음과 같은 이유에서 아주 유용합니다. : 두개의 ground 객체가 있고 이 두 ground 사이를 이 물체가 지나갈 때 이 foot sensor 는 두 ground 객체에 모두 닿아있게 됩니다. counter 대신에 true/false boolean 프로퍼티를 사용한다면 자칫 원하지 않는 상황이 연출 될 수 있습니다. 그래서 센서가 ground 객체에 접촉할 때 이 counter 를 사용해서 숫자를 증감시켜서 현재의 상태를 보다 정확하게 파악할 수 있도록 합니다.


local character = display.newRect( 100, 300, 120, 120 ) ; character:setFillColor(0)
physics.addBody( character, "dynamic",
 { density=1.0, friction=0.0, bounce=0.0 },
 { shape={20,0,20,65,-20,65,-20,0}, isSensor=true }
 )
character.isFixedRotation = true
character.canJump = 0


Jump Handler

점프하도록 만드는 것도 아주 간단합니다. 그냥 canJump counter를 체크해서 0보다 크면 점프 시키면 됩니다.


function touchAction(event)
   if ( event.phase == "began" and character.canJump > 0 ) then
      --jump procedure here
   end
end
stage:addEventListener( "touch", touchAction )


Collision Handler


마지막으로 다룰 것은 collision 핸들러 입니다. 이 핸들러를 구현하기 위해 아래 사항들을 체크해야 합니다.

    1. colliding body element index 가 2 이다 - 이것으로 그 물체가 아니라 foot sensor 가 collid 된 것을 알 수 있습니다.
    2. ground 객체의 지형 element - 만약 지형 element이면 이 물체는 안전하게 점프할 수 있습니다.


이 conditional clause 안에서 우리는 아래 둘 중 하나를 실행시키게 됩니다.


    1. began phase 에서 (foot sensor 가 ground 객체에 들어 섰을때), canJump counter를 증가시킨다.
    2. ended phase 에서 (foot sensor 가 ground object 를 나갔을 때), canJump counter 를 감소시킨다.


function charCollide( self,event )

   if ( event.selfElement == 2 and event.other.objType == "ground" ) then
      if ( event.phase == "began" ) then
         self.canJump = self.canJump+1
      elseif ( event.phase == "ended" ) then
         self.canJump = self.canJump-1
      end
   end
end
character.collision = charCollide ; character:addEventListener( "collision", character )


여기까지가 jump를 구현하기 위해 가장 기본적으로 필요한 것들 입니다.


전체 소스와 이미지들은 아래 파일을 다운 받아서 사용하세요.

canJump.zip



저작자 표시 비영리 동일 조건 변경 허락
신고

티스토리 툴바