C++ : Jeu Damier (aide)

Marsh Posté le 10-02-2012 à 02:31:28

Bonjour,
Est-ce qu'il y a quelqu'un qui peut me dire quel est le problème dans mon code:

Instructions:
Le jeu est composé d'un damier de 8 lignes et de 12 colonnes. L'objectif est en se déplaçant sur le damier, de découvrir 15 cases où il y a des $$$$ cachés, et bien sûr de ramasser ces $$$$. Le jeu se termine lorsqu'on a cumulé 15 point (ou si on ferme la fenêtre de jeu). Tout déplacement illégal sera signalé par un beep (tentative de déplacement hors du jeu ou sur une case de type mur noir).

Chaque case du jeu est visible sous une des formes suivant:
-pierre blanche;
-pierre grise;
-mur noir;
-$$$$;

Au début toutes les case forment un mur noir ou sont composées de pierre blanche. Lorsque vous quitterez une case pierre blanche, celle-ci deviendra pierre grise ou bien $$$$.
Si on découvre une case $$$, retournez-y pour amasser votre fortune. En quittant la case $$$$, celle-ci devient pierre grise.
Lorsqu'on quitte une case pierre grise elle devient mur noir et on ne peut plus passer par là.

Diagramme d'action (avant première ébauche):
Afficher le jeu
Tant que point < 15
Lire ToucheValide (une touche valide étant une touche de déplacement)
Valider le déplacement
Calculer le nouvelle position courante (si le déplacement est valide)
Modifier le code de la nouvelle case courante (si le déplacement est valide)
Afficher le jeu (Si nécessaire)

Code :

