Python

En utilisant les instructions de la tortue donnée sur la page découverte, proposez un programme pour chacune des applications suivantes.

Il y a 4 applications à réaliser correspondant chacune à une figure graphique :

Proposez un programme qui trace une étoile à 5 branches régulière dans la fenêtre de la tortue :

Voici pour information quelques éléments géométriques de l'étoile à 5 branches :

Remarques concernant les angles particuliers de l'étoile à 5 branches sachant que l'angle plein vaut 360° :

Proposez un programme qui trace un cœur dans la fenêtre de la tortue, constitué de 2 segments et de 2 arcs de cercle parfaitement joints :

Améliorez votre programme du cœur afin de rajouter dans la fenêtre de la tortue un carreau, un trèfle et un pique.

Vous structurerez votre programme pique.py comme indiqué ci-dessous, en créant une fonction pour chaque figure (coeur, carreau, trèfle et pique) ainsi qu'un fonction deplacer(x,y) permettant de déplacer le curseur aux coordonnées (x,y) en levant le crayon et sans tracer de trait :

# ----------------------------------------------------------------------------
# Programme pique.py qui trace les 4 figures : coeur, carreau, trèfle et pique
# ----------------------------------------------------------------------------

# importation du module turtle :
from turtle import *

# ----------------------------------------------------------------------------
# Déclaration des fonctions
# ----------------------------------------------------------------------------

# fonction coeur() qui trace la figure coeur :
def coeur():
        color('red')
        pensize(6)
        left(120)
        forward(150)
        left(180)
        circle(60,-200)
        etc.

# fonction carreau() qui trace la figure carreau :
def carreau():
        color('red')
        pensize(6)
        left(60)
        forward(150)
        right(120)
        forward(150)
        right(60)
        forward(150)
        right(120)
        forward(150)

# fonction trefle() qui trace la figure trèfle :
def trefle():
        color('black')
        pensize(6)
        ???

# fonction pique() qui trace la figure pique :
def pique():
        color('black')
        pensize(6)
        ???

# fonction deplacer(x,y) qui déplace le curseur sans tracer de trait entre 2 figures :
def deplacer(x,y):
        # lève le crayon :
        up()
        # déplace le curseur au point de coordonnées (x,y) :
        goto(x,y)
        # baisse le crayon :
        down()

# ----------------------------------------------------------------------------
# Programme principal
# ----------------------------------------------------------------------------

# efface le curseur de la tortue :
hideturtle()

# trace les 4 figures en appelant les différentes fonctions :
deplacer(-200,200)
coeur()
deplacer(200,200)
carreau()
deplacer(-200,-200)
trefle()
deplacer(200,-200)
pique()

# libère la fenêtre de la tortue :
done()

IMPORTANT : les valeurs en bleu dans le programme ci-dessus sont à adapter ou à compléter. Cet exemple vous donne seulement la structure de votre programme (liste et nom des fonctions à créer, séparation entre la déclaration des fonctions et le programme principal) et non ses instructions exactes.

Dans cette application on va demander à la tortue de Python de tracer une rosace exactement comme on l'aurait fait au compas sur le papier.

Et voici l'algorithme qui a permis d'obtenir cette rosace simple. Un algorithme donne les instructions à réaliser, avec des phrases simples en français. Pour obtenir la rosace il vous appartient de convertir cet algorithme en programme Python en remplaçant les indications données par des instructions Python équivalentes et permettant de piloter la tortue.

Dans ces algorithmes la variable R est le rayon de la rosace. Utilisez par exemple R=200

Algorithme 1 de la rosace simple non colorée

Configurer l'épaisseur du crayon

Répéter 3 fois:

Tracer un arc de cercle de rayon R et d'angle 120°
Faire tourner le curseur de 120° vers la gauche

Tracer un arc de cercle de rayon R et d'angle 60°
Faire tourner le curseur de 60° vers la gauche
Tracer un arc de cercle de rayon R et d'angle 60°

Répéter 3 fois:

Faire tourner le curseur de 120° vers la gauche
Tracer un arc de cercle de rayon R et d'angle 120°

Faire tourner le curseur de 60° vers la gauche
Tracer un cercle entier de rayon R

