Jump to content

  • Log In with Google      Sign In   
  • Create Account

Le Journal de Yahiko



Développer son premier jeu Web (partie 2)

Posted by , in Développement 17 September 2013 - - - - - - · 696 views

Introduction au langage TypeScript

Prérequis :
  • Connaissance des principes de bases de la programmation orientée objet
  • Connaissance des principes de bases de Javascript
  • Compilateur TypeScript installé

(0.1)

Sommaire :
  • Introduction
  • Typage
  • Classe
  • Fonction anonyme fléchée
  • Modularité
  • Conclusion

(0.2)

1. Introduction
Cet article est une présentation succincte des principaux apports de TypeScript que sont le typage, les classes, les fonctions anonymes "fléchées" et la modularité. L'installation proprement dite du compilateur TypeScript est décrite dans l'article suivant : Développer son premier jeu Web (partie 1).

Il convient également de rappeler que le langage TypeScript est avant tout du Javascript amélioré ce qui permet la réutilisation de ses connaissances en Javascript. Il faut en effet avoir conscience que les limitations intrinsèques de Javascript se reflètent également dans TypeScript. Par exemple, la notion d'attributs privés d'une classe qui existe dans la plupart des langages orientés objets, bien que syntaxiquement présente dans TypeScript, n'est pas restrictive mais uniquement indicative dans la mesure où un attribut privé pourra malgré tout être utilisé en dehors de sa classe.

La spécification complète du langage TypeScript est disponible sur le site officiel.


2. Typage

Le principal apport du langage TypeScript, celui qui justifie le nom même du langage, est la possibilité d'associer, facultativement, un type à une donnée.






var pi: number;
var message: string;
var flag: boolean;
var joker: any;

(2.1)

Dans l'exemple ci-dessus, quatre variables sont déclarées sans être initialisées à l'aide d'un type dont la signification est explicite.
  • La variable pi a pour type number, un nombre entier ou flottant.
  • La variable message a pour type string, une chaine de caractères.
  • La variable flag a pour type boolean, un booléen qui peut prendre la valeur true ou false.
  • La variable joker a pour type any, qui est le type par défaut qu'attribut TypeScript à une variable s'il ne parvient pas à déterminer son type lors de sa déclaration.

(2.2)

Bien entendu, il est possible d'initialiser une variable au moment de sa déclaration comme on peut le voir ci-dessous.

var pi: number = 3.14;
var message: string = "Bonjour !";
var flag: boolean = true;
var joker: any = null;

(2.3)

Bien que la mention explicite du type soit recommandée, en l'absence de celui-ci lors de la première initialisation d'une variable, TypeScript en infère automatiquement le type.

A noter que TypeScript, contrairement à Javascript, peut ainsi être considéré comme un langage à typage statique.


3. Classe

La notion de classe introduite dans TypeScript anticipe la prochaine évolution de Javascript (ECMAScript 6).
class Greeter {
    element: HTMLElement;
    span: HTMLElement;
    timerToken: number;

    constructor(element: HTMLElement) {
        this.element = element;
        this.element.innerHTML += "The time is: ";
        this.span = document.createElement('span');
        this.element.appendChild(this.span);
        this.span.innerText = new Date().toUTCString();
    }

    start() {
        this.timerToken = setInterval(() => this.span.innerHTML = new Date().toUTCString(), 500);
    }

    stop() {
        clearTimeout(this.timerToken);
    }

}

window.onload = () => {
    var el = document.getElementById('content');
    var greeter = new Greeter(el);
    greeter.start();
};

(3.1)

Comme on peut le voir dans l'exemple ci-dessus, une classe Greeter y est définie d'une façon proche de la plupart des langages orientés objet.

La classe Greeter possède ici trois attributs (element, span et timerToken), défini un constructeur (constructor) et deux méthodes (start et stop). Son instanciation se fait à l'aide de l'opérateur new comme on peut le voir à la fin de l'exemple précédent.
var greeter = new Greeter(el);

(3.2)

De pair avec la notion de classe, TypeScript implémente la notion d'héritage simple par l'utilisation du mot-clé extends.
L'extension de la classe Greeter de l'exemple précédent pourrait se faire ainsi :
class GreeterId extends Greeter {
  id: string;
  constructor(element: HTMLElement, id: string) {
    super(element);
    
    this.id = id;
  }
}

(3.3)

Cette nouvelle classe GreeterId se contente d'ajouter un nouvel attribut id à la classe Greeter.

Toutes les classes définies dans TypeScript peuvent ensuite être considérées comme des nouveaux types.


4. Fonction anonyme fléchée

Un autre apport notable de TypeScript à Javascript est sa nouvelle manière de définir une fonction anonyme. Comme celle présente à l'intérieur de la méthode start en paramètre à l'appel de setInterval et qui peut être dénommée ici notation "fléchée" (arrow function).
this.timerToken = setInterval(() => this.span.innerHTML = new Date().toUTCString(), 500);

(4.1)

L'avantage par rapport à l'actuelle norme de Javascript (ECMAScript 5), est que la notation fléchée ne change pas la valeur de contexte du mot-clé this à l'intérieur de la fonction anonyme. Cela évite donc l'utilisation d'une variable intermédiaire servant à propager la valeur de this à l'intérieur de la fonction anonyme. Par exemple, la ligne de code précédente aurait pu être transcrite ainsi en Javascript actuel :
var _this = this;
this.timerToken = setInterval(function () {
    return _this.span.innerHTML = new Date().toUTCString();
}, 500);

(4.2)

Cette la nouvelle notation plus concise sera utile en particulier pour les fonctions callback.


5. Modularité

TypeScript introduit de nouvelles techniques de modularisation devenues nécessaires par le typage statique et par l'héritage de classes.
Parmi ces techniques de modularisation, le référencement d'un fichier TypeScript externe est peut-être la plus simple.
Elle consiste à ajouter en tout début de fichier, le source TypeScript externe contenant des déclarations nécessaire au compilateur afin qu'il en déduise entre autre les types et les héritages.
/// <reference path="Externe.ts"/>

(5.1)

A noter que cela ressemble un peu aux #include des langages C/C++.


6. Conclusion

Cette présentation est évidemment loin d'être complète. Pour se familiariser avec TypeScript, il peut être utile d'utiliser la page de test afin de voir instantanément la conversion d'un code TypeScript en un code Javascript. Sinon, la spécification, malheureusement non traduite en français, reste indispensable pour approfondir le sujet.

