def __init__(self, config, *args, **kwargs):
super(Menu, self).__init__(config, *args, **kwargs)
self.interface = sprite.LayeredDirty()
button_pos = config.RESOLUTION[0] / 2, config.RESOLUTION[1] / 2
button = ui.Button("Play", button_pos, Game, Menu.PUSH_SCENE, self.interface)
self.subscribe(MOUSEBUTTONDOWN, button.name, button.clicked)
self.background = Surface(config.RESOLUTION)
def setUp(self):
pygame.display.init()
self.screen = pygame.display.set_mode(screen_dims, flags)
self.screen.fill([0,0,0])
pygame.display.flip()
sprite_surface = pygame.image.load(os.path.join(data_dir, "asprite.bmp"))
sprite_surface2 = pygame.image.load(os.path.join(data_dir, "static.png"))
if use_rle:
sprite_surface.set_colorkey([0xFF, 0xFF, 0xFF], SRCCOLORKEY|RLEACCEL)
sprite_surface2.set_colorkey([0xFF, 0xFF, 0xFF], SRCCOLORKEY|RLEACCEL)
else:
sprite_surface.set_colorkey([0xFF, 0xFF, 0xFF], SRCCOLORKEY)
sprite_surface2.set_colorkey([0xFF, 0xFF, 0xFF], SRCCOLORKEY)
if use_alpha:
sprite_surface = sprite_surface.convert_alpha()
sprite_surface2 = sprite_surface2.convert_alpha()
else:
sprite_surface = sprite_surface.convert()
sprite_surface2 = sprite_surface2.convert()
Thingy.images = [sprite_surface]
if use_static:
Static.images = [sprite_surface2]
self.sprites = None
if use_FastRenderGroup:
## sprites = FRG.FastRenderGroup()
self.sprites = FRG.LayeredDirty()
else:
if update_rects:
self.sprites = pygame.sprite.RenderUpdates()
else:
self.sprites = pygame.sprite.Group()
for i in xrange_(0, self.numsprites):
if use_static and i%2==0:
self.sprites.add(Static())
self.sprites.add(Thingy())
self.background = pygame.Surface(self.screen.get_size())
self.background = self.background.convert()
self.background.fill([0,0,0])
def __init__(self, game, color='red'):
self.game = game
self.left_hand = 0, 0
self.right_hand = 0, 0
self.min_left_hand_y = self.game.height / 2 - 1
self.max_left_hand_y = self.game.height / 2
self.min_right_hand_y = self.game.height / 2 - 1
self.max_right_hand_y = self.game.height / 2
self.active = False
self.old_rects = [None, None, None, None]
self.color = color
self.score = 0
self.image1 = pygame.SurfaceType((15, 40))
pygame.draw.rect(self.image1, THECOLORS[color],
pygame.Rect(0, 0, 15, 40))
self.image2 = pygame.SurfaceType((15, 40))
pygame.draw.rect(self.image2, THECOLORS[color],
pygame.Rect(0, 0, 15, 40))
self.bumpers = Bumper(self.image1), Bumper(self.image2)
for bumper in self.bumpers:
bumper.player = self
if self.color == 'red':
x = self.game.blocks_across / 2 - 2
else:
x = self.game.blocks_across / 2
y = self.game.blocks_down / 2 - 1
width = (((self.game.width - self.game.left_margin) /
self.game.blocks_across) - 5) * 2
height = (((self.game.height - self.game.top_margin) /
self.game.blocks_down) - 5) * 2
x_loc = ((self.game.width - self.game.left_margin) /
self.game.blocks_across) * x + (self.game.left_margin / 2)
y_loc = ((self.game.height - self.game.top_margin) /
self.game.blocks_down) * y + (self.game.top_margin / 2)
self.face = PlayerFace(self, x_loc, y_loc, width, height)
self.face.player = self
self.group = sprite.LayeredDirty(self.face.background, self.face,
*self.bumpers)
def __init__(self, config, *args, **kwargs):
super(Game, self).__init__(config, *args, **kwargs)
self.background = Surface(config.RESOLUTION)
self.rendering = sprite.LayeredDirty()
self.player = sprite.GroupSingle()
self.creeps = sprite.Group()
image = Surface((20, 20)).convert(self.display)
image.fill((255, 255, 255))
mob.Player(image, 0, config, self.rendering, self.player, self.rendering)
self.rendering.change_layer(self.player.sprite, 1)
self.camera = FollowCam(Vector(0, 0), self.player.sprite, config,
max_dist=100, max_speed=(60))
offset = self.camera.get_offset()
image = Surface((20, 20)).convert(self.display)
image.fill((0, 128, 0))
m_image = Surface((100, 100)).convert(self.display)
m_image.set_alpha(64)
m_image.fill((128, 64, 192))
for x in xrange(config.INITIAL_SPAWN):
mob.Creep(image, m_image, self.player.sprite, offset, config, self.rendering, self.creeps, self.rendering)
def main(
update_rects=True,
use_static=False,
use_FastRenderGroup=False,
screen_dims=[640, 480],
use_alpha=False,
flags=0,
):
"""Show lots of sprites moving around
Optional keyword arguments:
update_rects - use the RenderUpdate sprite group class (default True)
use_static - include non-moving images (default False)
use_FastRenderGroup - Use the FastRenderGroup sprite group (default False)
screen_dims - Pygame window dimensions (default [640, 480])
use_alpha - use alpha blending (default False)
flags - additional display mode flags (default no addiontal flags)
"""
if use_FastRenderGroup:
update_rects = True
#pygame.init()
pygame.display.init()
#if "-fast" in sys.argv:
screen = pygame.display.set_mode(screen_dims, flags)
# this is mainly for GP2X, so it can quit.
pygame.joystick.init()
num_joysticks = pygame.joystick.get_count()
if num_joysticks > 0:
stick = pygame.joystick.Joystick(0)
stick.init() # now we will receive events for the joystick
screen.fill([0, 0, 0])
pygame.display.flip()
sprite_surface = pygame.image.load(os.path.join(data_dir, "asprite.bmp"))
sprite_surface2 = pygame.image.load(os.path.join(data_dir, "static.png"))
if use_rle:
sprite_surface.set_colorkey([0xFF, 0xFF, 0xFF], SRCCOLORKEY | RLEACCEL)
sprite_surface2.set_colorkey([0xFF, 0xFF, 0xFF],
SRCCOLORKEY | RLEACCEL)
else:
sprite_surface.set_colorkey([0xFF, 0xFF, 0xFF], SRCCOLORKEY)
sprite_surface2.set_colorkey([0xFF, 0xFF, 0xFF], SRCCOLORKEY)
if use_alpha:
sprite_surface = sprite_surface.convert_alpha()
sprite_surface2 = sprite_surface2.convert_alpha()
else:
sprite_surface = sprite_surface.convert()
sprite_surface2 = sprite_surface2.convert()
Thingy.images = [sprite_surface]
if use_static:
Static.images = [sprite_surface2]
if len(sys.argv) > 1:
try:
numsprites = int(sys.argv[-1])
except Exception:
numsprites = 100
else:
numsprites = 100
sprites = None
if use_FastRenderGroup:
## sprites = FRG.FastRenderGroup()
sprites = FRG.LayeredDirty()
else:
if update_rects:
sprites = pygame.sprite.RenderUpdates()
else:
sprites = pygame.sprite.Group()
for i in xrange_(0, numsprites):
if use_static and i % 2 == 0:
sprites.add(Static())
sprites.add(Thingy())
done = False
frames = 0
start = time()
background = pygame.Surface(screen.get_size())
background = background.convert()
background.fill([0, 0, 0])
while not done:
if not update_rects:
screen.fill([0, 0, 0])
## for sprite in sprites:
## sprite.move()
if update_rects:
sprites.clear(screen, background)
sprites.update()
rects = sprites.draw(screen)
if update_rects:
pygame.display.update(rects)
else:
pygame.display.flip()
for event in pygame.event.get():
if event.type in [KEYDOWN, QUIT, JOYBUTTONDOWN]:
done = True
frames += 1
end = time()
print("FPS: %f" % (frames / ((end - start))))
pygame.quit()
def setUp(self):
self.LG = sprite.LayeredDirty()
def __init__(self):
PM.pre_init(44100, -16, 1, 1024)
PG.init()
###(Screen stuff)####
Globals.SCREEN.fill((255, 255, 255))
PD.set_caption("Master Chef's wicked adventure " +
"with his ice cream buddies")
###(Declare interface)#####
self.font = PF.SysFont('Arial', 25)
#Win/Lose items
self.end_time = 100
self.win_image = PI.load("FPGraphics/" +
"specialEffects/UWIN.png").convert_alpha()
self.lose_image = PI.load("FPGraphics/" +
"specialEffects/ULOSE.png").convert_alpha()
self.MAX_LEVEL = 4
self.MAX_STAGE = 2
#items
self.pill_img = PI.load("FPGraphics/tiles/" +
"lactasePill.png").convert_alpha()
######(Initialize objects on screen)####
##draw map/background
##draw sprites
self.character = Player(Globals.DELTA)
self.INVINCIBILITY_TIME = Globals.DEFAULT_INVINCIBILITY
self.player_group = PS.GroupSingle(self.character)
# adding extra since cutscene bug deletes one
# self.remainingEnemies = self.num_enemies
#create icecream group
self.icecream_list = PS.Group()
self.burger_list = PS.Group()
self.egg_list = PS.Group()
self.lettuce_list = PS.Group()
self.cupcake_list = PS.Group()
self.enemy_list = PS.Group() # all enemies
self.pad_list = PS.Group()
self.trap_group = PS.Group()
self.item_group = PS.Group()
self.projectile_group = PS.Group()
self.enemies = None
#allsprites has all dirty sprites (player, enemies, traps, pads)
self.allsprites = PS.LayeredDirty(self.trap_group, self.pad_list,
self.item_group, self.player_group,
self.icecream_list, self.burger_list,
self.egg_list, self.lettuce_list,
self.cupcake_list,
self.projectile_group)
#variables to be handled in change_level method
self.objective = None
self.objectiveBlit = True
self.updated_obj = False
self.map = None
self.num_enemies = 0
self.background = None
self.end_time = 100
self.end_image_position = (100, 178)
self.block_group = None
####(Level variables)####
Globals.INVINCIBILITY_COUNT = 0 # player's invinicibility frame time
#what kind of enemy by ID (-1 means no enemy) used for collisions
self.enemy_ID = -1
#if true, tells map to redraw
self.map_modified = False
# self.level = 1
# self.stage = 1
self.level = 1
self.stage = 1
self.change_level(self.level, self.stage)
self.burn_player = False
####Joystick#########
self.joy = Joystick()
self.use_joy = str(inbx.ask(Globals.SCREEN, 'Joystick? y/n'))
self.score_health_background = PI.load(
"FPGraphics/specialEffects/ScoreHealth.png").convert_alpha()
self.items_table = PI.load(
"FPGraphics/specialEffects/ItemsTable.png").convert_alpha()
def change_level(self, currentLevel, stage):
self.reset_level()
self.level = currentLevel
self.stage = stage
ldata = Lvl_Data(self.level, stage)
self.objective = ldata.objective
self.updated_obj = False ######CHANGED
PM.music.load(ldata.music_file)
PM.music.play(-1)
PM.music.set_volume(0.5)
####turn back on only for presentations?
if self.stage == 1:
Cutscene(Globals.SCREEN, self.level)
#interpretting mapfile.txt
if (self.level > 1):
del self.map
Map.GRASS_ARRAY = []
Map.PAD_ARRAY = []
self.pad_list.empty()
##new map is different than level 1's map, of course.
self.map = Map.Map(ldata.map_file, self.level)
self.camera = cam.Camera(self.map.get_surface())
self.camera_background = None
self.background = self.map.create_background()
self.allsprites.clear(Globals.SCREEN, self.background)
Globals.SCREEN.blit(self.background, (0, 0))
PD.update()
self.num_enemies += self.map.get_num_enemies(1) # icecream
self.num_enemies += self.map.get_num_enemies(2) # burger
self.num_enemies += self.map.get_num_enemies(3) # lettuce
self.num_enemies += self.map.get_num_enemies(4) # cupcake
self.num_enemies += self.map.get_num_enemies(5) # egg
#icecream
for e in range(self.map.get_num_enemies(1)):
icecream = IceCream(self.map.get_enemy_coordx(e, 1),
self.map.get_enemy_coordy(e, 1))
self.icecream_list.add(icecream)
#burger
for e in range(self.map.get_num_enemies(2)):
burger = Burger(self.map.get_enemy_coordx(e, 2),
self.map.get_enemy_coordy(e, 2), self.level)
self.burger_list.add(burger)
#lettuce
for e in range(self.map.get_num_enemies(3)):
lettuce = Lettuce(self.map.get_enemy_coordx(e, 3),
self.map.get_enemy_coordy(e, 3))
self.lettuce_list.add(lettuce)
#cupcake
for e in range(self.map.get_num_enemies(4)):
cupcake = Cupcake(self.map.get_enemy_coordx(e, 4),
self.map.get_enemy_coordy(e, 4))
self.cupcake_list.add(cupcake)
#egg
for e in range(self.map.get_num_enemies(5)):
egg = Egg(self.map.get_enemy_coordx(e, 5),
self.map.get_enemy_coordy(e, 5), self.level)
self.egg_list.add(egg)
self.enemy_list.add(self.icecream_list)
self.enemy_list.add(self.burger_list)
self.enemy_list.add(self.lettuce_list)
self.enemy_list.add(self.cupcake_list)
self.enemy_list.add(self.egg_list)
player_health = 0
#get enemy health
if self.stage > 1:
player_health = self.character.get_health()
self.character = Player(Globals.DELTA)
self.player_group = PS.GroupSingle(self.character)
if self.stage > 1:
self.character.set_health(player_health, True)
#pads
for e in range(len(self.map.padtiles)):
if self.map.pad_type[e] == 0: # hot
newPad = Pad.create_Pad(self.map.get_pad_x(e),
self.map.get_pad_y(e), 0)
self.pad_list.add(newPad)
elif self.map.pad_type[e] == 1:
newPad = Pad.create_Pad(self.map.get_pad_x(e),
self.map.get_pad_y(e), 1)
self.pad_list.add(newPad)
#get block sprite group from the map file
self.block_group = self.map.get_object_group()
#list that holds traps
self.trap_list = []
# self.trap_group = PS.Group()
# self.item_group = PS.Group()
#allsprites has all dirty sprites (player, enemies, traps)
self.allsprites = PS.LayeredDirty(self.trap_group, self.pad_list,
self.item_group, self.player_group,
self.icecream_list, self.burger_list,
self.egg_list, self.lettuce_list,
self.projectile_group)
self.allsprites.clear(Globals.SCREEN, self.background)
####(Level variables)####
Globals.INVINCIBILITY_COUNT = 0 # player's invinicibility frame time
#what kind of enemy by ID (-1 means no enemy) used for collisions
self.enemy_ID = -1
#if true, tells map to update w/o key & door
self.map_modified = False
##temp obj conditions
self.cheesed = True
self.killed = True
self.camera_background = self.camera.update(
self.character.get_coordinates(), self.map.get_surface())
def update(self):
###(variables)####
trap_attack_player = False # tells if a trap attacked
trap_attack_enemy = False
projectile_attack_player = False # tells if a projectile attacked
projectile_attack_enemy = False
enemy_attacked = None
self.enemy_ID = -1
###(attacks on player)####
##trap handling
for trap in self.trap_group.sprites():
if (trap.get_trap_attack_player()
and Globals.INVINCIBILITY_COUNT == 0):
trap_attack_player = True
if (trap.get_trap_attack_enemy()):
enemies_attacked = trap.get_enemies_attacked()
if enemies_attacked is not None:
for enemy in enemies_attacked:
enemy.decrement_health(1)
if trap.will_remove():
self.trap_group.remove(trap)
##icecream attacks
for icecream in self.icecream_list.sprites():
#see if the enemy will release weapon/attack
if (icecream.will_attack(self.level)):
#get a new puddle sprite
#sending level through to tell it to make a puddle
#with a longer life
new_trap = icecream.attack(self.map.get_surface(), self.level)
#add the new trap to the list of traps
self.trap_group.add(new_trap)
if (icecream.get_attacked_player() or trap_attack_player):
if trap_attack_player:
trap_attack_player = False
#if so start invincibility count after attack
if Globals.INVINCIBILITY_COUNT == 0:
Globals.INVINCIBILITY_COUNT = self.INVINCIBILITY_TIME
#see which enemy attacked the player
self.enemy_ID = icecream.get_ID()
#lettuce
##projectile handling
for projectile in self.projectile_group.sprites():
if (projectile.attacked_player
and Globals.INVINCIBILITY_COUNT == 0):
projectile_attack_player = True
projectile.attacked_player = False
break
if (projectile.projectile_attack_enemy):
enemies_attacked = projectile.get_enemies_attacked()
if enemies_attacked is not None:
for enemy in enemies_attacked:
enemy.decrement_health(1)
# if projectile.will_remove():
# self.projectile_group.remove(projectile)
##lettuce attacks
for lettuce in self.lettuce_list.sprites():
#see if the enemy will release weapon/attack
if (lettuce.will_attack(self.level)):
#get a new puddle sprite
new_projectile = lettuce.attack()
#add the new projectile to the list of projectiles
self.projectile_group.add(new_projectile)
if (lettuce.get_attacked_player() or projectile_attack_player):
if projectile_attack_player:
projectile_attack_player = False
#if so start invincibility count after attack
if Globals.INVINCIBILITY_COUNT == 0:
Globals.INVINCIBILITY_COUNT = self.INVINCIBILITY_TIME
#see which enemy attacked the player
self.enemy_ID = lettuce.get_ID()
##burger attacks
for burger in self.burger_list.sprites():
#see if the enemy will release weapon/attack
if (burger.will_attack(self.level)):
#get a new puddle sprite
new_projectile = burger.attack()
#add the new projectile to the list of projectiles
self.projectile_group.add(new_projectile)
if (burger.get_attacked_player() or projectile_attack_player):
if projectile_attack_player:
projectile_attack_player = False
#if so start invincibility count after attack
if Globals.INVINCIBILITY_COUNT == 0:
Globals.INVINCIBILITY_COUNT = self.INVINCIBILITY_TIME
#see which enemy attacked the player
self.enemy_ID = burger.get_ID()
##egg attacks
for egg in self.egg_list.sprites():
if (egg.get_attacked_player()):
if Globals.INVINCIBILITY_COUNT == 0:
Globals.INVINCIBILITY_COUNT = self.INVINCIBILITY_TIME
#see which enemy attacked the player
self.enemy_ID = egg.get_ID()
##cupcake attacks
for cupcake in self.cupcake_list.sprites():
#see if the enemy will release weapon/attack
if cupcake.will_attack(self.level):
#get a new puddle sprite
new_projectile = cupcake.attack()
#add the new projectile to the list of projectiles
self.projectile_group.add(new_projectile)
if (cupcake.get_attacked_player() or projectile_attack_player):
if projectile_attack_player:
projectile_attack_player = False
#if so start invincibility count after attack
if Globals.INVINCIBILITY_COUNT == 0:
Globals.INVINCIBILITY_COUNT = self.INVINCIBILITY_TIME
#see which enemy attacked the player
self.enemy_ID = cupcake.get_ID()
self.burn_player = False
######Pad damage here
for pad in self.pad_list.sprites():
if pad.rect.colliderect(self.character.rect):
#DEPENDING ON PAD TYPE, CALL DIFFERENT PAD METHODS
if pad.type == 0:
# pad.i_am_hot(self.character)
self.burn_player = pad.will_burn()
if self.burn_player and Globals.INVINCIBILITY_COUNT == 0:
Globals.INVINCIBILITY_COUNT = self.INVINCIBILITY_TIME
elif pad.type == 1:
pad.i_am_cold(self.character)
##player damage & invincibility handling
#If enemy attacked the player while player not invincible
if ((self.enemy_ID != -1 or self.burn_player)
and Globals.INVINCIBILITY_COUNT == self.INVINCIBILITY_TIME):
self.character.decrement_health(self.enemy_ID)
self.enemy_ID = -1
self.burn_player = False
#decrement invincibility count if player is in invincibility
#handles player flashing during invincibility
if (Globals.INVINCIBILITY_COUNT > 0):
if (Globals.INVINCIBILITY_COUNT % 50 == 0):
self.character.invincibility_frames()
Globals.INVINCIBILITY_COUNT -= 1
###Joystick
if self.use_joy == 'y':
self.character.handle_joy(self.block_group, self.enemy_list,
self.item_group, self.map.get_surface())
else:
self.character.handle_keys(self.block_group, self.enemy_list,
self.item_group, self.map.get_surface())
if self.character.chng_invincibility():
self.INVINCIBILITY_TIME = self.character.get_invincibility()
#get new items from the killed enemies
new_items = self.character.get_items_of_killed()
for item in new_items:
if (item != None):
self.item_group.add(item)
#check if any of the items need to be removed (lifetime == 0)
# if(item != None):
for item in self.item_group.sprites():
if item.will_remove():
self.item_group.remove(item)
player_traps = self.character.get_player_traps()
for trap in player_traps:
self.trap_group.add(trap)
trap.set_enemy_list(self.enemy_list)
# for traps in player_traps:
if trap.will_remove():
self.character.remove_player_trap(trap)
player_projectiles = self.character.get_player_projectiles()
for projectile in player_projectiles:
self.projectile_group.add(projectile)
projectile.set_enemy_list(self.enemy_list)
#update the allsprites
self.allsprites = PS.LayeredDirty(self.trap_group, self.pad_list,
self.item_group, self.player_group,
self.icecream_list, self.burger_list,
self.egg_list, self.cupcake_list,
self.lettuce_list,
self.projectile_group)
#cheese/door handling
if self.character.get_modified_map():
self.background = self.map.update_background()
self.map_modified = False
if self.character.banner != -1: #make sure it doesn't redraw banner already presen t?
self.objective.changeObj(self.character.banner)
self.updated_obj = True #allow banner to be drawn in draw()
self.character.banner = -1
#update camera's position on the map
if self.character.update_camera():
self.camera_background = self.camera.update(
self.character.get_coordinates(), self.map.get_surface())
self.allsprites.update(self.block_group, self.player_group)
if (Locals.CHANGESTATE == "Menu"):
PM.music.fadeout(1000)
# Globals.SCORE = self.character.score
return False
PD.update() # update the screen
def main(
update_rects=True,
use_static=False,
use_FastRenderGroup=False,
screen_dims=[640, 480],
use_alpha=False,
flags=0,
plot=False,
):
"""Show lots of sprites moving around
Optional keyword arguments:
update_rects - use the RenderUpdate sprite group class (default True)
use_static - include non-moving images (default False)
use_FastRenderGroup - Use the FastRenderGroup sprite group (default False)
screen_dims - Pygame window dimensions (default [640, 480])
use_alpha - use alpha blending (default False)
flags - additional display mode flags (default no addiontal flags)
"""
global jit_on
if use_FastRenderGroup:
update_rects = True
# pygame.init()
pygame.display.init()
# if "-fast" in sys.argv:
screen = pygame.display.set_mode(screen_dims, flags)
# this is mainly for GP2X, so it can quit.
pygame.joystick.init()
num_joysticks = pygame.joystick.get_count()
if num_joysticks > 0:
stick = pygame.joystick.Joystick(0)
stick.init() # now we will receive events for the joystick
screen.fill([0, 0, 0])
pygame.display.flip()
sprite_surface = pygame.image.load(os.path.join(data_dir, "asprite.bmp"))
sprite_surface2 = pygame.image.load(os.path.join(data_dir, "static.png"))
if use_rle:
sprite_surface.set_colorkey([0xFF, 0xFF, 0xFF], SRCCOLORKEY | RLEACCEL)
sprite_surface2.set_colorkey([0xFF, 0xFF, 0xFF],
SRCCOLORKEY | RLEACCEL)
else:
sprite_surface.set_colorkey([0xFF, 0xFF, 0xFF], SRCCOLORKEY)
sprite_surface2.set_colorkey([0xFF, 0xFF, 0xFF], SRCCOLORKEY)
if use_alpha:
sprite_surface = sprite_surface.convert_alpha()
sprite_surface2 = sprite_surface2.convert_alpha()
else:
sprite_surface = sprite_surface.convert()
sprite_surface2 = sprite_surface2.convert()
Thingy.images = [sprite_surface]
if use_static:
Static.images = [sprite_surface2]
if len(sys.argv) > 1:
try:
numsprites = int(sys.argv[-1])
except Exception:
numsprites = 100
else:
numsprites = 100
sprites = None
if use_FastRenderGroup:
## sprites = FRG.FastRenderGroup()
sprites = FRG.LayeredDirty()
else:
if update_rects:
sprites = pygame.sprite.RenderUpdates()
else:
sprites = pygame.sprite.Group()
for i in xrange_(0, numsprites):
if use_static and i % 2 == 0:
sprites.add(Static())
sprites.add(Thingy())
done = False
frames = 0
start = time()
background = pygame.Surface(screen.get_size())
background = background.convert()
background.fill([0, 0, 0])
frame_times = []
gc.disable()
frames_since_last_gc = 0
while not done:
# print('1) at top of loop')
t0 = time()
for event in pygame.event.get():
if event.type in [KEYDOWN, QUIT, JOYBUTTONDOWN]:
done = True
if not update_rects:
screen.fill([0, 0, 0])
## for sprite in sprites:
## sprite.move()
if update_rects:
sprites.clear(screen, background)
sprites.update()
rects = sprites.draw(screen)
t1 = time()
# print (t1-t0)
# gc.collect(0)
if t1 - t0 > 0.011:
print("slow")
# print('frame')
# if (t1-t0 < 0.0011 and frames_since_last_gc > 30):
# print('2) tell GC thread to collect')
# gc_queue.put(True)
gc_event.set()
# gc.collect_step()
# if frames_since_last_gc > 0:
# # print('collecting')
# frames_since_last_gc = 0
# # gc.collect(0)
# # gc.collect_step()
# print('put on queue')
# gc_queue.put(True)
# else:
# frames_since_last_gc += 1
# print ('3) flipping display. GIL released')
if update_rects:
pygame.display.update(rects)
else:
pygame.display.flip()
# print ('6) finished flipping. GIL grabbed')
# frame_times.append(time() - t0)
frame_times.append(t1 - t0)
if jit_on and time() - start > 10:
# print('turning off pypyjit')
# pypyjit.set_param("off")
jit_on = 0
frames += 1
end = time()
print("FPS: %f" % (frames / ((end - start))))
pygame.quit()
if plot:
msg = "\n".join((
"update_rects:%s,",
"use_static:%s,",
"use_FastRenderGroup:%s",
"screen_dims:%s,",
"use_alpha:%s,",
"flags: %s",
)) % (
update_rects,
use_static,
use_FastRenderGroup,
screen_dims,
use_alpha,
flags,
)
print(msg)
import pickle
with open("spriteplot.pickle", "wb") as picklef:
pickle.dump({"msg": msg, "frame_times": frame_times}, picklef)
class AVRSprite(object):
availableHandles = [i for i in range(0xFE)]
spriteList = {}
deletedSprites = []
spriteDrawGroup = sprite.LayeredDirty()
deleteLock = Lock()
spriteLock = Lock()
def __init__(self, filename, pos, angle, size, order):
self.pos = pos
self.angle = angle
self.size = size[:] #copy
self.order = order
self.filename = filename
self.groups = []
if len(AVRSprite.availableHandles) == 0:
print "ERROR: AVRSprite out of handles!"
self.handle = -1
return
try:
self.surface = image.load(self.filename).convert_alpha()
except error as e:
print "ERROR: Could not load image: '%s'" % self.filename
raise e
self.scaledSurface = transform.smoothscale(self.surface, self.size)
self.transformedSurface = transform.rotate(self.scaledSurface,
self.angle)
self.sprite = sprite.DirtySprite()
self.sprite.image = self.transformedSurface
self.sprite.rect = self.transformedSurface.get_rect()
self.sprite.rect.center = self.pos
self.sprite.dirty = 1
self.sprite.maskDirty = True
self.sprite.AVRSprite = self
self.posDirty = False
self.rotateDirty = False
self.sizeDirty = False
AVRSprite.spriteDrawGroup.add(self.sprite, layer=self.order)
AVRGroup.AVRGroup.groupList[const.ALL_GROUP].addSprite(self)
self.handle = AVRSprite.availableHandles.pop()
AVRSprite.spriteList[self.handle] = self
#print 'sprite %s with handle %s' % (self.filename, self.handle)
def setOrder(self, order):
self.order = order
AVRSprite.spriteDrawGroup.change_layer(self.sprite, order)
self.sprite.dirty = 1
def setPos(self, pos):
self.pos = pos
self.posDirty = True
def setAngle(self, angle):
if angle == self.angle:
return
self.angle = angle
self.rotateDirty = True
def setSize(self, size):
if size[0] == self.size[0] and size[1] == self.size[1]:
return
self.size = size[:]
self.sizeDirty = True
def delete(self):
#locks required because in order to delete,
#the main thread must clear and then call AVRSprite.onDelete atomically
#also, this gaurantees the order of object deletion so no infinite reference loops occur
AVRSprite.deleteLock.acquire()
AVRSprite.deletedSprites.append(self)
self.sprite.dirty = 1
for g in self.groups[:]:
g.removeSprite(self)
self.groups = []
self.sprite.AVRSprite = None
del AVRSprite.spriteList[self.handle]
AVRSprite.availableHandles.append(self.handle)
AVRSprite.deleteLock.release()
def collide(self, group):
if self.sprite.maskDirty:
self.sprite.maskDirty = False
AVRSprite.spriteLock.acquire()
self.sprite.mask = mask.from_surface(self.transformedSurface)
AVRSprite.spriteLock.release()
sprites = sprite.spritecollide(self.sprite, group.group, False)
results = []
for s in sprites:
if s == self.sprite:
continue
if s.maskDirty:
s.maskDirty = False
AVRSprite.spriteLock.acquire()
s.mask = mask.from_surface(s.AVRSprite.transformedSurface)
AVRSprite.spriteLock.release()
if sprite.collide_mask(self.sprite, s) != None:
results.append(s.AVRSprite.handle)
return results
@staticmethod
def onDelete():
for s in AVRSprite.deletedSprites:
AVRSprite.spriteDrawGroup.remove(s.sprite)
s.sprite = None
AVRSprite.deletedSprites = []
@staticmethod
def update():
for s in AVRSprite.spriteList.values():
if s.posDirty or s.sizeDirty or s.rotateDirty:
s.sprite.dirty = 1
@staticmethod
def updateGraphics():
for s in AVRSprite.spriteList.values():
if s.sizeDirty:
s.scaledSurface = transform.smoothscale(s.surface, s.size)
s.transformedSurface = transform.rotate(
s.scaledSurface, s.angle)
s.sprite.image = s.transformedSurface
s.sprite.rect = s.transformedSurface.get_rect()
s.sprite.rect.center = s.pos
s.sprite.maskDirty = True
elif s.rotateDirty:
s.transformedSurface = transform.rotate(
s.scaledSurface, s.angle)
s.sprite.image = s.transformedSurface
s.sprite.rect = s.transformedSurface.get_rect()
s.sprite.rect.center = s.pos
s.sprite.maskDirty = True
elif s.posDirty:
s.sprite.rect.center = s.pos
s.posDirty = False
s.posDirty = True
s.rotateDirty = True
s.sizeDirty = True
