ugrás a tartalomhoz

Python egymásról lepattanó labdák

morocztamas · 2012. Jún. 22. (P), 14.44
Egy Python alkalmazás készítése során akadt gondom. Nem pont a nyelvvel, inkább a feladat megoldással. A lényeg, hogy a labdáknak egymásról vissza kellene pattanniuk, de nem nagyon csinálják, vagy ha igen, akkor is csak néha. Hogyan hozhatom helyre? Két labdánál tökéletesen működött még.
# -*- coding:Utf-8 -*-
################################################################################
# Python program                                                               #
# Szerző: Mórocz Tamás, Budapest, 2012                                         #
# Liszensz: GPL                                                                #
#                                                                              #
# Több színű labda mozog, amik egymásról és az oldalfalakról visszapattannak.  #
################################################################################

################################################################################
# Külső függvények importálása                                                 #

from Tkinter import *

################################################################################
# Függvények lokális definíciója                                               #

def move():
    "A labda mozgatását végző függvény."
    global oval, x, y, dx, dy, d3, d4                                           # oval, x, y, dx és dy listák globálisak
    i = 0
    while i < len(x):                                                           # amíg i kisebb, mint az x lista hosszúsága
        x[i] += dx[i]                                                           # x i-edik elemének növelése a dx i-edik elemével
        y[i] += dy[i]                                                           # y i-edik elemének növelése a dy i-edik elemével
        i += 1                                                                  # ciklus változó növelése
    i = 0                                                                       # ciklus változó létrehozása
    while i < len(x):                                                           # amíg i kisebb, mint az x lista hosszúsága
        if x[i] > 360 or x[i] < 10:                                             # ha x i-edik elemének értéke nagyobb háromszázhatvannál vagy kisebb tíznél
            dx[i] *= -1                                                         # dx iedik elemét megszorozza mínuszeggyel
        if y[i] > 360 or y[i] < 10:                                             # ha y i-edik elemének értéke nagyobb háromszázhatvannál vagy kisebb tíznél
            dy[i] *= -1                                                         # dy i-edik elemét megszorozza mínuszeggyel
        j = 0                                                                   # ciklusváltozó létrehozás
        while j < len(x):                                                       # amíg j kisebb az x lista hosszánál
            if j != i: 
                if x[j] >= x[i] - 30 and x[j] <= x[i] + 30 and y[j] >= y[i] - 30 and y[j] <= y[i] + 30: # ha j nem egyenlő i-vel és x j-edik eleme nagyobb vagy egyenlő, mint az x i-edik eleme harminccal csökkentve és x j-edik eleme kisebb vagy egyenlő, mint az x i-edik eleme harminccal megnövelve (a labdák méretével) és y j-edik eleme nagyobb vagy egyenlő, mint az y i-edik eleme harminccal csökkentve és y j-edik eleme kisebb vagy egyenlő, mint az y i-edik eleme harminccal megnövelve
                    dx[i] *= -1
                    dx[j] *= -1
                    dy[i] *= -1
                    dy[j] *= -1
                    print 1
            j += 1                                                              # ciklusváltozó növelése
        can.coords(oval[i], x[i], y[i], x[i] + 30, y[i] + 30)                   # oval i-edik elemének áthelyezése az új helyre
        i += 1                                                                  # ciklusváltozó növelése
    abl.after(50, move)                                                         # függvény ötven milisecundum után újra meghívása
    

################################################################################
# Főprogram törzse                                                             #

# Globális változók
oval, x, y = [], [0, 0, 360, 360], [360, 0, 360, 0]                             # oval, x és y lista létrehozása
dx, dy = [15, 10, 15, 10], [10, 15, 10, 15]                                     # dx és dy változók létrehozása
colors = ['red', 'blue', 'dark green', 'maroon']                                # színek tárolására lista létrehozása

# Főwidget létrehozása
abl = Tk()                                                                      # ablak létrehozása
abl.title('Több labda mozog')                                                   # ablak fejlécének szövegének módosítása

# Alwidgetek létrehozása
can = Canvas(abl, bg = 'dark grey', width = 400, height = 400)                  # négyszázszor négyszáz képpontos sötétszürke vászon létrehozása
i = 0                                                                           # ciklusváltozó létrehozása
while i < len(x):                                                               # amíg i az x lista hosszánál
    oval.append(can.create_oval(x[i], y[i], x[i] + 30, y[i] + 30, fill = colors[i])) # kör létrehozása és hozzáfűzése az oval listához
    i += 1                                                                      # ciklus változó eggyel való növelése
can.pack()                                                                      # can vászon elhelyezése az abl ablakban
move()                                                                          # move függvény meghívása

# Eseményfigyelő (főhurok) indítása
abl.mainloop()
 
1

Jol latom?

janoszen · 2012. Jún. 22. (P), 14.51
Most nem ertem ra vegigertelmezni a kododat, de jol latom, hogy 30px-esek a labdaid es ennyivel is mozgatod lepesenkent? Mert igy siman 'elmehetnek' egymas felett.
2

10, 15

morocztamas · 2012. Jún. 22. (P), 15.16
10, 15 képponttal mozognak.
3

Hát ugye az i=0..len-1,

tgr · 2012. Jún. 23. (Szo), 08.56
Hát ugye az i=0..len-1, j=0..len-1 ciklus éppen kétszer megy át minden elempáron.

Illetve nem ismerem a canvas szintaxisát, de mintha az ábrázolt körök középpontja x+15, y+15 lenne, az algoritmus meg x,y-t használná.
4

Összes labdával megvizsgálja

morocztamas · 2012. Jún. 23. (Szo), 09.54
Összes labdával megvizsgálja, azért raktam azt be. Amúgy azt vizsgálom, hogy a szélük érintkezik-e már, ezért nem a középpontját. (balszél x, teteje y, jobbszél x + 30, alja y + 30)
5

Na de nem azt vizsgálod.

tgr · 2012. Jún. 23. (Szo), 15.12
Na de nem azt vizsgálod.