Nouvelle présentation de la liste des ateliers

J’ai revu toute la présentation de la liste des ateliers afin de mettre en place :

  • Les parcours d’apprentissages
  • Les classifications des ateliers (en conformité avec mon arbre d’évolution)

Afficher 23 ateliers sur une seule page commençait à devenir non seulement lourd mais également peu lisible ! Vu l’ampleur du contenu, il fallait que j’y remédie rapidement…

J’espère que ça vous plaira et que ça vous permettra d’y voir clair dans le contenu de la formation, chaque semaine un peu plus riche !

Consultez la nouvelle liste des ateliers

This entry was posted in News and tagged . Bookmark the permalink.

Nouvel atelier Monogame : Créer une map avec Tiled, la charger et l’afficher

Apprenez comment utiliser Tiled, un éditeur de map gratuit, pour créer une map. Découvrez ensuite comment la charger facilement en C#, accéder à ses données (calques, etc.) et l’afficher à l’aide de Monogame. A la fin de cet atelier de formation vous saurez :

  • Créer une map avec l’éditeur Tiled (lien : http://www.mapeditor.org/)
  • Intégrer les fichiers générés par Tiled à un projet C# / Monogame
  • Intégrer la librairie TiledSharp à un projet C# / Monogame
  • Charger la map et le tileset
  • Lire les données de la map à travers la classe TmxMap
  • Afficher des tuiles (tiles) issues d’un tileset
  • Parcourir, par code, les calques de la map pour les afficher
Type d’atelier pour votre fiche d’objectif d’apprentissage  Centre de production
Durée de l’atelier Environ 45 mn
Nombre de vidéos :  6

Langage : C#
Framework : Monogame

Atelier prérequis :
Tilemaps : Les bases (conseillé)

Accédez à l’atelier complet
This entry was posted in News and tagged . Bookmark the permalink.

Lunar-Landing – Générateur de sol aléatoire

Bonjour/Bonsoir tout le monde,

En regardant les diverses vidéos de David sur sa page Youtube, j’en ai vu une qui parlait d’un Lunar-landing. Cela m’a rappelé des moments passés sur un vieux jeux où l’objectif était de poser le module lunaire sur la Lune. Il faut savoir que je n’ai jamais réussi à le poser…
Et puis, il y avait un jeu plus ancien, un peu dans le genre de Lander 2.

Alors j’ai suivi l’atelier « Comment faire voler un vaisseau spatial ». Il contient tous les éléments permettant de préparer un jeu de type « Lunar landing » ou « Asteroides ».

J’ai donc décidé de rajouter un sol à cet atelier pour avoir un jeu qui commence à être complet.

Le lien ci-dessous est un tutoriel vous expliquant comment ajouter un sol généré de manière aléatoire ET comment détecter et gérer la collision avec le vaisseau :

[Lien masqué – réservé aux membres Premium]

 

JDev : Screeps un jeu pour codeur ?

Bonjour à tous,

Dans mon aventure de codeur et toujours en quête d’apprentissage, notamment du javascript, je suis tombé sur un jeu spécialement étudié pour les codeurs, développeurs : Screeps.

Je trouve le concept très intéressant : Il s’agit en fait d’un RTS (Real Time Strategy), dans lequel vous devez ériger une colonie, des constructions etc… mais pas en jouant de manière classique non non, vous devez coder, développer, programmer votre IA en javascript.

Screeps

Ainsi, vous ne commandez pas vos unités directement, vous programmez en fait en javascript des scripts, des comportements, une IA qui permettront à vos lambins de travailler pour vous, construire des bâtiments, défendre votre colonie et ce, sur un serveur 24/24.

je trouve ce concept vraiment innovant et sympathique pour apprendre le javascript tout en s’amusant. Bien entendu vous n’êtes pas seul sur les serveurs…Il existe aussi un mode « offline » en fait c’est un serveur privé qui se lance sur votre machine.

Le jeu est en fait fourni avec une API qui donne tout ce qu’il faut pour créer et gérer sa colonie, le tout en javascript. Alors il n’est pas question ici de créer un jeu bien sur, mais je trouve le concept pas mal pour apprendre un langage et ses concepts en douceur. Le jeu se présente avec une sorte d’IDE couplé à un écran de jeu.

Alors évidemment, ce n’est pas fait pour apprendre à programmer, je parle ici des fondamentaux de programmation, c’est pas le but, et d’ailleurs sur GameCodeur l’atelier à ce sujet est parfait, et là pour cela. Mais pour appréhender le langage javascript en s’amusant, c’est bien fait !

Connaissiez vous ce jeu ?

A bientôt !

JDev : La physique, le mal absolu ?

Bonjour à tous,

Ces derniers jours, je me suis penché un petit peu en faisant des recherches sur Internet, sur des algorithmes pour gérer les collisions entre deux objets. Pas forcément en Löve ou autre, les algos peuvent s’appliquer dans n’importe quel langage. Cependant j’ai cherché quelques applications exemples pour voir un petit peu comment tout cela était mis en place.

Ce que j’ai pu découvrir m’a laissé de marbre.

Les moteurs physiques mis en avant : une ânerie ?

C’est hallucinant, à chaque fois que je cherchais un exemple de gestion collision en Löve ou ailleurs, c’était toujours sur la base d’un moteur physique. Mais pourquoi faire ? Certes ces moteurs peuvent être pratiques, mais dans le cas de simple collisions entre deux sprites, quel intérêt ? Se faciliter la vie car il y a une méthode qui permet de faire des tests de collisions ?

Pour moi ce n’est pas valable. L’émulation de la physique demande pas mal de calculs, beaucoup trop à mon avis pour gérer une simple collision. Si on prend en compte le nombre de facteurs existants sur les moteurs physiques (gravité, friction, masse etc…) est ce que cela vaut le coup de faire faire à la machine tout un tas de calculs savants pour tester une collision entre deux « carrés » ? Calculs qui je parie font ralentir l’exécution du programme…

Après tout Super Mario Bross, il n’y avait pas de moteur physiques à l’époque. J’ai fait une recherche pour voir d’exemple de gestion de collisions sur Löve, à 80 % les gens utilisent le moteur physique (sauf quelques exceptions bien sur).

Unity ou la fausse bonne idée

Voilà pourquoi d’ailleurs je n’aime pas Unity. Unity l’ensemble d’outils magiques qui permet de faire un jeux vidéo de A à Z. Sans parler de l’interface que je n’aime pas et de son workflow 2D que je trouve un peu bancal (si je devais comparer à d’autres solutions, je le trouve pas intuitif et c’est qu’une question de goût personnel), si on va chercher un tuto sur la création de jeu 2D sous Unity, sur le site officiel, on tombe sur un petit projet sympathique mais qui utilise direct la physique ! Tout cela pour faire déplacer un sprite et faire quelques collisions.

D’ailleurs c’est pareil, la plupart des tutos utilisent ce principe de physique.

De la physique partout

Donc la grande mode du moment, on utilise de la physique pour tout et n’importe quoi, même si le jeu n’en a pas besoin. Je pense que c’est pour se faciliter la vie, mais d’un autre côté niveau performances, un jeu qui fait autrement serait super fluide, on se retrouve avec des petites « latences », ou des acoups.

J’ai même déjà vu un casse brique codé avec de la physique oO D’ailleurs pour certains engines, c’est presque un argument de vente.

Ce que j’en dis

Bien entendu, je ne suis pas un codeur exceptionnel, je suis loin de connaître ne serait ce que le 10ème dans ce domaine, et ce que je raconte ici, ne représente que mon avis personnel bien entendu. Mais je pense qu’il faut arrêter de mettre de la physique partout alors que cela n’est pas utile.

Bien sur que les moteurs physiques peuvent être pratiques pour certains projets qui demandent….de la physique, mais pour les autres projets, je ne pense pas que ce soit une option de facilité. Pour le codeur peut être dans le sens où il y a des routines toutes faites généralement, mais en terme d’optimisation, et surtout de sensation pour le joueur, je ne suis pas sur que ce soit la solution à tout.

Malheureusement, quand je vois le nombre de tuto, d’exemples qui « poussent » à utiliser ces systèmes pour simplifier la gestion de certaines routines, ce n’est pas près de changer.

Et vous qu’en pensez vous ?

PS : je précise que mes « JDev » ne sont que la retranscription de mes pensées et en rien une vérité absolue, je ne partage que mon avis, mes sentiments sur un sujet.

Jdev : Effet sinusoidale oldschool en Löve (sources incluses)

Bonjour tout le monde,

Aujourd’hui un billet un peu particulier. Après avoir fait joujou avec l’atelier du casse brique, je me suis plongé sur le portage d’un code que j’avais fait il y a longtemps, histoire de m’habituer aux tableaux et listes de Lua. C’est tellement particulier sur ce langage.

Je partage ce code avec vous ici, il s’agit de créer un effet oldschool sinusoïdale comme dans le temps quand on faisait des demos sur Atari ou autre. Je vous met le lien du zip qui contient les sources, et vous explique un petit peu le principe.

Voici les sources : Télécharger les sources

Voici une image (non animé du coup) :

Comment cela marche ?

Fonction love.load()

Dans la fonction « load »  on commence par charger notre image. Ensuite on initialise une variable que j’ai appelé startAngle, c’est l’angle de départ. On initialise également un tableau que j’ai appelé tableSin qu’on remplit avec des valeurs « sin ». Vu qu’un angle peut aller jusqu’à 360 degrés, le tableau aura 360 valeurs (de 0 à 359).

Aussi vous remarquerez que pour les besoins de l’algorithme je convertit l’angle de degrés en radians. En fait c’est tout simplement parce que à l’époque où j’avais codé cette routine, le langage utilisait que des radians. La routine est donc prévue comme cela.

je lance ensuite la fonction cutTheImage en donnant en paramètre notre source.

Fonction cutTheImage()

Dans cette fonction j’initialise un tableau qui va contenir une liste d’images. Ensuite la boucle for nous permet de découper dans le sens de la largeur des bandes de l’image de 612 pixel de large et de 1 de hauteur (les valeurs sont adaptées selon l’image choisie), l’indice va jusqu’à 100 qui représente la hauteur totale de l’image. Ensuite on remplit le tableau d’images (ou la liste si vous préférez) avec le résultat de la découpe.

Fonction love.update()

A chaque update on initialise l’angle courant. Au premier tour, l’angle de départ est à 0, et donc l’angle courant également (voir la fonction draw plus bas).

Fonction love.draw()

Le but de la fonction est d’afficher tour à tour chaque partie ou morceau de l’image qu’on a découpée. Souvenez vous on a stocké chaque partie lors de la découpe dans un tableau ou une liste. Dans la boucle for, on affiche l’image à la position y , à la coordonnée x et y indiquée. La position x est prise dans le tableau tableSin qu’on a initialisé au départ et qui contient des positions permettant de faire la sinusoïde, on va chercher la valeur à l’emplacement donné par la variable currentAngle, la coordonnée y est définit par la boucle for. En effet, on affiche chaque morceau de haut en bas.

Ensuite on ajoute 1 à currentAngle pour passer à la position suivante pour le prochain morceau d’image. Il faut tester qu’on dépasse pas 360 (logique pour un angle). Enfin on change l’angle de départ pour la prochaine frame en ajoutant 2 à startAngle. Etant donné que dans la fonction update, on met la valeur de currentAngle à startAngle, cela permet de faire un « déplacement » et donc de donner au final ce mouvement sinusoïdale.

Vous pouvez essayer : au lieu d’ajouter 2 à startAngle, ajoutez par ex 5 vous verrez que l’animation sera plus rapide. Aussi dans le calcul du tableau tableSin, changez la valeur 30 en 50 par ex, vous verrez que l’amplitude de l’effet sera plus grand.

Voilà j’espère que ce petit code vous aura plu et je vous dis à très bientôt sur GameCodeur !

Happy coding !

Journal d’un dev de « crystal »

Bonjour à toutes et à tous,

J’ai franchis le pas et je suis dorénavant comme beaucoup d’entre vous membre premium. Cet article est un peu l’introduction à un exercice que je me suis donné en entrant ici : partager mon avancement, mes échecs, mes craintes, mes réussites, mes difficultés. Appelons cela un journal de dev ou « Jdev ». Quel drôle d’idée me diriez vous ?

Un bug dans mon esprit ?

En réalité, je ne suis pas complètement nouveau dans le développement. Je m’intéresse au développement de jeu depuis longtemps. Cependant je suis ennuyé par point : Je ne suis pas productif ! Pas bien le Crystal !

En fait ceci est l’oeuvre d’un phénomène particulier : j’aime bien tout tester, en soif d’apprendre, je ne compte plus les livres sur le développement de jeu, sur plusieurs langages / engines que j’ai. Et pourtant je ne fais rien de concret. Je commence à coder/créer sur un langage, au bout d’un moment j’ai besoin de voir un autre langage / engine, de voir du neuf, ou d’essayer autre chose.Résultat : rien de concret à part un ou deux petits moteurs.

C’est ainsi que je me suis essayé à la libGDX, Game Maker Studio (1 et 2), Clickteam Fusion 2.5, Purebasic, GLBasic, Construct (1 et 2) et j’ en passe. Et pourtant…

Il y a quand même quelque chose de positif la dedans : Je prend un réel plaisir à tester ces langages / engines, à coder, créer. Maintenant j’aimerais pouvoir moins m’égarer et faire quelque chose tout en continuant d’apprendre.

Qu’est ce que j’attends de GameCodeur ?

Apprendre encore plus bien sur. Mais j’ai un tout autre objectif : Essayer de me focaliser et de faire quelque chose de concret sans avoir de blocage quelconque, mon esprit se pose beaucoup trop de questions !

Par ex les graphismes sont un problème chez moi, et souvent je suis jamais allé bien loin, car regarder un carré sauter cela m’a jamais fait vibrer, mais j’avais surement tord. L’idée est donc de faire un travail de code certes mais aussi (du moins en ce qui me concerne) un travail de fond. Essayer d’aller jusqu’au bout de quelque chose et surtout, partagez avec vous et via ce blog mes sentiments, mes difficultés, mes réussites et pourquoi pas mes astuces. Et surtout éviter de me poser trop de question et d’avoir toujours ce besoin d’avoir une réponse (même quand il n’en n’existe pas…).

Je pense que partager de cette manière aide à se fixer un objectif, à se défouler (d’une certaines manières) et à se motiver !

Sur quoi vais je coder alors ?

Vous commencez à me connaître, me focaliser sur un seul langage ou engine va m’être difficile, alors je pense que je vais tout simplement me donner une liste on va dire de 4 ou 5 outils sur lesquels je travaillerai sur Gamecodeur :

  • Löve : Bien que je sois pas un fan du lua cela me permettra d’apprendre plus ce langage avec lequel j’ai du mal (et peut être l’apprivoiser finalement).
  • libGDX : Bon c’est moins sur mais quand même, j’aime bien le java.
  • MonoGame : J’ai envie d’apprendre ce framework il peut être sympa à utiliser, le C# est un langage que j’aime bien (au même titre que Java).
  • Pico-8 : du lua mais bon tellement bien pensée cette console.
  • Game Maker Studio 2 : Contrairement à ce qu’on peut entendre il est très puissant, certes on est plus sur un langage de script, mais cela reste du code quand même.

Cela peut paraître beaucoup, mais croyez moi, si j’arrive déjà à me focaliser que sur ces solutions là, j’aurais déjà fait un grand pas ! D’autant plus que l’objectif n’est pas de tous les utiliser ou les utiliser en même temps, mais de pouvoir varier mon plaisir et mes envies ! Mon objectif premier c’est de me faire plaisir.

J’essayerai de participer à des Jam. Peut être pas au début, histoire de me mettre dans le bain mais après pourquoi pas !

Conclusion ?

Ceci va conclure ce premier article qui était plus destiné à vous donner mes sentiments sur le développement, une partie de mes expériences et soucis, et ce que je veux accomplir. L’idée du partage comme cela de manière sincère, je pense, est une bonne idée, afin de « photographier » les étapes d’apprentissage, ses réussites, ses échecs et ses sentiments sur les objectifs qu’on se fixe, mais aussi de s’entraider, et bien sur partager ses codes et routines et plus globalement partager avec vous !

Merci et à bientôt pour un nouveau Jdev de crystal.

Happy coding !

Retour sur la Jam #3

Voici (enfin!) mon retour sur la jam…

Je vais commencer tout d’abord par une petite présentation. Il y a environs 2 ans que j’ai commencé à apprendre à programmer. J’ai commencé par le C et le C++ en suivant les (mauvais) conseils que m’ont donnés des programmeurs sur un forum. Avec le recul, je dirai que c’est un peu comme placer un débutant en alpinisme devant l’Everest et lui dire ne t’inquiète pas, en prenant ton temps tu va y arriver… C’est donc ainsi que j’ai appris les bases, puis je me suis lancé dans le langage Java, qui m’a attiré à l’époque pour sa portabilité.

je me suis inscrit sur GameCodeur quelques jours avant la vidéo « Sortez vous les doigts !! ». Je me suis donc tout de suite inscrit à la jam avec l’intention de livrer quelque chose en Java, mais sur les conseils de David j’ai commencé par visionner les ateliers Lua/Love2d (et j’avoue que j’aurai vraiment aimé commencer mon apprentissage de la programmation par ce langage, si seulement GameCodeur existait déjà à l’époque).

J’ai donc développé Blobscape pour la Jam en Lua avec le framework Love2d en un peu plus d’une vingtaine, en comptant la création des images (je les ai réalisées avec PhotoFiltre, pas forcément adapté mais c’est un logiciel que j’ai l’habitude d’utiliser). Les musiques et les sons ont étés réalisées par Søll (mon frère) avec BoscaCeoil (pour les musiques, c’est un excellent logiciel qui une fois pris en main permet de réaliser des musiques pour ses jeux assez facilement) et BFXR (Pour les effets sonores).

A l’origine je comptai faire une simple liste de slimes animés, mais ayant ajouté les collisions, les déplacements, les sauts… Je me suis dit autant en faire un mini-jeu complet. Si certains sont allés jusque au bout ils auront peut être vu que je ne savais pas trop comment finir le jeu, d’où l’ajout des petit feux d’artifice, une façon simple de dire « vous avez gagné! » ^^

Pour les contrôls j’avoue que rajouter la possibilité d’utiliser les flèches directionnelles ne m’aurait pris que deux secondes, ou j’aurai pu donner la possibilité de changer les contrôls, même si ça aurait été plus long,  je n’y ai tout simplement pas pensé car j’ai l’habitude d’utiliser zqsd.

Voili voilou pour Blobscape. Sinon pour la prochaine Jam ce sera du C#/Monogame pour moi, la ressemblance entre le C# et le Java m’a beaucoup facilité l’apprentissage, et Monogame est un framework qui est juste excellent (en plus j’aurai dû me renseigner plus tôt sur Monogame puisque c’est le framework avec lequel ont été développés plusieurs jeux indés que j’ai adoré)

J’ai toujours aimé regarder et tester les jeux du Ludum Dare, et j’ai beaucoup appris en lisant le code des participants, mais je n’avais jamais participé à une Jam et ça a été un réel plaisir.

En tout cas bon code à tous, et courage à tous ceux qui participeront à la Jam#4, je suis vraiment pressé de voir les réalisations de chacun, surtout avec un thème aussi ouvert.

JGC#3 _Akira_s_back

Petit retour d’expérience sur la JGC#3.
Étant inscrit depuis début octobre, et partant de très très peu, j’ai participé à la JGC d octobre et cette dernière , pour moi la question ne se pose pas, il faut que je participe à toutes les JGC car je considère que c’est un bon exercice…cf les vidéos de David sur les challenges à se mettre…
Pour le sujet, les Listes, si vous avez vu mon « projet » l’intro vous dit ce que j’en pense, dans le sens ou je ne comprends pas comment on peut coder sans listes, déjà avec c est vite le bord.. mais alors sans ça doit juste être l’horreur, donc un peu vague comme sujet !!

Alors en fan de JDR et de JdPlateaux (WagH40KKKKKKKKKKKKKKKKKKKKKKKK -_- pardon), je me suis dit tiens je vais taffer sur un projet de jeu de plateau.
J’ai bossé 2 semaines très sérieusement dessus, le temps de mettre au point les formules mathématiques d’intersection de droites et de segments, afin d’éviter les fameux polygones concaves… [[Au passage un grand remerciement à la chaine youtube coding math , une vraie mine d’or – j’adore les maths]]

Le résultat est très moche, certes, mais efficace, ne cherchez pas le gameplay ni le but, c’est juste un simulateur de plateau avec une interface graphique pour poser des décors de taille et formes différentes sur le dit plateau, avec comme règle que les décors ne peuvent ni être hors de la table ni se superposés (bon par contre ils peuvent être circonscrites l’un dans l’autre !!).

Pour ce qui est des listes, pour vous donner une idée si vous placer un décors en forme de L, il est initialement définit par une liste de nombres représentant les x et y des 6 points composants la forme L.

Puis cette liste de chiffres va être travaillée:
– la convertir en liste de points de type {(x1,y1), (x2,y2)…}, plus facile pour manier les maths…
-recalculées les valeurs des (xi,yi) lorsque l on modifie la taille, AINSI que lorsque l on modifie la position du décors (avec la souris)
-définir sous forme Ax+By=C chaque droite reliant les points 2 à 2, vérifier l’intersection de toutes les droites du nouveau décors avec toutes les droites de chaque autre décors, et si il y a intersection, calculé si les segments se croisent réellement, sans oublier les colinéaires 😉

De là j’ai eu du boulot et des retrouvailles fraternelles à célébrer, j’ai donc laissé 15 jours passer, et mon code étant très peu organisé, je me suis dit ok si je rajoute quelle que chose, je risque a 90%+ de tout faire foirer.

Donc pas de petit perso a deplacer, ni de gestion des collisions et lignes de vues (enfin les maths ayant été débrouillées c’était assez simple à adapter).

 

Ce que j’en retire:

-tout d abord une bonne leçon, essayer de rendre mon code propre, il faut que David nous enseigne ça, au passage merci Veronimish pour tous tes précieux conseils.
-Je vais refaire ce projet plus tard en mieux en plus propre.

Sinon par pitié impose nous des contraintes dans les thèmes des JGC David, parce que là encore c’est complètement ouvert donc pas assez contraignant….

Voilà, je vais essayer de tenir un journal de bord pour la 5ème , car pour la 4ème, je pars dans 3 jours, pour 20 jours en Thaïlande, pas sur que j’ai le temps de faire grand chose d autre que kiffer !!

Last but not least : Je recommande vivement Trello (ou autre) car c’est encore un excellent conseil de david, pour ce qui ont du mal à s’organiser/planifier.

Bonne année, et tout et tout pour vous tous.

Akira_s_back

La suite de l’atelier Tilemap arrive demain !

Je viens de finir de filmer la 2ème partie de l’atelier Tilemap en Love2D/Lua !
 
Je vous montre comment je déplace un personnage sur une Tilemap, case par case, et comment je détecte les collisions avec le décor !
 
C’est vraiment facile. On part de ce qu’on a appris dans l’atelier précédent, on améliore le code, et on y intègre le personnage.
 
Je vous montre tout pas à pas et je vous apprend à
– reprendre un code pour l’améliorer
– afficher un sprite à une ligne et une colonne de la map
– animer le sprite image par image !
– le déplacer avec le clavier, en gérant les limites de la map
– détecter si il collisionne avec un élément « solide » : arbre, rocher
 
45 minutes de pur bonheur ! Coooooool !
 
Je le publie demain !
 
On reprendra ces concepts en C# et on en fera un prototype de jeu (un platformer je pense).
This entry was posted in News and tagged . Bookmark the permalink.