Java Game Development

LIBGDX dependency injection with Dagger

2015-04-27T04:58:00.000-07:00

So I've given up on writing games with JavaScript and decided to go back to good old Java. I love Java, and now with LIBGDX creating cross platform games has never been easier (and fun!).

In this article, I'm going to focus on enhancing the LIBGDX library to accommodate dependency injection with the lightweight IoC Dagger.

Note - this method has only been tested on the Desktop and Android LIBDGX deployments, however, as Dagger pre-complies dependencies it *should* work on other platforms, but alas I haven't got around to testing the HTML or IOS deployments yet .

The basic design I'm going to follow is to provide an adapter class to handle the construction of the Dagger object graph and delegate calls to the game's ApplicationListener. We need to make sure we follow the LIBGDX ApplicationListener's interface, otherwise the object graph will be created before the LIBGDX game engine has had a chance to initialise itself.

So here we go.

First up we will make sure we have the correct dependencies in our Gradle build file. I don't pretend to be a Gradle guru, but this seems to be working fine for me:

build.gradle

buildscript {
    repositories {
        mavenCentral()
        maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
    }
    dependencies {
        classpath "com.android.tools.build:gradle:1.0.0"
        classpath "com.neenbedankt.gradle.plugins:android-apt:1.4+"
    }
}

allprojects {
    apply plugin: "eclipse"
    apply plugin: "idea"
    version = '1.0'
    ext {
        appName = 'example-game'
        gdxVersion = '1.5.6'
        roboVMVersion = '1.0.0'
        box2DLightsVersion = '1.3'
        ashleyVersion = '1.3.1'
        aiVersion = '1.5.0'
    }

    repositories {
        mavenCentral()
        maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
        maven { url "https://oss.sonatype.org/content/repositories/releases/" }
    }
}

project(":desktop") {
    apply plugin: "java"
    dependencies {
        compile project(":core")
        compile "com.badlogicgames.gdx:gdx-backend-lwjgl:$gdxVersion"
        compile "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-desktop"
        compile "com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-desktop"
    }
}

project(":android") {
    apply plugin: "android"
    apply plugin: "com.android.application"
    apply plugin: "com.neenbedankt.android-apt"
    configurations { natives }
    dependencies {
        compile project(":core")
        apt "com.squareup.dagger:dagger-compiler:1.2.2"
        compile "com.badlogicgames.gdx:gdx-backend-android:$gdxVersion"
        natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-armeabi"
        natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-armeabi-v7a"
        natives "com.badlogicgames.gdx:gdx-platform:$gdxVersion:natives-x86"
        compile "com.badlogicgames.gdx:gdx-box2d:$gdxVersion"
        natives "com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-armeabi"
        natives "com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-armeabi-v7a"
        natives "com.badlogicgames.gdx:gdx-box2d-platform:$gdxVersion:natives-x86"
    }
}

project(":core") {
    apply plugin: "java"
    dependencies {
        compile "com.badlogicgames.gdx:gdx:$gdxVersion"
        compile "com.badlogicgames.gdx:gdx-box2d:$gdxVersion"
        compile "com.squareup.dagger:dagger:1.2.2"
        compile "com.squareup.dagger:dagger-compiler:1.2.2"
    }
}

tasks.eclipse.doLast {
    delete ".project"
}

Next we write the DaggerAdapter - this is the guy that will accept our LIBGDX ApplicationListener and create the Dagger Object Graph:

DaggerAdapter.java

package com.nrg.dagger;

import com.badlogic.gdx.ApplicationListener;

import dagger.ObjectGraph;

public class DaggerAdapter implements ApplicationListener {
    
    private Class applicationListenerClass;
    private ApplicationListener delegateApplicationListener;
    private Object[] daggerModules;
    
    public DaggerAdapter(Class<? extends ApplicationListener> applicationListener,
                         Object... daggerModules){
        this.setApplicationListenerClass(applicationListener);
        this.setDaggerModules(daggerModules);
    }

