Exemplo n.º 1
0
    def __init__(self, player):
        """ Create level 1. """

        # Call the parent constructor
        Level.__init__(self, player, self._BACKGROUND_IMAGE)

        self.player = player
        self.show_text(self._INTRO_TEXT)
        self.level_limit = -1000

        # Array with width, height, x, and y of platform
        level = [[210, 70, 500, 500],
                 [210, 70, 800, 400],
                 [210, 70, 1000, 500],
                 [210, 70, 1120, 280],
                 ]

        # Go through the array above and add platforms
        for platform in level:
            block = Platform()
            block.rect.x = platform[2]
            block.rect.y = platform[3]
            block.player = self.player
            self.platform_list.add(block)

        self.enemy_list = pygame.sprite.Group()
        self.make_n_random_enemies(2)
Exemplo n.º 2
0
 def __init__(self, width, height):
     Level.__init__(self, width, height)
     ##initialize blocks##
     boxtop = Terrain(20, -19, 40, 2, 0, 0,100, self, 0.5)
     boxleft= Terrain(-1,-5,2,30,0,0,100,self,0.5)
     boxbottom= Terrain(20,9,40,2,0,0,100,self,0.5)
     boxright= Terrain(41,-5,2,30,0,0,100,self,0.5)
     barrbottom = Terrain(15,-6,6,1,0,0,100,self,.5)
     barrright = Terrain(18.5,-11,1,10,0,0,100,self,.5)
     
     goal= Goal(38,-15.5,1,5,0,0,100,self,0.5)
     
     tramp1= Trampoline(7,7,6,1,0,0,100,self,.5)
     tramp2= Trampoline(36,7,6,1,0,0,100,self,.5)
     tramp3= Trampoline(32,-8,6,1,0,0,100,self,.5)
     tramp4= Trampoline(36,-23,6,1,0,0,100,self,.5)
     p =  Player(2, 5,  1, 2, 0, 0,  1, self, 0.5) 
     g =   GoalBlock(16.5, -7, 2, 2, 0, 0,  2, self, 0.5)
     self.add_elem(p)
     self.add_elem(barrbottom)
     self.add_elem(barrright)
     self.add_elem(tramp1)
     self.add_elem(tramp2)
     self.add_elem(tramp3)
     self.add_elem(tramp4)
     self.add_elem(g)
     self.add_elem(boxtop)
     self.add_elem(boxright)
     self.add_elem(boxbottom)
     self.add_elem(boxleft)
     self.add_elem(goal)
Exemplo n.º 3
0
    def __init__(self, player):
        """ Create level 1. """

        # Call the parent constructor
        Level.__init__(self, player)

        self.level_limit = -1500

        # Array with width, height, x, and y of platform
        level = [
            [210, 70, 500, 500],
            [210, 70, 800, 400],
            [210, 70, 1000, 500],
            [210, 70, 1120, 280],
        ]

        # Go through the array above and add platforms
        for platform in level:
            block = Platform(platform[0], platform[1])
            block.rect.x = platform[2]
            block.rect.y = platform[3]
            block.player = self.player
            self.platform_list.add(block)

        # Add a custom moving platform
        block = MovingPlatform(70, 40)
        block.rect.x = 1350
        block.rect.y = 280
        block.boundary_left = 1350
        block.boundary_right = 1600
        block.change_x = 1
        block.player = self.player
        block.level = self
        self.platform_list.add(block)
Exemplo n.º 4
0
    def processEvent(self, event):
        if event.type == pygame.USEREVENT and event.code == PAGEDEAD:
            m = MessageScene(self.director, self, 'Congratulations', "You have completed the game!\nNow you're entitled \nto the 3D version.", "Press to quit")
            m.messageBox.button.onMouseDown = lambda: pygame.event.post(pygame.event.Event(pygame.QUIT))
            self.director.setScene(m)

        Level.processEvent(self, event)
Exemplo n.º 5
0
 def __init__(self):
     pygame.init()
     pygame.mixer.init()
     self.screen = pygame.display.set_mode((896, 896))
     self.screen_rect = self.screen.get_rect()
     self.font = pygame.font.Font(None, 50)
     self.font2 = pygame.font.Font(None, 25)
     self.won = False
     self.lost = False
     pygame.display.set_caption("Bobby The Destroyer")
     self.clock = pygame.time.Clock()
     this_folder = os.path.dirname(os.path.abspath(__file__))
     my_file = os.path.join(this_folder, 'maze_old.txt')
     self.level = Level(self.screen, my_file)
     self.player = Player(self.screen, 1, 1, self.level)
     self.guard = Guard(self.screen, 12, 1, self.player, self.level)
     self.bombs = []
     self.numfin = 0
     self.bombs.append(Bomb(self.screen, 3, 5, self.player, self.guard))
     self.bombs.append(Bomb(self.screen, 3, 8, self.player, self.guard))
     self.bombs.append(Bomb(self.screen, 10, 7, self.player, self.guard))
     self.bombs.append(Bomb(self.screen, 10, 6, self.player, self.guard))
     self.bombs.append(Bomb(self.screen, 12, 2, self.player, self.guard))
     self.bombs.append(Bomb(self.screen, 12, 10, self.player, self.guard))
     self.bombs.append(Bomb(self.screen, 7, 3, self.player, self.guard))
     self.bombs.append(Bomb(self.screen, 7, 10, self.player, self.guard))
     self.game_active = True
     self.bg = PhotoRect(self.screen, "background", 896, 896)
Exemplo n.º 6
0
 def __init__(self, player):
     Level.__init__(self, player)
     self.init_enemies()
     self.init_items()
     self.PLAYER_START = [72, 57]
     self.is_beatable = False
     self.init_labels()
Exemplo n.º 7
0
 def run(self):
     while True:
         self.event()
         self.show()
         self.level.traffic(self.player)
         if self.level.failed(self.player):
             pygame.mixer.Sound.play(self.l_sound)
             if not self.health.loose_health():
                 self.reset_game()
             else:
                 time.sleep(1)
                 self.player.reset()
                 self.level = Level(self.screen, self.player,
                                    self.path_height)
                 self.clean_events()
                 self.player.image = self.player.u_image
             pygame.mixer.Sound.stop(self.l_sound)
         if self.player.player_won():
             self.score.add_score()
             self.creat_text("Level completed!", (0, 255, 0))
             pygame.mixer.Sound.play(self.w_sound)
             time.sleep(1)
             self.player.reset()
             self.level = Level(self.screen, self.player, self.path_height)
             self.player.image = self.player.u_image
