stock numArgs()
{
    // Get the adress
    #emit LOAD.S.PRI 0
    // Skip over the function header
    #emit ADD.C 8
    // Load the address
    #emit LOAD.I
    // Convert from bytes to cells
    #emit SHR.C.PRI 2
    // Return the value
    #emit RETN
    // Return a random value to ignore the warning
    return 0;
}

stock
    GetXYZInViewOfPlayer(playerid, &Float:X, &Float:Y, &Float:Z, Float:distance)
{
    new Float:VX, Float:VY, Float:VZ;
    
    GetPlayerPos(playerid, X, Y, Z);
    GetPlayerCameraFrontVector(playerid, VX, VY, VZ);
    
    X += (distance * VX);
    Y += (distance * VY);
    Z += (distance * VZ);
}

CMD:xyztest(playerid, params[])
{
    new Float:X, Float:Y, Float:Z;

    GetPlayerPos(playerid, X,Y,Z);

    new object = CreateObject(18647, X, Y, Z, 0, 0, 0, 100);

    GetXYZInViewOfPlayer(playerid, X, Y, Z, 10);

    MoveObject(object, X,Y,Z, 2);
    
    return true;
}

stock getArg(iArg, iIdx)
{
    #emit LOAD.S.PRI iArg   // Load parameter address
    #emit SHL.C.PRI 2       // Convert that value from cells to bytes
    #emit ADD.C 12          // Add 12 to skip the function header
    #emit LOAD.S.ALT 0      // Get previous function's frame
    #emit ADD               // Add to pri
    #emit LOAD.I            // Load address
    #emit LOAD.S.ALT iIdx   // Load parameter address
    #emit SHL.C.ALT 2       // Convert that value from cells to bytes
    #emit ADD               // Add to pri
    #emit LOAD.I            // Load address
    #emit RETN              // Return value
    
    return 0;               // Random return to ignore compiler warning
}

stock setArg(iArg, iIdx, iValue)
{
    new
        iAddr
    ;
    #emit LOAD.S.PRI iArg   // Load parameter address
    #emit SHL.C.PRI 2       // Convert that value from cells to bytes
    #emit ADD.C 12          // Add 12 to skip the function header
    #emit LOAD.S.ALT 0      // Get previous function's frame
    #emit ADD               // Add to pri
    #emit LOAD.I            // Load address
    #emit LOAD.S.ALT iIdx   // Load parameter address
    #emit SHL.C.ALT 2       // Convert that value from cells to bytes
    #emit ADD               // Add to pri
    #emit STOR.S.PRI iAddr  // Store pri to iAddr
    #emit LOAD.S.ALT iValue // Load parameter address
    #emit SREF.S.ALT iAddr  // Store value to reference parameters
    
    return 1;
}

stock GetXYZInViewOfPlayer(playerid, &Float:X, &Float:Y, &Float:Z, Float:distance)
{
    new Float:VX, Float:VY, Float:VZ;
   
    //GetPlayerPos(playerid, X, Y, Z);
    GetPlayerCameraPos(playerid,X,Y,Z);
    //I change this because the Cameravector starts from the CameraPos and not from the Player.
    //If it would start from the Player the Cameravector would be a little bit different.
    //Now you have to think that the distance you choose for this function is not from Player to a point,
    //it is from the CameraPos... (Don't forget it)
    GetPlayerCameraFrontVector(playerid, VX, VY, VZ);
   
    //--[Correction of the CameraVector]----------------------------------------------
    new Float:tmpfloat;
    tmpfloat = floatdiv(1,floatsqroot(floatpower(VX,2)+floatpower(VY,2)+floatpower(VZ,2))); 
    // I don't know how it is called in english but in Germany we say "Betrag"
    // With this calculation "floatsqroot(floatpower(VX,2)+floatpower(VY,2)+floatpower(VZ,2))" i know how long the vector is.
    // For example the vector could be 2.34 feet/meter/inch long... 
    VX = floatmul(VX, tmpfloat);
    VY = floatmul(VY, tmpfloat);
    VZ = floatmul(VZ, tmpfloat);
    // Now the cameravector is exactly 1 "distance" long... 
    // I calculate (1 div [How Long the vector is]) * [Vector] = [Vector which is 1 "distance" long]
    //-------------------------------------------------------------------
   
    X += (distance * VX);
    Y += (distance * VY);
    Z += (distance * VZ);
}

static
    Float: g_ObjectDeg [ MAX_OBJECTS ]
;

stock SetObjectMoveAroundPoint( objectid, Float: X, Float: Y, Float: Z, Float: distance, Float: speed = 1.0, Float: face = false)
{
    new
        Float: nX, Float: nY
    ;
    if( g_ObjectDeg[ objectid ] >= 360 ) g_ObjectDeg[ objectid ] = 0;
    else g_ObjectDeg[ objectid ] += speed;

    nX = X + distance * floatcos( g_ObjectDeg[ objectid ], degrees );
    nY = Y + distance * floatsin( g_ObjectDeg[ objectid ], degrees );

    SetObjectPos( objectid, nX, nY, Z );
    if(face) SetObjectRot( objectid, 0.0, 0.0, 90 - g_ObjectDeg[ objectid ] );
}

stock SendClientMessageFormatted(playerid, color, fstring[], {Float, _}:...)
{
    #define BYTES_PER_CELL              4
    static const STATIC_ARGS = 3;
    new n = (numargs() - STATIC_ARGS) * BYTES_PER_CELL;
    if(n)
    {
        new message[144],arg_start,arg_end;
        #emit CONST.alt        fstring
        #emit LCTRL          5
        #emit ADD
        #emit STOR.S.pri        arg_start

        #emit LOAD.S.alt        n
        #emit ADD
        #emit STOR.S.pri        arg_end
        do
        {
            #emit LOAD.I
            #emit PUSH.pri
            arg_end -= BYTES_PER_CELL;
            #emit LOAD.S.pri      arg_end
        }
        while(arg_end > arg_start);

        #emit PUSH.S          fstring
        #emit PUSH.C          144
        #emit PUSH.ADR         message

        n += BYTES_PER_CELL * 3;
        #emit PUSH.S          n
        #emit SYSREQ.C         format

        n += BYTES_PER_CELL;
        #emit LCTRL          4
        #emit LOAD.S.alt        n
        #emit ADD
        #emit SCTRL          4

        if(playerid == INVALID_PLAYER_ID)
        {
            #pragma unused playerid
            return SendClientMessageToAll(color, message);
        } else {
            return SendClientMessage(playerid, color, message);
        }
    } else {
        if(playerid == INVALID_PLAYER_ID)
        {
            #pragma unused playerid
            return SendClientMessageToAll(color, fstring);
        } else {
            return SendClientMessage(playerid, color, fstring);
        }
    }
}