Hogyan programozzunk játékokat a C. 1. bemutató

Ez az első a számos játékból, amely a C kezdő oktatóprogramjait programozza. Ahelyett, hogy a C oktatásra összpontosítana, majd példákat mutatna a programokra, megtanítják a C-t azáltal, hogy teljes programokat (azaz játékokat) nyújtanak Önnek C-ben

A sorozat első játékja egy konzol (azaz a Star Empires nevű szöveg alapú játék). A Star Empires egy egyszerű játék, ahol el kell ragadnia mind a 10 rendszert a Galaxisban, miközben megállítja az AI ellenfeled ugyanezt.

Elkezdi a 0-os rendszer birtoklását, míg az ellenség saját 9-es rendszere. A fennmaradó nyolc rendszer (1-8) semlegesen indul. Minden rendszer 5 5 x 4 x 4 cm-es négyzetből indul, tehát egyetlen rendszer sem haladhatja meg a 6 parset. A legtávolabbi két pont a (0,0) és (4,4). Pythagoras tétel szerint bármelyik rendszertől a legtávolabbi távolság a négyzetgyök (4)² + (4)²), amely a 32 négyzetgyöke, amely körülbelül 5.657.

Felhívjuk figyelmét, hogy ez nem a végleges változat, és módosulni fognak. Utolsó változtatás: 2011. augusztus 21.

A játék körön alapul, és minden egyes körben parancsot ad, hogy tetszőleges számú flottát költöztethet bármelyik rendszeréből a másik rendszerbe. Ha egynél több rendszer tulajdonosa van, akkor megrendelhet flottákat, hogy az összes rendszertől a célrendszerre mozogjon. Ezt arányosan kerekítve hajtják végre, tehát ha három rendszerünk (1,2,3) van, 20, 10 és 5 flottával és 10 flottát rendel el, hogy menjen a 4. rendszerbe, akkor a 6. az 1., 3., a 2. és az 1. rendszerből indul 3. Minden flotta fordulatonként 1 parsec-del mozog.

Minden fordulás 5 másodpercig tart, bár megváltoztathatja a sebességet, hogy felgyorsítsa vagy lelassítsa, ha ennek a kódsornak az 5-ét 3-ra vagy 7-re változtatja, vagy bármi, amit választ. Keresse meg a kód ezt a sorát:

onesec = óra () + (5 * CLOCKS_PER_SEC);

Ez a játék be van programozva, és feltételezi, hogy nem ismeri a C programozást. Bemutatom a C programozási funkciókat ebben és a következő két vagy három oktatóanyagban, ahogy fejlődnek. Először is szüksége lesz egy fordítóra a Windows rendszerhez. Itt van két ingyenes:

• Próbáld ki CC386
• Vagy Visual C ++ 2010 Express

A CC386 cikk bemutatja egy projekt létrehozását. Ha telepíti ezt a fordítót, akkor csak annyit kell tennie, hogy betölti a Hello World programot a leírtak szerint, másolja és illessze be a forráskódot a példára, mentse el, majd nyomja meg az F7 billentyűt, hogy összeállítsa és futtassa. Hasonlóképpen a Visual C ++ 2010 cikk létrehoz egy hello world programot. Írja felül, és nyomja meg az F7 billentyűt a Star Empires., F5 futtatásához.

A következő oldalon - A Csillagok Birodalmainak működése

Tárolnunk kell az információt a játék flottáin és rendszerein. A flotta egy vagy több hajó, amelyek parancsot kapnak az egyik rendszerről a másikra történő áthelyezésre. A csillagrendszer számos bolygó, de inkább absztrakt entitás ebben a játékban. A flotta számára a következő információkat kell tárolnunk.

• Eredeti rendszer (1-10).
• Célrendszer (1-10)
• Hány hajó (1-sok)
• Érkezésre fordul
• Kinek a flottája? 0 = játékos, 9 = ellenség

Ezt egy C szekcióban fogjuk használni:

A felépítés olyan adatgyűjtemény, ebben az esetben 5 szám, amelyet egyként kezelünk. Mindegyik számnak van egy neve, pl. Ezek a nevek változó nevek a C-ben, és aláhúzással lehetnek, mint a_e, de nem szóközök. C-ben a számok vagy egészek; egész számok, például 2 vagy 7, ezeket inteknek hívják, vagy tizedes részekkel rendelkező számok, például 2.5 vagy 7.3333, és ezeket úszóknak hívják. A Csillagbirodalmak egészében csak egyszer használunk úszót. Egy kóddarabban, amely kiszámítja a két hely közötti távolságot. Minden más szám egy int.

Tehát a flotta neve annak az adatszerkezetnek, amely öt int változót tartalmaz. Most ez egy flottának szól. Nem tudjuk, hány flottát kell tartanunk, így tömb segítségével nagyszerű helyet fogunk kiosztani 100-ra. Gondolj egy struktúrára úgy, mint egy vacsoraasztalra, ahol öt ember fér el (ints). A tömb olyan, mint egy hosszú sor ebédlőasztalokhoz. A 100 asztal azt jelenti, hogy 100 x 5 ember elfér.

Ha valóban azt a 100 vacsoraasztalot kiszolgálnánk, akkor tudnunk kellene, melyik asztal melyik volt, és számozással csináljuk. C-ben mindig a tömb elemeit számozzuk, 0-tól kezdve. Az első ebédlőasztal (flotta) 0, a következő 1 és az utolsó 99. Mindig emlékszem, hogy az elején hány vacsoraasztal van ez az asztal? Az első az elején van, tehát 0 mentén.

Így deklaráljuk a flottákat (azaz a vacsoraasztalunkat).

Olvassa el ezt balról jobbra. Az elválasztott flotta arra a szerkezetre utal, hogy egy flottát tartsunk fenn. A flotta név az a név, amelyet minden flottának megadunk, és [100] azt mondja, hogy 100 x struct flotta található a flotta változóban. Minden int 4 helyet foglal el a memóriában (bájtnak nevezik), tehát egy flotta 20 bájtot foglal el, 100 flotta pedig 2000 byte. Mindig jó ötlet tudni, hogy mennyi memória szükséges a programhoz az adatok tárolásához.

A sztrukturált flottában mindegyik inta egész számmal rendelkezik. Ezt a számot 4 bájt tárolja, és ennek tartománya -2 147 483 647 és 2 147 483 648 között lehet. Általában kisebb értékeket fogunk használni. Tíz rendszer létezik, így mind a rendszer, mind a tosisztéma 0 és 9 közötti értéket fog tartani.

A következő oldalon: Rendszerek és véletlen számok

A semleges rendszerek (1-8) mindegyike 15 hajóval kezdődik (egy számot, amelyet a levegőből vettem fel!), A másik kettőnek (a tiéd: a 0. rendszer és a számítógépes ellenfél a 9. rendszeren) mindegyiknek 50 hajója van. Minden fordulóban a hajók számát egy rendszernél 10% -kal növelik, kerekítve. Tehát egy fordulat után, ha nem mozgatja őket, az 50-ös 55-ös lesz, és a semleges rendszerek mindegyikének 16 lesz (15 + 1,5 lefelé kerekítve). Vegye figyelembe, hogy a másik rendszerbe költözött flották száma nem növekszik.

A hajók számának ilyen módon történő növelése kissé furcsanak tűnhet, de megtettem, hogy a játék tovább mozogjon. Ahelyett, hogy ezt az oktatóanyagot túl sokat fosztogatta volna a tervezési döntésekkel kapcsolatban, külön cikket írtam a Star Empires tervezési döntéseiről.

Kezdetben elő kell generálnunk az összes rendszert, és be kell állítanunk őket a térképre, legfeljebb egy rendszerrel minden helyszínen, mivel 25 hely van az 5 x 5 rácsunkon, tíz rendszerünk lesz és 15 üres helyszíneken. A GenMapSystems () függvénnyel állítjuk elő őket, amelyet a következő oldalon fogunk megnézni.