En espérant que cet article vous aura été utile.


Développer son premier jeu Web (partie 1)

Posted by , in Développement 18 August 2013 - - - - - - · 743 views
développement, jeux, typescript and 5 more...
Mise en place de l'environnement de travail

Prérequis :
  • Windows XP ou supérieur
  • 2,5 Go d'espace disque dur

(0.1)

Sommaire :
  • Introduction
  • Choix du langage et de la plateforme
  • Visual Studio Express 2012 for Web
  • TypeScript
  • Création du premier projet
  • jQuery
  • Git for Windows
  • Personnalisation de Visual Studio
  • L'alternative Notepad++
  • Conclusion

(0.2)


1. Introduction
Quand on souhaite développer un jeu en tant qu'amateur, tout débute souvent par une idée originale ou simplement une envie venue à maturité qui nous pousse à franchir le pas et à nous lancer dans un projet de développement. Cependant, passé cette première étape, la réalité du concret reprend ses droits et on se pose fatalement de nombreuses questions : choix du langage, choix de la plateforme, choix des bibliothèques logicielles ou du moteur de jeux, etc. On peut se sentir assez facilement perdu, et à raison, tant ce n'est pas le manque d'innovations qui guettent l'industrie du logiciel de nos jours.

C'est pourquoi, après avoir moi-même tâtonné longtemps à chercher des outils et des solutions, cet article se veut une petite introduction pour partir sur des bases suffisamment stables dans un projet de développement qui comportera suffisamment de problèmes pour ne pas perdre inutilement du temps sur des questions de simple organisation mais qui ont leur importance si elles ne sont pas prises en compte.


2. Choix du langage et de la plateforme
Choisir une technologie plutôt qu'une autre est toujours matière à débats et à controverses. Ici, nous ne chercherons pas à justifier par A+B les choix faits, l'important étant d'obtenir au final un jeu qui fonctionne dans un délai raisonnable.

Nous opterons dans le cadre de cette discussion pour la plateforme Web, à savoir les principaux navigateurs du marché. Cela aura l'avantage d'avoir un jeu qui pourra tourner sur de nombreuses architectures techniques (Windows, Linux, Mac, Android, iOs, etc.) sans retoucher à la moindre ligne de code. Concernant le langage de nombreux choix sont possibles comme les moteurs de jeu tel Unity ou Unreal Engine, mais même si ces derniers sont reconnus actuellement dans le domaine des jeux vidéo, il n'en est pas de même dans l'industrie du logiciel prise dans son ensemble.

Nous partirons du postulat que parmi les motivations à développer un jeu, on peut trouver celle de vouloir apprendre ou se perfectionner dans l'activité même du développement pour un usage généraliste. C'est la raison pour laquelle choisir un moteur de jeux propriétaire ne nous aidera pas forcément à acquérir des connaissances utiles dans le monde de l'entreprise, qui recherche plus des compétences sur l'informatique de gestion.

Pour un jeu Web, si nous excluons donc les moteurs de jeux (et à fortiori les outils de création de jeux comme Game Maker ou RPG Maker) pour une raison de ré employabilité des connaissances ainsi apprises à travers un tel projet, un langage comme Javascript vient immédiatement à l'esprit, et à juste titre.

Javascript qui a connu une montée en puissance ces dernières années grâce aux travaux de normalisations du HTML et des CSS, est actuellement la pierre angulaire du Web dynamique. Tout ou presque est possible avec Javascript. Pour s'en convaincre, j'invite les lecteurs à consulter le projet Epic Citadel et ce qui se fait autour des technologies Emscripten et Asm.js.

Néanmoins, malgré un Javascript pratiquement incontournable dès qu'une application concerne le Web, traîne encore l'héritage de son passé. Jadis conçu pour apporter une petite dose d'intelligence à des sites Web sous la forme de quelques lignes de codes, ce sont aujourd'hui des applications de plusieurs dizaines, voire centaines de milliers de lignes qui sont écrites en Javascript. Ce qui pose quelques problèmes de débogage à cause entre autre de son typage dynamique et aussi des problèmes d'architecture logicielle par l'absence de réelle notion de Programmation Orientée Objet, remplacée dans Javascript par la notion puissante de prototype, mais néanmoins différente.

Ceci étant dit, même si notre projet ne sera pas un monstre d'ingénierie logicielle, il y a fort à parier qu'il dépassera la dizaine de milliers de ligne de code (en comptant les commentaires). Ce qui risque de poser un petit souci de confiance envers le code produit ainsi que des dizaines et des dizaines d'heures perdues à debugger une erreur qui aurait été détectée à la compilation dans un langage de type C/C++.

Il existe actuellement deux principales alternatives intéressantes au Javascript pur qui sont CoffeScript et TypeScript. Ce sont tous deux des langages qui permettent de compiler le code source, typé et orienté objet, vers du Javascript, permettant ainsi de retomber sur nos pieds avec un code résultant en Javascript, interprétable sur tous les navigateurs.

Sans rentrer dans une guerre de religion pour l'un ou pour l'autre, nous choisirons ici le langage TypeScript qui est certain un peu moins mature que CoffeScript, mais a pour avantage d'être un sur-ensemble de Javascript (autrement dit, du code Javascript natif est directement reconnu sous TypeScript, ce qui n'est pas le cas de CoffeScript), c'est un projet Open Source dont le code est accessible à tous, et a été créé par le papa de C# qui travaille chez Microsoft ce qui est un gage de sérieux quoiqu'on en dise.

Le principal défaut de TypeScript est sa relative jeunesse, puisque le langage est toujours au stade de développement, même si une version de production est prévue d'ici la fin de l'année, ce qui restreint à l'heure actuelle les outils prenant en charge ce nouveau langage qui reste néanmoins promis à se pérenniser.

Pour tirer pleinement parti des possibilités de ce langage, papa de C# oblige, il nous faudra installer Visual Studio si vous ne l'avez pas déjà.


3. Visual Studio Express 2012 for Web

Visual Studio est un environnement de développement intégré (IDE) très populaire mis au point par Microsoft qui supporte nativement les principaux langages de l'éditeur (C#, ASP, J#) ainsi que le Javascript. Ce logiciel est payant et relativement onéreux pour une activité en amateur, mais heureusement il existe une version gratuite, Visual Studio Express, qui est cependant bridée avec notamment une restriction à un seul langage et une limitation dans l'ajout de modules complémentaires. Malgré tout, cela sera amplement suffisant pour nos besoins.

