Beispiel #1
0
    def generate(self, space_game, ship):
        x, y = random_edge_position()
        vx, vy = normalize_vector(ship.x - x, ship.y - y)

        vx *= ENEMY_BASE_SPEED
        vy *= ENEMY_BASE_SPEED

        enemy = Enemy(space_game, x, y, vx, vy)
        return [enemy]
Beispiel #2
0
    def create_enemy_from_edges(self):
        x, y = random_edge_position()
        vx, vy = normalize_vector(self.ship.x - x, self.ship.y - y)

        vx *= ENEMY_BASE_SPEED
        vy *= ENEMY_BASE_SPEED

        enemy = Enemy(self, x, y, vx, vy)
        return [enemy]
Beispiel #3
0
    def generate(self, space_game,
                 ship):  # TODO: extracted from method create_enemy_from_edge
        x, y = random_edge_position()
        vx, vy = normalize_vector(ship.x - x, ship.y - y)

        vx *= ENEMY_BASE_SPEED
        vy *= ENEMY_BASE_SPEED

        enemy = Enemy(space_game, x, y, vx, vy)
        return [enemy]
Beispiel #4
0
    def generate(self, space_game, ship):
        self.x, self.y = random_edge_position()
        self.vx, self.vy = normalize_vector(self.ship.x - self.x,
                                            self.ship.y - self.y)

        self.vx *= ENEMY_BASE_SPEED
        self.vy *= ENEMY_BASE_SPEED

        self.enemy = Enemy(self, self.x, self.y, self.vx, self.vy)
        return [self.enemy]
Beispiel #5
0
    def generate(self, space_game, ship):
        enemies = []
        x = randint(100, CANVAS_WIDTH - 100)
        y = randint(100, CANVAS_HEIGHT - 100)

        while vector_len(x - ship.x, y - ship.y) < 200:
            x = randint(100, CANVAS_WIDTH - 100)
            y = randint(100, CANVAS_HEIGHT - 100)

        for d in range(18):
            dx, dy = direction_to_dxdy(d * 20)
            enemy = Enemy(space_game, x, y, dx * ENEMY_BASE_SPEED, dy * ENEMY_BASE_SPEED)
            enemies.append(enemy)
        return enemies
Beispiel #6
0
    def create_enemy_star(self):
        enemies = []

        x = randint(100, CANVAS_WIDTH - 100)
        y = randint(100, CANVAS_HEIGHT - 100)

        while vector_len(x - self.ship.x, y - self.ship.y) < 200:
            x = randint(100, CANVAS_WIDTH - 100)
            y = randint(100, CANVAS_HEIGHT - 100)

        for d in range(18):
            dx, dy = direction_to_dxdy(d * 20)
            enemy = Enemy(self, x, y, dx * ENEMY_BASE_SPEED, dy * ENEMY_BASE_SPEED)
            enemies.append(enemy)

        return enemies
Beispiel #7
0
    def generate(self, space_game, ship):
        self.enemies = []

        self.x = randint(100, CANVAS_WIDTH - 100)
        self.y = randint(100, CANVAS_HEIGHT - 100)

        while vector_len(self.x - self.ship.x, self.y - self.ship.y) < 200:
            self.x = randint(100, CANVAS_WIDTH - 100)
            self.y = randint(100, CANVAS_HEIGHT - 100)

        for d in range(18):
            self.dx, self.dy = direction_to_dxdy(d * 20)
            self.enemy = Enemy(self, self.x, self.y,
                               self.dx * ENEMY_BASE_SPEED,
                               self.dy * ENEMY_BASE_SPEED)
            self.enemies.append(self.enemy)

        return self.enemies
Beispiel #8
0
    def generate(self, space_game, ship):
        ## ##
        # TODO: extracted from method create_enemy_star
        self.ship = ship
        enemies = []

        x = randint(100, CANVAS_WIDTH - 100)
        y = randint(100, CANVAS_HEIGHT - 100)

        while vector_len(x - self.ship.x, y - self.ship.y) < 200:
            x = randint(100, CANVAS_WIDTH - 100)
            y = randint(100, CANVAS_HEIGHT - 100)

        for d in range(18):
            dx, dy = direction_to_dxdy(d * 20)
            enemy = Enemy(self.ship, x, y, dx * ENEMY_BASE_SPEED, dy * ENEMY_BASE_SPEED)
            enemies.append(enemy)

        return enemies
Beispiel #9
0
    def init_objects(self):
        self.steps = 0
        for enemy in self.enemies:
            self.enemies.remove(enemy)

        for food in self.foods:
            self.foods.remove(food)

        for i in range(self.nFoods):
            while True:
                flag = False
                size = int(self.width * Food.sizeF)
                x = random.uniform(
                    int(size / 2.0) + 1, self.width - int(size / 2.0) + 1)
                y = random.uniform(
                    int(size / 2.0) + 1, self.width - int(size / 2.0) + 1)
                for n in self.foods:
                    if abs(x - n.posX) < size + 1 and abs(y -
                                                          n.posY) < size + 1:
                        flag = True
                if not flag:
                    break

            self.foods.extend([Food(x, y, self.width)])

        for j in range(self.nEnemies):
            while True:
                flag = False
                size = int(self.width * Enemy.sizeF)
                x = random.uniform(
                    int(size / 2.0) + 1, self.width - int(size / 2.0) + 1)
                y = random.uniform(
                    int(size / 2.0) + 1, self.width - int(size / 2.0) + 1)

                for n in self.enemies:
                    if abs(x - n.posX) < size + 1 and abs(y -
                                                          n.posY) < size + 1:
                        flag = True
                for n in self.foods:
                    if abs(x - n.posX) < size + 1 and abs(y -
                                                          n.posY) < size + 1:
                        flag = True
                if not flag:
                    break

            self.enemies.extend([Enemy(x, y, self.width)])

        while True:
            flag = False
            # size = random.randint(0, 0.1)
            size = int(self.width * Player.sizeF)
            x = random.uniform(
                int(size / 2.0) + 1, self.width - int(size / 2.0) + 1)
            y = random.uniform(
                int(size / 2.0) + 1, self.width - int(size / 2.0) + 1)
            for n in self.foods:
                if abs(x - n.posX) < size + 1 and abs(y - n.posY) < size + 1:
                    flag = True
            for n in self.enemies:
                if abs(x - n.posX) < size + 1 and abs(y - n.posY) < size + 1:
                    flag = True
            if not flag:
                break

        self.player = Player(x, y, self.width)