Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon

2. December 2015

 

I find once you’ve learned a couple of programming languages, the way you learn future programming languages changes a bit.  Instead of learning a language feature by feature, you instead tend to jump right in and learn the language relative to languages you already know.  In this case I find it handy to create a quick cheat sheet or Coles/Cliff notes version as I learn that programming language.  This is that sheet, so if you already know a couple programming languages and want to learn Kotlin, hopefully this will be as useful as any tutorial at getting you going quickly.  Keep in mind I don’t even pretend to be a subject matter expert here!

 

Hello World

Starting off with a Hello World example is all but required by law, so here it is:

fun main(args: Array<String>){
    println("Hello World")
}

As you can see the app entry point is main() just like most C influenced programming languages.  Functions are marked with fun keyword and unlike Java, they do not have to be in a class nor in a package really cutting down the code count.  Variables and parameters are named in the format  name:type, it is increasingly popular for variable type to be on the right ( Haxe, Swift, Go, etc ).  Otherwise nothing shocking here.  It should be noted that semicolon line terminators are completely optional.

 

Variables

Read Only Vs. Variant Types

Let's look at a simple example with variables allocated.

fun main(args: Array<String>){
    val meaningOfLife:Int = 42;
    var meaningOfDeath = meaningOfLife +1
    meaningOfLife++ // NOT ALLOWED!!!
}

Notice val and var.  A val type is read only and once initialized cannot be altered.  A var type is a traditional variable and as you can see in this case, type can be inferred automatically by the compiler.  The final line there will not compile because meaningOfLife is a read only type.  If it was a var type however, that line would compile just fine (in other words, there is a postfix increment operator in Kotlin).  Oh and Kotlin supports C++ style // Comments.  Speaking of comments…

 

Commenting

All the traditional C++ style comments are supported, as are JDoc style

// This is a comment
/*
And so is this
 */
/**
 * And this is a JDoc/KDoc style comment
 * @param args Comment documenting param args meaning
 */
fun main(args: Array<String>){

}

 

Numeric Types

Kotlin has several built in number types: Char, Byte, Short, Int, Float, Long and Double:

fun main(args: Array<String>){
    var byte: Byte = 127 // Signed byte, -128 to 127
    var char: Char = 'A' // A 16bit Unicode character
    var short: Short = Short.MAX_VALUE //16bit signed MAX_VALUE == 32767
    var int: Int = 0xff // 32bit signed, Hex can be used with 0x prefix
    var long:Long = 0b11101101// 64bit signed, binary can be used with 0b prefix
    var float:Float = 3.14f // 32bit floating point number, floats designated with f postfix
    var double:Double = 3.1e10 // 64bit floating point, IEEE notation can be used too

    //double = float; // automatic down conversation is not allowed
    //float = double; // Nor is up conversion!

    double = float.toDouble() //Explicit conversion is allowed
    float = double.toFloat()

    byte = short.toByte() // allowed, but value too big so value is -1
    short = 42;
    byte = short.toByte() // value fits, new val would be 42
}

Bigger and smaller types share no relationship, so automatic conversation does not exist, except in the case of literals.  So you cant automatically assign a short to a byte, nor a byte to a short without calling the appropriate to() method.  Truncation will occur if the type doesn’t fit the new type.

 

Functions

As we’ve seen already, functions are marked with the fun keyword.  The format is “fun named(args): return type” like so:

fun doSomething(a:Int, b:String): String {
    return "$b $a";
}

fun main(args: Array<String>){
    println(doSomething(42,"Meaning of Life is"));
}

This example declares a function that takes and Int and a String and returns a String.  This example also illustrates the use of string templates in Kotlin.  Inside a string you can use the $ symbol to do a C printf style format.  If however you need to use a dollar sign in a literal string you can escape it in the form {‘$’}.

 

Nullable Types

Functions can also return a null value, but need to be marked as such using the ? operator, like so:

fun setName(name:String) : String? {
    if(name == "Mike")
        return "Mike"
    else
        return null;
}
fun main(args: Array<String>) {
    var name = setName("Mike");
    if (name is String) {
        // in if block containing an is, no casting is required
        println(name);
    }
}