Il est recommandé de faire attention à bien télécharger la version anglaise et non pas française de Visual Studio, du fait d'un bug sur la localisation de la dernière version de TypeScript 0.9.1.

Téléchargez Visual Studio Express 2012 for Web - English

Ceci téléchargera l'image ISO de Visual Studio Express 2012 for Web - English, et pour lancer l'installation proprement dire, il vous faudra soit graver sur un CD ou bien utiliser un logiciel de virtualisation tel Virtual Clone Drive dont on pourra trouver des tutoriels sur la toile tel que celui-ci.

A noter aussi que l'installation nécessite plus de 2 Go d'espace libre sur votre disque dur.

Laissez-vous guider par la procédure d'installation, simple mais assez longue, en restant sur les choix par défaut.


4. TypeScript

Une fois Visual Studio Express 2012 for Web installé, ainsi que les mises à jour de base et l'obtention d'une clé d'enregistrement pour usage privé, nous pouvons installer TypeScript.

Pour rappel, TypeScript est un langage fortement typé avec une syntaxe orientée-objet plus conventionnelle que celle du Javascript, et qui permet de générer au final du Javascript afin d'être interprété par tous les navigateurs.

L'avantage de ce langage réside en partie sur le fait que c'est un sur-ensemble du Javascript et ce qui lui permet d'accepter nativement n'importe quel code Javascript.

Téléchargez le plugin TypeScript 0.9.1 pour Visual Studio

A noter que si vous avez installé une version différente que la version anglaise de Visual Studio Express 2012 for Web, alors le plugin de TypeScript ne fonctionnera pas.


5. Création du premier projet

Armés désormais de Visual Studio et de son plugin TypeScript, nous voilà prêt pour créer notre projet dans l'outil de développement.

Il faut tout d'abord savoir que Visual Studio fait une distinction logique entre la notion globale de solution et celle de projets qui sont des composants d'une solution. Tout au long de ce guide, le mot projet en italique, désignera la notion spécifique à Visual Studio, tandis que le mot projet sans mise en forme en italique désignera la définition du langage courant, à savoir développer un jeu vidéo. La notion de solution est pour le moment facultative, car étant surtout nécessaire dans le cadre de grandes applications d'entreprise.

Pour créer un projet, cliquez sur le menu FILE > New Project, ou bien appuyez sur CTRL + MAJ + N. Une fenêtre de dialogue telle que ci-dessous devrait apparaître :

Posted Image

(5.1)

Puis saisissez les informations nécessaires dans les champs suivants :
Projet : PremierJeuVideo
Location : C:/Users/VotreCompte/Dev

Si vous n'avez pas de sous-répertoire Dev dans votre répertoire utilisateur dédié, je suppose que vous ne vous êtes pas connecté en Administrateur, alors Visual Studio le créera pour vous.

Veillez aussi à ce que l'option Create directory for solution soit décoché afin d'éviter de rajouter un niveau d'arborescence inutile.

Une fois la fenêtre de création de projet validée, vous pouvez ignorer la fenêtre suivante à propos du Team Foundation Server. Cela peut être éventuellement utile dans le cadre d'un projet en équipe, mais je suppose aussi que vous réalisez votre projet en solo.

Nous allons maintenant mettre en place une arborescence type qui nous permettra de ranger les multiples fichiers qui seront impliqués pour ce projet. Le but est au final d'obtenir l'arborescence minimale suivante :
PremierJeuVideo
  \-- art
  |     \-- interface
  |     \-- sounds
  +-- doc
  |     \-- private
  |     \-- public
  \-- lib
  \-- src
  \-- tools

(5.2)

Voici un rapide descriptif des répertoires de cette arborescence :
  • art : ensemble des éléments artistiques du projet
  • art/interface : ensemble des éléments d'interface utilisateur
  • art/sounds : musiques et bruitages
  • doc : documentation du projet
  • doc/private : documentation interne
  • doc/public : documentation utilisateur
  • lib : bibliothèques Javascript personnalisée
  • src : sous-projets contenant les fichiers sources
  • tools : utilitaires divers facilitant la gestion du projet

(5.3)

Il est entendu que cette arborescence n'est pas complète. Elle sera complétée au fil des développements, notamment le répertoire "src" pour le moment vide.

La création de cette arborescence peut se faire à travers le panneau Solution Explorer qui devrait apparaître par défaut à droite.


Posted Image

(5.4)

A l'aide d'un clic droit sur l'élément PremierJeuVideo désignant la racine du projet, un menu contextuel devrait apparaître où vous pouvez choisir l'option Add > New Folder. De cette façon vous pourrez créer simplement l'arborescence du projet au sein de Visual Studio.


6. jQuery

S'il y a un framework incontournable pour qui veut développer en Javascript, c'est bien jQuery développé et maintenu par Google.

Néanmoins, pour l'intégrer à nos développements TypeScript, il convient de générer un fichier d'interfaçage pour TypeScript afin que le compilateur puisse vérifier le typage de votre code utilisant jQuery.

Pour récupérer en local le framework jQuery ainsi que le fichier d'interfaçage TypeScript, c'est très simple, il suffit d'utiliser le module NuGet intégré à Visual Studio. Pour cela, dans le panneau Solution Explorer comme dans le paragraphe précédent, cliquez droit sur l'élément racine du projet PremierJeuVideo puis cliquez sur l'option Manage NuGet Packages.

Après une phase de chargement, voici le type d'écran qui devrait s'afficher :


Posted Image

(6.1)

Le package jQuery devrait arriver en tête de liste. Si ce n'est pas le cas, vous pouvez le rechercher à l'aide de la zone de recherche en haut à droite. Cliquez sur le bouton Install.

En l'état, jQuery est opérationnel pour qui veut programmer en Javascript, mais comme dit précédemment, il a besoin d'un complément pour que TypeScript puisse l'exploiter.

Dans le champ de saisie de recherche en haut à droite, tapez : jquery.Typescript.DefinitelyTyped

Puis cliquez sur le bouton Install sur l'élément correspondant à notre recherche (en principe le premier) dans la zone principale de la fenêtre

A l'issue de cette étape, nous venons d'installer avec succès jQuery pour TypeScript.


7. Git for Windows

Un cycle de développement n'est jamais linéaire et gérer manuellement les versions de ses fichiers sources quand ceux-ci se multiplient peut se révéler un véritable casse-tête.

