IntelliJ, LibGDX, Kotlin and Android

As I stated in the "introduce yourself" thread, I've chosen to write my game using Kotlin rather than Java. I've been looking for an opportunity to learn it for a while, and there are few better ways of learning a language than actually building a project with it.

The first step in any project is setting up the build environment. There is plenty of useful guidance on doing this, including an article on setting up LibGDX to work with Kotlin, but as I hit a few snags along the way I've shared my steps here in case anyone else is thinking of using Kotlin and is struggling to get it to work with an Android project.

Part 1 - Building and running desktop and Android configurations

Install IntellIJ IDEA Community Edition.

Install the standalone Android SDK.

Run the LibGDX project setup and create sub-projects for both desktop and Android.

Open IntelliJ and load build.gradle.

Fix the project so that the desktop run configuration will work, by adding the Java-Gradle facet to all sub-projects except Android, i.e, to the "core" and "desktop" sub-projects.

Create the desktop configuration.

At this point, it should be possible to build and run the desktop and Android configurations without errors. If the desktop configuration doesn't run, try closing and re-opening the project.

But that doesn't get us Kotlin. That requires jumping through a few more hoops.

Part 2 follows in the next post.

Part 2 - Configuring Kotlin

These instructions are based on the ones that I found here. However, they only worked for a desktop-only project and failed with an error for projects with an Android sub-project. The solution was to follow those instructions then tweak build.gradle a little. These steps are reproducible - I went through them twice more when writing this guide.

Go to the core project and find the single Java file.

Right-click on it and select New -> Kotlin File/Class.

Enter the name, setting it to the same as the Java file, and setting "Kind" to "Class".

You will be prompted to configure Kotlin. Click on the link to do this. It will make changes to build.gradle in the "core" sub-project.

Open the Java class and copy its contents to the clipboard.

Switch to the Kotlin class that you just created, delete its contents, then paste from the clipboard. Select "Yes" when prompted to convert the code from Java to Kotlin.

Delete the old Java file. Do not use safe-delete otherwise it won't work.

Insert "lateinit" in front of the "var" for both of the member variables.

 internal lateinit var batch: SpriteBatch
 internal lateinit var img: Texture

Edit build.gradle in the "core" project, replacing "kotlin-android" with "kotlin" and removing the "android" section.

The resulting file should look like this:

apply plugin: "java" 
apply plugin: 'kotlin' 
 
sourceCompatibility = 1.6 
[compileJava, compileTestJava]*.options*.encoding = 'UTF-8' 
 
sourceSets.main.java.srcDirs = [ "src/" ] 
 
 
eclipse.project { 
 name = appName + "-core" 
} 
buildscript { 
 ext.kotlin_version = '1.0.0-beta-3595' 
 repositories { 
 mavenCentral() 
 } 
 dependencies { 
 classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" 
 } 
} 
repositories { 
 mavenCentral() 
} 
dependencies { 
 compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" 
}

Sync the project, then run the desktop configuration. Everything should work as expected.

N.O.A.H.

We have had relatives over for a while (and they're still here) but I've found a spare hour or two where I can think about this. I've decided to go for a game similar to Defender in concept, but the roles are reversed in that you play the alien. It's called "N.O.A.H." for Near Orbit Alien Harvester. Controls will probably be Lunar Lander style, at least for the vertical component. The player will be given quotas of particular animals to collect from Earth, but of course the humans won't take too kindly to that and will no doubt defend themselves vigorously.

I am using Ashley as Entity Component Systems are reminiscent of how we used to write games in the olden days, when would cajole performance out of 1.77MHz Z80 processors on computers with less RAM than is required for one line of pixels on my phone. No wonder the T-1000 used a 6502.

It would appear that I'm not the only one who has tried to use Kotlin, LibGDX and Ashley. This is good, because I don't have to spend hours trawling for simple fixes to things that I just don't know about yet. Admittedly it's a little out of date, but still…

At first glance Kotlin's data classes seem to be a good candidate for implementing Components.

e.g.,

data class TransformComponent(var x: Float, var y: Float) : Component

But then again, it's also fine without being a data class. Either way, I love how it can be done in one line. It did cause me a little difficulty with Family.all() until I found that I had to use TransformComponent::class.java rather than TransformComponent.class.

Progress in the last couple of hours:

• Implemented a simple RenderSystem, derived from IteratingSystem, overriding update() to bookend the drawing calls with spritebatch begin() and end().
• Learned about Kotlin's xxx::class.java.
• Learned about Kotlin's .forEach() but ultimately didn't use it.
• Created a RenderableComponent.
• Created a TransformComponent. Again, I love how this can be done in one line.
• Added a couple of entities just to prove that everything works.
• Accidentally typed a semi-colon just once.

Still no game, but I know where I'm going with this and I like the idea - always a good sign.

I'm trying to figure out the best way of getting Box2D to play well with Ashley. Fortunately there are existing examples, such as those found in Overlap2D, so I don't have to do too much thinking – just as well as I'm shattered! My daughter wanted to see in the New Year, not realizing just how exhausted my wife and I are having had to cater to her relatives.

Much of today - at least once I got up - was taken up with spending time with my wife and daughter, playing Yoshi's Woolly World on the Wii-U, and Avian Attorney and Shovel Knight on the PC. For what it's worth, Shovel Knight is my favourite as it has very precise controls and a great retro feel. I think I may be putting in more than a few hours.

Eventually, when everyone else had gone to bed and the house was quiet, I managed to squeeze in a couple of hours programming. I'm impressed with Kotlin's when expression and smart casts. By the way, createFixture() is a nested function. Nice.

when (shapedComponent.shape) {
    is CircleShaped -> {
        val circle = CircleShape().apply {
            radius = shapedComponent.shape.radius
        }
        createFixture(circle)
        circle.dispose()
    }
    is BoxShaped -> {
        val polygon = PolygonShape().apply {
            setAsBox(shapedComponent.shape.halfWidth, shapedComponent.shape.halfHeight)
        }
        createFixture(polygon)
        polygon.dispose();
    }
}

Today's progress:

• Added Box2D physics and implemented a PhysicsSystem. It still needs some work, but the rudiments are there.
• Created a BodyComponent to represent Box2D bodies in Ashley.
• Created a ShapedComponent, which can currently be either circle shaped or box shaped.
• Learned about Kotlin's smart casts and when expression.