(C++) INPC

/*

    Copyright (c) 2013 ipsBruno



*/
#include "../incs/sdk/amx/amx.h"
#include "../incs/sdk/plugincommon.h"

#include <windows.h>

#include <tchar.h>
#include <strsafe.h>

#include <string>
#include <vector>

#include <cstdlib>
#include <ctime>

#pragma warning( disable : 4996 )


using namespace std;

#define alloca _alloca

typedef void (*logprintf_t)(char* format, ...);
logprintf_t logprintf;

AMX * pAMX;

extern void *pAMXFunctions;

#define PI 3.14159265
#define pow2(a)                                            ((a) * (a))
#define distance(aa,ab,ac,ba,bb,bc)                        sqrt(pow2(aa - ba) + pow2(ab - bb) + pow2(ac - bc))

bool JogadorProcessado [ 1000 ] ;

float FOOT_RATE = 130.0f;


void EscreverRota(char * c, int tempo, short leftright, short updown, short addkey, float x, float y, float z, float wq, float zq, int vida, int colete, int armaid, int acao, float velocidadex, float velocidadey, float velocidadez, float surfx, float surfy, float surfz, short surfid, short animeid, short animeidx) {


    c[0] = (tempo & 0x000000FF);
    c[1] = (tempo & 0x0000FF00) >> 8;
    c[2] = (tempo & 0x00FF0000) >> 16;
    c[3] = (tempo & 0xFF000000) >> 24;
    c[4] = (leftright & 0x00FF);
    c[5] = (leftright & 0xFF00) >> 8;
    c[6] = (updown & 0x00FF);
    c[7] = (updown & 0xFF00) >> 8;
    c[8] = (addkey & 0x00FF);
    c[9] = (addkey & 0xFF00) >> 8;

    char * fstrx = (char*) &x;
    c[10] = fstrx[0];
    c[11] = fstrx[1];
    c[12] = fstrx[2];
    c[13] = fstrx[3];

    char * fstry = (char*) &y;
    c[14] = fstry[0];
    c[15] = fstry[1];
    c[16] = fstry[2];
    c[17] = fstry[3];


    char * fstrz = (char*) &z;
    c[18] = fstrz[0];
    c[19] = fstrz[1];
    c[20] = fstrz[2];
    c[21] = fstrz[3];

    char * fstrw = (char*) &wq;
    c[22] = fstrw[0];
    c[23] = fstrw[1];
    c[24] = fstrw[2];
    c[25] = fstrw[3];


    float null = 0.0;
    char * fstrn = (char*) &null;

    c[26] = fstrn[0];
    c[27] = fstrn[1];
    c[28] = fstrn[2];
    c[29] = fstrn[3];
    c[30] = fstrn[0];
    c[31] = fstrn[1];
    c[32] = fstrn[2];
    c[33] = fstrn[3];

    char * fstrzq = (char*) &zq;

    c[34] = fstrzq[0];
    c[35] = fstrzq[1];
    c[36] = fstrzq[2];
    c[37] = fstrzq[3];
    c[38] = vida;
    c[39] = colete;
    c[40] = armaid;
    c[41] = acao;


    char * fstrvx = (char*) &velocidadex;
    c[42] = fstrvx[0];
    c[43] = fstrvx[1];
    c[44] = fstrvx[2];
    c[45] = fstrvx[3];


    char * fstrvy = (char*) &velocidadey;
    c[46] = fstrvy[0];
    c[47] = fstrvy[1];
    c[48] = fstrvy[2];
    c[49] = fstrvy[3];

    char * fstrvz = (char*) &velocidadez;
    c[50] = fstrvz[0];
    c[51] = fstrvz[1];
    c[52] = fstrvz[2];
    c[53] = fstrvz[3];


    for(int i = 54; i <68; i++) c[i] = 0;

    c[68] = (animeid & 0x00FF);
    c[69] = (animeid & 0xFF00) >> 8;
    c[70] = (animeidx & 0x00FF);
    c[71] = (animeidx & 0xFF00) >> 8;



}

struct THREAD_PARAMS
{
    int id;
    float infos_0;
    float infos_1;
    float infos_2;
    float infos_3;
    float infos_4;
    float infos_5;
    float infos_6;
    float infos_7;

};


