First Cocos2d-x LUA game

First Cocos2d-x LUA game

Our first cocos2d-x Lua program, named Hellolua, began to learn other things from the project.
Create a project
Our creation of the Cocos2d-x LUA project can be implemented cocos by the command tools provided by Cocos2d-x, but this approach is not well integrated with Cocos Code IDE integrated development tools and is not easy to program and debug. Because the Cocos Code IDE tool was developed specifically for COCOS2D-JS and cocos2d-x Lua development, the Cocos Code IDE tool makes it easy to create cocos2d-x LUA projects.
First we need to configure the LUA framework in the Cocos Code IDE tool, open the Cocos Code IDE tool, select the menu window→preferences, pop Up the dialog box, select Cocos→lua in the LUA frameworks on the right <cocos2d-x Engine Catalog >.

Configuring the LUA Framework

The LUA framework configuration does not need to be done every time, but only in the initial configuration, but when the project is created, the Cocos Code IDE tool creates the project file from the LUA framework directory.
Next we can create a LUA project, select the menu File→new→project, as shown in the Popup Item Type selection dialog box.

Project Type selection dialog box

We selected Cocos Lua Project and then clicked the Next button to pop up the dialog box as shown. We enter the project name in Project name, the Create project in Workspace is created in the workspace directory, we need to select the project, create from Existing Resource item selection lets us create from an existing project, and now we don't need to select it.
Select Finish click the Next button to go to the Configure Run Environment dialog box where we can configure the project run-time information. The orientation project is the orientation of the configuration emulator, where landscape is a horizontal screen display, and the portriat is a vertical screen. The title in the desktop Runtime settings is the header of the set emulator, and the desktop Windows initialize size is the setting emulator. Add Native codes is to set up adding local code to the project, and in the original we do not need to add local code. Finally click the Finish button to complete the creation and create the project, as shown in the following figure.

New Project Dialog box

Configure the Run Environment dialog box

Create a project Success interface

Running in the Cocos Code IDE
After creating the project we can test, in the left of the Project navigation panel selected in the Hellolua project, the right-click menu select Run As→cocos luainding run the project we just created, run the result as shown.

Run the Engineering interface

Our main programming code is in the SRC directory, in this case the LUA file is responsible for handling the main scene interface logic. If we want to debug the program, we can set breakpoints, as shown in, click the position before the line number, set the breakpoint.

Set breakpoints

Debug the Run process, select the Debug As→cocos luabinding menu in the right-click menu. As shown, the program runs to line 31st pending and into the debug view, in the debug view we can see the stack, variables, breakpoints, calculation expressions, and stepping programs that the program runs.

Run to Breakpoint pending

Project file Structure
The Hellolua project we created has been able to run, let's look at the file structure in the Hellolua project, we use the Cocos Code IDE to open the Hellolua project, as shown in the navigation panel on the left.

Document structure in the Hellolua project

In the navigation panel shown, the Res folder holds the resource file, the SRC folder is the main program code Main.lua and Gamescene.lua, where Main.lua is the program portal file, Cocos2d-x binds the file at the bottom and starts and runs it. The game scene is implemented in Gamescene.lua.

Code explanation
There are two documents in the Hellolua project. Below we explain in detail their internal code:

1. Main.lua file
Main.lua is the program entry file code as follows:

R

[HTML]View Plaincopy

2. Equire "Cocos2d" ①
6. --Cclog
8. Local Cclog = function (...) ②
10. Print (String.Format (...)) ③
12. End
18. --For Ccluaengine Traceback
20. function __g__trackback__ (msg) ④
22. Cclog ("----------------------------------------")
24. Cclog ("LUA ERROR:"). ToString (msg): "\ n")
26. Cclog (Debug.traceback ())
28. Cclog ("----------------------------------------")
30. Return msg
32. End
38. Local function main () ⑤
40. CollectGarbage ("collect") ⑥
42. --Avoid memory leak
44. CollectGarbage ("Setpause", 100) ⑦
46. CollectGarbage ("Setstepmul", 5000) ⑧
50. Cc. Fileutils:getinstance (): Addsearchpath ("src")
52. Cc. Fileutils:getinstance (): Addsearchpath ("res")
54. Cc. Director:getinstance (): Getopenglview (): Setdesignresolutionsize (480, 320, 0)
58. --create scene
60. Local scene = require ("Gamescene") ⑨
62. Local Gamescene = scene.create () ⑩
64. Gamescene:playbgmusic ()
68. If CC. Director:getinstance (): Getrunningscene () then?
70. Cc. Director:getinstance (): Replacescene (Gamescene)
72. Else
74. Cc. Director:getinstance (): Runwithscene (Gamescene)
76. End
82. End
92. Local status, msg = Xpcall (main, __g__trackback__)?
94. If not status Then
96. Error (MSG)
98. End

The above code, ① line require, is loading the cocos2d module and can avoid repeated loading. The ② Line code declares the Cclog function, which functions as output log information. Line ③ Code print (String.Format (...)) is the output function.
The ④ Line code is a declaration __g__trackback__ (msg) function, called by the Xpcall of the line when the program goes wrong, and outputs the stack information. The following is the stack information for the log output:

[HTML]View Plaincopy

1. [Lua-print] Stack traceback:
2. [string]. \src/main.lua "]:13:in function ' __index '
3. [string]. \gamescene.lua "]:52:in function <[string". \gamescene.lua "]:49>
4. [Lua-print]----------------------------------------