As you can see, with a type preceded with a ? can be set to null.  This example also illustrates the is operator, which is the Kotlin analog of typeof in C++.  Another neat trick is illustrated here, within the scope of an if using the is operator, typecasts are not required.  Speaking of typecasts…

 

Typecasts

As we saw earlier, all of the built in numeric types have a toXXX() method for type conversion.  However to straight casts, Kotlin has “safe” and “unsafe” casts.  An unsafe cast could potentially result in an exception because the type cast isn’t possible.  To perform an unsafe cast, use the as operator, like so:

    var i:Int = 42;
    println(i as String);

However if you run this code, BOOM!

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String.

If there is a possibility your cast could fail, instead use the operator as? like so:

 

    var i:Int = 42;
    println(i as? String);

This will result in either the casted value being returned, but if the cast cannot be performed, instead of throwing an exception, it instead returns null.

 

Conditionals and Flow Control

Kotlin works much like most modern languages with a couple exceptions.  if works pretty much like you would expect, except its an expression and returns a value ( the evaluated conditional ) like so:

    var a = 1; var b = 2;
    var bigger = if( a > b) a else b;
    println(bigger); // Prints 2

As a result Kotlin does not have C's confusing ternary ? operators. Additionally you can also set the value returned within an if block, it's simply the last value within the block. Like so:

enum class Enemies { Orc, Skeleton, Pigeon}
fun main(args: Array<String>) {
    var enemy = Enemies.Pigeon;
    println("Enemy was of type " +
        if(enemy == Enemies.Orc){
            // Do Orc related code
            "Orc";
        }
        else{
            "Not Orc";
        }
    );
}

As you can see, the final value in the if block is the returned value by the if statement.  Oh yeah… and Kotlin supports enums, as you can see from this example.

 

One other major difference in Kotlin is there is no else if, nor is there a switch statement.  Instead you have the somewhat confusingly named when that fills both roles, like so:

enum class Enemies { Orc, Skeleton, Pigeon}
fun main(args: Array<String>) {
    var enemy = Enemies.Pigeon;
    when(enemy){
        Enemies.Pigeon -> print("Pigeon");
        Enemies.Orc -> print("Orc");
        else -> {
            print("Who the heck knows at this point??")
        }
    }
}

Much like a C/C++ style switch statement except there is no case keyword, default is replaced with an else statement and you use –> instead of a colon.

You can also do ranges in when statements, like so:

fun main(args: Array<String>) {
    var meaningOfLife:Int = 42;
    when(meaningOfLife){
        in 1..22 -> print("Between 1 and 22");
        !in 22..44 -> print("Not between 22 and 44");
        else -> {
            // None of the above
        }
    }
}

 

For, while and do-while loops all work pretty much the same as other languages.  Kotlin supports break, return and continue statements and they work as expected ( and can be used to short circuit a when statement ).  You can however set a label using the @ postfix then specify it specifically in the break/continue/return statement, like so:

fun main(args: Array<String>) {
    outer@ for(i in 1..100){
        inner@ for(j in 1..100) {
            if (j == 42) {
                continue@outer;
            }
        }
    }
}

This above example will immediately cause the outer loop to jump to it’s next iteration when the inner loops condition is true, effectively short circuiting the inner loop. (Yes, an un-labeled break would have the exact same result)

 

Extension Method

Class can be easily via extensions methods.

class A {}

fun A.somethingNew() {
    print("Gave A new superpowers, woot")
}

fun String.toA() : A {
    return A();
}
fun main(args: Array<String>) {
    var a = A();
    a.somethingNew()

    var s = "Meaningless initial value";
    s.toA().somethingNew();

}

As you can see any class can be extended using the form 'fun classname.newMethod". You can also extended built-in classes, like shown here with String.

 

And that brings us nicely too…

 

Classes

As we just saw, a class is declared like:

class MyClass {
    
}

 

In fact for an empty class like this, you can omit the body entirely, like:

class MyClass;

fun main(args: Array<String>) {
    var myClass = MyClass();
}

Of course, that code wont actually do anything.  As you can see from this and earlier examples there is no new operator.

 

Constructors

