path: root/life.c

/* @BAKE \
   cc -O2 -Wshadow -Wall -Wextra -Wpedantic -g -fsanitize=address,undefined,bounds \
   $@ -o $* -lm -DNDEBUG $+ @STOP */

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#define DELC static inline

/* nearness mask, life mask */
#define LIFE_NEAR_MASK ((1 << 4) - 1)
#define LIFE_MASK (32)
/* life nearness function */
#define life_near life_near_lim

enum {
  LIFE_NONE,
  LIFE_ALIVE,
  LIFE_DEAD
};

char symbol [] = " O.";

/* tty */

#define CSI "\033["

DELC void clear (void) { printf (CSI "3J"); }

DELC void move_up (int n) { printf (CSI "%dF", n); }

DELC void move_down (int n) { printf (CSI "%dE", n); }

DELC void move_back (int n) { printf (CSI "%dD", n); }

DELC void move_forward (int n) { printf (CSI "%dC", n); }

DELC void color (int fg, int bg) { printf (bg != -1 ? CSI "%d;%dm" : CSI "%dm", fg, bg); }

/* board */

typedef struct {
  int w, h;
  int ** g;
} board_t;

DELC board_t * board_alloc (int w, int h) {
  board_t * b = malloc (sizeof (board_t));
  b->w = w;
  b->h = h;
  b->g = malloc (sizeof (int *) * h);
  for (int i = 0; i < h; ++i) {
    b->g [i] = malloc (sizeof (int) * w);
  }
  return b;
}

DELC void board_free (board_t * b) {
  for (int i = 0; i < b->h; ++i) {
    free (b->g [i]);
  }
  free (b->g);
  free (b);
}

DELC void board_set (board_t * b, int v) {
  for (int i = 0; i < b->h; ++i) {
    for (int f = 0; f < b->w; ++f) {
      b->g [i] [f] = v;
    }
  }
}

DELC void board_randomize (board_t * b, int v) {
  for (int i = 0; i < b->h; ++i) {
    for (int f = 0; f < b->w; ++f) {
      b->g [i] [f] = rand () % v;
    }
  }
}

DELC void board_eq_filter (board_t * b, int v) {
  for (int i = 0; i < b->h; ++i) {
    for (int f = 0; f < b->w; ++f) {
      b->g [i] [f] = b->g [i] [f] == v;
    }
  }
}

DELC void board_copy_to (board_t * dest, board_t * src, int x, int y) {
  for (int i = 0; i < src->h; ++i) {
    for (int f = 0; f < src->w; ++f) {
      dest->g [y + i] [x + f] = src->g [i] [f];
    }
  }
}

DELC void board_copy (board_t * dest, board_t * src) {
  board_copy_to (dest, src, 0, 0);
}

/* TODO: dup without copy */
DELC board_t * board_dup (board_t * b) {
  board_t * a = board_alloc (b->w, b->h);
  board_copy (a, b);
  return a;
}

#if 0
DELC int board_cmp (board_t * a, board_t * b) {
  int s = 0;
  for (int i = 0; i < b->h; ++i) {
    for (int f = 0; f < b->w; ++f) {
      s += a->g [i] [f] != b->g [i] [f];
    }
  }
  return s;
}

DELC void board_invert (board_t * b) {
  for (int i = 0; i < b->h; ++i) {
    for (int f = 0; f < b->w; ++f) {
      b->g [i] [f] = !(b->g [i] [f] == 1);
    }
  }
}
#endif

/* Must place the cursor at the top left of the already printed board */
DELC void board_highlight (board_t * b, int fg, int x, int y) {
  if (y) { move_down (y); }
  if (x) { move_forward (x*2); }

  color (fg, -1);
  printf ("%c", symbol [b->g [y] [x]]);
  color (0, -1);

  if (x) { move_back (x*2); }
  if (y) { move_up (y); }
}

DELC void board_print (board_t * b) {
  for (int i = 0; i < b->h; ++i) {
    for (int f = 0; f < b->w; ++f) {
      printf (f + 1 != b->w ? "%c " : "%c\n", symbol [(b->g [i] [f])]);
    }
  }
}

DELC board_t * board_alloc_text (char * s) {
  int r = atoi (s);
  return board_alloc (r, r);
}

/* life */

#if 0
DELC int life_near_loop (board_t * b, int x, int y) {
  int ** g = b->g, w = b->w, h = b->h;

  int
    ty = (y-1) % h, lx = (x-1) % w,
    cy = (  y) % h, cx = (  x) % w,
    by = (y+1) % h, rx = (x+1) % w;

  return
      g [ty] [lx] +  g [ty] [cx]       + g [ty] [rx]
    + g [cy] [lx] + (g [cy] [cx] << 5) + g [cy] [rx]
    + g [by] [lx] +  g [by] [cx]       + g [by] [rx];
}

