[C] Afficher une grille

[Vupen]

Bonsoir,

Débutant en C, je dois réaliser un démineur. Pour cela, j'ai à ma disposition la lib CINI crée exprès pour mon UE. Elle dispose des fonctions usuelles + des fonctions graphiques comme

- CINI_open_window pour créer la fenetre;
– CINI_fill_rect(X0, Y0, LARGEUR, HAUTEUR, COULEUR) pour dessiner un rectangle avec (X0, Y0) les coordonnées du sommet supérieur gauche. Je dois m'en servir pour tracer la bordure autour de la grille (en plus de la bordure "naturelle" de la grille) et pour tracer les traits de la grille, d'épaisseurs fixées.
– CINI_draw_string pour ecrire dans une case le nombre de ses voisins;
– CINI_loop_until_clic pour attendre un clic souris;
– CINI_clic_posx et CINI_clic_posy pour récupérer les coordonnées du dernier clic de l’utilisateur.

Mon problème, pour le moment, c'est d'afficher la grille. Pour ne pas avoir de pb pour les cases à la limite, le DM impose une grille de dimension M+2*N+2 mais seulement la grille M*N sera affichée (les autres cases, elles seront non minées par défaut).

Voici un bout de code (le "bla bla" c'est pour les fonctions d'intéraction avec le joueur toussa, mais y a pas de pb, ça compile bien).

http://pastebin.com/dwkBKBx7

Cela me donne l'image suivante (il me manque donc 2 traits) :

http://www.noelshack.com/2014-11-1394915854-capture1.png

Si j'augmente de deux la variable i (jusqu'à X + 4 donc), j'obtiens presque la grille, (à 1-2 pixels près) mais du coup, cela contredit mes calculs que j'ai beau refaire, je ne trouve pas la faille ...

http://www.noelshack.com/2014-11-1394915863-capture2.png

Merci d'avance.

[fatal_error]

ben sachant qu'il manque la signification de N, terrain_x, tes fonctions d'affichage... c'est quand même assez difficile...

Sinon t'as qu'à prendre i=0 à i

[Vupen]

Oui, j'ai oublié, N et M sont dans des #define et sont fixées à 10.

MàJ : http://pastebin.com/dwkBKBx7

[Vupen]

Bah terrain_x et terrain_y ce sont resp la largeur et hauteur de la grille (en compte les bordures de largeur BORD autour de la grille + les 11 traits de largeur TRAIT intrinsèques à la grille)

[Vupen]

Si je prends i = 0 -> < X +2, j'obtiens ceci

http://www.noelshack.com/2014-12-1395176621-capture3.png

[fatal_error]

on va clairement pas s'en sortir si tu y vas au compte goutte.

Donc :
- tu n'as toujours pas dit ce que fait CINI_fill_rect, ni à quoi servent ses arguments
- lorsque tu montres une image, montre son code associé, sinon on peut pas deviner

Enfin:

Code: Tout sélectionner

#define M 10 // lignes
#define N 10 // colonnes
#define Y M-2 // lignes
#define X N-2 // colonnes

ces commentaires sont complètement incohérents. si M vaut 10 et désigne "lignes" c'est quoi "lignes", alors pourquoi Y=8 désigne la même chose!!!!

Code: Tout sélectionner

#define CASE 50
//case ca désigne quoi!!!
#define TRAIT 2
//pareil pour trait
#define BORD 2
//et également pour bord

Appeler M au lieu de NB_LIGNES c'est déjà discutable, mais si en plus tu appèles Y en lui associant la même signification mais une valeur différente, c'est attendre de te faire flageller...

idem case, appèle le CASE_WIDTH
idem BORDER_WIDTH, TRAIT je sais même pas ce que c'est...

donne du sens à ton code sans quoi on devine quedalle.

Mais sinon, c'est juste un problème d'indice, qui se résoud trivialement:

Code: Tout sélectionner

CINI_fill_rect(X0 + BORD + (i-1)*(TRAIT + CASE), Y0, TRAIT, terrain_Y, "grey") ;

semble tracer une ligne.
Ben tu crèes ta fonction qui trace ca.
et tu vérifies pour chaque valeur de X passé quelle est la ligne qui est tracée...

[Vupen]

on va clairement pas s'en sortir si tu y vas au compte goutte.

Donc :
- tu n'as toujours pas dit ce que fait CINI_fill_rect, ni à quoi servent ses arguments
- lorsque tu montres une image, montre son code associé, sinon on peut pas deviner

Euh, si, dans l'intro :

CINI_fill_rect(X0, Y0, LARGEUR, HAUTEUR, COULEUR) pour dessiner un rectangle avec (X0, Y0) les coordonnées du sommet supérieur gauche.

