Számítógépes játékok programozása (képekkel)

2024 Szerző: Robert Blare | [email protected]. Utoljára módosítva: 2024-01-31 12:16

Van ötlete egy számítógépes játékra, és szeretné megvalósítani? Vagy elgondolkodott már azon, hogyan írják a számítógépes játékokat? Ez a wikiHow megtanítja, hogyan kell három alapvető számítógépes játékot írni Pythonban. Az első játék kifejlesztéséhez alapvető ismeretekkel kell rendelkeznie a Pythonról és az általános programozási koncepciókról.

Lépések

Rész 1 /3: Szövegalapú játék készítése

1. lépés Válasszon programozási nyelvet

Minden programozási nyelv különböző, ezért el kell döntenie, hogy melyiket használja a játék megírásához. Minden fontosabb programozási nyelv támogatja a szövegbevitelt, a szövegkimenetet és az if-konstrukciókat (az egyszerű szövegalapú játékhoz szükséges legfontosabb dolgokat), ezért fedezze fel a lehetőségeket, és döntse el, hogy melyikben érzi magát a legkényelmesebben és mely elkötelezett a tanulás iránt. Íme néhány tényező, amelyet figyelembe kell venni:

Mire használják leginkább a nyelvet?

Egyes programozási nyelveket, például a JavaScriptet, weben való használatra tervezték, míg másokat, mint például a Python, C vagy C ++, számítógépes programok futtatására. Játékod során törekedj egy szélesebb körű nyelvre, például Python, C, C ++ vagy JavaScript.
Mennyire nehéz megtanulni?

Bár a program írásának elég egyszerűnek kell lennie a gyakorlás után bármilyen normál programozási nyelven (azaz nem kifejezetten zavarosra tervezett Malbolge -hoz hasonlóan), egyesek barátságosabbak a kezdők számára, mint mások. A Java és a C például megköveteli a mélyebb programozási fogalmak megértését, mint a Python, amely hozzáférhetőbb és egyszerűbb szintaxisáról ismert.
Hol használhatom?

Valószínűleg azt szeretné, ha a különböző rendszereken (például Linux, Mac vagy Windows) dolgozók játszhatnának a játékával. Tehát ne használjon olyan nyelvet, amelyet csak néhány rendszer támogat, mint például a Visual Basic, amelyet csak a Windows támogat.

Ez a cikk a Python-ot fogja használni a szövegalapú játékok példáihoz, de utánanézhet, hogy a fogalmak hogyan készülnek más programozási nyelveken.

2. lépés Készítse elő számítógépét

A két fő összetevőre szüksége lesz egy szövegszerkesztőre, amelybe be kell írnia a kódját, és egy fordítóra, amellyel játékgá alakíthatja. Ha követni szeretné a cikkben szereplő példát, telepítse a Python alkalmazást, és ismerje meg a programok futtatását. Ha szeretné, beállíthat egy IDE -t (Integrált asztali környezet), amely egyesíti a szerkesztést, a fordítást és a hibakeresést egyetlen programba. A Python IDE -jét IDLE -nek hívják. De bármilyen szöveges szerkesztőt is használhat, amely támogatja a sima szöveget, például a Notepad for Windows, a TextEdit a macOS vagy a Vim Linux számára.

3. lépés. Írjon néhány kódot a játékos üdvözléséhez

A játékos tudni akarja, hogy mi történik és mit kell tennie, ezért nyomtasson ki nekik egy szöveget.

Ez a print () függvénnyel történik a Pythonban. A kipróbáláshoz nyisson meg egy új fájlt.py kiterjesztéssel, írja be a következő kódot, mentse és futtassa:
```
print ("Üdvözöljük a számkitalálós játékban!") print ("Adjon meg egy egész számot 1 és 1000 között:")
```

4. Létrehoz egy véletlen számot

Készítsünk egy szöveges játékot, amely arra kéri a játékost, hogy kitalálja a helyes számot. Az első dolog, amit tennünk kell, hogy véletlen számot kell generálnunk a játék elején, hogy a játékos ne mindig ugyanazt a számot találja ki. Mivel a szám a program során változatlan marad, a véletlen számot egy változóban kell tárolni.

A Python nem rendelkezik beépített véletlenszám-függvénnyel, de rendelkezik szabványos könyvtárral (ez azt jelenti, hogy a felhasználónak nem kell semmit extra telepítenie). Tehát menjen a kód elejére (a print () funkciók előtt), és írja be a sorimportálást véletlenszerűen.
Használja a véletlenszerű függvényt. Randint () -nak hívják, az imént importált véletlenszerű könyvtárban található, és a szám minimális és maximális értékét veszi argumentumként. Tehát menjen vissza a kód végére, és írja be a következő sort:
```
rightNum = random.randint (0, 1000)
```

Lépés 5. Nyerjen információt a lejátszótól

A játékban a játékos tenni akar valamit, vagy kölcsönhatásba lép valamivel. Szövegalapú játékban ez szöveg bevitelével lehetséges. Most, hogy van egy véletlen számunk, a következő kódsorainknak meg kell kérniük a játékost, hogy adja meg legjobb tippjét.

Mivel a beírt kód kinyomtatja a számot a lejátszóba történő beírásra vonatkozó utasítást, olvasnia kell a beírt számot is. Ez a (Python 3) input () és a Python 2 programban a raw_input () segítségével történik. A Python 3 -ban kell írnia, mivel a Python 2 hamarosan elavulttá válik. Adja hozzá a következő sort a kódjához, hogy a játékos bemenetét egy szám nevű változóban tárolja:
```
userNum = input ()
```

