<?xml version="1.0" encoding="utf-8"?>
<!-- generator="FeedCreator 1.7.2-ppt DokuWiki" -->
<?xml-stylesheet href="http://slick.cokeandcode.com/wiki/lib/exe/css.php?s=feed" type="text/css"?>
<rdf:RDF
    xmlns="http://purl.org/rss/1.0/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">
    <channel rdf:about="http://slick.cokeandcode.com/wiki/feed.php">
        <title>Slick Wiki</title>
        <description></description>
        <link>http://slick.cokeandcode.com/wiki/</link>
        <image rdf:resource="http://slick.cokeandcode.com/wiki/lib/images/favicon.ico" />
       <dc:date>2010-09-07T14:44:57+00:00</dc:date>
        <items>
            <rdf:Seq>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=01_-_a_basic_slick_game&amp;rev=1277834174"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=01_-_setting_up_your_environment&amp;rev=1238052439"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=01_-_tiled_and_maps&amp;rev=1259766082"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=02_-_a_basic_slick_applet&amp;rev=1238052338"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=02_-_barebone_game&amp;rev=1260213531"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=02_-_slickblocks&amp;rev=1277359812"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=03_-_looking_at_the_code&amp;rev=1260232961"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=03_-_setting_up_the_web-page&amp;rev=1238056991"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=03_-_slickout&amp;rev=1282910168"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=04_-_slopes_and_collisions&amp;rev=1261449783"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=animation-fr&amp;rev=1221935858"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=animations&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=applets&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=buffer&amp;rev=1221938042"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=capturer_l_etat_d_une_entree&amp;rev=1222594350"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=clipping&amp;rev=1214209448"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=color_image_editor&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=color_image_system&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=configurable_emitters&amp;rev=1218714858"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=configurable_emitters_code_example&amp;rev=1251270629"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=controle_de_la_vitesse_de_jeu&amp;rev=1230330626"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=controlling_game_updates&amp;rev=1246662347"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=corporeal_tutorial&amp;rev=1256047542"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=create_a_project_template&amp;rev=1253910660"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=custom_configurable_emitters&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=deferred_resource_loading_getting_a_loading_bar&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=embedding_the_mozilla_rhino_javascript_engine&amp;rev=1205530078"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=emitters&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=entity_tutorial&amp;rev=1256004555"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=evenements_liees_aux_entrees&amp;rev=1222615709"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=event_driven_input&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=exemples&amp;rev=1222618067"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=fade_in_out_effect&amp;rev=1250668229"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=font_rendering&amp;rev=1188655421"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=fr-wiki&amp;rev=1223278453"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=freeaks_tutorials&amp;rev=1260214035"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=game_containers_and_basic_game&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=generer_une_image&amp;rev=1221940144"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=geometry&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=getting_started_and_setup&amp;rev=1282901452"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=image_buffer&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=images-fr&amp;rev=1221911789"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=images&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=importer_et_utiliser_une_map_generee_via_tiled&amp;rev=1223280191"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=importer_et_utiliser_une_tiled_map&amp;rev=1223278736"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=input_handling&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=installation_et_premiere_application&amp;rev=1230330100"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=introduction&amp;rev=1221656980"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=les_classes_principales_gamecontainer_et_basicgame&amp;rev=1230330298"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=les_entrees&amp;rev=1222593248"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=loading_and_binding_opengl_textures_with_slick-util&amp;rev=1206854301"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=logging&amp;rev=1214201066"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=netbeans_tutorials&amp;rev=1253910558"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=open_source_games&amp;rev=1282903476"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=overview&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=packed_sprite_sheets&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=particle_engine&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=polling_the_current_input_state&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=rendering_to_an_image&amp;rev=1221865891"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=rendu_des_polices_de_caracteres&amp;rev=1221942931"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=resource_loading&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=resource_manager_tutorial&amp;rev=1275438658"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=saving&amp;rev=1251150274"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=saving_local_settings&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=scalable_vector_graphics_svg&amp;rev=1213545280"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=shaking_the_camera&amp;rev=1250667133"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=slick-util_javadoc_and_location&amp;rev=1206851798"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=son_et_musique&amp;rev=1222591727"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=sound_with_slick-util&amp;rev=1206853768"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=sounds_and_music&amp;rev=1194642312"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=spiegel_tutorials&amp;rev=1277359624"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=spins_tutorials&amp;rev=1238055574"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=sprite_sheets&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=spritesheet&amp;rev=1221924472"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=start&amp;rev=1278497761"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=state_based_games&amp;rev=1237289670"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=support_des_polices_bitmap-based&amp;rev=1221948750"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=support_des_polices_truetypefonts&amp;rev=1221946665"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=support_des_tile_map&amp;rev=1223278493"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=support_des_tiled_map&amp;rev=1223278500"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=testarea&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=texture_handling&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=the_pedigree_editor&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=tile_map_support&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=tiled_import_and_use&amp;rev=1250289355"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=truetype_font_support&amp;rev=1221946813"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=tutorials&amp;rev=1282901419"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=unicode_font_support&amp;rev=1276895427"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=user_manual&amp;rev=1255397683"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=using_slick_utilities_without_the_framework_lwjgl_direct&amp;rev=1188286186"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=webstart&amp;rev=1281723133"/>
                <rdf:li rdf:resource="http://slick.cokeandcode.com/wiki/doku.php?id=xml_packed_sprite_sheets_pack-u-like&amp;rev=1213904678"/>
            </rdf:Seq>
        </items>
    </channel>
    <image rdf:about="http://slick.cokeandcode.com/wiki/lib/images/favicon.ico">
        <title>Slick Wiki</title>
        <link>http://slick.cokeandcode.com/wiki/</link>
        <url>http://slick.cokeandcode.com/wiki/lib/images/favicon.ico</url>
    </image>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=01_-_a_basic_slick_game&amp;rev=1277834174">
        <dc:format>text/html</dc:format>
        <dc:date>2010-06-29T17:56:14+00:00</dc:date>
        <title>01_-_a_basic_slick_game</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=01_-_a_basic_slick_game&amp;rev=1277834174</link>
        <description>Slick Basic Game

 Welcome to the first instance of Path to glory.

