General refactor and minor improvements
This commit is contained in:
297
grid.c
Normal file
297
grid.c
Normal file
@@ -0,0 +1,297 @@
|
||||
#include "grid.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/*
|
||||
* The grid type this program is build around.
|
||||
*/
|
||||
typedef struct grid_data {
|
||||
char *rost;
|
||||
int height;
|
||||
int width;
|
||||
state state;
|
||||
} grid;
|
||||
|
||||
static int internal_location(const grid *gp, const int x, const int y) {
|
||||
return y * (gp->width + 1) + x;
|
||||
}
|
||||
|
||||
grid *grid_create_from_string(const char* input) {
|
||||
int width = 0;
|
||||
int height = 0;
|
||||
const size_t len = strlen(input) / sizeof(char);
|
||||
if (input == NULL || len == 0) {
|
||||
printf("invalid input\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (int i = 0; input[i] != '\n'; i++) {
|
||||
width++;
|
||||
}
|
||||
|
||||
height = (int)len / (width + 1);
|
||||
|
||||
for (int i = 0; i < height; i = i + width + 1) {
|
||||
if ((int)strcspn(&input[i], "\n") != width) {
|
||||
printf("line %d was not %d wide\n", i, width);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
const int grid_size = (width + 1) * height + 1;
|
||||
|
||||
grid *gp = malloc(sizeof(grid));
|
||||
|
||||
if (gp == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
gp->rost = malloc(grid_size * sizeof(char));
|
||||
gp->height = height;
|
||||
gp->width = width;
|
||||
gp->state = STATE_BEGIN;
|
||||
|
||||
strcpy(gp->rost, input);
|
||||
|
||||
return gp;
|
||||
}
|
||||
|
||||
/*
|
||||
* Sets a grids width and height
|
||||
*
|
||||
* Input:
|
||||
* fh: the stream to read the grid from.
|
||||
* rost: a grid file to store the width and height in.
|
||||
*
|
||||
* Side effects:
|
||||
* the grid gets its width and height set
|
||||
*
|
||||
* Output:
|
||||
* 1 if the file width and height seem to match with its size
|
||||
* 0 otherwise
|
||||
*/
|
||||
static int get_grid_sizes(FILE *fh, grid *rost) {
|
||||
while (getc(fh) != '\n') {
|
||||
if (feof(fh)) {
|
||||
return 0;
|
||||
}
|
||||
rost->width++;
|
||||
}
|
||||
|
||||
if (rost->width == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
fseek(fh, 0, SEEK_END);
|
||||
|
||||
// Get file size (- 1 for the blank newline and EOF at the end)
|
||||
if (ftell(fh) % (rost->width + 1) != 0) {
|
||||
// Not all lines are the same width
|
||||
return 0;
|
||||
}
|
||||
|
||||
rost->height = (int)ftell(fh) / (int)sizeof(char) / (rost->width + 1);
|
||||
fseek(fh, 0, SEEK_SET);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
grid *grid_create_from_file(FILE *fh) {
|
||||
if (fh == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
grid rost = {
|
||||
NULL,
|
||||
0,
|
||||
0,
|
||||
STATE_BEGIN
|
||||
};
|
||||
|
||||
// Sets the width and height of the grid.
|
||||
if (get_grid_sizes(fh, &rost) != 1) {
|
||||
// Unlogical file structure.
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const int grid_size = (rost.width + 1) * rost.height + 1;
|
||||
|
||||
rost.rost = malloc(grid_size * sizeof(char));
|
||||
if (rost.rost == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// This makes the strncat() work.
|
||||
rost.rost[0] = '\0';
|
||||
|
||||
char *line = malloc((rost.width + 2) * sizeof(char));
|
||||
if (line == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (int i = 0; i < rost.height; i++) {
|
||||
if (fgets(line, rost.width + 2, fh) == NULL) {
|
||||
free(rost.rost);
|
||||
free(line);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Validate that the line length is correct
|
||||
if ((int)strcspn(line, "\n") != rost.width) {
|
||||
free(rost.rost);
|
||||
free(line);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Width is without the newline at the end.
|
||||
strncat(rost.rost, line, rost.width + 1);
|
||||
}
|
||||
|
||||
free(line);
|
||||
|
||||
grid *return_grid = malloc(sizeof(rost));
|
||||
if (return_grid == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
memcpy(return_grid, &rost, sizeof(rost));
|
||||
|
||||
return return_grid;
|
||||
}
|
||||
|
||||
state grid_fetch_state(const grid *gp) {
|
||||
if (gp != NULL) {
|
||||
return gp->state;
|
||||
}
|
||||
return STATE_VERLOREN;
|
||||
}
|
||||
|
||||
void grid_put_state(grid *gp, const state t) {
|
||||
if (gp != NULL) {
|
||||
switch (t) {
|
||||
case STATE_BEGIN:
|
||||
gp->state = STATE_BEGIN;
|
||||
break;
|
||||
case STATE_AAN_HET_SPELEN:
|
||||
gp->state = STATE_AAN_HET_SPELEN;
|
||||
break;
|
||||
case STATE_GEWONNEN:
|
||||
gp->state = STATE_GEWONNEN;
|
||||
break;
|
||||
case STATE_VERLOREN:
|
||||
gp->state = STATE_VERLOREN;
|
||||
break;
|
||||
case STATE_QUIT:
|
||||
gp->state = STATE_QUIT;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void grid_cleanup(grid *gp) {
|
||||
if (gp != NULL) {
|
||||
if (gp->rost != NULL)
|
||||
{
|
||||
free(gp->rost);
|
||||
}
|
||||
free(gp);
|
||||
}
|
||||
}
|
||||
|
||||
int grid_width(const grid *gp) {
|
||||
if (gp == NULL) {
|
||||
return 0;
|
||||
}
|
||||
return gp->width;
|
||||
}
|
||||
|
||||
int grid_height(const grid *gp) {
|
||||
if (gp == NULL) {
|
||||
return 0;
|
||||
}
|
||||
return gp->height;
|
||||
}
|
||||
|
||||
int grid_contains(const grid *gp, const int x, const int y) {
|
||||
if (gp != NULL && gp->rost != NULL) {
|
||||
if (x >= 0 && y >= 0 && x < gp->width && y < gp->height)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
char grid_fetch(const grid *gp, const int x, const int y) {
|
||||
if (gp != NULL && gp->rost != NULL && grid_contains(gp, x, y) == 1) {
|
||||
return gp->rost[internal_location(gp, x, y)];
|
||||
}
|
||||
return '\0';
|
||||
}
|
||||
|
||||
int grid_put(grid *gp, const int x, const int y, const char c) {
|
||||
if (gp != NULL && gp->rost != NULL && grid_contains(gp, x, y) == 1) {
|
||||
gp->rost[internal_location(gp, x, y)] = c;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
char *grid_fetch_row(const grid *gp, const int y) {
|
||||
if (gp != NULL && gp->rost != NULL && grid_contains(gp, 0, y) == 1) {
|
||||
// we're going to remove the newline so this is long enough
|
||||
char *row = malloc((gp->width + 1) * sizeof(char));
|
||||
memcpy(row, &gp->rost[internal_location(gp, 0, y)], gp->width * sizeof(char));
|
||||
row[gp->width] = '\0';
|
||||
return row;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
grid *grid_copy(const grid *gp) {
|
||||
if (gp != NULL && gp->rost != NULL) {
|
||||
const size_t grid_memory = ((gp->width + 1) * gp->height + 1) * sizeof(char);
|
||||
|
||||
char *rost = malloc(grid_memory);
|
||||
if (rost == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
grid *new_grid = malloc(sizeof(*gp));
|
||||
if (new_grid == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
memcpy(rost, gp->rost, grid_memory);
|
||||
|
||||
memcpy(new_grid, gp, sizeof(*gp));
|
||||
|
||||
new_grid->rost = rost;
|
||||
return new_grid;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void grid_find(const grid *gp, const char c, int *x, int *y) {
|
||||
if (gp == NULL || gp->rost == NULL) {
|
||||
*x = -1;
|
||||
*y = -1;
|
||||
return;
|
||||
}
|
||||
|
||||
const char search[2] = {c};
|
||||
|
||||
const int char_index = (int)strcspn(gp->rost, search);
|
||||
|
||||
if (gp->rost[char_index] == '\0')
|
||||
{
|
||||
*x = -1;
|
||||
*y = -1;
|
||||
return;
|
||||
}
|
||||
|
||||
*x = char_index % (gp->width + 1);
|
||||
*y = char_index / (gp->width + 1);
|
||||
}
|
||||
Reference in New Issue
Block a user