Algorithme 2 de la rosace simple non colorée

Configurer l'épaisseur du crayon

Lever le crayon
Déplacer le curseur au point de coordonnées (R,0)
Baisser le crayon

Faire tourner le curseur de 90° vers la gauche
Tracer un cercle entier de rayon R

Lever le crayon
Remettre le curseur à l'origine
Tracer un arc de cercle invisible de rayon R et d'angle 60°
Baisser le crayon

Répéter 3 fois:

Faire tourner le curseur de 120° vers la gauche
Tracer un arc de cercle de rayon R et d'angle 120°

Lever le crayon
Déplacer le curseur au point de coordonnées (0,R)
Orienter le curseur à 120°
Baisser le crayon

Répéter 3 fois:

Faire tourner le curseur de 120° vers la gauche
Tracer un arc de cercle de rayon R et d'angle 120°

En utilisant un des deux algorithmes au choix, proposez un programme qui trace une rosace dans la fenêtre de la tortue.

Améliorez votre programme rosace.py de la rosace afin de la colorer et de la complexifier.

Pour obtenir une rosace simple dont chaque surface fermée est colorée, vous pouvez suivre cet algorithme :

Algorithme de la rosace colorée

Lever le crayon
Déplacer le curseur au point de coordonnées (0,R)
Baisser le crayon

Configurer l'épaisseur du crayon
Configurer les couleurs du trait et du remplisage

Orienter le curseur à 180°
Commencer une nouvelle figure
Tracer un cercle entier de rayon R
Fermer la figure pour la colorer

Lever le crayon
Remettre le curseur à l'origine
Baisser le crayon

Répéter 6 fois :

Configurer les couleurs du trait et du remplisage
Commencer une nouvelle figure
Tracer un arc de cercle de rayon R et d'angle 60°
Faire tourner le curseur de 120° vers la gauche
Tracer un arc de cercle de rayon R et d'angle 60°
Fermer la figure pour la colorer
Faire tourner le curseur de 60° vers la gauche

On peut également utiliser les fonctions afin de dessiner plusieurs fois la même figure sans répéter le code source.

Exemple 1 : on peut créer une fonction petale(R) à qui on passe en paramètre le rayon R. Un pétale est une figure composée de 2 arc de cercle de rayon R. En appelant plusieurs fois la fonction petale(R) on peut dessiner plusieurs pétales correctement répartis, de plus en plus petits et de plus en plus nombreux. Voici un exemple de résultat obtenu :

Exemple 2 : on peut créer une fonction rosace(R,c1,c2) à qui on passe en paramètre le rayon R ainsi que 2 couleurs : c1 pour la couleur du cercle entier et c2 pour la couleur des pétales. Une rosace est une figure composée de 6 pétales dessinés sur un cercle entier de rayon R. En appelant plusieurs fois la fonction rosace(R,c1,c2) on peut dessiner plusieurs rosaces correctement répartis et de plus en plus petites. Voici un exemple de résultat obtenu :

En joignant chaque milieu des 3 côtés du triangle on obtient un nouveau triangle au centre :

Nous avons maintenant 4 triangles : 3 triangles "à l'endroit" et 1 triangle "à l'envers" (le triangle central). Pour chacun de ces 4 triangles, toujours en joignant le milieu de leur 3 côtés, traçons 4 nouveaux triangles. Voici le triangle en bas à gauche :

Nous avons maintenant 16 triangles : 10 triangles "à l'endroit" et 6 triangles "à l'envers".

Vous l'avez compris, dans chacun de ces 16 triangles il faut maintenant tracer le triangle central joignant les milieux ces côtés, puis recommencer avec tous les nouveaux triangles obtenus.

