shithub: orca

ref: bc56c51c61e71212eaa99f39aae9c481a1d3311b
dir: /field.c/

#include "field.h"
#include "gbuffer.h"
#include <ctype.h>

void field_init(Field* f) {
  f->buffer = NULL;
  f->height = 0;
  f->width = 0;
}

void field_init_fill(Field* f, Usz height, Usz width, Glyph fill_char) {
  assert(height <= ORCA_Y_MAX && width <= ORCA_X_MAX);
  Usz num_cells = height * width;
  f->buffer = malloc(num_cells * sizeof(Glyph));
  memset(f->buffer, fill_char, num_cells);
  f->height = (U16)height;
  f->width = (U16)width;
}

void field_deinit(Field* f) { free(f->buffer); }

void field_resize_raw(Field* f, Usz height, Usz width) {
  assert(height <= ORCA_Y_MAX && width <= ORCA_X_MAX);
  Usz cells = height * width;
  f->buffer = realloc(f->buffer, cells * sizeof(Glyph));
  f->height = (U16)height;
  f->width = (U16)width;
}

void field_resize_raw_if_necessary(Field* field, Usz height, Usz width) {
  if (field->height != height || field->width != width) {
    field_resize_raw(field, height, width);
  }
}

void field_copy(Field* src, Field* dest) {
  field_resize_raw_if_necessary(dest, src->height, src->width);
  gbuffer_copy_subrect(src->buffer, dest->buffer, src->height, src->width,
                       dest->height, dest->width, 0, 0, 0, 0, src->height,
                       src->width);
}

static inline bool glyph_char_is_valid(char c) { return c >= '!' && c <= '~'; }

void field_fput(Field* f, FILE* stream) {
  enum { Column_buffer_count = 4096 };
  char out_buffer[Column_buffer_count];
  Usz f_height = f->height;
  Usz f_width = f->width;
  Glyph* f_buffer = f->buffer;
  if (f_width > Column_buffer_count - 2)
    return;
  for (Usz iy = 0; iy < f_height; ++iy) {
    Glyph* row_p = f_buffer + f_width * iy;
    for (Usz ix = 0; ix < f_width; ++ix) {
      char c = row_p[ix];
      out_buffer[ix] = glyph_char_is_valid(c) ? c : '?';
    }
    out_buffer[f_width] = '\n';
    out_buffer[f_width + 1] = '\0';
    fputs(out_buffer, stream);
  }
}

Field_load_error field_load_file(char const* filepath, Field* field) {
  FILE* file = fopen(filepath, "r");
  if (file == NULL) {
    return Field_load_error_cant_open_file;
  }
  enum { Bufsize = 4096 };
  char buf[Bufsize];
  Usz first_row_columns = 0;
  Usz rows = 0;
  for (;;) {
    char* s = fgets(buf, Bufsize, file);
    if (s == NULL)
      break;
    if (rows == ORCA_Y_MAX) {
      fclose(file);
      return Field_load_error_too_many_rows;
    }
    Usz len = strlen(buf);
    if (len == Bufsize - 1 && buf[len - 1] != '\n' && !feof(file)) {
      fclose(file);
      return Field_load_error_too_many_columns;
    }
    for (;;) {
      if (len == 0)
        break;
      if (!isspace(buf[len - 1]))
        break;
      --len;
    }
    if (len == 0)
      continue;
    if (len >= ORCA_X_MAX) {
      fclose(file);
      return Field_load_error_too_many_columns;
    }
    // quick hack until we use a proper scanner
    if (rows == 0) {
      first_row_columns = len;
    } else if (len != first_row_columns) {
      fclose(file);
      return Field_load_error_not_a_rectangle;
    }
    field_resize_raw(field, rows + 1, first_row_columns);
    Glyph* rowbuff = field->buffer + first_row_columns * rows;
    for (Usz i = 0; i < len; ++i) {
      char c = buf[i];
      rowbuff[i] = glyph_char_is_valid(c) ? c : '.';
    }
    ++rows;
  }
  fclose(file);
  return Field_load_error_ok;
}