Learning LibGDX Game Development- Second Edition

4.4 (8 reviews total)
By Suryakumar Balakrishnan Nair , Andreas Oehlke
  • Instant online access to over 7,500+ books and videos
  • Constantly updated with 100+ new titles each month
  • Breadth and depth in over 1,000+ technologies
  1. Introduction to LibGDX and Project Setup

About this book

LibGDX is a multiplatform game development framework, and is one of the most popular frameworks for building games, providing a comprehensive set of development capabilities and features to use and incorporate into games.

This book starts off by introducing you to LibGDX and how to use its project setup tool to build an application that can support multiple platforms, before gradually moving on to configuring your game. Then, you will learn to organize resources, create a scene, actors, and a menu system. You will also enhance the visual appearance of your game and manage its transitions, along with music and sound effects. You will then move on to cover the advanced programming techniques and create and manage different kinds of animations.

Finally, you will be introduced to the basics of 3D programming and the 3D physics engine. By the end of this book, you will be able to start developing your very own cross-platform games using the LibGDX framework.

Publication date:
January 2015
Publisher
Packt
Pages
478
ISBN
9781783554775

 

Chapter 1. Introduction to LibGDX and Project Setup

This book will take you on an exciting tour to show and teach you about game development using the open source LibGDX framework. Actually, you have chosen just the right time to read about game development as the game industry is in a remarkable state of change. With the advent of increasingly powerful smartphones and tablets as well as the ever-growing application stores for desktop computers and mobile platforms serving millions of users a day, it has never been easier for Independent Game Developers (also known as Indies) to enter the market with virtually no risks and very low budgets.

In this chapter, you will learn about what LibGDX is and the advantages that it provides when developing your own games. You will also get a brief overview of the feature set that LibGDX provides.

Before you can start developing games with LibGDX, you have to install and set up your development environment accordingly. You will be using the freely available and open source software Eclipse as your Integrated Development Environment (IDE) to set up a basic project that uses LibGDX. It will feature a runnable example application for every currently supported target platform. These platforms are as follows:

  • Windows

  • Linux

  • Mac OS X

  • Android (2.2+)

  • iOS

  • HTML5 (using JavaScript and WebGL)

    Note

    The target platforms, namely, Windows, Linux, and Mac OS X will from now on be referred to as desktop and also share a project in our development environment.

You are going to explore what a game needs by looking at it from a technical standpoint, and why it is so important to plan a game project before the development starts.

At the end of this chapter, you will be introduced to the game project that is going to be developed and enhanced throughout this book.

 

Diving into LibGDX


LibGDX is an open source, cross-platform development framework, which is designed mainly, but not exclusively, to create games using the Java programming language. Besides Java, LibGDX also makes heavy use of the C programming language for performance-critical tasks to incorporate other C-based libraries and to enable cross-platform capabilities. Moreover, the framework abstracts the complex nature of all its supported target platforms by combining them into one common Application Programming Interface (API). One of the highlights of LibGDX is the ability to run and debug your code on the desktop as a native application. This enables you to use very comfortable functions of the Java Virtual Machine (JVM), such as Code Hot Swapping, which in turn lets you immediately see the effect of your changed code at runtime. Therefore, it will significantly reduce your time to iterate through different ideas or even to find and fix nasty bugs more quickly.

Another critical point is to understand that LibGDX is a framework and not a game engine that usually comes with lots of tools, such as a full-blown level editor and a completely predefined workflow. This might sound like a disadvantage at first, but actually it turns out to be an advantage that enables you to freely define your own workflow for each project. For example, LibGDX allows you to go low-level so you could add your own OpenGL calls if that really became necessary at some point. However, most of the time it should be sufficient enough to stay high-level and use the already built-in functionalities of LibGDX to realize your ideas.

 

Features of LibGDX 1.2.0


Since the release of LibGDX Version 0.1 back in March 2010, a lot of work has been contributed in order to improve this library. The latest stable release of LibGDX is Version 1.2.0 from June 2014, which we are going to use throughout this book.

