Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon
13. March 2019


Just 7 years after doing our Battle of the Lua Game Engines comparison between Gideros, Corona, Love and MOAI, we have finally done a hands-on review of the Gideros game engine.  A lot has changed in 7 years, including the fact that Gideros is now free and open source, available on GitHub.  It is a well documented, cross platform (Windows, Mac, Linux, Pi) 2D game engine capable of targeting all those platforms as well as the most popular mobile platforms including iOS and Android.  One of the biggest strengths of Gideros is it’s Player application, enabling real-time testing over Wi-Fi, vastly improving the testing and deployment phases.

Thankfully you do not have to build Gideros from source, with downloadable installers available here.  In addition to Gideros, I highly recommend you check out ZeroBrane Studio for a superior Lua development experience.

The following video shows Gideros Studio in action:


The code we created in the video above was:

local font = TTFont.new("Roboto.ttf", 64)
local text = TextField.new(font,"Hello Cruel World!")
text:setPosition(application:getContentWidth()/2,application:getContentHeight()/2)

stage:addChild(text)

function mainLoop()
	local x,y,z = text:getPosition()
	text:setPosition(x,y+1)
	text:setTextColor(0xff0000)
end

stage:addEventListener(Event.ENTER_FRAME, mainLoop)
You need to place a font named Roboto.ttf (or any ttf font, just change the parameter in the first line of code if you substitute your own font) in your assets directory for this to run.

If Gideros doesn’t appeal to you, but you are still interested in a Lua based game engine, be sure to check out our Love/Lua tutorial series available here.

Programming


3. January 2019


Corona is an open source Lua powered cross platform game engine, first released way back in 2009.  Back in 2017 Corona was released for free, after being acquired by AppoDeal earlier in the year.  Yesterday they announced that Corona will now be available under a dual licenses, GPLv3 and a proprietary commercial license.  If you require more details on the various open source licenses, be sure to check out our guide to open source licenses available here.

Details of the open sourcing:

“The transition of Corona to the open source model of development has been our long-term vision since Corona Labs was acquired by Appodeal in 2017. We believe that this move will bring transparency to the development process, and will allow users to contribute features or bug fixes to make the project better for everyone,” said Vlad Sherban, product manager for Corona Labs.

The open source model will bring more visibility and flexibility to the development process by allowing visibility into exactly what the engine team is working on and where the project is going, and by contributing valuable new features that will help spearhead Corona to the next level. Additional benefits for businesses include the potential to acquire a commercial license for source code and customize the engine for specific commercial projects.

“Corona Labs will continue to have a dedicated team and infrastructure to support our flourishing plugin ecosystem and infrastructure, as well as to keep up to date with the ever-changing requirements and updates coming from applications stores. Powered by the new open source model and supported by the development of new features and bug fixes will make Corona more community driven — but not without our help and guidance. Ultimately, going open source will provide confidence in the future of the engine and an opportunity to grow community involvement in engine development,” said Vlad Sherban, product manager for Corona Labs.

Corona is available under a split license:

  1. You can download the Corona source code under the GPLv3 license and build your games and apps, however, those games have to be distributed under the GPLv3 license, i.e you have to make your source available. Games and apps based on the open source distribution of Corona have to be distributed using the same license (GPLv3).
  2. You can download the Corona source code, negotiate a commercial license agreement with Corona Labs, and build a version of Corona that has a custom feature. You can then distribute your games and apps without opening your own source.
  3. This does not apply to daily builds and releases. Their license remains unchanged. You can download builds to freely build and distribute your apps as before. The new changes only apply to the source code of the engine which is now available.

The last point is important, as it means existing customers using the free engine can continue to use the binary releases for free, so long as they don’t touch the source code.  Speaking of source code, the code is now live on GitHub.

GameDev News


24. September 2018


Defold is a free 2D Lua powered game engine made by King.  If you are interested in learning more about the Defold game engine, be sure to check out our existing Defold Tutorial Series, and stay tuned for our upcoming Defold Crash Course, currently available in preview form for Patreons.  The 1.2.137 release includes a new angular velocity mode for particle systems, new build options and the removal of Linux and OSX 32 bit version.


Full details from the release:

