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 !

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 :

• Pour lancer l’exécutable, vous devez posséder le XNA Redistributable 4.0.
• Pour compiler la solution, vous devez installer les outils de développement XNA 4.0, disponibles à cette adresse : http://create.msdn.com/en-us/home/getting_started

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.

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 :

• http://devernay.free.fr/hacks/chip8/
• http://howtoemulation.netfirms.com/extra_pages/chip8.shtml
• http://users.skynet.be/drealmer/chip8/

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 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 :

• http://www.chip8.com
• http://www.revival-studios.com/

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.

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 !

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.

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 !

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.

Si vous avez suivi ce blog ou celui d’Aranoth/Dri récemment, quelque chose a du vous faire réagir dans l’extrait de cette note. En effet, il y a quelques semaines, nous vous annoncions que nous étions en train de commencer à travailler sur un jeu Web, et plus précisément un Shoot’em up. Seulement un soir, après avoir été faire ma prière devant le site officiel de Tales of Monkey Island, une idée m’est venu.

Tales of Monkey Island par Telltale Games

Je ne pensais pas alors qu’en postant un petit descriptif de 3 lignes dans notre boite à idée, l’équipe serait aussi enthousiaste. Finalement, après quelques discussions, nous abandonnions le Shoot’em up pour nous lancer sur les voies du Point&Click !

Un choix que beaucoup ne jugeraient pas judicieux, mais qui me paraît être un des plus intéressants à l’heure actuelle. En effet, il est coutume de nos jours de faire passer le visuel avant l’interaction et de titiller d’avantage les réflexes du joueur plutôt que de faire travailler sa réflexion et de l’impliquer dans l’action.

L’avantage du Point&Click est qu’il est basé sur l’interaction : Pour avancer dans l’histoire, le joueur doit utiliser donner des ordres à son personnage à l’aide d’une liste de verbes (Marcher, Prendre, Utiliser, Parler…). Il n’est plus question de progresser grâce aux nombres de plombs que nous plaçons entre les deux yeux d’un monstre, mais grâce aux actions que le joueur semble judicieuses. Bien entendu, l’essentiel des P&C d’hier et d’aujourd’hui sont “scriptés”, ils ne laissent pas place à de nombreuses libertés, peut-être que nous travaillerons dans le futur à changer cet état de fait !

Sam & Max par Telltale Games

Après ce constat, je vais vous parler très brièvement de ce sur quoi nous nous lançons. Le but était de créer une œuvre originale à partir d’un Gameplay rodé. L’idée que j’ai présenté était très simple, mélanger “l’école Américaine” du P&C (Lucas Arts, Sierra, Telltale Games) avec “l’école Japonaise” du Visual Novel. Grâce à ce mélange hétéroclite, nous pouvons combler les lacunes de chacun des styles.

D’un côté le P&C n’a jamais touché à l’univers Manga/Animé, il s’est toujours développé autour d’un univers et d’une vision très occidentale du monde, cela m’a parut assez aberrant tant la mise en scène et le Gameplay me paraissent excellent.

De l’autre côté, j’ai toujours trouvé que le Visual Novel manquait de profondeur, les décors sont souvent plats et la plupart du temps masqués par des personnages apparaissant au premier plan (Voir Phoenix Wright). 

Professeur Layton et l'étrange village par Level-5

Un autre défaut du Visual Novel est la façon dont le joueur interagit avec le jeu. Dans la plupart des VN, le joueur doit seulement pointer les éléments qui paraissent important à l’écran (Professeur Layton ou Phoenix Wright). Je trouve dommage de limiter le Gameplay du jeu à un détournement de “Ou est Charlie“. Néanmoins, les Visual Novel possèdent un atout important, leur style graphique et narratif : un concentré de culture Asiatique !

Phoenix Wright : Ace Attorney par Capcom

Vous l’aurez peut être comprit, notre but va être d’appliquer les codes du P&C à un univers Japonais, dans un style (graphique et narratif) très Manga/Anime.

Pour l’instant, vous n’en saurez pas plus, je n’ai pas beaucoup de détail supplémentaires à vous donner. Néanmoins, à chaque palier que nous franchirons dans le développement du jeu, vous en serez les premiers informés au travers de ce blog ! D’ici là, si vous avez des questions à propos du projet, je vous répondrai avec plaisir

Bon jeu !

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.

Depuis hier nous avons en effet ouvert un dépôt SVN dédié à la création de jeux à but lucratif. Alors oui pour l’instant c’est une étape plutôt anecdotique, mais c’est quand même le tremplin que j’attendais.

Pour débuter sur de bonnes bases, nous sommes dors et déjà en train de développer les outils nécessaire à la création de nos futurs jeux, et en particulier Dri qui travail sur plusieurs choses totalement énorme. L’un des outils dont nous allons sans doute nous servir en premier s’appelle Uniscript. Sans entrer dans les détails, c’est un langage de script interprété crée de A à Z par Dri, et qui va nous permettre -entre autres choses- de créer des jeux portables sur plusieurs plateforme et technologies.

Notre premier projet quant à lui sera un jeu web, qui va nous permettre d’une part d’améliorer Uniscript, et d’autre part de nous familiariser avec le business du jeu vidéo. Nous ne prenons pas les choses à la légère, nous partons avec un investissement faible, nous nous devons donc de faire les choses à la perfection afin de paraître crédible. Business Plan, Outils Adapté, Game Design Documents Clairs, Cahiers des charges, voila une partie de ce qui nous attend avant de démarrer le développement de notre premier jeu.

Si tout va bien, nous publierons le premier jeu estampillé D2P d’ici l’année prochaine. Gardez l’œil ouvert !