Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon

24. May 2012


This tutorial is going to cover everything you need to know to get a PlayN project up and running using NetBeans.  In the end you will know everything you need in order to be able to create and run the Java, Web and Android projects using PlayN 1.3.  The iOS project should work as well, but I am not on a Mac.


I have come to a conclusion recently.  I hate Eclipse, every time I work in it, I am fighting with the IDE more than anything else.  More specifically, I hate the M2E maven plugin more than words can describe.  I have attempted to create a series of beginner tutorials for PlayN and each and every time, I end up jumping through a half hour or more of hoops in order to get Eclipse to build my project.  Not much point in making tutorials, if my readers can’t even get PlayN up and running, right?  I don’t want to spend all of my time troubleshooting PlayN installs!  It seems like 90% of the support issues you see with PlayN revolve around Eclipse and M2E problems.


So that is what this guide addresses.  It is about getting a specific version of PlayN ( 1.3 ) running with a specific version of NetBeans ( 7.1.2 ), to the point you can run all of the different kinds of targets it supports.  So if you want to get started with PlayN development, start here!  It’s going to look long and daunting, but it really isn’t all that bad, I just go into a lot of detail.  If you’ve already got Netbeans up and running, you can skip 80% of it!



What you need to get started



Before we go too far ahead, you are going to need to have downloaded and installed a Java JDK.  Note, the JRE and JDK are different things, and you very much need a JDK installed.  I recommend version 6 over 7 ( that link was to 6 ) at this point, but either *should* work. Additionally, if you are intending to do Android development, you will have to download and configure the Android SDK.  Details on configuring the Android SDK are available here, just ignore all the Eclipse bits.


You are now going to need a version of Netbeans.  Here you have a couple of choices:




You want either JavaSE or Jave EE.  If you don’t care about HTML development, go with Java SE, otherwise go with EE.  In this tutorial we are going to go with the Java SE version and add the bits as we need them.  Download and install whichever version you choose now.  Before you install, make sure you have a Java JDK installed already, you will be asked for the JDK path as part of the install process.  Otherwise it’s just a next , I agree, next, I agree, click fest.  Unless of course you are the type that reads EULAs… in which case, see you in a couple hours!



Configuring NetBeans’ required plugins



Now that you’ve installed Netbeans, fire it up.  We need to configure a couple plugins right away.  Select Tools->Plugins




In the resulting dialog, select the Available Plugins tab, scroll down and check “Java Web Applications” then click Install.  You can skip this part if you installed Netbeans EE.




Dialog will appear, click Next




Agree to the license agreements and click Install





This process will take a few minutes, then request that it restart NetBeans, let it.


Now we need to set up the NBAndroid plugin, which is the Netbeans Android connector.  Once again select Tools->Plugins.  This time select Settings in the resulting dialog:




Then click add, and fill in the following in the dialog.  For name enter whatever you want, I went with NBAndroid.  For URL enter, now click OK.




At this point Android should show up as an option under Available plugins.  For me, as is the way with software, I encountered a bug and it didn’t.  At this point I exited and re-launch NetBeans, go to Tools->Plugins and now the options are there under Available Plugins.  If they don’t show up for you, restart Netbeans.  Now select Android and Android Test Runner for Net Beans 7.x, like so:




Click install, then as before, agree to the EULA and continue. You may run into this scary message, just click continue:





All right, Android is now configured, let’s create our project!



Creating your PlayN project



Select the File->New Project menu




In the resulting dialog, select the Maven category, then under Projects select “Project from Archetype”. Click Next.





In the next screen, on the right hand side click the Add… button





Fill the next dialog in with the following details; Group Id = com.googlecode.playn Artifact Id= playn-archetype Version 1.3, then click OK.




Now make sure your newly added Archetype is selected and click Next.





Now fill in the following details.  Name your project in ProjectName, I am going with playndemo and assume you did too for the rest of this tutorial.  Artifact Id will be set automatically.  Group id is your url, in my case com.gamefromscratch.  Be sure to specify 1.3, it will start as 1.0-SNAPSHOT, you don’t want this!  Finally, and this part is extremely important, fill in the value for JavaGameClassName!  I went with playndemo, but it is extremely important to click somewhere on the screen after setting it, another text box for example, or the setting will not be saved!!!  If you get an error later on that JavaGameClassName was not set, you ran into the bug of this value not saving. Now click Finish.





If all went well, it should have generated your project like this:





Building your project ( resolve Maven dependencies )



This next part is incredibly important, we need Maven to bring in all the various dependencies.  Right click the Meta Project and select Clean and Build.




Maven is now going to download and configure all of the various dependencies, and there are a lot of them.  Like tea?  Perhaps now would be a good time to brew a cup.  Just keep an eye on the bottom right of your screen:





Ideally what you want to see is this:




