def test_memoryleak_bug(self):
# For memoryleak bug posted to mailing list by Tobias Steinrücken on 16/11/10.
# Fixed in revision 2953.
import weakref
import gc
class MySprite(sprite.Sprite):
def __init__(self, *args, **kwargs):
sprite.Sprite.__init__(self, *args, **kwargs)
self.image = pygame.Surface((2, 4), 0, 24)
self.rect = self.image.get_rect()
g = sprite.GroupSingle()
screen = pygame.Surface((4, 8), 0, 24)
s = MySprite()
r = weakref.ref(s)
g.sprite = s
del s
gc.collect()
self.assertIsNotNone(r())
g.update()
g.draw(screen)
g.sprite = MySprite()
gc.collect()
self.assertIsNone(r())
def __init__(self, game_state):
self.done = False
self.next = None
self.quit = False
self.previous = None
self.game_state = game_state
self.active_sprites = sprite.Group()
self.buttons = sprite.Group()
self.preview = sprite.GroupSingle()
self.prev_x = c.VIEW_LEFT
self.prev_y = c.VIEW_TOP
self.reset = False
self.quit = False
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 __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 __init__(self, hub, level_name="1-1-1"):
""" Initialize default values """
# Necessary component to communicate with game screens
self.hub = hub
self.screen = hub.main_screen
self.controller = hub.controller
self.camera = hub.camera
self.gamemode = hub.gamemode
self.level_name = level_name
self.time_seconds = pygame.time.get_ticks() + 1000
# Bounce physics
self.counter_bounce = 0
self.bounce_max_height = 100
self.bounce_velocity = 35
# Set up background
self.bg_image = pygame.image.load(
self.hub.game_levels[self.level_name]["background_image"])
self.bg_rect = self.bg_image.get_rect()
self.prep_bg_image()
# Background Collision Group where all the background collisions will be store
# This does not include brick collision. the background collisions are also referred to as "world collision"
self.background_collisions = sprite.Group()
# Teleporter Group, teleporter to the given destination
self.teleporter_group = sprite.Group()
# Points Group, show the points that was shown
self.point_group = sprite.Group()
# Player group spawn player in again if needed
self.player_group = sprite.GroupSingle()
# Player fire ball
self.player_fireball_group = sprite.Group()
# Gumba group spawn gumba when appropriate
self.enemy_group = sprite.Group()
# Piranhaplant group spawn gumba when appropriate
self.plant_group = sprite.Group()
# Magic mushroom group
self.magic_mushroom_group = sprite.Group()
# Oneup mushroom group
self.oneup_mushroom_group = sprite.Group()
# Fireflower group
self.fireflower_group = sprite.Group()
# Starman group
self.starman_group = sprite.Group()
# For red or green shells
self.shells_group = sprite.Group()
# Projectiles (Shell, Fire, Bullet bills)
self.projectile_group = sprite.Group()
# Enemies set to die
self.death_group = sprite.Group()
# Bricks to be spawned
self.brick_group = sprite.Group()
# Platforms to be spawned
self.platform_group = sprite.Group()
# Bricks pieces to be spawned
self.brickpieces_group = sprite.Group()
# Coins to be spawned
self.coin_group = sprite.Group()
# Pipe group
self.pipe_group = sprite.Group()
# Flag Pole Group
self.flagpole_group = sprite.Group()
# Firebar Group
self.firebar_group = sprite.Group()
# Spawn all instances from the JSON File
self.spawn_objects(hub)
def __init__(self, hub, level_name="1-1-1"):
self.hub = hub
self.screen = hub.main_screen
self.controller = hub.controller
self.camera = hub.camera
self.gamemode = hub.gamemode
self.level_name = level_name
# Bounce physics
self.counter_bounce = 0
self.bounce_max_height = 100
self.bounce_velocity = 35
# Set up background
self.bg_image = pygame.image.load(
self.hub.game_levels[self.level_name]["background_image"])
self.bg_rect = self.bg_image.get_rect()
self.prep_bg_image()
# Back Collision Group where all the background collisions will be store
# This does not include brick collision.
self.background_collisions = sprite.Group()
# Teleporter Group
self.teleporter_group = sprite.Group()
# Player group spawn player in again if needed
self.player_group = sprite.GroupSingle()
# Gumba group spawn gumba when appropriate
self.enemy_group = sprite.Group()
# For red or green shells
self.shells_group = sprite.Group()
# Projectiles (Shell, Fire, Bullet bills)
self.projectile_group = sprite.Group()
# Enemies set to die
self.death_group = sprite.Group()
# Bricks to be spawned
self.brick_group = sprite.Group()
try:
for gumba in self.hub.game_levels[self.level_name]["gumba_group"]:
self.enemy_group.add(Gumba(hub=hub, x=gumba["x"],
y=gumba["y"]))
except Exception:
print('no gumba exist within this level')
try:
for koopatroop in self.hub.game_levels[
self.level_name]["koopatroop_group"]:
self.enemy_group.add(
Koopatroops(hub=hub, x=koopatroop["x"], y=koopatroop["y"]))
except Exception:
print('no koopatroop exist within this level')
# Add floor collision instances to the map
try:
for collision in self.hub.game_levels[
self.level_name]["collision_group"]:
self.background_collisions.add(
FloorCollision(hub, (collision["x"], collision["y"]),
(collision["width"], collision["height"])))
except Exception:
print('no collision found in within this level')
# Add teleport instances
try:
for teleporter in self.hub.game_levels[
self.level_name]["teleporter"]:
self.teleporter_group.add(
Teleport(hub, teleporter["x"], teleporter["y"],
teleporter["level_name"],
teleporter["world_offset"]))
except Exception:
print('no teleporter found within this level')
# Add Brick Instance
try:
print(len(self.hub.game_levels[self.level_name]["bricks"]))
for brick in self.hub.game_levels[self.level_name]["bricks"]:
self.brick_group.add(
Bricks(hub=hub,
x=brick["x"],
y=brick["y"],
insides=brick["inside"],
powerup_group=brick["powerup"],
name=brick["name"]))
except Exception:
print('no bricks exist within this level')
# Add Brick Group Instance
try:
print(len(self.hub.game_levels[self.level_name]["brick_group"]))
for brickset in self.hub.game_levels[
self.level_name]["brick_group"]:
for i in range(0, brickset["Row"]):
print(str(i))
for j in range(0, brickset["Col"]):
print(str(j))
row = i * 50
col = j * 50
print(str(row) + " equals" + str(col))
self.brick_group.add(
Bricks(hub=hub,
x=row,
y=col,
insides="None",
powerup_group="Brick",
name="Brick"))
except Exception:
print('no brickset exist within this level')
# Add player instance
self.player_spawn_point = self.hub.game_levels[
self.level_name]["spawn_point"]
self.current_player = Player(hub, self.player_spawn_point[0],
self.player_spawn_point[1])
self.player_group.add(self.current_player)
