Néhány példaprogram, mely bemutatja a Pawn programozási nyelv elemeit.
Alapvető nyelvi elemek
Az alábbi egyszerű mintaprogram a Pawn nyelv alapvető elemeit mutatja be. Az alkalmazás egy magyar kártyacsomagból képez adott számú kisebb csomagokat, oly módon mintha játékosoknak kerülnének a lapok kiosztásra.
Az alkalmazás konstans értékeket tartalmaz a lapok színeinek és értékeinek tekintetében. Az ezekből következő lapszám is egy konstans, illetve a kiosztandó lapokat is konstansnak tekintjük. Ezek definiálását a main függvény előtt találhatjuk.
A programozás egy szimbolikus indexű tömböt is tartalmaz ami a kártyalapot megvalósító struktúrát reprezentálja. Ennek három "tulajdonsága" van, melyből kettő a lap színére és értékére vonatkozik és egy a kiírandó kártyalap nevére. Erre optimalizációs célból van szükség. Ezt a csomag létrehozásakor töltjük ki, hivatkozva a konstans tömbelemek értékeire.
Az alkalmazás három fő részből áll. Elsőként létrehozzunk a kártyacsomagot. Két iteráció egymásba ágyazásával készül. A külső iteráció a színeken megy végig, a belső meg az értékeken. Az egyes iterációkban állítjuk be a kártyára vonatkozo értékeket köztük a nevet is. A második fázis a csomag összekeverése, mivel egy sorba rendezett csomagot generáltunk. A módszer egyszerű: 1000-szer kiválasztunk két kártyát, melyet felcserélünk a csomagban. A cserét egy külső függvényben hajtjuk végre, reprezentálva a függvényhívási módszert is. A harmadik fázis a kis csomagok képzése. Ez is két iterációban történik szimulálva az egy lapos osztás módszerét. A külső iteráció a csomagbeli lapszámon megy végig, míg a belső a kis csomagok számán (egy ide, egy oda elv).
Miután ezekkel megvagyunk kiírjuk a kis csomagokban megtalálható lapok neveit.
Az alkalmazás alább alaposan kommentelve látható.
#include
// ----------------------------------------------------------------
// PAWN Mintaprogram - Keszitette: Kereszti Zalan
// ----------------------------------------------------------------
//
// Mintaprogram a PAWN nyelv legtobb elemenek bemutatasara.
// Aki programozott mar C-ben sok ujat nem talal, egyedul a szintaktikai
// eggyszeruseget, illetve a tipustalansagot.
//
// Tobb egyedi elem is bemutatasra kerul, tobbek kozott:
// - Struktura keszitese
// - Formai egyszeruseg
// - Az elhagyhato zarojelek es pontosvesszok
// - Valtozok letrehozasa
// - Tobbdimenzios tombok kezelese
// - include-olt konyvtar hasznalata (strcat)
// - elhagyhato includeok hasznalata (printf)
//(Mivel nem mindent kell, de a string-et pont igen)
//
// Az egyszerusitesnek egy nagy hatranya van: Aki sokat kodolt
// C/C++ es tarsai nyelven, annak a kodjaban elofordulhat, hogy
// pontosvesszo itt-ott van benne, mashol nincs benne.
// Ez igaz a zarojelezesre is.
//
//
// A minta alkalmazas egy kartyacsomagkeszito Ă©s kevero alkalmazas
//
// Az alkalmazas kepes az elore definialt elemek alapjan
// - Kartyacsomagot generalni
// - Megkeverni
// - Adott mennyisegu lapokbol allo csomagot kepezni
// - A csomagokat kiirni a kepernyore
//
//
// Elerheto kartyaszinek es tipusok szama
// Jelen esetben magyar kartya, azaz 4 szin 8 ertekkel
const KartyaSzinek = 4;
const KartyaTipusok = 8;
// Kartyalapok szama, a fenti ket szambol kepzett szorzat
const KartyakSzama = KartyaSzinek * KartyaTipusok;
// Jatekosok szama es a kezben tartott lapok szama
const KisCsomagokSzama = 2;
const KisCsomagokLapokSzama = 3;
// Kartyaszinek nevei
new KartyaSzinNevek[KartyaSzinek + 1]{10} =
[ "Ismeretlen", "Piros", "Tok", "Zold", "Makk" ]
// Kartyatipusok nevei
new KartyaTipusNevek[KartyaTipusok + 1]{15} =
[ "Ismeretlen", "Hetes", "Nyolcas", "Kilences", "Tizes", "Also", "Felso", "Kiraly", "Asz" ];
// Definialunk egy Kartyalairo strukturat
// Megj: Ez egy nevesitett tomb! Konkret struktura nincs a nyelvben csak ilyen kiskapu
#define KartyaLeiro[
.KartyaNeve{30}, // A kartya neve lesz (amit a ket fenti ertekbol kepzunk)
.KartyaSzin, // A kartya szine
.KartyaTipus, // A kartya tipusa
]
// Program belepesi pontja
main()
{
// Kartyacsomag (pakli) letrehozasa.
// Ket dimenzio:
// - Egyik a csomag lapjainak szama (fent kiszamoltertek)
// - Masik az adott lapindexhez tartozo kartyaleiro, azaz kartyalap.
printf("Tomb letrehozasa\n");
new Pakli[KartyakSzama][KartyaLeiro];
new KisPaklik[KisCsomagokSzama][KisCsomagokLapokSzama][KartyaLeiro];
// Ket egymasba agyazott for ciklussal letrehozzuk a lapokat
// Szintaxisa C
printf("Kartyacsomag feltoltese\n");
for (new szin = 0; szin < KartyaSzinek; szin++)
{
for (new tipus = 0; tipus < KartyaTipusok; tipus++)
{
// Itt a kenyeg
// Kiszamoljuk az aktualis indexet
new index = szin * KartyaTipusok + tipus;
// A csomag adott indexu lapjan beallitjuk a szint es tipust
Pakli[index].KartyaSzin = szin + 1;
Pakli[index].KartyaTipus = tipus + 1;
// Majd kiszamoljuk (osszerakjuk) a kartya tenyleges nevet
// Ehhez a fent definialt tomboket hasznaljuk, a ciklusok iteracios indexeivel
// strcat egy c-beli fuggveny. Az include tartalmazza
// Erre azert van szukseg, mert Pawnban nem lehet karakterlancokat konkatenalni!
strcat(Pakli[index].KartyaNeve, KartyaSzinNevek[szin+1]);// Lehet zarojellel
strcat Pakli[index].KartyaNeve, " "; // vagy anelkul
strcat Pakli[index].KartyaNeve, KartyaTipusNevek[tipus+1];
}
}
printf("Keveres\n");
// Csomag megkeverese
// Modszer: 1000-szer kivalasztok ket lapot amit megcserelek.
for (new iter = 0; iter < 1000; iter++)
{
// Csere metodus kiszervezve
Csere(Pakli)
}
// Lapok szetosztasa
new i = 0; // Valtozo letrehozas
// Egyenkent osztjuk a lapokat, ezert ez a kulso ciklus
for (new lapszam = 0; lapszam < KisCsomagokLapokSzama; lapszam++)
{
// Minden csomagra rakunk, ezert ez a belso ciklus
for (new csomag = 0; csomag < KisCsomagokSzama; csomag++)
{
// Ertekadas
//KisPaklik[csomag][lapszam].KartyaSzin = Pakli[i].KartyaSzin;
//KisPaklik[csomag][lapszam].KartyaTipus = Pakli[i].KartyaTipus;
//strcat KisPaklik[csomag][lapszam].KartyaNeve, Pakli[i].KartyaNeve;
// Ez is mukodik
KisPaklik[csomag][lapszam] = Pakli[i];
++i;
}
}
// Eredmeny kiirasa
for (new csomag = 0; csomag < KisCsomagokSzama; csomag++)
{
printf "%d. csomag tartalma:\n---------------------", csomag+1
for (new lapszam = 0; lapszam < KisCsomagokLapokSzama; lapszam++)
{
printf "\n%s", KisPaklik[csomag][lapszam].KartyaNeve
}
printf "\n\n"
}
}
// Klasszikus swap metĂłdus
// Tombot kap parameterul, meg kell adni a meretet! Anelkul nem fordul
// Itt is latszik, hogy erdemes a konstansokat az elejen leirni
Csere( Pakli[KartyakSzama][KartyaLeiro] )
{
// Valtozok
new egyes = random(KartyakSzama) // veletlenszeru egyik lap
new kettes = random(KartyakSzama) // veletlenszeru masik lap
new puffer[KartyaLeiro]// atmeneti tarolo
// Csere
puffer = Pakli[ egyes ]
Pakli[egyes] = Pakli[kettes]
Pakli[kettes] = puffer
}
State programozás
Mintaprogram a PAWN nyelv legtöbb elemének bemutatására.
Akik programoztak már C-ben azok sok újat nem fognak találni, egyedül a szintaktikai egyszerűséget, amiket a gyors kódolás és átláthatóság végett vezettek be.
Több egyedi elem is bemutatásra kerül, többek között:
- Statek kezelése
- Eseményvezérlés
- Timerek
Leginkább a state-ek, s a vele jaró egyszerűsítések lesznek itt a szokatlan dolgok.
A minta alkalmazás útkereszteződésben lévő közlekedési lámpák működését mutatja be.
Az alkalmazással nyomon követhető, mikor milyen állapotban vannak a lámpák, illetve a gyalogosok megnyomhatják az átkeléshez szükséges gombot (space).
Kezdetben az autósoknak zöld, míg a gyalogosoknak piros a lámpája.
A gyalogosok a gomb megnyomásával megváltoztathatják kis időre a forgalmat.
Ekkor a szokványos lámpaváltások történnek, konkrétabban:
Zöld-Piros => Sárga-Piros => Piros-Piros => Piros-Zöld (Első az autósoknak, míg a másik a gyalogosoknak a lámpájának állapotát jelzi)
Ebben az állapotba tudnak átkelni a gyalogosok, erre 5 másodpercük van.
Annak elteltével Piros-Villogó Zöld állapotba jutunk.
A gomb újboli megnyomásával mindig visszatérünk a Piros-Zöld állapotba, s újraindul az 5 másodperc.
Amennyiben nem nyomjuk le kellő időben a gombot, akkor az alábbi váltások zajlanak le a lámpákon:
Piros-Piros => Piros és Sárga- Piros => Zöld-Piros.
Ezek alapján az alábbi állapotokat veheti fel a program:
- zold_piros
- sarga_piros
- piros_piros1
- piros_piros2
- piros_zold
- piros_villogo_zold
- piros_es_sarga_piros
Az állapotváltásokat timerrel oldjuk meg. Alapjáraton a zold_piros állapotban vagyunk, ez reprezentálja a Zöld-Piros állapotot.
Ekkor az autósoknak szabad az út.
A gomb (space) megnyomásával elindul a körforgás: Minden állapotváltást automatikusan újabb álapotváltás követ, emiatt minden állapot változáshoz rendelünk egy entry függvényt. Ez mindig akkor fut le ha állapotváltozás történik.
Állapotonként vesszük fel, így minden egyes állapotban más állapotváltozást kezdeményez.
Ezt úgy lehet elképzelni, mint egy rekurzív függvényhívás történne.
gomb megnyomásakor egy timer állítódik be, ami lefutáskor újabb időzítőt és állapotot állít be. Ez addig tart, amíg vissza nem térünk a kezdeti állapothoz.
// ------------------------------------------------------------------
// PAWN Mintaprogram - Keszitette: Kereszti Krisztián
// ------------------------------------------------------------------
//
// Mintaprogram a PAWN nyelv legtobb elemenek bemutatasara.
// Akik programoztak mar C-ben azok sok ujat nem fognak talalni, egyedul a szintaktikai egyszeruseget,
// amiket a gyors kodolas es atlathatosag vegett vezettek be.
//
// Tobb egyedi elem is bemutatasra kerul, tobbek kozott:
// - Statek kezelese
// - Esemenyvezerles
// - Timerek
//
// Leginkabb a state-ek, s a vele jaro egyszerusitesek lesznek itt a szokatlan dolgok.
//
// A minta alkalmazas utkeresztezodesben levo kozlekedesi lampak mukodeset mutatja be.
// Az alkalmazassal nyomon kovetheto, mikor milyen allapotban vannak a lampak, illetve a gyalogosok megnyomhatjak az atkeleshez szukseges gombot (space).
// Kezdetben az autosoknak zold, mig a gyalogosoknak piros a lampaja.
// A gyalogosok a gomb megnyomasaval megvaltoztathatjak kis idore a forgalmat.
// Ekkor a szokvanyos lampavaltasok tortennek, konkretabban:
// Zold-Piros => Sarga-Piros => Piros-Piros => Piros-Zold (Elso az autosoknak, mig a masik a gyalogosoknak a lampajanak allapotat jelzi)
// Ebben az allapotba tudnak atkelni a gyalogosok, erre 5 masodpercuk van.
// Annak elteltevel Piros-Villogo Zold allapotba jutunk.
// A gomb ujboli megnyomasaval mindig visszaterunk a Piros-Zold allapotba, s ujraindul az 5 masodperc.
// Amennyiben nem nyomjuk le kello idoben a gombot, akkor az alabbi valtasok zajlanak le a lampakon:
// Piros-Piros => Piros es Sarga- Piros => Zold-Piros.
//
// Ezek alapjan az alabbi allapotokat veheti fel a program:
// zold_piros
// sarga_piros
// piros_piros1
// piros_piros2
// piros_zold
// piros_villogo_zold
// piros_es_sarga_piros
//
// Az allapotvaltasokat timerrel oldjuk meg. Alapjaraton a zold_piros allapotban vagyunk, ez reprezentalja a Zold-Piros allapotot.
// Ekkor az autosoknak szabad az ut.
// A gomb (space) megnyomasaval elindul a korforgas:
// Minden allapotvaltast automatikusan ujabb alapotvaltas kovet, emiatt minden allapot valtozashoz rendelunk egy entry fuggvenyt.
// Ez mindig akkor fut le ha allapotvaltozas tortenik.
// Allapotonkent vesszuk fel, igy minden egyes allapotban mas allapotvaltozast kezdemenyez.
// Ezt ugy lehet elkepzelni, mint egy rekurziv fuggvenyhivas tortenne.
// Gomb megnyomasakor egy timer allitodik be, ami lefutaskor ujabb idozitot es allapotot allit be.
// Ez addig tart, amig vissza nem terunk a kezdeti allapothoz.
#include