Content # Draws stuff based on user input and grammar rules import display import buttons import random import mch22 from machine import Timer animate = False tim1 = Timer(-1) # animate tim2 = Timer(-2) # randomize tim3 = Timer(-3) # clean screen # Weighted randomization for random rulesets rnd_ltr_A = lambda : random.choice("BBBBBDBBBCCCCDDDDaaaabbbccd") rnd_ltr_B = lambda : random.choice("AAAAAAAAACCCCDDDDaaaabbbccd") rnd_ltr_C = lambda : random.choice("AAAABDBBBDDDaaaaaaabbbbbbccccccddddd") rnd_ltr_D = lambda : random.choice("AABBCCCCDDDDDDaaaabbbccccccccdddddddddd") rnd_ltr_CAPS = lambda : random.choice("AABBCCCCDDDDDD") rnd_ltr_TERM = lambda : random.choice("aaabbbccd") def random_rule(): return([ ("AA", rnd_ltr_A() + rnd_ltr_A() + rnd_ltr_A()), ("BB", rnd_ltr_B() + rnd_ltr_B() + rnd_ltr_B()), ("CC", rnd_ltr_C() + rnd_ltr_C()), ("DD", rnd_ltr_D() + rnd_ltr_D()), (rnd_ltr_CAPS() + rnd_ltr_CAPS(), rnd_ltr_TERM() + rnd_ltr_TERM()), ("A", "a"), ("B", "b"), ("C", "c"), ("D", "d") ]) seed = "" # USER INPUT result = "" # INTERMEDIATE RULE draw_result = [] # END RESULT RULE FOR GRAPHICS # The ruleset, first 4 are constant and the rest are random each time rulesets = [ [("AA", "C"), ("BB", "AbA"), ("B", "ACA"), ("A", "a"), ("C", "c")], [("AA", "C"), ("BB", "AbA"), ("CC", "D"), ("B", "ACA"), ("A", "a"), ("C", "c"), ("D", "d")], [("AA", "B"), ("BB", "AcA"), ("CC", "BDB"), ("B", "ACA"), ("A", "a"), ("C", "c"), ("D", "d")], [("AAA", "AD"), ("AA", "CA"), ("CC", "AB"), ("BB", "BDB"), ("B", "ACA"), ("A", "a"), ("C", "c"), ("D", "d")] , random_rule(), random_rule(), random_rule(), random_rule(), random_rule(), random_rule(), random_rule(), random_rule() ] rules_selection = 0 rules = rulesets[rules_selection] # X direction, Y direction, color, position X, poisition Y start_vec = [(1, 0, 0xffa822, (display.width() - 40) / 2 / 5 , display.height() / 2 / 5)] vec = start_vec # The different operations a rule can get identity = lambda v : (v[0], v[1], v[2], v[3]+v[0], v[4]+v[1]) rot_L = lambda v : (v[1], -v[0], v[2], v[3]+v[0], v[4]+v[1]) rot_R = lambda v : (-v[1], v[0], v[2], v[3]+v[0], v[4]+v[1]) rot_F = lambda v : (-v[0], -v[1], v[2], v[3]+v[0], v[4]+v[1]) #rot_C = lambda v : (v[0], v[1], v[2] * 255 % 4228250370, v[3]+v[0], v[4]+v[1]) # A nicer colours rot_C: def rot_C(v): if(v[2] == 0xffa822): return((v[0], v[1], 0x134e6f, v[3]+v[0], v[4]+v[1])) elif(v[2] == 0x134e6f): return((v[0], v[1], 0xff6150, v[3]+v[0], v[4]+v[1])) elif(v[2] == 0xff6150): return((v[0], v[1], 0x1ac0c6, v[3]+v[0], v[4]+v[1])) elif(v[2] == 0x1ac0c6): return((v[0], v[1], 0xdee0e6, v[3]+v[0], v[4]+v[1])) else: return((v[0], v[1], 0xffa822, v[3]+v[0], v[4]+v[1])) # What drawing rules output is assigned with vrules = [("a", identity), ("b", rot_C), ("c", rot_L), ("d", rot_R)] # THE HORROR BEGINS BELOW def draw_rule_text(): display.drawRect(10, 110, 30, 30, True, display.WHITE) display.drawText(10, 110, "Rule\n" + str(rules_selection+1), display.MAGENTA, "roboto_regular12") def draw_bottom_text(): global animate if animate: display.drawText(100, 220, "ANIMATE", display.RED, "roboto_regular12") else: display.drawText(100, 220, "ANIMATE", display.GREEN, "roboto_regular12") display.drawText(30, 220, "QUIT CLEAN DRAW", display.BLACK, "roboto_regular12") def draw_input_text(): global seed display.drawText(8, 8, "Set seed sequence with A & B, delete with <-", display.BLACK, "roboto_regular12") display.drawText(10, 25, seed, display.BLUE, "roboto_regular18") def init_screen(): display.drawFill(display.WHITE) draw_input_text() draw_rule_text() draw_bottom_text() display.flush() # The rules both for parsing the input and converting it to drawing rules # Enrich the user input by feeding it through parser (with some of rules randomly generated) def apply_rules(s): global rules_selection global rulesets for r in rulesets[rules_selection]: if(s.startswith(r[0])): return((r[1], len(r[0]))) return(s[0], 1) # Match the parsed output with corresponding drawing rule def find_draw_rule(s): global vrules for vr in vrules: if(s.startswith(vr[0])): return(vr[1]) def apply_draw_rules(acc, s): if(len(s) == 0): return(acc) r = find_draw_rule(s) # Associate the next drawing rule based on parsed output last = r(acc[-1]) acc.append(last) apply_draw_rules(acc, s[1:]) return(acc) def draw_figure(points): for p in points: display.drawRect(p[3] * 5 % 320, p[4] * 5 % 240, 5, 5, True, p[2]) #display.drawPixel(p[3] * 5 % 320, p[4] * 5 % 240, p[2]) display.flush() def calc_origin_vec(): global vec xorgigin = ( min(vec,key=lambda item:item[3]) + max(vec,key=lambda item:item[3]) ) / 2 xorgigin = ( min(vec,key=lambda item:item[4]) + max(vec,key=lambda item:item[4]) ) / 2 return(xorigin, yorigin) def acc_rules(acc_next): racc = acc_next[0] rnext = acc_next[1] if(rnext != ""): ar = apply_rules(rnext[0:]) return(racc + ar[0], rnext[ar[1]:]) return(racc,"") def run_rules(s_str): acc = "" counter = 0 res = (acc, s_str) while res[1] != "" and counter < 100: counter += 1 res = acc_rules(res) return(res[0]) def iter_rules(s_str): counter = 0 cyc = run_rules(s_str) while cyc.lower() != cyc and counter < 100: counter += 1 cyc = run_rules(cyc) return(cyc) def parse_result(): global result global draw_result global seed global vec result = iter_rules(seed) draw_result = apply_draw_rules(vec, result) # keep only latest ones vec = vec[-10:] # Animation randomization def randomize_state(): global vec global rules_selection #vec[-1][3] = random.randint(10, 54) #vec[-1][4] = random.randint(10, 38) rules_selection = random.randint(0, len(rulesets)) draw_rule_text() display.flush() # Drawing frames def draw_frame(): global draw_result draw_figure(draw_result) display.flush() def animate_frame(): global animate if animate: parse_result() draw_frame() # Button presses def DRAW_btn_press(pressed): if(pressed): parse_result() draw_frame() def ANIM_btn_press(pressed): if(pressed): global animate animate = not animate draw_bottom_text() if animate: tim1.init(period=79, mode=Timer.PERIODIC, callback=lambda t:animate_frame()) tim2.init(period=1151, mode=Timer.PERIODIC, callback=lambda t:randomize_state()) tim3.init(period=71119, mode=Timer.PERIODIC, callback=lambda t:init_screen()) else: tim1.deinit() tim2.deinit() tim3.deinit() display.flush() def A_btn_press(pressed): if pressed: global seed parse_result() seed = seed + "A" draw_input_text() display.flush() def B_btn_press(pressed): if pressed: global seed parse_result() seed = seed + "B" draw_input_text() display.flush() def CLEAN_btn_press(pressed): if(pressed): init_screen() def BCKSPC_btn_press(pressed): if(pressed): global seed seed = seed[0:-1] parse_result() display.drawRect(10 + display.getTextWidth(seed, "roboto_regular18"), 23, 13, 25, True, display.WHITE) display.drawText(10, 25, seed, display.BLUE, "roboto_regular18") display.flush() def RULEUP_btn_press(pressed): if(pressed): global rules_selection global start_vec global vec rules_selection = (rules_selection + 1) % len(rulesets) parse_result() draw_rule_text() display.flush() def RULEDOWN_btn_press(pressed): if(pressed): global rules_selection global start_vec global vec rules_selection = (rules_selection - 1) % len(rulesets) parse_result() draw_rule_text() display.flush() def EXIT_btn_press(pressed): if(pressed): tim1.deinit() tim2.deinit() tim3.deinit() mch22.exit_python() # Attach button functions buttons.attach(buttons.BTN_UP, RULEUP_btn_press) buttons.attach(buttons.BTN_DOWN, RULEDOWN_btn_press) buttons.attach(buttons.BTN_LEFT, BCKSPC_btn_press) buttons.attach(buttons.BTN_SELECT, CLEAN_btn_press) buttons.attach(buttons.BTN_START, DRAW_btn_press) buttons.attach(buttons.BTN_MENU, ANIM_btn_press) buttons.attach(buttons.BTN_A, A_btn_press) buttons.attach(buttons.BTN_B, B_btn_press) buttons.attach(buttons.BTN_HOME, EXIT_btn_press) # Init screen display.drawFill(display.WHITE) draw_input_text() draw_rule_text() draw_bottom_text() display.flush()