def __init__(self):
pygame.init()
self.window = pygame.display.set_mode((WIDTH, HEIGHT))
self.running = True
victory_spritesheet = Spritesheet('sudoku_winner_spritesheet.png')
border_sprites = Spritesheet('borders.png')
VictoryAnimation.images = victory_spritesheet.imgsat(
VictoryAnimation.img_rects, -1)
self.border_images = border_sprites.imgsat(border_img_locs, -1)
self.grid = [[0 for i in range(9)] for j in range(9)]
self.grid_finished = [[0 for i in range(9)] for j in range(9)]
# self.grid = test_board_2
# self.grid_finished = test_board_2_finished
self.selected = None
self.mouse_pos = None
self.mouse_click = None
self.finished = False
self.cell_changed = False
self.show_victory = False
self.status = ''
self.incorrect_cells = []
self.locked_cells = []
self.state = "playing"
self.playing_buttons = []
self.menu_buttons = []
self.end_buttons = []
self.victory = VictoryAnimation(victory_pos)
self.font = pygame.font.SysFont('arial', int(cell_size / 2))
self.load()
def __init__(self, world):
ss = Spritesheet(Sara.IMAGE_FILENAME, 44)
self.ss = {
'left': ss,
'right': ss,
'up': Spritesheet(Sara.UP_IMAGE_FILENAME, 44),
'down': Spritesheet(Sara.DOWN_IMAGE_FILENAME, 44)
}
super(Sara, self).__init__(world,
'sara',
spritesheet=self.ss['right'],
passable=False,
can_leave_screen=True,
speed=Sara.SPEED)
self.animation = 0
self.animation_time = 0
self.moving = False
# Weapon init
self.weapon = Weapon(self, world)
self.life = 3
self.auto = False
self.image_reload = pygame.image.load(
RELOAD_BUTTON_IMAGE_FILENAME).convert_alpha()
self.show_reload = False
self._keys = []
self.face_to = 'right'
self.flip()
def load_data(self):
"""Loads pertinent data for the game"""
# Map initialization
self.map = TiledMap(r'../assets/stage_1.tmx')
self.map_image = self.map.make_map()
map_rect = self.map_image.get_rect()
# Sprite initialization
pacman_sprites = Spritesheet(r'../assets/sprites.png')
self.open_mouth = pacman_sprites.get_sprite(0, 0, TILESIZE, TILESIZE)
pellet_sprites = Spritesheet(r'../assets/small_pellet.png')
self.pellet_sprite = pellet_sprites.get_sprite(0, 0, TILESIZE, TILESIZE)
def __init__(self, ai_settings, screen):
#initialize the alien and set its starting position
super(Alien_2, self).__init__()
self.screen = screen
self.ai_settings = ai_settings
self.image = Spritesheet('images/spritesheet.png')
self.images = []
self.index = 0
self.images.append(
self.image.image_at((64, 0, 64, 64), colorkey=(0, 0, 0, 1)))
self.images.append(
self.image.image_at((128, 0, 64, 64), colorkey=(0, 0, 0, 1)))
self.score = 20
self.image = self.images[self.index]
#load the alien image and set its rect attribute
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
#store the alien's exact position
self.x = float(self.rect.x)
def load_data(self):
"""Loading item images"""
root_folder = path.dirname(__file__)
img_folder = path.join(root_folder, "data", "img")
sprites = Spritesheet(path.join(img_folder, "spritesheet_x2.png"))
# IMAGES
self.item_images = {}
for item_name in ITEMS:
sprite_at = ITEMS[item_name]['SPRITE_AT']
self.item_images[item_name] = sprites.image_at(
sprite_at[0], sprite_at[1], TILESIZE, 2, KEY_COLOR)
self.player_img = sprites.image_at(PLAYER_SPRITE_AT[0],
PLAYER_SPRITE_AT[1], TILESIZE, 2,
KEY_COLOR)
self.bee_img = sprites.image_at(BEE_SPRITE_AT[0], BEE_SPRITE_AT[1],
TILESIZE, 2, KEY_COLOR)
self.bee_nest_img = sprites.image_at(BEE_NEST_SPRITE_AT[0],
BEE_NEST_SPRITE_AT[1], TILESIZE,
2, KEY_COLOR)
self.top_wall_img = sprites.image_at(TOP_WALL_SPRITE_AT[0],
TOP_WALL_SPRITE_AT[1], TILESIZE,
2, KEY_COLOR)
self.front_wall_img = sprites.image_at(FRONT_WALL_SPRITE_AT[0],
FRONT_WALL_SPRITE_AT[1],
TILESIZE, 2, KEY_COLOR)
def load_frames(self):
my_spritesheet = Spritesheet('poppy_sheet.png')
#pygame.image.load('MY_IMAGE_NAME.png').convert()
self.idle_frames_left = [
my_spritesheet.parse_sprite("poppy_idle1.png"),
my_spritesheet.parse_sprite("poppy_idle2.png")
]
self.walking_frames_left = [
my_spritesheet.parse_sprite("poppywalk1.png"),
my_spritesheet.parse_sprite("poppywalk2.png"),
my_spritesheet.parse_sprite("poppywalk3.png"),
my_spritesheet.parse_sprite("poppywalk4.png"),
my_spritesheet.parse_sprite("poppywalk5.png"),
my_spritesheet.parse_sprite("poppywalk6.png"),
my_spritesheet.parse_sprite("poppywalk7.png"),
my_spritesheet.parse_sprite("poppywalk8.png")
]
self.idle_frames_right = []
for frame in self.idle_frames_left:
self.idle_frames_right.append(
pygame.transform.flip(frame, True, False))
self.walking_frames_right = []
for frame in self.walking_frames_left:
self.walking_frames_right.append(
pygame.transform.flip(frame, True, False))
def __init__(self, ai_settings, screen):
"""Initialize the alien, and set its starting position."""
super(Alien, self).__init__()
self.screen = screen
self.ai_settings = ai_settings
ss = Spritesheet('images/space_invaders_spritesheet.png')
#
# # Load the ship image, and get its rect.
# self.image = ss.image_at((0, 192, 64, 64))
# Load the alien image, and set its rect attribute.
self.images = []
self.images.append(ss.image_at((65, 512, 64, 64)))
self.images.append(ss.image_at((0, 576, 64, 64)))
# self.images.append(load_image('images/alien1_down.bmp'))
self.index = 0
self.image = self.images[self.index]
# self.image2 = pygame.image.load('images/alien2_up.bmp')
# self.rect = self.image2.get_rect()
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
# Store the alien's exact position.
self.x = float(self.rect.x)
def __init__(self, game, pos_x, pos_y, color, name):
super(AxeToolButton, self).__init__(game, pos_x, pos_y, color, name)
spritesheet_file = 'assets/tools.png'
spritesheet = Spritesheet(spritesheet_file)
self.image = spritesheet.get_image((0, 0), (32, 32))
self.image = pg.transform.scale(self.image, (100, 100))
self.damage = 2
def initialize_player(self):
""" (None) -> None
Initialize the player character for use in the game loop.
"""
if not self.player:
player_spritesheet = Spritesheet('player.png', 2, 4)
self.player = Player(self.screen_w // 2, self.screen_h // 2, 7, *player_spritesheet[0:6])
self.player.set_aiming_image(player_spritesheet[6])
def load_frames(self):
bullet_spritesheet = Spritesheet('images/bullet/player/bullet.png')
e_bullet_spritesheet = Spritesheet('images/bullet/enemy/bullet.png')
self.bullet_frames = [
bullet_spritesheet.parse_sprite('bullet1.png'),
bullet_spritesheet.parse_sprite('bullet2.png'),
bullet_spritesheet.parse_sprite('bullet3.png'),
bullet_spritesheet.parse_sprite('bullet4.png'),
bullet_spritesheet.parse_sprite('bullet5.png'),
bullet_spritesheet.parse_sprite('bullet6.png'),
]
self.enemy_bullet_frames = [
e_bullet_spritesheet.parse_sprite('bullet1.png'),
e_bullet_spritesheet.parse_sprite('bullet2.png'),
e_bullet_spritesheet.parse_sprite('bullet3.png')
]
def __init__(self):
ss = Spritesheet(Arena.IMAGE_FILENAME, Arena.MAP_WIDTH)
self.start_frame = time.time()
self.fps = 12
self.index = 0
self.images = ss.get_images()
self.image = self.images[self.index]
self.rect = pygame.Rect(0, 0, Arena.MAP_WIDTH, Arena.MAP_HEIGHT)
def __init__(self, tileset, assetdir):
self._imageCache = {}
self.tileset = tileset
self.tile_count = self.tileset.tile_count
self.usecache = True
fp = os.path.join(assetdir, tileset.image.source)
self._spriteSheet = Spritesheet(fp)
def load_data(self):
"""Let's create more sensible data structures for each group"""
root_folder = path.dirname(__file__)
img_folder = path.join(root_folder, "data", "img")
music_folder = path.join(root_folder, "data", "music")
fx_folder = path.join(root_folder, "data", "fx")
sprites = Spritesheet(path.join(img_folder, "spritesheet_x2.png"))
# IMAGES & SOUND
self.images = {}
self.fx = {}
for item in ITEMS:
sprite_at = ITEMS[item]['SPRITE']
self.images[item] = sprites.image_at(sprite_at[0], sprite_at[1],
TILESIZE, 2, KEY_COLOR)
fx = pygame.mixer.Sound(
path.join(fx_folder, ITEMS[item]['FX_PICKUP']))
fx.set_volume(0.1)
self.fx[item] = fx
for mob in MOBS:
sprite_at = MOBS[mob]['SPRITE']
self.images[mob] = sprites.image_at(sprite_at[0], sprite_at[1],
TILESIZE, 2, KEY_COLOR)
fx = pygame.mixer.Sound(path.join(fx_folder,
MOBS[mob]['FX_DEATH']))
fx.set_volume(0.1)
self.fx[mob] = fx
for nest in NESTS:
sprite_at = NESTS[nest]['SPRITE']
self.images[nest] = sprites.image_at(sprite_at[0], sprite_at[1],
TILESIZE, 2, KEY_COLOR)
fx = pygame.mixer.Sound(
path.join(fx_folder, NESTS[nest]['FX_DEATH']))
fx.set_volume(0.1)
self.fx[nest] = fx
for weapon in WEAPONS:
fx = pygame.mixer.Sound(path.join(fx_folder,
WEAPONS[weapon]['FX']))
fx.set_volume(0.1)
self.fx[weapon] = fx
self.tiles = {}
for wall in WALLS:
for orientation in ['TOP', 'FRONT']:
sprite_at = WALLS[wall][orientation]
self.tiles[f"{wall}_{orientation}"] = sprites.image_at(
sprite_at[0], sprite_at[1], TILESIZE, 2, KEY_COLOR)
# MUSIC
pygame.mixer.music.load(path.join(music_folder, BG_MUSIC))
def on_init(self):
self._running = True
pygame.init()
pygame.font.init()
self.font = pygame.font.Font(None, 20)
self.TILE_HEIGHT = 32
self.TILE_WIDTH = 32
self.MESSAGE_BOX_WIDTH = 400
self.size = self.weight, self.height = self.gameMap.xSize * self.TILE_WIDTH + self.MESSAGE_BOX_WIDTH, \
self.gameMap.ySize * self.TILE_HEIGHT
self.msgBoxLeft = self.gameMap.xSize * self.TILE_WIDTH
self.output = self
self.screen = pygame.display.set_mode(
self.size, pygame.HWSURFACE | pygame.DOUBLEBUF)
# msgBaseDelaySecs = self.msgBaseDelaySecs;
# Default spritesheet assets
self.sprites = Spritesheet(
"assets/fantasy-tileset-8cols-26rows-32x32pixels.png")
self.spritesPlural = Spritesheet(
"assets/fantasy-tileset-8cols-26rows-32x32pixels-shadow.png")
self.enemySprites = Spritesheet(
"assets/fantasy-tileset-8cols-26rows-32x32pixels-red.png")
output = self.output
self.gameTime = 0
output.log("Game begins!")
self.dead = []
output.dump()
# time.sleep(2 * msgBaseDelaySecs);
# Position armies
iX = 0
iY = 2
for oItemA in self.aAttackers:
oItemA.x = iX
oItemA.y = iY
iX += 1
if (iX == self.gameMap.xSize):
iX = 0
iY += 1
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.image = Spritesheet('spritesheet.png').parse_sprite('chick.png')
self.rect = self.image.get_rect()
self.LEFT_KEY, self.RIGHT_KEY, self.FACING_LEFT = False, False, False
self.is_jumping, self.on_ground = False, False
self.gravity, self.friction = .35, -.12
self.position, self.velocity = pygame.math.Vector2(
0, 0), pygame.math.Vector2(0, 0)
self.acceleration = pygame.math.Vector2(0, self.gravity)
def _init_pictures(self):
"""Load every picture in a variable."""
_ss = Spritesheet(self.TILES)
self.wall = _ss.image_at(self.WALL)
self.floor = _ss.image_at(self.FLOOR)
self.exit = _ss.image_at(self.EXIT)
self.macgyver = self._resize_pic(self.MACGYVER)
self.guardian = self._resize_pic(self.GUARDIAN)
self.needle = self._resize_pic(self.NEEDLE)
self.ether = self._resize_pic(self.ETHER)
self.tube = self._resize_pic(self.TUBE)
def __init__(self, power, x, y):
self.power = power
self.get = Spritesheet(self.power)
self.image = self.get.get_spritte()[0]
self.rect = self.image.get_rect()
self.rect.x = x
self.rect.y = y
self.vel = pygame.math.Vector2(0, 0)
self.acceleration = pygame.math.Vector2(0, .1)
self.on_ground = False
self.col = False
self.drop = False
def get_unscaled_portal_sprites():
portalsheet = Spritesheet('images/portals.png')
portal_images_unscaled = [
portalsheet.get_image(x=364, y=7, w=177, h=176),
portalsheet.get_image(x=553, y=14, w=163, h=163),
portalsheet.get_image(x=7, y=222, w=161, h=159),
portalsheet.get_image(x=193, y=220, w=155, h=158),
portalsheet.get_image(x=373, y=222, w=159, h=158),
portalsheet.get_image(x=553, y=220, w=163, h=163)
]
return portal_images_unscaled
def __init__(self, tree, x, y):
self.tree = tree
self.get = Spritesheet(tree)
self.image = self.get.get_spritte()
self.rect = self.image[0].get_rect()
self.rect.x = x
self.rect.y = y
self.vel = pygame.math.Vector2(0, 0)
self.acceleration = pygame.math.Vector2(0, .1)
self.on_ground = False
self.drop = False
self.col = False
def load(self):
self.all_sprites = pg.sprite.Group()
self.solid = pg.sprite.Group()
self.items_on_floor = pg.sprite.Group()
self.doors = pg.sprite.Group()
assets_folder = path.join(getcwd(), 'assets')
self.map = Map(path.join(assets_folder, 'maps/map1.json'))
self.spritesheet = Spritesheet(
path.join(assets_folder, 'spritesheet.png'), 32)
wall_img = self.spritesheet.get_image_at_col_row(0, 0)
apple_img = self.spritesheet.get_image_alpha_at_col_row(1, 0)
keycard_img = self.spritesheet.get_image_alpha_at_col_row(0, 3)
self.background_surface = pg.Surface(
(self.map.width * TILE_SIZE, self.map.height * TILE_SIZE))
self.visibility_data = [[True] * self.map.height
for i in range(self.map.width)]
self.fov_data = [[True] * self.map.height
for i in range(self.map.width)]
for node in self.map.objects:
x, y = node['x'], node['y']
if node["name"] == 'WALL':
#self.collisions.append(pg.Rect(x, y, TILE_SIZE, TILE_SIZE)) # TODO big rectangles
wall = Wall(self, x, y, wall_img)
if not LIMIT_FOV_FOR_STATIC_SPRITES:
wall.remove(self.all_sprites) # skip drawing
self.background_surface.blit(
wall_img, (x * TILE_SIZE, y * TILE_SIZE))
self.visibility_data[x][y] = False
elif node["name"] == 'PLAYER':
self.player = Player(self, x, y)
elif node["name"] == 'APPLE':
item = Item(self, x, y, apple_img)
item.pickable = Pickable(item, 'apple', False, 1, False)
elif node["name"] == 'KEYCARD': # key card
item = Item(self, x, y, keycard_img)
item.pickable = Pickable(item, 'keycard', False, 1, False)
elif node["name"] == "DOOR":
Door(self, x, y, node["dir"])
self.visibility_data[x][
y] = False # TODO opened doors visibility
for trigger in self.map.triggers:
TextTrigger(
self,
pg.Rect(trigger["x"], trigger["y"], trigger["width"],
trigger["height"]), trigger["text"])
self.camera = Camera(self.map.width_screen, self.map.height_screen)
def load_data(self):
"""Adding music & fx"""
root_folder = path.dirname(__file__)
img_folder = path.join(root_folder, "data", "img")
music_folder = path.join(root_folder, "data", "music")
fx_folder = path.join(root_folder, "data", "fx")
sprites = Spritesheet(path.join(img_folder, "spritesheet_x2.png"))
# IMAGES
self.item_images = {}
for item_name in ITEMS:
sprite_at = ITEMS[item_name]['SPRITE_AT']
self.item_images[item_name] = sprites.image_at(
sprite_at[0], sprite_at[1], TILESIZE, 2, KEY_COLOR)
self.player_img = sprites.image_at(PLAYER_SPRITE_AT[0],
PLAYER_SPRITE_AT[1], TILESIZE, 2,
KEY_COLOR)
self.bee_img = sprites.image_at(BEE_SPRITE_AT[0], BEE_SPRITE_AT[1],
TILESIZE, 2, KEY_COLOR)
self.bee_nest_img = sprites.image_at(BEE_NEST_SPRITE_AT[0],
BEE_NEST_SPRITE_AT[1], TILESIZE,
2, KEY_COLOR)
self.top_wall_img = sprites.image_at(TOP_WALL_SPRITE_AT[0],
TOP_WALL_SPRITE_AT[1], TILESIZE,
2, KEY_COLOR)
self.front_wall_img = sprites.image_at(FRONT_WALL_SPRITE_AT[0],
FRONT_WALL_SPRITE_AT[1],
TILESIZE, 2, KEY_COLOR)
# SOUND
# Using arrays to add some variance
pygame.mixer.music.load(path.join(music_folder, BG_MUSIC))
self.basic_gun_fx = []
for fx in BASIC_GUN_FX:
pewpew = pygame.mixer.Sound(path.join(fx_folder, fx))
pewpew.set_volume(0.1)
self.basic_gun_fx.append(pewpew)
self.critter_death_fx = []
for fx in CRITTER_DEAD_FX:
self.critter_death_fx.append(
pygame.mixer.Sound(path.join(fx_folder, fx)))
self.item_fx = {}
for fx in ITEMS:
self.item_fx[fx] = pygame.mixer.Sound(
path.join(fx_folder, ITEMS[fx]['FX']))
def __init__(self, x, y):
pygame.sprite.Sprite.__init__(self)
ss = Spritesheet(bullet_image)
self. bullets = ss.images_at([\
(19,336,10,14), (32,340,14,10),\
(48,339,14,11),(65,338,14,12)], -1)
self.idx = 0
self.image = self.bullets[self.idx]
self.last_idx = len(self.bullets) - 1
self.rect = self.image.get_rect()
self.rect.center = (x, y)
self.speed = 4
self.frames_count = 0
self.animate_each_frame = 10
def get_fireball_images():
path = os.path.join('assets', 'fire1_64.png')
rows, cols = 6, 10
sheet = Spritesheet(path)
images = []
width = height = 64
for row in range(rows):
images.extend(sheet.load_strip((0, row * height, width, height), cols))
return images
def __init__(self, filename, numberFrames, X, Y):
super().__init__()
self.filename = filename # arquivo
self.spritesheet = Spritesheet(filename) # sprites do arquivo
self.numberFrames = numberFrames # quantidade de frames
self.sprites = [] # vetor das sprites
for i in range(0, numberFrames): # adicionando todas as sprites
self.sprites.append(
self.spritesheet.get_sprite(0 + i * 312, 0, 312, 38)) #
self.current_sprite = 0 # sprite atual
self.image = self.sprites[self.current_sprite] # imagem atual
self.rect = self.image.get_rect(top=Y, left=X) # posição da sprite
def __init__(self):
SceneBase.__init__(self)
self.scrabble = Scrabble(True)
self.board = Board('imgs/board.jpg', [0, 0])
self.letter_ss = Spritesheet('imgs/letters.jpg')
self.player_tiles = []
self.game_tiles = []
self.selected_tile = None
self.offset_x = 0
self.offset_y = 0
for i, letter in enumerate(self.scrabble.get_rack()):
self.player_tiles.append(
Tile(letter, self.letter_ss, PLAYER_TILE_POSITIONS[i]))
def __init__(self, filename, numberFrames, X, Y):
super().__init__()
self.filename = filename # arquivo
self.spritesheet = Spritesheet(filename)
self.numberFrames = numberFrames # número de frames
self.sprites = [] # vetor das sprites
for i in range(0, numberFrames): # adicionando todas as sprites
self.sprites.append(
self.spritesheet.get_sprite(0 + i * 32, 0, 32, 32)) #
self.current_sprite = 0 # sprite atual
self.image = self.sprites[
self.current_sprite] # carrega a sprite atual, no caso a primeira
self.rect = self.image.get_rect(top=Y, left=X) # posição da explosão
def __init__(self):
self.sprite_sheet = Spritesheet('images/spritesheet.png')
self.pacman = self.get_pacman_sprites()
self.blinky = self.get_blinky_sprites()
self.pinky = self.get_pinky_sprites()
self.clyde = self.get_clyde_sprites()
self.inkey = self.get_inkey_sprites()
self.portal = self.get_unscaled_portal_sprites()
self.fruits = self.get_fruit_sprites()
self.pac_life = self.sprite_sheet.get_image(x=(24 * 2),
y=(24 * 3),
w=24,
h=24)
def __init__(self, pos_x, pos_y):
"""Constructs a new floor class
Args:
pos_x: x position on the map
pos_y: y position on the map
"""
super().__init__()
self.sprite_sheet = Spritesheet("floor.png")
self.image = choice(self.sprite_sheet.load_strip((0, 0, 50, 50), 4))
self.rect = self.image.get_rect()
self.rect.x = pos_x
self.rect.y = pos_y
def load_data(self):
root_folder = path.dirname(__file__)
sprites = Spritesheet(
path.join(root_folder, "data", "img", "spritesheet.png"))
self.player_img = sprites.image_at(
PLAYER_SPRITE_AT[0], PLAYER_SPRITE_AT[1], TILESIZE, 1, KEY)
self.bee_img = sprites.image_at(
BEE_SPRITE_AT[0], BEE_SPRITE_AT[1], TILESIZE, 1, KEY)
self.top_wall_img = sprites.image_at(
TOP_WALL_SPRITE_AT[0], TOP_WALL_SPRITE_AT[1], TILESIZE, 1, KEY)
self.front_wall_img = sprites.image_at(
FRONT_WALL_SPRITE_AT[0], FRONT_WALL_SPRITE_AT[1], TILESIZE, 1, KEY)
def get_fruit_sprites():
spritesheet = Spritesheet('images/spritesheet.png')
fruit_images = [
spritesheet.get_image(x=(24 * 0), y=(24 * 5), w=24,
h=24), # cherries
spritesheet.get_image(x=(24 * 1), y=(24 * 5), w=24,
h=24), # strawberry
spritesheet.get_image(x=(24 * 2), y=(24 * 5), w=24,
h=24), # orange
spritesheet.get_image(x=(24 * 3), y=(24 * 5), w=24, h=24), # ?????
spritesheet.get_image(x=(24 * 4), y=(24 * 5), w=24, h=24), # apple
spritesheet.get_image(x=(24 * 5), y=(24 * 5), w=24,
h=24), # grapes
]
return fruit_images