Pour répondre à ce problème aussi ancien que la programmation, les développeurs ont mis au point des outils pour gérer les modifications apportées aux fichiers sources. Il en existe de nombreux qui se regroupent sous l'appellation CVS (Control Version System). Nous utiliserons l'un d'entre eux qui se nomme Git for Windows qui a l'avantage d'être simple à utiliser et compatible avec la solution d'hébergement de sources en ligne GitHub.

Téléchargez Git for Windows

Lors de l'installation, il est recommandé de laisser toutes les options par défaut.

Une fois installé, nous allons indiquer à Git d'utiliser le répertoire de la solution précédemment créée avec Visual Studio en cliquant sur l'option Créer un nouveau dépôt.

Dans la zone de saisie, tapez le répertoire du projet que vous avez créé avec Visual Studio précédemment : C:/Users/VotreCompte/Dev/PremierJeuVideo



Posted Image

(7.1)

Indiquons maintenant à Git de suivre les modifications de tous les fichiers du projet en les sélectionnant tout d'abord :
  • mettre en surbrillance le tout premier élément de la liste en haut à gauche,
  • faire défiler l'ascenseur pour parvenir tout en bas,
  • maintenir la touche MAJ et cliquer sur le dernier élément.

(7.2)

Une fois tous les fichiers sélectionnés, nous pouvons en demander l'indexation de trois façons :
  • En sélectionner dans le menu Commit > Indexer
  • En cliquant sur le bouton Indexer modifs.
  • En tapant sur CTRL + T.

(7.3)

Si une boite de dialogue apparaît pour avertir qu'un nombre important de fichiers sont sur le point d'être indexés
Si une boite de dialogue apparaît pour vous demander de réaliser une conversion de retour chariot, accepter la conversion en cliquant sur le bouton Continuer.

Désormais, tous les fichiers qui se trouvaient dans le panneau des Modifs non indexées en haut à gauche, devraient apparaitre maintenant dans le panneau des Modifs indexées (pour commit) en bas à gauche.

Dans la zone de saisie inférieure, correspondant à la description de vos modifications, tapons le texte "Initialisation", et cliquons sur le bouton Commiter.

Nous venons ainsi de créer le dépôt de suivi des changements de notre projet dans Git ce qui sera très utile lorsque vous souhaiterez revenir sur une ou plusieurs modifications malencontreuses.

Nous pouvons apporter un petit raffinement à notre suivi des changements dans la mesure où certains fichiers sont générés et modifiés automatiquement par Visual Studio comme les fichiers internes de Visual Studio pour gérer le projet, ou bien les fichiers de travail qui seront générés lors des compilations. A l'aide d'un éditeur de texte, dans le répertoire du projet, ici en l'occurrence C:\Users\VotreCompte\Dev\PremierJeuVideo\, créez un fichier dénommé .gitignore avec le contenu suivant :
.gitignore:
pakages.config
*.csproj
*.csproj.user
*.sln
*.suo
bin/
obj/

(7.4)


8. Personnalisation de Visual Studio

Visual Studio y compris dans son édition Express est un outil très puissant. Néanmoins, cela ne l'exonère pas de quelques lacunes qu'il est possible de combler à l'aide d'outils externes.

Il sera par exemple utile de pouvoir compiler indépendamment du reste du projet un seul fichier TypeScript, notamment pour des raisons de rapidité. Tout comme il peut être intéressant d'appeler Git for Windows sans quitter Visual Studio.

On peut rajouter un appel à ces deux outils simplement en cliquant sur le menu TOOLS > External Tools.


Posted Image

(8.1)

Si vous avez laissé les options par défaut durant l'installation de ces deux outils, voici les paramètres à saisir pour ces deux outils.

Paramètres pour TypeScript
  • Title: TypeScript
  • Command: C:\Program Files\Microsoft SDKs\TypeScript\tsc.exe
  • Arguments: $(ItemPath)
  • Initial directory: $(ItemDir)

(8.2)

Paramètres pour Git for Windows
  • Title: Git for Windows
  • Command: C:\Program Files\Git\bin\wish.exe
  • Arguments: "C:\Program Files\Git\libexec\git-core\git-gui"
  • Initial directory: $(SolutionDir)

(8.3)


9. L'alternative Notepad++

Si vous êtes allergique à Visual Studio et sa consommation de mémoire vie de plusieurs centaines de Mo, vous pouvez vous rabattre sur des éditeurs plus simples et moins gourmands en ressources machine.

Si vous êtes sur le système d'exploitation Windows, il existe une solution open source qui a fait ses preuves : Notepad++

En plus d'être à la base un éditeur de texte très puissant, il s'est vu rajouter de nombreuses fonctionnalités au fil du temps faisant de lui un outsider non négligeable par rapport à des solutions commerciales dans le domaine du développement logiciel.

Même si vous ne comptez pas programmer votre jeu avec Notepad++, je vous recommande néanmoins de l'installer pour tous les services qu'il pourra vous rendre comme la conversion des fichiers en UTF8 et ses plugins de formatage de fichiers XML.

Téléchargez Notepad++

Une fois Notepad++ installé puis lancé, configurons-le pour en faire un environnement TypeScript friendly.

Encodage
Le compilateur TypeScript dans sa version 0.9 n'accepte plus que les fichiers encodés en UTF-8. Pour éviter de se retrouver devant de mystérieuses erreurs d'inclusion de fichiers, activons d'emblée le mode UTF-8 par défaut. Pour cela, cliquez sur le menu Paramétrage > Préférences > Nouveau document. Sélectionnez la troisième option, UTF-8.

Auto complétion
L'auto complétion est une fonction dans un environnement de développement qui permet d'accélérer sensiblement la saisie à partir des premiers caractères en se basant sur l'ensemble des variables, des fonctions et autres identificateurs déjà déclarés dans le projet, tout en filtrant les possibilités en fonction du contexte de la saisie (eg. seuls les attributs de l'objet courant seront pris en compte).

Notepad ne permet pas d'aller jusqu'à ce raffinement, mais permet tout de même de proposer une liste de l'ensemble des mots déjà présent dans un fichier source. Pour activer cette possibilité, il faut cliquer sur le menu Paramétrage > Préférences > Auto complétion, puis sélectionnez les options suivantes :
  • Activer la complétion automatique > Complétion de mot
  • Paramètres affichés durant la saisie
  • A partir du 2 è caractère

(9.1)