A rendszert egy struktúrában tárolják, a következő 4 mezővel, amelyek mind int.

A galaxist (mind a 10 rendszert) egy másik tömbben tároljuk, csakúgy, mint a flották esetében, kivéve tíz rendszerünk van.

Minden játéknak véletlen számokra van szüksége. A C beépített függvénye a rand () függvénynek, amely egy véletlenszerű int eredményt ad vissza. Ezt a tartományba kényszeríthetjük úgy, hogy átadjuk a maximális számot, és felhasználjuk a% operátort. (Modulus). Ez olyan, mint az óra aritmetikai, azzal a különbséggel, hogy 12 vagy 24 helyett egy max számú int számot adunk át.

Ez egy példa egy funkcióra, amely egy konténer belsejébe csomagolt kóddarab. Az első sor, amely kezdődik / * és befejeződik * /, egy megjegyzés. Azt mondja, mit csinál a kód, de azt a fordító figyelmen kívül hagyja, amely elolvassa a C utasításokat, és azokat olyan utasításokká alakítja át, amelyeket a számítógép megért, és nagyon gyorsan végrehajthat.

• Kíváncsi, mi a fordító? Olvas Mi az a fordító? (Cikk)

Egy függvény olyan, mint egy matematikai függvény, például Sin (x). Ennek a funkciónak három része van:

Az int megmondja, hogy milyen típusú számot ad vissza (általában int vagy float). A véletlen a függvény neve és (int max) azt mondja, hogy int számot adunk át. Használhatjuk így:

A vonal:

A következő oldalon: Véletlenszerű kezdőtérkép létrehozása

Az alábbi kód generálja a kezdőképet. Ez fent látható.

A Rendszerek generálása a játékos és az ellenfél rendszerek (0,0) és (4,4) pontjának hozzáadásával, majd véletlenszerűen 8 rendszer hozzáadásával a fennmaradó 23 üres helyre.

A kód három, a sor által definiált int változót használ

A változó egy olyan hely a memóriában, amely int értéket tart. Az x és y változók tartják a rendszerek koordinátáit, és 0 és 4 közötti értéket fognak tartani. Az i változót használjuk a hurkok számlálására.

A 8 véletlenszerű rendszer elhelyezéséhez az 5x5 rácsban tudnunk kell, hogy van-e egy adott helynek már egy rendszere, és meg kell akadályoznunk, hogy egy másik rendszer ugyanabba a helyre kerüljön. Ehhez egy egyszerű, kétdimenziós karaktersort használunk. A char típus egy másik típusú változó a C-ben, és egyetlen karaktert tartalmaz, például „B” vagy „x”.

A C változóinak alapvető típusai az int (egész számok, mint 46), char (egyetlen karakter, mint „A”) és úszó (lebegőpontos számok tartásához, mint például 3.567). A [] tömbök ugyanazon elem listáinak tárolására szolgálnak. Tehát char [5] [5] meghatározza a listák listáját; egy karakter kétdimenziós tömbje. Gondoljon rá, mint például 25 Scrabble darab 5 x 5 méretű rácsba rendezve.

Mindegyik karakter kezdetben egy kettős hurokban lévő szóközt állít be, kettőt használva az utasításokhoz. Az állítás három részből áll. Inicializálás, összehasonlító és módosító rész.

• X = 0; Ez az inicializálás része.
• x
• x ++. Ez a változás része. 1-t és x-t ad hozzá.

