Here is the code for the method "plein",
so we will ask alternately the red player and the yellow player
into which colomn he wants to place his piece.
Suppose that it's yellow's turn,
if he decides to play in the first column
then since it is filled automatically
from the bottom up,
then this means we will fill in this case
the very first position of the grid.
This effects how the grid is tested to see if it is full:
indeed, it is not necessary to test each box of the grid
to see if they contain a color or are empty
but we can simply test the last line of the grid (at the top).
Indeed, if this row is filled,
this means that each box of the grid is also already allotted a color
because the grid is filled from the bottom up.
Therefore the grid is filled.
Let's examine how to code this method "plein".
We saw from a methodological point of view
that we we consider coding a method,
we have to always ask ourselves the question "what?"
"what does the method do?", "what information does it need to work?"
"what does it return?".
These are elements that we have considered quickly here
because the function is so simple
through how we anticipated its utilization
in the principal program.
So we have anticipated that we will invoke this method "plein" on the grid
and that it returns obviously
a boolean variable, no doubt.
This boolean
indicates whether the grid is full or not.
This corresponds naturally to this header of the method "plein".
Now that the "what" is clear, we can now examine the question "how?".
"How to program the body of the method 'plein'?"
We can use the algorithm that we sketched earlier
that is that if we find in the first line,
that is to say in the last line according to how the grid is filled,
an empty slot,
this means that the grid is not full.
It's this procedure we will implement.
First we will use a for-loop
iterating on the values
of the slots of the first line.
which is written "grille[0]",
and test if the cell considered is empty
which would mean that the grid is not full
and so we would exit the method "plein"
by indicating that the grid is not full with "false".
If we have to go through all the cells of the first line
without finding any empty slot
then we leave the loop
which means in this case that the grid is full
and "plein" has to return the boolean "true".
Note that a frequent error for beginners
in this kind of situation
is to implement the algorithm but in a wrong manner
by returning "false" if the cell is empty,
which is correct,
but then to return "true" right afterwards,
which is obviously not the correct procedure
that we want to implement. Why?
Because we have to have tested all the cells
of the first line of the grid
before determining that the grid is indeed full.
And this cannot be known inside the body of the loop
so we have to finish the whole loop before returning "true".
We pay attention to these little details
that beginners tend to forget but that are important in the end.
So, now we've finished programming our application for "Connect 4",
of course, there are many ways of programming this game
and we have only presented one of them.
The goal of this case study was to essentially show
how to take on programming such an application
when you do it for the first time.
Several key ideas:
first, always proceed from bottom up
start by identifying the essential types of data needed,
and the main functions before going into small details.
Each of the functionalities and fundamental methods
can in turn be modularized
that is, can invoke other more detailed methods
that will help it do the tasks needed.
We saw that in coding
each method
it is preferable to have a certain methodology,
and always ask the question "what does the method do?",
"what information does it require?",
"what information does it return?".
An only then ask the question "how?"
and think of the algorithms that will allow you to do the wanted manipulations.
Finally we saw that it was fundamental to work on the essential aspects
before working on the aesthetics.
And an important point
is to systematically test as
you write your code and not only at the end.
So, that concludes what we wanted to teach you
in this case study
and we hope it will be useful
farther along when you will take on similar programming challenges.
