スーパマリオ(講師/作)
講師から一言
30ファイル以上あるためソースコードは一部抜粋とします。開発メンバーには日本人以外もいるのでコメントは英語で書いています。
将来、エンジニアとして大きなプロジェクトに挑戦したい場合、英語は必須です。
大企業は海外にいくつも子会社を持っています。国内の会社と海外の子会社が利用するシステムを構築する際、プロジェクト導入メンバーが日本人だけということはありません。
グローバル案件の場合、プロジェクトの共通言語は英語になります。
「英語が苦手です」って本当に言いにくい空気が流れてるので将来、困りたくない人は英語も勉強してください。
必ず役に立ちます。
Pythonで記述したコード
#__init__.py
__author__ = 'justinarmstrong'
#bricks.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import setup
from .. import constants as c
from . import powerups
from . import coin
class Brick(pg.sprite.Sprite):
"""Bricks that can be destroyed"""
def __init__(self, x, y, contents=None, powerup_group=None, name='brick'):
"""Initialize the object"""
pg.sprite.Sprite.__init__(self)
self.sprite_sheet = setup.GFX['tile_set']
self.frames = []
self.frame_index = 0
self.setup_frames()
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.mask = pg.mask.from_surface(self.image)
self.bumped_up = False
self.rest_height = y
self.state = c.RESTING
self.y_vel = 0
self.gravity = 1.2
self.name = name
self.contents = contents
self.setup_contents()
self.group = powerup_group
self.powerup_in_box = True
def get_image(self, x, y, width, height):
"""Extracts the image from the sprite sheet"""
image = pg.Surface([width, height]).convert()
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.BRICK_SIZE_MULTIPLIER),
int(rect.height*c.BRICK_SIZE_MULTIPLIER)))
return image
def setup_frames(self):
"""Set the frames to a list"""
self.frames.append(self.get_image(16, 0, 16, 16))
self.frames.append(self.get_image(432, 0, 16, 16))
def setup_contents(self):
"""Put 6 coins in contents if needed"""
if self.contents == '6coins':
self.coin_total = 6
else:
self.coin_total = 0
def update(self):
"""Updates the brick"""
self.handle_states()
def handle_states(self):
"""Determines brick behavior based on state"""
if self.state == c.RESTING:
self.resting()
elif self.state == c.BUMPED:
self.bumped()
elif self.state == c.OPENED:
self.opened()
def resting(self):
"""State when not moving"""
if self.contents == '6coins':
if self.coin_total == 0:
self.state == c.OPENED
def bumped(self):
"""Action during a BUMPED state"""
self.rect.y += self.y_vel
self.y_vel += self.gravity
if self.rect.y >= (self.rest_height + 5):
self.rect.y = self.rest_height
if self.contents == 'star':
self.state = c.OPENED
elif self.contents == '6coins':
if self.coin_total == 0:
self.state = c.OPENED
else:
self.state = c.RESTING
else:
self.state = c.RESTING
def start_bump(self, score_group):
"""Transitions brick into BUMPED state"""
self.y_vel = -6
if self.contents == '6coins':
setup.SFX['coin'].play()
if self.coin_total > 0:
self.group.add(coin.Coin(self.rect.centerx, self.rect.y, score_group))
self.coin_total -= 1
if self.coin_total == 0:
self.frame_index = 1
self.image = self.frames[self.frame_index]
elif self.contents == 'star':
setup.SFX['powerup_appears'].play()
self.frame_index = 1
self.image = self.frames[self.frame_index]
self.state = c.BUMPED
def opened(self):
"""Action during OPENED state"""
self.frame_index = 1
self.image = self.frames[self.frame_index]
if self.contents == 'star' and self.powerup_in_box:
self.group.add(powerups.Star(self.rect.centerx, self.rest_height))
self.powerup_in_box = False
class BrickPiece(pg.sprite.Sprite):
"""Pieces that appear when bricks are broken"""
def __init__(self, x, y, xvel, yvel):
super(BrickPiece, self).__init__()
self.sprite_sheet = setup.GFX['item_objects']
self.setup_frames()
self.frame_index = 0
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.x_vel = xvel
self.y_vel = yvel
self.gravity = .8
def setup_frames(self):
"""create the frame list"""
self.frames = []
image = self.get_image(68, 20, 8, 8)
reversed_image = pg.transform.flip(image, True, False)
self.frames.append(image)
self.frames.append(reversed_image)
def get_image(self, x, y, width, height):
"""Extract image from sprite sheet"""
image = pg.Surface([width, height]).convert()
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.BRICK_SIZE_MULTIPLIER),
int(rect.height*c.BRICK_SIZE_MULTIPLIER)))
return image
def update(self):
"""Update brick piece"""
self.rect.x += self.x_vel
self.rect.y += self.y_vel
self.y_vel += self.gravity
self.check_if_off_screen()
def check_if_off_screen(self):
"""Remove from sprite groups if off screen"""
if self.rect.y > c.SCREEN_HEIGHT:
self.kill()
#castle_flag.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import setup
from .. import constants as c
class Flag(pg.sprite.Sprite):
"""Flag on the castle"""
def __init__(self, x, y):
"""Initialize object"""
super(Flag, self).__init__()
self.sprite_sheet = setup.GFX['item_objects']
self.image = self.get_image(129, 2, 14, 14)
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.state = 'rising'
self.y_vel = -2
self.target_height = y
def get_image(self, x, y, width, height):
"""Extracts image from sprite sheet"""
image = pg.Surface([width, height])
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.SIZE_MULTIPLIER),
int(rect.height*c.SIZE_MULTIPLIER)))
return image
def update(self, *args):
"""Updates flag position"""
if self.state == 'rising':
self.rising()
elif self.state == 'resting':
self.resting()
def rising(self):
"""State when flag is rising to be on the castle"""
self.rect.y += self.y_vel
if self.rect.bottom <= self.target_height:
self.state = 'resting'
def resting(self):
"""State when the flag is stationary doing nothing"""
pass
#checkpoint.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import constants as c
class Checkpoint(pg.sprite.Sprite):
"""Invisible sprite used to add enemies, special boxes
and trigger sliding down the flag pole"""
def __init__(self, x, name, y=0, width=10, height=600):
super(Checkpoint, self).__init__()
self.image = pg.Surface((width, height))
self.image.fill(c.BLACK)
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.name = name
#coin.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import setup
from .. import constants as c
from . import score
class Coin(pg.sprite.Sprite):
"""Coins found in boxes and bricks"""
def __init__(self, x, y, score_group):
pg.sprite.Sprite.__init__(self)
self.sprite_sheet = setup.GFX['item_objects']
self.frames = []
self.frame_index = 0
self.animation_timer = 0
self.state = c.SPIN
self.setup_frames()
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.centerx = x
self.rect.bottom = y - 5
self.gravity = 1
self.y_vel = -15
self.initial_height = self.rect.bottom - 5
self.score_group = score_group
def get_image(self, x, y, width, height):
"""Get the image frames from the sprite sheet"""
image = pg.Surface([width, height]).convert()
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.SIZE_MULTIPLIER),
int(rect.height*c.SIZE_MULTIPLIER)))
return image
def setup_frames(self):
"""create the frame list"""
self.frames.append(self.get_image(52, 113, 8, 14))
self.frames.append(self.get_image(4, 113, 8, 14))
self.frames.append(self.get_image(20, 113, 8, 14))
self.frames.append(self.get_image(36, 113, 8, 14))
def update(self, game_info, viewport):
"""Update the coin's behavior"""
self.current_time = game_info[c.CURRENT_TIME]
self.viewport = viewport
if self.state == c.SPIN:
self.spinning()
def spinning(self):
"""Action when the coin is in the SPIN state"""
self.image = self.frames[self.frame_index]
self.rect.y += self.y_vel
self.y_vel += self.gravity
if (self.current_time - self.animation_timer) > 80:
if self.frame_index < 3:
self.frame_index += 1
else:
self.frame_index = 0
self.animation_timer = self.current_time
if self.rect.bottom > self.initial_height:
self.kill()
self.score_group.append(score.Score(self.rect.centerx - self.viewport.x,
self.rect.y,
200))
#coin_box.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import setup
from .. import constants as c
from . import powerups
from . import coin
class Coin_box(pg.sprite.Sprite):
"""Coin box sprite"""
def __init__(self, x, y, contents='coin', group=None):
pg.sprite.Sprite.__init__(self)
self.sprite_sheet = setup.GFX['tile_set']
self.frames = []
self.setup_frames()
self.frame_index = 0
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.mask = pg.mask.from_surface(self.image)
self.animation_timer = 0
self.first_half = True # First half of animation cycle
self.state = c.RESTING
self.rest_height = y
self.gravity = 1.2
self.y_vel = 0
self.contents = contents
self.group = group
def get_image(self, x, y, width, height):
"""Extract image from sprite sheet"""
image = pg.Surface([width, height]).convert()
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.BRICK_SIZE_MULTIPLIER),
int(rect.height*c.BRICK_SIZE_MULTIPLIER)))
return image
def setup_frames(self):
"""Create frame list"""
self.frames.append(
self.get_image(384, 0, 16, 16))
self.frames.append(
self.get_image(400, 0, 16, 16))
self.frames.append(
self.get_image(416, 0, 16, 16))
self.frames.append(
self.get_image(432, 0, 16, 16))
def update(self, game_info):
"""Update coin box behavior"""
self.current_time = game_info[c.CURRENT_TIME]
self.handle_states()
def handle_states(self):
"""Determine action based on RESTING, BUMPED or OPENED
state"""
if self.state == c.RESTING:
self.resting()
elif self.state == c.BUMPED:
self.bumped()
elif self.state == c.OPENED:
self.opened()
def resting(self):
"""Action when in the RESTING state"""
if self.first_half:
if self.frame_index == 0:
if (self.current_time - self.animation_timer) > 375:
self.frame_index += 1
self.animation_timer = self.current_time
elif self.frame_index < 2:
if (self.current_time - self.animation_timer) > 125:
self.frame_index += 1
self.animation_timer = self.current_time
elif self.frame_index == 2:
if (self.current_time - self.animation_timer) > 125:
self.frame_index -= 1
self.first_half = False
self.animation_timer = self.current_time
else:
if self.frame_index == 1:
if (self.current_time - self.animation_timer) > 125:
self.frame_index -= 1
self.first_half = True
self.animation_timer = self.current_time
self.image = self.frames[self.frame_index]
def bumped(self):
"""Action after Mario has bumped the box from below"""
self.rect.y += self.y_vel
self.y_vel += self.gravity
if self.rect.y > self.rest_height + 5:
self.rect.y = self.rest_height
self.state = c.OPENED
if self.contents == 'mushroom':
self.group.add(powerups.Mushroom(self.rect.centerx, self.rect.y))
elif self.contents == 'fireflower':
self.group.add(powerups.FireFlower(self.rect.centerx, self.rect.y))
elif self.contents == '1up_mushroom':
self.group.add(powerups.LifeMushroom(self.rect.centerx, self.rect.y))
self.frame_index = 3
self.image = self.frames[self.frame_index]
def start_bump(self, score_group):
"""Transitions box into BUMPED state"""
self.y_vel = -6
self.state = c.BUMPED
if self.contents == 'coin':
self.group.add(coin.Coin(self.rect.centerx,
self.rect.y,
score_group))
setup.SFX['coin'].play()
else:
setup.SFX['powerup_appears'].play()
def opened(self):
"""Placeholder for OPENED state"""
pass
#collider.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import constants as c
class Collider(pg.sprite.Sprite):
"""Invisible sprites placed overtop background parts
that can be collided with (pipes, steps, ground, etc."""
def __init__(self, x, y, width, height, name='collider'):
pg.sprite.Sprite.__init__(self)
self.image = pg.Surface((width, height)).convert()
#self.image.fill(c.RED)
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.state = None
#enemies.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import setup
from .. import constants as c
class Enemy(pg.sprite.Sprite):
"""Base class for all enemies (Goombas, Koopas, etc.)"""
def __init__(self):
pg.sprite.Sprite.__init__(self)
def setup_enemy(self, x, y, direction, name, setup_frames):
"""Sets up various values for enemy"""
self.sprite_sheet = setup.GFX['smb_enemies_sheet']
self.frames = []
self.frame_index = 0
self.animate_timer = 0
self.death_timer = 0
self.gravity = 1.5
self.state = c.WALK
self.name = name
self.direction = direction
setup_frames()
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.bottom = y
self.set_velocity()
def set_velocity(self):
"""Sets velocity vector based on direction"""
if self.direction == c.LEFT:
self.x_vel = -2
else:
self.x_vel = 2
self.y_vel = 0
def get_image(self, x, y, width, height):
"""Get the image frames from the sprite sheet"""
image = pg.Surface([width, height]).convert()
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.SIZE_MULTIPLIER),
int(rect.height*c.SIZE_MULTIPLIER)))
return image
def handle_state(self):
"""Enemy behavior based on state"""
if self.state == c.WALK:
self.walking()
elif self.state == c.FALL:
self.falling()
elif self.state == c.JUMPED_ON:
self.jumped_on()
elif self.state == c.SHELL_SLIDE:
self.shell_sliding()
elif self.state == c.DEATH_JUMP:
self.death_jumping()
def walking(self):
"""Default state of moving sideways"""
if (self.current_time - self.animate_timer) > 125:
if self.frame_index == 0:
self.frame_index += 1
elif self.frame_index == 1:
self.frame_index = 0
self.animate_timer = self.current_time
def falling(self):
"""For when it falls off a ledge"""
if self.y_vel < 10:
self.y_vel += self.gravity
def jumped_on(self):
"""Placeholder for when the enemy is stomped on"""
pass
def death_jumping(self):
"""Death animation"""
self.rect.y += self.y_vel
self.rect.x += self.x_vel
self.y_vel += self.gravity
if self.rect.y > 600:
self.kill()
def start_death_jump(self, direction):
"""Transitions enemy into a DEATH JUMP state"""
self.y_vel = -8
if direction == c.RIGHT:
self.x_vel = 2
else:
self.x_vel = -2
self.gravity = .5
self.frame_index = 3
self.image = self.frames[self.frame_index]
self.state = c.DEATH_JUMP
def animation(self):
"""Basic animation, switching between two frames"""
self.image = self.frames[self.frame_index]
def update(self, game_info, *args):
"""Updates enemy behavior"""
self.current_time = game_info[c.CURRENT_TIME]
self.handle_state()
self.animation()
class Goomba(Enemy):
def __init__(self, y=c.GROUND_HEIGHT, x=0, direction=c.LEFT, name='goomba'):
Enemy.__init__(self)
self.setup_enemy(x, y, direction, name, self.setup_frames)
def setup_frames(self):
"""Put the image frames in a list to be animated"""
self.frames.append(
self.get_image(0, 4, 16, 16))
self.frames.append(
self.get_image(30, 4, 16, 16))
self.frames.append(
self.get_image(61, 0, 16, 16))
self.frames.append(pg.transform.flip(self.frames[1], False, True))
def jumped_on(self):
"""When Mario squishes him"""
self.frame_index = 2
if (self.current_time - self.death_timer) > 500:
self.kill()
class Koopa(Enemy):
def __init__(self, y=c.GROUND_HEIGHT, x=0, direction=c.LEFT, name='koopa'):
Enemy.__init__(self)
self.setup_enemy(x, y, direction, name, self.setup_frames)
def setup_frames(self):
"""Sets frame list"""
self.frames.append(
self.get_image(150, 0, 16, 24))
self.frames.append(
self.get_image(180, 0, 16, 24))
self.frames.append(
self.get_image(360, 5, 16, 15))
self.frames.append(pg.transform.flip(self.frames[2], False, True))
def jumped_on(self):
"""When Mario jumps on the Koopa and puts him in his shell"""
self.x_vel = 0
self.frame_index = 2
shell_y = self.rect.bottom
shell_x = self.rect.x
self.rect = self.frames[self.frame_index].get_rect()
self.rect.x = shell_x
self.rect.bottom = shell_y
def shell_sliding(self):
"""When the koopa is sliding along the ground in his shell"""
if self.direction == c.RIGHT:
self.x_vel = 10
elif self.direction == c.LEFT:
self.x_vel = -10
#flagpole.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import setup
from .. import constants as c
class Flag(pg.sprite.Sprite):
"""Flag on top of the flag pole at the end of the level"""
def __init__(self, x, y):
super(Flag, self).__init__()
self.sprite_sheet = setup.GFX['item_objects']
self.setup_images()
self.image = self.frames[0]
self.rect = self.image.get_rect()
self.rect.right = x
self.rect.y = y
self.state = c.TOP_OF_POLE
def setup_images(self):
"""Sets up a list of image frames"""
self.frames = []
self.frames.append(
self.get_image(128, 32, 16, 16))
def get_image(self, x, y, width, height):
"""Extracts image from sprite sheet"""
image = pg.Surface([width, height])
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.BRICK_SIZE_MULTIPLIER),
int(rect.height*c.BRICK_SIZE_MULTIPLIER)))
return image
def update(self, *args):
"""Updates behavior"""
self.handle_state()
def handle_state(self):
"""Determines behavior based on state"""
if self.state == c.TOP_OF_POLE:
self.image = self.frames[0]
elif self.state == c.SLIDE_DOWN:
self.sliding_down()
elif self.state == c.BOTTOM_OF_POLE:
self.image = self.frames[0]
def sliding_down(self):
"""State when Mario reaches flag pole"""
self.y_vel = 5
self.rect.y += self.y_vel
if self.rect.bottom >= 485:
self.state = c.BOTTOM_OF_POLE
class Pole(pg.sprite.Sprite):
"""Pole that the flag is on top of"""
def __init__(self, x, y):
super(Pole, self).__init__()
self.sprite_sheet = setup.GFX['tile_set']
self.setup_frames()
self.image = self.frames[0]
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
def setup_frames(self):
"""Create the frame list"""
self.frames = []
self.frames.append(
self.get_image(263, 144, 2, 16))
def get_image(self, x, y, width, height):
"""Extracts image from sprite sheet"""
image = pg.Surface([width, height])
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.BRICK_SIZE_MULTIPLIER),
int(rect.height*c.BRICK_SIZE_MULTIPLIER)))
return image
def update(self, *args):
"""Placeholder for update, since there is nothing to update"""
pass
class Finial(pg.sprite.Sprite):
"""The top of the flag pole"""
def __init__(self, x, y):
super(Finial, self).__init__()
self.sprite_sheet = setup.GFX['tile_set']
self.setup_frames()
self.image = self.frames[0]
self.rect = self.image.get_rect()
self.rect.centerx = x
self.rect.bottom = y
def setup_frames(self):
"""Creates the self.frames list"""
self.frames = []
self.frames.append(
self.get_image(228, 120, 8, 8))
def get_image(self, x, y, width, height):
"""Extracts image from sprite sheet"""
image = pg.Surface([width, height])
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.SIZE_MULTIPLIER),
int(rect.height*c.SIZE_MULTIPLIER)))
return image
def update(self, *args):
pass
#flashing_coin.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import setup
from .. import constants as c
class Coin(pg.sprite.Sprite):
"""Flashing coin next to coin total info"""
def __init__(self, x, y):
super(Coin, self).__init__()
self.sprite_sheet = setup.GFX['item_objects']
self.create_frames()
self.image = self.frames[0]
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.timer = 0
self.first_half = True
self.frame_index = 0
def create_frames(self):
"""Extract coin images from sprite sheet and assign them to a list"""
self.frames = []
self.frame_index = 0
self.frames.append(self.get_image(1, 160, 5, 8))
self.frames.append(self.get_image(9, 160, 5, 8))
self.frames.append(self.get_image(17, 160, 5, 8))
def get_image(self, x, y, width, height):
"""Extracts image from sprite sheet"""
image = pg.Surface([width, height])
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.BRICK_SIZE_MULTIPLIER),
int(rect.height*c.BRICK_SIZE_MULTIPLIER)))
return image
def update(self, current_time):
"""Animates flashing coin"""
if self.first_half:
if self.frame_index == 0:
if (current_time - self.timer) > 375:
self.frame_index += 1
self.timer = current_time
elif self.frame_index < 2:
if (current_time - self.timer) > 125:
self.frame_index += 1
self.timer = current_time
elif self.frame_index == 2:
if (current_time - self.timer) > 125:
self.frame_index -= 1
self.first_half = False
self.timer = current_time
else:
if self.frame_index == 1:
if (current_time - self.timer) > 125:
self.frame_index -= 1
self.first_half = True
self.timer = current_time
self.image = self.frames[self.frame_index]
#info.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import setup
from .. import constants as c
from . import flashing_coin
class Character(pg.sprite.Sprite):
"""Parent class for all characters used for the overhead level info"""
def __init__(self, image):
super(Character, self).__init__()
self.image = image
self.rect = self.image.get_rect()
class OverheadInfo(object):
"""Class for level information like score, coin total,
and time remaining"""
def __init__(self, game_info, state):
self.sprite_sheet = setup.GFX['text_images']
self.coin_total = game_info[c.COIN_TOTAL]
self.time = 401
self.current_time = 0
self.total_lives = game_info[c.LIVES]
self.top_score = game_info[c.TOP_SCORE]
self.state = state
self.special_state = None
self.game_info = game_info
self.create_image_dict()
self.create_score_group()
self.create_info_labels()
self.create_load_screen_labels()
self.create_countdown_clock()
self.create_coin_counter()
self.create_flashing_coin()
self.create_mario_image()
self.create_game_over_label()
self.create_time_out_label()
self.create_main_menu_labels()
def create_image_dict(self):
"""Creates the initial images for the score"""
self.image_dict = {}
image_list = []
image_list.append(self.get_image(3, 230, 7, 7))
image_list.append(self.get_image(12, 230, 7, 7))
image_list.append(self.get_image(19, 230, 7, 7))
image_list.append(self.get_image(27, 230, 7, 7))
image_list.append(self.get_image(35, 230, 7, 7))
image_list.append(self.get_image(43, 230, 7, 7))
image_list.append(self.get_image(51, 230, 7, 7))
image_list.append(self.get_image(59, 230, 7, 7))
image_list.append(self.get_image(67, 230, 7, 7))
image_list.append(self.get_image(75, 230, 7, 7))
image_list.append(self.get_image(83, 230, 7, 7))
image_list.append(self.get_image(91, 230, 7, 7))
image_list.append(self.get_image(99, 230, 7, 7))
image_list.append(self.get_image(107, 230, 7, 7))
image_list.append(self.get_image(115, 230, 7, 7))
image_list.append(self.get_image(123, 230, 7, 7))
image_list.append(self.get_image(3, 238, 7, 7))
image_list.append(self.get_image(11, 238, 7, 7))
image_list.append(self.get_image(20, 238, 7, 7))
image_list.append(self.get_image(27, 238, 7, 7))
image_list.append(self.get_image(35, 238, 7, 7))
image_list.append(self.get_image(44, 238, 7, 7))
image_list.append(self.get_image(51, 238, 7, 7))
image_list.append(self.get_image(59, 238, 7, 7))
image_list.append(self.get_image(67, 238, 7, 7))
image_list.append(self.get_image(75, 238, 7, 7))
image_list.append(self.get_image(83, 238, 7, 7))
image_list.append(self.get_image(91, 238, 7, 7))
image_list.append(self.get_image(99, 238, 7, 7))
image_list.append(self.get_image(108, 238, 7, 7))
image_list.append(self.get_image(115, 238, 7, 7))
image_list.append(self.get_image(123, 238, 7, 7))
image_list.append(self.get_image(3, 246, 7, 7))
image_list.append(self.get_image(11, 246, 7, 7))
image_list.append(self.get_image(20, 246, 7, 7))
image_list.append(self.get_image(27, 246, 7, 7))
image_list.append(self.get_image(48, 248, 7, 7))
image_list.append(self.get_image(68, 249, 6, 2))
image_list.append(self.get_image(75, 247, 6, 6))
character_string = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ -*'
for character, image in zip(character_string, image_list):
self.image_dict[character] = image
def get_image(self, x, y, width, height):
"""Extracts image from sprite sheet"""
image = pg.Surface([width, height])
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey((92, 148, 252))
image = pg.transform.scale(image,
(int(rect.width*2.9),
int(rect.height*2.9)))
return image
def create_score_group(self):
"""Creates the initial empty score (000000)"""
self.score_images = []
self.create_label(self.score_images, '000000', 75, 55)
def create_info_labels(self):
"""Creates the labels that describe each info"""
self.mario_label = []
self.world_label = []
self.time_label = []
self.stage_label = []
self.create_label(self.mario_label, 'MARIO', 75, 30)
self.create_label(self.world_label, 'WORLD', 450, 30)
self.create_label(self.time_label, 'TIME', 625, 30)
self.create_label(self.stage_label, '1-1', 472, 55)
self.label_list = [self.mario_label,
self.world_label,
self.time_label,
self.stage_label]
def create_load_screen_labels(self):
"""Creates labels for the center info of a load screen"""
world_label = []
number_label = []
self.create_label(world_label, 'WORLD', 280, 200)
self.create_label(number_label, '1-1', 430, 200)
self.center_labels = [world_label, number_label]
def create_countdown_clock(self):
"""Creates the count down clock for the level"""
self.count_down_images = []
self.create_label(self.count_down_images, str(self.time), 645, 55)
def create_label(self, label_list, string, x, y):
"""Creates a label (WORLD, TIME, MARIO)"""
for letter in string:
label_list.append(Character(self.image_dict[letter]))
self.set_label_rects(label_list, x, y)
def set_label_rects(self, label_list, x, y):
"""Set the location of each individual character"""
for i, letter in enumerate(label_list):
letter.rect.x = x + ((letter.rect.width + 3) * i)
letter.rect.y = y
if letter.image == self.image_dict['-']:
letter.rect.y += 7
letter.rect.x += 2
def create_coin_counter(self):
"""Creates the info that tracks the number of coins Mario collects"""
self.coin_count_images = []
self.create_label(self.coin_count_images, '*00', 300, 55)
def create_flashing_coin(self):
"""Creates the flashing coin next to the coin total"""
self.flashing_coin = flashing_coin.Coin(280, 53)
def create_mario_image(self):
"""Get the mario image"""
self.life_times_image = self.get_image(75, 247, 6, 6)
self.life_times_rect = self.life_times_image.get_rect(center=(378, 295))
self.life_total_label = []
self.create_label(self.life_total_label, str(self.total_lives),
450, 285)
self.sprite_sheet = setup.GFX['mario_bros']
self.mario_image = self.get_image(178, 32, 12, 16)
self.mario_rect = self.mario_image.get_rect(center=(320, 290))
def create_game_over_label(self):
"""Create the label for the GAME OVER screen"""
game_label = []
over_label = []
self.create_label(game_label, 'GAME', 280, 300)
self.create_label(over_label, 'OVER', 400, 300)
self.game_over_label = [game_label, over_label]
def create_time_out_label(self):
"""Create the label for the time out screen"""
time_out_label = []
self.create_label(time_out_label, 'TIME OUT', 290, 310)
self.time_out_label = [time_out_label]
def create_main_menu_labels(self):
"""Create labels for the MAIN MENU screen"""
player_one_game = []
player_two_game = []
top = []
top_score = []
self.create_label(player_one_game, '1 PLAYER GAME', 272, 360)
self.create_label(player_two_game, '2 PLAYER GAME', 272, 405)
self.create_label(top, 'TOP - ', 290, 465)
self.create_label(top_score, '000000', 400, 465)
self.main_menu_labels = [player_one_game, player_two_game,
top, top_score]
def update(self, level_info, mario=None):
"""Updates all overhead info"""
self.mario = mario
self.handle_level_state(level_info)
def handle_level_state(self, level_info):
"""Updates info based on what state the game is in"""
if self.state == c.MAIN_MENU:
self.score = level_info[c.SCORE]
self.update_score_images(self.score_images, self.score)
self.update_score_images(self.main_menu_labels[3], self.top_score)
self.update_coin_total(level_info)
self.flashing_coin.update(level_info[c.CURRENT_TIME])
elif self.state == c.LOAD_SCREEN:
self.score = level_info[c.SCORE]
self.update_score_images(self.score_images, self.score)
self.update_coin_total(level_info)
elif self.state == c.LEVEL:
self.score = level_info[c.SCORE]
self.update_score_images(self.score_images, self.score)
if level_info[c.LEVEL_STATE] != c.FROZEN \
and self.mario.state != c.WALKING_TO_CASTLE \
and self.mario.state != c.END_OF_LEVEL_FALL \
and not self.mario.dead:
self.update_count_down_clock(level_info)
self.update_coin_total(level_info)
self.flashing_coin.update(level_info[c.CURRENT_TIME])
elif self.state == c.TIME_OUT:
self.score = level_info[c.SCORE]
self.update_score_images(self.score_images, self.score)
self.update_coin_total(level_info)
elif self.state == c.GAME_OVER:
self.score = level_info[c.SCORE]
self.update_score_images(self.score_images, self.score)
self.update_coin_total(level_info)
elif self.state == c.FAST_COUNT_DOWN:
level_info[c.SCORE] += 50
self.score = level_info[c.SCORE]
self.update_count_down_clock(level_info)
self.update_score_images(self.score_images, self.score)
self.update_coin_total(level_info)
self.flashing_coin.update(level_info[c.CURRENT_TIME])
if self.time == 0:
self.state = c.END_OF_LEVEL
elif self.state == c.END_OF_LEVEL:
self.flashing_coin.update(level_info[c.CURRENT_TIME])
def update_score_images(self, images, score):
"""Updates what numbers are to be blitted for the score"""
index = len(images) - 1
for digit in reversed(str(score)):
rect = images[index].rect
images[index] = Character(self.image_dict[digit])
images[index].rect = rect
index -= 1
def update_count_down_clock(self, level_info):
"""Updates current time"""
if self.state == c.FAST_COUNT_DOWN:
self.time -= 1
elif (level_info[c.CURRENT_TIME] - self.current_time) > 400:
self.current_time = level_info[c.CURRENT_TIME]
self.time -= 1
self.count_down_images = []
self.create_label(self.count_down_images, str(self.time), 645, 55)
if len(self.count_down_images) < 2:
for i in range(2):
self.count_down_images.insert(0, Character(self.image_dict['0']))
self.set_label_rects(self.count_down_images, 645, 55)
elif len(self.count_down_images) < 3:
self.count_down_images.insert(0, Character(self.image_dict['0']))
self.set_label_rects(self.count_down_images, 645, 55)
def update_coin_total(self, level_info):
"""Updates the coin total and adjusts label accordingly"""
self.coin_total = level_info[c.COIN_TOTAL]
coin_string = str(self.coin_total)
if len(coin_string) < 2:
coin_string = '*0' + coin_string
elif len(coin_string) > 2:
coin_string = '*00'
else:
coin_string = '*' + coin_string
x = self.coin_count_images[0].rect.x
y = self.coin_count_images[0].rect.y
self.coin_count_images = []
self.create_label(self.coin_count_images, coin_string, x, y)
def draw(self, surface):
"""Draws overhead info based on state"""
if self.state == c.MAIN_MENU:
self.draw_main_menu_info(surface)
elif self.state == c.LOAD_SCREEN:
self.draw_loading_screen_info(surface)
elif self.state == c.LEVEL:
self.draw_level_screen_info(surface)
elif self.state == c.GAME_OVER:
self.draw_game_over_screen_info(surface)
elif self.state == c.FAST_COUNT_DOWN:
self.draw_level_screen_info(surface)
elif self.state == c.END_OF_LEVEL:
self.draw_level_screen_info(surface)
elif self.state == c.TIME_OUT:
self.draw_time_out_screen_info(surface)
else:
pass
def draw_main_menu_info(self, surface):
"""Draws info for main menu"""
for info in self.score_images:
surface.blit(info.image, info.rect)
for label in self.main_menu_labels:
for letter in label:
surface.blit(letter.image, letter.rect)
for character in self.coin_count_images:
surface.blit(character.image, character.rect)
for label in self.label_list:
for letter in label:
surface.blit(letter.image, letter.rect)
surface.blit(self.flashing_coin.image, self.flashing_coin.rect)
def draw_loading_screen_info(self, surface):
"""Draws info for loading screen"""
for info in self.score_images:
surface.blit(info.image, info.rect)
for word in self.center_labels:
for letter in word:
surface.blit(letter.image, letter.rect)
for word in self.life_total_label:
surface.blit(word.image, word.rect)
surface.blit(self.mario_image, self.mario_rect)
surface.blit(self.life_times_image, self.life_times_rect)
for character in self.coin_count_images:
surface.blit(character.image, character.rect)
for label in self.label_list:
for letter in label:
surface.blit(letter.image, letter.rect)
surface.blit(self.flashing_coin.image, self.flashing_coin.rect)
def draw_level_screen_info(self, surface):
"""Draws info during regular game play"""
for info in self.score_images:
surface.blit(info.image, info.rect)
for digit in self.count_down_images:
surface.blit(digit.image, digit.rect)
for character in self.coin_count_images:
surface.blit(character.image, character.rect)
for label in self.label_list:
for letter in label:
surface.blit(letter.image, letter.rect)
surface.blit(self.flashing_coin.image, self.flashing_coin.rect)
def draw_game_over_screen_info(self, surface):
"""Draws info when game over"""
for info in self.score_images:
surface.blit(info.image, info.rect)
for word in self.game_over_label:
for letter in word:
surface.blit(letter.image, letter.rect)
for character in self.coin_count_images:
surface.blit(character.image, character.rect)
for label in self.label_list:
for letter in label:
surface.blit(letter.image, letter.rect)
surface.blit(self.flashing_coin.image, self.flashing_coin.rect)
def draw_time_out_screen_info(self, surface):
"""Draws info when on the time out screen"""
for info in self.score_images:
surface.blit(info.image, info.rect)
for word in self.time_out_label:
for letter in word:
surface.blit(letter.image, letter.rect)
for character in self.coin_count_images:
surface.blit(character.image, character.rect)
for label in self.label_list:
for letter in label:
surface.blit(letter.image, letter.rect)
surface.blit(self.flashing_coin.image, self.flashing_coin.rect)
#mario.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import setup, tools
from .. import constants as c
from . import powerups
class Mario(pg.sprite.Sprite):
def __init__(self):
pg.sprite.Sprite.__init__(self)
self.sprite_sheet = setup.GFX['mario_bros']
self.setup_timers()
self.setup_state_booleans()
self.setup_forces()
self.setup_counters()
self.load_images_from_sheet()
self.state = c.WALK
self.image = self.right_frames[self.frame_index]
self.rect = self.image.get_rect()
self.mask = pg.mask.from_surface(self.image)
self.key_timer = 0
def setup_timers(self):
"""Sets up timers for animations"""
self.walking_timer = 0
self.invincible_animation_timer = 0
self.invincible_start_timer = 0
self.fire_transition_timer = 0
self.death_timer = 0
self.transition_timer = 0
self.last_fireball_time = 0
self.hurt_invisible_timer = 0
self.hurt_invisible_timer2 = 0
self.flag_pole_timer = 0
def setup_state_booleans(self):
"""Sets up booleans that affect Mario's behavior"""
self.facing_right = True
self.allow_jump = True
self.dead = False
self.invincible = False
self.big = False
self.fire = False
self.allow_fireball = True
self.in_transition_state = False
self.hurt_invincible = False
self.in_castle = False
self.crouching = False
self.losing_invincibility = False
def setup_forces(self):
"""Sets up forces that affect Mario's velocity"""
self.x_vel = 0
self.y_vel = 0
self.max_x_vel = c.MAX_WALK_SPEED
self.max_y_vel = c.MAX_Y_VEL
self.x_accel = c.WALK_ACCEL
self.jump_vel = c.JUMP_VEL
self.gravity = c.GRAVITY
def setup_counters(self):
"""These keep track of various total for important values"""
self.frame_index = 0
self.invincible_index = 0
self.fire_transition_index = 0
self.fireball_count = 0
self.flag_pole_right = 0
def load_images_from_sheet(self):
"""Extracts Mario images from his sprite sheet and assigns
them to appropriate lists"""
self.right_frames = []
self.left_frames = []
self.right_small_normal_frames = []
self.left_small_normal_frames = []
self.right_small_green_frames = []
self.left_small_green_frames = []
self.right_small_red_frames = []
self.left_small_red_frames = []
self.right_small_black_frames = []
self.left_small_black_frames = []
self.right_big_normal_frames = []
self.left_big_normal_frames = []
self.right_big_green_frames = []
self.left_big_green_frames = []
self.right_big_red_frames = []
self.left_big_red_frames = []
self.right_big_black_frames = []
self.left_big_black_frames = []
self.right_fire_frames = []
self.left_fire_frames = []
#Images for normal small mario#
self.right_small_normal_frames.append(
self.get_image(178, 32, 12, 16)) # Right [0]
self.right_small_normal_frames.append(
self.get_image(80, 32, 15, 16)) # Right walking 1 [1]
self.right_small_normal_frames.append(
self.get_image(96, 32, 16, 16)) # Right walking 2 [2]
self.right_small_normal_frames.append(
self.get_image(112, 32, 16, 16)) # Right walking 3 [3]
self.right_small_normal_frames.append(
self.get_image(144, 32, 16, 16)) # Right jump [4]
self.right_small_normal_frames.append(
self.get_image(130, 32, 14, 16)) # Right skid [5]
self.right_small_normal_frames.append(
self.get_image(160, 32, 15, 16)) # Death frame [6]
self.right_small_normal_frames.append(
self.get_image(320, 8, 16, 24)) # Transition small to big [7]
self.right_small_normal_frames.append(
self.get_image(241, 33, 16, 16)) # Transition big to small [8]
self.right_small_normal_frames.append(
self.get_image(194, 32, 12, 16)) # Frame 1 of flag pole Slide [9]
self.right_small_normal_frames.append(
self.get_image(210, 33, 12, 16)) # Frame 2 of flag pole slide [10]
#Images for small green mario (for invincible animation)#
self.right_small_green_frames.append(
self.get_image(178, 224, 12, 16)) # Right standing [0]
self.right_small_green_frames.append(
self.get_image(80, 224, 15, 16)) # Right walking 1 [1]
self.right_small_green_frames.append(
self.get_image(96, 224, 16, 16)) # Right walking 2 [2]
self.right_small_green_frames.append(
self.get_image(112, 224, 15, 16)) # Right walking 3 [3]
self.right_small_green_frames.append(
self.get_image(144, 224, 16, 16)) # Right jump [4]
self.right_small_green_frames.append(
self.get_image(130, 224, 14, 16)) # Right skid [5]
#Images for red mario (for invincible animation)#
self.right_small_red_frames.append(
self.get_image(178, 272, 12, 16)) # Right standing [0]
self.right_small_red_frames.append(
self.get_image(80, 272, 15, 16)) # Right walking 1 [1]
self.right_small_red_frames.append(
self.get_image(96, 272, 16, 16)) # Right walking 2 [2]
self.right_small_red_frames.append(
self.get_image(112, 272, 15, 16)) # Right walking 3 [3]
self.right_small_red_frames.append(
self.get_image(144, 272, 16, 16)) # Right jump [4]
self.right_small_red_frames.append(
self.get_image(130, 272, 14, 16)) # Right skid [5]
#Images for black mario (for invincible animation)#
self.right_small_black_frames.append(
self.get_image(178, 176, 12, 16)) # Right standing [0]
self.right_small_black_frames.append(
self.get_image(80, 176, 15, 16)) # Right walking 1 [1]
self.right_small_black_frames.append(
self.get_image(96, 176, 16, 16)) # Right walking 2 [2]
self.right_small_black_frames.append(
self.get_image(112, 176, 15, 16)) # Right walking 3 [3]
self.right_small_black_frames.append(
self.get_image(144, 176, 16, 16)) # Right jump [4]
self.right_small_black_frames.append(
self.get_image(130, 176, 14, 16)) # Right skid [5]
#Images for normal big Mario
self.right_big_normal_frames.append(
self.get_image(176, 0, 16, 32)) # Right standing [0]
self.right_big_normal_frames.append(
self.get_image(81, 0, 16, 32)) # Right walking 1 [1]
self.right_big_normal_frames.append(
self.get_image(97, 0, 15, 32)) # Right walking 2 [2]
self.right_big_normal_frames.append(
self.get_image(113, 0, 15, 32)) # Right walking 3 [3]
self.right_big_normal_frames.append(
self.get_image(144, 0, 16, 32)) # Right jump [4]
self.right_big_normal_frames.append(
self.get_image(128, 0, 16, 32)) # Right skid [5]
self.right_big_normal_frames.append(
self.get_image(336, 0, 16, 32)) # Right throwing [6]
self.right_big_normal_frames.append(
self.get_image(160, 10, 16, 22)) # Right crouching [7]
self.right_big_normal_frames.append(
self.get_image(272, 2, 16, 29)) # Transition big to small [8]
self.right_big_normal_frames.append(
self.get_image(193, 2, 16, 30)) # Frame 1 of flag pole slide [9]
self.right_big_normal_frames.append(
self.get_image(209, 2, 16, 29)) # Frame 2 of flag pole slide [10]
#Images for green big Mario#
self.right_big_green_frames.append(
self.get_image(176, 192, 16, 32)) # Right standing [0]
self.right_big_green_frames.append(
self.get_image(81, 192, 16, 32)) # Right walking 1 [1]
self.right_big_green_frames.append(
self.get_image(97, 192, 15, 32)) # Right walking 2 [2]
self.right_big_green_frames.append(
self.get_image(113, 192, 15, 32)) # Right walking 3 [3]
self.right_big_green_frames.append(
self.get_image(144, 192, 16, 32)) # Right jump [4]
self.right_big_green_frames.append(
self.get_image(128, 192, 16, 32)) # Right skid [5]
self.right_big_green_frames.append(
self.get_image(336, 192, 16, 32)) # Right throwing [6]
self.right_big_green_frames.append(
self.get_image(160, 202, 16, 22)) # Right Crouching [7]
#Images for red big Mario#
self.right_big_red_frames.append(
self.get_image(176, 240, 16, 32)) # Right standing [0]
self.right_big_red_frames.append(
self.get_image(81, 240, 16, 32)) # Right walking 1 [1]
self.right_big_red_frames.append(
self.get_image(97, 240, 15, 32)) # Right walking 2 [2]
self.right_big_red_frames.append(
self.get_image(113, 240, 15, 32)) # Right walking 3 [3]
self.right_big_red_frames.append(
self.get_image(144, 240, 16, 32)) # Right jump [4]
self.right_big_red_frames.append(
self.get_image(128, 240, 16, 32)) # Right skid [5]
self.right_big_red_frames.append(
self.get_image(336, 240, 16, 32)) # Right throwing [6]
self.right_big_red_frames.append(
self.get_image(160, 250, 16, 22)) # Right crouching [7]
#Images for black big Mario#
self.right_big_black_frames.append(
self.get_image(176, 144, 16, 32)) # Right standing [0]
self.right_big_black_frames.append(
self.get_image(81, 144, 16, 32)) # Right walking 1 [1]
self.right_big_black_frames.append(
self.get_image(97, 144, 15, 32)) # Right walking 2 [2]
self.right_big_black_frames.append(
self.get_image(113, 144, 15, 32)) # Right walking 3 [3]
self.right_big_black_frames.append(
self.get_image(144, 144, 16, 32)) # Right jump [4]
self.right_big_black_frames.append(
self.get_image(128, 144, 16, 32)) # Right skid [5]
self.right_big_black_frames.append(
self.get_image(336, 144, 16, 32)) # Right throwing [6]
self.right_big_black_frames.append(
self.get_image(160, 154, 16, 22)) # Right Crouching [7]
#Images for Fire Mario#
self.right_fire_frames.append(
self.get_image(176, 48, 16, 32)) # Right standing [0]
self.right_fire_frames.append(
self.get_image(81, 48, 16, 32)) # Right walking 1 [1]
self.right_fire_frames.append(
self.get_image(97, 48, 15, 32)) # Right walking 2 [2]
self.right_fire_frames.append(
self.get_image(113, 48, 15, 32)) # Right walking 3 [3]
self.right_fire_frames.append(
self.get_image(144, 48, 16, 32)) # Right jump [4]
self.right_fire_frames.append(
self.get_image(128, 48, 16, 32)) # Right skid [5]
self.right_fire_frames.append(
self.get_image(336, 48, 16, 32)) # Right throwing [6]
self.right_fire_frames.append(
self.get_image(160, 58, 16, 22)) # Right crouching [7]
self.right_fire_frames.append(
self.get_image(0, 0, 0, 0)) # Place holder [8]
self.right_fire_frames.append(
self.get_image(193, 50, 16, 29)) # Frame 1 of flag pole slide [9]
self.right_fire_frames.append(
self.get_image(209, 50, 16, 29)) # Frame 2 of flag pole slide [10]
#The left image frames are numbered the same as the right
#frames but are simply reversed.
for frame in self.right_small_normal_frames:
new_image = pg.transform.flip(frame, True, False)
self.left_small_normal_frames.append(new_image)
for frame in self.right_small_green_frames:
new_image = pg.transform.flip(frame, True, False)
self.left_small_green_frames.append(new_image)
for frame in self.right_small_red_frames:
new_image = pg.transform.flip(frame, True, False)
self.left_small_red_frames.append(new_image)
for frame in self.right_small_black_frames:
new_image = pg.transform.flip(frame, True, False)
self.left_small_black_frames.append(new_image)
for frame in self.right_big_normal_frames:
new_image = pg.transform.flip(frame, True, False)
self.left_big_normal_frames.append(new_image)
for frame in self.right_big_green_frames:
new_image = pg.transform.flip(frame, True, False)
self.left_big_green_frames.append(new_image)
for frame in self.right_big_red_frames:
new_image = pg.transform.flip(frame, True, False)
self.left_big_red_frames.append(new_image)
for frame in self.right_big_black_frames:
new_image = pg.transform.flip(frame, True, False)
self.left_big_black_frames.append(new_image)
for frame in self.right_fire_frames:
new_image = pg.transform.flip(frame, True, False)
self.left_fire_frames.append(new_image)
self.normal_small_frames = [self.right_small_normal_frames,
self.left_small_normal_frames]
self.green_small_frames = [self.right_small_green_frames,
self.left_small_green_frames]
self.red_small_frames = [self.right_small_red_frames,
self.left_small_red_frames]
self.black_small_frames = [self.right_small_black_frames,
self.left_small_black_frames]
self.invincible_small_frames_list = [self.normal_small_frames,
self.green_small_frames,
self.red_small_frames,
self.black_small_frames]
self.normal_big_frames = [self.right_big_normal_frames,
self.left_big_normal_frames]
self.green_big_frames = [self.right_big_green_frames,
self.left_big_green_frames]
self.red_big_frames = [self.right_big_red_frames,
self.left_big_red_frames]
self.black_big_frames = [self.right_big_black_frames,
self.left_big_black_frames]
self.fire_frames = [self.right_fire_frames,
self.left_fire_frames]
self.invincible_big_frames_list = [self.normal_big_frames,
self.green_big_frames,
self.red_big_frames,
self.black_big_frames]
self.all_images = [self.right_big_normal_frames,
self.right_big_black_frames,
self.right_big_red_frames,
self.right_big_green_frames,
self.right_small_normal_frames,
self.right_small_green_frames,
self.right_small_red_frames,
self.right_small_black_frames,
self.left_big_normal_frames,
self.left_big_black_frames,
self.left_big_red_frames,
self.left_big_green_frames,
self.left_small_normal_frames,
self.left_small_red_frames,
self.left_small_green_frames,
self.left_small_black_frames]
self.right_frames = self.normal_small_frames[0]
self.left_frames = self.normal_small_frames[1]
def get_image(self, x, y, width, height):
"""Extracts image from sprite sheet"""
image = pg.Surface([width, height])
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.SIZE_MULTIPLIER),
int(rect.height*c.SIZE_MULTIPLIER)))
return image
def update(self, keys, game_info, fire_group):
"""Updates Mario's states and animations once per frame"""
self.current_time = game_info[c.CURRENT_TIME]
self.handle_state(keys, fire_group)
self.check_for_special_state()
self.animation()
def handle_state(self, keys, fire_group):
"""Determines Mario's behavior based on his state"""
if self.state == c.STAND:
self.standing(keys, fire_group)
elif self.state == c.WALK:
self.walking(keys, fire_group)
elif self.state == c.JUMP:
self.jumping(keys, fire_group)
elif self.state == c.FALL:
self.falling(keys, fire_group)
elif self.state == c.DEATH_JUMP:
self.jumping_to_death()
elif self.state == c.SMALL_TO_BIG:
self.changing_to_big()
elif self.state == c.BIG_TO_FIRE:
self.changing_to_fire()
elif self.state == c.BIG_TO_SMALL:
self.changing_to_small()
elif self.state == c.FLAGPOLE:
self.flag_pole_sliding()
elif self.state == c.BOTTOM_OF_POLE:
self.sitting_at_bottom_of_pole()
elif self.state == c.WALKING_TO_CASTLE:
self.walking_to_castle()
elif self.state == c.END_OF_LEVEL_FALL:
self.falling_at_end_of_level()
def standing(self, keys, fire_group):
"""This function is called if Mario is standing still"""
self.check_to_allow_jump(keys)
self.check_to_allow_fireball(keys)
self.frame_index = 0
self.x_vel = 0
self.y_vel = 0
if keys[tools.keybinding['action']]:
if self.fire and self.allow_fireball:
self.shoot_fireball(fire_group)
if keys[tools.keybinding['down']]:
self.crouching = True
if keys[tools.keybinding['left']]:
self.facing_right = False
self.get_out_of_crouch()
self.state = c.WALK
elif keys[tools.keybinding['right']]:
self.facing_right = True
self.get_out_of_crouch()
self.state = c.WALK
elif keys[tools.keybinding['jump']]:
if self.allow_jump:
if self.big:
setup.SFX['big_jump'].play()
else:
setup.SFX['small_jump'].play()
self.state = c.JUMP
self.y_vel = c.JUMP_VEL
else:
self.state = c.STAND
if not keys[tools.keybinding['down']]:
self.get_out_of_crouch()
def get_out_of_crouch(self):
"""Get out of crouch"""
bottom = self.rect.bottom
left = self.rect.x
if self.facing_right:
self.image = self.right_frames[0]
else:
self.image = self.left_frames[0]
self.rect = self.image.get_rect()
self.rect.bottom = bottom
self.rect.x = left
self.crouching = False
def check_to_allow_jump(self, keys):
"""Check to allow Mario to jump"""
if not keys[tools.keybinding['jump']]:
self.allow_jump = True
def check_to_allow_fireball(self, keys):
"""Check to allow the shooting of a fireball"""
if not keys[tools.keybinding['action']]:
self.allow_fireball = True
def shoot_fireball(self, powerup_group):
"""Shoots fireball, allowing no more than two to exist at once"""
setup.SFX['fireball'].play()
self.fireball_count = self.count_number_of_fireballs(powerup_group)
if (self.current_time - self.last_fireball_time) > 200:
if self.fireball_count < 2:
self.allow_fireball = False
powerup_group.add(
powerups.FireBall(self.rect.right, self.rect.y, self.facing_right))
self.last_fireball_time = self.current_time
self.frame_index = 6
if self.facing_right:
self.image = self.right_frames[self.frame_index]
else:
self.image = self.left_frames[self.frame_index]
def count_number_of_fireballs(self, powerup_group):
"""Count number of fireballs that exist in the level"""
fireball_list = []
for powerup in powerup_group:
if powerup.name == c.FIREBALL:
fireball_list.append(powerup)
return len(fireball_list)
def walking(self, keys, fire_group):
"""This function is called when Mario is in a walking state
It changes the frame, checks for holding down the run button,
checks for a jump, then adjusts the state if necessary"""
self.check_to_allow_jump(keys)
self.check_to_allow_fireball(keys)
if self.frame_index == 0:
self.frame_index += 1
self.walking_timer = self.current_time
else:
if (self.current_time - self.walking_timer >
self.calculate_animation_speed()):
if self.frame_index < 3:
self.frame_index += 1
else:
self.frame_index = 1
self.walking_timer = self.current_time
if keys[tools.keybinding['action']]:
self.max_x_vel = c.MAX_RUN_SPEED
self.x_accel = c.RUN_ACCEL
if self.fire and self.allow_fireball:
self.shoot_fireball(fire_group)
else:
self.max_x_vel = c.MAX_WALK_SPEED
self.x_accel = c.WALK_ACCEL
if keys[tools.keybinding['jump']]:
if self.allow_jump:
if self.big:
setup.SFX['big_jump'].play()
else:
setup.SFX['small_jump'].play()
self.state = c.JUMP
if self.x_vel > 4.5 or self.x_vel < -4.5:
self.y_vel = c.JUMP_VEL - .5
else:
self.y_vel = c.JUMP_VEL
if keys[tools.keybinding['left']]:
self.get_out_of_crouch()
self.facing_right = False
if self.x_vel > 0:
self.frame_index = 5
self.x_accel = c.SMALL_TURNAROUND
else:
self.x_accel = c.WALK_ACCEL
if self.x_vel > (self.max_x_vel * -1):
self.x_vel -= self.x_accel
if self.x_vel > -0.5:
self.x_vel = -0.5
elif self.x_vel < (self.max_x_vel * -1):
self.x_vel += self.x_accel
elif keys[tools.keybinding['right']]:
self.get_out_of_crouch()
self.facing_right = True
if self.x_vel < 0:
self.frame_index = 5
self.x_accel = c.SMALL_TURNAROUND
else:
self.x_accel = c.WALK_ACCEL
if self.x_vel < self.max_x_vel:
self.x_vel += self.x_accel
if self.x_vel < 0.5:
self.x_vel = 0.5
elif self.x_vel > self.max_x_vel:
self.x_vel -= self.x_accel
else:
if self.facing_right:
if self.x_vel > 0:
self.x_vel -= self.x_accel
else:
self.x_vel = 0
self.state = c.STAND
else:
if self.x_vel < 0:
self.x_vel += self.x_accel
else:
self.x_vel = 0
self.state = c.STAND
def calculate_animation_speed(self):
"""Used to make walking animation speed be in relation to
Mario's x-vel"""
if self.x_vel == 0:
animation_speed = 130
elif self.x_vel > 0:
animation_speed = 130 - (self.x_vel * (13))
else:
animation_speed = 130 - (self.x_vel * (13) * -1)
return animation_speed
def jumping(self, keys, fire_group):
"""Called when Mario is in a JUMP state."""
self.allow_jump = False
self.frame_index = 4
self.gravity = c.JUMP_GRAVITY
self.y_vel += self.gravity
self.check_to_allow_fireball(keys)
if self.y_vel >= 0 and self.y_vel < self.max_y_vel:
self.gravity = c.GRAVITY
self.state = c.FALL
if keys[tools.keybinding['left']]:
if self.x_vel > (self.max_x_vel * - 1):
self.x_vel -= self.x_accel
elif keys[tools.keybinding['right']]:
if self.x_vel < self.max_x_vel:
self.x_vel += self.x_accel
if not keys[tools.keybinding['jump']]:
self.gravity = c.GRAVITY
self.state = c.FALL
if keys[tools.keybinding['action']]:
if self.fire and self.allow_fireball:
self.shoot_fireball(fire_group)
def falling(self, keys, fire_group):
"""Called when Mario is in a FALL state"""
self.check_to_allow_fireball(keys)
if self.y_vel < c.MAX_Y_VEL:
self.y_vel += self.gravity
if keys[tools.keybinding['left']]:
if self.x_vel > (self.max_x_vel * - 1):
self.x_vel -= self.x_accel
elif keys[tools.keybinding['right']]:
if self.x_vel < self.max_x_vel:
self.x_vel += self.x_accel
if keys[tools.keybinding['action']]:
if self.fire and self.allow_fireball:
self.shoot_fireball(fire_group)
def jumping_to_death(self):
"""Called when Mario is in a DEATH_JUMP state"""
if self.death_timer == 0:
self.death_timer = self.current_time
elif (self.current_time - self.death_timer) > 500:
self.rect.y += self.y_vel
self.y_vel += self.gravity
def start_death_jump(self, game_info):
"""Used to put Mario in a DEATH_JUMP state"""
self.dead = True
game_info[c.MARIO_DEAD] = True
self.y_vel = -11
self.gravity = .5
self.frame_index = 6
self.image = self.right_frames[self.frame_index]
self.state = c.DEATH_JUMP
self.in_transition_state = True
def changing_to_big(self):
"""Changes Mario's image attribute based on time while
transitioning to big"""
self.in_transition_state = True
if self.transition_timer == 0:
self.transition_timer = self.current_time
elif self.timer_between_these_two_times(135, 200):
self.set_mario_to_middle_image()
elif self.timer_between_these_two_times(200, 365):
self.set_mario_to_small_image()
elif self.timer_between_these_two_times(365, 430):
self.set_mario_to_middle_image()
elif self.timer_between_these_two_times(430, 495):
self.set_mario_to_small_image()
elif self.timer_between_these_two_times(495, 560):
self.set_mario_to_middle_image()
elif self.timer_between_these_two_times(560, 625):
self.set_mario_to_big_image()
elif self.timer_between_these_two_times(625, 690):
self.set_mario_to_small_image()
elif self.timer_between_these_two_times(690, 755):
self.set_mario_to_middle_image()
elif self.timer_between_these_two_times(755, 820):
self.set_mario_to_big_image()
elif self.timer_between_these_two_times(820, 885):
self.set_mario_to_small_image()
elif self.timer_between_these_two_times(885, 950):
self.set_mario_to_big_image()
self.state = c.WALK
self.in_transition_state = False
self.transition_timer = 0
self.become_big()
def timer_between_these_two_times(self,start_time, end_time):
"""Checks if the timer is at the right time for the action. Reduces
the ugly code."""
if (self.current_time - self.transition_timer) >= start_time\
and (self.current_time - self.transition_timer) < end_time:
return True
def set_mario_to_middle_image(self):
"""During a change from small to big, sets mario's image to the
transition/middle size"""
if self.facing_right:
self.image = self.normal_small_frames[0][7]
else:
self.image = self.normal_small_frames[1][7]
bottom = self.rect.bottom
centerx = self.rect.centerx
self.rect = self.image.get_rect()
self.rect.bottom = bottom
self.rect.centerx = centerx
def set_mario_to_small_image(self):
"""During a change from small to big, sets mario's image to small"""
if self.facing_right:
self.image = self.normal_small_frames[0][0]
else:
self.image = self.normal_small_frames[1][0]
bottom = self.rect.bottom
centerx = self.rect.centerx
self.rect = self.image.get_rect()
self.rect.bottom = bottom
self.rect.centerx = centerx
def set_mario_to_big_image(self):
"""During a change from small to big, sets mario's image to big"""
if self.facing_right:
self.image = self.normal_big_frames[0][0]
else:
self.image = self.normal_big_frames[1][0]
bottom = self.rect.bottom
centerx = self.rect.centerx
self.rect = self.image.get_rect()
self.rect.bottom = bottom
self.rect.centerx = centerx
def become_big(self):
self.big = True
self.right_frames = self.right_big_normal_frames
self.left_frames = self.left_big_normal_frames
bottom = self.rect.bottom
left = self.rect.x
image = self.right_frames[0]
self.rect = image.get_rect()
self.rect.bottom = bottom
self.rect.x = left
def changing_to_fire(self):
"""Called when Mario is in a BIG_TO_FIRE state (i.e. when
he obtains a fire flower"""
self.in_transition_state = True
if self.facing_right:
frames = [self.right_fire_frames[3],
self.right_big_green_frames[3],
self.right_big_red_frames[3],
self.right_big_black_frames[3]]
else:
frames = [self.left_fire_frames[3],
self.left_big_green_frames[3],
self.left_big_red_frames[3],
self.left_big_black_frames[3]]
if self.fire_transition_timer == 0:
self.fire_transition_timer = self.current_time
elif (self.current_time - self.fire_transition_timer) > 65 and (self.current_time - self.fire_transition_timer) < 130:
self.image = frames[0]
elif (self.current_time - self.fire_transition_timer) < 195:
self.image = frames[1]
elif (self.current_time - self.fire_transition_timer) < 260:
self.image = frames[2]
elif (self.current_time - self.fire_transition_timer) < 325:
self.image = frames[3]
elif (self.current_time - self.fire_transition_timer) < 390:
self.image = frames[0]
elif (self.current_time - self.fire_transition_timer) < 455:
self.image = frames[1]
elif (self.current_time - self.fire_transition_timer) < 520:
self.image = frames[2]
elif (self.current_time - self.fire_transition_timer) < 585:
self.image = frames[3]
elif (self.current_time - self.fire_transition_timer) < 650:
self.image = frames[0]
elif (self.current_time - self.fire_transition_timer) < 715:
self.image = frames[1]
elif (self.current_time - self.fire_transition_timer) < 780:
self.image = frames[2]
elif (self.current_time - self.fire_transition_timer) < 845:
self.image = frames[3]
elif (self.current_time - self.fire_transition_timer) < 910:
self.image = frames[0]
elif (self.current_time - self.fire_transition_timer) < 975:
self.image = frames[1]
elif (self.current_time - self.fire_transition_timer) < 1040:
self.image = frames[2]
self.fire = True
self.in_transition_state = False
self.state = c.WALK
self.transition_timer = 0
def changing_to_small(self):
"""Mario's state and animation when he shrinks from big to small
after colliding with an enemy"""
self.in_transition_state = True
self.hurt_invincible = True
self.state = c.BIG_TO_SMALL
if self.facing_right:
frames = [self.right_big_normal_frames[4],
self.right_big_normal_frames[8],
self.right_small_normal_frames[8]
]
else:
frames = [self.left_big_normal_frames[4],
self.left_big_normal_frames[8],
self.left_small_normal_frames[8]
]
if self.transition_timer == 0:
self.transition_timer = self.current_time
elif (self.current_time - self.transition_timer) < 265:
self.image = frames[0]
self.hurt_invincible_check()
self.adjust_rect()
elif (self.current_time - self.transition_timer) < 330:
self.image = frames[1]
self.hurt_invincible_check()
self.adjust_rect()
elif (self.current_time - self.transition_timer) < 395:
self.image = frames[2]
self.hurt_invincible_check()
self.adjust_rect()
elif (self.current_time - self.transition_timer) < 460:
self.image = frames[1]
self.hurt_invincible_check()
self.adjust_rect()
elif (self.current_time - self.transition_timer) < 525:
self.image = frames[2]
self.hurt_invincible_check()
self.adjust_rect()
elif (self.current_time - self.transition_timer) < 590:
self.image = frames[1]
self.hurt_invincible_check()
self.adjust_rect()
elif (self.current_time - self.transition_timer) < 655:
self.image = frames[2]
self.hurt_invincible_check()
self.adjust_rect()
elif (self.current_time - self.transition_timer) < 720:
self.image = frames[1]
self.hurt_invincible_check()
self.adjust_rect()
elif (self.current_time - self.transition_timer) < 785:
self.image = frames[2]
self.hurt_invincible_check()
self.adjust_rect()
elif (self.current_time - self.transition_timer) < 850:
self.image = frames[1]
self.hurt_invincible_check()
self.adjust_rect()
elif (self.current_time - self.transition_timer) < 915:
self.image = frames[2]
self.adjust_rect()
self.in_transition_state = False
self.state = c.WALK
self.big = False
self.transition_timer = 0
self.hurt_invisible_timer = 0
self.become_small()
def adjust_rect(self):
"""Makes sure new Rect has the same bottom and left
location as previous Rect"""
x = self.rect.x
bottom = self.rect.bottom
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.bottom = bottom
def become_small(self):
self.big = False
self.right_frames = self.right_small_normal_frames
self.left_frames = self.left_small_normal_frames
bottom = self.rect.bottom
left = self.rect.x
image = self.right_frames[0]
self.rect = image.get_rect()
self.rect.bottom = bottom
self.rect.x = left
def flag_pole_sliding(self):
"""State where Mario is sliding down the flag pole"""
self.state = c.FLAGPOLE
self.in_transition_state = True
self.x_vel = 0
self.y_vel = 0
if self.flag_pole_timer == 0:
self.flag_pole_timer = self.current_time
elif self.rect.bottom < 493:
if (self.current_time - self.flag_pole_timer) < 65:
self.image = self.right_frames[9]
elif (self.current_time - self.flag_pole_timer) < 130:
self.image = self.right_frames[10]
elif (self.current_time - self.flag_pole_timer) >= 130:
self.flag_pole_timer = self.current_time
self.rect.right = self.flag_pole_right
self.y_vel = 5
self.rect.y += self.y_vel
if self.rect.bottom >= 488:
self.flag_pole_timer = self.current_time
elif self.rect.bottom >= 493:
self.image = self.right_frames[10]
def sitting_at_bottom_of_pole(self):
"""State when mario is at the bottom of the flag pole"""
if self.flag_pole_timer == 0:
self.flag_pole_timer = self.current_time
self.image = self.left_frames[10]
elif (self.current_time - self.flag_pole_timer) < 210:
self.image = self.left_frames[10]
else:
self.in_transition_state = False
if self.rect.bottom < 485:
self.state = c.END_OF_LEVEL_FALL
else:
self.state = c.WALKING_TO_CASTLE
def set_state_to_bottom_of_pole(self):
"""Sets Mario to the BOTTOM_OF_POLE state"""
self.image = self.left_frames[9]
right = self.rect.right
#self.rect.bottom = 493
self.rect.x = right
if self.big:
self.rect.x -= 10
self.flag_pole_timer = 0
self.state = c.BOTTOM_OF_POLE
def walking_to_castle(self):
"""State when Mario walks to the castle to end the level"""
self.max_x_vel = 5
self.x_accel = c.WALK_ACCEL
if self.x_vel < self.max_x_vel:
self.x_vel += self.x_accel
if (self.walking_timer == 0 or (self.current_time - self.walking_timer) > 200):
self.walking_timer = self.current_time
elif (self.current_time - self.walking_timer) > \
self.calculate_animation_speed():
if self.frame_index < 3:
self.frame_index += 1
else:
self.frame_index = 1
self.walking_timer = self.current_time
def falling_at_end_of_level(self, *args):
"""State when Mario is falling from the flag pole base"""
self.y_vel += c.GRAVITY
def check_for_special_state(self):
"""Determines if Mario is invincible, Fire Mario or recently hurt"""
self.check_if_invincible()
self.check_if_fire()
self.check_if_hurt_invincible()
self.check_if_crouching()
def check_if_invincible(self):
if self.invincible:
if ((self.current_time - self.invincible_start_timer) < 10000):
self.losing_invincibility = False
self.change_frame_list(30)
elif ((self.current_time - self.invincible_start_timer) < 12000):
self.losing_invincibility = True
self.change_frame_list(100)
else:
self.losing_invincibility = False
self.invincible = False
else:
if self.big:
self.right_frames = self.right_big_normal_frames
self.left_frames = self.left_big_normal_frames
else:
self.right_frames = self.invincible_small_frames_list[0][0]
self.left_frames = self.invincible_small_frames_list[0][1]
def change_frame_list(self, frame_switch_speed):
if (self.current_time - self.invincible_animation_timer) > frame_switch_speed:
if self.invincible_index < (len(self.invincible_small_frames_list) - 1):
self.invincible_index += 1
else:
self.invincible_index = 0
if self.big:
frames = self.invincible_big_frames_list[self.invincible_index]
else:
frames = self.invincible_small_frames_list[self.invincible_index]
self.right_frames = frames[0]
self.left_frames = frames[1]
self.invincible_animation_timer = self.current_time
def check_if_fire(self):
if self.fire and self.invincible == False:
self.right_frames = self.fire_frames[0]
self.left_frames = self.fire_frames[1]
def check_if_hurt_invincible(self):
"""Check if Mario is still temporarily invincible after getting hurt"""
if self.hurt_invincible and self.state != c.BIG_TO_SMALL:
if self.hurt_invisible_timer2 == 0:
self.hurt_invisible_timer2 = self.current_time
elif (self.current_time - self.hurt_invisible_timer2) < 2000:
self.hurt_invincible_check()
else:
self.hurt_invincible = False
self.hurt_invisible_timer = 0
self.hurt_invisible_timer2 = 0
for frames in self.all_images:
for image in frames:
image.set_alpha(255)
def hurt_invincible_check(self):
"""Makes Mario invincible on a fixed interval"""
if self.hurt_invisible_timer == 0:
self.hurt_invisible_timer = self.current_time
elif (self.current_time - self.hurt_invisible_timer) < 35:
self.image.set_alpha(0)
elif (self.current_time - self.hurt_invisible_timer) < 70:
self.image.set_alpha(255)
self.hurt_invisible_timer = self.current_time
def check_if_crouching(self):
"""Checks if mario is crouching"""
if self.crouching and self.big:
bottom = self.rect.bottom
left = self.rect.x
if self.facing_right:
self.image = self.right_frames[7]
else:
self.image = self.left_frames[7]
self.rect = self.image.get_rect()
self.rect.bottom = bottom
self.rect.x = left
def animation(self):
"""Adjusts Mario's image for animation"""
if self.state == c.DEATH_JUMP \
or self.state == c.SMALL_TO_BIG \
or self.state == c.BIG_TO_FIRE \
or self.state == c.BIG_TO_SMALL \
or self.state == c.FLAGPOLE \
or self.state == c.BOTTOM_OF_POLE \
or self.crouching:
pass
elif self.facing_right:
self.image = self.right_frames[self.frame_index]
else:
self.image = self.left_frames[self.frame_index]
#powerups.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import constants as c
from .. import setup
class Powerup(pg.sprite.Sprite):
"""Base class for all powerup_group"""
def __init__(self, x, y):
super(Powerup, self).__init__()
def setup_powerup(self, x, y, name, setup_frames):
"""This separate setup function allows me to pass a different
setup_frames method depending on what the powerup is"""
self.sprite_sheet = setup.GFX['item_objects']
self.frames = []
self.frame_index = 0
setup_frames()
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.centerx = x
self.rect.y = y
self.state = c.REVEAL
self.y_vel = -1
self.x_vel = 0
self.direction = c.RIGHT
self.box_height = y
self.gravity = 1
self.max_y_vel = 8
self.animate_timer = 0
self.name = name
def get_image(self, x, y, width, height):
"""Get the image frames from the sprite sheet"""
image = pg.Surface([width, height]).convert()
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.SIZE_MULTIPLIER),
int(rect.height*c.SIZE_MULTIPLIER)))
return image
def update(self, game_info, *args):
"""Updates powerup behavior"""
self.current_time = game_info[c.CURRENT_TIME]
self.handle_state()
def handle_state(self):
pass
def revealing(self, *args):
"""Action when powerup leaves the coin box or brick"""
self.rect.y += self.y_vel
if self.rect.bottom <= self.box_height:
self.rect.bottom = self.box_height
self.y_vel = 0
self.state = c.SLIDE
def sliding(self):
"""Action for when powerup slides along the ground"""
if self.direction == c.RIGHT:
self.x_vel = 3
else:
self.x_vel = -3
def falling(self):
"""When powerups fall of a ledge"""
if self.y_vel < self.max_y_vel:
self.y_vel += self.gravity
class Mushroom(Powerup):
"""Powerup that makes Mario become bigger"""
def __init__(self, x, y, name='mushroom'):
super(Mushroom, self).__init__(x, y)
self.setup_powerup(x, y, name, self.setup_frames)
def setup_frames(self):
"""Sets up frame list"""
self.frames.append(self.get_image(0, 0, 16, 16))
def handle_state(self):
"""Handles behavior based on state"""
if self.state == c.REVEAL:
self.revealing()
elif self.state == c.SLIDE:
self.sliding()
elif self.state == c.FALL:
self.falling()
class LifeMushroom(Mushroom):
"""1up mushroom"""
def __init__(self, x, y, name='1up_mushroom'):
super(LifeMushroom, self).__init__(x, y)
self.setup_powerup(x, y, name, self.setup_frames)
def setup_frames(self):
self.frames.append(self.get_image(16, 0, 16, 16))
class FireFlower(Powerup):
"""Powerup that allows Mario to throw fire balls"""
def __init__(self, x, y, name=c.FIREFLOWER):
super(FireFlower, self).__init__(x, y)
self.setup_powerup(x, y, name, self.setup_frames)
def setup_frames(self):
"""Sets up frame list"""
self.frames.append(
self.get_image(0, 32, 16, 16))
self.frames.append(
self.get_image(16, 32, 16, 16))
self.frames.append(
self.get_image(32, 32, 16, 16))
self.frames.append(
self.get_image(48, 32, 16, 16))
def handle_state(self):
"""Handle behavior based on state"""
if self.state == c.REVEAL:
self.revealing()
elif self.state == c.RESTING:
self.resting()
def revealing(self):
"""Animation of flower coming out of box"""
self.rect.y += self.y_vel
if self.rect.bottom <= self.box_height:
self.rect.bottom = self.box_height
self.state = c.RESTING
self.animation()
def resting(self):
"""Fire Flower staying still on opened box"""
self.animation()
def animation(self):
"""Method to make the Fire Flower blink"""
if (self.current_time - self.animate_timer) > 30:
if self.frame_index < 3:
self.frame_index += 1
else:
self.frame_index = 0
self.image = self.frames[self.frame_index]
self.animate_timer = self.current_time
class Star(Powerup):
"""A powerup that gives mario invincibility"""
def __init__(self, x, y, name='star'):
super(Star, self).__init__(x, y)
self.setup_powerup(x, y, name, self.setup_frames)
self.animate_timer = 0
self.rect.y += 1 #looks more centered offset one pixel
self.gravity = .4
def setup_frames(self):
"""Creating the self.frames list where the images for the animation
are stored"""
self.frames.append(self.get_image(1, 48, 15, 16))
self.frames.append(self.get_image(17, 48, 15, 16))
self.frames.append(self.get_image(33, 48, 15, 16))
self.frames.append(self.get_image(49, 48, 15, 16))
def handle_state(self):
"""Handles behavior based on state"""
if self.state == c.REVEAL:
self.revealing()
elif self.state == c.BOUNCE:
self.bouncing()
def revealing(self):
"""When the star comes out of the box"""
self.rect.y += self.y_vel
if self.rect.bottom <= self.box_height:
self.rect.bottom = self.box_height
self.start_bounce(-2)
self.state = c.BOUNCE
self.animation()
def animation(self):
"""sets image for animation"""
if (self.current_time - self.animate_timer) > 30:
if self.frame_index < 3:
self.frame_index += 1
else:
self.frame_index = 0
self.animate_timer = self.current_time
self.image = self.frames[self.frame_index]
def start_bounce(self, vel):
"""Transitions into bouncing state"""
self.y_vel = vel
def bouncing(self):
"""Action when the star is bouncing around"""
self.animation()
if self.direction == c.LEFT:
self.x_vel = -5
else:
self.x_vel = 5
class FireBall(pg.sprite.Sprite):
"""Shot from Fire Mario"""
def __init__(self, x, y, facing_right, name=c.FIREBALL):
super(FireBall, self).__init__()
self.sprite_sheet = setup.GFX['item_objects']
self.setup_frames()
if facing_right:
self.direction = c.RIGHT
self.x_vel = 12
else:
self.direction = c.LEFT
self.x_vel = -12
self.y_vel = 10
self.gravity = .9
self.frame_index = 0
self.animation_timer = 0
self.state = c.FLYING
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.right = x
self.rect.y = y
self.name = name
def setup_frames(self):
"""Sets up animation frames"""
self.frames = []
self.frames.append(
self.get_image(96, 144, 8, 8)) #Frame 1 of flying
self.frames.append(
self.get_image(104, 144, 8, 8)) #Frame 2 of Flying
self.frames.append(
self.get_image(96, 152, 8, 8)) #Frame 3 of Flying
self.frames.append(
self.get_image(104, 152, 8, 8)) #Frame 4 of flying
self.frames.append(
self.get_image(112, 144, 16, 16)) #frame 1 of exploding
self.frames.append(
self.get_image(112, 160, 16, 16)) #frame 2 of exploding
self.frames.append(
self.get_image(112, 176, 16, 16)) #frame 3 of exploding
def get_image(self, x, y, width, height):
"""Get the image frames from the sprite sheet"""
image = pg.Surface([width, height]).convert()
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.SIZE_MULTIPLIER),
int(rect.height*c.SIZE_MULTIPLIER)))
return image
def update(self, game_info, viewport):
"""Updates fireball behavior"""
self.current_time = game_info[c.CURRENT_TIME]
self.handle_state()
self.check_if_off_screen(viewport)
def handle_state(self):
"""Handles behavior based on state"""
if self.state == c.FLYING:
self.animation()
elif self.state == c.BOUNCING:
self.animation()
elif self.state == c.EXPLODING:
self.animation()
def animation(self):
"""adjusts frame for animation"""
if self.state == c.FLYING or self.state == c.BOUNCING:
if (self.current_time - self.animation_timer) > 200:
if self.frame_index < 3:
self.frame_index += 1
else:
self.frame_index = 0
self.animation_timer = self.current_time
self.image = self.frames[self.frame_index]
elif self.state == c.EXPLODING:
if (self.current_time - self.animation_timer) > 50:
if self.frame_index < 6:
self.frame_index += 1
self.image = self.frames[self.frame_index]
self.animation_timer = self.current_time
else:
self.kill()
def explode_transition(self):
"""Transitions fireball to EXPLODING state"""
self.frame_index = 4
centerx = self.rect.centerx
self.image = self.frames[self.frame_index]
self.rect.centerx = centerx
self.state = c.EXPLODING
def check_if_off_screen(self, viewport):
"""Removes from sprite group if off screen"""
if (self.rect.x > viewport.right) or (self.rect.y > viewport.bottom) \
or (self.rect.right < viewport.x):
self.kill()
#score.py
__author__ = 'justinarmstrong'
import pygame as pg
from .. import setup
from .. import constants as c
class Digit(pg.sprite.Sprite):
"""Individual digit for score"""
def __init__(self, image):
super(Digit, self).__init__()
self.image = image
self.rect = image.get_rect()
class Score(object):
"""Scores that appear, float up, and disappear"""
def __init__(self, x, y, score, flag_pole=False):
self.x = x
self.y = y
if flag_pole:
self.y_vel = -4
else:
self.y_vel = -3
self.sprite_sheet = setup.GFX['item_objects']
self.create_image_dict()
self.score_string = str(score)
self.create_digit_list()
self.flag_pole_score = flag_pole
def create_image_dict(self):
"""Creates the dictionary for all the number images needed"""
self.image_dict = {}
image0 = self.get_image(1, 168, 3, 8)
image1 = self.get_image(5, 168, 3, 8)
image2 = self.get_image(8, 168, 4, 8)
image4 = self.get_image(12, 168, 4, 8)
image5 = self.get_image(16, 168, 5, 8)
image8 = self.get_image(20, 168, 4, 8)
image9 = self.get_image(32, 168, 5, 8)
image10 = self.get_image(37, 168, 6, 8)
image11 = self.get_image(43, 168, 5, 8)
self.image_dict['0'] = image0
self.image_dict['1'] = image1
self.image_dict['2'] = image2
self.image_dict['4'] = image4
self.image_dict['5'] = image5
self.image_dict['8'] = image8
self.image_dict['3'] = image9
self.image_dict['7'] = image10
self.image_dict['9'] = image11
def get_image(self, x, y, width, height):
"""Extracts image from sprite sheet"""
image = pg.Surface([width, height]).convert()
rect = image.get_rect()
image.blit(self.sprite_sheet, (0, 0), (x, y, width, height))
image.set_colorkey(c.BLACK)
image = pg.transform.scale(image,
(int(rect.width*c.BRICK_SIZE_MULTIPLIER),
int(rect.height*c.BRICK_SIZE_MULTIPLIER)))
return image
def create_digit_list(self):
"""Creates the group of images based on score received"""
self.digit_list = []
self.digit_group = pg.sprite.Group()
for digit in self.score_string:
self.digit_list.append(Digit(self.image_dict[digit]))
self.set_rects_for_images()
def set_rects_for_images(self):
"""Set the rect attributes for each image in self.image_list"""
for i, digit in enumerate(self.digit_list):
digit.rect = digit.image.get_rect()
digit.rect.x = self.x + (i * 10)
digit.rect.y = self.y
def update(self, score_list, level_info):
"""Updates score movement"""
for number in self.digit_list:
number.rect.y += self.y_vel
if score_list:
self.check_to_delete_floating_scores(score_list, level_info)
if self.flag_pole_score:
if self.digit_list[0].rect.y <= 120:
self.y_vel = 0
def draw(self, screen):
"""Draws score numbers onto screen"""
for digit in self.digit_list:
screen.blit(digit.image, digit.rect)
def check_to_delete_floating_scores(self, score_list, level_info):
"""Check if scores need to be deleted"""
for i, score in enumerate(score_list):
if int(score.score_string) == 1000:
if (score.y - score.digit_list[0].rect.y) > 130:
score_list.pop(i)
else:
if (score.y - score.digit_list[0].rect.y) > 75:
score_list.pop(i)