ajout de licence et overhaul

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 <https://www.gnu.org/licenses/>.
+ */
+
 #include <stdio.h> // à enlever après
 #include <stdlib.h>
 #include <stdbool.h>
 
-#define X_BLOCK_SIZE 20
+#include "grille.h"
-#define Y_BLOCK_SIZE 10
 
 
-typedef enum jeton {
+char repr_jeton(jeton j)
-	VIDE = 0,
+{
-	BLEU = 1,
+	switch (j)
-	ROUGE = 2
+	{
-} jeton;
+		case (BLEU):
-
+			return 'X';
-typedef struct colonne {
+		case (ROUGE):
-	int hauteur;
+			return '0';
-	int capacite;
+		default:
-	jeton* jetons;
+			return ' ';
-} colonne;
+	}
+}
 
 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; i<col->hauteur; 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
+	 *	d'où n_positifs = largeur/2 + largeur%2
-	 *	     n_negatifs = 1 + (largeur-1)/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]
+	 * 		10 nombres positifs [0, 9] et 10 nombres négatifs [-10, -1] représenté
-	 *	
-	 *	-	... TODO
 	 */
 
 	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; i<g->n_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<d_len; i++)
 	{
 		(*tab)[*len + i] = creer_colonne(Y_BLOCK_SIZE);
 		if ((*tab)[*len + i] == NULL)
@@ -234,19 +259,52 @@ bool etendre_droite(int d_len, grille *g)
 }
 
 
-colonne* get_colonne(int indice)
+colonne *get_colonne(int i, grille *g)
 {
-	// pour les positifs, de l'indice dans la représentation à double sensles positifs: 0 |-> 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; i<g->n_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();
+}

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 */