Beispiel #1
0
    def renderBackground(self):
        floor = league.Spritesheet(self.map.floor[0], 16, self.map.floor[1])
        wall = league.Spritesheet(self.map.walls[0], 16, self.map.walls[1])
        decoration = league.Spritesheet(self.map.decoration[0], 16,
                                        self.map.decoration[1])
        decoration2 = league.Spritesheet(self.map.decoration2[0], 16,
                                         self.map.decoration2[1])

        floorLayer = league.Tilemap(self.map.floor[2], floor, layer=0)
        wallLayer = league.Tilemap(self.map.walls[2], wall, layer=1)
        decoLayer = league.Tilemap(self.map.decoration[2], decoration, layer=2)
        deco2Layer = league.Tilemap(self.map.decoration2[2],
                                    decoration2,
                                    layer=3)

        world_size = (floorLayer.wide * league.Settings.tile_size,
                      floorLayer.high * league.Settings.tile_size)

        self.engine.mapDrawables.add(floorLayer.passable.sprites())
        self.engine.mapDrawables.add(wallLayer.impassable.sprites())
        self.engine.mapDrawables.add(decoLayer.impassable.sprites())
        self.engine.mapDrawables.add(deco2Layer.impassable.sprites())

        # list of all impassable objects that are only used in game.py for collisions

        return world_size
Beispiel #2
0
    def renderForeGround(self):
        ceiling = league.Spritesheet(self.map.ceiling[0], 16,
                                     self.map.ceiling[1])
        ceilingLayer = league.Tilemap(self.map.ceiling[2], ceiling, layer=4)

        self.engine.mapDrawables.add(ceilingLayer.impassable.sprites())
        self.all_impassables.append(ceilingLayer.impassable.sprites())
Beispiel #3
0
def init_map(engine):
    """Create map and background"""
    league.Settings.tile_size = 16
    league.Settings.fill_color = (31, 38, 84)
    sprites = league.Spritesheet('./assets/tileset-collapsed.png', league.Settings.tile_size, 14)
    level1 = league.Tilemap('./assets/level1.lvl', sprites, layer = 1)
    world_size = (level1.wide*league.Settings.tile_size, level1.high*league.Settings.tile_size)
    engine.drawables.add(level1.passable.sprites()) 
    background = Background('./assets/near-buildings-bg.png')
    engine.drawables.add(background)
Beispiel #4
0
    def __parse(self):
        """This function begins the process of (attempting) to
        parse a level file.  The structure of the file is described above.
        """
        #default image for replacing tiles with blank images
        defaultImg = league.Spritesheet(
            '../assets/map assets/sprite sheets/Hospital Tiles/TileA5_PHC_Interior-Hospital.png',
            16, 1)

        with open(self.path, 'r') as f:
            reader = csv.reader(f)
            contents = list(reader)
        # How many tiles wide is our world?
        self.wide = int(contents[0][0])
        # And how tall?
        self.high = int(contents[1][0])
        # Sprite numbers for all tiles are in the
        # multidimensional list "world".
        self.world = contents[2:]
        a = 0

        skipVal = 555

        for i in self.world:
            b = 0
            for j in i:
                x = b * self.spritesheet.tile_size
                y = a * self.spritesheet.tile_size
                num = int(j)

                if (num == skipVal):
                    base_sprite = defaultImg.sprites[25]
                else:
                    if num < 0:
                        base_sprite = self.spritesheet.sprites[abs(num)]
                    else:
                        base_sprite = self.spritesheet.sprites[num]

                sprite = Drawable(self.layer)
                sprite.image = base_sprite.image

                # Set rectangle coords (using top-left coords here)
                rect = sprite.image.get_rect()
                rect.x = x
                rect.y = y
                sprite.x = x
                sprite.y = y
                sprite.rect = rect
                if num < 0:
                    self.impassable.add(sprite)
                else:
                    self.passable.add(sprite)
                b = b + 1
            a = a + 1
Beispiel #5
0
    def __init__(self, x, y):
        """
        Inits the victory item. sets its location and sets won to false.

        param - x,y: the coordinates for the victory item
        """
        super().__init__(self)
        self._layer = 10
        self.x = x
        self.y = y
        self.won = False
        self.spritesheet = league.Spritesheet(
            './assets/18_midnight_spritesheet.png', 100, 8)
        self.image = pygame.Surface((100, 100))
        self.rect = self.image.get_rect()
        self.rect.x = x
        self.rect.y = y
        self.image_index_x = 0
        self.image_index_y = 0
