🚀 go-pugleaf

To compile it: cc -o rps rps.c -lcurses -ltermcap
To run it: rps height width num_states threshold

There are absolutely no guarantees whatsoever about the quality of
this code.  

====================================================================

#include <stdio.h>
#include <curses.h>
#include <ctype.h>

typedef char State;

#define MAX_STATES (32)

char printnames[] = " +#/@*AbCdEfGhIjKlMnOpQrStUvWxYz";

#define PrintName(x) (printnames[(x)])

State num_states;

int ysize;
int xsize;
int size;			/* ysize * xsize */

State *field;
State *changed;
int *check_list;
int check_list_top;

/* positive modulus */
#define Mod(x, m) ((x) < 0 ? ((x) % (m)) + (m) : (x) % (m))

void touch_cell(int i)
{
    if(!changed[i]) {
	changed[i]++;
        check_list[check_list_top++] = i;
    }
}

void init_states(int y, int x, int states)
{
    int i;

    ysize = y;
    xsize = x;
    size = ysize * xsize;
    num_states = states;

    field = (State *) malloc(sizeof(State) * size);

    changed = (State *) malloc(sizeof(State) * size);
    bzero(changed, sizeof(State) * size);

    check_list = (int *) malloc(sizeof(int) * size);
    check_list_top = 0;

    for(i = 0; i < x * y; i++) {
	field[i] = random() % num_states;
	touch_cell(i);
    }
}

void display_cell(int i, State new)
{
    mvaddch(i / xsize, i % xsize, PrintName(new));
}

void change_cell(int i, State new)
{
    touch_cell(i);

    touch_cell(Mod(i-xsize-1, size));
    touch_cell(Mod(i-xsize, size));
    touch_cell(Mod(i-xsize+1, size));
    touch_cell(Mod(i-1, size));
    touch_cell(Mod(i+1, size));
    touch_cell(Mod(i+xsize-1, size));
    touch_cell(Mod(i+xsize, size));
    touch_cell(Mod(i+xsize+1, size));

    display_cell(i, new);
}

void init_display(void)
{
    int i;

    initscr();

    for(i = 0; i < size; i++) {
	display_cell(i, field[i]);
    }

    refresh();
}

int sweep(int threshold)
{
    State *new;
    int i;
    int j;
    int ncount[MAX_STATES];
    int delta;
    int changes = 0;
    int *old_check;
    int old_check_top;

    new = (State *) malloc(sizeof(State) * size);
    bzero(changed, sizeof(State) * size);

    old_check = check_list;
    old_check_top = check_list_top;

    check_list = (int *) malloc(sizeof(int) * size);
    check_list_top = 0;
    
    while(--old_check_top >= 0) {
	i = old_check[old_check_top];

	for(j = 0; j < num_states; j++) ncount[j] = 0;

	/* add up neighbors */
	ncount[field[Mod(i-xsize-1, size)]]++;
	ncount[field[Mod(i-xsize, size)]]++;
	ncount[field[Mod(i-xsize+1, size)]]++;
	ncount[field[Mod(i-1, size)]]++;
	ncount[field[Mod(i+1, size)]]++;
	ncount[field[Mod(i+xsize-1, size)]]++;
	ncount[field[Mod(i+xsize, size)]]++;
	ncount[field[Mod(i+xsize+1, size)]]++;

	/* default is no change */
	new[i] = field[i];

	/* look for winning neighbor */
	j = (field[i] + 1) % num_states;
	if(ncount[j] >= threshold) {
	    changes++;
	    new[i] = j;
	    change_cell(i, j);
	}
    }

    free(old_check);

    free(field);
    field = new;

    refresh();

    return changes;
}

void mutate(void)
{
    int i;
    State s;

    i = random() % size;
    s = random() % num_states;

    field[i] = s;
    change_cell(i, s);
}

main(int argc, char **argv)
{
    srandom(getpid() + time(0));

    init_states(atoi(argv[1]), atoi(argv[2]), atoi(argv[3]));
    init_display();
    
    for(;;) {
	if(sweep(atoi(argv[4])) == 0) mutate();
    }
}