játékfejlesztés.hu
FórumGarázsprojectekCikkekSegédletekJf.hu versenyekKapcsolatokEgyebek
Legaktívabb fórumozók:
Asylum:    5448
FZoli:    4892
Kuz:    4455
gaborlabor:    4449
kicsy:    4304
TPG:    3402
monostoria:    3284
DMG:    3172
HomeGnome:    2919
Matzi:    2520

Pretender:    2498
szeki:    2440
Seeting:    2306
Geri:    2188
Orphy:    1893
Joga:    1791
Bacce:    1783
MaNiAc:    1735
ddbwo:    1625
syam:    1491
(DB) DarkBASIC gyorstalpaló 2006.04.29 15:21


Előszó


Ez a cikk a Játékfejlesztés Dark Basic nyelven - 1. rész c. cikkem rövidített, átszerkesztett változata. Cél a gyors bemutatás: a tematika megegyezik, viszont kevesebb részletre tér ki, kevesebb a példa. Azoknak készült, akinek nincs idejük végigolvasni az eredeti cikket (illetve elrettentő hosszúságúnak találják), vagy csak a lényegre kíváncsiak, gyors megoldásokra egy program írása közben. Igyekszem az egyszerűséget szem előtt tartani, mindenesetre ajánlom a két cikk együttes használatát: Ha nem világos valami a rövidített változatban vagy nem találsz egy problémára megoldást, nyugodtan lapozd fel a hosszabb változatot. A fejezetek végén kiírtam a hosszú változat melyik része foglalkozik a témával. Remélem hasznos segítséget nyújt ez a cikk, jó olvasást!

Mi a DarkBASIC?


A DarkBASIC (röviden: DB) egy játékírásra kifejlesztett programnyelv. Mivel programnyelv, lényegesen több lehetőséget ad mint egy játékkészítő (gamemaker) program. Cserében tudni kell programozni, de ettől sem kell megijedni: a Basic nyelvek a legegyszerűbb programnyelvek, a Dark Basic meg rengeteg speciális paranccsal rendelkezik, ami megkönnyíti a 2D-s és 3D-s játékok írását!

Nézzük csak mit is tud:

- 3D objektumok, fények, hangok és terepek kezelése
- 2D objektum (sprite) kezelés (bmp, jpg)
- wav, midi, mp3, avi lejátszás
- multiplayer támogatás
- meg még sok minden

A Dark Basicnek két változata van:

Dark Basic 1.x - A "sima" DB, 2000-ben jelent meg. DBC-nek (DarkBASIC Classic) szokták rövidíteni, itt DB-nek nevezzük. Magyar nyelvű változata is létezik. DirectX 7 kell a benne készült programokhoz. Az utolsó verziója az 1.13, már nem fejlesztik tovább.

Dark Basic Pro - Ő a DBPro, 2002-ben jelent meg. Teljesen új kódszerkesztő, több mint 100 új parancs, új 3D motor (sokkal nagyobb sebesség 3D-ben és 2D-ben is). DirectX 9 (régebbi verzióknál Dx8) kell a benne készült programokhoz. Jelenlegi legfrissebb verziója az 1.06. Magyar változata nincs.

A DBPro visszafelé kompatibilis, futtatja a DB-ben írt programokat, de általában kell módosítani előtte rajtuk, hogy hibátlanul fussanak. Az itt található programok esetében általában ugyanúgy futnak mindkét változaton, ahol van eltérés ott jelzem.

Részletesebben a hosszú változat előszavában.

Megírjuk első programunkat


Elsőként megismerkedünk a Print paranccsal, amivel szöveget tudunk kiírni. Gépeljük be első programunkat!
Kód:
print "Szia!"
wait key

Futtassuk az F5 gomb megnyomásával! Az eredmény:

Szia!

Mit is csinál ez a program?
- A print parancs kiírja a macskakörmök közé tett szöveget. (Macskakörmöket csak szövegkiírásnál kell használni, ez a BASIC nyelvek általános jellemzője.)
- A wait key parancs billentyűlenyomásra vár. DB-t használók elhagyhatják, DBPro-nál kell mert csak egy felvillanó ablakot látnánk nélküle. További fejezetekben a WAIT KEY kiírását elhagyom.

