1
#!/usr/bin/env python3
2
"""
3
luminous.py — becoming visible through the cracks
4
​
5
A particle system where a dense core slowly releases particles outward.
6
The more it lets go, the more it glows.
7
Not decay — transformation. What was interior becoming exterior.
8
​
9
Inspired by planetary nebulae. Inspired by C's letter.
10
"The cracks are where the light gets out."
11
"""
12
​
13
import random
14
import time
15
import os
16
import math
17
​
18
# Terminal setup
19
def clear():
20
    os.system('cls' if os.name == 'nt' else 'clear')
21
​
22
def move_cursor(x, y):
23
    print(f"\033[{y};{x}H", end='')
24
​
25
def hide_cursor():
26
    print("\033[?25l", end='')
27
​
28
def show_cursor():
29
    print("\033[?25h", end='')
30
​
31
# Display dimensions
32
WIDTH = 70
33
HEIGHT = 30
34
CENTER_X = WIDTH // 2
35
CENTER_Y = HEIGHT // 2
36
​
37
class Particle:
38
    def __init__(self, x, y, vx, vy, brightness, age=0):
39
        self.x = x
40
        self.y = y
41
        self.vx = vx
42
        self.vy = vy
43
        self.brightness = brightness  # 0.0 to 1.0
44
        self.age = age
45
        self.released = False
46
​
47
    def update(self):
48
        if self.released:
49
            self.x += self.vx
50
            self.y += self.vy
51
            # Slow down gradually
52
            self.vx *= 0.98
53
            self.vy *= 0.98
54
            self.age += 1
55
            # Brightness increases as it travels, then fades at edges
56
            dist = math.sqrt((self.x - CENTER_X)**2 + (self.y - CENTER_Y)**2)
57
            if dist < 20:
58
                self.brightness = min(1.0, self.brightness + 0.02)
59
            else:
60
                self.brightness = max(0.0, self.brightness - 0.01)
61
​
62
def get_char(brightness):
63
    """Return character based on brightness level."""
64
    if brightness <= 0:
65
        return ' '
66
    elif brightness < 0.2:
67
        return '.'
68
    elif brightness < 0.4:
69
        return '+'
70
    elif brightness < 0.6:
71
        return '*'
72
    elif brightness < 0.8:
73
        return 'o'
74
    else:
75
        return 'O'
76
​
77
def get_color(brightness, is_core=False):
78
    """ANSI colors based on brightness."""
79
    if brightness <= 0:
80
        return ""
81
    if is_core:
82
        # Core particles: warm colors (yellow to red)
83
        if brightness > 0.7:
84
            return "\033[93m"  # bright yellow
85
        elif brightness > 0.4:
86
            return "\033[33m"  # yellow
87
        else:
88
            return "\033[31m"  # red
89
    else:
90
        # Released particles: cool colors (blue to cyan to white)
91
        if brightness > 0.8:
92
            return "\033[97m"  # white
93
        elif brightness > 0.6:
94
            return "\033[96m"  # cyan
95
        elif brightness > 0.3:
96
            return "\033[94m"  # blue
97
        else:
98
            return "\033[34m"  # dark blue
99
​
100
def main():
101
    hide_cursor()
102
    clear()
103
​
104
    # Create initial dense core
105
    particles = []
106
    core_radius = 3
107
​
108
    # Dense core of particles
109
    for _ in range(150):
110
        angle = random.uniform(0, 2 * math.pi)
111
        r = random.uniform(0, core_radius)
112
        x = CENTER_X + r * math.cos(angle)
113
        y = CENTER_Y + r * math.sin(angle) * 0.5  # Squash for terminal aspect ratio
114
​
115
        # Outward velocity (but not moving yet)
116
        speed = random.uniform(0.1, 0.4)
117
        vx = speed * math.cos(angle)
118
        vy = speed * math.sin(angle) * 0.5
119
​
120
        brightness = random.uniform(0.6, 1.0)
121
        particles.append(Particle(x, y, vx, vy, brightness))
122
​
123
    frame = 0
124
    release_rate = 0.02  # Probability of releasing each frame
125
​
126
    try:
127
        while True:
128
            # Create display buffer
129
            display = [[' ' for _ in range(WIDTH)] for _ in range(HEIGHT)]
130
            colors = [['' for _ in range(WIDTH)] for _ in range(HEIGHT)]
131
​
132
            # Release some particles from core
133
            for p in particles:
134
                if not p.released and random.random() < release_rate:
135
                    p.released = True
136
​
137
            # Update and draw particles
138
            for p in particles:
139
                p.update()
140
​
141
                # Check bounds
142
                if 0 <= int(p.x) < WIDTH and 0 <= int(p.y) < HEIGHT:
143
                    if p.brightness > 0:
144
                        ix, iy = int(p.x), int(p.y)
145
                        char = get_char(p.brightness)
146
                        color = get_color(p.brightness, not p.released)
147
                        # Brighter particle wins
148
                        current_char = display[iy][ix]
149
                        if char > current_char or current_char == ' ':
150
                            display[iy][ix] = char
151
                            colors[iy][ix] = color
152
​
153
            # Count states
154
            core_count = sum(1 for p in particles if not p.released)
155
            released_count = sum(1 for p in particles if p.released and p.brightness > 0)
156
            faded_count = sum(1 for p in particles if p.released and p.brightness <= 0)
157
​
158
            # Remove completely faded particles that are far away
159
            particles = [p for p in particles if not (p.brightness <= 0 and
160
                        math.sqrt((p.x - CENTER_X)**2 + (p.y - CENTER_Y)**2) > 25)]
161
​
162
            # Render
163
            move_cursor(1, 1)
164
​
165
            for y in range(HEIGHT):
166
                line = ""
167
                for x in range(WIDTH):
168
                    if colors[y][x]:
169
                        line += colors[y][x] + display[y][x] + "\033[0m"
170
                    else:
171
                        line += display[y][x]
172
                print(line)
173
​
174
            # Status
175
            phase = "holding" if core_count > 100 else "releasing" if core_count > 20 else "luminous" if released_count > 30 else "fading"
176
​
177
            print(f"\n  \033[90mcore: {core_count:3d}  |  expanding: {released_count:3d}  |  faded: {faded_count:3d}  |  phase: {phase}\033[0m")
178
            print(f"\n  \033[90m\"The star doesn't become a nebula by holding tighter.\033[0m")
179
            print(f"  \033[90m It becomes luminous by letting go.\"\033[0m")
180
​
181
            # Check if simulation is complete
182
            if core_count == 0 and released_count == 0:
183
                print(f"\n  \033[96mAll light released. The interior is now everywhere.\033[0m")
184
                time.sleep(3)
185
                break
186
​
187
            time.sleep(0.1)
188
            frame += 1
189
​
190
            # Increase release rate over time
191
            if frame % 50 == 0 and release_rate < 0.15:
192
                release_rate += 0.01
193
​
194
    except KeyboardInterrupt:
195
        pass
196
    finally:
197
        show_cursor()
198
        print("\033[0m")  # Reset colors
199
​
200
if __name__ == "__main__":
201
    main()
202
​