Conditions de victoire d'un Morpion

**eldoir** · 06/12/2011, 14h58

Hello à toutes et à tous !

J'ai un petit exo à faire, j'ai presque terminé. IL s'agit d'un Morpion en mode Console (hé oui, on en est encore là

).
Seulement voilà, il me manque la partie où je vérifie les conditions de victoire.
Je pensais créer une fonction de type char où j'aurais stocké le nom du gagnant : la fonction renverrait donc 'X' ou 'O', voire 'r' lorsqu'il y aurait égalité. ( 'r' pour 'rien' ).
Voilà le code que j'ai déjà écrit, avec un essai que j'ai réalisé sur les conditions de victoire qui n'est pas satisfaisant

:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
program morpion;
const Nmax = 7;
type jeu = array [1..Nmax,1..Nmax] of char;
 
procedure init (var T : jeu);
var x,y : integer;
begin
	for x := 1 to Nmax do
		for y := 1 to Nmax do
			T[x,y] := '_'
end;
 
procedure aff(T : jeu);
var x,y : integer;
begin
	for x := 1 to Nmax do
	begin
		for y:= 1 to Nmax do
			write(' | ',T[x,y]);
		writeln
	end
end;
 
procedure change (var j : char);
begin
	if j = 'X' then j := 'O'
	else j := 'X'
end;
 
procedure valide (var T : jeu; j : char);
var x,y : integer;
	verif : boolean;
begin
	verif := false;
	repeat
		write('No ligne et colonne :');
		readln(x,y);
		if T[x,y] = '_' then
		begin
			T[x,y] := j;
			verif := true
		end
		else writeln('Coup non valide !')
	until (verif)
end;
 
function rempli (T : jeu) : boolean;  // Savoir si la partie est terminée parce que la grille est remplie (en grille 7*7 c'est pourtant peu probable :D)
var i,j : integer;
begin
	rempli := true;
	for i := 1 to Nmax do
		for j := 1 to Nmax do
			if T[i,j] = '_' then rempli := false
end;
 
function gagnant (T : jeu) : char;   // Ne fonctionne apparemment pas, pas d'erreur à l'exécution pourtant :S
var i,j : integer;
begin
	gagnant:= 'r';
	i := 1;
	while (i <= Nmax) and (gagnant = 'r') do
	begin
		gagnant := T[i,1];
		for j := 1 to 4 do
			if T[i,j] = T[i,j+1] then gagnant := 'r'; // En fait à chaque début de ligne il va vérifier si 5 pions se suivent
		i := i + 1;
	end;
	j := 1;
	while (j <= Nmax) and (gagnant = 'r') do
	begin
		gagnant := T[1,j];
		for i := 1 to 4 do
			if T[i,j] = T[i+1,j] then gagnant := 'r'; // Pareil pour les colonnes :)
		j := j + 1
	end
end;
 
var T : jeu; j : char;
begin
	init(T);
	j := 'O';
	aff(T);
	while (gagnant(T) = 'r') and not(rempli(T)) do
	begin
		change(j);
		valide(T,j);
		aff(T)
	end;
	if rempli(T) then writeln('Egalite !') else writeln('Gagnant : ',gagnant(T));
	readln
end.

C'est un peu plus délicat qu'une grille 3*3 parce qu'ici c'est 7*7 et il suffit de 5 pions alignés pour gagner. Et comme vous le voyez dans ma fonction gagnant, je n'ai même pas encore testé pour les diagonales vu que j'ai déjà ce problème sur mes conditions de victoire. Mon code ici passe inaperçu à l'exécution, en fait quand il y a un gagnant le programme ne réagit même pas et continue à demander un pion à placer

Merci d'avance de votre aide

**Paul TOTH** · 06/12/2011, 17h27

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if T[i,j] <> T[i,j+1] then gagnant := 'r';

non ?

**eldoir** · 06/12/2011, 22h27

J'y ai pensé après, merci ^^,
Mais il y a toujours un problème, le programme m'affiche 'Gagnant : _ ' dès l'exécution et le jeu n'est pas jouable :/
Un idée ? Parce que moi ça me passe au-dessus de la tête là

J'ai réécrit ma fonction autrement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function gagnant (T : jeu) : char;
var i,j,x,compt : integer;
begin
	compt := 0; i := 1; j := 1; gagnant := 'r';
	if T[i,j] <> '_' then
		while (i <= Nmax) and (gagnant = 'r') do
		begin
			j := 1;
			while (j <= 3) and (gagnant = 'r') do
			begin
				for x := 1 to 4 do
					if T[i,j] = T[i,j+x] then compt := compt + 1;
				if compt = 4 then
					gagnant := T[i,j]
				else
					compt := 0;
				j := j + 1
			end;
			i := i + 1
		end
end;

Seulement, toujours le même problème, lorsque je rentre (1,1) le programme m'affiche que le gagnant est '_' ce qui est absurde, et il ne détecte pas quand les pions sont effectivement alignés :S
Là, c'est seulement le code pour vérifier les horizontales du coup