Coloration syntaxique
Bien qu'il n'existe pas à ma connaissance de fichier de définition de coloration syntaxique pour TypeScript, nous pouvons utiliser une possibilité bien pratique offerte par Notepad++, à savoir la possibilité d'étendre la coloration syntaxique d'un langage déjà défini.

Pour cela cliquez sur le menu Paramétrage > Configurateur de coloration syntaxique.


http://imageshack.com/scaled/large/41/sqo1.png

(9.2)

Tout d'abord, vous pouvez si vous le souhaitez changer ici le thème de votre éditeur. Certains développeurs préfèrent non sans raison un fond moins vif que le blanc brillant par défaut, mais cela reste avant tout une histoire de goûts personnels.

Dans la première liste de gauche, recherchez et sélectionnez l'élément Javascript.
Dans la deuxième liste, sélectionnez l'élément KEYWORD.

Dans la zone de saisie en bas dénommée Ext. utilisateur, saisissez ts qui est l'extension des fichiers TypeScript.

Enfin, dans la zone de saisie tout à droite dénommée Mots-clés utilisateur, saisissez les uns à la suite des autres, les mots suivants :
any boolean class constructor declare enum export extends implements import interface module number public private require static string super

Il existe de nombreux plugins pour Notepad++. Parmi eux, deux seront indispensables à notre situation :
  • NppExec
  • XML Tools

(9.3)

Pour vérifier si ces deux plugins sont installés ou non, il suffit de cliquer sur le menu Compléments et de rechercher ces deux noms. Si au moins l'un des deux manque à l'appel, pas de souci, l'installation d'un plugin est très simple grâce à un autre plugin qui est livré par défaut avec l'outil, à savoir Plugin Manager qu'on peut retrouver également dans ce menu Compléments.

Plugin Manager un petit module qui permet de rechercher l'ensemble des plugins disponibles et de les installer. C'est en quelque sorte l'équivalent de NuGet sous Visual Studio.

Une fois ces deux plugins d'installés, et surtout NppExec, nous pourrons définir les commandes prédéfinies suivantes :
  • TypeScript
  • Git for Windows

(9.4)

La procédure de définition est identique pour ces trois commandes, seule le script d'exécution varie. Cette procédure est la suivante :
1. Cliquez sur le menu Compléments > NppExec > Execute, ou appuyer sur la touche F6.
2. Dans la zone de saisie, tapez le script de la commande
3. Cliquer sur le bouton Save
4. Donner un nom à votre commande
5. Cliquez sur le menu Compléments > NppExec > Advanced Options. Dans la boite de dialogue qui s'affiche, seule la zone Menu Item est vraiment importante.
6. Dans le champ de saisie Item name, taper le nom de votre commande.
7. Dans le menu déroulant Associated script qui se trouve juste en dessous, choisissez la commande souhaitée puis valider en cliquant sur le bouton OK.


http://imageshack.com/scaled/large/812/j3lq.png

(9.5)

Script de commande TypeScript
cd "$(CURRENT_DIRECTORY)"
tsc.exe "$(FILE_NAME)"

Script de commande Git for Windows
"C:\Program Files\Git\bin\wish.exe" "C:\Program Files\Git\libexec\git-core\git-gui"

Après, rien ne vous empêche d'ajouter les commandes de votre choix comme make/jake, node.js et bien d'autres, mais cela dépasserait sans doute le cadre de ce guide.


10. Conclusion

Comme nous venons de le voir, l'installation d'un environnement de développement en TypeScript n'est pas très compliquée, mais n'est pas si triviale non plus lorsqu'on démarre de rien, ce qui est souvent le cas quand on débute dans le développement.

Tout ce qui est décrit dans cet article est absolument facultatif. En effet, il est tout à fait possible de réaliser un projet sans mettre en place toute cette logistique, mais tôt ou tard, à mesure de la complexification de l'application, le besoin d'organisation se fera ressentir, et il sera plus difficile d'y remettre de l'ordre à postériori que de partir sur de bonnes bases.

En espérant que cet article vous a été utile.

( Partie 2 )


Conseils généraux sur le processus de développement solo d'un jeu (5/5)

Posted by , in Développement 19 July 2013 - - - - - - · 490 views

Cet article est la traduction de la cinquième partie de celui ci : General Tips on the Process of Solo Game Development (Macoy Madson)
La quatrième partie en français est disponible ici : Conseils généraux sur le processus de développement solo d'un jeu (4/5)

Cinquième étape: Finalisation !

Si vous en êtes rendu à ce point, vous êtes prêt à terminer votre jeu ! Les derniers 10% de développement ressemblent souvent à 90%, mais il ne faut pas abandonner ! N'oubliez pas que même un jeu à "90% terminé" est un jeu qui ne vaut rien ! La finition c'est avant tout vous pousser à travers le Mur et faire en sorte que tous ces bouts épars soient rattachés entre eux. Rappelez-vous jusqu'où vous êtes parvenu, et regardez la distance qu'il vous reste à parcourir. Ce n'est pas si loin que ça !

Pendant que vous apportez la touche finale et packagez le tout pour la première fois, testez sur autant de plateformes que possible. Vous devez tout tester, même vos fichiers "lisezmoi" (une fois mon caractère de nouvelle ligne était de type Unix et cela ne fonctionnait pas sur les ordinateurs Windows Posted Image) !

Il est recommandé que le cheminement qu'un joueur emprunte pour découvrir votre jeu et pour ensuite y jouer soit le plus court et le plus direct possible. Abaissez toutes les barrières que vous pouvez, et faites en sorte que votre jeu soit facile à juger. La praticité est essentielle à ce stade.

Si vous vous demandez pourquoi votre jeu ressemble toujours à un projet "amateur", c'est parce qu'il n'est pas assez fignolé. De très petites choses, comme les menus ou les écrans de chargement, peuvent faire une grande différence sur les impressions du joueur envers votre jeu. Rappelez-vous, la première chose que le joueur verra sera l'une de ces choses, il est donc très important de bien les faire. Étudiez les jeux « professionnels » et les raisons pour lesquelles ils ont l'air plus « professionnels ». Le fignolage est en grande partie une question de feeling, ce qui fait qu'il est juste nécessaire de pratiquer pour y arriver, mais le temps supplémentaire en vaut la peine.

Si vous êtes extrêmement gêné par la « qualité » de votre jeu ou si vous savez qu'elle a de sérieuses lacunes, corriger autant que vous le pouvez et publiez-le quand même. Terminez votre projet, apprenez de vos erreurs et faites mieux pour le prochain jeu.

