// Player tömb létrehozása, 32 tömbelemmel

new Players[32]

// Most már van egy 32 elemu tömbünk, az elemeire 0-ról n-1-ig (jelen esetben 0-tól 31-ig) hivatkozhatunk.

// Tehát minden tömb elso eleme a 0. indexű elem.

 

// 0. indexű elemet 5re állítjuk.

Players[0] = 5

 

// Az 1. indexű elembe belepakoljuk a 0. indexű elemet.

Players[1] = Players[0]

 

// Példa hibás indexelésekre:

// Egy 32 elemű tömb első eleme a 0. utolsó a 31.

// Ez a kód nem fordul le, már fordítási időben hibát dob, mivel fix az értéke.

Players[32] = 15

 

// Ez a kód lefordul, de futási idoben hibát dob. Eredménye: AMX Native Error 4 - AMX_ERR_BOUNDS

new A=33

Players[A] = 15

 

// Ez abszolút hibás        

Players[-1] = 6

 

// Változót nem adhatunk meg csak úgy egy tömb deklarálásakor, mivel nem lehet meghatározni a méretét. Ha a változó konstans, vagy fordítási direktíva a mérete, akkor gond nélkül lefordul, mivel előre meghatározott értéket vehet fel. (Előbbi esetben futási időben, utóbbi esetben a fordító illeszti bele az értéket a fordítandó kódba)

// Ez se nem konstans, se nem #DEFINE => Fordítási hiba

new a = 3

new BadArray[a]

 

// Ez egy jó, lefordítható kód.

new const b = 3

new GoodArray[b]

#define ARRAY_SIZE 3

new Array[ARRAY_SIZE]

new Numbers[4] = {0,1,2,3}

// Megjegyzés: Ekkor pont annyi elemet kell megadni, ahány elemű a tömbünk.

// Float tömb:

new Float:Numbers[4] = {0.0, 1.2, 2.4, 3.8}

// Boolean tömb

new bool:playerHasGun[33] = {true, ...}

// Megjegyzés: A Boolean tömb ekként való definiálása estén nem kell kiírni az összes true értéket, ugyanis ekkor az össze elem true lesz.

 

// Létrehozunk egy "myString" nevu számtömböt ami a "Hello" karaktersorozatot fogja tárolni.

// 6 eleme lesz a tömbnek, ebből 5 a karaktereknek van fenntartva.

// Az utolsó tömbelem a 0 értéket veszi fel, ami jelzi a Pawn motorjának, hogy ez a tömb egy stringet tartalmaz.

// Ebben az esetben nem kell kitenni a deklarációkor a tömb méretet, mivel maga a karaktersorozat fogja meghatérozni a tömbméretet.

new myString[] = "Hello"

new myString[6]

myString[0] = 'H'

myString[1] = 'e'

myString[2] = 'l'

myString[3] = 'l'

myString[4] = 'o'

myString[5] = 0

// Megjegyzés: mint írtam, az utolsó 0 jelzi, hogy a tömb egy stringet tartalmaz. Ha nem tennénk ki, nem lehetne stringként használni.

new myString[6]

myString = "Hello"     // INVALID!

myString[0] = "Hello"  // INVALID!

// Egy stringnek szánt tömbe adatot az alábbi módon rakhatunk:

new goodString[7]

copy(goodString, 6, "Hello")

// Megjegyzés:Itt 6 hosszú stringet pakolunk be a tömbbe. Figyeljünk arra, hogy 7 byte másolása esetén a copy függvén képes egy extra byteot másolni a tömbbe a null karakter miatt, ami túlcsordulást okozhat.

// A copy egy függvény, ami 3 paraméterből áll:

copy(destination[], length, source[])

// a source tömbből legfeljebb length hosszú stringet másol a destination tömbbe

 

// Végül megmutatom, miként reprezentálják a számok a karaktereket:

new metal[6]

metal[0] = 77

metal[1] = 69

metal[2] = 84

metal[3] = 65

metal[4] = 76

metal[5] = 0

// Ez a metal tömbbe beállítja a "METAL" stringet

// Ez deklarál egy 50 sorból és 50 oszlopból álló táblát (aka kétdimenziós tömb)

new BigArray[50][50]

// Float típusú tömb, 25 sorral és 10 oszloppal

new Float:BigArray[25][10]

 

new BigArray[3][3]

BigArray[0][0] = 10

BigArray[0][1] = 20

BigArray[0][2] = 30

BigArray[1][0] = 40

BigArray[1][1] = 50

BigArray[1][2] = 60

BigArray[2][0] = 70

BigArray[2][1] = 80

BigArray[2][2] = 90

 

// Így képzelhető el a változónk tartalma: 

   0   1   2 

0  10  20  30 

1  40  50  60 

2  70  80  90 

// Például ilyen a sum_of_array() függvény, ami visszaadja  az első n elem összegét.

new sum = sum_of_array(BigArray, 9)  // INVALID

// Igy használható, de ekkor csak egy részét summázva:

new sum = sum_of_array(BigArray[2], 3)

sum_of_table(array[][], rows, cols)

{

   new i, j, sum

 

   // Egymásba ágyazott for ciklusok segítenek abban, hogy végigiteráljunk a tömb elemein

   for (i=0; i<rows; i++)

   {

      for (j=0; j<cols; j++)

      {

         sum += array[i][j]

      }

   }

 

   return sum

}

new StringList[3][] = {"Hello", "my", "friend"}

/*

  StringList [0][0]-tól [0][5]-ig tartalmazza a "Hello" stringet

  StringList [1][0]-tól [1][2]-ig tartalmazza "my" stringet

  StringList [2][0]-tól [2][6]-ig tartalmazza "friend" stringet

*/

if (StringList[0] == "Hello")       //INVALID

if (StringList[0][0] == "Hello")    //INVALID

if (equali(StringList[0], "Hello")) //Valid

new Players[32]
Players[5] = 15

new Players[32]

// Ezek helyesek:

Players[2]=12345

Players[3]='a'

// Ez helytelen

Players[4]='aaa'

 

new a=77
new b='M'

a == b

new Players[32]
Players[5] = 15

new Players[32]
Players[id] = 15

new Players[10], Players2[10]

for (new id=0; id<10; id++)
    Players[id]=id*2;

for (new alma=0; alma<10; alma++)
    Players2[alma]=alma*2;

for (new i=0; i<10; i++)
    if (Players2[i] == Players[i])
    {
        // ide mindig bejut, mivel mind2 tömb i. eleme ugyanaz lesz
    }

new Players[32]
Players[id] = 15