/This function demonstrates: how to get and modify array values.
//PAWN native: native PrintPawnArray(arr[], size = sizeof(arr));
cell AMX_NATIVE_CALL PrintPawnArray(AMX* amx, cell* params)
{
    //Make sure there's something to print...
    if(params[2] > 0)
    {
        cell* addr = NULL;

        //Get the address of the first value in our PAWN array.
        amx_GetAddr(amx, params[1], &addr);

        for(int i = 0, l = params[2]; i < l; i++)
        {
            //This is pretty straight forward: We dereference the addr pointer to get our value to print.
            //You should know this already, but arrays and pointers are almost the same thing, so we can use pointer
            //arithmetic to add an offset OR just use the subscript operator (in the end *(addr+1) and addr[1] are the same).
            logprintf("arr[%d] = %d", i, *(addr + i));

            //If you wanted to modify the array you would just change its value by dereferencing addr and assigning a new value. 
            //You should know this as well, im just adding it in for completeness. Here we change the first value of our array
            //to 5 (Note: Since its the first value, no offset it used).

            // *(addr) = 5;   
        }
    }
    return 1;
}

static cell AMX_NATIVE_CALL n_ReturnArray( AMX* amx, cell* params )
    {
        for(int i = 0, j = RouteVector.size(); i < j; ++i)
        {
            if(RouteVector.at(i).id == params[1])
            {
                cell *dest = NULL;
                amx_GetAddr(amx,params[2],&dest);
                for(int a = 0, b = params[3]; a < b; ++a)
                {
                    dest[a] = RouteVector.at(i).Paths[a];
                }
                //dest = NULL;
                return RouteVector.at(i).Paths.size();
            }
        }
        return 0;
    }

namespace Natives
{
    //native TwoDArrayFunction(array[][],size_a = sizeof(array),size_b = sizeof(array[]));
    static cell AMX_NATIVE_CALL TwoDArrayFunction( AMX* amx, cell* params )
    {
        cell *dest = NULL;
        amx_GetAddr(amx,params[1],&dest);

        for(int a = params[2], b = a+(params[2]*params[3]); a < b; ++a)
        {
            std::cout << dest[a] << std::endl;
        }
        return 1;
    }
    //native ThreeDArrayFunction(array[][][],size_a = sizeof(array),size_b = sizeof(array[]),size_c = sizeof(array[][]));
    static cell AMX_NATIVE_CALL ThreeDArrayFunction( AMX* amx, cell* params )
    {
        cell *dest = NULL;
        amx_GetAddr(amx,params[1],&dest);

        for(int a = (params[2]*params[3])+params[2], b = a+(params[2]*params[3]*params[4]); a < b; ++a)
        {
            std::cout << dest[a] << std::endl;
            //dest[a] = 0;//modify array
        }
        return 1;
    }
    //native SomeStringfunc(array[][],size_a = sizeof(array),size_b = sizeof(array[]));
    static cell AMX_NATIVE_CALL SomeStringfunc( AMX* amx, cell* params )
    {
        cell *dest = NULL;
        amx_GetAddr(amx,params[1],&dest);

        for(int a = params[2], b = a+(params[2]*params[3]); a < b; a+=params[3])
        {
            //std::cout << dest[a] << std::endl;
            amx_SetString(&dest[a],"This is a test string\0",0,0,strlen("This is a test string\0")+1);
        }
        return 1;
    }
    AMX_NATIVE_INFO AMXNatives[ ] =
    {
        {"TwoDArrayFunction", TwoDArrayFunction},
        {"ThreeDArrayFunction", ThreeDArrayFunction},
        {"SomeStringfunc", SomeStringfunc},
        {0,                0}
    };
};//namespace Natives

#include <a_samp>

native TwoDArrayFunction(array[][],size_a = sizeof(array),size_b = sizeof(array[]));
native ThreeDArrayFunction(array[][][],size_a = sizeof(array),size_b = sizeof(array[]),size_c = sizeof(array[][]));
native SomeStringfunc(array[][],size_a = sizeof(array),size_b = sizeof(array[]));
/*
enum ArrayStuff7
{
    SomeStuff7[7]
};

enum ArrayStuff5
{
    SomeStuff5[5]
};
*/
public OnFilterScriptInit()
{
    new array1[3][5];
    //new array2[3][ArrayStuff5];
    new array3[3][5][7];
    //new array4[3][5][ArrayStuff7];
    for(new a = 0,b,c,z=0,y=0; a < 3; ++a)
    {
        for(b = 0; b < 5; ++b)
        {
            array1[a][b] = z;
            //array2[a][SomeStuff5][b] = z;
            ++z;
            //printf("2)[%d][%d] = (%d)",a,b,array2[a][b]);
            for(c = 0; c < 7; ++c)
            {
                array3[a][b][c] = y;
                //array4[a][b][SomeStuff7][c] = y;
                //printf("3)[%d][%d] = (%d)",a,b,array3[a][b][c]);
                ++y;
            }
        }
    }
    printf("done");
    TwoDArrayFunction(array1);
    //TwoDArrayFunction(array2);
    ThreeDArrayFunction(array3);
    //ThreeDArrayFunction(array4);
    new strings[10][256];
    SomeStringfunc(strings);
    for(new i = 0; i < 10; ++i)
        print(strings[i]);
    return 1;
}

//native RetrieveFileList(directory[],array[][],&returned_files=0,&index=0,size_a = sizeof(array),size_b = sizeof(array[]));
    static cell AMX_NATIVE_CALL TwoDArrayFunction( AMX* amx, cell* params )
    {
        char* DirectoryToLoop;

        cell * index = NULL;
        amx_GetAddr(amx,params[4],&index);
        cell *returned_files = NULL;
        amx_GetAddr(amx,params[3],&returned_files);

        returned_files = 0;

        amx_StrParam(amx, params[1], DirectoryToLoop);
        if(!DirectoryToLoop)
            DirectoryToLoop = ".";
        if(index < 0)
            return false;

        cell *dest = NULL;
        amx_GetAddr(amx,params[1],&dest);

        int ArrayIdxStart = params[5];
        int ArrayStep = params[6];
        int ArrayMax = ArrayIdxStart+(ArrayIdxStart*ArrayStep);
        
        int LoopsDone = 0;

        int WriterPosition = 0;
        foreach(|file| in {DirectoryToLoop}, start looping files at {index})
        {
            WriterPosition = ArrayIdxStart+(ArrayStep*LoopsDone);
            if(WriterPosition < ArrayMax)
            {
                amx_SetString(&dest[ArrayIdxStart+(ArrayStep*LoopsDone)],file,0,0,strlen(file)+1);
            }
            else
            {
                index = index+(LoopsDone);
                returned_files = (LoopsDone+1);
                return (|files in directory| - index);//we still have files to loop
            }
            ++LoopsDone;
        }
        index = index+(LoopsDone-1);
        returned_files = (LoopsDone);
        return 0;//no more files to loop
    }

#include <a_samp>
native RetrieveFileList(directory[],array[][],&returned_files=0,&index=0,size_a = sizeof(array),size_b = sizeof(array[]));

new MyArrayOfFiles[32][267];

public OnFilterScriptInit()
{
    //print all files in directory "./scriptfiles/"
    new index = 0;
    new FilesReturned = 0;
    while(RetrieveFileList("./scriptfiles/",MyArrayOfFiles,FilesReturned,index))
    {
        for(new i = 0; i < FilesReturned; ++i)
        {
            print(MyArrayOfFiles[i]);
        }
    }
    return 1;
}