X-Git-Url: http://git.subgeniuskitty.com/screensavers/.git/blobdiff_plain/39e6fe44effdfb443b1b9766b31803dd173eb1be..6b4b1b563ebbd3ddc4069eff5e56a260f2e92828:/hacks/WolframAutomata/WolframAutomata.c diff --git a/hacks/WolframAutomata/WolframAutomata.c b/hacks/WolframAutomata/WolframAutomata.c index e84ba44..edf1dc3 100644 --- a/hacks/WolframAutomata/WolframAutomata.c +++ b/hacks/WolframAutomata/WolframAutomata.c @@ -36,23 +36,19 @@ struct state { /* the 'evolution_history' Pixmap and subsequently ignored. */ Bool * current_generation; - /* When randomizing the seed generation, we can specify a population */ - /* density, or we can restrict to a single living cell. */ - int population_density; - Bool population_single; - /* For more information on the encoding used for rule_number and on the */ /* method used to apply it: https://en.wikipedia.org/wiki/Wolfram_code */ uint8_t rule_number; /* At the end of the simulation, the user is given time to admire the */ - /* output. Delay is available to user as CLI option. */ + /* output. Delay is available to user as CLI option '-admiration-delay'. */ Bool admiration_in_progress; - size_t admiration_delay; /* ...in microseconds. */ + size_t admiration_delay; /* ...in seconds. */ /* The following values correspond directly to independent CLI options. */ - Bool rule_random; - uint8_t rule_requested; /* Note: Repurposing Rule 0 as null value. */ + Bool random_rule; + int requested_rule; + int seed_density; int cell_size; /* If cell_size=N then draw NxN pixels per cell. */ int delay_microsec; /* ...between calls to WolframAutomata_draw(). */ int num_generations; /* Reset simulation after this many generations. */ @@ -176,12 +172,22 @@ static const struct color_pair color_list[] = { /* Helper Functions */ /* -------------------------------------------------------------------------- */ +static void +randomize_seed_density(struct state * state) +{ + switch (random() % 3) { + case 0: state->seed_density = 30; break; + case 1: state->seed_density = 50; break; + case 2: state->seed_density = 70; break; + } +} + static void generate_random_seed(struct state * state) { int i; for (i = 0; i < state->number_of_cells; i++) { - state->current_generation[i] = ((random() % 100) < state->population_density) ? True : False; + state->current_generation[i] = ((random() % 100) < state->seed_density) ? True : False; } } @@ -276,7 +282,7 @@ WolframAutomata_init(Display * dpy, Window win) state->dpy_height = xgwa.height; state->ypos = 0; - state->admiration_delay = 5000000; + state->admiration_delay = get_integer_resource(state->dpy, "admiration-delay", "Integer"); state->admiration_in_progress = False; /* Set foreground and background colors for active/inactive cells. Either */ @@ -307,14 +313,14 @@ WolframAutomata_init(Display * dpy, Window win) state->gc = XCreateGC(state->dpy, state->win, GCForeground, &gcv); /* Set the size of each simulated cell to NxN pixels for cell_size=N. */ - if (get_boolean_resource(state->dpy, "random-pixel-size", "Boolean")) { + if (get_boolean_resource(state->dpy, "random-cell-size", "Boolean")) { /* Although we are choosing the pixel size 'randomly', a truly random */ /* selection would bias toward large numbers since there are more of */ /* them. To avoid this, we select a random number for a bit shift, */ /* resulting in a pixel size of 1, 2, 4, 8, 16 or 32, equally likely. */ state->cell_size = 1 << (random() % 6); } else { - state->cell_size = get_integer_resource(state->dpy, "pixel-size", "Integer"); + state->cell_size = get_integer_resource(state->dpy, "cell-size", "Integer"); } if (state->cell_size < 1) state->cell_size = 1; if (state->cell_size > state->dpy_width) state->cell_size = state->dpy_width; @@ -353,13 +359,13 @@ WolframAutomata_init(Display * dpy, Window win) /* the exponent in '2^11'. */ state->delay_microsec = 1 << ((random() % 3) + 11 + pixel_shift_range); } else { - state->delay_microsec = get_integer_resource(state->dpy, "delay-usec", "Integer"); + state->delay_microsec = get_integer_resource(state->dpy, "delay", "Integer"); } if (state->delay_microsec < 0) state->delay_microsec = 0; /* Set the number of generations to simulate before wiping the simulation */ /* and re-running with new settings. */ - if (get_boolean_resource(state->dpy, "random-num-generations", "Boolean")) { + if (get_boolean_resource(state->dpy, "random-length", "Boolean")) { /* By empirical observation, keep the product */ /* state->num_generations * state->cell_size */ /* below 10,000 to avoid BadAlloc errors from the X server due to */ @@ -372,7 +378,7 @@ WolframAutomata_init(Display * dpy, Window win) state->num_generations = (state->dpy_height / state->cell_size) + 1; } } else { - state->num_generations = get_integer_resource(state->dpy, "num-generations", "Integer"); + state->num_generations = get_integer_resource(state->dpy, "length", "Integer"); } /* The minimum number of generations is 2 since we must allocate enough */ /* space to hold the seed generation and at least one pass through */ @@ -387,21 +393,19 @@ WolframAutomata_init(Display * dpy, Window win) } /* Time to figure out which rule to use for this simulation. */ - /* We ignore any weirdness resulting from the following cast since every */ + /* We ignore any weirdness resulting from the following casts since every */ /* bit pattern is also a valid rule; if the user provides weird input, */ /* then we'll return weird (but well-defined!) output. */ - state->rule_requested = (uint8_t) get_integer_resource(state->dpy, "rule-requested", "Integer"); - state->rule_random = get_boolean_resource(state->dpy, "rule-random", "Boolean"); + state->requested_rule = get_integer_resource(state->dpy, "rule", "Integer"); + state->random_rule = get_boolean_resource(state->dpy, "random-rule", "Boolean"); /* Through the following set of branches, we enforce CLI flag precedence. */ - if (state->rule_random) { + if (state->random_rule) { /* If this flag is set, the user wants truly random rules rather than */ /* random rules from a curated list. */ state->rule_number = (uint8_t) random(); - } else if (state->rule_requested != 0) { - /* Rule 0 is terribly uninteresting, so we are reusing it as a 'null' */ - /* value and hoping nobody notices. Finding a non-zero value means */ - /* the user requested a specific rule. Use it. */ - state->rule_number = state->rule_requested; + } else if (state->requested_rule != -1) { + /* The user requested a specific rule. Use it. */ + state->rule_number = (uint8_t) state->requested_rule; } else { /* No command-line options were specified, so select rules randomly */ /* from a curated list. */ @@ -411,9 +415,6 @@ WolframAutomata_init(Display * dpy, Window win) } /* Time to construct the seed generation for this simulation. */ - state->population_single = get_boolean_resource(state->dpy, "population-single", "Boolean"); - state->population_density = get_integer_resource(state->dpy, "population-density", "Integer"); - if (state->population_density < 0 || state->population_density > 100) state->population_density = 50; state->current_generation = calloc(1, sizeof(*state->current_generation)*state->number_of_cells); if (!state->current_generation) { fprintf(stderr, "ERROR: Failed to calloc() for cell generation in WolframAutomata_init().\n"); @@ -424,7 +425,7 @@ WolframAutomata_init(Display * dpy, Window win) /* setting the seed generation, instead drawing that information from */ /* the curated ruleset. */ switch (curated_ruleset->seed) { - case random_cell: generate_random_seed(state); break; + case random_cell: randomize_seed_density(state); generate_random_seed(state); break; case middle_cell: state->current_generation[state->number_of_cells/2] = True; break; case edge_cell : state->current_generation[0] = True; break; } @@ -432,9 +433,18 @@ WolframAutomata_init(Display * dpy, Window win) /* If we're not using a curated ruleset, process any relevant flags */ /* from the user, falling back to a random seed generation if nothing */ /* else is specified. */ - if (state->population_single) { + if (get_boolean_resource(state->dpy, "seed-left", "Boolean")) { state->current_generation[0] = True; + } else if (get_boolean_resource(state->dpy, "seed-center", "Boolean")) { + state->current_generation[state->number_of_cells/2] = True; + } else if (get_boolean_resource(state->dpy, "seed-right", "Boolean")) { + state->current_generation[state->number_of_cells-1] = True; + } else if (get_integer_resource(state->dpy, "seed-density", "Integer") != -1) { + state->seed_density = get_integer_resource(state->dpy, "seed-density", "Integer"); + if (state->seed_density < 0 || state->seed_density > 100) state->seed_density = 50; + generate_random_seed(state); } else { + randomize_seed_density(state); generate_random_seed(state); } } @@ -482,7 +492,7 @@ WolframAutomata_draw(Display * dpy, Window win, void * closure) closure = WolframAutomata_init(dpy, win); } else { state->admiration_in_progress = True; - return state->admiration_delay; + return 1000000 * state->admiration_delay; } } @@ -502,32 +512,38 @@ WolframAutomata_draw(Display * dpy, Window win, void * closure) } static const char * WolframAutomata_defaults[] = { - "*delay-usec: 25000", - "*num-generations: 5000", - "*pixel-size: 2", + "*delay: 25000", + "*admiration-delay: 5", + "*length: 5000", + "*cell-size: 2", "*color-index: -1", - "*population-density: 50", - "*population-single: False", - "*random-cellsize: False", + "*seed-density: -1", + "*seed-left: False", + "*seed-center: False", + "*seed-right: False", + "*random-cell-size: False", "*random-delay: False", "*random-length: False", "*random-rule: False", - "*rule-requested: 0", + "*rule: -1", 0 }; static XrmOptionDescRec WolframAutomata_options[] = { - { "-delay-usec", ".delay-usec", XrmoptionSepArg, 0 }, - { "-num-generations", ".num-generations", XrmoptionSepArg, 0 }, - { "-pixel-size", ".pixel-size", XrmoptionSepArg, 0 }, + { "-delay", ".delay", XrmoptionSepArg, 0 }, + { "-admiration-delay", ".admiration-delay", XrmoptionSepArg, 0 }, + { "-length", ".length", XrmoptionSepArg, 0 }, + { "-cell-size", ".cell-size", XrmoptionSepArg, 0 }, { "-color-index", ".color-index", XrmoptionSepArg, 0 }, - { "-population-density", ".population-density", XrmoptionSepArg, 0 }, - { "-population-single", ".population-single", XrmoptionNoArg, "True" }, - { "-random-cellsize", ".random-pixel-size", XrmoptionNoArg, "True" }, + { "-seed-density", ".seed-density", XrmoptionSepArg, 0 }, + { "-seed-left", ".seed-left", XrmoptionNoArg, "True" }, + { "-seed-center", ".seed-center", XrmoptionNoArg, "True" }, + { "-seed-right", ".seed-right", XrmoptionNoArg, "True" }, + { "-random-cell-size", ".random-cell-size", XrmoptionNoArg, "True" }, { "-random-delay", ".random-delay", XrmoptionNoArg, "True" }, - { "-random-length", ".random-num-generations", XrmoptionNoArg, "True" }, - { "-random-rule", ".rule-random", XrmoptionNoArg, "True" }, - { "-rule", ".rule-requested", XrmoptionSepArg, 0 }, + { "-random-length", ".random-length", XrmoptionNoArg, "True" }, + { "-random-rule", ".random-rule", XrmoptionNoArg, "True" }, + { "-rule", ".rule", XrmoptionSepArg, 0 }, { 0, 0, 0, 0 } };