Enfin:

Code: Tout sélectionner

#define M 10 // lignes
#define N 10 // colonnes
#define Y M-2 // lignes
#define X N-2 // colonnes

ces commentaires sont complètement incohérents. si M vaut 10 et désigne "lignes" c'est quoi "lignes", alors pourquoi Y=8 désigne la même chose!!!!

J'ai aussi expliqué ça dans l'intro

Pour ne pas avoir de pb pour les cases à la limite, le DM impose une grille de dimension M+2*N+2 mais seulement la grille M*N sera affichée (les autres cases, elles seront non minées par défaut).

La grille que j'affiche est donc la grille Y*X

Code: Tout sélectionner

#define CASE 50
//case ca désigne quoi!!!
#define TRAIT 2
//pareil pour trait
#define BORD 2
//et également pour bord

CASE désigne la largeur d'une case, TRAIT la largeur des traits de la grille (bordures comprises) et BORD la largeur de la bordure autour de la grille)

Mais sinon, c'est juste un problème d'indice, qui se résoud trivialement:

Code: Tout sélectionner

CINI_fill_rect(X0 + BORD + (i-1)*(TRAIT + CASE), Y0, TRAIT, terrain_Y, "grey") ;

semble tracer une ligne. (oui, en fait un rectangle mais ce DM impose aux traits des largeurs, donc cela revient à tracer des rectangles de largeurs fines ...)
Ben tu crèes ta fonction qui trace ca.
et tu vérifies pour chaque valeur de X passé quelle est la ligne qui est tracée...

[fatal_error]

ok pardon pour CINI... pas lu la description.
Pour Y et X, je maintiens.

Mis à part:

Je comprends donc avec X vers la droite, Y vers le bas

Code: Tout sélectionner

//border-top
CINI_fill_rect(X0, Y0, terrain_X, BORD, "grey") ;

//border-bottom
CINI_fill_rect(X0, Y0 + terrain_Y, terrain_X, BORD, "grey") ;
//border-left
CINI_fill_rect(X0, Y0,BORD, terrain_Y, "grey") ;
//border-right
CINI_fill_rect(X0 + terrain_X - BORD, Y0,BORD, terrain_Y, "grey") ;
//je suggère de tracer le contour en red pour etre sur qu'il est bien délimité


//on trace donc les traits uniquement a l'intérieur
//il y a X colonnes donc X+1 traits
//on enleve les deux traits de contour : X+1 -2 =X-1

for (i=0 ; i < X-1 ; i++) { //on va tracer exactement X-1 traits
//on commence à partir de
//bord gauche + taille case
int offsetLeft = X0+BORD+CASE;
  CINI_fill_rect(offsetLeft + i*(TRAIT + CASE), Y0, TRAIT, blabla) ;
}       

Ca devrait etre pas trop mal

