414 lines
16 KiB
Python
414 lines
16 KiB
Python
from tkinter import *
|
|
from random import randrange as rand
|
|
from random import uniform as uni
|
|
from math import radians, cos, sin, atan2, sqrt
|
|
|
|
|
|
def obroc(x, y, sx, sy, a_stopnie):
|
|
a_rad = radians(a_stopnie)
|
|
x_nowy = (x - sx) * cos(a_rad) - (y - sy) * sin(a_rad) + sx
|
|
y_nowy = (x - sx) * sin(a_rad) + (y - sy) * cos(a_rad) + sy
|
|
return x_nowy, y_nowy
|
|
|
|
|
|
def klawisz_wcisniety(event):
|
|
key = event.keysym.lower()
|
|
if key in wcisniete_klawisze:
|
|
wcisniete_klawisze[key] = True
|
|
|
|
|
|
def klawisz_puszczony(event):
|
|
key = event.keysym.lower()
|
|
if key in wcisniete_klawisze:
|
|
wcisniete_klawisze[key] = False
|
|
|
|
|
|
def gluwna():
|
|
global czekaj_scala, przeladowanie
|
|
rusz()
|
|
strzal()
|
|
aktu_pociski()
|
|
skala()
|
|
asteroidy_ruch()
|
|
sprawdz_kolizje_statku()
|
|
sprawdz_kolizje_asteroid_i_pociskow()
|
|
odlamki_ruch()
|
|
czekaj_scala -= 1
|
|
przeladowanie -= 1
|
|
root.after(16, gluwna)
|
|
|
|
|
|
def asteroidy_ruch():
|
|
for a in range(len(asteroidy)):
|
|
ast = asteroidy[a]
|
|
xp = uni(-0.01, 0.01)
|
|
ast["dx"] += xp
|
|
yp = uni(-0.01, 0.01)
|
|
ast["dy"] += yp
|
|
canvas.move(ast["id"], ast["dx"], ast["dy"])
|
|
if ast["dziury"]:
|
|
for dz in ast["dziury"]:
|
|
canvas.move(dz["id1"], ast["dx"], ast["dy"])
|
|
canvas.move(dz["id2"], ast["dx"], ast["dy"])
|
|
dz["x"] += ast["dx"]
|
|
dz["y"] += ast["dy"]
|
|
|
|
|
|
def sprawdz_kolizje_statku():
|
|
global v, mapa_x, mapa_y
|
|
if v == 0:
|
|
return
|
|
cx = srodek_ekranu_x
|
|
cy = srodek_ekranu_y
|
|
promien_statku = 25
|
|
|
|
for k in asteroidy:
|
|
kordy_ast = canvas.coords(k["id"])
|
|
if len(kordy_ast) < 4:
|
|
continue
|
|
|
|
kx_srodek = (kordy_ast[0] + kordy_ast[2]) / 2
|
|
ky_srodek = (kordy_ast[1] + kordy_ast[3]) / 2
|
|
r_asteroidy = k["r"]
|
|
odleglosc = sqrt((cx - kx_srodek) ** 2 + (cy - ky_srodek) ** 2)
|
|
min_odleglosc = promien_statku + r_asteroidy
|
|
|
|
if odleglosc < min_odleglosc:
|
|
nakladanie = min_odleglosc - odleglosc
|
|
kat = atan2(cy - ky_srodek, cx - kx_srodek)
|
|
dx = nakladanie * cos(kat)
|
|
dy = nakladanie * sin(kat)
|
|
|
|
canvas.move("gwiazdy", dx, dy)
|
|
canvas.move(koniec_mapy, dx, dy)
|
|
mapa_x -= dx
|
|
mapa_y -= dy
|
|
v = 0
|
|
wcisniete_klawisze["w"] = False
|
|
break
|
|
|
|
|
|
def odlamki_ruch():
|
|
if odlamki:
|
|
for odlamek in odlamki:
|
|
canvas.move(odlamek["id"], odlamek["dx"], odlamek["dy"])
|
|
|
|
|
|
def sprawdz_kolizje_asteroid_i_pociskow():
|
|
for ast in asteroidy:
|
|
kordy_ast = canvas.coords(ast["id"])
|
|
if not kordy_ast:
|
|
continue
|
|
|
|
srx = (kordy_ast[0] + kordy_ast[2]) / 2
|
|
sry = (kordy_ast[1] + kordy_ast[3]) / 2
|
|
r_ast = ast["r"]
|
|
|
|
for zast in asteroidy:
|
|
if ast["id"] == zast["id"]:
|
|
continue
|
|
|
|
kordy_zast = canvas.coords(zast["id"])
|
|
if not kordy_zast: continue
|
|
|
|
srxz = (kordy_zast[0] + kordy_zast[2]) / 2
|
|
sryz = (kordy_zast[1] + kordy_zast[3]) / 2
|
|
r_zast = zast["r"]
|
|
|
|
odleglosc = sqrt((srx - srxz) ** 2 + (sry - sryz) ** 2)
|
|
min_odleglosc = r_ast + r_zast
|
|
# print(f"Sprawdzam asteroidę {ast["id"]}. Liczba dziur: {len(ast["dziury"])}")
|
|
if odleglosc < min_odleglosc:
|
|
ast["dx"] = -ast["dx"]
|
|
ast["dy"] = -ast["dy"]
|
|
zast["dx"] = -zast["dx"]
|
|
zast["dy"] = -zast["dy"]
|
|
canvas.move(ast["id"], ast["dx"], ast["dy"])
|
|
if ast["dziury"]:
|
|
for dz in ast["dziury"]:
|
|
canvas.move(dz["id1"], ast["dx"], ast["dy"])
|
|
canvas.move(dz["id2"], ast["dx"], ast["dy"])
|
|
dz["x"] += ast["dx"]
|
|
dz["y"] += ast["dy"]
|
|
|
|
# print("xx")
|
|
if len(kordy_ast) >= 4:
|
|
kx_srodek = (kordy_ast[0] + kordy_ast[2]) / 2
|
|
ky_srodek = (kordy_ast[1] + kordy_ast[3]) / 2
|
|
r_ast = ast["r"]
|
|
for p in range(len(pociski) - 1, -1, -1):
|
|
po = pociski[p]
|
|
|
|
pos1 = canvas.coords(po["id1"])
|
|
pos2 = canvas.coords(po["id2"])
|
|
|
|
if not pos1 or not pos2:
|
|
continue
|
|
pos_x = (pos1[0] + pos1[2] + pos2[0] + pos2[2]) / 4
|
|
pos_y = (pos1[1] + pos1[3] + pos2[1] + pos2[3]) / 4
|
|
rpos = po["r"]
|
|
odleglosc = sqrt((pos_x - kx_srodek) ** 2 + (pos_y - ky_srodek) ** 2)
|
|
if odleglosc < r_ast + rpos:
|
|
prze = 2 * po["rr"] + uni(0.0, 1.0)
|
|
canvas.move(po["id1"], po["dx"] * prze, po["dy"] * prze)
|
|
canvas.move(po["id2"], po["dx"] * prze, po["dy"] * prze)
|
|
pos1 = canvas.coords(po["id1"])
|
|
pos2 = canvas.coords(po["id2"])
|
|
if pos1 and pos2:
|
|
p1_srodek_x = (pos1[0] + pos1[2]) / 2
|
|
p1_srodek_y = (pos1[1] + pos1[3]) / 2
|
|
p2_srodek_x = (pos2[0] + pos2[2]) / 2
|
|
p2_srodek_y = (pos2[1] + pos2[3]) / 2
|
|
pos_x = (p1_srodek_x + p2_srodek_x) / 2
|
|
pos_y = (p1_srodek_y + p2_srodek_y) / 2
|
|
dz1 = canvas.create_oval(p1_srodek_x - po["rr"], p1_srodek_y - po["rr"], p1_srodek_x + po["rr"], p1_srodek_y + po["rr"], fill=kolory[po["zestaw"]][po["kolor"] - 1], outline=kolory[po["zestaw"]][po["kolor"]], tags="gwiazdy")
|
|
dz2 = canvas.create_oval(p2_srodek_x - po["rr"], p2_srodek_y - po["rr"], p2_srodek_x + po["rr"], p2_srodek_y + po["rr"], fill=kolory[po["zestaw"]][po["kolor"] - 1], outline=kolory[po["zestaw"]][po["kolor"]], tags="gwiazdy")
|
|
ast["dziury"].append({"id1": dz1, "id2": dz2, "x": pos_x, "y": pos_y})
|
|
|
|
for odla in range(10):
|
|
odlamek1 = canvas.create_oval(p1_srodek_x - po["rr"], p1_srodek_y - po["rr"], p1_srodek_x + po["rr"], p1_srodek_y + po["rr"], fill=f"grey{rand(20, 30)}", outline="", tags="gwiazdy")
|
|
odlamki.append({"id": odlamek1, "dx": uni(-1.0, 1.0), "dy": uni(-1.0, 1.0)})
|
|
root.after(1000, lambda od=odlamek1: canvas.delete(od))
|
|
|
|
odlamek2 = canvas.create_oval(p2_srodek_x - po["rr"], p2_srodek_y - po["rr"], p2_srodek_x + po["rr"], p2_srodek_y + po["rr"], fill=f"grey{rand(20, 30)}", outline="", tags="gwiazdy")
|
|
odlamki.append({"id": odlamek2, "dx": uni(-1.0, 1.0), "dy": uni(-1.0, 1.0)})
|
|
root.after(1000, lambda od=odlamek2: canvas.delete(od))
|
|
|
|
root.after(600, lambda d1=dz1: canvas.itemconfig(d1, fill=f"grey{rand(10, 30)}", outline=""))
|
|
root.after(600, lambda d2=dz2: canvas.itemconfig(d2, fill=f"grey{rand(10, 30)}", outline=""))
|
|
# print("Dziura dodana pomyślnie!")
|
|
canvas.delete(po["id1"])
|
|
canvas.delete(po["id2"])
|
|
|
|
pociski.pop(p)
|
|
# print("x")
|
|
|
|
|
|
def bok(lewo):
|
|
global srodek_ekranu_x, srodek_ekranu_y, obroc_o, statek_bazowy
|
|
if lewo:
|
|
r = 3
|
|
x, y = obroc(statek_bazowy[2], statek_bazowy[3], srodek_ekranu_x, srodek_ekranu_y, obroc_o)
|
|
s2 = canvas.create_oval(x - r, y - r, x + r, y + r, fill="#000000", outline="", tags="gwiazdy")
|
|
for i in range(50):
|
|
wartosc_rgb = int((49 - i) * (255 / 49))
|
|
he = f"{wartosc_rgb:02X}"
|
|
kolor = f"#0000{he}"
|
|
root.after(i * 6, lambda k=kolor: canvas.itemconfig(s2, fill=k))
|
|
|
|
root.after(300, lambda: canvas.delete(s2))
|
|
canvas.tag_lower(s2)
|
|
else:
|
|
r = 3
|
|
x, y = obroc(statek_bazowy[6], statek_bazowy[7], srodek_ekranu_x, srodek_ekranu_y, obroc_o)
|
|
s2 = canvas.create_oval(x - r, y - r, x + r, y + r, fill="#000000", outline="", tags="gwiazdy")
|
|
for i in range(50):
|
|
wartosc_rgb = int((49 - i) * (255 / 49))
|
|
he = f"{wartosc_rgb:02X}"
|
|
kolor = f"#0000{he}"
|
|
root.after(i * 6, lambda k=kolor: canvas.itemconfig(s2, fill=k))
|
|
|
|
root.after(300, lambda: canvas.delete(s2))
|
|
canvas.tag_lower(s2)
|
|
|
|
|
|
def skala():
|
|
global czekaj_scala
|
|
if wcisniete_klawisze["q"] and wiel_pocis.get() >= 1 and czekaj_scala <= 0:
|
|
wiel_pocis.set(wiel_pocis.get() - 1)
|
|
czekaj_scala = 20
|
|
if wcisniete_klawisze["e"] and wiel_pocis.get() < 6 and czekaj_scala <= 0:
|
|
wiel_pocis.set(wiel_pocis.get() + 1)
|
|
czekaj_scala = 20
|
|
|
|
|
|
def rusz():
|
|
global wcisniete_klawisze, mapa_y, mapa_x, obroc_o, probrotowa, v
|
|
|
|
a_rad = radians(obroc_o)
|
|
|
|
dx = v * sin(a_rad)
|
|
dy = v * cos(a_rad)
|
|
|
|
if wcisniete_klawisze["a"]:
|
|
probrotowa -= 0.1
|
|
bok(True)
|
|
|
|
if wcisniete_klawisze["d"]:
|
|
probrotowa += 0.1
|
|
bok(False)
|
|
|
|
if probrotowa < 0:
|
|
probrotowa += 0.03
|
|
if probrotowa > 0:
|
|
probrotowa -= 0.03
|
|
obroc_o += probrotowa
|
|
|
|
if -1500 < mapa_x + dx < 3600 and -800 < mapa_y - dy < 1800:
|
|
canvas.move("gwiazdy", -dx, dy)
|
|
canvas.move("pociski", -dx, dy)
|
|
canvas.move(koniec_mapy, -dx, dy)
|
|
mapa_x += dx
|
|
mapa_y -= dy
|
|
if wcisniete_klawisze["w"] and v < 5:
|
|
v += 0.05
|
|
if wcisniete_klawisze["s"] and v > -2:
|
|
v -= 0.05
|
|
|
|
nowe_punkty = []
|
|
for i in range(0, len(statek_bazowy), 2):
|
|
bx = statek_bazowy[i]
|
|
by = statek_bazowy[i + 1]
|
|
nx, ny = obroc(bx, by, srodek_ekranu_x, srodek_ekranu_y, obroc_o)
|
|
nowe_punkty.extend([nx, ny])
|
|
|
|
canvas.coords(statek, *nowe_punkty)
|
|
|
|
nowe_punkty = []
|
|
for i in range(0, len(lewe_bazowe), 2):
|
|
bx = lewe_bazowe[i]
|
|
by = lewe_bazowe[i + 1]
|
|
nx, ny = obroc(bx, by, srodek_ekranu_x, srodek_ekranu_y, obroc_o)
|
|
nowe_punkty.extend([nx, ny])
|
|
|
|
canvas.coords(lewe_dzialo, *nowe_punkty)
|
|
|
|
nowe_punkty = []
|
|
for i in range(0, len(prawe_bazowe), 2):
|
|
bx = prawe_bazowe[i]
|
|
by = prawe_bazowe[i + 1]
|
|
nx, ny = obroc(bx, by, srodek_ekranu_x, srodek_ekranu_y, obroc_o)
|
|
nowe_punkty.extend([nx, ny])
|
|
|
|
canvas.coords(prawe_dzialo, *nowe_punkty)
|
|
|
|
if wcisniete_klawisze["w"] or wcisniete_klawisze["s"]:
|
|
r = 6
|
|
s1 = canvas.create_oval(srodek_ekranu_x - r, srodek_ekranu_y - r, srodek_ekranu_x + r, srodek_ekranu_y + r, fill="#000000", outline="", tags="gwiazdy")
|
|
for i in range(50):
|
|
wartosc_rgb = int((49 - i) * (255 / 49))
|
|
he = f"{wartosc_rgb:02X}"
|
|
kolor = f"#{he}0000"
|
|
root.after(i * 24, lambda k=kolor: canvas.itemconfig(s1, fill=k))
|
|
|
|
root.after(1200, lambda: canvas.delete(s1))
|
|
canvas.tag_lower(s1)
|
|
|
|
|
|
def strzal():
|
|
global srodek_ekranu_x, srodek_ekranu_y, obroc_o, v, przeladowanie
|
|
if wcisniete_klawisze["space"] and przeladowanie <= 0:
|
|
r = wiel_pocis.get()
|
|
kolor = kolory[int(kol_pocis.get() - 1)][rand(0, len(kolory[int(kol_pocis.get() - 1)]))]
|
|
|
|
xl, yl = obroc(lewe_bazowe[2], lewe_bazowe[3], srodek_ekranu_x, srodek_ekranu_y, obroc_o)
|
|
xp, yp = obroc(prawe_bazowe[2], prawe_bazowe[3], srodek_ekranu_x, srodek_ekranu_y, obroc_o)
|
|
|
|
s3 = canvas.create_oval(xl - r, yl - r, xl + r, yl + r, fill=kolor, outline="", tags="pociski")
|
|
s4 = canvas.create_oval(xp - r, yp - r, xp + r, yp + r, fill=kolor, outline="", tags="pociski")
|
|
|
|
kat_rad = radians(obroc_o)
|
|
predkosc_pocisku = v + 8 - wiel_pocis.get()
|
|
przeladowanie = wiel_pocis.get() ** 2.5
|
|
|
|
vx = predkosc_pocisku * sin(kat_rad) + uni(-0.1, 0.1)
|
|
vy = -predkosc_pocisku * cos(kat_rad) + uni(-0.1, 0.1)
|
|
# print(kolory[int(kol_pocis.get())])
|
|
pociski.append({"id1": s3, "id2": s4, "dx": vx, "dy": vy, "r": 2 * r + 14, "rr": r, "zestaw": kol_pocis.get() - 1, "kolor": kolory[int(kol_pocis.get()) - 1].index(kolor)})
|
|
|
|
r_blysk = wiel_pocis.get() * 2
|
|
s5 = canvas.create_oval(xl - r_blysk, yl - r_blysk, xl + r_blysk, yl + r_blysk, fill="yellow", outline="red", tags="pociski")
|
|
s6 = canvas.create_oval(xp - r_blysk, yp - r_blysk, xp + r_blysk, yp + r_blysk, fill="yellow", outline="red", tags="pociski")
|
|
|
|
root.after(rand(30, 60), lambda w6=s6: canvas.delete(w6))
|
|
root.after(rand(30, 60), lambda w5=s5: canvas.delete(w5))
|
|
|
|
|
|
def aktu_pociski():
|
|
global pociski
|
|
aktywne_pociski = []
|
|
|
|
for p in pociski:
|
|
wspolrzedne = canvas.coords(p["id1"])
|
|
if not wspolrzedne:
|
|
continue
|
|
|
|
if wspolrzedne[0] < -2000 or wspolrzedne[0] > 4000 or wspolrzedne[1] < -1500 or wspolrzedne[1] > 2500:
|
|
canvas.delete(p["id1"])
|
|
canvas.delete(p["id2"])
|
|
continue
|
|
|
|
canvas.move(p["id1"], p["dx"], p["dy"])
|
|
canvas.move(p["id2"], p["dx"], p["dy"])
|
|
aktywne_pociski.append(p)
|
|
|
|
pociski = aktywne_pociski
|
|
|
|
|
|
root = Tk()
|
|
root.geometry("1000x700")
|
|
root.attributes("-fullscreen", True)
|
|
|
|
canvas = Canvas(root, bg="black", highlightthickness=0)
|
|
canvas.pack(fill="both", expand=True)
|
|
|
|
koniec_mapy = canvas.create_rectangle(-1900, -1000, 3800, 2000, fill="", outline="red", width=5)
|
|
|
|
for i in range(1000):
|
|
x = rand(-1900, 3800)
|
|
y = rand(-1000, 2000)
|
|
r = 2
|
|
g = canvas.create_oval(x, y, x + r, y + r, fill="white", outline="", tags="gwiazdy")
|
|
|
|
wcisniete_klawisze = {"w": False, "s": False, "a": False, "d": False, "space": False, "q": False, "e": False}
|
|
|
|
root.update()
|
|
|
|
x_w = canvas.winfo_width()
|
|
y_w = canvas.winfo_height()
|
|
srodek_ekranu_x = x_w / 2
|
|
srodek_ekranu_y = y_w / 2
|
|
mapa_x = srodek_ekranu_x
|
|
mapa_y = srodek_ekranu_y
|
|
|
|
x = 20
|
|
y = 30
|
|
statek_bazowy = [srodek_ekranu_x, srodek_ekranu_y - y, srodek_ekranu_x + x, srodek_ekranu_y + y, srodek_ekranu_x, srodek_ekranu_y, srodek_ekranu_x - x, srodek_ekranu_y + y]
|
|
statek = canvas.create_polygon(*statek_bazowy, fill="lightblue", outline="")
|
|
|
|
lewe_bazowe = [srodek_ekranu_x - 7, srodek_ekranu_y + 5, srodek_ekranu_x - 7, srodek_ekranu_y - y + 10]
|
|
lewe_dzialo = canvas.create_line(*lewe_bazowe, fill="lightblue", width=3)
|
|
|
|
prawe_bazowe = [srodek_ekranu_x + 7, srodek_ekranu_y + 5, srodek_ekranu_x + 7, srodek_ekranu_y - y + 10]
|
|
prawe_dzialo = canvas.create_line(*prawe_bazowe, fill="lightblue", width=3)
|
|
przeladowanie = 10
|
|
|
|
pociski = []
|
|
wiel_pocis = Scale(root, from_=1, to=6, orient=HORIZONTAL, length=200, width=20, bg="grey30", fg="#ffffff", troughcolor="#4a90e2", activebackground="#ff9900", label="Wielkość pocisków: < q | e >", highlightthickness=0, bd=2)
|
|
wiel_pocis.place(x=0, y=0)
|
|
wiel_pocis.set(1)
|
|
czekaj_scala = 10
|
|
kolory = [["red", "yellow", "gold", "orange", "red3"], ["green", "limegreen", "forestgreen", "darkgreen", "lawngreen"], ["blue", "blue2", "DeepSkyBlue3", "RoyalBlue3", "mediumblue"], ["grey20", "grey18", "grey16", "grey14", "grey12", "grey10"]]
|
|
kol_pocis = Scale(root, from_=1, to=len(kolory), showvalue=False, tickinterval=1, orient=HORIZONTAL, length=200, width=20, bg="grey30", fg="#ffffff", troughcolor="#4a90e2", activebackground="#ff9900", label="Kolor pocisków: zestaw: ", highlightthickness=0, bd=2)
|
|
kol_pocis.place(x=0, y=68)
|
|
kol_pocis.set(1)
|
|
obroc_o = 0
|
|
probrotowa = 0
|
|
v = 0
|
|
|
|
odlamki = []
|
|
asteroidy = []
|
|
for i in range(rand(40, 80)):
|
|
x = rand(-1900, 3800)
|
|
y = rand(-1000, 2000)
|
|
r = rand(10, 50)
|
|
g = canvas.create_oval(x - r, y - r, x + r, y + r, fill=f"grey{rand(20, 31)}", outline="", tags=("gwiazdy", "asteroidy"))
|
|
asteroidy.append({"id": g, "r": r, "dx": 0, "dy": 0, "dziury": []})
|
|
|
|
root.bind("<KeyPress>", klawisz_wcisniety)
|
|
root.bind("<KeyRelease>", klawisz_puszczony)
|
|
root.bind("<Escape>", lambda event: root.destroy())
|
|
|
|
gluwna()
|
|
root.mainloop()
|