Conclusion

Vous venez de faire un jeu ! Félicitations ! Maintenant, faites en à nouveau, évitez seulement les erreurs qui ont causé du tort à la qualité de votre dernier jeu.

J'ai couvert beaucoup d'aspects, donc je vais juste faire un bref rappel de chaque étape :

Idée
  • Le prototypage reste essentiel
  • Fixez-vous un objectif et des contraintes bien définies
  • Donnez-vous un peu de temps
  • Trouvez l'élément central sur lequel repose votre idée
  • Vous allez mourir, alors faites en sorte qu'elle ait de l'importance !
Prototypage
  • Soyez ouvert à l'échec
  • Faites-le aussi rapidement que possible, et rendez votre code le plus pratique possible
  • Utilisez les outils que vous connaissez déjà
  • Ayez une question bien définie à résoudre
Itération
  • Faites du code de haute qualité
  • Allez des éléments les plus importants au moins importants
  • Expérimentez, mais ne perdez pas de vue l'élément de base
  • KISS / Optimisez l'usage / PAS d’optimisation prématurée
  • Ajoutez le code réutilisable à votre bibliothèque
  • N'ajoutez que les fonctionnalités à votre bibliothèque qui rendent le développement plus rapide ou qui ajoutent des possibilités (ne codez pas quelque chose pour améliorer la vitesse, sauf si vous en avez besoin)
  • Ne pas abandonnez ou renoncez à un projet à ce niveau !
Tests
  • Testez tôt, testez souvent
  • Diversifiez vos les origines de nos testeurs
  • Remplacez vos testeurs trop utilisés
  • Posez des questions
Finalisation
  • Persistez
  • Testez, testez, testez !
  • Rendez facile la découverte de votre jeu
  • Fignolez
  • Publiez-le et apprenez de vos erreurs
Merci d'avoir pris le temps de lire ça ! J'espère que je vous ai aidé !


Conseils généraux sur le processus de développement solo d'un jeu (4/5)

Posted by , in Développement 19 July 2013 - - - - - - · 357 views

Cet article est la traduction de la quatrième partie de celui ci : General Tips on the Process of Solo Game Development (Macoy Madson)
La troisième partie en français est disponible ici : Conseils généraux sur le processus de développement solo d'un jeu (3/5)

Quatrième étape: Tests

Je dois admettre, j'ai beaucoup de mal avec les tests. Il est assez difficile de les faire correctement, mais lorsque c'est fait correctement, cela abouti à améliorer votre jeu considérablement. La phase de tests est assez simple, donc je vais vous présenter quelques règles de base que vous pourrez utiliser pour les faire plus efficacement.

Tout d'abord, testez tôt, testez souvent ! Vous ne pouvez jamais trop tester ! Testez dès le stade du prototypage, et pas plus tard que la publication. Vous verrez que certaines parties de votre jeu qui sont parfaitement claires pour vous seront complètement confuses pour d'autres, par conséquent, ne développez pas dans le vide !

Ensuite, diversifiez ! Cela inclut les personnes et la technologie. Exécuter votre jeu sur autant d'appareils et de systèmes d'exploitation que vous le pouvez. Un de mes jeux fonctionnait bien sur mes deux ordinateurs (avec des configurations très différentes) et des systèmes d'exploitation virtuels, mais avait des bugs de déplacement qui ruinaient mon jeu sur la plupart des autres ordinateurs ! Quand il s'agit de personnes, n'écartez aucune catégorie de gens. Laissez quiconque jouer à votre jeu, peu importe son sexe, son âge, ou ses centres d'intérêts ! Plus vos testeurs seront divers, plus votre public sera divers, et moins votre jeu sera subjectif.

Ne gaspillez pas vos testeurs. Après un certain temps, ils deviendront très partiaux, notamment parce qu'ils auront vu les versions précédentes du jeu. Il est préférable que vos testeurs n'aient aucun préjugés et un esprit ouvert, alors assurez-vous de changer les gens souvent.

L'observation est la chose la plus importante que vous devez apprendre à faire lors d'une session de tests. Regardez quand les gens parlent, quand les gens arrêtent de parler, quand leur personnage meurt, quand ils réussissent, et quand ils arrêtent de jouer. Les probabilités sont que la plupart des gens vont faire la même chose, malgré l'influence de votre simple présence. L'observation est aussi la seule chose que vous devez faire pendant une session de tests. Ne leur indiquez pas le contexte, ou expliquer quelque chose, ou les aider, ou quoi que ce soit. Il suffit de regarder et de prendre des notes.

Après qu'ils aient fini de jouer, vous devriez leur poser les trois questions suivantes:

Qu'avez-vous aimé ?
Qu'est-ce que vous détestez ?
Qu'est-ce qui vous a dérouté ?


Cela vous donnera des retours très précis sur ce dont vous avez besoin de mettre l'accent et ce que vous devez changer. Aussi, lorsque le joueur vous fait des suggestions pour améliorer le jeu, ne vous focalisez pas sur la suggestion, mais sur les causes qui ont fait qu'il vous a fait cette suggestion.

La cinquième partie en français est disponible ici : Conseils généraux sur le processus de développement solo d'un jeu (5/5)


Conseils généraux sur le processus de développement solo d'un jeu (3/5)

Posted by , in Développement 19 July 2013 - - - - - - · 395 views

Cet article est la traduction de la troisième partie de celui ci : General Tips on the Process of Solo Game Development (Macoy Madson)
La seconde partie en français est disponible ici : Conseils généraux sur le processus de développement solo d'un jeu (2/5)

Troisième étape: Itération

À ce stade, vous avez fait suffisamment de prototypes pour démontrer le potentiel positif de votre idée. Vous avez également démontré la faisabilité technique de l'idée et la façon dont vous pourriez aborder sa mise en œuvre dans le code de production. Vous avez aussi cerné ce que vous aimez le plus de cette l'idée et avez retiré ce qui n'était pas nécessaire à l'expérience du joueur. Si vous n'avez pas tout cela, revenez en arrière et faites plus de prototypes !