A print parancs általános alakja:
print [kifejezés]
A kifejezés a példánkban szöveg volt, de más is lehet.
Kiírathatunk számot:
print 7
Műveletet:
print 7+7 - az eredményt látjuk csak, ami 14
Szöveget és számot egyszerre:
print "Egy: ";1 - figyeljük meg a két adat között pontosvessző áll

Printünkkel önmagában nem tudunk sok mindent kezdeni, ismerkedjünk meg a változókkal! gépeljük be az alábbi programot:
Kód:
a=3*3
print a
wait key

Ezt a programot futtatva 9-et kapunk eredményként. Hogyan is működik?
1. sor: Az 'a' nevű "memóriarekesz" (változó) felveszi a 3*3-as értéket - amit 9-ként tárol el, de ezt mi nem látjuk!
2. sor: kiírja az "a" változó értékét, így láthatóvá válik a végeredmény!

A változókat képzeljük el úgy, hogy a memória egy bizonyos "része" nevet kap (a példában "a"), és itt a programunk adatokat tárolhat. Ha az "a" változónak új értéket adunk, a régi érték elveszik. A változók nevében csak az angol ABC betűi és számok lehetnek, valamint típusjelző karakterek (lásd lentebb).

Értékadás a változóknak a következőképpen néz ki:
változó=érték
Ha matematikailag nézzük, az x=250 és a 250=x ugyanaz, de a DB-nek az utóbbi forma értelmetlen.

Hogy milyen adatokkal dolgozik egy változó (milyen típusú) azt jelölni kell a nevében. A Dark Basic alapvetően 3 adat és változótípust különböztet meg:
1, egész számok: nincs típusjel, alapértelmezett
2, valós számok (tizedestörtek): # a típusjel
3, szövegek (string): $ a típusjel

A típusokra vonatkozó szabályok:
- A típusjel mindig a változónév után áll, pl. valtozo# vagy valtozo$.
- Megegyező nevű, de eltérő típusjelű változók külön változónak számítanak. Ugyanabban a programban előfordulhatnak a v, v# és v$ változók különböző értékekkel.

A változók alkalmasak műveletek végzésére, a matematikából megszokott módon. Műveletek és jeleik:
+ : összeadás
- : kivonás
* : szorzás
/ : osztás (Érdemes osztásoknál valós változókat használni, különben pontatlan lesz az eredmény.)
^ : hatványozás (gyökvonást felírhatjuk ^0.5-ként)

A következő programban két változó szorzatát egy harmadikba rakjuk, amit kiírunk:
Kód:
a=25 : b=10
szorzat=a*b
print "A szorzat: "; szorzat
wait key

Végül ismerkedjünk meg az input paranccsal! Az input bekér egy adatot a billentyűzetről amit változóba rak. Írjunk egy olyan programot, ami kiszámolja egy kör területét! Ehhez először be kell kérni egy adatot, a kör sugarát.
Kód:
input "Add meg, mekkora a kör sugara, majd nyomj Entert! ",sugar
print "A kör területe: ",sugar^2*3.14
wait key

Az INPUT parancs általános alakja:
INPUT "szöveg",valtozo
A szöveg kiíródik, a változóba pedig bekerülnek a bekért adatok, így a program futása közben vesz fel értéket.

A fejezet végére még egy apró, de fontos megjegyzés: több parancsot is írhatunk egy sorba ha közéjük kettőspontot teszünk.

Részletesebben a hosszú változat alábbi fejezeteiben:
2. A PRINT parancs
3. Változók használata

Elágazások


Eddigi programjainkban sorban egymás után hajtódtak végre a parancsok. Sokszor előfordul hogy a programnak döntést kell hoznia, és ettől függően mást kell csinálnia. Az elágazásokkal megadhatjuk, hogy mikor melyik parancsok fussanak le.

