RTS FACILE

Comme tout le monde, tu te dis que programmer un jeu comme ça ce n'est pas de ton niveau.

Il y a tellement de choses qui composent un tel gameplay !

Pourtant ce genre de jeu te passionne et tu rêverais de pouvoir en programmer un.

En poser les bases et pouvoir voir, de tes propres yeux, des unités se déplacer sous tes ordres.

A moins que tu veuilles tout simplement comprendre enfin comment un tel jeu est construit (voir sous le capot !).

Transporter son PC et son écran pour aller jouer en LAN chez des amis.

(et oui, on n'avait pas d'ordinateur portable donc on transportait tout : UC, écran, clavier, souris...)

Les parties jusqu'au matin, le souvenir des voix du jeu "Go go go !!".

Tout ça quand la connexion marchait bien sûr 😉.

Alors je me suis lancé dans ce projet fou.

Je me suis mis à en décortiquer les principaux éléments :

• La map

• Le scrolling

• Le zoom

• Les bâtiments

• La construction d'unités

• Les sélections des unités au lasso

• Les déplacements en groupe en contournant les obstacles...

Et je me suis rendu compte que ces éléments, individuellement, étaient réalisables.

Et mis bout à bout, ils posaient les bases d'un jeu de RTS plutôt excitant !

Une base de jeu évolutive, véritable TEMPLATE qu'on peut utiliser pour créer un jeu de stratégie, un 4X, un jeu de colonies...

Les sensations que j'ai ressenties quand mon jeu a commencé à fonctionner sont incomparables.

Il s'agit de ce frisson que seul un programmeur de jeux vidéo peut ressentir : celui de donner la vie.

J'ai repris chaque "brique" de code pour la rendre la plus simple possible.

J'ai tout simplifié sans jamais devenir simpliste.

Jusqu'à obtenir un code qui "raconte une histoire" et que j'allais pouvoir vous expliquer pas à pas : EN LE CODANT LIGNE PAR LIGNE DEVANT VOUS.

J'ai rarement travaillé sur un projet aussi complexe, tout en le simplifiant à un point qui l'a rendu digeste même pour un amateur en programmation.

Tu vas apprendre à programmer de tes mains.

Tu vas passer par les véritables étapes nécessaires à la production des bases d'un RTS tel que StarCraft.

Chaque concept te sera expliqué.

A la fin de ce cours, tu auras appris tellement de nouvelles choses !

Voici ce que tu vas apprendre dans ce cours :

🗺️ Une map de jeu comme tu n'en as jamais codé :

• Utiliser Tiled pour créer une map complexe : Comment créer et exporter une map depuis un éditeur de map mythique : Tiled Map Editor.

• Gère ta map comme un pro : Prend en compte les différents calques qui ont été créés dans Tiled, importe les tilesets, etc.

• Donner vie à la map : Afficher la map en quelques lignes de code, la faire scroller et gérer un facteur de zoom avec la molette de la souris.

🏢 Une map n'est rien sans bâtiments et unités :

• Décris tes bâtiments et tes unités par programmation : Comment le faire en quelques lignes de code et pouvoir gérer toutes les statistiques de tes éléments de jeu.

• Positionner des bâtiments : Apprends à programmer un système pour permettre au joueur de positionner le bâtiment sur une zone libre : affiche une ombre rouge, ou verte, comme dans Stacraft.

• Construction progressive : Comment faire pour que le bâtiment prenne du temps pour se construire et que le joueur le voit évoluer visuellement.

• Unités produites : Apprends à programmer que chaque bâtiment produit des unités différentes.

🏭 Produire des unités depuis un bâtiment :

• Spawn des unités : Comment faire produire une unité à un bâtiment et qu'elle apparaisse sur la map à proximité, sur une case libre.

• Animations : Apprends à programmer un système d'animation image par image, en fonction de ce que fait l'unité (attente, marche, etc.) et de son orientation.

🤠 Sélection et lasso :

• Sélection multiple : Comment programmer un lasso qui sélectionne les unités qui se trouve dans sa zone de sélections.

• Système de coordonnées : Apprends à gérer le système de coordonnées pour que le lasso fonctionne quel que soit le scrolling et le zoom de la map.

• Limite de sélection : Apprends à limiter le nombre d'unités que le joueur peut sélectionner.

🔎 Le Pathfinding, le Graal de tout RTS :

• Déplacement en groupe : Apprends à calculer l'ensemble des cases de destination des unités sélectionnées, pour qu'elle rejoigne la zone cliquée par le joueur, et calcule le chemin de l'unité.

• Trouver son chemin : Comment calculer le chemin que doit parcourir une unité pour atteindre sa destination, en évitant les obstacles ?

• Le A* (AStar) : Apprends à programmer, de la théorie à la pratique, l'algorithme de Pathfinding le plus utilisé.

• Déplacement des unités : Comment faire se déplacer une unité le long du chemin qui a été calculé pour elle, tout en animant l'unité en fonction de son orientation sur le parcours.

