Develop Reference

Create fire particles for the gun

I'm working on a space shooting game and I want my gun to emit a cluster of particles every time it fires. I tried creating a class for the model of one particle and another class to apply this to 50 particles. Everything was pretty good since there was no syntax error, yet the code did not work. This is my code:
import pygame, sys, random
CLOCK = pygame.time.Clock()
pygame.init()
Screen = pygame.display.set_mode((500,500))
class FireParticles_system:
def __init__(self,pos):
self.particles = []
self.pos_x, self.pos_y = pos[0], pos[1]
self.radius = 5
def emit (self,Screen):
for particle in self.particles:
particle[0][0] += particle[2][0]
particle[0][1] += particle[2][1]
if random.randint(0,100)< 60:
particle[1] -= 0.1
pygame.draw.circle(Screen,(255,255,255),particle[0],int(particle[1]))
def add_particles(self):
vx, vy = random.randint(10,0)*.1, random.randint(-2,2)
self.particles.append[[self.pos_x,self.pos_y],self.radius,[vx,vy]]
class Fire:
def __init__(self,pos):
self.particles = []
for i in range(50):
self.particles.append(FireParticles_system(pos))
def update(self,Screen):
for i in self.particles:
i.emit(Screen)
self.particles = [particle for particle in self.particles if particle.radius > 0]
fire = []
while True:
Screen.fill((0,0,0))
mouse_x, mouse_y = pygame.mouse.get_pos()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
f = Fire([mouse_x, mouse_y])
fire.append(f)
for i in range(len(fire)):
if len(fire[i].particles) > 0:
fire[i].update(Screen)
pygame.display.update()
CLOCK.tick(60)
I could not spot any problems. Pls, help me T.T

FireParticles_system has a list of particles. However Fire needs just 1 particle system:
import pygame, sys, random
CLOCK = pygame.time.Clock()
pygame.init()
Screen = pygame.display.set_mode((500,500))
class FireParticles_system:
def __init__(self,pos):
self.particles = []
self.pos_x, self.pos_y = pos[0], pos[1]
self.radius = 5
def emit (self,Screen):
for particle in self.particles:
particle[0][0] += particle[2][0]
particle[0][1] += particle[2][1]
particle[1] -= 0.1
pygame.draw.circle(Screen,(255,255,255),particle[0],int(particle[1]))
def add_particles(self):
vx, vy = random.randint(0, 10), random.randint(-2,2)
self.particles.append([[self.pos_x,self.pos_y],self.radius,[vx,vy]])
class Fire:
def __init__(self,pos):
self.particles_system = FireParticles_system(pos)
def update(self,Screen):
self.particles_system.add_particles()
self.particles_system.emit(Screen)
fire = []
while True:
Screen.fill((0,0,0))
mouse_x, mouse_y = pygame.mouse.get_pos()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
f = Fire([mouse_x, mouse_y])
fire.append(f)
for i in range(len(fire)):
fire[i].update(Screen)
pygame.display.update()
CLOCK.tick(60)

How to know if the spacebar is pressed for more than 2 seconds in pygame