Exemplo n.º 8
0
    def __init__(self, director, player):
        Level.__init__(self, director, player)
        self.player.rect.x = 766
        self.player.rect.y = 82

        self.enemyGroup.add([
            Nazist(640, 140, self.player, director),
            # 							Nazist(640, 176, self.player, director),
            # 							Nazist(688, 18, self.player, director),
            Nazist(524, 51, self.player, director),
            # 							Nazist(524, 140, self.player, director),
            Nazist(345, 46, self.player, director),
            Nazist(345, 70, self.player, director),
            # 							Nazist(345, 100, self.player, director),
            Nazist(140, 145, self.player, director),
            Nazist(140, 175, self.player, director),
            Nazist(185, 10, self.player, director),
            Mr_H(27, 48, self.player, director)
        ])

        self.bg = load_image("mapa_h.png", Constants.MAP_DIR)
        self.collisionBg = load_image("mapa_h_bg.png", Constants.BG_MAP_DIR)

        load_music("level_three.xm")
        pygame.mixer.music.set_volume(0.25)
        pygame.mixer.music.play(-1)

        player.setWeapons([WpnGrenade(), WpnRifle()])
Exemplo n.º 9
0
 def __init__(self):
     self.pencil = Pencil()
     self.level = Level(1)
     self.affichage = Affichage()
     self.player = self.get_user()
     self.nb_python = 0
     self.db = Database()
Exemplo n.º 10
0
class Grid:
    def __init__(self, levelmap, screen, grid_dim, view_coord):
        self.screen_pos = view_coord
        self.screen = screen  # pygame display
        # tuple, grid dimensions (horizontal tiles, vertical tiles)
        self.size = grid_dim
        # View coordinates (offset from (0,0), in pixels)
        self.view_coord = view_coord
        self.tilesize = int(screen.get_rect().width / grid_dim[0]), \
            int(screen.get_rect().height / grid_dim[1])
        self.level = Level(levelmap)
        self.background = self.level.render(self.screen, self.size)
        self.entities = dict()

    def setLevel(self, levelmap):
        self.level = Level(levelmap)
        self.background = self.level.render(self.screen, self.size)

    def get_mod(self):
        return self.view_coord[0] % self.tilesize[0], \
               self.view_coord[1] % self.tilesize[1]

    def add_entity(self, entity):
        for i in range(len(self.entities) + 1):
            if i not in self.entities:
                self.entities[i] = entity
                return i

    def remove_entity(self, entity):
        for i in self.entities:
            if entity is self.entities[i]:
                del self.entities[i]
                return i
Exemplo n.º 11
0
Arquivo: World.py Projeto: churay/zol
    def load(self):
        # get list of segment files
        seg_file_pattern = os.path.join('assets','data','segdata','*[0-9].gif')
        seg_files = glob.glob(seg_file_pattern)

        # load segments into pygame surfaces
        # creates Segments
        # groups segments into levels
        lvl_groups = {}
        for seg_file in seg_files:
            seg_id = string.split(os.path.basename(seg_file),'.')[1]
            filename = os.path.basename(seg_file)
            lvl_id = filename[:string.find(filename,'.')]

            segment = Segment(lvl_id + '.' + seg_id)
            
            if (lvl_id not in lvl_groups):
                lvl_groups[lvl_id] = [segment]
            else:
                lvl_groups[lvl_id].append(segment)

        # create Levels
        for lvl_id in lvl_groups.keys():
            segments = lvl_groups[lvl_id]
            level = Level(lvl_id)
            for segment in segments:
                level.add_segment(segment)
            level.connect()
            self.levels[lvl_id] = level
Exemplo n.º 12
0
    def __init__(self, width, height):
        Level.__init__(self, width, height)
        ##initialize blocks##
        boxtop = Terrain(20, -19, 40, 2, 0, 0,100, self, 0.5)
        boxleft= Terrain(-1,-5,2,30,0,0,100,self,0.5)
        boxbottom= Terrain(27.0,9.0,54.0,2.0,0.0,0.0,100,self,0.5)
        boxright= Terrain(55,-5,2,30,0,0,100,self,0.5)

        goal= Goal(53,5,1,5,0,0,100,self,0.5)
        
        
        b =   Block(2, 2,  4, 1, 0, 0,  1, self, 0.5)
        c =  Player(7, 5,  1, 2, 0, 0,  1, self, 0.5)
        d =   Block(4, 2, 4, 1, 0, 5,  2, self, 0.5)  
        a =   GoalBlock(4, 5, 2, 2, 0, 5,  2, self, 0.5) 
        m = Trampoline(30, -4, 2, 1, 0, 0, 1, self, 0.5)
        e = Spike(30.0, 7.5, 41.0, 1.0, 0.0, 0.0, 100, self, 0.1)
        f = Spike(29.0, 6.5, 1.0, 1.0, 0.0, 0.0, 100, self, 0.1)
        self.add_elem(c)
        self.add_elem(m)
        self.add_elem(b)
        self.add_elem(a)
        self.add_elem(d)
        self.add_elem(e)
        self.add_elem(f)
        self.add_elem(boxtop)
        self.add_elem(boxright)
        self.add_elem(boxbottom)
        self.add_elem(boxleft)
        self.add_elem(goal)
Exemplo n.º 13
0
    def __init__(self, director, player):
        Level.__init__(self, director, player)
        self.player.rect.x = 782
        self.player.rect.y = 912
        self.dead_sub_boss = 0      #Counts the dead Centurions.
        self.enemyGroup.add([Legionnaire(987, 768, self.player, director),
                             Legionnaire(1083, 768, self.player, director),
                             Legionnaire(1119, 768, self.player, director),
                             Legionnaire(987, 834, self.player, director),
                             Legionnaire(477, 747, self.player, director),
                             Legionnaire(645, 738, self.player, director),
                             Legionnaire(477, 891, self.player, director),
                             Legionnaire(645, 788, self.player, director),
                             Centurion(150, 288, self.player, director),
                             Centurion(1455, 288, self.player, director),
                             Centurion(1329, 1248, self.player, director)]) 

        self.door = Door(760, 575, 'door_sheet.png', -1, 'coordDoor.txt', [2], 'door_open.wav')     
        self.doorGroup = EntityGroup([])
        self.doorGroup.add(self.door)
        self.groups.append(self.doorGroup)

        self.bg = load_image("map_caesar_a_img.png", Constants.MAP_DIR)
        self.collisionBg = load_image(
            "map_caesar_a_bg.png", Constants.BG_MAP_DIR)

        load_music("level_one.it")
        pygame.mixer.music.set_volume(1)
        pygame.mixer.music.play(-1)

        player.setWeapons([WpnBlade("wpns2.png", -1, pygame.Rect(344, 342, 28, 28), "blade_swing.wav", 0.5), \
                          WpnBow("items-1.png", None, pygame.Rect(0, 24, 24, 24))])
