Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon

5. January 2016

 

LibGDX, the cross platform open source Java based gaming library, just released version 1.8 today and unlike many recent releases, there is a ton in this release.  The biggest aspect of this release is probably the change to LWJGL 3 on the backend.  LWJGL is a Light Weight (that’s the LW part) Java (the J) based Game Library (GL, tada!) that LibGDX desktop targets were built on top off.  Some of the limits of LWJGL 2 were holding back what LibGDX could do, such as multiple monitor support.

From the announcement blog post, the big wall of text of new features:

[1.8.0]
- API Change: Rewrote FreeType shadow rendering (much better).
- Added spaceX/Y to FreeType fonts.
- Higher quality FreeType font rendering.
- Hiero updated to v5, now with FreeType support and other new features!
- GlyphLayout now allocates much, much less memory when processing long text that wraps.
- Added LWJGL 3 backend, see https://github.com/libgdx/libgdx/issues/3673 for more info.
- Added Graphics#getFramebufferWidth and Graphics#getFramebufferHeight for HDPI handling
- API Change: Added HdpiUtils. Instead of calling GL20#glViewport and GL20#glScissor yourself
  please use HdpiUtils instead. It will ensure that you handle HDPI monitors correctly when
  using those OpenGL functions. On HDPI monitors, the size reported by Gdx.graphics 
  getWidth/getHeight is in logical coordinates as dictated by the operating system, usually half
  the HDPI resolution. The OpenGL drawing surface works in backbuffer coordinates at the full
  HDPI resolution. If you pass logical coordinates to glViewport and glScissor, you only 
  affect a quarter of the real backbuffer size. Use HdpiUtils instead, it will do the right thing, while letting you continue to work in logical (aka returned by Gdx.graphics.getWidth/getHeight) coordinates.
- API Change: Graphis#getDesktopDisplayMode() has been renamed to Graphics#getDisplayMode() and
  returns the current display mode of the monitor the window is shown on (primary monitor on
  all backends except LWJGL3, which supports real multi-monitor setups).
- API Change: Graphics#getDisplayModes() return the display modes of the monitor the monitor
  the window is shown on (primary monitor on all backends except LWJGL3 which supports real
  multi-monitor setups).
- API Change: Graphics#setDisplayMode(DisplayMode) has been renamed to 
  Graphics#setFullscreenMode(). If the window is in windowed mode, it will be switched 
  to fullscreen mode on the monitor from which the DisplayMode stems from.
- API Change: Graphics#setDisplayMode(int, int, boolean) has been renamed to 
  Graphics#setWindowedMode(int, int). This will NOT allow you to switch to fullscreen anymore, 
  use Graphics#setFullscreenMode() instead. If the window is in fullscreen mode, it will be
  switched to windowed mode on the monitor the window was in fullscreen mode on.
 - API Addition: Graphics#Monitor, represents a monitor connected to the machine the app is
  running on. A monitor is defined by a name and it's position relative to other connected
  monitors. All backends except the LWJGL3 backend will report only the primary monitor
 - API Addition: Graphics#getPrimaryMonitor() returns the primary monitor you usually want
  to work with.
 - API Addition: Graphics#getMonitor() returns the monitor your app's window is shown on,
  which may not be the primary monitor in >= 2 monitor systems. All backends except the 
  LWJGL3 backend will report only the primary monitor.
 - API Addition: Graphics#getMonitors() returns all monitors connected to the system. All
  backends except the LWJGL3 backend will only report the primary monitor.
 - API Addition: Graphics#getDisplayMode(Monitor) returns the display mode of the monitor
  the app's window is shown on. All backends except the LWJGL3 backend will report the
  primary monitor display mode instead of the actual monitor's display mode. Not a problem
  as all other backends run on systems with only a single monitor so far (primary monitor).
