From 8605e937a90c3873dea966de64ab6167ea86b15d Mon Sep 17 00:00:00 2001 From: tymek Date: Sun, 17 May 2026 19:55:12 +0200 Subject: [PATCH] first commit --- .idea/.gitignore | 3 + .idea/codeStyles/codeStyleConfig.xml | 5 + .idea/inspectionProfiles/Project_Default.xml | 12 + .../inspectionProfiles/profiles_settings.xml | 6 + .idea/misc.xml | 7 + .idea/modules.xml | 8 + .idea/zolwik.iml | 10 + Nibypait.py | 244 ++++ __pycache__/fraktele.cpython-312.pyc | Bin 0 -> 52172 bytes __pycache__/pilka.cpython-312.pyc | Bin 0 -> 1493 bytes __pycache__/vektory.cpython-312.pyc | Bin 0 -> 1908 bytes fraktele.py | 1296 +++++++++++++++++ mist.py | 17 + nbkalkulator.py | 0 pilka.py | 17 + pilka1.py | 28 + sand.py | 95 ++ statek.py | 526 +++++++ test.py | 108 ++ testy.py | 15 + vektory.py | 32 + 21 files changed, 2429 insertions(+) create mode 100644 .idea/.gitignore create mode 100644 .idea/codeStyles/codeStyleConfig.xml create mode 100644 .idea/inspectionProfiles/Project_Default.xml create mode 100644 .idea/inspectionProfiles/profiles_settings.xml create mode 100644 .idea/misc.xml create mode 100644 .idea/modules.xml create mode 100644 .idea/zolwik.iml create mode 100644 Nibypait.py create mode 100644 __pycache__/fraktele.cpython-312.pyc create mode 100644 __pycache__/pilka.cpython-312.pyc create mode 100644 __pycache__/vektory.cpython-312.pyc create mode 100644 fraktele.py create mode 100644 mist.py create mode 100644 nbkalkulator.py create mode 100644 pilka.py create mode 100644 pilka1.py create mode 100644 sand.py create mode 100644 statek.py create mode 100644 test.py create mode 100644 testy.py create mode 100644 vektory.py diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml new file mode 100644 index 0000000..a55e7a1 --- /dev/null +++ b/.idea/codeStyles/codeStyleConfig.xml @@ -0,0 +1,5 @@ + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..7e7ac73 --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,12 @@ + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000..105ce2d --- /dev/null +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..eb7d473 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,7 @@ + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..70ffb66 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/zolwik.iml b/.idea/zolwik.iml new file mode 100644 index 0000000..6cb8b9a --- /dev/null +++ b/.idea/zolwik.iml @@ -0,0 +1,10 @@ + + + + + + + + + + \ No newline at end of file diff --git a/Nibypait.py b/Nibypait.py new file mode 100644 index 0000000..bd99473 --- /dev/null +++ b/Nibypait.py @@ -0,0 +1,244 @@ +import random +import tkinter as tk +from tkinter import * +from tkinter.ttk import Combobox +from PIL import Image, ImageDraw +import os + +promien = 5 +punkty_do_zapisu = [] +helped = False + + +def kolory(): + lis = ["white", "white smoke", "gainsboro", "light gray", "silver", "gray", "dim gray", "black", "light slate gray", + "slate gray", "alice blue", "light steel blue", "cornflower blue", "royal blue", "blue", "medium blue", + "navy", "dark blue", "midnight blue", "light blue", "deep sky blue", "dodger blue", "powder blue", + "sky blue", "light sky blue", "steel blue", "azure", "light cyan", "cyan", "pale turquoise", + "dark turquoise", "turquoise", "medium turquoise", "light sea green", "cadet blue", "dark cyan", "teal", + "dark slate gray", "mint cream", "aquamarine", "medium aquamarine", "dark sea green", "medium sea green", + "sea green", "honeydew", "pale green", "light green", "medium spring green", "spring green", "lime green", + "green", "forest green", "dark green", "green yellow", "chartreuse", "lawn green", "lime", "yellow green", + "olive drab", "beige", "dark khaki", "olive", "dark olive green", "pale goldenrod", "khaki", "ivory", + "light yellow", "light goldenrod yellow", "cornsilk", "lemon chiffon", "yellow", "gold", "goldenrod", + "dark goldenrod", "wheat", "tan", "burlywood", "peru", "sienna", "saddle brown", "floral white", "old lace", + "navajo white", "moccasin", "sandy brown", "orange", "dark orange", "chocolate", "firebrick", "brown", + "dark red", "maroon", "antique white", "papaya whip", "blanched almond", "bisque", "peach puff", + "light salmon", "coral", "tomato", "orange red", "red", "crimson", "dark salmon", "salmon", "light coral", + "indian red", "rosy brown", "linen", "seashell", "misty rose", "pink", "light pink", "hot pink", "deep pink", + "snow", "lavender blush", "pale violet red", "violet red", "medium violet red", "purple", "dark magenta", + "violet", "magenta", "thistle", "plum", "orchid", "medium orchid", "dark orchid", "dark violet", + "blue violet", "medium purple", "rebecca purple", "indigo", "ghost white", "lavender", "light slate blue", + "medium slate blue", "slate blue", "dark slate blue"] + return lis[random.randrange(0, len(lis))] + + +def on_key_press(event): + print(f"Key pressed: {event.keysym}") + label = tk.Label(root, text=f"Key pressed: {event.keysym} ") + label.config(bg=kolory()) + label.place(x=0, y=0) + if event.keysym == 'd': + canvas.move(kwadrat, 5, 0) + elif event.keysym == 'a': + canvas.move(kwadrat, -5, 0) + elif event.keysym == 'w': + canvas.move(kwadrat, 0, -5) + elif event.keysym == 's': + canvas.move(kwadrat, 0, 5) + # label.pack() + kolor() + + +def on_left_click(event): + print(f"Left click at ({event.x}, {event.y})") + global promien + aktualny_kolor = canvas.itemcget(podonzaj, "fill") + + canvas.create_oval(event.x - promien, event.y - promien, event.x + promien, event.y + promien, + fill=aktualny_kolor, outline="") + punkty_do_zapisu.append((event.x, event.y, promien, aktualny_kolor)) + + +def on_right_click(event): + print(f"Right click at ({event.x}, {event.y})") + + +def on_mouse_motion(event): + odswiez_pozycje_kropki(event.x, event.y) + + +def zapisz_obraz(): + # 1. Znajdowanie wolnego numeru + licznik = 1 + while os.path.exists(f"obraz_tk_{licznik}.png"): + licznik += 1 + + nazwa_pliku = f"obraz_tk_{licznik}.png" + + # 2. Tworzenie i rysowanie obrazu (jak wcześniej) + szer = canvas.winfo_width() + wys = canvas.winfo_height() + obraz = Image.new("RGB", (szer, wys), "white") + rysuj = ImageDraw.Draw(obraz) + + for x, y, r, kolor in punkty_do_zapisu: + rysuj.ellipse([x - r, y - r, x + r, y + r], fill=kolor) + + # 3. Zapis pod nową nazwą + obraz.save(nazwa_pliku) + print(f"Zapisano jako {nazwa_pliku}") + + +def zmien_promien(wartosc): + global promien + promien = int(wartosc) + skrajny_x = root.winfo_pointerx() + skrajny_y = root.winfo_pointery() + canvas_x = skrajny_x - canvas.winfo_rootx() + canvas_y = skrajny_y - canvas.winfo_rooty() + odswiez_pozycje_kropki(canvas_x, canvas_y) + + +def odswiez_pozycje_kropki(x, y): + global promien + canvas.coords(podonzaj, x - promien, y - promien, x + promien, y + promien) + + +def relly(): + rel = Button(root, text="Are you sure???", width=20, bg="red", command=root.destroy) + niet = Button(root, text="no", width=20, fg="black", command=lambda: [rel.place_forget(), niet.place_forget()]) + rel.place(relx=0.5, rely=0.5, anchor=tk.CENTER) + niet.place(relx=1.0, rely=1.0, anchor='se', x=-10, y=-10) + root.bind("", lambda e: root.destroy) + root.bind("", lambda e: [rel.place_forget(), niet.place_forget()]) + # return 0 + + +def skroluj_suwak(event): + obecna = vertical_scale.get() + + if event.num == 4: + nowa = obecna + 1 + elif event.num == 5: + nowa = obecna - 1 + else: + nowa = obecna + + vertical_scale.set(nowa) + + +def kolor(val=None): + r = red.get() + g = green.get() + b = blue.get() + + kolor_hex = f"#{r:02x}{g:02x}{b:02x}" + canvas.itemconfig(podonzaj, fill=kolor_hex) + + +def r_up(event): + aktualna = red.get() + if aktualna < 255: + red.set(aktualna + 5) + + +def r_down(event): + aktualna = red.get() + if aktualna > 0: + red.set(aktualna - 5) + + +def g_up(event): + aktualna = green.get() + if aktualna < 255: + green.set(aktualna + 5) + + +def g_down(event): + aktualna = green.get() + if aktualna > 0: + green.set(aktualna - 5) + + +def b_up(event): + aktualna = blue.get() + if aktualna < 255: + blue.set(aktualna + 5) + + +def b_down(event): + aktualna = blue.get() + if aktualna > 0: + blue.set(aktualna - 5) + + +def helpp(): + global helped + helped = not helped + if helped: + helplist.place(relx=1.0, y=60, anchor='ne') + else: + helplist.place_forget() + + +# global promien +root = Tk() +canvas = tk.Canvas(root, bg="white", highlightthickness=0) +canvas.pack(fill="both", expand=True) +kwadrat = canvas.create_rectangle(50, 50, 100, 100, fill="blue") +podonzaj = canvas.create_oval(100, 100, 110, 110, fill="green") + +root.bind("", on_key_press) +root.bind("", on_left_click) +root.bind("", on_right_click) +root.bind("", on_mouse_motion) +root.bind_all("", skroluj_suwak) +root.bind_all("", skroluj_suwak) + +root.bind("r", r_down) +root.bind("t", r_up) +root.bind("f", g_down) +root.bind("g", g_up) +root.bind("v", b_down) +root.bind("b", b_up) + +stop = Button(root, text="Escape", width=20, bg="red", fg="black", command=relly) +stop.place(relx=0.5, rely=0, anchor='n', y=0) +root.bind("", lambda e: relly()) + +przycisk_zapis = Button(root, text="Zapisz PNG", bg="green", fg="white", command=zapisz_obraz) +przycisk_zapis.place(relx=1.0, rely=0.0, anchor='ne') + +vertical_scale = Scale(root, from_=1, to=50, command=zmien_promien) +vertical_scale.place(x=0, rely=0.5, anchor='sw') +vertical_scale.set(5) + +blue = Scale(root, from_=0, to=255, command=kolor, orient=tk.HORIZONTAL) +blue.place(x=0, rely=1, anchor='sw') +blue.set(0) +green = Scale(root, from_=0, to=255, command=kolor, orient=tk.HORIZONTAL) +green.place(x=0, rely=1, anchor='sw', y=-40) +green.set(0) +red = Scale(root, from_=0, to=255, command=kolor, orient=tk.HORIZONTAL) +red.place(x=0, rely=1, anchor='sw', y=-80) +red.set(0) +rgb = Label(root, text="\nRed \n\n\nGreen \n\nBlue\n") +rgb.place(x=102, rely=1, anchor='nw', y=-122) + +helpbuton = Button(root, text=" Help ", bg="lightblue", fg="blue", command=helpp) +helpbuton.place(relx=1.0, y=30, anchor='ne') +helplist = Listbox(root, bg="lightblue", fg="blue") +instrukcje = ["Scroll - size", "r - red-5", "t - red+5", "f - green-5", "g - green+5", "v - blue-5", "b - blue+5"] + +for opcja in instrukcje: + helplist.insert(tk.END, opcja) + + +wszystkie_teksty = helplist.get(0, tk.END) +najdluzsza_dlugosc = 0 +for tekst in wszystkie_teksty: + najdluzsza_dlugosc = max(najdluzsza_dlugosc, len(tekst)) +helplist.config(width=12, height=helplist.size()) + +root.mainloop() diff --git a/__pycache__/fraktele.cpython-312.pyc b/__pycache__/fraktele.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af19fd6ca153389a35a462cb4a214bfcfd90b8ba GIT binary patch literal 52172 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 i*IYY3O@#yz{mI literal 0 HcmV?d00001 diff --git a/__pycache__/pilka.cpython-312.pyc b/__pycache__/pilka.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..51ccd66ec3e4c7ea09c83d3d8b0b9b4005510e4d GIT binary patch literal 1493 zcmbVMUyB=66hHT7CUY~%Y~AkaR&*t@FHMz(YE>-KQmi5sN=pSHR7;vWo1JDdGu%v! z2`OYH#R;2-2txP4FCdF=egyHw7iG7wJ4R^nDK8ScK9s&}&rLF$Z3|2Bz&-c;zrSj9_Nm)HV=1KJ|;wvisS}jX@cZjdnyw+Yb;bIN7D?nTO7D zb|3X5ze%PKu?}^}Brgr*#Se1GgnS+Y$*ckz2lA5|{EV!K3+djuiSY2;U>@~MB2+7$ zY4VWTeyFXOd2TtyQ1yi6_#qXzmbp+cGE_z0DVm|?@*7scGBZj@oRBPss(syaYay{J zGAxbs=#A`(TQ;+Py=<1Um+OUYu1*&xW05(U+gnuq_SgurU$12(RsJ4 zZ!@De+tCA6+RlGZJ0JJ1bS|zh{gGVUVy|tpL~ymk0h0p9-^S8YJ`d^%ey5Dw%6>A z>lzs;2P!Rz)7kno|+4{#PkA}_RZSswMsbkN&Du_ z%=f)tGqb-10)7OtbMqhVv4GHDeBubqZ8;o);XYE3g45_n0dq@8)X zlrS4cXc@a01-}GCI7ShwLfJ!rvy8!douFl~D34@INpP6>l$f&`_z^o8q9QH)SZ4&z7;rppo+YV?EP0yuf@{i^Ely?p{{07OcZ0&aXi6v2t-Jg#)cAk< zLHQFJzgRReTYF|Bcwvw#js#1$r=hohFA*XEI@jmxK zz`y-S^4nQl7}{8T5ZjlBE7Rp(D|xSPM;_*B4m)X*E^Bh-!;Wl2Jlk$-+FD$_0U3Yd z#(yIBLmg$WyoGJYY9>^ehlsPgEAy#_rBGkR)+u!E@_oEnb`cc66<{ z7aVLL?0e6etaqPr%d7>f7rs*-e7+leb0fKhH?`@O6k*`Bj=g5X{D(HVGf%V8AnhKN0L2h4*O3Xv^ z28Da$)2M1tT~C|#CA5#6$(f{ 0: + lt(90) + print(ilo) + kwgene(wiel, ilo - 1, t) + # fd(wiel) + + +def kolowkole(wie, kol): + fillcolor(kolory()) + if kol: + begin_fill() + + for i in range(36): + forward((2 * pi * wie) / 36) + if wie > 20 and i % 3 == 0: + kolowkole(wie / 5, kol) + left(10) + end_fill() + + +def gwiazda(): + n = int(input("ile ramion: ")) + h = int(input("dułgosc ramion: ")) + w = float(input("wspulczynik pomniejszenia: ")) + a = kolory() + print("kolor wypelnienia (ang): " + a) + h *= 37 + speed(0) + color('gray') + fillcolor(a) + begin_fill() + for kli in range(n): + penup() + fd(h) + x, y = pos() + lt(180) + fd(h) + lt(180) + lt(360 / n / 2) + fd(h * w) + pendown() + goto(x, y) + penup() + goto(0, 0) + rt(360 / n) + fd(h * w) + pendown() + goto(x, y) + penup() + goto(0, 0) + rt(360 / n * 3 / 2) + end_fill() + + +def dzewo(wys): + if wys <= 5: + fd(wys) + bk(wys) + return + pensize(wys / 37) + c = random.randrange(25, 35) + fd(wys) + if w > 9: + lt(c) + dzewo(wys * (1 / 1.5)) + rt(c * 2) + dzewo(wys * (1 / 1.5)) + lt(c) + bk(wys) + + +def pieciokat(w, t): + if w < 2: + return + fillcolor(kolory()) + if t: + begin_fill() + for c in range(5): + pieciokat(w / 2.643, t) + fd(w) + lt(360 / 5) + end_fill() + + +def fgwiazda(w, n): + if n == 0: + fd(w) + return + fgwiazda(w / 3, n - 1) + lt(60) + fgwiazda(w / 3, n - 1) + rt(120) + fgwiazda(w / 3, n - 1) + lt(60) + fgwiazda(w / 3, n - 1) + + +def TT(w, y): + speed(0) + if w < y: + return + fd(w) + if w > y * 1.5: + lt(90) + TT(w * (1 / 1.5), y) + rt(180) + TT(w * (1 / 1.5), y) + lt(90) + bk(w) + + +def koniczyna(w, n): + if n > 2: + + for i in range(n): + fd(w / 10 - i * 2) + lt(90) + koniczyna(w / (i + 2), n - 1) + rt(180) + koniczyna(w / (i + 2), n - 1) + lt(120) + i += 1 + for j in range(n): + rt(30) + bk(w / 10 - (n - j - 1) * 2) + else: + i = 0 + while i * 2 <= w / 10: + fd(w / 10 - i * 2) + lt(30) + i += 1 + for j in range(i): + rt(30) + bk(w / 10 - (i - j - 1) * 2) + + +def trujkat(w, t): + if w > 2: + fillcolor(kolory()) + if t: + begin_fill() + for i in range(3): + fd(w) + lt(120) + trujkat(w / 2, t) + rt(120) + fd(w) + rt(120) + end_fill() + + +def dzewoniekon(ile_k, sto, wiel): + fd(wiel) + if sto == 0: + for i in range(ile_k): + + rt(360 / ile_k) + if wiel / 2 > 5: + dzewoniekon(ile_k, sto, wiel / 2) + else: + fd(wiel / 2) + bk(wiel / 2) + else: + if ile_k % 2 == 1: + if wiel / 2 > 10: + dzewoniekon(ile_k, sto, wiel / 2) + else: + fd(wiel / 2) + bk(wiel / 2) + for i in range(int(ile_k / 2)): + rt(sto) + if wiel / 2 > 10: + dzewoniekon(ile_k, sto, wiel / 2) + else: + fd(wiel / 2) + bk(wiel / 2) + lt(sto * int(ile_k / 2)) + for i in range(int(ile_k / 2)): + lt(sto) + if wiel / 2 > 10: + dzewoniekon(ile_k, sto, wiel / 2) + else: + fd(wiel / 2) + bk(wiel / 2) + rt(sto * int(ile_k / 2)) + else: + lt(sto / 2) + for i in range(int(ile_k / 2)): + rt(sto) + if wiel / 2 > 10: + dzewoniekon(ile_k, sto, wiel / 2) + else: + fd(wiel / 2) + bk(wiel / 2) + lt(sto * (int(ile_k / 2) - 1)) + for i in range(int(ile_k / 2)): + lt(sto) + if wiel / 2 > 10: + dzewoniekon(ile_k, sto, wiel / 2) + else: + fd(wiel / 2) + bk(wiel / 2) + rt(sto * (int(ile_k / 2) - 1)) + rt(sto / 2) + + +def kolory(): + lis = ["white", "white smoke", "gainsboro", "light gray", "silver", "gray", "dim gray", "black", "light slate gray", + "slate gray", "alice blue", "light steel blue", "cornflower blue", "royal blue", "blue", "medium blue", + "navy", "dark blue", "midnight blue", "light blue", "deep sky blue", "dodger blue", "powder blue", + "sky blue", "light sky blue", "steel blue", "azure", "light cyan", "cyan", "pale turquoise", + "dark turquoise", "turquoise", "medium turquoise", "light sea green", "cadet blue", "dark cyan", "teal", + "dark slate gray", "mint cream", "aquamarine", "medium aquamarine", "dark sea green", "medium sea green", + "sea green", "honeydew", "pale green", "light green", "medium spring green", "spring green", "lime green", + "green", "forest green", "dark green", "green yellow", "chartreuse", "lawn green", "lime", "yellow green", + "olive drab", "beige", "dark khaki", "olive", "dark olive green", "pale goldenrod", "khaki", "ivory", + "light yellow", "light goldenrod yellow", "cornsilk", "lemon chiffon", "yellow", "gold", "goldenrod", + "dark goldenrod", "wheat", "tan", "burlywood", "peru", "sienna", "saddle brown", "floral white", "old lace", + "navajo white", "moccasin", "sandy brown", "orange", "dark orange", "chocolate", "firebrick", "brown", + "dark red", "maroon", "antique white", "papaya whip", "blanched almond", "bisque", "peach puff", + "light salmon", "coral", "tomato", "orange red", "red", "crimson", "dark salmon", "salmon", "light coral", + "indian red", "rosy brown", "linen", "seashell", "misty rose", "pink", "light pink", "hot pink", "deep pink", + "snow", "lavender blush", "pale violet red", "violet red", "medium violet red", "purple", "dark magenta", + "violet", "magenta", "thistle", "plum", "orchid", "medium orchid", "dark orchid", "dark violet", + "blue violet", "medium purple", "rebecca purple", "indigo", "ghost white", "lavender", "light slate blue", + "medium slate blue", "slate blue", "dark slate blue"] + return lis[random.randrange(0, len(lis))] + + +def litera(wiel, lit): + pendown() + if lit == "a": + penup() + fd(wiel / 4) + pendown() + for i in range(36): + forward((pi * wiel / 2) / 36) + lt(10) + penup() + fd(wiel / 4) + pendown() + lt(90) + fd(wiel / 2) + bk(wiel / 2) + rt(90) + elif lit == "A": + x = xcor() + y = ycor() + goto(x + wiel / 8, y + wiel / 2) + ob = heading() + rt(ob) + fd(wiel / 4) + bk(wiel / 4) + lt(ob) + goto(x + wiel / 4, y + wiel) + goto(x + wiel / 2, y) + elif lit == "b": + penup() + fd(wiel / 4) + pendown() + for i in range(36): + forward((pi * wiel / 2) / 36) + lt(10) + penup() + bk(wiel / 4) + pendown() + lt(90) + fd(wiel) + bk(wiel) + rt(90) + penup() + fd(wiel / 2) + pendown() + elif lit == "B": + penup() + fd(wiel / 4) + pendown() + for i in range(36): + forward((pi * wiel / 2) / 36) + lt(10) + penup() + bk(wiel / 4) + pendown() + + lt(90) + fd(wiel / 2) + rt(90) + + penup() + fd(wiel / 4) + pendown() + for i in range(36): + forward((pi * wiel / 2) / 36) + lt(10) + penup() + bk(wiel / 4) + pendown() + + lt(90) + fd(wiel / 2) + + bk(wiel) + rt(90) + penup() + fd(wiel / 2) + pendown() + elif lit == "c": + penup() + fd(wiel / 4) + lt(180) + for i in range(36): + if i < 22 or i > 33: + pendown() + else: + penup() + fd((pi * wiel / 2) / 36) + rt(10) + rt(180) + penup() + fd(wiel / 4) + pendown() + elif lit == "C": + penup() + fd(wiel / 4) + lt(180) + for i in range(36): + if i < 22 or i > 33: + pendown() + else: + penup() + if i == 9 or i == 27: + fd(wiel / 2) + fd((pi * wiel / 2) / 36) + rt(10) + rt(180) + penup() + fd(wiel / 4) + pendown() + elif lit == "d": + penup() + fd(wiel / 4) + pendown() + for i in range(36): + forward((pi * wiel / 2) / 36) + lt(10) + penup() + fd(wiel / 4) + pendown() + lt(90) + fd(wiel) + bk(wiel) + rt(90) + elif lit == "D": + lt(90) + fd(wiel) + rt(90) + for i in range(36): + fd((pi * wiel) / 72) + rt(5) + lt(180) + penup() + fd(wiel / 2) + pendown() + elif lit == "e": + penup() + fd(wiel / 4) + pendown() + lt(180) + for i in range(36): + + if 27 <= i <= 32: + penup() + else: + pendown() + fd((pi * wiel / 2) / 36) + rt(10) + penup() + rt(90) + fd(wiel / 4) + rt(90) + pendown() + fd(wiel / 4) + bk(wiel / 4) + penup() + lt(90) + bk(wiel / 4) + rt(90) + fd(wiel / 4) + pendown() + elif lit == "E": + lt(90) + fd(wiel) + rt(90) + fd(wiel / 2) + rt(90) + penup() + fd(wiel) + rt(90) + pendown() + fd(wiel / 2) + rt(90) + fd(wiel / 2) + rt(90) + fd(wiel / 4) + bk(wiel / 4) + lt(90) + bk(wiel / 2) + rt(90) + fd(wiel / 2) + elif lit == "f": + x = xcor() + y = ycor() + penup() + fd(wiel / 4) + pendown() + lt(90) + fd(wiel * 3 / 4) + lt(90) + fd(wiel / 4) + bk(wiel / 2) + fd(wiel / 4) + rt(90) + for i in range(9): + fd((pi * wiel / 2) / 36) + rt(10) + penup() + goto(x + wiel / 2, y) + elif lit == "F": + lt(90) + fd(wiel) + rt(90) + fd(wiel / 2) + bk(wiel / 2) + lt(90) + bk(wiel / 2) + rt(90) + fd(wiel / 4) + bk(wiel / 4) + lt(90) + bk(wiel / 2) + rt(90) + penup() + fd(wiel / 2) + pendown() + elif lit == "g": + penup() + fd(wiel / 4) + pendown() + for i in range(36): + fd(wiel / 2 * pi / 36) + lt(10) + penup() + fd(wiel / 4) + pendown() + rt(90) + for i in range(9): + fd(wiel / 2 * pi / 36) + rt(10) + for i in range(9): + lt(10) + bk(wiel / 2 * pi / 36) + bk(wiel / 4) + fd(wiel / 4) + lt(90) + elif lit == "G": + penup() + fd(wiel / 4) + lt(180) + pendown() + for i in range(36): + fd((pi * wiel / 4) / 72) + rt(2.5) + fd(wiel / 2) + for i in range(36): + fd((pi * wiel / 2) / 72) + rt(5) + penup() + fd(wiel / 4) + pendown() + rt(90) + fd(wiel / 4) + bk(wiel / 4) + lt(90) + fd(wiel / 4) + for i in range(36): + fd((pi * wiel / 4) / 72) + rt(2.5) + penup() + bk(wiel / 4) + lt(180) + pendown() + elif lit == "h": + lt(90) + fd(wiel) + bk(wiel / 4 * 3) + for i in range(36): + fd((pi * wiel / 2) / 72) + rt(5) + fd(wiel / 4) + lt(90) + elif lit == "H": + lt(90) + fd(wiel) + bk(wiel / 2) + rt(90) + fd(wiel / 2) + lt(90) + fd(wiel / 2) + bk(wiel) + rt(90) + elif lit == "i": + penup() + fd(wiel / 4) + pendown() + lt(90) + fd(wiel / 4 * 3) + penup() + fd(wiel / 8) + pendown() + lt(90) + for i in range(36): + fd((wiel / 8 * pi) / 36) + rt(10) + lt(90) + penup() + fd(wiel / 8 * 7) + lt(90) + fd(wiel / 4) + pendown() + elif lit == "I": + penup() + fd(wiel / 4) + pendown() + lt(90) + fd(wiel) + bk(wiel) + rt(90) + penup() + fd(wiel / 4) + pendown() + elif lit == "j": + penup() + lt(90) + fd(wiel / 4) + rt(90) + pendown() + fd(wiel / 4) + lt(90) + penup() + fd(wiel / 8) + lt(90) + pendown() + for i in range(36): + fd((wiel / 8 * pi) / 36) + rt(10) + penup() + lt(90) + fd(wiel / 8) + pendown() + fd(wiel / 4 * 3) + for i in range(36): + fd((wiel / 8 * pi) / 36) + rt(6) + fd(wiel / 2) + bk(wiel / 2) + penup() + for i in range(36): + bk((wiel / 8 * pi) / 36) + lt(6) + bk(wiel / 2) + lt(90) + fd(wiel / 4) + pendown() + elif lit == "J": + penup() + lt(90) + fd(wiel) + rt(90) + pendown() + fd(wiel / 2) + rt(90) + fd(wiel) + for i in range(36): + fd((wiel / 4 * pi) / 36) + rt(5) + penup() + rt(90) + fd(wiel / 2) + elif lit == "k" or lit == "K": + lt(90) + fd(wiel / 2) + rt(60) + fd(wiel / 2) + bk(wiel / 2) + rt(75) + p = 2 * ((wiel / 2) * (wiel / 2)) + fd(sqrt(p)) + bk(sqrt(p)) + lt(135) + fd(wiel / 2) + bk(wiel) + rt(90) + penup() + fd(wiel / 2) + pendown() + elif lit == "l": + penup() + lt(90) + fd(wiel / 8) + pendown() + fd(wiel / 8 * 7) + lt(180) + fd(wiel / 8 * 7) + for i in range(36): + fd((wiel / 16 * pi) / 36) + lt(2.5) + fd(wiel / 4) + elif lit == "L": + lt(90) + fd(wiel) + bk(wiel) + rt(90) + fd(wiel / 2) + elif lit == "m": + lt(90) + fd(wiel / 2) + for i in range(18): + fd((pi * wiel / 8) / 18) + rt(10) + fd((pi * wiel / 8) / 18) + fd(wiel / 2) + rt(180) + fd(wiel / 2) + for i in range(18): + fd((pi * wiel / 8) / 18) + rt(10) + fd((pi * wiel / 8) / 18) + fd(wiel / 2) + lt(90) + elif lit == "M": + lt(90) + fd(wiel) + x = xcor() + y = ycor() + goto(x + wiel / 4, y - wiel) + goto(x + wiel / 2, y) + bk(wiel) + rt(90) + elif lit == "n": + lt(90) + fd(wiel / 2) + for i in range(18): + rt(10) + fd((2 * pi * wiel / 8) / 18) + fd(wiel / 2) + lt(90) + elif lit == "N": + lt(90) + fd(wiel) + x = xcor() + y = ycor() + goto(x + wiel / 2, y - wiel) + fd(wiel) + bk(wiel) + rt(90) + elif lit == "o": + penup() + fd(wiel / 4) + pendown() + for i in range(36): + lt(10) + fd((2 * pi * wiel / 4) / 36) + penup() + fd(wiel / 4) + pendown() + elif lit == "O": + penup() + fd(wiel / 4) + pendown() + for i in range(18): + lt(5) + fd((2 * pi * wiel / 4) / 72) + fd(wiel / 2) + for i in range(18): + lt(10) + fd((2 * pi * wiel / 4) / 36) + fd(wiel / 2) + for i in range(18): + lt(5) + fd((2 * pi * wiel / 4) / 72) + penup() + fd(wiel / 4) + pendown() + elif lit == "p": + lt(90) + fd(wiel / 2) + bk(wiel) + fd(wiel / 4 * 3) + for i in range(36): + rt(10) + fd((pi * wiel / 2) / 36) + bk(wiel / 4) + penup() + rt(90) + fd(wiel / 2) + elif lit == "P": + lt(90) + fd(wiel) + rt(90) + for i in range(18): + fd((wiel / 4 * pi) / 18) + rt(10) + fd((wiel / 4 * pi) / 18) + penup() + lt(90) + fd(wiel / 2) + lt(90) + fd(wiel / 2) + pendown() + elif lit == "q": + penup() + fd(wiel / 4) + pendown() + for i in range(36): + fd((wiel / 2 * pi) / 36) + lt(10) + penup() + fd(wiel / 4) + pendown() + lt(90) + fd(wiel / 2) + bk(wiel) + fd(wiel / 2) + rt(90) + elif lit == "Q": + penup() + fd(wiel / 4) + pendown() + for i in range(18): + lt(5) + fd((2 * pi * wiel / 4) / 72) + fd(wiel / 2) + for i in range(18): + lt(10) + fd((2 * pi * wiel / 4) / 36) + fd(wiel / 2) + for i in range(18): + lt(5) + fd((2 * pi * wiel / 4) / 72) + rt(45) + fd(wiel / 4) + bk(wiel / 4) + lt(45) + penup() + fd(wiel / 4) + pendown() + elif lit == "r": + lt(90) + fd(wiel / 2) + bk(wiel / 16) + for i in range(18): + rt(5) + fd((2 * pi * wiel / 4) / 36) + for i in range(18): + bk((2 * pi * wiel / 4) / 36) + lt(5) + bk(wiel * 15 / 16 / 2) + rt(90) + penup() + fd(wiel / 2) + elif lit == "R": + lt(90) + fd(wiel) + rt(90) + for i in range(18): + fd((wiel / 4 * pi) / 18) + rt(10) + fd((wiel / 4 * pi) / 18) + goto(xcor() + wiel / 2, ycor() - wiel / 2) + lt(180) + elif lit == "s": + penup() + fd(wiel / 4) + pendown() + for i in range(36): + lt(5) + fd((2 * pi * wiel / 16) / 36) + for i in range(72): + rt(5) + fd((2 * pi * wiel / 16) / 36) + if i == 54: + penup() + for i in range(36): + lt(5) + fd((2 * pi * wiel / 16) / 36) + if i == 18: + pendown() + penup() + fd(wiel / 4) + elif lit == "S": + penup() + fd(wiel / 4) + pendown() + for i in range(36): + lt(5) + fd((2 * pi * wiel / 8) / 36) + for i in range(72): + rt(5) + fd((2 * pi * wiel / 8) / 36) + if (i == 54): + penup() + for i in range(36): + lt(5) + fd((2 * pi * wiel / 8) / 36) + if (i == 18): + pendown() + penup() + fd(wiel / 4) + elif lit == "t": + penup() + fd(wiel / 4) + lt(90) + pendown() + fd(wiel) + bk(wiel / 4) + lt(90) + fd(wiel / 4) + bk(wiel / 2) + fd(wiel / 4) + rt(90) + bk(wiel * 3 / 4) + rt(90) + penup() + fd(wiel / 4) + elif lit == "T": + penup() + fd(wiel / 4) + pendown() + lt(90) + fd(wiel) + lt(90) + fd(wiel / 4) + bk(wiel / 2) + penup() + lt(90) + fd(wiel) + lt(90) + elif lit == "u": + penup() + lt(90) + fd(wiel / 8) + fd(wiel * 3 / 8) + rt(180) + pendown() + fd(wiel * 3 / 8) + for i in range(36): + lt(5) + fd((2 * pi * wiel / 8) / 36) + fd(wiel * 3 / 8) + penup() + bk(wiel / 2) + rt(90) + elif lit == "U": + penup() + lt(90) + fd(wiel / 8) + fd(wiel * 7 / 8) + rt(180) + pendown() + fd(wiel * 7 / 8) + for i in range(36): + lt(5) + fd((2 * pi * wiel / 8) / 36) + fd(wiel * 7 / 8) + penup() + bk(wiel) + rt(90) + elif lit == "v": + penup() + goto(xcor(), ycor() + wiel / 2) + pendown() + goto(xcor() + wiel / 4, ycor() - wiel / 2) + goto(xcor() + wiel / 4, ycor() - wiel / 2) + penup() + goto(xcor(), ycor() - wiel / 2) + elif lit == "V": + penup() + goto(xcor(), ycor() + wiel) + pendown() + goto(xcor() + wiel / 4, ycor() - wiel) + goto(xcor() + wiel / 4, ycor() - wiel) + penup() + goto(xcor(), ycor() - wiel) + elif lit == "w": + penup() + goto(xcor(), ycor() + wiel / 2) + pendown() + goto(xcor() + wiel / 8, ycor() - wiel / 2) + goto(xcor() + wiel / 8, ycor() + wiel / 2) + goto(xcor() + wiel / 8, ycor() - wiel / 2) + goto(xcor() + wiel / 8, ycor() + wiel / 2) + penup() + goto(xcor(), ycor() - wiel / 2) + elif lit == "W": + penup() + goto(xcor(), ycor() + wiel) + pendown() + goto(xcor() + wiel / 8, ycor() - wiel) + goto(xcor() + wiel / 8, ycor() + wiel) + goto(xcor() + wiel / 8, ycor() - wiel) + goto(xcor() + wiel / 8, ycor() + wiel) + penup() + goto(xcor(), ycor() - wiel) + elif lit == "x": + goto(xcor() + wiel / 2, ycor() + wiel / 2) + penup() + bk(wiel / 2) + pendown() + goto(xcor() + wiel / 2, ycor() - wiel / 2) + elif lit == "X": + goto(xcor() + wiel / 2, ycor() + wiel) + penup() + bk(wiel / 2) + pendown() + goto(xcor() + wiel / 2, ycor() - wiel) + elif lit == "y": + penup() + goto(xcor(), ycor() + wiel / 2) + pendown() + goto(xcor() + wiel / 4, ycor() - wiel / 2) + goto(xcor() + wiel / 4, ycor() + wiel / 2) + goto(xcor() - wiel / 2, ycor() - wiel) + penup() + goto(xcor() + wiel / 2, ycor() + wiel / 2) + elif lit == "Y": + penup() + fd(wiel / 4) + lt(90) + pendown() + fd(wiel / 2) + goto(xcor() - wiel / 4, ycor() + wiel / 2) + goto(xcor() + wiel / 4, ycor() - wiel / 2) + goto(xcor() + wiel / 4, ycor() + wiel / 2) + goto(xcor() - wiel / 4, ycor() - wiel / 2) + bk(wiel / 2) + penup() + rt(90) + fd(wiel / 4) + elif lit == "z": + goto(xcor() + (wiel / 2), ycor() + wiel / 2) + bk(wiel / 2) + penup() + goto(xcor(), ycor() - wiel / 2) + pendown() + fd(wiel / 2) + elif lit == "Z": + goto(xcor() + (wiel / 2), ycor() + wiel) + bk(wiel / 2) + penup() + goto(xcor(), ycor() - wiel) + pendown() + fd(wiel / 2) + elif lit == "0": + penup() + fd(wiel / 4) + pendown() + for i in range(18): + lt(5) + fd((2 * pi * wiel / 4) / 72) + fd(wiel / 2) + for i in range(18): + lt(10) + fd((2 * pi * wiel / 4) / 36) + fd(wiel / 2) + for i in range(18): + lt(5) + fd((2 * pi * wiel / 4) / 72) + penup() + lt(90) + fd(wiel / 2) + lt(90) + pendown() + for i in range(36): + rt(10) + fd((2 * pi * wiel / 36) / 36) + penup() + lt(90) + fd(wiel / 2) + lt(90) + fd(wiel / 4) + pendown() + # elif lit == "1": + # elif lit == "2": + # elif lit == "3": + # elif lit == "4": + # elif lit == "5": + # elif lit == "6": + # elif lit == "7": + # elif lit == "8": + # elif lit == "9": + elif lit == "/": + goto(xcor() + wiel / 2, ycor() + wiel) + penup() + goto(xcor(), ycor() - wiel) + elif lit == "$": + penup() + goto(xcor(), ycor() + wiel) + pendown() + goto(xcor() + wiel / 2, ycor() - wiel) + else: + lt(90) + fd(wiel) + rt(90) + fd(wiel / 2) + rt(90) + fd(wiel) + rt(90) + fd(wiel / 2) + x = xcor() + y = ycor() + goto(x + wiel / 2, y + wiel) + fd(wiel / 2) + goto(x + wiel / 2, y) + rt(180) + pendown() + + +k = input("haslo: ") +if k != "surf": + while True: + if random.randrange(0, 10) == 1: + print("Intruz! (# - #)") + else: + print("Intruz! (^ - ^)") + time.sleep(0.3) +while True: + k = input("kod(p-pomoc): ") + if k == "p": + print(" |ko-rysuje kolo |", "\n", "|dz-rysuje drzewo |", "\n", + "|fg-rysuje gwiazge trojkatowa |", "\n", "|gw-rysuje gwiazdę |", "\n", + "|tt-rysuje fraktal złozony z liter'T' |", "\n", "|pi-rysuje pieciokaty w pieciokatach |", "\n", + "|pa-rysuje koniczyne |", "\n", "|tr-rysuje trojkaty w trojkatach |", "\n", + "|dznk-rysuje fraktal do zmodefikowania.|", "\n", "|kk-rysuje kola w kolach |", "\n", + "|pil-rysuje parabole pilki |", "\n", "|del-wyczysc ekran |", "\n", + "|q-wyjscie |", "\n", "|gt-idz do(x,y) |", "\n", + "|vek-vektory") + k = input("kod: ") + if k == "gt": + x, y = input("x,y (-460 10: + pendown() + kolowkole(w, t) + penup() + forward((2 * pi * w) / 144) + lt(90) + fd(w / 2.5) + rt(90) + w -= 2 * w / 5 + if k == "kwa": + wiel = int(input("wielkość(piksele): ")) + t = input("kolor(t/N): ") + if t == "t": + t = True + else: + t = False + # wiel *= 37 + ilo = int(input("ilość: ")) + tracer(0, 0) + li = [] + kwgene(wiel, ilo - 1, t) + # fd(90) + if k == "lit": + w = int(input("wielkość: ")) + l = input("znak: ") + w *= 37 + tracer(0, 0) + litera(w, l) + if k == "nap": + w = input("wielkość: ") + l = input("ciąg znakow: ").split() + w = float(w) + w *= 37 + # print(l) + o = 0 + for i in l: + for j in i: + o += 1 + o += 1 + print("znaki: ", end="") + print(o - 1) + pensize(int(w / 37)) + tracer(0, 0) + px = xcor() + for i in l: + for k in i: + if k == '|': + penup() + fd(w / 10) + goto(px, ycor() - (w + 10)) + pendown() + else: + litera(w, k) + penup() + fd(w / 10) + if xcor() + w > 460: + goto(px, ycor() - (w + 10)) + pendown() + penup() + fd(w) + pendown() + print(" ", end="") + # print("\n", ll) + if k == "pil": + n = int(input("moc: ")) + f = int(input("Kąt(od pionu w prawo): ")) + tracer(0, 0) + # odbicie(n, f) + goto(0, 0) + if k == "del": + clear() + o = 0 + if k == "q": + o = 0 + break + if k == "vek": + n = int(input("Podaj ilość wektorów: ")) + vektor(n) + penup() + goto(0, 0) + rt(heading() + 720) + print("") + pendown() + update() +mainloop() +# aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ \ No newline at end of file diff --git a/mist.py b/mist.py new file mode 100644 index 0000000..5273f6b --- /dev/null +++ b/mist.py @@ -0,0 +1,17 @@ +n = int(input()) +s = 10 +while s >= 10: + s = 0 + while n >= 10: + s += n % 10 + n /= 10 + s += n + if s > 9: + n = s + s = 10 +s=int(s) +if s != 1: + print(s) + +else: + print("Szczesliwego Nowego Roku") diff --git a/nbkalkulator.py b/nbkalkulator.py new file mode 100644 index 0000000..e69de29 diff --git a/pilka.py b/pilka.py new file mode 100644 index 0000000..38341bc --- /dev/null +++ b/pilka.py @@ -0,0 +1,17 @@ +from turtle import * + + +vy = int(input()) +vx = int(input()) +waga = int(input()) +opur=waga/10 +while ycor() >= 0: + vy -= waga - opur + if vx - opur >= 0: + vx -= opur + else: + vx = 0 + goto(vx + xcor(), vy + ycor()) + print(vx, vy) + +mainloop() diff --git a/pilka1.py b/pilka1.py new file mode 100644 index 0000000..f285b33 --- /dev/null +++ b/pilka1.py @@ -0,0 +1,28 @@ +from turtle import * +import turtle as t + +n = int(input()) +speed(1) + +lt(90) + + +def uno(n): + f = n + for i in range(n): + f -= 1 + fd(f) + if f != 0: + rt(90 / n) + for i in range(n): + f += 1 + if f != 0: + rt(90 / n) + fd(f) + if n > 2: + rt(180) + uno(int(n / 2)) + + +uno(n) +t.mainloop() diff --git a/sand.py b/sand.py new file mode 100644 index 0000000..41ed892 --- /dev/null +++ b/sand.py @@ -0,0 +1,95 @@ +from tkinter import * +from random import randrange + +promien = 5 +listapixeli = [] + + +def zmien_promien(wartosc): + global promien + promien = int(wartosc) + skrajny_x = root.winfo_pointerx() + skrajny_y = root.winfo_pointery() + canvas_x = skrajny_x - canvas.winfo_rootx() + canvas_y = skrajny_y - canvas.winfo_rooty() + odswiez_pozycje_kropki(canvas_x, canvas_y) + + +def odswiez_pozycje_kropki(x, y): + global promien + canvas.coords(podonzaj, x - promien, y - promien, x + promien, y + promien) + + +def on_mouse_motion(event): + odswiez_pozycje_kropki(event.x, event.y) + + +def skroluj_suwak(event): + obecna = vertical_scale.get() + + if event.num == 4: + nowa = obecna + 1 + elif event.num == 5: + nowa = obecna - 1 + else: + nowa = obecna + + vertical_scale.set(nowa) + + +def lewywci(event): + canvas.create_rectangle(event.x, event.y, event.x + 1, event.y + 1) + listapixeli.append([event.x, event.y]) + + +def czas(event=None): + canvas.delete("all") + global t + global listapixeli + for x, y in listapixeli: + listapixeli.remove([x, y]) + if y == canvas.winfo_height() - 100: + listapixeli.append([x, y]) + canvas.create_rectangle(x, y, x + 1, y + 1) + elif [x, y + 1] not in listapixeli: + listapixeli.append([x, y + 1]) + canvas.create_rectangle(x, y + 1, x + 1, y + 2) + elif [x + 1, y + 1] not in listapixeli and [x - 1, y + 1] not in listapixeli: + if t: + listapixeli.append([x + 1, y + 1]) + canvas.create_rectangle(x + 1, y + 1, x + 2, y + 2) + t=False + else: + listapixeli.append([x - 1, y + 1]) + canvas.create_rectangle(x - 1, y + 1, x, y + 2) + t=True + elif [x + 1, y + 1] not in listapixeli: + listapixeli.append([x + 1, y + 1]) + canvas.create_rectangle(x + 1, y + 1, x + 2, y + 2) + elif [x - 1, y + 1] not in listapixeli: + listapixeli.append([x - 1, y + 1]) + canvas.create_rectangle(x - 1, y + 1, x, y + 2) + else: + listapixeli.append([x, y]) + canvas.create_rectangle(x, y, x + 1, y + 1) + + # print(listapixeli) + + +t = True +root = Tk() +canvas = Canvas(root, bg="white", highlightthickness=0) +canvas.pack(fill="both", expand=True) + +vertical_scale = Scale(root, from_=1, to=50) # , command=zmien_promien) +vertical_scale.place(x=0, rely=0.5, anchor='sw') +vertical_scale.set(1) + +podonzaj = canvas.create_rectangle(100, 100, 110, 110, fill="green") + +root.bind("", lambda e: [on_mouse_motion, czas]) +# root.bind_all("", skroluj_suwak) +# root.bind_all("", skroluj_suwak) +root.bind("", lewywci) +root.bind("", czas) +root.mainloop() diff --git a/statek.py b/statek.py new file mode 100644 index 0000000..1a5577f --- /dev/null +++ b/statek.py @@ -0,0 +1,526 @@ +import math +from tkinter import * +from random import randrange +import tkinter.ttk as tk + + +def obroc_prostokat_o_2_stopnie_zg(canvas, element_id): + wspolrzedne = canvas.coords(element_id) + xs = [wspolrzedne[i] for i in range(0, len(wspolrzedne), 2)] + ys = [wspolrzedne[i] for i in range(1, len(wspolrzedne), 2)] + cx = sum(xs) / len(xs) + cy = sum(ys) / len(ys) + + radiany = math.radians(2) + cos_k = math.cos(radiany) + sin_k = math.sin(radiany) + + nowe_wspolrzedne = [] + for x_val, y_val in zip(xs, ys): + nx = cx + (x_val - cx) * cos_k - (y_val - cy) * sin_k + ny = cy + (x_val - cx) * sin_k + (y_val - cy) * cos_k + nowe_wspolrzedne.extend([nx, ny]) + + canvas.coords(element_id, nowe_wspolrzedne) + + +def obroc_prostokat_o_2_stopnie_prz(canvas, element_id): + wspolrzedne = canvas.coords(element_id) + xs = [wspolrzedne[i] for i in range(0, len(wspolrzedne), 2)] + ys = [wspolrzedne[i] for i in range(1, len(wspolrzedne), 2)] + cx = sum(xs) / len(xs) + cy = sum(ys) / len(ys) + + radiany = math.radians(-2) + cos_k = math.cos(radiany) + sin_k = math.sin(radiany) + + nowe_wspolrzedne = [] + for x_val, y_val in zip(xs, ys): + nx = cx + (x_val - cx) * cos_k - (y_val - cy) * sin_k + ny = cy + (x_val - cx) * sin_k + (y_val - cy) * cos_k + nowe_wspolrzedne.extend([nx, ny]) + + canvas.coords(element_id, nowe_wspolrzedne) + + +def rusz_w_strone_boku(canvas, element_id, dystans): + wspolrzedne = canvas.coords(element_id) + if len(wspolrzedne) < 8: + return + + x1, y1 = wspolrzedne[4], wspolrzedne[5] + x2, y2 = wspolrzedne[2], wspolrzedne[3] + + kat_krutkiego_boku = math.atan2(y2 - y1, x2 - x1) + kat_ruchu = kat_krutkiego_boku + (math.pi / 2) + + dx = dystans * math.cos(kat_ruchu) + dy = dystans * math.sin(kat_ruchu) + + canvas.move(element_id, dx, dy) + + +def klawisz_wcisniety(event): + key = event.keysym.lower() + if key in wcisniete_klawisze: + if key == "q": + global tempomat + tempomat = not tempomat + else: + wcisniete_klawisze[key] = True + + +def klawisz_puszczony(event): + key = event.keysym.lower() + if key in wcisniete_klawisze and key != "q": + wcisniete_klawisze[key] = False + + +def strzal_z_karabinu(): + global firerate, magazynek, pelny + amo['value'] = magazynek + + if firerate <= 0 < magazynek and pelny: + firerate = 5 + magazynek -= 1 + wspol = canvas.coords(dul) + xs = [wspol[i] for i in range(0, len(wspol), 2)] + ys = [wspol[i] for i in range(1, len(wspol), 2)] + cx = sum(xs) / len(xs) + cy = sum(ys) / len(ys) + + kat_myszy = math.atan2(mysz_y - cy, mysz_x - cx) + + dlugosc_lufy = 15 + start_x = cx + dlugosc_lufy * math.cos(kat_myszy) + start_y = cy + dlugosc_lufy * math.sin(kat_myszy) + + predkosc_karabinu = 12 + dx = predkosc_karabinu * math.cos(kat_myszy) + dy = predkosc_karabinu * math.sin(kat_myszy) + + r_karabinu = 1 + id_karabinu = canvas.create_oval(start_x - r_karabinu, start_y - r_karabinu, start_x + r_karabinu, start_y + r_karabinu, fill="black", outline="") + + karabiny.append({"id": id_karabinu, "dx": dx, "dy": dy}) + + +def stzal_gluwny(event): + global ladowanie, pociski + if ladowanie == 300: + ladowanie = 0 + wspol = canvas.coords(dul) + xs = [wspol[i] for i in range(0, len(wspol), 2)] + ys = [wspol[i] for i in range(1, len(wspol), 2)] + cx = sum(xs) / len(xs) + cy = sum(ys) / len(ys) + + kat_myszy = math.atan2(mysz_y - cy, mysz_x - cx) + + dlugosc_lufy = 15 + start_x = cx + dlugosc_lufy * math.cos(kat_myszy) + start_y = cy + dlugosc_lufy * math.sin(kat_myszy) + + predkosc_pocisku = 15 + dx = predkosc_pocisku * math.cos(kat_myszy) + dy = predkosc_pocisku * math.sin(kat_myszy) + + r_pocisku = 3 + id_pocisku = canvas.create_oval(start_x - r_pocisku, start_y - r_pocisku, start_x + r_pocisku, start_y + r_pocisku, fill="red", outline="black") + + pociski.append({"id": id_pocisku, "dx": dx, "dy": dy}) + + +def aktualizuj_karabiny(): + szerokosc_okna = canvas.winfo_width() + wysokosc_okna = canvas.winfo_height() + + pociski_do_usuniecia = [] + kamyki_do_usuniecia = [] + + for i in range(len(karabiny) - 1, -1, -1): + p = karabiny[i] + canvas.move(p["id"], p["dx"], p["dy"]) + + coords = canvas.coords(p["id"]) + if coords: + px, py = coords[0], coords[1] + if px < 0 or px > szerokosc_okna or py < 0 or py > wysokosc_okna: + pociski_do_usuniecia.append(i) + continue + + for idx, j in enumerate(kamycki): + if j["x"] <= px <= j["x"] + j["pr"] and j["y"] <= py <= j["y"] + j["pr"]: + pociski_do_usuniecia.append(i) + if idx not in kamyki_do_usuniecia and j["pr"] < 12: + kamyki_do_usuniecia.append(idx) + break + + kamyki_do_usuniecia.sort(reverse=True) + for idx in kamyki_do_usuniecia: + kam = kamycki[idx] + + srodek_x = kam["x"] + (kam["pr"] / 2) + srodek_y = kam["y"] + (kam["pr"] / 2) + promien_wybuchu = 10 + wybuch_id = canvas.create_oval(srodek_x - promien_wybuchu, srodek_y - promien_wybuchu, srodek_x + promien_wybuchu, srodek_y + promien_wybuchu, fill="yellow", outline="orange") + root.after(200, lambda wid=wybuch_id: canvas.delete(wid)) + + promien_sladu = 6 + slad_id = canvas.create_oval(srodek_x - promien_sladu, srodek_y - promien_sladu, srodek_x + promien_sladu, srodek_y + promien_sladu, fill="grey13", outline="") + canvas.tag_lower(slad_id) + + canvas.delete(kam["id"]) + kamycki.pop(idx) + + pociski_do_usuniecia = list(set(pociski_do_usuniecia)) + pociski_do_usuniecia.sort(reverse=True) + + for idx in pociski_do_usuniecia: + c = karabiny[idx] + + coords_pocisku = canvas.coords(c["id"]) + if coords_pocisku: + pocisk_x = coords_pocisku[0] + pocisk_y = coords_pocisku[1] + + if 0 <= pocisk_x <= szerokosc_okna and 0 <= pocisk_y <= wysokosc_okna: + promien_wybuchu = 2 + wybuch_id = canvas.create_oval(pocisk_x - promien_wybuchu, pocisk_y - promien_wybuchu, pocisk_x + promien_wybuchu, pocisk_y + promien_wybuchu, fill="yellow", outline="orange") + root.after(400, lambda wid=wybuch_id: canvas.delete(wid)) + + promien_sladu = 1 + slad_id = canvas.create_oval(pocisk_x - promien_sladu, pocisk_y - promien_sladu, pocisk_x + promien_sladu, pocisk_y + promien_sladu, fill="gold", outline="") + canvas.tag_lower(slad_id) + + canvas.delete(c["id"]) + karabiny.pop(idx) + + +def aktualizuj_pociski(): + szerokosc_okna = canvas.winfo_width() + wysokosc_okna = canvas.winfo_height() + + pociski_do_usuniecia = [] + kamyki_do_usuniecia = [] + + for i in range(len(pociski) - 1, -1, -1): + p = pociski[i] + canvas.move(p["id"], p["dx"], p["dy"]) + + coords = canvas.coords(p["id"]) + if coords: + px, py = coords[0], coords[1] + if px < 0 or px > szerokosc_okna or py < 0 or py > wysokosc_okna: + pociski_do_usuniecia.append(i) + continue + + for idx, j in enumerate(kamycki): + if j["x"] <= px <= j["x"] + j["pr"] and j["y"] <= py <= j["y"] + j["pr"]: + pociski_do_usuniecia.append(i) + if idx not in kamyki_do_usuniecia: + kamyki_do_usuniecia.append(idx) + break + + kamyki_do_usuniecia.sort(reverse=True) + for idx in kamyki_do_usuniecia: + kam = kamycki[idx] + srodek_x = kam["x"] + (kam["pr"] / 2) + srodek_y = kam["y"] + (kam["pr"] / 2) + + promien_wybuchu = 24 + wybuch_id = canvas.create_oval(srodek_x - promien_wybuchu, srodek_y - promien_wybuchu, srodek_x + promien_wybuchu, srodek_y + promien_wybuchu, fill="yellow", outline="red", width=2) + root.after(500, lambda wid=wybuch_id: canvas.delete(wid)) + + promien_sladu = 16 + slad_id = canvas.create_oval(srodek_x - promien_sladu, srodek_y - promien_sladu, srodek_x + promien_sladu, srodek_y + promien_sladu, fill="black", outline="") + canvas.tag_lower(slad_id) + + canvas.delete(kam["id"]) + kamycki.pop(idx) + + pociski_do_usuniecia.sort(reverse=True) + for idx in pociski_do_usuniecia: + canvas.delete(pociski[idx]["id"]) + pociski.pop(idx) + + +def sprawdz_kolizje_czolgu(): + global x, tempomat, hp + if x == 0: + return + + wspol = canvas.coords(dul) + if len(wspol) < 8: + return + + xs = [wspol[i] for i in range(0, len(wspol), 2)] + ys = [wspol[i] for i in range(1, len(wspol), 2)] + cx = sum(xs) / len(xs) + cy = sum(ys) / len(ys) + + promien_czolgu = 18 + + for k in kamycki: + + kx_srodek = k["x"] + (k["pr"] / 2) + ky_srodek = k["y"] + (k["pr"] / 2) + odleglosc = math.sqrt((cx - kx_srodek) ** 2 + (cy - ky_srodek) ** 2) + min_odleglosc = promien_czolgu + (k["pr"] / 2) + if odleglosc < min_odleglosc: + nakladanie = min_odleglosc - odleglosc + kat = math.atan2(cy - ky_srodek, cx - kx_srodek) + dx = nakladanie * math.cos(kat) + dy = nakladanie * math.sin(kat) + canvas.move(dul, dx, dy) + + if x >= 0: + hp -= x * 10 + else: + hp += x * 10 + print(x) + hpbar['value'] = hp + hpile["text"] = str(int(hp)) + x = 0 + tempomat = False + break + + +def gluwna(): + global x, tempomat, firerate, czekajmagazynek, pelny, magazynek, ladowanie, pzeladowanie + + if wcisniete_klawisze["a"]: + obroc_prostokat_o_2_stopnie_prz(canvas, dul) + if wcisniete_klawisze["d"]: + obroc_prostokat_o_2_stopnie_zg(canvas, dul) + if wcisniete_klawisze["w"]: + x += 0.02 + tempomat = False + if wcisniete_klawisze["s"]: + x -= 0.01 + tempomat = False + if wcisniete_klawisze["space"]: + strzal_z_karabinu() + if x != 0: + rusz_w_strone_boku(canvas, dul, x) + if x > 0 and not tempomat: + x -= 0.003 + if x < 0 and not tempomat: + x += 0.003 + if x > 2: + x = 2 + if x < -1: + x = -1 + if x != 0: + rusz_w_strone_boku(canvas, dul, x) + sprawdz_kolizje_czolgu() + + wspol = canvas.coords(dul) + xs = [wspol[i] for i in range(0, len(wspol), 2)] + ys = [wspol[i] for i in range(1, len(wspol), 2)] + cx = sum(xs) / len(xs) + cy = sum(ys) / len(ys) + + r = 5 + canvas.coords(wieza, cx - r, cy - r, cx + r, cy + r) + + kxl = (wspol[2] * 3 + wspol[4]) / 4 + kyl = (wspol[3] * 3 + wspol[5]) / 4 + kxp = (wspol[2] + wspol[4] * 3) / 4 + kyp = (wspol[3] + wspol[5] * 3) / 4 + + rk = 2 + canvas.coords(swietlo_lewe, kxl - rk, kyl - rk, kxl + rk, kyl + rk) + canvas.coords(swietlo_prawe, kxp - rk, kyp - rk, kxp + rk, kyp + rk) + + dlugosc_lufy = 15 + kat_myszy = math.atan2(mysz_y - cy, mysz_x - cx) + lx = cx + dlugosc_lufy * math.cos(kat_myszy) + ly = cy + dlugosc_lufy * math.sin(kat_myszy) + canvas.coords(lufa, cx, cy, lx, ly) + + canvas.tag_raise(wieza, dul) + canvas.tag_lower(swietlo_lewe, dul) + canvas.tag_lower(swietlo_prawe, dul) + canvas.tag_raise(temo, prtlo) + + aktualizuj_karabiny() + aktualizuj_pociski() + + if firerate > 0: + firerate -= 1 + + if magazynek == 0 and pelny: + czekajmagazynek = 320 + pelny = False + + if czekajmagazynek > 0: + czekajmagazynek = czekajmagazynek - 1 + amo['value'] = 40 - (czekajmagazynek / 8) + + if czekajmagazynek == 0: + magazynek = 40 + pelny = True + amo['value'] = magazynek + + pzeladowanie['value'] = ladowanie + if ladowanie < 300: + ladowanie += 1 + + aktualizuj_pozycje_figur() + + rk_slad = 1.5 + sxl = (wspol[0] * 3 + wspol[6]) / 4 + syl = (wspol[1] * 3 + wspol[7]) / 4 + sxp = (wspol[0] + wspol[6] * 3) / 4 + syp = (wspol[1] + wspol[7] * 3) / 4 + + k1 = "#00" + str(randrange(4000, 6000, 100)) + k2 = "#00" + str(randrange(4000, 6000, 100)) + + t1 = canvas.create_oval(sxl - rk_slad, syl - rk_slad, sxl + rk_slad, syl + rk_slad, fill=k1, outline="") + t2 = canvas.create_oval(sxp - rk_slad, syp - rk_slad, sxp + rk_slad, syp + rk_slad, fill=k2, outline="") + canvas.tag_lower(t1) + canvas.tag_lower(t2) + canvas.tag_lower(t1) + canvas.tag_lower(t2) + + root.after(16, gluwna) + + +def ruch_myszy(event): + global mysz_x, mysz_y + mysz_x = event.x + mysz_y = event.y + + +def aktualizuj_pozycje_figur(): + wysokosc_okna = canvas.winfo_height() + promien_tarczy = 150 + cx_tarczy = 160 + cy_tarczy = wysokosc_okna - 100 + canvas.coords(prtlo, cx_tarczy - promien_tarczy, cy_tarczy - promien_tarczy, cx_tarczy + promien_tarczy, cy_tarczy + promien_tarczy) + canvas.coords(temo, cx_tarczy + 20, cy_tarczy - 20, cx_tarczy + 35, cy_tarczy - 35) + if tempomat: + canvas.itemconfig(temo, fill="green2") + else: + canvas.itemconfig(temo, fill="firebrick1") + + maks_predkosc = 2.0 + min_predkosc = -1.0 + procent = (x - min_predkosc) / (maks_predkosc - min_predkosc) + stopnie = procent * 270 + aktualny_kat = 225 - stopnie + radiany = math.radians(aktualny_kat) + dlugosc_wskazowki = promien_tarczy - 10 + + wx = cx_tarczy + dlugosc_wskazowki * math.cos(radiany) + wy = cy_tarczy - dlugosc_wskazowki * math.sin(radiany) + canvas.coords(prwska, cx_tarczy, cy_tarczy, wx, wy) + + promien_tekstu = promien_tarczy - 20 + for i, predkosc_punktu in enumerate(wartosci_predkosci): + proc = (predkosc_punktu - min_predkosc) / (maks_predkosc - min_predkosc) + stopn = proc * 270 + kat_napisu = 225 - stopn + rad = math.radians(kat_napisu) + tx = cx_tarczy + promien_tekstu * math.cos(rad) + ty = cy_tarczy - promien_tekstu * math.sin(rad) + canvas.coords(napisy_ids[i], tx, ty) + + +root = Tk() +root.geometry("1000x700") + +canvas = Canvas(root, bg="darkolivegreen", highlightthickness=0) +canvas.pack(fill="both", expand=True) + +x1, y1 = 100, 100 +x2, y2 = 130, 120 + +dul = canvas.create_polygon(x1, y1, x2, y1, x2, y2, x1, y2, fill="green", outline="black") +x = 0 +mysz_x, mysz_y = 0, 0 +wcisniete_klawisze = {"w": False, "s": False, "a": False, "d": False, "q": False, "space": False} + +karabiny = [] +pociski = [] +firerate = 0 +magazynek = 40 +czekajmagazynek = 0 +pelny = True + +style = tk.Style() +style.theme_use('clam') +style.configure("szary.Horizontal.TProgressbar", troughcolor="grey15", background="grey61", thickness=20, borderwidth=0) +style.configure("zielony.Horizontal.TProgressbar", troughcolor="darkgreen", background="green3", thickness=50, borderwidth=0, lightcolor="green3", darkcolor="green3", bordercolor="green4") +amo = tk.Progressbar(root, orient="horizontal", length=300, mode="determinate", style="szary.Horizontal.TProgressbar", maximum=40) +amo.place(x=400, rely=1.0, y=-50) +amo['value'] = magazynek + +ladowanie = 300 +pzeladowanie = tk.Progressbar(root, orient="horizontal", length=300, mode="determinate", style="szary.Horizontal.TProgressbar", maximum=300) +pzeladowanie.place(x=400, rely=1.0, y=-80) +pzeladowanie['value'] = ladowanie + +tempomat = False +temo = canvas.create_oval(0, 0, 0, 0, fill="firebrick1", outline="") + +hp = 100 +hpbar = tk.Progressbar(root, orient="horizontal", length=300, mode="determinate", style="zielony.Horizontal.TProgressbar", maximum=100) +hpbar.place(relx=0.5, y=0, x=-150) +hpbar['value'] = hp +hpile = Label(root, text=hp, background="green4", foreground="green3", font=("Arial", 9, "bold")) +hpile.place(relx=0.5, y=0, x=+150) + +cx_poczatkowy = (x1 + x2) / 2 +cy_poczatkowy = (y1 + y2) / 2 + +promien_kola = 5 +wieza = canvas.create_oval(cx_poczatkowy - promien_kola, cy_poczatkowy - promien_kola, cx_poczatkowy + promien_kola, cy_poczatkowy + promien_kola, fill="darkgreen", outline="black") +kx_poczatkowe = x2 +ky_poczatkowe = (y1 + y2) / 2 + +r_kropki = 2 +swietlo_lewe = canvas.create_oval(kx_poczatkowe - r_kropki, ky_poczatkowe - r_kropki, kx_poczatkowe + r_kropki, ky_poczatkowe + r_kropki, fill="orange2", outline="black") +swietlo_prawe = canvas.create_oval(kx_poczatkowe - r_kropki, ky_poczatkowe - r_kropki, kx_poczatkowe + r_kropki, ky_poczatkowe + r_kropki, fill="orange2", outline="black") +lufa = canvas.create_line(0, 0, 0, 0, fill="black", width=3) + +prtlo = canvas.create_oval(0, 0, 0, 0, fill="grey60", outline="black", width=2) +prwska = canvas.create_line(0, 0, 10, 10, width=5, fill="black") + +wartosci_predkosci = [-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0] +teksty_napisow = ["-1", "-0.75", "-0.5", "-0.25", "0", "0.25", "0.5", "0.75", "1", "1.25", "1.5", "1.75", "2"] +napisy_ids = [] + +for tekst in teksty_napisow: + id_tekstu = canvas.create_text(0, 0, text=tekst, font=("Arial", 10, "bold"), fill="black") + napisy_ids.append(id_tekstu) + +kamycki = [] +for i in range(60): + kax = randrange(0, 1900) + kay = randrange(0, 1000) + ka = "grey" + str(randrange(30, 40)) + wt = randrange(7, 20) + t = canvas.create_oval(kax, kay, kax + wt, kay + wt, fill=ka, outline="") + canvas.tag_lower(t) + kamycki.append({"id": t, "x": kax, "y": kay, "pr": wt}) + +for i in range(1600): + trxx = randrange(0, 1900) + tryy = randrange(0, 1000) + tr = "#00" + str(randrange(40, 60)) + tr += "00" + wt = randrange(3, 7) + t = canvas.create_oval(trxx, tryy, trxx + wt, tryy + wt, fill=tr, outline="") + canvas.tag_lower(t) + +root.bind("", klawisz_wcisniety) +root.bind("", klawisz_puszczony) +root.bind("", ruch_myszy) +root.bind("", stzal_gluwny) + +gluwna() +root.mainloop() diff --git a/test.py b/test.py new file mode 100644 index 0000000..82b7f69 --- /dev/null +++ b/test.py @@ -0,0 +1,108 @@ +zawartosc = """====================================================================== + LISTA ZNAKÓW, KLAWISZY I MYSZY W TKINTER (EVENT.KEYSYM / BIND) +====================================================================== + +1. LITERY I CYFRY +---------------------------------------------------------------------- +Znak | Nazwa w Tkinter (event.keysym) +---------------------------------------------------------------------- +a do z | "a" do "z" (zawsze małe przy ) +0 do 9 | "0" do "9" + + +2. KLAWISZE STERUJĄCE I SPECJALNE +---------------------------------------------------------------------- +Znak / Klawisz | Nazwa w Tkinter (event.keysym) +---------------------------------------------------------------------- +Spacja | "space" +Enter / Powrót | "Return" +Backspace | "BackSpace" +Tabulator | "Tab" +Caps Lock | "Caps_Lock" +Shift (lewy) | "Shift_L" +Shift (prawy) | "Shift_R" +Ctrl (lewy) | "Control_L" +Ctrl (prawy) | "Control_R" +Alt (lewy) | "Alt_L" +Alt Gr (prawy) | "Alt_R" +Escape | "Escape" + + +3. STRZAŁKI I NAWIGACJA +---------------------------------------------------------------------- +Klawisz | Nazwa w Tkinter (event.keysym) +---------------------------------------------------------------------- +Strzałka w górę | "Up" +Strzałka w dół | "Down" +Strzałka w lewo | "Left" +Strzałka w prawo| "Right" +Home | "Home" +End | "End" +Page Up | "Prior" +Page Down | "Next" +Insert | "Insert" +Delete | "Delete" + + +4. ZNAKI INTERPUNKCYJNE I MATEMATYCZNE +---------------------------------------------------------------------- +Znak | Nazwa w Tkinter (event.keysym) +---------------------------------------------------------------------- +. | "period" +, | "comma" +/ | "slash" +\\ | "backslash" +; | "semicolon" +' | "apostrophe" +[ | "bracketleft" +] | "bracketright" +- | "minus" += | "equal" +` | "grave" + + +5. KLAWISZE NUMERYCZNE (KEYPAD) +---------------------------------------------------------------------- +Klawisz (Num) | Nazwa w Tkinter (event.keysym) +---------------------------------------------------------------------- +Cyfry 0 do 9 | "KP_0" do "KP_9" ++ | "KP_Add" +- | "KP_Subtract" +* | "KP_Multiply" +/ | "KP_Divide" +Enter | "KP_Enter" +. | "KP_Decimal" + + +6. PRZYCISKI MYSZY (KLIKNIĘCIA) +---------------------------------------------------------------------- +Akcja myszy | Nazwa zdarzenia (root.bind) +---------------------------------------------------------------------- +Lewy przycisk myszy | "" lub "" +Środkowy przycisk (rolka) | "" lub "" +Prawy przycisk myszy | "" lub "" +Puszczenie lewego przycisku | "" +Puszczenie środkowego przycisku| "" +Puszczenie prawego przycisku | "" +Podwójne kliknięcie lewym | "" +Potrójne kliknięcie lewym | "" + + +7. RUCH MYSZY I ZACHOWANIE +---------------------------------------------------------------------- +Akcja myszy | Nazwa zdarzenia (root.bind) +---------------------------------------------------------------------- +Ruch myszy bez klikania | "" +Przeciąganie z wciśniętym lewym| "" +Przeciąganie z wciśniętym prawym| "" +Ruch rolką w górę / dół | "" +Wejście kursora w obszar okna | "" +Opuszczenie obszaru okna | "" +---------------------------------------------------------------------- +""" + +# Zapisywanie danych do pliku tekstowego z kodowaniem UTF-8 (w celu obsługi polskich znaków) +with open("lista_tkinter.txt", "w", encoding="utf-8") as plik: + plik.write(zawartosc) + +print("Plik 'lista_tkinter.txt' został pomyślnie utworzony!") \ No newline at end of file diff --git a/testy.py b/testy.py new file mode 100644 index 0000000..a6f815e --- /dev/null +++ b/testy.py @@ -0,0 +1,15 @@ +from turtle import * +import turtle as t + + +def cc(c): + if c <= 3: + o = 0 + return + fd(c) + lt(30) + cc(c / 2) + + +cc(80) +t.mainloop() diff --git a/vektory.py b/vektory.py new file mode 100644 index 0000000..d4b6736 --- /dev/null +++ b/vektory.py @@ -0,0 +1,32 @@ +from turtle import * +from itertools import permutations + + +def vektor(ile): + t = [[0 for _ in range(2)] for _ in range(ile)] + print(t) + for i in range(ile): + print(i + 1, end="") + t[i][0], t[i][1] = input(". wektor: ").split(" ") + t[i][0] = int(t[i][0]) + t[i][1] = int(t[i][1]) + print(t) + w = [list(p) for p in permutations(t)] + print(w) + pensize(2) + for i in range(ile): + goto(t[i][0], t[i][1]) + penup() + goto(0, 0) + pendown() + pensize(1) + + for i in range(len(w)): + for j in range(len(w[i])): + goto(w[i][j][0] + xcor(), w[i][j][1] + ycor()) + penup() + goto(0, 0) + pendown() + + +mainloop()