def __init__(self):
"""
Initializes the background
Variables:
sprite_sheet: The spritesheet to where the custom spries came from
image: Holds the custom
self.image: The sprite used to represent
self.rect: This creates the shape of the sprite
self.rect.x: The x-position of the sprite
self.rect.y: The y-position of the sprite
"""
super().__init__()
pygame.sprite.Sprite.__init__(self)
self.sprite_sheet = SpriteSheet("backTitle.png")
image = self.sprite_sheet.get_image(0, 0, 1000, 700)
self.image = image
self.rect = self.image.get_rect()
self.rect.x = 0
self.rect.y = 0
def __init__(self, direction):
# Call the parent class (Sprite) constructor
super().__init__()
self.bullet_frames = []
##Load animations
# walking
sprite_sheet = SpriteSheet("animations/bullet.png")
sizeX = 172
sizeY = 28
n = 5
for i in range(n):
image = sprite_sheet.get_image(i*sizeX/n, 0, sizeX/n, sizeY)
if direction == 0:
image = pygame.transform.flip(image, True, False)
self.bullet_frames.append(image)
# Set the image the player starts with
self.image = self.bullet_frames[0]
# Set a reference to the image rect.
self.rect = self.image.get_rect()
self.direction = direction
# Play Sounds
pygame.mixer.Channel(0).play(pygame.mixer.Sound('sounds/laser.wav'))
def __init__(
self,
UAV,
prop_dia=10,
prop_pitch=4.5,
thrust_unit='N',
):
super(Propeller, self).__init__()
self.dia = prop_dia # in.
self.pitch = prop_pitch # in.
self.thrust_unit = thrust_unit
self.speed = 0 # RPM
self.thrust = 0
self.max_speed = 25000 # RPM
self.uav = UAV
self.rotating_frames = []
sprite_sheet = SpriteSheet("propeller1.png")
for frame_nb in range(7):
frame = sprite_sheet.get_image(1, frame_nb * 49, 235, 49)
frame = pygame.transform.scale(frame, (234 // 4, 49 // 4))
self.rotating_frames.append(frame)
# Set the image the propeller starts with
self.image = self.rotating_frames[0]
# Set a reference to the image rect.
self.rect = self.image.get_rect()
self.last_frame = {'prop_angle': 0, 'time': time.time()}
def __init__(self, x, y):
""" In order to make a coin, you need to have a constructor. """
# Call upon the sprite's constructor.
super().__init__()
# Need to have the frame(s) for the coin.
self.f_coin = []
# Need to check if things collide (use sprites!)
self.mask = None
sprite_sheet = SpriteSheet(os.path.join("assets", "sprites.png"))
lookup_table = [(0, 1)]
for value in lookup_table:
pixel_x, pixel_y = SPRITEHELPER.lookup(value)
image = sprite_sheet.get_image(pixel_x, pixel_y, \
c.SPRITEWIDTH, c.SPRITEHEIGHT, c.CHROMA)
self.f_coin.append(pygame.transform.scale(image, \
(c.SPRITEWIDTH * c.SCALING, c.SPRITEHEIGHT * c.SCALING)))
self.image = self.f_coin[0]
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.mask = pygame.mask.from_surface(self.image)
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, 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__()
sprite_sheet = SpriteSheet("platform_sheet.png")
# Grab the image for this platform
self.image = sprite_sheet.get_image(156, 15, 40, 40)
self.rect = self.image.get_rect()
def __init__(self):
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet("chicken.png")
self.vida = 1000
# Cargamos la imagen de la gallina mirando a la izquierda
image = self.walking_frames_r.append(pygame.image.load('uno.png'))
image = self.walking_frames_r.append(pygame.image.load('dos.png'))
image = self.walking_frames_r.append(pygame.image.load('tres.png'))
# Cargamos las imagenes de la gallina mirando a la derecha
image = sprite_sheet.get_image(0, 47, 50, 20)
image = pygame.transform.flip(image, True, False)
image = self.walking_frames_l.append(pygame.image.load('cuatro.png'))
image = self.walking_frames_l.append(pygame.image.load('cinco.png'))
image = self.walking_frames_l.append(pygame.image.load('seis.png'))
# La gallina inicia mirando a la derecha
self.image = self.walking_frames_l[0]
# Obtenemos una refecian del rectangulo que cubre a la imagen
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, 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()
class Enemy(pygame.sprite.Sprite):
def __init__(self, player, level):
super().__init__()
self.player = player
self.level = level
self.direction = None
self.status = constants.ENEMY_INIT
self.change_status_time = 0
self.collisionManager = CollisionManager(self)
# Grab the images for the snake
self.sprite_sheet0 = None
self.sprite_sheet1 = None
# Egg images
self.sprite_sheet1 = SpriteSheet("Assets/Egg.png")
self.egg_images = [
self.sprite_sheet1.get_image(0, 0, 58, 58),
self.sprite_sheet1.get_image(58, 0, 116, 58)
]
self.image = None
self.rect = None
self.change_x = 0
self.change_y = 0
def update(self):
self.collisionManager.fixed_objects(self.level.walls_list)
self.collisionManager.fixed_objects(self.level.door_list)
self.collisionManager.fixed_objects(self.level.artifact_list)
self.collisionManager.fixed_objects(self.level.water_list)
self.collisionManager.fixed_objects(self.level.block_list)
self.collisionManager.fixed_objects(self.level.chest_list)
def set_egg(self):
""" Called when the player shots the enemy. """
self.image = self.egg_images[0]
self.status = constants.ENEMY_EGG
self.change_status_time = pygame.time.get_ticks()
pygame.time.set_timer(constants.BROKE_EGG, constants.EGG_TIME)
def broke_egg(self):
""" Called when broke egg event is throwed. """
self.image = self.egg_images[1]
self.status = constants.ENEMY_BREAKING_EGG
self.change_status_time = pygame.time.get_ticks()
pygame.time.set_timer(constants.BROKE_EGG, 0)
pygame.time.set_timer(constants.REMOVE_EGG, constants.EGG_TIME)
def remove_egg(self):
""" Called when remove egg event is throwed. """
self.image = self.egg_images[1]
self.status = constants.ENEMY_INIT
self.change_status_time = 0
pygame.time.set_timer(constants.REMOVE_EGG, 0)
def get_status(self):
return self.status
def __init__(self, name, patrol_zone, sprite_img_path = "img/husband.png"):
super(Husband, self).__init__()
# Attributes
self.name = name
self._change_x = -1
self._change_y = 0
self._x0 = patrol_zone[1]
self._y0 = 0
self._direction = "L"
self._sprite_frame_frequency = 4
self._walking_frames_l = []
self._walking_frames_r = []
self._patrol_zone = []
self._enabled = True
self._patrol_zone = patrol_zone
sprite_sheet = SpriteSheet(sprite_img_path)
for i in range(9):
image = sprite_sheet.get_image(i * self._PL_WIDTH, 3 * self._PL_HEIGHT, self._PL_WIDTH, self._PL_HEIGHT-self._PL_MARGIN)
self._walking_frames_r.append(image)
for i in range(9):
image = sprite_sheet.get_image(i * self._PL_WIDTH, self._PL_HEIGHT, self._PL_WIDTH, self._PL_HEIGHT-self._PL_MARGIN)
self._walking_frames_l.append(image)
# Set the image the player starts with
self.image = self._walking_frames_l[0]
# Set a reference to the image rect.
self.rect = self.image.get_rect()
def __init__(self, sprite_sheet_data, x, y, player, open_image):
super(Door, self).__init__(sprite_sheet_data, x, y, player)
self.open = False
self.closed_image = self.image
sprite_sheet = SpriteSheet("img/things_spritesheet2.png")
self.open_image = sprite_sheet.get_image(*open_image)
self.last_change = time.time()
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, 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, 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, player, level):
super().__init__()
self.player = player
self.level = level
self.direction = None
self.status = constants.ENEMY_INIT
self.change_status_time = 0
self.collisionManager = CollisionManager(self)
# Grab the images for the snake
self.sprite_sheet0 = None
self.sprite_sheet1 = None
# Egg images
self.sprite_sheet1 = SpriteSheet("Assets/Egg.png")
self.egg_images = [
self.sprite_sheet1.get_image(0, 0, 58, 58),
self.sprite_sheet1.get_image(58, 0, 116, 58)
]
self.image = None
self.rect = None
self.change_x = 0
self.change_y = 0
def __init__(self, location, speed, direction=pg.K_RIGHT):
"""
The location is an (x,y) coordinate pair, and speed is the player's
speed in pixels per frame. Speed should be an integer.
"""
tools._Physics.__init__(self)
pg.sprite.Sprite.__init__(self)
self.sheet = SpriteSheet("spritesheet.png")
self.image = self.sheet.get_image(441, 2, 17, 21)
self.image.set_colorkey(c.SPRITESHEET_BACKGROUND)
self.rect = self.image.get_rect()
self.direction = direction
self.speed = speed
self.jump_power = -9.0
self.jump_cut_magnitude = -3.0
self.on_moving = False
self.collide_below = False
self.old_direction = None
self.direction_stack = []
self.redraw = False
self.frame = 0
self.frames = self.get_frames()
self.animate_timer = 0.0
self.animate_fps = 7.0
self.walkframes = []
self.walkframe_dict = self.make_frame_dict()
self.adjust_images()
def __init__(self):
#constructor function
super(Player, self).__init__()
# attributes
# set vector speed
self.change_x = 0
self.change_y = 0
# this holds all the animated images for walking left/right
self.walking_frames_l = []
self.walking_frames_r = []
# What direction is the player facing?
self.direction = "R"
# list of sprites we can bump up against
self.level = None
sprite_sheet = SpriteSheet('birdpersonFlip.png')
# Load all the right facing images into a list
#image = sprite_sheet.get_image(18,750,104,148)
#self.walking_frames_r.append(image)
#image = sprite_sheet.get_image(276,750,102,148)
#self.walking_frames_r.append(image)
image = sprite_sheet.get_image(10, 926, 110, 138)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(142, 928, 110, 134)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(268, 926, 112, 136)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(400, 926, 104, 136)
self.walking_frames_r.append(image)
# Load all the right facing images, then flip to face left
#image = sprite_sheet.get_image(18,750,104,148)
#image = pygame.transform.flip(image, True, False)
#self.walking_frames_l.append(image)
#image = sprite_sheet.get_image(276,750,102,148)
#image = pygame.transform.flip(image, True, False)
#self.walking_frames_l.append(image)
image = sprite_sheet.get_image(10, 926, 110, 138)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(142, 928, 110, 134)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(268, 926, 112, 136)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(400, 926, 104, 136)
image = pygame.transform.flip(image, True, False)
# Set the image player starts with
self.image = self.walking_frames_r[0]
# set a reference to the image rect
self.rect = self.image.get_rect()
def __init__(self, pos):
pygame.sprite.Sprite.__init__(self)
self.mad_frames = []
sprite_sheet = SpriteSheet("MadMe.png")
image = pygame.transform.scale(
sprite_sheet.get_image(0, 0, Mad_Size[0] + mad_buff, Mad_Size[1]),
(int(Mad_Size[0] / Mad_Resize), int(Mad_Size[1] / Mad_Resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(Mad_Size[0], 0, Mad_Size[0] + mad_buff,
Mad_Size[1]),
(int(Mad_Size[0] / Mad_Resize), int(Mad_Size[1] / Mad_Resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(Mad_Size[0] * 2, 0, Mad_Size[0] + mad_buff,
Mad_Size[1]),
(int(Mad_Size[0] / Mad_Resize), int(Mad_Size[1] / Mad_Resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(0, Mad_Size[1], Mad_Size[0] + mad_buff,
Mad_Size[1]),
(int(Mad_Size[0] / Mad_Resize), int(Mad_Size[1] / Mad_Resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(Mad_Size[0], Mad_Size[1],
Mad_Size[0] + mad_buff, Mad_Size[1]),
(int(Mad_Size[0] / Mad_Resize), int(Mad_Size[1] / Mad_Resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(Mad_Size[0] * 2, Mad_Size[1] + mad_buff,
Mad_Size[0] + mad_buff, Mad_Size[1]),
(int(Mad_Size[0] / Mad_Resize), int(Mad_Size[1] / Mad_Resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(0, Mad_Size[1] * 2, Mad_Size[0] + mad_buff,
Mad_Size[1]),
(int(Mad_Size[0] / Mad_Resize), int(Mad_Size[1] / Mad_Resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(Mad_Size[0], Mad_Size[1] * 2,
Mad_Size[0] + mad_buff, Mad_Size[1]),
(int(Mad_Size[0] / Mad_Resize), int(Mad_Size[1] / Mad_Resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
self.frame = 0
self.image = self.mad_frames[self.frame]
self.rect = self.image.get_rect()
self.rect.center = pos
def __init__(self, player):
"""
walk_images is a list of sprite locations found in constants
and sprite_sheet is the walking PNG file
"""
# Call the parent's constructor
pygame.sprite.Sprite.__init__(self)
self.pname = player['name']
# Set speed vector of player
self.change_x = 0
self.change_y = 0
self.sprite_sheet = SpriteSheet(player['spritesheet'])
self.frozen_sprite_sheet = SpriteSheet(player['frozen_spritesheet'])
# This holds all the images for the animated walk left/right
# of our player
self.walking_frames_l = []
self.walking_frames_r = []
self.frozen_frames_l = []
self.frozen_frames_r = []
self.direction = player['direction']
self.stunned = False
self.stunned_direction = None
self.stun_start = time.time()
self.lives = 3
# Load all the right facing images into a list
for frame in player['walk_images']:
image = self.sprite_sheet.get_image(frame[0], frame[1], frame[2],
frame[3]).convert()
self.walking_frames_r.append(image)
# Flip them and load into left facing list
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
# Creates the frozen sprites
image = self.frozen_sprite_sheet.get_image(frame[0], frame[1],
frame[2],
frame[3]).convert()
self.frozen_frames_r.append(image)
# Flip them and load into left facing list
image = pygame.transform.flip(image, True, False)
self.frozen_frames_l.append(image)
# Set the image the player starts with
self.image = self.walking_frames_r[0]
# Set a referance to the image rect.
self.rect = self.image.get_rect()
def stop(self):
""" Called when the user lets off the keyboard. """
pygame.sprite.Sprite.__init__(self)
self.change_x = 0
sprite_sheet = SpriteSheet("p1_walk.png")
image = sprite_sheet.get_image(4, 4, 70, 81)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
def __init__(self, pos):
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet("Netflix.png")
self.image = pygame.transform.scale((sprite_sheet.get_image(0, 0, icon_size,icon_size),(icon_size/Mad_Resize), int(icon_size/Mad_Resize)))
self.image.set_colorkey(black)
self.rect = self.image.get_rect()
self.rect.center = pos
def __init__(self, x, y):
super().__init__()
sprite_sheet = SpriteSheet("world_spritesheet.png")
# Вырезаем изображение из спрайтшита
self.image = sprite_sheet.get_image(0, 0, 40, 40)
self.rect = self.image.get_rect()
self.rect.y = y
self.rect.x = x
def __init__(self):
super(DoorSprite, self).__init__()
sprite_sheet = SpriteSheet('images/tilesets/doors.png')#4 x 1
horiz = [0, 32, 64, 96]
vert= [0]
self.image = sprite_sheet.get_image(random.choice(horiz),random.choice(vert),32,32)
def __init__(self):
super(FloorSprite, self).__init__()
sprite_sheet = SpriteSheet('images/tilesets/floors.png')#7x6
horiz = [0, 32, 64, 96, 128, 160, 192]
vert= [0, 32, 64, 96, 128, 160]
self.image = sprite_sheet.get_image(random.choice(horiz),random.choice(vert),32,32)
def __init__(self, pos):
pygame.sprite.Sprite.__init__(self)
self.char_frames = []
sprite_sheet = SpriteSheet(".png") # change to given spritesheet
image = pygame.transform.scale(
sprite_sheet.get_image(0, 0, char_size[0] + char_buff,
char_size[1]),
(int(char_size[0] / char_resize), int(char_size[1] / char_resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(char_size[0], 0, char_size[0] + char_buff,
char_size[1]),
(int(char_size[0] / char_resize), int(char_size[1] / char_resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(char_size[0] * 2, 0,
char_size[0] + char_buff, char_size[1]),
(int(char_size[0] / char_resize), int(char_size[1] / char_resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(0, char_size[1], char_size[0] + char_buff,
char_size[1]),
(int(char_size[0] / char_resize), int(char_size[1] / char_resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(char_size[0], char_size[1],
char_size[0] + char_buff, char_size[1]),
(int(char_size[0] / char_resize), int(char_size[1] / char_resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(char_size[0] * 2, char_size[1] + char_buff,
char_size[0] + char_buff, char_size[1]),
(int(char_size[0] / char_resize), int(char_size[1] / char_resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(0, char_size[1] * 2,
char_size[0] + char_buff, char_size[1]),
(int(char_size[0] / char_resize), int(char_size[1] / char_resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
image = pygame.transform.scale(
sprite_sheet.get_image(char_size[0], char_size[1] * 2,
char_size[0] + char_buff, char_size[1]),
(int(char_size[0] / char_resize), int(char_size[1] / char_resize)))
image.set_colorkey(black)
self.mad_frames.append(image)
self.frame = 0
self.image = self.char_frames[self.frame]
self.rect = self.image.get_rect()
self.rect.center = pos
def __init__(self, xy, speed=1):
""" Constructing an enemy! """
# Using the parent (sprite) constructor.
super().__init__()
self.change_x = 0
self.change_y = 0
self.speed = speed
self.direction = "WF"
# We have 3 sets of animations: walking forward, walking back, dabbing front.
self.f_walking_front = []
self.f_walking_back = []
self.f_dab_front = []
# Need to check if things collide (use sprites!)
self.mask = None
sprite_sheet = SpriteSheet(os.path.join("assets", "sprites.png"))
lookup_table = [(0, 0), (1, 0), (0, 0), (2, 0)]
for value in lookup_table:
pixel_x, pixel_y = SPRITEHELPER.lookup(value)
image = sprite_sheet.get_image(pixel_x, pixel_y, \
c.SPRITEWIDTH, c.SPRITEHEIGHT, c.CHROMA)
self.f_walking_front.append(pygame.transform.scale(image, \
(c.SPRITEWIDTH * c.SCALING, c.SPRITEHEIGHT * c.SCALING)))
lookup_table = [(3, 0), (4, 0), (3, 0), (5, 0)]
for value in lookup_table:
pixel_x, pixel_y = SPRITEHELPER.lookup(value)
image = sprite_sheet.get_image(pixel_x, pixel_y, \
c.SPRITEWIDTH, c.SPRITEHEIGHT, c.CHROMA)
self.f_walking_back.append(pygame.transform.scale(image, \
(c.SPRITEWIDTH * c.SCALING, c.SPRITEHEIGHT * c.SCALING)))
lookup_table = [(6, 0)]
for value in lookup_table:
pixel_x, pixel_y = SPRITEHELPER.lookup(value)
image = sprite_sheet.get_image(pixel_x, pixel_y, \
c.SPRITEWIDTH, c.SPRITEHEIGHT, c.CHROMA)
self.f_dab_front.append(pygame.transform.scale(image, \
(c.SPRITEWIDTH * c.SCALING, c.SPRITEHEIGHT * c.SCALING)))
self.image = self.f_walking_front[0]
self.frame = 0
self.count = 0
self.rect = self.image.get_rect()
self.rect.x = xy[0]
self.rect.y = xy[1]
self.mask = pygame.mask.from_surface(self.image)
self.currently_dabbing = False
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):
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, x, y, player, closed_image,
closed_image2):
super(Wardrobe, self).__init__(sprite_sheet_data, x, y, player)
self.hidden = False
self.open_image = self.image
sprite_sheet = SpriteSheet("img/things_spritesheet2.png")
self.closed_image = sprite_sheet.get_image(*closed_image)
self.closed_image2 = sprite_sheet.get_image(*closed_image2)
self.last_change = time.time()
def __init__(self, sprite_sheet_data):
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet("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, enemy, platform_list):
"""
walk_images is a list of sprite locations found in constants
and sprite_sheet is the walking PNG file
"""
# Call the parent's constructor
pygame.sprite.Sprite.__init__(self)
self.platform_list = platform_list
self.sprite_sheet = SpriteSheet(enemy['spritesheet'])
self.walking_frames_l = []
self.walking_frames_r = []
self.change_x = enemy['change_x']
self.change_y = enemy['change_y']
self.direction = None
# For deciding frame
self.creation_time = time.time()
# Time in seconds until next direction change
self.time_direct = randint(2, 3)
# Compared against to decide on movement
self.timer = time.time()
self.health = enemy['health']
# Pick random start direction for enemy
face = random.randint(0, 1)
if face == 0:
self.direction = "R"
else:
self.direction = "L"
# Change walking direction
if self.direction == "L":
self.change_x *= -1
# Load all the right facing images into a list
for frame in enemy['walk_images']:
image = self.sprite_sheet.get_image(frame[0], frame[1], frame[2],
frame[3])
self.walking_frames_r.append(image)
# Flip them and load into left facing list
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
# Set the image the player starts with
self.image = self.walking_frames_r[0]
# Set a referance to the image rect.
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):
""" Constructor function """
colorkey = constants.BLACK
# Call the parent's constructor
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet("img/all.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image_colorkey(28, 14, 60, 80,colorkey)
image = pygame.transform.scale(image, (100, 100))
self.walking_frames_r.append(image)
image = sprite_sheet.get_image_colorkey(87, 14, 60, 80,colorkey)
image = pygame.transform.scale(image, (100, 100))
self.walking_frames_r.append(image)
image = sprite_sheet.get_image_colorkey(28, 110, 60, 80,colorkey)
image = pygame.transform.scale(image, (100, 100))
self.walking_frames_r.append(image)
# image = sprite_sheet.get_image(0, 93, 66, 90)
# self.walking_frames_r.append(image)
# image = sprite_sheet.get_image(66, 93, 66, 90)
# self.walking_frames_r.append(image)
# image = sprite_sheet.get_image(132, 93, 72, 90)
# self.walking_frames_r.append(image)
# image = sprite_sheet.get_image(0, 186, 70, 90)
# self.walking_frames_r.append(image)
# Load all the right facing images, then flip them
# to face left.
# image = sprite_sheet.get_image(0, 0, 66, 90)
# image = pygame.transform.flip(image, True, False)
# self.walking_frames_l.append(image)
# image = sprite_sheet.get_image(66, 0, 66, 90)
# image = pygame.transform.flip(image, True, False)
# self.walking_frames_l.append(image)
# image = sprite_sheet.get_image(132, 0, 67, 90)
# image = pygame.transform.flip(image, True, False)
# self.walking_frames_l.append(image)
# image = sprite_sheet.get_image(0, 93, 66, 90)
# image = pygame.transform.flip(image, True, False)
# self.walking_frames_l.append(image)
# image = sprite_sheet.get_image(66, 93, 66, 90)
# image = pygame.transform.flip(image, True, False)
# self.walking_frames_l.append(image)
# image = sprite_sheet.get_image(132, 93, 72, 90)
# image = pygame.transform.flip(image, True, False)
# self.walking_frames_l.append(image)
# image = sprite_sheet.get_image(0, 186, 70, 90)
# image = pygame.transform.flip(image, True, False)
# self.walking_frames_l.append(image)
self.hidden = False
self.hide_timer = pygame.time.get_ticks()
# Set the image the player starts with
self.image = self.walking_frames_r[0]
# Set a referance to the image rect.
self.rect = self.image.get_rect()
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):
super().__init__()
self.change_y = 1.5
sprite_sheet = SpriteSheet("zombiespritesheet.png")
self.image = sprite_sheet.get_image(0, 192, 62, 60)
self.rect = self.image.get_rect()
def __init__(self, sprite_sheet_data):
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet('images/Invisible_Block.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__()
sprite_sheet = SpriteSheet("some_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()
def __init__(self, sprite_sheet_data):
super().__init__()
sprite_sheet = SpriteSheet('Pics/Untitled.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]).convert_alpha()
self.mask = pygame.mask.from_surface(self.image)
self.rect = self.image.get_rect()
def __init__(self, length, level = 0):
""" Create level 1. """
# Call the parent constructor
Platform.__init__(self)
width = 128
height = 93
sprites_names = [
"animations/green_tiles/platforms/",
"animations/desert_tiles/platforms/"
]
self.image = pygame.Surface([width*(2+length), height])
sprite_sheet = SpriteSheet(sprites_names[level]+"1.png")
image = sprite_sheet.get_image(0,0,width,height)
#image.set_colorkey(WHITE)
image = pygame.transform.scale(image, (width, height))
self.image.blit(image, dest=(0,0,width, height))
sprite_sheet = SpriteSheet(sprites_names[level]+"2.png")
for i in range(length):
image = sprite_sheet.get_image(0,0,width,height)
#image.set_colorkey(WHITE)
image = pygame.transform.scale(image, (width, height))
self.image.blit(image, dest=((i+1)*width,0,width, height))
sprite_sheet = SpriteSheet(sprites_names[level]+"3.png")
image = sprite_sheet.get_image(0,0,width,height)
#image.set_colorkey(WHITE)
image = pygame.transform.scale(image, (width, height))
self.image.blit(image, dest=((length+1)*width,0,width, height))
self.image.set_colorkey(WHITE)
self.rect = self.image.get_rect()
self.can_fall_through = 0
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):
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):
""" 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):
""" 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, 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, cx, cy, player):
super().__init__()
sheet = SpriteSheet("enemy_sheet.png")
self.image = sheet.get_image(0, 208, 48, 48)
self.rect = self.image.get_rect()
self.change_x = cx
self.change_y = cy
self.player = player
self.player_g = pygame.sprite.Group()
self.player_g.add(self.player)
self.level = self.player.level
self.rect.y = 0
self.rect.x = 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()
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, x, y, floor_locations):
"""
Initializes the player class using a passes x and y coordinate
Args:
x (int): the horizontal location of where the sprite will appear.
y (int): the vertical location of where the sprite will appear.
floor_locations(list): Contains the y coordinates of the different
floors. This reduces the amount of hard coding necessary, and
is used in to set the ground for the Player at different
floors.
Note:
This init function is very reliant on the image mario_edited.png
being saved in a directory name Sprites.
This function is also relies on a specific the specific sprite
sheet mario_edited.png in order to display the correct sprite.
"""
pygame.sprite.Sprite.__init__(self)
#get the player images from the Sprites folder
script_dir = sys.path[0]
image_directory = os.path.join(script_dir, 'Sprites/mario_edited.bmp')
# get the four images for the sprite sheet. the first 3 images are
# walking animations while the last is the jumping sprite
sprite_sheet = SpriteSheet(image_directory)
image = sprite_sheet.get_image(0, 0, 50, 81)
self.__movement_frames.append(image)
image = sprite_sheet.get_image(50, 0, 50, 81)
self.__movement_frames.append(image)
image = sprite_sheet.get_image(107, 0, 50, 81)
self.__movement_frames.append(image)
image = sprite_sheet.get_image(162 , 0, 50, 81)
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
# Set the boundaries for the floors.
self.__floor_boundaries = floor_locations
class Basic_Enemy(pygame.sprite.Sprite):
def __init__(self):
super().__init__()
self.change_x = 0
self.change_y = 0
self.frames = []
self.level = None
self.player = None
self.called_times = 0
self.sheet = SpriteSheet("platform_sheet.png")
image = self.sheet.get_image(8, 85, 48, 48)
self.frames.append(image)
image = pygame.transform.flip(self.frames[0], True, False)
self.frames.append(image)
self.image = self.frames[0]
self.rect = self.image.get_rect()
def update(self):
self.calc_grav()
self.rect.x += self.change_x
pos = self.rect.x + self.level.world_shift
frame = (pos // 30) % len(self.frames)
self.image = self.frames[frame]
block_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False)
for block in block_hit_list:
# If we are moving right,
# set our right side to the left side of the item we hit
if self.change_x > 0:
self.rect.right = block.rect.left
self.change_x = 1
elif self.change_x < 0:
# Otherwise if we are moving left, do the opposite.
self.rect.left = block.rect.right
self.change_x = -1
self.rect.y += self.change_y
# Check and see if we hit anything
block_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False)
for block in block_hit_list:
# Reset our position based on the top/bottom of the object.
if self.change_y > 0:
self.rect.bottom = block.rect.top
elif self.change_y < 0:
self.rect.top = block.rect.bottom
# Stop our vertical movement
self.change_y = 0
if isinstance(block, platforms.MovingPlatform):
self.rect.x += block.change_x
def calc_grav(self):
if self.change_y == 0:
self.change_y = 1
else:
self.change_y += .35
#see if we are on the bottom of the screen.
if self.rect.y >= constants.SCREEN_HEIGHT - self.rect.height and self.change_y >= 0:
self.change_y = 0
self.rect.y = constants.SCREEN_HEIGHT - self.rect.height
def __init__(self, x, y, change_x, level):
self.spritesheet = SpriteSheet("resources/graphics/enemy.bmp", (36, 50, 63))
self.frames = []
image = self.spritesheet.grab_image(0, 0, 16, 16)
image = pygame.transform.scale2x(image)
self.frames.append(image)
image = self.spritesheet.grab_image(16, 0, 16, 16)
image = pygame.transform.scale2x(image)
self.frames.append(image)
image = self.spritesheet.grab_image(32, 0, 16, 16)
image = pygame.transform.scale2x(image)
self.frames.append(image)
self.index = 0
self.MAX_FRAMES = 9
self.image = self.frames[0]
'''
self.image = pygame.Surface([constants.TILE_WIDTH, constants.TILE_HEIGHT])
self.image.fill(constants.RED)
'''
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.level = level
self.game = self.level.game
self.change_x = change_x
self.change_y = 0
def __init__(self,location,speed,direction=pg.K_RIGHT):
"""
The location is an (x,y) coordinate pair, and speed is the player's
speed in pixels per frame. Speed should be an integer.
"""
tools._Physics.__init__(self)
pg.sprite.Sprite.__init__(self)
self.sheet = SpriteSheet("spritesheet.png")
self.image = self.sheet.get_image(441, 2, 17, 21)
self.image.set_colorkey(c.SPRITESHEET_BACKGROUND)
self.rect = self.image.get_rect()
self.direction = direction
self.speed = speed
self.jump_power = -9.0
self.jump_cut_magnitude = -3.0
self.on_moving = False
self.collide_below = False
self.old_direction = None
self.direction_stack = []
self.redraw = False
self.frame = 0
self.frames = self.get_frames()
self.animate_timer = 0.0
self.animate_fps = 7.0
self.walkframes = []
self.walkframe_dict = self.make_frame_dict()
self.adjust_images()
def __init__(self, shooter_name, direction, ix, iy, speed, damage, range, size):
# Call the parent class (Sprite) constructor
super().__init__()
self.direction = direction
# inherited x & y velocities
if self.direction == "U" or self.direction == "D":
self.ix = ix
else:
self.ix = 0
if self.direction == "L" or self.direction == "R":
self.iy = iy
else:
self.iy = 0
self.speed = speed
self.damage = damage
self.range = range
sprite_sheet = SpriteSheet("res/img/space.png")
if shooter_name == "Luci":
if self.direction == "U":
image = sprite_sheet.get_image(74, 269, 27, 44)
self.image = pygame.transform.scale(image, size[0])
elif self.direction == "D":
image = sprite_sheet.get_image(168, 269, 27, 44)
self.image = pygame.transform.scale(image, size[0])
elif self.direction == "L":
image = sprite_sheet.get_image(112, 277, 44, 26)
self.image = pygame.transform.scale(image, size[1])
elif self.direction == "R":
image = sprite_sheet.get_image(18, 277, 44, 26)
self.image = pygame.transform.scale(image, size[1])
else:
if self.direction == "U":
image = sprite_sheet.get_image(75, 314, 27, 44)
self.image = pygame.transform.scale(image, size[0])
elif self.direction == "D":
image = sprite_sheet.get_image(168, 320, 27, 44)
self.image = pygame.transform.scale(image, size[0])
elif self.direction == "L":
image = sprite_sheet.get_image(110, 324, 44, 26)
self.image = pygame.transform.scale(image, size[1])
elif self.direction == "R":
image = sprite_sheet.get_image(20, 324, 44, 26)
self.image = pygame.transform.scale(image, size[1])
self.rect = self.image.get_rect()
def __init__(self, blockers):
super(Player, self).__init__()
# sprite processing, probably need to move this
# to a separate module
sprite_sheet = SpriteSheet("spritesheet.png")
# Load all right facing images into a list
image = sprite_sheet.get_image(441, 2, 17, 21)
self.initial_r.append(image)
image = sprite_sheet.get_image(464, 2, 16, 21)
self.initial_r.append(image)
image = sprite_sheet.get_image(648, 2, 16, 21)
self.initial_r.append(image)
image = sprite_sheet.get_image(671, 2, 16, 21)
self.initial_r.append(image)
# Load all the right facing images, then flip them
# to face left.
for image in self.initial_r:
image = pg.transform.flip(image, True, False)
self.initial_l.append(image)
for image in self.initial_r:
image.set_colorkey(c.SPRITESHEET_BACKGROUND)
size = image.get_size()
bigger_img = pg.transform.scale(image, (int(size[0]*self.factor),
int(size[1]*self.factor)))
self.walking_frames_r.append(bigger_img)
for image in self.initial_l:
image.set_colorkey(c.SPRITESHEET_BACKGROUND)
size = image.get_size()
bigger_img = pg.transform.scale(image, (int(size[0]*self.factor),
int(size[1]*self.factor)))
self.walking_frames_l.append(bigger_img)
# set starting player image
self.image = self.walking_frames_r[0]
# set reference to image rect
# spawn location:
self.rect = self.image.get_rect(x = 200, y = 200)
self.x_vel = 0
self.y_vel = 0
self.blockers = blockers
