Bonjour,
 
J'aimerai bien commencer le codage d'un petit pong en C++ (avec OpenGL mais ça c'est pas important ici) histoire d'apprendre à coder proprement des jeux.
Donc coder un pong en soit c'est pas trop difficile, en mettant des if et des else partout des fonctions ici et là vas y que je t'en met... seulement c'est pas très propre... et pour faire des jeux plus poussés (pas que pour les jeux d'ailleurs) ca ne sera plus très efficace... surtout que ca fait pas très PrOO...
Donc pour que ca fasse bien POO comme il faut, il faudrait que tout le code soit englobé dans des classes.
Le main devrait donc pouvoir se limiter a quelque chose comme ca :
 
int main(int argc, char* argv[]) {
    new Game();
 
    return 0;
}
 
On lancerait donc toute la machine dans le constructeur de Game et puis après dans le reste du programme on aurait plus que des classes qui communiquent entre elles.
Es-ce que c'est une bonne façon de faire ?
Maintenant ma question c'est surtout comment faire pour choisir quelles classes vont composer le programme ? Y'a t-il des techniques ou des règles ?
 
Merci bien.
Bonne soirée!
 
 

Salut,
 
1- Classiquement le code d'un tel programme tourne dans un while() de ce type (en version simplifiée; les noms des fonctions sont bidons):
 
initScreen();
while (notfinished)
{
updateGameLogic()
updateScreen()
verifySomeoneWon()
}
 
Ceci pourrait être le contenu de ta classe Game (pas du constructeur, mais d'une méthode run() par ex.)
En gros tu réitères un certain nombre d'étapes qui forment la logique du jeu et ce plusieurs fois par seconde.
 
2- Un objet est composé de données et de traitements. Les traitements s'appliquent sur les données contenues.
 
Donc une classe se fait en fonction de ces données qui sont indépendantes les unes des autres.
 
Par exemple une classe Joueur, une classe Jeu, une classe Balle, une classe Raquette, de ce style:
 
class Joueur
{
String name;
int points;
 
Joueur (String name)
{
this->name = name;
points = 0;
}
 
void addPoints (int num)
{
this->points += num;
}
 
 
}

Je ne suis pas certain que ce soit une bonne idée.
 
On est souvent tenté de mettre trop de chose dans le constructeur. Mais le constructeur est limité. Par exemple, il ne renvoie pas de message d'erreur. C'est gênant, si on ouvre un fichier de paramètres, et que l'ouverture se passe mal car le chemin est mauvais, ou une autre raison. Ou si on alloue de la mémoire, et que cela échoue.
 
En fait, d'après mon expérience, je trouve qu'il est préférable de ne mettre que des initialisations très simples dans les constructeurs. Ensuite, pour certains objets, s'il faut une initialisation complémentaire, il est possible de la mettre dans une méthode, que j'appelle après la création de l'objet.
 

en même temps tu peux toujours lever une exception dans un constructeur

Déjà, merci à vous pour vos réponses.
Et effectivement, l'idée de lancer le tout dans le constructeur n'est pas très propre.
Je me doute bien qu'il faut faire une classe balle, raquette, etc mais le problème vient de la façon de faire communiquer ces classes ensemble... de manière à ce que ca soit assez flexible et réutilisable.
Par exemple, si maintenant je programme un pong jouable à 2 sur un même PC (pour faire simple) et que apres j'aimerai le faire fonctionner en réseau local, il serait bien de ne pas avoir à tout rearchitecturer...
Y'a pas longtemps, j'ai lu un article sur le pattern MVC (Modele - Vue - Controlleur) et ca a l'air d'être une facon propre d'organiser les choses, seulement dans certains articles il était indiqué que ce n'est pas tres adapté pour les jeux vidéos, et dans d'autres il est dit le contraire... Vous en pensez quoi ?

Le framework MVC sert uniquement de  modèle entre tes sources de données et leur représentation à l'écran. Pour un jeu multi c'est une autre partie en dehors de ce modèle MVC qu'il faudra greffer.