--- /dev/null
+/* -*- Mode: C; tab-width: 4 -*- */
+/* juggle */
+
+#if !defined( lint ) && !defined( SABER )
+static const char sccsid[] = "@(#)juggle.c 5.00 2000/11/01 xlockmore";
+
+#endif
+
+/*-
+ * Copyright (c) 1996 by Tim Auckland <Tim.Auckland@Procket.com>
+ *
+ * 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
+ * 01-Nov-2000: Allocation checks
+ * 1996: Written
+ */
+
+/*-
+ * TODO
+ * Fix timing to run at approx same speed on all machines.
+ * Store shorter pattern and refill when required.
+ * Use -cycles and -count in a rational manner.
+ * Merge pattern selector with pattern generator.
+ * Add clubs
+ * Clap when all the balls are in the air
+ */
+
+
+/*-
+Notes on Adam Chalcraft Juggling Notation (used by permission)
+a-> Adam's notation s-> Site swap (Cambridge) notation
+
+To define a map from a-notation to s-notation
+("site-swap"), both of which look like doubly infinite sequences of natural
+numbers. In s-notation, there is a restriction on what is allowed, namely
+for the sequence s_n, the associated function f(n)=n+s_n must be a
+bijection. In a-notation, there is no restriction.
+
+To go from a-notation to s-notation, you start by mapping each a_n to a
+permutation of N, the natural numbers.
+
+0 -> the identity
+1 -> (10) [i.e. f(1)=0, f(0)=1]
+2 -> (210) [i.e. f(2)=1, f(1)=0, f(0)=2]
+3 -> (3210) [i.e. f(3)=2, f(2)=1, f(1)=0, f(0)=3]
+etc.
+
+Then for each n, you look at how long 0 takes to get back to 0 again and
+you call this t_n. If a_n=0, for example, then since the identity leaves 0
+alone, it gets back to 0 in 1 step, so t_n=1. If a_n=1, then f(0)=1. Now any
+further a_n=0 leave 1 alone, but the next a_n>0 sends 1 back to 0. Hence t_n
+is 2 + the number of 0's following the 1. Finally, set s_n = t_n - 1.
+
+To give some examples, it helps to have a notation for cyclic sequences. By
+(123), for example, I mean ...123123123123... . Now under the a-notation ->
+s-notation mapping we have some familiar examples:
+
+(0)->(0), (1)->(1), (2)->(2) etc.
+(21)->(31), (31)->(51), (41)->(71) etc.
+(10)->(20), (20)->(40), (30)->(60) etc.
+(331)->(441), (312)->(612), (303)->(504), (321)->(531)
+(43)->(53), (434)->(534), (433)->(633)
+(552)->(672)
+
+In general, the number of balls is the *average* of the s-notation, and the
+*maximum* of the a-notation. Another theorem is that the minimum values in
+the a-notation and the s-notation and equal, and preserved in the same
+positions.
+
+The usefulness of a-notation is the fact that there are no restrictions on
+what is allowed. This makes random juggle generation much easier. It also
+makes enumeration very easy. Another handy feature is computing changes.
+Suppose you can do (5) and want a neat change up to (771) in s-notation
+[Mike Day actually needed this example!]. Write them both in a-notation,
+which gives (5) and (551). Now concatenate them (in general, there may be
+more than one way to do this, but not in this example), to get
+...55555555551551551551551...
+Now convert back to s-notation, to get
+...55555566771771771771771...
+So the answer is to do two 6 throws and then go straight into (771).
+Coming back down of course,
+...5515515515515515555555555...
+converts to
+...7717717717716615555555555...
+so the answer is to do a single 661 and then drop straight down to (5).
+
+[The number of balls in the generated pattern occasionally changes. In
+ order to decrease the number of balls I had to introduce a new symbol
+ into the Adam notation, [*] which means 'lose the current ball'.]
+*/
+
+#define STANDALONE
+#ifdef STANDALONE
+#define MODE_juggle
+#define PROGCLASS "Juggle"
+#define HACK_INIT init_juggle
+#define HACK_DRAW draw_juggle
+#define juggle_opts xlockmore_opts
+#define DEFAULTS "*delay: 10000 \n" \
+"*count: 150 \n" \
+"*cycles: 30 \n" \
+"*ncolors: 32 \n"
+#define SMOOTH_COLORS
+#include "xlockmore.h" /* in xscreensaver distribution */
+#else /* STANDALONE */
+#include "xlock.h" /* in xlockmore distribution */
+#endif /* STANDALONE */
+
+#ifdef MODE_juggle
+
+#define DEF_PATTERN "." /* All patterns */
+#define DEF_TRAIL "0" /* No trace */
+#ifdef UNI
+#define DEF_UNI "FALSE" /* No unicycle */ /* Not implemented yet */
+#endif
+#define DEF_SOLID "FALSE" /* Not solid */
+
+static char *pattern;
+static int trail;
+#ifdef UNI
+static Bool uni;
+#endif
+static Bool solid;
+
+static XrmOptionDescRec opts[] =
+{
+ {(char* ) "-pattern", (char *) ".juggle.pattern",
+ XrmoptionSepArg, (caddr_t) NULL},
+ {(char* ) "-trail", (char *) ".juggle.trail",
+ XrmoptionSepArg, (caddr_t) NULL},
+#ifdef UNI
+ {(char *) "-uni", (char *) ".juggle.uni", XrmoptionNoArg, (caddr_t) "on"},
+ {(char *) "+uni", (char *) ".juggle.uni", XrmoptionNoArg, (caddr_t) "off"},
+#endif
+ {(char *) "-solid", (char *) ".juggle.solid", XrmoptionNoArg, (caddr_t) "on"},
+ {(char *) "+solid", (char *) ".juggle.solid", XrmoptionNoArg, (caddr_t) "off"}
+};
+static argtype vars[] =
+{
+ {(caddr_t *) &pattern, (char *) "pattern",
+ (char *) "Pattern", (char *) DEF_PATTERN, t_String},
+ {(caddr_t *) &trail, (char *) "trail",
+ (char *) "Trail", (char *) DEF_TRAIL, t_Int},
+#ifdef UNI
+ {(caddr_t *) &uni, (char *) "uni",
+ (char *) "Uni", (char *) DEF_UNI, t_Bool},
+#endif
+ {(caddr_t *) &solid, (char *) "solid",
+ (char *) "Solid", (char *) DEF_SOLID, t_Bool}
+};
+static OptionStruct desc[] =
+{
+ {(char *) "-pattern string", (char *) "Cambridge Juggling Pattern"},
+ {(char *) "-trail num", (char *) "Trace Juggling Patterns"},
+#ifdef UNI
+ {(char *) "-/+uni", (char *) "Unicycle"},
+#endif
+ {(char *) "-/+solid", (char *) "solid color (else its a 4 panel look (half white))"}
+};
+
+ModeSpecOpt juggle_opts =
+{sizeof opts / sizeof opts[0], opts,
+ sizeof vars / sizeof vars[0], vars, desc};
+
+#ifdef USE_MODULES
+ModStruct juggle_description = {
+ "juggle", "init_juggle", "draw_juggle", "release_juggle",
+ "draw_juggle", "init_juggle", (char *) NULL, &juggle_opts,
+ 10000, 150, 30, 1, 64, 1.0, "",
+ "Shows a Juggler, juggling", 0, NULL
+};
+
+#endif
+
+#ifdef USE_XVMSUTILS
+#include <X11/unix_time.h>
+#endif
+#include <time.h>
+#if HAVE_SYS_TIME_H
+#include <sys/time.h>
+#else
+#if HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+#endif
+
+/* Figure */
+#define ARMLENGTH ((int) (40.0 * sp->scale))
+#define ARMWIDTH ((int) (8.0 * sqrt(sp->scale)))
+#define POSE ((int) (10.0 * sp->scale))
+#define SX ((int) (25.0 * sp->scale))
+#define SZ ((int) (25.0 * sp->scale))
+#define SY ((int) (25.0 * sp->scale))
+#define HIPY ((int) (85.0 * sp->scale))
+#define RHIPX ((int) (-15.0 * sp->scale))
+#define LHIPX ((int) (15.0 * sp->scale))
+#define RFX ((int) (-25.0 * sp->scale))
+#define LFX ((int) (25.0 * sp->scale))
+#define FY ((int) (155.0 * sp->scale))
+#define WSTY ((int) (65.0 * sp->scale))
+#define NEY ((int) (15.0 * sp->scale))
+#define HED ((int) (35.0 * sp->scale))
+#define BALLRADIUS ARMWIDTH
+#define FIGURE1 7
+#define FIGURE2 3
+#define TRACE_LENGTH 50
+#define SPIN_DEGREES 750 /* Average spinning between a throw and the next catch */
+
+/* macros */
+
+#ifndef XtNumber
+#define XtNumber(arr) ((unsigned int) (sizeof(arr) / sizeof(arr[0])))
+#endif
+
+#define GRAVITY(h, t) 4*(double)(h)/((t)*(t))
+
+#define THROW_CATCH_INTERVAL (sp->count)
+#define THROW_NULL_INTERVAL (sp->count * 0.5)
+#define CATCH_THROW_INTERVAL (sp->count * 0.2)
+#define COR 0.8 /* coeff of restitution of balls (1 = perfect bounce) */
+
+
+/* typedefs */
+
+typedef enum {HEIGHT, ADAM} Notation;
+typedef enum {Empty, Full, Ball} Throwable;
+typedef enum {LEFT, RIGHT} Hand;
+typedef enum {THROW, CATCH} Action; /* DROP is not an option */
+typedef enum {ATCH, THRATCH, ACTION, LINKEDACTION, PTHRATCH, BPREDICTOR,
+ PREDICTOR} TrajectoryStatus;
+
+typedef struct trajectory *TrajectoryPtr;
+
+typedef struct {double a, b, c, d; } Spline;
+
+typedef struct trajectory {
+ TrajectoryPtr prev, next; /* for building list */
+ TrajectoryStatus status;
+
+ /* Throw */
+ char posn;
+ int height;
+ int adam;
+
+ /* Action */
+ Hand hand;
+ Action action;
+
+ /* LinkedAction */
+ int color;
+ int spin, divisions;
+ double degree_offset;
+ TrajectoryPtr balllink;
+ TrajectoryPtr handlink;
+
+ /* PThratch */
+
+ double dx; /* initial velocity */
+ double dy;
+
+ /* Predictor */
+ Throwable type;
+ int start, finish;
+ Spline xp, yp;
+ int x, y; /* current position */
+} Trajectory;
+
+/* structs */
+
+typedef struct {
+ int width;
+ int height;
+ double scale;
+ int complexity;
+ int cx;
+ int cy;
+ double Gr;
+ int pattern;
+ Trajectory *head;
+ XPoint figure_path[FIGURE1];
+ XSegment figure_segs[FIGURE2];
+ XPoint arm[2][3];
+ XPoint *trace;
+ int traceindex;
+ int count;
+ time_t begintime; /* seconds */
+ int time; /* millisecond timer */
+ Bool solid, uni;
+} jugglestruct;
+
+static jugglestruct *juggles = (jugglestruct *) NULL;
+
+typedef struct {
+ char * pattern;
+ char * name;
+} patternstruct;
+
+#define MINBALLS 2
+#define MAXBALLS 7
+
+typedef struct {
+ int start;
+ int number;
+} PatternIndex;
+
+static PatternIndex* patternindex = (PatternIndex *) NULL;
+
+/* List of popular patterns, in any order */
+static patternstruct portfolio[] = {
+ {(char *) "[+2 1]", (char *) "+3 1, Typical 2 ball juggler"},
+ {(char *) "[2 0]", (char *) "4 0, 2 balls 1 hand"},
+ {(char *) "[2 0 1]", (char *) "5 0 1"},
+ {(char *) "[+2 0 +2 0 0]", (char *) "+5 0 +5 0 0"},
+ {(char *) "[3]", (char *) "3, cascade"},
+ {(char *) "[+3]", (char *) "+3, reverse cascade"},
+ {(char *) "[=3]", (char *) "=3, cascade under arm"},
+ {(char *) "[&3]", (char *) "&3, cascade catching under arm"},
+ {(char *) "[_3]", (char *) "_3, bouncing cascade"},
+ {(char *) "[+3 x3 =3]", (char *) "+3 x3 =3, Mill's mess"},
+ {(char *) "[3 2 1]", (char *) "5 3 1"},
+ {(char *) "[3 3 1]", (char *) "4 4 1"},
+ {(char *) "[3 1 2]", (char *) "6 1 2, See-saw"},
+ {(char *) "[=3 3 1 2]", (char *) "=4 5 1 2"},
+ {(char *) "[=3 2 2 3 1 2]", (char *) "=6 2 2 5 1 2, =4 5 1 2 stretched"},
+ {(char *) "[+3 3 1 3]", (char *) "+4 4 1 3, anemic shower box"},
+ {(char *) "[3 3 1]", (char *) "4 4 1"},
+ {(char *) "[+3 2 3]", (char *) "+4 2 3"},
+ {(char *) "[+3 1]", (char *) "+5 1, 3 shower"},
+ {(char *) "[_3 1]", (char *) "_5 1, bouncing 3 shower"},
+ {(char *) "[3 0 3 0 3]", (char *) "5 0 5 0 5, shake 3 out of 5"},
+ {(char *) "[3 3 3 0 0]", (char *) "5 5 5 0 0, flash 3 out of 5"},
+ {(char *) "[3 3 0]", (char *) "4 5 0, complete waste of a 5 ball juggler"},
+ {(char *) "[3 3 3 0 0 0 0]", (char *) "7 7 7 0 0 0 0, 3 flash"},
+ {(char *) "[+3 0 +3 0 +3 0 0]", (char *) "+7 0 +7 0 +7 0 0"},
+ {(char *) "[4]", (char *) "4, 4 cascade"},
+ {(char *) "[+4 3]", (char *) "+5 3, 4 ball half shower"},
+ {(char *) "[4 4 2]", (char *) "5 5 2"},
+ {(char *) "[+4 4 4 +4]", (char *) "+4 4 4 +4, 4 columns"},
+ {(char *) "[4 3 +4]", (char *) "5 3 +4"},
+ {(char *) "[+4 1]", (char *) "+7 1, 4 shower"},
+ {(char *) "[4 4 4 4 0]", (char *) "5 5 5 5 0, learning 5"},
+ {(char *) "[5]", (char *) "5, 5 cascade"},
+ {(char *) "[_5 _5 _5 _5 _5 5 5 5 5 5]", (char *) "_5 _5 _5 _5 _5 5 5 5 5 5, jump rope"},
+ {(char *) "[+5 x5 =5]", (char *) "+5 x5 =5, Mill's mess for 5"},
+ {(char *) "[6]", (char *) "6, 6 cascade"},
+ {(char *) "[7]", (char *) "7, 7 cascade"},
+ {(char *) "[_7]", (char *) "_7, bouncing 7 cascade"},
+};
+
+/* Private Functions */
+
+/* list management */
+
+/* t receives trajectory to be created. ot must point to an existing
+ trajectory or be identical to t to start a new list. */
+#define INSERT_AFTER_TOP(t, ot) \
+ if ((t = (Trajectory *)calloc(1, sizeof(Trajectory))) == NULL) \
+ {free_juggle(sp); return;} \
+ (t)->next = (ot)->next; \
+ (t)->prev = (ot); \
+ (ot)->next = (t); \
+ (t)->next->prev = (t)
+#define INSERT_AFTER(t, ot) \
+ if ((t = (Trajectory *)calloc(1, sizeof(Trajectory))) == NULL) \
+ {free_juggle(sp); return False;} \
+ (t)->next = (ot)->next; \
+ (t)->prev = (ot); \
+ (ot)->next = (t); \
+ (t)->next->prev = (t)
+
+
+/* t must point to an existing trajectory. t must not be an
+ expression ending ->next or ->prev */
+#define REMOVE(t) \
+ (t)->next->prev = (t)->prev; \
+ (t)->prev->next = (t)->next; \
+ (void) free((void *) t)
+
+static void
+free_pattern(jugglestruct *sp) {
+ if (sp->head != NULL) {
+ while (sp->head->next != sp->head) {
+ Trajectory *t = sp->head->next;
+
+ REMOVE(t); /* don't eliminate t */
+ }
+ (void) free((void *) sp->head);
+ sp->head = (Trajectory *) NULL;
+ }
+}
+
+static void
+free_juggle(jugglestruct *sp)
+{
+ if (sp->trace != NULL) {
+ (void) free((void *) sp->trace);
+ sp->trace = (XPoint *) NULL;
+ }
+ free_pattern(sp);
+}
+
+static Bool
+add_throw(jugglestruct *sp, char type, int h, Notation n)
+{
+ Trajectory *t;
+
+ INSERT_AFTER(t, sp->head->prev);
+ t->posn = type;
+ if (n == ADAM) {
+ t->adam = h;
+ t->status = ATCH;
+ } else {
+ t->height = h;
+ t->status = THRATCH;
+ }
+ return True;
+}
+
+/* add a Thratch to the performance */
+static Bool
+program(ModeInfo *mi, const char *patn, int repeat)
+{
+ jugglestruct *sp = &juggles[MI_SCREEN(mi)];
+ const char *p;
+ int h, i, seen;
+ Notation notation;
+ char type;
+
+ if (MI_IS_VERBOSE(mi)) {
+ (void) fprintf(stderr, "%s x %d\n", patn, repeat);
+ }
+
+ for(i=0; i < repeat; i++) {
+ type=' ';
+ h = 0;
+ seen = 0;
+ notation = HEIGHT;
+ for(p=patn; *p; p++) {
+ if (*p >= '0' && *p <='9') {
+ seen = 1;
+ h = 10*h + (*p - '0');
+ } else {
+ Notation nn = notation;
+ switch (*p) {
+ case '[': /* begin Adam notation */
+ notation = ADAM;
+ break;
+ case '-': /* Inside throw */
+ case '+': /* Outside throw */
+ case '=': /* Cross throw */
+ case '&': /* Cross catch */
+ case 'x': /* Cross throw and catch */
+ case '_': /* Bounce */
+ type = *p;
+ break;
+ case '*': /* Lose ball */
+ seen = 1;
+ h = -1;
+ /* fall through */
+ case ']': /* end Adam notation */
+ nn = HEIGHT;
+ /* fall through */
+ case ' ':
+ if (seen) {
+ if (!add_throw(sp, type, h, notation))
+ return False;
+ type=' ';
+ h = 0;
+ seen = 0;
+ }
+ notation = nn;
+ break;
+ default:
+ (void) fprintf(stderr, "Unexpected pattern instruction: '%s'\n", p);
+ break;
+ }
+ }
+ }
+ if (seen) {
+ if (!add_throw(sp, type, h, notation))
+ return False;
+ }
+ }
+ return True;
+}
+
+/*
+ ~~~~\~~~~~\~~~
+ \\~\\~\~\\\~~~
+ \\~\\\\~\\\~\~
+ \\\\\\\\\\\~\\
+
+[33134231334021]
+
+4 4 1 3 12 2 4 1 4 4 13 0 3 1
+
+*/
+#define BOUNCEOVER 10
+
+static void
+adam(jugglestruct *sp)
+{
+ Trajectory *t, *p;
+ for(t = sp->head->next; t != sp->head; t = t->next) {
+ if (t->status == ATCH) {
+ int a = t->adam;
+ t->height = 0;
+ for(p = t->next; a > 0 && p != sp->head; p = p->next) {
+ if (p->status != ATCH || p->adam < 0 || p->adam>= a) {
+ a--;
+ }
+ t->height++;
+ }
+ if(t->height > BOUNCEOVER && t->posn == ' '){
+ t->posn = '_'; /* high defaults can be bounced */
+ }
+ t->status = THRATCH;
+#if 0
+ (void) fprintf(stderr, "%d\t%d\n", t->adam, t->height);
+#endif
+ }
+ }
+}
+
+/* Split Thratch notation into explicit throws and catches.
+ Usually Catch follows Throw in same hand, but take care of special
+ cases. */
+
+/* ..n1.. -> .. LTn RT1 LC RC .. */
+/* ..nm.. -> .. LTn LC RTm RC .. */
+
+static Bool
+part(jugglestruct *sp)
+{
+ Trajectory *t, *nt, *p;
+ Hand hand = (LRAND() & 1) ? RIGHT : LEFT;
+
+ for (t = sp->head->next; t != sp->head; t = t->next) {
+ if (t->status > THRATCH) {
+ hand = t->hand;
+ } else if (t->status == THRATCH) {
+ char posn = '=';
+
+ /* plausibility check */
+ if (t->height <= 2 && t->posn == '_') {
+ t->posn = ' '; /* no short bounces */
+ }
+ if (t->height <= 1 && (t->posn == '=' || t->posn == '&')) {
+ t->posn = ' '; /* 1's need close catches */
+ }
+
+ switch (t->posn) {
+ /* throw catch */
+ case ' ': /* fall through */
+ case '-': posn = '-'; t->posn = '+'; break;
+ case '+': posn = '+'; t->posn = '-'; break;
+ case '=': posn = '='; t->posn = '+'; break;
+ case '&': posn = '+'; t->posn = '='; break;
+ case 'x': posn = '='; t->posn = '='; break;
+ case '_': posn = '_'; t->posn = '-'; break;
+ default: (void) fprintf(stderr, "unexpected posn %c\n", t->posn); break;
+ }
+ hand = (Hand) ((hand + 1) % 2);
+ t->status = ACTION;
+ t->hand = hand;
+ p = t->prev;
+
+ if (t->height == 1) {
+ p = p->prev; /* early throw */
+ }
+ t->action = CATCH;
+ INSERT_AFTER(nt, p);
+ nt->status = ACTION;
+ nt->action = THROW;
+ nt->height = t->height;
+ nt->hand = hand;
+ nt->posn = posn;
+ }
+ }
+ return True;
+}
+
+/* Connnect up throws and catches to figure out which ball goes where.
+ Do the same with the juggler's hands. */
+
+static void
+lob(ModeInfo *mi)
+{
+ jugglestruct *sp = &juggles[MI_SCREEN(mi)];
+ Trajectory *t, *p;
+ int h;
+ for (t = sp->head->next; t != sp->head; t = t->next) {
+ if (t->status == ACTION) {
+#if 0
+ (void) fprintf(stderr, (t->action == CATCH) ? "A %c%c%c\n" : "A %c%c%c%d\n",
+ t->posn,
+ t->hand ? 'R' : 'L',
+ (t->action == THROW) ? 'T' : (t->action == CATCH ? 'C' : 'N'),
+ t->height);
+#endif
+ if (t->action == THROW) {
+ if (t->type == Empty) {
+ if (MI_NPIXELS(mi) > 2) {
+ t->color = 1 + NRAND(MI_NPIXELS(mi) - 2);
+ }
+ t->spin = NRAND(5) - 2;
+ t->degree_offset = NRAND(360);
+ t->divisions = 2 * ((LRAND() & 1) + 1);
+ }
+
+ /* search forward for next hand catch */
+ for (p = t->next; t->handlink == NULL && p != sp->head; p = p->next) {
+ if (p->action == CATCH) {
+ if (t->handlink == NULL && p->hand == t->hand) {
+ t->handlink = p; /* next catch in this hand */
+ }
+ }
+ }
+
+ if (t->height > 0) {
+ h = t->height - 1;
+
+ /* search forward for next ball catch */
+ for (p = t->next; t->balllink == NULL&& p != sp->head; p = p->next) {
+ if (p->action == CATCH) {
+ if (t->balllink == NULL && --h < 1) { /* caught */
+#if 0
+ if (p->type == Full) {
+ /* dropped */
+ }
+#endif
+ t->balllink = p; /* complete trajectory */
+ p->type = Full;
+ p->color = t->color; /* accept catch */
+ p->spin = t->spin;
+ p->degree_offset = t->degree_offset;
+ p->divisions = t->divisions;
+ }
+ }
+ }
+ }
+ t->type = Empty; /* thrown */
+ } else if (t->action == CATCH) {
+ /* search forward for next throw from this hand */
+ for (p = t->next; t->handlink == NULL && p != sp->head; p = p->next) {
+ if (p->action == THROW && p->hand == t->hand) {
+ p->type = t->type; /* pass ball */
+ p->color = t->color; /* pass color */
+ p->spin = NRAND(5) - 2;
+ p->degree_offset = NRAND(360);
+ p->divisions = 2 * ((LRAND() & 1) + 1);
+ t->handlink = p;
+ }
+ }
+ }
+ t->status = LINKEDACTION;
+ }
+ }
+}
+
+/* Convert hand position symbols into actual time/space coordinates */
+static void
+positions(jugglestruct *sp)
+{
+ Trajectory *t;
+ int now = 0;
+ for (t = sp->head->next; t != sp->head; t = t->next) {
+ if (t->status == PTHRATCH) {
+ now = t->start;
+ } else if (t->status == LINKEDACTION) {
+ int xo = 0, yo;
+
+ /* time */
+ if (t->action == CATCH) {
+ if (t->type == Empty) {
+ now += (int) THROW_NULL_INTERVAL; /* failed catch is short */
+ } else {
+ now += THROW_CATCH_INTERVAL; /* successful catch */
+ }
+ } else {
+ now += (int) CATCH_THROW_INTERVAL; /* throws are very short */
+ }
+ t->start = now;
+
+ /* space */
+ yo = ARMLENGTH;
+ switch (t->posn) {
+ case '-': xo = SX - POSE; break;
+ case '_':
+ case '+': xo = SX + POSE; break;
+ case '=': xo = - SX - POSE; yo += 2 * POSE; break;
+ default: (void) fprintf(stderr, "unexpected posn %c\n", t->posn); break;
+ }
+ t->x = sp->cx + ((t->hand == LEFT) ? xo : -xo);
+ t->y = sp->cy + yo;
+
+ t->status = PTHRATCH;
+ }
+ }
+}
+
+
+/* Private physics functions */
+
+static Spline
+makeSpline(int x0, double dx0, int t0, int x1, double dx1, int t1)
+{
+ Spline s;
+ double a, b, c, d;
+ int x10;
+ double t10;
+
+ x10 = x1 - x0;
+ t10 = t1 - t0;
+ a = ((dx0 + dx1)*t10 - 2*x10) / (t10*t10*t10);
+ b = (3*x10 - (2*dx0 + dx1)*t10) / (t10*t10);
+ c = dx0;
+ d = x0;
+ s.a = a;
+ s.b = -3*a*t0 + b;
+ s.c = (3*a*t0 - 2*b)*t0 + c;
+ s.d = ((-a*t0 + b)*t0 - c)*t0 +d;
+ return s;
+}
+
+static double
+makeSplinePair(Spline *s1, Spline *s2,
+ int x0, double dx0, int t0,
+ int x1, int t1,
+ int x2, double dx2, int t2)
+{
+ int x10, x21;
+ double t21, t10, t20, dx1;
+ x10 = x1 - x0;
+ x21 = x2 - x1;
+ t21 = t2 - t1;
+ t10 = t1 - t0;
+ t20 = t2 - t0;
+ dx1 = (3*x10*t21*t21 + 3*x21*t10*t10 + 3*dx0*t10*t21*t21
+ - dx2*t10*t10*t21 - 4*dx0*t10*t21*t21) /
+ (2*t10*t21*t20);
+ *s1 = makeSpline(x0, dx0, t0, x1, dx1, t1);
+ *s2 = makeSpline(x1, dx1, t1, x2, dx2, t2);
+ return dx1;
+}
+
+/* Turn abstract timings into physically appropriate ball trajectories. */
+static Bool
+projectile(jugglestruct *sp)
+{
+ Trajectory *t, *n;
+ for (t = sp->head->next; t != sp->head; t = t->next) {
+ if (t->status != PTHRATCH) {
+ continue;
+ }
+ if (t->action == THROW) {
+ if (t->balllink != NULL) {
+ if (t->posn == '_') { /* Bounce once */
+ double tc, y0, yf, yc, tb, e, i;
+
+ tc = t->balllink->start - t->start;
+
+ yf = sp->cy + FY;
+ y0 = t->y;
+ yc = t->balllink->y;
+ e = 1; /* permissible error in yc */
+
+ /*
+ tb = time to bounce
+ yt = height at catch time after one bounce
+ one or three roots according to timing
+ find one by interval bisection
+ */
+ tb = tc;
+ for(i = tc / 2; i > 0; i/=2){
+ double dy, dt, yt;
+ if(tb == 0){
+ (void) fprintf(stderr, "div by zero!\n");
+ break;
+ }
+ dy = (yf - y0)/tb + 0.5*sp->Gr*tb;
+ dt = tc - tb;
+ yt = -COR*dy*dt + 0.5*sp->Gr*dt*dt + yf;
+ if(yt > yc + e){
+ tb-=i;
+ }else if(yt < yc - e){
+ tb+=i;
+ }else{
+ break;
+ }
+ }
+
+ {
+ double t0, dy;
+
+ t->dx = (t->balllink->x - t->x) / tc;
+
+ /* ball follows parabola down */
+ INSERT_AFTER(n, t->prev);
+ n->start = t->start;
+ n->finish = (int) (t->start + tb);
+ n->type = Ball;
+ n->color = t->color;
+ n->spin = t->spin;
+ n->degree_offset = t->degree_offset;
+ n->divisions = t->divisions;
+ n->status = PREDICTOR;
+
+ t->dy = (yf - y0)/tb - 0.5*sp->Gr*tb;
+ t0 = n->start;
+ /* Represent parabola as a degenerate spline -
+ linear in x, quadratic in y */
+ n->xp.a = 0;
+ n->xp.b = 0;
+ n->xp.c = t->dx;
+ n->xp.d = -t->dx*t0 + t->x;
+ n->yp.a = 0;
+ n->yp.b = sp->Gr/2;
+ n->yp.c = -sp->Gr*t0 + t->dy;
+ n->yp.d = sp->Gr/2*t0*t0 - t->dy*t0 + t->y;
+
+
+ /* ball follows parabola up */
+ INSERT_AFTER(n, t->prev);
+ n->start = (int) (t0 + tb);
+ n->finish = (int) (t0 + tc);
+ n->type = Ball;
+ n->color = t->color;
+ n->spin = t->spin;
+ n->degree_offset = t->degree_offset;
+ n->divisions = t->divisions;
+ n->status = PREDICTOR;
+
+ n->xp.a = 0;
+ n->xp.b = 0;
+ n->xp.c = t->dx;
+ n->xp.d = -t->dx*t0 + t->x;
+
+ dy = (yf - y0)/tb + 0.5*sp->Gr*tb;
+ t0 = n->start;
+ /* Represent parabola as a degenerate spline -
+ linear in x, quadratic in y */
+ n->yp.a = 0;
+ n->yp.b = sp->Gr/2;
+ n->yp.c = -sp->Gr*t0 - COR*dy;
+ n->yp.d = sp->Gr/2*t0*t0 + COR*dy*t0 + yf;
+ }
+
+ t->status = BPREDICTOR;
+
+ } else {
+ double t0, dt;
+
+ /* ball follows parabola */
+ INSERT_AFTER(n, t->prev);
+ n->start = t->start;
+ n->finish = t->balllink->start;
+ n->type = Ball;
+ n->color = t->color;
+ n->spin = t->spin;
+ n->degree_offset = t->degree_offset;
+ n->divisions = t->divisions;
+ n->status = PREDICTOR;
+
+ t0 = n->start;
+ dt = t->balllink->start - t->start;
+ t->dx = (t->balllink->x - t->x) / dt;
+ t->dy = (t->balllink->y - t->y) / dt - sp->Gr/2 * dt;
+
+ /* Represent parabola as a degenerate spline -
+ linear in x, quadratic in y */
+ n->xp.a = 0;
+ n->xp.b = 0;
+ n->xp.c = t->dx;
+ n->xp.d = -t->dx*t0 + t->x;
+ n->yp.a = 0;
+ n->yp.b = sp->Gr/2;
+ n->yp.c = -sp->Gr*t0 + t->dy;
+ n->yp.d = sp->Gr/2*t0*t0 - t->dy*t0 + t->y;
+
+
+ t->status = BPREDICTOR;
+ }
+ } else { /* Zero Throw */
+ t->status = BPREDICTOR;
+ }
+ }
+ }
+ return True;
+}
+
+/* Turn abstract hand motions into cubic splines. */
+static void
+hands(jugglestruct *sp)
+{
+ Trajectory *t, *u, *v;
+ for (t = sp->head->next; t != sp->head; t = t->next) {
+ /* no throw => no velocity */
+ if (t->status != BPREDICTOR) {
+ continue;
+ }
+
+ u = t->handlink;
+ if (u == NULL) { /* no next catch */
+ continue;
+ }
+ v = u->handlink;
+ if (v == NULL) { /* no next throw */
+ continue;
+ }
+
+ /* double spline takes hand from throw, thru catch, to
+ next throw */
+
+ t->finish = u->start;
+ t->status = PREDICTOR;
+
+ u->finish = v->start;
+ u->status = PREDICTOR;
+
+ (void) makeSplinePair(&t->xp, &u->xp,
+ t->x, t->dx, t->start,
+ u->x, u->start,
+ v->x, v->dx, v->start);
+ (void) makeSplinePair(&t->yp, &u->yp,
+ t->y, t->dy, t->start,
+ u->y, u->start,
+ v->y, v->dy, v->start);
+
+ t->status = PREDICTOR;
+ }
+}
+
+/* Given target x, y find_elbow puts hand at target if possible,
+ * otherwise makes hand point to the target */
+static void
+find_elbow(jugglestruct *sp, XPoint *h, XPoint *e, int x, int y, int z)
+{
+ double r, h2, t;
+
+ h2 = x*x + y*y + z*z;
+ if (h2 > 4*ARMLENGTH*ARMLENGTH) {
+ t = ARMLENGTH/sqrt(h2);
+ e->x = (short) (t*x);
+ e->y = (short) (t*y);
+ h->x = 2 * e->x;
+ h->y = 2 * e->y;
+ } else {
+ r = sqrt((double)(x*x + z*z));
+ t = sqrt(4 * ARMLENGTH * ARMLENGTH / h2 - 1);
+ e->x = (short) (x*(1 - y*t/r)/2);
+ e->y = (short) ((y + r*t)/2);
+ h->x = x;
+ h->y = y;
+ }
+}
+
+/* NOTE: returned x, y adjusted for arm reach */
+static void
+draw_arm(ModeInfo * mi, Hand side, int *x, int *y)
+{
+ Display *dpy = MI_DISPLAY(mi);
+ Window win = MI_WINDOW(mi);
+ GC gc = MI_GC(mi);
+ jugglestruct *sp = &juggles[MI_SCREEN(mi)];
+
+ int sig = (side == LEFT) ? 1 : -1;
+
+ XSetLineAttributes(dpy, gc,
+ ARMWIDTH, LineSolid, CapRound, JoinRound);
+ if (sp->arm[side][0].x != *x || sp->arm[side][0].y != *y) {
+ XPoint h, e;
+ XSetForeground(dpy, gc, MI_BLACK_PIXEL(mi));
+ find_elbow(sp, &h, &e, *x - sig*SX - sp->cx, *y - SY - sp->cy, SZ);
+ XDrawLines(dpy, win, gc, sp->arm[side], 3, CoordModeOrigin);
+ *x = sp->arm[side][0].x = sp->cx + sig*SX + h.x;
+ *y = sp->arm[side][0].y = sp->cy + SY + h.y;
+ sp->arm[side][1].x = sp->cx + sig*SX + e.x;
+ sp->arm[side][1].y = sp->cy + SY + e.y;
+ }
+ XSetForeground(dpy, gc, MI_WHITE_PIXEL(mi));
+ XDrawLines(dpy, win, gc, sp->arm[side], 3, CoordModeOrigin);
+ XSetLineAttributes(dpy, gc,
+ 1, LineSolid, CapNotLast, JoinRound);
+}
+
+static void
+draw_figure(ModeInfo * mi)
+{
+ Display *dpy = MI_DISPLAY(mi);
+ Window win = MI_WINDOW(mi);
+ GC gc = MI_GC(mi);
+ jugglestruct *sp = &juggles[MI_SCREEN(mi)];
+
+ XSetLineAttributes(dpy, gc,
+ ARMWIDTH, LineSolid, CapRound, JoinRound);
+ XSetForeground(dpy, gc, MI_WHITE_PIXEL(mi));
+ XDrawLines(dpy, win, gc, sp->figure_path, FIGURE1, CoordModeOrigin);
+ XDrawSegments(dpy, win, gc, sp->figure_segs, FIGURE2);
+ XDrawArc(dpy, win, gc,
+ sp->cx - HED/2, sp->cy + NEY - HED, HED, HED, 0, 64*360);
+ XSetLineAttributes(dpy, gc,
+ 1, LineSolid, CapNotLast, JoinRound);
+}
+
+
+/* dumps a human-readable rendition of the current state of the juggle
+ pipeline to stderr for debugging */
+#ifdef OLDDEBUG
+static void
+dump(jugglestruct *sp)
+{
+ Trajectory *t;
+
+ for (t = sp->head->next; t != sp->head; t = t->next) {
+ switch (t->status) {
+ case THROW:
+ (void) fprintf(stderr, "T %c%d\n", t->posn, t->height);
+ break;
+ case ACTION:
+ (void) fprintf(stderr, t->action == CATCH?"A %c%c%c\n":"A %c%c%c%d\n",
+ t->posn,
+ t->hand ? 'R' : 'L',
+ (t->action == THROW)?'T':(t->action == CATCH?'C':'N'),
+ t->height);
+ break;
+ case LINKEDACTION:
+ (void) fprintf(stderr, "L %c%c%c%d %d\n",
+ t->posn,
+ t->hand?'R':'L',
+ (t->action == THROW)?'T':(t->action == CATCH?'C':'N'),
+ t->height, t->color);
+ break;
+ case PTHRATCH:
+ (void) fprintf(stderr, "O %c%c%c%d %d %2d %6d %6d\n", t->posn,
+ t->hand?'R':'L',
+ (t->action == THROW)?'T':(t->action == CATCH?'C':'N'),
+ t->height, t->type, t->color,
+ t->start, t->finish);
+ break;
+ case PREDICTOR:
+ (void) fprintf(stderr, "P %c %2d %6d %6d %g\n",
+ t->type == Ball?'b':t->type == Empty?'e':'f',
+ t->color,
+ t->start, t->finish, t->yp.c);
+ break;
+ default:
+ (void) fprintf(stderr, "status %d not implemented\n", t->status);
+ break;
+ }
+ }
+}
+#endif
+
+static int get_num_balls(const char *j)
+{
+ int balls = 0;
+ const char *p;
+ int h = 0;
+ for (p = j; *p; p++) {
+ if (*p >= '0' && *p <='9') { /* digit */
+ h = 10*h + (*p - '0');
+ } else {
+ if (h > balls) {
+ balls = h;
+ }
+ h = 0;
+ }
+ }
+ return balls;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static int compare_num_balls(const void *p1, const void *p2)
+{
+ int i = get_num_balls(((patternstruct*)p1)->pattern);
+ int j = get_num_balls(((patternstruct*)p2)->pattern);
+ if (i > j) {
+ return (1);
+ } else if (i < j) {
+ return (-1);
+ } else {
+ return (0);
+ }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Public functions */
+
+void
+release_juggle(ModeInfo * mi)
+{
+ if (juggles != NULL) {
+ int screen;
+
+ for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
+ free_juggle(&juggles[screen]);
+ (void) free((void *) juggles);
+ juggles = (jugglestruct *) NULL;
+ }
+ if (patternindex != NULL) {
+ (void) free((void *) patternindex);
+ patternindex = (PatternIndex *) NULL;
+ }
+}
+
+void
+init_juggle(ModeInfo * mi)
+{
+ jugglestruct *sp;
+ int i;
+ XPoint figure1[FIGURE1];
+ XSegment figure2[FIGURE2];
+ if (pattern != NULL && *pattern == '.') {
+ pattern = NULL;
+ }
+ if (pattern == NULL && patternindex == NULL) {
+ /* pattern list needs indexing */
+ int i;
+ int nelements = sizeof(portfolio)/sizeof(patternstruct);
+ int maxballs;
+ int numpat = 0;
+
+ /* sort according to number of balls */
+ qsort((void*)portfolio, nelements,
+ sizeof(patternstruct), compare_num_balls);
+
+ /* last pattern has most balls */
+ maxballs = get_num_balls(portfolio[nelements - 1].pattern);
+ /* allocate index */
+ if ((patternindex = (PatternIndex *) calloc(maxballs + 1,
+ sizeof (PatternIndex))) == NULL) {
+ return;
+ }
+
+ /* run through sorted list, indexing start of each group
+ and number in group */
+ maxballs = 1;
+ for (i = 0; i < nelements; i++) {
+ int b = get_num_balls(portfolio[i].pattern);
+ if (b > maxballs) {
+ if (MI_IS_VERBOSE(mi)) {
+ (void) fprintf(stderr, "%d %d ball pattern%s\n",
+ numpat, maxballs, (numpat == 1) ? "" : "s");
+ }
+ patternindex[maxballs].number = numpat;
+ maxballs = b;
+ numpat = 1;
+ patternindex[maxballs].start = i;
+ } else {
+ numpat++;
+ }
+ }
+ if (MI_IS_VERBOSE(mi)) {
+ (void) fprintf(stderr, "%d %d ball pattern%s\n",
+ numpat, maxballs, (numpat == 1) ? "" : "s");
+ }
+ patternindex[maxballs].number = numpat;
+ }
+
+ if (juggles == NULL) { /* allocate jugglestruct */
+ if ((juggles = (jugglestruct *) calloc(MI_NUM_SCREENS(mi),
+ sizeof (jugglestruct))) == NULL) {
+ release_juggle(mi);
+ return;
+ }
+ }
+ sp = &juggles[MI_SCREEN(mi)];
+
+ sp->count = 0;
+
+ if (MI_IS_FULLRANDOM(mi)) {
+ sp->solid = (Bool) (LRAND() & 1);
+#ifdef UNI
+ sp->uni = (Bool) (LRAND() & 1);
+#endif
+ } else {
+ sp->solid = solid;
+#ifdef UNI
+ sp->uni = uni;
+#endif
+ }
+
+ sp->width = MI_WIDTH(mi);
+ sp->height = MI_HEIGHT(mi);
+ sp->count = ABS(MI_COUNT(mi));
+ if (sp->count == 0)
+ sp->count = 150;
+ sp->scale = sp->height / 480.0;
+ /* vary x a little so the juggler does not burn the screen */
+ sp->cx = sp->width / 2 + RFX + NRAND(LFX - RFX + 1);
+ sp->cy = sp->height - FY - ((int) sp->uni) * FY / 3; /* raise higher */
+ /* "7" hits top of screen */
+ sp->Gr = GRAVITY(sp->cy, 7 * THROW_CATCH_INTERVAL);
+
+ figure1[0].x = LHIPX, figure1[0].y = HIPY;
+ figure1[1].x = 0, figure1[1].y = WSTY;
+ figure1[2].x = SX, figure1[2].y = SY;
+ figure1[3].x = -SX, figure1[3].y = SY;
+ figure1[4].x = 0, figure1[4].y = WSTY;
+ figure1[5].x = RHIPX, figure1[5].y = HIPY;
+ figure1[6].x = LHIPX, figure1[6].y = HIPY;
+ figure2[0].x1 = 0, figure2[0].y1 = SY,
+ figure2[0].x2 = 0, figure2[0].y2 = NEY;
+ figure2[1].x1 = LHIPX, figure2[1].y1 = HIPY,
+ figure2[1].x2 = LFX, figure2[1].y2 = FY;
+ figure2[2].x1 = RHIPX, figure2[2].y1 = HIPY,
+ figure2[2].x2 = RFX, figure2[2].y2 = FY;
+
+ /* Body Path */
+ for (i = 0; i < FIGURE1; i++) {
+ sp->figure_path[i].x = figure1[i].x + sp->cx;
+ sp->figure_path[i].y = figure1[i].y + sp->cy;
+ }
+ /* Body Segments */
+ for (i = 0; i < FIGURE2; i++) {
+ sp->figure_segs[i].x1 = figure2[i].x1 + sp->cx;
+ sp->figure_segs[i].y1 = figure2[i].y1 + sp->cy;
+ sp->figure_segs[i].x2 = figure2[i].x2 + sp->cx;
+ sp->figure_segs[i].y2 = figure2[i].y2 + sp->cy;
+ }
+ /* Shoulders */
+ sp->arm[LEFT][2].x = sp->cx + SX;
+ sp->arm[LEFT][2].y = sp->cy + SY;
+ sp->arm[RIGHT][2].x = sp->cx - SX;
+ sp->arm[RIGHT][2].y = sp->cy + SY;
+
+ if (sp->trace == NULL) {
+ if ((sp->trace = (XPoint *)calloc(trail, sizeof(XPoint))) == NULL) {
+ free_juggle(sp);
+ return;
+ }
+ }
+
+ /* Clear the background. */
+ MI_CLEARWINDOW(mi);
+
+ draw_figure(mi);
+
+ /* record start time */
+ sp->begintime = time(NULL);
+
+ free_pattern(sp);
+
+ /* create circular list */
+ INSERT_AFTER_TOP(sp->head, sp->head);
+
+ /* generate pattern */
+ if (pattern == NULL) {
+
+#define MAXPAT 10
+#define MAXREPEAT 30
+#define CHANGE_BIAS 8 /* larger makes num_ball changes less likely */
+#define POSITION_BIAS 20 /* larger makes hand movements less likely */
+
+ int count = 0;
+ int num_balls = MINBALLS + NRAND(MAXBALLS - MINBALLS);
+ while (count < MI_CYCLES(mi)) {
+ char buf[MAXPAT * 3 + 3], *b = buf;
+ int maxseen = 0;
+ int l = NRAND(MAXPAT) + 1;
+ int t = NRAND(MAXREPEAT) + 1;
+
+ { /* vary number of balls */
+ int new_balls = num_balls;
+ int change;
+
+ if (new_balls == 2) /* Do not juggle 2 that often */
+ change = NRAND(2 + CHANGE_BIAS / 4);
+ else
+ change = NRAND(2 + CHANGE_BIAS);
+ switch (change) {
+ case 0:
+ new_balls++;
+ break;
+ case 1:
+ new_balls--;
+ break;
+ default:
+ break; /* NO-OP */
+ }
+ if (new_balls < MINBALLS) {
+ new_balls += 2;
+ }
+ if (new_balls > MAXBALLS) {
+ new_balls -= 2;
+ }
+ if (new_balls < num_balls) {
+ if (!program(mi, "[*]", 1)) /* lose ball */
+ return;
+ }
+ num_balls = new_balls;
+ }
+ count++;
+
+ if (NRAND(2) && patternindex[num_balls].number) {
+ /* Pick from PortFolio */
+ if (!program(mi,
+ portfolio[patternindex[num_balls].start +
+ NRAND(patternindex[num_balls].number)].pattern,
+ t))
+ return;
+ } else {
+ /* Invent a new pattern */
+ *b++='[';
+ for(i = 0; i < l; i++){
+ int n, m;
+ do { /* Triangular Distribution => high values more likely */
+ m = NRAND(num_balls + 1);
+ n = NRAND(num_balls + 1);
+ } while(m >= n);
+ if (n == num_balls) {
+ maxseen = 1;
+ }
+ switch(NRAND(6 + POSITION_BIAS)){
+ case 0: /* Inside throw */
+ *b++ = '-'; break;
+ case 1: /* Outside throw */
+ *b++ = '+'; break;
+ case 2: /* Cross throw */
+ *b++ = '='; break;
+ case 3: /* Cross catch */
+ *b++ = '&'; break;
+ case 4: /* Cross throw and catch */
+ *b++ = 'x'; break;
+ case 5: /* Bounce */
+ *b++ = '_'; break;
+ default:
+ break; /* NO-OP */
+ }
+
+ *b++ = n + '0';
+ *b++ = ' ';
+ }
+ *b++ = ']';
+ *b = '\0';
+ if (maxseen) {
+ if (!program(mi, buf, t))
+ return;
+ }
+ }
+ }
+ } else { /* pattern supplied in height or 'a' notation */
+ if (!program(mi, pattern, MI_CYCLES(mi)))
+ return;
+ }
+
+ adam(sp);
+
+ if (!part(sp))
+ return;
+
+ lob(mi);
+
+ positions(sp);
+
+ if (!projectile(sp))
+ return;
+
+ hands(sp);
+
+#ifdef OLDDEBUG
+ dump(sp);
+#endif
+}
+
+#define CUBIC(s, t) ((((s).a * (t) + (s).b) * (t) + (s).c) * (t) + (s).d)
+
+#ifdef SUNOS4
+/*-
+ * Workaround SunOS 4 framebuffer bug which causes balls to leave dust
+ * trace behind when erased
+ */
+#define ERASE_BALL(x,y) \
+ XSetForeground(dpy, gc, MI_BLACK_PIXEL(mi)); \
+ XFillArc(dpy, window, gc, \
+ (x) - BALLRADIUS - 2, (y) - BALLRADIUS - 2, \
+ 2*(BALLRADIUS + 2), 2*(BALLRADIUS + 2), 0, 23040)
+#else
+
+#define ERASE_BALL(x,y) \
+ XSetForeground(dpy, gc, MI_BLACK_PIXEL(mi)); \
+ XFillArc(dpy, window, gc, \
+ (x) - BALLRADIUS, (y) - BALLRADIUS, \
+ 2*BALLRADIUS, 2*BALLRADIUS, 0, 23040)
+#endif
+
+static void
+draw_juggle_ball(ModeInfo *mi, unsigned long color, int x, int y, double degree_offset, int divisions)
+{
+ Display *dpy = MI_DISPLAY(mi);
+ Window window = MI_WINDOW(mi);
+ GC gc = MI_GC(mi);
+ jugglestruct *sp = &juggles[MI_SCREEN(mi)];
+ int offset;
+
+ XSetForeground(dpy, gc, color);
+ if ((color == MI_WHITE_PIXEL(mi)) ||
+ ((divisions != 2) && (divisions != 4)) || sp->solid) {
+ XFillArc(dpy, window, gc,
+ x - BALLRADIUS, y - BALLRADIUS,
+ 2*BALLRADIUS, 2*BALLRADIUS,
+ 0, 23040);
+ return;
+ }
+ offset = (int) (degree_offset * 64);
+ if (divisions == 4) { /* 90 degree divisions */
+ XFillArc(dpy, window, gc,
+ x - BALLRADIUS, y - BALLRADIUS,
+ 2*BALLRADIUS, 2*BALLRADIUS,
+ offset, 5760);
+ XFillArc(dpy, window, gc,
+ x - BALLRADIUS, y - BALLRADIUS,
+ 2*BALLRADIUS, 2*BALLRADIUS,
+ (offset + 11520) % 23040, 5760);
+ XSetForeground(dpy, gc, MI_WHITE_PIXEL(mi));
+ XFillArc(dpy, window, gc,
+ x - BALLRADIUS, y - BALLRADIUS,
+ 2*BALLRADIUS, 2*BALLRADIUS,
+ (offset + 5760) % 23040, 5760);
+ XFillArc(dpy, window, gc,
+ x - BALLRADIUS, y - BALLRADIUS,
+ 2*BALLRADIUS, 2*BALLRADIUS,
+ (offset + 17280) % 23040, 5760);
+ } else { /* 180 degree divisions */
+ XFillArc(dpy, window, gc,
+ x - BALLRADIUS, y - BALLRADIUS,
+ 2*BALLRADIUS, 2*BALLRADIUS,
+ offset, 11520);
+ XSetForeground(dpy, gc, MI_WHITE_PIXEL(mi));
+ XFillArc(dpy, window, gc,
+ x - BALLRADIUS, y - BALLRADIUS,
+ 2*BALLRADIUS, 2*BALLRADIUS,
+ (offset + 11520) % 23040, 11520);
+ }
+ XFlush(dpy);
+}
+
+void
+draw_juggle(ModeInfo * mi)
+{
+ Display *dpy = MI_DISPLAY(mi);
+ Window window = MI_WINDOW(mi);
+ GC gc = MI_GC(mi);
+ Trajectory *traj;
+ int future = 0;
+ int length = 0;
+ jugglestruct *sp;
+
+ if (juggles == NULL)
+ return;
+ sp = &juggles[MI_SCREEN(mi)];
+ if (sp->trace == NULL)
+ return;
+
+ MI_IS_DRAWN(mi) = True;
+
+ draw_figure(mi);
+
+ {
+ struct timeval tv;
+ (void)gettimeofday(&tv, NULL);
+ sp->time = (int) ((tv.tv_sec - sp->begintime)*1000 + tv.tv_usec/1000);
+ }
+ for (traj = sp->head->next; traj != sp->head; traj = traj->next) {
+ length++;
+ if (traj->status != PREDICTOR) {
+ continue;
+ }
+ if (traj->start > future) {
+ future = traj->start;
+ }
+ if (sp->time < traj->start) { /* early */
+ continue;
+ } else if (sp->time < traj->finish) { /* working */
+ int x = (int) CUBIC(traj->xp, sp->time);
+ int y = (int) CUBIC(traj->yp, sp->time);
+ unsigned long color;
+
+ if (MI_NPIXELS(mi) > 2) {
+ color = MI_PIXEL(mi, traj->color);
+ } else {
+ color = MI_WHITE_PIXEL(mi);
+ }
+ if (traj->type == Empty || traj->type == Full) {
+ draw_arm(mi, traj->hand, &x, &y);
+ }
+ if (traj->type == Ball || traj->type == Full) {
+ if(trail > 0) {
+ ERASE_BALL(sp->trace[sp->traceindex].x,
+ sp->trace[sp->traceindex].y);
+ sp->trace[sp->traceindex].x = traj->x;
+ sp->trace[sp->traceindex].y = traj->y;
+ if (++sp->traceindex >= trail) {
+ sp->traceindex = 0;
+ }
+ } else {
+ ERASE_BALL(traj->x, traj->y);
+ }
+ draw_juggle_ball(mi, color, x, y, traj->degree_offset, traj->divisions);
+ traj->degree_offset = traj->degree_offset +
+ SPIN_DEGREES * traj->spin / sp->count;
+ if (traj->degree_offset < 0.0)
+ traj->degree_offset += 360.0;
+ else if (traj->degree_offset >= 360.0)
+ traj->degree_offset -= 360.0;
+ }
+ traj->x = x;
+ traj->y = y;
+ } else { /* expired */
+ Trajectory *n = traj;
+
+ ERASE_BALL(traj->x, traj->y);
+ traj=traj->prev;
+ REMOVE(n);
+ }
+ }
+
+ /*** FIXME-BEGIN ***/
+ /* pattern generator would refill here when necessary */
+#if 1
+ if (future == 0) {
+#else
+ if (sp->count > MI_CYCLES(mi)) { /* pick a new juggle */
+#endif
+ init_juggle(mi);
+ }
+ /*** FIXME-END ***/
+
+}
+
+#endif /* MODE_juggle */
projects / xscreensaver / blobdiff