Beispiel #6
0
    def __init__(self, player):
        super().__init__(self)
        self._layer = 1000
        self.player = player
        self.image = pygame.Surface([480, 480]).convert_alpha()
        self.image.fill((255, 255, 255, 0))
        self.rect = self.image.get_rect()
        self.x = 100
        self.y = 10
        self.rect.x = 100
        self.rect.y = 10
        self.static = True

        # set up any text display stuffs
        self.font = pygame.font.Font('freesansbold.ttf', 32)
        self.text = self.font.render(
            str(self.player.health) + "        4 lives", True, (255, 255, 255))

        # set up action meter for user interaction
        self.action_meter_sheet = league.Spritesheet(
            "../assets/player/action_meter.png", 16, 3)
        self.action_meter_sprites = self.action_meter_sheet.sprites
        self.action_meter_index = 0
        self.action_meter_len = len(self.action_meter_sprites) - 2
        self.action_meter_animation_speed = self.player.interaction_timer // self.action_meter_len + 3
        self.action_meter_animation_counter = self.action_meter_animation_speed

        # set up inventory gui stuffs
        self.ui_box = pygame.image.load("../assets/overlay assets/ui_box.png")
        self.item_icons = [
            pygame.image.load('../assets/icons/beartrap.png').convert_alpha(),
            pygame.image.load(
                '../assets/game objects/lantern.png').convert_alpha(),
            pygame.image.load(
                '../assets/icons/rancidmeat.png').convert_alpha()
        ]
