Related
Right now, my game blits all the images in random positions correctly and also gets the rect of the images correctly, but I can´t figure out how to use colliderect to make sure the images don´t overlap. How could it work for my code?
Also I´m trying to make the first text fade out and I don´t know why it doesn´t work for me.
Here is the code:
class GAME1:
def __init__(self, next_scene):
self.background = pygame.Surface(size)
# Create an array of images with their rect
self.images = []
self.rects = []
self.imagenes1_array = ['autobus.png','coche.png','barco.png','autobus2.png','grua.png','bici.png']
for i in self.imagenes1_array:
# We divide in variables so we can then get the rect of the whole Img (i2)
i2 = pygame.image.load(i)
self.images.append(i2)
s = pygame.Surface(i2.get_size())
r = s.get_rect()
# Trying to use colliderect so it doesnt overlap
if pygame.Rect.colliderect(r,r) == True:
x = random.randint(300,1000)
y = random.randint(200,700)
self.rects.append(r)
def start(self, gamestate):
self.gamestate = gamestate
for rect in self.rects:
# Give random coordinates (we limit the dimensions (x,y))
x = random.randint(300,1000)
y = random.randint(200,700)
rect.x = x
rect.y = y
def draw(self,screen):
self.background = pygame.Surface(size)
font = pygame.font.SysFont("comicsansms",70)
# First half (Show image to remember)
text1 = font.render('¡A recordar!',True, PURPLE)
text1_1 = text1.copy()
# This surface is used to adjust the alpha of the txt_surf.
alpha_surf = pygame.Surface(text1_1.get_size(), pygame.SRCALPHA)
alpha = 255 # The current alpha value of the surface.
if alpha > 0:
alpha = max(alpha-4, 0)
text1_1 = text1.copy()
alpha_surf.fill((255, 255, 255, alpha))
text1_1.blit(alpha_surf, (0,0), special_flags = pygame.BLEND_RGBA_MULT)
screen.blit(text1_1, (600,50))
# Second half (Show all similar images)
text2 = font.render('¿Cuál era el dibujo?',True, PURPLE)
#screen.blit(text2, (500,50))
for i in range(len(self.images)):
#colliding = pygame.Rect.collidelistall(self.rects)
screen.blit(self.images[i], (self.rects[i].x, self.rects[i].y))
def update(self, events, dt):
for event in events:
if event.type == pygame.MOUSEBUTTONDOWN:
for rect in self.rects:
if rect.collidepoint(event.pos):
print('works!')
Use collidelist() to test test if one rectangle in a list intersects:
for i in self.imagenes1_array:
s = pygame.image.load(i)
self.images.append(s)
r = s.get_rect()
position_set = False
while not position_set:
r.x = random.randint(300,1000)
r.y = random.randint(200,700)
margin = 10
rl = [rect.inflate(margin*2, margin*2) for rect in self.rects]
if len(self.rects) == 0 or r.collidelist(rl) < 0:
self.rects.append(r)
position_set = True
See the minimal example, that uses the algorithm to generate random not overlapping rectangles:
import pygame
import random
pygame.init()
window = pygame.display.set_mode((400, 400))
clock = pygame.time.Clock()
def new_recs(rects):
rects.clear()
for _ in range(10):
r = pygame.Rect(0, 0, random.randint(30, 40), random.randint(30, 50))
position_set = False
while not position_set:
r.x = random.randint(10, 340)
r.y = random.randint(10, 340)
margin = 10
rl = [rect.inflate(margin*2, margin*2) for rect in rects]
if len(rects) == 0 or r.collidelist(rl) < 0:
rects.append(r)
position_set = True
rects = []
new_recs(rects)
run = True
while run:
clock.tick(60)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
elif event.type == pygame.KEYDOWN:
new_recs(rects)
window.fill(0)
for r in rects:
pygame.draw.rect(window, (255, 0, 0), r)
pygame.display.flip()
pygame.quit()
exit()
I am trying to make realistic water in pygame:
This is till now my code:
from random import randint
import pygame
WIDTH = 700
HEIGHT = 500
win = pygame.display.set_mode((WIDTH, HEIGHT))
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
AQUA = 'aqua'
RADIUS = 1
x, y = 0, HEIGHT//2
K = 1
FORCE = 100
VELOCITY = 0.5
run = True
class Molecule:
def __init__(self, x, y, radius, force, k):
self.x = x
self.y = y
self.radius = radius
self.force = force
self.k = k
self.max_amplitude = y + force/k
self.min_amplitude = y - force/k
self.up = False
self.down = True
self.restore = False
def draw(self, win):
pygame.draw.circle(win, BLACK, (self.x, self.y), self.radius)
def oscillate(self):
if self.y <= self.max_amplitude and self.down == True:
self.y += VELOCITY
if self.y == self.max_amplitude or self.up:
self.up = True
self.down = False
self.y -= VELOCITY
if self.y == self.min_amplitude:
self.up = False
self.down = True
molecules = []
for i in range(100):
FORCE = randint(10, 20)
molecules.append(Molecule(x, y, RADIUS, FORCE, K))
x += 10
while run:
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
win.fill(WHITE)
for molecule in molecules:
molecule.draw(win)
molecule.oscillate()
for i in range(len(molecules)):
try:
pygame.draw.line(win, BLACK, (molecules[i].x, molecules[i].y), (molecules[i+1].x, molecules[i+1].y))
pygame.draw.line(win, AQUA, (molecules[i].x, molecules[i].y), (molecules[i+1].x, HEIGHT))
except:
pass
pygame.display.flip()
pygame.quit()
But as may expected the water curve is not smooth:
Look at it:
Sample Img1
I want to connect the two randomly added wave points using a set of circles not line like in this one so that a smooth curve could occur.
And in this way i could add the water color to it such that it will draw aqua lines or my desired color line from the point to the end of screen and all this will end up with smooth water flowing simulation.
Now the question is how could i make the points connect together smoothly into a smooth curve by drawing point circles at relative points?
I suggest sticking the segments with a Bézier curves. Bézier curves can be drawn with pygame.gfxdraw.bezier
Calculate the slopes of the tangents to the points along the wavy waterline:
ts = []
for i in range(len(molecules)):
pa = molecules[max(0, i-1)]
pb = molecules[min(len(molecules)-1, i+1)]
ts.append((pb.y-pa.y) / (pb.x-pa.x))
Use the the tangents to define 4 control points for each segment and draw the curve with pygame.gfxdraw.bezier:
for i in range(len(molecules)-1):
p0 = molecules[i].x, molecules[i].y
p3 = molecules[i+1].x, molecules[i+1].y
p1 = p0[0] + 10, p0[1] + 10 * ts[i]
p2 = p3[0] - 10, p3[1] - 10 * ts[i+1]
pygame.gfxdraw.bezier(win, [p0, p1, p2, p3], 4, BLACK)
Complete example:
from random import randint
import pygame
import pygame.gfxdraw
WIDTH = 700
HEIGHT = 500
win = pygame.display.set_mode((WIDTH, HEIGHT))
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
AQUA = 'aqua'
RADIUS = 1
x, y = 0, HEIGHT//2
K = 1
FORCE = 100
VELOCITY = 0.5
class Molecule:
def __init__(self, x, y, radius, force, k):
self.x = x
self.y = y
self.radius = radius
self.force = force
self.k = k
self.max_amplitude = y + force/k
self.min_amplitude = y - force/k
self.up = False
self.down = True
self.restore = False
def draw(self, win):
pygame.draw.circle(win, BLACK, (self.x, self.y), self.radius)
def oscillate(self):
if self.y <= self.max_amplitude and self.down == True:
self.y += VELOCITY
if self.y == self.max_amplitude or self.up:
self.up = True
self.down = False
self.y -= VELOCITY
if self.y == self.min_amplitude:
self.up = False
self.down = True
molecules = []
for i in range(50):
FORCE = randint(10, 20)
molecules.append(Molecule(x, y, RADIUS, FORCE, K))
x += 20
clock = pygame.time.Clock()
run = True
while run:
clock.tick(100)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
win.fill(WHITE)
for molecule in molecules:
molecule.draw(win)
molecule.oscillate()
ts = []
for i in range(len(molecules)):
pa = molecules[max(0, i-1)]
pb = molecules[min(len(molecules)-1, i+1)]
ts.append((pb.y-pa.y) / (pb.x-pa.x))
for i in range(len(molecules)-1):
p0 = molecules[i].x, molecules[i].y
p3 = molecules[i+1].x, molecules[i+1].y
p1 = p0[0] + 10, p0[1] + 10 * ts[i]
p2 = p3[0] - 10, p3[1] - 10 * ts[i+1]
pygame.gfxdraw.bezier(win, [p0, p1, p2, p3], 4, BLACK)
for i in range(len(molecules)-1):
pygame.draw.line(win, AQUA, (molecules[i].x, molecules[i].y), (molecules[i].x, HEIGHT))
pygame.display.flip()
pygame.quit()
If you want to "fill" the water, you must calculate the points along the Bézier line and draw a filled polygon. How to calculate a Bézier curve is explained in Trying to make a Bezier Curve on PyGame library How Can I Make a Thicker Bezier in Pygame? and "X". You can use the following function:
def ptOnCurve(b, t):
q = b.copy()
for k in range(1, len(b)):
for i in range(len(b) - k):
q[i] = (1-t) * q[i][0] + t * q[i+1][0], (1-t) * q[i][1] + t * q[i+1][1]
return round(q[0][0]), round(q[0][1])
def bezier(b, samples):
return [ptOnCurve(b, i/samples) for i in range(samples+1)]
Use the bezier to stitch the wavy water polygon:
ts = []
for i in range(len(molecules)):
pa = molecules[max(0, i-1)]
pb = molecules[min(len(molecules)-1, i+1)]
ts.append((pb.y-pa.y) / (pb.x-pa.x))
pts = [(WIDTH, HEIGHT), (0, HEIGHT)]
for i in range(len(molecules)-1):
p0 = molecules[i].x, molecules[i].y
p3 = molecules[i+1].x, molecules[i+1].y
p1 = p0[0] + 10, p0[1] + 10 * ts[i]
p2 = p3[0] - 10, p3[1] - 10 * ts[i+1]
pts += bezier([p0, p1, p2, p3], 4)
Draw the polygon with pygame.draw.polygon():
pygame.draw.polygon(win, AQUA, pts)
Complete example:
from random import randint
import pygame
class Node:
def __init__(self, x, y, force, k, v):
self.x = x
self.y = y
self.y0 = y
self.force = force
self.k = k
self.v = v
self.direction = 1
def oscillate(self):
self.y += self.v * self.direction
if self.y0 - self.force / self.k > self.y or self.y0 + self.force / self.k < self.y:
self.direction *= -1
def draw(self, surf):
pygame.draw.circle(surf, "black", (self.x, self.y), 3)
window = pygame.display.set_mode((700, 500))
clock = pygame.time.Clock()
width, height = window.get_size()
no_of_nodes = 25
dx = width / no_of_nodes
nodes = [Node(i*dx, height//2, randint(15, 30), 1, 0.5) for i in range(no_of_nodes+1)]
def ptOnCurve(b, t):
q = b.copy()
for k in range(1, len(b)):
for i in range(len(b) - k):
q[i] = (1-t) * q[i][0] + t * q[i+1][0], (1-t) * q[i][1] + t * q[i+1][1]
return round(q[0][0]), round(q[0][1])
def bezier(b, samples):
return [ptOnCurve(b, i/samples) for i in range(samples+1)]
run = True
while run:
clock.tick(100)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
for molecule in nodes:
molecule.oscillate()
ts = []
for i in range(len(nodes)):
pa = nodes[max(0, i-1)]
pb = nodes[min(len(nodes)-1, i+1)]
ts.append((pb.y-pa.y) / (pb.x-pa.x))
pts = [(width, height), (0, height)]
for i in range(len(nodes)-1):
p0 = nodes[i].x, nodes[i].y
p3 = nodes[i+1].x, nodes[i+1].y
p1 = p0[0] + 10, p0[1] + 10 * ts[i]
p2 = p3[0] - 10, p3[1] - 10 * ts[i+1]
pts += bezier([p0, p1, p2, p3], 4)
window.fill("white")
pygame.draw.polygon(window, 'aqua', pts)
for molecule in nodes:
molecule.draw(window)
pygame.display.flip()
pygame.quit()
exit()
I'm making a game with pygame and pymunk as a physics engine. I'm trying to kill a bullet whenever it hits a player or goes past its lifetime.
When I tried to space.remove(self.shape) and the second bullet hits the player, it gives me an "AssertionError: shape not in space, already removed. I simply changed it to teleport the bullets away, and then learned of the real error.
When I have more than one bullet in the space and a bullet hits the enemy player, all the current bullets teleport away, which means that when I tried to remove one bullet, it called the remove on all the bullets and thats why I had the initial error.
However the problem still remains that one bullet is being treated as every bullet.
Why is something that should be a non-static variable being called as a static variable?
I even tried to use deepcopy to see if that fixed it, but to no avail
This is my chunk of code, apologies since I don't know what is needed to understand it.
The key parts are most likely the Bullet class, the shoot() function in the Player class, and the drawBulletCollision() function
# PyGame template.
# Import modules.
import sys, random, math, time, copy
from typing import List
import pygame
from pygame.locals import *
from pygame import mixer
import pymunk
import pymunk.pygame_util
from pymunk.shapes import Segment
from pymunk.vec2d import Vec2d
pygame.mixer.pre_init(44110, -16, 2, 512)
mixer.init()
# Set up the window.
width, height = 1440, 640
screen = pygame.display.set_mode((width, height))
bg = pygame.image.load("space.png")
def draw_bg():
screen.blit(bg, (0, 0))
#load sounds
#death_fx = pygame.mixer.Sound("")
#death_fx.set_volume(0.25)
shoot_fx = mixer.Sound("shot.wav")
shoot_fx.set_volume(0.25)
#mixer.music.load("video.mp3")
#mixer.music.play()
#time.sleep(2)
#mixer.music.stop()
#gun_mode_fx = pygame.mixer.Sound("")
#gun_mode_fx.set_volume(0.25)
#thrust_mode_fx = pygame.mixer.Sound("")
#thrust_mode_fx.set_volume(0.25)
collision_fx = mixer.Sound("thump.wav")
collision_fx.set_volume(0.25)
ship_group = pygame.sprite.Group()
space = pymunk.Space()
space.gravity = 0, 0
space.damping = 0.6
draw_options = pymunk.pygame_util.DrawOptions(screen)
bulletList = []
playerList = []
environmentList = []
arbiterList = []
b0 = space.static_body
segmentBot = pymunk.Segment(b0, (0,height), (width, height), 4)
segmentTop = pymunk.Segment(b0, (0,0), (width, 0), 4)
segmentLef = pymunk.Segment(b0, (width,0), (width, height), 4)
segmentRit = pymunk.Segment(b0, (0,0), (0, height), 4)
walls = [segmentBot,segmentLef,segmentRit,segmentTop]
for i in walls:
i.elasticity = 1
i.friction = 0.5
i.color = (255,255,255,255)
environmentList.append(i)
class Player(object):
radius = 30
def __init__(self, position, space, color):
self.body = pymunk.Body(mass=5,moment=10)
self.mode = 0 # 0 is gun, 1 is thrust, ? 2 is shield
self.body.position = position
self.shape = pymunk.Circle(self.body, radius = self.radius)
#self.image
#self.shape.friction = 0.9
self.shape.elasticity= 0.2
space.add(self.body,self.shape)
self.angleGun = 0
self.angleThrust = 0
self.health = 100
self.speed = 500
self.gearAngle = 0
self.turningSpeed = 5
self.shape.body.damping = 1000
self.cooldown = 0
self.fireRate = 30
self.shape.collision_type = 1
self.shape.color = color
playerList.append(self)
def force(self,force):
self.shape.body.apply_force_at_local_point(force,(0,0))
def rocketForce(self):
radians = self.angleThrust * math.pi/180
self.shape.body.apply_force_at_local_point((-self.speed * math.cos(radians),-self.speed * math.sin(radians)),(0,0))
def draw(self):
gear = pygame.image.load("gear.png")
gearBox = gear.get_rect(center=self.shape.body.position)
gearRotated = pygame.transform.rotate(gear, self.gearAngle)
#gearRotated.rect.center=self.shape.body.position
x,y = self.shape.body.position
radianGun = self.angleGun * math.pi/180
radianThrust = self.angleThrust * math.pi/180
radiyus = 30 *(100-self.health)/100
screen.blit(gearRotated,gearBox)
self.gearAngle += 1
if radiyus == 30:
radiyus = 32
pygame.draw.circle(screen,self.shape.color,self.shape.body.position,radiyus,0)
pygame.draw.circle(screen,(0,0,0),self.shape.body.position,radiyus,0)
pygame.draw.line(
screen,(0,255,0),
(self.radius * math.cos(radianGun) * 1.5 + x,self.radius * math.sin(radianGun) * 1.5 + y),
(x,y), 5
)
pygame.draw.line(
screen,(200,200,0),
(self.radius * math.cos(radianThrust) * 1.5 + x,self.radius * math.sin(radianThrust) * 1.5 + y),
(x,y), 5
)
#more
def targetAngleGun(self,tAngle):
tempTAngle = tAngle - self.angleGun
tempTAngle = tempTAngle % 360
if(tempTAngle < 180 and not tempTAngle == 0):
self.angleGun -= self.turningSpeed
elif(tempTAngle >= 180 and not tempTAngle == 0):
self.angleGun += self.turningSpeed
self.angleGun = self.angleGun % 360
#print(tAngle, "target Angle")
#print(self.angleGun, "selfangleGun")
#print(tempTAngle, "tempTAngle")
def targetAngleThrust(self,tAngle):
tempTAngle = tAngle - self.angleThrust
tempTAngle = tempTAngle % 360
if(tempTAngle < 180 and not tempTAngle == 0):
self.angleThrust -= self.turningSpeed
elif(tempTAngle >= 180 and not tempTAngle == 0):
self.angleThrust += self.turningSpeed
self.angleThrust = self.angleThrust % 360
#print(tAngle, "target Angle")
#print(self.angleThrust, "selfangleGun")
#print(tempTAngle, "tempTAngle")
def targetAngle(self,tAngle):
if(self.mode == 0):
self.targetAngleGun(tAngle)
elif(self.mode == 1):
self.targetAngleThrust(tAngle)
def shoot(self):
if(self.cooldown == self.fireRate):
x,y = self.shape.body.position
radianGun = self.angleGun * math.pi/180
spawnSpot = (self.radius * math.cos(radianGun) * 1.5 + x,self.radius * math.sin(radianGun)*1.5+y)
self.shape.body.apply_impulse_at_local_point((-20 * math.cos(radianGun),-20 * math.sin(radianGun)),(0,0))
print(spawnSpot)
bT = Bullet(spawnSpot, 5, 50,self.shape.color)
b = copy.deepcopy(bT)
bulletList.append(b)
space.add(b.shape,b.shape.body)
b.getShot(self.angleGun)
self.cooldown = 0
print('pew')
shoot_fx.play()
# HEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEREEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
def tick(self):
self.draw()
if(self.cooldown < self.fireRate):
self.cooldown += 1
#for o in playerList:
# c = self.shape.shapes_collide(o.shape)
# if(len(c.points)>0):
# self.damage(c.points[0].distance/10)
for o in bulletList:
c = self.shape.shapes_collide(o.shape)
#print(c)
for o in walls:
c = self.shape.shapes_collide(o)
if(len(c.points)>0):
self.damage(c.points[0].distance * 3)
def damage(self, damage):
self.health -= abs(damage)
if self.health < 0:
self.health = 0
#maybe make it part of the player class
def drawWallCollision(arbiter, space, data):
for c in arbiter.contact_point_set.points:
r = max(3, abs(c.distance * 5))
r = int(r)
p = tuple(map(int, c.point_a))
pygame.draw.circle(data["surface"], pygame.Color("red"), p, r, 0)
print('magnitude', math.sqrt(arbiter.total_impulse[0]**2 + arbiter.total_impulse[1]**2))
#print('position', p)
#print(data)
print("its all arbitrary")
s1, s2 = arbiter.shapes
collision_fx.play()
def drawBulletCollision(arbiter, space, data):
s1, s2 = arbiter.shapes
for c in arbiter.contact_point_set.points:
magnitude = math.sqrt(arbiter.total_impulse[0]**2 + arbiter.total_impulse[1]**2)
for p in playerList:
avr = ((c.point_a[0] + c.point_b[0])/2, (c.point_a[1] + c.point_b[1])/2)
distance = (math.sqrt((avr[0] - p.shape.body.position[0]) **2 + (avr[1] - p.shape.body.position[1]) **2 ))
if(distance < Bullet.explosionRadius + Player.radius):
if not(s1.color == s2.color):
p.damage(magnitude)
for b in bulletList:
avr = ((c.point_a[0] + c.point_b[0])/2, (c.point_a[1] + c.point_b[1])/2)
distance = (math.sqrt((avr[0] - p.shape.body.position[0]) **2 + (avr[1] - p.shape.body.position[1]) **2 ))
if(distance < Bullet.explosionRadius + Player.radius):
if not(s1.color == s2.color):
b.damage(magnitude)
pygame.draw.circle(data["surface"], pygame.Color("red"), tuple(map(int, c.point_a)), 10, 0)
print('magnitude', magnitude)
#print('position', p)
#print(data)
print("its all arbitrary")
def drawArbitraryCollision(arbiter, space, data):
collision_fx.play()
class Ship(pygame.sprite.Sprite):
def __init__(self, x, y):
pygame.sprite.Sprite.__init__(self)
self.image = pygame.image.load("gear.png")
self.rect = self.image.get_rect()
self.rect.center = [x, y]
def rotate(self):
self.image = pygame.transform.rotate(self.image,1)
class Bullet(object):
damage = 2
explosionRadius = 5
def __init__(self, position, size, speed,color):
pts = [(-size, -size), (size, -size), (size, size), (-size, size)]
self.body = copy.deepcopy(pymunk.Body(mass=0.1,moment=1))
self.shape = copy.deepcopy(pymunk.Poly(self.body, pts))
self.shape.body.position = position
self.shape.friction = 0.5
self.shape.elasticity = 1
self.shape.color = color
self.speed = speed
self.size = size
self.shape.collision_type = 2
#space.add(self.body,self.shape)
#bulletList.append(self)
self.lifetime = 0
def getShot(self,angle):
radians = angle * math.pi/180
self.shape.body.apply_impulse_at_local_point((self.speed * math.cos(radians),self.speed * math.sin(radians)),(0,0))
def tick(self):
self.lifetime += 1
if(self.lifetime > 300):
self.shape.body.position = (10000,30)
def damage(self, damage):
self.lifetime = 300
#VELOCITY OF BULLET STARTS WITH VELOCITY OF PLAYER
#MAKE VOLUME OF SOUND DEPEND ON THE IMPULSE FOR THE IMPACTS
#error on purpose so you notice this
#INSTANCES NOT WORKING????
def runPyGame():
# Initialise PyGame.
pygame.init()
# Set up the clock. This will tick every frame and thus maintain a relatively constant framerate. Hopefully.
fps = 60.0
fpsClock = pygame.time.Clock()
running = True
font = pygame.font.SysFont("Arial", 16)
p1 = Player((240,240),space,(132, 66, 245,255))
p2 = Player((1200,400),space,(47, 247, 184,255))
space.add(segmentBot,segmentTop,segmentLef,segmentRit)
# Main game loop.
ch = space.add_collision_handler(1, 0)
ch.data["surface"] = screen
ch.post_solve = drawWallCollision
ch = space.add_collision_handler(1, 2)
ch.data["surface"] = screen
ch.post_solve = drawBulletCollision
ch = space.add_collision_handler(0, 2)
ch.data["surface"] = screen
ch.post_solve = drawArbitraryCollision
dt = 1/fps # dt is the time since last frame.
while True: # Loop forever!
keys = pygame.key.get_pressed()
for event in pygame.event.get():
# We need to handle these events. Initially the only one you'll want to care
# about is the QUIT event, because if you don't handle it, your game will crash
# whenever someone tries to exit.
if event.type == QUIT:
pygame.quit() # Opposite of pygame.init
sys.exit() # Not including this line crashes the script on Windows.
if event.type == KEYDOWN:
if event.key == pygame.K_s:
p1.mode = -(p1.mode - 0.5) + 0.5
print(p1.mode)
if (event.key == pygame.K_k and p1.mode == 0):
p1.shoot()
if event.key == pygame.K_KP_5:
p2.mode = -(p2.mode - 0.5) + 0.5
print(p2.mode)
if (event.key == pygame.K_m and p2.mode == 0):
p2.shoot()
#b = Bullet((200,200),51,51)
if(keys[K_w]):
p1.targetAngle(90)
if(keys[K_q]):
p1.targetAngle(45)
if(keys[K_a]):
p1.targetAngle(0)
if(keys[K_z]):
p1.targetAngle(315)
if(keys[K_x]):
p1.targetAngle(270)
if(keys[K_c]):
p1.targetAngle(225)
if(keys[K_d]):
p1.targetAngle(180)
if(keys[K_e]):
p1.targetAngle(135)
if(keys[K_k] and p1.mode == 1):
p1.rocketForce()
if(keys[K_KP_8]):
p2.targetAngle(90)
if(keys[K_KP_7]):
p2.targetAngle(45)
if(keys[K_KP_4]):
p2.targetAngle(0)
if(keys[K_KP_1]):
p2.targetAngle(315)
if(keys[K_KP_2]):
p2.targetAngle(270)
if(keys[K_KP_3]):
p2.targetAngle(225)
if(keys[K_KP_6]):
p2.targetAngle(180)
if(keys[K_KP_9]):
p2.targetAngle(135)
if(keys[K_m] and p2.mode == 1):
p2.rocketForce()
# Handle other events as you wish.
screen.fill((250, 250, 250)) # Fill the screen with black.
# Redraw screen here.
### Draw stuff
draw_bg()
space.debug_draw(draw_options)
for i in playerList:
i.tick()
screen.blit(
font.render("P1 Health: " + str(p1.health), True, pygame.Color("white")),
(50, 10),
)
screen.blit(
font.render("P2 Health: " + str(p2.health), True, pygame.Color("white")),
(50, 30),
)
for i in bulletList:
i.tick()
ship_group.draw(screen)
# Flip the display so that the things we drew actually show up.
pygame.display.update()
dt = fpsClock.tick(fps)
space.step(0.01)
pygame.display.update()
runPyGame()
I cant point to the exact error since the code is quite long and depends on files I dont have. But here is a general advice for troubleshooting:
Try to give a name to each shape when you create them, and then print it out. Also print out the name of each shape that you add or remove from the space. This should show which shape you are actually removing and will probably make it easy to understand whats wrong.
For example:
...
self.shape = pymunk.Circle(self.body, radius = self.radius)
self.shape.name = "circle 1"
print("Created", self.shape.name)
...
print("Adding", self.shape.name)
space.add(self.body,self.shape)
...
(Note that you need to reset the name of shapes you copy, since otherwise the copy will have the same name.)
Since character movement is grid based, characters look a bit odd when going from square to square as they just appear from one square onto another. To make the movement feel more natural, I wanted to add "afterimages" so that there would be a simulation of smooth movement.
Demonstrational image:
Since my code has characters moving directly onto the next square, I don't know how to blit sprites in between.
if IDO.get_key(pygame.K_RIGHT):
if PhaseFocus == 0 or PhaseFocus == 2:
Reticlex +=1
if Currently_Selected != 0 and Currently_Selected.Phase == 2:
if Currently_Selected.x != Reticlex:
Currently_Selected.x = Reticlex
if Currently_Selected.x != Reticley:
Currently_Selected.y = Reticley
if IDO.get_key(pygame.K_LEFT):
if PhaseFocus == 0 or PhaseFocus == 2:
Reticlex -=1
if Currently_Selected != 0 and Currently_Selected.Phase == 2:
if Currently_Selected.x != Reticlex:
Currently_Selected.x = Reticlex
if Currently_Selected.x != Reticley:
Currently_Selected.y = Reticley
When the currently selected character is in Phase 2 (carried around) they should have these afterimages.
Let's see how we can do this.
Step 1: Basic setup
We start with an "empty" pygame game, like this:
import pygame
def main():
screen = pygame.display.set_mode((640, 480))
clock = pygame.time.Clock()
while True:
events = pygame.event.get()
for e in events:
if e.type == pygame.QUIT:
return
screen.fill((30, 30, 30))
pygame.display.flip()
clock.tick(60)
if __name__ == '__main__':
main()
We have a Clock, a single game loop and handle the QUIT event. I always store the events from event.get() in a variable in case I want to iterate over them again, e.g. when a Sprite wants to listen for an event. Always call event.get() only once per frame!
Step 2: A grid
We want a grid based game, so let's draw a grid. Also, we store a bunch of Rects in a list so it will be easy for us to lookup the screen coordinates of an object. We want to center objects in their tile, so using the Rect class will do the dirty work for us.
import pygame
TILESIZE = 32
GRID_W, GRID_H = (20, 15)
def create_grid():
surf = pygame.Surface((TILESIZE * GRID_W, TILESIZE * GRID_H))
surf.set_colorkey((2, 2, 2))
surf.fill((2, 2, 2))
grid = []
for y in range(GRID_H):
line = []
for x in range(GRID_W):
r = pygame.Rect(x * TILESIZE, y * TILESIZE, TILESIZE, TILESIZE)
line.append(r)
pygame.draw.rect(surf, pygame.Color('grey'), r, 1)
grid.append(line)
return grid, surf
def main():
screen = pygame.display.set_mode((TILESIZE * GRID_W, TILESIZE * GRID_H))
clock = pygame.time.Clock()
grid, grid_surf = create_grid()
while True:
events = pygame.event.get()
for e in events:
if e.type == pygame.QUIT:
return
screen.fill((30, 30, 30))
screen.blit(grid_surf, (0, 0))
pygame.display.flip()
clock.tick(60)
Step 3: Something's moving on the grid
We now create an actor that travels on this grid. In this case it's a simple Sprite that moves every second.
import pygame
import random
TILESIZE = 32
GRID_W, GRID_H = (20, 15)
LOOKUP = None
class Actor(pygame.sprite.Sprite):
def __init__(self, grid_pos):
super().__init__()
self.image = pygame.Surface((TILESIZE // 2, TILESIZE // 2))
self.rect = self.image.get_rect()
self.pos = pygame.Vector2()
self.update_pos(grid_pos)
self.image.fill(pygame.Color('dodgerblue'))
self.timeout = 1000
def update_pos(self, grid_pos):
self.grid_pos = grid_pos
self.rect.center = get_grid_rect(grid_pos).center
self.pos = pygame.Vector2(self.rect.topleft)
def move_random(self):
d = random.choice([-1, 1])
x, y = self.grid_pos
if random.randint(0, 2):
x += d
else:
y += d
self.update_pos((x, y))
def update(self, events, dt):
self.timeout -= dt
if self.timeout <= 0:
self.timeout = 1000
self.move_random()
def get_grid_rect(pos):
x, y = pos
return LOOKUP[y][x]
def create_grid():
surf = pygame.Surface((TILESIZE * GRID_W, TILESIZE * GRID_H))
surf.set_colorkey((2, 2, 2))
surf.fill((2, 2, 2))
grid = []
for y in range(GRID_H):
line = []
for x in range(GRID_W):
r = pygame.Rect(x * TILESIZE, y * TILESIZE, TILESIZE, TILESIZE)
line.append(r)
pygame.draw.rect(surf, pygame.Color('grey'), r, 1)
grid.append(line)
return grid, surf
def main():
screen = pygame.display.set_mode((TILESIZE * GRID_W, TILESIZE * GRID_H))
dt, clock = 0, pygame.time.Clock()
grid, grid_surf = create_grid()
global LOOKUP
LOOKUP = grid
sprites = pygame.sprite.Group(Actor((9, 6)))
while True:
events = pygame.event.get()
for e in events:
if e.type == pygame.QUIT:
return
sprites.update(events, dt)
screen.fill((30, 30, 30))
screen.blit(grid_surf, (0, 0))
sprites.draw(screen)
pygame.display.flip()
dt = clock.tick(60)
if __name__ == '__main__':
main()
Step 4: Smooth movement
Instead of always drawing the Actor that the center of the tiles, we set a target_grid_pos when we want to move. Each frame, we move the Actor a little bit until we reached our target tile. We use pygame's Vector2 class and it's lerp and distance_to methods.
import pygame
import random
TILESIZE = 32
GRID_W, GRID_H = (20, 15)
LOOKUP = None
class Actor(pygame.sprite.Sprite):
def __init__(self, grid_pos):
super().__init__()
self.image = pygame.Surface((TILESIZE // 2, TILESIZE // 2))
self.rect = self.image.get_rect()
self.pos = pygame.Vector2()
self.update_pos(grid_pos)
self.image.fill(pygame.Color('dodgerblue'))
self.timeout = 1000
def update_pos(self, grid_pos):#
self.target_pos = None
self.target_grid_pos = None
self.grid_pos = grid_pos
self.rect.center = get_grid_rect(grid_pos).center
self.pos = pygame.Vector2(self.rect.center)
def move_random(self):
d = random.choice([-1, 1])
x, y = self.grid_pos
if random.randint(0, 2):
x += d
else:
y += d
self.target_pos = pygame.Vector2(get_grid_rect((x, y)).center)
self.target_grid_pos = (x, y)
def update(self, events, dt):
self.timeout -= dt
if self.timeout <= 0:
self.timeout = 1000
self.move_random()
if self.target_grid_pos:
self.pos = self.pos.lerp(self.target_pos, 0.1)
if self.pos.distance_to(self.target_pos) < 1:
self.update_pos(self.target_grid_pos)
self.rect.center = self.pos
def get_grid_rect(pos):
x, y = pos
return LOOKUP[y][x]
def create_grid():
surf = pygame.Surface((TILESIZE * GRID_W, TILESIZE * GRID_H))
surf.set_colorkey((2, 2, 2))
surf.fill((2, 2, 2))
grid = []
for y in range(GRID_H):
line = []
for x in range(GRID_W):
r = pygame.Rect(x * TILESIZE, y * TILESIZE, TILESIZE, TILESIZE)
line.append(r)
pygame.draw.rect(surf, pygame.Color('grey'), r, 1)
grid.append(line)
return grid, surf
def main():
screen = pygame.display.set_mode((TILESIZE * GRID_W, TILESIZE * GRID_H))
dt, clock = 0, pygame.time.Clock()
grid, grid_surf = create_grid()
global LOOKUP
LOOKUP = grid
sprites = pygame.sprite.Group(Actor((9, 6)))
while True:
events = pygame.event.get()
for e in events:
if e.type == pygame.QUIT:
return
sprites.update(events, dt)
screen.fill((30, 30, 30))
screen.blit(grid_surf, (0, 0))
sprites.draw(screen)
pygame.display.flip()
dt = clock.tick(60)
if __name__ == '__main__':
main()
Step 5: Adding the effect
Every 300 ms, we create a copy of the Actor's image, blit it at the Actor's position, and make sure to delete it after 200ms. In a real game, you probably want to cache the images or use pre-rendered ones.
I switched the Group for LayeredUpdates so we can make sure the original images is always drawn above the "shadows".
I also added an image (from rltiles) instead of a simple rect so it looks nicer in this demo.
import pygame
import random
import gzip
import base64
TILESIZE = 64
GRID_W, GRID_H = (10, 7)
LOOKUP = None
class Shadow(pygame.sprite.Sprite):
def __init__(self, source):
super().__init__()
self._layer = 5
self.image = source.image.copy().convert_alpha()
self.image.fill((0, 0, 200, 100), special_flags=pygame.BLEND_ADD)
self.rect = source.rect.copy()
self.timeout = 200
def update(self, events, dt):
self.timeout -= dt
if self.timeout <= 0:
self.kill()
class Actor(pygame.sprite.Sprite):
def __init__(self, grid_pos):
super().__init__()
self._layer = 10
data, size = gzip.decompress(base64.b64decode(HYDRA)), (64, 64)
self.image = pygame.image.fromstring(data, size, "RGB")
self.image.set_colorkey((71, 108, 108))
self.rect = self.image.get_rect()
self.pos = pygame.Vector2()
self.update_pos(grid_pos)
self.timeout = 1000
self.shadow_timeout = 100
def update_pos(self, grid_pos):#
self.target_pos = None
self.target_grid_pos = None
self.grid_pos = grid_pos
self.rect.center = get_grid_rect(grid_pos).center
self.pos = pygame.Vector2(self.rect.center)
def move_random(self):
d = random.choice([-1, 1])
x, y = self.grid_pos
if random.randint(0, 2):
x += d
else:
y += d
self.target_pos = pygame.Vector2(get_grid_rect((x, y)).center)
self.target_grid_pos = (x, y)
def update(self, events, dt):
self.timeout -= dt
if self.timeout <= 0:
self.timeout = 1000
self.move_random()
if self.target_grid_pos:
self.shadow_timeout -= dt
if self.shadow_timeout <= 0:
self.shadow_timeout = 100
self.groups()[0].add(Shadow(self))
self.pos = self.pos.lerp(self.target_pos, 0.1)
if self.pos.distance_to(self.target_pos) < 1:
self.update_pos(self.target_grid_pos)
self.rect.center = self.pos
def get_grid_rect(pos):
x, y = pos
return LOOKUP[y][x]
def create_grid():
surf = pygame.Surface((TILESIZE * GRID_W, TILESIZE * GRID_H))
surf.set_colorkey((2, 2, 2))
surf.fill((2, 2, 2))
grid = []
for y in range(GRID_H):
line = []
for x in range(GRID_W):
r = pygame.Rect(x * TILESIZE, y * TILESIZE, TILESIZE, TILESIZE)
line.append(r)
pygame.draw.rect(surf, pygame.Color('grey'), r, 1)
grid.append(line)
return grid, surf
def main():
screen = pygame.display.set_mode((TILESIZE * GRID_W, TILESIZE * GRID_H))
dt, clock = 0, pygame.time.Clock()
grid, grid_surf = create_grid()
global LOOKUP
LOOKUP = grid
sprites = pygame.sprite.LayeredUpdates(Actor((4, 3)))
while True:
events = pygame.event.get()
for e in events:
if e.type == pygame.QUIT:
return
sprites.update(events, dt)
screen.fill((30, 30, 30))
screen.blit(grid_surf, (0, 0))
sprites.draw(screen)
pygame.display.flip()
dt = clock.tick(60)
HYDRA = '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'
if __name__ == '__main__':
main()
So my question is simple: How do I make a sprite that my mouse can't pass through? I've been experimenting, and I found an unreliable way to do it that is also super glitchy. If anyone knows how I might go about this, please help.
Here is the code that I am currently using:
import pygame
import pyautogui
import sys
import time
pygame.init()
game_display = pygame.display.set_mode((800,600))
pygame.mouse.set_visible(True)
pygame.event.set_grab(True)
exit = False
class Wall(pygame.sprite.Sprite):
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.image = pygame.Surface((30, 100))
self.image.fill((255, 255, 255))
self.rect = self.image.get_rect()
self.rect.center = (200, 200)
def collision(self):
loc = pygame.mouse.get_pos()
yy = loc[1]
xx = loc[0]
if yy >= self.rect.top and yy <= self.rect.bottom and xx >= self.rect.left and xx <= self.rect.right:
if xx >= 200:
pyautogui.move(216 - xx, 0)
if xx <= 200:
pyautogui.move(-xx + 184, 0)
w = Wall()
all_sprites = pygame.sprite.Group()
all_sprites.add(w)
print(w.rect.top)
print(w.rect.bottom)
while (not exit):
mouse_move = (0,0)
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit = True
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
exit = True
w.collision()
clock = pygame.time.Clock()
game_display.fill((0, 0, 0))
clock.tick(30)
all_sprites.update()
all_sprites.draw(game_display)
pygame.display.flip()
pygame.quit()
note: please ignore my extra import statements, I am going to use them for later.
To do what you want you have to check if the line form the previous mouse position to the new mouse position intersects the rectangle. Write a function IntersectLineRec which checks for the intersection and use it and returns a list of intersection points, sorted by the distance.
The function returns a list of tules whith points and distances:
e.g.
[((215.0, 177.0), 12.0), ((185.0, 177.0), 42.0)]
prev_loc = pygame.mouse.get_pos()
class Wall(pygame.sprite.Sprite):
# [...]
def collision(self):
global prev_loc
loc = pygame.mouse.get_pos()
intersect = IntersectLineRec(prev_loc, loc, self.rect)
prev_loc = loc
if intersect:
ip = [*intersect[0][0]]
for i in range(2):
tp = self.rect.center[i] if ip[i] == loc[i] else loc[i]
ip[i] += -3 if ip[i] < tp else 3
pyautogui.move(ip[0]-loc[0], ip[1]-loc[1])
prev_loc = loc = ip
The function IntersectLineRec has to check if one of the 4 outer lines between the 4 corners of the rectangle inter sects the line between the mouse positions:
def IntersectLineRec(p1, p2, rect):
iL = [
IntersectLineLine(p1, p2, rect.bottomleft, rect.bottomright),
IntersectLineLine(p1, p2, rect.bottomright, rect.topright),
IntersectLineLine(p1, p2, rect.topright, rect.topleft),
IntersectLineLine(p1, p2, rect.topleft, rect.bottomleft) ]
iDist = [(i[1], pygame.math.Vector2(i[1][0] - p1[0], i[1][1] - p1[1]).length()) for i in iL if i[0]]
iDist.sort(key=lambda t: t[1])
return iDist
IntersectLineRec checks if to endless lines, which are defined by to points are intersecting. Then it checks if the intersection point is in the rectangles which are defined by the each of the lines (the line is the diagonal of the rectangle):
def IntersectLineLine(l1_p1, l1_p2, l2_p1, l2_p2):
isect, xPt = IntersectEndlessLineLine(l1_p1, l1_p2, l2_p1, l2_p2)
isect = isect and PtInRect(xPt, l1_p1, l1_p2) and PtInRect(xPt, l2_p1, l2_p2)
return isect, xPt
To check if a point is in an axis aligned rectangle has to check if both coordinates of the point are in the range of the coordinates of the rectangle:
def InRange(coord, range_s, range_e):
if range_s < range_e:
return coord >= range_s and coord <= range_e
return coord >= range_e and coord <= range_s
def PtInRect(pt, lp1, lp2):
return InRange(pt[0], lp1[0], lp2[0]) and InRange(pt[1], lp1[1], lp2[1])
The intersection of to endless lines can be calculated like this:
def IntersectEndlessLineLine(l1_p1, l1_p2, l2_p1, l2_p2):
# calculate the line vectors and test if both lengths are > 0
P = pygame.math.Vector2(*l1_p1)
Q = pygame.math.Vector2(*l2_p1)
line1 = pygame.math.Vector2(*l1_p2) - P
line2 = pygame.math.Vector2(*l2_p2) - Q
if line1.length() == 0 or line2.length() == 0:
return (False, (0, 0))
# check if the lines are not parallel
R, S = (line1.normalize(), line2.normalize())
dot_R_nvS = R.dot(pygame.math.Vector2(S[1], -S[0]))
if abs(dot_R_nvS) < 0.001:
return (False, (0, 0))
# calculate the intersection point of the lines
# t = dot(Q-P, (S.y, -S.x)) / dot(R, (S.y, -S.x))
# X = P + R * t
ptVec = Q-P
t = ptVec.dot(pygame.math.Vector2(S[1], -S[0])) / dot_R_nvS
xPt = P + R * t
return (True, (xPt[0], xPt[1]))
See the animation: