def __init__(self, player):
        """ Create level 1. """

        # Call the parent constructor
        Level.__init__(self, player)

        sprite_sheet = SpriteSheet("backgrounds.png")
        self.background = sprite_sheet.get_image(0, 63, 231, 63)
        self.background = pygame.transform.scale(self.background, (constants.SCREEN_WIDTH,
                                                                 constants.SCREEN_HEIGHT))
        self.background.set_colorkey(constants.WHITE)
        self.level_limit = -2500

        # Array with type of platform, and x, y location of the platform.
        level = [ [platforms.STONE_WALL, 30, 650]
                  ]

        

        # Go through the array above and add platforms
        for platform in level:
            block = platforms.Platform(platform[0])
            block.rect.x = platform[1]
            block.rect.y = platform[2]
            block.player = self.player
            self.platform_list.add(block)

    def __init__(self, sprite_sheet_data):
        """ Platform constructor. Assumes constructed with user passing in
            an array of 5 numbers like what's defined at the top of this
            code. """
        super().__init__()

        #sprite_sheet = SpriteSheet("tiles_spritesheet.png")
        sprite_sheet = SpriteSheet( \
                "images/green-hill-zone/level-fragments/27190.png")

        self.x0 = sprite_sheet_data[0];
        self.y0 = sprite_sheet_data[1];
        self.x1 = sprite_sheet_data[2];
        self.y1 = sprite_sheet_data[3];

        self.image = sprite_sheet.get_image(self.x0, \
                self.y0, self.x1-self.x0, self.y1-self.y0)

        if (len(sprite_sheet_data) > 4):
            a = sprite_sheet_data[4]
            b = sprite_sheet_data[5]
            self.image = pygame.transform.scale(self.image, (a,b))
        
        colorkey = self.image.get_at((0,0))
        self.image.set_colorkey(colorkey)

        self.rect = self.image.get_rect()

 def load_sprite(self):    
     # Load sword sprite
     sprite_sheet = SpriteSheet("resources/attacks/Sword_Update1.png")
     image = sprite_sheet.get_image(0, 0, 103, 32)
     self.sword_frame_r.append(image)
     image = pygame.transform.flip(image, True, False)
     self.sword_frame_l.append(image)

