cave_gen_4

Appliquer un tileset sur une tilemap

0
6 days ago
by Adrien in ,

Maintenant que nous avons vu comment avoir un monde généré aléatoirement, et pouvant servir de donjon, voyons maintenant comment appliquer un tileset sur cette même map.

Nous avons besoin de déterminer l’état de chaque cellule en fonction de l’état des quatre cellules avoisinantes (on ne prendra pas compte des diagonales).

Plutôt que partir sur des conditions relativement énorme vu le nombre de cas à traiter, nous allons nous baser sur le même principe que pour les nombres binaires, car de la même manière nous devons représenter une combinaison de 4 valeurs dans un état 1 ou 0.

 

Un peu de théorie

Pour essayer de mieux comprendre, voici l’énumération des premiers nombres, et ce que ça veut dire pour nous.

  • Décimal – Binaire (Explication)
  • 0 – 0
  • 1 – 1 (2⁰)
  • 2 – 10 (2¹)
  • 3 – 11 (2¹ + 2⁰)
  • 4 – 100 (2²)
  • 5 – 101 (2² + 2⁰)
  • 6 – 110 (2² + 2¹)
  • 7 – 111 (2² + 2¹ + 2⁰)
  • 8 – 1000 (2³)
  • …

Ok… mais comment je détermine la valeur de mes cellules ?

En pratique nous devons donc regarder les cellules environnantes et déterminer la valeur de chaque cellule en fonction des autres.

Tout d’abord le schéma correspondant aux valeurs de chaque cellule voisine :

Une case pleine sur la gauche vaut 8, une case pleine en dessous 4, un case pleine au dessus 1, et une case à droite 2.

Et voici un exemple avec les valeurs pour chaque cellule pleine :

Chaque valeur ainsi obtenue permet d’avoir la position de la tile dans la tileset :

(more…)

cave_gen_final

Génération aléatoire d’un donjon

1
6 days ago
by Adrien in ,

Dans le post Génération aléatoire d’un terrain, nous avons vu comment générer un terrain grâce à la méthode des Automates Cellulaires.

Dans ce post-ci, nous allons maintenant voir comment générer des donjons, c’est-à-dire avoir la possibilité de se déplacer sur toutes les zones de la carte, sans avoir de murs bloquant le déplacement.

La méthode reste relativement la même, cependant nous allons devoir traiter plusieurs cas supplémentaires.

Le plus gros souci de nos cartes pour un donjon correspond aux trop grosses zones vides. Pour les éliminer, nous allons simplement ajouter une condition supplémentaire à la transformation : si une cellule est entourée de 0 mur dans un rayon de 1, nous passons la cellule en type mur.

for(p in levelMap)
    if( R1(p) >= 5 || R2(p) <= 1)
        p = 1;
    else
        p = 0;

Où Rn(p) est le nombre de voisin de type mur à une distance n de la cellule p. La fonction comptabilisant le nombre de voisins compte forcément la case en cours de test.

Voici ce que nous pouvons obtenir en 5 passes :

Comme on peut le constater, nous avons presque toutes les zones accessibles, et aucune grosse zone vide, mais il nous faut maintenant traiter le cas des blocs seuls, isolés un peu partout sur le terrain.

Pour continuer à nettoyer ça, nous allons rajouter des passages supplémentaires, mais avec des conditions différentes :

for(i in 0...3)
    for(p in levelMap)
        if( R1(p) >= 5 || R2(p) <= 1 )
            p = 1;
        else
            p = 0;
 
for(i in 0...2)
    for(p in levelMap)
        if( R1(p) >= 5 )
            p = 1;
        else
            p = 0;

Ce qui va maintenant nous permettre d’obtenir, par exemple :

Et pour finaliser notre donjon, nous pouvons ajouter les bordures.

Voici un exemple de rendu final avec un ratio de 0.45, suivi de 5 itérations 1, et 3 itérations 2 :

nme

HxSpriter released

0
1 week ago
by Adrien in ,

HxSpriter is the Haxe implementation of the Spriter application and file format.
It’s a port a the SpriterAS3 lib, but working with NME. It basically lets you use Spriter with your games or applications.

First of all, what’s Spriter?