Here is a list of features taken from the official website (http://libgdx.badlogicgames.com/features.html).

Graphics

The graphic features are as follows:

  • Render through OpenGL ES 2.0 on all platforms

  • Custom OpenGL ES 2.0 bindings for Android 2.0 and higher versions

  • Low-level OpenGL helpers:

    • Vertex arrays and vertex buffer objects

    • Meshes

    • Textures

    • Framebuffer objects (GLES 2.0 only)

    • Shaders, integrating easily with meshes

    • Immediate mode rendering emulation

    • Simple shape rendering

    • Automatic software or hardware mipmap generation

    • ETC1 support (not available in JavaScript backend)

    • Automatic handling of OpenGL ES context loss that restores all textures, shaders, and other OpenGL resources

  • High-level 2D APIs:

    • Custom CPU side bitmap manipulation library

    • Orthographic camera

    • High-performance sprite batching and caching

    • Texture atlases with whitespace stripping support, which are either generated offline or online

    • Bitmap fonts (does not support complex scripts such as Arabic or Chinese), which are either generated offline or loaded from TTF files (unsupported in JavaScript backend)

    • 2D particle system

    • TMX tile map support

    • 2D scene-graph API

    • 2D UI library, based on the scene-graph API, fully skinable

  • High-level 3D APIs:

    • Perspective camera

    • Decal batching for 3D billboards or particle systems

    • Basic loaders for Wavefront OBJ and MD5

    • 3D rendering API with materials and lighting system and support to load FBX models via fbx-conv

Audio

The following are the audio features:

  • Streaming music and sound effect playback for WAV, MP3, and OGG

  • Direct access to audio device for PCM sample playback and recording (unsupported in JavaScript backend)

Input handling

The various input features are as follows:

  • Using abstractions for mouse and touchscreen, keyboard, accelerometer, and compass

  • The gesture detector that detects taps, panning, flinging, and pinch zooming

File I/O and storage

The following are the features for the file I/O and storage:

  • Filesystem abstraction for all platforms

  • Read-only filesystem emulation for JavaScript backend

  • Binary file support for JavaScript backend

  • Preferences for lightweight setting storage

Math and physics

The math and physics features for LibGDX are as follows:

  • Matrix, vector, and quaternion classes. Matrix and vector operations are accelerated via native C code where possible.

  • Bounding shapes and volumes.

  • Frustum class to pick and cull.

  • Catmull-Rom splines.

  • Common interpolators.

  • Concave polygon triangulator.

  • Intersection and overlap testing.

  • JNI wrapper for Box2D physics. It is so awesome that other engines use it as well.

  • JNI wrapper for bullet physics.

Utilities

The different utilities in LibGDX are as follows:

  • Custom collections with primitive support

  • JSON writer and reader with POJO (de-)serialization support

  • XML writer and reader

Tools

The following are the different tools in LibGDX:

  • Particle editor

  • Texture packer

  • Bitmap font generator

 

Getting in touch with the community


The LibGDX project enjoys a steadily growing and active community. If you ever find yourself stuck with a problem and you just cannot figure out how to solve it, check out the official forum at http://badlogicgames.com/forum/. There is a great chance someone else has already asked your question and has even found a solution with the help of the community. Otherwise, do not hesitate to ask your question on the forums.

There is also an official IRC channel (#libgdx) on Freenode (https://freenode.net/) where you can find some of the users and developers to talk about LibGDX.

If you want to read about the latest news on development of LibGDX, visit the blog of Mario Zechner who is the founder of the LibGDX project, or follow him on Twitter using the following links:

Also, check out the following links for more in-depth information:

 

Prerequisites to install and configure LibGDX


Before you can start writing any application or game with LibGDX, you need to download and install the library and some additional software.

To target Windows, Linux, Mac OS X, Android, and HTML5, you will need to install the following software:

  • Java Development Kit 7+ (JDK) (v6 will not work!).

  • Eclipse (the Eclipse IDE for Java developers is usually sufficient).

  • Android SDK; you only need the SDK, not the ADT bundle, which includes Eclipse. Install all platforms via the SDK Manager.

  • Android Development Tools for Eclipse, also known as ADT Plugin. Use this updated site (https://dl-ssl.google.com/android/eclipse/).

  • Eclipse Integration Gradle, use this updated site (http://dist.springsource.com/release/TOOLS/gradle).

To additionally target iOS, you will also need:

  • Mac, as iOS Development does not work on Windows/Linux, thanks to Apple

  • The latest Xcode, which you can get from the Mac OS X App Store for free

  • The RoboVM plugin

Java Development Kit

Due to the fact that LibGDX is a framework based on Java, it is necessary to download Java Development Kit (JDK). To install it, follow these steps:

  1. The software is freely available on Oracle's website: http://www.oracle.com/technetwork/java/javase/downloads/index.html. Enter this address and you will see the following page:

  2. Click on the DOWNLOAD button to start downloading the latest JDK.

    Note

    It is important to choose the JDK instead of the JRE package. The reason is that the JDK package contains the Java Runtime Environment (JRE) to run Java applications and everything else that is required to develop them.

    You will have to accept the license agreement and choose the version that is appropriate for your platform. For example, if you are using a 64-bit version of Windows, choose the download labeled as Windows x64. Here, we are using the 32-bit version that is labeled window-i586:

  3. To install the JDK, simply run the downloaded installer file (for example, jdk-8u5-windows-i586.exe) and follow the instructions on the screen:

  4. On the welcome screen of the installer, click on Next to continue:

  5. Then, keep all the features selected to be installed, and click on Next again to continue, as shown in the following screenshot:

  6. Once the installation is complete, click on the Close button to exit the installer.

Eclipse – Integrated Development Environment

The next step is to download and install Eclipse, a freely available and open source Integrated Development Environment (IDE) in order to develop applications in Java. Go to http://www.eclipse.org/downloads/ and choose Eclipse IDE for Java Developers, as shown in the following screenshot, to download for the platform you are using:

Once the download is finished, extract the archive to C:\eclipse\.

Downloading LibGDX

Go to http://libgdx.badlogicgames.com/releases/ and choose the libgdx-1.2.0.zip file to download LibGDX.

Note

At the time of writing this book, the latest stable version of LibGDX is 1.2.0. It is recommended to use the same version while working with this book.

The following screenshot shows a list of all the available files:

In the meantime, create a new folder inside the root folder of your C drive with the name libgdx. Once the download is finished, move the archive to C:\libgdx\.

Installing Android SDK

The Android mobile OS is one of LibGDX's supported target platforms. Before you can create Android applications, you have to download and install the Android SDK.

  1. Go to http://developer.android.com/sdk/index.html and click on the Download the stand-alone Android SDK Tools for Windows button, as shown in the following screenshot. In case you are using an OS other than Windows, you will have to scroll down a bit further, click on Download for other platforms and choose the appropriate platform.

  2. Once the download is finished, run the installer (for example, installer_r22.0.4-windows.exe) and follow the instructions on the screen.

  3. You will see the following screen when you try to install the Android SDK. This is because the installer cannot find the JDK although you have already installed it.

  4. You need to set the value of the environment variable JAVA_HOME to the installation path of the JDK. To find the correct path, go to C:\Program Files\Java\. You will see a folder starting with jdk. Take the full name of this folder (here, it is jdk1.8.0_05) and append it to its path, as shown in the following screenshot:

  5. The complete path will now look like C:\Program Files\Java\jdk1.8.0_05. Now you have to set the environment variable. Click on the Windows Start button and right-click on Computer. Then click on Properties to open the control panel system window, as shown in the following screenshot:

  6. Click on Advanced system settings on the left-hand side of the window, as shown here:

  7. The System Properties window will appear. Click on the Environment Variables button:

  8. The Environment Variables window will appear. Click on the New button (at the top) that corresponds to User variables for <USERNAME> (the username in this case is andreas), as shown here:

  9. A window with the title New User Variable will appear. Now, fill in the two text fields. Enter JAVA_HOME in the Variable name field and the JDK's path you found earlier in the Variable value field, as shown in the following screenshot:

    Great! Now your system is prepared for the Android SDK installer. Make sure to exit the Android SDK installer if it is still running to let the change take effect. You will be presented with the next screen after the installer has restarted.

  10. Now, back in the Android SDK setup, click on Next to continue the installation, as shown here:

  11. The following screenshot will ask you to choose the users for which the Android SDK should be installed. Usually, the suggested Install for anyone using this computer selection is perfectly fine, so just click on Next to continue.

  12. Now, choose the installation location on your computer. You can safely keep the suggested location and click on Next to continue:

  13. After this, you will be asked to choose a start menu folder. Again, you can safely keep the suggestion and click on Install to start the installation process:

  14. After the installation is complete, click on Next to continue:

  15. Once the installation is finished, you can choose to start the Android SDK Manager. Leave the Start SDK Manager (to download system images, etc.) checkbox enabled and click on Finish to start the manager:

    The Android SDK Manager enables you to download system images for the specific API levels you want to develop applications for. For up-to-date and detailed information about Android API levels, check out the link http://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels.

  16. Now, choose at least Android 2.2 (API 8) and/or any other higher API levels that you might need and click on the Install 7 packages button to automatically download and install all the relevant files, as shown in the following screenshot. The reason why we want to use at least API level 8 is that the earlier versions before Android 2.2 do not support OpenGL ES 2.0, which we will need in later chapters. Using a certain API level also allows you to control the range of devices that you will be able to see and install on your application via the Google Play Store.

  17. Once the download and installation process is finished, close the Android SDK Manager window.

Running Eclipse and installing plugins

Great! You are almost done setting everything up. The remaining steps involve running Eclipse for the first time and installing important plugins, which are required to develop applications for Android, iOS, and HTML5/GWT with Eclipse.

Open Windows Explorer, and go to the location where you extracted Eclipse (here, C:\eclipse\), and simply run the program by double-clicking on the executable called eclipse.

Eclipse will ask you to select a so-called workspace. This is the folder where all your projects will be saved. We want to use the C:\libgdx\ folder we created a bit earlier:

Select the Use this as the default and do not ask again checkbox if you don't want to see this dialog box every time you start Eclipse. To proceed, confirm the dialog box by clicking on the OK button.

The first time Eclipse is started with a new workspace, it will greet you with a welcome screen. Simply click on the small cross (x) of the Welcome tab to close it:

You should now see the standard view of Eclipse, which is also called the Java Perspective. On the left-hand side, you can see the Package Explorer section, as shown in the following screenshot. This is where you will see and manage your different projects. This is all you need to know about Eclipse for the moment.

If you have never worked with Eclipse before, it might seem quite overwhelming with all these windows, toolbars, huge context menus, and so on. However, be rest assured that all the steps will be discussed in detail as required to make it easy for you to follow.

To install new plugins, go to the menu bar, and click on Help, and then click on Install New Software. This will open the Install window, where you can type the special repository URLs to browse for new plugins. Google provides a list of such URLs at https://developers.google.com/eclipse/docs/getting_started. You have to choose the correct URL that corresponds with your Eclipse installation.

At the time of writing this book, Eclipse 4.3.2 (Kepler) was the most current version available. According to Google's website, the suggested URL for our version is http://dl.google.com/eclipse/plugin/4.3.

Type the URL in the text field that is labeled Work with and press return to let Eclipse request a list of available downloads. Select everything in the list that is shown in Developer Tools to add support for Android applications. Then, select everything in Google Plugin for Eclipse (required) to install the required Eclipse plugin. Lastly, select Google Web Toolkit SDK 2.5.1 in SDKs to add support for HTML5/GWT applications and click on Next to continue:

Now, click on Next to start the installation:

You will now be prompted to accept the terms of the license agreements by selecting the I accept the terms of the license agreements option. You have to do this before you can click on Finish to continue, as shown in the following screenshot:

The download process should only take a couple of minutes, depending on the speed of your network connection. When downloading is finished, Eclipse will show a security warning that you are about to install unsigned content and wants to know whether it should continue or abort. There is always a potential risk of installing malicious software. However, in this case, the download is provided by Google, a well-known company, which is trustworthy enough. Click on the OK button to accept the warning and continue the installation, as shown in the following screenshot:

After the installation is finished, a final restart of Eclipse is required. Click on the Yes button to confirm the restart:

Now, let's install the Gradle plugin for Eclipse so that we can import the project into Eclipse via Gradle. For this, let's perform the previous steps again. Go to the Install New Software option in the Help menu.

Enter the URL http://dist.springsource.com/release/TOOLS/gradle in the Work with field:

Select Gradle IDE under Extensions / Gradle Integration and click on Next. Continue as you did while installing Eclipse plugins to finish the process.

Additionally, in order to enable the iOS development, you need to install the RoboVM plugin in Eclipse. RoboVM for Eclipse integrates the RoboVM AOT (ahead-of-time) compiler with the Eclipse Java IDE. With this plugin, you will be able to develop native iOS apps in Java and launch them on the iOS simulator and iOS devices from within Eclipse.

Note

To execute an application using RoboVM as backend, you need a Mac with Mac OS X 10.9 or higher version with Xcode 5.0 or higher version installed. However, you can construct the project in Windows and later copy it to Mac for execution.

To download and install the latest RoboVM plugin, we will perform the same steps that we did to install Eclipse plugins earlier. Go to the Install New Software option in the Help menu.

Enter the URL http://download.robovm.org/eclipse/ and continue, as shown in the following screenshot:

The latest RoboVM release while writing the book was v0.0.13.

Congratulations! You have just finished the installation of everything that you will need to develop and build your own games with LibGDX.

 

Creating a new application


The next step is to create a new application. Usually, you would have to create several projects in Eclipse: one project for the shared game code, another one for the desktop launcher, and more for the Android, iOS, and HTML5/GWT launchers. Furthermore, the projects would also have to be configured and linked together in a certain way. This is quite a time-consuming task and more or less an error-prone process for inexperienced users.

Luckily, LibGDX provides tools to generate preconfigured projects for a new application that can be directly imported into Eclipse. There are two tools to create a LibGDX project, the latest one is using Gradle, and the old project setup tool written by Aurelien Ribon. First, we will learn about the old setup tool and then about the Gradle setup tool.

Using the old setup tool

The old project setup tool is an executable JAR file called gdx-setup-ui.jar.

Step 1

You can download the old setup tool from https://github.com/libgdx/libgdx-old-setup-ui, as shown here:

Step 2

To run the tool, double-click on the gdx-setup-ui file. When the program starts, click on the big Create button:

Step 3

In the next window, you will see a box labeled CONFIGURATION on the left-hand side. Here, you can configure what the tool will generate.

Enter demo in the Name field, which defines a common project name for your application. Each launcher project will add its own suffix to it, such as -desktop, -android, or -html. A preview of the outcome is shown in the OVERVIEW box on the right-hand side of the window.

The Package field defines the name of your Java package. This needs to be a unique identifier written in lowercase, which is usually derived from a reversed domain name. You do not have to own a domain name nor does it have to really exist, but it helps in choosing nonconflicting namespaces for Java applications. This is especially important on Android, as identical package names for two separate applications would mean that the already installed application is going to be overwritten by the second one while trying to install it. For this demo application, use com.packtpub.libgdx.demo as the package name for now.

The Game class field defines the name of the main class in the shared game code project. Enter MyDemo as the game class name.

The Destination field defines the destination folder where all the projects will be generated. Click on the blue folder button (just next to the field) and set the destination folder to C:\libgdx\.

In another box called LIBRARY SELECTION, the status of required libraries is shown. If there is any item listed in red, it needs to be fixed before any project can be generated. You will see LibGDX being listed in red in the Required section. Click on the blue folder icon next to it:

Step 4

Then, choose the downloaded archive file libgdx-1.2.0.zip from C:\libgdx\ and click on Open, as shown in the following screenshot:

Step 5

The text color of the LibGDX label should have changed from red to green by now. Click on the Open the generation screen button to continue:

Step 6

Next, click on the Launch! button to generate all the projects, as shown here:

Step 7

All done! You can now go to Eclipse and start importing the generated projects into your workspace. To do this, simply navigate to the Import option in the File menu.

Step 8

In the Import dialog box, open the General category, select Existing Projects into Workspace, and click on the Next button, as shown here:

Step 9

Click on the radio button Select root directory and enter C:\libgdx in the text field. This is the directory where all your generated projects were created. You need to confirm your text input by pressing the return key once. Eclipse will start to scan the directory for your projects and list them. Leave all checkboxes selected and click on the Finish button, as shown in the following screenshot:

Step 10

Eclipse will automatically try to build (compile) all the four newly imported projects in your workspace and probably fail. There are two issues that need to be resolved manually after the import. The first one is reported directly to the Console window in Eclipse. It complains about being unable to resolve the target android-15, as shown in the following screenshot:

You have to open the project properties of the demo-android project. First, select it in the Package Explorer box on the left-hand side. Then, go to the menu bar and navigate to Properties option in the Project menu:

Step 11

The title of the window will say Properties for demo-android. If this is not the case, close the window and make sure you have selected the correct project and try again. Next, select Android from the list on the left-hand side. You will see a list of targets that are available on your system. Select Android 2.2, which uses API level 8, and click on the OK button, as shown here:

Step 12

Eclipse will recognize the change and successfully build the Android project this time.

The second issue requires you to click on the Problems tab in Eclipse. Open the Errors list and right-click on the reported problem, which will say The GWT SDK JAR gwt-servlet.jar is missing in the WEB-INF/lib directory. Choose Quick Fix from the context menu, as shown in the following screenshot:

Step 13

In the Quick Fix dialog box, select Synchronize <WAR>/WEB-INF/lib with SDK libraries as the desired fix and click on the Finish button, as shown here:

The two issues will be solved by now, which means that all the projects are now automatically built without failure and can be compiled.

Note

Though the steps to create a project using gdx-setup-ui might seem difficult, actually it's very easy. In our book, we will generate the project setup for our first game using this setup tool, and later in Chapter 14, Bullet Physics, we will use the Gradle-based tool to generate the project, thereby mastering the two technologies.

Using the Gradle-based setup

For the first game, we will use the projects generated using the old setup tool; however, read this section and understand how it works, so that we can use it later in Chapter 14, Bullet Physics.

You can download the gdx-setup.jar file from http://libgdx.badlogicgames.com/download.html and then click on Download Setup App, as shown in the following screenshot:

However, we have already downloaded the libgdx-1.2.0.zip file, which contains gdx-setup.jar; hence, we will extract gdx-setup from the archive. To run the tool, double-click on gdx-setup to get the following screenshot:

The Name, Package, Game Class, and Destination fields are the same that we learned for the old project setup tool.

The Android SDK field defines the path to where you have installed your android sdk. Click on the Browse button and set it to the android sdk folder. Here, it's C:\Program Files\Android\android-sdk.

We will now select Release 1.2.0 from the drop-down list in the Libgdx Version field. Next under the Sub Projects tab, you can select the hardware platforms that you want to support. Here, we select all four, namely, Desktop, Android, Ios, and Html.

Finally, you can select the extensions (for example, box2d, physics bullet, and so on) to be included in your app. Some might not work on all the platforms for which you'll get a warning. For the demo, we don't need any extensions, hence ignore this part.

Note

Once chosen and created, you will have to add new hardware platforms or extensions manually. For manually adding dependencies, visit https://github.com/libgdx/libgdx/wiki/Dependency-management-with-Gradle.

Now, click on the Advanced button, enable Eclipse, and then click on Save, as shown in the following screenshot:

Now that we have set everything, click on Generate.

Note

The gdx-setup option will prompt you to download and install the latest SDK platform and build tools. Just ignore this. While writing the book, the SDK platform was 19 and build tools were 19.0.3.

It will take a while to download and generate the projects. Make sure that you are connected to the Internet. Finally, it will display BUILD SUCCESSFUL like this:

This means you are now ready to import the project into your IDE, run, debug, and package it! All done! You can now go to Eclipse and start importing the generated projects into your workspace.

You can import projects to Eclipse as in the old project setup by following Step 7 to Step 9. However, in order to access the features of the Gradle plugin, you need to import it quite differently. Navigate to the Import option in the File menu. In the Import dialog box, select the Gradle Project subfolder from the Gradle folder, as shown in the following screenshot:

Now in the Import Gradle Project window, click on Browse and select the folder where you created the demo project. Here, it's C:\libgdx. Then, click on the Build Model button:

It will take a while to build the project. After this, select the different projects and click on Finish, as shown in the following screenshot:

All done! After importing, change the API level of Android to 8 by following Step 10 and Step 11 from the old project setup.

 

gdx-setup versus gdx-setup-ui


Before entering into the game, let's make a quite distinction between the two project setup tools. Why choose one over the other?

There is no doubt that the Gradle-based setup tool is the best. One of the biggest advantages of using Gradle is the dependency management system. The dependency management system is quick, simple, efficient, and easy. If you are developing a simple project without any extensions such as Box2d, you might use the old setup tool; however, if you are developing a multi-platform project, which might be updated soon, then you can use the Gradle-based setup tool.

The projects generated using Gradle and the old setup tool have some minor naming differences that are illustrated in the following figure:

The Java classes shown in the preceding figure are starter classes; we will learn about them in the next chapter. Although the names for projects, packages, and classes generated by the two tools are slightly different, other aspects of the projects such as the assets folder, manifest files, and project wiring are the same.

Note

All the chapters in this book will be explained based on the projects generated from the old setup tool. However, understanding projects generated from Gradle is very easy because the names are easily comparable.

The old setup tool (gdx-setup-ui) is now not encouraged by LibGDX and it might be phased out later; however, it is included in this book because it will be useful for smaller projects.

You can also see that the projects generated and organized under the C:\libgdx path are different for both tools. The old setup tool (gdx-setup-ui) creates all the five projects in the respective folders, as shown in the following screenshot:

However, the Gradle-based tool (gdx-setup) creates a lot file, as shown here:

Observe that our projects are named core, android, desktop, html, and ios. Additionally, take a note of the build.gradle file. This file is important because this is the file you need to edit in order to add more dependencies (such as hardware platform) or new extensions (such as Box2D or Bullet).

 

Kicking your game to life


Let's take a moment to discuss what a game basically consists of. From a very high-level point of view, a game can be split up into two parts: game assets and game logic.

Game assets include everything that is going to be used as a kind of working material in your game, such as images, sound effects, background music, and level data.

Game logic is responsible for keeping track of the current game state and to only allow a defined set of state transitions. These states will change a lot over time due to the events triggered either by the player or by the game logic itself. For example, when a player presses a button, picks up an item, or an enemy hits the player, the game logic will decide the appropriate action to be taken. All this is better known as gameplay. It constrains the ways of action in which a player can interact with the game world, and also how the game world would react to the player's actions.

To give you a better idea of this, take a look at the following diagram:

The very first step is to initialize the game, that is, loading assets into memory, creating the initial state of the game world, and registering with a couple of subsystems, such as input handlers for keyboard, mouse and touch input, audio for playback and recording, sensors, and network communication.

When everything is up and running, the game logic is ready to take over and will loop for the rest of the time until the game ends and will then be terminated. This kind of looping is also referred to as the game loop. Inside the game loop, the game logic accumulates all (new) data it is interested in and updates the game-world model accordingly.

It is very important to consider the speed at which updates will occur in the game world. Currently, the game will just run at the maximum speed of the available hardware. In most cases, this is not a desirable effect because it makes your game dependent on the processing power and the complexity of the scene to be rendered, which will vary from computer to computer. This implies that your game world will also progress at different speeds on different computers with an almost always negative impact on the gameplay.

The key to tackle this issue is to use delta times in order to calculate the fractional progress of the game world. The delta time is the real time between the last rendered frame and current frame. Now, every update to the game world will occur in relation to real time that is passed since the last frame was rendered. You will see how this actually works with LibGDX in the later examples.

What you have just read was an overview of the basic concept to create games. Yes, it is that simple! Frankly speaking, there is a lot more to learn before your application becomes a real game. There are lots of topics and concepts waiting to be discovered in this book. For instance, you will need to understand how to use and manage different images in an efficient manner. Efficiency becomes even more important if you plan to target mobile devices such as Android or iOS smartphones, where the available resources are constantly scarce.

 

Key to success lies in planning


Great! Now you have your development environment set up and a basic understanding of what a game is and what it might need. It appears to be a good idea to dedicate some additional time to think about your first game project and create a plan for it. In general, planning your game projects is what you should always do in the first place before any actual work is done. For novice game developers, it might be very tempting to skip this planning phase, which admittedly is a lot more fun in the beginning, but this approach is very likely to fall short in the long run. You will need some sort of outline of what you want to achieve. It does not have to be a very long and detailed description.

A simple and brief feature list of your design goals will do just fine for this purpose. The reason behind this is that you will make yourself aware of each single feature that is a part of your game. In addition, this list will also serve you as a great tool to measure and compare your progress in the game during the development phase. Bear in mind that game development is a very dynamic and iterative process. Although, you should try to adhere to your list of design goals for most of the time, there should always be room to adapt to shifting requirements. Just keep in mind that adhering to the list will make sure that you are going to push development in the right direction. Conversely, it will let you focus on the important parts first, while also protecting you from running out of time and taking too many detours, which prevents you from reaching the finish line due to unclear goals.

 

Game project – Canyon Bunny


To make this guide both easy and fun to read, it makes perfect sense to show you how to plan and develop a whole game project throughout this book. As we now know, planning should be the first step to take on the journey of any new game project.

So, let's begin with the outline:

  • The name or working title for the game will be Canyon Bunny

  • The genre will be 2D side-scrolling jump and run

  • The list of actors are as follows:

    • The player character (can jump and move forward and will be controlled by the player)

    • Rocks will be serving as platforms for the player character and items

    • Canyons in the background (for level decoration)

    • Clouds in the sky (for level decoration)

    • Water at the bottom of the level (which will be deadly for the player character)

    • Collectible items (such as gold coins and feather power-up) for the player

Next, it is always helpful to write down some supporting text to further describe the overall behavior of the game, and how the features should be implemented.

Description of the game

The game world is presented in a 2D-side view to the player. The view will scroll horizontally to the right-hand side when the player character moves forward. The background shows distant canyons and clouds in the sky. The bottom of the level is filled with water and will instantly kill the player character if both get in touch with each other.

The player character will move on and jump over to random rocks, sticking out of the water. The width and height will be different to make the game more challenging. The player is only in control of a jump button, which will keep the automatically forward-moving player character from falling down into the deadly water.

The level will be randomly populated with collectible items consisting of gold coins and feather power-ups. Collecting the gold coins will increase the player's high score. The feather power-up grants the player character the ability to fly for a limited time and can be used by repeatedly pressing the jump button. The player's goal is to beat the last high score.

As a picture is worth a thousand words, creating a sketch based on our outline can help us even more to get a better idea of the resulting game. Moreover, changing a sketch is usually a lot easier than having to change (complex) game code. So, you really want to keep it very simple; just grab your pen and paper and start to draw. If you feel lucky or have some time to spend, you can do something more elaborate, of course.

Here is a mock-up for Canyon Bunny:

The previous mock-up has been created entirely by using vector graphics. Using vector graphics in favor of raster graphics for your sketches can be an advantage as they are infinitely scalable to any size without losing the image quality. However, the final graphics used in games are almost, always, rasterized graphics, simply because vector graphics are costly to render in real time. So, the common approach is to create vector graphics and later on export them choosing an appropriate rasterized graphics file format, such as Portable Network Graphics (PNG) for lossless compression with alpha channel support, or Joint Photographic Experts Group (JPEG) for lossy but high compression without alpha channel support.

For more details, check out the following Wikipedia articles:

There is a free and open source tool called Inkscape similar to Adobe Illustrator. It allows you to easily create your own drawings as vector graphics and is available for Windows, Linux, and Mac OS X. Check out the project's website http://inkscape.org/.

 

Summary


We learned a lot about LibGDX in this chapter and all the other bits and bobs to prepare your system for multi-platform game development, specifically on the following points:

  • We discussed every step in great detail to successfully download, install, and configure all the required software components: JDK, Eclipse, LibGDX, Android SDK, and additional Eclipse plugins for Android, HTML5/GWT, and RoboVM.

  • We learned how to use the project setup tool that comes with LibGDX to easily generate all the required Eclipse projects for a new application and how to import them. We also learned what a game needs to come alive.

  • We found out why planning game projects is so important.

  • We also saw how to plan a game project by writing an outline.

In Chapter 2, Cross-platform Development – Build Once, Deploy Anywhere, we will learn more about how to deploy and run a LibGDX application on all supported target platforms. Building on this knowledge, we will finally jump to the first code examples where the magic happens and take a closer look at it to find out how it works.

About the Authors

  • Suryakumar Balakrishnan Nair

    Suryakumar Balakrishnan Nair is an engineering graduate from Cochin University of Science and Technology, Cochin, India with a specialization in computer science. He just loves programming and likes to keep on experimenting.He has designed a dozen games on the Android platform using LibGDX.

    He loves traveling and visiting various places. He reads articles and books on a range of issues from politics to environment. He is currently working as a full-time Android game developer for an Indian game company, Csharks (http://csharks.com/site/).

    Browse publications by this author
  • Andreas Oehlke

    Andreas Oehlke is a professional software engineer and computer scientist who feels very much at home on any Linux/UNIX machine. He holds a bachelor's degree in Computer Science and loves to assemble and disassemble software and hardware alike. The exorbitant affinity for electronics and computers has always been his trademark. His hobbies include game and web development, programming in general (software design and new languages), programming embedded systems with microcontrollers, playing sports, and making music.

    He currently works full time as a software engineer for a German financial institution. Furthermore, he has worked as a consultant and game developer in San Francisco, CA. In his spare time, he provides his expertise to a German start-up called Gamerald (http://www.gamerald.com/).

    Browse publications by this author

Latest Reviews

(8 reviews total)
Just because 1 2 3 4 5 6 7 8 9 0 1 2.
Very good, easy to deal with
Batante bien como libro de apoyo.

Recommended For You

LibGDX Game Development By Example

Learn how to create your very own game using the libGDX cross-platform framework

By James Cook
Mastering LibGDX Game Development

Leverage the power of LibGDX to create a fully functional, customizable RPG game for your own commercial title

By Patrick Hoey
Building a 3D Game with LibGDX

Learn how to build an exciting 3D game with LibGDX from scratch

By Sebastian Di Giuseppe
LibGDX Cross-Platform Development Blueprints

Develop four exciting, cross-platform games using LibGDX with increasing complexity and understand its key concepts

By Indraneel Potnis