#include <iostream>
#include <conio.h>
#include <iomanip>
using namespace std;
void main(void)
{
const int BAS=80, HAUT=72, DROITE=77, GAUCHE=75, HD=73, HG=71, BG=79, BD=81;
const int NB_LIG=8, NB_COL=12;
int i=0, j=0, Lig=0, Col=0, Points=0;
// Matrice composant le damier du jeu :
// 0==Normal(Pierre blanche), 1==$$$$ caché, 2==$$$$ visible, 3==Pierre grise, 4==Mur Noir
int Mat[NB_LIG][NB_COL]={ { 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1},
{ 0, 0, 4, 4, 0, 0, 0, 0, 0, 4, 0, 4},
{ 0, 0, 4, 1, 4, 0, 0, 0, 0, 0, 4, 1},
{ 0, 0, 4, 1, 4, 0, 0, 4, 4, 0, 4, 1},
{ 1, 0, 4, 4, 4, 1, 4, 0, 4, 0, 4, 0},
{ 1, 0, 1, 1, 0, 1, 4, 1, 4, 0, 4, 0},
{ 1, 0, 1, 0, 0, 0, 4, 4, 4, 0, 4, 0},
{ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
};
char Touche;
bool TValide = false;
bool DValide = false;
cout << "D\x82" "couvrez et amassez 15 cases $$$$"<< setw(44) << "Points:" << Points;
while (Points<15)
{
/* VALIDER LA TOUCHE */
do
{
Touche = _getch();
if (Touche==80 || Touche==72 || Touche==77 || Touche==75 || Touche==73 || Touche==71 || Touche==79 || Touche==81)
{
TValide = true;
}
} while(!TValide);
/* VALIDER LE DÉPLACEMENT ET SE DÉPLACER */
switch (Touche)
{
// Bas
case 80:
if (Lig==NB_LIG-1 || Mat[Lig+1][Col]==4)
DValide = false;
else
{
Lig++;
DValide = true;
}
break;
// Haut
case 72:
if (Lig==0 || Mat[Lig-1][Col]==4)
DValide = false;
else
{
Lig--;
DValide = true;
}
break;
// Droite
case 77:
if (Col==NB_COL-1 || Mat[Lig][Col+1]==4)
DValide = false;
else
{
Col++;
DValide = true;
}
break;
// Gauche
case 75:
if (Col==0 || Mat[Lig][Col-1]==4)
DValide = false;
else
{
Col--;
DValide = true;
}
break;
// Haut Droite
case 73:
if (Col==NB_COL-1 || Lig==0 || Mat[Lig-1][Col+1]==4)
DValide = false;
else
{
Lig--;
Col++;
DValide = true;
}
break;
// Haut Gauche
case 71:
if (Lig==0 || Col==0 || Mat[Lig-1][Col-1]==4)
DValide = false;
else
{
Lig--;
Col--;
DValide = true;
}
break;
// Bas Gauche
case 79:
if (Lig==NB_LIG-1 || Col==0 || Mat[Lig+1][Col-1]==4)
DValide = false;
else
{
Lig++;
Col--;
DValide = true;
}
break;
// Bas Droite
case 81:
if (Lig==NB_LIG-1 || Col==NB_COL-1 || Mat[Lig+1][Col+1]==4)
DValide = false;
else
{
Lig++;
Col++;
DValide = true;
}
break;
}
// MODIFICATION DE LA MATRICE ET ACCUMULATION DE POINTS
while (!DValide)
{
if (Mat[Lig][Col]==0){
Mat[Lig][Col]=3;
DValide = true;}
if (Mat[Lig][Col]==1){
Mat[Lig][Col]=2;
DValide = true;}
/* CETTE PARTIE N'A PAS L'AIR DE FONCTIONNER--------------*/
if (Mat[Lig][Col]==2){
Mat[Lig][Col]=3;
Points++;
DValide = true;}
if (Mat[Lig][Col]==3){
Mat[Lig][Col]=4;
DValide = true;}
/*---------------------------------------------------------*/
}
//--------------------------------------------------------------------------
/* AFFICHER LE JEU */
for (i=0; i<NB_LIG; i++) // Pierre blanche + $$$$ cache
{
for (j=0; j<NB_COL; j++)
{
if (Mat[i][j]==0 || Mat[i][j]==1)
{
gotoxy(j*5+11, i*3+3);
cout << (char) 178 << (char) 178 << (char) 178 << (char) 178;
gotoxy(j*5+11, i*3+4);
cout << (char) 178 << (char) 178 << (char) 178 << (char) 178;
}
}
}
for (i=0; i<NB_LIG; i++) // $$$$ visible
{
for (j=0; j<NB_COL; j++)
{
if (Mat[i][j]==2)
{
gotoxy(j*5+11, i*3+3);
cout << "$$$$";
gotoxy(j*5+11, i*3+4);
cout << "$$$$";
}
}
}
for (i=0; i<NB_LIG; i++) // Pierre grise
{
for (j=0; j<NB_COL; j++)
{
if (Mat[i][j]==3)
{
gotoxy(j*5+11, i*3+3);
cout << (char) 176 << (char) 176 << (char) 176 << (char) 176;
gotoxy(j*5+11, i*3+4);
cout << (char) 176 << (char) 176 << (char) 176 << (char) 176;
}
}
}
//-------------------------------------------------------------------------------------
/* CURSEUR (POSITION INITIALE)*/
gotoxy(Col*5+11, Lig*3+3);
cout << (char) 201 << (char) 203 << (char) 203 << (char) 187;
gotoxy(Col*5+11, Lig*3+4);
cout << (char) 200 << (char) 202 << (char) 202 << (char) 188;
} // Fin boucle while()
_getch();
}

Les problèmes:
1) Lorsque je clique 2x sur les extrémités (ex: je suis au coin de départ Mat[0][0], je descend d'une case pour ensuite appuyer sur "haut" "haut" ) l'empreinte du curseur reste à la case Mat[0][0] mais, mon curseur se déplace quand même. Si je clique 3x sur une touche (directionnant vers le hors-champ) lorsque je suis à une extrémité, mon curseur ne se déplace plus.

2) Au départ, l'écran est noir avec seulement la ligne "cout << "D\x82" "couvrez et amassez 15 cases $$$$"<< setw(44) << "Points:" << Points;". Je dois appuyer sur une touche directionnelle pour afficher le jeu, alors que le jeu doit s'afficher immédiatement lorsque j'ouvre l'exécutable.

3) Les cases sont toutes grises au départ (elles sont supposées d'être blanches) et aucun changement ne se fait lorsque je me déplace.

4) Devrais-je plutôt mette la "MODIFICATION DE LA MATRICE ET ACCUMULATION DE POINTS" dans aucune boucle? Est-ce que le while est inutile?

