diff --git a/adafruit_led_animation/animation/comet.py b/adafruit_led_animation/animation/comet.py
index ce9c843..2bf763b 100644
--- a/adafruit_led_animation/animation/comet.py
+++ b/adafruit_led_animation/animation/comet.py
@@ -64,14 +64,14 @@ class Comet(Animation):
 
     # pylint: disable=too-many-arguments
     def __init__(
-            self,
-            pixel_object,
-            speed,
-            color,
-            tail_length=0,
-            reverse=False,
-            bounce=False,
-            name=None,
+        self,
+        pixel_object,
+        speed,
+        color,
+        tail_length=0,
+        reverse=False,
+        bounce=False,
+        name=None,
     ):
         if tail_length == 0:
             tail_length = len(pixel_object) // 4
@@ -98,9 +98,10 @@ class Comet(Animation):
     def _comet_recompute_color(self, color):
         self._comet_colors = [BLACK]
         for n in range(self._tail_length):
-            self._comet_colors.append(calculate_intensity(color, n * self._color_step + 0.05))
+            self._comet_colors.append(
+                calculate_intensity(color, n * self._color_step + 0.05)
+            )
         self._computed_color = color
-        print(self._comet_colors)
 
     def draw(self):
         for pixel_no in range(self._tail_length + 1):
@@ -113,8 +114,10 @@ class Comet(Animation):
 
         if self._tail_start < self._left_side or self._tail_start > self._right_side:
             self.reverse = not self.reverse
-            self._direction = - self._direction
+            self._direction = -self._direction
             self._tail_start += self._direction
+            if self.reverse == self._initial_reverse:
+                self.cycle_complete = True
 
     def reset(self):
         """
diff --git a/adafruit_led_animation/animation/rainbowcomet.py b/adafruit_led_animation/animation/rainbowcomet.py
index 785b795..572f859 100644
--- a/adafruit_led_animation/animation/rainbowcomet.py
+++ b/adafruit_led_animation/animation/rainbowcomet.py
@@ -45,7 +45,7 @@ Implementation Notes
 """
 
 from adafruit_led_animation.animation.comet import Comet
-from adafruit_led_animation.color import colorwheel, BLACK
+from adafruit_led_animation.color import colorwheel, BLACK, calculate_intensity
 
 
 class RainbowComet(Comet):
@@ -60,6 +60,7 @@ class RainbowComet(Comet):
     :param bool reverse: Animates the comet in the reverse order. Defaults to ``False``.
     :param bool bounce: Comet will bounce back and forth. Defaults to ``True``.
     :param int colorwheel_offset: Offset from start of colorwheel (0-255).
+    :param int step: Colorwheel step (defaults to automatic).
     """
 
     # pylint: disable=too-many-arguments
@@ -71,30 +72,27 @@ class RainbowComet(Comet):
         reverse=False,
         bounce=False,
         colorwheel_offset=0,
+        step=0,
         name=None,
     ):
-        self._colorwheel_is_tuple = isinstance(colorwheel(0), tuple)
+        if step == 0:
+            self._colorwheel_step = int(256 / tail_length)
+        else:
+            self._colorwheel_step = step
         self._colorwheel_offset = colorwheel_offset
-
         super().__init__(pixel_object, speed, 0, tail_length, reverse, bounce, name)
 
-    def _calc_brightness(self, n, color):
-        brightness = (n * self._color_step) + self._color_offset
-        if not self._colorwheel_is_tuple:
-            color = (color & 0xFF, ((color & 0xFF00) >> 8), (color >> 16))
-        return [int(i * brightness) for i in color]
-
     def _comet_recompute_color(self, color):
-        factor = int(256 / self._tail_length)
-        self._comet_colors = [BLACK] + [
-            self._calc_brightness(
-                n,
-                colorwheel(
-                    int((n * factor) + self._color_offset + self._colorwheel_offset)
-                    % 256
-                ),
+        self._comet_colors = [BLACK]
+        for n in range(self._tail_length):
+            invert = self._tail_length - n - 1
+            self._comet_colors.append(
+                calculate_intensity(
+                    colorwheel(
+                        int((invert * self._colorwheel_step) + self._colorwheel_offset)
+                        % 256
+                    ),
+                    n * self._color_step + 0.05,
+                )
             )
-            for n in range(self._tail_length - 1)
-        ]
-        self._reverse_comet_colors = list(reversed(self._comet_colors))
         self._computed_color = color
diff --git a/adafruit_led_animation/color.py b/adafruit_led_animation/color.py
index 27f4b24..74311f2 100644
--- a/adafruit_led_animation/color.py
+++ b/adafruit_led_animation/color.py
@@ -74,12 +74,28 @@ def calculate_intensity(color, intensity=1.0):
     :return: color
     """
     if isinstance(color, int):
-        return ((int((color & 0xff0000) * intensity) & 0xff0000) |
-                (int((color & 0xff00) * intensity) & 0xff00) |
-                (int((color & 0xff) * intensity) & 0xff))
+        return (
+            (int((color & 0xFF0000) * intensity) & 0xFF0000)
+            | (int((color & 0xFF00) * intensity) & 0xFF00)
+            | (int((color & 0xFF) * intensity) & 0xFF)
+        )
 
     if len(color) == 3:
-        return int(color[0] * intensity), int(color[1] * intensity), int(color[2] * intensity)
+        return (
+            int(color[0] * intensity),
+            int(color[1] * intensity),
+            int(color[2] * intensity),
+        )
     elif len(color) == 4 and isinstance(color[3], float):
-        return int(color[0] * intensity), int(color[1] * intensity), int(color[2] * intensity), color[3]
-    return int(color[0] * intensity), int(color[1] * intensity), int(color[2] * intensity), int(color[3] * intensity)
+        return (
+            int(color[0] * intensity),
+            int(color[1] * intensity),
+            int(color[2] * intensity),
+            color[3],
+        )
+    return (
+        int(color[0] * intensity),
+        int(color[1] * intensity),
+        int(color[2] * intensity),
+        int(color[3] * intensity),
+    )