import { system, Player } from '@minecraft/server';

////Player/////

system.afterEvents.scriptEventReceive.subscribe(({ sourceEntity: player, id }) => {
    if (id !== 'script:swing') return;

    // Verificar se o sourceEntity é um jogador
    if (!(player instanceof Player)) return;

    // Obter a direção de visão do jogador
    const { x, y, z } = player.getViewDirection();

    // Normalizar o vetor horizontal (x, z) para garantir direção consistente
    const horizontalMagnitude = Math.sqrt(x * x + z * z);
    const normalizedX = x / horizontalMagnitude;
    const normalizedZ = z / horizontalMagnitude;

    // Ajustar a força para alcançar 10 blocos
    const horizontalForce = 1.2; // Valor ajustado para 10 blocos
    const verticalForce = 0.1; // Ajuste para simular um leve salto (opcional)

    // Aplicar o knockback ao jogador
    player.applyKnockback({ x: normalizedX * horizontalForce, z: normalizedZ * horizontalForce }, verticalForce);;
});

system.afterEvents.scriptEventReceive.subscribe(({ sourceEntity: player, id }) => {
    if (id !== 'script:swing2') return;

    // Verificar se o sourceEntity é um jogador
    if (!(player instanceof Player)) return;

    // Obter a direção de visão do jogador
    const { x, y, z } = player.getViewDirection();

    // Normalizar o vetor horizontal (x, z) para garantir direção consistente
    const horizontalMagnitude = Math.sqrt(x * x + z * z);
    const normalizedX = x / horizontalMagnitude;
    const normalizedZ = z / horizontalMagnitude;

    // Ajustar a força para alcançar 10 blocos
    const horizontalForce = 1.5; // Valor ajustado para 5 blocos
    const verticalForce = 0.1; // Ajuste para simular um leve salto (opcional)

    // Aplicar o knockback ao jogador
    player.applyKnockback({ x: normalizedX * horizontalForce, z: normalizedZ * horizontalForce }, verticalForce);;
});

system.afterEvents.scriptEventReceive.subscribe(({ sourceEntity: player, id }) => {
    if (id !== 'script:swing3') return;

    // Verificar se o sourceEntity é um jogador
    if (!(player instanceof Player)) return;

    // Obter a direção de visão do jogador
    const { x, y, z } = player.getViewDirection();

    // Normalizar o vetor horizontal (x, z) para garantir direção consistente
    const horizontalMagnitude = Math.sqrt(x * x + z * z);
    const normalizedX = x / horizontalMagnitude;
    const normalizedZ = z / horizontalMagnitude;

    // Ajustar a força para alcançar 10 blocos
    const horizontalForce = 2.0; // Valor ajustado para 7 blocos
    const verticalForce = 0.1; // Ajuste para simular um leve salto (opcional)

    // Aplicar o knockback ao jogador
    player.applyKnockback({ x: normalizedX * horizontalForce, z: normalizedZ * horizontalForce }, verticalForce);;
});

system.afterEvents.scriptEventReceive.subscribe(({ sourceEntity: player, id }) => {
    if (id !== 'script:pulo_frente_ninja') return;

    // Verificar se o sourceEntity é um jogador
    if (!(player instanceof Player)) return;

    // Obter a direção de visão do jogador
    const { x, y, z } = player.getViewDirection();

    // Normalizar o vetor horizontal (x, z) para garantir direção consistente
    const horizontalMagnitude = Math.sqrt(x * x + z * z);
    const normalizedX = x / horizontalMagnitude;
    const normalizedZ = z / horizontalMagnitude;

    // Ajustar a força para alcançar 10 blocos
    const horizontalForce = 2.0; // Valor ajustado para 7 blocos
    const verticalForce = 0.7; // Ajuste para simular um leve salto (opcional)

    // Aplicar o knockback ao jogador
    player.applyKnockback({ x: normalizedX * horizontalForce, z: normalizedZ * horizontalForce }, verticalForce);;
});

system.afterEvents.scriptEventReceive.subscribe(({ sourceEntity: player, id }) => {
    if (id !== 'script:pulo_tras_ninja') return;

    // Verificar se o sourceEntity é um jogador
    if (!(player instanceof Player)) return;

    // Obter a direção de visão do jogador
    const { x, y, z } = player.getViewDirection();

    // Normalizar o vetor horizontal (x, z) para garantir direção consistente
    const horizontalMagnitude = Math.sqrt(x * x + z * z);
    const normalizedX = x / horizontalMagnitude;
    const normalizedZ = z / horizontalMagnitude;

    // Ajustar a força para alcançar 10 blocos
    const horizontalForce = -2.0; // Valor ajustado para 7 blocos
    const verticalForce = 1.2; // Ajuste para simular um leve salto (opcional)

    // Aplicar o knockback ao jogador
    player.applyKnockback({ x: normalizedX * horizontalForce, z: normalizedZ * horizontalForce }, verticalForce);;
});