- Added option to include credentials on cross-origin http requests (used only for GWT backend).
- Added option to specify crossorigin attribute when loading images with AssetDownloader (GWT), see #3216.
- API Change: removed Sound#setPriority, this was only implemented for the Android backend. However, Android itself never honoured priority settings.
- API Change: cursor API has been cleaned up. To create a custom cursor, call Graphics#newCursor(), to set the custom cursor call Graphics#setCursor(), to set a system cursor call Graphics#setSystemCursor(). The Cursor#setSystemCursor method has been removed as that was not the
right place. Note that cursors only work on the LWJGL, LWJGL3 and GWT backends. Note that system cursors only fully work on LWJGL3 as the other two backends lack a means to set a specific system cursor. These backends fall back to displaying an arrow cursor when setting any system cursor.
- API Addition: Added Lwjgl3WindowListener, allows you to hook into per-window iconficiation, focus and close events. Also allows you to prevent closing the window when a close event arrives.
 


There are a lot more details available on the announcement post if you want more details on the specifics of the update. 

GameDev News ,

17. December 2015

 

The first ever LibGDX Jam starts tomorrow, or today, or yesterday or sometime ago, I suppose it’s all relative to when you read this, isn’t it?  Well temporal factors aside, the first ever LibGDX Game Jam begins/began on Friday Dec 18th.  It is called creatively enough #LibGDXJam.  The rules and prizes from this jam are:

The 10 Rules of Jamming

The jam will be held from December 18th to January 18th. Here are the rules:

  1. You must use libGDX to create a game that fits the theme.
  2. You may work alone or in a team. Only one submission per person/team is allowed.
  3. You may use pre-existing code, e.g. libraries like Ashley, or your own code libraries.
  4. You may use pre-existing art, e.g. assets from OpenGameArt, or your own art.
  5. You may use external tools like Tiled or Overlap2D.
  6. You must not re-skin an already existing game or prototype!
  7. You must submit your game before the end of the 18th of January via the jam’s site on itch.io (to be made public).
  8. You must publish the source of your game, e.g. to GitHub.
  9. You must submit your game to the itch.io libGDX Jam page before the end of day January 18th, UTC-12!
  10. If you want to win one of the sponsored prizes, you must tweet about your game and document its development, using the hashtag #libGDXJam and the handles @robovm and@robotality.

First of all, you can participate in the jam without following these rules! In that case, you will not qualify for the prizes though.

Documenting your progress is a great way of sharing your experience, and an invaluable tool for others to learn. Making a bit of noise on Twitter is also a great way to give back to our sponsors. Chaining those 2 things together via rule 9 is my evil overlord plan to make everyone happy.

Here are a few examples of tweets:

Progress screenshot of my #libGDXJam entry @robovm @robotality

New dev log entry for my #libGDXJam game @robovm @robotality

For the dev logs, we want quality first and foremost! Progress screenshots, descriptions of problems you ran into and their solutions, streaming and so on is what we want to see! Just mindless spamming will not get you anywhere.

Prizes & Judging

We are happy to have RoboVM and Robotality as sponsors for the following prizes:

  • Grand Prize: Mac Mini, sponsored by RoboVM.
  • Silver: iPad, sponsored by RoboVM.
  • Bronze: iPod Touch, sponsored by RoboVM.
  • For 20 random submissions: Steam keys for Halfway, sponsored by Robotality.
  • For another 5 random submissions: libGDX Jam t-shirt.

To qualify for any of the prizes, you'll need to follow rule 10 as outlined above. Judging works as follows:

  • The community can vote on itch.io from the 19th of January to the 2nd of February.
  • The Grand Prize will be awarded to the entry with the highest community votes on itch.io. This way the highest quality entry will win!
  • The Silver and Bronze prizes will be awarded to the entries with the best mixture of dev logs and tweets and community votes. * Our sponsors and the libGDX core team will pick these entries. This should motivate people to make some noise on the web and document their progress for the greater good of the community!
  • The random awards guarantee that everyone has a chance to win a prize!
  • The winners will be announced on the 3rd of February!