Tehát (mert (x = 0; x

A for (ben) (az x hurok egy y jelű hurok, amely ugyanezt teszi y esetén. Ez az y hurok történik az X minden értékére. Ha X értéke 0, Y 0-tól 4-ig hurkol, amikor X értéke 1, Y hurkol és így tovább. Ez azt jelenti, hogy az elrendezési tömb 25 helyének mindegyike szóközbe inicializálódik.

A for hurok után az InitSystem függvényt öt int paraméterrel hívják. Egy függvényt meg kell határozni, mielőtt meghívná. Ellenkező esetben a fordító nem tudja, hány paraméternek kell lennie. Az InitSystem ezen öt paraméterrel rendelkezik.

A következő oldalon: Folytatódik a véletlenszerű kezdőtérkép generálása ...

Ezek az InitSystem paraméterei.

• systemindex - 0 és 9 közötti érték.
• x és y - a rendszer koordinátái (0-4).
• numships - hány hajó van ebben a rendszerben.
• tulajdonos. Ki birtokolja a rendszert? 0 a játékosot, 9 az ellenséget jelenti.

Tehát az InitSystem sor (0,0,0,50,0) inicializálja a 0. rendszert x = -0, y = 0 helyeken 50 hajóval a 0 tulajdonoshoz.

A C háromféle hurkot tartalmaz, míg a hurkokat a hurkokhoz és a hurkokhoz, és a GenMapSystems függvényben használjuk és teszjük. Itt a fennmaradó 8 rendszert el kell helyeznünk valahol a galaxisba.

Ebben a kódban két beágyazott hurok található. A külső hurok egy kifejezés, amely az i változót 1 kezdeti értékről 8-ra végső értékre számolja. Az i-vel fogunk hivatkozni a rendszerre. Ne feledje, hogy már inicializáltuk a 0 és a 9 rendszert, tehát most az 1-8 rendszereket inicializáljuk.

Minden, a do {időpontig (az elrendezés [x] [y]) a második hurok. Szintaxisa: csinálj valamit, amíg (a helyzet igaz); Tehát véletlenszerű értékeket rendelünk x és y értékhez, mindegyik érték a 0-4 tartományba esik. A véletlenszerű (5) az 1 és 5 közötti értéket adja vissza, az 1 kivonásával a 0-4 tartományt kapjuk.

Nem akarunk két rendszert egyazon koordinátára tenni, így ez a hurok véletlenszerű helyet keres, amelyben szóköz található. Ha van egy rendszer, akkor az [x] [y] elrendezés nem szóköz. Ha az InitSystem-t hívjuk, akkor más érték jelenik meg. BTW! = Azt jelenti, hogy nem egyenlő és == azt jelenti, egyenlő.

Amikor a kód egy idő után eléri az InitSystem-t (elrendezés [x] [y]! = ''), X és y határozottan arra a helyre utalnak az elrendezésben, ahol van szóköz. Felhívhatjuk az InitSystem-t, majd körbejárhatjuk a for hurkot, hogy véletlenszerű helyet találhassunk a következő rendszerhez, amíg mind a 8 rendszer el nem kerül.

Az InitSystem első hívása a 0-at állítja be a 0,0 helyen (a rács bal felső sarkában), 50 flottával, és én megnyertem. A második hívás a 9-es rendszert a 4,4-es helyen (jobbra lent) 50 flottával inicializálja, és az 1. játékos tulajdonában van. A következő oktatóanyagban közelebbről megvizsgáljuk, mit tesz az InitSystem.

Ezek a sorok szó szerinti értékeket deklarálnak. Szokás, hogy nagybetűsre tesszük. Mindenütt, ahol a fordító látja a MAXFLEETS-t, a 100 értéket használja. Itt változtassa meg őket, és mindenhol érvényes:

• #define 80 SZÉLESSÉG
• #define 50 Magasság
• #define MAXLEN 4
• #define MAXFLEETS 100
• #define MAXSYSTEMS 10
• #define FIGHTMARKER 999

Ebben az oktatóanyagban lefedtük a változókat, valamint az int, char és struct használatát csoportosításukra, valamint tömböt a lista létrehozásához. Ezután egyszerű hurkolás a és a dolgok használatával. Ha megvizsgálja a forráskódot, ugyanazok a struktúrák láthatók időről időre.

• for (i = 0; i
• for (i = 0; i

A Twowill bemutató az ebben az oktatóban említett C. szempontjait vizsgálja meg.