def __init__(self, screen, settings):
pac_ss = spritesheet.SpriteSheet('/images/pacman.png')
# pac_imgs = []
# pac_imgs = [pac_ss.images_at((0, 0, 32, 32), (33, 0, 32, 32), (65, 0, 32, 32), (97, 0, 32, 32),
# (129, 0, 32, 32), (161, 0, 32, 32), (193, 0, 32, 32), (225, 0, 32, 32),
# (257, 0, 32, 32), (389, 0, 32, 32), (321, 0, 32, 32), (353, 0, 32, 32),
# (0, 33, 32, 32), (33, 33, 32, 32), (65, 33, 32, 32), (97, 33, 32, 32),
# (129, 33, 32, 32), (161, 33, 32, 32), (193, 33, 32, 32), (225, 33, 32, 32),
# (257, 33, 32, 32), (389, 33, 32, 32), (321, 33, 32, 32), (353, 33, 32, 32),
# colorkey=(255, 255, 255))]
self.pac_left = [
pac_ss.images_at(
((0, 33, 32, 32), (33, 33, 32, 32), (65, 33, 32, 32),
(97, 33, 32, 32), (129, 33, 32, 32), (161, 33, 32, 32),
(193, 33, 32, 32), (225, 33, 32, 32), (257, 33, 32, 32)))
]
self.pac_down = [
pac_ss.images_at(
((0, 0, 32, 32), (33, 0, 32, 32), (65, 0, 32, 32),
(97, 0, 32, 32), (129, 0, 32, 32), (161, 0, 32, 32),
(193, 0, 32, 32), (225, 0, 32, 32), (257, 0, 32, 32)))
]
self.pac_right = [pygame.transform.flip(self.pac_left, True, False)]
self.pac_up = [pygame.transform.flip(self.pac_down, False, True)]
ghost_ss = spritesheet.SpriteSheet('/images/ghosts.png')
blinky = [ghost_ss.images_at(((0, 0, 32, 32), (0, 0, 32, 32)))]
pinky = []
inky = []
clyde = []
def __init__(self,
filename,
rect,
count,
colorkey=None,
loop=False,
frames=1):
"""construct a SpriteStripAnim
filename, rect, count, and colorkey are the same arguments used
by spritesheet.load_strip.
loop is a boolean that, when True, causes the next() method to
loop. If False, the terminal case raises StopIteration.
frames is the number of ticks to return the same image before
the iterator advances to the next image.
"""
self.filename = filename
ss = spritesheet.SpriteSheet(filename)
self.images = ss.load_strip(rect, count, colorkey)
self.i = 0
self.loop = loop
self.frames = frames
self.f = frames
def __init__(self, guard):
# Constructor
pygame.sprite.Sprite.__init__(self)
# Load the image
self.sprite_sheet = spritesheet.SpriteSheet("resources/arms.png")
self.arm_right = self.sprite_sheet.get_image(0, 0, 28, 12)
self.arm_left = self.sprite_sheet.get_image(0, 12, 28, 12)
self.image = self.arm_right
self.guard = guard
# Set a reference to the images rectangle
self.rect = self.image.get_rect()
self.rect.x = self.guard.rect.x + self.guard.rect.width / 4
self.rect.y = self.guard.rect.y + self.guard.rect.height / 4
self.start_x = self.rect.x
self.start_y = self.rect.y
self.degrees = 0
self.counter = random.randrange(85, 115)
# Sounds the guard makes
self.gunshot_sound = self.guard.level.sound_engine.gunshot_sound
self.shell_sound = self.guard.level.sound_engine.shell_sound
self.shell_sound.set_volume(0.5)
self.drop_delay = 0
self.played_dropped = True
def __init__(self, sprite_sheet_data, x, y, layer=1):
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
self.sprite_sheet = spritesheet.SpriteSheet("resources/terrain.png")
self.images = []
# Take the image for each frame from the spritesheet
# And add it to the list of frames
for sprite in sprite_sheet_data:
new_image = self.sprite_sheet.get_image(sprite[0], sprite[1],
sprite[2], sprite[3])
self.images.append(new_image)
self.image = self.images[0]
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.start_x = x
self.start_y = y
# A timer var for animation
self.tick = 0
self.frame = 0
# The layer the tile is in
self.layer = layer
def __init__(self, sprite_sheet, sprite_sheet_data, x, y, command):
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
# Set the sprites images
self.sprite_sheet = spritesheet.SpriteSheet(sprite_sheet)
self.image_inactive = self.sprite_sheet.get_image_srcalpha(
sprite_sheet_data[0][0], sprite_sheet_data[0][1],
sprite_sheet_data[0][2], sprite_sheet_data[0][3])
self.image_active = self.sprite_sheet.get_image_srcalpha(
sprite_sheet_data[1][0], sprite_sheet_data[1][1],
sprite_sheet_data[1][2], sprite_sheet_data[1][3])
self.image = self.image_inactive
# Correct the sprites position
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
# Set the command
self.command = command
def __init__(self, x, y, image, level):
# Constructor
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
# Set the image
sprite_sheet = spritesheet.SpriteSheet("resources/terrain.png")
self.image = sprite_sheet.get_image(image[0], image[1], image[2],
image[3])
# Set the image's rectangle and position
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.start_x = self.rect.x
self.start_y = self.rect.y
# The level the camera is in
self.level = level
# Different sprites the camera interacts with
self.laser = None
self.keypad = None
def __init__(self, sprite_sheet_data, x, y, layer=1):
# Constructor
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
# Load the image
sprite_sheet = spritesheet.SpriteSheet("resources/sky.png")
self.image = sprite_sheet.get_image(sprite_sheet_data[0],
sprite_sheet_data[1],
sprite_sheet_data[2],
sprite_sheet_data[3])
# Set the rectangle and position
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.start_x = x
self.start_y = y
# The layer the tile is in
self.layer = layer
def __init__(self, spriteSheetData):
''' Constructor '''
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
spriteSheet = spritesheet.SpriteSheet("resources/images/terrain.png")
self.images = []
# Take the image for each srite from the spritesheet
# and add it to the list of frames
for sprite in spriteSheetData:
newImage = spriteSheet.get_image(sprite[0], sprite[1], sprite[2],
sprite[3])
self.images.append(newImage)
self.image = self.images[0]
self.rect = self.image.get_rect()
# A timer var for the animation
self.tick = 0
self.costume = 0
def __init__(self,num):
''' Constructor '''
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
self.spriteSheet = spritesheet.SpriteSheet("resources/images/hearts.png")
# Grab the sprites from the spritesheet
image = self.spriteSheet.get_image(0,0,46,40)
self.images.append(image)
image = self.spriteSheet.get_image(46,0,46,40)
self.images.append(image)
image = self.spriteSheet.get_image(92,0,46,40)
self.images.append(image)
self.image = self.images[self.state]
self.rect = self.image.get_rect()
self.id = num
# Set position
self.rect.x = self.id*50+10
self.rect.y = 10
def __init__(self):
''' Constructor '''
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
spriteSheet = spritesheet.SpriteSheet("resources/images/player.png")
# Load the static images
self.standImgR = spriteSheet.get_image(0, 0, 27, 62)
self.jumpImgR = spriteSheet.get_image(113, 0, 30, 69)
self.fallImgR = spriteSheet.get_image(143, 0, 35, 67)
self.attackImgR = spriteSheet.get_image(178, 0, 33, 62)
self.standImgL = pygame.transform.flip(self.standImgR, True, False)
self.jumpImgL = pygame.transform.flip(self.jumpImgR, True, False)
self.fallImgL = pygame.transform.flip(self.fallImgR, True, False)
self.attackImgL = pygame.transform.flip(self.attackImgR, True, False)
# Load all the right-facing images into the list
image = spriteSheet.get_image(0, 0, 27, 62)
self.walkingFramesR.append(image)
image = spriteSheet.get_image(27, 0, 31, 62)
self.walkingFramesR.append(image)
image = spriteSheet.get_image(58, 0, 27, 62)
self.walkingFramesR.append(image)
image = spriteSheet.get_image(85, 0, 28, 62)
self.walkingFramesR.append(image)
# Do the same, but flip them to left
for frame in self.walkingFramesR:
image = pygame.transform.flip(frame, True, False)
self.walkingFramesL.append(image)
# Set the starting image
self.image = self.standImgR
# Set a reference to the image rect
self.rect = self.image.get_rect()
# Load sounds
self.jumpSound = pygame.mixer.Sound("resources/sounds/Jump Sound.wav")
self.deathSound = pygame.mixer.Sound(
"resources/sounds/Death Sound.wav")
self.attackSound = pygame.mixer.Sound(
"resources/sounds/Attack Sound.wav")
self.jumpSound.set_volume(0.25)
self.deathSound.set_volume(0.25)
self.attackSound.set_volume(0.25)
# Initiate the hearts
self.heartList = pygame.sprite.Group()
for n in range(int(constants.PLAYER_HEALTH / 2)):
newHeart = heart.Heart(n)
newHeart.player = self
self.heartList.add(newHeart)
def __init__(self, screen, pacman, scoreboard):
super().__init__()
self.screen = screen
self.screen_rect = screen.get_rect()
self.pacman = pacman
self.chase = False
self.portal = False
self.active = True
self.wait = 720
self.scoreboard = scoreboard
self.move_speed = 1
ss = spritesheet.SpriteSheet('images/sheet.png')
self.rimages = []
self.rimages = ss.images_at(((457, 81, 13, 14), (473, 81, 13, 14)),
colorkey=(0, 0, 0))
self.limages = []
self.limages = ss.images_at(((489, 81, 13, 14), (505, 81, 13, 14)),
colorkey=(0, 0, 0))
self.uimages = []
self.uimages = ss.images_at(((521, 81, 13, 14), (521, 81, 13, 14)),
colorkey=(0, 0, 0))
self.dimages = []
self.dimages = ss.images_at((
(553, 81, 13, 14),
(569, 81, 13, 14),
),
colorkey=(0, 0, 0))
self.bimages = []
self.bimages = ss.images_at(((585, 65, 13, 14), (601, 65, 13, 14)),
colorkey=(0, 0, 0))
self.bwimages = []
self.bwimages = ss.images_at(((585, 65, 13, 14), (633, 65, 13, 14),
(601, 65, 13, 14), (617, 65, 13, 14)),
colorkey=(0, 0, 0))
self.image = pygame.transform.scale(self.uimages[0], (13 * 3, 13 * 3))
self.rect = self.image.get_rect()
self.index = 0
self.image_speed = 30
self.rect.centery = 28.5 * 13
self.rect.centerx = 31.5 * 13
self.centerx = self.rect.centerx
self.centery = self.rect.centery
self.pghost = (self.rect.centerx, self.rect.centery)
self.font = pygame.font.Font(None, 28)
self.ptext = self.font.render(str(self.pacman.ghost_score * 200), 1,
(255, 255, 255))
if random.randint(0, 1) == 0:
self.direction = "right"
else:
self.direction = "left"
self.next_move = "none"
def createExplosion(image, speed, col, row, onSprite):
explosionSound.play()
aExplosion = sh.SpriteSheet(image, speed, col, row, True)
diffCenterX = aExplosion.centerX - onSprite.centerX
diffCenterY = aExplosion.centerY - onSprite.centerY
posCentered = [
onSprite.pos[0] - diffCenterX, onSprite.pos[1] - diffCenterX
]
aExplosion.pos = [posCentered[0], posCentered[1]]
aExplosion.vel = [onSprite.vel[0], onSprite.vel[1]]
return aExplosion
def __init__(self, x, y):
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
self.sprite_sheet = spritesheet.SpriteSheet("resources/guard.png")
# Get the standing images
self.stand_image_r = self.sprite_sheet.get_image_srcalpha(0, 0, 24, 48)
self.stand_image_l = pygame.transform.flip(self.stand_image_r, True,
False)
# Arrays for animation
self.walking_frames_r = []
self.walking_frames_l = []
# Load the images
image = self.sprite_sheet.get_image(0, 0, 24, 48)
self.walking_frames_r.append(image)
image = self.sprite_sheet.get_image(24, 0, 25, 48)
self.walking_frames_r.append(image)
image = self.sprite_sheet.get_image(48, 0, 24, 48)
self.walking_frames_r.append(image)
image = self.sprite_sheet.get_image(72, 0, 24, 48)
self.walking_frames_r.append(image)
# Flip them
for image in self.walking_frames_r:
self.walking_frames_l.append(
pygame.transform.flip(image, True, False))
# Set the starting image and rect
self.image = self.stand_image_r
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.start_x = x
self.start_y = y
self.torch = torches.Torch()
self.torch.guard = self
self.torch.start_x = self.start_x + self.rect.width / 2
self.torch.start_y = self.start_y + self.rect.height / 2
# Var for animation
self.walk_dist = 0
def __init__(self):
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
# Load all of the images
self.sprite_sheet = spritesheet.SpriteSheet("resources/healthbar.png")
self.images = []
image = self.sprite_sheet.get_image(0, 0, 32, 16)
self.images.append(image)
image = self.sprite_sheet.get_image(0, 16, 32, 16)
self.images.append(image)
image = self.sprite_sheet.get_image(0, 32, 32, 16)
self.images.append(image)
image = self.sprite_sheet.get_image(0, 48, 32, 16)
self.images.append(image)
image = self.sprite_sheet.get_image(0, 64, 32, 16)
self.images.append(image)
image = self.sprite_sheet.get_image(0, 80, 32, 16)
self.images.append(image)
image = self.sprite_sheet.get_image(32, 0, 32, 16)
self.images.append(image)
image = self.sprite_sheet.get_image(32, 16, 32, 16)
self.images.append(image)
image = self.sprite_sheet.get_image(32, 32, 32, 16)
self.images.append(image)
image = self.sprite_sheet.get_image(32, 48, 32, 16)
self.images.append(image)
image = self.sprite_sheet.get_image(32, 64, 32, 16)
self.images.append(image)
self.image = self.images[0]
self.rect = self.image.get_rect()
self.start_x = None
self.start_y = None
self.timer = 30
def __init__(self, spriteSheetData):
''' Platform contructor '''
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
spriteSheet = spritesheet.SpriteSheet("resources/images/terrain.png")
# Take the image from the spritesheet
self.image = spriteSheet.get_image(spriteSheetData[0],
spriteSheetData[1],
spriteSheetData[2],
spriteSheetData[3])
self.rect = self.image.get_rect()
def __init__(self):
''' Constructor '''
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
# Load the images
self.spriteSheet = spritesheet.SpriteSheet(
"resources/images/blob2.png")
# Grab the sprites
self.imageR = self.spriteSheet.get_image(0, 0, 43, 33)
self.imageL = pygame.transform.flip(self.imageR, True, False)
self.image = self.imageR
self.rect = self.image.get_rect()
def __init__(self):
super().__init__()
self.image = pygame.Surface([75, 75])
self.image.fill((255, 255, 255))
self.image.set_colorkey(WHITE)
#self.innerbounds = [self.x + 10, self.y + 10, self.x+width-10, self.y+height-10]
#self.trees_sprites = pygame.image.load("tree.png")
sprite_sheet = spritesheet.SpriteSheet("tree.png")
self.image = sprite_sheet.get_image(TREE1[0], TREE1[1], TREE1[2],
TREE1[3])
self.image = pygame.transform.scale(self.image, (height, width))
#pygame.draw.rect(self.image, (255,255,0), [0, 0, 50, 50])
self.rect = self.image.get_rect()
def __init__(self, x, y, width, height):
''' Constructor '''
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
# Load the image
self.spriteSheet = spritesheet.SpriteSheet("resources/images/buttons.png")
self.regImg = self.spriteSheet.get_image(x,y,width,height)
self.hoverImg = self.spriteSheet.get_image(x,y+height,width,height)
self.pressImg = self.spriteSheet.get_image(x,y+(height*2),width,height)
self.image = self.regImg
self.rect = self.image.get_rect()
def __init__(self):
# Constructor
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
# Set the image
sprite_sheet = spritesheet.SpriteSheet("resources/crosshair.png")
self.image = sprite_sheet.get_image(0, 0, 24, 24)
# Set the rectangle
self.rect = self.image.get_rect()
# This is where the mouse is at
self.mouse_x = 0
self.mouse_y = 0
def __init__(self, screen, scoreboard, game):
super().__init__()
self.screen = screen
self.screen_rect = screen.get_rect()
self.scoreboard = scoreboard
self.game = game
ss = spritesheet.SpriteSheet('images/sheet.png')
self.rimages = []
self.rimages = ss.images_at(((457, 1, 13, 13), (473, 1, 13, 13), (489, 1, 14, 14), (473, 1, 13, 13)),
colorkey=(0, 0, 0))
self.limages = []
self.limages = ss.images_at(((461, 17, 13, 13), (474, 17, 13, 13), (489, 1, 14, 14), (474, 17, 13, 13)),
colorkey=(0, 0, 0))
self.uimages = []
self.uimages = ss.images_at(((457, 36, 13, 13), (473, 34, 13, 13), (489, 1, 14, 14), (473, 34, 13, 13)),
colorkey=(0, 0, 0))
self.dimages = []
self.dimages = ss.images_at(((457, 49, 13, 13), (473, 49, 13, 13), (489, 1, 14, 14), (473, 49, 13, 13)),
colorkey=(0, 0, 0))
self.ripimages = []
self.ripimages = ss.images_at(((505, 1, 13, 13), (520, 1, 13, 13), (536, 1, 13, 13), (552, 1, 13, 13),
(568, 2, 13, 13), (584, 3, 13, 13),
(601, 4, 13, 13), (616, 4, 13, 13),
(631, 4, 13, 13), (649, 4, 13, 13), (666, 6, 13, 13)), colorkey=(0, 0, 0))
self.image = pygame.transform.scale(self.limages[0], (13 * 3, 13 * 3))
self.rect = self.image.get_rect()
self.index = 0
self.alive = True
self.boosted = False
self.boosted_duration = 1440
self.ghost_score = 0
self.image_speed = 30
self.move = True
self.wait = 10 * 60
self.rect.centery = 34.5 * 13
self.rect.centerx = 27.5 * 13
self.centerx = self.rect.centerx
self.centery = self.rect.centery
self.direction = "left"
self.next_move = "none"
def __init__(self, player, tool):
''' Constructor '''
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
# Load images from the sprite sheet
self.spriteSheet = spritesheet.SpriteSheet("resources/images/tools.png")
# Then set the images
self.imageSwordR = self.spriteSheet.get_image(0,0,45,18)
self.imageSwordL = pygame.transform.flip(self.imageSwordR, True, False)
self.imageShieldR = self.spriteSheet.get_image(47,0,25,43)
self.imageShieldL = pygame.transform.flip(self.imageShieldR, True, False)
if tool == "sword":
self.imageR = self.imageSwordR
self.imageL = self.imageSwordL
self.xOff = 14
self.yOff = 40
elif tool == "shield":
self.imageR = self.imageShieldR
self.imageL = self.imageShieldL
self.xOff = 8
self.yOff = 24
self.player = player
if self.player.direction == "R":
self.image = self.imageR
self.rect = self.image.get_rect()
self.rect.topleft = (self.player.rect.x+self.xOff,self.player.rect.y+self.yOff)
else:
self.image = self.imageL
self.rect = self.image.get_rect()
self.rect.topleft = (self.player.rect.x-self.xOff,self.player.rect.y+self.yOff)
def __init__(self):
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
# Set the image
self.sprite_sheet = spritesheet.SpriteSheet("resources/light.png")
self.image_r = self.sprite_sheet.get_image_srcalpha(0, 0, 160, 94)
self.image_l = self.sprite_sheet.get_image_srcalpha(0, 94, 160, 94)
self.image = self.image_r
# Set the position
self.rect = self.image.get_rect()
# Create a hitmask
self.hitmask_r = funcs.create_mask(self.image_r)
self.hitmask_l = funcs.create_mask(self.image_l)
self.hitmask = self.hitmask_r
def __init__(self, x, y, level):
# Constructor
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
# Set the level the keypad is located in
self.level = level
# Get the images for both when the keypad is active and not
self.sprite_sheet = spritesheet.SpriteSheet("resources/keypad.png")
self.image_off = self.sprite_sheet.get_image(0, 0, 12, 14)
self.image_on = self.sprite_sheet.get_image(12, 0, 12, 14)
self.image = self.image_off
# Set the keypads rect and position
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
# Keep track of where it started so when
# we reset the level we know where to put it
self.start_x = x
self.start_y = y
# Set references to the sounds the keypad makes
self.beep_sound = self.level.sound_engine.beep_sound
self.beep_sound.set_volume(0.25)
self.hiss_sound = self.level.sound_engine.hiss_sound
self.hiss_sound.set_volume(0.25)
# So we don't keep on playing the sounds
# this is used to check whether we've not
# played the sound yet.
self.played_sound = False
# How much is required for the keypad to be activated
self.progress = 0
def __init__(self, x, y, level):
# Constructor
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
self.level = level
# Load the image
self.sprite_sheet = spritesheet.SpriteSheet("resources/hguard.png")
self.stand_img_r = self.sprite_sheet.get_image(0, 0, 24, 48)
self.stand_img_l = pygame.transform.flip(self.stand_img_r, True, False)
self.walking_frames_r = []
self.walking_frames_l = []
image = self.sprite_sheet.get_image(0, 0, 24, 48)
self.walking_frames_r.append(image)
image = self.sprite_sheet.get_image(24, 0, 24, 48)
self.walking_frames_r.append(image)
image = self.sprite_sheet.get_image(48, 0, 24, 48)
self.walking_frames_r.append(image)
image = self.sprite_sheet.get_image(72, 0, 24, 48)
self.walking_frames_r.append(image)
for frame in self.walking_frames_r:
image = pygame.transform.flip(frame, True, False)
self.walking_frames_l.append(image)
self.image = self.stand_img_r
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.start_x = x
self.start_y = y
self.arm = guard_parts.Arm(self)
def __init__(self, namesurf, surf):
"""Classe per il campo"""
self.surf = spritesheet.SpriteSheet(surf, 'file')
# Prendo le misure dell'immagine
size = surf.get_size()
self.square_size = 30
# Calcolo il numero di righe e di colonne
self.raws = range(int(size[1] / self.square_size))
self.columns = range(int(size[0] / self.square_size))
# Calcolo i colori dominanti attravero un algoritmo
# chiamato "k-means clustering"
self.color = clustering.Kmeans(5).run(namesurf)
self.color.sort(key=lambda x: sum(x))
self.color = self.color[::-1]
self.back, self.cflags, self.lines, self.cmine, self.numbers = self.color
def __init__(self, guard):
# Constructor
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
# Set an attribute referencing the guard
self.guard = guard
# Load the image
sprite_sheet = spritesheet.SpriteSheet("resources/exclamation.png")
self.image = sprite_sheet.get_image_srcalpha(0, 0, 29, 43)
# Set the rect and position
self.rect = self.image.get_rect()
self.rect.centerx = self.guard.rect.centerx
self.rect.y = self.guard.rect.y - 36
self.start_x = self.rect.x
self.start_y = self.rect.y
def __init__(self, sprite_sheet_data, x, y, layer=1):
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
sprite_sheet = spritesheet.SpriteSheet("resources/terrain.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()
self.rect.x = x
self.rect.y = y
self.start_x = x
self.start_y = y
# The layer the tile is in
self.layer = layer
def __init__(self):
''' Imp Constructor '''
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
self.spriteSheet = spritesheet.SpriteSheet("resources/images/Imp.png")
# Load the images
image = self.spriteSheet.get_image(0,0,37,70)
self.walkingFramesR.append(image)
self.imageR = image
self.imageL = pygame.transform.flip(image, True, False)
image = self.spriteSheet.get_image(37,0,37,70)
self.walkingFramesR.append(image)
image = self.spriteSheet.get_image(74,0,40,70)
self.walkingFramesR.append(image)
image = self.spriteSheet.get_image(114,0,41,70)
self.walkingFramesR.append(image)
image = self.spriteSheet.get_image(155,0,41,70)
self.walkingFramesR.append(image)
image = self.spriteSheet.get_image(196,0,41,70)
self.walkingFramesR.append(image)
image = self.spriteSheet.get_image(237,0,40,70)
self.walkingFramesR.append(image)
image = self.spriteSheet.get_image(277,0,46,70)
self.walkingFramesR.append(image)
image = self.spriteSheet.get_image(323,0,37,70)
self.walkingFramesR.append(image)
image = self.spriteSheet.get_image(360,0,37,70)
for frame in self.walkingFramesR:
image = pygame.transform.flip(frame, True, False)
self.walkingFramesL.append(image)
self.image = self.imageR
self.rect = self.image.get_rect()
def __init__(self, x, y, level):
# Constructor
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
# Set a reference to the level
self.level = level
# Load and set the sprites images
self.sprite_sheet = spritesheet.SpriteSheet("resources/bomb.png")
self.image_off = self.sprite_sheet.get_image(0, 0, 24, 24)
self.image_on = self.sprite_sheet.get_image(24, 0, 24, 24)
self.image = self.image_off
# Set the rectangle, position and start position
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.start_x = x
self.start_y = y
# A beep sound to be played when the bomb is activated
self.beep_sound = self.level.sound_engine.beep_sound
self.played_sound = False
# How much is required for the bomb to be activated
self.progress = 0
# Bools to control the state of the bomb
self.placed = False
self.has_placed = False
def __init__(self, player, small):
# Call the parents constructor
pygame.sprite.Sprite.__init__(self)
self.middle = 360 if small else 480
# Load all of the components
sprite_sheet = spritesheet.SpriteSheet("resources/hud_bar.png")
self.image = sprite_sheet.get_image(0, 0, 480, 48)
self.rect = self.image.get_rect()
self.rect.centerx = self.middle
self.rect.y = 672
self.health_label = Label("Health:", 28, self.middle - 232, 680)
self.stamina_label = Label("Stamina:", 28, self.middle + 8, 680)
self.health_num = Label("100%", 28, self.middle - 112, 680)
self.stamina_num = Label("100%", 28, self.middle + 128, 680)
self.player = player
self.y_pos = 492 if small else 672
