Petites notes à propos de l'état du moteur à l'heure actuelle:
La version 3 se profile (mais ce n'est pas encore pour demain).
En résumé, 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:
- 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:
- 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.
Exemple avec une classe générique utilisée par tout mes bâtiments:
// ...
private final ProducerAbility<SkillModel, Attributes> producer;
// Constructeur
// ...
@Override
public void addToProductionQueue(String name, int time) {
this.producer.addToProductionQueue(name, time);
}
@Override
public void updateProduction() {
this.producer.updateProduction();
}
@Override
public int getProductionProgress() {
return this.producer.getProductionProgress();
}
@Override
public void stopProduction() {
this.producer.stopProduction();
}
@Override
public int getQueueLength() {
return this.producer.getQueueLength();
}
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 !
Il y a encore beaucoup de secrets, que je ne détaillerais pas pour le moment.
Pour cette prochaine version, j'axe beaucoup le travail sur la doc. En effet, j'essaye de donner une explication sur chaque méthodes et interface/classe abstraites, afin d'en comprendre rapidement le fonctionnement.
De toute façon, 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 (qui commence à devenir sacrément complexe...)
Affaire à suivre ;)
il y a 20 ans, un tas de jeux étaient développés par des équipes très réduites, voire des personnes seules. 