Exemplo n.º 14
0
    def __init__(self, width, height):
        Level.__init__(self, width, height)
        ##initialize blocks##
        boxtop = Terrain(20, -19, 40, 2, 0, 0, 100, self, 0.5)
        boxleft = Terrain(-1, -5, 2, 30, 0, 0, 100, self, 0.5)
        boxbottom = Terrain(20, 9, 40, 2, 0, 0, 100, self, 0.5)
        boxright = Terrain(41, -5, 2, 30, 0, 0, 100, self, 0.5)
        barrbottom = Terrain(15, -6, 6, 1, 0, 0, 100, self, .5)
        barrright = Terrain(18.5, -11, 1, 10, 0, 0, 100, self, .5)

        goal = Goal(38, -15.5, 1, 5, 0, 0, 100, self, 0.5)

        tramp1 = Trampoline(7, 7, 6, 1, 0, 0, 100, self, .5)
        tramp2 = Trampoline(36, 7, 6, 1, 0, 0, 100, self, .5)
        tramp3 = Trampoline(32, -8, 6, 1, 0, 0, 100, self, .5)
        tramp4 = Trampoline(36, -23, 6, 1, 0, 0, 100, self, .5)
        p = Player(2, 5, 1, 2, 0, 0, 1, self, 0.5)
        g = GoalBlock(16.5, -7, 2, 2, 0, 0, 2, self, 0.5)
        self.add_elem(p)
        self.add_elem(barrbottom)
        self.add_elem(barrright)
        self.add_elem(tramp1)
        self.add_elem(tramp2)
        self.add_elem(tramp3)
        self.add_elem(tramp4)
        self.add_elem(g)
        self.add_elem(boxtop)
        self.add_elem(boxright)
        self.add_elem(boxbottom)
        self.add_elem(boxleft)
        self.add_elem(goal)
Exemplo n.º 15
0
	def __init__(self, director, player):
		Level.__init__(self, director, player)
		self.player.rect.x = 766
		self.player.rect.y = 82

		self.enemyGroup.add([Nazist(640, 140, self.player, director),
# 							Nazist(640, 176, self.player, director),
# 							Nazist(688, 18, self.player, director),
							Nazist(524, 51, self.player, director),
# 							Nazist(524, 140, self.player, director),
							Nazist(345, 46, self.player, director),
							Nazist(345, 70, self.player, director),
# 							Nazist(345, 100, self.player, director),
							Nazist(140, 145, self.player, director),
							Nazist(140, 175, self.player, director),
							Nazist(185, 10, self.player, director),
							Mr_H(27, 48, self.player, director)])


		self.bg = load_image("mapa_h.png", Constants.MAP_DIR)
		self.collisionBg = load_image("mapa_h_bg.png", Constants.BG_MAP_DIR)

		load_music("level_three.xm")
		pygame.mixer.music.set_volume(0.25)
		pygame.mixer.music.play(-1)

		player.setWeapons([WpnGrenade(), WpnRifle()])
Exemplo n.º 16
0
    def __init__(self, player, active_sprite_list):
        """ Create level 1. """

        # Call the parent constructor
        Level.__init__(self, player, self._BACKGROUND_IMAGE)
        self.show_text(self._INTRO_TEXT)
        self.active_sprite_list = active_sprite_list

        self.level_limit = -1000

        # Array with type of platform, and x, y location of the platform.
        level = [
            [210, 30, 450, 500],
            [210, 30, 850, 500],
            [210, 30, 1000, 500],
        ]

        # Go through the array above and add platforms
        for platform in level:
            block = Platform()
            block.rect.x = platform[2]
            block.rect.y = platform[3]
            block.player = self.player
            self.platform_list.add(block)

        toots = Toots(player, self.active_sprite_list)
        toots.level = self
        toots.rect.x = 1000
        toots.rect.y = SCREEN_HEIGHT + 100
        self.enemy_list = pygame.sprite.Group()
        self.enemy_list.add(toots)
Exemplo n.º 17
0
class Game:
    """Game config"""
    def __init__(self):
        self.screen = Screen(300, 300, 20)
        self.level = Level(self.screen.sprite, self.screen)
        self.level.items_cord()
        self.guardian = Guardian(self.level)
        self.player = Player(self.level, self.screen.sprite, self.screen, self.guardian)
        self.needle = Items(self.level, "ressource/aiguille.png")
        self.ether = Items(self.level, "ressource/ether.png")
        self.syringue = Items(self.level, "ressource/seringue.png")
        self.pipe = Items(self.level, "ressource/tube_plastique.png")

    def collect_items(self):
        """Set items collection by player"""
        if self.player.rect == self.needle.rect:
            self.player.health_attack_up()
        elif self.player.rect == self.ether.rect:
            self.player.health_attack_up()
        elif self.player.rect == self.syringue.rect:
            self.player.health_attack_up()
        elif self.player.rect == self.pipe.rect:
            self.player.health_attack_up()

    def guardian_collide(self):
        """Set player behavior against guardian"""
        log_x, log_y = self.level.from_cord_to_grid(self.player.rect.x, self.player.rect.y)
        if self.level.level[log_y][log_x] == 3:
            self.player.health = self.player.health - self.guardian.attack
            self.guardian.health = self.guardian.health - self.player.attack
Exemplo n.º 18
0
class GameManager:
    def __init__(self, entity_table):
        self.level = Level("content/level1.dat")
        self.level.load_from_file()
        self.description_manager = DescriptionManager(10)
        self.player = entity_table[0]
        index = 0
        self.enemies = []
        for entity in entity_table:
            if index == 0:
                index += 1
                continue
            self.enemies.append(entity)
            index += 1

    def update(self, orientation):
        if self.player.is_dead():
            self.player.play_sound_through("content/sound/failure.wav")
            return "fail"
        self.player.attack(self.description_manager, self.enemies, orientation)

        total_dead = 0
        for e in self.enemies:
            if not e.is_dead():
                e.attack(self.description_manager, self.player, orientation)
            else:
                total_dead += 1
                if total_dead == len(self.enemies):
                    self.player.play_sound_through("content/sound/victory.wav")
                    return "victory"
        return self.description_manager.get_str()

    def get_level(self):
        return self.level