Message édité par CH0622 le 10-02-2012 à 02:32:55

Reply

Marsh Posté le 10-02-2012 à 02:31:28

Reply

Marsh Posté le 10-02-2012 à 15:34:04

L'erreur de base, c'est déjà de tout mettre dans un main unique, ce qui ne te permet plus de comprendre pourquoi l'affichage n'est pas appelé (pour le 2) tellement ton code est monobloc.

A+,

---------------
There's more than what can be linked! -- Iyashikei Anime Forever! -- AngularJS c'est un framework d'engulé! --

Reply

Marsh Posté le 10-02-2012 à 18:04:49

Pour l'affichage c'est facile : tu as une belle boucle while qui ne se termine qu'a l'appui d'une touche et elle se trouve avant le code d'affichage, donc forcément, tant que n'appuie pas sur une touche le code d'affichage n'est pas appelé.

Comme gilou te le conseille, commence par découper ton code avec des fonctions ou des classes, on dirait un vieux code non structuré.

Une classe 'Damier' qui contient ta matrice, des méthodes de déplacement qui font les vérifications de validité, une méthode d'affichage, et on verrait bcp plus clair.

Ensuite par exemple :

Code :

while (!DValide)
{
if (Mat[Lig][Col]==0){
Mat[Lig][Col]=3;
DValide = true;}
if (Mat[Lig][Col]==1){
Mat[Lig][Col]=2;
DValide = true;}
/* CETTE PARTIE N'A PAS L'AIR DE FONCTIONNER--------------*/
if (Mat[Lig][Col]==2){
Mat[Lig][Col]=3;
Points++;
DValide = true;}
if (Mat[Lig][Col]==3){
Mat[Lig][Col]=4;
DValide = true;}

Si par hasard Mat[Lig][Col]==1 au début, tu le passes à 2 PUIS tu tests s'il est == 2 et tu le passes à 3 ET tu testes == 3 et tu le passes à 4...
En fait dans tous les cas tu va mettre 4 comme valeur pour Mat[Lig][Col]...
Quel intérêt de mettre un while ici ? Tu peut soit faire un switch/case soit utiliser if/else.
En plus tu testes "while (!DValide)" donc:
- Si ton déplacement est invalide tu modifies les valeurs de ta case (en écrivant toujours 4)
- Si ton déplacement est valide tu ne change pas les valeurs

Reply

Marsh Posté le 10-02-2012 à 19:04:34

Tout fonctionne.... MAIS à l'exception de...

J'ai un autre problème (que j'ai oublié de mentionner)... mon pointage ne s'accumule pas. Il est toujours à 0. Le problème c'est surement que je ne l'ai pas mis dans la grande boucle (while<15), mais je ne sais pas où exactement mettre la variable Points. Je l'ai mise à certaines place dans la boucle mais, lors de l'exécution, la ligne 27 "cout << "D\x82" "couvrez et amassez 15 cases $$$$"<< setw(44) << "Points:" << Points;" s'affiche un peu partout sur mon jeu mais le pointage s'accumule par contre. Je voudrais qu'elle reste au point (0,0).

Message édité par CH0622 le 10-02-2012 à 19:38:45

Reply

Marsh Posté le 10-02-2012 à 23:32:25

C'est pas bien d'effacer son sujet alors que je tape une version qui passe sous code::blocks et ne necessite pas le bousin propriétaire et pas portable de conio.h

Bon, c'est pas un modèle du genre, et si j'avais fait ça en C++, j'aurais fait autrement, mais partant de ton code, et grosso modo, en découpant un peu ça de manière plus logique, ça donne ceci:

Code :