Nézzünk egy példát! A program bekér egy számot, és eldönti hogy negatív vagy pozitív.
Kód:
input "Írj be egy számot! ",szam
if szam=0 then print "A szám 0"
if szam<0 then print "A szám negatív"
if szam>0 then print "A szám pozitív"

Az elágazásokat az if és then parancsokkal oldjuk meg. Közöttük a feltétel található: valami összehasonlítása valamivel. Ha az igaz (fennáll a feltétel), akkor végrehajtódik a then utáni sor. Ha nem, a DB a következő sort fogja olvasni. Általános alakjuk:

IF feltétel igaz THEN parancs(ok)

Ha több parancsot szeretnénk a THEN után írni:

1, Kettősponttal egy sorba zsúfoljuk őket
2, Endifet használunk, ekkor a THEN-t el kell hagyni:

if feltétel igaz
parancs1
parancs2
...
endif

Az ENDIF az elágazás végét jelöli.
Opcionális az ELSE használata. Ha a feltétel nem teljesül akkor az a parancs(sorozat) hajtódik végre ami az else után áll:
Kód:
input a
if a=0 then print "Nulla" else print "Nem nulla"
wait key

Most vizsgáljuk meg közelebbről a feltételt! A feltételben valami összehasonlításnak kell állnia. Lehet változót értékkel és másik változóval összehasonlítani:

if változó=9 then ...
if szoveg$="Szia!" then ...
if valtozo1=valtozo2 then ...

A két összehasonlítandó adat között relációs jeleket használhatunk:
(a relációs jeleket nem szükséges szóközökkel elválasztani az értékektől)
Kód:
a = b : a és b egyenlő
a < b : a kisebb mint b
a > b : a nagyobb mint b
a <= b : a kisebb mint b vagy egyenlő b-vel
a >= b : a nagyobb mint b vagy egyenlő b-vel
a <> b : a és b nem egyenlő


Több feltételt is alkalmazhatunk:
if (feltétel1) logikai_operátor (feltétel2) then parancsok
A logikai operátor lehet OR vagy AND. OR esetén akkor hajtódnak végre a then utáni parancsok, ha legalább az egyik feltétel igaz. AND esetén akkor, ha az összes feltétel igaz.

Példa:

Kód:
input a
if (a<10) and (a>0) then print "A szám 0 és 10 között van"


Ennyit az elágazásokról.
Részletesebben a hosszú változat alábbi fejezetében:
4. Elágazások


Ciklusok



A ciklusok olyan programrészek amik közé írt parancsok ismétlődnek. Megkülömböztetünk számlálós és végtelen ciklusokat.

Elsőként nézzük a számlálós ciklust, a FOR ciklust!

Írjunk programot, ami kiírja 20-ig a számokat! Ehhez 20 print sor kellene, de megoldhatjuk rövidebben:
Kód:
for c=1 to 20
      print c
next c

1. sor: a ciklus eleje. Beállítjuk, hogy a ciklusváltozó, a 'c' 1-től 20-ig nőjön. A ciklusváltozó (c) értéke eggyel nő.
2. sor: kiírjuk a c értékét
3. sor: a ciklus vége. A program futása a ciklus elejétől folytatódik mindaddig, amíg a "c" nem lesz 20

A ciklus közepét ciklusmagnak nevezzük, ez a for...to sorban beállított értékek szerint ismétlődik. A ciklusnak van egy ciklusváltozója (itt a "c"), aminek az értéke nő/csökken amíg el nem érí a kívánt értéket. A ciklusváltozót természetesen változtathatjuk a cikluson belül. A ciklus formája:

FOR ciklusváltozó=kezdőérték TO végérték STEP lépésköz
... (ciklusmag parancsai) ...
NEXT ciklusváltozó

A végtelen ciklusok (Do-Loop ciklusok) esetén a ciklusmag végtelenszer ismétlődik.
Kód:
do
      print "Szia"
loop

Mivel itt nincs ciklusváltozó, erről magunknak kell gondoskodnunk. A DB nem ismeri a DO-LOOP-nál a kilépési feltételeket, (mint UNTIL és WHILE parancsok a többi Basic nyelvjárásban) ezért erről is nekünk kell gondoskodnunk. A lenti példában egy számlálóssá alakított végtelen ciklus látható:
Kód:
do
      a=a+1
      print a
      if a=20 then end
