Ce cours initie aux bases de la programmation en utilisant le langage Java : variables, boucles, fonctions, ... Il ne présuppose pas de connaissance préalable. Les aspects plus avancés (programmation orientée objet) sont donnés dans un cours suivant, «Introduction à la programmation orientée objet (en Java)». Il s'appuie sur de nombreux éléments pédagogiques : vidéos sous-titrées, quizz dans et hors vidéos, exercices, devoirs notés automatiquement, notes de cours.
Puissance 4 : méthodes estCeGagne et compte
Loading...
En provenance du cours de École Polytechnique Fédérale de Lausanne
Initiation à la programmation (en Java)
211 notes
À partir de la leçon
Etude de cas
Nous voulons terminer notre cours avec une étude de cas, la création d'un jeu de « Puissance 4 », nous permettant de revoir tous les concepts abordés au long du cours.
Rencontrer les enseignants
Jean-Cédric ChappelierDr.
School of Computer and Communication Sciences
Jamila SamDr
School of Computer and Communication Sciences
In the previous video, you saw how to write
the main loop that allows the players to play in turn.
All that was missing was the break condition,
that is, what must be written here
so that the loop stops when one of the players has won,
or when the grid is full.
So for the moment, we'll concentrate on the case
where one of the two players has won.
I'll therefore introduce a new method
that I'll name 'estCeGagne' and that I'll call like this:
I'll put the return value of my 'estCeGagne' method
in a variable
that I'll name 'gagne', of boolean type.
To function, my 'estCeGagne' method needs the grid
and the color of the player that has just played.
I need to declare my 'gagne' variable,
and I need to declare it before the loop,
as I'm going to use it within the loop's break condition.
It's of boolean type
and I can now use it to define the break condition,
and we'll repeat the loop until the player hasn't won.
We have to write this 'estCeGagne' method,
which is probably the most difficult part of our program.
There are many ways of writing this 'estCeGagne' method,
and we propose the following one.
We'll navigate through the grid
line by line and column by column
until we find a chip of the color of the player that has just played.
Let's say for example that the red player has just played,
and that we find this chip.
We'll start from this chip and navigate through the grid
in several directions,
horizontally, vertically, and diagonally,
to count how many chips of the same color
there are starting from this chip.
For example, if we consider this direction,
we can count one, two, three, four red chips,
we therefore know that the player has won.
Instead, if we navigated through the whole grid
and we've always counted less than four chips,
we know that the player hasn't won.
We can note that we don't need
to consider all the directions
and in fact we'll content ourselves to count the chips
in four directions only,
and we'll choose for example upwards to the right,
to the right, downwards to the right, and straigth downwards.
So why is it sufficient to consider these four directions?
I said that we'll browse the grid
line by line and column by column.
Let's suppose once again
that the red player has just played.
The first chip we'll find is this one.
We'll first of all count the chips in this directions,
we'll count a single chip, this one.
The same goes for this direction, and this direction,
there's only one chip in these three directions.
In this direction, there are two chips.
This isn't sufficient to win,
so we'll continue navigating the grid.
The next red chip that we'll find is this one.
In this direction and this direction
we'll count only two chips,
which isn't enough to win.
In this direction and this direction,
we'll count only one chip,
which still isn't enough to win.
We'll continue navigating the gris until we reach this chip;
we'll continue counting the chips in this direction
and this time we'll count one, two,three, four chips
and we know that the player has won.
To prove that the red player has just aligned these four chips,
we can either start from this chip here and go in this direction,
or start from this chip here and go in this direction.
Therefore, we aren't obliged to consider these two directions,
we can content ourselves of only one,
and the same goes for the six other directions.
We'll only look at this direction
and not this direction.
In this direction and not this one, in this direction and not this one.
We are left with four directions to consider.
We now have to code this strategy
by writing the 'estCeGagne' method.
Let me remind you that we call the 'estCeGagne' method
by the following way, for example.
We put the return value of the 'estCeGagne' method
in a variable of boolean type.
And the method awaits a grid
and the color of the player that has just played as parameters.
The method's header will simply be the following.
Other strategies consist of navigating through the grid,
which we'll do with the help of these two for-loops.
And as we need the chip's coordinates,
we'll use two standard for-loops like this.
The ligne (= line) and colonne (= column) variables will contain the disc's coordinates
from which we'll count the number of aligned discs.
To simplify a bit the code,
I'll introduce a local variable that I'll name 'couleurCase'
to contain this chip's color, which is grille[ligne] [colonne].
If the cell's color is the same as the player that has just played,
then I must count the chips
in the four directions in which we are interested.
So, as it's a bit difficult to count the chips,
well I'll introduce a method that I'll simply name 'compte' (= count)
and that will do this task.
What arguments does the 'compte' method need?
Well first of all, of course, of the chip, the coordinates of the disc
from which we want to count the aligned chips.
These coordinates are contained in the 'ligne' and colonne' variables.
And we need the direction in which we want to count the aligned chips.
So how can we define this direction?
Let's suppose for example that I want to count the chips
diagonally to the top-right.
In this case, to go from one cell to another,
we'll have to subtract one from the line and add one to the column.
Therefore, I'll use these two values,
this minus one and this plus one,
as the arguments for my 'compte' method,
to say that I want to go to the top-right.
I'll send to my 'compte' method the number of aligned chips
and if this number of chips is greater than or equal to four,
then I know that the player has won.
So why greater than or equal to four, and not simply equal to four?
Well, that's simply because one can win by aligning more than four discs.
So of course, I need to consider the three other directions
and that will be written like this.
To count the chips horizontally, I won't change the line,
and that's why I use zero as argument here.
But the column will change, and I'll go to the next column,
that's why I'll use the value plus one as last argument.
Then, to count the discs diagonally to the bottom-right,
to go from one cell to the other, I'll add one to the line,
that's why I use the value plus one here,
and I also add one to the column,
and that's why I use the value plus one here.
Finally, there remains a last direction.
To count the chips vertically downwards,
I'll go from one cell to the other,
By adding one to the line, that's why I have the value plus one here,
But the column won't change and I use the value zero here.
If one of these four conditions is true, then I know that the player has won.
It is sufficient that one of these four conditions is true,
that's why I use an 'or' here.
And in this case,
I'll return everything to my method,
I'll close the curly braces I had previously opened,
and if I get to this point of my method,
it's because I've never passed by here,
that is, I never found at least four aligned chips,
and I know that in this case, the player hasn't won yet.
So I'll return 'false' from my method,
and as a good programmer, I'll add comments
to explain the difficult points of my method.
Of course, we still need to write the 'compte' method.
Let me remind you that we'll call the 'compte' method
like this, for example.
That is, the method will return a number of discs,
that's why I'll use the 'int' type
to define the type of the result value of the method.
The first parameter is the grid,
the two next parameters are the line and the column
of the disc from which we'll count.
They are both of 'int' type,
and the two last parameters are the direction for the line and the column
that I'll call 'dirLigne' and 'dirColonne',
as they are of the same nature,
and one refers to the line and the other to the column.
I'll declare a 'compteur' variable initialized with zero
to count the number of aligned discs.
What must the 'compte' method do exactly?
Well, it must start from the line 'ligneDepart colonneDepart',
and must browse the grid in the given direction
starting from 'ligneDepart' 'colonneDepart'
while we find chips of the same color as
the chip at 'ligneDepart' 'colonneDepart'.
So how will we achieve this?
Well, we'll use two variables that I'll name 'ligne' and 'colonne',
that we'll respectively initialize with 'ligneDepart' and 'colonneDepart'.
And to go from one cell to the other, at each loop cycle,
we'll add the value of 'dirLigne' to 'ligne',
and the value of 'dirColonne' to 'colonne'.
As we'll browse the grid
while we find discs of the same color as the disc
that is at 'ligneDepart colonneDepart',
we'll use a while-loop.
During each cycle of the while-loop,
we'll have found a new chip of the same color
and we'll increment the 'compteur' variable.
How will we write all this?
Well, we'll begin by declaring the 'ligne' and 'colonne' variables,
initialized with 'ligneDepart' and 'colonneDepart',
we'll therefore use a while-loop
with a break condition that depends on the color of the disc at position 'ligne colonne',
and we'll continue while the color of this disc
is the same as the color of the disc at the position 'ligneDepart colonneDepart'.
During each loop cycle,we'll increment the 'compteur' variable,
as we've found a new disc of the same color as the first,
and we'll add 'dirLigne' and 'dirColonne' to 'ligne' and 'colonne'.
By the way, note that I added spaces here and here
to align the equal and plus characters on these two lines,
that makes the code more readable,
it highlights the fact that the variables 'ligne' and 'colonne' are of the same nature.
When we exit the loop, it means that we've found a disc
that wasn't of the same color,
and we can return the value contained in the 'compteur' variable.
Except that our method isn't totally correct,
and maybe you see why.
As with the 'joue' method,
we could leave the grid,
that is, the 'ligne' or 'colonne' variables
can take illicit values.
So, to correct this, I'll add a few tests
to the while-loop condition.
I'll verify that the line is indeed greater than or equal to zero,
and that it is less than the number of lines,
and I'll add the same tests for the column.
Finally, I'll add a comment
to describe what the loop does.
To conclude, I'll come back to my 'estCeGagne' method to note that
if the starting cell's line has the value zero, one, or two,
it isn't necessary to look in this direction, for example,
as we already know
that the player can't align at least four discs.
If we start from the line two, we know
that the player can align a maximum of three discs.
The same goes when we start from the right-side of the grid.
It isn't necessary to look in this direction,
and the same goes when we start form the bottom of the grid,
it isn't necessary to look to the bottom.
Our 'estCeGagne' method does more than necessary,
so I'll modify the code to avoid counting the number of discs
when we are sure that there won't be at least four aligned discs.
So, that will be written like this.
When we consider the direction diagonally to the top-right,
to be able to align at least four discs,
the line must be greater than or equal to three.
And the column mustn't be too big,
and, I'll let you verify when you do it,
the column must be less than the number of columns minus four.
When we look to the right horizontally,
it is sufficient that the column isn't great enough
and that it is, similarly, less than the number of columns minus four.
When we look diagonally to the bottom-right,
the line mustn't be too big, and as with the column,
the line must be less than the number of lines minus four,
and the column mustn't be too big.
And when we count the number of discs downwards,
it is sufficient that the line is less than the number of lines minus four.
Now, you can observe that I've introduced a few repetitions,
as this expression appears here and here,
and this expression also appears twice.
I'll therefore introduce constants to replace these repetitions,
constants that I'll logically name 'ligneMax' and 'colonneMax',
and which will avoid the repetitions.
Voilà, this time was really the final version
of the 'estCeGagne' and 'compte' methods.
We still have to handle the case where the grid is full
without any of the players having won,
and that's what we'll see in the last video.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2019 Coursera Inc. Tous droits réservés.
