Slick2D Wiki - User contributions [en-gb]

Tutorial

2013-08-09T18:30:19Z

Sigtau: Redirected page to Category:Tutorials

#REDIRECT: [[:Category:Tutorials]]

Main Page

2013-08-09T00:12:05Z

Sigtau:

Slick2D is an easy to use set of tools and utilities wrapped around LWJGL OpenGL bindings to make 2D Java game development easier.

Slick2D includes support for images, animations, particles, sounds, music and much much more. Additionally there are many community based projects that add additional functionality such as entity support, theme-able widgets and box2d wrappers.

With an active forum and new features in development Slick2D is a great choice for your 2D java game!

'''New!''' All of the old wiki pages from the cokeandcode.org wiki have been ported to this wiki. Use the search feature to find out more!

=Tutorials=
* [[Setting up Slick2D with NetBeansIDE]]
* [[Hello World]]
* [[Input]]
* [[:Category:Tutorials|...and more]]

=Links=
* [http://slick.ninjacave.com/ Website]
* [http://slick.javaunlimited.net/ Forums]
* [http://slick.ninjacave.com/javadoc/ Javadoc]
* [https://bitbucket.org/kevglass/slick Source code repo]

XML Packed SpriteSheet

2013-08-09T00:10:54Z

Sigtau:

These kind of sprite sheets are generated by [https://jhulk.googlecode.com/svn-history/r60/trunk/resources/packulike/packulike.jar Pack-U-Like] (Slick2D's Sprite Packer). Each XMLPackedSheet needs a base Image which contains the packed sprites and a XML-File for it's description (Position, Name, etc).

== Usage ==

Create a new Sheet:

<pre>XMLPackedSheet sheet = new XMLPackedSheet("res/sheet.png", "res/sheet.xml");</pre>

Get a Sprite:

<pre>Image image = sheet.getImage("someImage");</pre>

When images are loaded into the Pack-U-Like tool, the name of the image is set to the name of the image file which has been loaded. When referencing the image using the getImage method above, someImage refers to the image name (filename) of the image which was loaded into the packed sheet.

== See Also ==
* [[SpriteSheet]]
* [[Packed Sprite Sheets]]

[[Category:Sprites]]

TrueType Font Support

2013-08-09T00:10:13Z

Sigtau:

Slick has the capability to easily display True Type fonts on screen.

True Type Fonts are loaded and rendered using the <code>org.newdawn.slick.TrueTypeFont</code> class.

<pre>import org.newdawn.slick.TrueTypeFont;</pre>

You can find the full javadoc to the TrueTypeFont class [http://slick.ninjacave.com/javadoc/org/newdawn/slick/TrueTypeFont.html here].

== Basic Usage ==

<pre>// initialise the font
Font font = new Font("Verdana", Font.BOLD, 20);
TrueTypeFont trueTypeFont = new TrueTypeFont(font, true);

// render some text to the screen
trueTypeFont.drawString(20.0f, 20.0f, "Slick displaying True Type Fonts", Color.green);</pre>

== Additional Usage ==

=== Anti Aliasing ===

The second parameter to the TrueTypeFont constructor controls whether the font is [http://www.sdltutorials.com/Data/Posts/112/antialias.gif antialiased or not].

==Loading fonts from the classpath==

There are a number of true type fonts available on any java system. For reference, see:

http://java.sun.com/j2se/1.5.0/docs/api/index.html?java/awt/Font.html

Most people will also want to load custom fonts for display. Below is a short example which loads a ttf font that has been included in the programs classpath.

<pre>import org.newdawn.slick.Color;
import org.newdawn.slick.TrueTypeFont;

import java.awt.Font;
import java.io.BufferedInputStream;
import java.io.IOException;

public class TTFTest {

public static void main(String[] args)
throws LWJGLException, FontFormatException, IOException {

Font font;
TrueTypeFont trueTypeFont;

// not included for brevity
initGL();

Font startFont = Font.createFont(Font.TRUETYPE_FONT,
new BufferedInputStream(TTFTest.class.getClassLoader().getResourceAsStream(
"technoid.ttf")));
Font baseFont = startFont.deriveFont(Font.PLAIN, 20);
trueTypeFont = new TrueTypeFont(baseFont, true);

while (true) {
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
trueTypeFont.drawString(20.0f, 20.0f, "this is a test", Color.gray);

Display.update();
if (Display.isCloseRequested()) {
System.exit(0);
}
}
}
}</pre>

== Using the TrueTypeFont Class Outside of Slick ==

You may use the TrueTypeFont class outside of the slick 2d engine. If you do this, keep in mind:

The TrueTypeFont class assumes you are using the TextureLoader (also included in slick-util) to load and bind gl textures. See:

* [http://web.archive.org/web/20090129084145/http://slick.cokeandcode.com/javadoc-util/index.html?org/newdawn/slick/opengl/TextureLoader.html TextureLoader]
* [http://web.archive.org/web/20090129084145/http://slick.cokeandcode.com/javadoc-util/index.html?org/newdawn/slick/opengl/Texture.html Texture]

If you use your own GL methods to bind textures, TrueTypeFont may not display correctly. To ensure TrueTypeFont works, insert a call to <code>TextureImpl.bindNone()</code> before your drawstring calls. For example:

<pre>TextureImpl.bindNone();
trueTypeFont.drawString(20.0f, 20.0f, "this is a test", Color.gray);</pre>

[[Category:Fonts]]

State Based Games

2013-08-09T00:09:43Z

Sigtau:

The [http://slick.ninjacave.com/javadoc/org/newdawn/slick/BasicGame.html BasicGame] class can get you a long way with simple game development. However, when games become more complicated it's often useful to separate out the different parts into separate classes with logic and rendering. These different parts are referred to states, as in the state a game is in.

In Slick this concept is supported via the Game implementation [http://slick.ninjacave.com/javadoc/org/newdawn/slick/state/StateBasedGame.html StateBasedGame]. This game implementation proxies the render and logic methods to the “current” state. The states available and current are set externally by supplying implementations of the [http://slick.ninjacave.com/javadoc/org/newdawn/slick/state/GameState.html GameState interface]. However, a convenience implementation of State is supplied, analogous to BasicGame, named [http://slick.ninjacave.com/javadoc/org/newdawn/slick/state/BasicGameState.html BaseGameState].

The GameState is similar to the game interface, in that it has an init, render and update methods. However, the state based game can hold multiple of these state implementation which it can then switch between. In this way the render and logic associated with each facet of the game can be separated into different classes.

As an added bonus, when swapping between these game states a visual effect can be applied to make the swap seem more fluent. These visual effects are referred to and implemented as [http://slick.ninjacave.com/javadoc/org/newdawn/slick/state/transition/Transition.html Transitions].

== See Also ==
* [http://slick.ninjacave.com/javadoc/org/newdawn/slick/tests/StateBasedTest.html StateBasedTest] on the Slick Javadoc

[[Category:Miscellaneous]]

Setting up Slick2D with NetBeansIDE

2013-08-09T00:09:15Z

Sigtau:

==Introduction==

This tutorial will run you through the steps you'll need to set Slick2D up with [http://www.netbeans.org/ NetBeans].

Since Slick2D uses [http://www.lwjgl.org/ LWJGL], setup is split into 2 parts, the JAR files, and the LWJGL natives (*.dll files for Windows, *.so files for Unix and Linux and *.dylib/*.jnilib for Mac).

==Downloading and Extracting Slick2D and LWJGL==

* Download [http://slick.ninjacave.com/slick.zip Slick2D]
* Download [http://www.lwjgl.org/download.php LWJGL] standard bundle

* Extract the LWJGL zip (lwjgl-x.x.zip) file somewhere in your computer, remember or note down the location, you will need this later. We suggest you create a library (/lib) folder to store all these files in a well-known place.

==Setting Up Slick2D and LWJGL in NetBeans==

Extracted from [http://lwjgl.org/wiki/index.php?title=Setting_Up_LWJGL_with_NetBeans LWJGL with Netbeans]

# Open up NetBeans.
# Go to Tools|Libraries in the main menu.
# Click on the New Library button.
# Type in Slick2D or any other name that you want for the Library Name.
# Select Classpath tab for your newly created Library and then click the Add JAR/Folder... button.
# Go to where you extracted lwjgl-X.X.zip and add the following '.jar'('Ctrl' or 'Alt' to select multiple files)
## lwjgl.jar
## slick.jar
## jinput.jar
## lwjgl_util.jar (if want to use OpenGL's GLU class)

==Setting Up a Project to use LWJGL in NetBeans==

* In a new Java project:

# Right-Click your project node or go to File>Project Properties and select Libraries
# Add your Slick2D Library , created as instructed above
# Select Run
# On VM Options put the following:

-Djava.library.path=<lwjgl-X.X path>/native/<linux|macosx|solaris|windows>

Note: Remember to select the natives of your operating system.

[[Category:Tutorials]]

Resource Loading

2013-08-09T00:08:34Z

Sigtau:

When referencing resources ([[images]], [[SpriteSheet|spritesheets]], fonts, sounds etc.) the underlying class will use the ResourceManager to find the resource and obtain an input stream to it.

The resource manager first tries to look the resource up using the classpath. Putting your resources in the classpath is generally the best way to work since it makes transitioning to deployment (webstart and/or applets) much easier - since the classpath is present at testing and at deployment. Note that the context class loader is used which ensure that at deployment what ever the framework being used for deployment is can specify an appropriate class loader to obtain resources.

If the resource manager is unable to locate the resoruce within the classpath it will attempt to use the reference provided as a file name relative to the current directory. This is sometimes useful during testing. It is also possible to deploy while still being dependent on direct file reference (maybe using an installer and keeping files unjarred) but this is not recommended.

Finally if the resource manager can not locate the resource it will report an error which may stop initialisation. It is possible that resource location can fail but still the resource can remain valid and so a resource simply not being located is not always a reason to stop init.

== See Also ==
* [[Deferred Resource Loading]]

[[Category:Resources]]

Pedigree Editor

2013-08-09T00:08:06Z

Sigtau:

The particle system included with Slick is simple but very effective at providing organic looking effects. However, it can be hard to understand how to achieve these effects.

The Pedigree particle editor was intended as a “stand in” until a more ornate and complete 2D particle system editor came along. However, as yet we've been unable to find anything that is full functional with an open specification. The Pedigree Editor is based around the XML specification that drives the Configurable Emitters.

Pedigree (and hence the XML specification) has thus far been developed in two iterations. The first of which was intended to give basic functionality for particle effects. It allows you to define how the particles will be created (size, position, initial velocity, initial colour) and how they will change over their life time (size, colour, velocity, alpha change).

The second iteration (referred to as Whiskas) was supplied by an active user, Void256, who added the facilities to define the change over the life time of the particles with a graph of points using linear intepolation between the values to allow more creative designs.

The recommended way to learn to use the editor is by simply fiddling. Most users have had great success producing effects just by tweaking different configuration values. Note that this tool is provided as a stop gap and hence there isn't a complete manual or much in the way of formal testing. With luck a full replacement will become available.

One of the established “we will not dos” of Slick is the intention not to write ornate specific tools for the library - which end up taking more time that the rest of the library of useful facilities. With this in mind we're still looking for a good clean replacement - if you know of one please let us know on the forums

Example XML files are provided with the tool, however all Configurable Emitters XML files should be loadable.

== External Links ==
* [https://bitbucket.org/kevglass/slick/src/c0e4b96798d1c5b1969a26cb62eb7489d701ca6f/trunk/Slick/tools/org/newdawn/slick/tools/peditor?at=default Pedigree Editor source code] at BitBucket

[[Category:Particles]]

Overview

2013-08-09T00:07:11Z

Sigtau:

Slick2D is a simple set of tools wrapped around the [http://lwjgl.org/ LWJGL] OpenGL binding for Java. It's aims are as follows:
* Provide a simple 2D API
* Make transition from Java2D to OpenGL easier
* Enable distribution via WebStart without the complexity
* Provide the tools required for most simple games out of the box
* Extensible framework for flexibility
* Mix and Match - you use what you want, nothing is enforced.
* Help with rendering, sound, input, collision and anything else we can think of.

Here are some things we're explicitly not doing and why:
* Abstracting the rendering method (i.e. Java2D or OpenGL). With the advent of LWJGL Applets, it's a waste of time and just makes things more complicated.
* Take over your development - where would the fun be if the library just forced you to do everything it's way?
* Fix everything - there will always be challenges in games development.
* Move to 3D eventually.

Check out the [[Getting Started]] guide to start your journey into slick-smooth Java game development!

[[Category:Tutorials]]

Input Handling

2013-08-09T00:06:22Z

Sigtau:

Slick input can handle keyboard, mouse and controller input (mostly just wrapped carefully around the existing LWJGL functionality). The input processing is handled by the [http://slick.ninjacave.com/javadoc/org/newdawn/slick/Input.html Input] class. To receive input you need to get an instance of this class and call <code>poll()</code> during the game loop to check input and fire events to registered listeners. If you're using the GameContainer framework then this is all handled for you and you can simply call GameContainer.getInput() (which is the preferred option).

Input can be retrieved in two ways (discussed in later section). You can either poll the keyboard, mouse and controllers by using the direct method calls on Input such as <code>isKeyPressed()</code>. This will give you the state of the input at any time. Alternatively you can register a listener with the Input instance you're using with addListener and then implement the [http://slick.ninjacave.com/javadoc/org/newdawn/slick/InputListener.html InputListener interface] to handle notifications of input changes. Note that if you're using an extension of [http://slick.ninjacave.com/javadoc/org/newdawn/slick/BasicGame.html BasicGame] then this is done for you and you can simply override the input event handler methods.

== See Also ==
* [[Polling the Current Input State]]
* [[Event-Driven Input]]

[[Category:Input]]

ImageBuffer

2013-08-09T00:05:54Z

Sigtau:

Normally you'll load images from files in known formats. However, there are cases where you'd like to be able to generate an image based on a set of data you've created. Some examples are terrain and custom image loading. In Slick you have two options - either you understand the underlying image data classes and build yourself a modified one - or you use the simple [http://slick.ninjacave.com/javadoc/org/newdawn/slick/ImageBuffer.html ImageBuffer utility class].

An ImageBuffer is set of data that can be converted to a Slick Image at a later point. However, the created image is a copy of the image buffer and hence subsequent changes to the ImageBuffer don't change previously created images.

Using the ImageBuffer is reasonably simple. Create an ImageBuffer with the appropriate size for your desired image - note that this can not be bigger than the texture size supported by your target platform (2048×2048 is a normal, but 512×512 is a safe bet). Next set the pixels in the buffer with <code>setRGBA()</code> as required. Finally convert the buffer into an image by calling <code>getImage()</code>. The returned image will be made up of the buffer's contents converted into an OpenGL texture.

== See Also ==
* [[Rendering to an Image]]

[[Category:Graphics]] [[Category:Images]]

ImageBuffer

2013-08-09T00:05:40Z

Sigtau:

Normally you'll load images from files in known formats. However, there are cases where you'd like to be able to generate an image based on a set of data you've created. Some examples are terrain and custom image loading. In Slick you have two options - either you understand the underlying image data classes and build yourself a modified one - or you use the simple [http://slick.ninjacave.com/javadoc/org/newdawn/slick/ImageBuffer.html ImageBuffer utility class].

An ImageBuffer is set of data that can be converted to a Slick Image at a later point. However, the created image is a copy of the image buffer and hence subsequent changes to the ImageBuffer don't change previously created images.

Using the ImageBuffer is reasonably simple. Create an ImageBuffer with the appropriate size for your desired image - note that this can not be bigger than the texture size supported by your target platform (2048×2048 is a normal, but 512×512 is a safe bet). Next set the pixels in the buffer with <code>setRGBA()</code> as required. Finally convert the buffer into an image by calling <code>getImage()</code>. The returned image will be made up of the buffer's contents converted into an OpenGL texture.

== See Also ==
* Rendering to an Image

[[Category:Graphics]] [[Category:Images]]

Getting Started

2013-08-09T00:04:29Z

Sigtau:

The information below will let you know what to get and how to get it. However, the first challenge with any new API is getting some idea of where to start code wise. Most users of Slick so far have found that starting by playing with the included test examples is a good place to start understanding how things hold together. To get the tests you can download the distribution (see below) and find the tests in the org.newdawn.slick.tests package.

==Getting the Slick Distribution==

The Slick distribution contains a complete set of source code, test resources and tools for the library. It also contains build scripts and tests for the API. This is useful both to get a feel for how to use Slick and for making modifications to the platform to enhance how you use it. The distribution package also contains all the libraries required for deployment as webstart and applet. The distribution is available as a ZIP from:

http://slick.ninjacave.com/slick.zip

==Determining Your Build Version==

The current Slick version is always displayed at the top of the website. To determine the version of your Slick JAR open it in a ZIP tool. At the root of the JAR you'll find a file named “version”. This file contains a property defining the version in the form:

<code>build=75</code>

==Getting Slick via BitBucket==

Slick's source code and resources are stored in a central git repository. You can browse this repository using the a web client. You can also get direct read only access to the Slick git using the following git repository URL:

https://bitbucket.org/kevglass/slick

Alternatively, you can browse the source tree using a web browser using the link above.

Slick development is currently closed to new developers, hence write access to the repository is not currently available. Patches and feature adds are accepted via the forums and the development is planned to open up to selected developers at a later date.

==Building Against Slick==

To build against Slick you require “slick.jar” in your build classpath. How this is setup varies from build environment to build environment. Refer to the documentation for your IDE to determine how this can be setup. It is also advisable to have the runtime dependencies in the build classpath while building. This will allow you to use direct access to LWJGL and other dependencies when it becomes necessary to get a finer level of control.

==Runtime JARs and Libraries==

When running your Slick game you need to include the libraries in the “lib” directory in your classpath. These support each of the facets of the Slick API. In addition the native libraries (DLLs on Windows, .so on Linux, jnilib on MacOSX) must be included in your native library search path.

If you are seeing errors including the term 'UnsatisifiedLinkError' when trying to run the demos or the application this always means that Java cannot find the native libraries.

On Windows the library path includes the current directory. So if you run from the location of the DLLs they should automatically be found. However, on other platforms and if you want to use the natives from a different location you must specify the following command line argument when running Java:

<code>-Djava.library.path=<the directory in which the native libraries are placed></code>

This argument should be placed directly after the “Java” executable name on the command line. The value specified should be the fully qualified path to the directory containing your DLLs, .so or .jnilib files. The native libraries should not be in jars. There should be no spaces in the path to the location.

Please note that an unsatisfied linking error always indicates that the native libraries can not be found (for one reason or another). This does not relate to not being able to find JAR files which are specified separately in the classpath.

== See Also ==
* [http://www.cs.bsu.edu/homepages/pvg/misc/slick_eclipse_tutorial.php Setting up Slick with Eclipse]
* [http://ray3k.com/site/tutorials/tutorial-setup-slick-in-netbeans/ Setting up Slick with Netbeans]

[[Category:Tutorials]]

Fonts

2013-08-09T00:03:59Z

Sigtau:

#REDIRECT [[Font Rendering]]

[[Category:Fonts]]

Deferred Resource Loading

2013-08-09T00:03:05Z

Sigtau:

Slick is implicitly single threaded. The game loop is written around the concept that there is only a single thread and hence no need to worry about synchronization. One of the areas that this falls down is when loading a large amount of resources needed to be loaded. This can cause a blank screen to be displayed at start up while the single thread loads all the resource before feeding back that the game is starting to the user. One option would be to allow another thread to be running in the background to load resources - however, this is technically annoying to do while maintaining a simple API and code base.

Slick provides a way to get this loading bar style initialization - called deferred loading. When deferred loading is enabled all the calls to load resources (images, sounds, music, fonts etc) are wrapped in the library to load only the explicit data required for the resource immediately. Each resource handle that is returned is then placed in the global [http://slick.ninjacave.com/javadoc/org/newdawn/slick/loading/LoadingList.html LoadingList]. As each part of your game requests resources, this list builds up to be a global set of resource handles for everything in the game.

Once initialization is complete, we can then simply cycle through the loading list loading each resource. However, we can do this in a controller manner - load one resource, update the screen, load the next resource, update the screen. No one resource should take so long to load that it keeps the screen from refreshing for a significant amount of time (if it does, then the resource should probably be streamed anyway :)).

The [http://slick.ninjacave.com/javadoc/org/newdawn/slick/tests/DeferredLoadingTest.html DeferredLoadingTest] should give you a clear view of how this intended to be used. Essentially it works like so:

<pre>
public void render(GameContainer container, Graphics g) {
g.drawString("Loaded: "+lastLoaded, 100, 100);
}

public void update(GameContainer container, int delta) throws SlickException {
if (LoadingList.get().getRemainingResources() > 0) {
DeferredResource nextResource = LoadingList.get().getNext();
nextResource.load();
lastLoaded = nextResource.getDescription();
} else {
// loading is complete, do normal updat ehere
}
}</pre>

While this solution isn't perfect in practice it works for most situations, while keeping the implementation and API simple.

== See Also ==
* [[Resource Loading]]

[[Category:Resources]]

Configurable Emitters

2013-08-09T00:02:25Z

Sigtau:

[http://slick.ninjacave.com/javadoc/org/newdawn/slick/particles/ConfigurableEmitter.html ConfigurableEmitters] are a generic type of [[Emitter]] that is configured by an open XML specification. These emitters can be visually designed with the [[Pedigree Editor]] and can be loaded into Slick using the ConfigurableEmitters.

The configurable emitter description allows definition of how particles will be produced (their size, colour, location etc) and how they will change with time. An extension to the specification (and the Editor) produced by Void allows these changes to specified with multiple point interpolation - allowing wierd and wonderful changes during the lifetime of the particles.

== Examples ==
=== Flame.xml ===
'''Description:''' A burning flame.
<pre>
<emitter imageName="" name="Flame">
<spawnInterval enabled="false" max="100.0" min="100.0"/>
<spawnCount enabled="true" max="20.0" min="5.0"/>
<initialLife enabled="false" max="1000.0" min="1000.0"/>
<initialSize enabled="true" max="25.0" min="25.0"/>
<xOffset enabled="true" max="8.0" min="-8.0"/>
<yOffset enabled="true" max="15.0" min="-8.0"/>
<initialDistance enabled="false" max="0.0" min="0.0"/>
<speed enabled="true" max="200.0" min="50.0"/>
<length enabled="false" max="1000.0" min="1000.0"/>
<spread value="26.0"/>
<angularOffset value="0.0"/>
<growthFactor value="50.0"/>
<gravityFactor value="0.0"/>
<startAlpha value="255.0"/>
<endAlpha value="0.0"/>
<color>
<step b="1.0" g="1.0" offset="0.0" r="1.0"/>
<step b="0.0" g="1.0" offset="0.336" r="1.0"/>
<step b="0.0" g="0.0" offset="1.0" r="1.0"/>
</color>
</emitter>
</pre>

=== Smoke ===
'''Description:''' Smoke emitting from a centerpoint
<pre>
<emitter imageName="" name="Smoke">
<spawnInterval enabled="false" max="100.0" min="100.0"/>
<spawnCount enabled="true" max="1.0" min="1.0"/>
<initialLife enabled="true" max="4000.0" min="4000.0"/>
<initialSize enabled="true" max="28.0" min="28.0"/>
<xOffset enabled="false" max="0.0" min="0.0"/>
<yOffset enabled="true" max="0.0" min="0.0"/>
<initialDistance enabled="false" max="0.0" min="0.0"/>
<speed enabled="true" max="70.0" min="50.0"/>
<length enabled="false" max="1000.0" min="1000.0"/>
<spread value="30.0"/>
<angularOffset value="0.0"/>
<growthFactor value="9.0"/>
<gravityFactor value="0.0"/>
<startAlpha value="255.0"/>
<endAlpha value="0.0"/>
<color>
<step b="1.0" g="0.8" offset="0.0" r="0.8"/>
<step b="0.4" g="0.4" offset="1.0" r="0.4"/>
</color>
</emitter>
</pre>

[[Category:Particles]]

Basic Setup

2013-08-09T00:01:34Z

Sigtau:

1.Download Slick2D from [http://slick.ninjacave.com/slick.zip here] and LWJGL from [http://lwjgl.org/download.php here]. 
2.Create a library in your [http://en.wikipedia.org/wiki/Integrated_development_environment IDE], call it however you want! 
3.Include slick.jar (under the ''lib'' folder inside the slick.zip file), lwjgl.jar (under the ''jar'' folder inside the lwjgl.zip file) and lwjgl-util (again, under the ''jar'' folder inside the lwjgl.zip file). 
4.Create a new project in your IDE and add the library you created. 
5.Extract the ''native'' folder from the lwjgl.zip file. 
6.Go to your project properties (yeah, the one you created with me) and add the natives path. But how? 

=== Adding natives in NetBeans ===
#Right click your project -> properties.
#Select the ''run'' category.
#Enter the following into VMOptions: -Djava.library.path='''<lwjgl-X.X path>'''/native/'''<linux|macosx|solaris|windows>''' (complete needed).
#Cheer.

7.Now we'll try running a very simple game! The point of the game will be checking if our setup succeeded! 
Create a main class includes the following:
<pre>
package simpleslickgame;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.newdawn.slick.AppGameContainer;
import org.newdawn.slick.BasicGame;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.SlickException;

public class SimpleSlickGame extends BasicGame {

public SimpleSlickGame(String gamename) {
super(gamename);
}

@Override
public void init(GameContainer gc) throws SlickException {
}

@Override
public void update(GameContainer gc, int i) throws SlickException {
}

@Override
public void render(GameContainer gc, Graphics g) throws SlickException {
g.drawString("Howdy!", 10, 10);
}

public static void main(String[] args) {
try {
AppGameContainer appgc;
appgc = new AppGameContainer(new SimpleSlickGame("Simple Slick Game"));
appgc.setDisplayMode(640, 480, false);
appgc.start();
} catch (SlickException ex) {
Logger.getLogger(SimpleSlickGame.class.getName()).log(Level.SEVERE, null, ex);
}

}
}
</pre>
8.If everything went smooth, cheer harder.

[[Category:Tutorials]]

Basic Setup

2013-08-09T00:01:03Z

Sigtau: Undo revision 26 by Shpitzick (talk) - Why the hell did you delete this? It's a perfectly good page.

Webstart

2013-08-08T23:59:55Z

Sigtau:

Java Webstart is a very handy way of deploying your game or application over the web. Fortunately, Slick makes it easy to enable your application for use with webstart. For more information see the Webstart Docs, or have a look at [http://web.archive.org/web/20090125183754/http://www.cokeandcode.com/webstarthowto Kev's Webstart Walkthrough (archived)].

==Creating JAR Packages==

The first step is to package up your application into a JAR package. There are a number of ways of doing this depending on your development environment. For more information about JARs see the [http://java.sun.com/docs/books/tutorial/deployment/jar/ Java JAR Tutorial].

=== Creating a JAR Package using the Command Line ===

For example using the commandline, the following will create a JAR package containing all the .class files in the current folder (and any subfolders) and all the .bmp files in the subfolder images.

<pre>jar cvf MyGame.jar *.class images/*.bmp</pre>

Note that you do not have to include a manifest file or specify a start up class if you are going to use the package with webstart. There are many other options available when using the jar command such as being able to update a JAR if you have made changes to some of the files contained in it. To see these options just type jar with no arguments on the command line.

=== Creating a JAR Package in Eclipse ===

In Eclipse the best way to create a JAR from your application is to use the export method. Right click your project and select Export from the menu. You'll then be asked how you want to export the project. Expand the Java node, select JAR file and click Next. Then you'll be able to select the resources you want to include in the jar. Include all the Java classes and packages that your application needs. Then select the other resources in your filespace that your application uses such as images, sounds, particle systems etc. You might find that the filespace shown in Eclipse is not up-to-date in which case you'll need to close the Export dialog and refresh your filespace by right clicking your project and clicking Refresh. Once you have selected the files you want to include in your JAR, select the export destination to store your jar file and then click Next.

In the next screen, make sure you tick “Save the description of this JAR in the workspace”. Type in or click browse to enter a location and file name to store the settings for this export for example “MyProject/BuildJAR”. Then click Next.

In the next screen you can either generate a manifest file automatically, or use an existing manifest file if you have already created one. You can also Select a main class for this JAR which will run when the jar itself is run. This isn't necessary for Webstart though. When you click Finish, the JAR file will be built. If you see warnings then it's likely that Eclipse is informing you that you have some compile warnings in your code. It should be safe to ignore these if you want.

After you have first built your JAR in Eclipse, you will see a .jardesc in your workspace (if you don't then make sure you saved the JAR description in the steps above). If you make changes to your code and you want to recreate your JAR, then simply right click on the .jardesc file and select Create JAR. If you want to include new files or remove old files from the JAR then select Open JAR Packager to change these options.

=== Creating JARs from ZIPs ===

An alternative way to create JARs is to create a zip archive with all the classes and resources your application needs and the simply rename the .zip to .jar. It should work fine with Webstart!

=== Creating a JNLP ===

In Webstart, the JNLP file is the XML file that your users download which describes all the JARs and other libraries and resources that your application needs to run. In a Slick application you only need to reference the JAR of your application and the Slick library.

<pre>
<?xml version="1.0" encoding="utf-8"?>
<jnlp
spec="1.0+"
codebase="http://www.mydomain.com/games"
href="mygame.jnlp">
<information>
<title>My Game</title>
<vendor>My Vendor Name</vendor>
<homepage href="http://www.mydomain.com"/>
<description>My Game</description>
<description kind="short">My Game</description>
<icon href="icon.gif"/>
</information>
<resources>
<j2se href="http://java.sun.com/products/autodl/j2se" version="1.4+" max-heap-size="128m"/>
<jar href="mygame.jar"/>
<extension href="http://slick.cokeandcode.com/demos/slick.jnlp" version="0.4"/>
</resources>
<application-desc main-class="MyMainStartupClass"/>
</jnlp>
</pre>

Just use the above structure and save the xml file as a .jnlp file. Make sure you change all the details such as the codebase (the location of your jnlp and jar files), the jnlp file name, the game title, vendor and description information. You can also include an icon if you like. This should be 64x64px.

The last few settings are the most important. Firstly the j2se tag points to the download location of the required build of Java needed to run your program. It also specifies the minimum Java version needed and will display an error if the user's version is below that.

The jar tag points to your JAR file. If you have more than one JAR file you can simply add multiple jar tags.

The extension tag is what links your application to Slick. The slick.jnlp file includes the LWJGL libraries, the Slick library itself along with some other supporting files. You can also optionally specify a version attribute to this tag. This will make sure that your application only uses the specified version of Slick. If you want to always use the latest version of Slick, just remove this attribute.

Finally the last option is the main-class attribute. Just set this to the class name (including the package if you're using them) of your main start up class. This is the class that will be run once Webstart has finished everything else.

== Uploading and Deploying your Application ==

Now that you have your JAR and JNLP files created all that remains to do is to upload them to the web. For this you need a webhost that supports jnlp files. If your host runs on linux you can probably enable support for JNLPs yourself. If your host uses Windows you may have to request JNLP support to be enabled.

If you don't have a host then I recommend using MyJavaServer. This service is currently exclusive to Java developers and restricts access to others by posing a Java related problem which you have to solve to obtain an account.

With your host ready, simply upload your JAR, JNLP and any icon files you're using to some location on your server. Now if you did everything right, you should be able to simply navigate to your jnlp file through your browser and the application should fire up in Webstart. If so, congratulations! You can show share your game with all your friends!

[[Category:Deployment]]

Tile Map Support

2013-08-08T23:59:22Z

Sigtau:

In 2D games the environment is quite often rendered a series of images arranged in a grid formation - this is referred to as a Tile Map. Each image is called a tile, the tile map being the laying down of a collection tiles (sometimes repeating single tiles) to form the environment. Tile Maps can be of arbitrary size and may have multiple layers of tiles. For instance, in may make sense in a top down game to have a layer of tiles for the floor, a layer of tiles for the walls and a layer for the ceiling. This allows you to render the appropriate parts of the map at the appropriate times.

In Slick there is no generic tile map support, since it's essentially drawing a set of images to form a grid. However, where appropriate tools exist Slick provides loaders and renderer for their tile map format. At the current time there is a single tile map tool supported named [http://mapeditor.org/ TileD]. This editor provides good support for layers, variable size tiles and maps. It's also very easy and productive to use. See [[TileD Import and Usage]] for more details.

[[Category:TileMaps]]

SpriteSheet

2013-08-08T23:58:45Z

Sigtau:

Sprite sheets are individual sprites (or images) put together to build one image. This is often done for performance reasons (it's faster to use one image than multiple seperate small ones). Slick provides the [http://slick.ninjacave.com/javadoc/org/newdawn/slick/SpriteSheet.html SpriteSheet] class that lets you access each of the sub-images of the sheet as seperate images easily.

The SpriteSheet class assumed that all the images are evenly spaced. It essentially splits the source image in to an even grid and then allows access to the image in each cell of the grid as a seperate image. These images can then be combined into animations or used as individual sprites/images in game rendering.

While the SpriteSheet class assumes that all the sprites are evenly spaced, the Packed Sprite Sheets uses a descriptor file to allow seconds to be placed a arbitrary location on the image and still be accessed as individual sprites.

== See Also ==
* [[Packed Sprite Sheets]]

[[Category:Sprites]] [[Category:Images]]

Scalable Vector Graphics

2013-08-08T23:58:14Z

Sigtau:

Scalable Vector Graphics (SVG) use XML files to describe 2d graphics. While other image formats like GIF or JPG represent images as arrays of colored pixels, SVG represents an image as a list of lines and shapes. The benefit of SVG images is that they can be cleanly scaled in size without causing aliasing (jagged or blurry edges). SVG images can be created with the open source program [http://inkscape.org/ Inkscape].

Slick currently supports many (but not all) SVG features. Features not yet supported include:

* Cloned objects
* Paths with jumps (ie shapes with multiple subshapes)

== Usage ==

To display an SVG image in Slick, use the [http://slick.ninjacave.com/javadoc/org/newdawn/slick/svg/SimpleDiagramRenderer.html SimpleDiagramRenderer] class. This will allow you to render the SVG using the primitive geometry entities provided by Slick.

<pre>SimpleDiagramRenderer svgimg =
new SimpleDiagramRenderer(InkscapeLoader.load("image.svg"));</pre>

In your game's <code>render()</code> method, the SVG's own render method must be called to draw it to screen:

<pre>
public void render(GameContainer container, Graphics g) throws SlickException {
...
svgimg.render(g);
...
}
</pre>

The shapes within an SVG are represented by the Figure class. You can access attributes of a figure using the <code>getData()</code> function. This can be used to obtain attributes related to how the image is rendered (colors, line widths, etc) as well as any other attributes defined in the XML describing the diagram. For example, to obtain both the fill color for the first shape in a diagram, as well as its ID, you would use:

<pre>Color c = svgimg.diagram.getFigure(0).getData().getAsColor(NonGeometricData.FILL);
String id = svgimg.diagram.getFigure(0).getData().getAttribute("id");</pre>

== See Also ==
* [[Images]]
* [http://inkscape.org/ Inkscape]

[[Category:Graphics]] [[Category:Geometry]]

Rendering to an Image

2013-08-08T23:57:39Z

Sigtau:

Sometimes you might want to create graphics procedurally using code. This is where rendering to an image fits perfectly.

To render into an image you first need to create a new one and get access to its graphics context.

<pre>private Image localImg;
private Graphics localImgG;
try {
localImg = new Image(256,256);
localImgG = localImg.getGraphics();
} catch (SlickException e) {
Log.error("creating local image or graphics context failed: " + e.getMessage());
}</pre>

The code fragment above creates an image of size 256 x 256 pixels and retrieves the graphics context of the image (localImgG).

Now we are prepared to draw on the image, so let's clear the image and prepare it with a background color of our choice:

<pre>localImgG.setBackground(new Color(0,0,0,0));
localImgG.clear();</pre>

Now let's draw something simple like a green rectangle onto the image:

<pre>localImgG.setColor(Color.green);
localImgG.drawRect(10, 10, 20, 20);</pre>

Once you finish drawing, you need to flush the operations to the actual context. You can then return the localImg for your game.

<pre>localImgG.flush();
...
g.drawImage(localImg, 100, 100);</pre>

But just a hint: on my machine it takes around a second to retrieve the GraphicsContext for an Image! This is of course not bearable in a game… To work around this I created a static Image and its appropriate GraphicsContext on game startup. Whenever I want to create a procedurally generated image I use the static one for all drawing commands. Finally I return a copy of the static image to be used in my game code. And this is fast enough. It works like this:

<pre>Image img = new Image(width, height);
localImgG.copyArea(img, 0, 0);
return img;</pre>

[[Category:Graphics]] [[Category:Images]]

Particle Engine

2013-08-08T23:57:07Z

Sigtau:

A particle engine is a collection of small sprites that each move independently based on the properties assigned by the overall engine to which the particles belong. The properties of the particle control have they move, grow and change in appearance. They also describe the state the particle are initialized in. These values are often based on pseduo-random numbers which leads to effects that tend to look more organic and unique than with canned animations.

Slick provides a simple particle engine designed to produce 2D organic effects. The [http://slick.ninjacave.com/javadoc/org/newdawn/slick/particles/ParticleSystem.html ParticleSystem] class provides the central repository for all particles. This system is a collection of particles and [http://slick.ninjacave.com/javadoc/org/newdawn/slick/particles/ParticleEmitter.html ParticleEmitter] implementations which are responsible for causing the production and change of particles during their life time.

== See Also ==
* [http://slick.ninjacave.com/javadoc/org/newdawn/slick/tests/ParticleTest.html ParticleTest] on the Slick Javadoc

[[Category:Particles]]

User:Sigtau

2013-08-08T23:56:29Z

Sigtau:

Hi, my name is Will Preston, and I'm a CG artist, hobbyist programmer, and budding game developer.

I found the old Slick Wiki in a web archive and I used this account to port all of the old Slick wiki info onto the new wiki, because I love this library and I don't want to see it fail--hopefully the port should benefit new users.

Check out my work at [http://sigmatauproductions.com/ my blog]. Happy coding!

Input

2013-08-08T23:55:21Z

Sigtau:

Slick2D input can handle keyboard, mouse and controller input (mostly just wrapped carefully around the existing LWJGL functionality).

The input processing is handled by the Input class. To receive input you need to get an instance of this class and call poll() during the game loop to check input and fire events to registered listeners.

If you're using the GameContainer framework then this is all handled for you and you can simply call gameContainer.getInput() (which is the preferred option).

There are 2 ways to handle input: You can either poll the keyboard, mouse and controllers by using the direct method calls on Input such as isKeyDown(). This will give you the state of the input at any time.

Alternatively you can register a listener with the Input instance you're using with addListener and then implement the InputListener interface to handle notifications of input changes. Note that if you're using an extension of BasicGame then this is done for you and you can simply override the input event handler methods.

==Input polling==

Polling the input allows you to check the state of the input devices at a given moment in time.This is suitable for cases where you're expecting the player to hold a button/key down while something happens in game.

For instance, hold left arrow key to run left. The key can be simply polled from the game loop. However, the downside is that if the game loop isn't running quickly enough the input may miss changes.

For instance if the user were to tap left and the tap occurred while your game was rendering it may be missed. When short lived input is expected it may be more suitable to use the event based input.

====Mouse====

Mouse input can be checked by using the isMouseButtonDown() method to check the buttons and getMouseX() and getMouseY() to check positional information. Note that the mouse position has it's origin (0,0) in the top left hand corner of the display unlike OpenGL. This is down to author discretion rather than any desperate need.

====Keyboard====

Keyboard state can be polled using the isKeyDown() method on the Input class. The identifier of the key to check should be supplied and these identifiers are defined within the Input class. For instance to check if space is pressed you do the following:
<pre class="brush:java">
input.isKeyDown(Input.KEY_SPACE);
</pre>

====Controllers====

An arbitrary number of gamepads and joysticks are support. At initialisation the controllers are detected and assigned IDs. The controller directional and button state can be polled using the isButtonXPressed() methods and the isControllerXXXX() for directional control. For instance if we'd like to check if the controller was pushed left and button 1 was pressed the following code can be used:

<pre class="brush:java">
// note we're specifying controller ID zero here, using BasicGame you can
// check all the controller in one sweep
if (input.isControllerLeft(0) && input.isButton1Pressed(0)) {
// fire the big guns here!
}
</pre>

====Examples====

[https://bitbucket.org/kevglass/slick/src/9d7443ec33af/trunk/Slick/src/org/newdawn/slick/tests/InputTest.java See the input test]

==Event based input==

In some cases it makes sense to be notified when input changes occur. The most obvious case is when implementing a GUI.

It's important that key presses aren't missed (which could happen if you poll input) and the GUI is also generally event driven. The InputListener defines a set of methods that can be implemented to receive notifications of input events from an Input instance by adding a listener using addListener().

Note that if you're using a subclass of basic game that it already implements InputListener and hence you can simply override the interface methods from the BasicGame class.

====Mouse====

Mouse events are reported to the input listener through the following methods:

<pre class="brush:java">
public void mouseMoved(int oldx, int oldy, int newx, int newy)
public void mousePressed(int button, int x, int y)
public void mouseReleased(int button, int x, int y)
public void mouseWheelMoved(int change)
</pre>

What the methods are indicating when they're called should be fairly self explanatory, however it is worth mentioning that the origin of the screen for mouse coordinates is the top left - unlike that of OpenGL which uses bottom left. This means if the mouse is clicked at the top of the screen the mousePressed() method will be called with a y value of zero.

====Keyboard====

Keyboard events are reported each time a key is pressed and release to the following two methods on the InputListener interface:

<pre class="brush:java">
public void keyPressed(int key, char c)
public void keyReleased(int key, char c)
</pre>
Note that both the key code and the character representing that key are reported. The character will only be reported for keys that can be visualised, a value of zero will be reported for other keys (like CTRL, ALT, etc).

====Controllers====

As with keyboard and mouse, connected game controllers will report events as buttons and directional controls are pressed. The following input listener methods will be called when controllers are manipulated:

<pre class="brush:java">
public void controllerButtonPressed(int controller, int button)
public void controllerButtonReleased(int controller, int button)
public void controllerDownPressed(int controller)
public void controllerDownReleased(int controller)
public void controllerLeftPressed(int controller)
public void controllerLeftReleased(int controller)
public void controllerRightPressed(int controller)
public void controllerRightReleased(int controller)
public void controllerUpPressed(int controller)
public void controllerUpReleased(int controller)
</pre>

Each event method includes the index of the controller on which the change was detected. Basic game also provides this state as protected member variables. Controller input on events is a very special case. In nearly all cases polling controllers state is more appropriate than relying on the input listener.

To use a controller, you need to add Jinput.jar to your classpath. When your game does not use a controller you can remove Jinput.jar and disable support for controllers:
<pre class="brush:java">
Input.disableControllers();
</pre>

====Within Update====

The following methods are included in Input for your convenience, and can be used to check for event-driven input within the update method. Calling them will clear their state. So they should only be called once per frame.

<pre class="brush:java">
input.isKeyPressed(Input.KEY_SPACE);
input.isMousePressed(0);
input.isControlPressed(0); //if LEFT is pressed
</pre>

Note that isControlPressed uses different indices than isButtonPressed, this is because isControlPressed checks for directional first with indices 0, 1, 2, 3 and LEFT, RIGHT, UP, DOWN, respectively. So, isControlPressed(4) checks to see if button 1 is pressed.

====Examples====

[https://bitbucket.org/kevglass/slick/src/9d7443ec33af/trunk/Slick/src/org/newdawn/slick/tests/InputProviderTest.java?at=default See the input test]

==Abstract Input==

The InputProvider binds abstract physical device controls (keyboard, mouse or game controller) to arbitrary objects which implement Command. When one of the input sources triggers, an event is fired indicating that a command should be enacted.

This allows you to separate the game commands from the configured controls.

====Usage====

First you have to create a Command object:
<pre class="brush:java">
private Command attack = new BasicCommand("attack");
</pre>
Then you define the inputs for that command:
<pre>
public void init(GameContainer container) throws SlickException {
provider = new InputProvider(container.getInput());
provider.addListener(this);
provider.bindCommand(new KeyControl(Input.KEY_SPACE), attack);
provider.bindCommand(new MouseButtonControl(0), attack);
}
</pre>
The attack command is triggered when: Space is pressed

The left mouse button is pressed
<pre>
public void controlPressed(Command command) {
message = "Pressed: "+command;
}

public void controlReleased(Command command) {
message = "Released: "+command;
}
</pre>

====Example====
* [https://bitbucket.org/kevglass/slick/src/9d7443ec33af/trunk/Slick/src/org/newdawn/slick/tests/InputProviderTest.java?at=default See the input test]

[[Category:Input]]

Image

2013-08-08T23:54:20Z

Sigtau:

#REDIRECT [[Images]]

[[Category:Images]]

Geometry

2013-08-08T23:53:49Z

Sigtau:

Slick provides some simple geometry classes in the [http://slick.ninjacave.com/javadoc/org/newdawn/slick/geom/package-frame.html org.newdawn.slick.geom] package. These classes were originally intended for basic collision detection but the basic rendering Graphics class has been extended to include rendering of the primitives at user's request.

It is not recommended that you render using primitives like rectangles, circles and polygons. While it is possible to render these shapes it isn't particularly efficient to do so in OpenGL especially as lines and so it's recommended that you use images where possible.

The following shapes are implemented/being implemented:

* [http://slick.ninjacave.com/javadoc/org/newdawn/slick/geom/Circle.html Circle]
* [http://slick.ninjacave.com/javadoc/org/newdawn/slick/geom/Rectangle.html Rectangle]
* [http://slick.ninjacave.com/javadoc/org/newdawn/slick/geom/Polygon.html Polygon]
* [http://slick.ninjacave.com/javadoc/org/newdawn/slick/geom/Line.html Line]

Each of these shapes is designed to be used (eventually) for collision though at the current time they're under development. Note that by far the most efficient collision checking to be using is circle vs circle, so where possible it's recommended you use circles or collections of circle to approximate your collision shapes.

[[Category:Geometry]]

Input

2013-08-08T23:53:18Z

Sigtau:

Slick2D input can handle keyboard, mouse and controller input (mostly just wrapped carefully around the existing LWJGL functionality).

The input processing is handled by the Input class. To receive input you need to get an instance of this class and call poll() during the game loop to check input and fire events to registered listeners.

If you're using the GameContainer framework then this is all handled for you and you can simply call gameContainer.getInput() (which is the preferred option).

There are 2 ways to handle input: You can either poll the keyboard, mouse and controllers by using the direct method calls on Input such as isKeyDown(). This will give you the state of the input at any time.

Alternatively you can register a listener with the Input instance you're using with addListener and then implement the InputListener interface to handle notifications of input changes. Note that if you're using an extension of BasicGame then this is done for you and you can simply override the input event handler methods.

==Input polling==

Polling the input allows you to check the state of the input devices at a given moment in time.This is suitable for cases where you're expecting the player to hold a button/key down while something happens in game.

For instance, hold left arrow key to run left. The key can be simply polled from the game loop. However, the downside is that if the game loop isn't running quickly enough the input may miss changes.

For instance if the user were to tap left and the tap occurred while your game was rendering it may be missed. When short lived input is expected it may be more suitable to use the event based input.

====Mouse====

Mouse input can be checked by using the isMouseButtonDown() method to check the buttons and getMouseX() and getMouseY() to check positional information. Note that the mouse position has it's origin (0,0) in the top left hand corner of the display unlike OpenGL. This is down to author discretion rather than any desperate need.

====Keyboard====

Keyboard state can be polled using the isKeyDown() method on the Input class. The identifier of the key to check should be supplied and these identifiers are defined within the Input class. For instance to check if space is pressed you do the following:
<pre class="brush:java">
input.isKeyDown(Input.KEY_SPACE);
</pre>

====Controllers====

An arbitrary number of gamepads and joysticks are support. At initialisation the controllers are detected and assigned IDs. The controller directional and button state can be polled using the isButtonXPressed() methods and the isControllerXXXX() for directional control. For instance if we'd like to check if the controller was pushed left and button 1 was pressed the following code can be used:

<pre class="brush:java">
// note we're specifying controller ID zero here, using BasicGame you can
// check all the controller in one sweep
if (input.isControllerLeft(0) && input.isButton1Pressed(0)) {
// fire the big guns here!
}
</pre>

====Examples====

[https://bitbucket.org/kevglass/slick/src/9d7443ec33af/trunk/Slick/src/org/newdawn/slick/tests/InputTest.java See the input test]

==Event based input==

In some cases it makes sense to be notified when input changes occur. The most obvious case is when implementing a GUI.

It's important that key presses aren't missed (which could happen if you poll input) and the GUI is also generally event driven. The InputListener defines a set of methods that can be implemented to receive notifications of input events from an Input instance by adding a listener using addListener().

Note that if you're using a subclass of basic game that it already implements InputListener and hence you can simply override the interface methods from the BasicGame class.

====Mouse====

Mouse events are reported to the input listener through the following methods:

<pre class="brush:java">
public void mouseMoved(int oldx, int oldy, int newx, int newy)
public void mousePressed(int button, int x, int y)
public void mouseReleased(int button, int x, int y)
public void mouseWheelMoved(int change)
</pre>

What the methods are indicating when they're called should be fairly self explanatory, however it is worth mentioning that the origin of the screen for mouse coordinates is the top left - unlike that of OpenGL which uses bottom left. This means if the mouse is clicked at the top of the screen the mousePressed() method will be called with a y value of zero.

====Keyboard====

Keyboard events are reported each time a key is pressed and release to the following two methods on the InputListener interface:

<pre class="brush:java">
public void keyPressed(int key, char c)
public void keyReleased(int key, char c)
</pre>
Note that both the key code and the character representing that key are reported. The character will only be reported for keys that can be visualised, a value of zero will be reported for other keys (like CTRL, ALT, etc).

====Controllers====

As with keyboard and mouse, connected game controllers will report events as buttons and directional controls are pressed. The following input listener methods will be called when controllers are manipulated:

<pre class="brush:java">
public void controllerButtonPressed(int controller, int button)
public void controllerButtonReleased(int controller, int button)
public void controllerDownPressed(int controller)
public void controllerDownReleased(int controller)
public void controllerLeftPressed(int controller)
public void controllerLeftReleased(int controller)
public void controllerRightPressed(int controller)
public void controllerRightReleased(int controller)
public void controllerUpPressed(int controller)
public void controllerUpReleased(int controller)
</pre>

Each event method includes the index of the controller on which the change was detected. Basic game also provides this state as protected member variables. Controller input on events is a very special case. In nearly all cases polling controllers state is more appropriate than relying on the input listener.

To use a controller, you need to add Jinput.jar to your classpath. When your game does not use a controller you can remove Jinput.jar and disable support for controllers:
<pre class="brush:java">
Input.disableControllers();
</pre>

====Within Update====

The following methods are included in Input for your convenience, and can be used to check for event-driven input within the update method. Calling them will clear their state. So they should only be called once per frame.

<pre class="brush:java">
input.isKeyPressed(Input.KEY_SPACE);
input.isMousePressed(0);
input.isControlPressed(0); //if LEFT is pressed
</pre>

Note that isControlPressed uses different indices than isButtonPressed, this is because isControlPressed checks for directional first with indices 0, 1, 2, 3 and LEFT, RIGHT, UP, DOWN, respectively. So, isControlPressed(4) checks to see if button 1 is pressed.

====Examples====

[https://bitbucket.org/kevglass/slick/src/9d7443ec33af/trunk/Slick/src/org/newdawn/slick/tests/InputProviderTest.java?at=default See the input test]

==Abstract Input==

The InputProvider binds abstract physical device controls (keyboard, mouse or game controller) to arbitrary objects which implement Command. When one of the input sources triggers, an event is fired indicating that a command should be enacted.

This allows you to separate the game commands from the configured controls.

====Usage====

First you have to create a Command object:
<pre class="brush:java">
private Command attack = new BasicCommand("attack");
</pre>
Then you define the inputs for that command:

public void init(GameContainer container) throws SlickException {
provider = new InputProvider(container.getInput());
provider.addListener(this);
provider.bindCommand(new KeyControl(Input.KEY_SPACE), attack);
provider.bindCommand(new MouseButtonControl(0), attack);
}
The attack command is triggered when:

Space is pressed
The left mouse button is pressed

public void controlPressed(Command command) {
message = "Pressed: "+command;
}

public void controlReleased(Command command) {
message = "Released: "+command;
}

====Example====

[https://bitbucket.org/kevglass/slick/src/9d7443ec33af/trunk/Slick/src/org/newdawn/slick/tests/InputProviderTest.java?at=default See the input test]

Font Rendering

2013-08-08T23:52:37Z

Sigtau:

There are currently two implementations of font rendering in Slick, both complying to one common Font interface. This interface allows us to render the text and also to determine the size and spacing of characters within that font (allowing for justification). The two implementations currently available are bitmap based - this provides fast convenient rendering but does not allow smooth scaling. A glyph rendering approach directly liked to true type fonts may be provided later.

== AngelCode Fonts ==

The wonderful folks at [http://angelcode.com/ AngelCode] provide the Bitmap Font Generator (see below) which can be used to produce textures filled with the characters from a font. The tools also produces a descriptor file which defined the positions of the font characters and the associated [http://en.wikipedia.org/wiki/Kerning kerning] values (kerning defines how characters should be placed next to each other for smooth looking paragraphs).

Slick provides the font implementation [http://slick.ninjacave.com/javadoc/org/newdawn/slick/AngelCodeFont.html AngelCodeFont] which is responsible for loading both the texture and descriptor file and making the font itself available to be rendered. The benefits of AngelCode font is flexibility, ease of use and kerning support. However, AngelCode font support in Slick can be slightly slower than the alternatives due to the need to account for kerning when rendering text.

== Sprite Sheet Fonts ==

The alternative approach is to use evenly spaced fonts, where the font texture is split into an even grid and each character is placed within a cell. The font implementation [[SpriteSheetFont]] provides a way to load a texture with a given spacing and use it as a font.

While this is slightly faster than using AngelCode generated font it does not support kerning and it is advised that where large paragraphs of text are to be displayed that AngelCode fonts are used in preference.

== External Links ==
* [http://www.angelcode.com/products/bmfont/ Bitmap Font Generator]

[[Category:Fonts]]

Emitter

2013-08-08T23:51:44Z

Sigtau:

#REDIRECT [[Emitters]]

[[Category:Particles]]

Emitters

2013-08-08T23:51:19Z

Sigtau:

[http://slick.ninjacave.com/javadoc/org/newdawn/slick/particles/ParticleEmitter.html ParticleEmitters] are added to a [http://slick.ninjacave.com/javadoc/org/newdawn/slick/particles/ParticleSystem.html ParticleSystem] to control the production of particles and how they change over their life time. There are two key methods in the ParticlEmitter interface. First, we have <code>update()</code>:

<pre>public void update(ParticleSystem system, int delta)</pre>

This method should be used to create particles. It's called every time particle system which the emitter belongs to is updated. The emitter is responsible for calling methods on ParticleSystem and the Particle class itself to create and configure particles for the effect the emitter is trying to achieve.

The second important method is <code>updateParticle()</code>:

<pre>public void updateParticle(Particle particle, int delta)</pre>

This method is called every time the particle system is updated for every particle that was created as owned by the emitter (part of the particle creation parameters). The emitter is responsible for updating the particles based on the passing of their life. Often this method is left blank as it's possible to set a velocity on a particle which will take effect without any code in this update method.

[[Category:Particles]]

Custom Configurable Emitters

2013-08-08T23:50:23Z

Sigtau:

You may have found that the particle effects made possible by Configurable Emitters just don't provide enough customisation to provide the effect that you want. For example, what if you want to implement collision detection in your emitter? You could do this by simply creating a subclass of a ConfigurableEmitter to implement these more advanced properties. But what if you also what to be able to load particle system settings from an XML file using the ParticleIO class? The ParticleIO class doesn't know about your custom subclass so it's unable to return an instance of it when it loads settings from an XML file. This is where the ConfigurableEmitterFactory comes in. This article will explain what it is and how to use it to create more advanced custom particle effects.

== The ConfigurableEmitterFactory ==

The [http://slick.ninjacave.com/javadoc/org/newdawn/slick/particles/ConfigurableEmitterFactory.html ConfigurableEmitterFactory] is an interface which describes a method called createEmitter() which returns a [[Configurable Emitter]], or any subclass of a ConfigurableEmitter. When you create a subclass of a ConfigurableEmitter you must also create a ConfigurableEmitterFactory and then pass this on to the ParticleIO class so it is able to return a ConfigurableEmitter of any subclass that you specify.

In fact this is less complicated than it sounds. The best way to do this is to subclass the ConfigurableEmitter and implement the ConfigurableEmitterFactory interface in the same class. In this class there will be the createEmitter() method along with any overloaded methods of the ConfigurableEmitter class to provide custom functionality. Here is an example of an emitter that accepts a Boundary object in its constructor which it uses to then provide collision detection.

<pre>import org.newdawn.slick.particles.ConfigurableEmitter;
import org.newdawn.slick.particles.ConfigurableEmitterFactory;
import org.newdawn.slick.particles.Particle;

public class DynamicEmitter extends ConfigurableEmitter implements ConfigurableEmitterFactory{

private Boundary boundary;

//The method required by the ConfigurableEmitterFactory interface
public ConfigurableEmitter createEmitter(String name) {
return this;
}

public DynamicEmitter(Boundary boundary) {
super("dynamicemitter");
this.boundry = boundary;
}

public void updateParticle(Particle particle, int delta) {
super.updateParticle(particle, delta);

//Check for collisions
if (boundry.checkCollision(particle.getX(), particle.getY())) {
particle.setVelocity(0, 0);
}
}
}</pre>

To use this class you simply pass an instance of it to the ParticleIO class when loading a particle system from an XML file. For example:

<pre>
DynamicEmitter myCustomEmitter = new DynamicEmitter(boundry);
ParticleSystem = ParticleIO.loadConfiguredSystem("emitters/custom.xml", myCustomEmitter);
</pre>

[[Category:Particles]]

Color Image System

2013-08-08T23:49:52Z

Sigtau:

Note: Note that this system as not been accepted yet. As such all information in here is subject to change or removal.

This system consists of four classes:

* ColorImageIO - Allows you to load system that was saved as an XML file.
* ColorImageSystem - The main class of the system. Each system of colored images is controlled from here
* ColorImage - Contains an Image and a ColorTimer
* ColorTimer - Contains all the defined colors and the timing for color switching.

== Usage ==
There are 2 ways to use this system.
=== Color Image Editor ===
You can use the [[Color Image Editor]] to create a system for you and then save that system to an XML file. You then use ColorImageIO to load that file at game time.
=== Manual Usage ===
To create a system manually, you first instantsiate a ColorImageSystem object for each light effect that you want. You can set the 'x' and 'y' display location of each system by calling setSystemX/Y. You can add an image to be displayed beneath the colored images by calling setBaseImage. For each colored image, you create a ColorImage and add it to the ColorImageSystem by calling addImage.

ColorImage contains a single slick Image and a ColorTimer. The slick image is typically a white or grayscale image that you want to dynamically apply color to. The four important methods here are setColorTimer, setImage, setImageX/Y. The 'x' and 'y' coordinates of the ColorImage are used as offsets from the ColorImageSystem 'x' and 'y' coordiantes.

ColorTimer contains all the colors to be displayed and controls how they will be displayed. The colors can be set to slowly change between each color with setInterpolate using true. If false is used, the colors will only switch at each timing interval. The starting color is set with setStartColor. Every other color can be added with addColor which takes a slick Color and an 'int' as arguments. The int is the time, in milliseconds, at which to switch to the Color provided.

[[Category:Miscellaneous]] [[Category:Images]]

Applets

2013-08-08T23:49:13Z

Sigtau:

'''Note: Due to continuing security issues in the Java browser plugin, it is advisable to avoid distributing your game in the form of an applet. Use [[Webstart]] or simply distribute your game's executable JAR.'''

Applet support in LWJGL is being still it's early stages and so it still has some compatibility issues in certain browsers (notably Opera). However, the concensus agrees that having a full OpenGL context in an Applet leads to some great jumps forward in Java games.

Slick allows applets in a very convienient manner. A game written originally to sit within an application game container can be easily transfered into an AppletGameContainer and hence be used an Applet. The “applet” directory of the distribution contains the required libraries and an example HTML page that will display a game as an Applet.

== Example HTML ==

The following HTML is used for all Slick games displayed as Applet. Note that you may have to include extra signed JARs in the archive tags depending on what libraries you use in your game:

<pre>
<html>
<body>
<applet code="org.newdawn.slick.AppletGameContainer"
archive="slick.jar,testdata.jar,lwjgl_applet.jar,lwjgl.jar,lwjgl_util_applet.jar,natives.jar,jinput.jar"
width="640" height="480">
<param name="game" value="org.newdawn.slick.tests.InputTest">
</applet>
</body>
</html>
</pre>

The significant change required from game to game is changing the value of the parameter “game” passed into the applet. The parameter should be set to the fully qualified name of your Game implementation.

== Known Issues ==
* Low specification/Old machines stutter heavily
* Opera often doesn't show the applet at all
* Major security risks with the Java browser plugin has led to many users disabling the Java plugin, thus support may be spotty

[[Category:Deployment]]

Using Slick Utilities Without the Framework

2013-08-08T23:48:40Z

Sigtau:

This page covers all information related to using the individual parts of the Slick library instead as opposed to the library as a whole, by means of the Slick-Util library, in order to interface directly with LWJGL. You can grab the Slick-Util library from [http://slick.ninjacave.com/slick-util/ here].

Remember: '''Slick is not a game engine.''' It doesn't intend to take over how you want to work or render. It's intended as a set of utilities that mesh together to form the library. Each of these utilities can be used in their own right. It can act like an engine if you use the GameContainer utilities - but this isn't an absolute. If you simple need something to get images on to the screen and want to manage the game loop yourself - fine! Just pick up the library and use Image. Input, Sound and Fonts among other things are all intended to be useable this way.

So, if you want a complete solution, you can use GameContainer and have Slick manage alot for you. If you just want some utilities, Slick can help there too. More so, if you want some source code to look at to get an idea where to start with something - go ahead. The license for Slick is loose - the code running everything is intentionally simplistic so it should be easy to pick up and understand.

Overall, let us know what you do with things - it's really fun to find a new game to play in any way!

== Texture Handling ==
Texture loading in Slick is designed to work directly with the [[Image]] classes. When using Slick as a set of utilities within your LWJGL game you may find it required to load textures and bind them outside of Slick (for certain custom effects, different data sources). There is one gotcha here, Slick caches the last texture it bound - so that textures aren't rebound if they're already current. This means that should you bind a different texture outside of the Slick framework it may confuse the rendering in Slick.

To get round this, before you start doing your own thing with rendering in LWJGL, call the following on texture:

<pre>texture.unbind();</pre>

This will clear the internal cacheing state and allow you to do whatever you need with textures through OpenGL without contaminating your Slick rendering.

== Sound with Slick-Util ==

The slick-util library provides a simple and easy to use mechanism to load and play sounds via openAL.

It supports the following formats:

* wav
* aif
* ogg
* xm

Sounds can be loaded and played as sfx and music can be streamed.

=== Basic Example ===

Here's some basic code that loads an ogg file and plays it.

<pre>Audio sound = AudioLoader.getAudio("OGG",
new FileInputStream("sfx/enemyHit.ogg"));
sound.playAsSoundEffect(1.0f, 1.0f, false);</pre>

This is a simple example, typically you would load your sounds in some sort of initialization phase, then play the sounds at points during your main game loop. It's still this easy though.

=== Native libraries and Java dependancies ===

You need to include the openAL native libraries from the lwjgl distribution in your runtime environment for openAL to work.

If you use ogg audio, you need to include the following jar files from the slick-util package:

* jogg-0.0.7.jar
* jorbis-0.0.15.jar

If you use Mod or XM audio you'll need to include the following jar file:

* ibxm.jar

== Loading and Binding GL Textures ==
The slick-util library provides a simple and easy to use mechanism to load images into openGL textures, and a way to bind those textures while rendering.

The texture loader supports the following graphics formats:

* tga
* png

=== Basic Example ===

Here's some basic code that shows how to load a texture file and bind it.

<pre>// init gl
Texture tex = TextureLoader.getTexture("PNG",
new FileInputStream("example.png"));

// in your render loop:
tex.bind();

// gl rendering code etc..</pre>

== TrueType Fonts with Slick-Util ==
Slick has the capability to easily display True Type fonts on screen.

True Type Fonts are loaded and rendered using the org.newdawn.slick.TrueTypeFont class.

<pre>import org.newdawn.slick.TrueTypeFont;</pre>

You can find the full javadoc to the TrueTypeFont class [http://slick.ninjacave.com/javadoc/org/newdawn/slick/TrueTypeFont.html here].

=== Basic Usage ===

<pre>// initialise the font
Font font = new Font("Verdana", Font.BOLD, 20);
TrueTypeFont trueTypeFont = new TrueTypeFont(font, true);

// render some text to the screen
trueTypeFont.drawString(20.0f, 20.0f, "Slick displaying True Type Fonts", Color.green);</pre>

=== Additional Usage ===

==== Anti Aliasing ====

The second parameter to the TrueTypeFont constructor controls whether the font is antialiased or not.

==== Loading fonts from the classpath ====

There are a number of true type fonts available on any java system. For reference, see:

http://java.sun.com/j2se/1.5.0/docs/api/index.html?java/awt/Font.html

Most people will also want to load custom fonts for display. Below is a short example which loads a ttf font that has been included in the programs classpath.

<pre>
import org.newdawn.slick.Color;
import org.newdawn.slick.TrueTypeFont;

import java.awt.Font;
import java.io.BufferedInputStream;
import java.io.IOException;

public class TTFTest {

public static void main(String[] args)
throws LWJGLException, FontFormatException, IOException {

Font font;
TrueTypeFont trueTypeFont;

// not included for brevity
initGL();

Font startFont = Font.createFont(Font.TRUETYPE_FONT,
new BufferedInputStream(TTFTest.class.getClassLoader().getResourceAsStream(
"technoid.ttf")));
Font baseFont = startFont.deriveFont(Font.PLAIN, 20);
trueTypeFont = new TrueTypeFont(baseFont, true);

while (true) {
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
trueTypeFont.drawString(20.0f, 20.0f, "this is a test", Color.gray);

Display.update();
if (Display.isCloseRequested()) {
System.exit(0);
}
}
}
}</pre>

[[Category:LWJGL]]

Category:TileMaps

2013-08-08T23:47:55Z

Sigtau: Created page with "This category contains all pages relevant to tile maps."

This category contains all pages relevant to tile maps.

TileD Import and Usage

2013-08-08T23:47:20Z

Sigtau:

TileD is a tile map editor written in Java and available [http://mapeditor.org/ here]. Slick provides support for loading and rendering orthographic maps created in this tool.

The TiledMap class allows the developer to load a map, interegate the data and render the tiles to the screen. Loading the map is similar to loading images and sounds, simply construct a TiledMap class with a reference to the map to load. The map XML can specify a reference to a tileset to use on the map, this is done as a relative path. If required the constructor can take both the reference to the tile map XML and a base path to use to look up the tilset files. Assume that I keep all my resources (tilemaps and tilesets included) in a directory called “res” in my classpath an appropriate constructor would be:

<pre>TiledMap map = new TiledMap("res/testmap.tmx","res");</pre>

To render this whole map we'd simply call the render method:

<pre>map.render();</pre>

Or to render just a section of the map (maybe based on the location of the current player) the render method can take parameters:

<pre>// render(int x, int y, int sx, int sy, int width, int height)
map.render(100,100,0,0,10,10);</pre>

Which would render the section of the map in tiles from 0,0 to 10,10 at the screen position 100,100. This can be be very useful for performance when scroll round large tile maps.

The other option provided when rendering is to render “lineByLine”. This option indicates that the each row of the tilemap rendering should be done seperately allowing you to render characters in the appropriate places on RPG Maker style maps. For instance, you may want to render your character before the items at a greater y axis location so that the character appears to behind some item.

To get a chance to render between these lines you must subclass TiledMap and override the renderedLine() method. This method is a notification that a single line of the map has been rendered and gives you a chance to render character/entity sprites.

The other extremely useful thing about Tiled maps is the ability to assign meta data to the tiles that are placed. A good example is collision - it's wonderful to be able to assign a proprty to a particular tile in a generic editor that indicates the tile blocks movement.

The Slick TiledMap support allows you to integrate the properties of a given location based on the properties assigned to the tiles in Tiled. This is a two stage process, first we must identify the ID of the tile at the given location using:

<pre>// getTileId(int x, int y, int layerIndex)
int tileID = getTileId(10,10,0);
Which gets the ID of the tile at location 10,10 on layer 0. We can then use this ID to look up meta data properties like so:

// getTileProperty(int tileID, String propertyName, String def)
String blocked = getTileProperty(tileID, "blocked", "false");</pre>

Note that we can specify a default value that will be returned if the specified property is not defined for the given tile ID. This makes conversion code tidier, for example.

<pre>boolean blocked = "true".equals(getTileProperty(tileID, "blocked", "false"));</pre>

Finally, it's worth noting that the meta data properties are not stored in a way that is suitable for high perfromance use. It much better for game development to read the properties at initialisation time and store them in some more perforant format later. Check tile properties on a per frame basis is likely to be slow.

'''NOTE:''' Slick only supports maps that are created with tilesets that use a single image for the tiles. You can have multiple tilesets, but only one image per set. Essentially, this means that animations on tiles are not supported.

[[Category:TileMaps]]

Sound and Music

2013-08-08T23:46:50Z

Sigtau:

Sounds and music are available in a similar manner to Images. You simple construct an object of the appropriate type (either Sound or Music) with a reference to the resource to be loaded. Sound and music are seperated due to their use of source (the term OpenAL uses for channels). When a sound effect a played the next available source is selected and used to play the sound. If no source is available the sound isn't played. However, music is always played on a single reserved channel which is not interferred with by the sound effects.

== Sound FX ==

The sound class supports loading WAVs and OGGs. Sound effects can be played, stopped and looped (useful for engine sounds). Note that if no channel is available when attempting to play a sound it will not be heard. Playing a sound in Slick is as simple as:

<pre>Sound fx = new Sound("res/boom.wav");
fx.play();
// or fx.play(1.0f,0.5f) to set the volume and pitch of the sound effect</pre>

You can also play sound effects using 3D sound to make them sound as thought they are originating from a particular location. You can do this by using playAt():

<pre>Sound fx = new Sound("res/bounds.wav");
fx.playAt(-1,0,0);</pre>

== Music ==

Music in Slick is treated in much the same manner as Sound FX with the notable exception mentioned above. Slick supports WAV, OGG and MOD/XM music tracks. Note that if you request that a music track be played or looped any music currently playing will be stopped as a side effect.

Music can be loaded a and playing (repeatedly) like so:

<pre>Music music = new Music("res/musicwithrocksin.ogg");
music.loop();</pre>

== Troubleshooting ==

On some systems, playback of OGG files may be choppy, crackly or otherwise of poor quality. If you are hearing frequent popping and clicks in playback, it may be because you do not have the proper OpenAL drivers installed on your system.

[[Category:Audio]]

Saving Local Settings

2013-08-08T23:46:11Z

Sigtau:

Local settings are easy to save when you're working with a local file system and no security settings. However, if you're deploying via webstart you may find your game in a sandboxed environment that prevents direct file access - so how are we going to save game settings?

Webstart provides a service referred to as Muffins (like HTTP Cookies, but for webstart). However the interface to these is fairly complex. Additionally, it'd be useful if when developing you could swap and change between a file based storage and a muffin based storage at deployment.

Slick provides exactly this. The SavedState class provides methods to load and save arbitrary game properties to an abstract storage area. Underneath this storage will switch between file based or muffin based dependent on the operating environment. Note that this storage will not currently work within Applets - this is still an open issue.

The saved state class provides methods to store numbers and string seperately. To save data simply set the data using:

<pre>public void setNumber(String nameOfField, double value)
public void setString(String nameOfField, String value)</pre>

and finally commit your data by calling save(). When loading data first get the data from the underlying implementation by calling load(). Then use the following methods to extract the previously stored data:

<pre>public double getNumber(String nameOfField)
public double getNumber(String nameOfField, double defaultValue)
public String getString(String nameOfField)
public String getString(String nameOfField, String defaultValue)</pre>

Note that when loading data you can specify default values. If the field name provided does not exist in the saved data then the default value is returned.

Remember, the two storage systems (file based and muffin based) are not compatible with each other and hence if you test using file based storage your settings will not be available when you use your webstart deployment.

[[Category:Miscellaneous]]

Polling the Current Input State

2013-08-08T23:45:28Z

Sigtau:

Polling the input allows you to check the state of the input devices at a given momemnt in time. This suitable for cases where you're expecting the player to hold a button/key down while something happens in game - for instance, hold cursor left to run left. The key can be simply polled from the game loop. However, the downside is that if the game loop isn't running quickly enough the input may miss changes.. for instance if the user were to tap left and the tap occured while your game was rendering it may be missed. When short lived input is expected it may be more suitable to use the event based input.

== Mouse ==

Mouse input can be checked by using the <code>isMouseButtonDown()</code> method to check the buttons and <code>getMouseX()</code> and <code>getMouseY()</code> to check positional information. Note that the mouse position has it's origin <code>(0,0)</code> in the top left hand corner of the display unlike OpenGL. This is down to author discretion rather than any desperate need.

== Keyboard ==

Keyboard state can be passed using the <code>isKeyDown()</code> method on the [http://slick.ninjacave.com/javadoc/org/newdawn/slick/Input.html Input] class. The identifier of the key to check should be supplied and these identifiers are defined within the Input class. For instance to check if space is pressed you do the following:

<pre>inputInstance.isKeyDown(Input.KEY_SPACE);</pre>

== Controllers ==

An arbitrary number of gamepads or joysticks are supported. At initialization the controllers are detected and assigned IDs. The controller directional and button state can be polled using the <code>isButtonXPressed()</code> methods and the <code>isControllerXXXX()</code> for directional control. For instance if we'd like to check if the controller was pushed left and button 1 was pressed the following code can be used:

<pre>// note we're specifying controller ID zero here, using BasicGame you can
// check all the controller is one sweep
if (input.isControllerLeft(0) && input.isButton1Pressed(0)) {
// fire the big guns here!
}</pre>

== See Also ==
* [[Input Handling]]
* [[Event-Driven Input]]

[[Category:Input]]

Packed Sprite Sheets

2013-08-08T23:44:51Z

Sigtau:

Basic sprite sheets are pretty useful if you're building a simple set of sprites into a sheet. However, sprite sheets can get more complicated, where multiple different size sprites need to be packed into a single sheet. Doing this by hand is both hard and inefficient - luckily there's a nice tool build for the job named [http://homepage.ntlworld.com/config/imagepacker/ ImagePacker].

The image packing tools allows you to build a single image out of many smaller ones and it optimizes the layout of this sprites onto the sheet. Of course the layout of sprites is important and so the tool produces a descriptor file which defines where different named sprites are placed.

Slick provides the [http://slick.ninjacave.com/javadoc/org/newdawn/slick/PackedSpriteSheet.html PackedSpriteSheet] class which allows you to load both the packed image and the descriptor file. The class then provides methods to get individual images from the sheet either as separate images or interpreted as an embedded sprite sheet. This allows you to utilize the packed sprites as with any other image and what's more allows you to embed animation sprite sheets into larger sheets of sprites.

== See Also ==
* [[SpriteSheet]]
* [[XML Packed SpriteSheet]]
* [http://homepage.ntlworld.com/config/imagepacker/ ImagePacker], for packing a series of separate images into a single spritesheet

[[Category:Sprites]] [[Category:Images]]

Logging

2013-08-08T23:43:09Z

Sigtau:

The logging package provided by slick (<code>org.newdawn.slick.util.Log</code>) is relatively straightforward. By default it logs all output to standard out, so everything is displayed in the console window that your game is launched from. This can be easily changed to dump info to a file. The logger is a zero setup utility so long as you want to print all messages and have them displayed in the console.

== Basic Logging ==

The slick logger supports four “levels” of messages. These can be used to, for instance, separate out debugging information from more critical game state errors. The four available logging levels are info, debug, warn, and error. The first two of these can be turned on and off as needed. There is a static member function of the Log class that corresponds to each logging level. These functions all take a string that is the log message.

Here is an example using the logging class:

<pre>
// ... Some code
Log.info("A logging message");
</pre>

The basics of it are that simple. When Log.info is called it will generate a log entry similar to the following:

<pre>
Wed Mar 26 22:06:30 PDT 2008 INFO:A logging message.
</pre>

== Advanced Logging ==

=== Logging Exceptions ===

Although the basic logging concept provided above is useful, one area where it doesn't help much is documenting exceptions. There are two other version of the Log.error method. One accepts a string representing a logging message, as above, and an Exception object. The other takes just an Exception object. These will print the logging message (if provided) and the stack trace generated by the exception. Here's an example of each:

<pre>
try {
// ... Some code
}
catch (SlickException e1) {
Log.error("A slick-specific problem occurred", e1);
}
catch (Exception e2) {
Log.error(e2);
}
</pre>

Generally it is more useful to provide a logging message along with an exception stack trace, but if you need to log only an exception the ability is there. Here's a sample of the output from a log generated with an exception:

<pre>
// Assuming our exception has the message "A logged exception."
Log.error("A logging message." e);

// Results in the following console message:
Wed Mar 26 22:14:50 PDT 2008 ERROR:A logging message.
Wed Mar 26 22:14:50 PDT 2008 ERROR:A logged exception.
java.lang.Exception: A logged exception.
at clojure.fns.clojure.make_ant__1122.invoke(Unknown Source)
at clojure.fns.clojure.TEST_create_ant__1120.invoke(main.clj:276)
at clojure.lang.Var.invoke(Var.java:268)
at com.finiteimprobability.Invasion.keyPressed(Unknown Source)
at org.newdawn.slick.Input.poll(Input.java:877)
at org.newdawn.slick.GameContainer.updateAndRender(GameContainer.java:417)
at org.newdawn.slick.AppGameContainer.start(AppGameContainer.java:344)
at com.finiteimprobability.Invasion.main(Unknown Source)
</pre>

As you can see the logging message is printed before the stack trace, which includes the exception message.

== Reducing Logger Output ==

By default the logger will print all logged messages to the log. The method Log.setVerbose takes a single boolean argument. If set to false info and debug messages will not be printed.

[[Category:Miscellaneous]]

Images

2013-08-08T23:42:23Z

Sigtau:

Images are the most primitive drawing tool within Slick. They are the root of most of utilities for rendering. Each image will draw a rectangular area on the screen filled with some pixels based on either a generated source (see [[ImageBuffer]]) or a image loaded from disk.

Slick currently uses java's ImageIO to load images so supports, PNG, GIF and JPG. It also supports TGA through a pure java loader which is generally much faster than using ImageIO. However, the TGA must be non-compressed and 32 bit to be loaded correctly. Note that of course resources are generally placed in JAR files and as such TGA compresses down in this context in a similar magnitude to PNG.

As with most things in Slick images are currently rendered in the simplest manner possible, using OpenGL immediate mode. This is not the most efficient manner and hence this is subject to change at a later date (should a need arise).

Note that fonts, sprite sheets and particles all rely on the basic image class. It's also worth remember that any given texture (or extenal image) is loaded only once and hence no caching is required on the developers side. This also means that sub-images and references to the original data so memory is not duplicated. As a side effects images are considered non-mutable - i.e. they can not be changed - which may have invalidated another references rendering.

== Usage ==

Images can be loaded and used simply by construction. To load an image ready for use the following code could be used at initialization:

<pre>Image img = new Image("res/myimage.png");</pre>

The image can either be in the classpath (for webstart) or on the file system (for local testing).

== See Also ==
* [[Resource Loading]]

[[Category:Images]] [[Category:Graphics]]

Hello World

2013-08-08T23:41:38Z

Sigtau:

To make sure your setup succeeded, create a main class like the following:
<pre>
package simpleslickgame;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.newdawn.slick.AppGameContainer;
import org.newdawn.slick.BasicGame;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.SlickException;

public class SimpleSlickGame extends BasicGame
{
public SimpleSlickGame(String gamename)
{
super(gamename);
}

@Override
public void init(GameContainer gc) throws SlickException {}

@Override
public void update(GameContainer gc, int i) throws SlickException {}

@Override
public void render(GameContainer gc, Graphics g) throws SlickException
{
g.drawString("Howdy!", 10, 10);
}

public static void main(String[] args)
{
try
{
AppGameContainer appgc;
appgc = new AppGameContainer(new SimpleSlickGame("Simple Slick Game"));
appgc.setDisplayMode(640, 480, false);
appgc.start();
}
catch (SlickException ex)
{
Logger.getLogger(SimpleSlickGame.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
</pre>

If a window opens saying 'Howdy!', your setup is fully configured and ready for development.

[[Category:Tutorials]]

Category:Tutorials

2013-08-08T23:40:31Z

Sigtau: Created page with "This category contains tutorials for getting started in Slick2d."

This category contains tutorials for getting started in Slick2d.

Game Containers

2013-08-08T23:39:01Z

Sigtau:

The concept of containers isn't a particularly new one, the container provides environment in which your application (in this case a game) can run. It provides that game with a set of facilities and expects the game to comply to a certain interface. This allows the container (sometimes called the framework) to handle most of the bits of code common between all games for you - leaving you to focus on the important game logic bits and pieces.

== Basic Functionality ==

In the case of Slick, the container holds a Game - that is the class that is contained must comply to the Game interface. To make things even easier Slick provides a basic abstract implementation of Game which you can simply extend, called BasicGame. When extending BasicGame you'll need to implement 3 methods:

'''init()''' - This is called when the game starts and should be used to load resources and initialise the game state.

'''render()''' - This method is passed a graphics content which can be used to draw to the screen. All of your game's rendering should take place in this method (or in methods called from this method)

'''update()''' - The method is called each game loop to cause your game to update it's logic. So if you have a little guy flying across the screen this is where you should make him move. This is also where you should check input and change the state of the game.

The GameContainer itself provides methods to control the properties of the game rendering and update. For instance, the game container is where you look for controlling what resolution the game runs at and whether it's in fullscreen mode. It's also responsible for maintaining the game timer and loop. There are a couple of implementations of GameContainer currently available (discussed below), however where possible you should rely on the GameContainer interface - apart from of course when constructing your container where you are making an explicit decision about how your game is to be displayed.

While the Slick game container framework is useful it doesn't suit everyone. It is intended that the features of Slick can be used outside of the framework as part of a generic LWJGL game.

== Application Game Container ==

The application game container is the most used, it's intended to run your game stand alone or as a webstart. It uses a simple a window to display the game and allows you to configure the display mode directly. It's generally constructed in main and started with the following lines:

<pre>
try {
AppGameContainer container = new AppGameContainer(new MyGame());
container.setDisplayMode(800,600,false);
container.start();
} catch (SlickException e) {
e.printStackTrace();
}
</pre>

Where the 800 and 600 specify the window resolution and the false (or true) specify whether the game should be run in fullscreen mode. Note how the container is created with an instance of the game implementation. In this way when you change containers the game itself does not need to be changed at all. This makes it very easy to make a demo version of your game available via a webpage while mainitaining the full version as a standalone application.

== Applet Game Container ==

The applet game container uses the recently added LWJGL Applet support to present the game as a Java Applet embedded into a webpage. This functionality is currently still being tested and developed. It is known to have issues running within Opera and on low end machines. Supporting an OpenGL context within a browser window is proving to be difficult to be make stable in all cases.

However, for most people this is a great option and allows you deploy your game as an applet with the minimal of fuss. The Slick distribution provides the files required for applet distribution in the “applet” directory. To use your game in the applet you need to specify something similar to the following in the applet tag in the HTML:

<pre>
<applet code="org.newdawn.slick.AppletGameContainer" archive="slick.jar,testdata.jar,lwjgl_applet.jar,lwjgl.jar,lwjgl_util_applet.jar,natives.jar,jinput.jar"
width="640" height="480">
<param name="game" value="org.newdawn.slick.tests.InputTest">
</applet>
</pre>

Where the game parameters is replaced with the fully qualified name of your Game class and the archive list contains all the jars you require signed with an appropriate certificate. See the webstart tutorial for details on how to produce a certificate and sign the the JARs correctly.

== Future Game Containers ==

There are currently no other containers in development, although there are plans for a container that uses a AWT Canvas to display the game. This would allow tools developers the ability to embedded the games (and application displays) into other GUIs, much like the Pedigree Particle Editor.

Developing a game container is resonably simple by extending the standard GameContainer class and adding the part specific to the particular rendering context. If something about the game containers provided doesn't fit with the way you usually write games it's often easiest to simply create a new game container that does exactly what you want rather than attempt to fit in with existing implementations.

[[Category:Graphics]]

Event-Driven Input

2013-08-08T23:38:25Z

Sigtau:

In some cases it makes sense to be notified when input changes occur. The most obvious case is when implementing a GUI. It's important that key presses aren't missed (which could happen if you poll input) and GUI are also generally event driven. The InputListener defines a set of methods that can be implemented to receive notifications of input events from an Input instance by adding it using <code>addListener()</code>.

Note that if you're using a subclass of basic game that it already implements InputListener and hence you can simply use override the interface methods from the BasicGame class.

== Mouse ==

Mouse events are reported to the input listener through the following methods:

<pre>public void mouseMoved(int oldx, int oldy, int newx, int newy)
public void mousePressed(int button, int x, int y)
public void mouseReleased(int button, int x, int y)
public void mouseWheelMoved(int change)</pre>

What the methods are indicating when they're called should be fairly self explanatory, however it is worth noting that the origin of the screen for mouse coordinates is the top left - unlike that of OpenGL which uses bottom left. This means if the mouse is clicked at the top of the screen the <code>mousePressed()</code> method will be called with a y value of zero.

== Keyboard ==

Keyboard events are reported each time a key is pressed and release to the following two methods on the InputListener interface:

<pre>public void keyPressed(int key, char c)
public void keyReleased(int key, char c)</pre>

Note that both the key code and the character represeting that key are reported. The character will only be reported for keys that can be visualised, a value of zero will be reported for other keys (like CTRL, ALT, etc).

== Controllers ==

As with keyboard and mouse, game controllers connected will report events as buttons and directional controls are pressed. The following input listener methods will be called when controllers are manipulated:

<pre>public void controllerButtonPressed(int controller, int button)
public void controllerButtonReleased(int controller, int button)
public void controllerDownPressed(int controller)
public void controllerDownReleased(int controller)
public void controllerLeftPressed(int controller)
public void controllerLeftReleased(int controller)
public void controllerRightPressed(int controller)
public void controllerRightReleased(int controller)
public void controllerUpPressed(int controller)
public void controllerUpReleased(int controller)</pre>

Each event method includes the index of the controller on which the change was detected. Basic game also provides this state as protected member variables. Controller input on events is '''very''' special case. In nearly all cases polling controllers state is more appropriate than relying on the input listener.

== See Also ==
* [[Polling the Current Event State]]
* [[Event-Driven Input]]

[[Category:Input]]

Embedding Mozilla Rhino

2013-08-08T23:37:48Z

Sigtau:

Scripting engines have started to become very popular game development tools. They allow developers to make changes to game logic without needing to recompile, or possibly even restart, the game.

This tutorial describes the steps needed to get start using the Mozilla Rhino Javascript engine in your Slick-based games.

== Getting Rhino ==

The obvious first step is to [https://developer.mozilla.org/en-US/docs/Rhino get the Rhino distribution]. Unpack the zip file and place the js.jar file in your project. Make sure to add it to your classpath and double check your build setup to be sure the jar file is included when your program is compiled and run.

== Running Rhino and Slick together ==

The following program is a simple implementation of Rhino running inside a Slick game. It is pretty well commented, and should explain the necessary steps as they happen.

<pre>
/*
This file demonstrates using the Rhino Javascript engine within the
Slick 2d game engine.

Rhino can be found at: http://www.mozilla.org/rhino/
Slick can be found at: http://slick.cokeandcode.com/
*/

import org.newdawn.slick.AppGameContainer;
import org.newdawn.slick.BasicGame;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Input;
import org.newdawn.slick.SlickException;

import org.mozilla.javascript.Context;
import org.mozilla.javascript.ScriptableObject;

public class Rhino extends BasicGame {

/*
The ScriptProxy class defined here is one half of the interface
between Java code and the Javascript environment. It is used to,
among other things, provide access to Java objects within Rhino.

The ScriptableObject class implements the majority of the
Scriptable interface. The Scriptable interface is used to define
functions and objects that will be available to the javascript
environment.
*/
class ScriptProxy extends ScriptableObject {
String test1;

/*
This is the only method required to fully implement the
abstract class ScriptableObject. I'm not sure what it is
supposed to do. The "global" value is used in at least one
example in the Rhino documentation.
*/
public String getClassName() {
return "global";
}

/*
Access to the "test" object in the javascript environment is
implemented through calls to the setTest and getTest
methods.
*/
public void setTest(String str) {
test1 = str;
}

public String getTest() {
return test1;
}

/*
A test function that can be called within the JavaScript
environment.
*/
public void testfunc(String s) {
// System.out.println("test function called");
System.out.println(s);
}
}

/*
A Context is an instance of the javascript environment. The
context is used to load and interpret .js files and interpret
Javascript code as strings, among other things. In this example
it is used exclusively to interpret Javascript strings.
*/
protected Context scriptContext;
protected ScriptProxy gameProxy;

public void init(GameContainer container) throws SlickException {
/*
The static method Context.enter is, apparently, the easiest
way to obtain a javascript environment.
*/
scriptContext = Context.enter();
gameProxy = new ScriptProxy();

/*
We'll set a string for the "test" property that will be
exposed in Javascript now so we know it is calling across
the bridge.
*/
gameProxy.setTest("This was set within java, but called from javascript.");

/*
This must be called before scripts can be evaluated in this
Context. It creates some of the basic Javascript objects.
*/
scriptContext.initStandardObjects(gameProxy);

/*
Functions provided by a ScriptableObject (such as our
example 'testfunc') are initialized in the following manner.
*/
String[] scriptAvailableFunctions = { "testfunc" };
gameProxy.defineFunctionProperties(scriptAvailableFunctions, ScriptProxy.class, ScriptableObject.DONTENUM);

/*
A "property" is a Javascript object that is exposed through
getters and setters in the ScriptableObject. Rhino
automatically prepends the "set" and "get" terms and
uppercases the first letter, so exact naming is important.
*/
gameProxy.defineProperty("test", ScriptProxy.class, ScriptableObject.DONTENUM);

}

public void render(GameContainer container, Graphics g) {
/*
Here we are using the context (javascript engine) to
evaluate a string. The first parameter is our
ScriptableObject, which is used to provide definitions for
the engine. The second argument is the code to be evaluated.
In this case simply writing "test" evaluates the Javascript
object named "test", which is looked up in our gameProxy,
which passed the result of it's getTest() method to the
Javascript engine.

Since this is the only instruction in the string to be
evaluated it is used as the return value for
evaluateString. To provide flexibility in return type
handling evaluateString returns a java.lang.Object, which is
why the result must be cast back into a String.

The third parameter is a string that describes the source
for the Javascript code being evaluated. This may be a
filename if that is where the string comes from.

The fourth parameter is the starting line number for this
script, which might be useful if a script is being pieced
together from a variety of components.

The last parameter is used to provide a security domain for
the script to run under. I *think* this is used to ensure
that the Javascript code cannot execute certain methods or
instantiate some objects, but haven't done enough research
to be sure. Passing a null value here does not restrict the
evaluation of Javascript code.
*/
String result = (String) scriptContext.evaluateString(gameProxy, "test;", "js", 1, null);
g.drawString("Javascript result: " + result, 40, 120);

}

public void update(GameContainer container, int delta) {

}

public void keyPressed(int key, char c) {
if(key == Input.KEY_ESCAPE) {
/*
The script context will most likely be shut down
properly, but it's a good idea to be neat and tidy,
right?
*/
scriptContext.exit();
System.exit(0);
}
if(key == Input.KEY_SPACE) {
/*
This example is largely similar to the above, except
that now we are calling the javascript function
"testfunc()". This is found and executed on gameProxy,
printing a string to the console."
*/
scriptContext.evaluateString(gameProxy, "testfunc(\"testing console output\");", "js", 5, null);
}
}

public Rhino(String s) {
super(s);
}

public static void main(String[] Args) {
try {
AppGameContainer container = new AppGameContainer(new Rhino("Rhino"));
container.setDisplayMode(600,480,false);
// container.setShowFPS(false);
container.setMinimumLogicUpdateInterval(30);
container.start();
} catch (SlickException e) {
e.printStackTrace();
}
}
}
</pre>

== Next Steps ==

The next step to consider from here is how the Javascript code handles game logic updates. One simple option is to create a Javascript function named tick that your game calls every time update() runs. This in turn calls all of the functions that need to be run in Javascript on every game update.

One obvious step to take from this point is to extend the access of the Javascript environment into your game. You don't need to use an inner class to implement your ScriptableObject, and could easily have it in another file. If you already have a scene graph it probably has quite a few methods for interacting with your game environment, which might make it a good idea to turn this into a ScriptableObject and make it available to the Javascript engine.

Since the ScriptableObject we are using also stores all of the definitions that are in scope, a second ScriptableObject can be created for a user interaction console. This allows you to expose only very specific parts of the game to the user and prevent them from directly modifying the underlying game.

== Hot Loading Definitions ==

One interesting use for the Javascript environment is being able to modify the game logic as the game is running. This is remarkably easy to set up. We can create a command-line input prompt that runs with the game by declaring a boolean consolePrinted member variable and adding the following code to the update method:

<pre>
if(!consolePrinted) {
System.out.print("rhino> ");
consolePrinted = true;
}
// Only parse input strings when the input buffer is empty so we
// don't block the game loop.
if(System.in.available() != 0) {
byte[] b = new byte[System.in.available()];
System.in.read(b);
String s = new String(b);
gameProxy.setTest(s);
consolePrinted = false;
}
</pre>

This example simply alter the test property in Javascript, but we could just as easily be executing the string directly as Javascript or using it to provide a simple command system for reloading Javascript files.

[[Category:Miscellaneous]]

Controlling Game Updates

2013-08-08T23:37:12Z

Sigtau:

It's important to understand that, by default, Slick calls the render() and update() method of your game on every frame. This obviously is necessary for the render() method, but may not be what you want for the update() method. Since framerates vary from one computer to another, or even from one scene to another, calling update() on every frame can make your game logic a little unpredictable.

The GameContainer class has a built-in solution for this. It has two properties, <code>minimumLogicRate</code> and <code>maximumLogicRate</code>, that can be used to ensure that your update() method is executed consistently, even in the face of very low or very high framerates.

== Using minimumLogicRate ==

Conceptually <code>minimumLogicRate</code> is pretty simple. It specifies an amount of time (in miliseconds) that has to pass since the last update() call before it is called again. By default <code>minimumLogicRate</code> is set to 1, which means that your update() method is going to be called on every frame render. This may work well in testing on one particular system, but can make the game logic a bit difficult to get right on other machines. Older games often relied on the assumption that the rendering each frame took a fixed minimum amount of time. That's why on current computers a lot of older games don't work well, the computers are just too fast and the game logic updates too quickly.

By raising the value of <code>minimumLogicRate</code> you can prevent this problem. By setting it to a specific value (20 is a good initial choice) you can get consistent updates that allow your game logic to run in step with real time instead of depending on the framerate.

It's pretty simple to make this change. The GameContainer class has methods named setMinimumLogicRate() and getMinimumLogicRate(), that can be used to change this value. Do this in your main function and you can go about planning your game logic without worrying about the framerate. Well, mostly. One problem we still need to deal with is if the framerate drops to the point that our update() function isn't running as many times as it should. See <code>maximumLogicRate</code> below for that.

== Using maximumLogicRate ==

Now that we have <code>minimumLogicRate</code> solving any logic consistency problems we might get from too high of a framerate, we need to tackle problems due to too low of one. This can be a source of some rather nasty bugs, especially because the framerate may not drop far enough on your computer or until you get into some of the more heavy-duty scenes. If you are relying on the logic being updated every twenty milliseconds and the framerate dips so that it happens every fifty you could run into problems.

To help handle this, Slick uses <code>maximumLogicRate</code> to allow you to run the update code multiple times in one time through the game loop. The GameContainer looks at <code>maximumLogicRate</code> every time through the game loop and compares it to the amount of time that has accrued since the last update() call. If that time exceeds <code>maximumLogicRate</code> then it divides the time from the last updated by <code>maximumLogicRate</code> and runs your update() method that many times. For instance if your <code>maximumLogicRate</code> is set to 20 and the last update() call happened 50 miliseconds ago the game will run your update code (50 / 20 = 2.5) twice.
[[Category:Miscellaneous]]