[WP7] Des nouvelles de PointEmUp

Il y à quelques mois, je vous parlais de PointEmUp, un Shmup que je commençais à développer sur Windows Phone 7.

J’ai depuis bien avancé sur le projet, et je viens vous apporter quelques nouvelles.

Vaisseaux Ennemis

Look

Tout d’abord, j’ai choisit de générer aléatoirement les sprites des ennemis, pour donner à chacun un look unique. Pour cela, j’utilise pour chaque type de vaisseau une image spéciale, composée de 5 couleurs différentes : Chaque couleur permet au générateur de sprite de déterminer s’il doit dessiner une partie du vaisseau ou non.

Caractéristiques

J’ai décidé de créer une dizaine de vaisseaux ennemis différents. Chacun aura une couleur différente afin de pouvoir les identifier au premier coup d’œil.
Le jeu comporte pour l’instant trois types de vaisseaux ennemis. les bleus mitraillent leur bullets en direction du joueur, les gris tirent un cercle de bullets autour d’eux et les rouges tirent en spirale.

Le joueur

Armes du joueur

Je compte implémenter 6 armes différentes dans le jeu, possédant toutes une puissance et une vitesse différente. Je suis encore en train de déterminer la manière de changer d’arme, mais j’ai déjà une idée assez intéressante en tête. Pour l’instant, le jeu comporte les trois armes les plus basique d’un Shmup : de simple bullets, un laser dévastateur, et une bombe.

Déplacements

J’ai choisis d’utiliser la manière la plus simple et efficace pour gérer les déplacements du vaisseau du joueur : Suivre les mouvements du doigt.
Pour pouvoir déplacer le vaisseau, le joueur doit tout d’abord pointer une zone de l’écran, puis ensuite déplacer son doigt autour de cette zone pour déplacer le vaisseau. On retrouve la même manière de joueur dans Dodonpachi Resurrection sur Iphone

Score

Le système de scoring est toujours en cours de développement, j’ai décidé d’utiliser un système de combo et de multiplicateur de score. Plus vous tuez d’ennemis à la suite, plus votre multiplicateur augmente. Si vous ne tuez plus d’ennemis pendant quelques secondes, le multiplicateur retombe à zéro. Je compte également rajouter des points bonus à ramasser dans le niveau.

Niveaux

Je pense créer 5 niveaux d’une dizaine de minutes. J’ai choisi ici de dérouler les niveaux en utilisant un système de vague plutôt qu’une Timeline. Le joueur doit donc détruire tous les vaisseaux présent dans la scène avant de passer à la vague suivante. S’il n’y arrive pas, la vague disparait et le prive d’augmenter son score.

Avancement global

Le moteur du jeu est pratiquement terminé, il me reste à implémenter le système de score, de changement d’arme et de gestion des boss.
C’est au niveau du contenu du jeu qu’il reste le plus de travail : il faut rajouter plusieurs vaisseaux ennemis, plusieurs armes au jouer et terminer les 5 niveaux.
Enfin, il va me falloir encore pas mal de temps pour optimiser, passer du polish et tester le jeu.
Encore beaucoup de travail en perspective !

Game States Stack : Comment gérer simplement les états d’un jeu vidéo ?

Avant de débuter je tiens à préciser que ce petit tutoriel n’est en rien une solution miracle et adaptée à tous les projets. Gardez en tête en lisant ce tutoriel -et si possible quand vous lisez n’importe quel tutoriel- que les bonnes pratiques n’existent pas en programmation. Chaque code a ses avantages et ses inconvénients qui peuvent varier en fonction de la plateforme, les besoins des utilisateurs, les délais à respecter, etc… Le plus important, c’est que votre code fasse son boulot, et qu’il le fasse de manière efficace et performante.

Vous vous êtes peut être déjà demandés comment sont faits les jeux vidéos, quelles en sont les bases, et de quelles briques ils sont formés ? Je vais essayer de vous expliquer à travers cet article, et d’autres à venir, les rudiments à savoir pour commencer à développer votre propre jeu vidéo.

Notre premier article sera consacré aux Game States. Nous allons dans un premier temps essayer comprendre le principe d’état appliqué au jeu vidéo, puis nous verrons comment gérer ces différents états.

Qu’est ce qu’un Game State ?

Cette notion de game state peut paraître un peu abstraite lorsque l’on débute, mais elle est très simple. Les game states sont les différents états que va prendre votre jeu au cours d’une partie. Le joueur rencontrera dans une partie différents game states sans parfois s’en rendre compte. Le menu principal, une phase de jeu, une phase de combat à l’intérieur de la phase de jeu, une carte du monde, un menu de dialogue, le menu en jeu, la pause, l’écran des high scores sont autant de game states possibles.

