hori:
2111
1211
1121

vert
2
1
1
1

dia:
2
  1
    1
      1

1
  2 
    1
      1

1
  1
    2
      1

1
  1
    1
      2

et idem dans l'autre sens

56    57    58    59    60    61    62    63    64
48    49    50    51    52    53    54    55   
40    41    42    43    44    45    46    47
32    33    34    35    36    37    38    39
24    25    26    27    28    29    30    31
16    17    18    19    20    21    22    23
 8    9     10    11    12    13    14    15
 0     1     2     3     4     5     6     7

0->a
25->i
While mat[i]!=-1
If mat[i]=joueur Then
a+1->a
If a=4 : return 1
Else
0->a
EndIf
i+1->i
EndWhile

 0  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

#include <tigcclib.h>

int aligne(int,int,char*);
int ai(int,char*);
void rec(int,int,char*, int*);

// Main Function
void _main(void)
{
  int  g, pos=3, cp=0,jo=1 ;
  char m[49] ;
  static unsigned char circle[14] = {0b00011100,0b00100010,0b01000001,0b01000001,0b01000001,0b00100010,0b00011100,0b00011100,0b00111110,0b01111111,0b01111111,0b01111111,0b00111110,0b00011100};
  char *pt=circle ;
  memset (m, 0, 49 * sizeof(char)); //initialise les cases du jeu et la hauteur (cases 42 à 49) à 0;
  ClrScr();
  //Affichage du plateau
  for (g=20 ; g<91 ; g+=10) DrawLine (g, 32, g, 80, A_NORMAL); // g sera aussi utilisé pour les touches
  DrawLine (20, 80, 90, 80, A_NORMAL);
   while (g != 264) //tant qu'on appuie pas sur ESC
  {
     memset (LCD_MEM, 0, 960);//efface ligne de reflexion + curseur
     DrawStr ( pos*10+22, 24, "24", A_NORMAL); //affichage du curseur
     g=ngetchx(); //si une touche est appuyée
     if (pos>0 && g==338) pos--;  //déplacement du curseur
     if (pos<6 && g==344) pos++;   //déplacement du curseur
     while(g==340 && m[42+pos]<6)
    {
      Sprite8 ( pos*10+21, 72-m[42+pos]*8, 7, pt + (7*jo-7), LCD_MEM, SPRT_OR);
       m[(5-m[42+pos]++)*7+pos]=jo;
       if (aligne( pos, jo, m) || ++cp==42)
       {
         DrawStr ( 10, 92,cp==42 ? "Match nul." : jo==1 ? "Vous avez gagné !!!" :  "Vous avez perdu.", A_NORMAL);
         ngetchx();
         return;
       } 
       jo=3-jo;
      if (jo==1) break;
       pos=ai(jo, m);
    }  
  }
}
int aligne(int pos,int jo, char *m)
{
  int i,a,b,i2,i3;
  a=b=0;
  for (i=0;i<7;i++)
  {
    a=(a+1)*(m[(6-m[42+pos])*7+i]==jo);  //horizontal
    b=(b+1)*(m[i*7+pos]==jo);      //vertical
    if (a==4 || b==4) return 1;
  }
  for (i=0;i<3;i+=2)              //test des diagonales
  {
    a=0;
    i2=(i-1)*m[42+pos]-i+pos+36;
    if ((i2 < 35) || (i2 > 41)) i2=(-7*i+7)*i2+269*i-210;
    i3=i2;
    while((i2>=0) && ((i2%7) != 3*i || i2 == i3 ))
    {
      a = (a+1)*(m[i2]==jo);
      if (a==4) return 1;
      i2-=6+i;
    }
  }
  return 0; //si aucune ligne, retourne 0
}

int ai(int jo, char *m)  
{
  int imax=0, score[8] ; //score[7] est la position(colonne) en cours de reflexion
   memset (score, 0, 8 * sizeof(int));  //initialise les scores à 0
  rec(jo, 0, m, score); //Lance la fonction récursive
  score[3]+=8; //pour que le coup du milieu ait plus de points
   for (jo=1;jo<7;jo++) //utilisation de jo pour ne pas définir une variable en plus
  {
    if (score[jo] > score[imax]) imax=jo;
  }
  return (imax);
}

void rec(int jo, int compt, char *m, int *score)
{
  int i,posm; 
    if (compt<5) //limite la profondeur à 5 coups à l'avance
    {
      for (i=0;i<7;i++) //parcourt les différentes colonnes
      {
        if (m[42+i]<6) //si la colonnes n'est pas pleine
        {
          posm=(5-m[42+i])*7+i;
          m[posm]=jo;
          m[42+i]++;
          rec(3-jo,compt+1,m, score);
          if (aligne(i,jo, m))
          {
            //decompte des points en fonction du joueur
            score[score[7]]-=3*jo*(compt-20)+2*compt+100 ;
            if (compt<2)
            {
              score[score[7]]=(compt*-55+30)*1000;
              score[i]+=500*compt;
              m[posm]=0;
              m[42+i]--;
              break;
            }
            if (compt == 2) score[i]-=400;
          }
          m[posm]=0;
          m[42+i]--;
          
        }
        if (compt==0) 
        {
          memset (LCD_MEM, 255, score[7]*3+3);//affichage d'une barre de réflexion
          if (m[42+i]==6) score[score[7]]=-30000; //si la colonne est pleine, score dérisoir pour pas qu'il soit joué
          score[7]++;
        }
      }
    }
}