6. lépés: A lejátszó bemenetét alakítsa használható adattípusba

A játékos beírt egy számot-most mi van?

Adja meg a játékos által bevitt számot. Ez most zavaróan hangozhat, mert most adtak meg egy számot. Ennek azonban jó oka van: a Python feltételezi, hogy minden bemenet szöveg, vagy "karakterlánc", ahogy a programozásban nevezik. Ez a szöveg tartalmazza a kívánt számot. A Pythonnak van egy funkciója, amely a csak számot tartalmazó karakterláncot a benne lévő számmá alakítja át. Típus:
```
userNum = int (userNum)
```

7. lépés Hasonlítsa össze a játékos számát a megfelelő számmal

Miután a játékos megadta a számát, össze kell hasonlítania azt a véletlenszerűen generált számmal. Ha a számok nem egyeznek, a játék arra kényszerítheti a játékost, hogy próbáljon ki egy másik számot. Ha a számok megegyeznek, elmondhatja a játékosnak, hogy helyesen tippelt, és kilép a programból. Ez a következő kóddal történik:

míg userNum! = rightNum: userNum = int (input ())

8. lépés. Adjon visszajelzést a játékosnak

Amíg már feldolgozta a bemenetüket, a játékos ezt nem fogja látni. Ki kell nyomtatnia az eredményeket a lejátszónak, hogy megértsék, mi történik.

Bizonyára csak meg tudná mondani a játékosnak, hogy a számuk helyes vagy rossz. De ezzel a megközelítéssel a játékosnak a legrosszabb esetben 1000 -szer kell kitalálnia, ami nagyon unalmas lenne.
Tehát mondja meg a játékosnak, hogy a számuk túl kicsi vagy túl nagy. Ez jelentősen csökkenti a találgatások számát. Ha például a játékos először 500-at tippel, és a játék azt válaszolja: "Túl nagy. Próbálja újra", csak 500 lehetséges szám lesz 1000 helyett. Ez if-konstrukciókkal történik, ezért cserélje ki a nyomtatást ("Rossz. Próbálja újra. ") Egyikével.
Ne feledje, hogy annak ellenőrzése, hogy két szám azonos -e, a ==, nem pedig a = használatával történik. = a tőle jobbra lévő értéket a tőle balra lévő változóhoz rendeli!

if userNum <rightNum: print ("Túl kicsi. Próbálja újra:") if userNum> rightNum: print ("Túl nagy. Próbálja újra:")

9. lépés. Tesztelje a kódot

Programozóként meg kell győződnie arról, hogy a kód működik, mielőtt befejezte.

A python programozásakor ügyeljen arra, hogy a behúzások helyesek legyenek. A kódnak így kell kinéznie:

véletlenszerű nyomtatás importálása ("Üdvözöljük a számkitalálós játékban!") print ("Egész szám megadása 1 és 1000 között:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum), míg userNum! = rightNum: if userNum <rightNum: print ("Túl kicsi. Próbálja újra:") if userNum> rightNum: print ("Túl nagy. Próbálja újra:") userNum = int (input ()) print ("Sejtette helyesen.")

10. lépés. Ellenőrizze a bemenetet

A játékosnak nem szabad megtörnie a játékát, ha egyszerűen rossz dolgot ír be. A bemenet ellenőrzése azt jelenti, hogy a feldolgozás előtt meg kell győződni arról, hogy a játékos helyesen írta be.

Nyissa meg újra a játékot, és próbáljon meg mindent megadni, ami nem szám. A játék ValueError -tal lép ki. Ennek elkerülése érdekében végrehajthat egy módszert annak ellenőrzésére, hogy a bemenet szám volt -e.
Funkció definiálása. Mivel a bemenet érvényesítése meglehetősen hosszú, és többször kell elvégeznie, meg kell határoznia egy függvényt. Ez nem igényel érveket, és visszaad egy számot. Először írja be a def numInput (): kódot a kód tetejére, közvetlenül az importálási véletlen alá.
Kérdezze meg egyszer a játékos bemenetét. Használja az input () függvényt, és rendelje hozzá az eredményt az inp változóhoz.
Ha a játékos bevitele nem szám, kérje meg, hogy adjon meg egy számot. Annak ellenőrzéséhez, hogy egy karakterlánc szám -e, használja az isdigit () függvényeket, amelyek csak egy egész számot engednek meg, így nem kell külön ellenőrizni.
Ha a bemenet egy szám, konvertálja azt karakterláncból számgá, és adja vissza az eredményt. Használja az int () függvényt a karakterlánc egész számmá alakításához. Ez szükségtelenné teszi a fő kódban lévő konverziót, és el kell távolítania onnan.
Cserélje ki az összes hívást a fő kód bemenetére () a numInput () hívásokra.
A numInput () függvény kódja így néz ki:

def numInput (): inp = input (), míg nem inp.isdigit (): print ("Azt mondták, hogy írjon be egy egész számot! Írjon be egy egész számot:") inp = input () return int (inp)

11. lépés: Tesztelje újra a játékot

Szándékosan írja be a rossz dolgokat, hogy lássa, mi történik, majd javítsa ki az esetleges hibákat.

Próbáljon meg szöveget írni, amikor a program számot kér. Most ahelyett, hogy hibaüzenettel lépne ki, a program ismét egy számot kér

12. lépés. Javasolja, hogy a játék befejezése után indítsa újra a játékot

Így a játékos hosszabb ideig játszhatja a játékot anélkül, hogy folyamatosan újra kellene indítania.

Tegye az összes kódot az importálás és a függvénydefiníció kivételével egy while-ciklusba. Állítsa a True értéket feltételként: ez mindig igaz lesz, így a ciklus örökké folytatódik.
Kérdezze meg a játékost, hogy akar -e újra játszani, miután helyesen kitalálta a számot. Használja a print () funkciót.
Ha nemmel válaszolnak, törjön ki a tekintetből. Ha válaszolnak még valamire, folytassa. A hurokból való kitörés a break utasítással történik.
Mozgassa az „Üdvözöljük a számkitalálós játékban” részt a while cikluson kívül. A játékos valószínűleg nem akarja, hogy minden alkalommal üdvözöljék, amikor játszanak vele. Mozgassa az utasítás nyomtatását ("Üdvözöljük a számkitalálós játékban!"), Míg a True: fölé, így csak egyszer lesz kinyomtatva, amikor a felhasználó elindítja az első játékot.

13. lépés: Tesztelje a játékot

Minden alkalommal, amikor új funkciót telepít, tesztelnie kell a játékát.

Feltétlenül válaszoljon legalább egyszer az „Igen” és a „Nem” válaszra, hogy mindkét lehetőség működjön. A kódnak így kell kinéznie:

import véletlen def ("Üdvözöljük a számkitalálós játékban!"), Míg True: print ("Egész számot adjon meg 1 és 1000 között:") rightNum = random.randint (0, 1000) userNum = numInput (), míg userNum! = RightNum: if userNum <rightNum: print ("Túl kicsi. Próbálja újra:") if userNum> rightNum: print ("Túl nagy. Próbálja újra:") userNum = numInput () print ("Jól sejtette.") print ("Do you do újra szeretné játszani? A kilépéshez írja be a Nem gombot. ") if input () ==" No ": break

14. lépés. Írjon más szövegalapú játékokat

Mit szólnál ahhoz, hogy szöveges kalandot írj legközelebb? Vagy kvízjáték? Légy kreatív.

Tipp: Néha hasznos megnézni a dokumentációt, ha nem biztos abban, hogyan történik valami, vagy hogyan használják a funkciót. A Python 3 dokumentáció a https://docs.python.org/3/ címen található. Néha az interneten történő keresés is jó eredményeket hoz.

Rész 2 /3: Játék készítése 2D grafikával

1. lépés. Válasszon egy grafikus könyvtárat

A grafika készítése nagyon bonyolult, és a legtöbb programozási nyelv (beleértve a Python, C ++, C, JavaScript) csak minimális vagy egyáltalán nem támogatja a grafikát a magban vagy a szabványos könyvtárakban. Tehát külső könyvtárat kell használnia a grafika készítéséhez, például a Pygame for Python.

Még egy grafikus könyvtár esetében is aggódnia kell, például a menü megjelenítésével, annak ellenőrzésével, hogy mire kattintott a játékos, hogyan jelenítse meg a lapokat stb. Ha inkább a tényleges játék fejlesztésére összpontosít, használhat olyan játékmotor -könyvtárat, mint a Unity, amely ezeket a dolgokat könnyen megvalósítja

Ez a cikk a Python -t használja a Cocos2D -vel, hogy bemutassa, hogyan lehet egyszerű 2D -s platformer készíteni. Az említett fogalmak némelyike más játékmotorokban nem létezik. További információért olvassa el dokumentációjukat.

2. lépés: Telepítse a kiválasztott grafikus könyvtárat

A Cocos2D for Python könnyen telepíthető. Letöltheti a https://python.cocos2d.org/index.html webhelyről, vagy a sudo pip3 install cocos2d futtatásával, ha Linuxot használ.

3. lépés. Hozzon létre egy új könyvtárat a játékhoz és a médiához

Olyan dolgokat fog használni a játékban, mint a képek és a hangok. Tartsa ezeket a dolgokat ugyanabban a könyvtárban, mint a program. Ez a könyvtár nem tartalmazhat mást, így könnyen láthatja, hogy milyen eszközei vannak a játékban.

4. lépés. Hozzon létre egy új kódfájlt az új könyvtárban

Nevezze főnek, a programozási nyelv fájlkiterjesztésével. Ha nagy és összetett programot ír, ahol több programfájl van értelme, ez megmutatja, melyik a fő fájl.

Ebben a példában létrehozunk egy main.py nevű fájlt, amely tartalmazza az összes kódunkat

5. lépés: Hozza létre a játékablakot

Ez az alapvető előfeltétele egy grafikus játéknak.

Importálja a szükséges cocos2d almodulokat: cocos.director, cocos.sene és cocos.layer. Ez a subModuleName import *programból történik, ahol az almodul neve az importálni kívánt almodul. A különbség az… import * és az import… között az, hogy nem kell a modul nevét minden elé írnia, amit az adott modulból használ az előbbivel.
Határozza meg a ColorLayer MainMenuBgr alosztályát. Ez alapvetően azt jelenti, hogy bármilyen főmenü -háttér, amelyet létrehoz, színes rétegként fog viselkedni bizonyos változtatásokkal.
Indítsa el a kókuszrendezőt. Ezzel új ablakot kap. Ha nem állít be feliratot, az ablak ugyanazt a feliratot tartalmazza, mint a fájl neve (main.py), ami nem tűnik professzionálisnak. Engedélyezze az ablak átméretezését az átméretezhető érték beállításával True.
A showMainMenu függvény meghatározása. A főmenü megjelenítésének kódját egy függvénybe kell beillesztenie, mert így könnyen visszatérhet a főmenübe a funkció újbóli meghívásával.
Hozzon létre egy jelenetet. A jelenet egy rétegből áll, amely az Ön által meghatározott MainMenuBgr osztály objektuma.
Futtassa ezt a jelenetet az ablakban.

from cocos.director import * from cocos.scene import * from cocos.layer import * class MainMenuBgr (ColorLayer): def _init _ (self): szuper (MainMenu, self)._ init _ (0, 200, 255, 255) def showMainMenu (): menuSc = Jelenet (MainMenuBgr ()) director.run (menuSc) director.init (caption = "IcyPlat - a simple platformer", resizable = True) showMainMenu ()

6. lépés. Adjon hozzá egy főmenüt az ablakhoz

A tényleges játék mellett hozzá kell adnia egy menüt, amellyel a játékos bezárhatja az ablakot, többek között a későbbiekben hozzáadható elemekkel.

Importálja a cocos.menu -t (ismét az utasításból) és a pyglet.app -t (ezúttal importálással).
Határozza meg a MainMenu -t a Menü alosztályaként.
Állítsa be a főmenü igazítását. Külön kell beállítani a függőleges és vízszintes igazítást.
Hozzon létre egy listát a menüpontokról, és vegye fel őket a menübe. Legalább a "Start Game" és a "Quit" menüpontoknak kell lennie. Minden menüpontot zárójelben kell elhelyezni. Minden elemnek címkével és visszahívási funkcióval kell rendelkeznie, amely meghatározza, hogy mi történik, ha a játékos rákattint. A "Játék indítása" elemhez használja a startGame függvényt (hamarosan megírja), a "Kilépés" elemhez pedig a "pyglet.app.exit" parancsot (már létezik). Hozza létre a tényleges menüt a self.create_menu (menuItems) hívásával.
A startGame () meghatározása. Egyelőre csak tegye bele a definíciót, és ezt lecseréli, amikor a tényleges játékot írja.
Lépjen a kódban arra a helyre, ahol a menuSc jelenetet létrehozta, és adjon hozzá egy MainMenu objektumot.

A teljes kódnak most így kell kinéznie:

from cocos.director import * from cocos.menu import * from cocos.scene import * from cocos.layer import * import pyglet.app class MainMenuBgr (ColorLayer): def _init _ (self): szuper (MainMenuBgr, self)._ init _ (0, 200, 255, 255) osztály MainMenu (Menü): def _init _ (self): szuper (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Játék indítása) ", startGame)), (MenuItem (" Kilépés ", pyglet.app.exit))] self.create_menu (menuItems) def startGame (): pass def showMainMenu (): menuSc = Jelenet (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) director.init (caption = "IcyPlat - a simple platformer", resizable = True) showMainMenu ()

7. lépés: Tesztelje a kódot

Tesztelje a kódot korán, még mindig rövid és viszonylag egyszerű. Ezután azonosíthatja és kijavíthatja az alapvető struktúra hibáit, mielőtt a dolgok túl bonyolulttá válnának.

Az utasításokból származó kódnak meg kell nyitnia egy ablakot "IcyPlat - egyszerű platformer". A háttér világoskék, és átméretezheti az ablakot. Ha a menüben a "Játék indítása" gombra kattint, semmi sem történhet (még). Ha a "Kilépés" gombra kattint, az ablak bezáródik

8. lépés. Hozzon létre egy sprite -ot

A sprite egy "játék objektum" vagy egy 2 dimenziós kép. A sprite lehet játékon belüli objektum, ikon, háttér-dekoráció, karakter és bármi más, amit a játékban megjeleníthet egy képpel. Kezdjük azzal, hogy létrehozunk egy sprite -ot egy karakter számára, amellyel a játékos kölcsönhatásba léphet.

Importálja a cocos.sprite almodult az import-from-kifejezéssel.
Keressen egy képet, amely a sprite -ot ábrázolja. Nem jeleníthet meg sprite -ot, ha nincs hozzá képe. Rajzolhat egyet, vagy beszerezhet egyet az internetről (vigyázzon az engedélyekre, ha a játék közzétételét tervezi). Ebben a példában menjen a https://opengameart.org/content/tux-classic-hero-style oldalra, és mentse el a futó pingvinek PNG-képét a számítógépére. Ezután vágja ki az egyik futó pingvint, mivel egyelőre csak egyre lesz szüksége.
Hozzon létre egy réteget a ScrollableLayer osztály új objektumaként. Ezután hozza létre a sprite -t Sprite -objektumként, és állítsa a pozícióját (8, 250) értékre. Referenciaként a (0, 0) pont a bal alsó sarokban található. Ez elég magas, de gondoskodik arról, hogy a pingvin ne ragadjon a jégben.
Adja hozzá a sprite -ot a sprite rétegéhez.
Hozzon létre egy új jelenetet a sprite rétegéből, és futtassa azt.

def startGame (): figLayer = ScrollableLayer () fig = Sprite ('pingu.png') fig.position = (75, 100) figLayer.add (fig) # gameSc = Jelenet (figLayer) director.run (gameSc)

Futtassa a kódot. Látnia kell egy kis pingvinfigurát (vagy bármit, amit rajzolt) fekete háttérre kattintás után Játék kezdése.

9. lépés. Álmodja meg a tájat

A legtöbb játékban a sprite -nek nem szabad csak az űrben lebegnie. Valójában valamilyen felületen kell állniuk, valami körülöttük. A 2D -s játékokban ezt gyakran csempe készlettel és cserép -térképpel teszik. A csempe készlet alapvetően azt mondja meg, hogy milyen felszíni négyzetek és háttérszögek léteznek, és hogyan néznek ki.

Hozzon létre csempehalmazt. A csempe készlet ehhez a játékhoz nagyon egyszerű lesz: egy csempe a jéghez és egy csempe az éghez. A példában használt jégcserép innen származik, a CC-BY-SA 3.0 alatt.
Hozzon létre egy cserépkészlet -képet. Ez egy kép az összes csempéről, amelyeknek egyforma méretűnek kell lenniük (ha nem, akkor szerkessze őket), és a játékban látni kívánt méret mellett. Mentse a képet icyTiles-p.webp" />
Hozza létre a csempehalmaz leírását. Ez egy XML fájl. Az XML fájl információkat tartalmaz arról, hogy a csempék mekkora méretűek a csempehalmaz képén, melyik képet kell használni, és hol található melyik csempe. Hozzon létre egy XML fájlt icyTiles.xml néven az alábbi kóddal:
```
     
```

10. lépés. Készítsen csempe térképet a tájhoz

A cserép térkép egy olyan térkép, amely meghatározza, hogy melyik csempe melyik szinten van a szintjén. A példában definiálnia kell egy függvényt a cserép -térképek létrehozásához, mert a cserép -térképek kézi tervezése nagyon fárasztó. Egy fejlettebb játéknak általában valamilyen szintszerkesztője van, de a 2D játékfejlesztés megismeréséhez egy algoritmus elég jó szinteket tud biztosítani.

Tudja meg, hány sor és oszlop szükséges. Ehhez ossza el a képernyő méretét a csempe méretével vízszintesen (oszlopok) és függőlegesen (sorok). Kerekítse a számot felfelé; ehhez szüksége van a matematikai modul funkciójára, ezért adja hozzá a matematikai import plafonból a kód tetején lévő importhoz.
Nyisson meg egy fájlt íráshoz. Ez törli a fájl összes korábbi tartalmát, ezért válasszon egy nevet, amelyet még egyetlen könyvtárbeli fájl sem tartalmaz, például a levelMap.xml fájlt.
Írja be a fájlba a nyitó címkéket.
Létrehoz egy cserép térképet az algoritmus szerint. Használhatja az alábbi kódban szereplőt, vagy saját maga is kitalálhat egyet. Győződjön meg róla, hogy importálja a randint függvényt a véletlenszerű modulból: ez szükséges az alábbi kód működéséhez, és bármit is talál, valószínűleg véletlenszerű egész számokra is szüksége lesz. Ezenkívül ügyeljen arra, hogy az égboltlapokat és a jégcsempéket különböző rétegekbe helyezze: a jég szilárd, az ég nem.
Írja be a záró címkéket a fájlba, és zárja be a fájlt.

defgeneTilemap (): colAmount = mennyezet (800/16) * 3 # (képernyő szélessége / csempe mérete) * 3 rowAmount = mennyezet (600/16) # képernyőmagasság / csempe mérete tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) az i tartományban (0, colAmount): tileFile.write ('') makeHole = Hamis, ha randint (0, 50)) == 10 és i! = 0: # ne engedélyezzen lyukakat a spawnpoint -ban makeHole = Igaz j -re a tartományban (0, rowAmount): if makeHole: tileFile.write ('\ n') else: if j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) if iceHeight <0: # korlátozza a csempék túl alacsony jégre való menésétHeight = randint (1, 5) if iceHeight> rowAmount: # limit csempék túl magas jégkorrekciótólHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') i esetén a (0, colAmount) tartományban: tileFile.write ('') a j tartományban (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

11. lépés. Jelenítse meg a csempe térképét

Importáljon mindent a cocos.tiles -ből, majd lépjen be a startGame funkcióba.

A startGame függvény elején hozzon létre egy cserép térképet az ehhez definiált függvény segítségével.
Hozzon létre egy új görgetéskezelőt. Tegye ezt közvetlenül a vonal alatt, ahol hozzáadja a sprite -t a rétegéhez.
Hozzon létre egy új réteget, amely a csempéket tartalmazza, és a generált csempe függvény által létrehozott levelMap.xml lapkaptérképből töltődik be.
Adja hozzá a nem szilárd réteget, a szilárd réteget és a sprite réteget a görgetéskezelőhöz, pontosan ebben a sorrendben. Z-pozíciót is hozzáadhat, ha akar.
Ahelyett, hogy a jelenetet a sprite rétegből hozná létre, hozza létre a görgetéskezelőben.

A startGame funkciónak most így kell kinéznie:

def startGame (): createTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 500) figLayer = ScrollableLayer () figLayer.add (ábra) # tileLayer = load ('levelMap.xml') solidTiles = tileLayer ['solid'] nsoliTiles = tileLayer ['not_solid'] # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Jelenet (scrMang) director.run (gameSc)