Exemplo n.º 19
0
    def __init__(self, player):
        """ Create level 1. """

        # Call the parent constructor
        Level.__init__(self, player)

        self.level_limit = -1000

        # Array with type of platform, and x, y location of the platform.
        level = [
            [210, 70, 500, 550],
            [210, 70, 800, 400],
            [210, 70, 1000, 500],
            [210, 70, 1120, 280],
        ]

        # Go through the array above and add platforms
        for platform in level:
            block = Platform(platform[0], platform[1])
            block.rect.x = platform[2]
            block.rect.y = platform[3]
            block.player = self.player
            self.platform_list.add(block)

        # Add a custom moving platform
        block = MovingPlatform(70, 70)
        block.rect.x = 1500
        block.rect.y = 300
        block.boundary_top = 100
        block.boundary_bottom = 550
        block.change_y = -1
        block.player = self.player
        block.level = self
        self.platform_list.add(block)
Exemplo n.º 20
0
    def __init__(self):

        #*************** основное window ***************

        self.win_width = settings.WIDTH_WIN  # Ширина окна

        self.win_height = settings.HEIGHT_WIN  # Высота окна

        self.win_display = (self.win_width, self.win_height)  # Компановка

        self.timer = pygame.time.Clock()  # Таймер кадров

        #*************** инициализация объектов ***************

        self.left = self.right = self.up = self.down = self.space = False

        self.exit_ = True  # флаг для выхода

        self.windows = Windows()  # инициализируем Windows

        self.TARGET = pygame.USEREVENT

        self.level1 = Level(settings.LEVEL_1)  # Инициализируем level1

        self.level1.load_level()

        self.player = Player(
            self.level1.ret_A())  # инициализируем Tank по карте

        self.enemy = Enemy(self.level1.ret_B())

        self.platforms = self.level1.ret_tiles()

        self.end = (self.player.ret_topleft()[0] / 32,
                    self.player.ret_topleft()[1] / 32)

        self.start = (self.level1.ret_B()[0] / 32, self.level1.ret_B()[1] / 32)

        #*************** блоки спрайтов ***************

        self.block_list = pygame.sprite.Group(
        )  #Это список спрайтов. Каждый блок добавляется в этот список.

        self.all_sprites_list = pygame.sprite.Group(
        )  # # Это список каждого спрайта. Все блоки, а также блок игрока.

        self.bullet_list = pygame.sprite.Group()  #тес массив спрайтов пули

        self.block_list.add(self.platforms)

        self.all_sprites_list.add(self.player, self.enemy)

        self.walls = []

        for i in self.block_list:

            x, y = i.rect.topleft

            self.walls.append((x / 32, y / 32))
Exemplo n.º 21
0
    def startGame(self):
        self.gameOverScreen.hide()

        self.cleanup()

        self.player = Player()

        self.currentLevel = Level("testLevel")
Exemplo n.º 22
0
def initLevel(level_set, level):
    # Create an instance of this Level
    global myLevel
    myLevel = Level(level_set, level)

    # Draw this level

    gui.drawLevel(myLevel.getMatrix())
Exemplo n.º 23
0
class GameSpace():

    def __init__(self):
        pygame.init()
        pygame.display.set_caption('Tanks')
        self.screen = pygame.display.set_mode(WIN_DISPLAY)
        self.background = Surface(WIN_DISPLAY)
        self.background.fill(Color(WIN_COLOR))

        self.timer = pygame.time.Clock()

        self.cf = ClientConnFactory(self)
        reactor.connectTCP(HOST,PORT,self.cf)
        reactor.run()

    def start(self):
        self.player = Player(100,100)# инициализируем Tank
        self.level1 = Level('level1.txt')#Инициализируем level1
        self.level1.load_level()

        #self.test_loop()


    def tick(self):
        print 'tick'
        for e in pygame.event.get():
            if e.type == QUIT:
                reactor.stop()
                raise SystemExit, "Quit"
            if e.type == KEYDOWN and e.key == K_LEFT:
                print '*'*100
                print "KEYDOWN K_LEFT"
                self.sendData("KEYDOWN LEFT! Yu-hooo")
            print 'end tick for'
        #self.sendData("**********************Hello!")
        self.screen.blit(self.background,(0,0))
        self.screen.blit(self.player.image,(100,100))
        pygame.display.update()


    def sendData(self, data):
        self.cf.conn.send(data)

    def addData(self, data):
        print "INCOMING: ", data

    def test_loop(self):
        while True:
            for e in pygame.event.get():
                if e.type == QUIT:
                     raise SystemExit, "QUIT"
                if e.type == KEYDOWN and e.key == K_LEFT:
                    print "KEYDOWN K_LEFT"


            self.screen.blit(self.background,(0,0))
            self.screen.blit(self.player.image,(100,100))
            pygame.display.update()
Exemplo n.º 24
0
 def extract_levels_from_content(self, file):
     self.levels = []
     content = self.file_reader.read_content(file)
     levels = self.load_levels(content)
     for level in levels:
         level_object = Level()
         level_object.create_level(content, level)
         self.levels.append(level_object)
     return self.levels
Exemplo n.º 25
0
    def __init__(self, player):
        """ Create level 1. """

        # Call the parent constructor
        Level.__init__(self, player)

        self.level_limit = -6000
        BLOCK_WIDTH = 210
        self.block_height = 70
        # Array with width, height, x, and y of platform
        level = [
            [BLOCK_WIDTH, BLOCK_HEIGHT, 500, 500],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 800, 400],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 1000, 500],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 1120, 280],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 1500, 280],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 2000, 280],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 2500, 280],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 3000, 280],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 3500, 280],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 4000, 280],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 4500, 280],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 5000, 280],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 5500, 280],
            [BLOCK_WIDTH, BLOCK_HEIGHT, 60000, 280],
        ]

        # Go through the array above and add platforms
        for platform in level:
            block = Platform(platform[0], platform[1])
            block.rect.x = platform[2]
            block.rect.y = platform[3]
            block.player = self.player
            self.platform_list.add(block)

        # Add a custom moving platform
        block = MovingPlatform(70, 40)
        block.rect.x = 1350
        block.rect.y = 280
        block.boundary_left = 1350
        block.boundary_right = 1600
        block.change_x = 1
        block.player = self.player
        block.level = self
        self.platform_list.add(block)

        # Add a custom enemy
        enemy = Enemy(30, 30)
        enemy.rect.x = 900
        enemy.rect.y = 300
        enemy.boundary_left = 800
        enemy.boundary_right = 1000
        enemy.change_x = 1
        enemy.player = self.player
        enemy.level = self
        self.enemy_list.add(enemy)