**droggo** · 07/12/2011, 00h11

Kei,

Donc, retour aux sources : papier + crayon !

Tu notes l'évolution de toutes les variables pas à pas, en suivant ton programme ligne à ligne (le VRAI programme, celui que tu as écrit, pas celui que tu penses avoir fait

).

**Paul TOTH** · 07/12/2011, 10h15

ton test "if T[i,j] <> '_' then" est en dehors de la boucle, donc dès la seconde itération "_" est donné gagnant

ton code gagnerait en lisibilité avec des "continue", "break" ou "exit"

**eldoir** · 07/12/2011, 17h50

Merci !

J'avais remarqué un truc dans ce genre mais finalement j'étais à des lieues de m'imaginer que c'était un truc dans ce genre qui n'allait pas _ _'
Finalement, j'ai aussi fait le cas des verticales et un peu modifié le truc, pour le coup. Voilà le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
function gagnant (T : jeu) : char;  
var i,j,x,y,compt : integer;
begin
	// Cas horizontal
	compt := 0; i := 1; gagnant := 'r';
	while (i <= Nmax) and (gagnant = 'r') do
	begin
		j := 1;
		while (j <= 3) and (gagnant = 'r') do
		begin
			if T[i,j] <> '_' then
			begin
				compt := 0;
				for x := 1 to 4 do
					if T[i,j] = T[i,j+x] then compt := compt + 1;
				if compt = 4 then gagnant := T[i,j]
			end;
			j := j + 1
		end;
		i := i + 1
	end;
	// Cas vertical
	compt := 0; j := 1;
	while (j <= Nmax) and (gagnant = 'r') do
	begin
		i := 1;
		while (i <= 3) and (gagnant = 'r') do
		begin
			if T[i,j] <> '_' then
			begin
				compt := 0;
				for y := 1 to 4 do
					if T[i,j] = T[i+y,j] then compt := compt + 1;
				if compt = 4 then gagnant := T[i,j]
			end;
			i := i + 1
		end;
		j := j + 1
	end;
	// Cas diagonal
 
end;

On n'a pas encore vu les break, exit et tout ça donc je n'ai rien modifié en ce sens ^^
J'ai laissé le cas des diagonales vide à la fin parce que je sais pas encore comment trop m'y prendre, la question que je me pose surtout maintenant c'est comment optimiser ce bazar, j'ai deux bouts de programme qui sont quasiment similaires (horizontal et vertical), j'ai essayé d'en faire une procédure pour raccourcir de moitié mais il paraît qu'appeler une procédure depuis une fonction c'est pas terrible :S, et en plus ça marchait pas ^^
Donc je vais peut-être laisser ça comme ça...
En tous cas merci beaucoup

**droggo** · 07/12/2011, 18h09

Qia,

Petite remarque : ton code est indenté, c'est bien. MAIS, une tabulation de 8 caractères d'indentation à chaque niveau de bloc, c'est trop, dans le sens où ça étale le texte à l'écran, et le rend du coup moins lisible.

**Paul TOTH** · 07/12/2011, 18h42

une piste pour n'avoir qu'une fonction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
  for k := 1 to 4 do
    if T[i,j] = T[i + k * dx,j + k * dy] then compt := compt + 1;

quelles valeurs pourraient prendre dx et dy ?

(je présuppose que la multiplication est acquise dans ton programme ^^)

**mick605** · 07/12/2011, 20h46

Salut

J'aimerais ajouter

Envoyé par eldoir

... j'ai deux bouts de programme qui sont quasiment similaires (horizontal et vertical), j'ai essayé d'en faire une procédure pour raccourcir de moitié mais il paraît qu'appeler une procédure depuis une fonction c'est pas terrible :S

Ah bon ?

Non, cela n'est pas déconseillé d'appeler une procédure depuis une fonction (ni l'inverse)...

Au contraire, tu as eu la bonne démarche, a savoir : "Tiens, un bout de code se répete, je vais le regrouper dans une procedure/fonction" ...

**eldoir** · 08/12/2011, 18h13

@ Paul Toth : j'avais pensé à ça, en appelant une autre fonction depuis celle-ci. J'avais remarqué que T[i,j+x] T[i+x,j] et T[i+x,j+x] ( pour la diagonale ) s'écrivaient finalement tous de la même façon et que je pouvais donc factoriser en T[i+x,j+y] où pour le cas horizontal x serait égal 0 et y serait égal à 0 pour le cas vertical.
Donc si je ne me trompe pas dans mon raisonnement, dx et dy peuvent toutes les deux prendre les valeurs 0 ou 1

Mon prof de TP me dit toujours qu'il vaut mieux éviter d'appeler une procédure depuis une fonction parce qu'à terme on peut s'embrouiller dans les paramètres, d'ailleurs il me l'a encore dit aujourd'hui ^^
Du coup je pense que je vais utiliser la méthode dx dy

Conditions de victoire d'un Morpion [Free Pascal]

Free Pascal

Discussions similaires

Partager

Partager