    @Override
    public void create(){
        final ObjectGraph objectGraph = ObjectGraph.create(this.getDaggerModules());
        final ApplicationListener applicationListener =
                objectGraph.get(this.getInjectableGameClass());
        this.setDelegateApplicationListener(applicationListener);
        this.getDelegateApplicationListener().create();
    }

    @Override
    public void resize(int width, int height) {
        this.getDelegateApplicationListener().resize(width, height);
    }

    @Override
    public void render() {
        this.getDelegateApplicationListener().render();
    }

    @Override
    public void pause() {
        this.getDelegateApplicationListener().pause();
    }

    @Override
    public void resume() {
        this.getDelegateApplicationListener().resume();
    }

    @Override
    public void dispose() {
        this.getDelegateApplicationListener().dispose();
    }
    
    public Class getInjectableGameClass() {
        return applicationListenerClass;
    }

    private void setApplicationListenerClass(Class injectableGameClass) {
        this.applicationListenerClass = injectableGameClass;
    }
    
    private void setDaggerModules(Object[] daggerModules) {
        this.daggerModules = daggerModules;
    }
    
    private Object[] getDaggerModules(){
        return this.daggerModules;
    }

    private ApplicationListener getDelegateApplicationListener() {
        return delegateApplicationListener;
    }

    private void setDelegateApplicationListener(ApplicationListener applicationListener) {
        this.delegateApplicationListener = applicationListener;
    }
}

And we're done! That's all we need to support Dagger in LIBGDX.

Now let's see our DaggerAdapter in action. First let's create a quick injectable GameScreen:

GameScreen.java

package com.nrg.example.screens;

import com.badlogic.gdx.Screen;
import javax.inject.Inject;

public class GameScreen implements Screen {

    @Inject
    public GameScreen(){

    }

    @Override
    public void show() {

    }

    @Override
    public void render(float delta) {

      //do game rendering stuff here

    }

    @Override
    public void resize(int width, int height) {

    }

    @Override
    public void pause() {

    }

    @Override
    public void resume() {

    }

    @Override
    public void hide() {

    }

    @Override
    public void dispose() {

    }
}

inject it into our game:

Main.java

package com.nrg.example;

import com.badlogic.gdx.Game;
import com.nrg.example.screens.GameScreen;
import javax.inject.Inject;

public class Main extends Game {

    @Inject GameScreen gameScreen;

    @Override
    public void create() {
        this.setScreen(gameScreen);
    }

}

and create the Dagger module:

GameModule.java

package com.nrg.example.inject;

import com.nrg.example.Main;
import com.nrg.example.screens.GameScreen;
import dagger.Module;

@Module(
        injects = {
            Main.class,
            GameScreen.class
        }
    )
public class GameModule {

}

Now for each of the deployments we simply use the DaggerAdapter instead of the regular LIBGDX ApplicationListener, here's the one for Android:

AndroidLauncher.java

package com.nrg.example.android;

import android.os.Bundle;

import com.badlogic.gdx.backends.android.AndroidApplication;
import com.badlogic.gdx.backends.android.AndroidApplicationConfiguration;
import com.nrg.dagger.DaggerAdapter;
import com.nrg.example.Main;
import com.nrg.example.inject.GameModule;

import dagger.ObjectGraph;

public class AndroidLauncher extends AndroidApplication {
 @Override
 protected void onCreate (Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         AndroidApplicationConfiguration config = new AndroidApplicationConfiguration();
         DaggerAdapter daggerAdapter = new DaggerAdapter(Main.class, new GameModule());
         initialize(daggerAdapter, config);
 }
}

Likewise, here's the one for the Desktop:

DesktopLauncher.java

package com.nrg.example.desktop;

import com.badlogic.gdx.backends.lwjgl.LwjglApplication;
import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;
import com.nrg.dagger.DaggerAdapter;

import com.nrg.example.Main;
import com.nrg.example.inject.GameModule;

import dagger.ObjectGraph;

public class DesktopLauncher {
 public static void main (String[] arg) {
         final LwjglApplicationConfiguration config = new LwjglApplicationConfiguration();
         config.width = 800;
         config.height = 600;
         DaggerAdapter daggerAdapter = new DaggerAdapter(Main.class, new GameModule());
         new LwjglApplication(daggerAdapter, config);
 }
}