Exemplo n.º 26
0
    def processEvent(self, event):
        if event.type == pygame.KEYDOWN and event.key == pygame.K_RETURN:
            nextLevel = LevelTwo(self.director, self.player)
            self.director.setScene(nextLevel)
        if event.type == pygame.KEYDOWN and event.key == pygame.K_F1:
            self.door.setActive(True)
            # nextLevel = LevelOneB(self.director, self.player)
            # self.director.setScene(nextLevel)

        Level.processEvent(self, event)
Exemplo n.º 27
0
def loadRandomLevel():
    global current_level
    global last_level
    # TODO: Make more levels by rotation and mirroring
    last_level = current_level
    current_level = random.randint(min_level, max_level)
    matrix = Level(level_set, current_level).matrix
    matrix.moves = 0
    matrix.actions = ""
    return matrix
Exemplo n.º 28
0
def initLevel(level_set,level):
	# Create an instance of this Level
	global myLevel
	myLevel = Level(level_set,level)

	# Draw this level
	drawLevel(myLevel.getMatrix())
	
	global target_found
	target_found = False
Exemplo n.º 29
0
    def processEvent(self, event):
        if event.type == pygame.KEYDOWN and event.key == pygame.K_RETURN:
            nextLevel = LevelTwo(self.director, self.player)
            self.director.setScene(nextLevel)

        if event.type == pygame.USEREVENT and event.code == CAESARDEAD:
            nextLevel = LevelTwo(self.director, self.player)
            self.director.setScene(nextLevel)

        Level.processEvent(self, event)
Exemplo n.º 30
0
def initLevel(level_set, level):
    # Create an instance of this Level
    global myLevel
    myLevel = Level(level_set, level)

    # Draw this level
    drawLevel(myLevel.getMatrix())

    global target_found
    target_found = False
Exemplo n.º 31
0
	def processEvent(self, event):
		if event.type == pygame.KEYDOWN and event.key == pygame.K_RETURN:
			nextLevel = LevelFour(self.director, self.player)
			self.director.setScene(nextLevel)

		if event.type == pygame.USEREVENT and event.code == MRHDEAD:
			nextLevel = LevelFour(self.director, self.player)
			self.director.setScene(nextLevel)

		Level.processEvent(self, event)
Exemplo n.º 32
0
 def __init__(self):
     self.screen = Screen(300, 300, 20)
     self.level = Level(self.screen.sprite, self.screen)
     self.level.items_cord()
     self.guardian = Guardian(self.level)
     self.player = Player(self.level, self.screen.sprite, self.screen, self.guardian)
     self.needle = Items(self.level, "ressource/aiguille.png")
     self.ether = Items(self.level, "ressource/ether.png")
     self.syringue = Items(self.level, "ressource/seringue.png")
     self.pipe = Items(self.level, "ressource/tube_plastique.png")
Exemplo n.º 33
0
    def processEvent(self, event):
        if event.type == pygame.USEREVENT and event.code == PAGEDEAD:
            m = MessageScene(
                self.director, self, 'Congratulations',
                "You have completed the game!\nNow you're entitled \nto the 3D version.",
                "Press to quit")
            m.messageBox.button.onMouseDown = lambda: pygame.event.post(
                pygame.event.Event(pygame.QUIT))
            self.director.setScene(m)

        Level.processEvent(self, event)
Exemplo n.º 34
0
class playerTests(unittest.TestCase):
    
    def setUp(self):
        self.level = Level(200, 200)

        self.level.gen_base(60, 60)

        board = self.level.board
        self.player = Player(60, 60, '@', board)
        self.level.board[self.player.y][self.player.x - 1] = ' '
        self.level.board[self.player.y][self.player.x + 1] = ' '
        self.level.board[self.player.y - 1][self.player.x] = ' '
        self.level.board[self.player.y + 1][self.player.x] = ' '


    def test_playercantgothroughwalls(self):
        initx = self.player.x
        inity = self.player.y

        #Set a wall to the left of player
        self.level.board[self.player.y][self.player.x-1] = '+'
        self.player.move('a')
        assert self.player.y == inity and self.player.x == initx
        
    def test_playercanmoveleft(self):
        initx = self.player.x
        inity = self.player.y
        print(inity, " ", self.player.y)
        print(initx, " ", self.player.x)


        self.player.move('a')
        assert self.player.y == inity and self.player.x == initx -1
        
        
    def test_playercanmoveright(self):
        initx = self.player.x
        inity = self.player.y
        self.player.move('d')
        assert self.player.y == inity and self.player.x == initx +1
    
        
    def test_playercanmoveup(self):
        initx = self.player.x
        inity = self.player.y
        self.player.move('w')
        assert self.player.y == inity - 1 and self.player.x == initx
        
        
    def test_playercanmovedown(self):
        initx = self.player.x
        inity = self.player.y
        self.player.move('s')
        assert self.player.y == inity +1 and self.player.x == initx
Exemplo n.º 35
0
    def test_get_column_index(self):
        content = [
            ["Plaats", "School", "Niveau", "Leerling", "Score", "Label"],
            ["Apeldoorn", "HAN", "HBO", "563631", "15", "test1"]]
        niveau = Level()
        niveau.name = "School"
        column_number = 1

        result = niveau.get_column_index(content)

        self.assert_niveau_is_in_column_number(column_number, result)
Exemplo n.º 36
0
 def readDetailsForCustomLevel(self):
     """
     This method allows to the user create and use a new customized level
     to generate Sudoku games.
     Note. This level will not be stored in the .xml file
     """
     userLevel = Level(0, 0, "Custom level")
     userLevel.setBottomLimit = int(self.getUserInput("\
     Please enter a number to set the minimun limit for empty spaces"))
     userLevel.setTopLimit = int(self.getUserInput("\
     Please enter a number to set the maximun limit for empty spaces"))
     return userLevel
Exemplo n.º 37
0
 def __init__(self, levelmap, screen, grid_dim, view_coord):
     self.screen_pos = view_coord
     self.screen = screen  # pygame display
     # tuple, grid dimensions (horizontal tiles, vertical tiles)
     self.size = grid_dim
     # View coordinates (offset from (0,0), in pixels)
     self.view_coord = view_coord
     self.tilesize = int(screen.get_rect().width / grid_dim[0]), \
         int(screen.get_rect().height / grid_dim[1])
     self.level = Level(levelmap)
     self.background = self.level.render(self.screen, self.size)
     self.entities = dict()