⌨️ Langage de programmation : Lua
🕹️ Framework : Love2D

✅ Un cours complet en vidéo : plus de 7h de formation, découpées en vidéos digestes et didactiques. Tu pourras revoir chaque concept à volonté.

✅ Des fiches de concepts qui te serviront de pense bête ou d'anti sèche pour comprendre et réutilise plusieurs concepts clés.

✅ Le code source du projet complet. C'est un véritable template de jeu que tu pourras étudier et/ou réutiliser.

✅ Les graphismes utilisés dans le cours.

1. Conversions entre systèmes de coordonnées (coordonnées monde, coordonnées écran).

2. Gestions de tableaux à 2 dimensions pour gérer la position des unités et des bâtiments.

3. Utilisation de références (vs valeurs).

4. Implémentation d'un algorithme de pathfinding A* pour le déplacement des unités.

5. Chargement de code avec la fonction require de Lua.

6. Utilisation de fonctions thématiques pour améliorer la lisibilité du code.

7. Utilisation de timers pour la construction progressive de bâtiments.

8. Chargement d’une map issue de Tiled Map Editor.

9. Exploitation des informations d’une map issue de Tiled Map Editor.

10. Affichage d’une map issue de Tile Map Editor, multi-calques.

11. Scaling (zoom) des pixels pour un effet pixel art.

12. Chargement et découpage de tilesets.

13. Utilisation des Quads de Love2D pour optimiser les performances. 

14. Défilement de la caméra en fonction des entrées du joueur ou de la position de la souris.

15. Zoom et mise à l’échelle de la carte pour ajuster la vue, avec la molette de la souris.

16. Calcul de la position du scrolling pendant le zoom pour maintenir le centrage de la map sur la position de la souris.

17. Police personnalisée pour l'affichage des informations de l'interface utilisateur.

18. Chargement et utilisations de sons lors de certains évènements du gameplay.

19. Utilisation du clavier pour contrôler certains éléments du jeu (raccourcis, scrolling).

20. Définitions de bâtiments ou d’unités par programmation, avec leurs caractéristiques.

21. Sélection du type de bâtiment à construire parmi une liste, et affichage du type et des informations à l’écran.

22. Gestion d’un “mode de jeu” : play, build, etc.

23. Placement d’un bâtiment sur une carte, à la souris avec indicateur de zone libre ou pas.

24. Prise en charge de la taille des bâtiments (occupent plusieurs cases sur la map)

25. Evaluation de l’état d’une case pour savoir si elle est libre ou pas (walkable, non occupée par une unité, un bâtiment ou hors des limites de la map)

26. Evaluation de zones libres ou non libres pour construire un bâtiment (ensemble de cases).

27. Système de construction de bâtiments avec une barre de progression pour indiquer l’avancement.

28. Affichage d’un bâtiment en fonction de sa progression de fabrication, avec calcul de la bonne frame dans le tileset des bâtiments.

29. Production d’unités à partir d’un bâtiment.

30. Calcul d’une position libre à proximité d’un bâtiment pour la production d’une unité.

31. Détection des clics pour sélectionner des unités et interagir avec les bâtiments.

32. Sélection d'unités à l'aide d'un lasso pour regrouper plusieurs unités.

33. Affichage du lasso en temps réel, avec gestion des spécificités du système de coordonnées.

34. Calcul si une unité se trouve dans la zone entourée par le lasso ou pas.

35. Sélection / déselection de bâtiments ou unités et affichage d’un cadre de sélection.

36. Animation des unités frame par frame, avec différents types d’animations (idle, walk).

37. Calcul de quelle tuile d’un tileset afficher en fonction du type d’animation et de la frame dans l’animation.

38. Orientation des unités dans les 8 directions.

39. Affichage du nombre de FPS (frames par seconde).

40. Affichage d’informations de debug à l’écran (mode de jeu, etc.).

41. Utilisation d'outils de débogage pour corriger les erreurs dans le code.

42. Gestion des cases “walkable” et “non walkable” de la map.

43. Calcul de parcours via l’algorithme AStar (A*) évitant les obstacles.

44. Calcul de multiples emplacements d’arrivée d’un groupe d’unités, en prenant en compte les obstacles, autour du point choisi par le joueur.

45. Affichage des emplacements d’arrivée des unités.

46. Déplacement des unités le long du parcours précalculé par l’algorithme A*.

47. Optimisation des déplacements en groupe afin de permettre qu’une seule unité occupe une case à la fois.

48. Optimisation des déplacements en cas de déplacement d’un groupe dense, afin qu’une unité ne reste pas bloquée.

49. Interpolation des déplacements d’unités pixel par pixel.

50. Calcul de l’orientation d’une unité en fonction de la direction de son déplacement.

51. Affichage des chemins que vont empreinter les unités.

52. Limitation des blocages en cas d’absence de chemin possible. 

    
    Et bien d'autres. Ce dont les bases de nombreux gameplays !