Spriter is a powerful animation tool for creating highly detailed 2d real-time game characters and effects in an intuitive, visual editor. The characters are saved to a format that allows game engines to produce higher quality visuals, while also using less video ram, and requiring less disk space per frame than traditional 2d sprite animation.

Spriter also provides several game specific features like collision boxes, and sound effect triggering, and saves to an open format that will be useable across many different game engines and platforms.

Spriter is currently in an usable beta state, but it’s really subject to changes, so the various implementations might stop working from a version to another, and they will need constant updating. The file format may also get incompatible across future versions, and the application may cause some crashes. For these reasons, Spriter is not production ready, but you can test it and play with it if you want.

How to use it ?

To use it, just install it from haxelib :

haxelib install HxSpriter

In your NME file, you have to define a sprites directory (just rename the directory where you have all your Spriter’s animations).

<assets path="path/to/the/sprites/directory" rename="sprites" />

Now, if you want to use the library :

var spriter : BitmapSpriter = new BitmapSpriter('BetaFormatHero.SCML', 100, 300);
spriter.playAnimation('idle_healthy');
addChild(spriter);

Or with the Flixel port :

var spriter : FlxSpriter = new FlxSpriter('BetaFormatHero.SCML', 100, 300);
spriter.playAnimation('idle_healthy');
add(spriter);

Or with HaxePunk :

var spriter : HxpSpriter = new HxpSpriter('BetaFormatHero.SCML', 100, 300);
spriter.playAnimation('idle_healthy');
addGraphic( spriter );

You can also checkout the repository : https://github.com/po8rewq/hxSpriter.

flixel

FlxCollisions port to Haxe

0
3 weeks ago
by Adrien in

Here is the FlxCollisions demo ported to the Haxe version of Flixel. Watch the FPS value of the Android version… just awesome! This demo uses the tmx file to generate the level (Tmx library).

You can download sources on github.

flixel

Tmx format with Flixel Haxe

0
3 weeks ago
by Adrien in

During the past few days, I’ve been working with the HaxePunk framework to develop a game. But because of a lack of performance on Android (and no time to try to fix it), I’ve tried the Flixel port to see if I could build a game quickly.

First of all, I’ve tried the example based on Demo on my Android device and… surprise, the game turns at 50-60 FPS. So against my heart, I decided to start building my game on Flixel (actually, I really prefer the HaxePunk structure).

First of all, I tried to remember how Flixel works (I’ve already used it on My Hero Factory…).

So I started to initialise a project, and tried to import a level I’ve made with Tiled Map Editor… only to discover the tmx format is not supported in Flixel o_O.

Thanks to Matt Tuttle, the library is already ported to HaxePunk (the original one was from Thomas Jahn) so it was not difficult to make it work with Flixel.

So here is how you used it (make sure to download the sources) :

// Create a TmxMap with a tmx file
var tmx : TmxMap = new TmxMap( nme.Assets.getText('levels/map01.tmx') );
 
// Basic level structure
var t:FlxTilemap = new FlxTilemap();
 
// Generate a CSV from the layer 'map' with all the tiles from the TileSet 'tiles'
var mapCsv:String = tmx.getLayer('map').toCsv( tmx.getTileSet('tiles') );
 
t.loadMap(mapCsv, "gfx/tiles.png", 8, 8, FlxTilemap.OFF);
add(t);

And that’s it! Of course if you want to have collisions detections, just add:

override public function update()
{
    super.update();
    FlxG.collide(_player, _tilemap);
}
ld48-screen1

My entry for Ludum Dare 23

0
3 weeks ago
by Adrien in

Last weekend, I entered the great contest that is Ludum Dare. For those who don’t know what the Ludum Dare is, it’s an event that takes place every 3 months, and that gathers a lot of people wanting to create games… in only 48 hours for the solo contest, and around a precise theme. To give you an idea of the popularity of this contest, people submitted over 1200 games during the weekend!

When the subject of this Ludum Dare has been announced (Tiny World), a lot of people started to post on the official website all their ideas, and that it was an inspiring subject … but it wasn’t my case. So I took 2 or 3 hours looking for a good idea and trying to have a good concept.

Thanks to the coffee, I managed to finish my game in time to submit it (click to see the entry). Its name ? Pixel World !

How I prepared

  • Trying concepts using HaxePunk to start learning this great tool
  • Used tiled map editor with HaxePunk
  • In fact, I prepared all the tools I needed