12. lépés. Tesztelje a kódot

Gyakran tesztelje a kódot, hogy megbizonyosodjon arról, hogy az Ön által bevezetett új funkciók valóban működnek.

A példában szereplő kódnak most jeges tájat kell mutatnia a pingvin mögött. Ha a pingvin úgy tűnik, hogy messze lebeg a jég felett, akkor nem tett semmi rosszat, és a következő lépésben kijavítják

13. lépés. Adja hozzá a vezérlőket

A játékosnak sokkal több módja van a programmal való interakcióra egy 2D-s játékban, mint egy szövegalapú játékban. A leggyakoribb a figura mozgatása a megfelelő gomb megnyomásakor.

Importáljon mindent a cocos.mapcolliders és a cocos.actions műveletekből. Importálja a kulcsot a pyglet.window -ból is.
Néhány globális változó "deklarálása". A globális változókat megosztják a függvények között. A Python -ban valójában nem lehet deklarálni a változókat, de azt kell mondanunk, hogy a globális változó a fő kódban létezik, mielőtt használná. 0 -t rendelhet értékként, mert egy függvény gondoskodik a helyes érték későbbi hozzárendeléséről. Tehát adja hozzá az import kifejezésekhez:
```
# "deklaráló" globális változók billentyűzet = 0 scrMang = 0
```

