Added DIGITALRAIN_INTENSITY setting to control digital rain density (#191)

* fix for clock.py display date-time overlapping

* Added adjustable setting for density and frequency

SUMMARY OF MODIFICATIONS AND CURRENT SCRIPT BEHAVIOR
---------------------------------------------------

1. NEW SETTING: DIGITALRAIN_INTENSITY
   - Added at the top of the script:
       DIGITALRAIN_INTENSITY = 5
   - Range: 1 (sparse/light) → 9 (dense/heavy)
   - Purpose: Controls both the number of "digital rain" drops per spawn and the spawn frequency.

2. MODIFIED increase_population()
   - Original:
       def increase_population():
           blue_pilled_population.append([randint(0, device.width), 0, gauss(1.2, 0.6)])
   - Modified:
       def increase_population():
           drops_per_tick = max(1, int(DIGITALRAIN_INTENSITY * 0.5))
           for _ in range(drops_per_tick):
               blue_pilled_population.append([randint(0, device.width), 0, gauss(1.2, 0.6)])
   - Effect: The number of drops added per spawn scales with intensity.
       - Intensity 1 → 1 drop per spawn
       - Intensity 9 → 4 drops per spawn (capped to prevent screen saturation)

3. NEW HELPER FUNCTION: should_spawn(clock)
   - Original spawn condition:
       if clock % 5 == 0 or clock % 3 == 0:
           increase_population()
   - Modified:
       def should_spawn(clock):
           interval = max(1, 10 - DIGITALRAIN_INTENSITY)
           return clock % interval == 0
       ...
       if should_spawn(clock):
           increase_population()
   - Effect: Spawn frequency dynamically scales with intensity.
       - Intensity 1 → interval = 9 ticks (sparse rain)
       - Intensity 9 → interval = 1 tick (heavy rain)
   - Combined with drop-per-tick scaling, ensures heavy rain remains dynamic without filling the screen entirely.

4. OTHER CODE
   - All other original behavior preserved:
       - Color gradient in wrd_rgb is unchanged
       - Speed of each drop controlled by gauss(1.2, 0.6)
       - Maximum population still capped at device.width * 8
       - Framerate regulated at 10 fps
       - Canvas rendering logic unchanged
   - KeyboardInterrupt handling preserved

5. HOW THE SCRIPT WORKS NOW
   - Loop increments clock each tick
   - On each tick:
       a) Render all current drops on the canvas with their colors
       b) Move each drop downward according to its speed
       c) Determine if new drops should spawn using should_spawn(clock)
           - If yes, spawn drops_per_tick new drops
       d) Trim blue_pilled_population if it exceeds max_population
   - Result: Digital rain density and intensity scale with the DIGITALRAIN_INTENSITY setting, giving smooth, adjustable visual effect without saturation or static appearance.

6. TUNABLE EFFECTS
   - Adjust DIGITALRAIN_INTENSITY (1–9) to control visual density and dynamic behavior:
       - 1 = very light rain
       - 5 = balanced medium rain
       - 9 = heavy rain, still dynamic, screen not static

* Apply suggestion from @gemini-code-assist[bot]

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

* corrected formatting on matrix_intensity.py code


qa: commands[0]> flake8
./examples/matrix_intensity.py:24:1: E302 expected 2 blank lines, found 1
./examples/matrix_intensity.py:84:1: E305 expected 2 blank lines after class or function definition, found 1
./examples/matrix_intensity.py:90:1: E265 block comment should start with '# '
./examples/matrix_intensity.py:91:1: W391 blank line at end of file

* Update matrix_intensity.py

Added 'device.width -1' to enhance display effect of digital rain.

Addressed and corrected the line spacing errors:

qa: commands[0]> flake8
./examples/matrix_intensity.py:24:1: E302 expected 2 blank lines, found 1
./examples/matrix_intensity.py:84:1: E305 expected 2 blank lines after class or function definition, found 1
./examples/matrix_intensity.py:90:1: E265 block comment should start with '# '
./examples/matrix_intensity.py:91:1: W391 blank line at end of file

* Fix QA transgressions

---------

Co-authored-by: Richard Hull <rm_hull@yahoo.co.uk>
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

Author: 3 people

examples/matrix_intensity.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2014-19 Richard Hull and contributors
+# See LICENSE.rst for details.
+# PYTHON_ARGCOMPLETE_OK
+
+"""
+The Matrix.
+
+Adapted from:
+https://github.com/pimoroni/unicorn-hat-hd/blob/master/examples/matrix-hd.py
+"""
+
+from random import randint, gauss, uniform
+from demo_opts import get_device
+from luma.core.render import canvas
+from luma.core.sprite_system import framerate_regulator
+
+
+# Digital rain intensity setting
+# 1 (sparse/light) → 9 (dense/heavy)
+
+DIGITALRAIN_INTENSITY = 5
+
+
+def matrix(device):
+    wrd_rgb = [
+        (154, 173, 154),
+        (0, 255, 0),
+        (0, 235, 0),
+        (0, 220, 0),
+        (0, 185, 0),
+        (0, 165, 0),
+        (0, 128, 0),
+        (0, 0, 0),
+        (154, 173, 154),
+        (0, 145, 0),
+        (0, 125, 0),
+        (0, 100, 0),
+        (0, 80, 0),
+        (0, 60, 0),
+        (0, 40, 0),
+        (0, 0, 0),
+    ]
+
+    clock = 0
+    blue_pilled_population = []
+    max_population = device.width * 8
+    regulator = framerate_regulator(fps=10)
+
+    def increase_population():
+        drops_per_tick = max(1, int(DIGITALRAIN_INTENSITY * 0.5))
+        for _ in range(drops_per_tick):
+            blue_pilled_population.append(
+                [randint(0, device.width - 1), 0, gauss(1.2, 0.6)]
+            )
+
+    def should_spawn(clock):
+        interval = max(1, 10 - DIGITALRAIN_INTENSITY)
+        return clock % interval == 0
+
+    while True:
+        clock += 1
+        with regulator:
+            with canvas(device, dither=True) as draw:
+                for person in blue_pilled_population:
+                    x, y, speed = person
+                    # Add subtle speed jitter
+                    speed += uniform(-0.05, 0.05)
+                    person[2] = speed
+
+                    for rgb in wrd_rgb:
+                        if 0 <= y < device.height:
+                            # Add subtle brightness variation
+                            r, g, b = rgb
+                            multiplier = uniform(0.6, 1.2)  # 60% → 120% of base green
+                            g = max(0, min(255, int(g * multiplier)))
+                            draw.point((x, y), fill=(r, g, b))
+                        y -= 1
+                    person[1] += speed
+
+        if should_spawn(clock):
+            increase_population()
+
+        while len(blue_pilled_population) > max_population:
+            blue_pilled_population.pop(0)
+
+
+if __name__ == "__main__":
+    try:
+        matrix(get_device())
+    except KeyboardInterrupt:
+        pass