DELC int life_near_lim (board_t * b, int x, int y) {
  int ** g = b->g, w = b->w, h = b->h;

  int
    ty = (y-1), lx = (x-1),
    cy = (  y), cx = (  x),
    by = (y+1), rx = (x+1),
    s  = g [cy] [cx] << 5;

  if (ty < h) {
    s +=  lx < w  ? g [ty] [lx] : 0;
    s +=            g [ty] [cx]    ;
    s +=  rx >= 0 ? g [ty] [rx] : 0;
  }

  s +=  lx < w  ? g [cy] [lx] : 0;
  s +=  rx >= 0 ? g [cy] [rx] : 0;

  if (by >= 0) {
    s +=  lx < w  ? g [by] [lx] : 0;
    s +=            g [by] [cx]    ;
    s +=  rx >= 0 ? g [by] [rx] : 0;
  }

  return s;
}
#endif

DELC int life_near_lim (board_t * b, int x, int y) {
  int ** g = b->g, w = b->w, h = b->h, s = 0, i, f, yi, xf;
  for (i = -1; i < 2; ++i) {
    for (f = -1; f < 2; ++f) {
      if (i == 0 && f == 0)
      { s += g [y] [x] * LIFE_MASK; continue; }
      yi = y + i;
      xf = x + f;
      if (yi >= 0 && yi < h
	  &&  xf >= 0 && xf < w)
      { s += g [yi] [xf] == 1; }
    }
  }
  return s;
}

DELC int life_pop (board_t * b) {
  int s = 0;
  for (int i = 0; i < b->h; ++i) {
    for (int f = 0; f < b->w; ++f) {
      s += b->g [i] [f] == LIFE_ALIVE;
    }
  }
  return s;
}

DELC void life_update (board_t * a, board_t * b) {
  int near;
  for (int i = 0; i < b->h; ++i) {
    for (int f = 0; f < b->w; ++f) {
      near = life_near (b, f, i);
      if ((near & LIFE_NEAR_MASK) == 3) { a->g [i] [f] = LIFE_ALIVE; }
      else if ((near & LIFE_MASK) && (near & LIFE_NEAR_MASK) < 2) { a->g [i] [f] = LIFE_DEAD; }
      else if ((near & LIFE_MASK) && (near & LIFE_NEAR_MASK) > 3) { a->g [i] [f] = LIFE_DEAD; }
    }
  }
}

#if 0
DELC void life_update (board_t * a, board_t * b) {
  int near, me, ** g = a->g;
  for (int i = 0; i < b->h; ++i) {
    for (int f = 0; f < b->w; ++f) {
      near = life_near (b, f, i);
      me = near & LIFE_ALIVE;
      near &= LIFE_NEAR_MASK;
      g [i] [f] =
	  (near == 3)
	+ (  (me && (near < 2))
          || (me && (near > 3))) * LIFE_DEAD;
    }
  }
}
#endif

DELC void life (board_t * b, int step, int wait) {
  printf (
    "rect %d:%d\n"
    "step %d\n"
    "wait sec / %d\n\n",
    b->w, b->h,
    step,
    wait);

  wait = 1e6 / wait;

  board_t * a = board_dup (b);

  int gen = 1;

  while (step) {
    board_print (b);

    printf ("\npop: %d\ngen: %d\n", life_pop (b), gen);

    move_up (b->h + 3);

    life_update (a, b);
    board_copy (b, a);

    usleep (wait);
    --step;
    ++gen;
  };
  board_free (a);

  move_down (b->h + 3);

  printf ("\nEnd of this life.\n");
}

#ifndef NDEBUG
DELC void life_debug_near (board_t * b, int w, int h) {
  board_print (b);
  move_up (b->h);
  board_highlight (b, 31, w, h);
  move_down (b->h);
  int near = life_near (b, w, h);
  printf ("%s near %d,%d: %d\n", near & LIFE_MASK ? "alive" : "dead", w, h, near & LIFE_NEAR_MASK);
}
#endif

int main (int argc, char ** argv) {
  srand (time (NULL));

  if ( argc >= 2
  &&  (strcmp (argv [1], "-h") == 0
  ||   strcmp (argv [1], "--help") == 0)) {
    printf ("%s [GRID SIZE] [WAIT BETWEEN EACH STEP=4] [MAX STEP=-1]\n", argv [0]);
    return 1;
  }

  char * rect = argc >= 2 ? argv [1] : "20";
  board_t * b = board_alloc_text (rect);

  board_randomize (b, 5);
  board_eq_filter (b, 1);

  int wait = argc >= 3 ? atoi (argv [2]) : 4;
  int step = argc >= 4 ? atoi (argv [3]) : -1;

#ifndef NDEBUG
  life_debug_near (b, 0, 0);
#endif

  life (b, step, wait);

  board_free (b);

  return 0;
}