Kotlin has a primary constructor, which is similar to a default constructor in C++.   However no code can be contained in the constructor.  Here is an example:

class MyClass(myString:String){};

fun main(args: Array<String>) {
    var myClass = MyClass("test");
}

If you need to set initial values programmatically, you can do so in the init block, like so:

class MyClass(stringParam:String){
    var myString:String;
    val valToAppend: String = "42";
    init {
        myString = stringParam;
        myString += valToAppend;
    }

    constructor(stringParam:String, myInt:Int) : this(stringParam){
        myString += myInt.toString();
    }
};

fun main(args: Array<String>) {
    var myClass = MyClass("test");
    print(myClass.myString); // Prints test42

    var myClass2 = MyClass("test", 43);
    print(myClass2.myString); //Prints test4243 !!!!
}

This example also showed how to set a secondary constructor using the constructor keyword.  Note the call back to the default constructor in the secondary constructor.  Also note the result on myClass as per the comment, showing the order of constructor calls.

 

Inheritance

 

The base class of all classes in Kotlin is Any, which is analogous to object in Java ( and there is no equivalent in C++ ).  Inheritance looks almost exactly like Java, like so:

open class Base{};

class Derived : Base() {};

The only major difference is the parent class is marked open, otherwise it would be marked final. If the base class has a constructor, you must call it in the derived class like so:

open class Base(param:Int){};

class Derived : Base(42) {};

 

If a derived class has no primary constructor then it’s secondary constructors need to call the base class using super like so:

open class Base(param:Int){};

class Derived : Base {
    constructor(param:Int) : super(param){}
}

 

Method inheritance is done with a combination of open and override, like so:

open class Base {
    open fun baseFunc() {
        println("base");
    }
};

class Derived : Base() {
    override fun baseFunc() {
        println("derived");
    }
}

fun main(args: Array<String>) {
    var derived = Derived()
    derived.baseFunc() // prints "derived"
}

 

There are also interfaces in Kotlin, but they are probably a bit different than what you expect, as the interface can contain both abstract functions as well as implementations, like so:

interface BaseInterface {
    fun a()
    fun b() {print("b");}
};

class implementation : BaseInterface {
    override fun a() { print("a");}
}

fun main(args: Array<String>) {
    var imp = implementation()
    imp.a();
    imp.b();
}

The abstract method must be implemented in the derived class.  The only difference between an interface and abstract class is an interface does not have state.  Like Java you can only have one base class but as many interfaces as wanted.  If you name collision, it can be resolved like so:

interface A {
    fun a(){print("A")};
};
interface B {
    fun a(){print("B")};
};


class implementation : A,B {
    override fun a() {
        super<A>.a();
        super<B>.a();
    }
}

fun main(args: Array<String>) {
    var imp = implementation()
    imp.a();
}

 

Functional Programming

Kotlin also has good functional programming capabilities, consider the following example that takes a function, both anonymous or named:

fun onCallback(callback:() -> Unit) {
    return callback();
}
fun otherFunc() { print("Maybe"); }

fun main(args: Array<String>) {
    onCallback({print("Callme")});
    onCallback(::otherFunc);
}

 

An anonymous function takes the form (params) –> return.  In the above example there are no params and no return.  In Kotlin Unit is the equivalent of void in C.  The :: operator returns a callable reference.

 

 

This material should be more than enough to get started making a game in Kotlin.  I guess we shall see.  Of course, this is just a quick start, to dig deeper the entire language reference is available here.

Programming , ,

30. November 2015

 

 

 

This entry in the Closer Look series is a bit different than normal.  First, Blade Engine is very much a work in progress, so expect bugs and flaws and minimal documentation.  Second, it’s actually built over top of an existing game engine, LibGDX.  Finally, it’s a game engine focused on one very specific genre – adventure games.  Given the popularity of hidden object games on mobile these days, there are no doubt a number of people looking for an appropriate engine.  So without further adieu, I present the Bladecoder Adventure Engine, an open source cross platform LibGDX based game engine and editor for creating adventure games.

image

As always there is an HD video version available here.

 

Meet Bladecoder Adventure Engine

 