Állítsa be a startGame funkciót:

Tegyük fel, hogy a globális változók billentyűzetét és a scrMang billentyűt használja. Ehhez írja be a globális billentyűzetet, a scrMang funkciót a funkció tetején.
Figyelje az ablakot a billentyűzet eseményeinek hallgatására.
Mondja meg az ábrának, hogy cselekedjen a PlatformerController alapján. Hamarosan megvalósítja azt a PlatformerControllert.
Hozzon létre egy térképütköztetőt a tömör lapok és az ábra közötti ütközések kezelésére.

def startGame (): globális billentyűzet, scrManggeneTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (ábra) # tileLayer = load ('levelMap.xml ') solidTiles = tileLayer [' solid '] nsoliTiles = tileLayer [' not_solid '] # keyboard = key. KeyStateHandler () director.window.push_handlers (billentyűzet) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on = 'dia') ábra.ütközéskezelő = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z =) 1) # gameSc = Jelenet (scrMang) director.run (gameSc)

Hozzon létre egy platformer vezérlőt. Ez fogja mozgatni a figurát a gombnyomásoknak megfelelően.
- Határozza meg a platformvezérlőt a cselekvés alosztályaként.
- Határozza meg a mozgási sebességet, az ugrási sebességet és a gravitációt.
- Határozza meg az indítási funkciót. Ezt a funkciót egyszer hívják meg, amikor a platformer vezérlő csatlakoztatva van az ábrához. Sebességét 0 -ra kell állítani mind x, mind y irányban.
- Határozza meg a lépésfüggvényt. Ez megismétlődik, amíg a jelenet fut.
- Mondja meg a lépésfüggvénynek, hogy használja a globális változók billentyűzetét és a scrMang funkciót.
- Szerezze be és változtassa meg a sebességet. Mentse az x és az y sebességet külön változókba. Állítsa az x sebességet 1 -re vagy -1 -re (attól függően, hogy a bal vagy a jobb gombot nyomták -e) szorozva a mozgási sebességgel. Add hozzá a gravitációt az y sebességhez. Szorozza meg az állásidővel, így lassabban működő eszközökön is ugyanúgy működik. Ha megnyomja a szóköz billentyűt, és a figura a földön áll, ugorjon úgy, hogy megváltoztatja az y sebességet az ugrási sebességre.
- Számítsa ki, hogy az ábra hová mozogjon. Ezután hagyja, hogy az ütközéskezelő állítsa be ezt a helyzetet, ha egy szilárd burkolólapon belül van. Végül mozgassa az ábrát az új beállított helyzetbe.
- Állítsa a görgetéskezelő fókuszát az ábrára. Ez azt eredményezi, hogy a kamera ésszerű módon mozog, amikor a figura mozog.
```
class PlatformerController (Action): globális billentyűzet, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (self, dt): globális billentyűzet, scroller, ha dt> 0,1: # ne csináljon semmit, amíg leáll a nagy visszatérési vx, vy = self.target.velocity vx = (billentyűzet [key. RIGHT] - billentyűzet [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground és keyboard [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () new = last.copy () new.x += dx new.y += dy self.target.velocity = self.target.collision_handler (utolsó, új, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (*new.center)
```

