Apprendre>
Informatique>
Développement de logiciels>
Initiation à la programmation (en Java) cours>
Puissance 4 : méthodes estCeGagne et compte

Loading...

Puissance 4 : méthodes estCeGagne et compte

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.

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.

Visualiser le programme de cours

Compétences que vous apprendrez

Problem Solving, Java Programming, Object-Oriented Programming (OOP), Eclipse (Software), Computer Programming

Enseigné par

Jean-Cédric Chappelier
Dr.
Jamila Sam
Dr

Transcription

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.

À propos de Coursera

Cours, Spécialisations et Diplômes en ligne enseignés par des enseignants du plus haut niveau provenant des meilleurs universités et établissements d'enseignement du monde.

Join a community of 40 million learners from around the world

Earn a skill-based course certificate to apply your knowledge

Gain confidence in your skills and further your career

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.

Télécharger dans l'App Store

Disponible sur Google Play