CODEWITHSUNDEEP
pythonpygamedraw
mr. bug
mr. bug

Reputation: 309

How to delete a single pygame drawing from the screen?

When the big circle touches the little circles I want the little circle that it touched to disappear from the screen. However, I can't figure out how exactly you delete an individual drawing in pygame. How do I fix this issue? does pygame have this feature built-in?

from pygame import *
import random as rd
import math as m

init()
screen = display.set_mode((800, 600))

p_1_x = 200
p_1_y = 200
p_1_change_x = 0
p_1_change_y = 0

def p_1(x, y):
    player_1 = draw.circle(screen, (0, 0, 0), (x, y), 15)

def pick_up(x, y, xx, yy):
    distance = m.sqrt(m.pow(xx - x, 2) + m.pow(yy - y, 2))
    if distance < 19:
        # I think the code to delete should go here
        pass

dots = []
locations = []

for i in range(5):
    x = rd.randint(100, 700)
    y = rd.randint(100, 500)
    locations.append((x, y))

while True:
    screen.fill((255, 255, 255))
    for events in event.get():
        if events.type == QUIT:
            quit()
        if events.type == KEYDOWN:
            if events.key == K_RIGHT:
                p_1_change_x = 1
            if events.key == K_LEFT:
                p_1_change_x = -1
            if events.key == K_UP:
                p_1_change_y += 1
            if events.key == K_DOWN:
                p_1_change_y -= 1

        if events.type == KEYUP:
            if events.key == K_RIGHT or K_LEFT or K_UP or K_DOWN:
                p_1_change_x = 0
                p_1_change_y = 0

    p_1_x += p_1_change_x
    p_1_y -= p_1_change_y
    for i, locate in enumerate(locations):
        dot = draw.circle(screen, (0, 0, 0), locate, 5)
        dots.append(dot)
        for l in enumerate(locate):
            pick_up(p_1_x, p_1_y, locate[0], locate[1])

    p_1(p_1_x, p_1_y)
    display.update()

Upvotes: 3

Views: 1321

Answers (2)

Peyman Majidi
Peyman Majidi

Reputation: 1985

Your code was so messy and hard to maintain, first I made 2 classes for Balls & Dots. I detect collision by pygame.Rect.colliderect, first I make 2 rectangle then I check the collision like this:

def pick_up(ball, dot):
    ball_rect = Rect( ball.x - ball.SIZE , ball.y - ball.SIZE , ball.SIZE*2, ball.SIZE*2)
    dot_rect = Rect( dot.x - dot.SIZE , dot.y - dot.SIZE , dot.SIZE*2, dot.SIZE*2)
    if ball_rect.colliderect(dot_rect): 
        return True
    return False

If collision detects I remove it from dots array in the while loop:

for dot in dots:
    if pick_up(ball, dot): # if dot in range ball
            dots.remove(dot)
    dot.draw()

Here is the whole source:

from pygame import *
import random as rd

SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
NUMBER_OF_DOTS = 5

class Ball():
    SIZE = 15
    def __init__(self, x, y):
        self.x = x
        self.y = y
        
    def draw(self):
        draw.circle(screen, (0, 0, 0), (self.x, self.y), Ball.SIZE)
    def move(self, vx, vy):
        self.x += vx
        self.y += vy

class Dot():
    SIZE = 5    
    def __init__(self, x, y):
        self.x = x
        self.y = y
        
    def draw(self):
        draw.circle(screen, (0, 0, 0), (self.x, self.y), Dot.SIZE)


def pick_up(ball, dot):
    ball_rect = Rect( ball.x - ball.SIZE , ball.y - ball.SIZE , ball.SIZE*2, ball.SIZE*2)
    dot_rect = Rect( dot.x - dot.SIZE , dot.y - dot.SIZE , dot.SIZE*2, dot.SIZE*2)
    if ball_rect.colliderect(dot_rect): 
        return True
    return False



init()
screen = display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

dots = []
ball = Ball(200,200)

# generate dots
for i in range(NUMBER_OF_DOTS):
    x = rd.randint(100, 700)
    y = rd.randint(100, 500)
    dots.append(Dot(x,y))

# the main game loop
while True:
    screen.fill((255, 255, 255))
    keys=key.get_pressed()

    for events in event.get():
        keys=key.get_pressed()
        if events.type == QUIT:
            quit()

    if keys[K_RIGHT]:
        ball.move(+1,0)
    if keys[K_LEFT]:
        ball.move(-1,0)
    if keys[K_UP]:
        ball.move(0,-1)
    if keys[K_DOWN]:
        ball.move(0,+1)

    for dot in dots:
        dot.draw()
        
        if pick_up(ball, dot):
                dots.remove(dot)

    ball.draw()
    display.update()
    time.delay(1) # Speed down

Update1:

PyGame Rectangle Collision http://www.pygame.org/docs/ref/rect.html#pygame.Rect.colliderect

Update2:

I make a repo in the github and did some changes,
Dots are colorful, new dot gets random color and the ball gets bigger whenever eats a dot. shot

https://github.com/peymanmajidi/Ball-And-Dots-Game__Pygame

Upvotes: 4

Kingsley
Kingsley

Reputation: 14906

The code should delete it from the locations list so that it's not re-drawn in the future. You clear the screen each frame, so clearing + not-redrawing is "deleting".

Say you modified pick_up() to simply return True or False:

def pick_up(x, y, xx, yy):
    result = False
    distance = m.sqrt(m.pow(xx - x, 2) + m.pow(yy - y, 2))
    if distance < 19:
        result = True              # It was picked
    return result

Then as you iterate through the locations list drawing & checking for being picked, save the index of the picked circles, then remove them from the locations in a second step. Using the 2-step form means you don't have to worry about accidentally skipping items if you delete from the list as you iterate over it.

p_1_x += p_1_change_x
p_1_y -= p_1_change_y
picked_up = []                           # empty list to hold "picked" items
for i, locate in enumerate(locations):
    dot = draw.circle(screen, (0, 0, 0), locate, 5)
    dots.append(dot)
    for l in enumerate(locate):
        if ( pick_up(p_1_x, p_1_y, locate[0], locate[1]) ):
            picked_up.append( i )        # save the index of anything "picked"

# remove any picked-up circles from the list
for index in sorted( picked_up, reverse=True ):   # start with the highest index first
    print( "Removing circle from location[%d]" % ( index ) )  # DEBUG
    del( locations[ index ] )

Upvotes: 3

Related Questions