/* -*- Mode: C; tab-width: 4 -*- */ /* loop --- Chris Langton's self-producing loops */ #if !defined( lint ) && !defined( SABER ) static const char sccsid[] = "@(#)loop.c 4.13 98/10/18 xlockmore"; #endif /*- * Copyright (c) 1996 by David Bagley. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose and without fee is hereby granted, * provided that the above copyright notice appear in all copies and that * both that copyright notice and this permission notice appear in * supporting documentation. * * This file is provided AS IS with no warranties of any kind. The author * shall have no liability with respect to the infringement of copyrights, * trade secrets or any patents by this file or any part thereof. In no * event will the author be liable for any lost revenue or profits or * other special, indirect and consequential damages. * * Revision History: * 18-Oct-98: Started creating a hexagon version, probably will not work * for a while since some work has to go into getting not * only the program to handle the hexagonal data but the loop * has to be "programmed" as well. I suspect it should be easier * than the original since the loop will have six sides to * store its genes (data). * 10-May-97: Compatible with xscreensaver * 15-Nov-95: Coded from Chris Langton's Self-Reproduction in Cellular * Automata Physica 10D 135-144 1984 * also used wire.c as a guide. */ /*- Grid Number of Neigbors ---- ------------------ Square 4 Hexagon 6 (currently in development) */ /*- * From Steven Levy's Artificial Life * Chris Langton's cellular automata "loops" reproduce in the spirit of life. * Beginning from a single organism, the loops from a colony. As the loops * on the outer fringes reproduce, the inner loops -- blocked by their * daughters -- can no longer produce offspring. These dead progenitors * provide a base for future generations' expansion, much like the formation * of a coral reef. This self-organizing behavior emerges spontaneously, * from the bottom up -- a key characteristic of artificial life. */ /*- Don't Panic -- When the artificial life tries to leave its petri dish (ie. the screen) it will (usually) die... The loops are short of "real" life because a general purpose Turing machine is not contained in the loop. This is a simplification of von Neumann and Codd's self-producing Turing machine. The data spinning around could be viewed as both its DNA and its internal clock. */ #ifdef STANDALONE # define PROGCLASS "loop" # define HACK_INIT init_loop # define HACK_DRAW draw_loop # define loop_opts xlockmore_opts # define DEFAULTS "*delay: 100000 \n" \ "*cycles: 1600 \n" \ "*size: -12 \n" \ "*ncolors: 15 \n" \ "*neighbors: 0 \n" # define SMOOTH_COLORS # include "xlockmore.h" /* in xscreensaver distribution */ #else /* STANDALONE */ # include "xlock.h" /* in xlockmore distribution */ #endif /* STANDALONE */ #include "automata.h" /*- * neighbors of 0 randomizes between 4 and 6. */ #ifdef STANDALONE static int neighbors; #else extern int neighbors; #endif /* !STANDALONE */ ModeSpecOpt loop_opts = {0, NULL, 0, NULL, NULL}; #ifdef USE_MODULES ModStruct loop_description = {"loop", "init_loop", "draw_loop", "release_loop", "refresh_loop", "init_loop", NULL, &loop_opts, 100000, 1, 1600, -12, 64, 1.0, "", "Shows Langton's self-producing loops", 0, NULL}; #endif #define LOOPBITS(n,w,h)\ lp->pixmaps[lp->init_bits++]=\ XCreatePixmapFromBitmapData(display,window,(char *)n,w,h,1,0,1) static int local_neighbors = 0; static int neighbor_kind = 0; #define COLORS 8 #define REALCOLORS (COLORS-2) #define MINLOOPS 1 #define REDRAWSTEP 2000 /* How many cells to draw per cycle */ #define ADAM_SIZE 8 /* MIN 5 */ #if 1 # define ADAM_LOOPX (ADAM_SIZE+2) # define ADAM_LOOPY (ADAM_SIZE+2) #else # define ADAM_LOOPX 16 # define ADAM_LOOPY 10 #endif #define MINGRIDSIZE (3*ADAM_LOOPX) /* TRIA stuff was an attempt to make a triangular lifeform on a hex grid but I got bored. You probably need an additional 7th state for a coherent step by step process of separation and initial stem development. */ /* #define TRIA 1 */ #ifdef TRIA # define HEX_ADAM_SIZE 3 /* MIN 3 */ #else # define HEX_ADAM_SIZE 5 /* MIN 3 */ #endif #if 1 # define HEX_ADAM_LOOPX (2*HEX_ADAM_SIZE+1) # define HEX_ADAM_LOOPY (2*HEX_ADAM_SIZE+1) #else # define HEX_ADAM_LOOPX 3 # define HEX_ADAM_LOOPY 7 #endif #define HEX_MINGRIDSIZE (6*HEX_ADAM_LOOPX) #define MINSIZE 5 /* jwz -- really tiny cells don't look good */ #define NEIGHBORKINDS 2 #define ANGLES 360 #define MAXNEIGHBORS 6 /* Singly linked list */ typedef struct _CellList { XPoint pt; struct _CellList *next; } CellList; typedef struct { int init_bits; int generation; int xs, ys; int xb, yb; int nrows, ncols; int bx, by, bnrows, bncols; int mincol, minrow, maxcol, maxrow; int width, height; int redrawing, redrawpos; unsigned char *newcells, *oldcells; int ncells[COLORS]; CellList *cellList[COLORS]; unsigned long colors[COLORS]; GC stippledGC; Pixmap pixmaps[COLORS]; union { XPoint hexagon[6]; } shape; } loopstruct; static loopstruct *loops = NULL; #define TRANSITION(TT,V) V=TT&7;TT>>=3 #define TABLE(R,T,L,B) (table[((B)<<9)|((L)<<6)|((T)<<3)|(R)]) #define HEX_TABLE(R,T,t,l,b,B) (table[((B)<<15)|((b)<<12)|((l)<<9)|((t)<<6)|((T)<<3)|(R)]) #ifdef RAND_RULES /* Hack, see below */ #define TABLE_IN(C,R,T,L,B,I) (TABLE(R,T,L,B)&=~(7<<((C)*3)));\ (TABLE(R,T,L,B)|=((I)<<((C)*3))) #define HEX_TABLE_IN(C,R,T,t,l,b,B,I) (HEX_TABLE(R,T,t,l,b,B)&=~(7<<((C)*3)));\ (HEX_TABLE(R,T,t,l,b,B)|=((I)<<((C)*3))) #else #define TABLE_IN(C,R,T,L,B,I) (TABLE(R,T,L,B)|=((I)<<((C)*3))) #define HEX_TABLE_IN(C,R,T,t,l,b,B,I) (HEX_TABLE(R,T,t,l,b,B)|=((I)<<((C)*3))) #endif #define TABLE_OUT(C,R,T,L,B) ((TABLE(R,T,L,B)>>((C)*3))&7) #define HEX_TABLE_OUT(C,R,T,t,l,b,B) ((HEX_TABLE(R,T,t,l,b,B)>>((C)*3))&7) static unsigned int *table = NULL; /* 8*8*8*8 = 2^12 = 2^3^4 = 4K */ /* 8*8*8*8*8*8 = too big? */ static char plots[NEIGHBORKINDS] = { 4, 6 /* Neighborhoods */ }; static unsigned int transition_table[] = { /* Octal CBLTR->I */ /* CBLTRI CBLTRI CBLTRI CBLTRI CBLTRI */ 0000000, 0025271, 0113221, 0202422, 0301021, 0000012, 0100011, 0122244, 0202452, 0301220, 0000020, 0100061, 0122277, 0202520, 0302511, 0000030, 0100077, 0122434, 0202552, 0401120, 0000050, 0100111, 0122547, 0202622, 0401220, 0000063, 0100121, 0123244, 0202722, 0401250, 0000071, 0100211, 0123277, 0203122, 0402120, 0000112, 0100244, 0124255, 0203216, 0402221, 0000122, 0100277, 0124267, 0203226, 0402326, 0000132, 0100511, 0125275, 0203422, 0402520, 0000212, 0101011, 0200012, 0204222, 0403221, 0000220, 0101111, 0200022, 0205122, 0500022, 0000230, 0101244, 0200042, 0205212, 0500215, 0000262, 0101277, 0200071, 0205222, 0500225, 0000272, 0102026, 0200122, 0205521, 0500232, 0000320, 0102121, 0200152, 0205725, 0500272, 0000525, 0102211, 0200212, 0206222, 0500520, 0000622, 0102244, 0200222, 0206722, 0502022, 0000722, 0102263, 0200232, 0207122, 0502122, 0001022, 0102277, 0200242, 0207222, 0502152, 0001120, 0102327, 0200250, 0207422, 0502220, 0002020, 0102424, 0200262, 0207722, 0502244, 0002030, 0102626, 0200272, 0211222, 0502722, 0002050, 0102644, 0200326, 0211261, 0512122, 0002125, 0102677, 0200423, 0212222, 0512220, 0002220, 0102710, 0200517, 0212242, 0512422, 0002322, 0102727, 0200522, 0212262, 0512722, 0005222, 0105427, 0200575, 0212272, 0600011, 0012321, 0111121, 0200722, 0214222, 0600021, 0012421, 0111221, 0201022, 0215222, 0602120, 0012525, 0111244, 0201122, 0216222, 0612125, 0012621, 0111251, 0201222, 0217222, 0612131, 0012721, 0111261, 0201422, 0222272, 0612225, 0012751, 0111277, 0201722, 0222442, 0700077, 0014221, 0111522, 0202022, 0222462, 0701120, 0014321, 0112121, 0202032, 0222762, 0701220, 0014421, 0112221, 0202052, 0222772, 0701250, 0014721, 0112244, 0202073, 0300013, 0702120, 0016251, 0112251, 0202122, 0300022, 0702221, 0017221, 0112277, 0202152, 0300041, 0702251, 0017255, 0112321, 0202212, 0300076, 0702321, 0017521, 0112424, 0202222, 0300123, 0702525, 0017621, 0112621, 0202272, 0300421, 0702720, 0017721, 0112727, 0202321, 0300622 }; static unsigned int hex_transition_table[] = { /* Octal CBbltTR->I */ /* CBbltTRI CBbltTRI CBbltTRI CBbltTRI CBbltTRI */ #ifdef TRIA 000000000, 000000020, 000000220, 000002220, 000022220, 011122121, 011121221, 011122221, 011221221, 011222221, 011112121, 011112221, 020021122, 020002122, 020211222, 021111222, 020221122, 020027122, 020020722, 020021022, 001127221, 011122727, 011227227, 010122121, 010222211, 021117222, 020112272, 070221220, 001227221, 010221121, 011721221, 011222277, 020111222, 020221172, 070211220, 001217221, 010212277, 010221221, 020122112, 070122220, 001722221, 010221271, 020002022, 021122172, 070121220, 011122277, 011172121, 010212177, 011212277, 070112220, 001772221, 021221772, 070121270, 070721220, 000112721, 000272211, 010022211, 012222277, 020072272, 020227122, 020217222, 010211121, 020002727, 070222220, 001727721, 020021072, 020070722, 070002072, 070007022, 001772721, 070002022, 000000070, 000000770, 000072220, 000000270, 020110222, 020220272, 020220722, 070007071, 070002072, 070007022, 000000012, 000000122, 000000212, 001277721, 020122072, 020202212, 010002121, 020001122, 020002112, 020021722, 020122022, 020027022, 020070122, 020020122, 010227027, 020101222, 010227227, 010227277, 021722172, 001727221, 010222277, 020702272, 070122020, 000172721, 010022277, 010202177, 010227127, 001214221, 010202244, 020024122, 020020422, 040122220, 001422221, 010221241, 010224224, 021122142, 040121220, 001124221, 010224274, 020112242, 021422172, 040221220, 001224221, 001427221, 010222244, 020227042, 040122020, 000142721, 010022244, 010202144, 010224124, 040112220, 001442221, 021221442, 040121240, 040421220, 000242211, 000112421, 020042242, 020214222, 020021422, 020220242, 020024022, 011224224, 020224122, 020220422, 012222244, 020002424, 040222220, 001244421, 000000420, 000000440, 000000240, 000000040, 020040121, 020021042, 040004022, 040004042, 040002042, 010021121, 020011122, 020002112, 001424421, 020040422, 001442421, 040002022, 001724221, 010227247, 020224072, 021417222, 000172421, 010021721, 020017022, 020120212, 020271727, 070207072, 070701220, 000001222, 020110122, 001277221, 001777721, 020021222, 020202272, 020120222, 020221722, 020027227, 070070222, 000007220, 020101272, 020272172, 020721422, 020721722, 020011222, 020202242, #if 0 {2,2,0,0,2,7,0}, {2,0,2,0,2,0,2}, {2,4,1,2,2,1,2}, {2,1,2,1,2,1,2}, {2,0,2,2,1,1,2}, {2,7,1,1,1,1,2}, {0,2,2,2,2,2,2}, {2,2,0,0,7,7,0}, {2,1,2,0,2,0,7}, {2,0,1,2,2,1,2}, {2,4,2,1,2,1,2}, {2,1,2,2,1,1,2}, {2,0,7,1,1,1,2}, {0,2,2,2,2,2,2}, #endif #else 000000000, 000000020, 000000220, 000002220, 011212121, 011212221, 011221221, 011222221, 020002122, 020021122, 020211122, 010221221, 010222121, 020002022, 020021022, 020020122, 020112022, 010202121, 020102022, 020202112, 000000012, 000000122, 000000212, 010002121, 020001122, 020002112, 020011122, 001227221, 001272221, 001272721, 012212277, 011222727, 011212727, 020021722, 020027122, 020020722, 020027022, 020211722, 020202172, 020120272, 020271122, 020202172, 020207122, 020217122, 020120272, 020210722, 020270722, 070212220, 070221220, 070212120, 012222277, 020002727, 070222220, 001277721, 000000070, 000000270, 000000720, 000000770, 020070122, 020021072, 070002072, 070007022, 070007071, 020070722, 070002022, 010227227, 010222727, 010202727, 020172022, 020202712, 001224221, 001242221, 001242421, 012212244, 011222424, 011212424, 020021422, 020024122, 020020422, 020024022, 020211422, 020202142, 020120242, 020241122, 020202142, 020204122, 020214122, 020120242, 020210422, 020240422, 040212220, 040221220, 040212120, 012222244, 020002424, 040222220, 001244421, 000000040, 000000240, 000000420, 000000440, 020040122, 020021042, 040002042, 040004021, 040004042, 020040422, 040002022, 010224224, 010222424, 010202424, 020142022, 020202412, 020011722, 020112072, 020172072, 020142072, 000210225, 000022015, 000022522, 011225521, 020120525, 020020152, 020005122, 020214255, 020021152, 020255242, 050215222, 050225121, 000225220, 001254222, 010221250, 011221251, 011225221, 020025122, 020152152, 020211252, 020214522, 020511125, 050212241, 05221120, 040521225, 000000250, 000000520, 000150220, 000220520, 000222210, 001224251, 010022152, 010251221, 010522121, 011212151, 011221251, 011215221, 020000220, 020002152, 020020220, 020021020, 020022152, 020021422, 020022152, 020022522, 020025425, 020050422, 020051022, 020051122, 020211122, 020211222, 020215222, 020245122, 050021125, 050021025, 050011125, 051242221, 041225220, 000220250, 000220520, 001227521, 001275221, 011257227, 011522727, 020002052, 020002752, 020021052, 020057125, 050020722, 050027125, 070215220, 070212255, 071225220, 020275122, 051272521, 020055725, 020021552, 012252277, 050002521, 020005725, 050011022, 000000155, 020050722, 001227250, 010512727, 010002151, 020027112, 001227251, 012227257, 050002125, 020517122, 050002025, 020050102, 050002725, 020570722, 001252721, 020007051, 020102052, 020271072, 050001122, 010002151, 011227257, 020051722, 020057022, 020050122, 020051422, 011224254, 012224254, 020054022, 050002425, 040252220, 020002454, 000000540, 001254425, 050004024, 040004051, 000000142, 040001522, 010002547, 020045122, 051221240, 020002512, 020021522, 020020022, 021125522, 020521122, 020025022, 020025522, 020020522, 020202222, 020212222, 021212222, 021222722, 021222422, 020002222, 020021222, 020022122, 020212122, 020027222, 020024222, 020020222, 020212722, 020212422, 020202122, 001222221, 020002522, 020017125, 010022722, 020212052, 020205052, #endif }; /*- Neighborhoods are read as follows (rotations are not listed): T L C R ==> I B t T l C R ==> I b B */ static unsigned char self_reproducing_loop[ADAM_LOOPY][ADAM_LOOPX] = { /* 10x10 */ {0, 2, 2, 2, 2, 2, 2, 2, 2, 0}, {2, 4, 0, 1, 4, 0, 1, 1, 1, 2}, {2, 1, 2, 2, 2, 2, 2, 2, 1, 2}, {2, 0, 2, 0, 0, 0, 0, 2, 1, 2}, {2, 7, 2, 0, 0, 0, 0, 2, 7, 2}, {2, 1, 2, 0, 0, 0, 0, 2, 0, 2}, {2, 0, 2, 0, 0, 0, 0, 2, 1, 2}, {2, 7, 2, 2, 2, 2, 2, 2, 7, 2}, {2, 1, 0, 6, 1, 0, 7, 1, 0, 2}, {0, 2, 2, 2, 2, 2, 2, 2, 2, 0} }; static unsigned char hex_self_reproducing_loop[HEX_ADAM_LOOPY][HEX_ADAM_LOOPX] = { #if 0 /* Experimental TRIA5:7x7 */ {2,2,0,0,0,0,0}, {2,1,2,0,2,2,0}, {2,0,4,2,2,0,2}, {2,7,2,0,2,0,2}, {2,1,2,2,1,1,2}, {2,0,7,1,0,7,2}, {0,2,2,2,2,2,2}, /* Stem cells, only "5" will fully reproduce itself */ /* 3:12x7 */ {2,2,2,2,0,0,0,0,0,0,0,0}, {2,1,1,1,2,0,0,0,0,0,0,0}, {2,1,2,2,1,2,2,2,2,2,2,0}, {2,1,2,0,2,7,1,1,1,1,1,2}, {0,2,1,2,2,0,2,2,2,2,2,2}, {0,0,2,0,4,1,2,0,0,0,0,0}, {0,0,0,2,2,2,2,0,0,0,0,0} /* 4:14x9 */ {2,2,2,2,2,0,0,0,0,0,0,0,0,0}, {2,1,1,1,1,2,0,0,0,0,0,0,0,0}, {2,1,2,2,2,1,2,0,0,0,0,0,0,0}, {2,1,2,0,0,2,1,2,2,2,2,2,2,0}, {2,1,2,0,0,0,2,7,1,1,1,1,1,2}, {0,2,1,2,0,0,2,0,2,2,2,2,2,2}, {0,0,2,0,2,2,2,1,2,0,0,0,0,0}, {0,0,0,2,4,1,0,7,2,0,0,0,0,0}, {0,0,0,0,2,2,2,2,2,0,0,0,0,0} /* 5:16x11 */ {2,2,2,2,2,2,0,0,0,0,0,0,0,0,0,0}, {2,1,1,1,1,1,2,0,0,0,0,0,0,0,0,0}, {2,1,2,2,2,2,1,2,0,0,0,0,0,0,0,0}, {2,1,2,0,0,0,2,1,2,0,0,0,0,0,0,0}, {2,1,2,0,0,0,0,2,1,2,2,2,2,2,2,0}, {2,1,2,0,0,0,0,0,2,7,1,1,1,1,1,2}, {0,2,1,2,0,0,0,0,2,0,2,2,2,2,2,2}, {0,0,2,0,2,0,0,0,2,1,2,0,0,0,0,0}, {0,0,0,2,4,2,2,2,2,7,2,0,0,0,0,0}, {0,0,0,0,2,1,0,7,1,0,2,0,0,0,0,0}, {0,0,0,0,0,2,2,2,2,2,2,0,0,0,0,0} /* test:3x7 (0,4) is blank ... very strange. init_adam seems ok something after that I guess */ {2,2,0}, {2,0,2}, {0,2,2}, {0,0,0}, {2,2,0}, {2,1,2}, {0,2,2}, #else /* this might be better for hexagons, spacewise efficient... */ #ifdef TRIA /* Experimental TRIA5:7x7 */ {2,2,0,0,2,2,0}, {2,4,2,0,2,7,2}, {2,1,0,2,2,0,2}, {2,0,2,1,2,1,2}, {2,7,2,2,7,7,2}, {2,1,0,7,1,0,2}, {0,2,2,2,2,2,2}, #else /* 5:11x11 */ {2,2,2,2,2,2,0,0,0,0,0}, {2,1,1,7,0,1,2,0,0,0,0}, {2,1,2,2,2,2,7,2,0,0,0}, {2,1,2,0,0,0,2,0,2,0,0}, {2,1,2,0,0,0,0,2,1,2,0}, {2,1,2,0,0,0,0,0,2,7,2}, {0,2,1,2,0,0,0,0,2,0,2}, {0,0,2,1,2,0,0,0,2,1,2}, {0,0,0,2,1,2,2,2,2,4,2}, {0,0,0,0,2,1,1,1,1,5,2}, {0,0,0,0,0,2,2,2,2,2,2} #endif #endif }; static void position_of_neighbor(int dir, int *pcol, int *prow) { int col = *pcol, row = *prow; /* NO WRAPING */ if (local_neighbors == 6) { switch (dir) { case 0: col = col + 1; break; case 60: if (row & 1) col = col + 1; row = row - 1; break; case 120: if (!(row & 1)) col = col - 1; row = row - 1; break; case 180: col = col - 1; break; case 240: if (!(row & 1)) col = col - 1; row = row + 1; break; case 300: if (row & 1) col = col + 1; row = row + 1; break; default: (void) fprintf(stderr, "wrong direction %d\n", dir); } } else { switch (dir) { case 0: col = col + 1; break; case 90: row = row - 1; break; case 180: col = col - 1; break; case 270: row = row + 1; break; default: (void) fprintf(stderr, "wrong direction %d\n", dir); } } *pcol = col; *prow = row; } static Bool withinBounds(loopstruct * lp, int col, int row) { return (row >= 1 && row < lp->bnrows - 1 && col >= 1 && col < lp->bncols - 1 - (local_neighbors == 6 && (row % 2))); } static void fillcell(ModeInfo * mi, GC gc, int col, int row) { loopstruct *lp = &loops[MI_SCREEN(mi)]; if (local_neighbors == 6) { int ccol = 2 * col + !(row & 1), crow = 2 * row; lp->shape.hexagon[0].x = lp->xb + ccol * lp->xs; lp->shape.hexagon[0].y = lp->yb + crow * lp->ys; if (lp->xs == 1 && lp->ys == 1) XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), gc, lp->shape.hexagon[0].x, lp->shape.hexagon[0].y, 1, 1); else XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), gc, lp->shape.hexagon, 6, Convex, CoordModePrevious); } else { XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), gc, lp->xb + lp->xs * col, lp->yb + lp->ys * row, lp->xs - (lp->xs > 3), lp->ys - (lp->ys > 3)); } } static void drawcell(ModeInfo * mi, int col, int row, int state) { loopstruct *lp = &loops[MI_SCREEN(mi)]; XGCValues gcv; GC gc; if (MI_NPIXELS(mi) >= COLORS) { gc = MI_GC(mi); XSetForeground(MI_DISPLAY(mi), gc, lp->colors[state]); } else { gcv.stipple = lp->pixmaps[state]; gcv.foreground = MI_WHITE_PIXEL(mi); gcv.background = MI_BLACK_PIXEL(mi); XChangeGC(MI_DISPLAY(mi), lp->stippledGC, GCStipple | GCForeground | GCBackground, &gcv); gc = lp->stippledGC; } fillcell(mi, gc, col, row); } static void addtolist(ModeInfo * mi, int col, int row, unsigned char state) { loopstruct *lp = &loops[MI_SCREEN(mi)]; CellList *current = lp->cellList[state]; lp->cellList[state] = NULL; if ((lp->cellList[state] = (CellList *) malloc(sizeof (CellList))) == NULL) { lp->cellList[state] = current; return; } lp->cellList[state]->pt.x = col; lp->cellList[state]->pt.y = row; lp->cellList[state]->next = current; lp->ncells[state]++; } #ifdef DEBUG static void print_state(ModeInfo * mi, int state) { loopstruct *lp = &loops[MI_SCREEN(mi)]; CellList *locallist = lp->cellList[state]; int i = 0; (void) printf("state %d\n", state); while (locallist) { (void) printf("%d x %d, y %d\n", i, locallist->pt.x, locallist->pt.y); locallist = locallist->next; i++; } } #endif static void free_state(loopstruct * lp, int state) { CellList *current; while (lp->cellList[state]) { current = lp->cellList[state]; lp->cellList[state] = lp->cellList[state]->next; (void) free((void *) current); } lp->ncells[state] = 0; } static void draw_state(ModeInfo * mi, int state) { loopstruct *lp = &loops[MI_SCREEN(mi)]; GC gc; XGCValues gcv; CellList *current = lp->cellList[state]; if (MI_NPIXELS(mi) >= COLORS) { gc = MI_GC(mi); XSetForeground(MI_DISPLAY(mi), gc, lp->colors[state]); } else { gcv.stipple = lp->pixmaps[state]; gcv.foreground = MI_WHITE_PIXEL(mi); gcv.background = MI_BLACK_PIXEL(mi); XChangeGC(MI_DISPLAY(mi), lp->stippledGC, GCStipple | GCForeground | GCBackground, &gcv); gc = lp->stippledGC; } if (local_neighbors == 6) { /* Draw right away, slow */ while (current) { int col, row, ccol, crow; col = current->pt.x; row = current->pt.y; ccol = 2 * col + !(row & 1), crow = 2 * row; lp->shape.hexagon[0].x = lp->xb + ccol * lp->xs; lp->shape.hexagon[0].y = lp->yb + crow * lp->ys; if (lp->xs == 1 && lp->ys == 1) XFillRectangle(MI_DISPLAY(mi), MI_WINDOW(mi), gc, lp->shape.hexagon[0].x, lp->shape.hexagon[0].y, 1, 1); else XFillPolygon(MI_DISPLAY(mi), MI_WINDOW(mi), gc, lp->shape.hexagon, 6, Convex, CoordModePrevious); current = current->next; } } else { /* Take advantage of XFillRectangles */ XRectangle *rects = NULL; int nrects = 0; /* Create Rectangle list from part of the cellList */ if ((rects = (XRectangle *) malloc(lp->ncells[state] * sizeof (XRectangle))) == NULL) { return; } while (current) { rects[nrects].x = lp->xb + current->pt.x * lp->xs; rects[nrects].y = lp->yb + current->pt.y * lp->ys; rects[nrects].width = lp->xs - (lp->xs > 3); rects[nrects].height = lp->ys - (lp->ys > 3); current = current->next; nrects++; } /* Finally get to draw */ XFillRectangles(MI_DISPLAY(mi), MI_WINDOW(mi), gc, rects, nrects); /* Free up rects list and the appropriate part of the cellList */ (void) free((void *) rects); } free_state(lp, state); XFlush(MI_DISPLAY(mi)); } static int init_table(void) { if (table == NULL) { int mult = 1; unsigned int tt, c, n[MAXNEIGHBORS], i; int j, k; int size_transition_table = sizeof (transition_table) / sizeof (unsigned int); int size_hex_transition_table = sizeof (hex_transition_table) / sizeof (unsigned int); for (j = 0; j < local_neighbors; j++) mult *= 8; if ((table = (unsigned int *) calloc(mult, sizeof (unsigned int))) == NULL) { return 1; } #ifdef RAND_RULES /* Here I was interested to see what happens when it hits a wall.... Rules not normally used take over... takes too much time though */ { for (j = 0; j < mult; j++) { for (k = 0; k < 8; k++) table[j] |= (unsigned int) ((unsigned int) (NRAND(8)) << (k * 3)); } } #endif if (local_neighbors == 6) { for (j = 0; j < size_hex_transition_table; j++) { tt = hex_transition_table[j]; TRANSITION(tt, i); for (k = 0; k < local_neighbors; k++) { TRANSITION(tt, n[k]); } TRANSITION(tt, c); HEX_TABLE_IN(c, n[0], n[1], n[2], n[3], n[4], n[5], i); HEX_TABLE_IN(c, n[1], n[2], n[3], n[4], n[5], n[0], i); HEX_TABLE_IN(c, n[2], n[3], n[4], n[5], n[0], n[1], i); HEX_TABLE_IN(c, n[3], n[4], n[5], n[0], n[1], n[2], i); HEX_TABLE_IN(c, n[4], n[5], n[0], n[1], n[2], n[3], i); HEX_TABLE_IN(c, n[5], n[0], n[1], n[2], n[3], n[4], i); } } else { for (j = 0; j < size_transition_table; j++) { tt = transition_table[j]; TRANSITION(tt, i); for (k = 0; k < local_neighbors; k++) { TRANSITION(tt, n[k]); } TRANSITION(tt, c); TABLE_IN(c, n[0], n[1], n[2], n[3], i); TABLE_IN(c, n[1], n[2], n[3], n[0], i); TABLE_IN(c, n[2], n[3], n[0], n[1], i); TABLE_IN(c, n[3], n[0], n[1], n[2], i); } } } return 0; } static void init_adam(ModeInfo * mi) { loopstruct *lp = &loops[MI_SCREEN(mi)]; XPoint start, dirx, diry; int i, j; if (local_neighbors == 6) { int k; /* switch (0) */ switch (NRAND(6)) { case 0: start.x = (lp->bncols - HEX_ADAM_LOOPX / 2) / 2; start.y = (lp->bnrows - HEX_ADAM_LOOPY) / 2; lp->mincol = start.x - 2; lp->minrow = start.y - 1; lp->maxcol = start.x + HEX_ADAM_LOOPX + 1; lp->maxrow = start.y + HEX_ADAM_LOOPY + 1; for (j = 0; j < HEX_ADAM_LOOPY; j++) { for (i = 0; i < HEX_ADAM_LOOPX; i++) { k = (((lp->bnrows / 2 + HEX_ADAM_LOOPY / 2) % 2) ? -j / 2 : -(j + 1) / 2); lp->newcells[(start.y + j) * lp->bncols + start.x + i + k] = hex_self_reproducing_loop[j][i]; } } break; case 1: start.x = (lp->bncols - (HEX_ADAM_LOOPX + HEX_ADAM_LOOPY) / 2) / 2; start.y = (lp->bnrows - HEX_ADAM_LOOPX + HEX_ADAM_LOOPY) / 2; lp->mincol = start.x - 1; lp->minrow = start.y - HEX_ADAM_LOOPX; lp->maxcol = start.x + (HEX_ADAM_LOOPX + HEX_ADAM_LOOPY) / 2 + 1; lp->maxrow = start.y + HEX_ADAM_LOOPY + 1; for (j = 0; j < HEX_ADAM_LOOPY; j++) { for (i = 0; i < HEX_ADAM_LOOPX; i++) { k = (((lp->bnrows / 2 + (HEX_ADAM_LOOPX + HEX_ADAM_LOOPY) / 2) % 2) ? -(i + j + 1) / 2 : -(i + j) / 2); lp->newcells[(start.y + j - i) * lp->bncols + start.x + i + j + k] = hex_self_reproducing_loop[j][i]; } } break; case 2: start.x = (lp->bncols - HEX_ADAM_LOOPY / 2) / 2; start.y = (lp->bnrows - HEX_ADAM_LOOPX) / 2; lp->mincol = start.x - 2; lp->minrow = start.y - 1; lp->maxcol = start.x + HEX_ADAM_LOOPY + 1; lp->maxrow = start.y + HEX_ADAM_LOOPX + 1; for (j = 0; j < HEX_ADAM_LOOPX; j++) { for (i = 0; i < HEX_ADAM_LOOPY; i++) { k = (((lp->bnrows / 2 + HEX_ADAM_LOOPX / 2) % 2) ? -(HEX_ADAM_LOOPX - j - 1) / 2 : -(HEX_ADAM_LOOPX - j) / 2); lp->newcells[(start.y + j) * lp->bncols + start.x + i + k] = hex_self_reproducing_loop[i][HEX_ADAM_LOOPX - j - 1]; } } break; case 3: start.x = (lp->bncols - HEX_ADAM_LOOPX / 2) / 2; start.y = (lp->bnrows - HEX_ADAM_LOOPY) / 2; lp->mincol = start.x - 1, lp->minrow = start.y - 1; lp->maxcol = start.x + HEX_ADAM_LOOPX + 1, lp->maxrow = start.y + HEX_ADAM_LOOPY + 1; for (j = 0; j < HEX_ADAM_LOOPY; j++) { for (i = 0; i < HEX_ADAM_LOOPX; i++) { k = (((lp->bnrows / 2 + HEX_ADAM_LOOPY / 2) % 2) ? -j / 2 : -(j + 1) / 2); lp->newcells[(start.y + j) * lp->bncols + start.x + i + k] = hex_self_reproducing_loop[HEX_ADAM_LOOPY - j - 1][HEX_ADAM_LOOPX - i - 1]; } } break; case 4: start.x = (lp->bncols - (HEX_ADAM_LOOPX + HEX_ADAM_LOOPY) / 2) / 2; start.y = (lp->bnrows - HEX_ADAM_LOOPX + HEX_ADAM_LOOPY) / 2; lp->mincol = start.x - 1; lp->minrow = start.y - HEX_ADAM_LOOPX; lp->maxcol = start.x + (HEX_ADAM_LOOPX + HEX_ADAM_LOOPY) / 2 + 1; lp->maxrow = start.y + HEX_ADAM_LOOPY + 1; for (j = 0; j < HEX_ADAM_LOOPY; j++) { for (i = 0; i < HEX_ADAM_LOOPX; i++) { k = (((lp->bnrows / 2 + (HEX_ADAM_LOOPX + HEX_ADAM_LOOPY) / 2) % 2) ? -(i + j + 1) / 2 : -(i + j) / 2); lp->newcells[(start.y + j - i) * lp->bncols + start.x + i + j + k] = hex_self_reproducing_loop[HEX_ADAM_LOOPY - j - 1][HEX_ADAM_LOOPX - i - 1]; } } break; case 5: start.x = (lp->bncols - HEX_ADAM_LOOPY / 2) / 2; start.y = (lp->bnrows - HEX_ADAM_LOOPX) / 2; lp->mincol = start.x - 2; lp->minrow = start.y - 1; lp->maxcol = start.x + HEX_ADAM_LOOPY + 1; lp->maxrow = start.y + HEX_ADAM_LOOPX + 1; for (j = 0; j < HEX_ADAM_LOOPX; j++) { for (i = 0; i < HEX_ADAM_LOOPY; i++) { k = (((lp->bnrows / 2 + HEX_ADAM_LOOPX / 2) % 2) ? -(HEX_ADAM_LOOPX - j - 1) / 2 : -(HEX_ADAM_LOOPX - j) / 2); lp->newcells[(start.y + j) * lp->bncols + start.x + i + k] = hex_self_reproducing_loop[HEX_ADAM_LOOPX - i - 1][j]; } } break; } #if DEBUGTEST /* printf ("s %d s %d \n", start.x, start.y); */ printf ("%d %d %d %d %d\t", start.x + i + ((lp->bnrows / 2 % 2) ? -j / 2 : -(j + 1) / 2) - lp->bx, start.y + j - lp->by, i, j, hex_self_reproducing_loop[j][i]); /* Draw right away */ drawcell(mi, start.x + i + ((lp->bnrows / 2 % 2) ? -j / 2 : -(j + 1) / 2) - lp->bx, start.y + j - lp->by, hex_self_reproducing_loop[j][i]); #endif #if DEBUGTEST printf ("\n"); #endif #if DEBUGTEST printf ("\n"); #endif } else { switch (NRAND(4)) { case 0: start.x = (lp->bncols - ADAM_LOOPX) / 2; start.y = (lp->bnrows - ADAM_LOOPY) / 2; dirx.x = 1, dirx.y = 0; diry.x = 0, diry.y = 1; lp->mincol = start.x, lp->minrow = start.y; lp->maxcol = start.x + ADAM_LOOPX, lp->maxrow = start.y + ADAM_LOOPY; break; case 1: start.x = (lp->bncols + ADAM_LOOPY) / 2; start.y = (lp->bnrows - ADAM_LOOPX) / 2; dirx.x = 0, dirx.y = 1; diry.x = -1, diry.y = 0; lp->mincol = start.x - ADAM_LOOPY, lp->minrow = start.y; lp->maxcol = start.x, lp->maxrow = start.y + ADAM_LOOPX; break; case 2: start.x = (lp->bncols + ADAM_LOOPX) / 2; start.y = (lp->bnrows + ADAM_LOOPY) / 2; dirx.x = -1, dirx.y = 0; diry.x = 0, diry.y = -1; lp->mincol = start.x - ADAM_LOOPX, lp->minrow = start.y - ADAM_LOOPY; lp->maxcol = start.x, lp->maxrow = start.y; break; case 3: start.x = (lp->bncols - ADAM_LOOPY) / 2; start.y = (lp->bnrows + ADAM_LOOPX) / 2; dirx.x = 0, dirx.y = -1; diry.x = 1, diry.y = 0; lp->mincol = start.x, lp->minrow = start.y - ADAM_LOOPX; lp->maxcol = start.x + ADAM_LOOPY, lp->maxrow = start.y; break; } for (j = 0; j < ADAM_LOOPY; j++) for (i = 0; i < ADAM_LOOPX; i++) lp->newcells[(start.y + dirx.y * i + diry.y * j) * lp->bncols + start.x + dirx.x * i + diry.x * j] = self_reproducing_loop[j][i]; #if DEBUG /* Draw right away */ drawcell(mi, start.x + dirx.x * i + diry.x * j - lp->bx, start.y + dirx.y * i + diry.y * j - lp->by, self_reproducing_loop[j][i]); #endif } } static void do_gen(loopstruct * lp) { int i, j, k; unsigned char *z; unsigned int n[MAXNEIGHBORS]; unsigned int c; #define LOC(X, Y) (*(lp->oldcells + (X) + ((Y) * lp->bncols))) for (j = lp->minrow; j <= lp->maxrow; j++) { for (i = lp->mincol; i <= lp->maxcol; i++) { z = lp->newcells + i + j * lp->bncols; c = LOC(i, j); for (k = 0; k < local_neighbors; k++) { int newi = i, newj = j; position_of_neighbor(k * ANGLES / local_neighbors, &newi, &newj); n[k] = 0; if (withinBounds(lp, newi, newj)) { n[k] = LOC(newi, newj); } } if (local_neighbors == 6) { *z = HEX_TABLE_OUT(c, n[0], n[1], n[2], n[3], n[4], n[5]); } else { *z = TABLE_OUT(c, n[0], n[1], n[2], n[3]); } } } } static void free_list(loopstruct * lp) { int state; for (state = 0; state < COLORS; state++) free_state(lp, state); } void release_loop(ModeInfo * mi) { if (loops != NULL) { int screen; for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) { loopstruct *lp = &loops[screen]; int shade; for (shade = 0; shade < lp->init_bits; shade++) if (lp->pixmaps[shade] != None) XFreePixmap(MI_DISPLAY(mi), lp->pixmaps[shade]); if (lp->stippledGC != None) XFreeGC(MI_DISPLAY(mi), lp->stippledGC); if (lp->oldcells != NULL) (void) free((void *) lp->oldcells); if (lp->newcells != NULL) (void) free((void *) lp->newcells); free_list(lp); } (void) free((void *) loops); loops = NULL; } if (table != NULL) { (void) free((void *) table); table = NULL; } } void init_loop(ModeInfo * mi) { Display *display = MI_DISPLAY(mi); Window window = MI_WINDOW(mi); int i, size = MI_SIZE(mi); loopstruct *lp; XGCValues gcv; if (loops == NULL) { if ((loops = (loopstruct *) calloc(MI_NUM_SCREENS(mi), sizeof (loopstruct))) == NULL) return; } lp = &loops[MI_SCREEN(mi)]; lp->redrawing = 0; if ((MI_NPIXELS(mi) < COLORS) && (lp->init_bits == 0)) { if (lp->stippledGC == None) { gcv.fill_style = FillOpaqueStippled; lp->stippledGC = XCreateGC(display, window, GCFillStyle, &gcv); if (lp->stippledGC == None) { release_loop(mi); return; } } LOOPBITS(stipples[0], STIPPLESIZE, STIPPLESIZE); LOOPBITS(stipples[2], STIPPLESIZE, STIPPLESIZE); LOOPBITS(stipples[3], STIPPLESIZE, STIPPLESIZE); LOOPBITS(stipples[4], STIPPLESIZE, STIPPLESIZE); LOOPBITS(stipples[6], STIPPLESIZE, STIPPLESIZE); LOOPBITS(stipples[7], STIPPLESIZE, STIPPLESIZE); LOOPBITS(stipples[8], STIPPLESIZE, STIPPLESIZE); LOOPBITS(stipples[10], STIPPLESIZE, STIPPLESIZE); if (lp->pixmaps[COLORS - 1] == None) { release_loop(mi); return; } } if (MI_NPIXELS(mi) >= COLORS) { /* Maybe these colors should be randomized */ lp->colors[0] = MI_BLACK_PIXEL(mi); lp->colors[1] = MI_PIXEL(mi, 0); /* RED */ lp->colors[5] = MI_PIXEL(mi, MI_NPIXELS(mi) / REALCOLORS); /* YELLOW */ lp->colors[4] = MI_PIXEL(mi, 2 * MI_NPIXELS(mi) / REALCOLORS); /* GREEN */ lp->colors[6] = MI_PIXEL(mi, 3 * MI_NPIXELS(mi) / REALCOLORS); /* CYAN */ lp->colors[2] = MI_PIXEL(mi, 4 * MI_NPIXELS(mi) / REALCOLORS); /* BLUE */ lp->colors[3] = MI_PIXEL(mi, 5 * MI_NPIXELS(mi) / REALCOLORS); /* MAGENTA */ lp->colors[7] = MI_WHITE_PIXEL(mi); } free_list(lp); lp->generation = 0; lp->width = MI_WIDTH(mi); lp->height = MI_HEIGHT(mi); if (!local_neighbors) { for (i = 0; i < NEIGHBORKINDS; i++) { if (neighbors == plots[i]) { local_neighbors = neighbors; neighbor_kind = i; break; } if (i == NEIGHBORKINDS - 1) { #if 1 local_neighbors = plots[NRAND(NEIGHBORKINDS)]; neighbor_kind = (local_neighbors == 4) ? 0 : 1; #else local_neighbors = 4; neighbor_kind = 0; #endif break; } } } if (local_neighbors == 6) { int nccols, ncrows; if (lp->width < 4) lp->width = 4; if (lp->height < 4) lp->height = 4; if (size < -MINSIZE) { lp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(lp->width, lp->height) / HEX_MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE; } else if (size < MINSIZE) { if (!size) lp->ys = MAX(MINSIZE, MIN(lp->width, lp->height) / HEX_MINGRIDSIZE); else lp->ys = MINSIZE; } else lp->ys = MIN(size, MAX(MINSIZE, MIN(lp->width, lp->height) / HEX_MINGRIDSIZE)); lp->xs = lp->ys; nccols = MAX(lp->width / lp->xs - 2, HEX_ADAM_LOOPX + 1); ncrows = MAX(lp->height / lp->ys - 1, HEX_ADAM_LOOPY + 1); lp->ncols = nccols / 2; lp->nrows = ncrows / 2; lp->nrows -= !(lp->nrows & 1); /* Must be odd */ lp->xb = (lp->width - lp->xs * nccols) / 2 + lp->xs; lp->yb = (lp->height - lp->ys * ncrows) / 2 + lp->ys; for (i = 0; i < 6; i++) { lp->shape.hexagon[i].x = (lp->xs - 1) * hexagonUnit[i].x; lp->shape.hexagon[i].y = ((lp->ys - 1) * hexagonUnit[i].y / 2) * 4 / 3; } } else { if (size < -MINSIZE) lp->ys = NRAND(MIN(-size, MAX(MINSIZE, MIN(lp->width, lp->height) / MINGRIDSIZE)) - MINSIZE + 1) + MINSIZE; else if (size < MINSIZE) { if (!size) lp->ys = MAX(MINSIZE, MIN(lp->width, lp->height) / MINGRIDSIZE); else lp->ys = MINSIZE; } else lp->ys = MIN(size, MAX(MINSIZE, MIN(lp->width, lp->height) / MINGRIDSIZE)); lp->xs = lp->ys; lp->ncols = MAX(lp->width / lp->xs, ADAM_LOOPX + 1); lp->nrows = MAX(lp->height / lp->ys, ADAM_LOOPX + 1); lp->xb = (lp->width - lp->xs * lp->ncols) / 2; lp->yb = (lp->height - lp->ys * lp->nrows) / 2; } lp->bx = 1; lp->by = 1; lp->bncols = lp->ncols + 2 * lp->bx; lp->bnrows = lp->nrows + 2 * lp->by; MI_CLEARWINDOW(mi); if (lp->oldcells != NULL) { (void) free((void *) lp->oldcells); lp->oldcells = NULL; } if ((lp->oldcells = (unsigned char *) calloc(lp->bncols * lp->bnrows, sizeof (unsigned char))) == NULL) { release_loop(mi); return; } if (lp->newcells != NULL) { (void) free((void *) lp->newcells); lp->newcells = NULL; } if ((lp->newcells = (unsigned char *) calloc(lp->bncols * lp->bnrows, sizeof (unsigned char))) == NULL) { release_loop(mi); return; } if (init_table()) { release_loop(mi); return; } init_adam(mi); } void draw_loop(ModeInfo * mi) { loopstruct *lp = &loops[MI_SCREEN(mi)]; int offset, i, j, life = 0; unsigned char *z, *znew; if (loops == NULL) { init_loop(mi); return; } MI_IS_DRAWN(mi) = True; for (j = lp->minrow; j <= lp->maxrow; j++) { for (i = lp->mincol; i <= lp->maxcol; i++) { offset = j * lp->bncols + i; z = lp->oldcells + offset; znew = lp->newcells + offset; if (*z != *znew) { *z = *znew; addtolist(mi, i - lp->bx, j - lp->by, *znew); life = 1; if (i == lp->mincol && i > lp->bx) lp->mincol--; if (j == lp->minrow && j > lp->by) lp->minrow--; if (i == lp->maxcol && i < lp->bncols - 2 * lp->bx) lp->maxcol++; if (j == lp->maxrow && j < lp->bnrows - 2 * lp->by) lp->maxrow++; } } } for (i = 0; i < COLORS; i++) draw_state(mi, i); if (++lp->generation > MI_CYCLES(mi) /* || !life */) { init_loop(mi); return; } else do_gen(lp); if (lp->redrawing) { for (i = 0; i < REDRAWSTEP; i++) { if ((*(lp->oldcells + lp->redrawpos))) { drawcell(mi, lp->redrawpos % lp->bncols - lp->bx, lp->redrawpos / lp->bncols - lp->by, *(lp->oldcells + lp->redrawpos)); } if (++(lp->redrawpos) >= lp->bncols * (lp->bnrows - lp->bx)) { lp->redrawing = 0; break; } } } } void refresh_loop(ModeInfo * mi) { loopstruct *lp = &loops[MI_SCREEN(mi)]; if (loops == NULL) { init_loop(mi); return; } MI_CLEARWINDOW(mi); lp->redrawing = 1; lp->redrawpos = lp->by * lp->ncols + lp->bx; }