Quand je dis ici itération, je veux parler du développement et de l'amélioration du produit final. Vous devriez éviter d'utiliser un prototype pour votre code de production parce que ce prototype était du sur-mesure pour répondre à une question donnée, et pas pour devenir un jeu complet. A ce stade du développement, vous utilisez vos pratiques de codage les plus pérennes pour construire la version finale du jeu. Il y a beaucoup d'articles qui traitent de ces pratiques, c'est donc désormais le moment d'utiliser ce que vous avez appris sur le codage de haute qualité. Le prototypage n'était pas le moment d'utiliser ces pratiques, car les prototypes vont être jetés de toute façon !

Les itérations doivent passer en revue les éléments du plus important au moins important (tout comme les prototypes). Si vous codez un menu principal ou des fantaisies graphiques avant que vous n'ayez votre mécanique principale d'opérationel, vous faites quelque chose de très, très mal ! Personne ne se soucie de vos détails graphiques ou de vos menus, ils se soucient du gameplay ! Faites le « jouet » d'abord, et gardez les menus et le fignolage pour la fin.

Bien que vous travaillez maintenant sur le code "final", vous devriez toujours continuer à expérimenter. Soyez très prudent avec de telles expériences, car elles peuvent vous faire perdre votre vision de cet élément de base sur lequel vous vous concentriez avant. Assurez-vous que vous savez pourquoi votre jeu est intéressant. Neuf fois sur dix, ce n'est pas parce que vous avez une physique réaliste pour un PNJ ou que vous pouvez extraire les métaux sous terre ! Vos expériences devraient être séparées de la production (si vous utilisez un gestionnaire de code source, c'est là où la "ramification" devient utile) et facilement annulables. Vous devriez vous concentrer sur de telles expériences pour l'amélioration de l'élément de base uniquement ! Si l'expérience est trop divergente de l'élément de base, vous devriez la spécifier et la prototyper plus tard.

Ne jamais, en aucune circonstance, optimiser prématurément ! En tant que programmeur, vous avez probablement entendu parler de KISS, qui signifie "Keep It Simple, Stupid !" (NdT : Restez simple et stupide). Suivez ce principe autant que vous le pouvez ! Jonathan Blow parle d'algorithmes et de structures de données et comment elles sont optimisées pour des performances ou la mémoire, mais ne sont pas "optimisées pour l'usage". Il est plus important de finir un jeu dans un mois qui tourne à 20 FPS que de finir dans un an pour 60 FPS !

Concernant le codage pendant le cycle itératif, vous souhaitez identifier des composants qui peuvent facilement être réutilisés dans de futurs jeux et les ajouter à votre bibliothèque plutôt que de les rendre spécifiques à votre jeu. Cela permettra non seulement d'améliorer votre bibliothèque, mais aussi de rendre chaque jeu suivant (et prototypes) plus rapide à développer. N'essayez pas de réutiliser des composants qui sont trop spécifiques cependant !

Pendant que vous enrichissez par itération votre bibliothèque de composants, concentrez-vous sur les fonctionnalités qui a) sont utiles non pour leur performance, mais pour ce qu'elles accomplissent et b) d'encourager la réutilisation du code et ainsi raccourcir les temps de développement. Par exemple, la détection et la résolution des collisions est extrêmement utile et cela vaut la peine de prendre son temps à les implémenter, mais la mise en œuvre d'une routine de collision "optimisée" n'en vaut pas la peine. Rappelez-vous, ne faites pas quelque chose, sauf si vous en avez besoin ! Comme exemple de fonctionnalités (b), j'ai récemment mis en œuvre mon propre système COM (ou CES) parce que j'ai vu combien la réutilisation du code devenait plus facile avec elle. Bien sûr, cela impacte négativement les performances, mais l'idée de composants dynamiques, portables et réutilisables compense cet impact par l'optimisation de l'usage !

Si vous en êtes à ce point, il n'y a aucune raison d'abandonner le projet ! Bien sûr, vous avez beaucoup appris de vos erreurs de codage et un recodage complet rendrait probablement le projet meilleur, mais ne perdez pas votre temps ! Beaucoup de développeurs débutants de jeux abandonnent sans cesse des projets en plein milieu du développement. C'est la principale raison pour laquelle ils sont encore des développeurs débutants ! Vous avez touché ce qui est communément connu comme « le Mur », le point où vous ne voulez plus continuer le développement d'un projet. Il suffit de l'abattre et de persister, sinon tout le travail que vous avez réalisé ne vaudra plus rien (pour les joueurs, au moins) ! J'ai publié sept jeux, et deux d'entre eux se sont avérés être un enfer vers la fin. J'ai persisté, et j'ai appris de mes erreurs. Vous devez terminer complètement vos projets ! N'abandonnez pas !

Cette étape de l'itération sera fortement influencée par l'étape suivante, qui est ...

La quatrième partie en français est disponible ici : Conseils généraux sur le processus de développement solo d'un jeu (4/5)


Conseils généraux sur le processus de développement solo d'un jeu (2/5)

Posted by , in Développement 18 July 2013 - - - - - - · 385 views

Cet article est la traduction de la deuxième partie de celui ci : General Tips on the Process of Solo Game Development (Macoy Madson)
La première partie en français est disponible ici : Conseils généraux sur le processus de développement solo d'un jeu (1/5)

Deuxième étape: Prototype

Si le chapitre Idée n'a pas été suffisamment explicite, je vais le répéter : vous ne pouvez pas voir le potentiel (positif ou négatif) d'une idée tant que vous ne l'avez pas prototypée ! Heureusement, c'est souvent l'étape la plus amusante dans le développement d'un jeu parce vous voyez votre idée prendre vie. Cependant, il est aussi important de prototyper correctement afin d'exploiter le résultat le plus efficacement possible.

Lorsque vous prototypez, vous devez être ouvert à l'échec. Si vous craignez un échec, vous ne pourrez jamais sortir ce jeu. J'aime bien conserver mes prototypes hors de mon dossier de sources vérifiés et sur le bureau Windows (ou équivalent), juste parce que cela met l'accent sur l'aspect ludique et temporaire que cette phase de prototypage a besoin pour réussir. Si vous vous plantez sur un prototype, c'est important de vous dire que c'était attendu et absolument normal !

Du fait de cette tolérance à l'échec, vous devez également développer vos prototypes rapidement, parce que les chances sont que vous ferez l'expérience que l'échec de nombreuses fois avant de créer un prototype gagnant. Un gain important de vitesse peut être obtenu par l'optimisation de votre code. Je ne veux pas dire l'optimisation de sa performance, mais l'optimisation de son usage. Vous souhaitez concevoir votre code pour une réutilisation et une simplicité maximale, ce qui implique la création d'une bibliothèque complète de codes réutilisables et pertinents, et de faire un modèle de jeu que vous pouvez copier et réutiliser. Ce modèle de jeu devrait inclure une fenêtre ouverte avec l'affichage d'un sprite, la gestion des entrées et un makefile de travail, etc. Recherchez le confort !

