minigame-menu/grid.h

/*
 * Created by snapshot112 on 2/10/2025
 *
 * This module provides a grid api.
 *
 * A grid is a rectangular grid of objects. Every object in this grid is a char.
 */

#ifndef _GRID_H
#define _GRID_H

#include <stdio.h>


struct grid_data;
typedef struct grid_data grid;

typedef enum {
    STATE_BEGIN,
    STATE_AAN_HET_SPELEN,
    STATE_GEWONNEN,
    STATE_VERLOREN,
    STATE_QUIT
} state;

/* Maak een rooster op basis van de data in de gegeven stream.
 *
 * fh: de stream waaruit het doolhof gelezen moet worden.
 *
 * Uitvoer: als alles goed gaat, een pointer naar een rooster (die op de heap is
 *          gealloceerd), dat overeenkomt met de gegeven beschrijving.
 *          De begintoestand is BEGIN.
 *
 *          Als de beschrijving niet consistent is (bijvoorbeeld
 *          niet alle rijen zijn even lang, of er klopt iets anders niet), of
 *          als niet voldoende geheugen kan worden gereserveerd, dan wordt
 *          NULL teruggegeven. (In dat geval blijft geen gereserveerd geheugen
 *          achter.)
 */
grid *grid_create_from_file(FILE *fh);

/*
 * Maak een rooster op basis van een gegeven string.
 *
 * Uitvoer: als alles goed gaat, een pointer naar een rooster (die op de heap is
 *         gealloceerd), dat overeenkomt met de gegeven beschrijving.
 *         De begintoestand is BEGIN.
 *
 *         Als de beschrijving niet consistent is (bijvoorbeeld
 *         niet alle rijen zijn even lang, of er klopt iets anders niet), of
 *         als niet voldoende geheugen kan worden gereserveerd, dan wordt
 *         NULL teruggegeven. (In dat geval blijft geen gereserveerd geheugen
 *         achter.)
 */
grid *grid_create_from_string(const char* input);

/*
 * Haal een rij uit het rooster op.
 *
 * Input:
 * gp: een pointer naar het rooster
 * y: de y-coordinaat van de rij die je wilt hebben.
 *
 * Output:
 * Een pointer naar een nieuwe string met daarin alle karakters in die rij.
 */
char *grid_fetch_row(const grid *gp, int y);

/*
 * Maak een kopie van een rooster
 *
 * Input:
 * gp: Een pointer naar het rooster.
 *
 * Output:
 * Een pointer naar het kopie.
 */
grid *grid_copy(const grid *gp);

/* Vraag de huidige toestand van het spel op.
 *
 * Input:
 * gp: een pointer naar het rooster.
 *
 * Uitvoer: de toestand.
 */
state grid_fetch_state(const grid *gp);


/* Verander de huidige toestand van het spel.
 *
 * gp: een pointer naar het rooster.
 * t:  de nieuwe toestand.
 */
void grid_put_state(grid *gp, state t);


/* Geef alle resources vrij die zijn gealloceerd voor een rooster.
 * De rooster pointer is na aanroep van deze functie niet meer bruikbaar.
 *
 * gp: een pointer naar het rooster.
 */
void grid_cleanup(grid *gp);


/* Vraag de breedte van het rooster op, dat wil zeggen, het aantal kolommen.
 *
 * gp: een pointer naar het rooster.
 *
 * Uitvoer: de breedte.
 */
int grid_width(const grid *gp);


/* Vraag de hoogte van het rooster op, dat wil zeggen, het aantal rijen.
 *
 * gp: een pointer naar het rooster.
 *
 * Uitvoer: de hoogte.
 */
int grid_height(const grid *gp);


/* Kijk of de gegeven positie binnen het rooster valt.
 *
 * gp:  een pointer naar het rooster.
 * x,y: de positie.
 *
 * Uitvoer: 1 als de positie binnen het rooster valt, anders 0.
 */
int grid_contains(const grid *gp, int x, int y);


/* Kijk welk object er staat op een bepaalde positie in het rooster.
 *
 * gp : een pointer naar het rooster
 * x,y: de betreffende positie.
 *
 * Uitvoer: het object op die positie, of '\0' als de positie buiten het
 *          rooster valt.
 */
char grid_fetch(const grid *gp, int x, int y);


/* Schrijf een bepaald object op een bepaalde positie in het rooster.
 *
 * gp : een pointer naar het rooster
 * x,y: de betreffende positie.
 * c  : het object.
 *
 * Effect: als (x,y) binnen het rooster ligt, wordt het object op
 *         de opgegeven positie geplaatst, anders verandert er niets.
 *
 * Uitvoer: 1 als het object is geplaatst, of 0 als het buiten de grenzen lag.
 */
int grid_put(grid *gp, int x, int y, char c);


/* Zoek een bepaald object in het rooster, en geef de coordinaten van het
 * object terug via de gegeven pointers. Let op: als er meerdere objecten van
 * het gezochte soort in het rooster voorkomen, is niet gedefinieerd van welke
 * de positie wordt gevonden.
 *
 * gp : een pointer naar het rooster
 * c  : het object dat moet worden gezocht
 * x,y: pointers naar de geheugenlocaties waar de gevonden positie moet worden
 *      geschreven.
 *
 * Uitvoer: via de pointers x en y. Als het object niet wordt gevonden worden
 *          *x en *y op -1 gezet.
 */
void grid_find(const grid *gp, char c, int *x, int *y);

#endif //_GRID_H