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