In this tutorial we will make a simple prototype of a game that allows the player to control a plane and fly around the screen.

Note: These tutorials are meant for instructional purposes and may no longer be in a 100% working state. However, the main theory behind programming in Slick is covered. The code in these tutorials are best read as  pseudo-code.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=01_-_setting_up_your_environment&amp;rev=1238052439">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-26T07:27:19+00:00</dc:date>
        <title>01_-_setting_up_your_environment</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=01_-_setting_up_your_environment&amp;rev=1238052439</link>
        <description>Setting up the environment/prerequisites

In this tutorial, I'd like to catch all of you, from beginner to expert - so I will start from the bottom.
 Be sure, your preferred File-Zipper can handle both, jar-files AND lzma-file (we'll need to unpack some of those archives). If your not sure: visit ww.7-zip.org and get the pice of software, we'll need.
 We'll refer to some locations on your local machine:</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=01_-_tiled_and_maps&amp;rev=1259766082">
        <dc:format>text/html</dc:format>
        <dc:date>2009-12-02T15:01:22+00:00</dc:date>
        <title>01_-_tiled_and_maps</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=01_-_tiled_and_maps&amp;rev=1259766082</link>
        <description>(Work in Progress)
 

here we'll learn to create our initial map
  First we need to grab a copy ofTiled map editor.
  We will create a map with a tile size of 16×16 and with a map dimension of 40×30 tiles
  This will make us a 640×480 map (40×16=640) for our first test.
    Start Tiled, and go to the File menu, click New and 
  fill in the details according to the screenshot below:
  
  [platform:tiled1.png]
  
  
  Next we need to create two tilesets.
  one for the collision, and another on…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=02_-_a_basic_slick_applet&amp;rev=1238052338">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-26T07:25:38+00:00</dc:date>
        <title>02_-_a_basic_slick_applet</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=02_-_a_basic_slick_applet&amp;rev=1238052338</link>
        <description>Now that we have set up our project it's time to complete the class and write our first (minimal) applet (application so far).

Write a minimal applet

Another great tutorial on writing a first game (as an application) is available on this wiki:
 01 - A Basic Slick Game
 Even if this sample shows you how to write a Slick-application, it fits well because:
 Write your applet as if it was a java-application!
 Anyway, here comes our simple minimal applet. Copy the source over your “MyGame.java”…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=02_-_barebone_game&amp;rev=1260213531">
        <dc:format>text/html</dc:format>
        <dc:date>2009-12-07T19:18:51+00:00</dc:date>
        <title>02_-_barebone_game</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=02_-_barebone_game&amp;rev=1260213531</link>
        <description>(Work in Progress)
  
  
  In this article we will create a barebone “game” consiting of just one small class and make use of the map we just
  created in the previous tutorial. I've put the word “game” under quotes because this game won't be very exciting
  just yet. In fact we'll just open a window, display our previously created map and move an animated character around.
  There will be no collision test performed for now, so we'll be able to move through walls as if they didn't exist…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=02_-_slickblocks&amp;rev=1277359812">
        <dc:format>text/html</dc:format>
        <dc:date>2010-06-24T06:10:12+00:00</dc:date>
        <title>02_-_slickblocks</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=02_-_slickblocks&amp;rev=1277359812</link>
        <description>PATH TO GLORY : SlickBlocks

 Hello and welcome to the second part of Slick2D Path to glory, the road that will lead you from total slick2D newcomer into a veteran coding warrior.

In this tutorial we will make a falling brick game cloned after tetris, also a cute little penguin called Tux will appear in this game.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=03_-_looking_at_the_code&amp;rev=1260232961">
        <dc:format>text/html</dc:format>
        <dc:date>2009-12-08T00:42:41+00:00</dc:date>
        <title>03_-_looking_at_the_code</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=03_-_looking_at_the_code&amp;rev=1260232961</link>
        <description>wip: here i'll explain the code we used in previous article.
  
  
  
  full code: 


import org.newdawn.slick.Animation;
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.newdawn.slick.SpriteSheet;
import org.newdawn.slick.tiled.TiledMap;
 
public class Game extends BasicGame {
	private float playerX=320;
	pri…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=03_-_setting_up_the_web-page&amp;rev=1238056991">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-26T08:43:11+00:00</dc:date>
        <title>03_-_setting_up_the_web-page</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=03_-_setting_up_the_web-page&amp;rev=1238056991</link>
        <description>Great to see our first Slick-application in it's own window but we wanted to write an applet and display it inside an html-file. So here we go.
 Edit your WEB_ROOT/index.html and let it look like this: 


&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.01 Transitional//EN&quot; &quot;http://www.w3.org/TR/html4/loose.dtd&quot;&gt;
&lt;html&gt;
  &lt;head&gt;
    &lt;style type=&quot;text/css&quot;&gt;
      body { text-align:center;
             margin:0 auto;
             margin-left:0px;
             margin-right:0px;
             margin-top:10p…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=03_-_slickout&amp;rev=1282910168">
        <dc:format>text/html</dc:format>
        <dc:date>2010-08-27T11:56:08+00:00</dc:date>
        <title>03_-_slickout</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=03_-_slickout&amp;rev=1282910168</link>
        <description>PATH TO GLORY : SlickOut

Introduction

 Welcome to the second slick2d game tutorial... a breakout clone nicely called... slickout. This tutorial will help you not only get more out of your slick2d but also to understand some base concepts in game development.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=04_-_slopes_and_collisions&amp;rev=1261449783">
        <dc:format>text/html</dc:format>
        <dc:date>2009-12-22T02:43:03+00:00</dc:date>
        <title>04_-_slopes_and_collisions</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=04_-_slopes_and_collisions&amp;rev=1261449783</link>
        <description>wip: start implenting collisions and time things
  wip: try formating the page layout, put some stuffs for more readibility
  wip
 

Below is the revised code, to allow interaction with the level elements (blocks) so now you cannot walk through walls, floors and roofs anymore. Two new class were created, Block.java and BlockMap.java. Block is the class responsible for creating shapes you collide with.  BlockMap class, gather data from your map file and send informations to Block class like where…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=animation-fr&amp;rev=1221935858">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-20T18:37:38+00:00</dc:date>
        <title>animation-fr</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=animation-fr&amp;rev=1221935858</link>
        <description>Les animations sont des suites d'images affichées séquentiellement, où chaque image a une durée propre durant laquelle elle sera visible.
 Slick fournis une classe Animation qui permet de créer des animations à partir d'un tableau d'image, d'un spritesheet, etc ... qui peuvent ensuite être utilisées par les entités de votre jeu.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=animations&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>animations</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=animations&amp;rev=1188286186</link>
        <description>Animations

 Animations are a collection of images being displayed one after another, each image (or frame) for a set amount of time. Slick provides a class to allow you to build animation that can be reused by the entities in your game.

The Animation class allows you to add images with given durations and build an animation. By default the animation will automatically update between calls to its render() method. However, this isn't always useful since there may be a great deal of time between …</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=applets&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>applets</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=applets&amp;rev=1188286186</link>
        <description>Applets

 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.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=buffer&amp;rev=1221938042">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-20T19:14:02+00:00</dc:date>
        <title>buffer</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=buffer&amp;rev=1221938042</link>
        <description>Généralement, lorsque vous chargez une image, vous le faite à partir d'un fichier et dans un format supporté. Il se peut cependant que vous ayez envie de produire votre propre image à partir d'un ensemble de données. Quelques exemples sont la génération de terrains, ou alors la création d'images personnalisées. Slick met à votre disposition 2 solutions pour répondre à ce problème :</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=capturer_l_etat_d_une_entree&amp;rev=1222594350">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-28T09:32:30+00:00</dc:date>
        <title>capturer_l_etat_d_une_entree</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=capturer_l_etat_d_une_entree&amp;rev=1222594350</link>
        <description>Avec cette stratégie, vous pouvez connaitre à tout moment l'état d'un des dispositif d'entrée. Les méthodes décrites ci-dessous doivent être appelées sur une instance de GameContainer.getInput() .

Souris


public boolean isMouseButtonDown(int button) 
public boolean isMousePressed(int button) // Est-ce qu'un bouton a été pressé depuis le dernier appel ?
public int getMouseX() 
public int getMouseY()</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=clipping&amp;rev=1214209448">
        <dc:format>text/html</dc:format>
        <dc:date>2008-06-23T08:24:08+00:00</dc:date>
        <title>clipping</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=clipping&amp;rev=1214209448</link>
        <description>Clipping Introduction

 Clipping is the term used within computer graphics for not displaying graphics which are outside of the users viewport.  The viewport most commonly recognized is that of the screen.  To reduce the expense of calculating the position and appearance of graphics, the graphics which are outside of the viewport are clipped and therefore not drawn.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=color_image_editor&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>color_image_editor</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=color_image_editor&amp;rev=1188286186</link>
        <description>Note: Note that this system as not been accepted yet.  As such all information in here is subject to change or removal.

 

	*  Test drawing area.  This will show what your system will look like.
	*  The name of the base image in use.
	*  The 'x' and 'y' position of the entire system.
	*  The list of images that have been added to the system.
	*  The 'x' and 'y' offset position to show the selected image at.
	*  Select whether to use interpolation or discrete changes for colors in the selected i…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=color_image_system&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>color_image_system</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=color_image_system&amp;rev=1188286186</link>
        <description>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.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=configurable_emitters&amp;rev=1218714858">
        <dc:format>text/html</dc:format>
        <dc:date>2008-08-14T11:54:18+00:00</dc:date>
        <title>configurable_emitters</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=configurable_emitters&amp;rev=1218714858</link>
        <description>Configurable Emitters

 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.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=configurable_emitters_code_example&amp;rev=1251270629">
        <dc:format>text/html</dc:format>
        <dc:date>2009-08-26T07:10:29+00:00</dc:date>
        <title>configurable_emitters_code_example</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=configurable_emitters_code_example&amp;rev=1251270629</link>
        <description>This is a “HelloWorld” example for ConfigurableEmitters.  Hopefully this will help you get started.

Effect.java 


import org.newdawn.slick.*;
import org.newdawn.slick.particles.*;
import java.io.*;

public class Effect extends BasicGame {

	private ParticleSystem system;

	private ParticleIO particleIO;
	private ConfigurableEmitter emitter1;
	private ConfigurableEmitter emitter2;
	private int x = 0;
	
	public Effect() { super(&quot;Effect Test&quot;); }
	
	public void init(GameContainer container) t…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=controle_de_la_vitesse_de_jeu&amp;rev=1230330626">
        <dc:format>text/html</dc:format>
        <dc:date>2008-12-26T22:30:26+00:00</dc:date>
        <title>controle_de_la_vitesse_de_jeu</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=controle_de_la_vitesse_de_jeu&amp;rev=1230330626</link>
        <description>Il est important de comprendre que dans le fonctionnement de Slick, les méthodes render et update sont appelées à chaque frame. C'est évident pour la méthode render, mais pas forcément ce que vous attendez pour l'update.

Exemple

Un exemple très simple : imaginons que méthode update() contienne un code de déplacement tel que  :</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=controlling_game_updates&amp;rev=1246662347">
        <dc:format>text/html</dc:format>
        <dc:date>2009-07-03T23:05:47+00:00</dc:date>
        <title>controlling_game_updates</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=controlling_game_updates&amp;rev=1246662347</link>
        <description>update

 Was looking for these methods, appear to have been renamed to:  setMaximumLogicUpdateInterval(int interval);
setMinimumLogicUpdateInterval(int interval);

--cjanes

Controlling Game Updates

 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 sc…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=corporeal_tutorial&amp;rev=1256047542">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-20T14:05:42+00:00</dc:date>
        <title>corporeal_tutorial</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=corporeal_tutorial&amp;rev=1256047542</link>
        <description>The Corporeal library is an attempt to add Component based entity support to Slick2D. The objective of this library is to provide a simple way to create powerful game mechanics by adding simple components onto several entities.

So what's in Corporeal?</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=create_a_project_template&amp;rev=1253910660">
        <dc:format>text/html</dc:format>
        <dc:date>2009-09-25T20:31:00+00:00</dc:date>
        <title>create_a_project_template</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=create_a_project_template&amp;rev=1253910660</link>
        <description>This is valid as of Netbeans version 6.7.1 and up.  It may be similar for older versions, but I have not tested it.

Creating A Module

WARNING:  Names for Project Name and Code Name Base cannot contain spaces!

First, New Project... or press Ctrl + Shift + N.  When the Wizard comes up, click “NetBeans Modules” and select Module then click next.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=custom_configurable_emitters&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>custom_configurable_emitters</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=custom_configurable_emitters&amp;rev=1188286186</link>
        <description>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…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=deferred_resource_loading_getting_a_loading_bar&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>deferred_resource_loading_getting_a_loading_bar</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=deferred_resource_loading_getting_a_loading_bar&amp;rev=1188286186</link>
        <description>Deferred Resource Loading

 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 synchronisation. 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 th…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=embedding_the_mozilla_rhino_javascript_engine&amp;rev=1205530078">
        <dc:format>text/html</dc:format>
        <dc:date>2008-03-14T21:27:58+00:00</dc:date>
        <title>embedding_the_mozilla_rhino_javascript_engine</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=embedding_the_mozilla_rhino_javascript_engine&amp;rev=1205530078</link>
        <description>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.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=emitters&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>emitters</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=emitters&amp;rev=1188286186</link>
        <description>Emitters

 ParticleEmitters are added to a 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 update():


public void update(ParticleSystem system, int delta)</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=entity_tutorial&amp;rev=1256004555">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-20T02:09:15+00:00</dc:date>
        <title>entity_tutorial</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=entity_tutorial&amp;rev=1256004555</link>
        <description>Hello and welcome again, it's time for a quick break between games, in order to create some structures before we can continue.

This will be the first intermission in the game series and will host information on how,WHY to make and what is a Entity based game. Some other intermissions will arise in order to teach how to create some needed structures before we can continue.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=evenements_liees_aux_entrees&amp;rev=1222615709">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-28T15:28:29+00:00</dc:date>
        <title>evenements_liees_aux_entrees</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=evenements_liees_aux_entrees&amp;rev=1222615709</link>
        <description>Exceptionnellement, je vais écrire un exemple plutôt qu'une explication. Vous pouvez y retrouver toutes les stratégies permettant de connaitre ou de suivre l'état d'une entrée.

Exemple complet


package testInput;
	
import java.util.ArrayList;

import org.newdawn.slick.AppGameContainer;
import org.newdawn.slick.BasicGame;
import org.newdawn.slick.Color;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Input;
import org.newdawn.slick.SlickE…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=event_driven_input&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>event_driven_input</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=event_driven_input&amp;rev=1188286186</link>
        <description>Event Driven 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 arn'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 recieve notifications of input events from an Input instance by adding it using addListener().</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=exemples&amp;rev=1222618067">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-28T16:07:47+00:00</dc:date>
        <title>exemples</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=exemples&amp;rev=1222618067</link>
        <description>Vous retrouverez sur cette pages différentes exemples ou classes de test qui vous permettront de mieux appréhender la librairie Slick.

Classes 'tests'

 Toutes les classes de test sont accessibles sur le svn à l'adresse suivante :  &lt;https://bob.newdawnsoftware.com/repos/slick/trunk/Slick/src/org/newdawn/slick/tests/&gt;. N'hésitez pas à aller explorer les sources, elles sont réellement très enrichissantes.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=fade_in_out_effect&amp;rev=1250668229">
        <dc:format>text/html</dc:format>
        <dc:date>2009-08-19T07:50:29+00:00</dc:date>
        <title>fade_in_out_effect</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=fade_in_out_effect&amp;rev=1250668229</link>
        <description>Please see forum thread:

&lt;http://slick.javaunlimited.net/viewtopic.php?t=1797&gt;</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=font_rendering&amp;rev=1188655421">
        <dc:format>text/html</dc:format>
        <dc:date>2007-09-01T14:03:41+00:00</dc:date>
        <title>font_rendering</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=font_rendering&amp;rev=1188655421</link>
        <description>Font Rendering

 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 convienient rendering but does not allow smooth scaling. A glyph rendering approach directly liked to true type fonts may be provided later.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=fr-wiki&amp;rev=1223278453">
        <dc:format>text/html</dc:format>
        <dc:date>2008-10-06T07:34:13+00:00</dc:date>
        <title>fr-wiki</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=fr-wiki&amp;rev=1223278453</link>
        <description>Slick est une librairie Java permettant de réaliser des jeux 2D. 

	*  Site officiel : &lt;http://slick.cokeandcode.com/&gt;
	*  Forum : &lt;http://slick.javaunlimited.net/&gt;
	*  Wiki officiel (us) : &lt;http://slick.cokeandcode.com/wiki/doku.php&gt;
	*  Exemples de jeux / tests :  Exemples
	*  Tutoriaux disponibles : --</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=freeaks_tutorials&amp;rev=1260214035">
        <dc:format>text/html</dc:format>
        <dc:date>2009-12-07T19:27:15+00:00</dc:date>
        <title>freeaks_tutorials</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=freeaks_tutorials&amp;rev=1260214035</link>
        <description>(Work in Progress)
  wip: put some screenshots of the final project somewhere in this page
 

 This series of tutorials will explain how to build a platform game with Slick. Starting from scratch, with minimal to no assumed prerequisites or knowledge this will be suited for beginners. Each tutorial will be complete and independent, meaning all materials to have a complete working  example will be either provided and explained in each chapter, or linked from previous articles as we  build upon th…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=game_containers_and_basic_game&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>game_containers_and_basic_game</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=game_containers_and_basic_game&amp;rev=1188286186</link>
        <description>Game Containers

Concept

 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.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=generer_une_image&amp;rev=1221940144">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-20T19:49:04+00:00</dc:date>
        <title>generer_une_image</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=generer_une_image&amp;rev=1221940144</link>
        <description>Générer une image

 Il existe 2 méthodes pour générer une image : soit à partir de données brutes via la classe Image-Buffer, soit à partir d'instructions de dessin géométriques. C'est cette seconde solution que nous allons étudier ici.

Pour générer une nouvelle image, vous devez tout d'abord créer une image vide et accéder à son “contexte graphique”:</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=geometry&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>geometry</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=geometry&amp;rev=1188286186</link>
        <description>Geometry

 Slick provides some simple geometry classes in the 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.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=getting_started_and_setup&amp;rev=1282901452">
        <dc:format>text/html</dc:format>
        <dc:date>2010-08-27T09:30:52+00:00</dc:date>
        <title>getting_started_and_setup</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=getting_started_and_setup&amp;rev=1282901452</link>
        <description>Above and beyond the information on this page there is a great eclipse+slick tutorial  provided here.

A more recent tutorial, based on the link above, can be found  here. It covers the steps in the tutorial linked above but in a more concise manner. Additionally, the tutorial covers how to use the most recent version of LWJGL in the unlikely case that using the slightly older one packaged with Slick results in an error.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=image_buffer&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>image_buffer</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=image_buffer&amp;rev=1188286186</link>
        <description>Image Buffer

 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 ImageBuffer utility class.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=images-fr&amp;rev=1221911789">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-20T11:56:29+00:00</dc:date>
        <title>images-fr</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=images-fr&amp;rev=1221911789</link>
        <description>Les images sont les éléments de dessin les plus primitifs de Slick. Elles sont à la racine de tous les processus de rendus. Chaque image affichera à l'écran un rectangle remplis de pixels qui seront issues de plusieurs sources : image générée (cf ImageBuffer), ou d'une image chargée depuis le disque dur.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=images&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>images</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=images&amp;rev=1188286186</link>
        <description>Images

 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.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=importer_et_utiliser_une_map_generee_via_tiled&amp;rev=1223280191">
        <dc:format>text/html</dc:format>
        <dc:date>2008-10-06T08:03:11+00:00</dc:date>
        <title>importer_et_utiliser_une_map_generee_via_tiled</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=importer_et_utiliser_une_map_generee_via_tiled&amp;rev=1223280191</link>
        <description>TileD est un éditeur de map du type 'tile map' écrit en JAVA et disponible gratuitement sur le site de son auteur : &lt;http://www.mapeditor.org/&gt; . Slick vous permet de charger et d'afficher des cartes générées via cet éditeur, à condition qu'elles soient de type 'orthogonales', et compressées en 'base64' ( option par défaut ).</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=importer_et_utiliser_une_tiled_map&amp;rev=1223278736">
        <dc:format>text/html</dc:format>
        <dc:date>2008-10-06T07:38:56+00:00</dc:date>
        <title>importer_et_utiliser_une_tiled_map</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=importer_et_utiliser_une_tiled_map&amp;rev=1223278736</link>
        <description>suppr</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=input_handling&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>input_handling</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=input_handling&amp;rev=1188286186</link>
        <description>Input Handling

 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 Input class. To recieve 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 prefer…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=installation_et_premiere_application&amp;rev=1230330100">
        <dc:format>text/html</dc:format>
        <dc:date>2008-12-26T22:21:40+00:00</dc:date>
        <title>installation_et_premiere_application</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=installation_et_premiere_application&amp;rev=1230330100</link>
        <description>Exemples et tutorials

 Avant toute chose, sachez qu'un tutorial pour utiliser Slick sous Eclipse est disponible à l'adresse suivante ( en anglais certes ) :Tutorial eclipse      (Si quelqu'un veut le traduire)

Le premier chalenge avec une nouvelle API est d'apprendre à l'utiliser proprement. Une solution plébiscitée est de jouer avec les classes de tests et les exemples fournis. Vous pouvez les retrouver sur la page Exemples.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=introduction&amp;rev=1221656980">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-17T13:09:40+00:00</dc:date>
        <title>introduction</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=introduction&amp;rev=1221656980</link>
        <description>Slick2D est une simple librairie Java basée sur le binding LWJGL (OpenGl).

Buts de la librairie : 

	*  Fournir une api 2D simple à utiliser
	*  Fournir une transition facile entre Java2D et OpenGl
	*  Permettre la distribution via Webstart
	*  Fournir la plupart des outils pour la création d'un jeu
	*  Frameworks extensible et flexible
	*  Léger car vous pouvez sélectionner les éléments que vous souhaitez garder
	*  Vous aider à gérer le son, les entrées, les collisions, etc ...</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=les_classes_principales_gamecontainer_et_basicgame&amp;rev=1230330298">
        <dc:format>text/html</dc:format>
        <dc:date>2008-12-26T22:24:58+00:00</dc:date>
        <title>les_classes_principales_gamecontainer_et_basicgame</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=les_classes_principales_gamecontainer_et_basicgame&amp;rev=1230330298</link>
        <description>Concept

 Le concept de conteneurs n'est pas particulièment nouveau. Le conteneur fournis un environnement dans lequel votre application ( votre jeux ) peux s'exécuter. Il permet ainsi de traiter automatiquement les structures de codes communs à tous les jeux, pour que vous puissiez vous focaliser sur la programmation propre à votre jeux.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=les_entrees&amp;rev=1222593248">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-28T09:14:08+00:00</dc:date>
        <title>les_entrees</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=les_entrees&amp;rev=1222593248</link>
        <description>La gestion des entrées de slick prend en compte la clavier et la souris, mais aussi la plupart des contrôleurs (gamepad). Le traitement des entrées est assuré par la classe Input. En utilisant le 'framework' GameContainer, il vous suffit d'appeler GameContainer.getInput() pour recevoir l'état des différentes entrées.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=loading_and_binding_opengl_textures_with_slick-util&amp;rev=1206854301">
        <dc:format>text/html</dc:format>
        <dc:date>2008-03-30T05:18:21+00:00</dc:date>
        <title>loading_and_binding_opengl_textures_with_slick-util</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=loading_and_binding_opengl_textures_with_slick-util&amp;rev=1206854301</link>
        <description>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
	*  ??

 Here's some basic code that shows how to load a texture file and bind it.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=logging&amp;rev=1214201066">
        <dc:format>text/html</dc:format>
        <dc:date>2008-06-23T06:04:26+00:00</dc:date>
        <title>logging</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=logging&amp;rev=1214201066</link>
        <description>Logging Overview

 The logging package provided by slick ( org.newdawn.slick.util.Log) 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.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=netbeans_tutorials&amp;rev=1253910558">
        <dc:format>text/html</dc:format>
        <dc:date>2009-09-25T20:29:18+00:00</dc:date>
        <title>netbeans_tutorials</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=netbeans_tutorials&amp;rev=1253910558</link>
        <description>These Tutorials are specifically designed for users using NetBeans.

* Create a Project Template - Programmers will learn how to create their own project templates in NetBeans.  The template created in this Tutorial will create an empty Slick Basic Game, with all libraries included, and the VM Options path set up appropriately.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=open_source_games&amp;rev=1282903476">
        <dc:format>text/html</dc:format>
        <dc:date>2010-08-27T10:04:36+00:00</dc:date>
        <title>open_source_games</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=open_source_games&amp;rev=1282903476</link>
        <description>In this page will be listed all games made with Slick and their source code. You can add your game following format: 

	*  Name: 
	*  Description: 
	*  Status: 
	*  Source: 
	*  License: 
	*  Play now: 
	*  Author: 
	*  Homepage: 

----------

JPacman

	*  Name: Jpacman
	*  Description: pacman clone done with slick
	*  Status: Complete
	*  Source: &lt;http://code.google.com/p/jpacman/source/browse/#svn/trunk/jpacman&gt;
	*  License: Gplv2
	*  Play now: &lt;http://jpacman.googlecode.com/files/jpacman-win3…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=overview&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>overview</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=overview&amp;rev=1188286186</link>
        <description>Overview

 Slick2D is a simple set of tools wrapped around the 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 …</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=packed_sprite_sheets&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>packed_sprite_sheets</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=packed_sprite_sheets&amp;rev=1188286186</link>
        <description>Packed Sprite Sheets

 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 mutliple 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 ImagePacker.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=particle_engine&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>particle_engine</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=particle_engine&amp;rev=1188286186</link>
        <description>Particle Engine

 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 initialised in. These values are often based on pseduo-random numbers which leads to effects that tend to look more organic and unique than with pre-canned animations.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=polling_the_current_input_state&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>polling_the_current_input_state</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=polling_the_current_input_state&amp;rev=1188286186</link>
        <description>Polling Input

 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 you…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=rendering_to_an_image&amp;rev=1221865891">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-19T23:11:31+00:00</dc:date>
        <title>rendering_to_an_image</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=rendering_to_an_image&amp;rev=1221865891</link>
        <description>Rendering to an image

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.


private Image localImg;
private Graphics localImgG;
try {
	localImg = new Image(256,256);
	localImgG = localImg.getGraphics();
} catch (SlickException e) {
	Log.error(&quot;creating local image or graphics context failed: &quot; + e.getMessage());
}</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=rendu_des_polices_de_caracteres&amp;rev=1221942931">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-20T20:35:31+00:00</dc:date>
        <title>rendu_des_polices_de_caracteres</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=rendu_des_polices_de_caracteres&amp;rev=1221942931</link>
        <description>Slick fournis deux différentes façon d'afficher du texte à l'écran. 

	*  La première, dite 'Bitmap based', se base sur une image contenant tous les caractères utilisables, ainsi qu'un fichier annexe contenant toutes les informations sur le positionnement des caractères.
		*  Inconvénients : Lourds ( un TGA pour chaque police ), vous n'avez accés qu'à une taille, un seul type (normal/gras/italique)
		*  Avantages : Vous pouvez créer des polices personnalisées : contours, ombres, lueu…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=resource_loading&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>resource_loading</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=resource_loading&amp;rev=1188286186</link>
        <description>Resource Loading

 When referencing resources (images, 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…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=resource_manager_tutorial&amp;rev=1275438658">
        <dc:format>text/html</dc:format>
        <dc:date>2010-06-02T00:30:58+00:00</dc:date>
        <title>resource_manager_tutorial</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=resource_manager_tutorial&amp;rev=1275438658</link>
        <description>Resource Manager Tutorial

 Sometimes you just want to organize all your resources into a simple place. Loading images from strings within the code is avoidable, cumbersome and repetitive.

Why should we use those strings when something much more efficient may be devised.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=saving&amp;rev=1251150274">
        <dc:format>text/html</dc:format>
        <dc:date>2009-08-24T21:44:34+00:00</dc:date>
        <title>saving</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=saving&amp;rev=1251150274</link>
        <description>It's simple to save Slick2D's Images to your local HD. Snippet 


import org.newdawn.slick.Graphics;
import org.newdawn.slick.Image;
import org.newdawn.slick.Input;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.imageout.ImageOut;

//...

public void update(GameContainer container, StateBasedGame game, int delta) throws SlickException {
	// update game...
	
	if (container.getInput().isKeyPressed(Input.KEY_S)) {
		Image target = new Image(container.getWidth(), container.getHeig…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=saving_local_settings&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>saving_local_settings</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=saving_local_settings&amp;rev=1188286186</link>
        <description>Saving Local Settings

 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?</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=scalable_vector_graphics_svg&amp;rev=1213545280">
        <dc:format>text/html</dc:format>
        <dc:date>2008-06-15T15:54:40+00:00</dc:date>
        <title>scalable_vector_graphics_svg</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=scalable_vector_graphics_svg&amp;rev=1213545280</link>
        <description>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 Inkscape.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=shaking_the_camera&amp;rev=1250667133">
        <dc:format>text/html</dc:format>
        <dc:date>2009-08-19T07:32:13+00:00</dc:date>
        <title>shaking_the_camera</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=shaking_the_camera&amp;rev=1250667133</link>
        <description>Discussed in this thread:

&lt;http://slick.javaunlimited.net/viewtopic.php?t=1811&amp;highlight=shake+camera&gt;</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=slick-util_javadoc_and_location&amp;rev=1206851798">
        <dc:format>text/html</dc:format>
        <dc:date>2008-03-30T04:36:38+00:00</dc:date>
        <title>slick-util_javadoc_and_location</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=slick-util_javadoc_and_location&amp;rev=1206851798</link>
        <description>The slick-util library and support files can be downloaded from:

&lt;http://slick.cokeandcode.com/downloads/util/&gt;

 Javadocs for the slick-util distribution can be found at:

&lt;http://slick.cokeandcode.com/javadoc-util/&gt;</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=son_et_musique&amp;rev=1222591727">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-28T08:48:47+00:00</dc:date>
        <title>son_et_musique</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=son_et_musique&amp;rev=1222591727</link>
        <description>La gestion des sons et des musiques est similaire à celle des images. Construisez simplement un objet du type approprié ( Sound ou Music ) avec une référence à la ressource à charger. Les sons (intermittents) et les musiques sont séparées en raison de leur “source d'utilisation” ( Channels ). Quand un son doit être exécuté, on réserve une source disponible et on l'utiliser pour jouer le son. Si aucune source n'est disponible, le son ne sera pas joué. A l'opposé, les musiques so…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=sound_with_slick-util&amp;rev=1206853768">
        <dc:format>text/html</dc:format>
        <dc:date>2008-03-30T05:09:28+00:00</dc:date>
        <title>sound_with_slick-util</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=sound_with_slick-util&amp;rev=1206853768</link>
        <description>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.

 Here's some basic code that loads an ogg file and plays it.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=sounds_and_music&amp;rev=1194642312">
        <dc:format>text/html</dc:format>
        <dc:date>2007-11-09T21:05:12+00:00</dc:date>
        <title>sounds_and_music</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=sounds_and_music&amp;rev=1194642312</link>
        <description>Sound and Music

 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 souce is available the sound isn't played. However, music is always played on a single reserved cha…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=spiegel_tutorials&amp;rev=1277359624">
        <dc:format>text/html</dc:format>
        <dc:date>2010-06-24T06:07:04+00:00</dc:date>
        <title>spiegel_tutorials</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=spiegel_tutorials&amp;rev=1277359624</link>
        <description>Slick 2D - Path to glory

 Hi, my name is Tiago “Spiegel” Costa, a pseudo-game developer located in Portugal, main programmer/designer/audio engineer and basically the only guy in the office of foxholestudios, and welcome to Slick2d PATH to glory. In these tutorials I will try to show you how to develop several types of 2D Games using the Slick2D library. Ill try to use just a couple of things in each game so I wont overwhelm the reader with information. Feel free to argue with my explanatio…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=spins_tutorials&amp;rev=1238055574">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-26T08:19:34+00:00</dc:date>
        <title>spins_tutorials</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=spins_tutorials&amp;rev=1238055574</link>
        <description>A few days ago I started thinking about creating a game in Java (my first ever) and so I began, looking around for a game engine, written in Java and with the capability, to run as an applet.
 Because I don't want a 3D game, most of the actual engines (like JME) are oversized at all. Other engines are quite out of date or seem to be unstable. Also I “found out” that a pure Java-engine will be pretty slow (GTGE for example looks quite good, is well documented - but bases on Java2D - no suppor…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=sprite_sheets&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>sprite_sheets</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=sprite_sheets&amp;rev=1188286186</link>
        <description>Sprite Sheets

 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 SpriteSheet class that lets you access each of the sub-images of the sheet as seperate images easily.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=spritesheet&amp;rev=1221924472">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-20T15:27:52+00:00</dc:date>
        <title>spritesheet</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=spritesheet&amp;rev=1221924472</link>
        <description>Explications

 Un Sprite sheet est une collection de sprites (images) accolés ensemble pour n'obtenir qu'une unique image. 
  [Exemple de sprite sheet]    Exemple d'animation : un déplacement se décompose en plusieurs sprites 
 De manière générale, cette technique est utilisée pour 2 raisons : des performances accrues (il est plus rapide de charger une image importante qu'une multitude de petites), et par praticité. Slick fournit ainsi une classe SpriteSheet qui permet d'accéder à chaq…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=start&amp;rev=1278497761">
        <dc:format>text/html</dc:format>
        <dc:date>2010-07-07T10:16:01+00:00</dc:date>
        <title>start</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=start&amp;rev=1278497761</link>
        <description>Accéder au Wiki français

Slick is a simple Java based 2D games development library. You can read more about it on the Slick homepage at &lt;http://slick.cokeandcode.com&gt; or discuss it at over at the forums.

This wiki is intended for documentation purposes and will contain the following information</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=state_based_games&amp;rev=1237289670">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-17T11:34:30+00:00</dc:date>
        <title>state_based_games</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=state_based_games&amp;rev=1237289670</link>
        <description>State Based Game

 The 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.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=support_des_polices_bitmap-based&amp;rev=1221948750">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-20T22:12:30+00:00</dc:date>
        <title>support_des_polices_bitmap-based</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=support_des_polices_bitmap-based&amp;rev=1221948750</link>
        <description>Il existe actuellement 2 manières d'utiliser une police basée sur une image, les deux étant des implémentations de l'interface Font. Cette interface vous permet bien évidemment d'afficher du texte à l'écran, mais aussi de déterminer la grandeur,  l'écartement des caractères, et ainsi calculer à l'avance la taille que va occuper un texte ( très utile pour centrer un texte ! ).</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=support_des_polices_truetypefonts&amp;rev=1221946665">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-20T21:37:45+00:00</dc:date>
        <title>support_des_polices_truetypefonts</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=support_des_polices_truetypefonts&amp;rev=1221946665</link>
        <description>Slick a la capacité d'afficher facilement des polices de type TrueTypeFont (ttf) à l'écran. 

Classe utilisée : org.newdawn.slick.TrueTypeFont


// Initialisation de la police
Font font = new Font(&quot;Verdana&quot;, Font.BOLD, 20);
TrueTypeFont trueTypeFont = new TrueTypeFont(font, true); // voir plus bas pour l'explication du 'tru'
 
// Affiche un texte en verdana 20 gras à l'écran, en vert
trueTypeFont.drawString(20.0f, 20.0f, &quot;Slick displaying True Type Fonts&quot;, Color.green);</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=support_des_tile_map&amp;rev=1223278493">
        <dc:format>text/html</dc:format>
        <dc:date>2008-10-06T07:34:53+00:00</dc:date>
        <title>support_des_tile_map</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=support_des_tile_map&amp;rev=1223278493</link>
        <description>Il existe plusieurs types de moteurs 2D, dont les deux principaux reposent respectivement sur l'affichage d'une image unique, et sur l'affichage en tiles. Dans le premier cas, les niveaux sont faits d'une seule pièce, c'est-à-dire que le personnage dirigé par le joueur évolue sur une image unique de grande taille. Dans le second cas, les niveaux sont créés par assemblage d'une multitude de petites images, pour former une grande image. L'image de base est appelée « tile » et le fichier q…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=support_des_tiled_map&amp;rev=1223278500">
        <dc:format>text/html</dc:format>
        <dc:date>2008-10-06T07:35:00+00:00</dc:date>
        <title>support_des_tiled_map</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=support_des_tiled_map&amp;rev=1223278500</link>
        <description>suppr</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=testarea&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>testarea</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=testarea&amp;rev=1188286186</link>
        <description>A test area to play with the wiki</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=texture_handling&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>texture_handling</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=texture_handling&amp;rev=1188286186</link>
        <description>Using Textures with Slick Utilties

 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 arn't rebound if they're already current. This means that should you bind a different texture outside of the Sli…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=the_pedigree_editor&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>the_pedigree_editor</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=the_pedigree_editor&amp;rev=1188286186</link>
        <description>The Pedigree Editor

 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 dr…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=tile_map_support&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>tile_map_support</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=tile_map_support&amp;rev=1188286186</link>
        <description>Tile Map Support

 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 a…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=tiled_import_and_use&amp;rev=1250289355">
        <dc:format>text/html</dc:format>
        <dc:date>2009-08-14T22:35:55+00:00</dc:date>
        <title>tiled_import_and_use</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=tiled_import_and_use&amp;rev=1250289355</link>
        <description>TileD Map Support

 TileD is a tile map editor written in Java and available from the TileD Website. 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, th…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=truetype_font_support&amp;rev=1221946813">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-20T21:40:13+00:00</dc:date>
        <title>truetype_font_support</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=truetype_font_support&amp;rev=1221946813</link>
        <description>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.


import org.newdawn.slick.TrueTypeFont;


You can find the full javadoc to the TrueTypeFont class here:</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=tutorials&amp;rev=1282901419">
        <dc:format>text/html</dc:format>
        <dc:date>2010-08-27T09:30:19+00:00</dc:date>
        <title>tutorials</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=tutorials&amp;rev=1282901419</link>
        <description>This section contains all available tutorials about slick2D.

Spiegel tutorials

	*  Spiegel tutorials - Explains the ins and outs of Slick2D by making complete games.
		*  01 - A Basic Slick Game - Explains how to make a simple game in Slick.
		*  02 - SlickBlocks - Explains how to create a tetris clone game.  
		*  03 - Slickout - Explains how to create a breakout clone.
		*  04 - SlickMan - Eplains how to make a PacMan clone.
		*  05 - SlickBros - Explains how to make a game like Super Mario …</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=unicode_font_support&amp;rev=1276895427">
        <dc:format>text/html</dc:format>
        <dc:date>2010-06-18T21:10:27+00:00</dc:date>
        <title>unicode_font_support</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=unicode_font_support&amp;rev=1276895427</link>
        <description>UnicodeFont replaces the now deprecated TrueTypeFont.  The key advantage of UnicodeFont is that it allows new glyphs to be added on the fly.  If “on the fly” loading is not needed, it is probably better to use Heiro and AngelCodeFont.



Usage

Because UnicodeFont allows glyphs to be loaded on the fly, creating an instance of UnicodeFont can be unintuitive the code example below explains the required actions.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=user_manual&amp;rev=1255397683">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-13T01:34:43+00:00</dc:date>
        <title>user_manual</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=user_manual&amp;rev=1255397683</link>
        <description>Slick2D user Manual

	*  Game Containers and Basic Game
		*  Controlling Game Updates

	*  Graphics Context
		*  Clipping
		*  Alpha Buffer
		*  Fills and Gradients
		*  Shaking the Camera


	*  Images
		*  Sprite Sheets
		*  Packed Sprite Sheets
		*  XML Packed Sprite Sheets (Pack-U-Like)
		*  Animations
		*  Image Buffer
		*  Rendering to an Image
		*  Saving
		*  Fade In/Out Effect</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=using_slick_utilities_without_the_framework_lwjgl_direct&amp;rev=1188286186">
        <dc:format>text/html</dc:format>
        <dc:date>2007-08-28T07:29:46+00:00</dc:date>
        <title>using_slick_utilities_without_the_framework_lwjgl_direct</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=using_slick_utilities_without_the_framework_lwjgl_direct&amp;rev=1188286186</link>
        <description>Slick isn't an Engine!

 Slick isn't an 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…</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=webstart&amp;rev=1281723133">
        <dc:format>text/html</dc:format>
        <dc:date>2010-08-13T18:12:13+00:00</dc:date>
        <title>webstart</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=webstart&amp;rev=1281723133</link>
        <description>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 Kev's Webstart Walkthrough.</description>
    </item>
    <item rdf:about="http://slick.cokeandcode.com/wiki/doku.php?id=xml_packed_sprite_sheets_pack-u-like&amp;rev=1213904678">
        <dc:format>text/html</dc:format>
        <dc:date>2008-06-19T19:44:38+00:00</dc:date>
        <title>xml_packed_sprite_sheets_pack-u-like</title>
        <link>http://slick.cokeandcode.com/wiki/doku.php?id=xml_packed_sprite_sheets_pack-u-like&amp;rev=1213904678</link>
        <description>XML Packed Sprite Sheets

 These kind of sprite sheets are generated by 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).

Create a new Sheet:</description>
    </item>
</rdf:RDF>