What went right

  • I tried to stay simple and to focus on the concept
  • I used tools I was familiar with (HaxePunk, MonoDevelop and Gimp), so I didn’t lose time on that
  • Thanks to my lack of drawing abilities, I managed not to spend too much time on the graphic design (actually, it helped me to find a cool concept!)

What could have been better

  • More updates on my progress (I tried to stay away from the website, in order not to be distracted by watching the other’s amazing games)
  • I spent too much time on the level design : I tried to stay simple, but didn’t want to have a game that was too simple to play…

Next time

  • I will try to add sounds/music to my game
  • Much more updates on my work on the website
  • Less coffee ? (just kidding… or am I?)

(more…)

cellular_automaton_thb

Génération aléatoire d’un terrain : Cellular Automaton

1
1 month ago
by Adrien in ,

Cette méthode est utilisée dans beaucoup de domaines comme par exemple les maths, la physique…

Elle consiste à avoir une grille contenant des cellules, chacune ayant un état (dans notre cas eau/terre).

Pour chaque cellule, on regarde l’état des cellules voisines pour déterminer son nouvel état. Si une cellule est entourée d’au moins 5 cellules de type terre, alors la cellule est transformée en cellule terre, sinon on la passe en cellule de type eau.

Voici un exemple en 8 passes :

Pour plus de renseignements sur cette méthode : Cellular Automaton (ou Automate Cellulaire en français).

Il y a deux façons de procéder lors du traitement des données :

  • Pour chaque cellule, faire le traitement et modifier directement les données du tableau (et donc prendre le nouvel état en considération lors du traitement de la cellule suivante)
  • On traite les données à un instant t.

C’est cette deuxième solution que nous allons utiliser.

(more…)

Sauvegarder une liste d’entiers dans un shared object

0
6 months ago
by Adrien in ,

Voici une petite astuce qui peut vous simplifier la vie. Dans un grand nombre de jeux, nous avons besoin de stocker la liste des niveaux terminés par le joueur, et de pouvoir y accéder rapidement. La méthode la plus simple est de stocker cette donnée dans un SharedObject que nous retrouverons à chaque lancement de session.

Sauvegarde des données

Pour stocker une liste d’entiers dans un SharedObject sous la forme d’un entier seul, il faut sauvegarder la somme des puissances de 2 des valeurs souhaitées.

var mySo:SharedObject = SharedObject.getLocal("myApplication");
var dataToSave : Array = [2, 5, 4];
var somme : int = 0;
for each(var data : int in dataToSave)
{
    somme += Math.pow(2, data);
}
mySo.data.savedValue = somme;

Récupération des données

Et pour récupérer les données :

var intValue : int = mySo.data.savedValue;
var currentIndex : int; // identifiant du niveau à tester
if( ( Math.pow(2, currentIndex) & intValue) > 0 )
{
    // L'entier est bien présent dans la liste
}
nme

NME – Premiers pas sous android

0
8 months ago
by Adrien in

La version 3 de NME est enfin disponible sur haxelib !!

Le rêve de tout développeur est en train de se réaliser : developper une application, et la publier sur toutes les plates formes ! C’est enfin possible grâce à haXe et NME.

Quelques précisions :

Avant d’aller plus loin, voyons un peu de quoi il s’agit. Si vous êtes familié avec haXe, vous ne l’êtes peut etre pas avec NME.

NME (pour Neko Media Engine) est un framework open source permettant de publier une application vers tout type de plate forme (windows, linux, android, ios, et j’en passe). Ce framework s’appui sur le langage haXe, ce qui permet d’avoir une syntaxe proche de l’Actionscript. NME s’occupe ensuite de mapper tout ca, et de publier pour la plate forme voulue.

Nous ne nous interresserons pour le moment, qu’à la plate forme android.

Voici un schéma permettant de comprendre le fonctionnement :

(source: www.haxenme.org)

NME va utiliser le compilateur haxe, avec la librairie HXCPP pour générer les classes C++. La compilation va se poursuivre via le SDK et le NDK Android.

Et pour terminer, en passant par une tache Ant, le processus de compilation va se terminer et lancer (si besoin) l’installation sur le périphérique Android.

(more…)

Go to Top