system.afterEvents.scriptEventReceive.subscribe(({ sourceEntity: player, id }) => {
    if (id !== 'script:corte_ninja') return;

    // Verificar se o sourceEntity é um jogador
    if (!(player instanceof Player)) return;

    // Obter a direção de visão do jogador
    const { x, y, z } = player.getViewDirection();

    // Normalizar o vetor horizontal (x, z) para garantir direção consistente
    const horizontalMagnitude = Math.sqrt(x * x + z * z);
    const normalizedX = x / horizontalMagnitude;
    const normalizedZ = z / horizontalMagnitude;

    // Ajustar a força para alcançar 10 blocos
    const horizontalForce = 25.0; // Valor ajustado para 7 blocos
    const verticalForce = 0.1; // Ajuste para simular um leve salto (opcional)

    // Aplicar o knockback ao jogador
    player.applyKnockback({ x: normalizedX * horizontalForce, z: normalizedZ * horizontalForce }, verticalForce);;
});


system.afterEvents.scriptEventReceive.subscribe(({ sourceEntity: player, id }) => {
    if (id !== 'script:escudo_ladino') return;

    // Verificar se o sourceEntity é um jogador
    if (!(player instanceof Player)) return;

    // Obter a direção de visão do jogador
    const { x, y, z } = player.getViewDirection();

    // Normalizar o vetor horizontal (x, z) para garantir direção consistente
    const horizontalMagnitude = Math.sqrt(x * x + z * z);
    const normalizedX = x / horizontalMagnitude;
    const normalizedZ = z / horizontalMagnitude;

    // Ajustar a força para alcançar 10 blocos
    const horizontalForce = 1.0; // Valor ajustado para 7 blocos
    const verticalForce = 0.1; // Ajuste para simular um leve salto (opcional)

    // Aplicar o knockback ao jogador
    player.applyKnockback({ x: normalizedX * horizontalForce, z: normalizedZ * horizontalForce }, verticalForce);;
});




system.afterEvents.scriptEventReceive.subscribe(({ sourceEntity: player, id }) => {
    if (id !== 'script:pulo_frente_guerreiro') return;

    // Verificar se o sourceEntity é um jogador
    if (!(player instanceof Player)) return;

    // Obter a direção de visão do jogador
    const { x, y, z } = player.getViewDirection();

    // Normalizar o vetor horizontal (x, z) para garantir direção consistente
    const horizontalMagnitude = Math.sqrt(x * x + z * z);
    const normalizedX = x / horizontalMagnitude;
    const normalizedZ = z / horizontalMagnitude;

    // Ajustar a força para alcançar 10 blocos
    const horizontalForce = 0.5; // Valor ajustado para 7 blocos
    const verticalForce = 0.4; // Ajuste para simular um leve salto (opcional)

    // Aplicar o knockback ao jogador
    player.applyKnockback({ x: normalizedX * horizontalForce, z: normalizedZ * horizontalForce }, verticalForce);;
});


system.afterEvents.scriptEventReceive.subscribe(({ sourceEntity: player, id }) => {
    if (id !== 'script:impulso_sombrio') return;
    if (!(player instanceof Player)) return;

    const durationTicks = 20 * 6; // 6 segundos
    let ticksElapsed = 0;

    const intervalId = system.runInterval(() => {
        if (!player || !player.typeId) {
            system.clearRun(intervalId); // <-- CORRETO AQUI
            return;
        }

        const view = player.getViewDirection?.();
        if (!view) return;

        const { x, z } = view;
        const horizontalMagnitude = Math.sqrt(x * x + z * z) || 1;
        const normalizedX = x / horizontalMagnitude;
        const normalizedZ = z / horizontalMagnitude;

        const horizontalForce = 2.0;
        const verticalForce = 0.1;

        player.applyKnockback(
            { x: normalizedX * horizontalForce, z: normalizedZ * horizontalForce },
            verticalForce
        );

        ticksElapsed++;
        if (ticksElapsed >= durationTicks) {
            system.clearRun(intervalId); // <-- CORRETO AQUI TAMBÉM
        }
    }, 1); // a cada tick (~1/20s)
});