So, I am making a simple game using pygame in which a ninja has to dodge obstacles in front of him, the problem is that I can't get how to know if the spacebar(used for jump) is pressed for more than 2 seconds.
I have searched on many sites for this answer but couldn't get one.
Pls help.
Here is my code:
import pygame,time #import
pygame.init() #pygame initialization
screen = pygame.display.set_mode((0,0))
pygame.quit()
canvas = pygame.display.set_mode((1000,780)) #creating screen
caption = pygame.display.set_caption("Ninja Run") #creating caption
iconImage = pygame.image.load("C:/Garv/python/pygame/Ninja Game/Ninja_logo.png")
icon = pygame.display.set_icon(iconImage) #drawing icon image
land = pygame.image.load("C:/Garv/python/pygame/Ninja Game/land.jfif") #land image
sky = pygame.image.load("C:/Garv/python/pygame/Ninja Game/sky.jfif") # sky image
x = 50
y = 594
start = time.time()
ninjaRun = [pygame.image.load("C:/Garv/python/pygame/Ninja Game/ninja running 1.jpg"),pygame.image.load("C:/Garv/python/pygame/Ninja Game/ninja running 2.jpg")] #ninja images
ninjaImage = ninjaRun[0]
# ninjaStars = pygame.image.load("C:/Garv/python/pygame/Ninja Game/ninja stars.png")
class Ninja:
def __init__(self,canvas,start,run,image,x,y): #Initializing of variables
self.canvas = canvas
self.start = start
self.run = run
self.image = image
self.x = x
self.y = y
def ninja(self): #ninja movement method
self.image = ninjaRun[0]
self.time = 15
self.sec = int((time.time()-self.start)*self.time)
if self.sec % 2 != 0:
self.image = ninjaRun[0]
elif self.sec % 2 == 0:
self.image = ninjaRun[1]
self.canvas.blit(self.image, (self.x,self.y)) #ninja draw
player = Ninja(canvas,start,ninjaRun,ninjaRun[0],x,y) #calling Ninja class
cnt = 0
startTime = time.time()
while True: #main loop
for event in pygame.event.get(): #event handler
if event.type == pygame.QUIT: #quit handler
pygame.quit()
import sys
sys.exit()
if event.type == pygame.KEYDOWN: #keydown
if event.key == pygame.K_SPACE:
player.y -= 200
if player.y < 394:
player.y += 200
if event.type == pygame.KEYUP: #keyup
if event.key == pygame.K_SPACE:
player.y += 200
# canvas.blit(ninjaStars, (500,500))
pygame.draw.rect(canvas,(250,250,250),(500,500,20,20))
canvas.blit(land, (0,718)) #land drawing
canvas.blit(sky, (0,0)) #sky drawing
player.ninja() #ninja drawing
pygame.display.update() #display update

Use pygame.time.get_ticks() to get the number of milliseconds since pygame.init() was called:
while True: #main loop
for event in pygame.event.get(): #event handler
if event.type == pygame.QUIT: #quit handler
# [...]
if event.type == pygame.KEYDOWN: #keydown
if event.key == pygame.K_SPACE:
space_start = pygame.time.get_ticks()
# [...]
if event.type == pygame.KEYUP: #keyup
if event.key == pygame.K_SPACE:
space_end = pygame.time.get_ticks()
if space_end - space_start >= 2000:
# [...]

How do I make a changing background while the game is running in Pygame?