Exemplo n.º 38
0
 def get_level(self, lvl):
     level = self._dh.get_level(lvl)
     if not level:
         level = Level(lvl)
     texts = self.get_level_texts(lvl)
     if texts:
         for k, v in texts.items():
             if v:
                 setattr(level, '_%s' % k , v)
     if not level._boss:
         level._boss = random.choice(self._gamedata['boss'])
     return level
Exemplo n.º 39
0
    def test_get_variables(self):
        content = [["Plaats", "School", "Niveau", "Leerling", "Score", "Label"],
                   ["Apeldoorn", "HAN", "HBO", "563631", "15", "test1"],
                   ["Arnhem", "HAN", "HBO", "563631", "15", "test1"]]
        niveau = Level()
        expected_result = ["Apeldoorn", "Arnhem"]
        column_number = 0
        niveau.name = "Plaats"

        variables = niveau.get_variables(column_number, content)

        self.assert_get_variables_contains(expected_result, variables)
Exemplo n.º 40
0
    def test_add_indexes_to_filtered_list(self):
        indexes_part_one = [0, 1, 2, 3, 4, 5, 6]
        indexes_part_two = [0, 1, 2, 3, 4, 5, 6]
        expected = [0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6]
        niveau = Level()

        niveau.add_row_numbers_to_filtered_list(indexes_part_one)
        niveau.add_row_numbers_to_filtered_list(indexes_part_two)

        result = niveau.row_numbers

        self.assertEqual(expected, result)
Exemplo n.º 41
0
    def __init__(self, width, height):
        Level.__init__(self, width, height)
        ##initialize blocks##
        boxtop = Terrain(20, -19, 40, 2, 0, 0,100, self, 0.5)
        boxleft= Terrain(-1,-5,2,30,0,0,100,self,0.5)
        boxbottom= Terrain(20,9,40,2,0,0,100,self,0.5)
        boxright= Terrain(41,-5,2,30,0,0,100,self,0.5)

        goal= Goal(38,5,1,5,0,0,100,self,0.5)
        
        
        b10 =   Block(1, 7,  2, 2, 0, 0,  1, self, 0.5)
        b20 =   Block(3, 7,  2, 2, 0, 0,  1, self, 0.5)
        b30 =   Block(5, 7,  2, 2, 0, 0,  1, self, 0.5)
        b40 =   Block(7, 7,  2, 2, 0, 0,  1, self, 0.5)
        b50 =   Block(9, 7,  2, 2, 0, 0,  1, self, 0.5)
        b11 =   Block(1, 5,  2, 2, 0, 0,  1, self, 0.5)
        b21 =   Block(3, 5,  2, 2, 0, 0,  1, self, 0.5)
        b31 =   Block(5, 5,  2, 2, 0, 0,  1, self, 0.5)
        b41 =   Block(7, 5,  2, 2, 0, 0,  1, self, 0.5)
        b51 =   Block(9, 5,  2, 2, 0, 0,  1, self, 0.5)
        b12 =   Block(1, 3,  2, 2, 0, 0,  1, self, 0.5)
        b22 =   Block(3, 3,  2, 2, 0, 0,  1, self, 0.5)
        b32 =   Block(5, 3,  2, 2, 0, 0,  1, self, 0.5)
        b42 =   Block(7, 3,  2, 2, 0, 0,  1, self, 0.5)
        b52 =   Block(9, 3,  2, 2, 0, 0,  1, self, 0.5)
        p =  Player(15, 5,  1, 2, 0, 0,  1, self, 0.5) 
        g =   GoalBlock(17, 5, 2, 2, 0, 0,  2, self, 0.5)  
        barrier = Terrain(35,-3,1,22,0,0,100,self,0.5)
        self.add_elem(p)
        self.add_elem(b10)
        self.add_elem(b20)
        self.add_elem(b30)
        self.add_elem(b40)
        self.add_elem(b50)
        self.add_elem(b11)
        self.add_elem(b21)
        self.add_elem(b31)
        self.add_elem(b41)
        self.add_elem(b51)
        self.add_elem(b12)
        self.add_elem(b22)
        self.add_elem(b32)
        self.add_elem(b42)
        self.add_elem(b52)
        self.add_elem(barrier)
        self.add_elem(g)
        self.add_elem(boxtop)
        self.add_elem(boxright)
        self.add_elem(boxbottom)
        self.add_elem(boxleft)
        self.add_elem(goal)
Exemplo n.º 42
0
    def __init__(self, director, player):
        Level.__init__(self, director, player)
        self.player.rect.x = 224
        self.player.rect.y = 1273

        self.laser0 = Laser(80, 340, 'laser_45.png')
        self.laser1 = Laser(400, 75, 'laser_45.png')
        self.laser2 = Laser(405, 332, 'laser_180.png')
        self.laser3 = Laser(80, 330, 'laser_180.png')
        self.laser4 = Laser(406, 341, 'laser_125.png')
        self.laser5 = Laser(80, 80, 'laser_125.png')
        self.laser6 = Laser(400, 350, 'laser_90.png')
        self.laserArray = [
            self.laser0, self.laser1, self.laser2, self.laser3, self.laser4,
            self.laser5, self.laser6
        ]
        self.laserGroup = EntityGroup([])
        self.laserGroup.add(self.laser0, self.laser1, self.laser2, self.laser3,
                            self.laser4, self.laser5, self.laser6)
        self.groups.append(self.laserGroup)
        self.laser0.active = False
        self.laser1.active = False
        self.activeLG = 1  # Pair of lasers active at a given time
        self.time = 0

        self.page = Page(408, 135, self.player, director)
        self.enemyGroup.add([
            FutureSoldier(141, 1084, self.player, director),
            #                              FutureSoldier(316, 1084, self.player, director),
            #                              FutureSoldier(141, 926, self.player, director),
            FutureSoldier(316, 926, self.player, director),
            FutureSoldier(686, 1260, self.player, director),
            FutureSoldier(508, 988, self.player, director),
            FutureSoldier(537, 1450, self.player, director),
            self.page
        ])

        self.bg = load_image("map_page_img.png", Constants.MAP_DIR)
        self.collisionBg = load_image("map_page_bg.png", Constants.BG_MAP_DIR)

        self.invisibleFloor = InvisibleFloor(
            384, 202, 59, 78)  # Invisible sprite, it functions as a trigger
        self.invisibleFloorG = EntityGroup([])
        self.invisibleFloorG.add(self.invisibleFloor)
        self.groups.append(self.invisibleFloorG)

        load_music("level_four.s3m")
        pygame.mixer.music.set_volume(0.5)
        pygame.mixer.music.play(-1)

        player.setWeapons([WpnBlade("lightsaber.png", -1, pygame.Rect(128, 77, 42, 42), "sthswng1.wav", 0.2), \
                          WpnLaser()])