Blade engine consists of two parts, the underlying game engine and the editor that is layered on top of it.  It is designed in such a way that you can work entirely in the editor and never once right a line of source code.  You assemble your game from a collection of Chapters, Scenes and Actors and added events and actions in the form of verbs.  If you want to modify the fundamental structure of the game itself, you are going to have to jump into the underlying source code.  Fortunately that is an option, as Bladecode Engine is hosted on Github and the source is available under the incredibly liberal Apache 2 license.

 

Blade Engine Features at a Glance:

  • Multi platform support: Android, IOS, Desktop (Windows, OSX, Linux) and HTML
  • Several animation techniques: sprite/atlas animation, Spine (cutout) animation and 3d model animation
  • 3d character support
  • Multiresolution to deal with different densities and screen sizes
  • Multilanguage support
  • Open source and free (as in beer and freedom)
  • Code free game creation possible

 

The heart of Bladecoder is ultimately the editor, so let’s focus there after we cover getting started.

 

Getting Started

 

To get started with Bladecoder you need to have Java and git installed and properly configured.  Bladecoder uses the JavaFX ui library so you will have to use JDK 8 or newer or be prepared to have to configure JavaFX manually in the build process.  You will also require an internet connection for the build process to succeed the first time. To start, from a terminal or command line, change to the folder you want to install Bladecoder and enter:

git clone https://github.com/bladecoder/bladecoder-adventure-engine.git

cd bladecoder-adventure-engine

gradlew build

gradlew run

 

There is an example repository, including the work in progress game The Goddess Robbery available in the repository https://github.com/bladecoder/bladecoder-adventure-tests.  You should probably clone this repository too, as this is perhaps the single biggest documentation source available right now.

 

The Editor

 

Assuming the compilation process went without issue above, you should now see the Adventure Editor, where the bulk of your work will occur.

image

 

Your game is composed of a collection of Chapters, which in turn contain Scenes.  Scenes in turn are a collection of Actors and organized in layers:

image

 

Game Props enables you to set global properties of your game:

image

 

Resolution enables you to quickly create scaling modes for supporting multiple device resolutions ( think Retina ):

image

 

While Assets enables you to import multiple defined assets include audio and music files, texture atlases, 3D models, images and more.

image

 

You organize your scene using the editor available in the center of the window:

image

You can place actors on different layers, define walk paths, etc.  Click the Test button to preview that scene in action.

 

The actual logic of your game is defined on the right hand side of the editor. 

Here you can set properties of your actors:

image

 

Create and edit dialogs:

image

 

Define sounds and animations:

image

 

Clicking the edit icon will bring up the appropriate editor:

image

 

While selecting an animation will preview it in the scene:

GIF

 

Finally Verbs are the heart of your application:

image

 

You can think of verbs an analogous to event handlers, and they can be applied at the world, scene or actor level.  There are also default verbs that will be fired if unhandled.  Think the generic “I don’t know how to use that” messages from adventure games from the past.

 

Let’s look at an example from the Scene, handling the Init verb which is fired when the scene is ready.

image

 

This verb causes the sequence of actions shown at the bottom part of the above image to be fired when the scene init verb is called.  This causes the player to move, a dialog sequence, the player is scripted to drop an item, a state value is changed, etc.  You can create new elements by clicking the + icon:

image

 

And filling out the resulting form.  Each element has a different form associated with it.  Here for example is the result of the Say element:

image

 

Once complete simply click the play or package button:

image

 

Play launches the standard loader:

image

 

This screen can obviously be customized to each individual game.  While package brings up a form enabling you to build your game for a variety of platforms:

image

 

And that essentially is it.

 

Help and Community

This is certainly a weak point of the Bladecoder engine, it’s the result of a single coder, there is minimal help available and if you don’t know how to debug Java code, you will probably end up in trouble, at least at this point in it’s lifecycle.  There is currently no community or forum available for this engine but perhaps that will change in the future.  I spoke with the developer a few times however and he was very responsive and quick with fixes and answers.  He is also on twitter at @bladerafa if you want status updates on the project.

For now documentation consists of a minimal wiki although for the most part the best source of documentation is going to be from following the examples.

 

Summary