Comment mettre en place la gestion des game states ?

Une des manière de gérer les game states assez populaire, et très simple à comprendre est celle de la Game State Stack.
Son principe est exactement calqué sur celui d’une Stack. Nous allons empiler nos différents états dans une stack, et nous mettrons à jour et afficherons l’état en tête de pile.

Pour gérer notre game state stack, nous allons utiliser trois méthodes : Add, Pop et Set.

Les méthodes Add (Push) et Pop sont directement inspirées des structures de données LIFO (ou Stack)

Schéma simplifié d'une pile LIFO

Add va nous permettre de rajouter un état dans la pile. Pop va nous permettre de retirer un état de la pile.
La méthode Set est simplement la combinaison de Pop et Add. On va tout d’abord appeler Pop et retirer l’état courant de la pile. Ensuite nous allons ajouter un nouvel état à la place de l’ancien.

Pourquoi différencier Add/Pop et set ? Afin d’être plus flexible. En effet, nous allons parfois vouloir simplement rajouter un état provisoirement puis reprendre l’état précédent sans aucune perte de donnée.

Schématisons tout cela. Prenons comme cas un jeu qui a pour états un menu principal, une phase de jeu, une pause, et un menu en jeu. Voila à quoi pourrait ressembler notre jeu :

Schéma simplifié des différents états d'un jeu

Comme vous pouvez le voir, nous avons utiliser différentes méthodes pour relier nos différents états.

Nous passons du menu principal à la phase de jeu grâce à la méthode Set. Nous passons le jeu en pause ou consultons le menu en jeu en utilisant la méthode Add, nous revenons au jeu avec la méthode Pop. Enfin, nous passons du menu en jeu au menu principal avec la méthode Set.

Pour être sûr de bien comprendre, nous allons voir le nombre d’états que nous aurons dans la game state stack pour chaque état :

  • Menu Principal : 1
  • Phase de Jeu : 1
  • Pause : 2
  • Menu en jeu : 2

Note : Quand nous allons passer du menu en jeu au menu principal, nous devrons veiller à bien détruire les deux states, sinon, nous aurons une fuite mémoire.

Passons au code !

Nous allons maintenant implémenter notre gestionnaire de Game State. J’ai choisit de vous présenter ici la manière la plus épurée possible.

La première étape consiste à créer une classe abstraite qui va représenter la base de nos états. Elle est composée des méthodes suivantes :

  • Initialize va nous permettre d’initialiser notre état. Elle sera appelée une seule fois quand l’état sera ajouté à la Game state stack.
  • Update va nous permettre de mettre à jour l’état. On lui a passé en paramètre un flottant qui représente le temps qui s’est écoulé depuis la précédente mise à jour.
  • Draw va nous permettre d’afficher l’état
  • Destroy enfin est facultative et nous permet de libérer les ressources allouée par l’état.

Voici le code :

// =============================================================================
/// Classe abstraite servant de base aux game states
// =============================================================================
public abstract class GameState
{
    // =========================================================================
    /// Initialise le game state
    // =========================================================================
    public abstract void Initialize();
 
    // =========================================================================
    /// Détruit le game state
    // =========================================================================
    public virtual void Destroy() {}
 
    // =========================================================================
    /// Met à jour le game state
    // =========================================================================
    public abstract void Update(float deltatime);
 
    // =========================================================================
    /// Affiche le game state
    // =========================================================================
    public abstract void Draw();
}

Maintenant, nous allons créer la classe GameStateStack qui va contenir les méthodes que nous avons vu plus haut : Set, Add et Pop. Nous allons également rajouter les méthodes Update et Draw qui vont nous permettre de mettre à jour et dessiner nos différents states.
Afin de stocker nos objets GameState, nous allons utiliser le type générique Stack<GameState>.

// =============================================================================
/// Game State Stack
// =============================================================================
public class GameStateStack
{
    // =========================================================================
    /// Remplace l'état courant par un nouvel état.
    /// S'il y a plusieurs états dans la stack, on les supprime tous
    // =========================================================================
    public void Set(GameState state)
    {
        while (States.Count > 0)
        {
            Pop();
        }
 
        Add(state);
    }
 
    // =========================================================================
    /// Initialize un état puis l'ajoute à la stack
    // =========================================================================
    public void Add(GameState state)
    {
        state.Initialize();
        States.Push(state);
    }
 