That's all folks, leave a note if you thought this was helpful.

I'll be using this in my next game project - currently in the incubation stage ;)

Interlude..

2009-11-18T19:07:00.000-08:00

Wellllllllll I know I am due for another entry on java game development, but bugger me, I just bought the game Dragon Age: Origins, and damn it looks good. Very good. That and we're revving up to do some recording for my band, not to mention my work is flat out (as always). Might be a week or two before I can spare some time to do a bit more late night programming... it wont happen today, but it will happen.

GWT Java Game Coding Basics: The GameLooper

2009-11-12T16:50:00.000-08:00

The first class I am going to code for my game is what I am calling the 'GameLooper'. The GameLooper will handle a never ending (unless paused) while loop.

At this point I'd like to acknowledge the great work by Mark Wilcox at Rebel Ideas who has kindly left his game "Hoth Strike" open source and un-obsfucated. It saved me a good couple of hours headache around looping.

The gaming mechanics will behave much like a television screen, the game looping will calculate if the FPS (frames per second) is too high (not much we can do about low FPS), cap if is it is too high, and then animate the next frame, rinse and repeat.

Let's take a look at the code:

package com.blueflame.alienstronghold.client;

import com.blueflame.alienstronghold.client.ui.ImageAnimator;

import com.google.gwt.user.client.Timer;