I want to have my background alternate between night and day (sprites) every 15 seconds or so, but I want this to happen only while the game is running (True), I've placed it in every place in my while loop, can't seem to get it going. The code we're looking at is the following:
if event.type == BACKCHANGE:
screen.blit(back_change,(0,0))
else:
screen.blit(bg_image,(0,0))
Here's how it fits into my game:
import pygame, sys, time, random
pygame.init()
clock = pygame.time.Clock()
screen = pygame.display.set_mode((500, 800))
pygame.display.set_caption('FALLING MAN')
#Game elements
gravity = 0.15
mov_of_man_x = 0
mov_of_man_y = 0
right_mov = 50
left_mov = 50
game_active = True
#day background
bg_image = pygame.image.load("/Users/apple/Downloads/Python Projects/Climbing_Game/bckwall.jpg").convert()
bg_image = pygame.transform.scale(bg_image,(500, 900))
#night background
bg_image2 = pygame.image.load("/Users/apple/Downloads/Python Projects/Climbing_Game/bckwall2.jpg").convert()
bg_image2 = pygame.transform.scale(bg_image2,(500, 900))
#background swap
back_changer = [bg_image, bg_image2]
back_change = random.choice(back_changer)
#the player
man = pygame.image.load("/Users/apple/Downloads/Python Projects/Climbing_Game/man.png").convert_alpha()
man = pygame.transform.scale(man, (51, 70))
man_rec = man.get_rect(center = (250, -500))
#the platforms player moves on
platform = pygame.image.load("/Users/apple/Downloads/Python Projects/Climbing_Game/platform.png").convert_alpha()
platform = pygame.transform.scale(platform,(300,60))
platform_rec = platform.get_rect(center = (250,730))
#game over screen
game_over_screen = pygame.image.load("/Users/apple/Downloads/Python Projects/Climbing_Game/End_screen.png").convert_alpha()
game_over_screen = pygame.transform.scale(game_over_screen,(500,800))
#moving platforms
def create_plat():
random_plat_pos = random.choice(plat_pos)
new_plat = platform.get_rect(center = (random_plat_pos, 800))
return new_plat
def mov_plat(plats):
for plat in plats:
plat.centery -= 4
return plats
def draw_plat(plats):
for plat in plats:
screen.blit(platform, plat)
#collison detection
def detect_plat(plats):
for plat in plats:
if man_rec.colliderect(plat):
global mov_of_man_y
mov_of_man_y = -4
return
def detect_man(mans):
for man in mans:
if man_rec.top <= -700 or man_rec.bottom >= 900:
return False
if man_rec.left <= -100 or man_rec.right >= 500:
return False
else:
return True
#score
def display_score():
pass
#moving platforms
plat_list = []
PLATMOV = pygame.USEREVENT
pygame.time.set_timer(PLATMOV, 1200)
plat_pos = [100,200,300,400]
#back change
BACKCHANGE = pygame.USEREVENT
pygame.time.set_timer(BACKCHANGE, 1200)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
mov_of_man_x += right_mov
man_rec.centerx += mov_of_man_x
mov_of_man_x -= 50
if event.key == pygame.K_LEFT:
mov_of_man_x += left_mov
man_rec.centerx -= mov_of_man_x
mov_of_man_x -= 50
if event.type == PLATMOV:
plat_list.append(create_plat())
#surfaces
screen.blit(bg_image,(0,0))
if game_active == True:
#gravity
mov_of_man_y += gravity
man_rec.centery += mov_of_man_y
#plats
plat_list = mov_plat(plat_list)
draw_plat(plat_list)
detect_plat(plat_list)
game_active = detect_man(man_rec)
#character
screen.blit(man, man_rec)
"""
if event.type == BACKCHANGE:
screen.blit(back_change,(0,0))
else:
screen.blit(bg_image,(0,0))
"""
else:
screen.blit(game_over_screen, (0,0))
pygame.display.update()
clock.tick(120)

Add a variable that indicates which background to draw:
bg_images = [bg_image, bg_image2]
bg_index = 0
Change the background index when the BACKCHANGE event occurs:
for event in pygame.event.get():
if event.type == BACKCHANGE:
bg_index += 1
if bg_index >= len(bg_images):
bg_index = 0
blit the current background in the application loop:
while True:
# [...]
screen.blit(bg_images[bg_index], (0,0))
# [...]
Application loop:
bg_images = [bg_image, bg_image2]
bg_index = 0
# [...]
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
# [...]
if event.type == pygame.KEYDOWN:
# [...]
if event.type == PLATMOV:
# [...]
if event.type == BACKCHANGE:
bg_index += 1
if bg_index >= len(bg_images):
bg_index = 0
if game_active == True:
screen.blit(bg_images[bg_index], (0,0))
# [...]
else:
screen.blit(game_over_screen, (0,0))
pygame.display.update()
clock.tick(120)

How to update the positional coordinates of my rect?