Engine

  • DEF-1593 - Added: New particle orientation mode for angular velocity.
  • DEF-2477 - Added: Engine build variants - debug, release and headless in Bob and Editor bundle dialogue
  • DEF-3487 - Changed: Removed 32 bit Linux+OSX engines from bob.jar.
  • DEF-3496 - Fixed: Missing iPad Pro 10.5" launch images.
  • DEF-3047 - Fixed: Log spam on Android 8+ devices related to CPU profiler.
  • DEF-3494 - Fixed: http.request() failed under certain conditions.
  • DEF-3456 - Fixed: Cloned spine nodes were not getting correct skin and animation.
  • DEF-1966 - Fixed: Collection proxies did not handle input consumption correctly.
  • DEF-3489 - Fixed: X11 context initialization for the Linux engine.
  • DEF-2929 - Fixed: on_input in GUI was missing accelerometer fields.
  • DEF-3464 - Fixed: Bug with stored notifications were not received on Android.
  • DEF-3479 - Fixed: Added API check before attempting to login with Facebook.

Editor

  • DEFEDIT-1420 - Changed: Long-running tasks such as bundling, building and saving are now performed on a background thread.
  • DEFEDIT-1420 - Fixed: The editor will no longer overwrite external changes when saving if it has not detected them.
  • DEFEDIT-1420 - Fixed: Broken library URLs are now reported correctly when bundling or building for HTML5.
  • DEFEDIT-1420 - Fixed: Sometimes the progress bar could disappear, leaving only the percentage-label visible.
  • DEFEDIT-1427 - Fixed: The Property and Outline panels could stop redrawing while a Particle FX or animation was playing.
  • DEFEDIT-1430 - Changed: Visibility Filters now have separate toggles for components inside or outside of GUI scenes.
  • DEFEDIT-1432 - Fixed: Improved progress reporting in several areas.
  • DEFEDIT-1437 - Fixed: Fixed occasional “File Not Found” errors when returning to the editor after switching branches.
  • DEFEDIT-1439 - Fixed: Updated autocomplete definitions for the Code Editor.
  • DEFEDIT-1440 - Fixed: Bundling a project with native extensions reported Ready too early.

GameDev News


6. September 2018


Recently we have broken down lists of 3D game engines that use the C++ language or C# language as a programming language for game logic.  Today we are going to look at game engines using the Lua programming language.  This doesn’t mean the game engine was created using the Lua language, instead we are covering engines that can be scripted using Lua.  In this list, unlike the previous two, we are going to include both 2D and 3D game engines in the list.  Additionally, for 2D engines, we will also include frameworks that don’t necessarily include level editors.


2D Lua Engines:

Defold (Learn More)

Corona

LÖVE (Learn More)

Gideros

Raylib (Learn More)

Instead


3D Lua Engines:

Spring RTS

GameGuru (Learn More)

Shiva

Leadwerks

Lumberyard (Learn More)

Roblox Studio

Urho3D (*Needs to be enabled)

Stingray|3DS Interactive


Defunct:

CryEngine (Deprecated)

Cocos2D (Undocumented)

PolyCode (Seemingly abandoned)

Marmalade (Deprecated)


Video

Programming


21. February 2017

 

Somewhat delayed from the rest of the Defold Engine tutorial series, I realized there was a major gap in subjects we covered... GUI programming.  Defold actually has some really solid UI functionality built in, and in this tutorial we are going to look at the basics of handling a UI in Defold. Well very conventional in it’s approach, if you’ve gotten accustomed to the Defold way of doing things, you will find Defold’s approach to handling UI remarkably consistent to the way you do just about everything else using the Defold game engine.

 

As always, there is an HD video version of this tutorial available here.

 

In this tutorial we are going to implement the simplest of UI, but all of the concepts of a much more complicated interface can easily be extrapolated from what we cover here. We are going to create a UI that pops up when the user hits the ESC key, dimming the existing screen, showing the UI, handling input, then un-dimming the UI.  There is a ton more UI functionality available in Defold, but it should be fairly easy to pick it up once you’ve got the basics down.  So without further ado, lets jump right in.

 

A UI in Defold consists of two different file types, a .gui and a .gui_script file.  A gui_script file is just a traditional lua script file, but has access to the gui namespace.    Let’s take a step by step look at creating a UI that appears when you hit the ESC key and handles a simple button being clicked.

 

First we need a font, drag any applicable TTF file to your project.  I personally created a folder called MyFont and dragged it there.  Next I created a Font file in the same folder.

image

 

Next open the newly created Font file and select the ttf file you just imported.  Please note that the filter is broken and you should manually type *.ttf to locate your font.

image

After selecting the font I also increased the size to 30pts.  This is aesthetic and purely optional.

 