class Platform(pygame.sprite.Sprite):
    """
    Class for basic platforms. Uses sprite_sheet.get
    to get the appropriate sprite according to defined values above
    """
    def __init__(self, sprite_sheet_data, x, y):
        super(Platform, self).__init__()

        self.sprite_sheet = SpriteSheet(path.join(img_dir, "tiles_spritesheet.png"))
        self.image = self.sprite_sheet.get_image(sprite_sheet_data[0],
                                                 sprite_sheet_data[1],
                                                 sprite_sheet_data[2],
                                                 sprite_sheet_data[3])

        self.sprite_sheet_data = sprite_sheet_data

        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y
        self.x_pos = x
        self.y_pos = y

    def collide(self):
        pass

    def update(self, dt):
        pass

    def set_image(self, block):
        self.image = self.sprite_sheet.get_image(block[0],
                                                 block[1],
                                                 block[2],
                                                 block[3])

    def __init__(self, file_name):
        ''' (1) charge le fichier TMX
            (2) charge le fichier image ou se trouvent les sprites dans l'objet sheet
        '''

        self.carte    = None                 # json data from file
        self.sheet    = None                 # SpriteSheet object
        self.spritesize = 0                  # sprite size in pixels (assume its a square)
        self.rowsize,self.colsize = None,None# number of sprites in a row , column

        dirname = os.path.dirname(os.path.abspath(__file__))

        with open(dirname + "/" + file_name, 'r') as f:
            self.carte = json.load(f)

        assert self.carte["tilewidth"]==self.carte["tileheight"], "les sprites doivent etre carres"

        self.spritesize               = self.carte["tilewidth"]
        self.rowsize , self.colsize   = self.carte["width"],self.carte["height"]

        try:
            sheet_filename  = dirname + "/" + self.carte["tilesets"][0]["image"]
            self.sheet      = SpriteSheet(sheet_filename,self.spritesize)
        except pygame.error:
            try:
                sheet_filename  = dirname + "/Cartes/" + self.carte["tilesets"][0]["image"]
                self.sheet      = SpriteSheet(sheet_filename,self.spritesize)
            except pygame.error as e2:
                print ("Error - impossible de trouver le fichier images des sprites -")
                raise e2

    def __init__(self, x, y):
        """
        Initializes the image at the given location.
        
        Args:
            x (int): the x coordinate to place the Sprite.
            y (int): the y coordinate to place the Sprite.
        """
        pygame.sprite.Sprite.__init__(self)

        #Get the ghost images from the Sprites folder
        script_dir = sys.path[0]
        image_directory = os.path.join(script_dir, 'Sprites/ghost2.bmp')
        
        # Get the 2 images for the sprite sheet. 
        sprite_sheet = SpriteSheet(image_directory)
        image = sprite_sheet.get_image(0, 0, 62, 75)
        self.__movement_frames.append(image)
        image = sprite_sheet.get_image(64 , 0, 62, 75)
        self.__movement_frames.append(image)
        
        
        # set the Player to the first sprite
        self.image = self.__movement_frames[self.__current_frame_reference]
        
        self.rect = self.image.get_rect()
        
        # Setting the location of rectangle
        self.rect.x = x
        self.rect.y = y

 def __init__(self):
     super().__init__()
     #Motion variables
     self.change_x = 0
     self.change_y = 0
     self.boundary_top = 0
     self.boundary_bottom = 0
     self.boundary_left = 0
     self.boundary_right = 0
     #Level information
     self.level = None
     self.player = None
     #How fast this sprite attacks, in number of frames. 5 = every 5 frames
     self.attack_speed = 10
     #How many times updated has been called. reset to zero when it = attack speed
     self.updates = 0
     self.firing = False
     self.fired_ticks = 0
     sheet = SpriteSheet("enemy_sheet.png")
     self.frames_l = []
     self.frames_r = []
     image = sheet.get_image(0, 48, 64, 132)
     self.frames_l.append(image)
     image = sheet.get_image(68, 48, 64, 132)
     self.frames_l.append(image)
     image = pygame.transform.flip(self.frames_l[0], True, False)
     self.frames_r.append(image)
     image = pygame.transform.flip(self.frames_l[1], True, False)
     self.frames_r.append(image)
     self.direction = 'L'
     if self.direction == 'R':
         self.image = self.frames_r[0]
     if self.direction == 'L':
         self.image = self.frames_l[0]
     self.rect = self.image.get_rect()

    def __init__(self):
        super(WallSprite, self).__init__()

        sprite_sheet = SpriteSheet('images/tilesets/walls.png')#3 x 4
        horiz = [0, 32, 64]
        vert= [0, 32, 64, 96]
        self.image = sprite_sheet.get_image(random.choice(horiz),random.choice(vert),32,32)

 def __init__(self, sprite_sheet_data):
   pygame.sprite.Sprite.__init__(self)
   sprite_sheet = SpriteSheet("elevator.png")
   # grab the image for the elevator
   self.image = sprite_sheet.get_image(sprite_sheet_data[0], sprite_sheet_data[1], sprite_sheet_data[2], sprite_sheet_data[3])
   self.rect = self.image.get_rect()
   self.router = ElevatorData(FLOORS)
   self.path = []
   self.wait = 0

    def __init__(self, sprite_sheet_data):
        pygame.sprite.Sprite.__init__(self)

        sprite_sheet = SpriteSheet("tiles_spritesheet.png")
        # grab image for this platform
        self.image = sprite_sheet.get_image(
            sprite_sheet_data[0], sprite_sheet_data[1], sprite_sheet_data[2], sprite_sheet_data[3]
        )
        self.rect = self.image.get_rect()

 def __init__(self, sprite_sheet_data, x=0, y=0):
     super().__init__()
     sprite_sheet = SpriteSheet("platform_sheet.png")
     # Grab the image for this platform
     self.image = sprite_sheet.get_image(sprite_sheet_data[0], sprite_sheet_data[1], sprite_sheet_data[2], sprite_sheet_data[3])
     # This platform can set its own position based on passed-in args
     self.rect = self.image.get_rect()
     self.x = x
     self.y = y

    def __init__(self):
        super().__init__()

        sprite_sheet = SpriteSheet("spritesheet.png")
        # Grab the image for this platform
        self.image = sprite_sheet.get_image(32, 128, 32, 32)

        self.imagesAndDurations = [(sprite_sheet.get_image(32, 96, 32, 32), 0.1),
                                   (sprite_sheet.get_image(63, 96, 32, 32), 0.5)]

    def __init__(self, sprite_sheet_data):
        pygame.sprite.Sprite.__init__(self)

        sprite_sheet = SpriteSheet("Levels/tiles_spritesheet.png")
        self.image = sprite_sheet.get_image(sprite_sheet_data[0],
                                            sprite_sheet_data[1],
                                            sprite_sheet_data[2],
                                            sprite_sheet_data[3])

        self.rect = self.image.get_rect()

    def __init__(self, sprite_sheet_data):

        super(Platform, self).__init__()
        self.x_velocity = 0
        self.y_velocity = 0
        sprite_sheet = SpriteSheet(TILES_SS_PATH)
        self.image = sprite_sheet.get_image(sprite_sheet_data[0],
                                            sprite_sheet_data[1],
                                            sprite_sheet_data[2],
                                            sprite_sheet_data[3])
        self.rect = self.image.get_rect()

	def __init__(self, sprite_sheet_data):
		pygame.sprite.Sprite.__init__(self)
		
		sprite_sheet = SpriteSheet(sprite_sheet_data[0])
		# Grab the image for this platform
		self.image = sprite_sheet.get_image(sprite_sheet_data[1],
											sprite_sheet_data[2],
											sprite_sheet_data[3],
											sprite_sheet_data[4])

		self.rect = self.image.get_rect()

 def __init__(self, sprite_sheet_data):
     """ Platform constructor. Assumes constructed with user passing in
         an array of 5 numbers like what's defined at the top of this
         code. """
     pygame.sprite.Sprite.__init__(self)
     sprite_sheet = SpriteSheet('resources/My_first_sprite_sheet.png')
     # Grab the image for this platform
     self.image = sprite_sheet.get_image(sprite_sheet_data[0],
                                         sprite_sheet_data[1],
                                         sprite_sheet_data[2],
                                         sprite_sheet_data[3])
     self.rect = self.image.get_rect()

    def __init__(self, sprite_sheet_data):
        """ Platform constructor. Assumes constructed with user passing in
            an array of 5 numbers like what's defined at the top of this
            code. """
        super().__init__()

        sprite_sheet = SpriteSheet("tiles_spritesheet.png")
        # Grab the image for this platform
        self.image = sprite_sheet.get_image(
            sprite_sheet_data[0], sprite_sheet_data[1], sprite_sheet_data[2], sprite_sheet_data[3]
        )

        self.rect = self.image.get_rect()

    def __init__(self, sprite_sheet_data):
        """ Hazard constructor. Assumes constructed with user passing in
            an array of 5 numbers like what's defined at the top of this
            cod. """
        pygame.sprite.Sprite.__init__(self)

        enemy_sheet = SpriteSheet("enemy1.png")
        # Grab the image for this enemy
        self.image = enemy_sheet.get_image(enemy_sheet_data[0],
                                            enemy_sheet_data[1],
                                            enemy_sheet_data[2],
                                            enemy_sheet_data[3])
        self.rect = self.image.get_rect()        

    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.walking_frames_d = [] # Images for animated walking.

        sprite_sheet = SpriteSheet("spritesheet.png")
        image = sprite_sheet.get_image(19, 0, 54, 96)
        self.walking_frames_d.append(image)

        image = sprite_sheet.get_image(169, 0, 54, 96) # Adds up by 150 everytime
        self.walking_frames_d.append(image)

        image = sprite_sheet.get_image(319, 0, 54, 96)
        self.walking_frames_d.append(image)

        image = sprite_sheet.get_image(469, 0, 54, 96)
        self.walking_frames_d.append(image)

        image = sprite_sheet.get_image(619, 0, 54, 96)
        self.walking_frames_d.append(image)

        image = sprite_sheet.get_image(769, 0, 54, 96)
        self.walking_frames_d.append(image)

        image = sprite_sheet.get_image(919, 0, 54, 96)
        self.walking_frames_d.append(image)

        self.image = self.walking_frames_d[0]
        self.rect = self.image.get_rect()
        self.rect.center = (WIDTH / 2, HEIGHT / 2)
        self.speedx = 0
        self.speedy = 0

        self.last_update = pygame.time.get_ticks()
        self.frame = 0

    def __init__(self, sprite_sheet_data):
        """ Block constructor. Assumes constructed with user passing in
            an array of 4 numbers like what's defined at the top of this
            code. """
        pygame.sprite.Sprite.__init__(self)
 
        sprite_sheet = SpriteSheet("Resources/Sprites/spritesheet_tiles.png")
        # Grab the image for this platform
        self.image = sprite_sheet.get_image(sprite_sheet_data[0],
                                            sprite_sheet_data[1],
                                            sprite_sheet_data[2],
                                            sprite_sheet_data[3])
 
        self.rect = self.image.get_rect()