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()
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):
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):
super().__init__()
sprite_sheet = SpriteSheet("slime.png")
scale = 5
# Load right facing images
image = sprite_sheet.get_image(0,0,32,24, scale)
self.r_walking_frames.append(image)
image = sprite_sheet.get_image(32,0,32,24, scale)
self.r_walking_frames.append(image)
image = sprite_sheet.get_image(64,0,32,24, scale)
self.r_walking_frames.append(image)
image = sprite_sheet.get_image(96,0,32,24, scale)
self.r_walking_frames.append(image)
image = sprite_sheet.get_image(128,0,32,24, scale)
self.r_walking_frames.append(image)
# Load right facing images, then flip
# to face left.
image = sprite_sheet.get_image(0,0,32,24,scale)
image = pygame.transform.flip(image, True, False)
self.l_walking_frames.append(image)
image = sprite_sheet.get_image(32,0,32,24,scale)
image = pygame.transform.flip(image, True, False)
self.l_walking_frames.append(image)
image = sprite_sheet.get_image(64,0,32,24,scale)
image = pygame.transform.flip(image, True, False)
self.l_walking_frames.append(image)
image = sprite_sheet.get_image(96,0,32,24,scale)
image = pygame.transform.flip(image, True, False)
self.l_walking_frames.append(image)
image = sprite_sheet.get_image(128,0,32,24,scale)
image = pygame.transform.flip(image, True, False)
self.l_walking_frames.append(image)
# Set the image the player starts with
self.image = self.r_walking_frames[0]
# Set rect
self.rect = self.image.get_rect()
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
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 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 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):
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):
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):
""" 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 __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, 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
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):
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, 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("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): 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, 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, 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()
class Player(pg.sprite.Sprite):
def __init__(self, x, y, blockers):
super(Player, self).__init__()
self.sheet = SpriteSheet('p1_walk.png')
self.image = self.sheet.get_image(4, 2, 17, 21)
self.image.set_colorkey(c.SPRITESHEET_BACKGROUND)
self.rect = self.image.get_rect(x=x, y=y)
self.x_vel = 0
self.y_vel = 0
self.blockers = blockers
self.grav = 0.4
self.fall = False
self.speed = c.PLAYER_SPEED
def physics_update(self):
"""If player is falling, add gravity to the current y velocity."""
if self.fall:
self.y_vel += self.grav
else:
self.y_vel = 0
def update(self, keys):
"""
Set player velocity by keys, move by velocity, check
for collision. It's important to check collisions
for both on the x-axis and y-axis, rather than just once.
"""
self.x_vel = 0
if keys[pg.K_LEFT]:
self.x_vel -= self.speed
elif keys[pg.K_RIGHT]:
self.x_vel += self.speed
else:
self.x_vel = 0
self.rect.x += self.x_vel
for blocker in self.blockers:
if self.rect.colliderect(blocker):
self.rect.x -= self.x_vel
self.x_vel = 0
self.rect.y += self.y_vel
for blocker in self.blockers:
if self.rect.colliderect(blocker):
self.rect.y -= self.y_vel
self.y_vel = 0
def draw(self, surface):
"""
Blit player image to screen.
"""
surface.blit(self.image, self.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):
""" 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):
""" 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 load_sprite(self, file):
# Load Movement sprites right side
sprite_sheet = SpriteSheet(file)
image = sprite_sheet.get_image(0, 0, 120, 165)
image = pygame.transform.scale(image, (64, 88))
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(125, 0, 120, 165)
image = pygame.transform.scale(image, (64, 88))
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(0, 0, 120, 165)
image = pygame.transform.scale(image, (64, 88))
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(250, 0, 120, 165)
image = pygame.transform.scale(image, (64, 88))
self.walking_frames_r.append(image)
# Load Movement Sprites Left side
image = sprite_sheet.get_image(0, 0, 120, 165)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale(image, (64, 88))
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(125, 0, 120, 165)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale(image, (64, 88))
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(0, 0, 120, 165)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale(image, (64, 88))
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(250, 0, 120, 165)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale(image, (64, 88))
self.walking_frames_l.append(image)
# Load jumping sprite
image = sprite_sheet.get_image(375, 0, 120, 165)
image = pygame.transform.scale(image, (64, 88))
self.jumping_frames_r.append(image)
self.jumping_frames_r.append(image)
image = pygame.transform.flip(image, True, False)
self.jumping_frames_l.append(image)
self.jumping_frames_l.append(image)
def __init__(self, ai_settings, screen):
"""Initialize the alien, and set its starting position."""
super(Pinky, self).__init__()
self.screen = screen
self.ai_settings = ai_settings
self.frame = 0
self.redr = []
self.redl = []
self.redu = []
self.redd = []
self.redblue = []
# Load the alien image, and set its rect attribute.
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(160, 128, 32, 32)
self.redr.append(image)
image = sprite_sheet.get_image(160, 160, 32, 32)
self.redr.append(image)
image = sprite_sheet.get_image(160, 128, 32, 32)
image = pygame.transform.flip(image, 1, 0)
self.redl.append(image)
image = sprite_sheet.get_image(160, 160, 32, 32)
image = pygame.transform.flip(image, 1, 0)
self.redl.append(image)
image = sprite_sheet.get_image(160, 192, 32, 32)
self.redu.append(image)
image = sprite_sheet.get_image(160, 224, 32, 32)
self.redu.append(image)
image = sprite_sheet.get_image(64, 224, 32, 32)
image = pygame.transform.rotate(image, 90)
self.redblue.append(image)
image = sprite_sheet.get_image(96, 224, 32, 32)
image = pygame.transform.rotate(image, 90)
self.redblue.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(192, 0, 32, 32)
self.redd.append(image)
image = sprite_sheet.get_image(192, 32, 32, 32)
self.redd.append(image)
self.image = self.redr[0]
self.rect = self.image.get_rect()
# Start each new alien near the top left of the screen.
self.rect.x = self.rect.width
self.rect.y = self.rect.height
self.rect.centery = 250
self.rect.centerx = 300
self.centery = self.rect.centery
self.centerx = self.rect.centerx
# Store the alien's exact position.
self.x = float(self.rect.x)
self.moving_right = False
self.moving_left = False
self.moving_up = True
self.moving_down = False
self.lastmove = 5
def __init__(self):
""" Constructor function """
# Call the parent's constructor
super().__init__()
# -- Attributes
# set scores for player
self.scores = 0
# set kills for player
self.kills = 0
# set health number for player
self.health_number = 100
# set restore health percentage
self.give_health = 20
# set damage for enemy
self.general_enemy_dmg = 20
self.special_enemy_dmg = 40
self.false_point_dmg = 40
# Set speed vector of player
self.change_x = 0
self.change_y = 0
# This holds all the images for the animated walk left/right
# of our player
self.walking_frames_l = []
self.walking_frames_r = []
# What direction is the player facing?
self.direction = "R"
# removing special enemy
# FOR LEVEL 11
# Vocal W
self.special_remove_WA = None
self.special_remove_WO = None
# Vocal N
self.special_remove_N = None
# List of sprites we can bump against
self.level = None
sprite_sheet = SpriteSheet("spritesheet/player.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(10, 7, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(85, 7, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(160, 7, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(10, 106, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(85, 106, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(160, 106, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(10, 208, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(85, 208, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(160, 208, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(10, 305, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(85, 305, 66, 90)
self.walking_frames_r.append(image)
# Load all the right facing images, then flip them
# to face left.
image = sprite_sheet.get_image(10, 7, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(85, 7, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(160, 7, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(10, 106, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(85, 106, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(160, 106, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(10, 208, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(85, 208, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(160, 208, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(10, 305, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(85, 305, 66, 90)
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 reference to the image rect.
self.rect = self.image.get_rect()
def __init__(self):
""" Constructor function """
# Call the parent constructor
super().__init__()
sprite_sheet = SpriteSheet("p1_walk.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(0, 0, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(66, 0, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(132, 0, 67, 90)
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 and 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)
#set the image the 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):
#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('link_sprite.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(23, 99, 41, 69)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(113, 102, 38, 66)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(205, 106, 40, 59)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(299, 102, 35, 65)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(390, 106, 32, 61)
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(23, 99, 41, 69)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(113, 102, 38, 66)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(205, 106, 40, 59)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(299, 102, 35, 65)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(390, 106, 32, 61)
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()
# -- Weapon & Shield init
self.shield = 100
self.shoot_delay = 250
self.last_shot = pygame.time.get_ticks()
self.lives = 3
self.hidden = False
self.hide_timer = pygame.time.get_ticks()
def __init__(self, sprite_sheet_walking):
"""Constructor, pass in the sprite sheet of the walking animation"""
# call the parent class Sprite Constructor
super().__init__()
# Lists to hold our walking and jumping animations
self.walking = False
self.frame = 0
self.walking_frames_r = []
self.walking_frames_l = []
self.walking_direction = "r"
# Load in all images to create Animation
# - Walking Right
sprite_sheet = SpriteSheet(sprite_sheet_walking)
image = sprite_sheet.get_image(0, 0, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(66, 0, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(132, 0, 66, 90)
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, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(0, 186, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(66, 186, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(132, 186, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(0, 280, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(67, 280, 66, 90)
self.walking_frames_r.append(image)
# - Walking 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, 66, 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, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(0, 186, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(66, 186, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(132, 186, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(0, 280, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(67, 280, 66, 90)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
self.image = self.walking_frames_r[0]
# Fetch the rectangular object that has the dimensions of the image.
# Update the position of this object by setting the values
# of rect.x and rect.y
self.rect = self.image.get_rect()
# starting location
self.rect.x = 0
self.rect.y = constants.SCREEN_HEIGHT - self.rect.height
# set inital velocity to O - or not moving
self.velocity = 0
def __init__(self):
""" Constructor function """
# Call the parent's constructor
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet(
os.path.join("ressources", "images", "player", "sprite-sheet.png"))
# Load all the idle images right
image = sprite_sheet.get_image(0, 0, 50, 37)
self.idle_frames_r.append(image)
image = sprite_sheet.get_image(50, 0, 50, 37)
self.idle_frames_r.append(image)
image = sprite_sheet.get_image(100, 0, 50, 37)
self.idle_frames_r.append(image)
image = sprite_sheet.get_image(150, 0, 50, 37)
self.idle_frames_r.append(image)
image = sprite_sheet.get_image(0, 0, 50, 37)
self.idle_frames_r.append(image)
image = sprite_sheet.get_image(50, 0, 50, 37)
self.idle_frames_r.append(image)
image = sprite_sheet.get_image(100, 0, 50, 37)
self.idle_frames_r.append(image)
image = sprite_sheet.get_image(150, 0, 50, 37)
self.idle_frames_r.append(image)
# Load all the idle images left
image = sprite_sheet.get_image(0, 0, 50, 37)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
image = sprite_sheet.get_image(50, 0, 50, 37)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
image = sprite_sheet.get_image(100, 0, 50, 37)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
image = sprite_sheet.get_image(150, 0, 50, 37)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
image = sprite_sheet.get_image(0, 0, 50, 37)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
image = sprite_sheet.get_image(50, 0, 50, 37)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
image = sprite_sheet.get_image(100, 0, 50, 37)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
image = sprite_sheet.get_image(150, 0, 50, 37)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
# Load all the right facing images
image = sprite_sheet.get_image(0, 37, 50, 37)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(50, 37, 50, 37)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(100, 37, 50, 37)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(150, 37, 50, 37)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(200, 37, 50, 37)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(250, 37, 50, 37)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(300, 37, 50, 37)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(350, 37, 50, 37)
self.walking_frames_r.append(image)
# Load all the right facing images, then flip them to face left.
image = sprite_sheet.get_image(0, 37, 50, 37)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(50, 37, 50, 37)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(100, 37, 50, 37)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(150, 37, 50, 37)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(200, 37, 50, 37)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(250, 37, 50, 37)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(300, 37, 50, 37)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(350, 37, 50, 37)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
"""for i in range(8):
self.idle_frames_l[i].scroll(-16,-5)
self.idle_frames_r[i].scroll(-16,-5)
self.walking_frames_l[i].scroll(-16,-5)
self.walking_frames_r[i].scroll(-16,-5)"""
# 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() #rect size: 50,37
#self.rect.size = (20,30)
self.diff_x = 15
self.diff_y = 3
self.hitbox = Hitbox(20, 31, self.rect.x + self.diff_x,
self.rect.y + self.diff_y)
#self.hitbox_rect = pygame.Rect(self.rect.x+self.diff_x,self.rect.y+self.diff_y,20,31) #difference: 15,3
self.hitbox_rect = self.hitbox.get_rect()
def __init__(self):
""" Fonction initial (constructeur) """
# Appelle le parent constructeur
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet("data/decoupage_orange.png")
#Standing
image = sprite_sheet.get_image(0, 0, 135, 135)
self.standing_frame.append(image)
#Standing_l
image = sprite_sheet.get_image(0, 0, 135, 135)
image = pygame.transform.flip(image, True, False)
self.standing_frame_l.append(image)
# Charge toutes les images à droite
image = sprite_sheet.get_image(135, 0, 135, 135)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(270, 0, 135, 135)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(405, 0, 135, 135)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(540, 0, 135, 135)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(675, 0, 135, 135)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(810, 0, 135, 135)
self.walking_frames_r.append(image)
# Load all the right facing images, then flip them
image = sprite_sheet.get_image(135, 0, 135, 135)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(270, 0, 135, 135)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(405, 0, 135, 135)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(540, 0, 135, 135)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(675, 0, 135, 135)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(810, 0, 135, 135)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
#Jumping
image = sprite_sheet.get_image(945, 0, 135, 135)
self.jumping_frame.append(image)
#Jumping_l
image = sprite_sheet.get_image(945, 0, 135, 135)
image = pygame.transform.flip(image, True, False)
self.jumping_frame_l.append(image)
# Defini l'image avec laquelle on démarre
self.image = self.standing_frame[0]
# reference à image rect
self.rect = self.image.get_rect()
def init_game(self):
sprite_sheet = SpriteSheet("tiles_spritesheet.png")
banan_sheet = SpriteSheet("Banan.png")
self.paddle_sprt = sprite_sheet.get_image(648, 648, 70, 40)
self.ball_sprt = banan_sheet.get_image(0, 0, 32, 32)
self.fireball_sprt = banan_sheet.get_image(0, 32, 32, 32)
self.fireball_aftersprt = banan_sheet.get_image(0, 64, 32, 32)
pygame.display.set_caption(self.caption_text)
#set lives state and score
self.fps = 50
self.lives = 3
self.score = 0
self.state = STATE_BALL_IN_PADDLE
self.double_chance = .0
self.power_chance = .2
self.start_message = ""
self.ball_speed = BALL_SPEED
self.max_paddle_x = MAX_PADDLE_X
self.start_total_time = 9999999
#create paddle, ball, collision object
self.paddle = pygame.Rect(300, PADDLE_Y, PADDLE_WIDTH, PADDLE_HEIGHT)
self.ball = pygame.Rect(300, PADDLE_Y - BALL_DIAMETER, BALL_DIAMETER,
BALL_DIAMETER)
#Create banner to be behind text for readability
self.banner = pygame.Rect(0, SCREEN_SIZE[1] / 2 - BANNER_HEIGHT / 2,
SCREEN_SIZE[0], BANNER_HEIGHT)
#Create sprites
self.paddle_image = pygame.transform.scale(
self.paddle_sprt, (self.paddle.width, self.paddle.height))
self.ball_image = pygame.transform.scale(
self.ball_sprt, (self.ball.width, self.ball.height))
self.fireball_image = pygame.transform.scale(
self.fireball_sprt, (self.ball.width, self.ball.height))
self.fireball_afterimage = pygame.transform.scale(
self.fireball_aftersprt, (self.ball.width, self.ball.height))
#Set starting angle, velocity, and setup powerups
theta = random.random() * math.pi * (90.) / 180. + math.pi * 45. / 180.
self.ball_vel = [
self.ball_speed * math.cos(theta),
self.ball_speed * -math.sin(theta)
]
self.ball_left = float(
self.ball.left) #save float versions of ball location
self.ball_top = float(
self.ball.top) #save float versions of ball location
self.ball_vel_orig = [
self.ball_speed * math.cos(theta),
self.ball_speed * -math.sin(theta)
] #Save initial velocity
self.pows = [] #list of PowerUp instances
self.powtypes = [
'fire', 'grow', 'shrink', 'airbounce', 'speedup', 'slowdown'
] # list of powerup types
self.powdict = {
'fire': FIREBLAZE,
'grow': GROW,
'shrink': SHRINK,
'airbounce': AIRBOUNCE,
'speedup': SPEEDUP,
'slowdown': SLOWDOWN
} #Dictionary for powerups their shape and their colors
self.totfiretime = 5 * self.fps #50 frames a second, so 5 seconds
self.totgrowtime = 8 * self.fps #8 seconds
self.totshrinktime = 8 * self.fps #8 seconds
self.totspeeduptime = 7 * self.fps #7 seconds
self.totslowdowntime = 7 * self.fps #7 seconds
self.create_bricks() #Run create_bricks method
# initialize screen
screenx = 800
screeny = 700
screen = pygame.display.set_mode((screenx, screeny))
bgcolor = (100, 20, 20)
gamearea = pygame.Surface((520, 680))
gacolor = (150, 200, 250)
# initialize fps
clock = pygame.time.Clock()
# initialize enemy sprite
sprite_sheet = SpriteSheet("ghost.png")
enemy_sprite = sprite_sheet.get_image(0, 0, 40, 40)
# initializes stage, player
stage = stages.Stage_01(gamearea)
reisen = Player(gamearea)
# allocate an array of enemies
# enemies = []
# allocate arrays of player and enemy bullets
player_bullets = []
enemy_bullets = []
# initalize bullet firing cooldown
cd = 0
def __init__(self):
super(Player, self).__init__()
self.sword_sound = pygame.mixer.Sound("game/EspadaSonido.wav")
self.shuriken_sound = pygame.mixer.Sound("game/shuriken.wav")
# Salud del personaje
self.health = 5
# Cantidad de Shurikens
self.shurikens = 10
# Velocidad del personaje
self.change_x = 0
self.change_y = 0
# Listas de las animaciones del protagonista
self.walking_frames_l = []
self.walking_frames_r = []
self.stopped_frames_l = []
self.stopped_frames_r = []
self.stoppedjumping_frames_l = []
self.stoppedjumping_frames_r = []
self.falling_frames_l = []
self.falling_frames_r = []
self.fall_frames_r = []
self.fall_frames_l = []
self.running_frames_r = []
self.running_frames_l = []
self.crouched_frames_r = []
self.crouched_frames_l = []
self.crouchedwalking_frames_l = []
self.crouchedwalking_frames_r = []
self.attack_frames_l = []
self.attack_frames_r = []
self.attackshuriken_frames_l = []
self.attackshuriken_frames_r = []
self.hurt_frames_r = []
self.hurt_frames_l = []
self.die_frames_l = []
self.die_frames_r = []
# Numero de Frame a mostrar
self.frame=0
# Direccion del personaje
self.direction = "R"
# Accion del personaje
self.action = "S"
# Lista de sprites que podemos impactar
self.level = None
# Lista de shurikens arrojados
self.shuriken_list = pygame.sprite.Group()
# Sprite de ataque
self.attack_list = pygame.sprite.Group()
if isinstance(self, enemy.Enemy):
self.image_file = "game/enemy.png"
else:
self.image_file = "game/ninja.png"
# Cargar hoja de sprites
sprite_sheet = SpriteSheet(self.image_file)
self.spritesheet = sprite_sheet
# Esta muerto?
self.death=False
# Cargar la cara derecha de la accion WALKING
image = sprite_sheet.get_image(1, 76, 37, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(45, 76, 33, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(84, 76, 46, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(132, 76, 41, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(176, 76, 39, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(220, 76, 35, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(260, 76, 42, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(308, 76, 44, 58)
self.walking_frames_r.append(image)
# Cargar la cara izquierda de la accion WALKING
image = sprite_sheet.get_image(1, 76, 37, 58)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(45, 76, 33, 58)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(84, 76, 46, 58)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(132, 76, 41, 58)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(176, 76, 39, 58)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(220, 76, 35, 58)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(260, 76, 42, 58)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(308, 76, 44, 58)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
# Cargar ambas caras de la accion STOPPED
image = sprite_sheet.get_image(3, 3, 29, 61)
self.stopped_frames_r.append(image)
image = sprite_sheet.get_image(3, 3, 29, 61)
image = pygame.transform.flip(image, True, False)
self.stopped_frames_l.append(image)
# Cargar ambas caras de STOPPED JUMPING
image = sprite_sheet.get_image(252,301,39,40)
self.stoppedjumping_frames_r.append(image)
image = sprite_sheet.get_image(300,281,32,60)
self.stoppedjumping_frames_r.append(image)
image = sprite_sheet.get_image(337,281,31,52)
self.stoppedjumping_frames_r.append(image)
image = sprite_sheet.get_image(134,286,39,49)
self.stoppedjumping_frames_r.append(image)
image = sprite_sheet.get_image(374,283,31,39)
self.stoppedjumping_frames_r.append(image)
image = sprite_sheet.get_image(252,301,39,40)
image = pygame.transform.flip(image, True, False)
self.stoppedjumping_frames_l.append(image)
image = sprite_sheet.get_image(300,281,32,60)
image = pygame.transform.flip(image, True, False)
self.stoppedjumping_frames_l.append(image)
image = sprite_sheet.get_image(337,281,31,52)
image = pygame.transform.flip(image, True, False)
self.stoppedjumping_frames_l.append(image)
image = sprite_sheet.get_image(134,286,39,49)
image = pygame.transform.flip(image, True, False)
self.stoppedjumping_frames_l.append(image)
image = sprite_sheet.get_image(374,283,31,39)
image = pygame.transform.flip(image, True, False)
self.stoppedjumping_frames_l.append(image)
# Cargar ambas caras de FALLING
image = sprite_sheet.get_image(3,355,39,40)
self.falling_frames_r.append(image)
image = sprite_sheet.get_image(49,355,40,44)
self.falling_frames_r.append(image)
image = sprite_sheet.get_image(92,357,40,43)
self.falling_frames_r.append(image)
image = sprite_sheet.get_image(135,356,39,47)
self.falling_frames_r.append(image)
image = sprite_sheet.get_image(178,356,39,47)
self.falling_frames_r.append(image)
image = sprite_sheet.get_image(3,355,39,40)
image = pygame.transform.flip(image, True, False)
self.falling_frames_l.append(image)
image = sprite_sheet.get_image(49,355,40,44)
image = pygame.transform.flip(image, True, False)
self.falling_frames_l.append(image)
image = sprite_sheet.get_image(92,357,40,43)
image = pygame.transform.flip(image, True, False)
self.falling_frames_l.append(image)
image = sprite_sheet.get_image(135,356,39,47)
image = pygame.transform.flip(image, True, False)
self.falling_frames_l.append(image)
image = sprite_sheet.get_image(178,356,39,47)
image = pygame.transform.flip(image, True, False)
self.falling_frames_l.append(image)
# Cargar ambas caras de FALL
image = sprite_sheet.get_image(248,353,35,61)
self.fall_frames_r.append(image)
image = sprite_sheet.get_image(288,363,37,51)
self.fall_frames_r.append(image)
image = sprite_sheet.get_image(328,380,32,33)
self.fall_frames_r.append(image)
image = sprite_sheet.get_image(367,376,35,37)
self.fall_frames_r.append(image)
image = sprite_sheet.get_image(248,353,35,61)
image = pygame.transform.flip(image, True, False)
self.fall_frames_l.append(image)
image = sprite_sheet.get_image(288,363,37,51)
image = pygame.transform.flip(image, True, False)
self.fall_frames_l.append(image)
image = sprite_sheet.get_image(328,380,32,33)
image = pygame.transform.flip(image, True, False)
self.fall_frames_l.append(image)
image = sprite_sheet.get_image(367,376,35,37)
image = pygame.transform.flip(image, True, False)
self.fall_frames_l.append(image)
# Cargar ambas caras de RUNNING
image = sprite_sheet.get_image(3,225,60,44)
self.running_frames_r.append(image)
image = sprite_sheet.get_image(69,226,57,45)
self.running_frames_r.append(image)
image = sprite_sheet.get_image(130,226,49,45)
self.running_frames_r.append(image)
image = sprite_sheet.get_image(182,226,61,42)
self.running_frames_r.append(image)
image = sprite_sheet.get_image(247,225,53,45)
self.running_frames_r.append(image)
image = sprite_sheet.get_image(304,226,51,45)
self.running_frames_r.append(image)
image = sprite_sheet.get_image(3,225,60,44)
image = pygame.transform.flip(image, True, False)
self.running_frames_l.append(image)
image = sprite_sheet.get_image(69,226,57,45)
image = pygame.transform.flip(image, True, False)
self.running_frames_l.append(image)
image = sprite_sheet.get_image(130,226,49,45)
image = pygame.transform.flip(image, True, False)
self.running_frames_l.append(image)
image = sprite_sheet.get_image(182,226,61,42)
image = pygame.transform.flip(image, True, False)
self.running_frames_l.append(image)
image = sprite_sheet.get_image(247,225,53,45)
image = pygame.transform.flip(image, True, False)
self.running_frames_l.append(image)
image = sprite_sheet.get_image(304,226,51,45)
image = pygame.transform.flip(image, True, False)
self.running_frames_l.append(image)
# Cargar ambas caras de CROUCHED
image = sprite_sheet.get_image(4,146,26,55)
self.crouched_frames_r.append(image)
image = sprite_sheet.get_image(79,163,34,39)
self.crouched_frames_r.append(image)
image = sprite_sheet.get_image(173,165,29,36)
self.crouched_frames_r.append(image)
image = sprite_sheet.get_image(4,146,26,55)
image = pygame.transform.flip(image, True, False)
self.crouched_frames_l.append(image)
image = sprite_sheet.get_image(79,163,34,39)
image = pygame.transform.flip(image, True, False)
self.crouched_frames_l.append(image)
image = sprite_sheet.get_image(173,165,29,36)
image = pygame.transform.flip(image, True, False)
self.crouched_frames_l.append(image)
# Cargar ambas caras de CROUCHED WALKING
image = sprite_sheet.get_image(269,165,39,37)
self.crouchedwalking_frames_r.append(image)
image = sprite_sheet.get_image(315,166,39,35)
self.crouchedwalking_frames_r.append(image)
image = sprite_sheet.get_image(355,167,35,34)
self.crouchedwalking_frames_r.append(image)
image = sprite_sheet.get_image(392,167,34,34)
self.crouchedwalking_frames_r.append(image)
image = sprite_sheet.get_image(427,168,35,33)
self.crouchedwalking_frames_r.append(image)
image = sprite_sheet.get_image(355,167,35,34)
self.crouchedwalking_frames_r.append(image)
image = sprite_sheet.get_image(315,166,39,35)
self.crouchedwalking_frames_r.append(image)
image = sprite_sheet.get_image(269,165,39,37)
image = pygame.transform.flip(image, True, False)
self.crouchedwalking_frames_l.append(image)
image = sprite_sheet.get_image(315,166,39,35)
image = pygame.transform.flip(image, True, False)
self.crouchedwalking_frames_l.append(image)
image = sprite_sheet.get_image(355,167,35,34)
image = pygame.transform.flip(image, True, False)
self.crouchedwalking_frames_l.append(image)
image = sprite_sheet.get_image(392,167,34,34)
image = pygame.transform.flip(image, True, False)
self.crouchedwalking_frames_l.append(image)
image = sprite_sheet.get_image(427,168,35,33)
image = pygame.transform.flip(image, True, False)
self.crouchedwalking_frames_l.append(image)
image = sprite_sheet.get_image(355,167,35,34)
image = pygame.transform.flip(image, True, False)
self.crouchedwalking_frames_l.append(image)
image = sprite_sheet.get_image(315,166,39,35)
image = pygame.transform.flip(image, True, False)
self.crouchedwalking_frames_l.append(image)
# Cargar ambas caras de ATTACK
image = sprite_sheet.get_image(5,425,58,67)
self.attack_frames_r.append(image)
image = sprite_sheet.get_image(66,426,48,66)
self.attack_frames_r.append(image)
image = sprite_sheet.get_image(114,427,71,65)
self.attack_frames_r.append(image)
image = sprite_sheet.get_image(191,427,68,67)
self.attack_frames_r.append(image)
image = sprite_sheet.get_image(265,451,44,41)
self.attack_frames_r.append(image)
image = sprite_sheet.get_image(5,425,58,67)
image = pygame.transform.flip(image, True, False)
self.attack_frames_l.append(image)
image = sprite_sheet.get_image(66,426,48,66)
image = pygame.transform.flip(image, True, False)
self.attack_frames_l.append(image)
image = sprite_sheet.get_image(114,427,71,65)
image = pygame.transform.flip(image, True, False)
self.attack_frames_l.append(image)
image = sprite_sheet.get_image(191,427,68,67)
image = pygame.transform.flip(image, True, False)
self.attack_frames_l.append(image)
image = sprite_sheet.get_image(265,451,44,41)
image = pygame.transform.flip(image, True, False)
self.attack_frames_l.append(image)
# Cargar ambas caras de ATTACKSHURIKEN
image = sprite_sheet.get_image(8,2437,41,46)
self.attackshuriken_frames_r.append(image)
image = sprite_sheet.get_image(57,2443,61,40)
self.attackshuriken_frames_r.append(image)
image = sprite_sheet.get_image(124,2443,66,40)
self.attackshuriken_frames_r.append(image)
image = sprite_sheet.get_image(214,2443,65,40)
self.attackshuriken_frames_r.append(image)
image = sprite_sheet.get_image(8,2437,41,46)
image = pygame.transform.flip(image, True, False)
self.attackshuriken_frames_l.append(image)
image = sprite_sheet.get_image(57,2443,61,40)
image = pygame.transform.flip(image, True, False)
self.attackshuriken_frames_l.append(image)
image = sprite_sheet.get_image(124,2443,66,40)
image = pygame.transform.flip(image, True, False)
self.attackshuriken_frames_l.append(image)
image = sprite_sheet.get_image(214,2443,65,40)
image = pygame.transform.flip(image, True, False)
self.attackshuriken_frames_l.append(image)
# Cargar ambas caras de HURT
image = sprite_sheet.get_image(134,1062,53,53)
self.hurt_frames_r.append(image)
image = sprite_sheet.get_image(193,1061,43,54)
self.hurt_frames_r.append(image)
image = sprite_sheet.get_image(247,1065,41,50)
self.hurt_frames_r.append(image)
image = sprite_sheet.get_image(134,1062,53,53)
image = pygame.transform.flip(image, True, False)
self.hurt_frames_l.append(image)
image = sprite_sheet.get_image(193,1061,43,54)
image = pygame.transform.flip(image, True, False)
self.hurt_frames_l.append(image)
image = sprite_sheet.get_image(247,1065,41,50)
image = pygame.transform.flip(image, True, False)
self.hurt_frames_l.append(image)
# Cargar ambas caras de DIE
image = sprite_sheet.get_image(266,221,32,55)
self.die_frames_r.append(image)
image = sprite_sheet.get_image(306,1220,30,56)
self.die_frames_r.append(image)
image = sprite_sheet.get_image(344,1233,33,43)
self.die_frames_r.append(image)
image = sprite_sheet.get_image(382,1234,33,42)
self.die_frames_r.append(image)
image = sprite_sheet.get_image(419,1236,27,40)
self.die_frames_r.append(image)
image = sprite_sheet.get_image(493,1238,27,38)
self.die_frames_r.append(image)
image = sprite_sheet.get_image(530,1243,30,33)
self.die_frames_r.append(image)
image = sprite_sheet.get_image(567,1250,38,27)
self.die_frames_r.append(image)
image = sprite_sheet.get_image(609,1260,49,18)
self.die_frames_r.append(image)
image = sprite_sheet.get_image(660,1258,51,20)
self.die_frames_r.append(image)
image = sprite_sheet.get_image(716,1258,50,20)
self.die_frames_r.append(image)
image = sprite_sheet.get_image(771,1261,48,19)
self.die_frames_r.append(image)
image = sprite_sheet.get_image(266,221,32,55)
image = pygame.transform.flip(image, True, False)
self.die_frames_l.append(image)
image = sprite_sheet.get_image(306,1220,30,56)
image = pygame.transform.flip(image, True, False)
self.die_frames_l.append(image)
image = sprite_sheet.get_image(344,1233,33,43)
image = pygame.transform.flip(image, True, False)
self.die_frames_l.append(image)
image = sprite_sheet.get_image(382,1234,33,42)
image = pygame.transform.flip(image, True, False)
self.die_frames_l.append(image)
image = sprite_sheet.get_image(419,1236,27,40)
image = pygame.transform.flip(image, True, False)
self.die_frames_l.append(image)
image = sprite_sheet.get_image(493,1238,27,38)
image = pygame.transform.flip(image, True, False)
self.die_frames_l.append(image)
image = sprite_sheet.get_image(530,1243,30,33)
image = pygame.transform.flip(image, True, False)
self.die_frames_l.append(image)
image = sprite_sheet.get_image(567,1250,38,27)
image = pygame.transform.flip(image, True, False)
self.die_frames_l.append(image)
image = sprite_sheet.get_image(609,1260,49,18)
image = pygame.transform.flip(image, True, False)
self.die_frames_l.append(image)
image = sprite_sheet.get_image(660,1258,51,20)
image = pygame.transform.flip(image, True, False)
self.die_frames_l.append(image)
image = sprite_sheet.get_image(716,1258,50,20)
image = pygame.transform.flip(image, True, False)
self.die_frames_l.append(image)
image = sprite_sheet.get_image(771,1261,48,19)
image = pygame.transform.flip(image, True, False)
self.die_frames_l.append(image)
# Rectangulo del sprite
self.image = pygame.Surface([25,58])
self.rect = self.image.get_rect()
self.image.fill(constants.BLUE)
# Sprite usado para activar a los enemigos
self.enemy_activator = pygame.sprite.Group()
self.enemy_activator.add(Enemy_Activator())
# Seleccionar con que imagen va a comenzar
self.draw_image = self.walking_frames_r[0]
self.draw_rect = self.rect.copy()
# Reloj para la hoja de sprites
self.reloj = 0
def __init__(self, position, player):
"""
:param player: The player object
:param position: The x-position of the player
This initializes the rocket
Variables:
self.player: The player object
self.spawnTime: The amout of time the punch will stay on screen
whichPice: Randomly chooses a number to choose which sprite to use
pieceOne: The first sprite
pieceTwo: the second sprite
pieceThree: The third sprite
usePice: The chosen sprite to be used
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
self.direction: The direction of the sprite
self.TDdirection: The direction of the sprite
"""
super().__init__()
self.spawnTime = 0
self.player = player
#Lists out rock sprites, chooses which sprite to use when initialized
whichPice = randint(1,3)
pieceOne = [154, 251, 34, 34]
pieceTwo = [199, 254, 39, 33]
pieceThree = [259, 254, 39, 34]
if whichPice == 1:
usePice = pieceOne
elif whichPice == 2:
usePice = pieceTwo
else:
usePice = pieceThree
pygame.sprite.Sprite.__init__(self)
#Load sheet
sprite_sheet = SpriteSheet("Golem.png")
image = sprite_sheet.get_image(usePice[0], usePice[1], usePice[2], usePice[3])
self.image = image
self.rect = self.image.get_rect()
#Sets rock position
self.rect.x = position
self.rect.y = -10
#Sets rock direction as it flies
self.direction = 'r'
self.TDdirection = 'b'
def __init__(self):
"""Constructor Function"""
# Call the parent's constructor
super(Player, self).__init__()
# -- Attributes
# Set speed vector of player
self.change_x = 0
self.change_y = 0
#This holds out all the images for the animated walk left /right of player
self.walking_frames_l = []
self.walking_frames_r = []
#What direction is the player facing?
self.direction = "R"
#List of sprites we can bump against:
self.level = None
sprite_sheet = SpriteSheet("resources\graphics\mariosheet.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(80, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(97, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(114, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(131, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(148, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(165, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(182, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(199, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(216, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(233, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(250, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(267, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(284, 49, 16, 16)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(301, 49, 16, 16)
# Load all right facing images, then flip them to face left
image = sprite_sheet.get_image(80, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(97, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(114, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(131, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(148, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(165, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(182, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(199, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(216, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(233, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(250, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(267, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(284, 49, 16, 16)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(301, 49, 16, 16)
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 reference to the image rect.
self.rect = self.image.get_rect()
def __init__(self):
""" Constructor function """
# Call the parent's constructor
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet("./resources/p1_walk.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(0, 0, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(66, 0, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(132, 0, 67, 90)
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)
# 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()
class Player(pygame.sprite.Sprite):
""" This class represents the bar at the bottom that the player
controls. """
# List of sprites we can bump against
level = None
# -- Methods
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 update(self):
""" Move the player. """
# Gravity
self.calc_grav()
# Check to see if player has been stunned
if self.stunned == True:
self.stun_check = time.time()
# How long the player has been stunned for
if self.stun_check - self.stun_start < 2:
# Stop horizontal movement
self.change_x = 0
# Keep player facing same direction
self.direction = self.stunned_direction
# If player is jumping stop vertical movement
if self.change_y < 0:
self.change_y = 0
else:
self.stunned = False
# Move left/right
self.rect.x += self.change_x
pos = self.rect.x
# Pick a frame (switch to frozen if needed)
if self.stunned == True:
if self.direction == "R":
frame = (pos // 30) % len(self.frozen_frames_r)
self.image = self.frozen_frames_r[frame]
else:
frame = (pos // 30) % len(self.frozen_frames_l)
self.image = self.frozen_frames_l[frame]
else:
if self.direction == "R":
frame = (pos // 30) % len(self.walking_frames_r)
self.image = self.walking_frames_r[frame]
else:
frame = (pos // 30) % len(self.walking_frames_l)
self.image = self.walking_frames_l[frame]
# See if we hit anything
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
elif self.change_x < 0:
# Otherwise if we are moving left, do the opposite.
self.rect.left = block.rect.right
# Move up/down
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
#For moving player if hit by moving platform
# if isinstance(block, MovingPlatform):
# self.rect.x += block.change_x
def calc_grav(self):
""" Calculate effect of gravity. """
if self.change_y == 0:
self.change_y = 1
else:
self.change_y += .45
if self.rect.y > constants.SCREEN_HEIGHT:
# Move to the top middle platform
self.rect.x = 585
self.rect.y = 100
# Minus a life
self.lives -= 1
def jump(self):
""" Called when user hits 'jump' button. """
# move down a bit and see if there is a platform below us.
# Move down 2 pixels because it doesn't work well if we only move down 1
# when working with a platform moving down.
self.rect.y += 2
platform_hit_list = pygame.sprite.spritecollide(
self, self.level.platform_list, False)
self.rect.y -= 2
# If it is ok to jump, set our speed upwards
if len(platform_hit_list
) > 0 or self.rect.bottom >= constants.SCREEN_HEIGHT:
self.change_y = -15
# Player-controlled movement:
def go_left(self):
""" Called when the user hits the left arrow. """
self.change_x = -6
self.direction = "L"
def go_right(self):
""" Called when the user hits the right arrow. """
self.change_x = 6
self.direction = "R"
def stop(self):
""" Called when the user lets off the keyboard. """
self.change_x = 0
def __init__(self):
""" Constructor function """
# Call the parent's constructor
super().__init__()
# -- Attributes
# Set speed vector of player
self.change_x = 0
self.change_y = 0
# This holds all the images for the animated walk left/right
# of our player
self.walking_frames_l = []
self.walking_frames_r = []
# What direction is the player facing?
self.direction = "R"
# List of sprites we can bump against
self.level = None
sprite_sheet = SpriteSheet("p1_walk.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(0, 0, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(66, 0, 66, 90)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(132, 0, 67, 90)
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)
# Set the image the 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, player, golem):
"""
:param player: The player object
:param golem: The golem object
This initializes the laser
Variables:
self.player: The player object
self.golem: The golem object
self.lazeroz: Holds the custom sprites
self.spawnTime: The amout of time the punch will stay on screen
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
self.oriX: The original x-position of the laser once it changes form
"""
super().__init__()
self.lazeroz = []
self.player = player
self.golem = golem
self.spawnTime = 0
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet("Golem.png")
image = sprite_sheet.get_image(BIG_CIRC[0], BIG_CIRC[1], BIG_CIRC[2],
BIG_CIRC[3])
self.image = image
self.rect = self.image.get_rect()
self.lazeroz.append(image)
image = sprite_sheet.get_image(MED_CIRC[0], MED_CIRC[1], MED_CIRC[2],
MED_CIRC[3])
self.lazeroz.append(image)
image = sprite_sheet.get_image(SMA_CIRC[0], SMA_CIRC[1], SMA_CIRC[2],
SMA_CIRC[3])
self.lazeroz.append(image)
image = sprite_sheet.get_image(SMA_BEAM[0], SMA_BEAM[1], SMA_BEAM[2],
SMA_BEAM[3])
self.lazeroz.append(image)
image = sprite_sheet.get_image(MED_BEAM[0], MED_BEAM[1], MED_BEAM[2],
MED_BEAM[3])
self.lazeroz.append(image)
image = sprite_sheet.get_image(BIG_BEAM[0], BIG_BEAM[1], BIG_BEAM[2],
BIG_BEAM[3])
self.lazeroz.append(image)
self.rect.x = golem.rect.x
self.oriX = golem.rect.x
self.rect.y = golem.rect.y + 131
def __init__(self, player):
"""
:param player: The player object
This initializes the scarab
Variables:
self.LRframes: A list to hold the custom sprites for animation when going right or left
self.LRframes: A list to hold the custom sprites for animation when going top or bottom
self.player: The player object
sprite_sheet: The spritesheet to where the custom spries came from
image: Holds the custom
self.image: The sprite used to represent the flyer
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
selection: A random int to select the direction the scarab faces
selectSpot: Selects where to place the scarab based on its direction
self.distance: How far the scarab will go before turning around
self.oriDistance: To set the distance when scarab reaches the end of its patrol
self.direction: The facing direction of the scarab
"""
super().__init__()
#Frames
self.LRframes = []
self.TBframes = []
#Selects what spot the scarab will be placed in
selection = randint(0, 3)
selectSpot = randint(0, 2)
#Sets how far the scarab will crawl
self.distance = 0
self.oriDistance = 0
self.direction = ''
pygame.sprite.Sprite.__init__(self)
#Load sheet
sprite_sheet = SpriteSheet("Skeleton.png")
#Right
image = sprite_sheet.get_image(46, 11, 78, 61)
self.LRframes.append(image)
#Left
image = sprite_sheet.get_image(351, 10, 78, 61)
self.LRframes.append(image)
#Top
image = sprite_sheet.get_image(160, 5, 61, 78)
self.TBframes.append(image)
#Bottom
image = sprite_sheet.get_image(252, 6, 61, 78)
self.TBframes.append(image)
self.image = image
self.rect = self.image.get_rect()
#Sets the scarab based on previous int variables
if selection == 0:
image = self.LRframes[0]
self.image = image
self.rect = self.image.get_rect()
self.rect.x = 30
self.direction = 'r'
if selectSpot == 0:
self.rect.y = 35
elif selectSpot == 1:
self.rect.y = 315
elif selectSpot == 2:
self.rect.y = 600
self.distance = 900
self.oriDistance = 900
elif selection == 1:
image = self.LRframes[1]
self.image = image
self.rect = self.image.get_rect()
self.rect.x = constants.SCREEN_WIDTH - 108
self.direction = 'l'
if selectSpot == 0:
self.rect.y = 35
elif selectSpot == 1:
self.rect.y = 315
elif selectSpot == 2:
self.rect.y = 600
self.distance = 900
self.oriDistance = 900
elif selection == 2:
image = self.TBframes[0]
self.image = image
self.rect = self.image.get_rect()
self.rect.y = constants.SCREEN_HEIGHT - 108
self.direction = 't'
if selectSpot == 0:
self.rect.x = 40
elif selectSpot == 1:
self.rect.x = 470
elif selectSpot == 2:
self.rect.x = 895
self.distance = 620
self.oriDistance = 620
elif selection == 3:
image = self.TBframes[1]
self.image = image
self.rect = self.image.get_rect()
self.rect.y = 35
self.direction = 'b'
if selectSpot == 0:
self.rect.x = 40
elif selectSpot == 1:
self.rect.x = 470
elif selectSpot == 2:
self.rect.x = 895
self.distance = 620
self.oriDistance = 620
self.player = player
def __init__(self):
super().__init__()
# Define o vetor velocidade do player
self.change_x = 0
self.change_y = 0
# Armazena todas as imagens da animação de descanço esquerda/direita do player
self.waiting_frames_l = []
self.waiting_frames_r = []
# Armazena todas as imagens da animação de andar para esquerda/direita do player
self.walking_frames_l = []
self.walking_frames_r = []
# Armazena todas as imagens da animação de pular para a esquerda/direita do player
self.jumping_frames_l = []
self.jumping_frames_r = []
# Armazena todas as imagens da animação de ataque leve para a esquerda/direita
self.lightatk_frames_l = []
self.lightatk_frames_r = []
# Direção que o player está virado
self.direction = "R"
# Lista de sprites que o player pode esbarrar
self.level = None
sprite_sheet = SpriteSheet("images/link.png")
# Carrega todas as sprites paradas viradas para a direita
image_wait = sprite_sheet.get_image(4, 61, 42, 42, constants.BLACK) #4,61,42,42#214,662,35,41
image_wait = pygame.transform.scale2x(image_wait)
self.waiting_frames_r.append(image_wait)
image_wait = sprite_sheet.get_image(54, 61, 42, 42, constants.BLACK) #54,61#253,662
image_wait = pygame.transform.scale2x(image_wait)
self.waiting_frames_r.append(image_wait)
image_wait = sprite_sheet.get_image(104, 61, 42, 42, constants.BLACK) #104,61#293,662
image_wait = pygame.transform.scale2x(image_wait)
self.waiting_frames_r.append(image_wait)
image_wait = sprite_sheet.get_image(154, 61, 42, 42, constants.BLACK) #154,61#333,662
image_wait = pygame.transform.scale2x(image_wait)
self.waiting_frames_r.append(image_wait)
# Carrega todas as sprites paradas viradas para a direita e as vira para a esquerda
image_wait = sprite_sheet.get_image(4, 61, 42, 42, constants.BLACK) #4,61,42,42#214,662,35,42
image_wait = pygame.transform.flip(image_wait, True, False)
image_wait = pygame.transform.scale2x(image_wait)
self.waiting_frames_l.append(image_wait)
image_wait = sprite_sheet.get_image(54, 61, 42, 42, constants.BLACK) #54,61#253,662
image_wait = pygame.transform.flip(image_wait, True, False)
image_wait = pygame.transform.scale2x(image_wait)
self.waiting_frames_l.append(image_wait)
image_wait = sprite_sheet.get_image(104, 61, 42, 42, constants.BLACK) #104,61#293,662
image_wait = pygame.transform.flip(image_wait, True, False)
image_wait = pygame.transform.scale2x(image_wait)
self.waiting_frames_l.append(image_wait)
image_wait = sprite_sheet.get_image(154, 61, 42, 42, constants.BLACK) #154,61#333,662
image_wait = pygame.transform.flip(image_wait, True, False)
image_wait = pygame.transform.scale2x(image_wait)
self.waiting_frames_l.append(image_wait)
# Carrega todas as sprites correndo viradas para a direita numa lista
image = sprite_sheet.get_image(204, 408, 42, 42, constants.BLACK)
image = pygame.transform.scale2x(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(154, 408, 42, 42, constants.BLACK)
image = pygame.transform.scale2x(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(104, 408, 42, 42, constants.BLACK)
image = pygame.transform.scale2x(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(54, 408, 42, 42, constants.BLACK)
image = pygame.transform.scale2x(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(4, 408, 42, 42, constants.BLACK)
image = pygame.transform.scale2x(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(204, 460, 42, 42, constants.BLACK)
image = pygame.transform.scale2x(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(154, 460, 42, 42, constants.BLACK)
image = pygame.transform.scale2x(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(104, 460, 42, 42, constants.BLACK)
image = pygame.transform.scale2x(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(54, 460, 42, 42, constants.BLACK)
image = pygame.transform.scale2x(image)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(4, 460, 42, 42, constants.BLACK)
image = pygame.transform.scale2x(image)
self.walking_frames_r.append(image)
# Carrega todas as imagens correndo viradas para a direita e as vira para a esquerda
image = sprite_sheet.get_image(4, 408, 42, 42, constants.BLACK)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale2x(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(54, 408, 42, 42, constants.BLACK)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale2x(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(104, 408, 42, 42, constants.BLACK)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale2x(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(154, 408, 42, 42, constants.BLACK)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale2x(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(204, 408, 42, 42, constants.BLACK)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale2x(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(4, 460, 42, 42, constants.BLACK)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale2x(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(54, 460, 42, 42, constants.BLACK)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale2x(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(104, 460, 42, 42, constants.BLACK)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale2x(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(154, 460, 42, 42, constants.BLACK)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale2x(image)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(204, 460, 42, 42, constants.BLACK)
image = pygame.transform.flip(image, True, False)
image = pygame.transform.scale2x(image)
self.walking_frames_l.append(image)
# Carrega todas as imagens pulando viradas para a direita numa lista
image_jump = sprite_sheet.get_image(304, 0, 42, 54, constants.BLACK)
image_jump = pygame.transform.scale2x(image_jump)
self.jumping_frames_r.append(image_jump)
image_jump = sprite_sheet.get_image(354, 0, 42, 54, constants.BLACK)
image_jump = pygame.transform.scale2x(image_jump)
self.jumping_frames_r.append(image_jump)
image_jump = sprite_sheet.get_image(404, 0, 42, 54, constants.BLACK)
image_jump = pygame.transform.scale2x(image_jump)
self.jumping_frames_r.append(image_jump)
# Carrega todas as imagens pulando viradas para a direita e as vira para a esquerda
image_jump = sprite_sheet.get_image(304, 0, 42, 54, constants.BLACK)
image_jump = pygame.transform.flip(image_jump, True, False)
image_jump = pygame.transform.scale2x(image_jump)
self.jumping_frames_l.append(image_jump)
image_jump = sprite_sheet.get_image(354, 0, 42, 54, constants.BLACK)
image_jump = pygame.transform.flip(image_jump, True, False)
image_jump = pygame.transform.scale2x(image_jump)
self.jumping_frames_l.append(image_jump)
image_jump = sprite_sheet.get_image(404, 0, 42, 54, constants.BLACK)
image_jump = pygame.transform.flip(image_jump, True, False)
image_jump = pygame.transform.scale2x(image_jump)
self.jumping_frames_l.append(image_jump)
# Carrega todas as imagens de ataque leve viradas para a direita
image_lightatk = sprite_sheet.get_image(204, 59, 41, 45, constants.BLACK)
image_lightatk = pygame.transform.scale2x(image_lightatk)
self.lightatk_frames_r.append(image_lightatk)
image_lightatk = sprite_sheet.get_image(328, 313, 63, 38, constants.BLACK)
image_lightatk = pygame.transform.scale2x(image_lightatk)
self.lightatk_frames_r.append(image_lightatk)
# Carrega todas as imagens de ataque leve viradas para a direita e as vira para a esquerda
image_lightatk = sprite_sheet.get_image(204, 59, 41, 45, constants.BLACK)
image_lightatk = pygame.transform.flip(image_lightatk, True, False)
image_lightatk = pygame.transform.scale2x(image_lightatk)
self.lightatk_frames_l.append(image_lightatk)
image_lightatk = sprite_sheet.get_image(328, 313, 63, 38, constants.BLACK)
image_lightatk = pygame.transform.flip(image_lightatk, True, False)
image_lightatk = pygame.transform.scale2x(image_lightatk)
self.lightatk_frames_l.append(image_lightatk)
# Define a sprite que o player começa
self.image_wait = self.waiting_frames_r[0]
self.image = self.walking_frames_r[0]
self.image_jump = self.jumping_frames_r[0]
# Define uma referência para o retângulo da sprite
self.rect = self.image.get_rect()
self.rect_jump = self.image_jump.get_rect()
def __init__(self):
""" Constructor function """
# Call the parent's constructor
super().__init__()
# -- Attributes
# Set speed
self.change_x = 0
self.change_y = 0
self.play_sound = False
# This holds all the images for the animated walk left/right
# of our player
self.walking_frames_l = []
self.walking_frames_r = []
self.walking_frames_u = []
self.walking_frames_d = []
# What direction is the player facing?
self.direction = "D"
sprite_sheet = SpriteSheet("assets\Char2.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(0, 158, 33, 42)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(34, 155, 33, 42)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(67, 157, 31, 43)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(100, 158, 33, 42)
self.walking_frames_r.append(image)
# Load all the right facing images, then flip them
# to face left.
image = sprite_sheet.get_image(0, 158, 33, 42)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(34, 155, 33, 42)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(67, 157, 31, 43)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(100, 158, 33, 42)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(0, 158, 33, 42)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(34, 155, 33, 42)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(67, 157, 31, 43)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(100, 158, 33, 42)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
# Load all the upward facing images into a list
image = sprite_sheet.get_image(0, 53, 34, 50)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(34, 53, 34, 42)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(68, 53, 32, 42)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(100, 53, 34, 42)
self.walking_frames_u.append(image)
# Load all the downward facing images into a list
image = sprite_sheet.get_image(0, 0, 34, 51)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(34, 0, 34, 50)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(68, 0, 34, 50)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(102, 0, 30, 50)
self.walking_frames_d.append(image)
# Set the image the player starts with
self.image = self.walking_frames_d[0]
# Set a reference to the image rect.
self.rect = self.image.get_rect()
def __init__(self):
""" Constructor function """
# Call the parent's constructor
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet("skeevy2.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(0, 0, 23, 32)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(84, 0, 26, 27)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(127, 0, 25, 27)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(169, 0, 26, 28)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(126, 43, 27, 26)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(125, 86, 29, 25)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(210, 166, 29, 34)
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, 23, 32)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(84, 0, 26, 27)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(127, 0, 25, 27)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(169, 0, 26, 28)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(126, 43, 27, 26)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(125, 86, 29, 25)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(210, 166, 29, 34)
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 defineAnimations(self):
spritesheet = SpriteSheet("TheKid.png")
# Define idle animation
self.idle = []
img = spritesheet.get_image(0, 0, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.idle.append(pygame.transform.scale2x(img))
img = spritesheet.get_image(27, 0, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.idle.append(pygame.transform.scale2x(img))
img = spritesheet.get_image(55, 0, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.idle.append(pygame.transform.scale2x(img))
img = spritesheet.get_image(82, 0, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.idle.append(pygame.transform.scale2x(img))
# Define walking animation
self.walking = []
img = spritesheet.get_image(1, 25, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.walking.append(pygame.transform.scale2x(img))
img = spritesheet.get_image(31, 25, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.walking.append(pygame.transform.scale2x(img))
img = spritesheet.get_image(59, 25, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.walking.append(pygame.transform.scale2x(img))
img = spritesheet.get_image(87, 25, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.walking.append(pygame.transform.scale2x(img))
img = spritesheet.get_image(118, 25, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.walking.append(pygame.transform.scale2x(img))
# Define jumping animation
self.jumping = []
img = spritesheet.get_image(0, 69, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.jumping.append(pygame.transform.scale2x(img))
img = spritesheet.get_image(24, 69, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.jumping.append(pygame.transform.scale2x(img))
# Define falling animation
self.falling = []
img = spritesheet.get_image(4, 101, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.falling.append(pygame.transform.scale2x(img))
img = spritesheet.get_image(33, 101, Player.WIDTH // 2,
Player.HEIGHT // 2)
self.falling.append(pygame.transform.scale2x(img))
def __init__(self, loc):
# Call parent's constructor
pygame.sprite.Sprite.__init__(self)
# Enemy PNG
sprite_sheet = SpriteSheet("e1_gunwalk.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(0, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(64, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(128, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(192, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(256, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(320, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(640, 0, 64, 78)
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, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(64, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(128, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(192, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(256, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(320, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(640, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
# Set the image the Enemy starts with
self.image = self.walking_frames_r[0]
# Reference the image rect.
self.rect = self.image.get_rect()
self.rect.bottomleft = loc
self.change_x = -5
def __init__(self):
""" Constructor function """
# Call the parent's constructor
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet("assets\\player1.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(324, 261, 30, 47)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(358, 262, 26, 47)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(388, 262, 24, 47)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(414, 260, 33, 47)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(451, 259, 38, 47)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(324, 210, 39, 47)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(367, 211, 36, 47)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(408, 211, 32, 47)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(444, 210, 28, 47)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(476, 212, 35, 47)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(515, 212, 38, 47)
self.walking_frames_r.append(image)
# Load all the right facing images, then flip them
# to face left.
for x in self.walking_frames_r[:]:
image = x
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
#load the right facing jumping frames
image = sprite_sheet.get_image(324, 63, 22, 22)
self.jumping_frames_r.append(image)
image = sprite_sheet.get_image(349, 65, 23, 20)
self.jumping_frames_r.append(image)
image = sprite_sheet.get_image(375, 64, 22, 22)
self.jumping_frames_r.append(image)
image = sprite_sheet.get_image(400, 64, 20, 25)
self.jumping_frames_r.append(image)
image = sprite_sheet.get_image(423, 64, 22, 22)
self.jumping_frames_r.append(image)
image = sprite_sheet.get_image(448, 66, 25, 20)
self.jumping_frames_r.append(image)
image = sprite_sheet.get_image(476, 64, 20, 23)
self.jumping_frames_r.append(image)
image = sprite_sheet.get_image(499, 64, 20, 25)
self.jumping_frames_r.append(image)
#load the left facing jumping frame
for x in self.jumping_frames_r[:]:
image = x
image = pygame.transform.flip(image, True, False)
self.jumping_frames_l.append(image)
#load the sprites for aiming upwards whilst running right
image = sprite_sheet.get_image(323, 310, 35, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(362, 310, 34, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(402, 310, 32, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(439, 310, 31, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(474, 310, 29, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(509, 310, 29, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(544, 309, 29, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(324, 366, 36, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(368, 368, 38, 49)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(411, 365, 36, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(451, 365, 35, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(490, 365, 34, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(529, 365, 31, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(564, 365, 29, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(596, 365, 29, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(323, 417, 29, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(355, 417, 30, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(389, 417, 33, 51)
self.aim_up_running_r.append(image)
image = sprite_sheet.get_image(425, 422, 36, 51)
self.aim_up_running_r.append(image)
#load the sprites for aiming upwards whilst running left
for x in self.aim_up_running_r[:]:
image = x
image = pygame.transform.flip(image, True, False)
self.aim_up_running_l.append(image)
#load the sprites for aiming downwards whilst running right
image = sprite_sheet.get_image(323, 579, 40, 46)
self.aim_mid_running_r.append(image)
image = sprite_sheet.get_image(368, 575, 36, 46)
self.aim_mid_running_r.append(image)
image = sprite_sheet.get_image(406, 574, 35, 46)
self.aim_mid_running_r.append(image)
image = sprite_sheet.get_image(444, 574, 35, 46)
self.aim_mid_running_r.append(image)
for x in self.aim_mid_running_r[:]:
image = x
image = pygame.transform.flip(image, True, False)
self.aim_mid_running_l.append(image)
image = sprite_sheet.get_image(323, 472, 34, 45)
self.aim_down_running_r.append(image)
image = sprite_sheet.get_image(360, 473, 33, 45)
self.aim_down_running_r.append(image)
image = sprite_sheet.get_image(396, 473, 31, 45)
self.aim_down_running_r.append(image)
image = sprite_sheet.get_image(431, 473, 31, 45)
self.aim_down_running_r.append(image)
image = sprite_sheet.get_image(467, 473, 31, 45)
self.aim_down_running_r.append(image)
image = sprite_sheet.get_image(502, 473, 31, 45)
self.aim_down_running_r.append(image)
image = sprite_sheet.get_image(535, 472, 31, 45)
self.aim_down_running_r.append(image)
image = sprite_sheet.get_image(568, 472, 31, 45)
self.aim_down_running_r.append(image)
image = sprite_sheet.get_image(602, 472, 31, 45)
self.aim_down_running_r.append(image)
image = sprite_sheet.get_image(323, 523, 32, 45)
self.aim_down_running_r.append(image)
image = sprite_sheet.get_image(359, 528, 36, 45)
self.aim_down_running_r.append(image)
for x in self.aim_down_running_r[:]:
image = x
image = pygame.transform.flip(image, True, False)
self.aim_down_running_l.append(image)
image = sprite_sheet.get_image(323, 950, 29, 42)
self.dead_anim.append(image)
image = sprite_sheet.get_image(355, 950, 28, 42)
self.dead_anim.append(image)
image = sprite_sheet.get_image(386, 950, 32, 42)
self.dead_anim.append(image)
image = sprite_sheet.get_image(421, 950, 38, 42)
self.dead_anim.append(image)
image = sprite_sheet.get_image(462, 950, 38, 42)
self.dead_anim.append(image)
image = sprite_sheet.get_image(503, 950, 37, 42)
self.dead_anim.append(image)
image = sprite_sheet.get_image(543, 950, 32, 42)
self.dead_anim.append(image)
image = sprite_sheet.get_image(578, 950, 32, 42)
self.dead_anim.append(image)
image = sprite_sheet.get_image(613, 950, 29, 42)
self.dead_anim.append(image)
image = sprite_sheet.get_image(323, 998, 30, 30)
self.dead_anim.append(image)
image = sprite_sheet.get_image(355, 995, 33, 33)
self.dead_anim.append(image)
image = sprite_sheet.get_image(391, 997, 36, 31)
self.dead_anim.append(image)
image = sprite_sheet.get_image(430, 1010, 40, 18)
self.dead_anim.append(image)
image = sprite_sheet.get_image(473, 1017, 41, 11)
self.dead_anim.append(image)
image = sprite_sheet.get_image(323, 1031, 43, 11)
self.dead_anim.append(image)
image = sprite_sheet.get_image(369, 1032, 48, 10)
self.dead_anim.append(image)
image = sprite_sheet.get_image(420, 1033, 45, 9)
self.dead_anim.append(image)
#load the idle aiming up frames
self.direct_upaim_r = sprite_sheet.get_image(613, 3, 24, 57)
self.direct_upaim_l = pygame.transform.flip(self.direct_upaim_r, True, False)
#load the idle frames
self.idle_frame_r = sprite_sheet.get_image(324, 93, 35, 42)
self.idle_frame_l = pygame.transform.flip(self.idle_frame_r, True, False)
#load the prone frames
self.prone_frame_r = sprite_sheet.get_image(324, 139, 50, 19)
self.prone_frame_l = pygame.transform.flip(self.prone_frame_r, True, False)
# Set the image the player starts with
self.image = self.walking_frames_r[0]
self.image = pygame.transform.scale(self.image,(self.image.get_width()*constants.playerscale,self.image.get_height()*constants.playerscale))
# Set a referance to the image rect.
self.rect = self.image.get_rect()
def __init__(self):
""" Constructor function """
pygame.mixer.init()
self.jumpSound = pygame.mixer.Sound('Jump.wav')
self.hitSound = pygame.mixer.Sound('Smacked.wav')
#Walking frames
self.walking_frames_l = []
self.walking_frames_r = []
#Idle frames
self.idle_frames_r = []
self.idle_frames_l = []
#Jump frames
self.jump_rightOrLeft = []
#falling frames
self.fall_rightOrLeft = []
#Hurt frames
self.hurt_rightOrLeft = []
#crouch frames
self.crouch_right = []
self.crouch_left = []
#Checks if player can crouch or not
self.canCrouch = False
#Used to determine which crouch frame to use
self.crouching = 0
#Checks if player is in boss level
self.bossTime = False
self.bossChange = False
#Used for idle frames
self.normalChange = False
#Sets player hp and checks if player is dead or hurt
self.hp = 100
self.dead = False
self.hurt = False
self.getHit = False
self.hurtCounter = 30
# Call the parent's constructor
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet("idleTest.png")
#Right idle
image = sprite_sheet.get_image(26, 17, 43, 106)
self.idle_frames_r.append(image)
self.image = image
image = sprite_sheet.get_image(89, 17, 49, 106)
self.idle_frames_r.append(image)
image = sprite_sheet.get_image(164, 11, 49, 112)
self.idle_frames_r.append(image)
image = sprite_sheet.get_image(233, 11, 55, 112)
self.idle_frames_r.append(image)
image = sprite_sheet.get_image(308, 17, 49, 106)
self.idle_frames_r.append(image)
image = sprite_sheet.get_image(395, 23, 43, 106)
self.idle_frames_r.append(image)
#Left idle
image = sprite_sheet.get_image(26, 17, 43, 106)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
image = sprite_sheet.get_image(89, 17, 49, 106)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
image = sprite_sheet.get_image(164, 11, 49, 112)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
image = sprite_sheet.get_image(233, 11, 55, 112)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
image = sprite_sheet.get_image(308, 17, 49, 106)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
image = sprite_sheet.get_image(395, 23, 43, 106)
image = pygame.transform.flip(image, True, False)
self.idle_frames_l.append(image)
#Walk right
image = sprite_sheet.get_image(26, 168, 70, 102)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(117, 165, 58, 106)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(198, 167, 46, 103)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(278, 169, 49, 103)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(351, 172, 58, 103)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(431, 172, 57, 103)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(516, 169, 52, 106)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(602, 172, 52, 106)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(46, 291, 49, 105)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(136, 293, 48, 105)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(215, 292, 61, 105)
self.walking_frames_r.append(image)
#Walk left
image = sprite_sheet.get_image(26, 168, 70, 102)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(117, 165, 58, 106)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(198, 167, 46, 103)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(278, 169, 49, 103)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(351, 172, 58, 103)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(431, 172, 57, 103)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(516, 169, 52, 106)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(602, 172, 52, 106)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(46, 291, 49, 105)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(136, 293, 48, 105)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(215, 292, 61, 105)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
#jump right and left
image = sprite_sheet.get_image(406, 300, 70, 106)
self.jump_rightOrLeft.append(image)
image = pygame.transform.flip(image, True, False)
self.jump_rightOrLeft.append(image)
#fall right and left
image = sprite_sheet.get_image(510, 306, 61, 106)
self.fall_rightOrLeft.append(image)
image = pygame.transform.flip(image, True, False)
self.fall_rightOrLeft.append(image)
#crouch right
image = sprite_sheet.get_image(37, 425, 43, 106)
self.crouch_right.append(image)
image = sprite_sheet.get_image(129, 430, 46, 97)
self.crouch_right.append(image)
image = sprite_sheet.get_image(203, 467, 52, 61)
self.crouch_right.append(image)
#crouch left
image = sprite_sheet.get_image(37, 425, 43, 106)
image = pygame.transform.flip(image, True, False)
self.crouch_left.append(image)
image = sprite_sheet.get_image(129, 430, 46, 97)
image = pygame.transform.flip(image, True, False)
self.crouch_left.append(image)
image = sprite_sheet.get_image(203, 467, 52, 61)
image = pygame.transform.flip(image, True, False)
self.crouch_left.append(image)
#hurt right and left
image = sprite_sheet.get_image(505, 439, 70, 100)
self.hurt_rightOrLeft.append(image)
image = pygame.transform.flip(image, True, False)
self.hurt_rightOrLeft.append(image)
#Checks if player wins level
self.winner = False
#Used for idle frames
self.idleCho = 0
self.idleChange = 0
#gets the rect of the image
self.rect = self.image.get_rect()
# Set speed vector of player
self.change_x = 0
self.change_y = 0
# List of sprites we can bump against
self.level = None
# Player's bullets
self.bullets = None
#Sets the player's initial direction
self.direction = 'r'
def __init__(self):
# Call the parent's constructor
pygame.sprite.Sprite.__init__(self)
#Setting up the sprite image for the character. The first two numbers below stand for the
#x,y coordinates of the image, the third number is the width and finally, the fourth
#number is the height of the image.
sprite_sheet = SpriteSheet("boy_2.png") #This loads the sprite sheet.
image = sprite_sheet.get_image(8, 210, 28, 45)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(40, 210, 28, 45)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(70, 210, 28, 45)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(103, 210, 28, 45)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(136, 210, 28, 45)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(166, 210, 28, 45)
self.walking_frames_r.append(image)
#This set of code will flip the image for when the character on the screen
#moves to the left. It is similar to the code above however, the image is
#simple being flipped for movement to the left.
image = sprite_sheet.get_image(8, 210, 28, 45)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(40, 210, 28, 45)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(70, 210, 28, 45)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(103, 210, 28, 45)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(136, 210, 28, 45)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(166, 210, 28, 45)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
#Setting the starting image.
self.image = self.walking_frames_r[0]
#Setting a reference.
self.rect = self.image.get_rect()
def __init__(self, sprite_sheet_data):
pygame.sprite.Sprite.__init__(self)
sprite_sheet = SpriteSheet("tiles_spritesheet.png")
sprite_sheet = SpriteSheet("brokenTableSprite.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, ai_settings, screen):
"""Initialize the ship, and set its starting position."""
super(Pacman, self).__init__()
self.screen = screen
self.ai_settings = ai_settings
self.frame = 0
self.centerx = 300
self.centery = 300
self.pacframesl = []
self.pacframesr = []
self.pacframesu = []
self.pacframesd = []
self.pacex = []
# Load the ship image, and get its rect.
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(0, 160, 32, 32)
self.pacframesl.append(image)
image = sprite_sheet.get_image(32, 160, 32, 32)
self.pacframesl.append(image)
image = sprite_sheet.get_image(0, 192, 32, 32)
self.pacframesl.append(image)
image = sprite_sheet.get_image(32, 192, 32, 32)
self.pacframesl.append(image)
self.image = self.pacframesl[0]
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(0, 160, 32, 32)
image = pygame.transform.rotate(image, 180)
self.pacframesr.append(image)
image = sprite_sheet.get_image(32, 160, 32, 32)
image = pygame.transform.rotate(image, 180)
self.pacframesr.append(image)
image = sprite_sheet.get_image(0, 192, 32, 32)
image = pygame.transform.rotate(image, 180)
self.pacframesr.append(image)
image = sprite_sheet.get_image(32, 192, 32, 32)
image = pygame.transform.rotate(image, 180)
self.pacframesr.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(0, 160, 32, 32)
image = pygame.transform.rotate(image, 270)
self.pacframesu.append(image)
image = sprite_sheet.get_image(32, 160, 32, 32)
image = pygame.transform.rotate(image, 270)
self.pacframesu.append(image)
image = sprite_sheet.get_image(0, 192, 32, 32)
image = pygame.transform.rotate(image, 270)
self.pacframesu.append(image)
image = sprite_sheet.get_image(32, 192, 32, 32)
image = pygame.transform.rotate(image, 270)
self.pacframesu.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(0, 160, 32, 32)
image = pygame.transform.rotate(image, 90)
self.pacframesd.append(image)
image = sprite_sheet.get_image(32, 160, 32, 32)
image = pygame.transform.rotate(image, 90)
self.pacframesd.append(image)
image = sprite_sheet.get_image(0, 192, 32, 32)
image = pygame.transform.rotate(image, 90)
self.pacframesd.append(image)
image = sprite_sheet.get_image(32, 192, 32, 32)
image = pygame.transform.rotate(image, 90)
self.pacframesd.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(0, 0, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(32, 0, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(64, 0, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(96, 0, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(0, 32, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(32, 32, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(64, 32, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(96, 32, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(0, 64, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(32, 64, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(64, 64, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(96, 64, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(0, 96, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(32, 96, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(64, 96, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(96, 96, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(0, 128, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(32, 128, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(64, 128, 32, 32)
self.pacex.append(image)
sprite_sheet = SpriteSheet('images/spreadsheet.png')
image = sprite_sheet.get_image(96, 128, 32, 32)
self.pacex.append(image)
self.rect = self.image.get_rect()
self.screen_rect = screen.get_rect()
# Start each new ship at the bottom center of the screen.
self.rect.centery = 304
# self.rect.centery = self.screen_rect.centery
self.rect.centerx = self.screen_rect.centerx
# self.rect.bottom = self.screen_rect.bottom
# Store a decimal value for the ship's center.
self.centerx = float(self.rect.centerx)
self.centery = float(self.rect.centery)
# Movement flags.
self.moving_right = False
self.moving_left = False
self.moving_up = False
self.moving_down = False
self.power = 0
self.seconds = 0
def __init__(self, bounds, direction):
# Bullet constructor.
pygame.sprite.Sprite.__init__(self)
self.direction = direction
self.bounds = bounds
# Add some random inaccuracy
self.accuracy = random.randint(-1, 1)
# Laser PNG
sprite_sheet = SpriteSheet("laser.png")
# Load all images into a list
image = sprite_sheet.get_image(0, 0, 48, 46)
self.bullet_frames.append(image)
image = sprite_sheet.get_image(48, 0, 48, 46)
self.bullet_frames.append(image)
image = sprite_sheet.get_image(96, 0, 48, 46)
self.bullet_frames.append(image)
image = sprite_sheet.get_image(96, 0, 48, 46)
self.bullet_frames.append(image)
image = sprite_sheet.get_image(96, 0, 48, 46)
self.bullet_frames.append(image)
image = sprite_sheet.get_image(96, 0, 48, 46)
self.bullet_frames.append(image)
image = sprite_sheet.get_image(96, 0, 48, 46)
self.bullet_frames.append(image)
image = sprite_sheet.get_image(96, 0, 48, 46)
self.bullet_frames.append(image)
image = sprite_sheet.get_image(96, 0, 48, 46)
self.bullet_frames.append(image)
image = sprite_sheet.get_image(96, 0, 48, 46)
self.bullet_frames.append(image)
image = sprite_sheet.get_image(96, 0, 48, 46)
self.bullet_frames.append(image)
image = sprite_sheet.get_image(96, 0, 48, 46)
self.bullet_frames.append(image)
# Set the image the Bullet starts with
self.image = self.bullet_frames[0]
# Reference the image rect.
self.rect = self.image.get_rect()
def __init__(self, type):
pygame.sprite.Sprite.__init__(self)
self.type = type
sprite_sheet = SpriteSheet("assets\\enemies1.png")
image = sprite_sheet.get_image(321, 1, 32, 47)
self.walk_r.append(image)
image = sprite_sheet.get_image(356, 1, 21, 47)
self.walk_r.append(image)
image = sprite_sheet.get_image(380, 1, 28, 47)
self.walk_r.append(image)
image = sprite_sheet.get_image(411, 1, 38, 47)
self.walk_r.append(image)
image = sprite_sheet.get_image(452, 1, 36, 47)
self.walk_r.append(image)
image = sprite_sheet.get_image(491, 1, 28, 47)
self.walk_r.append(image)
image = sprite_sheet.get_image(522, 1, 21, 47)
self.walk_r.append(image)
image = sprite_sheet.get_image(546, 1, 32, 47)
self.walk_r.append(image)
image = sprite_sheet.get_image(581, 1, 37, 47)
self.walk_r.append(image)
for x in self.walk_r[:]:
image = x
image = pygame.transform.flip(image, True, False)
self.walk_l.append(image)
self.up_r = sprite_sheet.get_image(321, 246, 25, 60)
self.up_l = pygame.transform.flip(self.up_r, True, False)
self.upangle_r = sprite_sheet.get_image(405, 250, 31, 56)
self.upangle_l = pygame.transform.flip(self.upangle_r, True, False)
self.mid_r = sprite_sheet.get_image(507, 261, 36, 45)
self.mid_l = pygame.transform.flip(self.mid_r, True, False)
self.downangle_r = sprite_sheet.get_image(321, 312, 32, 45)
self.downangle_l = pygame.transform.flip(self.downangle_r, True, False)
self.down_r = sprite_sheet.get_image(426, 312, 25, 45)
self.down_l = pygame.transform.flip(self.down_r, True, False)
image = sprite_sheet.get_image(528, 216, 49, 38)
self.die_R_r.append(image)
image = sprite_sheet.get_image(528, 178, 49, 38)
self.die_R_r.append(image)
for x in self.die_R_r[:]:
image = x
image = pygame.transform.flip(image, True, False)
self.die_R_l.append(image)
image = sprite_sheet.get_image(321, 109, 37, 39)
self.die_M_r.append(image)
image = sprite_sheet.get_image(358, 109, 37, 39)
self.die_M_r.append(image)
for x in self.die_M_r[:]:
image = x
image = pygame.transform.flip(image, True, False)
self.die_M_l.append(image)
#0 = Melee 1 = Ranged
if (self.type == 0):
self.speed = 4
self.health = 1
self.pos = Vector(0, 0)
self.image = self.walk_l[0]
elif (self.type == 1):
self.speed = 2
self.health = 1
self.pos = Vector(0, 0)
self.sprite = None
self.image = self.mid_l
bullet_list = pygame.sprite.Group()
self.image = pygame.transform.scale(
self.image, (self.image.get_width() * constants.enemyscale,
self.image.get_height() * constants.enemyscale))
self.rect = self.image.get_rect()
def __init__(self, loc, bounds):
# Call parent's constructor
pygame.sprite.Sprite.__init__(self)
# Player PNG
sprite_sheet = SpriteSheet("p1_gunwalk.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(0, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(64, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(128, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(192, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(256, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(320, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(640, 0, 64, 78)
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, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(64, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(128, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(192, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(256, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(320, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(640, 0, 64, 78)
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]
# Reference the image rect.
self.rect = self.image.get_rect()
self.rect.center = loc
self.bounds = bounds
self.bullets = Group()
self.bulletcasings = Group()