Fortunately, you only need to do that part once.  If you are sitting there thinking… wow, this really took a long time, I wonder if something went wrong?!?!?!  Nope, nothing went wrong, it really does take that long!  Welcome to maven.


Running the Desktop Java app


Normally all you would have to do is right click the Java project and choose run.  However as of right now there is a dependency on the LWJGL native dlls that you need to resolve manually. If you are reading this at some point in the future, you may no longer need to perform this step!


Try running the Java App.  Right click playndemo Java and select Run




In the resulting dialog, select your main class if required and click Select Main Class.




You will receive:

Failed to execute goal org.codehaus.mojo:exec-maven-plugin:1.2:exec (default-cli) on project playndemo-java: Command execution failed. Process exited with an error: 1(Exit value: 1) -> [Help 1]


If you scroll up the error, you will see:

Exception in thread "main" java.lang.UnsatisfiedLinkError: no lwjgl in java.library.path
    at java.lang.ClassLoader.loadLibrary(
    at java.lang.Runtime.loadLibrary0(
    at java.lang.System.loadLibrary(
    at org.lwjgl.Sys$
    at Method)
    at org.lwjgl.Sys.doLoadLibrary(
    at org.lwjgl.Sys.loadLibrary(
    at org.lwjgl.Sys.<clinit>(
    at org.lwjgl.opengl.Display.<clinit>(


This is because of the missing libraries, lets add those now.  ( Or if you didn’t, this problem is fixed and skip ahead! )


Head on over to LWJGL’s download site and download the binaries zip.  Now extract the contents of this file somewhere, it doesn’t really matter where.  I extracted to c:\temp, preserving folder names.  The end results looked like this:




It’s really only the native folder we care about.  Stick it anywhere, just remember the path.


Now back in NetBeans, right click playndemo Java and select Properties.





We now have to add a VM param to the Run options.  On the categories side, select Run, then on the right in VM options, add  -Djava.library.path=c:\path\to\lwjgwl\windows, like this:




Click OK, then right click the Java project and select Run.




Voila, your running Java PlayN application.  Now on the the HTML project.


Running the PlayN HTML application


Right click playndemo HTML and choose Run:




If Run isn’t an option, something went wrong when you configured the Java Webserver plugin, or you aren’t running EE edition.  Go back and repeat that step until run appears.


On first run ( assuming you didn’t install a webserver as part of your Netbeans install ), you will encounter this dialog with an empty server list:





We now need to install and configure a web server, don’t worry, its an easy process.  In the menu, select Tools->Servers




In the resulting dialog, click Add Server…




Click GlassFish Server 3+, then Next




Save it wherever you want, I went with the defaults, click Finish ( unless you want to change default settings ):




If all went well, you should see the following screen, simply click Close.




Now right click playndemo HTML and choose run. Now in the deployment dialog, you have a server you can select, do so and click OK:




And voila, your app running in a browser:




If you have problems or need to maintain or restart your GlassFish install, you can do so via the Window->Services menu option:




Running your PlayN Android Application in Netbeans


This part has a bit of a gotcha attached.  PlayN switched to use OpenGL 2.0 and the Android emulator simply doesn’t support Open GL 2.0 yet.  You can try to run it on the emulator, but it will crash every time.  If you have a physical device, you can get Netbeans to target it.


First right click playndemo and select Properties:



On the left hand side selection Actions.  In the Actions list, select Run Project.  Under Execute Goals: enter android:deploy android:run, and under Set Properties: enter skipTests=True and android.device=usb.  Finally click OK.  This is behind the scenes configuring a pair of maven commands.




Now with your Android phone plugged in, with USB debugging enabled, right click playndemo and choose Run.  Oddly enough, sometimes it deploys and runs the application, sometimes it simply deploys it and fails to run.  Worst case scenario, locate the app icon on your device and launch it manually.


Voila, PlayN running on my Galaxy Note  ( the black is because of the 1280x720 resolution ):





As you can see, you can successfully target all three platforms from Netbeans.  Trust me, that process looked a lot more complicated than it actually was.  Plus, you only have to do 95% of it once.

Programming , ,

23. May 2012


The developers over at Google have announced PlayN release 1.3!  Ok, I’m a bit late to theplayn-logo party, as they actually announced it two days ago, but hey… it was a holiday here in Canada, so I was allowed to be asleep at the wheel on this one! Winking smile


So, what have we got to look forward to in the 1.3 release?



- The Java backend has been rewritten to use LWJGL instead of Java2D.
This makes the Java backend behave more like the other OpenGL
backends, and allows one to write and test code that uses the GL20
(direct-to-OpenGL) abstraction on the desktop, just as one does for
the 2D PlayN APIs.

- HiDPI (aka Retina) support is implemented for the Java, iOS and
Android backends. Eventually we can probably make it work in the HTML
backend as well for games that wish to use HiDPI images for their web
incarnation. I will write an article explaining HiDPI support and how
to use it in the not wildly distant future.

Note that the Java backend now requires LWJGL's native libraries. The
new archetype contains the necessary changes to the POM to cause Maven
to automatically unpack and use the native libraries. I'll also update
the samples with the same changes. Please make these same changes to
your project's java/pom.xml when you upgrade to PlayN 1.3. Eclipse
users will probably need additional machinations, which can hopefully
be detailed by someone who has been using Eclipse with 1.3-SNAPSHOT
for the last month or so.


You can get the full details in the release notes.


To go along with PlayN’s 1.3 release, TriplePlay also has announced a 1.3 release.  TriplePlay is, in their own words:

Triple Play is a collection of game-related utility classes that can be used with the PlayN library on all of its myriad platform targets.


Basically it adds a heap of great functionality on top of PlayN, likes GUIs, animation controllers, etc…  The lead developer of TriplePlay, Michael Bayne, is probably the most unsung hero of the PlayN development, and is easily the most active developer outside of Google ( or perhaps, over all? ) and deserves kudos for his efforts.


TriplePlay 1.3 details are in the release notes.




To get up and running, follow these instructions.  Note, you need to set the version to 1.3 instead of the values mentioned in the tutorial.


EDIT: Big warning however!  The current build requires LWJGL native libraries or it will break.  They are in the process of making this part less… broken, but for now it simply won’t work unless you handle this dependency manually.

News ,

10. April 2012



Got an Android device and dreamed about coding while out and about?  Until now your choices have been slim to none, but that’s changed with the release of AIDE.aide  What is AIDE?  It’s a complete Java toolchain, including IDE that runs on your Android device.  Frankly, it’s really really really cool.  Did I mention yet, it’s very cool?  Cause it is!



Everything you need to create an Android app is included, from a text editor with full auto-completion, full compiler, app signing.  Perhaps more impressively, it also includes a full Git implementation and the ability to load Eclipse projects from your DropBox account.



Here is AIDE in action on my Samsung Galaxy Note:




On my Transformer, with full keyboard, it is actually a remarkably desktop-like development experience, but even more shocking, developing on my phone was actually do-able.  Not something I would want to do every day, but editing code was very natural.  The zooming feature is extremely smooth.




Now ready to be really impressed?



First off… it’s free!



Second, it’s just over 6MB in size!  An entire Java toolchain, including IDE in under 6 MB?  Extremely impressive.



AIDE is still currently in beta, but well worth checking out!  You do require Android 2.2 or higher.

Cool Thing of the Week

15. November 2011



Eclipse has this annoying habit of using the JRE instead of a JDK you have installed.  It isn’t immediately obvious what is happening until you attempt to build a project.  For example, I just move some PlayN source to a new laptop and when I try to compile I get:


[ERROR] Failed to execute goal on project tictactoe: Could not resolve dependencies for project com.gamefromscratch:tictactoe:pom:0.0.1-SNAPSHOT: Could not find artifact com.sun:tools:jar:1.6 at specified path C:\Program Files (x86)\Java\jre6\..\lib\tools.jar -> [Help 1]


Which can be a bit of a head scratcher if you haven’t been bit by it before, but there error is exactly right, the JRE unlike the JDK doesn’t have everything installed, including the aforementioned tools.jar.  Fortunately the fix is quite simple.




In Eclipse, select the Window menu->Preferences.  Then select Java->Installed JRE’s.  Then click Add… select Standard VM then click Next.  In the JRE home, navigate to the folder you’ve installed the JDK to ( c:\Program Files\Java\jdk1.6.0_21\ in my case ).  It will now churn away for a while.  After a few seconds, it should look like this:






Now click Finish.


This will bring you back to the installed JRE’s window, unclick the JRE and click your newly added JDK, like this:





And voila!  you are now configured to properly use the JDK instead of the JRE in Eclipse.  So if you run into the error saying tools.jar is missing and you are using Eclipse, this is probably the problem.



If you launch Eclipse from the command line or via a shortcut, you can also set this value using the –vm command line setting, simply type:


eclipse.exe –vm c:\path\to\jdk\bin\javaw.exe


12. October 2011



Google has released their new open sourced write once run anywhere gaming library, PlayN.  Well if by anywhere you mean Android, Flash, HTML5 or Java that is.  Here is the announcement video:



In a nutshell, you write your code in Java and it cross compiles to the 4 supported formats.  It’s odd that in the video they announce iOS as one of the platforms that developers need to support ( probably the biggest platform to boot! ) and yet PlayN doesn’t support iOS.  A bit of a headscratcher there!


Anyways, I will take a closer look into PlayN and give a review of sorts over the next couple days.

Programming, General , , , ,

Month List

Popular Comments