14. lépés. Tesztelje a kódot

Ha követte a példát, most már képesnek kell lennie a pingvin mozgatására a nyilakkal, és a szóköz megnyomásával ugorhat. Továbbá a pingvinnek le kell esnie, ahelyett, hogy a föld felett lebegne.

15. lépés: Végezze el a játék befejezését

Még a végtelenül folytatódó játékoknak is lehetőségük van a vesztésre. Mivel az a szint, amelyet a példában egy funkcióval tett, véget ér, a nyerést is lehetővé kell tennie, ha erre a célra érkezik. Ellenkező esetben a játékos csak ugrálna az ottani jégtömbökön, ami unalmas lenne.

A platformer vezérlőjében, a fókusz beállítása után, szerezze meg a figura x és y pozícióját. Ha az y pozíció kisebb, mint 0, hívja meg a finishGame () függvényt (később megírja) "Game Over" argumentumként. Ha az x pozíció nagyobb, mint a képernyő mérete szorozva 3 -mal (ezt korábban szintméretnek állította be).
```
posX, posY = self.target.position if posY <0: finishGame ("Game Over") visszatér, ha a posX> 800*3: # level size finishGame ("Level Completed") visszatér
```
Osztály befejezése Menü. Olyannak kell lennie, mint a főmenüosztály, amelyet korábban definiált, de ahelyett, hogy üres karakterlánc lenne a címe, változó szöveget kell használnia, amelyet a _init_ függvény argumentumként vesz fel. A menüpontokat "Próbálja újra" és "Kilépés" felirattal kell ellátni, de az általuk meghívott funkciók változatlanok maradnak.
```
class FinishMenu (Menu): def _init _ (self, text): szuper (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Try again", startGame)), (MenuItem ("Kilépés", pyglet.app.exit))] self.create_menu (menuItems)
```
Határozza meg a finishGame () függvényt. A szöveget érvként kell figyelembe venni. Jelenetet kell készítenie a főmenü hátteréből, egy FinishMenu menüt, amelyben a szöveg argumentum átkerül ebbe a menübe. Akkor ennek a jelenetnek kell futnia.
```
def finishGame (szöveg): menuSc = Jelenet (MainMenuBgr ()) menuSc.add (FinishMenu (szöveg)) director.run (menuSc)
```

