commit 8605e937a90c3873dea966de64ab6167ea86b15d Author: tymek Date: Sun May 17 19:55:12 2026 +0200 first commit 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 0000000..af19fd6 Binary files /dev/null and b/__pycache__/fraktele.cpython-312.pyc differ diff --git a/__pycache__/pilka.cpython-312.pyc b/__pycache__/pilka.cpython-312.pyc new file mode 100644 index 0000000..51ccd66 Binary files /dev/null and b/__pycache__/pilka.cpython-312.pyc differ diff --git a/__pycache__/vektory.cpython-312.pyc b/__pycache__/vektory.cpython-312.pyc new file mode 100644 index 0000000..e18764a Binary files /dev/null and b/__pycache__/vektory.cpython-312.pyc differ diff --git a/fraktele.py b/fraktele.py new file mode 100644 index 0000000..e0eb20b --- /dev/null +++ b/fraktele.py @@ -0,0 +1,1296 @@ +import random +import time +from turtle import * +from math import pi, sqrt +from itertools import permutations + + +def kolo(): + print("rogi: 360") + h = int(input("promień w centymetrach: ")) + c = input("kolor wypełnienia (ang): ") + h *= 37 + speed(0) + penup() + goto(0, -h) + pendown() + color('gray') + try: + fillcolor(c) + except: + print("no no no, white!") + fillcolor("white") + begin_fill() + for o in range(360): + forward((2 * pi * h) / 360) + left(1) + end_fill() + + +def vektor(ile): + t = [[0 for _ in range(2)] for _ in range(ile)] + 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]) + + w = [list(p) for p in permutations(t)] + 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() + + +def kwgene(wiel, ilo, t): + fillcolor(kolory()) + if t: + begin_fill() + for i in range(random.randrange(5, 10)): + rt(90) + fd(wiel) + if i == 3: + end_fill() + if ilo > 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()