diff options
Diffstat (limited to 'hacks/speedmine.c')
| -rw-r--r-- | hacks/speedmine.c | 1647 |
1 files changed, 1647 insertions, 0 deletions
diff --git a/hacks/speedmine.c b/hacks/speedmine.c new file mode 100644 index 0000000..17a3f2a --- /dev/null +++ b/hacks/speedmine.c @@ -0,0 +1,1647 @@ +/* -*- Mode: C; c-basic-offset: 4; tab-width: 4 -*- + * speedmine, Copyright (C) 2001 Conrad Parker <conrad@deephackmode.org> + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. No representations are made about the suitability of this + * software for any purpose. It is provided "as is" without express or + * implied warranty. + */ + +/* + * Written mostly over the Easter holiday, 2001. Psychedelic option due to + * a night at Home nightclub, Sydney. Three all-nighters of solid partying + * were involved in the week this hack was written. + * + * Happy Birthday to WierdArms (17 April) and Pat (18 April) + */ + +/* + * Hacking notes + * + * This program generates a rectangular terrain grid and maps this onto + * a semi-circular tunnel. The terrain has length TERRAIN_LENGTH, which + * corresponds to length along the tunnel, and breadth TERRAIN_BREADTH, + * which corresponds to circumference around the tunnel. For each frame, + * the tunnel is perspective mapped onto a set of X and Y screen values. + * + * Throughout this code the following temporary variable names are used: + * + * i iterates along the tunnel in the direction of travel + * j iterates around the tunnel clockwise + * t iterates along the length of the perspective mapped values + * from the furthest to the nearest + * + * Thus, the buffers are used with these iterators: + * + * terrain[i][j] terrain map + * worldx[i][j], worldy[i][j] world coordinates (after wrapping) + * {x,y,z}curvature[i] tunnel curvature + * wideness[i] tunnel wideness + * bonuses[i] bonus values + * + * xvals[t][j], yvals[t][j] screen coordinates + * {min,max}{x,y}[t] bounding boxes of screen coords + */ + +/* Define or undefine NDEBUG to turn assert and abort debugging off or on */ +/*#define NDEBUG*/ +/*#include <assert.h>*/ +#define assert(X) +#define DEBUG_FLAG 0 + +#include <math.h> + +#include "screenhack.h" +#include "erase.h" + +#define MIN(a,b) ((a)<(b)?(a):(b)) +#define MAX(a,b) ((a)>(b)?(a):(b)) + +#define RAND(r) (int)(((r)>0)?(random() % (long)(r)): -(random() % (long)(-r))) + +#define SIGN3(a) ((a)>0?1:((a)<0?-1:0)) + +#define MODULO(a,b) while ((a)<0) (a)+=(b); (a) %= (b); + +/* No. of shades of each color (ground, walls, bonuses) */ +#define MAX_COLORS 32 + + + +#define FORWARDS 1 +#define BACKWARDS -1 +/* Apparently AIX's math.h bogusly defines `nearest' as a function, + in violation of the ANSI C spec. */ +#undef nearest +#define nearest n3arest + +#define wireframe (st->wire_flag||st->wire_bonus>8||st->wire_bonus%2==1) +#define effective_speed (st->direction*(st->speed+st->speed_bonus)) + +/* No. of levels of interpolation, for perspective */ +#define INTERP 32 + +/* These must be powers of 2 */ +#define TERRAIN_LENGTH 256 +#define TERRAIN_BREADTH 32 + +/* total "perspective distance" of terrain */ +#define TERRAIN_PDIST (INTERP*TERRAIN_LENGTH) + +#define ROTS 1024 +#define TB_MUL (ROTS/TERRAIN_BREADTH) + +#define random_elevation() (st->terrain_flag?(random() % 200):0) +#define random_curvature() (st->curviness>0.0?((double)(random() % 40)-20)*st->curviness:0.0) +#define random_twist() (st->twistiness>0.0?((double)(random() % 40)-20)*st->twistiness:0.0) +#define random_wideness() (st->widening_flag?(int)(random() % 1200):0) + +#define STEEL_ELEVATION 300 + +struct state { + Display *dpy; + Window window; + + Pixmap dbuf, stars_mask; + Colormap cmap; + Visual *visual; + Screen *screen; + unsigned int default_fg_pixel; + GC draw_gc, erase_gc, tunnelend_gc, stars_gc, stars_erase_gc; + + int ncolors, nr_ground_colors, nr_wall_colors, nr_bonus_colors; + XColor ground_colors[MAX_COLORS], wall_colors[MAX_COLORS]; + XColor bonus_colors[MAX_COLORS]; + GC ground_gcs[MAX_COLORS], wall_gcs[MAX_COLORS], bonus_gcs[MAX_COLORS]; + + int be_wormy; + + int width, height; + int delay; + + int smoothness; + int verbose_flag; + int wire_flag; + int terrain_flag; + int widening_flag; + int bumps_flag; + int bonuses_flag; + int crosshair_flag; + int psychedelic_flag; + + double maxspeed; + + double thrust, gravity; + + double vertigo; + double curviness; + double twistiness; + + double pos; + double speed; + double accel; + double step; + + int direction; + + int pindex, nearest; + int flipped_at; + int xoffset, yoffset; + + int bonus_bright; + int wire_bonus; + + double speed_bonus; + + int spin_bonus; + int backwards_bonus; + + double sintab[ROTS], costab[ROTS]; + + int orientation; + + int terrain[TERRAIN_LENGTH][TERRAIN_BREADTH]; + double xcurvature[TERRAIN_LENGTH]; + double ycurvature[TERRAIN_LENGTH]; + double zcurvature[TERRAIN_LENGTH]; + int wideness[TERRAIN_LENGTH]; + int bonuses[TERRAIN_LENGTH]; + int xvals[TERRAIN_LENGTH][TERRAIN_BREADTH]; + int yvals[TERRAIN_LENGTH][TERRAIN_BREADTH]; + double worldx[TERRAIN_LENGTH][TERRAIN_BREADTH]; + double worldy[TERRAIN_LENGTH][TERRAIN_BREADTH]; + int minx[TERRAIN_LENGTH], maxx[TERRAIN_LENGTH]; + int miny[TERRAIN_LENGTH], maxy[TERRAIN_LENGTH]; + + int total_nframes; + int nframes; + double fps; + double fps_start, fps_end; + struct timeval start_time; + + int rotation_offset; + int jamming; +}; + +/* a forward declaration ... */ +static void change_colors(struct state *st); + + + +/* + * get_time () + * + * returns the total time elapsed since the beginning of the demo + */ +static double get_time(struct state *st) { + struct timeval t; + float f; +#if GETTIMEOFDAY_TWO_ARGS + gettimeofday(&t, NULL); +#else + gettimeofday(&t); +#endif + t.tv_sec -= st->start_time.tv_sec; + f = ((double)t.tv_sec) + t.tv_usec*1e-6; + return f; +} + +/* + * init_time () + * + * initialises the timing structures + */ +static void init_time(struct state *st) { +#if GETTIMEOFDAY_TWO_ARGS + gettimeofday(&st->start_time, NULL); +#else + gettimeofday(&st->start_time); +#endif + st->fps_start = get_time(st); +} + + +/* + * perspective() + * + * perspective map the world coordinates worldx[i][j], worldy[i][j] onto + * screen coordinates xvals[t][j], yvals[t][j] + */ +static void +perspective (struct state *st) +{ + int i, j, jj, t=0, depth, view_pos; + int rotation_bias, r; + double xc=0.0, yc=0.0, zc=0.0; + double xcc=0.0, ycc=0.0, zcc=0.0; + double xx, yy; + double zfactor, zf; + + zf = 8.0*28.0 / (double)(st->width*TERRAIN_LENGTH); + if (st->be_wormy) zf *= 3.0; + + depth = TERRAIN_PDIST - INTERP + st->pindex; + + view_pos = (st->nearest+3*TERRAIN_LENGTH/4)%TERRAIN_LENGTH; + + st->xoffset += - st->xcurvature[view_pos]*st->curviness/8; + st->xoffset /= 2; + + st->yoffset += - st->ycurvature[view_pos]*st->curviness/4; + st->yoffset /= 2; + + st->rotation_offset += (int)((st->zcurvature[view_pos]-st->zcurvature[st->nearest])*ROTS/8); + st->rotation_offset /= 2; + rotation_bias = st->orientation + st->spin_bonus - st->rotation_offset; + + if (st->bumps_flag) { + if (st->be_wormy) { + st->yoffset -= ((st->terrain[view_pos][TERRAIN_BREADTH/4] * st->width /(8*1600))); + rotation_bias += (st->terrain[view_pos][TERRAIN_BREADTH/4+2] - + st->terrain[view_pos][TERRAIN_BREADTH/4-2])/8; + } else { + st->yoffset -= ((st->terrain[view_pos][TERRAIN_BREADTH/4] * st->width /(2*1600))); + rotation_bias += (st->terrain[view_pos][TERRAIN_BREADTH/4+2] - + st->terrain[view_pos][TERRAIN_BREADTH/4-2])/16; + } + } + + MODULO(rotation_bias, ROTS); + + for (t=0; t < TERRAIN_LENGTH; t++) { + i = st->nearest + t; MODULO(i, TERRAIN_LENGTH); + xc += st->xcurvature[i]; yc += st->ycurvature[i]; zc += st->zcurvature[i]; + xcc += xc; ycc += yc; zcc += zc; + st->maxx[i] = st->maxy[i] = 0; + st->minx[i] = st->width; st->miny[i] = st->height; + } + + for (t=0; t < TERRAIN_LENGTH; t++) { + i = st->nearest - 1 - t; MODULO(i, TERRAIN_LENGTH); + + zfactor = (double)depth* (12.0 - TERRAIN_LENGTH/8.0) * zf; + for (j=0; j < TERRAIN_BREADTH; j++) { + jj = st->direction * j; MODULO(jj, TERRAIN_BREADTH); + /* jwz: not totally sure if this is right, but it avoids div0 */ + if (zfactor != 0) { + xx = (st->worldx[i][jj]-(st->vertigo*xcc))/zfactor; + yy = (st->worldy[i][j]-(st->vertigo*ycc))/zfactor; + } else { + xx = 0; + yy = 0; + } + r = rotation_bias + (int)(st->vertigo*zcc); MODULO(r, ROTS); + + st->xvals[t][j] = st->xoffset + (st->width>>1) + + (int)(xx * st->costab[r] - yy * st->sintab[r]); + st->maxx[t] = MAX(st->maxx[t], st->xvals[t][j]); + st->minx[t] = MIN(st->minx[t], st->xvals[t][j]); + + st->yvals[t][j] = st->yoffset + st->height/2 + + (int)(xx * st->sintab[r] + yy * st->costab[r]); + st->maxy[t] = MAX(st->maxy[t], st->yvals[t][j]); + st->miny[t] = MIN(st->miny[t], st->yvals[t][j]); + } + xcc -= xc; ycc -= yc; zcc -= zc; + xc -= st->xcurvature[i]; yc -= st->ycurvature[i]; zc -= st->zcurvature[i]; + depth -= INTERP; + } +} + +/* + * wrap_tunnel (start, end) + * + * wrap the terrain terrain[i][j] around the semi-circular tunnel function + * + * x' = x/2 * cos(theta) - (y-k) * x * sin(theta) + * y' = x/4 * sin(theta) + y * cos(theta) + * + * between i=start and i=end inclusive, producing world coordinates + * worldx[i][j], worldy[i][j] + */ +static void +wrap_tunnel (struct state *st, int start, int end) +{ + int i, j, v; + double x, y; + + assert (start < end); + + for (i=start; i <= end; i++) { + for (j=0; j < TERRAIN_BREADTH; j++) { + x = j * (1.0/TERRAIN_BREADTH); + v = st->terrain[i][j]; + y = (double)(v==STEEL_ELEVATION?200:v) - st->wideness[i] - 1200; + + /* lower road */ + if (j > TERRAIN_BREADTH/8 && j < 3*TERRAIN_BREADTH/8) y -= 300; + + st->worldx[i][j] = x/2 * st->costab[j*TB_MUL] - + (y-st->height/4.0)*x*st->sintab[j*TB_MUL]; + st->worldy[i][j] = x/4 * st->sintab[j*TB_MUL] + + y * st->costab[j*TB_MUL]; + } + } +} + +/* + * flip_direction() + * + * perform the state transitions and terrain transformation for the + * "look backwards/look forwards" bonus + */ +static void +flip_direction (struct state *st) +{ + int i, ip, in, j, t; + + st->direction = -st->direction; + + st->bonus_bright = 20; + + for (i=0; i < TERRAIN_LENGTH; i++) { + in = st->nearest + i; MODULO(in, TERRAIN_BREADTH); + ip = st->nearest - i; MODULO(ip, TERRAIN_BREADTH); + for (j=0; j < TERRAIN_BREADTH; j++) { + t = st->terrain[ip][j]; + st->terrain[ip][j] = st->terrain[in][j]; + st->terrain[in][j] = t; + } + } +} + +/* + * generate_smooth (start, end) + * + * generate smooth terrain between i=start and i=end inclusive + */ +static void +generate_smooth (struct state *st, int start, int end) +{ + int i,j, ii; + + assert (start < end); + + for (i=start; i <= end; i++) { + ii = i; MODULO(ii, TERRAIN_LENGTH); + for (j=0; j < TERRAIN_BREADTH; j++) { + st->terrain[i][j] = STEEL_ELEVATION; + } + } +} + +/* + * generate_straight (start, end) + * + * zero the curvature and wideness between i=start and i=end inclusive + */ +static void +generate_straight (struct state *st, int start, int end) +{ + int i,j, ii; + + assert (start < end); + + for (i=start; i <= end; i++) { + ii = i; MODULO(ii, TERRAIN_LENGTH); + for (j=0; j < TERRAIN_BREADTH; j++) { + st->xcurvature[ii] = 0; + st->ycurvature[ii] = 0; + st->zcurvature[ii] = 0; + st->wideness[ii] = 0; + } + } +} + +/* + * int generate_terrain_value (v1, v2, v3, v4, w) + * + * generate terrain value near the average of v1, v2, v3, v4, with + * perturbation proportional to w + */ +static int +generate_terrain_value (struct state *st, int v1, int v2, int v3, int v4, int w) +{ + int sum, ret; + int rval; + + if (!st->terrain_flag) return 0; + + sum = v1 + v2 + v3 + v4; + + rval = w*sum/st->smoothness; + if (rval == 0) rval = 2; + + ret = (sum/4 -(rval/2) + RAND(rval)); + + if (ret < -400 || ret > 400) { + ret = sum/4; + } + + return ret; +} + +/* + * generate_terrain (start, end, final) + * + * generate terrain[i][j] between i=start and i=end inclusive + * + * This is performed by successive subdivision of the terrain into + * rectangles of decreasing size. Subdivision continues until the + * the minimum width or height of these rectangles is 'final'; ie. + * final=1 indicates to subdivide as far as possible, final=2 indicates + * to stop one subdivision before that (leaving a checkerboard pattern + * uncalculated) etc. + */ +static void +generate_terrain (struct state *st, int start, int end, int final) +{ + int i,j,w,l; + int ip, jp, in, jn; /* prev, next values */ + int diff; + + assert (start < end); + assert (start >= 0 && start < TERRAIN_LENGTH); + assert (end >= 0 && end < TERRAIN_LENGTH); + + diff = end - start + 1; + + st->terrain[end][0] = random_elevation(); + st->terrain[end][TERRAIN_BREADTH/2] = random_elevation(); + + for (w= diff/2, l=TERRAIN_BREADTH/4; + w >= final || l >= final; w /= 2, l /= 2) { + + if (w<1) w=1; + if (l<1) l=1; + + for (i=start+w-1; i < end; i += (w*2)) { + ip = i-w; MODULO(ip, TERRAIN_LENGTH); + in = i+w; MODULO(in, TERRAIN_LENGTH); + for (j=l-1; j < TERRAIN_BREADTH; j += (l*2)) { + jp = j-1; MODULO(jp, TERRAIN_BREADTH); + jn = j+1; MODULO(jn, TERRAIN_BREADTH); + st->terrain[i][j] = + generate_terrain_value (st, st->terrain[ip][jp], st->terrain[in][jp], + st->terrain[ip][jn], st->terrain[in][jn], w); + } + } + + for (i=start+(w*2)-1; i < end; i += (w*2)) { + ip = i-w; MODULO(ip, TERRAIN_LENGTH); + in = i+w; MODULO(in, TERRAIN_LENGTH); + for (j=l-1; j < TERRAIN_BREADTH; j += (l*2)) { + jp = j-1; MODULO(jp, TERRAIN_BREADTH); + jn = j+1; MODULO(jn, TERRAIN_BREADTH); + st->terrain[i][j] = + generate_terrain_value (st, st->terrain[ip][j], st->terrain[in][j], + st->terrain[i][jp], st->terrain[i][jn], w); + } + } + + for (i=start+w-1; i < end; i += (w*2)) { + ip = i-w; MODULO(ip, TERRAIN_LENGTH); + in = i+w; MODULO(in, TERRAIN_LENGTH); + for (j=2*l-1; j < TERRAIN_BREADTH; j += (l*2)) { + jp = j-1; MODULO(jp, TERRAIN_BREADTH); + jn = j+1; MODULO(jn, TERRAIN_BREADTH); + st->terrain[i][j] = + generate_terrain_value (st, st->terrain[ip][j], st->terrain[in][j], + st->terrain[i][jp], st->terrain[i][jn], w); + } + } + } +} + +/* + * double generate_curvature_value (v1, v2, w) + * + * generate curvature value near the average of v1 and v2, with perturbation + * proportional to w + */ +static double +generate_curvature_value (double v1, double v2, int w) +{ + double sum, avg, diff, ret; + int rval; + + assert (!isnan(v1) && !isnan(v2)); + + sum = v1+v2; + avg = sum/2.0; + + diff = MIN(v1 - avg, v2 - avg); + + rval = (int)diff * w; + if (rval == 0.0) return avg; + + ret = (avg -((double)rval)/500.0 + ((double)RAND(rval))/1000.0); + + assert (!isnan(ret)); + + return ret; +} + +/* + * generate_curves (start, end) + * + * generate xcurvature[i], ycurvature[i], zcurvature[i] and wideness[i] + * between start and end inclusive + */ +static void +generate_curves (struct state *st, int start, int end) +{ + int i, diff, ii, in, ip, w; + + assert (start < end); + + diff = end - start + 1; MODULO (diff, TERRAIN_LENGTH); + + if (random() % 100 == 0) + st->xcurvature[end] = 30 * random_curvature(); + else if (random() % 10 == 0) + st->xcurvature[end] = 20 * random_curvature(); + else + st->xcurvature[end] = 10 * random_curvature(); + + if (random() % 50 == 0) + st->ycurvature[end] = 20 * random_curvature(); + else if (random() % 25 == 0) + st->ycurvature[end] = 30 * random_curvature(); + else + st->ycurvature[end] = 10 * random_curvature(); + + if (random() % 3 == 0) + st->zcurvature[end] = random_twist(); + else + st->zcurvature[end] = + generate_curvature_value (st->zcurvature[end], random_twist(), 1); + + if (st->be_wormy) + st->wideness[end] = random_wideness(); + else + st->wideness[end] = + generate_curvature_value (st->wideness[end], random_wideness(), 1); + + for (w=diff/2; w >= 1; w /= 2) { + for (i=start+w-1; i < end; i+=(w*2)) { + ii = i; MODULO (ii, TERRAIN_LENGTH); + ip = i-w; MODULO (ip, TERRAIN_LENGTH); + in = i+w; MODULO (in, TERRAIN_LENGTH); + st->xcurvature[ii] = + generate_curvature_value (st->xcurvature[ip], st->xcurvature[in], w); + st->ycurvature[ii] = + generate_curvature_value (st->ycurvature[ip], st->ycurvature[in], w); + st->zcurvature[ii] = + generate_curvature_value (st->zcurvature[ip], st->zcurvature[in], w); + st->wideness[ii] = + generate_curvature_value (st->wideness[ip], st->wideness[in], w); + } + } +} + +/* + * do_bonus () + * + * choose a random bonus and perform its state transition + */ +static void +do_bonus (struct state *st) +{ + st->bonus_bright = 20; + + if (st->jamming > 0) { + st->jamming--; + st->nearest -= 2; MODULO(st->nearest, TERRAIN_LENGTH); + return; + } + + if (st->psychedelic_flag) change_colors(st); + + switch (random() % 7) { + case 0: /* switch to or from wireframe */ + st->wire_bonus = (st->wire_bonus?0:300); + break; + case 1: /* speedup */ + st->speed_bonus = 40.0; + break; + case 2: + st->spin_bonus += ROTS; + break; + case 3: + st->spin_bonus -= ROTS; + break; + case 4: /* look backwards / look forwards */ + st->flipped_at = st->nearest; + flip_direction (st); + st->backwards_bonus = (st->backwards_bonus?0:10); + break; + case 5: + change_colors(st); + break; + case 6: /* jam against the bonus a few times; deja vu! */ + st->nearest -= 2; MODULO(st->nearest, TERRAIN_LENGTH); + st->jamming = 3; + break; + default: + assert(0); + break; + } +} + +/* + * check_bonus () + * + * check if a bonus has been passed in the last frame, and handle it + */ +static void +check_bonuses (struct state *st) +{ + int i, ii, start, end; + + if (!st->bonuses_flag) return; + + if (st->step >= 0.0) { + start = st->nearest; end = st->nearest + (int)floor(st->step); + } else { + end = st->nearest; start = st->nearest + (int)floor(st->step); + } + + if (st->be_wormy) { + start += TERRAIN_LENGTH/4; + end += TERRAIN_LENGTH/4; + } + + for (i=start; i < end; i++) { + ii = i; MODULO(ii, TERRAIN_LENGTH); + if (st->bonuses[ii] == 1) do_bonus (st); + } +} + +/* + * decrement_bonuses (double time_per_frame) + * + * decrement timers associated with bonuses + */ +static void +decrement_bonuses (struct state *st, double time_per_frame) +{ + if (!st->bonuses_flag) return; + + if (st->bonus_bright > 0) st->bonus_bright-=4; + if (st->wire_bonus > 0) st->wire_bonus--; + if (st->speed_bonus > 0) st->speed_bonus -= 2.0; + + if (st->spin_bonus > 10) st->spin_bonus -= (int)(st->step*13.7); + else if (st->spin_bonus < -10) st->spin_bonus += (int)(st->step*11.3); + + if (st->backwards_bonus > 1) st->backwards_bonus--; + else if (st->backwards_bonus == 1) { + st->nearest += 2*(MAX(st->flipped_at, st->nearest) - MIN(st->flipped_at,st->nearest)); + MODULO(st->nearest, TERRAIN_LENGTH); + flip_direction (st); + st->backwards_bonus = 0; + } +} + +/* + * set_bonuses (start, end) + * + * choose if to and where to set a bonus between i=start and i=end inclusive + */ +static void +set_bonuses (struct state *st, int start, int end) +{ + int i, diff, ii; + + if (!st->bonuses_flag) return; + + assert (start < end); + + diff = end - start; + + for (i=start; i <= end; i++) { + ii = i; if (ii>=TERRAIN_LENGTH) ii -= TERRAIN_LENGTH; + st->bonuses[ii] = 0; + } + if (random() % 4 == 0) { + i = start + RAND(diff-3); + ii = i; if (ii>=TERRAIN_LENGTH) ii -= TERRAIN_LENGTH; + st->bonuses[ii] = 2; /* marker */ + ii = i+3; if (ii>=TERRAIN_LENGTH) ii -= TERRAIN_LENGTH; + st->bonuses[ii] = 1; /* real thing */ + } +} + +/* + * regenerate_terrain () + * + * regenerate a portion of the terrain map of length TERRAIN_LENGTH/4 iff + * we just passed between two quarters of the terrain. + * + * choose the kind of terrain to produce, produce it and wrap the tunnel + */ +static void +regenerate_terrain (struct state *st) +{ + int start, end; + int passed; + + passed = st->nearest % (TERRAIN_LENGTH/4); + + if (st->speed == 0.0 || + (st->speed > 0.0 && passed > (int)st->step) || + (st->speed < 0.0 && (TERRAIN_LENGTH/4)-passed > (int)fabs(st->step))) { + + return; + } + + end = st->nearest - passed - 1; MODULO(end, TERRAIN_LENGTH); + start = end - TERRAIN_LENGTH/4 + 1; MODULO(start, TERRAIN_LENGTH); + + if (DEBUG_FLAG) printf ("Regenerating [%d - %d]\n", start, end); + + set_bonuses (st, start, end); + + switch (random() % 64) { + case 0: + case 1: + generate_terrain (st, start, end, 1); + generate_smooth (st, start, + start + TERRAIN_LENGTH/8 + (random() % TERRAIN_LENGTH/8)); + break; + case 2: + generate_smooth (st, start, end); + generate_terrain (st, start, end, 4); break; + case 3: + generate_smooth (st, start, end); + generate_terrain (st, start, end, 2); break; + default: + generate_terrain (st, start, end, 1); + } + + if (random() % 16 == 0) { + generate_straight (st, start, end); + } else { + generate_curves (st, start, end); + } + + wrap_tunnel (st, start, end); +} + +/* + * init_terrain () + * + * initialise the terrain map for the beginning of the demo + */ +static void +init_terrain (struct state *st) +{ + int i, j; + + for (i=0; i < TERRAIN_LENGTH; i++) { + for (j=0; j < TERRAIN_BREADTH; j++) { + st->terrain[i][j] = 0; + } + } + + st->terrain[TERRAIN_LENGTH-1][0] = - (random() % 300); + st->terrain[TERRAIN_LENGTH-1][TERRAIN_BREADTH/2] = - (random() % 300); + + generate_smooth (st, 0, TERRAIN_LENGTH-1); + generate_terrain (st, 0, TERRAIN_LENGTH/4 -1, 4); + generate_terrain (st, TERRAIN_LENGTH/4, TERRAIN_LENGTH/2 -1, 2); + generate_terrain (st, TERRAIN_LENGTH/2, 3*TERRAIN_LENGTH/4 -1, 1); + generate_smooth (st, 3*TERRAIN_LENGTH/4, TERRAIN_LENGTH-1); +} + +/* + * init_curves () + * + * initialise the curvatures and wideness for the beginning of the demo. + */ +static void +init_curves (struct state *st) +{ + int i; + + for (i=0; i < TERRAIN_LENGTH-1; i++) { + st->xcurvature[i] = 0.0; + st->ycurvature[i] = 0.0; + st->zcurvature[i] = 0.0; + } + + st->xcurvature[TERRAIN_LENGTH-1] = random_curvature(); + st->ycurvature[TERRAIN_LENGTH-1] = random_curvature(); + st->zcurvature[TERRAIN_LENGTH-1] = random_twist(); + + generate_straight (st, 0, TERRAIN_LENGTH/4-1); + generate_curves (st, TERRAIN_LENGTH/4, TERRAIN_LENGTH/2-1); + generate_curves (st, TERRAIN_LENGTH/2, 3*TERRAIN_LENGTH/4-1); + generate_straight (st, 3*TERRAIN_LENGTH/4, TERRAIN_LENGTH-1); + +} + +/* + * render_quads (dpy, d, t, dt, i) + * + * renders the quadrilaterals from perspective depth t to t+dt. + * i is passed as a hint, where i corresponds to t as asserted. + */ +static void +render_quads (struct state *st, Drawable d, int t, int dt, int i) +{ + int j, t2, j2, in; + int index; + XPoint points[4]; + GC gc; + + assert (i == (st->nearest - (t + dt) + TERRAIN_LENGTH) % TERRAIN_LENGTH); + + in = i + 1; MODULO(in, TERRAIN_LENGTH); + + for (j=0; j < TERRAIN_BREADTH; j+=dt) { + t2 = t+dt; if (t2 >= TERRAIN_LENGTH) t2 -= TERRAIN_LENGTH; + j2 = j+dt; if (j2 >= TERRAIN_BREADTH) j2 -= TERRAIN_BREADTH; + points[0].x = st->xvals[t][j]; points[0].y = st->yvals[t][j]; + points[1].x = st->xvals[t2][j]; points[1].y = st->yvals[t2][j]; + points[2].x = st->xvals[t2][j2]; points[2].y = st->yvals[t2][j2]; + points[3].x = st->xvals[t][j2]; points[3].y = st->yvals[t][j2]; + + index = st->bonus_bright + st->ncolors/3 + + t*(t*INTERP + st->pindex) * st->ncolors / + (3*TERRAIN_LENGTH*TERRAIN_PDIST); + if (!wireframe) { + index += (int)((points[0].y - points[3].y) / 8); + index += (int)((st->worldx[i][j] - st->worldx[in][j]) / 40); + index += (int)((st->terrain[in][j] - st->terrain[i][j]) / 100); + } + if (st->be_wormy && st->psychedelic_flag) index += st->ncolors/4; + + if (st->ncolors > MAX_COLORS) abort(); + index = MIN (index, st->ncolors-1); + index = MAX (index, 0); + + if (st->bonuses[i]) { + XSetClipMask (st->dpy, st->bonus_gcs[index], None); + } + + if (wireframe) { + if (st->bonuses[i]) gc = st->bonus_gcs[index]; + else gc = st->ground_gcs[index]; + XDrawLines (st->dpy, d, gc, points, 4, CoordModeOrigin); + } else { + if (st->bonuses[i]) + gc = st->bonus_gcs[index]; + else if ((st->direction>0 && j < TERRAIN_BREADTH/8) || + (j > TERRAIN_BREADTH/8 && j < 3*TERRAIN_BREADTH/8-1) || + (st->direction < 0 && j > 3*TERRAIN_BREADTH/8-1 && + j < TERRAIN_BREADTH/2) || + st->terrain[i][j] == STEEL_ELEVATION || + st->wideness[in] - st->wideness[i] > 200) + gc = st->ground_gcs[index]; + else + gc = st->wall_gcs[index]; + + XFillPolygon (st->dpy, d, gc, points, 4, Nonconvex, CoordModeOrigin); + } + } +} + +/* + * render_pentagons (dpy, d, t, dt, i) + * + * renders the pentagons from perspective depth t to t+dt. + * i is passed as a hint, where i corresponds to t as asserted. + */ +static void +render_pentagons (struct state *st, Drawable d, int t, int dt, int i) +{ + int j, t2, j2, j3, in; + int index; + XPoint points[5]; + GC gc; + + assert (i == (st->nearest -t + TERRAIN_LENGTH) % TERRAIN_LENGTH); + + in = i + 1; MODULO(in, TERRAIN_LENGTH); + + for (j=0; j < TERRAIN_BREADTH; j+=dt*2) { + t2 = t+(dt*2); if (t2 >= TERRAIN_LENGTH) t2 -= TERRAIN_LENGTH; + j2 = j+dt; if (j2 >= TERRAIN_BREADTH) j2 -= TERRAIN_BREADTH; + j3 = j+dt+dt; if (j3 >= TERRAIN_BREADTH) j3 -= TERRAIN_BREADTH; + points[0].x = st->xvals[t][j]; points[0].y = st->yvals[t][j]; + points[1].x = st->xvals[t2][j]; points[1].y = st->yvals[t2][j]; + points[2].x = st->xvals[t2][j2]; points[2].y = st->yvals[t2][j2]; + points[3].x = st->xvals[t2][j3]; points[3].y = st->yvals[t2][j3]; + points[4].x = st->xvals[t][j3]; points[4].y = st->yvals[t][j3]; + + index = st->bonus_bright + st->ncolors/3 + + t*(t*INTERP + st->pindex) * st->ncolors / + (3*TERRAIN_LENGTH*TERRAIN_PDIST); + if (!wireframe) { + index += (int)((points[0].y - points[3].y) / 8); + index += (int)((st->worldx[i][j] - st->worldx[in][j]) / 40); + index += (int)((st->terrain[in][j] - st->terrain[i][j]) / 100); + } + if (st->be_wormy && st->psychedelic_flag) index += st->ncolors/4; + + index = MIN (index, st->ncolors-1); + index = MAX (index, 0); + + if (st->bonuses[i]) { + XSetClipMask (st->dpy, st->bonus_gcs[index], None); + } + + if (wireframe) { + if (st->bonuses[i]) gc = st->bonus_gcs[index]; + else gc = st->ground_gcs[index]; + XDrawLines (st->dpy, d, gc, points, 5, CoordModeOrigin); + } else { + if (st->bonuses[i]) + gc = st->bonus_gcs[index]; + else if (j < TERRAIN_BREADTH/8 || + (j > TERRAIN_BREADTH/8 && j < 3*TERRAIN_BREADTH/8-1) || + st->terrain[i][j] == STEEL_ELEVATION || + st->wideness[in] - st->wideness[i] > 200) + gc = st->ground_gcs[index]; + else + gc = st->wall_gcs[index]; + + XFillPolygon (st->dpy, d, gc, points, 5, Complex, CoordModeOrigin); + } + } +} + +/* + * render_block (dpy, d, gc, t) + * + * render a filled polygon at perspective depth t using the given GC + */ +static void +render_block (struct state *st, Drawable d, GC gc, int t) +{ + int i; + + XPoint erase_points[TERRAIN_BREADTH/2]; + + for (i=0; i < TERRAIN_BREADTH/2; i++) { + erase_points[i].x = st->xvals[t][i*2]; + erase_points[i].y = st->yvals[t][i*2]; + } + + XFillPolygon (st->dpy, d, gc, erase_points, + TERRAIN_BREADTH/2, Complex, CoordModeOrigin); +} + +/* + * regenerate_stars_mask (dpy, t) + * + * regenerate the clip mask 'stars_mask' for drawing the bonus stars at + * random positions within the bounding box at depth t + */ +static void +regenerate_stars_mask (struct state *st, int t) +{ + int i, w, h, a, b, l1, l2; + const int lim = st->width*TERRAIN_LENGTH/(300*(TERRAIN_LENGTH-t)); + + w = st->maxx[t] - st->minx[t]; + h = st->maxy[t] - st->miny[t]; + + if (w<6||h<6) return; + + XFillRectangle (st->dpy, st->stars_mask, st->stars_erase_gc, + 0, 0, st->width, st->height); + + l1 = (t>3*TERRAIN_LENGTH/4?2:1); + l2 = (t>7*TERRAIN_LENGTH/8?2:1); + + for (i=0; i < lim; i++) { + a = RAND(w); b = RAND(h); + XDrawLine (st->dpy, st->stars_mask, st->stars_gc, + st->minx[t]+a-l1, st->miny[t]+b, st->minx[t]+a+l1, st->miny[t]+b); + XDrawLine (st->dpy, st->stars_mask, st->stars_gc, + st->minx[t]+a, st->miny[t]+b-l1, st->minx[t]+a, st->miny[t]+b+l1); + } + for (i=0; i < lim; i++) { + a = RAND(w); b = RAND(h); + XDrawLine (st->dpy, st->stars_mask, st->stars_gc, + st->minx[t]+a-l2, st->miny[t]+b, st->minx[t]+a+l2, st->miny[t]+b); + XDrawLine (st->dpy, st->stars_mask, st->stars_gc, + st->minx[t]+a, st->miny[t]+b-l2, st->minx[t]+a, st->miny[t]+b+l2); + } +} + +/* + * render_bonus_block (dpy, d, t, i) + * + * draw the bonus stars at depth t. + * i is passed as a hint, where i corresponds to t as asserted. + */ +static void +render_bonus_block (struct state *st, Drawable d, int t, int i) +{ + int bt; + + assert (i == (st->nearest -t + TERRAIN_LENGTH) % TERRAIN_LENGTH); + + if (!st->bonuses[i] || wireframe) return; + + regenerate_stars_mask (st, t); + + bt = t * st->nr_bonus_colors / (2*TERRAIN_LENGTH); + + XSetClipMask (st->dpy, st->bonus_gcs[bt], st->stars_mask); + + render_block (st, d, st->bonus_gcs[bt], t); +} + +static int +begin_at (struct state *st) +{ + int t; + int max_minx=0, min_maxx=st->width, max_miny=0, min_maxy=st->height; + + for (t=TERRAIN_LENGTH-1; t > 0; t--) { + max_minx = MAX (max_minx, st->minx[t]); + min_maxx = MIN (min_maxx, st->maxx[t]); + max_miny = MAX (max_miny, st->miny[t]); + min_maxy = MIN (min_maxy, st->maxy[t]); + + if (max_miny >= min_maxy || max_minx >= min_maxx) break; + } + + return t; +} + +/* + * render_speedmine (dpy, d) + * + * render the current frame. + */ +static void +render_speedmine (struct state *st, Drawable d) +{ + int t, i=st->nearest, dt=1; + GC gc; + + assert (st->nearest >= 0 && st->nearest < TERRAIN_LENGTH); + + if (st->be_wormy || wireframe) { + XFillRectangle (st->dpy, d, st->erase_gc, 0, 0, st->width, st->height); + + dt=4; + for (t=0; t < TERRAIN_LENGTH/4; t+=dt) { + render_bonus_block (st, d, t, i); + i -= dt; MODULO(i, TERRAIN_LENGTH); + render_quads (st, d, t, dt, i); + } + + assert (t == TERRAIN_LENGTH/4); + } else { + t = MAX(begin_at(st), TERRAIN_LENGTH/4); + /*t = TERRAIN_LENGTH/4; dt = 2; */ + /*dt = (t >= 3*TERRAIN_LENGTH/4 ? 1 : 2);*/ + i = (st->nearest -t + TERRAIN_LENGTH) % TERRAIN_LENGTH; + render_block (st, d, st->tunnelend_gc, t); + } + + dt=2; + + if (t == TERRAIN_LENGTH/4) + render_pentagons (st, d, t, dt, i); + + for (; t < 3*TERRAIN_LENGTH/4; t+=dt) { + render_bonus_block (st, d, t, i); + i -= dt; MODULO(i, TERRAIN_LENGTH); + render_quads (st, d, t, dt, i); + } + + dt=1; + if (st->be_wormy) { + for (; t < TERRAIN_LENGTH-(1+(st->pindex<INTERP/2)); t+=dt) { + render_bonus_block (st, d, t, i); + i -= dt; MODULO(i, TERRAIN_LENGTH); + } + } else { + if (wireframe) {assert (t == 3*TERRAIN_LENGTH/4);} + + if (t == 3*TERRAIN_LENGTH/4) + render_pentagons (st, d, t, dt, i); + + for (; t < TERRAIN_LENGTH-(1+(st->pindex<INTERP/2)); t+=dt) { + render_bonus_block (st, d, t, i); + i -= dt; MODULO(i, TERRAIN_LENGTH); + render_quads (st, d, t, dt, i); + } + } + + /* Draw crosshair */ + if (st->crosshair_flag) { + gc = (wireframe ? st->bonus_gcs[st->nr_bonus_colors/2] : st->erase_gc); + XFillRectangle (st->dpy, d, gc, + st->width/2+(st->xoffset)-8, st->height/2+(st->yoffset*2)-1, 16, 3); + XFillRectangle (st->dpy, d, gc, + st->width/2+(st->xoffset)-1, st->height/2+(st->yoffset*2)-8, 3, 16); + } + +} + +/* + * move (step) + * + * move to the position for the next frame, and modify the state variables + * st->nearest, pindex, pos, speed + */ +static void +move (struct state *st) +{ + double dpos; + + st->pos += st->step; + dpos = SIGN3(st->pos) * floor(fabs(st->pos)); + + st->pindex += SIGN3(effective_speed) + INTERP; + while (st->pindex >= INTERP) { + st->nearest --; + st->pindex -= INTERP; + } + while (st->pindex < 0) { + st->nearest ++; + st->pindex += INTERP; + } + + st->nearest += dpos; MODULO(st->nearest, TERRAIN_LENGTH); + + st->pos -= dpos; + + st->accel = st->thrust + st->ycurvature[st->nearest] * st->gravity; + st->speed += st->accel; + if (st->speed > st->maxspeed) st->speed = st->maxspeed; + if (st->speed < -st->maxspeed) st->speed = -st->maxspeed; +} + +/* + * speedmine (dpy, window) + * + * do everything required for one frame of the demo + */ +static unsigned long +speedmine_draw (Display *dpy, Window window, void *closure) +{ + struct state *st = (struct state *) closure; + double elapsed, time_per_frame = 0.04; + + regenerate_terrain (st); + + perspective (st); + + render_speedmine (st, st->dbuf); + if (st->dbuf != st->window) + XCopyArea (st->dpy, st->dbuf, st->window, st->draw_gc, 0, 0, st->width, st->height, 0, 0); + + st->fps_end = get_time(st); + st->nframes++; + st->total_nframes++; + + if (st->fps_end > st->fps_start + 0.5) { + elapsed = st->fps_end - st->fps_start; + st->fps_start = get_time(st); + + time_per_frame = elapsed / st->nframes - st->delay*1e-6; + st->fps = st->nframes / elapsed; + if (DEBUG_FLAG) { + printf ("%f s elapsed\t%3f s/frame\t%.1f FPS\n", elapsed, + time_per_frame, st->fps); + } + st->step = effective_speed * elapsed; + + st->nframes = 0; + } + + + move (st); + + decrement_bonuses (st, time_per_frame); + + check_bonuses (st); + + return st->delay; +} + +/* + * speedmine_color_ramp (dpy, gcs, colors, ncolors, s1, s2, v1, v2) + * + * generate a color ramp of up to *ncolors between randomly chosen hues, + * varying from saturation s1 to s2 and value v1 to v2, placing the colors + * in 'colors' and creating corresponding GCs in 'gcs'. + * + * The number of colors actually allocated is returned in ncolors. + */ +static void +speedmine_color_ramp (struct state *st, GC *gcs, XColor * colors, + int *ncolors, double s1, double s2, double v1, double v2) +{ + XGCValues gcv; + int h1, h2; + unsigned long flags; + int i; + + assert (*st->ncolors >= 0); + assert (s1 >= 0.0 && s1 <= 1.0 && v1 >= 0.0 && v2 <= 1.0); + + if (st->psychedelic_flag) { + h1 = RAND(360); h2 = (h1 + 180) % 360; + } else { + h1 = h2 = RAND(360); + } + + make_color_ramp (st->screen, st->visual, st->cmap, + h1, s1, v1, h2, s2, v2, + colors, ncolors, False, True, False); + + flags = GCForeground; + for (i=0; i < *ncolors; i++) { + gcv.foreground = colors[i].pixel; + if (gcs[i]) XFreeGC (st->dpy, gcs[i]); + gcs[i] = XCreateGC (st->dpy, st->dbuf, flags, &gcv); + } + +} + +/* + * change_colors () + * + * perform the color changing bonus. New colors are allocated for the + * walls and bonuses, and if the 'psychedelic' option is set then new + * colors are also chosen for the ground. + */ +static void +change_colors (struct state *st) +{ + double s1, s2; + + if (st->psychedelic_flag) { + free_colors (st->screen, st->cmap, st->bonus_colors, st->nr_bonus_colors); + free_colors (st->screen, st->cmap, st->wall_colors, st->nr_wall_colors); + free_colors (st->screen, st->cmap, st->ground_colors, st->nr_ground_colors); + s1 = 0.4; s2 = 0.9; + + st->ncolors = MAX_COLORS; + speedmine_color_ramp (st, st->ground_gcs, st->ground_colors, + &st->ncolors, 0.0, 0.8, 0.0, 0.9); + st->nr_ground_colors = st->ncolors; + } else { + free_colors (st->screen, st->cmap, st->bonus_colors, st->nr_bonus_colors); + free_colors (st->screen, st->cmap, st->wall_colors, st->nr_wall_colors); + st->ncolors = st->nr_ground_colors; + + s1 = 0.0; s2 = 0.6; + } + + st->ncolors = MAX_COLORS; + speedmine_color_ramp (st, st->wall_gcs, st->wall_colors, &st->ncolors, + s1, s2, 0.0, 0.9); + st->nr_wall_colors = st->ncolors; + + st->ncolors = MAX_COLORS; + speedmine_color_ramp (st, st->bonus_gcs, st->bonus_colors, &st->ncolors, + 0.6, 0.9, 0.4, 1.0); + st->nr_bonus_colors = st->ncolors; +} + +/* + * init_psychedelic_colors (dpy, window, cmap) + * + * initialise a psychedelic colormap + */ +static void +init_psychedelic_colors (struct state *st) +{ + XGCValues gcv; + + gcv.foreground = get_pixel_resource (st->dpy, st->cmap, "tunnelend", "TunnelEnd"); + st->tunnelend_gc = XCreateGC (st->dpy, st->window, GCForeground, &gcv); + + st->ncolors = MAX_COLORS; + speedmine_color_ramp (st, st->ground_gcs, st->ground_colors, &st->ncolors, + 0.0, 0.8, 0.0, 0.9); + st->nr_ground_colors = st->ncolors; + + st->ncolors = MAX_COLORS; + speedmine_color_ramp (st, st->wall_gcs, st->wall_colors, &st->ncolors, + 0.0, 0.6, 0.0, 0.9); + st->nr_wall_colors = st->ncolors; + + st->ncolors = MAX_COLORS; + speedmine_color_ramp (st, st->bonus_gcs, st->bonus_colors, &st->ncolors, + 0.6, 0.9, 0.4, 1.0); + st->nr_bonus_colors = st->ncolors; +} + +/* + * init_colors (dpy, window, cmap) + * + * initialise a normal colormap + */ +static void +init_colors (struct state *st) +{ + XGCValues gcv; + XColor dark, light; + int h1, h2; + double s1, s2, v1, v2; + unsigned long flags; + int i; + + gcv.foreground = get_pixel_resource (st->dpy, st->cmap, "tunnelend", "TunnelEnd"); + st->tunnelend_gc = XCreateGC (st->dpy, st->window, GCForeground, &gcv); + + st->ncolors = MAX_COLORS; + + dark.pixel = get_pixel_resource (st->dpy, st->cmap, "darkground", "DarkGround"); + XQueryColor (st->dpy, st->cmap, &dark); + + light.pixel = get_pixel_resource (st->dpy, st->cmap, "lightground", "LightGround"); + XQueryColor (st->dpy, st->cmap, &light); + + rgb_to_hsv (dark.red, dark.green, dark.blue, &h1, &s1, &v1); + rgb_to_hsv (light.red, light.green, light.blue, &h2, &s2, &v2); + make_color_ramp (st->screen, st->visual, st->cmap, + h1, s1, v1, h2, s2, v2, + st->ground_colors, &st->ncolors, False, True, False); + st->nr_ground_colors = st->ncolors; + + flags = GCForeground; + for (i=0; i < st->ncolors; i++) { + gcv.foreground = st->ground_colors[i].pixel; + st->ground_gcs[i] = XCreateGC (st->dpy, st->dbuf, flags, &gcv); + } + + st->ncolors = MAX_COLORS; + speedmine_color_ramp (st, st->wall_gcs, st->wall_colors, &st->ncolors, + 0.0, 0.6, 0.0, 0.9); + st->nr_wall_colors = st->ncolors; + + st->ncolors = MAX_COLORS; + speedmine_color_ramp (st, st->bonus_gcs, st->bonus_colors, &st->ncolors, + 0.6, 0.9, 0.4, 1.0); + st->nr_bonus_colors = st->ncolors; +} + +/* + * print_stats () + * + * print out average FPS stats for the demo + */ +#if 0 +static void +print_stats (struct state *st) +{ + if (st->total_nframes >= 1) + printf ("Rendered %d frames averaging %f FPS\n", st->total_nframes, + st->total_nframes / get_time(st)); +} +#endif + +/* + * init_speedmine (dpy, window) + * + * initialise the demo + */ +static void * +speedmine_init (Display *dpy, Window window) +{ + struct state *st = (struct state *) calloc (1, sizeof(*st)); + XGCValues gcv; + XWindowAttributes xgwa; + int i; + double th; + int wide; + + st->dpy = dpy; + st->window = window; + + st->speed = 1.1; + st->accel = 0.00000001; + st->direction = FORWARDS; + st->orientation = (17*ROTS)/22; + + XGetWindowAttributes (st->dpy, st->window, &xgwa); + st->cmap = xgwa.colormap; + st->visual = xgwa.visual; + st->screen = xgwa.screen; + st->width = xgwa.width; + st->height = xgwa.height; + + st->verbose_flag = get_boolean_resource (st->dpy, "verbose", "Boolean"); + +# ifdef HAVE_JWXYZ /* Don't second-guess Quartz's double-buffering */ + st->dbuf = st->window; +#else + st->dbuf = XCreatePixmap (st->dpy, st->window, st->width, st->height, xgwa.depth); +#endif + st->stars_mask = XCreatePixmap (st->dpy, st->window, st->width, st->height, 1); + + gcv.foreground = st->default_fg_pixel = + get_pixel_resource (st->dpy, st->cmap, "foreground", "Foreground"); + st->draw_gc = XCreateGC (st->dpy, st->window, GCForeground, &gcv); + gcv.foreground = 1; + st->stars_gc = XCreateGC (st->dpy, st->stars_mask, GCForeground, &gcv); + + gcv.foreground = get_pixel_resource (st->dpy, st->cmap, "background", "Background"); + st->erase_gc = XCreateGC (st->dpy, st->dbuf, GCForeground, &gcv); + gcv.foreground = 0; + st->stars_erase_gc = XCreateGC (st->dpy, st->stars_mask, GCForeground, &gcv); + + st->wire_flag = get_boolean_resource (st->dpy, "wire", "Boolean"); + + st->psychedelic_flag = get_boolean_resource (st->dpy, "psychedelic", "Boolean"); + + st->delay = get_integer_resource(st->dpy, "delay", "Integer"); + + st->smoothness = get_integer_resource(st->dpy, "smoothness", "Integer"); + if (st->smoothness < 1) st->smoothness = 1; + + st->maxspeed = get_float_resource(st->dpy, "maxspeed", "Float"); + st->maxspeed *= 0.01; + st->maxspeed = fabs(st->maxspeed); + + st->thrust = get_float_resource(st->dpy, "thrust", "Float"); + st->thrust *= 0.2; + + st->gravity = get_float_resource(st->dpy, "gravity", "Float"); + st->gravity *= 0.002/9.8; + + st->vertigo = get_float_resource(st->dpy, "vertigo", "Float"); + st->vertigo *= 0.2; + + st->curviness = get_float_resource(st->dpy, "curviness", "Float"); + st->curviness *= 0.25; + + st->twistiness = get_float_resource(st->dpy, "twistiness", "Float"); + st->twistiness *= 0.125; + + st->terrain_flag = get_boolean_resource (st->dpy, "terrain", "Boolean"); + st->widening_flag = get_boolean_resource (st->dpy, "widening", "Boolean"); + st->bumps_flag = get_boolean_resource (st->dpy, "bumps", "Boolean"); + st->bonuses_flag = get_boolean_resource (st->dpy, "bonuses", "Boolean"); + st->crosshair_flag = get_boolean_resource (st->dpy, "crosshair", "Boolean"); + + st->be_wormy = get_boolean_resource (st->dpy, "worm", "Boolean"); + if (st->be_wormy) { + st->maxspeed *= 1.43; + st->thrust *= 10; + st->gravity *= 3; + st->vertigo *= 0.5; + st->smoothness *= 2; + st->curviness *= 2; + st->twistiness *= 2; + st->psychedelic_flag = True; + st->crosshair_flag = False; + } + + if (st->psychedelic_flag) init_psychedelic_colors (st); + else init_colors (st); + + for (i=0; i<ROTS; i++) { + th = M_PI * 2.0 * i / ROTS; + st->costab[i] = cos(th); + st->sintab[i] = sin(th); + } + + wide = random_wideness(); + + for (i=0; i < TERRAIN_LENGTH; i++) { + st->wideness[i] = wide; + st->bonuses[i] = 0; + } + + init_terrain (st); + init_curves (st); + wrap_tunnel (st, 0, TERRAIN_LENGTH-1); + +#if 0 + if (DEBUG_FLAG || st->verbose_flag) atexit(print_stats); +#endif + + st->step = effective_speed; + + init_time (st); + + return st; +} + + +static void +speedmine_reshape (Display *dpy, Window window, void *closure, + unsigned int w, unsigned int h) +{ + struct state *st = (struct state *) closure; + st->width = w; + st->height = h; + if (st->dbuf != st->window) { + XWindowAttributes xgwa; + XGetWindowAttributes (st->dpy, st->window, &xgwa); + XFreePixmap (dpy, st->dbuf); + st->dbuf = XCreatePixmap (st->dpy, st->window, + st->width, st->height, xgwa.depth); + } +} + +static Bool +speedmine_event (Display *dpy, Window window, void *closure, XEvent *event) +{ + return False; +} + +static void +speedmine_free (Display *dpy, Window window, void *closure) +{ + struct state *st = (struct state *) closure; + free (st); +} + + + +/* + * Down the speedmine, you'll find speed + * to satisfy your moving needs; + * So if you're looking for a blast + * then hit the speedmine, really fast. + */ + +/* + * Speedworm likes to choke and spit + * and chase his tail, and dance a bit + * he really is a funky friend; + * he's made of speed from end to end. + */ + + +static const char *speedmine_defaults [] = { + ".verbose: False", + "*worm: False", + "*wire: False", + ".background: black", + ".foreground: white", + "*darkground: #101010", + "*lightground: #a0a0a0", + "*tunnelend: #000000", + "*delay: 30000", + "*maxspeed: 700", + "*thrust: 1.0", + "*gravity: 9.8", + "*vertigo: 1.0", + "*terrain: True", + "*smoothness: 6", + "*curviness: 1.0", + "*twistiness: 1.0", + "*widening: True", + "*bumps: True", + "*bonuses: True", + "*crosshair: True", + "*psychedelic: False", + 0 +}; + +static XrmOptionDescRec speedmine_options [] = { + { "-verbose", ".verbose", XrmoptionNoArg, "True"}, + { "-worm", ".worm", XrmoptionNoArg, "True"}, + { "-wireframe", ".wire", XrmoptionNoArg, "True"}, + { "-no-wireframe", ".wire", XrmoptionNoArg, "False"}, + { "-darkground", ".darkground", XrmoptionSepArg, 0 }, + { "-lightground", ".lightground", XrmoptionSepArg, 0 }, + { "-tunnelend", ".tunnelend", XrmoptionSepArg, 0 }, + { "-delay", ".delay", XrmoptionSepArg, 0 }, + { "-maxspeed", ".maxspeed", XrmoptionSepArg, 0 }, + { "-thrust", ".thrust", XrmoptionSepArg, 0 }, + { "-gravity", ".gravity", XrmoptionSepArg, 0 }, + { "-vertigo", ".vertigo", XrmoptionSepArg, 0 }, + { "-terrain", ".terrain", XrmoptionNoArg, "True"}, + { "-no-terrain", ".terrain", XrmoptionNoArg, "False"}, + { "-smoothness", ".smoothness", XrmoptionSepArg, 0 }, + { "-curviness", ".curviness", XrmoptionSepArg, 0 }, + { "-twistiness", ".twistiness", XrmoptionSepArg, 0 }, + { "-widening", ".widening", XrmoptionNoArg, "True"}, + { "-no-widening", ".widening", XrmoptionNoArg, "False"}, + { "-bumps", ".bumps", XrmoptionNoArg, "True"}, + { "-no-bumps", ".bumps", XrmoptionNoArg, "False"}, + { "-bonuses", ".bonuses", XrmoptionNoArg, "True"}, + { "-no-bonuses", ".bonuses", XrmoptionNoArg, "False"}, + { "-crosshair", ".crosshair", XrmoptionNoArg, "True"}, + { "-no-crosshair", ".crosshair", XrmoptionNoArg, "False"}, + { "-psychedelic", ".psychedelic", XrmoptionNoArg, "True"}, + { "-no-psychedelic", ".psychedelic", XrmoptionNoArg, "False"}, + { 0, 0, 0, 0 } +}; + + +XSCREENSAVER_MODULE ("SpeedMine", speedmine) + +/* vim: ts=4 + */ |