I'm creating a memory card game, but having difficulty updating each boxes' rect starting positions. First for loop loads each image and the second get's the starting position for each one. When I do a collision test, it only answers to <0,125,0,175> as my rect position's aren't updating. How can I update this?
import pygame, sys
from pygame.locals import *
screen_height = 800
screen_width = 800
card_x_size = 125
card_y_size = 175
marginx = 45
marginy = 25
class Box():
def __init__(self,image):
self.image = image
self.rect = image.get_rect()
def draw(self,screen):
screen.blit(self.image, self.rect)
def play_game():
pygame.init()
screen = pygame.display.set_mode((screen_width, screen_height))
back_images = ['back.jpg']*16
back_image_list = []
for back_image in back_images:
back_pic = pygame.image.load(back_image)
back_pic = pygame.transform.scale(back_pic, (card_x_size,card_y_size))
back_image_list.append(back_pic)
rect = back_pic.get_rect()
boxes = [Box(img) for img in back_image_list]
for j, box in enumerate(boxes):
pos_x = marginx + j % 4 * available_spacex
pos_y = marginy + j // 4 * available_spacey
box.rect.topleft = (pos_x, pos_y)
print(pos_x,pos_y)
while True:
mouse_clicked = False
clicked_card = False
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == MOUSEMOTION:
mousex, mousey = event.pos
elif event.type == MOUSEBUTTONUP:
mouse_clicked = True
print(mousex, mousey)
if rect.collidepoint(mousex,mousey):
clicked_card = True
print("hit")
for b in boxes:
b.draw(screen)
pygame.display.update()
play_game()

You have to evaluate whether the mouse click is on one of the box objects:
for box in boxes:
if box.rect.collidepoint(mousex, mousey):
clicked_card = True
print("hit")
function play_game:
def play_game():
# [...]
while True:
mouse_clicked = False
clicked_card = False
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == MOUSEMOTION:
mousex, mousey = event.pos
elif event.type == MOUSEBUTTONUP:
mousex, mousey = event.pos
mouse_clicked = True
print(mousex, mousey)
for box in boxes:
if box.rect.collidepoint(mousex, mousey):
clicked_card = True
print("hit")
for b in boxes:
b.draw(screen)
pygame.display.update()

Pygame animation using mutiple images overlapping/not working

import pygame
pygame.init()
window = pygame.display.set_mode((800,600))
pygame.display.set_caption("TEST2")
black=(0,0,0)
white=(255,255,255)
moveX,moveY=0,0
clock = pygame.time.Clock()
class Sprite:
def __init__(self,x,y):
self.x=x
self.y=y
self.width=100
self.height=110
self.i100 = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite0.PNG")
self.i1 = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite1.PNG")
self.i2 = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite2.PNG")
self.i3 = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite3.PNG")
self.i4 = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite4.PNG")
self.i5 = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite5.PNG")
self.i6 = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite6.PNG")
self.i7 = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite7.PNG")
self.i8 = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite8.PNG")
self.i9 = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite9.PNG")
self.i10 = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite10.PNG")
self.i11 = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite11.PNG")
self.timeTarget=10
self.timeNum=0
self.currentImage=0
def update(self):
self.timeNum+=1
if(self.timeNum==self.timeTarget):
if (self.currentImage==0):
self.currentImage+=1
else:
self.currentImage=0
self.timeNum=0
self.render()
def render(self):
if (self.currentImage==0):
window.blit(self.i100, (self.x,self.y))
else:
window.blit(self.i1, (self.x,self.y))
window.blit(self.i2, (self.x,self.y))
window.blit(self.i3, (self.x,self.y))
player=Sprite(110,100)
gameLoop = True
while gameLoop:
for event in pygame.event.get():
if event.type==pygame.QUIT:
gameLoop = False
if (event.type==pygame.KEYDOWN):
if (event.key==pygame.K_LEFT):
moveX = -3
if (event.key==pygame.K_RIGHT):
moveX = 3
if (event.key==pygame.K_UP):
moveY = -3
if (event.key==pygame.K_DOWN):
moveY = 3
if (event.type==pygame.KEYUP):
if (event.key==pygame.K_LEFT):
moveX=0
if (event.key==pygame.K_RIGHT):
moveX=0
if (event.key==pygame.K_UP):
moveY=0
if (event.key==pygame.K_DOWN):
moveY=0
window.fill(black)
player.x+=moveX
player.x+=moveY
player.update()
clock.tick(50)
pygame.display.flip()
pygame.quit()
What im doing is trying to animate 11 photos into an animation with pygame. this code works but when I run it the pictures seem to almost overlap. I did window.blit for the first few images and put them under else? I feel like I rendered them wrong. also I must add im really bad at picking up what people are trying to say and best learn from examples. Thanks!

