From 78144a6a92c6eab9e84cd225cfcd0e37eeaa83e9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Valentin=20Mogu=C3=A9rou?= Date: Sun, 22 Oct 2023 11:52:46 +0200 Subject: [PATCH] ajout de licence et overhaul --- grille.c | 154 ++++++++++++++++++++++++++++++++++++++++--------------- grille.h | 37 +++++++++++++ 2 files changed, 150 insertions(+), 41 deletions(-) create mode 100644 grille.h diff --git a/grille.c b/grille.c index af8ee82..db38fbb 100644 --- a/grille.c +++ b/grille.c @@ -1,22 +1,40 @@ +/* + * Infini puissance N : un jeu à plusieurs joueurs. + * Copyright (C) 2023 Valentin Moguérou + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + #include // à enlever après #include #include -#define X_BLOCK_SIZE 20 -#define Y_BLOCK_SIZE 10 +#include "grille.h" -typedef enum jeton { - VIDE = 0, - BLEU = 1, - ROUGE = 2 -} jeton; - -typedef struct colonne { - int hauteur; - int capacite; - jeton* jetons; -} colonne; +char repr_jeton(jeton j) +{ + switch (j) + { + case (BLEU): + return 'X'; + case (ROUGE): + return '0'; + default: + return ' '; + } +} void print_tab(jeton *tab, int n) { @@ -27,7 +45,9 @@ void print_tab(jeton *tab, int n) void print_colonne(colonne *col) { - print_tab(col->jetons, col->capacite); + for (int i=0; ihauteur; i++) + putc(repr_jeton(col->jetons[i]), stdout); + putc('\n', stdout); } void init_zeros(jeton* ptr, int count) @@ -77,7 +97,7 @@ bool agrandir_colonne(int diff_taille, colonne *col) } -bool ajouter_jeton(jeton j, colonne *col) +bool ajouter_jeton_col(jeton j, colonne *col) { if (col->hauteur >= col->capacite && !agrandir_colonne(Y_BLOCK_SIZE, col)) @@ -89,7 +109,7 @@ bool ajouter_jeton(jeton j, colonne *col) return true; } -jeton acceder_jeton_col(int indice, colonne *col) +jeton get_jeton_col(int indice, colonne *col) { return (indice < col->hauteur) ? col->jetons[indice] : VIDE; } @@ -100,14 +120,6 @@ void detruire_colonne(colonne *col) free(col); } - -typedef struct grille { - int n_positifs; - colonne **positifs; - int n_negatifs; - colonne **negatifs; -} grille; - /* * On essaie de représenter une structure abstraite comme ceci : * En abscisse, les "colonne*"; en ordonnée, les "jeton" @@ -128,7 +140,7 @@ typedef struct grille { * * g->negatifs = [colonne*(-1), colonne*(-2) , ...] * // autant que de colonnes str. négatives ç.à.d autant que g->n_negatifs - */ + */ grille *creer_grille(int largeur) { @@ -137,36 +149,49 @@ grille *creer_grille(int largeur) * |-----------------------------|-----------------------------| * negatifs 0 positifs * - * d'où n_positifs = (largeur-1)/2 - * n_negatifs = 1 + (largeur-1)/2 + * d'où n_positifs = largeur/2 + largeur%2 + * n_negatifs = largeur/2 * * de telle sorte que: * n_negatifs + n_positifs = largeur * * Ex : * - L'intervalle [-10, 9] de cardinal 20 se découpe en - * 10 nombres positifs [0, 9] et 10 nombres négatifs [-10, -1] - * - * - ... TODO + * 10 nombres positifs [0, 9] et 10 nombres négatifs [-10, -1] représenté */ grille *g = malloc(sizeof(grille)); if (g == NULL) return NULL; - g->n_positifs = largeur/2; + g->n_positifs = largeur/2 + largeur%2; + g->n_negatifs = largeur/2; g->positifs = malloc(g->n_positifs * sizeof(colonne*)); + g->negatifs = malloc(g->n_negatifs * sizeof(colonne*)); - if (g->positifs == NULL) + if (g->positifs == NULL || g->negatifs == NULL) + { + free(g->positifs); + free(g->negatifs); free(g); + } bool echec_allocation = false; - for (int i=0; in_positifs; i++) + + for (int i=0; i < g->n_positifs; i++) { g->positifs[i] = creer_colonne(Y_BLOCK_SIZE); if (g->positifs[i] == NULL) - allocation_fail = true; + echec_allocation = true; } + + for (int i=0; i < g->n_negatifs; i++) + { + g->negatifs[i] = creer_colonne(Y_BLOCK_SIZE); + if (g->negatifs[i] == NULL) + echec_allocation = true; + } + // si une colonne n'a pas pu être crée, on détruit la grille if (echec_allocation) @@ -199,7 +224,7 @@ bool etendre_tab(int d_len, int *len, colonne ***tab) *tab = tab_nouv; bool echec_allocation = false; - for (int i=0; i<*d_len; i++) + for (int i=0; i 0 ; 1 |-> 1 + /* La structure de tableau double sens se traduit de la façon suivante : + * + * Si i >= 0, on regarde g->positifs[i] + * Si i < 0, on regarde g->negatifs[-i-1] + */ + + if (i >= 0 && i < g->n_positifs) + return g->positifs[i]; + else if (i < 0 && ~i < g->n_negatifs) + return g->negatifs[~i]; + else + return NULL; // en dehors de l'allocation +} + +jeton get_case(int x, int y, grille *g) +{ + colonne *col = get_colonne(x, g); + return (col != NULL) ? get_jeton_col(y, col) : VIDE; +} + + +bool ajouter_jeton(jeton j, int x, grille *g) +{ + if (x >= 0 && x > g->n_positifs) + for (int i=0; i < x-g->n_positifs+1; i++) + if (!etendre_droite(X_BLOCK_SIZE, g)) + return false; + + if (x < 0 && ~x > g->n_negatifs) + for (int i=0; i < ~x-g->n_negatifs+1; i++) + if (!etendre_gauche(X_BLOCK_SIZE, g)) + return false; + + return ajouter_jeton_col(j, get_colonne(x, g)); } void detruire_grille(grille *g) { - for (int i=0; in_positifs) + for (int i=0; i < g->n_positifs; i++) if (g->positifs[i] != NULL) detruire_colonne(g->positifs[i]); - for (int i=-1; i>=g->n_negatifs) + for (int i=0; i < g->n_negatifs; i++) if (g->negatifs[i] != NULL) detruire_colonne(g->negatifs[i]); @@ -258,14 +316,14 @@ void detruire_grille(grille *g) -int main() +int test_colonne() { colonne *col = creer_colonne(Y_BLOCK_SIZE); print_colonne(col); for (int i=0; i<15; i++) { - if (ajouter_jeton((i%2==0) ? ROUGE : BLEU, col)) + if (ajouter_jeton_col((i%2==0) ? ROUGE : BLEU, col)) printf("Jeton ajouté.\n"); else fprintf(stderr, "Erreur dans l'ajout d'un jeton.\n"); @@ -277,3 +335,17 @@ int main() return 0; } + +int test_grille() +{ + grille *g = creer_grille(20); + + detruire_grille(g); + + return 0; +} + +int main() +{ + return test_grille(); +} diff --git a/grille.h b/grille.h new file mode 100644 index 0000000..bc43ea7 --- /dev/null +++ b/grille.h @@ -0,0 +1,37 @@ +#ifndef GRILLE_H_INCLUDED +#define GRILLE_H_INCLUDED + +#define X_BLOCK_SIZE 20 +#define Y_BLOCK_SIZE 10 + +typedef enum jeton { + VIDE = 0, + BLEU = 1, + ROUGE = 2 +} jeton; + +typedef struct colonne { + int hauteur; + int capacite; + jeton* jetons; +} colonne; + +typedef struct grille { + int n_positifs; + colonne **positifs; + int n_negatifs; + colonne **negatifs; +} grille; + + +grille *creer_grille(int largeur); + +colonne *get_colonne(int i, grille *g); + +jeton get_case(int x, int y, grille *g); + +bool ajouter_jeton(jeton j, int x, grille *g); + +void detruire_grille(grille *g); + +#endif /* GRILLE_H_INCLUDED */