enum {
   MAKE_DEFAULT_POINT = 0x1,
   MAKE_AIMING_POINT = 0x2
};

#define DATA_ORIGIN 0x0
#define DATA_VIEW_OFS 0x1
#define DATA_ANGLES 0x2
#define DATA_PUNCH_ANGLES 0x3
#define DATA_ANGLES_RESULT 0x4
#define DATA_ORIGIN_RESULT 0x5
#define DATA_GLOBAL_FORWARD 0x6
#define DATA_GLOBAL_RIGHT 0x7
#define DATA_GLOBAL_UP 0x8
#define DATA_SPHERE_ORIGIN 0x9
#define DATA_AIMING_POINT 0xA
#define DATA_ANGLES_RESULT_MULTIPLIED 0xB
#define DATA_GLOBAL_FORWARD_MULTIPLIED 0xC
#define DATA_AIMING_ORIGIN_FULL 0xD
#define DATA_TOTAL 0xE

Float:g_vec_fGlobalData[DATA_TOTAL][3];

stock GetVectorPointOrigin(Float:vec_fSource[3], const Float:vec_fMultiple[3]) {
   vec_fSource[0] = (
      g_vec_fGlobalData[DATA_ORIGIN_RESULT][0] + (
         g_vec_fGlobalData[DATA_GLOBAL_FORWARD][0] * 
         vec_fMultiple[0]
      ) + (
         g_vec_fGlobalData[DATA_GLOBAL_RIGHT][0] * 
         vec_fMultiple[1]
      ) + (
         g_vec_fGlobalData[DATA_GLOBAL_UP][0] * 
         vec_fMultiple[2]
      )
   );
   
   vec_fSource[1] = (
      g_vec_fGlobalData[DATA_ORIGIN_RESULT][1] + (
         g_vec_fGlobalData[DATA_GLOBAL_FORWARD][1] * 
         vec_fMultiple[0]
      ) + (
         g_vec_fGlobalData[DATA_GLOBAL_RIGHT][1] * 
         vec_fMultiple[1]
      ) + (
         g_vec_fGlobalData[DATA_GLOBAL_UP][1] * 
         vec_fMultiple[2]
      )
   );
   
   vec_fSource[2] = (
      g_vec_fGlobalData[DATA_ORIGIN_RESULT][2] + (
         g_vec_fGlobalData[DATA_GLOBAL_FORWARD][2] * 
         vec_fMultiple[0]
      ) + (
         g_vec_fGlobalData[DATA_GLOBAL_RIGHT][2] * 
         vec_fMultiple[1]
      ) + (
         g_vec_fGlobalData[DATA_GLOBAL_UP][2] * 
         vec_fMultiple[2]
      )
   );
}

stock UTIL_MakeVectors(id, iMode = MAKE_DEFAULT_POINT) {
   static iTraceResult;

   pev(id, pev_origin, g_vec_fGlobalData[DATA_ORIGIN]);
   pev(id, pev_view_ofs, g_vec_fGlobalData[DATA_VIEW_OFS]);
   pev(id, pev_v_angle, g_vec_fGlobalData[DATA_ANGLES]);
   pev(id, pev_punchangle, g_vec_fGlobalData[DATA_PUNCH_ANGLES]);
   
   xs_vec_add(g_vec_fGlobalData[DATA_ANGLES], g_vec_fGlobalData[DATA_PUNCH_ANGLES], g_vec_fGlobalData[DATA_ANGLES_RESULT]);
   xs_vec_add(g_vec_fGlobalData[DATA_ORIGIN], g_vec_fGlobalData[DATA_VIEW_OFS], g_vec_fGlobalData[DATA_ORIGIN_RESULT]);
   
   engfunc(EngFunc_MakeVectors, g_vec_fGlobalData[DATA_ANGLES_RESULT]);
   global_get(glb_v_forward, g_vec_fGlobalData[DATA_GLOBAL_FORWARD]);

   if(iMode & MAKE_AIMING_POINT) {
      xs_vec_mul_scalar(g_vec_fGlobalData[DATA_GLOBAL_FORWARD], 4096.0, g_vec_fGlobalData[DATA_GLOBAL_FORWARD_MULTIPLIED]);
      xs_vec_add(g_vec_fGlobalData[DATA_ORIGIN_RESULT], g_vec_fGlobalData[DATA_GLOBAL_FORWARD_MULTIPLIED], g_vec_fGlobalData[DATA_AIMING_ORIGIN_FULL]);

      engfunc(EngFunc_TraceLine, g_vec_fGlobalData[DATA_ORIGIN_RESULT], g_vec_fGlobalData[DATA_AIMING_ORIGIN_FULL], (DONT_IGNORE_MONSTERS | IGNORE_MISSILE), id, iTraceResult);
      get_tr2(iTraceResult, TR_vecEndPos, g_vec_fGlobalData[DATA_AIMING_POINT]);
   }
   
   if(iMode & MAKE_DEFAULT_POINT) {
      global_get(glb_v_right, g_vec_fGlobalData[DATA_GLOBAL_RIGHT]);
      global_get(glb_v_up, g_vec_fGlobalData[DATA_GLOBAL_UP]);
   }
}

velocityByAim(id, nPlasma, nVelocityMult, Float:vecVelocity[3]) {
    UTIL_MakeVectors(id, MAKE_AIMING_POINT);
    new Float:vec_fVector[3];
    GetVectorPointOrigin(vec_fVector, Float:((get_distance_f(g_vec_fGlobalData[DATA_ORIGIN_RESULT],
g_vec_fGlobalData[DATA_AIMING_POINT]) > 64.0) ? {32.0, 1.0, 2.5} : {1.0, 1.0, 2.5}));
    set_pev(nPlasma, pev_origin, vec_fVector);
         
    vecVelocity[0] = (g_vec_fGlobalData[DATA_GLOBAL_FORWARD][0] * nVelocityMult);
    vecVelocity[1] = (g_vec_fGlobalData[DATA_GLOBAL_FORWARD][1] * nVelocityMult);
    vecVelocity[2] = (g_vec_fGlobalData[DATA_GLOBAL_FORWARD][2] * nVelocityMult);
}