LionEngine (Moteur 2D en Java)
Bonjour,
Je me permet de vous présenter mon moteur de jeu, le LionEngine (développé en Java), permettant de réaliser des jeux plus rapidement, grâce à un ensemble d'outils pour manipuler les ressources (Images, Son, Entrées...), ainsi qu'un lot de classes abstraites pour faciliter le développement.
J'ai commencé à travailler sur ce moteur en même temps que j'étais sur mon remake de Lionheart (version Java).
L'intérêt était de réaliser un moteur correspondant aux besoins (d'où le développement d'un jeu en simultané utilisant ce moteur).
(Il me sert aussi pour mon remake de Warcraft I)
L'objectif de ce moteur est de regrouper un ensemble de classes abstraites contenant les éléments les plus redondant/communs pour chaque types de jeux (Plateforme, Stratégie, RPG...). En effet, que ce soit un Mario, ou un Lionheart (sur Amiga, connu notamment pour son aspect technique), plusieurs aspects sont identiques.
Voici ce que permet entre autre le moteur à l'heure actuelle (version 2):
- Gestion de l'affichage (compatible fenêtré/plein écran)
- Contrôle de la résolution de l'écran (largeur, hauteur, profondeur)
- Gestion facile des ratios d'affichage (4:3, 5:4, 16:9, 16:10)
- Gestion précise du frame rate (extrapolation possible)
- Chargement rapide de graphismes (bmp, png, jpg)
- Contrôle avancé des graphismes (sprites, animations, tiles, parallaxe...)
- Chargement et lecture de fichiers audio (wav, mp3)
- Manipulation de fichiers (lecture/écriture/parseur xml)
- Interception des entrées (clavier/souris) (détection des touches, clics souris...)
- Option de filtrage (Bilinéaire, hq3x)
- Petit réseau (Client/Serveur/Sockets)
- Ensemble de classes abstraites prêtes à l'utilisation (world, map, player, camera, pathfinding...)
- Plusieurs classes utilitaires (courbes curvées, parseur, fenêtres...)
- Ensemble d'exemples (launcher, jeu de plateforme, pathfinding...)
Exemples de points possibilités techniques:
- Imitation du rasterbar (technique sur Amiga pour augmenter le nombre de couleurs)
- Filtrage HQ3X:
- Réaliser un prototype de Mario rapidement:
- Remake Warcraft I:
* La page du projet se trouve ici:
http://www.b3dgs.com/v5/page.php?lan...ion=lionengine
* Les tutos/cours se trouvent ici:
http://poj.b3dgs.com/page.php?lang=fr§ion=home
(Explications théoriques sur la partie interne d'un moteur, réalisation d'un jeu de plateforme...)
* Deux projets en construction à l'aide de ce moteur:
- Lionheart Remake (Plateforme)
- Warcraft Remake (STR)
Actuellement, je travaille la partie "Jeux de Stratégie";
* Voici un petit avancement:
- Attaque
- Extraction, mouvement en groupe
- Projectiles
- Projectiles multiples
Je précise que ces vidéos ont pour but de présenter des caractéristiques gérées par le moteur de manière abstraite, et modulable; ce n'est pas le Gameplay qui est mis en avant. Ce point sera abordé dans le cadre d'un jeu utilisant le moteur.
* Petites notes à propos de l'état du moteur à l'heure actuelle (version 3 encours):
J'ai apporté énormément de couches abstraites pour aider à la réalisation d'un jeu de type Stratégie (et conjointement Hack'N Slash).
Entre autre, l'architecture est découpé de cette façon:
Objets abstraits
* AbstractEntity : classe la plus basse désignant tout objet pouvant appartenir ou non à un joueur, avec lequel il est possible d’interagir (de manière plus grossière, les bâtiments et les unités)
- AbstractBuilding : première couche plus spécifique, réalisant un contrôle bas niveau de ce que peut être un bâtiment
- AbstractUnit : comme précédemment, mais pour les unités.
Dans un but d'architecture propre, et de modularité la plus extrême possible (afin de ne pas brider les volontés du développeur), j'ai organisé les "habilités" principales en module, afin d'avoir un couplage le plus faible possible:
Habilités
* BuilderAbility : module permettant à celui qui l'utilise de construire un objet de type AbstractBuilding à une position spécifique. Il est aussi possible de compléter les méthodes de bases (par exemple, pour afficher la progression à l'écran)
* ExtractAbility : module traitant l'extraction de ressource (généralement associé à la même unité pouvant construire). Il est possible de définir un lieu d'extraction (de type AbstractEntity), ou d'une localité (pour un Tile par exemple, comme des arbres). La routine bas niveau s'occupera de gérer les allé-retour de l'unité; après avoir spécifié la zone de retour (pouvant être calculée automatiquement à partir du plus court chemin, selon les attributs définis par le programmeur)
On pourra aussi définir un temps d'extraction/dépôt, avec les animations qui vont bien, et des effets supplémentaire en remplissant la fonction prévue à cet effet.
* ProducerAbility : ce module permettra de produire n'importe quoi de type AbstractUnit. Généralement utilisé par les bâtiments (même si c'est applicable à une unité), le fonctionnement est similaire à la classe précédente, avec une routine fonctionnant en interne, qu'il est possible de compléter. Là encore, on peut définir la capacité de la file de production, le temps pour chaque élément, avoir la progression...
* AttackerAbility : ou comment transformer le possesseur en unité de combat. Je ne donnerai pas trop de détails sur cette dernière, car j'y travaille.
Ces principales habilités sont donc applicables à n'importe quoi. Tout ce qu'il faut, c'est ajouter un champs à la classe l'utilisant, implémenter l'interface, et effectuer une délégation pour chaque méthode.
Il est aussi possible de redéfinir une habilité en héritant de la version abstraite (pour des cas plus particulier).
Ensuite, c'est un peu de même pour des classes moins générale, telles que StrategyCamera (gérant le point de vue du joueur), et StrategyCursor (pour cliquer sur la map ou le panel de contrôle, ou encore effectuer une sélection avec filtrage des éléments selon ce que l'on souhaite).
Même chose pour les deux principales routines: AbstractEntryHandler (qui s'occupe de mettre à jour tous les objets), et AbstractControlPanel (pour gérer le panel, afin d'avoir des infos sur les unités sélectionnées, leur actions...)
Concernant les compétences, j'ai essayé de construire quelque chose de solide et efficace:
Que ce soit pour lancer un sort (Heal, Firebolt...), déplacer, attaquer, construire; tout est mis au rang de Skill au sens large.
Il suffit de décrire dans un fichier externe, des infos (nom, description, icone...), de créer une classe pour chacune d'elles, d'appeler la méthode addSkill(...) d'une AbstractEntity, et cette dernière apparait dans le Panel de contrôle, et on peut interagir avec celle-ci. Tout est paramétrable à souhait et facilement (je veux afficher les compétences sur 3 colonnes, avec un espacement X Y, et rajouter un cadre de sélection; ou cacher ce bloc, dans le cas d'un grand nombre).
Il suffit ensuite de définir l'action de cette compétence (appeler la BuildAbility pour construire un bâtiment à partir de son nom; produire une unité en l'ajoutant à la file de production; donner de la vie à un blessé...)
Il est évidemment aussi facile d'ajouter des effets visuel et sonore.
Je travaille en parallèle sur un remake de Warcraft I, et je m’étonne moi même de la facilité à développer un tel jeu en utilisant mon moteur !
Lorsque j'arriverai à quelque chose de très productif, je préparerai un tuto pour réaliser un jeu de stratégie; ainsi qu'une doc expliquant l'architecture globale du moteur.
Merci d'avoir eu le courage de lire jusque ici
Répondre avec citation
Envoyé par DjThunder
Partager