Az előző leckében letöltöttük, telepítettük az AGK-t, létrehoztunk egy új projektek, végigmentünk miből is áll egy projekt és le is futtattuk a programunkat ami annyit tett hogy kiírta egy üres ablakba hogy a programunk hány FPS-el fut. Ügye ezt a programot nem mi írtuk, ez csak egy alap program ami minden új elkészített projektel jön, ezért ezen a ponton még nem biztos hogy teljes egészében átlátjuk hogyan is működik a programunk és hogyan épül fel.
Habár AGK esetében, túl sok magyarázatot nem kíván, mégis jobbnak láttam egy külön leckében bemutatni a program felépítését.
Ha megnyitjuk az AGK-t akkor a legutóbb használt projektünk kell megnyissa automatikusan. Amennyiben ez nem így történne, először is zárjuk be a projektet ha megnyitott volna valamit és hogy megnyissuk az előző leckében használt projektet, a bal felső sarokban válasszuk a File menüpontot, majd az Open Project opciót válasszuk.
Keressük meg a legutóbb használt projekt könyvtárát, lépjünk be majd nyissuk meg az .agk projekt fájlt. Miután megnyitottuk a projekt fájlt a jobb oldalon máris látnunk kell a main.agc vagyis a fő forrásfájlunk tartalmát. Ha ez nem így lenne, csak kattinsunk duplán a main.agc fájlra a bal oldalon.
Ezen a ponton, csak egy alap programunk van.
// Project: snake
// Created: 2016-05-13
// set window properties
SetWindowTitle( "snake" )
SetWindowSize( 1024, 768, 0 )
// set display properties
SetVirtualResolution( 1024, 768 )
SetOrientationAllowed( 1, 1, 1, 1 )
do
Print( ScreenFPS() )
Sync()
loop
Az oldalon látható kód színeivel ne foglalkozzunk, helyenként félrevezető is lehet. Sajnos a kód kiemelő amit használok, nem ismeri az AGK Tier 1 kódját.
Mielőtt kitérnék arra mi is történik a programban, mit is csinálnak ezek a parancsok, először beszéljünk arról hogyan is működik egy program.Egy program gyakorlatilag csak utasításokból áll. Alapértelmezettként egy AGK program 60FPS az-az 60 Frame per másodperc sebességgel fut, ami azt jelenti hogy az utasítások 60 alkalommal futnak le egyetlen másodperc alatt. Ám nem minden utasítás. Rajtunk áll hogy melyik utasítás hányszor fut le.
Hogy ezt kifejtsem bővebben, térjünk rá hogyan is épül fel egy program. AGK esetében ez rendkívül egyszerű. Ha megnézzük a programunkat, láthatunk 2 darab utasítást. do és loop. Ez egy végtelen ciklus. A programunkban bármi is kerül ebbe a ciklusba, a 2 utasítás közé, az 60 alkalommal fut le minden egyes másodpercben újra és újra mind addig még a programunk fut vagy más utasítást nem kap, de erről majd később. Egyenlőre csak ezt jegyezzük meg hogy minden utasítás ami a do és loop között van, az folyamatosan fut.
A programunk az utasításokat fentről lefele haladva hajtja végre, egyiket a másik után sorról-sorra mind addig még eléri a do-loop ciklust. Ezen a ponton a programunk belép a ciklusba és csak a cikluson belül található utasításokat fogja végrehajtani újra és újra. Így értelem szerűen minden utasítás ami a do-loop ELŐTT helyezkedik el az csak és kizárólag a programunk elején, egyetlen egy alkalommal fut le és bármi ami a do-loop UTÁN helyezkedik el az soha nem fog lefutni ha csak erre utasítást nem adunk mi magunk.
Nos, lássuk parancsokat, pontosan mi is történik.
// Project: snake // Created: 2016-05-13 // set window properties
Ezek a sorok nem utasítások, csak megjegyzések. Megjegyzéseket használva információt közölhetünk a programunkról és hogy a programunk mely része pontosan mit csinál. Ez talán nem tűnhet fontosnak, ám több ezer soros programok esetén, nagyon is fontos emlékeztetni magunkat mit hol csináltunk illetve hol mit csináltunk. Hónapok múltán garantálom hogy nem fogunk rá emlékezni mire is szolgál az a pár sor kód amit 4 hónappal ezelőtt írtuk a 8652. sorba.
Ám megjegyzések nem csak azért fontosak hogy magunkat emlékeztessük hanem sokkal inkább hogy segítsünk azoknak akik netalán a mi kódunkat fogják használni. Soha nem tudhatjuk mikor fogják mások is látni és használni a kódunkat, ám megjegyzések nélkül valószínű hogy mindenki csak az arcunkhoz dobná a kódunkat néhány keresetlen szó kíséretében mivel nem fogja senki tanulmányozni hol mit csináltunk és hogyan is működik a kódunk. Szóval megjegyzések használata nem lehetőség hanem követelmény és a használatuk erősen ajánlott a legelső sor kódtól kezdve bármennyire is egyszerű és magától érthető legyen amit csinálunk.
Egysoros megjegyzéseket // jelellel kezdünk, több soros megjegyzéseket pedig a /* jellel kezdünk és a */ jellel fejezünk be.
// egysoros emlékeztető
/*
ez egy több soros emlékeztető
They are imposing the facts some times in so much of unrefined and distorted style with lots of attractive packages that the innocent people hardly get identifies that what is secretworldchronicle.com cheap viagra no rx? levitra is a drug that is newly discovered and has the main ingredient called as Tadalafil This drug will help in the stopping of the PDE5 and will make the tablet inefficient. However, pills viagra canada these effects last for a short time. Even though the physical & touching strains of cardiovascular illness frequently discount cialis take a levy on a couple s cherished deeds, well, there have been found a wide reason to persist. Male impotence perhaps order levitra on line is the constant incapability to aid oneself sustains a stiffer erection with concerning to sexual process. ami addig tart még le nem zárjuk
*/
Az első utasítás a programunkban:
SetWindowTitle( "snake" )
Ügye angolul némileg tudók itt előnyben vannak mivel minden parancs gyakorlatilag egy értelmes angol kifejezés ami sokak sejtet az adott parancs funkciójáról. Ez az utasítás csak annyit tesz hogy beállítja az ablak tetején olvasható címet (title) amit akkor látunk amikor a programunk ablakban fut. A címet amit kiszeretnénk íratni a zárójeleken belül, ” “ jelek közé kell helyezni.
Ha a programozás új lenne számunkra, ez egy általános dolog hogy minden parancs illetve utasítás ( ) jellel végződik, és ha be lehet bármilyen értéket vinni az utasításnak, azt a ( ) jelek közé kell írni. Számok esetében csak a számot, szöveg esetében ” “ jeleket használni.
parancs("szöveges érték")
parancs(1234)
Na de mielőtt túlságosan belebonyolódnánk ebbe így az elején, hagyjuk is ennyiben, egyenlőre csak azzal foglalkozzunk hogy a SetWindowTitle(“snake”) parancs, az ablak tetején látható címet állítja be hogy azt írja ki hogy snake.
A következő parancs.
SetWindowSize( 1024, 768, 0 )
Ezzel az utasítással beállíthatjuk a programunk képernyő méretét és hogy a programunk ablakban fusson-e vagy teljes képernyőn. Ahogy láthatjuk ebben az esetben, 3 paramétert adhatunk meg amiket vesszővel választunk el. Az megint csak általános a programozásban hogy egy utasítás akár több paramétert is fogadhat és hogy több paraméter esetén, el kell választani egymástól azokat. Az AGK-ben egy vesszővel tehetjük ezt meg. Az első paraméter 1024 a képernyő szélessége, a második paraméter 768 a képernyő magassága, a harmadik paraméter pedig hogy a programunk ablakban vagy teljes képernyőn fusson-e. Ha 0-át írunk akkor ablakban fut, ha 1-est akkor teljes képernyőn. Jelenleg az érték 0 szóval ablakban fut a programunk.
SetVirtualResolution( 1024, 768 )
Ez az utasítás beállítja a programunk képernyőjének felbontását. Csak azért mert az ablak 1024×768 méretű még nem jelenti azt hogy a felbontás nem lehet kisebb vagy nagyobb. Ebben az esetben a felbontás pontosan akkora mint a képernyő méret, ám gyakorlatilag akkorára állíthatjuk amekkorára szeretnénk.
SetOrientationAllowed( 1, 1, 1, 1 )
Ez az utasítás főleg hordozható eszközöknél hasznos mint mobilok és táblagépek. Ezzel az utasítással beállíthatjuk hogy a programunk képernyője alkalmazkodjon-e az eszköz orientációjához ha elforgatják az eszközt. Ügye egy eszközt gyakorlatilag 2 irányba lehet elfordítani. portré és tájkép ám mind a 2 állhat lefele és felfele is. szóval ez összesen 4 lehetséges orientáció ha körbeforgatjuk az eszközt. Az utasításban mind a 4-re engedély adhatunk külön-külön: portré, porté2, tájkép, tájkép2. Ha 1-est írunk azzal engedélyezzük, ha 0-át akkor nem.
Végül elérkeztünk a korábban már említett do-loop ciklushoz.
do
Print( ScreenFPS() )
Sync()
loop
Emlékezzünk, minden egyes utasítás amiről a do-loop előtt szó esett csak egyszer fut le amikor elindítjuk a programot és azok futnak le először mivel a program fentről halad lefele. Szóval a programunk amikor elindul, először beállítja az ablak címét, méretét, felbontását és hogy a képernyő orientációja alkalmazkodjon-e. Majd eléri a do-loop ciklust és ekkor belép a ciklusba ami egy végtelen ciklus és természeténél fogva soha nem áll meg. A ciklusban minden folyamatosan és ismétlődően fut.
Lássuk pontosan milyen utasítások is ismétlődnek a ciklusban.
Print( ScreenFPS() )
Ez az utasítás gondoskodik arról hogy kiírja a képernyőre a programunk sebességét (FPS). Ahogy láthatjuk ez gyakorlatilag 2 utasításból áll. Az egyik a Print() ami kiír bármit amit a zárójelek közé kerül. Ha például kiszeretnénk íratni hogy Hello, csak annyit kell tennünk hogy
Print("Hello")
A második utasítás a zárójel között a ScreenFPS() ami kiszámítja és vissza adja a programunk aktuális sebességet amit a Print() utasítás felhasznál és kiírja azt a képernyőre. A Print( ScreenFPS() ) egy egyszerű példa rá hogy miként tudunk különböző utasításokat kombinálni hogy elérjük a célunkat.
Sync()
Ez egy speciális utasítás, ami frissíti a programunk képernyőjét. Megkísérlem elmagyarázni.
Leegyszerűsítve a programunk a motorháztető alatt gyakorlatilag 2 rétegből áll. Az első buffer-ből és a hátsó buffer-ből. A képernyőn amit látunk az mindég az ami az első buffer-ben van. Amikor lefut egy utasítás, mind például a Print() az elvégzi a szükséges számításokat, műveletek és az eredményt ez esetben a képernyőt szöveggel, elmenti a hátsó buffer-ben amit csak akkor fogunk látni ha az eredményeket előre hozzuk a hátsóból az elsőbe amit a Sync() utasítással tehetünk meg és meg is kell tennünk máskülönben nem fogjuk látni a programozásunk eredményét.
Most gondolom felmerül a kérdés, oké szóval miért nem hozza előre automatikusan ha úgy is előre kell hozni? Azért mert adódhatnak helyzetek amikor szeretnénk apró módosításokat végrehajtani az adatokban mielőtt az a képernyőre kerül vagy csak magunk szeretnénk szabályozni, mikor mi kerül a képernyőre. Az esetek többségében ez miatt nem kell aggódnunk, mindent és mindég látni akarunk és ennek érdekében mindég a Sync() utasítás legyen az utolsó a do-loop ciklusban.
Amikor a programunk eléri a loop parancsot az-az a ciklus végét, a ciklus újra indul és ismétlődik újra és újra és újra.
Ha netalán felmerülne a kérdés hogy miért is kell a Print() parancsnak a do-loop ciklusban lenni, ennek az-az oka hogy minden alkalommal amikor frissítünk és előrehozzuk az első buffer-be ami a hátsóban van, ami addig az első buffer-ben volt az törlődik ami pedig a hátsóban volt, átkerül az elsőbe. Szóval ha a Print() parancsot csak egyszer futtatnánk le, az csak egyetlen egyszer kerülne ki a képernyőre és olyan rövid időre hogy valószínűleg észre sem vennénk mivel a programunk 60 alkalommal fut le egyetlen másodperc alatt és ez azt jelenti hogy az első és a hátsó buffer 60 alkalommal cserél információt másodpercenként. Szóval ha a Print() parancs egyetlen alkalommal fut le a 60-ból, akkor a szöveg is csak egyetlen alkalomra kerül ki a képernyőre mivel a következő alkalommal a parancs már nem fut le és a szöveg nem kerül be a hátsó buffer-be és így a képernyőre sem.
Nos, a programok felépítésével ezzel végeztünk is.
Talán így elsőre ez túl sok információ, de ha bármi homályos lenne, garantálom ahogy haladunk majd lépésről-lépésre előre, idővel kitisztul minden.
A következő leckében a változókról fogunk beszélni.