Beispiel #7
0
def main():
    gamin = True  #reset indicator
    while (gamin):
        gamin = False
        e = league.Engine("Go Nutts!")
        e.init_pygame()

        ##sprites = league.Spritesheet('../assets/base_chip_pipo.png', league.Settings.tile_size, 8)
        backgroundMaterial = league.Spritesheet(
            '../assets/woodlandMaterials.png', league.Settings.tile_size, 5)
        directionalInfo = league.Spritesheet('../assets/directions.png',
                                             league.Settings.tile_size, 3)
        t = league.Tilemap('../assets/woodland.lvl',
                           backgroundMaterial,
                           layer=1)
        ##d = league.Tilemap('../assets/directions.lvl', directionalInfo, layer = 2)
        b = league.Tilemap('../assets/background.lvl',
                           backgroundMaterial,
                           layer=0)
        world_size = (t.wide * league.Settings.tile_size,
                      t.high * league.Settings.tile_size)
        e.drawables.add(b.passable.sprites())
        e.drawables.add(t.passable.sprites())
        ##e.drawables.add(d.passable.sprites())
        m = SoundManager()
        m.bgm_start('Song_For_Someone.wav')
        p = Player(2, 420, 120)
        o = Overlay(p)
        bu = MusicButton()
        p.blocks.add(t.impassable)
        p.world_size = world_size
        p.rect = p.image.get_rect()

        s = Spider(10, 2810, 2527, 210, "v")
        s.blocks.add(t.impassable)
        s.world_size = world_size
        s.rect = s.image.get_rect()

        s2 = Spider(10, 1590, 630, 200, "v")
        s2.blocks.add(t.impassable)
        s2.world_size = world_size
        s2.rect = s2.image.get_rect()

        s3 = Spider(10, 3090, 700, 230, "v")
        s3.blocks.add(t.impassable)
        s3.world_size = world_size
        s3.rect = s3.image.get_rect()

        s4 = Spider(10, 3530, 957, 200, "fL")
        s4.blocks.add(t.impassable)
        s4.world_size = world_size
        s4.rect = s4.image.get_rect()

        b = Bee(10, 3482, 3134, 220, "v")
        b.blocks.add(t.impassable)
        b.world_size = world_size
        b.rect = b.image.get_rect()

        b2 = Bee(10, 2486, 790, 200, "s")
        b2.blocks.add(t.impassable)
        b2.world_size = world_size
        b2.rect = b2.image.get_rect()

        b3 = Bee(10, 5940, 1078, 170, "fL")
        b3.blocks.add(t.impassable)
        b3.world_size = world_size
        b3.rect = b3.image.get_rect()

        b4 = Bee(10, 6185, 1509, 250, "s")
        b4.blocks.add(t.impassable)
        b4.world_size = world_size
        b4.rect = b4.image.get_rect()

        ac = Acorn(10, 7000, 3300)
        ac.blocks.add(t.impassable)
        ac.world_size = world_size
        ac.rect = ac.image.get_rect()

        l = Leafbug(10, 2213, 3103, 500, "h")
        l.blocks.add(t.impassable)
        l.world_size = world_size
        l.rect = l.image.get_rect()

        l2 = Leafbug(10, 1230, 167, 400, "h")
        l2.blocks.add(t.impassable)
        l2.world_size = world_size
        l2.rect = l2.image.get_rect()

        l3 = Leafbug(10, 4259, 30, 150, "s")
        l3.blocks.add(t.impassable)
        l3.world_size = world_size
        l3.rect = l3.image.get_rect()

        l4 = Leafbug(10, 6559, 1215, 250, "h")
        l4.blocks.add(t.impassable)
        l4.world_size = world_size
        l4.rect = l4.image.get_rect()

        resetL = Overlay_Button(200, 250, False, "            Reset",
                                (209, 45, 25), (0, 0, 0), (255, 255, 255), e)
        quL = Overlay_Button(375, 250, False, "         Quit", (209, 45, 25),
                             (0, 0, 0), (255, 255, 255), e)
        resetW = Overlay_Button(200, 250, False, "            Reset",
                                (53, 50, 150), (209, 45, 25), (255, 255, 255),
                                e)
        quW = Overlay_Button(375, 250, False, "         Quit", (53, 50, 150),
                             (209, 45, 25), (255, 255, 255), e)

        lose = Lose_Overlay(p, resetL, quL, e)
        w = Win_Overlay(p, resetW, quW, e)
        c = league.LessDumbCamera(800, 400, p, e.drawables, world_size)

        e.objects.append(p)

        e.objects.append(b)
        e.objects.append(b2)
        e.objects.append(b3)
        e.objects.append(b4)
        e.objects.append(ac)

        e.objects.append(l)
        e.objects.append(l2)
        e.objects.append(l3)
        e.objects.append(l4)

        e.objects.append(s)
        e.objects.append(s2)
        e.objects.append(s3)
        e.objects.append(s4)

        #Adding Drawables
        e.drawables.add(p)
        e.drawables.add(s)

        e.drawables.add(b)
        e.drawables.add(b2)
        e.drawables.add(b3)
        e.drawables.add(b4)
        e.drawables.add(ac)

        e.drawables.add(l)
        e.drawables.add(l2)
        e.drawables.add(l3)
        e.drawables.add(l4)

        e.drawables.add(s)
        e.drawables.add(s2)
        e.drawables.add(s3)
        e.drawables.add(s4)

        e.drawables.add(o)
        e.drawables.add(bu)

        e.objects.append(resetL)
        e.objects.append(quL)
        e.objects.append(resetW)
        e.objects.append(quW)
        e.objects.append(lose)
        e.objects.append(c)
        e.objects.append(o)
        e.objects.append(w)
        e.objects.append(bu)

        e.drawables.add(quL)
        e.drawables.add(resetL)
        e.drawables.add(quW)
        e.drawables.add(resetW)
        e.drawables.add(lose)
        e.drawables.add(w)

        e.collisions[(p,
                      p.ouch)] = [s, s2, s3, s4, b, b2, b3, b4, l, l2, l3, l4]
        e.collisions[(p, p.win)] = [ac]

        #Bees
        pygame.time.set_timer(pygame.USEREVENT + 1,
                              100 // league.Settings.gameTimeFactor)
        pygame.time.set_timer(pygame.USEREVENT + 2,
                              100 // league.Settings.gameTimeFactor)
        pygame.time.set_timer(pygame.USEREVENT + 3,
                              100 // league.Settings.gameTimeFactor)
        pygame.time.set_timer(pygame.USEREVENT + 4,
                              100 // league.Settings.gameTimeFactor)
        #Leafbugs
        pygame.time.set_timer(pygame.USEREVENT + 10,
                              100 // league.Settings.gameTimeFactor)
        pygame.time.set_timer(pygame.USEREVENT + 11,
                              100 // league.Settings.gameTimeFactor)
        pygame.time.set_timer(pygame.USEREVENT + 12,
                              100 // league.Settings.gameTimeFactor)
        pygame.time.set_timer(pygame.USEREVENT + 13,
                              100 // league.Settings.gameTimeFactor)
        #Spiders
        pygame.time.set_timer(pygame.USEREVENT + 20,
                              100 // league.Settings.gameTimeFactor)
        pygame.time.set_timer(pygame.USEREVENT + 21,
                              100 // league.Settings.gameTimeFactor)
        pygame.time.set_timer(pygame.USEREVENT + 22,
                              100 // league.Settings.gameTimeFactor)
        pygame.time.set_timer(pygame.USEREVENT + 23,
                              100 // league.Settings.gameTimeFactor)
        #Nutthaniel
        pygame.time.set_timer(pygame.USEREVENT + 30,
                              10 // league.Settings.gameTimeFactor)
        pygame.time.set_timer(pygame.USEREVENT + 31,
                              5 // league.Settings.gameTimeFactor)
        #Acorn
        pygame.time.set_timer(pygame.USEREVENT + 5,
                              100 // league.Settings.gameTimeFactor)

        e.add_key(pygame.K_a, p.move_left)
        e.add_key(pygame.K_d, p.move_right)
        e.add_key(pygame.K_w, p.move_up)
        e.add_key(pygame.K_s, p.move_down)

        e.add_key(pygame.K_q, p.print_place)

        e.add_key(pygame.K_b, p.climb_on)
        e.add_key(pygame.K_SPACE, p.jump)

        e.events[pygame.MOUSEBUTTONDOWN] = bu.mouse_click

        e.events[pygame.USEREVENT + 1] = b.move
        e.events[pygame.USEREVENT + 2] = b2.move
        e.events[pygame.USEREVENT + 3] = b3.move
        e.events[pygame.USEREVENT + 4] = b4.move
        e.events[pygame.USEREVENT + 5] = ac.move
        e.events[pygame.USEREVENT + 10] = l.move
        e.events[pygame.USEREVENT + 11] = l2.move
        e.events[pygame.USEREVENT + 12] = l3.move
        e.events[pygame.USEREVENT + 13] = l4.move
        e.events[pygame.USEREVENT + 20] = s.move
        e.events[pygame.USEREVENT + 21] = s2.move
        e.events[pygame.USEREVENT + 22] = s3.move
        e.events[pygame.USEREVENT + 23] = s4.move
        e.events[pygame.USEREVENT + 30] = p.move_down_gravity
        e.events[pygame.USEREVENT + 31] = p.update_jump

        e.events[pygame.QUIT] = e.stop
        e.run()
        if e.reset:
            gamin = True
Beispiel #8
0
def main():

    e = league.Engine("The Lone Ranger")
    e.init_pygame()

    sprites = league.Spritesheet('./assets/base_chip_pipo.png',
                                 league.Settings.tile_size, 8)
    t = league.Tilemap('./assets/world.lvl', sprites, layer=1)
    b = league.Tilemap('./assets/background.lvl', sprites, layer=0)
    world_size = (t.wide * league.Settings.tile_size,
                  t.high * league.Settings.tile_size)

    e.drawables.add(t.passable.sprites())
    e.drawables.add(b.passable.sprites())

    p = Player(2, 400, 300)
    o = Overlay(p)
    p.blocks.add(t.impassable)
    p.world_size = world_size
    p.rect = p.image.get_rect()

    e.drawables.add(p)

    e.drawables.add(o)

    c = league.LessDumbCamera(800, 600, p, e.drawables, world_size)

    e.objects.append(c)
    e.objects.append(o)

    wave = 1
    zombieCount = 0

    #Register events?
    pygame.time.set_timer(pygame.USEREVENT + 0,
                          250 // league.Settings.gameTimeFactor)
    pygame.time.set_timer(pygame.USEREVENT + 1,
                          250 // league.Settings.gameTimeFactor)

    #Player movements

    zombies = []

    def shoot(time):
        now = pygame.time.get_ticks()
        if now - p.lastShot > 500:
            bullet = Bullet(p.direction, 10, p.x, p.y)
            e.objects.append(bullet)
            e.drawables.add(bullet)

            for z in zombies:
                e.collisions[z] = (bullet, z.ouch)

            p.lastShot = now

    '''
    Spawns Zombies with a 25% freqency every 250ms
    '''

    def spwanZombies(time):
        if p.zombieCount < p.wave * 5:
            if random.randint(1, 100) > 75:
                z = Zombie(p, 10, p.x, p.y)
                e.drawables.add(z)
                e.objects.append(z)
                e.collisions[z] = (p, p.ouch)
                p.zombieCount = p.zombieCount + 1
                zombies.append(z)

    def moveAndShoot(time):
        keys = pygame.key.get_pressed()
        if keys[pygame.K_w] or keys[pygame.K_a] or keys[pygame.K_s] or keys[
                pygame.K_d]:
            p.move(time, pygame.key.get_pressed())
        if keys[pygame.K_SPACE]:
            shoot(time)

    '''
    Moves zombies every 250ms
    '''

    def updateZoms(time):
        for i in e.objects:
            if isinstance(i, Zombie):
                if random.randint(1, 100) > 25:
                    i.move_towards_player(time)
                if i.health <= 0:
                    e.objects.remove(i)
                    e.drawables.remove(i)
            if isinstance(i, Bullet):
                if i.ttl > 10:
                    i.kill()
        e.objects.remove(c)
        e.objects.append(c)

    e.key_events[pygame.K_a] = moveAndShoot
    e.key_events[pygame.K_d] = moveAndShoot
    e.key_events[pygame.K_w] = moveAndShoot
    e.key_events[pygame.K_s] = moveAndShoot
    e.key_events[pygame.K_SPACE] = moveAndShoot

    #Register zombie movements in event list
    e.events[pygame.USEREVENT] = updateZoms
    e.events[pygame.USEREVENT + 1] = spwanZombies

    #Sets up exit button to quit game
    e.events[pygame.QUIT] = e.stop

    #Runs the main game loop
    e.run()
Beispiel #9
0
def init_map(engine, player, gravity):
    """
    Loads up all the assets for the game map and 
    background sprites. Updates actors to hold world data. Does an inital render
    of all game objects.

    param - engine: The engine being used for this game instance
    param - player: The player being used for this game instance
    param - enemy_list: A list of enemey objects that are in this game instance.
    """
    league.Settings.tile_size = 16
    league.Settings.fill_color = (0, 0, 60)
    # league.Settings.tile_scale = 1.7

    sprites = league.Spritesheet('./assets/tileset-collapsed.png',
                                 league.Settings.tile_size, 14)
    level1 = league.Tilemap('./assets/level1.lvl', sprites, layer=2)
    world_size = (level1.wide * league.Settings.tile_size,
                  level1.high * league.Settings.tile_size)

    # initialize camera
    cam = CameraUpdates(player, world_size)
    engine.objects.append(cam)
    engine.drawables = cam  # allow camera to override draw()

    # add in background and level1
    index = 0
    while index < world_size[0]:
        full_background = Background('./assets/skyline-a.png',
                                     x=index,
                                     layer=0)
        background = Background('./assets/buildings-bg.png', x=index, layer=1)
        engine.drawables.add(full_background)
        engine.drawables.add(background)
        index += league.Settings.width
    engine.drawables.add(level1.passable.sprites())

    # Gravity must be appended first
    engine.objects.append(gravity)
    player.world_size = world_size
    player.blocks.add(level1.impassable)

    engine.collisions[player] = []
    engine.objects.append(player)
    engine.drawables.add(player)

    place_random_items(engine, world_size, player)

    flag = Flag(world_size[0] - (league.Settings.tile_size * 10),
                world_size[1])
    engine.collisions[player].append((flag, flag.win))
    engine.objects.append(flag)
    engine.drawables.add(flag)

    # add background music with map creation
    ### MUSIC IS BROKEN WON' REPEAT
    # pygame.mixer.music.load('assets/Blazer Rail.wav')
    # pygame.mixer.music.play(-1, 0.0)

    for enemy in engine.enemy_list:
        enemy.world_size = world_size
        enemy.rect = enemy.image.get_rect()
        enemy.blocks.add(level1.impassable)
        engine.objects.append(enemy)
        engine.drawables.add(enemy)
        engine.collisions[player].append((enemy, player.take_dmg))
Beispiel #10
0
    def __init__(self, user, g_engine):
        """Calls the first game screen and creates data structures to pass to update.
        user is the player class.
        g_engine is the league engine.
        door_x and door_y set the player position when moving between screens.
        drawables holds all the objects that will be placed on top of the tilemap.
        collisions holds tuples of objects and their corresponding method call
        blocking_object adds sprites to the player's block group.
        change_flag changes the screen in update() when true.
        add_flag adds sprites to overlay some added blocking sprite in update() (not being used).
        move_player_to_door moves the player to the last used door in update().

        last_drawables stores a list of objects draw from a screen to remove when changing.
        last_collisions stores a list of collision from a screen to remove when changing
        last_blocking_object list of blocking objects to remove
        now is the current time
        last_switch is the time the screen last changed
        sprites_utu is a sprite sheet from ProjectUtumno_full.png
        sprites_base is a sprite sheet from base_chip_pipo.png
        south_door_image is a flipped image used for all south doors
        background is a tilemap for covering white show through
        terrain is a tilemap for the basic terrain/full covering sprites
        detail is a tilemap for additional sprites that show whats under them
        world_size is how many tiles the .lvl says it has times the size league.Settings says
            the tiles are. Currently only used to set the player boundary and is set once
        set_screen_beach loads the first screen"""

        self.engine = g_engine
        self.user = user
        self.enemy = Enemy(self.engine, self.user, "../assets/imp - walk - vanilla.png",
                      "../assets/imp - attack - vanilla.png", 100, 10, 200, 200)
        self.engine.drawables.add(self.user)

        self.door_x = 350
        self.door_y = 250

        self.drawables = []
        self.collisions = []
        self.objects = []
        self.blocking_object = pygame.sprite.Group()
        self.change_flag = True
        self.add_flag = False
        self.move_player_to_door = True
        self.terrain_switch_flag = False
        self.boss_door_east_flag = False
        self.boss_door_west_flag = False

        self.last_drawables = []
        self.last_collisions = []
        self.last_objects = []
        self.last_blocking_objects = pygame.sprite.Group()
        self.switching_objects = []
        self.switching_collision_list = []
        self.last_switching_collision_list = []
        self.enemy_list = []

        self.now = pygame.time.get_ticks()
        self.last_switch = pygame.time.get_ticks() + 1000
        self.next_terrain_switch_time = 0
        self.switch_interval = 0
        self.path_count = 0
        self.current_path = 0
        self.last_path = -1

        self.sprites_utu = league.Spritesheet('../assets/ProjectUtumno_full.png', league.Settings.tile_size, 64)
        self.sprites_base = league.Spritesheet('../assets/base_chip_pipo.png', league.Settings.tile_size, 8)
        self.south_door_image = pygame.transform.flip(self.sprites_utu.sprites[1094].image, 0, 1)
        self.background = league.Tilemap('../assets/blank.lvl', self.sprites_utu, layer=1)
        self.terrain = league.Tilemap('../assets/blank.lvl', self.sprites_utu, layer = 2)
        self.details = league.Tilemap('../assets/blank.lvl', self.sprites_utu, layer = 3)
        self.world_size = (self.terrain.wide*league.Settings.tile_size, self.terrain.high * league.Settings.tile_size)
        self.user.world_size = self.world_size
        self.set_screen_beach()
Beispiel #11
0
def all_done(self):
    print("Peace out ya'll.")
    pygame.quit()
    sys.exit()


league.Settings.width = 768
league.Settings.height = 768

e = league.Engine("Really sucky PvZ")
e.init_pygame()

e.events[pygame.QUIT] = all_done

sprites = league.Spritesheet('./assets/base_chip_pipo.png',
                             league.Settings.tile_size, 8)
t = league.Tilemap('./assets/defense.lvl', sprites, layer=0)

scs = []
scs_b = []
sc = sprites.sprites[155]
sc_b = sprites.sprites[163]
for i in range(6):
    scs.append(league.Drawable())
    scs_b.append(league.Drawable())
    scs[i].image = sc.image
    scs_b[i].image = sc_b.image
    scs[i].rect = scs[i].image.get_rect()
    scs_b[i].rect = scs_b[i].image.get_rect()
    scs[i].rect.x = 64
    scs_b[i].rect.x = 64