The ⑤ line code is the main () function, which is called by the Xpcall function of the first row. The CollectGarbage in line ⑥ code collectgarbage ("collect") is the common interface function of the garbage collector, which is used to manipulate the garbage collector, and the other definitions are as follows:
Collectgrabage (opt [, Arg])
The OPT parameter is an operation method flag, and the flags include the following:
Collect: Perform a full garbage collection cycle, see Code line ⑥.
Stop: Stop the garbage collector.
Restart: Restart the garbage collector.
Count: Returns the amount of memory used in the current LUA, in kilobytes.
Step: Stepping through a garbage collection, the Size property in step size is specified by the parameter arg and returns True if a collection cycle is completed.
Setpause: Set the value of arg/100 as the time of the garbage collection pause, see Code section ⑦ line.
Setstepmul: Set the value of arg/100 as the increment of step, that is, "new step" = "Old Step" * (arg/100), see Code section ⑧ line.


The above code, line ⑨, local scene = require ("Gamescene") loads the Gamescene module, and the return value is the table type global variable. The ⑩ line code local Gamescene = Scene.create () Creates a gamescene scene from the static Create () function.
Code line CC. Director:getinstance (): Getrunningscene () is to determine if there is a scene running if there is a scene running through CC. Director:getinstance (): Replacescene (gamescene) statement replaces the current scene with a gamescene scene, otherwise through CC. Director:getinstance (): Runwithscene (gamescene) statement runs the gamescene scene, Either the Replacescene or the Runwithscene function game will be entered into the gamescene scene.
The code of the local status, MSG = Xpcall (main, __g__trackback__) in the Xpcall function is provided by LUA, used to invoke other functions, and can catch the error, the Xpcall function is defined as follows:
Xpcall (f, Err)
Where the f parameter is the function to invoke, err is the function that is called when the path error is caught. The return value status is the error status and MSG is the error message.
In fact, the first line of code local status, MSG = Xpcall (main, __g__trackback__) is the entry of the program. It calls the main () function, 3-19, as shown in the call stack, and is able to see the order in which they are called.

Call stack

2. Gamescene.lua file
Gamescene.lua is responsible for creating the main game scene, we see the scene shown in Figure 3-15 is implemented in the Gamescene.lua, Gamescene.lua the main code is as follows:
R

[HTML]View Plaincopy

2. Equire "Cocos2d"
4. Require "cocos2dconstants"
6. --Declaring the Gamescene class
8. Local Gamescene = Class ("Gamescene", function () ①
10. return CC. Scene:create ()
12. End
14. --Create a function statically
16. function Gamescene.create () ②
18. Local scene = gamescene.new () ③
20. Scene:addchild (Scene:createlayerfarm ()) ④
22. Scene:addchild (Scene:createlayermenu ()) ⑤
24. Return scene
26. End
32. --Constructor function
34. function Gamescene:ctor () ⑥
36. self.visiblesize = cc. Director:getinstance (): Getvisiblesize ()
38. Self.origin = cc. Director:getinstance (): Getvisibleorigin ()
40. Self.schedulerid = Nil
42. End
44. --Play background music
46. function Gamescene:playbgmusic ()
48. Local Bgmusicpath = cc. Fileutils:getinstance (): Fullpathforfilename ("Background.mp3")
50. Cc. Simpleaudioengine:getinstance ():p laymusic (Bgmusicpath, True)
52. Local Effectpath = cc. Fileutils:getinstance (): Fullpathforfilename ("Effect1.wav")
54. Cc. Simpleaudioengine:getinstance ():p reloadeffect (Effectpath)
56. End
58. --Create a dog wizard
60. function Gamescene:creatdog () ⑦
62. ... ...
68. Local Spritedog = cc. Sprite:createwithspriteframe (FRAME0)
70. ... ...
76. Return Spritedog
78. End
84. --Create farm to build farms layer
86. function Gamescene:createlayerfarm () ⑧
88. Local layerfarm = cc. Layer:create () ⑨
90. ... ...
96. Return Layerfarm
98. End
104. --Create menu creates the menus layer
106. function Gamescene:createlayermenu () ⑩
112. Local Layermenu = cc. Layer:create ()
114. ... ...
118. Return Layermenu
120. End
126. Return Gamescene

?
We created the gamescene scene in Gamescene.lua and added a farm layer and a menu layer to the scene. The ① Line code is the declaration of the Gamescene scene class ("Gamescene", function () {...}) Functions are provided by the Cocos2d-x LUA engine and can be created by Lua. The class function is defined as follows:
Class (classname, Super)
Where parameter classname is the function name, it is a string type, and super is called the parent class constructor.
The ② Line code declares the gamescene.create () static function, which is called through the scene.create () statement in Main.lua. The ③ line code local scene = Gamescene.new () is the creation of the Gamescene creation object, the new () function calls the Gamescene:ctor () function of the ⑥ row, the ctor () is the constructor, Used to initialize the Gamescene scene object. The ④ line of code is to invoke the Createlayerfarm () function of the Gamescene scene object to create the farm layer (see Code ⑧ Line). The ⑤ line code is to invoke the Createlayermenu () function of the Gamescene scene object to create a menu layer (see Code ⑩ Line).
The Code ⑦ Line function is to create the dog Sprite, using CC. The Sprite:createwithspriteframe (FRAME0) statement creates the Sprite object, which we'll cover in more detail later.
The ⑨ line in the Create Farm layer function Createlayerfarm () is local layerfarm = cc. Layer:create () is the creation layer object, which we'll cover in more detail later.

The first line of code returns the Gamescene variable, which is the table type, which is returned when the local scene = require ("Gamescene") statement is called in the main () function.

First Cocos2d-x LUA game