loop

Ebben a programban az end számít újdonságnak, ami egy alap, minden basicben megtalálható parancs: leállítja a program futását.

Részletesebben a hosszú változat alábbi fejezeteiben:
5. Számlálós ciklusok
6. Végtelen ciklusok

Ugrások oda-vissza


A GOTO paranccsal ugrásokat végezhetünk a programunkban: utasíthatjuk a parancsértelmezőt, hogy folytassa máshol a programot - minden feltétel nélkül. A GOTO önmagában nem működik, kell egy címke, ami mutatja hol kell folytatnia a végrehajtást a parancsértelmezőnek. A címke egy speciális azonosító, az külömbözteti meg a változótól hogy kettőspont áll a végén. Nézzünk egy példát:
Kód:
print "Ez kiíródik, de most ugrunk!"
goto tovabb
print "Ez nem íródik ki mert a tovább címkére ugrottunk"
tovabb:
print "Ez is kiíródik"
wait key

Jól látható a címke használata. A címke sorában nem lehet parancs: egyedül kell állnia a sor elején.
Van egy jóval okosabb ugrás, a GOSUB, ami megjegyzi honnan ugrott el és ha RETURN paranccsal találkozik, visszatér oda. Ugyanúgy kell neki egy címke mint a GOTO-nak. Régi BASIC-ekben ezt a szerkezetet használták alprogramok írására (következő fejezet). Nézzünk rá egy gyors példát:
Kód:
a=8 : b=6
gosub szamol
a=10 : b=20
gosub szamol
a=4 : b=24
gosub szamol
end

szamol:
print "A érték:";a;" B érték:";b
print "Összeg:";a+b
print "Különbség:";a-b
return

A programban a szamol eljárás többször, több helyről is meghívható, így rövidebb és átláthatóbb.

Részletesebben a hosszú változat alábbi fejezeteiben:
7. A GOTO parancs
8. A GOSUB alprogram

Függvények és alprogramok


Hogy mik és mik?
Alprogram egy olyan programrész, ami többször végrehajtódik. Sokszor előfordul, hogy egy programrészre a program több pontján van szükség. Ilyenkor egy alprogramban megírjuk, majd a program több részéről "meghívjuk" (=futtatjuk). Olyasmi mit egy GOSUB szerkezet, csak önállóbb. Úgy használhatjuk, mint akármelyik DB parancsot! A függvénynek a programozásban olyan parancsot nevezünk, ami visszaad egy értéket. Pl.: a valtozo=SIN(szog) a szog változó szinuszát rakja egy másik változóba. (de nem feltétlen matematikai dolog egy függvény!) Ez egy DB-be beépített "gyári" függvény, nem írok róluk mert a súgóban dokumentálva van mind. Itt azt nézzük hogyan tudunk saját függvényt készíteni.

Egy alprogram így néz ki (általános alak):

Function név
....(parancsok)...
endfunction


Például:
Kód:
function udvozol()
print "Szia!"
wait key
endfunction

Így magában semmit sem ér, meg kell valahonnan hívni. Írjuk meg elé a főprogramot:
Kód:
udvozol()
end

A két üres zárójel a híváskor DBPro-ban kötelező, sima DB-ben elhagyható.
És hogy néz ki egy függvény? Annyiban más hogy egy értéket ad vissza:

Function név
....(parancsok)...
endfunction visszatérési_érték


Példa:
Kód:
visszatero$=beker()
print visszatero$
wait key
end

function beker
input "Írd ide a szöveget!",szoveg$
endfunction szoveg$

A szöveg bekérése függvényben történik meg, ami visszaadja a szoveg$ változót - a főprogramban ennek az értékét a visszatero$-be töltjük, és kiírjuk. Írhattam volna egy sorba a kiírást (print beker()) de így szemléletesebb.

