Beispiel #1
0
 def generate_wave(self):
     self.enemies.append(Enemy(
         self.starting_square["position"],
         self.map_entity.square_size,
         1,
         self.money_per_difficulty * 1,
         self.enemies_path,
     ))
     for i in range(1, self.difficulty + 1):
         for j in range(0, self.enemies_per_difficulty):
             self.to_spawn.append(Enemy(
                 self.starting_square["position"],
                 self.map_entity.square_size,
                 i,
                 self.money_per_difficulty * i,
                 self.enemies_path,
             ))
     return
Beispiel #2
0
    def __init__(self, world, factory, x, y, width, height):
        self.pos = Position(x, y)
        self.width = width
        self.height = height
        self.items = []

        if random.random() < 0.33:
            itemX = random.randint(x, x + width - 1)
            itemY = random.randint(y, y + height - 1)

            self.items.append(
                Item(world, factory, 'sandwich', itemX, itemY, DataTypes.ITEM,
                     'Sandwich'))
        else:
            enemyX = random.randint(x, x + width - 1)
            enemyY = random.randint(y, y + height - 1)

            self.items.append(Enemy(world, factory, enemyX, enemyY))
Beispiel #3
0
    def gameUpdate(self):
        if len(self.enemies.sprites()) == 0:
            self.statistics.plusRound()
            round = self.statistics.getRound()
            self.player.buffDamage()
            for amount in range(round % self.enemies_buffer):
                if (round % 15 == 0):
                    self.enemies_buffer += 5

                dice = random.randrange(0, 4)
                spawn = None
                if (dice == 0):
                    spawn = random.randrange(-100,
                                             1400), random.randrange(-100, 0)
                elif (dice == 1):
                    spawn = random.randrange(-100, 0), random.randrange(0, 800)
                elif (dice == 2):
                    spawn = random.randrange(0,
                                             1400), random.randrange(800, 900)
                else:
                    spawn = random.randrange(1400,
                                             1500), random.randrange(0, 800)
                self.enemies.add(Enemy(self.size, self.knifeAnimation, spawn))
Beispiel #4
0
    def level_advance(self):

        self.levelUP()
        self.player.lives = 3
        if (self.numberOfPlayer == 2):
            self.player2.lives = 3
            self.player.show()
            self.player2.show()
            self.playerOneCanShoot = True
            self.playerTwoCanShoot = True
            self.flag_playerOneDead = False
            self.flag_playerTwoDead = False

        self.update_GUI_lives(self.numberOfPlayer)

        # Postavljanje neprijatelja
        self.enemies = []
        self.enemies.append(Enemy())
        self.enemies[0].setPos(100, 50)

        for i in range(0, 55):
            self.enemies.append(Enemy())
            if i == 11:
                self.enemies[i].setPos(self.enemies[0].x(),
                                       self.enemies[0].y() + 60)
                continue
            if i == 22:
                self.enemies[i].setPos(self.enemies[11].x(),
                                       self.enemies[11].y() + 60)
                continue
            if i == 33:
                self.enemies[i].setPos(self.enemies[22].x(),
                                       self.enemies[22].y() + 60)
                continue
            if i == 44:
                self.enemies[i].setPos(self.enemies[33].x(),
                                       self.enemies[33].y() + 60)
                continue
            self.enemies[i].setPos(self.enemies[i - 1].x() + 60,
                                   self.enemies[i - 1].y())

        for i in range(0, 55):
            self.addItem(self.enemies[i])

        self.moveEnemy = MoveEnemy()
        self.moveEnemy.calc_done.connect(self.move_enemy)
        self.moveEnemy.start()

        self.enemyShoot = EnemyShoot()
        self.enemyShoot.can_shoot.connect(self.enemy_shoot_laser)
        self.enemyShoot.move_down.connect(self.move_enemy_laser)
        self.enemyShoot.collision_detected.connect(self.enemy_hit_player)
        self.enemyShoot.collision_detected_with_shield.connect(
            self.enemy_laser_shield_collide)
        # Ubrzavanje lasera igraca i enemya
        self.enemyShoot.enemyLaserSpeed += self.level_numberrr
        self.moveEnemy.enemyMoveSpeed += self.level_numberrr

        #print('Enemy move speed: {}'.format(self.moveEnemy.enemyMoveSpeed))
        #print('Enemy laser speed: {}'.format(self.enemyShoot.enemyLaserSpeed))

        if self.numberOfPlayer == 1:
            self.enemyShoot.add_player(self.player)
        else:
            # PROVERA AKO JE MRTAV NE IGRA VISE / A USTVARI IGRA PROCITANO IZ PROJEKTA, NEMA VEZE
            if self.player != None:
                self.enemyShoot.add_player(self.player)
            if self.player2 != None:
                self.enemyShoot.add_player(self.player2)
        self.enemyShoot.start()

        self.shootLaser = PlayerShoot()
        self.shootLaser.calc_done.connect(self.move_laser_up)
        self.shootLaser.collision_detected.connect(
            self.player_laser_enemy_collide)
        self.shootLaser.start()

        for i in range(0, 55):
            self.moveEnemy.add_enemy(self.enemies[i])
            self.shootLaser.add_enemy(self.enemies[i])
            self.enemyShoot.add_enemy(self.enemies[i])

        #Dodavanje stitova
        self.shields = []
        self.shields.append(Shield())
        self.shields[0].setPos(50, 350)
        self.shields.append(Shield())
        self.shields[1].setPos(375, 350)
        self.shields.append(Shield())
        self.shields[2].setPos(700, 350)

        for i in range(0, 3):
            self.addItem(self.shields[i])
            self.enemyShoot.add_shield(self.shields[i])
