278 lines
9.8 KiB
Python
278 lines
9.8 KiB
Python
import math
|
|
import random
|
|
import shutil
|
|
import string
|
|
import threading
|
|
import time
|
|
import tkinter
|
|
|
|
# Nice patterns
|
|
# 0, 15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165, 180, 195, 210, 225, 240, 255, 270, 285, 300, 315, 330, 345
|
|
# 0, 30, 60, 90, 120, 150, 180, 210, 240, 270, 300, 330
|
|
# 0, 15, 30, 45, 60, 180, 195, 210, 225, 240
|
|
# 0, 90, 180, 270
|
|
# ░▒▓
|
|
|
|
SCREEN_WIDTH = shutil.get_terminal_size()[0] - 6
|
|
print(SCREEN_WIDTH)
|
|
|
|
DEFAULT_LINE = {
|
|
'character': '#',
|
|
'degree': 0,
|
|
'degree_step': 1,
|
|
'horizontal_offset': 0,
|
|
'line_thickness': 1,
|
|
'original_degree': 0,
|
|
'damping': 3,
|
|
'depth': 0,
|
|
}
|
|
variables = {
|
|
'clock': 0,
|
|
'frames':[],
|
|
'delay': 0.02,
|
|
'lines':[
|
|
]
|
|
}
|
|
|
|
class LineControl(tkinter.Frame):
|
|
def __init__(self, master, line, *args, **kwargs):
|
|
tkinter.Frame.__init__(self, master, *args, **kwargs)
|
|
|
|
self.line = line
|
|
for x in range(4):
|
|
self.columnconfigure(x, minsize=40)
|
|
row = 0
|
|
tkinter.Button(self, text='\u21bb', command=self.refresh).grid(row=row, column=0, sticky='news')
|
|
tkinter.Button(self, text='Clone', command=self.clone).grid(row=row, column=1, columnspan=2, sticky='news')
|
|
tkinter.Button(self, text='X', command=self.suicide).grid(row=row, column=3, sticky='news')
|
|
row += 1
|
|
|
|
tkinter.Label(self, text='Degree:').grid(row=row, column=0, sticky='e')
|
|
self.entry_degree = tkinter.Entry(self, width=3)
|
|
self.entry_degree.insert(0, self.line['original_degree'])
|
|
self.entry_degree.grid(row=row, column=1, sticky='news')
|
|
tkinter.Button(self, text='Set', command=self.apply_degree).grid(row=row, column=2, sticky='news')
|
|
row += 1
|
|
|
|
def create_buttonpair(key, row):
|
|
minus = tkinter.Button(self, text='-', command=lambda *a: self.step_variable(key, -1, self.value_labels[key]))
|
|
minus.grid(row=row, column=1, sticky='news')
|
|
plus = tkinter.Button(self, text='+', command=lambda *a: self.step_variable(key, +1, self.value_labels[key]))
|
|
plus.grid(row=row, column=2, sticky='news')
|
|
|
|
self.value_labels = {}
|
|
tkinter.Label(self, text='Step:').grid(row=row, column=0, sticky='e')
|
|
create_buttonpair('degree_step', row)
|
|
self.value_labels['degree_step'] = tkinter.Label(self, text=str(self.line['degree_step']))
|
|
self.value_labels['degree_step'].grid(row=row, column=3)
|
|
row += 1
|
|
|
|
tkinter.Label(self, text='Thick:').grid(row=row, column=0, sticky='e')
|
|
create_buttonpair('line_thickness', row)
|
|
self.value_labels['line_thickness'] = tkinter.Label(self, text=str(self.line['line_thickness']))
|
|
self.value_labels['line_thickness'].grid(row=row, column=3)
|
|
row += 1
|
|
|
|
tkinter.Label(self, text='Offset:').grid(row=row, column=0, sticky='e')
|
|
create_buttonpair('horizontal_offset', row)
|
|
self.value_labels['horizontal_offset'] = tkinter.Label(self, text=str(self.line['horizontal_offset']))
|
|
self.value_labels['horizontal_offset'].grid(row=row, column=3)
|
|
row += 1
|
|
|
|
tkinter.Label(self, text='Dampen:').grid(row=row, column=0, sticky='e')
|
|
create_buttonpair('damping', row)
|
|
self.value_labels['damping'] = tkinter.Label(self, text=str(self.line['damping']))
|
|
self.value_labels['damping'].grid(row=row, column=3)
|
|
row += 1
|
|
|
|
tkinter.Label(self, text='Depth:').grid(row=row, column=0, sticky='e')
|
|
create_buttonpair('depth', row)
|
|
self.value_labels['depth'] = tkinter.Label(self, text=str(self.line['depth']))
|
|
self.value_labels['depth'].grid(row=row, column=3)
|
|
row += 1
|
|
|
|
tkinter.Label(self, text='Char:').grid(row=row, column=0, sticky='e')
|
|
self.entry_character = tkinter.Entry(self, width=2, font=('Consolas', 12))
|
|
self.entry_character.grid(row=row, column=1, sticky='news')
|
|
self.entry_character.insert(0, self.line['character'])
|
|
tkinter.Button(self, text='Set', command=self.apply_character).grid(row=row, column=2, sticky='news')
|
|
row += 1
|
|
|
|
def apply_character(self, *trash):
|
|
char = self.entry_character.get()
|
|
try:
|
|
assert len(char) == 1
|
|
except:
|
|
return
|
|
self.line['character'] = char
|
|
|
|
def apply_degree(self, *trash):
|
|
value = self.entry_degree.get()
|
|
try:
|
|
value = int(value)
|
|
except ValueError:
|
|
return
|
|
self.line['original_degree'] = value % 360
|
|
self.refresh()
|
|
regrid_frames()
|
|
|
|
def clone(self, *trash):
|
|
line = self.line.copy()
|
|
create_line_frame(line=line)
|
|
regrid_frames()
|
|
|
|
def refresh(self, *trash):
|
|
self.line['degree'] = self.line['original_degree'] + (self.line['degree_step'] * variables['clock'])
|
|
|
|
def step_variable(self, key, direction, label):
|
|
value = self.line[key]
|
|
value += direction
|
|
|
|
if key == 'line_thickness':
|
|
value = max(value, 0)
|
|
elif key == 'horizontal_offset':
|
|
value = value % SCREEN_WIDTH
|
|
elif key == 'delay':
|
|
value = max(value, 0.001)
|
|
elif key in ('damping', 'depth'):
|
|
value = max(value, 0)
|
|
value = min(value, int(SCREEN_WIDTH / 2))
|
|
|
|
self.line[key] = value
|
|
label.configure(text=str(value)[:5])
|
|
|
|
def suicide(self, *trash):
|
|
unregister_line(self.line)
|
|
variables['frames'].remove(self)
|
|
self.grid_forget()
|
|
regrid_frames()
|
|
|
|
def create_line(degree_offset, **kwargs):
|
|
line = DEFAULT_LINE.copy()
|
|
line.update(kwargs)
|
|
line['original_degree'] = degree_offset
|
|
line['degree'] = (variables['clock'] + degree_offset) % 360
|
|
# Line ID exists solely to make sure that even clones are unique.
|
|
line['id'] = random.getrandbits(32)
|
|
return line
|
|
|
|
def create_line_frame(offset=None, line=None):
|
|
if line is None:
|
|
if offset is None:
|
|
offset = t.entry_add.get()
|
|
offset = offset.replace(' ', '')
|
|
offset = offset.split(',')
|
|
try:
|
|
offset = [int(o) for o in offset]
|
|
except ValueError:
|
|
return
|
|
t.entry_add.delete(0, 'end')
|
|
|
|
lines = []
|
|
for x in offset:
|
|
line = create_line(x)
|
|
lines.append(line)
|
|
else:
|
|
line['id'] = random.getrandbits(32)
|
|
lines = [line]
|
|
|
|
for line in lines:
|
|
register_line(line)
|
|
frame = LineControl(t, line, relief='groove', borderwidth=2)
|
|
variables['frames'].append(frame)
|
|
regrid_frames()
|
|
|
|
def map_range(x, old_low, old_high, new_low, new_high):
|
|
'''
|
|
Given a number x in range [old_low, old_high], return corresponding
|
|
number in range [new_low, new_high].
|
|
'''
|
|
if x > old_high or x < old_low:
|
|
raise ValueError('%d not in range [%d..%d]' % (x, old_low, old_high))
|
|
percentage = (x - old_low) / (old_high - old_low)
|
|
y = (percentage * (new_high - new_low)) + new_low
|
|
return y
|
|
|
|
def position_from_degree(d, damping_units):
|
|
rad = math.radians(d)
|
|
sin = math.sin(rad)
|
|
sin = map_range(sin, -1, 1, 0, 1)
|
|
position = sin * (SCREEN_WIDTH - 1)
|
|
position = map_range(position, 0, SCREEN_WIDTH, damping_units, SCREEN_WIDTH-damping_units)
|
|
#position = (position * (1- (2 * damping_percent))) + damping_units
|
|
position = round(position)
|
|
position = position % SCREEN_WIDTH
|
|
return position
|
|
|
|
def print_loop():
|
|
while True:
|
|
next_frame = time.time() + variables['delay']
|
|
variables['clock'] = (variables['clock'] + 1) % 360
|
|
|
|
screen = ([' '] * SCREEN_WIDTH)
|
|
z_indexes = {}
|
|
|
|
for line_vars in variables['lines']:
|
|
start_degree = line_vars['degree']
|
|
end_degree = (start_degree + line_vars['degree_step']) % 360
|
|
line_vars['degree'] = end_degree
|
|
|
|
damping = line_vars['damping']
|
|
start_pos = position_from_degree(start_degree, damping)
|
|
end_pos = position_from_degree(end_degree, damping)
|
|
(start_pos, end_pos) = sorted([start_pos, end_pos])
|
|
|
|
start_pos -= line_vars['line_thickness']
|
|
end_pos += line_vars['line_thickness']
|
|
|
|
mini_step = line_vars['degree_step'] / max((end_pos - start_pos), 1)
|
|
for (index, position) in enumerate(range(start_pos, end_pos+1)):
|
|
position = (position + line_vars['horizontal_offset']) % SCREEN_WIDTH
|
|
this_rads = math.radians(start_degree + (mini_step * index))
|
|
z_index = math.cos(this_rads)
|
|
z_index = map_range(z_index, -1, 1, line_vars['depth'], SCREEN_WIDTH-line_vars['depth'])
|
|
#print(line_vars['character'], z_index)
|
|
if z_index > z_indexes.get(position, -2):
|
|
screen[position] = line_vars['character']
|
|
z_indexes[position] = z_index
|
|
|
|
print('%03d' % variables['clock'], ''.join(screen))
|
|
delay = max(next_frame - time.time(), 0)
|
|
time.sleep(delay)
|
|
|
|
def register_line(line):
|
|
variables['lines'].append(line)
|
|
|
|
def regrid_frames():
|
|
frames = variables['frames']
|
|
#frames.sort(key=lambda x: x.line['original_degree'])
|
|
for (index, frame) in enumerate(frames):
|
|
(row, column) = divmod(index, 4)
|
|
row += 1
|
|
frame.grid(row=row, column=column)
|
|
|
|
def unregister_line(line):
|
|
variables['lines'].remove(line)
|
|
|
|
def main():
|
|
global t
|
|
t = tkinter.Tk()
|
|
|
|
frame_add = tkinter.Frame(t)
|
|
entry_add = tkinter.Entry(frame_add)
|
|
t.entry_add = entry_add
|
|
entry_add.grid(row=0, column=0)
|
|
tkinter.Button(frame_add, text='+', command=create_line_frame).grid(row=0, column=1)
|
|
frame_add.grid(row=0, column=0)
|
|
|
|
frame_delay = tkinter.Frame(t)
|
|
tkinter.Label(frame_delay, text='Speed:')
|
|
thread = threading.Thread(target=print_loop)
|
|
thread.daemon=True
|
|
thread.start()
|
|
|
|
create_line_frame([0])
|
|
t.mainloop()
|
|
|
|
if __name__ == '__main__':
|
|
main()
|