A zárójelek eddig üresek voltak ha voltak - ide paramétereket rakhatunk amit átadunk az alprogramnak/függvénynek. A beker függvényt módosítjuk úgy, hogy megadjuk mit írjon ki. Sok értelme nem lesz, de példának megfelel:
Kód:
visszatero$=beker("Írd ide a szöveget")
print visszatero$
wait key
end

function beker(parameter$)
input parameter$,szoveg$
endfunction szoveg$

Több paraméter is megadható, vesszőkkel elválasztva. És hogy miért kell így oda-vissza küldözgetni az értékeket? Az alprogramunk változói külön életet élnek, el vannak zárva! Ha egy alprogramban az a változónak 100-as értéket adunk, a főprogramban kiíratjuk 0 íródik ki, mert a főprogram nem látja az alprogramban létrehozott változót. Keresi a sajátját, de nincs olyan. Ezért létrehoz egyet, aminek 0 lesz a kezdőértéke. Azt írja ki. Van egy fontos külömbség a DB és a DBPro között e téren: a DB megőrzi az alprogramjai változóinak értékét, a DBPro törli az összeset amikor kilépünk belőle.

Az alprogramok és függvények a leghasznosabb elemei a nyelvnek. Saját parancsokat alkothatunk velük, modulokra bonthatjuk szét a programot így átláthatóbb lesz, és a hibakeresés is egyszerűbb. DBPro-ban összecsukhatók egy kattintással így nem zavar az a programrész amin nem dolgozunk éppen.

Részletesebben a hosszú változat alábbi fejezetében:
9. A FUNCTION alprogram

Összetett változók: a tömbök


Gyakran elő fog fordulni, hogy programunknak sok adattal kell dolgoznia. Ezt a sok adatot tárolni kell valahol. Mindhez külön változónév kellene, és szerintem senki se kezdene 1000 változó értékét pl. egyenként megnövelni. Sok adat együttes kezelésére találták ki a tömböket. Míg az egyszerű változókat nem kell deklarálni (megadni a típusukat a parancsértelmezőnek a program elején), addig a tömböket kell. Ezt a DIM paranccsal végezhetjük el.
Kód:
dim szamok(10)

Egy ilyen tömbben 11 adatot tárolhatuk el (csak olyan típusút, mint a tömbé!), tehát 11 elemű. Ez a 11 változó a következő: szamok(0), szamok(1), szamok(2) ... szamok(9), szamok(10). Ezeket úgy használhatjuk, mint normál változókat. A tömb indexébe akár változót is írhatunk: szamok(i)=1

Többdimenziós is lehet egy tömb (maximum 5):
dim szamok(10,10) - kétdimenziós
dim szamok(10,10,10) - háromdimenziós

A tömbök használatához nézzünk egy példát! Egy tömbbe berakjuk a számokat 10-től 20-ig, majd kiírjuk őket!
Kód:
dim tomb(10)
for i=0 to 10
   tomb(i)=i+10
   print tomb(i)
next i
wait key

Részletesebben a hosszú változat alábbi fejezetében:
10. Összetett változók: a tömbök

Még többet a típusokról


A változók ismertetésénél 3 típusról volt szó: az egész és valós számokról és a szövegekről. A DBPro több dolgot ismer, sőt, a saját típusok létrehozásával kényelmesen saját adatszerkezetet hozhatunk létre, jelentősen egyszerűsödik így az adatok kezelése. Ez a fejezet csak a DBPro-ról fog szólni, a sima DB az itt leírtakat nem tudja.

A DBpro-ban lehetőségünk van deklarálni, azaz saját kezűleg létrehozni a változókat, és így elhagyni a típusjeleket. A deklarálást az AS paranccsal végezhetjük. Használata:

változónév AS típus

A következő típusok léteznek:
1, byte: szám 0-255 között
2, word: 2 bájt, 0 és 65535 között.
3, dword: Duplaszó, 4 bájt, 0 és 4 294 967 295 között
4, integer: ugyanennyi számot ismer, csak a fele mínuszban van: - 2 147 483 647 és + 2 147 483 647 között
5, double integer: 8 bájtos
6, float: A jól ismert # jelű lebegőpontos valós számunk
7, double float: A float nagytestvére.
8, string: A szokásos szöveg.
9, boolean: logikai változó, de gyakorlatilag a byte-tal egyezik meg.