Now that we have a font selected, we need to define an Input map.  I fully describe the process here for more information on how Input Maps work in Defold.  This are the bindings I created:

image

 

Next we create our gui file.  Simply select Gui File:

image

 

We can use the Gui File to arrange the controls that make up our UI.  Here are the options:

image

 

In this simple UI we are simply going to create a button by creating a box then adding a text label to it.  We will also create a label telling the user to click the button.  First we need to set up our font that we created earlier.  In the GUI editor, right click Fonts and select Add Font:

image

 

When prompted, select the font you just created:

image

 

Now right click Nodes and add a Box.  Once created it can be positioned by hitting W then moving manually.

TransformBox

 

Next right click the newly created box node and create a child Text field:

image

 

Child nodes automatically inherit the position of their parents.  With the Text node selected, lets set it’s font and text, like so:

image

 

I also created another Text field telling the user to click the button.  This one in the root of the GUI hierarchy and not parented to the box.  You’re outline should look something like:

image

 

While your Gui layout should look something like:

image

 

Now that we have a gui file, let’s right a script that will display it.  In our main.collection I simply create a new script and attach it to the default logo objecct.

image

 

Now of course we need to add the UI to our game object.  Create a new root level GameObject named UI, then add component from file and select our gui file:

image

 

So now you main.collection should look something like:

image

Now we enter the following code for main.script:

function init(self)
	-- we want focus and to hide our UI until needed
    msg.post(".", "acquire_input_focus")
    msg.post("UI","disable");
end


function on_message(self, message_id, message, sender)
	-- Wait for a message from the UI layer that the UI has been dismissed
	-- un-dim our sprite
    if(message_id == hash("DONE_UI")) then
    	go.set("#sprite","tint.w",1.0)
    end
end

function on_input(self, action_id, action)
	-- If the user hits the ESC show the UI and dim our sprite
    if(action_id == hash("ESC") and action.released) then
    	-- UI needed now, reenable
    	msg.post("UI","enable")
    	go.set("#sprite","tint.w",0.2)
	end
end

 

This code does a couple things, first on input it tells Defold we want to get input messages.  We also start out by disabling the UI, by sending it the built-in message disable.  When the user actually hits the escape key, we send a message to re-enable the UI layer.  We also dim the logo sprite so it’s not visually in focus when the UI is active.  Also note we wait for the DONE_UI message to undim our sprite.  This is sent by the UI script, which we will create now.

 

If you select your .gui file, in the properties you will notice there is a setting for Script.

image

 

There is a special kind of script, .gui_script, that is used to control gui objects, the Gui Script File.  Let’s create one in the same folder as our .gui file:

image

 

This is a standard lua script, but it has access to the gui namespace.  Once you’ve created your gui_script, set it as the script for your gui file.  Now enter the following script:

function init(self)
	-- We want input control.  AKA, pump input to the UI
    msg.post(".", "acquire_input_focus")
    
end

function on_message(self, message_id, message, sender)
	-- Expect to be enabled by main when needed.  Acquire focus and set text back to click me
	if(message_id == hash("enable")) then 
		msg.post(".", "acquire_input_focus")
		gui.set_text(gui.get_node("text"),"Click Me")
	end
end

function on_input(self, action_id, action)
	-- handle left clicks.  On left click, see if click was within box
	-- if so change our text (this wont actually be seen), disable ourself and pass a message back
	-- to logo that we are done so it can undim itself
	if(action_id == hash("LEFT_CLICK") and action.released == true) then
		local box = gui.get_node("box")
		if(gui.pick_node(box,action.x,action.y)) then
			local text = gui.get_node("text")
			gui.set_text(text,"Clicked")
			msg.post(".","disable")
			msg.post(".","release_input_focus")
			msg.post("/logo",hash("DONE_UI"))
			
		end
	end
end

 

This code waits for the enable message then sets input focus so the gui can receive input messages from Defold.  It also illustrates how you could change the text of a component within the gui.  The most important logic is in the on_input event handler.  We wait for the LEFT_CLICK input.  We then check to see if the click was within our box, if so we set the text of our control ( which is somewhat pointless as it’s about to be hidden! ) to “Clicked”, disable our self, release input focus then send the message DONE_UI back to main.script.  Now if you run the code:

GIF

 

Of course we only scratched the surface of what you can do in a Defold gui, but that should certainly get you started!

 

The Video

Programming


GFS On YouTube

See More Tutorials on DevGa.me!

Month List