Et en voici une autre, également plus avancée mais non terminée (car tous les triangles, qu'ils soient "à l'endroit" ou "à l'envers" doivent être divisés en 4 triangles) :

ici seuls les triangles "à l'envers" ont été tracés à l'intérieur des triangles "à l'endroit"

- tous les triangles sont équilatéraux (les 3 côtés ont la même longueur et chaque angle interne vaut 60°)

- chaque triangle possède 3 côtés (3 segments de même longueur) et 3 sommets (3 points de coordonnées précises)

- le sommet inférieur gauche du premier triangle a pour coordonnées (-300,-200)

# les triangles imbriqués
from turtle import *

up()
goto(-300,-200)
down()

for i in range(3):
forward(600)
left(120)

done()

Mais afin de bien organiser le programme nous allons le découper en différentes fonctions qui seront chacune appelée en cas de besoin.

from turtle import *

#======================================================
# Déclaration des fonctions
#======================================================

# - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Trace un triangle à l'endroit et renvoi la liste de ses sommets
def triangle_h(longueur):
    setheading(0)
    liste=[]
    for i in range(3):
        liste.append(position())
        forward(longueur)
        left(120)
    return liste

# - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Trace un triangle à l'envers et renvoi la liste de ses sommets
def triangle_b(longueur):
    setheading(0)
    liste=[]
    for i in range(3):
        liste.append(position())
        forward(longueur)
        right(120)
    return liste

# - - - - - - - - - - - - - - - - - - - - - - - - - - -
# déplace le curseur sans tracer :
def deplacer(xy):
    up()
    goto(xy[0],xy[1])
    down()

# - - - - - - - - - - - - - - - - - - - - - - - - - - -
# calcule le point milieu entre deux sommets et renvoie un tuple :
def milieu(sommet1,sommet2):
    x=(sommet1[0]+sommet2[0])/2
    y=(sommet1[1]+sommet2[1])/2
    return (x,y)

#======================================================
# Programme principal
#======================================================

# Trace le premier triangle :
segment=600
deplacer((-300,-200))
liste_sommets_1=triangle_h(segment)

# Trace le triangle du milieu :
deplacer(milieu(liste_sommets_1[0],liste_sommets_1[2]))
segment=segment/2
liste_sommets_2=triangle_b(segment)

# Il faut rajouter du code ici pour tracer les autres triangles ...

done()

Voici comment utiliser les fonctions ci-dessus pour tracer 4 triangles. Ce code est à ajouter juste avant le done() dans le programme principal :

segment=segment/2

deplacer(milieu(liste_sommets_2[0],liste_sommets_1[0]))
liste_sommets=triangle_b(segment)

deplacer(milieu(liste_sommets_2[0],liste_sommets_1[1]))
liste_sommets=triangle_b(segment)

deplacer(milieu(liste_sommets_2[0],liste_sommets_1[2]))
liste_sommets=triangle_b(segment)

deplacer(milieu(liste_sommets_2[0],liste_sommets_2[2]))
liste_sommets=triangle_h(segment)

Si on veut automatiser le tracé des triangles dans une boucle for on peut aussi utiliser un code ressemblant au suivant (à la place du bloc précédent) :

for s in range(3):
    liste_sommets=liste_sommets_2
    segment_1=segment
    for i in range(4):
        deplacer(milieu(liste_sommets[0],liste_sommets_1[s]))
        segment_1=segment_1/2
        liste_sommets=triangle_b(segment_1)

Mais aucune de ces solutions trace tous les triangles. Il vous reste à améliorer le programme afin de tracer le maximum de triangles sachant qu'il y a 2 cas de figure :

Le but de cette application 5 est de programmer en Python le jeu Puissance 4 en utilisant le module Turtle pour l'interface graphique :

Nous commençons en un premier temps par une version très simple, que nous ferons évoluer en ajoutant progressivement des fonctionnalités en enrichissant le code source.

Le but du jeu Puissance 4 est d'aligner une suite de 4 pions de même couleur sur une grille comptant 6 lignes et 7 colonnes. Chaque joueur dispose de 21 pions d'une couleur (ici bleu ou rouge). Tour à tour, les deux joueurs placent un pion dans la colonne de leur choix, le pion coulisse alors jusqu'à la position la plus basse possible dans la dite colonne à la suite de quoi c'est à l'adversaire de jouer.

Le vainqueur est le joueur qui réalise le premier un alignement (horizontal, vertical ou diagonal) consécutif d'au moins quatre pions de sa couleur. Si, alors que toutes les cases de la grille de jeu sont remplies, aucun des deux joueurs n'a réalisé un tel alignement, la partie est déclarée nulle.

Dans cette version totalement manuelle il n'y a pas de détection automatique des pions alignés (comme avec le jeu de société, il appartient aux joueurs d'observer la grille). Le joueur rouge commence.