Beispiel #5
0
    def __init__(self, singlemulti, level_number, parent=None):
        QGraphicsScene.__init__(self, parent)

        self.key_notifier = KeyNotifier()
        self.key_notifier.key_signal.connect(self.do_key_press)
        self.key_notifier.start()

        self.numberOfPlayer = singlemulti
        self.level_numberrr = level_number

        # Postavljanje pozadine
        self.set_background()

        #Postavljanje Glavnog igraca
        if (self.numberOfPlayer == 1):
            self.player = Player()
            self.player.setPos(400, 525)
            self.addItem(self.player)
            self.flag_playerOneDead = False

        elif (self.numberOfPlayer == 2):
            self.player = Player()
            self.player.setPos(400, 525)
            self.addItem(self.player)
            self.flag_playerOneDead = False

            self.player2 = Player2()
            self.player2.setPos(100, 525)
            self.addItem(self.player2)
            self.flag_playerTwoDead = False

        # Postavljanje neprijatelja
        self.enemies = []
        self.enemies.append(Enemy())
        self.enemies[0].setPos(100, 50)

        for i in range(0, 55):
            self.enemies.append(Enemy())
            if i == 11:
                self.enemies[i].setPos(self.enemies[0].x(),
                                       self.enemies[0].y() + 60)
                continue
            if i == 22:
                self.enemies[i].setPos(self.enemies[11].x(),
                                       self.enemies[11].y() + 60)
                continue
            if i == 33:
                self.enemies[i].setPos(self.enemies[22].x(),
                                       self.enemies[22].y() + 60)
                continue
            if i == 44:
                self.enemies[i].setPos(self.enemies[33].x(),
                                       self.enemies[33].y() + 60)
                continue
            self.enemies[i].setPos(self.enemies[i - 1].x() + 60,
                                   self.enemies[i - 1].y())

        for i in range(0, 55):
            self.addItem(self.enemies[i])

        # Pomeranje neprijatelja
        self.moveEnemy = MoveEnemy()
        self.moveEnemy.calc_done.connect(self.move_enemy)
        self.moveEnemy.start()

        # Pucanje igraca
        self.shootLaser = PlayerShoot()
        self.shootLaser.calc_done.connect(self.move_laser_up)
        self.shootLaser.collision_detected.connect(
            self.player_laser_enemy_collide)
        self.shootLaser.start()
        self.playerOneCanShoot = True
        self.playerTwoCanShoot = True

        # Pucanje protivnika
        self.enemyShoot = EnemyShoot()
        self.enemyShoot.can_shoot.connect(self.enemy_shoot_laser)
        self.enemyShoot.move_down.connect(self.move_enemy_laser)
        self.enemyShoot.collision_detected.connect(self.enemy_hit_player)
        self.enemyShoot.collision_detected_with_shield.connect(
            self.enemy_laser_shield_collide)
        #self.enemyShoot.next_level.connect(self.next_level)
        if self.numberOfPlayer == 1:
            self.enemyShoot.add_player(self.player)
        else:
            self.enemyShoot.add_player(self.player)
            self.enemyShoot.add_player(self.player2)
        self.enemyShoot.start()

        for i in range(0, 55):
            self.moveEnemy.add_enemy(self.enemies[i])
            self.shootLaser.add_enemy(self.enemies[i])
            self.enemyShoot.add_enemy(self.enemies[i])

        #Dodavanje stitova
        self.shields = []
        self.shields.append(Shield())
        self.shields[0].setPos(50, 350)
        self.shields.append(Shield())
        self.shields[1].setPos(375, 350)
        self.shields.append(Shield())
        self.shields[2].setPos(700, 350)

        for i in range(0, 3):
            self.addItem(self.shields[i])
            self.enemyShoot.add_shield(self.shields[i])

        self.view = QGraphicsView(self)
        self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        self.view.show()
        self.view.setFixedSize(WINDOW_WIDTH, WINDOW_HEIGHT)
        self.setSceneRect(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT)

        self.initUI(self.numberOfPlayer, self.level_numberrr)