    // =========================================================================
    /// Supprime l'état courant de la stack
    // =========================================================================
    public void Pop()
    {
        if (States.Count > 0)
        {
            States.Peek().Destroy();
            States.Pop();
        }
    }
 
    // =========================================================================
    /// Met à jour l'état courant
    // =========================================================================
    public void Update(float deltatime)
    {
        if (States.Count > 0)
        {
            States.Peek().Update(deltatime);
        }
    }
 
    // =========================================================================
    /// Affiche l'état courant
    // =========================================================================
    public void Draw()
    {
        if (States.Count > 0)
        {
            States.Peek().Draw();
        }
    }
 
    // =========================================================================
    /// Stack de Game States
    // =========================================================================
    public Stack<GameState> States = new Stack<GameState>();
}

Si vous avez bien suivit, vous devriez retrouver ce que nous avons expliqué plus haut dans ce code. Add ajoute un state à la game state stack, pop supprime le state courant, et Set est une combinaison des deux méthodes précédentes.

Il ne vous reste plus qu’à implémenter vos GameState en héritant de la classe abstraite GameState.

Un exemple ?

Je vous ai préparé un petit exemple en utilisant XNA 4.0.Vous pouvez le télécharger en cliquant ici : GameStateStack

Avant de le lancer ou d’essayer de le compiler, voici deux prérequis :

Note : Le XNA Redistributable 4.0 est inclus dans les outils de développement, vous n’aurez pas besoin de l’installer si vous installez les outils de développement.

Pour aller plus loin.

Vous pourrez trouver une internet quelques autres exemples de Game State Management, dont deux particulièrement intéressant sur App Hub, la plateforme de Microsoft dédiée au développement XNA.

Game State Management : Qui vous présente une autre manière d’aborder le problème, et rajoute quelques spécificités comme les transitions entre états.

Network Game State Management : Cet exemple applique le concept aux jeux en réseau.

[.NET] Chip8DotNet : Un interpréteur Chip-8

Il y à quelques temps, je me suis intéressé à l’émulation, notamment de console de jeu, afin d’en comprendre le fonctionnement. A force de fouiller dans différentes documentation technique (Gameboy, NES, et autre consoles de mon enfance), j’ai fini par tomber sur quelques documents sur Chip-8.

Qu’est ce que c’est que Chip 8 ?

Chip-8 n’est pas à proprement parlé d’une console de jeu, il s’agit en fait d’un langage interprété, crée au milieu des années 70 afin d’être embarqué dans des micro-ordinateurs tels que le COSMAC VIP ou bien le Telmac 1800. Chip-8 a été développé afin de faciliter entre autre le développement de jeux vidéos tels que Pong sur ces machines.

Le micro-ordinateur Cosmac VIP

L’émulation, comment ça marche ?

L’émulation a pour but essentiellement de recréer virtuellement votre console de jeu ou un quelconque Hardware. Grossièrement, dans le cas de Chip-8, il m’a fallu, à l’aide d’une documentation technique, recréer morceau par morceau une sorte de Cosmac VIP virtuel afin qu’il puisse interpréter le langage Chip-8. Il y a bien entendu différentes façon de faire, qui dépendent essentiellement du hardware à émuler et du jeu ou logiciel à interpréter.

Pour créer mon émulateur, j’ai utilisé une documentation technique, il en existe plusieurs sur internet :

Et plus particulièrement cette page.

Ces documentations techniques sont essentielles pour créer l’émulateur, sans elles, rien n’est possible. En effets elles décrivent précisément comment interpréter chacune des instructions de Chip-8, comment afficher un sprite à l’écran, comment gérer les différents timers, les registres, etc… En gros, ces documentations vont devenir vos meilleures amies tout au long du développement de votre interpréteur.

Chip8DotNet ça ressemble à quoi ?

Chip8DotNet a été codé en utilisant le Framework .NET 2.0 et le langage C#. Il est théoriquement compatible sur la plupart des machines équipé de Windows, ainsi que sous Linux et Mac Os X grâce à Mono.

L’exécutable et le code source sont sous licence MIT et peuvent être téléchargés sur cette page : Chip8DotNet

Fenêtre principale de Chip8DotNet

Fenêtre principale de Chip8DotNet

Fenêtre de debug de Chip8DotNet

Fenêtre de debug de Chip8DotNet

Des mises à jour de prévue ?

Pour l’instant je ne sais pas si je vais retoucher à l’application, mais si cela me prend, je pense corriger quelques problèmes, comme la vitesse excessive, en la rendant paramétrable, régler quelques bugs que j’ai vu surgir en préparant cette note, et peut être même rajouter le support de SCHIP, qui est une extention de Chip-8 développé par un fan du langage dans les anneés 90.