Étape 1 : créez une fonction dessiner_grille() qui dessine la grille avec 7 colonnes et 6 lignes dans la fenêtre de la tortue. Les colonne seront numérotées de 0 à 6.

Étape 2 : créez une fonction dessiner_pion(x,y,couleur) qui dessine un pion dans la case (x,y) et qui attend 3 paramètres :

Par exemple si on appelle la fonction dessiner_pion(4,0,2) elle doit dessiner un pion bleu dans la case (4,0) : colonne 4 ligne 0.

Étape 3 : écrire le programme principal qui demande à tour de rôle aux joueurs la colonne où ils veulent jouer. Le programme doit gérer la ligne et le nombre de pions présent dans chaque colonne en le mémorisant dans une liste liste_colonne qui vaut [0,0,0,0,0,0,0] au démarrage lorsque la grille est vide.

Étape 4 : améliorez votre programme Puissance 4 afin qu'il détecte lorsque la grille est pleine (42 pions joués) et qu'il affiche alors le message "Grille pleine"

Dans cette version 1 il y a 2 joueurs humains qui jouent à tour de rôle en saisissant au clavier le numéro de la colonne choisie (entre 0 et 6).

Voici une solution commentée pour cette version 1 de Puissance 4 à tester dans EduPython : puissance_4_v1.pyw

Évidemment cette solution n'est pas unique, mais elle répond aux 4 étapes demandées dans la version 1.

Dans ce programme la variable grille est une liste à 2 dimensions représentant l'état de la grille (0 : case vide, 1 : pion ROUGE ou 2 : pion BLEU)

Au départ la liste grille contient seulement des 0 puisque la grille est vide :

