//------------------------------------------------------------------------------
// Név: sscanf példaszkript, magyarázatokkal
// Készítõ: GameStar
// sscanf plugin, eredeti dokumentáció: Y_Less (a példák Y_Less dokumentációjára épülnek!)
// Web: gtaforum.hu, y-less.com
// Frissítve: 2012. május 20.
//------------------------------------------------------------------------------
#include <a_samp>
// Az sscanf funkció beágyazása ebbe a szkriptbe
#include <sscanf2>
// Ha egy példa nem kell, akkor tegyél az alábbi sorokban \"//\"-t elé. (kommenteld)
// Ha pedig kell, akkor töröld ki elõle.
#define EXAMPLE1
#define EXAMPLE2
#define EXAMPLE3
#define EXAMPLE4
#define EXAMPLE5
#define EXAMPLE6
#define EXAMPLE7
#define EXAMPLE8
//#define EXAMPLE9
// A példák a szkript indulásakor futnak le. Ha elindítod a szkriptet, akkor
// ellenõrizheted a leírtakat.
public OnFilterScriptInit()
{
    #if defined EXAMPLE1
// 1. PÉLDA: Az alap
    // Meg kell adni egy bemenetet, egy formátumot, és céltárolókat, amikbe az
    // értékeket szeretnéd menteni a bemenetbõl a formátum alapján.
    new
        EXAMPLE1_var0[32],
        EXAMPLE1_var1;
    
    // Az alábbi kód lefutásával az EXAMPLE1_var0 értéke \"üdv\", az EXAMPLE1_var1 értéke
    // pedig 10 lesz. A formátum egy 32 cellás karakterlánc és egy egész szám.
    sscanf(\"üdv 10\", \"s[32]i\", EXAMPLE1_var0, EXAMPLE1_var1);
    printf(\"EXAMPLE1_var0: %s\\nEXAMPLE1_var1: %i\", EXAMPLE1_var0, EXAMPLE1_var1);
    #endif
    
    #if defined EXAMPLE2
// 2. PÉLDA: Tömbök
    // A függvény lehetõvé teszi, hogy egy tömbbe mentsük bele az értékeket.
    new
        EXAMPLE2_array0[5];
    // Az alábbi kód lefutásával az EXAMPLE2_array0 minden indexbe sorra felveszi
    // az értékeket
    sscanf(\"1 2 3 4 5\", \"a<i>[5]\", EXAMPLE2_array0);
    for(new i = 0; i < sizeof(EXAMPLE2_array0); i++)
        printf(\"EXAMPLE2_array0[%i]: %i\", i, EXAMPLE2_array0);
    #endif
    
    #if defined EXAMPLE3
// 3. PÉLDA: Enum
    enum EXAMPLE3_enum0
    {
        e_integer,
        Float:e_float,
        e_string[32],
        e_character
    }
    new
        EXAMPLE3_var0[EXAMPLE3_enum0];
    // Az alábbi kód lefutásával az EXAMPLE3_var0 minden indexe felvesz egy értéket
    // a megadott formátum alapján
    sscanf(\"1 12.0 Bob c\", \"e<ifs[32]c>\", EXAMPLE3_var0);
    printf(\"EXAMPLE3_var0[e_integer]: %i\", EXAMPLE3_var0[e_integer]);
    printf(\"EXAMPLE3_var0[e_float]: %f\", EXAMPLE3_var0[e_float]);
    printf(\"EXAMPLE3_var0[e_string]: %s\", EXAMPLE3_var0[e_string]);
    printf(\"EXAMPLE3_var0[e_character]: %c\", EXAMPLE3_var0[e_character]);
    #endif
    
    #if defined EXAMPLE4
// 4. PÉLDA: Az úgynevezett \"csendes szekció\"
    // Amelyik formátumszakaszt {} közé rakjuk, azt a függvény késõbb érzékeli,
    // de nem veszi figyelembe.
    new
        EXAMPLE4_var0,
        EXAMPLE4_var1;
    // Az alábbi kód lefutásával az EXAMPLE3_var0 értéke -100 lesz, mert az elsõ egész
    // számot (42) nem vesszük figyelembe.
    sscanf(\"42 -100\", \"{i}i\", EXAMPLE4_var0);
    printf(\"EXAMPLE4_var0: %i\", EXAMPLE4_var0);
    // Az alábbi kód lefutásával az EXAMPLE3_var1 értéke 42 lesz, mert a második egész
    // számot (-100) nem vesszük figyelembe.
    sscanf(\"42 -100\", \"i{i}\", EXAMPLE4_var1);
    printf(\"EXAMPLE4_var1: %i\", EXAMPLE4_var1);
    #endif
    
    #if defined EXAMPLE5
// 5. PÉLDA: Szöveg keresése
    // \'\' közé rakva kereshetõ egy szöveg. Ilyenkor a függvény a szöveg pozíciójára
    // ugrik, ezért a korábbi és az új pozíció közötti dolgokat nem fogja figyelembe
    // venni. Az alábbi példa is szemlélteti ezt.
    // Formátumként megadunk egy egész számot (ami az elsõ egész szám - 10), amit a
    // függvény be is olvas. Majd megkerestetjük vele a szövegben a \"szöveg\" részt,
    // és végül lekérjük az utolsó egész számot (ami a 12). A 11 kimarad, mert a keresés
    // elõtt még nem lett figyelembe véve, utána pedig a függvény nem is törõdött vele,
    // mert a keresés miatt átugrott azon a részen.
    new
        EXAMPLE5_var0,
        EXAMPLE5_var1;
    sscanf(\"10 11 szöveg 12\", \"i\'szöveg\'i\", EXAMPLE5_var0, EXAMPLE5_var1);
    printf(\"EXAMPLE5_var0: %i\\nEXAMPLE5_var1: %i\", EXAMPLE5_var0, EXAMPLE5_var1);
    #endif
    
    #if defined EXAMPLE6
// 6. PÉLDA: Az elválasztók
    // Ha a bemeneti szövegekben az értékeket valami elválasztja (mondjuk vesszõ), akkor
    // megadhatjuk a függvénynek, hogy azok mentén válassza szét az értékeket.
    // A formátuma p<elválasztó>, tehát vesszõnél p<,>
    new
        EXAMPLE6_var0,
        EXAMPLE6_var1[12],
        EXAMPLE6_var2;
    sscanf(\"1,nem,3\", \"p<,>is[12]i\", EXAMPLE6_var0, EXAMPLE6_var1, EXAMPLE6_var2);
    printf(\"EXAMPLE6_var0: %i\\nEXAMPLE6_var1: %s\\nEXAMPLE6_var2: %i\", EXAMPLE6_var0, EXAMPLE6_var1, EXAMPLE6_var2);
    #endif
    
    #if defined EXAMPLE7
// 7. PÉLDA: Választható formátumok
    // Ugyanaz, mint a sima formátum, viszont ha a függvény nem talál neki értéket,
    // abban az esetben az általunk megadott \"alapértelmezett értéket\" adja neki.
    // Csak nagybetûvel kell írni, és meg kell adni az alapértelmezett értéket.
    new
        EXAMPLE7_var0,
        EXAMPLE7_var1[16],
        EXAMPLE7_var2[5];
    // Itt nem adunk meg bemeneti szöveget, a választható egész szám alapértelmezett értékét
    // pedig 12-re állítjuk. A függvény nem fog találni értéket, így automatikusan 12-t fog
    // adni.
    sscanf(\"\", \"I(12)\", EXAMPLE7_var0);
    printf(\"EXAMPLE7_var0: %i\", EXAMPLE7_var0);
    
    // Karakterlánccal
    sscanf(\"\", \"S(alapértelmezett)[16]\", EXAMPLE7_var1);
    printf(\"EXAMPLE7_var1: %s\", EXAMPLE7_var1);
    
    // Tömbbel
    sscanf(\"\", \"A<i>(1, 2, 3, 4, 5)[5]\", EXAMPLE7_var2);
    for(new i = 0; i < sizeof(EXAMPLE7_var2); i++)
        printf(\"EXAMPLE7_var2[%i]: %i\", i, EXAMPLE7_var2);
    #endif
    
    #if defined EXAMPLE8
// 8. PÉLDA: Egyéni formátumok
    // Lehetõségünk van saját formátumokat csinálni. Csak egy SSCANF: elõtag kell.
    // Ennek is van választható, és sima fajtája is. A választható esetében, ha nem tudja
    // meghívni a saját formátum eljárását, akkor az alapértelmezett értéket adja.
    new
        EXAMPLE8_var0[16],
        EXAMPLE8_var1,
        EXAMPLE8_var2[16],
        EXAMPLE8_var3;
    sscanf(\"GameStar PLAYER_STATE_PASSENGER\", \"s[16]k<playerstate>\", EXAMPLE8_var0, EXAMPLE8_var1);
    // Az EXAMPLE7_var1 értéke 3 kell, hogy legyen.
    printf(\"EXAMPLE8_var0: %s\\nEXAMPLE8_var1: %i\", EXAMPLE8_var0, EXAMPLE8_var1);
    
    // Ha a bemenetben nincs megadva az állapot szövegesen, akkor az alapértelmezett
    // értéket (PLAYER_STATE_PASSENGER) kapjuk
    sscanf(\"GameStar\", \"s[16]K<playerstate>(PLAYER_STATE_PASSENGER)\", EXAMPLE8_var2, EXAMPLE8_var3);
    // Az EXAMPLE8_var3 értéke 3 kell, hogy legyen.
    printf(\"EXAMPLE8_var2: %s\\nEXAMPLE8_var3: %i\", EXAMPLE8_var0, EXAMPLE8_var1);
    #endif
    
    #if defined EXAMPLE9
// 9. PÉLDA: Összetettebb használat
    // A függvénnyel akár egész komplex formátumokat is csinálhatunk, íme egy példa:
    enum EXAMPLE9_enum0
    {
        Float:e_float,  // f
        e_string[32],   // s[32]
        e_character,    // c
        e_hex           // h
    }
    new
        EXAMPLE9_var0[EXAMPLE9_enum0],
        EXAMPLE9_var1,
        Float:EXAMPLE9_var2[4];
    // unformat-ot is írhatunk, az is elfogadott...
    unformat(
        \"üdv 22 nem PLAYER_STATE_DRIVER 20.0 gtaforum.hu g FF00DD\",
        \"{s[4]}\'nem\'k<playerstate>e<fs[32]ch>A<f>(1.434, 2.233, 3.262 ,4.176)[4]\",
        // A formátum szöveges magyarázata:
        // - Az elsõ szöveget (üdv) kihagyjuk a \"csendes szekcióval\".
        // - A 22-t is kihagyjuk, mert rákeresünk a következõ szövegre (nem).
        // Azzal sem törõdünk.
        // - A következõ szövegrõl (PLAYER_STATE_DRIVER) lekérdezzük a saját
        // formátumunkkal, hogy milyen érték tartozik hozzá.
        // - Ezután az enumba tartozó értékeket olvassuk ki:
        //      - A lebegõpontos értéket (20.0)
        //      - A karakterláncot (gtaforum.hu)
        //      - A karaktert (g)
        //      - A tizenhatos számrendszer beli számot (FF00DD)
        // - Választható tömbformátummal az alapértelmezett lebhegõpontos értékeket 
        // fogjuk kapni, mivel nincs megadva a 4 lebegõpontos érték
        EXAMPLE9_var1,  // k<playerstate>
        EXAMPLE9_var0,  // e<fs[32]ch>
        EXAMPLE9_var2   // A<f>(1.434, 2.233, 3.262 ,4.176)[4]
    );
    printf(\"EXAMPLE9_var1: %i\", EXAMPLE9_var1);
    printf(\"EXAMPLE9_var0[e_float]: %.1f\", EXAMPLE9_var0[e_float]);
    printf(\"EXAMPLE9_var0[e_string]: %s\", EXAMPLE9_var0[e_string]);
    printf(\"EXAMPLE9_var0[e_character]: %c\", EXAMPLE9_var0[e_character]);
    printf(\"EXAMPLE9_var0[e_hex]: %x\", EXAMPLE9_var0[e_hex]);
    for(new i = 0; i < sizeof(EXAMPLE9_var2); i++)
        printf(\"EXAMPLE9_var2[%i]: %.3f\", i, EXAMPLE9_var2);
    #endif
    
    return 1;
}
// (A 8. és 9. példához) egy egyéni formátum. Megadja szöveges adat alapján számmal, hogy a játékosnak
// éppen mi az állapota.
SSCANF:playerstate(string[])
{
    // Ha a szöveg már szám formátumú
    if (\'0\' <= string[0] <= \'9\')
    {
        // Lekérjük az értékét
        new
            ret = strval(string);
        // Ha a lekért érték 0, vagy kisebb vagy egyenlõ mint 9, akkor visszaadjuk
        if (0 <= ret <= 9)
        {
            return ret;
        }
    }
    else if (!strcmp(string, \"PLAYER_STATE_NONE\")) return 0;
    else if (!strcmp(string, \"PLAYER_STATE_ONFOOT\")) return 1;
    else if (!strcmp(string, \"PLAYER_STATE_DRIVER\")) return 2;
    else if (!strcmp(string, \"PLAYER_STATE_PASSENGER\")) return 3;
    else if (!strcmp(string, \"PLAYER_STATE_WASTED\")) return 7;
    else if (!strcmp(string, \"PLAYER_STATE_SPAWNED\")) return 8;
    else if (!strcmp(string, \"PLAYER_STATE_SPECTATING\")) return 9;
    
    // Ha nem találtunk a megadott szöveghez azonosítót, akkor -1-el tér vissza
    return -1;
}