En outre, vous devriez éviter d'utiliser des outils soit-disant « plus faciles » pour le prototypage, mais plutôt tenez-vous en à ce que vous savez et ce avec quoi vous avez le plus d'expérience, parce que cela donnera le plus rapide des prototypes (et le plus utile). J'écris la plupart de mes prototypes en C++ parce que j'ai quatre ans d'expérience avec ce langage et sa bibliothèque.

Avant de rédiger la moindre ligne de code, assurez-vous que vous avez une question bien définie à laquelle vous souhaitez que votre prototype réponde. Cette question devrait être très simple et devrait impliquer en priorité les parties les plus importantes et/ou « à risque » de votre idée de jeu. Idéalement, vous devriez écrire la question quelque part clairement et de façon visible et ainsi vous ne devriez pas faire de hors-piste. Dès que le prototype répond à cette question et débroussaille un peu le terrain, vous devriez passer à un autre.

Une fois que vous avez fait le(s) prototype(s) qui démontre la puissance de votre idée, trouvez l'élément de base qui le démontre et laisser de côté tout le reste. La simplicité est la clé d'une conception élégante !

La troisième partie en français est disponible ici : Conseils généraux sur le processus de développement solo d'un jeu (3/5)


Conseils généraux sur le processus de développement solo d'un jeu (1/5)

Posted by , in Développement 17 July 2013 - - - - - - · 1,078 views

Cet article est la traduction de la première partie de celui ci : General Tips on the Process of Solo Game Development (Macoy Madson)

En tant que développeur de jeu solo, il est important d'apprendre autant que possible sur tout ce que vous pouvez, y compris le processus que vous suivez en faisant des jeux. Le processus, je vais en parler comprend les étapes suivantes:
  • l'Idée
  • le Prototype
  • l'Itération
  • le Test
  • la Finalisation
J'espère vous fournir des conseils utiles sur chaque étape de ce processus de sorte que vous pourrez améliorer la vitesse de développement et la qualité de vos jeux.

Le processus, étape par étape

Tout d'abord, il est important de noter que ce n'est pas un processus en "cascade" linéaire. Il est très organique. Alors que vous commencez toujours avec une idée, les étapes suivantes de prototypage, d'itération, et de test se passeront de façon désordonnée. C'est une bonne chose, car il encourage l'expérimentation et va à l'encontre de la rigidité de la conception d'un jeu, et ce qui permet l'évolution positive de l'ensemble. Au fil du temps, vous aurez une meilleure idée sur la façon dont vous suivez habituellement ce processus et comment vous pouvez l'améliorer.

Première étape: l'Idée

Les développeurs de jeux débutants pensent parfois que c'est l'étape la plus importante dans le processus, et que tout développement doit être à l'arrêt tant qu'une une idée n'est pas explorée à fond. Suite à cela, ils ont tendance à sur-concevoir (eg. d'indigestes documents de game design), voir trop grand par rapport à leurs compétences, et à surestimer la valeur des idées. Cela fait également une conception beaucoup plus rigide, qui finit par affecter négativement le jeu sur le long terme.

Bien que l'idée soit importante, il est plus important de comprendre la fragilité de vos connaissances tant que vous n'aurez pas fait un prototype et tester cette idée. Vous verrez que les idées qui sont dans votre tête peuvent paraître sympa, mais que jouer à un prototype de cette idée finit par être vraiment ennuyeux. Vous verrez également qu'une idée "terne" peut donner un prototype vraiment amusant !

Au cours de cette étape, assurez-vous que votre objectif et vos contraintes soient bien définies. Par exemple, "faire un jeu fun" n'est pas un objectif très clair, tandis que "faire un jeu dans un mois qui utilise le thème du jeu Flowers et utilise de préférence le nouveau système COM" l'est. Le deuxième exemple montre également de bonnes contraintes. Certaines contraintes très immédiates qui s'appliquent à la plupart des gens qui font un jeu dans un certain laps de temps ("avant la mort", même) et de rester à l'intérieur (voire très légèrement au dessus) de votre gamme de compétences. Les contraintes peuvent vous aider à penser à d'autres idées, mais il est souvent bon de faire varier le niveau de degrés de liberté que vous avez sur chaque projet de jeu.

L'inspiration est un mot qui revient souvent quand on parle des idées. N'oubliez pas que l'inspiration vient de partout, telle que de votre vie, d'autres médias, la théorie sur la conception de jeux, ou même la génération aléatoire ! La chose la plus importante que vous devez savoir sur « l'inspiration » est de ne pas sauter sur la première idée venue ! Lorsque vous êtes « inspiré », votre cerveau pompe ces substances chimiques associées à la récompense suite à cette production heureuse d'idée, ce qui vous rend très peu objectif sur les défauts de cette idée ! Tout ce que vous avez à faire est de vous donner du temps. Peu importe à quel point l'idée vous semble bonne sur le coup, donnez vous au moins trois ou quatre jours avant de faire davantage que d'y penser et d'écrire à son sujet.

A un niveau inférieur, il est important de se concentrer sur la/les mécanique/s de votre idée. Rappelez-vous, vous écrivez un jeu, pas une histoire, donc vous avez besoin d'un gameplay ! Si vous ne pouvez pas penser à bon gameplay pour cette histoire, peut-être que cette histoire serait mieux véhiculée sous une autre forme de média.

Lorsque vous avez une idée et que vous avez patienté un laps de temps suffisant (et qu'elle sonne toujours bien), la prochaine chose que vous devez faire est de la réduire à sa plus simple expression. Cherchez ce qui vous fait vraiment aimer cette idée. Vous devez trouver le(s) élément(s) noyau(x) le(s) plus fondamenta(ux) qui font que cette idée est si attirante pour vous. C'est la première chose dont vous avez besoin pour faire le prototype puisque l'intégralité de votre jeu reposera sur ces éléments de base !

Sur une note plus sombre, rappelez-vous que vous allez mourir. Gardez cela à l'esprit, et faite votre jeu comme si c'était le dernier.

La seconde partie en français est disponible ici : Conseils généraux sur le processus de développement solo d'un jeu (2/5)







PARTNERS