Make no mistakes, this is very much an under development engine so expect things to blow up spectacularly at any time.  When it does, you are probably going to be on your own figuring out why as there is no community to fall back on.  All that said this is a surprisingly robust tool that makes the process of creating an adventure game exceedingly simple.  Once the engine matures a little bit it will be an excellent tool for even a non-programmer interested in making adventure games.  For now though if you are competent in Java and interested in making an adventure game, this engine takes care of a hell of a lot of work for you and provides full source code for when it doesn’t.  Plus at the end of the day, the price is certainly good too!

 

The Video

Design, Art, Programming , , , ,

25. November 2015

 

With the upcoming LibGDX jam, it dawned on me I hadn’t done anything with LibGDX in a while.  I decided to look into doing a mini game series in advance of the Jam and decided it was a good opportunity for me to look into the Kotlin programming language.  Ironically a day later, RoboVM and IntelliJ announce a Kotlin code competition… stars aligning I suppose.

 

So I decided to start with Kotlin-afying a LibGDX project and see how the process went.  This tutorial is the result of that experience, although to be honest calling it a tutorial is a bit of a joke as the process was amazingly simple.

 

Before we begin there are a couple of things you are going to need:

 

Open the project in IntelliJ just like normal with a Java application.

In your project, in core create a new Kotlin file beside your main class like so:

image

 

That’s one of the cool things about Kotlin, it can exist along side existing java sources.  Once you create the Kotlin file, this popup will be shown:

image

 

Click the link and let it configure as a Kotlin module. Defaults are good, click OK.

image

 

Now this part is impressive and I discovered it by accident.  Open your existing .java file and copy the contents, then paste them into your newly created kt file.  When prompted, let it convert the Java to Kotlin code:

image

 

Now the default project will be converted to Kotlin, but there will be a pair of errors:

image

 

Kotlin does not appear to like unallocated variables.  There are a few options here.  You can move the initialization of batch and img to the KotlinDemo constructor, you can default initialize them to null (this will however cause LibGDX to explode, so not recommended ;) ) or you can add the lateinit modifer, which is the route I went.  Here is the resulting code:

package com.gamefromscratch

import com.badlogic.gdx.ApplicationAdapter
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.graphics.GL20
import com.badlogic.gdx.graphics.Texture
import com.badlogic.gdx.graphics.g2d.SpriteBatch

class KotlinDemo : ApplicationAdapter() {
    internal lateinit var batch: SpriteBatch
    internal lateinit var img: Texture

    override fun create() {
        batch = SpriteBatch()
        img = Texture("badlogic.jpg")
    }

    override fun render() {
        Gdx.gl.glClearColor(1f, 0f, 0f, 1f)
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT)
        batch.begin()
        batch.draw(img, 0f, 0f)
        batch.end()
    }
}

Congratulations, you’ve just created your first Kotlin application!  The mix and match nature enables you to slowly port your code over to Kotlin making the transition exceedingly easy.

Now there is one last very important step, we need to delete the original .java class. 

image

 

When you delete it, you want to make sure you don’t do a smart delete, as we want the existing references to this class to remain (as our Kotlin class is replacing it):

image

 

I’m going to continue to play around with Kotlin, so expect more coverage over the next few days/weeks.  Let me know what you think of Kotlin… any interest?

Programming ,

25. November 2015

 

This one has to be about the most ironic timing of a contest ever, as just last night I started working with Kotlin and IntelliJ (expect a post later today)… anyways, on to the competition.  The nutshell version, you create a Kotlin app using IntelliJ or Android Studio, submit it on Github and you could win a Mac Mini or other prize from RoboVM and JetBrains.

 

Just a bit of quick back story here.  RoboVM are the makers of technology the allows you t run JavaVM applications on iOS devices.  JetBrains make the popular IntelliJ IDE (along with WebStorm, CLion, etc) and somewhat recently released a new JVM based programming language called Kotlin.  Kotlin I will look at in more detail shortly.

 

The complete announcement is available here, but the rules and prize bits are included below:

