(Pawn) MoveNPC

/*
 *
 * @MOVE NPC
 * @Extract com INPC.inc
 * @Author: Bruno da Silva
 * @Url: ipsbr.net
 *
*/

stock MoveNPC(npc, Float:toX, Float:toY, Float:toZ, Float: speed) {

        toZ += Z_CORRECTION;

        if(speed < 0.0005) {
                #if defined DEBUG
                printf("Erro: NPC %d está muito lento (vel %f)", npc,speed);
                #endif
                return false;
        }

        static Float: pos[4];


        if(!GetPlayerPos(npc, pos[0] , pos[1] , pos[2])) return false;

        static Float: vel[2], Float: distancia;

        pos[3] = atan2( toY - pos[1], toX - pos[0] );

        vel[0]= (speed * floatcos(pos[3], degrees));
        vel[1]= (speed * floatsin(pos[3], degrees));

        distancia = floatsqroot( (toX - pos[0]) * ( toX - pos[0] ) + ( toY - pos[1] ) * ( toY - pos[1] ) + ( toZ - pos[2] ) * ( toZ - pos[2] ) );

        if(distancia < 1.0) {
                #if defined DEBUG
                printf("Erro: O NPC está muito próximo do destino (%f metros)", npc, distancia);
                #endif
                return false;
        }

        static tempo, blocos;

        tempo = floatround( distancia / speed );

        if(!tempo) {
                #if defined DEBUG
                printf("Erro: NPC %d está demorando muito pouco tempo para chegar no destino (tempo %d)", npc,tempo);
                #endif
                return false;
        }


        blocos= tempo / FOOT_RATE;

        if(!blocos) {
                #if defined DEBUG
                printf("Erro: NPC %d não tem nenhum caminho para ser calculado (%d blocos)", npc,blocos);
                #endif
                return false;
        }



        static Float: parteX, Float: parteY, Float: parteZ, Float: w;

        tempo = tempo / blocos;

        parteX = pos[0];
        parteX = pos[1];
        parteZ = pos[2];

        Euler2Quat( 90 - pos[3]  , w, parteX, parteY, parteZ);

        SetNPCAngle(npc, w, parteX, parteY, parteZ);

        parteX = (toX-pos[0])/blocos;
        parteY = (toY-pos[1])/blocos;
        parteZ = (toZ-pos[2])/blocos;


        SetNPCVelocity(npc, vel[0], vel[1], 0.0);

        SetNPCUpDownKey(npc, KEYUP);

        CreateBuild(npc, pos[0], pos[1], pos[2]);

        static i ;

        for(  i = 0;  i != blocos; ++ i) {
                SetNPCPos(npc, pos[0] + (i * parteX), pos[1] + (i * parteY), (pos[2] + (i * parteZ)));
                SetNPCTime(npc, FOOT_RATE * i);
                SaveBuild(npc);

        }

        SetNPCUpDownKey(npc, 0);
        SetNPCTime(npc, FOOT_RATE * (blocos + 1));
        SetNPCVelocity(npc, 0.0, 0.0, 0.0);
        SaveBuild(npc);

        FinishBuild(npc);

        PlayBuild(npc);

        return true;
}


stock Euler2Quat(Float: angle, &Float:w, &Float:x, &Float:y, &Float:z) {

        static
        Float:s
        ;

        s = (angle *(3.14/180)) / 2;

        z = floatsin(s);

        x *= z;
        y *= z;


        w = floatcos(s);

        return true;
}