Exemplo n.º 43
0
 def update(self, time):
     Level.update(self, time)
     if not self.door.active and self.dead_sub_boss == 3:
         #When all Centurions are dead we open the door
         self.door.setActive(True)
     if len(pygame.sprite.spritecollide(self.player,self.doorGroup,False)) == 1: 
         if self.door.active == False:
             m = MessageScene(self.director, self, 'Warning', 'You shall not pass!', 'Press to continue')
             self.director.setScene(m)
             self.player.rect.y+=25
         if self.door.active == True:
             nextLevel = LevelOneB(self.director, self.player)
             self.director.setScene(nextLevel)    
Exemplo n.º 44
0
 def __init__(self, entity_table):
     self.level = Level("content/level1.dat")
     self.level.load_from_file()
     self.description_manager = DescriptionManager(10)
     self.player = entity_table[0]
     index = 0
     self.enemies = []
     for entity in entity_table:
         if index == 0:
             index += 1
             continue
         self.enemies.append(entity)
         index += 1
Exemplo n.º 45
0
 def update(self, time):
     Level.update(self, time)
     self.time +=time
     if self.activeLG != 0 and self.time > 1000:
         self.change_lasers()
         self.time = 0
     laser = pygame.sprite.spritecollideany(self.player, self.laserGroup, pygame.sprite.collide_mask)
     if laser != None and laser.active:
         self.player.hp = 0                    
     if len(pygame.sprite.spritecollide(self.player,self.invisibleFloorG,True,pygame.sprite.collide_rect)) == 1: 
         print 'Floor'
         self.disconnect_lasers()
         self.page.rect.x = 414
         self.page.rect.y = 414   
Exemplo n.º 46
0
    def __init__(self, director, player):
        Level.__init__(self, director, player)
        self.player.rect.x = 381
        self.player.rect.y = 610
        self.enemyGroup.add([Legionnaire(207, 447, self.player, director),
                             Legionnaire(592, 447, self.player, director),
                             Caesar(399, 336, self.player, director)])

        self.bg = load_image("map_caesar_b_img.png", Constants.MAP_DIR)
        self.collisionBg = load_image(
            "map_caesar_b_bg.png", Constants.BG_MAP_DIR)

        load_music("level_one.it")
        pygame.mixer.music.set_volume(1)
        pygame.mixer.music.play(-1)
Exemplo n.º 47
0
 def __init__(self, player):
     Level.__init__(self, player)
     self.init_enemies()
     self.init_items()
     self.PLAYER_START = [105.2, 40]
     self.player.set_direction("up")
     self.is_beatable = False
     self.init_labels()
     self.time_between_fireballs = 0
     self.checkpoint = 0
     self.has_gotten_checkpoint_1 = False
     self.has_gotten_checkpoint_2 = False
     self.has_gotten_checkpoint_3 = False
     self.fireball_strength = 2
     self.timer = 0
     self.beaten = False
Exemplo n.º 48
0
    def __init__(self, director, player):
        Level.__init__(self, director, player)
        self.player.rect.x = 224
        self.player.rect.y = 1273
        
        self.laser0 = Laser(80, 340, 'laser_45.png')
        self.laser1 = Laser(400, 75, 'laser_45.png')
        self.laser2 = Laser(405, 332, 'laser_180.png')
        self.laser3 = Laser(80, 330, 'laser_180.png')
        self.laser4 = Laser(406, 341, 'laser_125.png')      
        self.laser5 = Laser(80, 80, 'laser_125.png')
        self.laser6 = Laser(400, 350, 'laser_90.png')
        self.laserArray = [self.laser0, self.laser1, self.laser2, self.laser3, self.laser4, self.laser5, self.laser6]
        self.laserGroup = EntityGroup([])
        self.laserGroup.add(self.laser0, self.laser1, self.laser2,self.laser3, self.laser4, self.laser5, self.laser6)
        self.groups.append(self.laserGroup)
        self.laser0.active = False
        self.laser1.active = False
        self.activeLG = 1       #Pair of lasers active at a given time
        self.time = 0
        
        self.page = Page(408, 135, self.player, director)
        self.enemyGroup.add([FutureSoldier(141, 1084, self.player, director),
                             FutureSoldier(316, 1084, self.player, director),
                             FutureSoldier(141, 926, self.player, director),
                             FutureSoldier(316, 926, self.player, director),
                             FutureSoldier(686, 1260, self.player, director),
                             FutureSoldier(508, 988, self.player, director),
                             FutureSoldier(537, 1450, self.player, director),
                             self.page])                             

        self.bg = load_image("map_page_img.png", Constants.MAP_DIR)
        self.collisionBg = load_image("map_page_bg.png", Constants.BG_MAP_DIR)
        
        self.invisibleFloor = InvisibleFloor(384,202,59,78)     #Invisible sprite, it functions as a trigger 
        self.invisibleFloorG = EntityGroup([])
        self.invisibleFloorG.add(self.invisibleFloor)
        self.groups.append(self.invisibleFloorG)
        
        load_music("level_four.s3m")
        pygame.mixer.music.set_volume(0.5)
        pygame.mixer.music.play(-1)

        player.setWeapons([WpnBlade("lightsaber.png", -1, pygame.Rect(128, 77, 42, 42), "sthswng1.wav", 0.2), \
                          WpnLaser()])
Exemplo n.º 49
0
def encryptFile():
    CharIndexMap.rangeTypeisCharacterBased=False
    start_time = time.time()

    baseMachineCfg=EnigmaConfigGenerator(RandomGenerator(123)).createMachineConfig("MCb")
    baseMachine=EnigmaDynamicFactory().createEnigmaMachineFromConfig(baseMachineCfg)
    baseMachine.adjustMachineSettings()

    levelMachine=EnigmaDynamicFactory().createEnigmaMachineFromModel("MCm")
    levelMachine.adjustMachineSettings()
    level=Level(baseMachine.getMachineSettings(),levelMachine.getMachineSettings())

    elapsed_time = time.time() - start_time
    print("2 MAchines were created in :"+str(elapsed_time))

    start_time = time.time()
    msg=FileReader().readSeqFromFile("tst.txt")
    elapsed_time = time.time() - start_time
    print("Parsed File to read Seq in : "+str(elapsed_time))
    level.inputMsg=msg


    start_time = time.time()
    levelEncryptor=LevelEncryptor(baseMachine,levelMachine,level,RandomGenerator(123))
    encLevel=levelEncryptor.encryptLevel()
    elapsed_time = time.time() - start_time
    print("Encrypted Seq in : "+str(elapsed_time))

    FileReader().writeSeqTofile(encLevel.outputMsg,"tst.enc",True)
    print("Encrypted File written")

    encLevel.inputMsg=""

    start_time = time.time()
    levelDecryptor=LevelDecryptor(baseMachine,levelMachine,level)
    levelDecryptor.level=encLevel
    resultLevel=levelDecryptor.decryptLevel()
    elapsed_time = time.time() - start_time
    print("Decrypted Sequence in :"+str(elapsed_time))

    FileReader().writeSeqTofile(resultLevel.inputMsg,"tst.dec",False)
    print("Decrypted File written")

    print("DONE !!")
