We Keep Coding

Explosions Sprite Despears Way To Fast When Enemy is Killed How Do Fix This?

on my draw I did this but the explosion doesnt event last a sec and just dispears
is there a better way I could do this instead of saying if the enemy health is greater then this load this?
for enemys in enemying:
if enemys.health < -4
for explode in explodes:
explode.draw((enemys.hitbox, enemys.hitbox))
my explosion class
class explode:
def __init__(self,x,y,height,width,color):
self.x = x
self.y = y
self.height = height
self.width = width
self.explode = [
pygame.image.load("spark_01.png"),
pygame.image.load("spark_02.png"),
pygame.image.load("spark_03.png"),
pygame.image.load("spark_04.png"),
pygame.image.load("spark_05.png"),
pygame.image.load("spark_06.png"),
pygame.image.load("spark_07.png")]
self.explode = [pygame.transform.scale(image,(image.get_width()//5,image.get_height()//5)) for image in self.explode]
self.rect = pygame.Rect(x,y,height,width)
self.direction = "blobright"
self.anim_index = 0
def draw(self,x):
self.rect.topleft = (self.x,self.y)
if self.direction == "blobright":
window.blit(self.explode[self.anim_index], self.rect)
self.anim_index += 1
if self.anim_index == len(self.explode):
self.anim_index = 0
black = (0,0,0)
explode1 = explode(400,450,50,50,black)
explodes = [explode1]
this is where I delete the enemys
for enemyshoot in enemyshooting:
for bullet in bullets:
if bullet.rect.colliderect(enemyshoot.hitbox):
if enemyshoot.health > -8:
enemyshoot.health -= 1
bullets.pop(bullets.index(bullet))
else:
del enemyshooting[one]

Here is the example I promised. Notice how the system clock and a flag
are used to control animation speed so that different actions can happen on the screen at different speeds. This program is written quick-and-dirty. There are MUCH more efficient ways to handle the animation so that the screen is only drawn to when it is time for something to move, and ONLY those parts of the screen that have changed are drawn and refreshed. But don't worry about that. The lesson here is how to use the clock to slow down your animation speed. What's the old saying? Code now, refactor later? Words to live by.
import pygame
from pygame.locals import * # Pygame Constants such as FULLSCREEN and KEYDOWN.
from pygame import Color
pygame.init()
import time
# ==============================================================
# Disable Windows Auto-scaling
# The windows auto-scaling feature can mess with pygame graphics.
# Windows-Specific: Delete if you are not on a Windows machine
# If you are on Windows, comment section to see the effect.
import ctypes
awareness = ctypes.c_int()
errorCode = ctypes.windll.shcore.GetProcessDpiAwareness(0, ctypes.byref(awareness))
errorCode = ctypes.windll.shcore.SetProcessDpiAwareness(2) # Awareness levels can be 0, 1 or 2:
# ===============================================================
# I will base the example on your explode class. If I were writing the
# game, I would use a sprite class along with a sprite group to simplify
# the code. However, these topics are an entirely different branch of study
# so I won't use them in the example. Forgive my quick-and-dirty code.
# I don't have your image files, but it looks as though
# you have an actual animation to use for your explosion that is
# made up of several different frames. We will emulate this for the
# sake of our demonstration.
class EXPLODE:
def create_spark(self):
TRANSPARENT = (254,255,255) # You can chose your own transparent color.
# Lacking the spark files, let's draw our own.
spark_img = pygame.Surface((31,31))
spark_img.fill(TRANSPARENT)
spark_img.set_colorkey(TRANSPARENT)
spark_rec = spark_img.get_rect()
left_center = (spark_rec.left,spark_rec.centery)
right_center = (spark_rec.right,spark_rec.centery)
top_center = (spark_rec.centerx,spark_rec.top)
bottom_center = (spark_rec.centerx,spark_rec.bottom)
top_left = spark_rec.topleft
top_right = spark_rec.topright
bottom_left = spark_rec.bottomleft
bottom_right = spark_rec.bottomright
pygame.draw.circle(spark_img,Color("yellow"),spark_rec.center,spark_rec.width//2,0)
pygame.draw.line(spark_img,Color("indianred"),left_center,right_center,2)
pygame.draw.line(spark_img,Color("red"),top_center,bottom_center,2)
pygame.draw.line(spark_img,Color("burlywood3"),top_left,bottom_right,3)
pygame.draw.line(spark_img,Color("orange"),top_right,bottom_left,3)
# Now crop line segments that fall outside the spark circle..
pygame.draw.circle(spark_img,TRANSPARENT,spark_rec.center,spark_rec.width//2+8,8)
return spark_img
def __init__(self,window,x,y,height,width,color = (255,0,0)):
self.window = window # Needed so class can draw to the screen.
self.T0 = time.time() # Holds the starting time for the timer.
self.x = x
self.y = y
self.height = height
self.width = width
self.anim_index = 0
image = self.create_spark()
# Standing in for actual animation pages, we scale up the spark image.
self.explode = [
image,
pygame.transform.scale(image,(image.get_width()*2,image.get_height()*2)),
pygame.transform.scale(image,(image.get_width()*4,image.get_height()*4)),
pygame.transform.scale(image,(image.get_width()*6,image.get_height()*6)),
pygame.transform.scale(image,(image.get_width()*8,image.get_height()*8))]
'''
# Or you can load your spark frames as before.
self.explode = [
pygame.image.load("spark_01.png"),
pygame.image.load("spark_02.png"),
pygame.image.load("spark_03.png"),
pygame.image.load("spark_04.png"),
pygame.image.load("spark_05.png"),
pygame.image.load("spark_06.png"),
pygame.image.load("spark_07.png")]
# All of the loaded images are scaled down to 1/5 their size.
self.explode = [pygame.transform.scale(image,(image.get_width()//5,image.get_height()//5)) for image in self.explode]
'''
self.rect = image.get_rect()
self.direction = "blobright" # <-- I don't know what this is, so I've ignored it.
self.anim_index = 0
def draw(self,enemy_rec,anin_speed): # Create an animation method to handle the draw routine.
clock = time.time()
elapsed_time = clock - self.T0
finish_flg = False
if elapsed_time > anin_speed: # Animation Speed Controlled Here!!
self.anim_index +=1
self.T0 = time.time() # Reset the start time.
if self.anim_index == len(self.explode)-1:
finish_flg = True
frame = self.explode[self.anim_index]
rec = frame.get_rect()
rec.center = enemy_rec.center
self.window.blit(frame,rec)
return finish_flg # The finish flag lets the main program know it can delete the enemy.
# ================== MAIN() ===================
# ----------------------------------------------
def main(): # By using a 'main()' function, your code will run faster!
screen = pygame.display.set_mode((3000,2000),pygame.FULLSCREEN,32)
screen_rec = screen.get_rect()
screen.fill(Color("steelblue1"))
# Declare and initialie an instance of the EXPLODE class.
# Only one enemy can blow up at the same time for any give instance
# of the class, so you may want each ship to have its own instance
# if there is a chance of simultanious explosions.
# I wouldn't normally use this aproach, but I wanted to stay
# as close as possible to your existing code.
explode = EXPLODE(screen,screen_rec.centerx,screen_rec.centery,30,20,Color('blue'))
# Let's create some "enemy" units.
# You would use an enemy class for this (and for drawing them)
# but this example is qick and dirty, so.. Two enemies coming up!
# One enemy to blow up when it hits the wall.
enemy1_img = pygame.Surface((30,30))
enemy1_rec = enemy1_img.get_rect()
enemy1_img.fill(Color("Green"))
pygame.draw.rect(enemy1_img,Color("Red"),enemy1_rec,5)
# And one 'enemy' to move while the other is blowing up.
enemy2_img = enemy1_img.copy()
enemy2_rec = enemy2_img.get_rect()
# Give enemies screen positions.
enemy1_rec.center = (screen_rec.centerx-300, screen_rec.centery-300)
enemy2_rec.center = (screen_rec.centerx-800,screen_rec.centery-300)
# Create a wall for a ship to crash into.
wall_img = pygame.Surface((100,60))
wall_img.fill(Color("Indianred"))
wall_rec = wall_img.get_rect()
wall_rec.center = screen_rec.center
wall_rec = wall_rec.move((400,0))
# Oh, this list is ugly. Forgive me! Used instead of a list of Enemy-Class objects.
enemy_list = [[10,enemy1_img,enemy1_rec,(2,1)],[10,enemy2_img,enemy2_rec,(3,0)]] # [Life, Image, Rectangle, Speed]
# Ok, the setup is finished. Time for some action!
# =============== BODY ===================
# ------------------------------------------
anin_speed = 0.3 # You can control explosion speed here!
pygame.mouse.set_visible(False)
run_cycle = True
while run_cycle == True:
# There are much better ways to erase images, but this will do for now.
screen.fill(Color("steelblue1")) # Erase old sprites.
screen.blit(wall_img,wall_rec) # Put the wall back in place.
# Because it is bad idea to modify an object being looped through,
# we will construct a new list, called 'hold', and copy it back at the end.
hold = []
for enmy in enemy_list:
life,enemy_img,enemy_rec,speed = enmy
if life > 4:
screen.blit(enemy_img,enemy_rec) # If enemy is healthy, put it on the screen.
enemy_rec = enemy_rec.move(speed)
if enemy_rec.colliderect(wall_rec) == True:
life = 0
if enemy_rec.left > screen_rec.right+10: # End the program after top ship leaves the screen.
run_cycle = False
hold.append([life,enemy_img,enemy_rec,speed])
else: # Otherwise draw the explosion.
finish_flg = explode.draw(enemy_rec,anin_speed)
if finish_flg == False: # If TRUE the enemy is ommitted from the hold list!
hold.append(enmy)
enemy_list = hold.copy() # And now the possibly modified list is copied back to the enemy_list.
pygame.display.flip()
# ================
# Main
# ----------------
main() # Hint! For technical reasons related to the compiler being able
# to control scope and predict variable sizes, keeping your
# main body encapsulated in a function like this will improve
# efficiency and run speeds.

You have a great start. If nothing needs to happen while the explosion is going on, you could use a sleep command in your loop. >> time.sleep(0.01)
If the action has to continue on the screen during the explosion, then you will need to use a timer and keep returning to that function after each duration to draw the next frame. Just initialize using >> T0 = time.time() before the explosion, visit the function when time.time()-T0 > 0.01 seconds (for example) and reset T0 = time.time() after each frame is drawn. Return a 'finished' value when the animation is over, so you can remove it from your enemy list.

In the __init__() for explode note the time when it is called and save it.
In the explodes draw() only increment self.anim_index when enough time has passed since the last time it was incremented (based on the time value you saved in the __init__()). This will let you go more slowly through the frames of the exploding animation.
There is really no difference between this and any other object animation, other than once the cycle completes the object (the explosion) goes a way.

How to make an image move through a pyglet window?

I am trying to make an animation using pyglet. So first I tried a simple animation, moving the image in a strait line. Idealy I would like it to bounce around from left to right.
Here is my code:
import pyglet
def center_image(image):
"""Sets an image's anchor point to its center"""
image.anchor_x = image.width // 2
image.anchor_y = image.height // 2
# Make window.
window = pyglet.window.Window(width=640, height=480)
# Load image.
pyglet.resource.path = ['images']
pyglet.resource.reindex()
heart_img = pyglet.resource.image('red-heart.png')
center_image(heart_img)
# Make animation sprite.
heart_grid = pyglet.image.ImageGrid(heart_img, rows=1, columns=5)
heart_ani = pyglet.image.Animation.from_image_sequence(heart_grid, duration=0.1)
heart_sprite = pyglet.sprite.Sprite(heart_ani, x=100, y=300)
heart_sprite.update(scale=0.05)
#window.event
def on_draw():
window.clear()
heart_sprite.draw()
if __name__ == '__main__':
pyglet.app.run()
This code produces this:
How can I make the whole heart move through the window?
The desired trajectory of the heart would be something like this:
Where the box is the frame, the arches are the trajectory and O is a sprite. So the heart would bounce of the first letter of each word and then bounce of the sprite.

So the main issue is that Animation assumes a series of images within a large image. It's called sprite animations and it's essentially just a series strip (usually in a row or a grid pattern) of the movements you want. It's useful for animating walking, attacking and other similar game mechanics.
But to move an object around the canvas, you would need to manipulate the vertices or the image location manually in some way. Your own solution works on the principle of checking if X is greater or less than min and max restrictions. And I would just like to add ontop of that to show some techniques to make it easier and faster to work with the movements and directions. Below I've worked with bitwise operations to determain the direction of movement and this makes the heart bounce around the parent (window) constraints of width and height.
I've also taken the liberty to make the whole project more object oriented by inheriting the pyglet Window class into one object/class as well as make heart it's own class to easier separate what is called when and on what object.
from pyglet import *
from pyglet.gl import *
key = pyglet.window.key
# Indented oddly on purpose to show the pattern:
UP = 0b0001
DOWN = 0b0010
LEFT = 0b0100
RIGHT = 0b1000
class heart(pyglet.sprite.Sprite):
def __init__(self, parent, image='heart.png', x=0, y=0):
self.texture = pyglet.image.load(image)
pyglet.sprite.Sprite.__init__(self, self.texture, x=x, y=y)
self.parent = parent
self.direction = UP | RIGHT # Starting direction
def update(self):
# We can use the pattern above with bitwise operations.
# That way, one direction can be merged with another without collision.
if self.direction & UP:
self.y += 1
if self.direction & DOWN:
self.y -= 1
if self.direction & LEFT:
self.x -= 1
if self.direction & RIGHT:
self.x += 1
if self.x+self.width > self.parent.width:
self.direction = self.direction ^ RIGHT # Remove the RIGHT indicator
self.direction = self.direction ^ LEFT # Start moving to the LEFT
if self.y+self.height > self.parent.height:
self.direction = self.direction ^ UP # Remove the UP indicator
self.direction = self.direction ^ DOWN # Start moving DOWN
if self.y < 0:
self.direction = self.direction ^ DOWN
self.direction = self.direction ^ UP
if self.x < 0:
self.direction = self.direction ^ LEFT
self.direction = self.direction ^ RIGHT
def render(self):
self.draw()
# This class just sets up the window,
# self.heart <-- The important bit
class main(pyglet.window.Window):
def __init__ (self, width=800, height=600, fps=False, *args, **kwargs):
super(main, self).__init__(width, height, *args, **kwargs)
self.x, self.y = 0, 0
self.heart = heart(self, x=100, y=100)
self.alive = 1
def on_draw(self):
self.render()
def on_close(self):
self.alive = 0
def on_key_press(self, symbol, modifiers):
if symbol == key.ESCAPE: # [ESC]
self.alive = 0
def render(self):
self.clear()
self.heart.update()
self.heart.render()
## Add stuff you want to render here.
## Preferably in the form of a batch.
self.flip()
def run(self):
while self.alive == 1:
self.render()
# -----------> This is key <----------
# This is what replaces pyglet.app.run()
# but is required for the GUI to not freeze
#
event = self.dispatch_events()
if __name__ == '__main__':
x = main()
x.run()
The basic principle is the same, manipulating sprite.x to move it laterally, and sprite.y vertically. There's more optimizations to be done, for instance, updates should be scaled according to last render. This is done to avoid glitches if your graphics card can't keep up. It can get quite complicate quite fast, so I'll leave you with an example of how to calculate those movements.
Further more, you probably want to render a batch, not the sprite directly. Which would speed up rendering processes quite a lot for larger projects.
If you're unfamiliar with bitwise operations, a short description would be that it operates on a bit/binary level (4 == 0100 as an example), and doing XOR operations on the values of UP, DOWN, LEFT and RIGHT. We can add/remove directions by merging 0100 and 0001 resulting in 0101 as an example. We can then do binary AND (not like the traditional and operator) to determinate if a value contains a 1 on the third position (0100) by doing self.direction & 0100 which will result in 1 if it's True. It's a handy quick way of checking "states" if you will.

My solution uses the midpoint between two fixed Sprites to determine whether the moving Sprite should go up or down. For this I made all letters individual Sprites, one png for each letter.
Hopefully this image will explain the code below a bit better.
#!/usr/bin/env python
import pyglet
CURR_BOUNCE = 0
MIDPOINTS = []
ENDPOINTS = []
def calculate_midpoint(s1, s2):
""" Calculate the midpoint between two sprites on the x axis. """
return (s1.x + s2.x) // 2
def should_move_down():
""" Decides if the Sprite is going up or down. """
global CURR_BOUNCE
# If the Sprite completed all bounces the app closes (not the best solution).
if max(len(MIDPOINTS), len(ENDPOINTS), CURR_BOUNCE) == CURR_BOUNCE:
raise SystemExit
# Move down if the Sprite is between the midpoint and the end (landing) point.
if MIDPOINTS[CURR_BOUNCE] <= heart_sprite.x <= ENDPOINTS[CURR_BOUNCE]:
return True
# If the Sprite has passed both the mid and end point then it can move on to the next bounce.
if max(MIDPOINTS[CURR_BOUNCE], heart_sprite.x, ENDPOINTS[CURR_BOUNCE]) == heart_sprite.x:
CURR_BOUNCE += 1
# Default behaviour is to keep going up.
return False
def update(dt):
"""
Move Sprite by number of pixels in each tick.
The Sprite always moves to the right on the x-axis.
The default movement on the y-axis is up.
"""
heart_sprite.x += dt * heart_sprite.dx
if should_move_down():
# To go down simply make the movement on the y-axis negative.
heart_sprite.y -= dt * heart_sprite.dy
else:
heart_sprite.y += dt * heart_sprite.dy
def center_image(image):
""" Sets an image's anchor point to its centre """
image.anchor_x = image.width // 2
image.anchor_y = image.height // 2
# Make window.
window = pyglet.window.Window(width=640, height=480)
# Set image path.
pyglet.resource.path = ['images']
pyglet.resource.reindex()
# Load images.
heart_img = pyglet.resource.image('red-heart.png')
cupcake_img = pyglet.resource.image('cupcake.png')
s_img = pyglet.resource.image('S.png')
# Add all letters here ...
t_img = pyglet.resource.image('t.png')
# Center images.
center_image(heart_img)
center_image(cupcake_img)
center_image(s_img)
# Centre all letters here ...
center_image(t_img)
# Make sprites.
half_window_height = window.height // 2
heart_sprite = pyglet.sprite.Sprite(img=heart_img, x=100, y=300)
# Set Sprite's speed.
heart_sprite.dx = 200
heart_sprite.dy = 90
cupcake_sprite = pyglet.sprite.Sprite(img=cupcake_img, x=550, y=half_window_height)
s_sprite = pyglet.sprite.Sprite(img=s_img, x=100, y=half_window_height)
# Make all letters into Sprites and adjust the x-axis coordinates...
t_sprite = pyglet.sprite.Sprite(img=t_img, x=310, y=half_window_height)
# Calculate midpoints.
# Here the midpoint between the 'bouncing point' and the 'landing point' is calculated.
# This is done for all bounces the Sprite makes.
MIDPOINTS.append(calculate_midpoint(s_sprite, t_sprite))
MIDPOINTS.append(calculate_midpoint(t_sprite, cupcake_sprite))
# The 'landing point' must be saved to be able to determine when one bounce has finished
# and move on to the next.
ENDPOINTS.append(t_sprite.x)
ENDPOINTS.append(cupcake_sprite.x)
# Rescale sprites.
heart_sprite.update(scale=0.05)
cupcake_sprite.update(scale=0.1)
s_sprite.update(scale=0.3)
# Resize all letter Sprites here ...
t_sprite.update(scale=0.3)
#window.event
def on_draw():
window.clear()
cupcake_sprite.draw()
heart_sprite.draw()
s_sprite.draw()
# Draw all letter Sprites here ...
t_sprite.draw()
#window.event
def on_mouse_press(x, y, button, modifiers):
"""
I only put the schedule_interval inside a mouse_press event so that I can control
when the animation begins by clicking on it. Otherwise the last line in this method
can be placed directly above the 'pyglet.app.run()' line. This would run the
animation automatically when the app starts.
"""
# Call update 60 times a second
pyglet.clock.schedule_interval(update, 1/60.)
if __name__ == '__main__':
pyglet.app.run()

how to make an animation in pygame [duplicate]

This question already has answers here:
Animated sprite from few images
(4 answers)
Closed 1 year ago.
i am trying to make an animation of when my player gets shot to make it seem like he is falling to the ground.
i have tried the code below but that doesn't seem to work. it slows down the frames and only shows the last image of my animation is there a simpler way of animation in pygame?
if player2_hit_sequence == True:
stage1 = True
if stage1 == True:
game_display.blit(dying1_p2, (player2X, player2Y))
time.sleep(0.2)
stage1 = False
stage2 = True
if stage2 == True:
game_display.blit(dying2_p2, (player2X, player2Y))
time.sleep(0.2)
stage2 = False
stage3 = True
if stage3 == True:
game_display.blit(dying3_p2, (player2X, player2Y))
time.sleep(0.2)
is there a function to make a sequence of images or something like that?

Ok so for animation you need a bunch of images, and a timer.
I'm presenting some code snippets based around a pygame sprite. Maybe this doesn't exactly fit the question, but it seems like a better solution then painting/blitting images manually.
So first the code starts with a sprite class:
class AlienSprite(pygame.sprite.Sprite):
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.base_image = pygame.image.load('alien.png').convert_alpha()
self.image = self.base_image
self.rect = self.image.get_rect()
self.rect.center = ( WINDOW_WIDTH//2, WINDOW_HEIGHT//2 )
# Load warp animation
self.warp_at_time = 0
self.warp_images = []
for filename in [ "warp1.png", "warp2.png", "warp3.png" ]:
self.warp_images.append( pygame.image.load(filename).convert_alpha() )
So the idea is the Alien Sprite has a "normal" image, but then when it "warps" (teleports) an animation plays. The way this is implemented is to have a list of animation images. When the animation starts, the sprite's image is changed from base_image to the first of the warp_images[]. As time elapses, the sprites image is changed to the next frame, and then the next, before finally reverting back to the base image. By embedding all this into the sprite update() function, the normal updating mechanism for sprites handles the current "state" of the alien sprite, normal or "warp". Once the "warp"-state is triggered, it runs without any extra involvement of the pygame main loop.
def update(self):
# Get the current time in milliseconds (normally I keep this in a global)
NOW_MS = int(time.time() * 1000.0)
# Did the alien warp? (and at what time)
if (self.warp_at_time > 0):
# 3 Frames of warp animation, show each for 200m
ms_since_warp_start = NOW_MS - self.warp_at_time
if ( ms_since_warp > 600 ):
# Warp complete
self.warp_at_time = 0
self.image = self.base_image # return to original bitmap
# Move to random location
self.rect.center = ( random.randrange( 0, WINDOW_WIDTH ), random.randrange( 0, WINDOW_HEIGHT ) )
else:
image_number = ms_since_warp // 200 # select the frame for this 200ms period
self.image = self.warp_images[image_number] # show that image
def startWarp(self):
# Get the current time in milliseconds (normally I keep this in a global)
NOW_MS = int(time.time() * 1000.0)
# if not warping already ...
if (self.warp_at_time == 0):
self.warp_at_time = NOW_MS
So the first thing to notice, is that the update() uses the clock to know the number of elapsed milliseconds since the animation started. To keep track of the time I typically set a global NOW_MS in the game loop.
In the sprite, we have 3 frames of animation, with 200 milliseconds between each frame. To start a sprite animating, simply call startWarp() which obviously just kicks-off the timer.
SPRITES = pygame.sprite.Group()
alien_sprite = AlienSprite()
SPRITES.add(alien_sprite)
...
# Game Loop
done = False
while not done:
SPRITES.update()
# redraw window
screen.fill(BLACK)
SPRITES.draw(screen)
pygame.display.update()
pygame.display.flip()
if (<some condition>):
alien_sprite.startWarp() # do it
Obviously all those frame timings & what-not should be member variables of the sprite class, but I didn't do that to keep the example simple.

dynamic body with segment shape do not move with a joint

In pymunk, I set the body mass and the space gravity, it should automatic fall down, but the body with segment shape do not move, here is my code in pyglet
import pyglet
import pymunk
from pymunk.pyglet_util import DrawOptions
window = pyglet.window.Window(1280,720,resizable=False)
options = DrawOptions()
space = pymunk.Space()
space.gravity = 0,-1000
ball_mass = 1
ball_radius = 10
ball_moment = pymunk.moment_for_circle(ball_mass,0,10)
ball = pymunk.Body(ball_mass,ball_moment)
ball_shape = pymunk.Circle(ball,ball_radius)
ball.position =200,500
ball_shape.elasticity = 1
ball_shape.friction = 1
space.add(ball,ball_shape)
stick = pymunk.Body(1,100,body_type=pymunk.Body.DYNAMIC)
stick_shape = pymunk.Segment(stick,(0,0),(150,150),4)
stick.position = (300,400)
pin = pymunk.PivotJoint(space.static_body,stick,(300,400))
# stick.apply_impulse_at_local_point((0,-100),(150,150))
space.add(stick,stick_shape,pin)
#window.event
def on_draw():
window.clear()
space.debug_draw(options)
def update(dt):
space.step(dt)
if __name__ == '__main__':
pyglet.clock.schedule_interval(update, 1/60.0)
pyglet.app.run()
the ball fall down but the stick do not move, or apply_impulse_at_local_point on stick, I just wondering, if there is no PivotJoint, the stick fall down, I just pin one point of the stick, why it does not move, it should rotate, is it?

One problem is that the stick has its center of gravity at one end. That make it behave a bit strange. Try making it have its center of gravity in its actual center instead.
stick_shape = pymunk.Segment(stick,(-75,-75),(75,75),4)

Pyglet: fireball shooter, fireballs keep accelerating whenever I press a specified key instead of keeping constant speed

How do you make this code work? Just have pyglet installed and change "fireball.png" with the name of an image stored in the directory where you saved this code to a file.
import pyglet
class Fireball(pyglet.sprite.Sprite):
def __init__(self, batch):
pyglet.sprite.Sprite.__init__(self, pyglet.resource.image("fireball.png"))
# replace "fireball.png" with your own image stored in dir of fireball.py
self.x = 10 # Initial x coordinate of the fireball
self.y = 10 # Initial y coordinate of the fireball
class Game(pyglet.window.Window):
def __init__(self):
pyglet.window.Window.__init__(self, width = 315, height = 220)
self.batch_draw = pyglet.graphics.Batch()
self.fps_display = pyglet.clock.ClockDisplay()
self.fireball = []
def on_draw(self):
self.clear()
self.fps_display.draw()
self.batch_draw.draw()
if len(self.fireball) != 0: # Allow drawing of multiple
for i in range(len(self.fireball)): # fireballs on screen
self.fireball[i].draw() # at the same time
def on_key_press(self, symbol, modifiers):
if symbol == pyglet.window.key.A:
self.fireball.append(Fireball(batch = self.batch_draw))
pyglet.clock.schedule_interval(func = self.update, interval = 1/60.)
print "The 'A' key was pressed"
def update(self, interval):
for i in range(len(self.fireball)):
self.fireball[i].x += 1 # why do fireballs get faster and faster?
if __name__ == "__main__":
window = Game()
pyglet.app.run()
This code creates a black background screen, where the fps are displayed and a fireball is shot along the x direction from the position (10, 10) whenever you press the A key.
You will notice that the more fireballs you shoot, the faster all fireballs will start to go.
Questions:
Why do the fireballs go faster and faster each time I press A ?
How should I stop the fireballs from accelerating each time I press A ?

The fireball goes faster and faster because every time you press the A you add another call of self.update to the scheduler. So self.update is called more and more times each time resulting in more updates of the position. To fix that move the line below to the __init__().
pyglet.clock.schedule_interval(func = self.update, interval = 1/60.)