Beispiel #6
0
 def set_enemies(self):
     for i in range(self.ENEMIES):
         enemy = Enemy(self.block_positions)
         self.gr_enemies.add(enemy)
Beispiel #7
0
def main():
    sdl2.ext.init()

    # Create the window
    window = sdl2.ext.Window("Foo", size=(960, 640))
    window.show()

    # Create the spirte factory and the sprite for the player
    factory         = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE)

    # Create the worl and spriterenderer system
    world           = sdl2.ext.World()
    spriterenderer  = SoftwareRenderer(window)
    movement        = MovementSystem(0, 0, 960, 640)
    playerMovement  = PlayerMovementSystem()
    collision       = CollisionSystem()
    battleSystem = BattleSystem()

    # Add all systems to the world
    world.add_system(playerMovement)
    world.add_system(collision)
    world.add_system(movement)
    world.add_system(spriterenderer)
    world.add_system(battleSystem)

    # Test map generation
    grid = mapGen.buildMap(world, factory, 4)
    grid.build(world, factory)

    enemyTile = random.choice(grid.tiles)
    enemy = Enemy(world, factory, enemyTile.position.x, enemyTile.position.y)

    # Pick random location for player
    playerTile = random.choice(grid.tiles)
    player = Player(world, factory, playerTile.position.x, playerTile.position.y)
    player_speed = 1

    battleSystem.player = player

    playerMovement.player = player
    playerMovement.grid = grid

    gridSystem = GridSystem(960, 640, player)
    world.add_system(gridSystem)

    # Colliders for said items
    collision.player = player
    collision.grid   = grid

    # Main event loop
    running = True
    key_down = False
    while(running):

        events = sdl2.ext.get_events()

        for event in events:

            # Hittin' dat X button doe
            if event.type == sdl2.SDL_QUIT:
                running = False
                break

            if event.type == sdl2.SDL_KEYUP:
                key_down = False

            # Movement
            if event.type == sdl2.SDL_KEYDOWN:
                d = None

                if(not key_down):
                    if event.key.keysym.sym == sdl2.SDLK_UP:
                        d = Direction.NORTH
                        key_down = True

                    elif event.key.keysym.sym == sdl2.SDLK_e:
                        print("I'm attacking with", player.get_damage(), "!")
                        key_down = True

                    elif event.key.keysym.sym == sdl2.SDLK_f:
                        print("Consuming")
                        player.consume()
                        print("Player health now at,", player.playerdata.health)

                    elif event.key.keysym.sym == sdl2.SDLK_DOWN:
                        d = Direction.SOUTH
                        key_down = True

                    elif event.key.keysym.sym == sdl2.SDLK_LEFT:
                        d = Direction.EAST
                        key_down = True

                    elif event.key.keysym.sym == sdl2.SDLK_RIGHT:
                        d = Direction.WEST
                        key_down = True

                    if d != None:
                        collision.player_dir = d
                        enemy.random_move(grid)
                        playerMovement.walk(d)

        sdl2.SDL_Delay(10)
        world.process()

    return 0