#include <iostream>
#include <cstdio>
#include <iomanip>
#include <windows.h>
using namespace std;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Emulation de procédures de dev-C++ (pas portables) sous windows
int getx(void) {
CONSOLE_SCREEN_BUFFER_INFO window;
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &window);
return window.dwCursorPosition.X;
}
int gety(void) {
CONSOLE_SCREEN_BUFFER_INFO window;
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &window);
return window.dwCursorPosition.Y;
}
void setx(int x) {
COORD pos;
pos.X = x;
pos.Y = gety();
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}
void sety(int y) {
COORD pos;
pos.X = getx();
pos.Y = y;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}
void gotoxy(int x,int y) {
setx(x);
sety(y);
}
void clrscr()
{
COORD pos;
COORD cs = { 0, 0 };
DWORD written;
CONSOLE_SCREEN_BUFFER_INFO window;
pos.X = 0;
pos.Y = 0;
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &window);
FillConsoleOutputCharacter(GetStdHandle(STD_OUTPUT_HANDLE), TEXT(' '), window.dwSize.X * window.dwSize.Y, cs, &written);
gotoxy(0,0);
}
WORD _getch() {
HANDLE handle = GetStdHandle(STD_INPUT_HANDLE);
DWORD events;
INPUT_RECORD buffer;
do {
ReadConsoleInput(handle, &buffer, 1, &events); // attend de manière bloquante un évènement clavier, menu, focus, souris...
} while (buffer.EventType != KEY_EVENT || !buffer.Event.KeyEvent.bKeyDown);
return buffer.Event.KeyEvent.wVirtualKeyCode;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const int NB_LIG = 8;
const int NB_COL = 12;
const int cell_width = 4;
const int cell_height = 2;
const int cell_top_margin = 3;
const int cell_left_margin = 11;
const int cell_margin = 1;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 0 == Normal(Pierre blanche), 1 == $$$$ caché, 2 == $$$$ visible, 3 == Pierre grise, 4 == Mur Noir
void PaintCell(int li, int co, int mode) {
char color;
switch(mode) {
case 0:
case 1:
color = 178;
break;
case 2:
color = '$';
break;
case 3:
color = 176;
break;
case 4:
color = ' ';
break;
default:
color = ' ';
break;
}
for (int k = 0; k < cell_height; ++k) {
gotoxy(cell_left_margin + co * (cell_width + cell_margin), k + cell_top_margin + li *(cell_height + cell_margin));
for (int l = 0; l < cell_width; ++l) {
cout << color;
}
}
}
void PaintCursor(int li, int co) {
gotoxy(cell_left_margin + co * (cell_width + cell_margin), cell_top_margin + li *(cell_height + cell_margin));
// cablé sur une largeur de 4
cout << (char) 201 << (char) 203 << (char) 203 << (char) 187;
// puis cell_height - 2 lignes a remplir si la hauteur n'est pas 2, puis
gotoxy(cell_left_margin + co * (cell_width + cell_margin), (cell_height - 1) + cell_top_margin + li *(cell_height + cell_margin));
// cablé sur une largeur de 4
cout << (char) 200 << (char) 202 << (char) 202 << (char) 188;
}
//positionne juste après la fin du tableau affiché
void EndPos() {
gotoxy(cell_width + cell_left_margin + ((NB_COL - 1) * (cell_width + cell_margin)),
(cell_height - 1) + cell_top_margin + ((NB_LIG - 1) * (cell_height + cell_margin)));
}
recalcule la couleur et éventuellement met a jour le score
int recalc(int color, int *score) {
switch (color) {
case 0:
color = 3;
break;
case 1:
color = 2;
break;
case 2:
color = 3;
++*score;
break;
case 3:
color = 4;
break;
case 4:
default:
break;
}
return color;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
int i=0, j=0, Lig=0, Col=0, Points=0;
// Matrice composant le damier du jeu :
// 0==Normal(Pierre blanche), 1==$$$$ caché, 2==$$$$ visible, 3==Pierre grise, 4==Mur Noir
int Mat[NB_LIG][NB_COL]= { { 1, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1},
{ 0, 0, 4, 4, 0, 0, 0, 0, 0, 4, 0, 4},
{ 0, 0, 4, 1, 4, 0, 0, 0, 0, 0, 4, 1},
{ 0, 0, 4, 1, 4, 0, 0, 4, 4, 0, 4, 1},
{ 1, 0, 4, 4, 4, 1, 4, 0, 4, 0, 4, 0},
{ 1, 0, 1, 1, 0, 1, 4, 1, 4, 0, 4, 0},
{ 1, 0, 1, 0, 0, 0, 4, 4, 4, 0, 4, 0},
{ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
};
WORD Touche;
bool TValide = false;
bool DValide = false;
bool quit = false;
clrscr();
cout << "D\x82" "couvrez et amassez 15 cases $$$$"<< setw(44) << "Points:" << Points;
for (i=0; i<NB_LIG; i++) {
for (j=0; j<NB_COL; j++) {
PaintCell(i, j, Mat[i][j]);
}
}
// Pour la position initiale
PaintCursor(Lig, Col);
// a toi de voir si tu veut le faire ou pas pour la position de départ
Mat[Lig][Col] = recalc(Mat[Lig][Col], &Points);
// Boucle principale du jeu
// On boucle jusqu'à ce que le score soit bon ou qu'on quitte
do {
DValide = false;
// On boucle jusqu'a avoir un déplacement valide
do {
TValide = false;
// On boucle jusqu'a avoir une touche valide
do {
switch (Touche = _getch()) {
case VK_DOWN:
case VK_UP:
case VK_RIGHT:
case VK_LEFT:
case VK_PRIOR:
case VK_NEXT:
case VK_END:
case VK_HOME:
case VK_ESCAPE:
TValide = true;
break;
default:
TValide = false;
break;
}
} while(!TValide);
// On a une touche valide, on regarde si le déplacement est valide
// sinon on reboucle
switch(Touche) {
case VK_DOWN:
DValide = ((Lig < NB_LIG - 1) && (Mat[Lig+1][Col] != 4));
break;
case VK_UP:
DValide = ((Lig > 0) && (Mat[Lig-1][Col]!=4));
break;
case VK_RIGHT:
DValide = ((Col < NB_COL - 1) && (Mat[Lig][Col+1] != 4));
break;
case VK_LEFT:
DValide = ((Col > 0) && (Mat[Lig][Col-1] != 4));
break;
case VK_PRIOR:
DValide = ((Col < NB_COL - 1) && (Lig > 0) && (Mat[Lig-1][Col+1]!=4));
break;
case VK_NEXT:
DValide = ((Lig < NB_LIG - 1) && (Col < NB_COL - 1) && (Mat[Lig+1][Col+1] != 4));
break;
case VK_END:
DValide = ((Lig < NB_LIG - 1) && (Col > 0) && (Mat[Lig+1][Col-1] != 4));
break;
case VK_HOME:
DValide = ((Lig > 0) && (Col > 0) && (Mat[Lig-1][Col-1] != 4));
break;
case VK_ESCAPE:
DValide = true;
break;
}
} while (!DValide);
// On va changer de position on repaint la case ou l'on était, que le curseur quitte
gotoxy(0,0);
cout << "D\x82" "couvrez et amassez 15 cases $$$$"<< setw(44) << "Points:" << Points;
PaintCell(Lig, Col, Mat[Lig][Col]);
// on a eu un déplacement valide, on effectue le changement de position
switch(Touche) {
case VK_DOWN:
++Lig;
break;
case VK_UP:
--Lig;
break;
case VK_RIGHT:
++Col;
break;
case VK_LEFT:
--Col;
break;
case VK_PRIOR:
--Lig;
++Col;
break;
case VK_NEXT:
++Lig;
++Col;
break;
case VK_END:
++Lig;
--Col;
break;
case VK_HOME:
--Lig;
--Col;
break;
case VK_ESCAPE:
quit = true;
break;
}
// On paint le curseur à la position courante
PaintCursor(Lig, Col);
// Pas certain que ce soit le moment adéquat
// a toi de voir quand le score doit être recalculé
Mat[Lig][Col] = recalc(Mat[Lig][Col], &Points);
} while (Points < 15 && !quit);
// Pour que la console reprenne bien positionnée après l'écran de jeu
EndPos();
printf("\n" ); // le prompt juste sous le tableau c'est moche
return 0;
}

J'espère que tu vois la qu'en découpant de manière logique ton switch en deux:
un pour la validité du déplacement et un pour le déplacement lui même, ça devient bien plus clair et simple comme code.
J'ai écrit des procédures assez génériques si tu modifies la taille des cases, mais celle d'affichage du curseur ne l'est pas.
A+,

Message édité par gilou le 12-02-2012 à 04:23:45

---------------
There's more than what can be linked! -- Iyashikei Anime Forever! -- AngularJS c'est un framework d'engulé! --

Reply

C++ : Jeu Damier (aide)

Sujets relatifs:

Leave a Replay