How to Enter

  1. Create an app using Kotlin and RoboVM for iOS and/or Android
  2. Publish your app on GitHub
  3. Tweet your entry using this link:
    “I just submitted my app <GitHub URL> for the @robovm @jetbrains Kotlin Contest:https://robovm.com/kotlin-contest

Don’t have a Mac for iOS development? No problem – we’re accepting Android-only apps as well! IntelliJ IDEA Ultimate and Community edition both have great support for building Android apps with Kotlin on Windows and Linux!

How to win

Want to give your entry the extra edge? Here are some tips:

  • Include a screenshot of your app in your tweet
  • Blog about how you built your app in Kotlin and include a link in your tweet
  • Use Kotlin everywhere – bonus points for shipping a cross-platform app or building your backend in Kotlin, too!

Prizes

All apps must be submitted by end of day PST December 14th 2015! The teams at RoboVM and JetBrains will pick the winners from all submissions. A valid entry consists of your tweet pointing to your app’s GitHub repository. Only one prize will be awarded per participant, and per GitHub repository. Bonus points for cross-platform apps, development logs in form of tweets or blog posts which we’ll happily promote, as well as code quality! Winners will be announced on the RoboVM and JetBrains blogs as well as on Twitter, and will be contacted via GitHub.

 

Also, stay tuned to GameFromScratch.com for some Kotlin specific content in the very near future.

GameDev News ,

23. November 2015

 

At the Android Developer Summit, Google just announced Android Studio 2.0 is available for download in preview form.  The two major new features will both be relevant for game developers, Instant Run which enables hot swapping of code on device and a GPU profiler, for profiling OpenGL ES code performance.

 

From the Android Developers blog:

Android Studio 2.0 Preview

Posted by, Jamal Eason, Product Manager, Android

One the most requested features we receive is to make app builds and deployment faster in Android Studio. Today at theAndroid Developer Summit, we’re announcing a preview of Android Studio 2.0 featuring Instant Run that will dramatically improve your development workflow. With Android Studio 2.0, we are also including a preview of a new GPU Profiler.

All these updates are available now in the canary release channel, so we can get your feedback. Since this initial release is a preview, you may want to download and run an additional copy of Android Studio in parallel with your current version.

New Features in Android Studio 2.0
Instant Run: Faster Build & Deploy

Android Studio’s instant run feature allows you to to quickly see your changes running on your device or emulator.

Getting started is easy. If you create a new project with Android Studio 2.0 then your projects are already setup. If you have a pre-existing app open Settings/Preferences, the go to Build, Execution, Deployment → Instant Run. Click on Enable Instant Run... This will ensure you have the correct gradle plugin for your project to work with Instant Run.

Enable Instant Run for Android Studio projects

Select Run as normal and Android Studio will perform normal compilation, packaging and install steps and run your app on your device or emulator. After you make edits to your source code or resources, pressing Run again will deploy your changes directly into the running app.

New Run & Stop Actions in Android Studio for Instant Run

For a more detailed guide setup and try Instant Run, click here.

GPU Profiler

Profiling your OpenGL ES Android code is now even easier with the GPU Profiler in Android Studio. The tool is in early preview, but is very powerful and not only shows details about the GL State and Commands, you can record entire sessions and walk through the GL Framebuffer and Textures as your app is running OpenGL ES Code.

Android Studio GPU Profiler

To get started, first download the GPU Debugging Tools package from the Android Studio SDK Manager. Click here for more details about the GPU Profiler tool and how to set up your Android app project for profiling.

Whats Next

This is just a taste of some of the bigger updates in this latest release of Android Studio. We'll be going through the full release in more detail at the Android Developer Summit (livestreamed on Monday and Tuesday). Over the next few weeks, we'll be showing how to take advantage of even more features in Android Studio 2.0, so be sure to check back in.

If you're interested in more Android deep technical content, we will be streaming over 16 hours of content from the inaugural Android Developer Summit over the next two days, and together with Codelabs, all of this content will be available online after the Summit concludes.

Android Studio 2.0 is available today on the Android Studio canary channel. Let us know what you think of these new features by connecting with the Android Studio development team on Google+.

 

I wonder how much of this functionality will be made available upstream to the IntelliJ IDE? 

GameDev News ,

Month List

Popular Comments