>>> grille=[7*[0], 7*[0], 7*[0], 7*[0], 7*[0], 7*[0]]
>>> grille
[[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]

grille[5] est une liste à 7 éléments représentant la ligne du bas (ligne 0) :

grille[5][0] est un entier valant 0, 1 ou 2 et représente la première case de la ligne du bas :

En modifiant grille[5][0] on modifie l'état de la case. Par exemple pour mettre un pion BLEU dans la case en bas à gauche on affecte la valeur 2 à grille[5][0] :

>>> grille[5][0]=2
>>> grille[5]
[2, 0, 0, 0, 0, 0, 0]
>>> grille
[[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[2, 0, 0, 0, 0, 0, 0]]

Comme vous l'aurez compris les autres cases de cette ligne sont indexées grille[5][1], grille[5][2], grille[5][3], grille[5][4], grille[5][5] et grille[5][6].

Chaque fois qu'on joue un nouveau pion le programme puissance_4_v1.pyw affiche sur la sortie standard l'état de la variable grille afin d'observer l'évolution de cette double liste.

Libre à chacun de tester cette version 1 dans EduPython, de s'en inspirer pour améliorer votre programme, ou de la prendre comme version de base à amélirer pour obtenir la version 2.

Nous allons faire évoluer la version 1 du programme Puissance 4 en ajoutant de l'interactivité : plutôt que de saisir à la main le numéro de la colonne où on veut jouer (nombre entre 0 et 6), on va faire en sorte que l'utilisateur clique simplement dans la colonne voulue avec le bouton gauche de la souris. Nous ajouterons ensuite quelques raccourcis clavier pratiques.

Étape 1 : améliorez votre programme Puissance 4 afin que l'utilisateur clique gauche dans la colonne où il veut jouer son pion à la place de la saisie du numéro de la colonne

Étape 2 : améliorez votre programme Puissance 4 afin que l'appui sur la touche Echap du clavier permette de recommencer une partie à zéro en vidant la grille

Dans cette version 2 il y a 2 joueurs humains qui jouent à tour de rôle en se passant la souris.

Si on clique dans la fenêtre de la tortue on est informé du point cliqué en recevant ses coordonnées (x,y) dans la fonction appelée par onscreenclick. Pour détecter une colonne nous allons analyser seulement l'intervale de l'abscisse x (peu importe la valeur de y).

En partant du programme puissance_4_v1.pyw de la version 1 donné ci-dessus, la variable x_base représente l'abscisse de la limite gauche de la grille et la variable largeur représente la largeur d'une colonne. Il en résulte que :

Plus que jamais, en utilisant les variables x_base et largeur la détection des colonnes restera valable même si on modifie la position ou la taille de la grille. En revanche, si on met des valeurs absolues sous forme de nombres entiers fixes pour détecter les colonnes, il faudrait tout refaire le jour où on change la taille de la grille.

Voici une solution commentée pour cette version 2 de Puissance 4 à tester dans EduPython : puissance_4_v2.pyw

Évidemment cette solution n'est pas unique, mais elle répond aux 2 étapes demandées dans la version 2 en ajoutant au jeu l'intéractivité demandée.

Cette version montre comment prendre en compte les actions venant de la souris, tout en distingant les 7 colonnes de la grille.

De plus comme demandé à l'étape 2 si on appuie sur la touche Echap (de code Escape) la grille se vide et la partie recommence à zéro (en lançant la fonction recommencer()).

Vous remarquerez il n'y a pas de boucle while dans ce programme : c'est la boucle principale lancée par done() à la fin du programme qui attend les évènements et la fermeture de la fenêtre.

Pour quitter proprement le programme il faut fermer la fenêtre de la tortue en cliquant sur la croix (il n'y a pas de raccourcis clavier programmé pour la fermeture).

Nous allons faire évoluer la version 2 du programme Puissance 4 afin de détecter automatiquement l'alignement de 4 pions de même couleur. Pour cela il faut analyser le contenu de la liste à 2 dimensions grille afin d'y détecter 4 valeurs identiques consécutives (1 pour ROUGE ou 2 pour BLEU).

Étape 1 : améliorez votre programme Puissance 4 afin qu'il détecte automatiquement 4 pions de même couleur alignés horizontalement

Étape 2 : améliorez votre programme Puissance 4 afin qu'il détecte automatiquement 4 pions de même couleur alignés verticalement

Étape 3 : améliorez votre programme Puissance 4 afin qu'il détecte automatiquement 4 pions de même couleur alignés en diagonale

Pour chacune de ces 3 étapes le programme doit afficher "Fin de la partie" ainsi que le joueur gagnant (joueur ROUGE ou joueur BLEU) lorsqu'il détecte l'alignement de 4 pions ou plus.

Si la grille est pleine et qu'il n'y a pas de gagnant le programme doit indiquer "Grille pleine : aucun gagnant".

Dans cette version 3 il y a toujours 2 joueurs humains qui jouent à tour de rôle en se passant la souris.

Toute la réflexion pour cette version 3 de Puissance 4 est concentré dans l'analyse de la variable grille afin d'y détecter 4 éléments identiques consécutifs correspondant à l'alignement de 4 pions de même couleur.

Prenons immédiatement un exemple concret pour illustrer l'analyse à faire sur la variable grille. On va analyser la grille lorsque le jeu est dans l'état suivant :

Comme illustré sur l'image ci-dessus les 6 lignes de la grille seront identifiées ici par les lettres de A (ligne du haut) à F (ligne du bas) et notre analyse portera uniquement sur la détection des pions alignés horizontalement (donc sur une même ligne).

Voici l'état de la variable grille correspondant à cet instant du jeu (0 : case vide, 1 : pion rouge, 2 : pion bleu) :

>>> grille
[[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 0, 0, 0],
[2, 2, 2, 2, 0, 0, 0],
[1, 2, 2, 1, 1, 1, 2]]

On rappelle que grille est une liste de 6 listes, correspondant chacune à une ligne :

Les lignes A, B et C sont vides donc il y a que des zéros dans la variable grille :

>>> grille[0]
[0, 0, 0, 0, 0, 0, 0]
>>> grille[1]
[0, 0, 0, 0, 0, 0, 0]
>>> grille[2]
[0, 0, 0, 0, 0, 0, 0]

La ligne D contient 4 pions rouges alignés. Voici l'état de la ligne D dans la variable grille :

La ligne E contient 4 pions bleus alignés. Voici l'état de la ligne E dans la variable grille :

La ligne F contient 7 pions quelconques. Voici l'état de la ligne F dans la variable grille :

Mais quelle analyse peut-on faire sur les listes grille[3], grille[4] et grille[5] ? Voici quelques exemples à affiner :

Combien de pions rouges sont présents sur la ligne D ? La méthode count liée aux listes permet de répondre à cette question :

On en déduit que la ligne D contient 4 pions rouges (puisqu'il y a 4 éléments "1" dans la liste grille[3]).

Combien de case vide y'a-t-il sur la ligne D ? Là encore la méthode count y répond :

On en déduit que la ligne E contient 0 pion rouge, 4 pions bleus et 3 cases vides.

On en déduit que la ligne F contient 4 pions rouges, 3 pions bleus et 0 case vide.

Problème : la méthode count permet de compter facilement le nombre de pions d'une même couleur présent sur une ligne, mais rien n'indique si les pions sont alignés ou pas.

Dans notre exemple on sait qu'on a 4 pions rouges sur la ligne D et 4 pions rouges sur la ligne F. Or sur la ligne D les 4 pions rouges sont alignés alors que sur la ligne F ils ne sont pas alignés.

Pour cela il ne suffit pas de compter le nombre de 1 présent dans la liste. Il faudrait pouvoir détecter si la sous-liste [1,1,1,1] appartient à la liste correspondant à la ligne :

Le travail qu'il reste à faire est donc d'écrire une fonction capable de repérer une sous-liste dans une liste. Une fois cette fonction écrite alors il sera possible de détecter tous les alignements de pions dans la grille.

Vous l'avez compris, la maîtrise de l'analyse et de la manipulation des listes en Python est fondamentale pour trouver la solution de la version 3 de Puissance 4 et ainsi détecter l'alignement de 4 pions de même couleur : la manipulation des listes en Python n'est pas qu'une vue de l'espris mais permet de résoudre des problèmes réels.

Voici une solution commentée pour cette version 3 de Puissance 4 à tester dans EduPython : puissance_4_v3.pyw

Nous allons maintenant faire évoluer le programme afin de jouer contre l'ordinateur.

Dans cette version le joueur humain aura les pions ROUGES et l'ordinateur jouera les pions BLEUS. Mais l'ordinateur ne sera pas, en un premier temps, très intelligent : il jouera au hasard une colonne non pleine parmi les 7.

Ne nous y trompons pas, même si la stratégie parait simpliste, elle peut être très déstabilisante pour un joueur humain qui chercherait à comprendre comment joue l'ordinateur ...

Étape 1 : améliorez votre programme Puissance 4 afin que les pions BLEUS soit joués automatiquement par l'ordinateur qui doit choisir au hasard une colonne non pleine

Étape 2 : améliorez votre programme Puissance 4 afin de demander au démarrage qui commence : le joueur humain (ROUGE) ou l'ordinateur (BLEU) ?

Dans cette version 4 il n'y a plus qu'un seul joueur humain, il joue les pions ROUGES à la souris, et l'ordinateur joue automatiquement les pions BLEUS.

Voici une solution commentée pour cette version 4 de Puissance 4 à tester dans EduPython : puissance_4_v4.pyw

Nous allons maintenant faire évoluer la stratégie gagnante de l'ordinateur. Dans la version précédente l'ordinateur jouait au hasard dans une colonne non pleine. Ici il va essayer d'empêcher le joueur humain (ROUGE) de gagner, ou essayer lui même (BLEU) d'aligner 4 pions.

L'objectif de cette version 5 de Puissance 4 est d'analyser la structure de données grille[][] (une liste de listes) afin d'y rechercher des informations sur la répartition des pions dans la grille et de prendre en fonction des décisions pour améliorer l'intelligence artificielle mise en jeu par le programme qui joue les pions BLEUS.

Étape 1 : améliorez votre programme Puissance 4 afin que l'ordinateur empêche en priorité l'alignement de pions ROUGES :

Étape 2 : améliorez votre programme Puissance 4 afin que l'ordinateur, s'il n'a pas de coup à casser côté ROUGE, se concentre sur l'alignement de 4 pions BLEUS plutôt que de jouer au hasard

Dans cette version 5 il y a toujours un seul joueur humain, il joue les pions ROUGES à la souris, et l'ordinateur qui joue automatiquement les pions BLEUS.