Chapter 10. Optimizing, Testing, and Shipping Your Games

Developing a game to the point of completion is a great accomplishment. It's one step closer to sharing it with the rest of the world, so that other people can play your new game. The benefit of creating your game with Corona SDK is that you have the option to build for iOS and/or Android. You want to ensure that your application is ready for submission so that it can be distributed in the mobile platform you're developing in. We'll go over the process of what it takes to prepare your game for its release.

Note

The application interface used here is frequently updated; however, you will be able to perform all the steps irrespective of the interface you're using.

In this chapter, we will cover the following topics:

• Improve the performance of your application
• Set up a distribution provisioning profile for the App Store
• Manage application information in iTunes Connect
• Learn how to submit an application to the Application Loader for the App Store
• Sign applications for Android
• Learn how to submit an application to the Google Play Store

Understanding memory efficiency

As you develop your application, you should always consider how your design choices affect the performance of your application. The device memory still has its constraints even though there are improvements in the computing power and memory. Performance and optimization within the device will not only achieve faster response times, but also help minimize memory usage and maximize battery life. A link to an example on how to check memory usage can be found at https://gist.github.com/JesterXL/5615023.

Memory is an important resource on mobile devices. When too much memory is being consumed, devices may be forced to quit your application when you least expect it. Here are some things to be aware of while developing:

• Eliminate memory leaks: Allowing leaks to exist means having extra used memory in your application that takes up valuable space. Even though Lua does automatic memory management, memory leaks can still occur in your code. For example, when you introduce global variables into your application, it is your job to tell Lua when they are not needed anymore so that memory can be freed. This is done through using nil in your code (myVariable = nil).
• Display images should be small in file size as much as possible: You may want to have many display images in your scene, but they may take up too much texture memory. Sprite sheets can take a toll on the memory in your apps. They should be created as small as conveniently possible and have an appropriate number of frames that demonstrate the animation clearly. For all items that you have displayed, plan out which elements are constantly in your background and foreground. If there is a way to combine several images together so that they don't move, do so. It'll save some memory when adding multiple display images.
• Do not load all your resources at once: Avoid loading resource files until they are actually needed. This will help save memory and keep your application from crashing while trying to load too many things at once.
• Remove objects from the display hierarchy: When a display object is created, it is implicitly added to a display hierarchy. When you no longer need a display object, you should remove it from the display hierarchy, especially when the objects contain images. This can be done using display.remove( myImage ); myImage = nil or myImage:removeSelf().

  Here is an example:

  local box = display.newRect( 0, 50, 100, 100)
  box:setFillColor( 1, 1, 1)
  box.alpha = 1
  
  local function removeBox()
    if box.alpha == 1 then
      print("box removed")
      display.remove( box )
      box = nil
    end
  end
  timer.performWithDelay( 1000, removeBox, 1 ) -- Runs timer to 1000 milliseconds before calling the block within removeBox()

• Sound files should be made as small as possible: Use a free program, such as Audacity at , or your preferred audio software to compress music or sound effects and build for the device. It is best to compare untouched audio with compressed audio to hear the difference in quality. This will help you determine a good median between sound quality and file size.

Graphics

Display images have a way of taking up a lot of texture memory if you're not paying attention to the size and number of images being used all at once.

Group objects

If a property of several objects is set to the same value, it's preferable to add the objects to a group and then modify the property of the group. It'll make it much easier for you to code, and it optimizes your animation.

Turning off animations when they're not being used

It's easy to forget to stop animations from running in the background when they're not needed or when you've made them invisible.

When you include a listener such as "enterFrame" and the objects registered under the listener have been set to .isVisible = false, it'll continue to run in the background even though it is not seen on screen. Make sure that listeners are removed when they are not needed.

Optimizing image sizes

When you have large file sizes, especially full-screen images, the responsiveness of your application will slow down because of the time it takes to load, and plus, it uses up a lot of memory. When using large images, try compressing the file size as much as you can with an image-editing tool, such as Photoshop or ImageOptim (https://imageoptim.com). It'll help reduce the file size and save you the pain of application lag. Compressing large image sizes will benefit you in the long run. If images are backgrounds, consider switching to tiled images.