Chip-8 est-il un langage d’avenir ?

Je ne crois pas. Cependant, certains fans ont développés depuis les dernières années de nombreuses applications, démos technique et jeux écris grace au langage, vous pouvez retrouvez de nombreux jeux et démos sur ces deux sites :

[WP7] Utiliser votre clavier avec le simulateur Windows Phone 7

N’ayant pas de device pour pouvoir tester mon Shoot Em Up en condition réelle, je dois simuler l’utilisation des accéléromètre avec mon clavier.

Sachant que XNA propose un ensemble de classe pour gérer un clavier, écrire le code est on ne peut plus simple. Il reste néanmoins un problème de taille : Faire en sorte que le simulateur WP7 soit relié à mon clavier.

Après quelques recherches, j’ai finit par trouver la réponse, et c’est on ne peut plus simple :

Après avoir démarré le simulateur WP7, cliquez sur l’écran du device afin d’avoir le focus et pressez la touche “Pause” de votre clavier. Si vous n’avez pas de touche pause sur votre clavier (Par exemple sur un laptop, ou un Mac) vous pouvez utiliser le clavier virtuel de windows :

Touche pause sur le clavier virtuel Windows

Vous pouvez maintenant utiliser votre clavier pour contrôler le WP7.

[WP7] PointEmUp : Un Shoot Em Up tactile !

Alors que le développement de Reckless Squad bat son plein, nous sommes plusieurs à D2P Games à commencer de nouveaux projets, soit dans le cadre de la société, soit pour s’amuser. Dernièrement, Dri a été plébiscité par la communauté de Games Creators Network lors des Novendiales avec son jeu Time Odyssey et semble ne pas vouloir s’arrêter là, et Daxou a déjà plusieurs idées.

Personnellement, je me suis lancé corps et âme dans le développement d’un Shoot Em Up pour Windows Phone 7. Mon but est de publier l’application sur le market place WP7. Mais je profite également d’une compétition organisé par Microsoft France afin de découvrir les prochaines killer apps du WP7.  En savoir plus sur le concours.

Pour développer ce jeu, j’utilise les outils fournit par Microsoft, à savoir Visual Studio 2010, et XNA Game Studio 4 for Windows Phone 7. Avec ce combo, je peux tester mon application sur un simulateur de WP7. Un peu à la manière de ce que l’on trouve pour le développement sur iPhone.

Comme le concours nécessite un temps de développement court, et que je développe pour l’instant sur mon temps libre, j’ai réfléchit à un concept simple et tout à fait adapté au WP7 :

Un Shoot Em Up tactile.

Impressionnant n’est-il pas ? 🙂 Afin de vous achever voici les deux fonctionnalités de base que je souhaite implémenter :

  • Utiliser l’écran tactile pour tirer des projectiles (le WP7 gère jusqu’à 4 points, je ne sais pas si je les utiliserai tous).
  • Utiliser les accéléromètre pour déplacer le vaisseau.

Mais ce n’est pas tout, je réfléchit à quelques fonctionnalités bonus, qui seront peut être dans l’application finale :

  • Utiliser le mode landscape du téléphone (lorsque vous le tournez pour que l’écran soit à l’horizontal) pour apporter un plus au jeu.
  • Créer un éditeur de niveaux intégré au jeu ou bien pour Windows. Et avoir la possibilité de partager ses niveaux (soit en exportant, soit sur un serveur web dédié)

Je n’ai pas encore fait de recherche graphique, mais comme je souhaite me focaliser sur le concept de base, je pense m’en occuper dans un second temps.

Actuellement, le développement en est à ses balbutiements, j’ai commencé à architecturer le projet en gardant en tête le support (Qui même s’il est performant reste un appareil mobile) et en le matchant au concept. J’aurai peut être l’occasion de vous reparler de l’architecture du projet dans un prochain article. En tout cas, l’utilisation de XNA facilite bien des choses.

Pour finir, voici la première image du jeu, ce n’est pas un triangle noir sur un fond noir, mais ce n’est guère plus impressionnant :

Première image de PointEmUp

Prochainement dans la todo list :

  • Gérer les états de jeu.
  • Implémenter les projectiles.
  • Implémenter un vaisseau pour le joueur qui se déplace au clavier
  • etc … 🙂

A la prochaine !

http://msdn.microsoft.com/fr-fr/isv/ff817766.aspx

Les béta-testeurs sont nos amis

S’il y a bien une chose que je sais après tout ces mois de développements sur Reckless Squad, c’est que les béta-testeurs sont nos amis les plus fidèles.