Petite parenthèse au passage terrain_x est mal calculé.
Il vaut normalement
2*BORD + X*CASE + (X-1)*TRAITS (car pour X CASE, il y a déjà les 2 BORDS, on soccupe donc que des traits à l'intérieur)

[Vupen]

Merci, je teste.

En ce qui concerne les traits d elargeur TRAIT, il est précisé dans le DM que je dois aussi tracer ceux de la bordure (en plus donc d ela bordure de largeur BORD). Du coup, on a X+1 colonnes.

[fatal_error]

ben s'il faut tracer les X+1 traits (attention pas colonnes),
la boucle for devient donc:

Code: Tout sélectionner

for (i=0 ; i < X+1 ; i++) { //on va tracer exactement X+1 traits
//on commence à partir de bord gauche
int offsetLeft = X0+BORD
  CINI_fill_rect(offsetLeft + i*(TRAIT + CASE), Y0, TRAIT, blabla) ;
}   

[Vupen]

Voici le code

Code: Tout sélectionner

#include
#define M 10 // lignes
#define N 10 // colonnes
#define Y M-2 // lignes
#define X N-2 // colonnes
#define CASE 50
#define TRAIT 2
#define BORD 2
#define X0 10
#define Y0 10
#define terrain_X 2*BORD + CASE*X + TRAIT*(X-1) // largeur
#define terrain_Y  2*BORD + CASE*Y + TRAIT*(Y-1) // hauteur
#define NBR_MINES 20
 
void afficher_terrain() {
        int i ;
        CINI_fill_rect(X0, Y0, terrain_X, BORD, "red") ;
   CINI_fill_rect(X0, Y0 + terrain_Y, terrain_X, BORD, "red") ;
   CINI_fill_rect(X0, Y0,BORD, terrain_Y, "red") ;
   CINI_fill_rect(X0 + terrain_X - BORD, Y0,BORD, terrain_Y, "red") ;
      
        for (i=0 ; i < X-1 ; i++) { //on va tracer exactement X-1 traits
//on commence à partir de
//bord gauche + taille case
int offsetLeft = X0+BORD+CASE;
  CINI_fill_rect(offsetLeft + i*(TRAIT + CASE), Y0, TRAIT, terrain_Y, "grey") ;
}     
}
int main() {
       
        CINI_open_window(2*BORD + CASE*X + TRAIT*(X+1) + 20, 2*BORD + CASE*Y + TRAIT*(Y+1) + 20, "Demineur") ;
        afficher_terrain() ;
        CINI_loop() ;
        return 0 ;
   }



Et ce que ça affiche :



J'ai aussi modifié le terrain_Y comme tu l'as suggéré (meme si il faudra rajouter les 2 colonnes qui bordent la grille mais déjà reagardons sans ces deux colonnes extremes ...)

[Cliffe]

Utilise Qt, tu gagneras du temps.

[Vupen]

"Utilise Qt, tu gagneras du temps."

Je suis les instructions du DM. La lib se base de toute façon sur QT donc bon

[Cliffe]

Tu génére m*n QPushButton que tu met dans une grille.
Tu connecte chaque button à un slot qui s'occupe de traiter l'action.

Deux boucles 'for' et c'est fini ...

[Vupen]

Comme je l'ai dit, le DM impose cette librairie ...

[Cliffe]

DM = DéMineur ?

[Vupen]

non, Devoir Maison ...

[fatal_error]

franchement, je suis aussi sur les fesses.
Sur le graphique, je compte 7 traits blancs (donc jusque là c'est normal, on voulait tracer X-1 traits==8-1=7 traits)

Maintenant pourquoi est-ce qu'il reste autant de zone noire sur la droite:
c'est comme si terrain_x était plus grand que la somme 8 cases + (éventuellement une demi si on ajoute les bords+la largeur des traits) (on pourrait rajouter au moins deux cases!)

Bref, il ne faut pas chercher sur le nombre d'indice, mais plutot sur la largeur du cadre rouge ou des bandes de largeur(CASE+TRAIT))

Je suggère d'afficher les différentes valeurs de x dans l'expression

Code: Tout sélectionner

int offsetLeft = X0+BORD+CASE;
int x=offsetLeft + i*(TRAIT + CASE);
prinft("%d",x);
  CINI_fill_rect(x, Y0, TRAIT, terrain_Y, "grey") ;
}   

de même qu'afficher celle de bordure gauche et bordure droite:
j'intuite

Code: Tout sélectionner

   CINI_fill_rect(X0, Y0,BORD, terrain_Y, "red") ;
normalement X0==10
   CINI_fill_rect(X0 + terrain_X - BORD, Y0,BORD, terrain_Y, "red") ;
normalement x0==10+400+20 (a peu pres)

et voir ou est-ce que disparaissent ces précieux pixels.

edit:
en js, il n'y a pas l'air d'avoir le problème d'implementation.
Peut-etre y a-t-il un bug avec tes constantes de préproc (M,X,N,Y)

Code: Tout sélectionner




canvas{background-color:#eeeeee;}






var ctx=document.getElementById('canvas').getContext('2d');
function CINI_fill_rect(x,y,width,height,color){
  ctx.fillStyle= color;
  ctx.fillRect(x,y,width,height);
}
function CINI_open_window(x,y){
  document.getElementById('canvas').width=x;
  document.getElementById('canvas').height=y;
}


var M=10,
    N=10,
    Y=M-2,
    X=N-2,
    CASE=50,
    TRAIT=2,
    BORD=2,
    X0=10,
    Y0=10,
    terrain_X=2*BORD + CASE*X + TRAIT*(X-1),
    terrain_Y=2*BORD + CASE*Y + TRAIT*(Y-1);

function afficher_terrain() {
  CINI_fill_rect(X0, Y0, terrain_X, BORD, "red") ;
  CINI_fill_rect(X0, Y0 + terrain_Y, terrain_X, BORD, "red") ;
  CINI_fill_rect(X0, Y0,BORD, terrain_Y, "red") ;
  CINI_fill_rect(X0 + terrain_X - BORD, Y0,BORD, terrain_Y, "red") ;
  for (var i=0 ; i




[Cliffe]

En 2min :

[CENTER] [/CENTER]

[Vupen]

Voici ce que j'obtiens :

X0 : 10
X0 + terrain_X - BORD : 52462 (????????????????)
114
166
218
270
322
374