How Do I Change These Two Balls Into Many Of Them?

i recently start learning about python, and made simple source of 2 balls in canvas which are moving with 2d vector rule. i want multiply the number of balls with list in python. h

Solution 1:

Question: How do i change these two balls into many of them?

Create a class object for each Ball or pair of Balls. This results in, all Balls using the same rules.

Note: I show only one Ball per class object, not a pair of Balls and without collision detection!

classBall:
    R = 15def__init__(self, parent=None, color=None):
        self.parent = parent

        # Define shortcuts
        radius = self.R

        # Random bbox Ellipse coordinates of the ball.
        x = random.randrange(50 + radius, 550 - radius)
        y = random.randrange(50 + radius, 350 - radius)
        coord1 = (x - radius, y - radius, x + radius, y + radius)

        # Random direction
        x = random.randrange(1, 10)
        y = random.randrange(1, 10)
        self.direction = (x, y)

        # Save the bbox coordinate of the ball
        self.coord1 = self.bbox(coord1, self.direction)

    defbbox(self, coord1=None, direction=None):
        # Return if NO moveif coord1 isNone:
            return self.coord1

        return (coord1[0] + direction[0],
                coord1[1] + direction[1],
                coord1[2] + direction[0],
                coord1[3] + direction[1]
                )

    defvector_rule(self):
        # Get the estimated new bbox coordinate of the Ball
        coord1 = self.bbox(self.coord1, self.direction)

        # Define shortcuts
        R = self.R
        x1 = coord1[0]
        y1 = coord1[1]
        vx1 = self.direction[0]
        vy1 = self.direction[1]

        # Boundary checkif (x1 > 530 - R):
            vx1 = -vx1

        if (x1 < 35 + R):
            vx1 = -vx1

        if (y1 > 330 - R) or (y1 < 35 + R):
            vy1 = -vy1

        # Save the new direction - could be the same as before
        self.direction = (vx1, vy1)

        # Save the new bbox coordinate of the Ball
        self.coord1 = self.bbox(self.coord1, self.direction)

        # Return the move offsetsreturn self.direction

Usage:

Create a class BallCanvas, in .create_balls(... loop to create class Ball objects and Canvas create_oval(... objects. Accumulate both in a list, loop this list to move the Balls using canvas.move(..., according the result of Ball.vector_rules(....

classBallCanvas(tk.Canvas):
    def__init__(self, parent, width, height):
        self.parent = parent
        super().__init__(parent, width=width, height=height)
        self.create_rectangle(50, 50, 550, 350)
        self.grid(row=1)

        self.balls = []
        self.create_balls()

    defcreate_balls(self):
        for n inrange(5):
            for color in ['red', 'blue']:
                ball = Ball()
                self.balls.append((self.create_oval(ball.bbox(), fill=color, tags='ball'), ball))

    defmove_balls(self):
        forid, ball in self.balls:
            new_x, new_y = ball.vector_rule()
            self.move(id, new_x, new_y)

Main Application:

Move the Ball objects using Tkinter .after(150, .... This means. all Ball objects moved every 150ms.

classApp(tk.Tk):
    def__init__(self):
        super().__init__()
        self.geometry("610x430+650+280")

        self.canvas = BallCanvas(self, width=600, height=400)

        self.count = 200
        self.after(500, self.move)

    defmove(self):
        self.count -= 1    
        self.canvas.move_balls()

        if self.count > 0:
            self.after(150, self.move)

if __name__ == "__main__":
    App().mainloop()

Tested with Python: 3.5

Solution 2:

you can start by initializing the variables as random arrays with the same length. Example with length 10:

x = np.random.randint(50+R,550-R, size=10)

Do this for all variables. Inside your current loop you can loop through all variables.