16. lépés. Hitelek hozzáadása

Itt kap hitelt a fantasztikus kódért, valamint bárki másnak, aki segített az úton. Ha egy másik webhelyről származó képet használt (engedéllyel), feltétlenül rendelje hozzá azt a készítőhöz.

Hozzon létre egy fájlt CREDITS, és adja meg az összes jóváírását, például:

Pingvin: Kelvin Shadewing, CC0 alatt Jégblokk: Michał Banas digit1024 az opengameart.org-on CC-BY-SA 3.0 alatt

Térjen vissza a Python -kódjához, és importálja a címkét a cocos.text -ből.

Definiálja a Réteg kreditjei alosztályt. _Init_ függvényében olvassa el a CREDITS fájlt, és készítsen szöveges címkét a megfelelő helyen minden sorából.

osztály Credits (Layer): def _init _ (self): szuper (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") a (0, len (creds)) tartományban lévő i esetében: credLabel = Címke (creds , font_size = 32, anchor_x =" left ", anchor_y =" top ") credLabel.position = 25, 500- (i +1)*40 self.add (credLabel)

Lépjen a főmenüosztályba, és adjon hozzá egy "Credits" feliratú menüpontot, amely kattintáskor meghívja a showCredits függvényt.
A menü BackToMainMenuButton alosztályának meghatározása. Készítse el ezt a menüt egy "Vissza" feliratú elemmel, amely meghívja a showMainMenu funkciót. Ezt a "menüt", amely inkább gombhoz hasonlít, függőlegesen kell alulra igazítani, vízszintesen pedig felülre.
```
class BackToMainMenuButton (Menü): def _init _ (self): szuper (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self create_menu (menuItems)
```
Határozza meg a showCredits függvényt. Jelenetet kell készítenie egy MainMenuBgr és egy Credits rétegből, és le kell futtatnia azt a jelenetet.
```
def showCredits (): credSc = Jelenet (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)
```

17. lépés. Ellenőrizze a kódot

Amikor úgy gondolja, hogy befejezte a kódot, nézze át újra az egészet. Ez segíthet észrevenni, hogy valami optimalizálható -e, vagy vannak -e felesleges sorok, amelyeket elfelejtett törölni. Ha követte a példát, a teljes kódnak most a következőképpen kell kinéznie:

a cocos.director importból * a cocos.menu importból * a cocos.scene importból * a cocos.layer importból * a cocos.sprite importból * a cocos.tiles importból * a cocos.mapcolliders importból * a cocos.actions importból * a cocosból.text import Label import pyglet.app from pyglet.window import key from math import ceil from random import randint # "deklaráló" globális változók billentyűzet = 0 scrMang = 0 class MainMenuBgr (ColorLayer): def _init _ (self): szuper (MainMenuBgr, self)._ init _ (0, 200, 255, 255) osztály MainMenu (menü): def _init _ (self): szuper (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems =

Ez összesen 168 sor, és 152 sor, ha csak a kódot számolja. Ez soknak tűnik, de egy ilyen összetett játék esetében ez valójában csekély összeg.

18. lépés. Kész

Most tesztelje a játékot. Amikor valamit programoz, ellenőriznie kell, hogy működik -e, amikor valami újat implementált. Továbbá, lehet, hogy egy ideig azt a játékot szeretné játszani, amit írt.

Rész 3 /3: Játék kiadása

1. lépés. Írja le a függőségeket

Bárki, aki másik számítógépet használ, nem telepíti ugyanazt a szoftvert és könyvtárat, mint Ön. Tehát gondoskodnia kell arról, hogy mindenki, aki telepíti a játékot, pontosan tudja, mire lesz szüksége a játék futtatásához. Nem kell leírnia az összes függőség összes függőségét, és így tovább, de legalább meg kell írnia a csomagok függőségeit és azok függőségeit.

2. lépés. Győződjön meg arról, hogy rendelkezik engedéllyel az összes média használatához

Ez minden grafikára vonatkozik, beleértve a 3D modelleket, a zenét, a párbeszédet, a zenét, a könyvtárakat és a játékhoz használt keretrendszereket. Bármit, amit nem maga írt.

Gyakran vannak bizonyos feltételek, például a szerző elismerése vagy a média módosításainak megosztása ugyanazon licenc alapján. Néha használhatja a grafikákat az alkotók hozzárendelése nélkül, amíg nem számít fel díjat a játékért. Ha jóvá kell írnia a szerzőt, tegye azt jól látható helyen, például a játék „Hitelek” lapján.
Vannak olyan médiák is, amelyekre szerzői jogi igények vonatkoznak, és nincs megadva engedély, néha olyan szöveggel, mint "Minden jog fenntartva". Ebben az esetben kifejezett engedélyt kell kérnie a szerzőtől, mielőtt bevonja a játékba.
A könyvtárakat általában olyan licencek alatt adják ki, amelyek lehetővé teszik könyvtárként való használatukat. Figyelemre méltó kivétel a GPL hivatkozás nélküli kivétel: Az ilyen licenc csak bizonyos licencekkel rendelkező programokban teszi lehetővé. És mindig olvassa el legalább a licenc alapvető pontjait, hogy megbizonyosodjon arról, hogy bármit is tesz a médiával vagy a könyvtárral.

Figyelem: A média vagy könyvtárak olyan módon történő használata, amelyet a licenc nem engedélyez egy közzétett játékban, komoly jogi problémákat okozhat. Tehát vagy kérdezze meg a szerzőt, vagy kerülje el teljesen a médiát, ha nem biztos abban, hogy a használata engedélyezett -e.

3. Döntse el, milyen feltételek mellett szeretné közzétenni a játékát

Eladja a játékát? Szeretné, hogy mások is használhassák képeit és ötleteit? Bár óvatosnak kell lennie a projektben használt médiával kapcsolatban, általában eldöntheti, hogy miként szeretné engedélyezni mások számára a játék használatát. Használhatja a Creative Commons CC0 licencét, hogy nyilvánosan hozzáférhetővé tegye játékát. Ha bizonyos feltételek mellett szeretné terjeszteni és módosítani bizonyos jogok megtartása mellett, próbálja ki a Gnu General Public License (GPL) vagy a Berkeley Software Distribution (BSD) licencet. Vagy szabadalmaztathatja szoftverét, ami azt jelenti, hogy senki sem terjesztheti vagy módosíthatja azt az Ön engedélye nélkül.

Játékok értékesítésével ugyan lehet pénzt keresni, de nem valószínű, hogy az emberek megveszik az első játékot, amely általában kevés funkcióval rendelkezik, és semmi különöset nem tartalmaz. Továbbá, ha egy ingyenes program nem működik, akkor azok, akik letöltötték, csak csalódni fognak. Ha azonban fizettek érte, akkor visszakövetelik a pénzüket, ami több problémát okoz Önnek és a felhasználóknak is. Ezért fontolja meg, hogy első néhány programját ingyenesen elérhetővé tegye

4. lépés: Döntse el, hogyan szeretné közzétenni játékát

Minden módszernek vannak előnyei és hátrányai, ezért döntenie kell.

Közzététel egy weboldalon:

Ha rendelkezik webhellyel, feltöltheti a játékot, hogy letölthető legyen. Győződjön meg arról, hogy egyértelmű utasításokat ad a szoftver telepítéséhez, valamint minden szükséges függőséget. Ennek hátránya, hogy a játékosoknak manuálisan kell telepíteniük a függőségeket, ami egyeseknek nehézséget okozhat.
Csomag készítése csomagkezelőnek:

Különféle csomagkezelők léteznek, például az apt, a Yum és a Homebrew, amelyek megkönnyítik az alkalmazások telepítését Linux és Linux alapú környezetben. Mindegyikük különböző csomagformátumokkal rendelkezik. A csomagokban az a jó, hogy automatikusan telepítik az összes függőséget (ha helyesen konfigurálja őket). Tehát a játékosnak csak telepítenie kell a csomagot, és utána játszhat. A probléma az, hogy sok különböző csomagkezelő létezik a különböző platformokon, ezért némi munkát kell tennie annak érdekében, hogy csomagokat biztosítson az összes leggyakoribbhoz.

5. lépés. Irányítsa a figyelmet a programjára

Fontolja meg a program feltöltését egy nagyobb csomagtárba, például az Ubuntu és a Debian által fenntartott tárolóba, az egyszerű telepítés érdekében. Tegyen közzé megfelelő fórumokon is, például a GameDev projektek szakaszában vagy a tigSource egy részében. De ne csalódjon, ha első játékai nem válnak híressé. Ha van egy ötlete, hogy sok embernek tetszik, a játék jól ismertté válhat.

Tippek

Légy türelmes és hajlandó tanulni. A programozás néha frusztráló tud lenni!
Ha kíváncsi, hogyan történik valami egy másik játékban, és a játék nyílt forráskódú, akkor megnézheti annak forráskódját.
Amikor médiát keres, próbáljon olyan tartalmat találni, amely nyilvános. Keresse meg a "Creative Commons" vagy a "Public Domain" képeket és zenét, és használjon olyan webhelyeket, mint a https://opengameart.org vagy a
Ne másoljon nagyobb kódrészleteket a licenc ellenőrzése nélkül. Gyakran tilos, és ha nem, általában hozzárendelést igényel.
A játék népszerűsítésekor ne tegyen spamet vagy tegyen közzé nem megfelelő helyeken. Ez valószínűleg blokkolja az oldalt, egyszerűen bosszantó, és rontja a hírnevét.