Exemplo n.º 50
0
    def __init__(self, player):
        Level.__init__(self, player)
        self.init_enemies()
        self.init_items()
        self.PLAYER_START = [104, 78]
        self.is_beatable = False
        self.init_labels()
        self.time_between_fireballs = 0
        self.checkpoint = 0
        self.has_gotten_checkpoint_1 = False
        self.has_gotten_checkpoint_2 = False
        self.has_gotten_checkpoint_3 = False
        self.fireball_strength = 2
        self.timer = 0
        #Counts number of kegs the player has killed
        self.kegs = 0

        self.player.inventory.append("fireball")
        self.has_fireball = True
Exemplo n.º 51
0
    def setUp(self):
        self.level = Level(200, 200)

        self.level.gen_base(60, 60)

        board = self.level.board
        self.player = Player(60, 60, '@', board)
        self.level.board[self.player.y][self.player.x - 1] = ' '
        self.level.board[self.player.y][self.player.x + 1] = ' '
        self.level.board[self.player.y - 1][self.player.x] = ' '
        self.level.board[self.player.y + 1][self.player.x] = ' '
Exemplo n.º 52
0
class LevelTests(unittest.TestCase):
    
    def setUp(self):
        self.width = 150
        self.height = 200
        self.level = Level(self.width, self.height)
    
    def test_width(self):
        assert self.level.width == self.width
            
    def test_height(self):
        assert self.level.height == self.height
        
    def test_genbase_outofbounds(self):
        self.level.gen_base(120, 120)
        assert self.level.board[2][2] == self.level.outofboundschar
        
    #outofbounds is 40 characters, so 41 should always be inbound
    def test_genbase_inbounds(self):
        self.level.gen_base(120, 120)
        assert self.level.board[41][41] == self.level.wallchar
        
    def test_genbase_adds_room(self):
        initial = len(self.level.rooms)
        self.level.gen_base(120, 120)
        aftergen = len(self.level.rooms)
        
        assert initial == 0 and aftergen == 1
Exemplo n.º 53
0
 def __init__(self, camera, luObserver, fxObserver, lvl):
     self.mSwitch = True
     self.mTimer = 0.0
     self.mLevelDone = False
     self.mCamera = camera
     self.mLuObs = luObserver
     self.mFxObs = fxObserver
     self.contactListener = ContactListener()
     self.gravity = Gravity()
     self.physWorld = b2World(gravity=(0,0),doSleep=True, contactListener=self.contactListener)
     self.level = Level(self.physWorld, self.gravity, lvl)
     self.player = Player(self.level.mStartPos, self.physWorld, self.gravity)
     self.mEntityToFollow = self.player
Exemplo n.º 54
0
    def __init__(self, w, h, filename, data_path):
        #If a blank filename is passed, create a new level file 'new_level_1.ini, if the file exists in level_data,
        #increment i until a filename that does not exist in working dir is found
        if os.path.isfile(os.path.join(data_path, 'level_data', filename)):
            print("Existing level found, loading..")
        else:
            if filename is "":
                i = 0
                while True:
                    i += 1
                    filename = 'new_level_' + str(i) + '.ini'
                    if not os.path.isfile(os.path.join(data_path, 'level_data', filename)):
                        break

        Level.__init__(self, w, h, filename, data_path)
        self.selected_obj = None
        self.camera = EditCamera(800, 600, 2000, 800)
        #offsets from selected object's top left corner to mouse at time of selection
        self._sel_m_x = 0
        self._sel_m_y = 0
        self._menu_focus = False
        self.sel_target = SelectionTarget(data_path)

        level_options = GuiLevelOptions(False)
        quit_lvl_gui = GuiQuitLevel(False)
        obj_search_gui = GuiObjSearch(False)
        edit_obj_gui = GuiEditObj(True)

        self.gui_manager.add(QUIT_GAME, quit_lvl_gui)
        self.gui_manager.add(OBJECT_SEARCH, obj_search_gui)
        self.gui_manager.add(LEVEL_OPTIONS, level_options)
        self.gui_manager.add(EDIT_OBJ, edit_obj_gui)
        self.del_bind = pygame.K_d
        self.edit_bind = pygame.K_e
        self.options_bind = pygame.K_F1
        self.spawn_bind = pygame.K_SPACE
        #1 = left mouse button
        self.sel_bind = 1
Exemplo n.º 55
0
    def __init__(self, player):
        """ Create level 1. """

        # Call the parent constructor
        Level.__init__(self, player)

        self.level_limit = -1000

        # Array with type of platform, and x, y location of the platform.
        level = [[210, 30, 450, 570],
                 [210, 30, 850, 420],
                 [210, 30, 1000, 520],
                 [210, 30, 1120, 280],
                 ]


        # Go through the array above and add platforms
        for platform in level:
            block = Platform(platform[0], platform[1])
            block.rect.x = platform[2]
            block.rect.y = platform[3]
            block.player = self.player
            self.platform_list.add(block)
Exemplo n.º 56
0
    def reload(self, score=0, level=1):
        self.__level = level
        self.__Lev = Level()
        self.__Lev.findLadderCoordinates()
        self.__Lev.coinsGen()
        self.__Lev.findCoinCoordinates()
        self.__Lev.paintLadder()
        self.__Lev.levelLoad(self.__level)
        self.__win = False
        self.__Kong = Donkey(self.__Lev)
        self.__play = Player(self.__Lev, score)
        self.__firas = [Fireball(self.__Lev) for i in range(1000)]
        for fira in self.__firas:
            fira.getLevelProperties()

        self.__Kong.getLevelProperties()
        self.__play.getLevelProperties()
        self.__Kong.getDonkeyPosition()
        self.__play.getPlayerPosition()