tanks/statek.py

import math
from tkinter import *
from tkinter import ttk
from random import randrange


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 = 0.1
        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 = 8
        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 = 8
        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 cele_ruch():
    global cele
    x1, y1, x2, y2, x3, y3, x4, y4 = canvas.coords(dul)
    celx = int((x1 + x2 + x3 + x4) / 4)
    cely = int((y1 + y2 + y3 + y4) / 4)
    for idx, c in enumerate(cele):
        if c["x1"] < celx:
            c["l"] = False
        if c["x2"] > celx:
            c["l"] = True
        if c["l"]:
            canvas.move(c["id"], -1, 0)
            c["x1"] -= 1
            c["x2"] -= 1
        else:
            canvas.move(c["id"], 1, 0)
            c["x1"] += 1
            c["x2"] += 1
        c["ip"].place(x=c["x1"] + 2.5, y=c["y1"] - 10)
        c["ip"]['value'] = c["hp"]


def aktualizuj_karabiny():
    global cele_zniszczone
    szerokosc_okna = canvas.winfo_width()
    wysokosc_okna = canvas.winfo_height()

    pociski_do_usuniecia = []
    kamyki_do_usuniecia = []
    cele_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
            for idx, c in enumerate(cele):
                if c["x1"] <= px <= c["x2"] and c["y1"] <= py <= c["y2"]:
                    pociski_do_usuniecia.append(i)
                    if idx not in cele_do_usuniecia:
                        c["hp"] -= 1
                        if c["hp"] <= 0:
                            cele_do_usuniecia.append(idx)
                    break

    cele_do_usuniecia.sort(reverse=True)
    for idx in cele_do_usuniecia:
        c = cele[idx]
        c["ip"].destroy()
        srodek_x = (c["x1"] + c["x2"]) / 2
        srodek_y = (c["y1"] + c["y2"]) / 2

        promien_wybuchu = 24
        wybuch_id1 = 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)
        promien_wybuchu = 18
        wybuch_id2 = 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)
        promien_wybuchu = 13
        wybuch_id3 = 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)
        promien_wybuchu = 17
        wybuch_id4 = canvas.create_oval(srodek_x - promien_wybuchu, srodek_y - promien_wybuchu, srodek_x + promien_wybuchu, srodek_y + promien_wybuchu, fill="grey60", outline="", width=2)
        canvas.tag_lower(wybuch_id2, wybuch_id1)
        canvas.tag_lower(wybuch_id3, wybuch_id2)
        canvas.tag_lower(wybuch_id4, wybuch_id3)
        root.after(500, lambda wid1=wybuch_id1: canvas.delete(wid1))
        root.after(1000, lambda wid2=wybuch_id2: canvas.delete(wid2))
        root.after(1500, lambda wid3=wybuch_id3: canvas.delete(wid3))
        root.after(3000, lambda wid4=wybuch_id4: canvas.delete(wid4))
        slad_id = canvas.create_rectangle(srodek_x - 15, srodek_y - 10,
                                          srodek_x + 15, srodek_y + 10,
                                          fill="black", outline="")
        canvas.tag_lower(slad_id)

        canvas.delete(c["id"])
        cele.pop(idx)
        cele_zniszczone += 1
        tekst_celu["text"] = f"Cele do zniszczenia: {cele_zniszczone}/{cel_wymagany}"
        if cele_zniszczone == cel_wymagany:
            tekst_celu["text"] = "MISJA UKOŃCZONA! ZNISZCZYŁEŚ CELE!"
            tekst_celu["foreground"] = "gold"
            root.after(5000, lambda: tekst_celu.place_forget())

    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 misja():
    print("X")
    global ktura_misja, cele, cele_zniszczone, cel_wymagany
    ktura_misja += 1
    tekst_celu.place(x=20, y=20)
    tekst_celu["text"] = f"misja {ktura_misja}"
    cele = []
    cele_zniszczone = 0
    cel_wymagany = ktura_misja * 5

    for i in range(cel_wymagany):
        cx = randrange(200, 900)
        cy = randrange(200, 600)
        wrog_id = canvas.create_polygon(cx, cy, cx + 30, cy, cx + 30, cy + 20, cx, cy + 20, fill="red3", outline="black")
        hp_wrog_id = ttk.Progressbar(root, orient="horizontal", length=25, mode="determinate", style="wrog.Horizontal.TProgressbar", maximum=60)
        hp_wrog_id.place(x=cx, y=cy - 10)
        hp_wrog_id['value'] = 10
        cele.append({"id": wrog_id, "x1": cx, "y1": cy, "x2": cx + 30, "y2": cy + 20, "hp": 60, "l": True, "ip": hp_wrog_id})


