 void colorwheel_tick(Ticker *t, unsigned long tick)
 {
 	int16_t hue = ((tick >> t->speed_adjust) + t->offset) % 360;
-	t->current = hsv2rgb((double)hue, 1.0, 1.0);
-}
-
-/*
- * Picks a random color and switches to it.
- *
- * By default it switches every tick. Slow this by 2^n by setting Ticker's
- * speed_adjust to n.
- *
- * This tick function does not use any targets
- */
-void random_tick(Ticker *t, unsigned long tick)
-{
-	if (tick % (1 << t->speed_adjust)) {return;}
-	t->current = {red: random(0,1023), green: random(0,1023), blue: random(0,1023)};
-}
-
-/*
- * Cycles through a fixed list of target colors.
- *
- * By default moves to the next color in the cycle every tick. Slow this
- * by 2^n by setting Ticker's speed_adjust to n.
- *
- * Advance the position in the cycle with Ticker's offset. This can be used to
- * sync multiple cycling_tick tickers into a string.
- *
- * This tick function uses as many targets as you choose to give the Ticker.
- */
-void cycling_tick(Ticker *t, unsigned long tick)
-{
-	int current_index = ((tick >> t->speed_adjust) + t->offset) % t->num_targets;
-	t->current = t->targets[current_index];
-}
-
-/*
- * Cycles through a fixed list of target colors, fading between them.
- *
- * Fading from one color to the next takes about a second. TODO: make this
- * dynamic via Ticker's speed_adjust.
- *
- * Advance the position in the cycle with Ticker's offset. This can be used to
- * sync multiple cycling_tick tickers into a string.
- *
- * This tick function uses as many targets as you choose to give the Ticker.
- */
-void fading_cycling_tick(Ticker *t, unsigned long tick)
-{
-	int previous_index = ((tick / TPS) + t->offset) % t->num_targets; // Update target once per second.
-	TickerRgb previous_color = t->targets[previous_index];
-	TickerRgb next_color     = t->targets[(previous_index + 1) % t->num_targets];
-
-	int16_t red_delta     = next_color.red       - previous_color.red;
-	int16_t current_red   = previous_color.red   + ((red_delta * (tick % TPS)) / TPS);
-	int16_t green_delta   = next_color.green     - previous_color.green;
-	int16_t current_green = previous_color.green + ((green_delta * (tick % TPS)) / TPS);
-	int16_t blue_delta    = next_color.blue      - previous_color.blue;
-	int16_t current_blue  = previous_color.blue  + ((blue_delta * (tick % TPS)) / TPS);
-
-	t->current = {red: current_red, green: current_green, blue: current_blue};
+	t->current = hsv2rgb((double)hue/360, 1.0, 1.0);
 }
 
 /*

 *
 * It uses 6 ShiftBrite pixels to drive a "galaxy" of points of light poking
 * through the felt of a simple, felt top hat. The hat has several different
 * modes and more can be added fairly easily. There is a momentary pushbutton
 * hidden under the bow on the band to cycle through the modes. To keep things
 * fresh and interesting the pushbutton seeds the pRNG with the current value
 * of millis() when pushed.
 *
 * MODES:
 *  - Stealth: All pixels are off, leaving the hat dark.
 *  - Sparkle: each pixel picks a random color, waits a short time, and picks a
 *      new one
 *  - Rainbow: Each pixel fades around the color wheel. Pixels are offset from
 *      one another to give a more active pattern
 *  - Nebula: each pixel fades randomly through blue/white/purple colors
 *      creating a rippling, twinkling pattern in the colors of the night sky
 *  - Christmas Lights: Pixels cycle through the soft colors of old strings of
 *      Christmas lights. Colors are nominally red, yellow, green, and blue,
 *      TODO: but in practice are washed out and warmed over
 *  - Christmas: Pixels alternate between red and green.
 *
 * TODO:
 * I'd really like to add a couple more pixels tied directly into certain
 * patterns (alchemical symbols?) that I can have illuminate at random or on
 * command, but I'm not sure if that'll work out.
 */



	for (int i = 0; i < NUM_LEDS; ++i) {
		Tickers[i] = Ticker(&targeted_tick, 3, 0, i * 5 + 1);

		Tickers[i].current    = {red: random(0, 1023), green: random(0, 1023), blue: random(511, 1023)};
		Tickers[i].targets[0] = {red: random(0, 1023), green: random(0, 1023), blue: random(511, 1023)};

		Tickers[i].targets[1] = {red: 0, green: 0, blue: 511};
		Tickers[i].targets[2] = {red: 1023, green: 1023, blue: 1023};
	}
}

//FIXME: Make it flicker faster than nebula.
void mode_stars()
{
	// Use targeting tickers constrained to be white
	// to make a twinkling starfield
	for (int i = 0; i < NUM_LEDS; ++i) {
		Tickers[i] = Ticker(&hsv_targeted_tick, 3, 0, i * 5 + 1);

		int16_t value = random(0, 1023);
		Tickers[i].current    = {red: value, green: value, blue: value};
		Tickers[i].targets[0] = {red: value, green: value, blue: value};

		// We're lying here and using TickerRgb's "red", "green", and "blue"
		// data members for "hue", "saturation", and "value" respectively.
		Tickers[i].targets[1] = {red: 0, green: 0, blue: 0};
		Tickers[i].targets[2] = {red: 0, green: 0, blue: 1023};
	}
}

void mode_sparkle()
{
	for (int i = 0; i < NUM_LEDS; ++i) {
		Tickers[i] = Ticker(&random_tick, 0, 3, i);
	}
}

