Jeu morpion 5 croix

	
#include <ncurses.h>

#include <stdlib.h>

#include <unistd.h>

#include <time.h>

/* option: la longueur d'une ligne. */
int line_length = 5;

/* option: si deux lignes sont autorisées à être dans la même direction et
 connectées bout à bout. Remarque: deux lignes qui se croisent sont toujours correctes. */

int disjoint = 0;

int **grille = 0, width, height;

enum {
    s_blank        = 0,
    s_occupied    = 1 << 0,
    s_dir_ns    = 1 << 1,
    s_dir_ew    = 1 << 2,
    s_dir_ne_sw    = 1 << 3,
    s_dir_nw_se    = 1 << 4,
    s_newly_added    = 1 << 5,
    s_current    = 1 << 6,
};

int irand(int n)
{
    int r, rand_max = RAND_MAX - (RAND_MAX % n);
    while ((r = rand()) >= rand_max);
    return r / (rand_max / n);
}

int alloc_grille(int w, int h)
{
    int i;
    int buf = calloc(1, sizeof(int *) * h + sizeof(int) * h * w);

buf[0] = (int*)(buf + h);
for (i = 1; i < h; i++)
    buf[i] = buf[i - 1] + w;
return buf;
}

/* -1: élargit l'extrémité inférieure de l'index; 1: exten high index end */

void elargir_grille(int dw, int dh)
{
    int i, j;
    int nlargeur = width + !!dw, nhauteur = height + !!dh;

/* garanti pour fragmenter le tas: pas de réallocation car la copie d'éléments
  est un peu délicate */


int **nbuf = alloc_grille(nlargeur, nhauteur);

dw = -(dw < 0), dh = -(dh < 0);

for (i = 0; i < nhauteur; i++) {
    if (i + dh < 0 || i + dh >= height) continue;
    for (j = 0; j < nlargeur; j++) {
        if (j + dw < 0 || j + dw >= width) continue;
        nbuf[i][j] = grille[i + dh][j + dw];
    }
}
free(grille);

grille = nbuf;
width = nlargeur;
height = nhauteur;
}

void tab_set(int **buf, int v, int x0, int y0, int x1, int y1)
{
    int i, j;
    for (i = y0; i <= y1; i++)
        for (j = x0; j <= x1; j++)
            buf[i][j] = v;
}

void show_grille()
{
    int i, j;
    for(i = 0; i < height; i++)
    {
        for(j = 0; j < width; j++)
        {
            mvprintw(i + 1, j * 2,
            (grille[i][j] & s_current) ? "X "
            : (grille[i][j] & s_newly_added) ? "O "
            : (grille[i][j] & s_occupied) ? "+ " : "  ");
    refresh();
        }
    }
}

void init_grille()
{
    width = height = 3 * (line_length - 1);
    grille = alloc_grille(width, height);

tab_set(grille, s_occupied, line_length - 1, 1, 2 * line_length - 3, height - 2);
tab_set(grille, s_occupied, 1, line_length - 1, width - 2, 2 * line_length - 3);

tab_set(grille, s_blank, line_length, 2, 2 * line_length - 4, height - 3);
tab_set(grille, s_blank, 2, line_length, width - 3, 2 * line_length - 4);
}

int ofs[4][3] = {
    {0, 1, s_dir_ns},
    {1, 0, s_dir_ew},
    {1, -1, s_dir_ne_sw},
    {1, 1, s_dir_nw_se}
};

typedef struct { int m, s, seq, x, y; } move_t;

/* teste si un point peut compléter une ligne, ou prendre ce point */

void test_postion(int y, int x, move_t * rec)
{
    int m, k, s, dx, dy, xx, yy, dir;
    if (grille[y][x] & s_occupied) return;

for (m = 0; m < 4; m++) { /* 4 directions */
    dx = ofs[m][0];
    dy = ofs[m][1];
    dir = ofs[m][2];

    for (s = 1 - line_length; s <= 0; s++) { /* ligne de décalage */
        for (k = 0; k < line_length; k++) {
            if (s + k == 0) continue;

            xx = x + dx * (s + k);
            yy = y + dy * (s + k);
            if (xx < 0 || xx >= width || yy < 0 || yy >= height)
                break;

            /* aucune pièce à la position */
            if (!(grille[yy][xx] & s_occupied)) break;

            /* cette direction prise */
            if ((grille[yy][xx] & dir)) break;
        }
        if (k != line_length) continue;

        /* position ok; irand () pour égaliser la chance de chaque option d'
           être choisit */
        if (! irand(++rec->seq))
            rec->m = m, rec->s = s, rec->x = x, rec->y = y;
    }
}
}

void add_piece(move_t *rec) {
    int dx = ofs[rec->m][0];
    int dy = ofs[rec->m][1];
    int dir= ofs[rec->m][2];
    int xx, yy, k;

grille[rec->y][rec->x] |= (s_current | s_occupied);

for (k = 0; k < line_length; k++) {
    xx = rec->x + dx * (k + rec->s);
    yy = rec->y + dy * (k + rec->s);
    grille[yy][xx] |= s_newly_added;
    if (k >= disjoint || k < line_length - disjoint)
        grille[yy][xx] |= dir;
}
}

int next_move()
{
    int i, j;
    move_t rec;
    rec.seq = 0;

/* effacer les nouveaux marqueurs de ligne de la dernière itération */

for(i = 0; i < height; i++)
{
    for(j = 0; j < width; j++)
    {
         grille[i][j] &= ~(s_newly_added | s_current);
    }
}

/* choisir au hasard l'un des prochains coups légaux */

for(i = 0; i < height; i++)
{
    for(j = 0; j < width; j++)
    {
        test_postion(i, j, &rec);
    }
}

/* n'a trouvé aucun coup, jeu terminé */

if (!rec.seq) return 0;

add_piece(&rec);

if (rec.x == width - 1)
{
 rec.x == 1;
}
else {
      if (rec.x)
    {
        rec.x = 0;
    }
      else {
        rec.x = -1;
    }
}

if (rec.y == height - 1)
{
 rec.y == 1;
}
else {
        if (rec.y)
        {
            rec.y = 0;
        }
        else {
            rec.y = -1;
        }
}

if (rec.x || rec.y) elargir_grille(rec.x, rec.y);
return 1;
}

int main()
{
    int ch = 0;
    int move = 0;
    int wait_key = 1;

init_grille();
srand(time(0));

initscr();
noecho();
cbreak();

do  {
    mvprintw(0, 0, "Move %d", move++);
    show_grille();
    if (!next_move()) {
        next_move();
        show_grille();
        break;
    }
    if (!wait_key) usleep(100000);
    if ((ch = getch()) == ' ') {
        wait_key = !wait_key;
        if (wait_key) timeout(-1);
        else timeout(0);
    }
} while (ch != 'q');

timeout(-1);
nocbreak();
echo();

endwin();
return 0;
}