En effet, après des mois plongés dans du code, à sortir la tête que pour le casse croûte ou regarder la game de hockey à la TV, on finit par perdre beaucoup de reculs sur le projet.

Les deux semaines précédentes nous avons donc organisés nos premiers béta-tests en invitant la crème de la crème du monde vidéo ludique, c’est à dire nos camarades de classes. Il en est ressortit des kilos de ramette de papier remplis à ras bord d’annotations gribouillées au fil des parties de nos chers joueurs de l’extrême.

De tout cela, on retire énormément de feedback importants, venant de joueur de tout horizons, les experts de Starcraft et DOTA d’un côté, et leur manie de cliquer partout, et les joueurs de FPS de l’autre, qui ne comprennent rien au principe de RTS.

Nous en avons retiré assez d’information pour faire passer le jeu de bien à bon. Il ne nous reste plus qu’à mettre la main à la pâte, et à implémenter tout ça dans notre IDE préféré.

Quel beau métier. 🙂

On apprend de nos erreurs…

Si vous avez lu ce blog depuis son premier article -ce qui ne vous prendra pas tant de temps que cela- vous aurez remarqué que dans le cadre de D2P Games, nous avons travaillé sur au moins deux projets différents.

Bien que l’erreur la plus visible semble être le fait d’avoir annoncé ce sur quoi nous travaillions bien trop tôt, j’ai appris au fur et à mesure de nos expériences que ce n’était que la partie immergé de l’iceberg et qu’on aurait préféré le couler

Pour éviter des erreurs dans le futurs, nous avons choisit d’établir des règles afin de choisir le bon jeu sur lequel travailler. Ces règles, nous les avons empruntés à de grands créateurs qui n’hésitent pas à partager leur savoir faire dans des articles ou des interviews. Dri est d’ailleurs devenu un expert dans la recherche d’articles intéressants. Gamasutra est définitivement la source la plus prolifique. C’est sur Gamasutra d’ailleurs qu’est apparu aujourd’hui un article tout simplement excellent d’Edmund McMillen qui présente 24 commandements à suivre pour être un parfait créateur indépendant.

Grâce à ce travail de remise en question permanent, nous avons pu et dû changer ou mettre de côté plusieurs fois ce sur quoi nous travaillions. Bien entendu rien n’est perdu : plusieurs idées que nous avons eu ne sont pas mauvaises, mais nous avons été obligé des les abandonner car nous ne pouvions pas les concrétiser, soit par manque de temps, soit par manque de moyens.

Malgré toutes ces règles impitoyables,  nous avons finalement trouvé une idée qui corresponde à nos critères, et nous vous en reparlerons en temps voulu sur le site officiel ! 🙂

Création de D2P Games

Cela fait quelques jours déjà,  plus exactement depuis le 15 décembre, que mes collègues et moi avons créé la société D2P Games*.

Nous devenons ainsi officiellement créateur indépendants de jeux vidéos !

C’est une très grande étape pour nous, elle marque le début d’une grande aventure, qui je l’espère sera belle et trépidante !

Pour nous suivre, rien de plus simple, nous avons mit à votre disposition un site web, une page Facebook, et même un fil Tweeter.

Mon blog devrait repartir de plus belle, puisque je posterai dessus les traductions en français des articles postés sur le site officiel, ainsi que de nouveaux articles sur la création de jeux vidéo grâce à l’expérience que je vais acquérir tout au long des mois de création qui nous attendent.

Merci de nous suivre ! 🙂

* Petite anecdote : Au Québec, le nom de toutes les sociétés doit obligatoirement être traduit en français, notre société s’appelle donc à la fois D2P Games et à la fois Jeux D2P.

Premier projet de la D2P Team : Un Point&Click !

Après quelques brainstorming rondement menés, la D2P Team a enfin choisit ce sur quoi elle allait travailler dans les prochains mois. Le choix ne fût pas facile, nous étions même prêts à partir sur quelque chose de totalement opposé il y a quelques semaines…Finalement, tel un fil d’or sur une soupe de truffe, l’idée nous est venu : Un Point&Click !
Read more »

Quasi officialisation de la D2P Team

C’est un petit pas pour D2P, mais un grand pas pour l’humanité ! (oui rien que ça).

D2P c’est l’acronyme de Dax Dri Paul, un mélange de pseudos et prénoms de trois élèves en école informatique qui ont pour rêve de devenir créateurs de jeux vidéos. Plus ou moins organisés jusqu’à présent, nous avons voulu il y a peu concrétiser notre rêve. Aujourd’hui une des toutes premières étapes vient d’etre franchie.

Read more »