BTW: your code could look like this:
I use my images in example but there are still lines with your images.
I use timer to change images.
You can press space to pause and escape to exit.
etc.
import pygame
#----------------------------------------------------------------------
class Sprite:
def __init__(self, x, y, curren_time):
self.rect = pygame.Rect(x, y, 100, 110)
self.images = []
#for x in range(12):
for x in range(1,4):
img = pygame.image.load("ball" + str(x) +".png")
#img = pygame.image.load("C:/Users/Trevor/SkyDrive/Documents/TEST2.0/Sprite" + str(x) +".PNG")
self.images.append( img )
self.current_image = 0
self.time_num = 100 # miliseconds
self.time_target = curren_time + self.time_num
def update(self, curren_time):
if curren_time >= self.time_target:
self.time_target = curren_time + self.time_num
self.current_image += 1
if self.current_image == len(self.images):
self.current_image = 0
def render(self, window):
window.blit(self.images[self.current_image], self.rect)
#----------------------------------------------------------------------
# CONSTANS - uppercase
BLACK = (0 ,0 ,0 )
WHITE = (255,255,255)
#----------------------------------------------------------------------
# MAIN
def main():
pygame.init()
window = pygame.display.set_mode((800,600))
pygame.display.set_caption("TEST2")
move_x, move_y = 0, 0
clock = pygame.time.Clock()
curren_time = pygame.time.get_ticks()
player = Sprite(110,100, curren_time)
font = pygame.font.SysFont(None, 150)
pause_text = font.render("PAUSE", 1, WHITE)
pause_rect = pause_text.get_rect( center = window.get_rect().center ) # center text on screen
# mainloop
state_game = True
state_pause = False
while state_game:
curren_time = pygame.time.get_ticks()
# events
for event in pygame.event.get():
if event.type == pygame.QUIT:
state_game = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
state_game = False
elif event.key == pygame.K_SPACE:
state_pause = not state_pause
if event.key == pygame.K_LEFT:
move_x = -3
elif event.key == pygame.K_RIGHT:
move_x = 3
elif event.key == pygame.K_UP:
move_y = -3
elif event.key == pygame.K_DOWN:
move_y = 3
elif event.type == pygame.KEYUP:
if event.key in (pygame.K_LEFT, pygame.K_RIGHT):
move_x = 0
elif event.key in (pygame.K_UP, pygame.K_DOWN):
move_y = 0
# moves
if not state_pause:
player.rect.x += move_x
player.rect.y += move_y
player.update(curren_time)
# draws
window.fill(BLACK)
player.render(window)
if state_pause:
window.blit(pause_text, pause_rect)
pygame.display.flip()
# FPS
clock.tick(50)
# the end
pygame.quit()
#----------------------------------------------------------------------
if __name__ == '__main__':
main()
ball1.png
ball2.png
ball3.png

By putting all those window.blit(...) calls one after another, you are drawing those three frames on top of each other. Even if your computer lagged for a second between each call, you still wouldn't see them individually because they all can't appear until pygame.display.flip() is called.
You should store the images in a list, and keep a counter like currentFrame that loops from 0 to number_of_frames-1 (or len(frames)-1). Then each frame of the game you do something like this:
class Player:
...
def draw(window):
window.blit(self.frames[self.currentFrame])