DWORD WINAPI  ProcessarRota(LPVOID lpStatus)
{
    THREAD_PARAMS* args = reinterpret_cast<THREAD_PARAMS*>(lpStatus);

    float origemX       = args->infos_3;
    float origemY       = args->infos_4;
    float origemZ       = args->infos_5;

    float objetivoX     = args->infos_0;
    float objetivoY     = args->infos_1;
    float objetivoZ     = args->infos_2;
    float velocidade    = args->infos_6;

    int slot = args->id;

    printf("PROCESSANDO ROTA %d\n",slot );



    float distancia = distance(origemX, origemY, origemZ, objetivoX, objetivoY, objetivoZ);

    float angulo =   (atan2(objetivoY - origemY,  objetivoX - origemX));


    float tempo = distancia / velocidade ;

    float blocos =   tempo / FOOT_RATE  ;

    float velocidadeX =  cos(angulo) * velocidade;
    float velocidadeY =  sin(angulo) * velocidade;

    float velocidadeZ =  0.0;

    angulo = (-angulo) / 0.01745329251f + 90.0f;

    float passosX  = (objetivoX - origemX) /  blocos;
    float passosY  = (objetivoY - origemY) /  blocos;

    float passosZ  = (objetivoZ - origemZ) /  blocos;


    angulo = angulo / 114.591559157f;

    float x = 0.0f, y = 0.0f;
    float wq = cos(angulo);
    float zq = sin(angulo);

    char header[8] = {
        (char)
        0xE8 ,
        0x03 ,
        0x00 ,
        0x00 ,
        0x01 ,
        0x00 ,
        0x00 ,
        0x00
    } ;

    FILE * npcFile = fopen("npcmodes/recordings/npc.rec", "wb");


    fwrite(header, 1, 8, npcFile);

    float passoAtual = 0.0f ;

    tempo = tempo / blocos;

    int correr = velocidade > 0.0020f ? 0x00FF : 0xFFFF;


    while(blocos) {

        char script[73];

        float x = origemX + (passosX * passoAtual);
        float y = origemY + (passosY * passoAtual);
        float z = origemZ + (passosZ * passoAtual);

        int vida = 100;
        int colete = 0;
        int arma = 0;
        int acao = 0;



        EscreverRota(script, (short)floor((tempo * passoAtual)+0.5f), 0,  correr, 0, x, y, z, wq, zq, vida, colete, arma, acao, velocidadeX, velocidadeY, velocidadeZ,  0.0, 0.0,0.0, 0, 0, 0);

        passoAtual += 1.0f;

        fwrite(script, 1, 72, npcFile);


        if(passoAtual > blocos - 2) break;

    }

    fclose(npcFile);

    JogadorProcessado[slot] = true;

    return true;
}

/*
*
* MoverNPC( Float: x, Float: y, Float: z, npcid )
*
*/



AMX* amxGlobal ;
cell AMX_NATIVE_CALL MoverNPC(AMX* amx, cell* params)
{

    amxGlobal = amx;

    int slot = (int)params[4];

    float objetivoX = amx_ctof(params[1]);
    float objetivoY = amx_ctof(params[2]);
    float objetivoZ = amx_ctof(params[3]);

    float origemX = amx_ctof(params[5]);
    float origemY = amx_ctof(params[6]);
    float origemZ = amx_ctof(params[7]);

    float velocidade = amx_ctof(params[8]);

    THREAD_PARAMS * passArgs = new THREAD_PARAMS();

    passArgs->id = slot;

    passArgs->infos_0 = objetivoX;
    passArgs->infos_1 = objetivoY;
    passArgs->infos_2 = objetivoZ;

    passArgs->infos_3 = origemX;
    passArgs->infos_4 = origemY;
    passArgs->infos_5 = origemZ;
    passArgs->infos_6 = velocidade;

    CreateThread(0, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(ProcessarRota), passArgs, 0, NULL);


    return true;
}



AMX_NATIVE_INFO natives[ ] =
{
    {"MoverINPC", MoverNPC},
    {0,0}
};

PLUGIN_EXPORT unsigned int PLUGIN_CALL Supports()
{
    return SUPPORTS_VERSION | SUPPORTS_AMX_NATIVES | SUPPORTS_PROCESS_TICK;
}


PLUGIN_EXPORT bool PLUGIN_CALL Load( void **ppData )
{
    pAMXFunctions = ppData[PLUGIN_DATA_AMX_EXPORTS];
    logprintf = (logprintf_t) ppData[PLUGIN_DATA_LOGPRINTF];

    return true;
}


PLUGIN_EXPORT void PLUGIN_CALL Unload( )
{

}

PLUGIN_EXPORT int PLUGIN_CALL AmxLoad( AMX *amx )
{
    return amx_Register( amx, natives, -1 );
}

PLUGIN_EXPORT int PLUGIN_CALL AmxUnload( AMX *amx )
{

    return AMX_ERR_NONE;
}


PLUGIN_EXPORT void PLUGIN_CALL ProcessTick()

{
    static int contar ;

    if( GetTickCount() - contar > FOOT_RATE) {

        for(int i = 0; i != 1000; i++) {

            if(JogadorProcessado[i] == true) {

                int idx;

                if (!amx_FindPublic( amxGlobal , "OnCompleteRec", &idx))
                {
                    cell retVal             ;

                    amx_Push(amxGlobal, i);
                    amx_Exec(amxGlobal, &retVal, idx);

                }

                JogadorProcessado[i] = false;
            }
        }
    }
    else {
        contar = GetTickCount();
    }
}