def aktualizuj_pociski():
    global cele_zniszczone
    szerokosc_okna = canvas.winfo_width()
    wysokosc_okna = canvas.winfo_height()

    pociski_do_usuniecia = []
    kamyki_do_usuniecia = []
    cele_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
            for idx, c in enumerate(cele):
                if c["x1"] <= px <= c["x2"] and c["y1"] <= py <= c["y2"]:
                    pociski_do_usuniecia.append(i)
                    if idx not in cele_do_usuniecia:
                        cele_do_usuniecia.append(idx)
                    break

    cele_do_usuniecia.sort(reverse=True)
    for idx in cele_do_usuniecia:
        c = cele[idx]

        srodek_x = (c["x1"] + c["x2"]) / 2
        srodek_y = (c["y1"] + c["y2"]) / 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(c["id"])
        c["ip"].place_forget()
        cele.pop(idx)
        cele_zniszczone += 1
        tekst_celu["text"] = f"Cele do zniszczenia: {cele_zniszczone}/{cel_wymagany}"
        if cele_zniszczone == cel_wymagany:
            tekst_celu["text"] = "MISJA UKOŃCZONA! ZNISZCZYŁEŚ CELE!"
            tekst_celu["foreground"] = "gold"
            root.after(5000, lambda: tekst_celu.place_forget())
            root.after(7000, misja)
    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
            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'] = 160 - (czekajmagazynek / 2)

        if czekajmagazynek == 0:
            magazynek = 160
            pelny = True
            amo['value'] = magazynek

    pzeladowanie['value'] = ladowanie
    if ladowanie < 300:
        ladowanie += 1

    aktualizuj_pozycje_figur()

    rk_slad = 1.5
    klawisze_ruchu = ["w", "s", "a", "d"]

    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

    if any(wcisniete_klawisze[k] for k in klawisze_ruchu):
        k1 = "#00" + str(randrange(5000, 6000, 100))
        k2 = "#00" + str(randrange(5000, 6000, 100))
        sl = True
    elif x != 0:
        k1 = "#00" + str(randrange(6000, 7000, 100))
        k2 = "#00" + str(randrange(6000, 7000, 100))
        sl = True
    else:
        sl = False
        k2 = k1 = "#000000"

    if sl:
        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)

    cele_ruch()
    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 = 160
czekajmagazynek = 0
pelny = True

style = ttk.Style()
style.theme_use('default')
style.configure("szary.Horizontal.TProgressbar", troughcolor="grey15", background="grey61", thickness=15, borderwidth=1)
style.configure("zielony.Horizontal.TProgressbar", troughcolor="darkgreen", background="green3", thickness=15, borderwidth=1, lightcolor="green3", darkcolor="green3", bordercolor="green4")
amo = ttk.Progressbar(root, orient="horizontal", length=300, mode="determinate", style="szary.Horizontal.TProgressbar", maximum=160)
amo.place(x=400, rely=1.0, y=-50)
amo['value'] = magazynek

ladowanie = 300
pzeladowanie = ttk.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 = ttk.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)

cele = []
cele_zniszczone = 0
cel_wymagany = 5
ktura_misja = 1
tekst_celu = Label(root, text=f"Cele do zniszczenia: {cele_zniszczone}/{cel_wymagany}", background="darkolivegreen", foreground="white", font=("Arial", 14, "bold"))
tekst_celu.place(x=20, y=20)
style.configure("wrog.Horizontal.TProgressbar", troughcolor="darkgreen", background="green3", borderwidth=0, thickness=6)
for i in range(cel_wymagany):
    cx = randrange(200, 900)
    cy = randrange(200, 600)
    wrog_id = canvas.create_polygon(cx, cy, cx + 30, cy, cx + 30, cy + 20, cx, cy + 20, fill="red3", outline="black")
    hp_wrog_id = ttk.Progressbar(root, orient="horizontal", length=25, mode="determinate", style="wrog.Horizontal.TProgressbar", maximum=60)
    hp_wrog_id.place(x=cx, y=cy - 10)
    hp_wrog_id['value'] = 10
    cele.append({"id": wrog_id, "x1": cx, "y1": cy, "x2": cx + 30, "y2": cy + 20, "hp": 60, "l": True, "ip": hp_wrog_id})

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("<KeyPress>", klawisz_wcisniety)
root.bind("<KeyRelease>", klawisz_puszczony)
root.bind("<Motion>", ruch_myszy)
root.bind("<Button-1>", stzal_gluwny)

gluwna()
root.mainloop()