Salut à tous .

Je postes ici, car je travaille actuellement sur un jeu de rôle en 2D (je n'en suis encore qu'à la partie "mentale" ) semblable à un Fallout ou Arcanum (je vise un gameplay plus réaliste).
Ceci dit , je suis conscient que c'est un projet de très gande envergure, mais je ne recherche de toute façon pas le résultat final, mais bien l'experience (je ne programme que depuis quelques mois en C++) que je peux acquérir en travaillant dessus , avec la possibilité d'approfondir mes connaissances en matière de POO.

Avant, je faisais, des tas de minis tests graphiques, et autres essais, et je me suis rendu compte que ce n'était rien de plus des parcelles d'un projet semblable à celui-ci, éparpillés sur mon disque dur.

Mon projet a pour objectif d'être entièrement modulable, c'est pourquoi j'ai décidé que la création d'éditeurs en parallèle au jeu (pour permettre la création de mondes, nouveaux objets, etc) était primordiale.
En soit, je cherches plus à faire une plateforme pour jeu de rôle, qu'un jeu à part entière.

Jusqu'à présent, j'ai entamé l'éditeur de monde. Le logiciel est fonctionnel à 75% et toutes les fonctionnalités sont présentes (options, chargement de niveau, etc), sauf celle qui sont liées au jeu lui même (l'affichage graphique des données est encore au stade experimentatif et sera implémenté une fois terminé).

Mon souçi actuel, est que bien que je mette sur papier toute mes idées sur le jeu, l'organisation du moteur du jeu etc, je me suis rendu compte que l'architecture du moteur n'était pas du tout infaillible, mais surtout pas claire et vraiment compliqué .

Pour résumer brièvement (je ne cite pas toutes mes classes, telles que le son) mon jeu tournait de la sorte:

J'avais une classe Monde, qui faisait office de classe principale, et qui regroupait tout les personnages/monstres et objets, ainsi que les méthodes de dessin du monde et données systèmes (sauvegarde, options, etc).
Des classes annexes telles que l'inventaire ou l'ia, étaient liées aux personnages.

Pour un souçi de sécurité, j'ai décidé de bloquer l'accès direct au Monde pour l'utilisateur, et toute l'interface se faisait au niveau de la classe Interface, qui communiquait au monde, et au personnage, les opérations à effectuer.


Il n'y à aucun doute que ma méthode est complètement barbare, et il en sortait que le fonctionnement n'était rien de plus qu'un imbriquement plus qu'aléatoire de mes différentes classes, soit un moteur contraire à l'ergonomie et la simplicité que je souhaites viser ...

Cela étant dit, je me rensegne depuis quelques temps déjà, sur ce qui est fait habituellement, et donc sur la méthode préconisée (bien que j'aimes avoir l'avis, et les pour et contre de chaque solution).
Ce lien est peut être le document le plus complet que j'ai trouvé à ce sujet: ici

J'ai donc essayé de revoir mon organisation, mais je tend à m'embrouiller plus qu'autre chose.

En découpant déjà la partie graphique, de la partie donnée, de la partie sonore, je gagne en simplicité. A partir de là, je vois un peu plus clair, mais il reste quelques choses qui me gènent, ou dumoins que je n'arrive plus à cerner.

Je vous demandes donc votre avis sur les questions suivante, ainsi qu'une quelconque suggetion au sujet des moteurs si vous en avez une (experience personnelle bienvenue ).



Voila, je penses avoir tout dis (Bravo aux courageux qui auraient lu l'intégralité de mon message ).
Comme j'ai dis plus haut, si vous avez vous même déjà programmé un moteur (que ce soit 2D ou 3D), si vous pouviez m'expliquer rapidement comment vous avez procédé, je vous serait reconnaissant .

Je penses que j'aurais été assez clair sur le fait que je ne cherches pas de réponse unique, ou de solution toute faite, mais bien des explications et où des conseils de votre part sur l'organisation et la réalisation d'un moteur de jeu je suis donc ouvert à tout ce que vous pourrez me dire .

Je vous remercie d'avance !!

D'abort , la seul lecture du tuto C++ sur ce site est totalement incomplète pour faire un jeu(ou quoi que se soit d'autre un peu réaliste).

Il faut avoir des notions d'héritage ,de polymorphisme qui ne sont pas encore abordé içi...