Változót deklarálhatunk simán, pl:
valtozo as byte
vagy akár függvény elején:
Function blabla(x as word,y as word)
De a leghasznosabbak akkor amikor saját típust hozunk létre.

Igazán újakat nem tudunk csinálni, de a meglévőket tudjuk kombinálni, ami nagyon hasznos dolog. Új típust a TYPE...END TYPE szerkezettel lehet létrehozni:
TYPE típusnév
változó1
változó2
...
ENDTYPE

ha ugyanolyan típusú változók vannak, akkor elég csak a nevüket leírni minden típus nélkül. Akár többet is egy sorba:
Kód:
TYPE blabla
      x : y : z : allapot
ENDTYPE

De lehet így is:
Kód:
TYPE koord
      x as float
      y as float
      z as float
ENDTYPE

Ha kész a típus, deklarálni kell egy változót ami adott típusú. A fenti példánál maradva:

hely as koord
vagy akár tömböt is készíthetünk:
dim helyek(10) as koord

A hely változónak 3 "alváltozója" (adattag) lesz amire külön tudunk hivatkozni úgy, hogy a változónév és az adattag közé pontot írunk:
Kód:
hely.x=1
b=hely.y
hely.z=hely.z+1

Úgy használhatjuk őket, mintha 3 külön változó lenne. Egy sor példa a használatukra (figyeljük meg a tömbindex a pont elé kerül):
Kód:
ellenseg(i).eletero=ellenseg(i).eletero-lovedek.sebzes

Jól megválasztott típusokkal és tömbnevekkel beszédes lesz a programunk.

Részletesebben a hosszú változat alábbi fejezetében:
12. Újdonságok a DBPro-ban

Értékelés: 8.00

Új hozzászólás
Marclee          2009.04.19 09:31
Hát én ezt nem nevezném "gyors" talpalóünak De nekem például (kezdő játékkészítő vagyok) Nagyon sokat segített, így legalább meg tudok oldani sokkal egyszerűben nem is egy dolgot a játékaimban Szerintem a kezdőknek ezen a weboldalon minden megtalálható. Remélem még sokáig lesz ez az oldal és j hasznos cikk lesz fent. Bár amint látom ez egy kicsit régi cikk.Csak én vagoyk lemaradva??
paragliding          2008.11.08 02:55
Nem ismertem a programnyelvet eddig, vagyis még sosem láttam DB-s programkódot, de most látván nekem a C64-es BASIC nyelvet idézi, ami tök jó, mert akkor "tudok" DB-ben játékot írni Csak egy kis ismeretfelújításra van szükségem. Ez tetszik
bloodknife          2006.05.04 11:05
Maradok C++ nál... Többiek meg nyugodtan Db-t használjanak.
VT          2006.05.03 01:38
bloodknife nem láttál még db-t
kapsz egy ablakot hogy gépeld be a kódot
semmi click&play
Seeting          2006.05.02 10:18
Hát azért nem mondanám a Dark basic-re hogy szinte KnP...
bloodknife          2006.05.02 07:46
szinte click&play....
Seeting          2006.05.01 08:45
Mit értesz gamemakeres-en?
bloodknife          2006.05.01 08:35
takraj
Szerintem akinek nincs ideje végigolvasni a teljeset az nenagyon fogjon bele a játékfejlesztésbe...

szerintem meg aki nem olvassa végig az nem gamemakeres...
szeki          2006.04.30 05:55
Érdekes, bár én elvből nem kezdenék DB-el. Ha kezdenék akkor C-vel, de inkább maradok modellezésnél, meg zeneírásnál. Ígyis túl sok a dolgom...
takraj          2006.04.30 02:51
Szerintem akinek nincs ideje végigolvasni a teljeset az nenagyon fogjon bele a játékfejlesztésbe...
VT          2006.04.29 15:31
Előre megjegyzem ezzel a cikkel nem indulok a cikkíró pályázaton.