/**

* Creates a never ending game loop and caps the game if if is going too fast.

* @author anaish

public class GameLooper {

//ticker timestamp

private static long timeStamp;

//should we cap the frame rate?

private static boolean capFrameRate;

//frame rate cap amount (ms)

private static int capAmount = 42;

//the game timer

private static Timer gameTicker;

/**

* Starts the game based on the current keyboard state.

* @param keyState the current state of the keyBoard

public static void startGame(final KeyboardState keyState){

//initialise the game ticker to run the loop() method

gameTicker = new Timer(){

@Override

public void run() {

loop(keyState);

}

};

//start the game in 250 ms

gameTicker.schedule(250);

ImageAnimator.flashMessage(5,"Ready!");

}

/**

* Loops the game based on the keyboardState

* @param keyState the current state of the keyBoard

public static void loop(final KeyboardState keyState){

//cancel the game ticker

gameTicker.cancel();

//if we're paused then don't do anything

if(GameState.isPaused())

return;

//Update the keyboard state

ImageAnimator.updateKeyboardState(keyState);

//Animate the objects on the screen

ImageAnimator.animate();

//cap the frame rate if we are going too fast

capFrameRate();

//re-schedule the never ending loop

gameTicker = new Timer(){

@Override

public void run() {

loop(keyState);

}

};

if(capFrameRate)

gameTicker.schedule(capAmount);

else

gameTicker.schedule(1);

}

/**

* Caps the frame rate

public static void capFrameRate(){

capFrameRate = (System.currentTimeMillis() - timeStamp)<capamount;

timeStamp = System.currentTimeMillis();

}

The full source code is available here.

You'll see I have made a few references to two other classes ImageAnimator and KeyboardState each responsible for animating objects on the screen and storing the state of the keyboard at any point in time respectively. I'll be explaining these classes a bit later on.

Planning a GWT Shoot 'em up - Part 2

2009-11-10T22:35:00.000-08:00

OK so I've decided pretty much what I want the game to be in Part 1, I expect that some of the details may change as I get in to the nitty gritty of coding, but let's go with what we have and see what happens, rememer the idea is to do small chuncks of code to get something working, then redesign, rinse and repeat.

The next part of the planning process I am going to choose the development environment.

I'll need:

- An IDE: My preferred environment is Eclipse , it's free, easy to use and is a perfect way to work with the GWT.

- A source repository: I'll be making a lot of mistakes, so I'll get myself a nice source repository to work with so I can roll back my changes at any time. I'll be using Google's SVN repository.

- Something to access my source repository with. Although there are ways to integrate Eclipse with SVN, I prefer to use TortoiseSVN, it does all I need.

Setting up these three tools are a piece of cake, simply install Eclipse, add the GWT as a plugin and, once you have setup your google code repository, you can link it to Eclipse (using Subversion) or like I do, with TortioseSVN.

Now we're ready to start coding.

Planning a GWT Shoot 'em up - Part 1

2009-11-10T19:12:00.000-08:00

I'd like to take you through some planning behind the first game I will be making with the GWT, tentatively called "Alien Stronghold". I'll be using what I'd like to call the Agile++ methodology, which is basically a cut down version of the Agile methodology.. I'll explain it in another post, but for the moment, think of it like the Agile methodology on steroids.

Here are some of the project details:

Game type: Shoot 'em up. I have intentionally stuck to a very simple shoot'em up style game in order to keep the scope as narrow as possible, this will allow me to get something up and going quickly - that's the essence of an Agile project - get something that works and is demonstrable, and get it done quickly.

Game audience: Gamers and coders Age 8+ (I was 12 when I started coding, so you never know!). The idea behind this project is to make something fun and intuitive. It s for people interested in shoot-em ups, but also for those wanting to learn something along the way, and hopefully help other people who may be creating games using the GWT.

Core game features:

- Works on all modern mobile and desktop browsers (IE8, FireFox, Opera, Chrome, Safari)
- Playable online for free and requires no downloads.
- 10 levels, 10 bosses.
- Multiple alien types.
- Fast paced, responsive space ship with cool lasers.
- Top score indicator.

Now that doesn't look like much does it? Believe me it is. As a first time game developer I don't want to bite off too much, I'll keep the scope short and sweet so I can get a demo out there an working. That way I can continually test and improve it as I go.

Extended game features:

- Save your game at the end of the level
- Introduce currency (Space bucks for blasting aliens!)
- Buy new ships
- Buy Guns

Although not core features (i.e I'll do them after we have something up and going) these features will make it more palatable to a wider range of audience, and hopefully get people coming back for more.

Mobile java game development becomes viable.

2009-11-10T17:44:00.000-08:00

I've been software engineering as Java Developer for nearly fifteen years, during that time I've been mainly coding corporate back end server side systems - things like call center applications, content management systems and web data dissemination platforms - which, I must admit, has paid the bills and allowed me to learn new technologies along the way. I've also been lucky enough to code a few mobile apps - some in BREW (http://brew.qualcomm.com) and others using MIDP (http://java.sun.com/products/midp).

However, I've always had a passion for games, love playing them, would love to develop them. There's a few problems with my situation though, and I suspect there's plenty of other Java developers out there with the same issues - no one makes games (mobile or desktop) with Java. Why?

- Games must perform to be viable. Currently here is a perception that Java is slower than C/C++. Of course this is not true in all circumstances, it highly depends on implementation, but the perception is there, has been there since Java became mainstream, and seems to be sticking. The preferred language for games is C/C++ (or a derivative thereof).

- Java's "write once, run anywhere" just isn't true, especially for mobile devices. Handset manufactures seemed to have almost made an striving effort to diverge from the (many) standards for mobile devices, I know - I've tried writing (rather simple) applications and porting them to different devices, it's not fun. At all.

- The iphone is currently king of the mobile app market, and it doesn't support a JVM (unless you jailbreak it).

- Most mobile application hosting is expensive and difficult to access.

So I'd like to propose an alternative.

The alternative will:

- Allow you to code decent games in your favorite language (Java) for mobile devices.
- Will run on most mobile platforms (including the IPhone) with the added benefit of any (modern) browser you like.
- Allow you to host your games online for free.

You guessed it - the GWT (http://code.google.com/webtoolkit/)

Google's GWT has it all - Java to JavaScript compiler, persistence, authentication, code optimisation and obfuscation, cross-browser compatibility + more. It's all there.

Now I admit you're not going to be able to develop World of Warcraft for the IPhone with the GWT, however I promise you, as a Java developer will be able to start moving out of those dark server rooms and onto the client to make something fun and viable.

Ive started coding a simple shoot'em up using the GWT, and I must admin I am very impressed. I'll be taking some time to show you the code once I'm ready.