Timetable

  • Theme Voting round 1: Nov. 22nd – Dec. 11th
  • Final Theme Voting: Dec. 11th – Dec. 18th
  • Jam: Dec. 18th – Jan. 18th
  • Judging: Jan 19th – Feb. 2nd

You can read the full details here on github.

GameDev News ,

17. December 2015

 

Just in time for the first ever LibGDX Game Jam, LibGDX 1.7.2 was released. 

image

 

This released included the following updates:

[1.7.2]
- Added AndroidAudio#newMusic(FileDescriptor) to allow loading music from a file descriptor, see #2970
- Added GLOnlyTextureData, which is now the default for FrameBuffer and FrameBufferCubemap, see #3539
- Added rotationChanged() for Actor class, called when rotation changes, see https://github.com/libgdx/libgdx/pull/3563
- Fixed crash on MacOS when enumerating connected gamepads.
- ParticleEmitter no longer says it's complete when it's set to continuous, see #3516
- Improved JSON parsing and object mapping error messages.
- Updated FreeType from version 2.5.5 to 2.6.2.
- Fixed corrupt FreeType rendering for some font sizes.
- API Change: FreeTypeFontParameter has new fields for rendering borders and shadows.
- FreeTypeFontParameter can render much better fonts at small sizes using gamma settings.
- BitmapFont can now render missing (tofu) glyph for glyphs not in the font.
- FreeTypeFontGenerator depreacted methods removed.
- Fixed BitmapFont color tags changing glyph spacing versus not using color tags. BitmapFont#getGlyphs has a new paramter. See #3455.
- Skin's TintedDrawable now works with TiledDrawable. #3627
- Updated jnigen to Java Parser 2.3.0 (http://javaparser.github.io/javaparser/).
- FreeType fonts no longer look terrible at small size. This is a big deal!
- Updated to RoboVM 1.12.0, includes tvOS support!
 

Full details are available here.

GameDev News ,

13. December 2015

 

GDX AI, a Java based AI library that works with (but doesn’t require) LibGDX just released version 1.7.

 

From the change log:

[1.7.0]

- Updated to libgdx 1.7.1

- API Addition: added GdxAI service locator that reduces coupling with libgdx and allows you to use gdx-ai

out of a libgdx application without having to initialize libgdx environment, so avoiding the waste of resources

and the need of native libraries; see https://github.com/libgdx/gdx-ai/wiki/Initializing-and-Using-gdxAI

- API Change and Addition: Messaging API

* Removed delta time argument from the update method of the MessageDispatcher; the new GdxAI.getTimepiece().getTime() is internally used instead.

* Added return receipt support, see https://github.com/libgdx/gdx-ai/wiki/Message-Handling#return-receipt

* The report method of PendingMessageCallback now takes an additional argument for the return receipt.

- API Change and Addition: State Machine API

* Now the StateMachine interface has a generic type parameter for the state.

* Added owner's getter and setter to the DefaultStateMachine; also, the owner is now optional in constructor.

- API Change and Addition: Behavior tree API revised and improved, see https://github.com/libgdx/gdx-ai/wiki/Behavior-Trees

* Now tasks have a status that is updated each time they run.

* Added enum support in behavior tree files.

* Now parallel task can specify sequence or selector policy.

* Added cancel method for task termination, mainly used by the parallel task.

* Now you can add listeners to the tree in order to be notified when a task has run and a child is added.

* Now task methods setControl, success and fail are final.

* Now method addChild is final and Task's subclasses have to implement addChildToTask.

* Added decorator tasks Repeat and Random.

* Added leaf tasks Failure, Success and Wait.

* Added branch tasks RandomSelector and RandomSequence; removed deterministic attribute from Selector and Sequence.

* Now the UntilFail decorator succeeds when its child fails.

* Added ability to clone tasks through third-party libraries like Kryo.

* Added support for custom distributions in behavior tree files.

* Now LeafTask usage is less error prone thanks to the execute method.

GdxAI is available on Github or as part of the LibGDX setup.

GameDev News, Programming ,

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 , ,

Month List

Popular Comments