Ensuite pour avoir une idée de comment organiser ton jeu (car la ton idée est très débile tu semble faire de l'objet divin [1]) va ici :
http://www.developpez.net/forums/forumdisplay.php?f=66
Et recheche tout les topics qui parlent d'organisation de code.
Tu en apprendra beaucoup.

Ensuite pour répondre a tes questions :

Citation : Pas de titre

Quelle est la place idéale pour l'interface avec l'utilisateur (clavier, souris), doit elle être une classe à part entière, et agir à distance (par quels moyens)? Ou une implémentation simple par contexte est viable

Il faut diviser l'interface en deux : Le moteur de rendu et la GUI.
Le moteur va se charger de d'afficher toutes les sprites a l'écran et de gérer les déplacement/clic de souris.
La GUI elle, va se charger d'afficher toute ce qui n'est pas sprites (bouttons,menu...)

Citation : Pas de titre

Comment faire alors, si par exemple je veux afficher un personnage (contenu dans jeu/données)? J'ai mes petites idées, mais je n'arrive pas à sortir quelque chose de concrêt ...

Chaque donnée affichable redéfinit une fonction virtuelle pure draw qui recoit en paramètre le moteur de rendu.
Ensuite ca fait un truc du genre:

Citation : Pas de titre

J'ai lu quelque part (nottament sur le lien plus haut), qu'il était astucieux de tout gérer via un "Event manager" (on supprime toute communication entres les modules du moteur, et tout passe par ce manager). Bien que je comprennes le concept, je n'arrive pas à saisir les subtilités, ainsi que le fonctionnement brut (envoi/reception des infos).
Je vous remercie d'avance si vous pouviez m'éclaircir à ce sujet

Regarde le code que j'ai fait pour pouvoir faire communiquer des classes entre elles de facon dynamique :
http://prog.codeblog.powa.fr/fileevent.zip



[1]:http://fr.wikipedia.org/wiki/Antipattern#L.27objet_divin

Salut à toi Davidbrcz

Tout d'abord, merci pour ta réponse . J'ai bien pris en note ce que tu m'as dis, consulté quelques posts venant du lien que tu m'as donné (le lien que j'avais proposé n'était pas le seul document que j'ai consulté ).

J'ai aussi jeté un coup d'oeil sur ton fileevent, et je commence enfin à comprendre comment ça fonctionne, et comment c'est réalisé (je n'ai pas pris conscience de l'utilité de conteneur pour ce genre de processus ). Je vois donc à présent comment bien faire communiquer mes modules entres eux, sans qu'elles ne soient directement conscientes l'une de l'autre (ce que je n'arrivais pas à concevoir avant).

Je suis bien conscient que mon organisation du jeu était plus que "débile" , du "n'importe nawak" , mais c'est la raison pour laquelle j'ai posté ici . Bien que la décomposition brute en module pour chaque domaine (graphique, sonore, jeu, réseau, etc) m'étais évidente et logique, j'étais bloqué à l'idée qu'elles soient complètement isolées les unes des autres.
Je vais donc pouvoir etablir une organisation plus logique du moteur (maintenant que je vois comment les faire intéragir entres-elles), et me renseigner en détail sur les conteneurs, que je n'ai encore jamais utilisé.
Je ne suis de toute façon pas pressé de passer à l'action , alors j'ai tout le temps pour me documenter afin de monter, le moment venu un truc stable.

Sinon, au niveau des fonctions virtuelles, quelles sont les utilisations en général pour un moteur de jeu, autre que gérer la possibilité d'utiliser par exemple d'autres moteurs de rendu(ex: SDL, ou OpenGL)?

En gros, si je suis sûr que le moteur restera le même (la partie modulable, est au niveau des données "externes" de jeu tel que le monde, les objets, les quêtes, etc), est-il vraiment utile de prévoir ce genre de fonctions? Y aurait t'il une autre utilisation courante, à laquelle je ne semble pas avoir pensé?

En tout cas, merci de m'avoi éclairçi les idées

Citation : Pas de titre

Sinon, au niveau des fonctions virtuelles, quelles sont les utilisations en général pour un moteur de jeu, autre que gérer la possibilité d'utiliser par exemple d'autres moteurs de rendu(ex: SDL, ou OpenGL)?

L'utilisation des fonctions virtuelles des indispensable dès que tu met a gérer différentes classes d'une même façon car dans les fond elle répondes a un même besoin mais pas de la même facon.
Par exemple , cela me sert dans ma pile d'événement mais cela va me servir aussi dans mes fonctions de rendu.

Citation : Pas de titre

En gros, si je suis sûr que le moteur restera le même (la partie modulable, est au niveau des données "externes" de jeu tel que le monde, les objets, les quêtes, etc), est-il vraiment utile de prévoir ce genre de fonctions? Y aurait t'il une autre utilisation courante, à laquelle je ne semble pas avoir pensé?

J'ai pas vraiment compris.
Si c'est juste les données qui change mais quelles sont toutes au même format , c'est du chargement dynamique de donnée.

Ok, merci , je comprends mieu l'utilité des fonctions virtuelles .

Pour ce qui est de ce que j'ai dis, et que tu n'as pas compris (faut dire j'étais pas très clair ...): je disais que le moteur du jeu n'est pas prévu de changer (pas de support OpenGL, ou de nouveautés prévues), et que seules les données externes au jeu (les niveaux, les objets et autres données sauvées sur des fichiers externes) sont modulables.

Le moteur du jeu est donc "simplement" un interprêteur pour ces données, mais lui ne doit pas changer .
C'est donc comme tu dis, du chargement dynamique de donnée. Le jeu ne pourra pas tourner sans ces fichiers externes.