Tietokonepelien ohjelmointi (kuvilla)

2024 Kirjoittaja: Robert Blare | [email protected]. Viimeksi muokattu: 2023-12-17 07:39

Onko sinulla idea tietokonepelistä ja haluat tehdä siitä todellisen? Tai oletko koskaan miettinyt, miten tietokonepelejä kirjoitetaan? Tämä wikiHow opettaa sinulle, miten voit kirjoittaa kolme perustietokonetta Pythonissa. Tarvitset perustiedot Pythonista ja yleisistä ohjelmointikonsepteista kehittääksesi ensimmäisen pelisi.

Askeleet

Osa 1/3: Tekstipohjaisen pelin tekeminen

Vaihe 1. Valitse ohjelmointikieli

Kaikki ohjelmointikielet ovat erilaisia, joten sinun on päätettävä, kumpaa käytät pelin kirjoittamiseen. Kaikki suuret ohjelmointikielet tukevat tekstinsyöttöä, tekstin tulostusta ja if-rakenteita (tärkeimmät asiat, joita tarvitset yksinkertaiseen tekstipohjaiseen peliin), joten tutustu vaihtoehtoihin ja päätä, mikä tuntuu mukavimmalta ja omistetulle oppimiselle. Tässä muutamia tekijöitä, jotka on otettava huomioon:

Mihin kieltä käytetään enimmäkseen?

Jotkut ohjelmointikielet, kuten JavaScript, on suunniteltu käytettäväksi verkossa, kun taas toiset, kuten Python, C tai C ++, on suunniteltu suorittamaan tietokoneohjelmia. Tavoita pelissäsi kieli, jolla on laajempi käyttöalue, kuten Python, C, C ++ tai JavaScript.
Kuinka vaikeaa on oppia?

Vaikka ohjelman kirjoittamisen pitäisi olla riittävän helppoa harjoituksen jälkeen millä tahansa normaalilla ohjelmointikielellä (eli ei ole suunniteltu erityisesti hämmentäväksi, kuten Malbolge), jotkut ovat aloittelijoille ystävällisempiä kuin toiset. Esimerkiksi Java ja C edellyttävät sinua ymmärtämään syvempiä ohjelmointikonsepteja kuin jotain Pythonia, joka tunnetaan helpommin saavutettavasta ja suoraviivaisesta syntaksistaan.
Missä voin käyttää sitä?

Haluat todennäköisesti, että eri järjestelmissä, kuten Linuxissa, Macissa tai Windowsissa, olevat ihmiset voivat pelata peliäsi. Joten sinun ei pitäisi käyttää kieltä, jota tuetaan vain muutamissa järjestelmissä, kuten Visual Basic, jota tuetaan vain Windowsissa.

Tässä artikkelissa käytetään Pythonia esimerkkeinä tekstipohjaisesta pelistä, mutta voit katsoa, miten käsitteet tehdään millä tahansa muulla ohjelmointikielellä.

Vaihe 2. Ota tietokone valmiiksi

Kaksi tärkeintä komponenttia, joita tarvitset, ovat tekstieditori, johon kirjoitat koodisi, ja kääntäjä, jonka avulla voit muuttaa sen peliksi. Jos haluat noudattaa tämän artikkelin esimerkkiä, asenna Python ja opi käyttämään ohjelmia. Halutessasi voit määrittää IDE: n (Integraded Desktop Environment), joka yhdistää muokkaamisen, kääntämisen ja virheenkorjauksen yhdeksi ohjelmaksi. Pythonin IDE on IDLE. Mutta voit myös käyttää mitä tahansa tekstieditoria, joka tukee pelkkää tekstiä, kuten Notepad for Windows, TextEdit macOS: lle tai Vim Linuxille.

Vaihe 3. Kirjoita koodi tervehtimään pelaajaa

Pelaaja haluaa tietää, mitä on tekeillä ja mitä heidän on tehtävä, joten sinun tulee tulostaa heille tekstiä.

Tämä tehdään Pythonin print () -toiminnolla. Voit kokeilla sitä avaamalla uuden tiedoston, jonka laajennus on.py, kirjoittamalla siihen seuraava koodi, tallentamalla ja suorittamalla se:
```
print ("Tervetuloa numeroarvauspeliin!") print ("Anna kokonaisluku väliltä 1 - 1000:")
```

Vaihe 4. Luo satunnaisluku

Tehdään tekstipohjainen peli, jossa pyydetään pelaajaa arvaamaan oikea numero. Ensimmäinen asia, joka meidän on tehtävä, on luoda satunnainen numero pelin alussa, jotta pelaaja ei aina arvaa samaa numeroa. Koska luku pysyy samana koko ohjelman ajan, satunnaisluku kannattaa tallentaa muuttujaan.

Pythonissa ei ole sisäänrakennettua satunnaislukutoimintoa, mutta sillä on vakiokirjasto (tämä tarkoittaa, että käyttäjän ei tarvitse asentaa mitään ylimääräistä). Siirry siis koodin alkuun (ennen tulostustoimintoja) ja kirjoita rivin tuonti satunnaisesti.
Käytä satunnaistoimintoa. Sitä kutsutaan randintiksi (), se on juuri tuodussa satunnaiskirjastossa, ja se käyttää argumentin minimi- ja maksimiarvoa. Palaa siis koodisi loppuun ja kirjoita seuraava rivi:
```
rightNum = random.randint (0, 1000)
```

Vaihe 5. Hanki syötettä soittimesta

Pelissä pelaaja haluaa tehdä jotain tai olla vuorovaikutuksessa jonkin kanssa. Tekstipelissä tämä on mahdollista kirjoittamalla tekstiä. Nyt kun meillä on satunnaisluku, seuraavien koodiriviemme pitäisi pyytää pelaajaa antamaan paras arvauksensa.

Koska syöttämäsi koodi tulostaa ohjeet numeron syöttämiseen soittimeen, sen pitäisi myös lukea syöttämäsi numero. Tämä tehdään syötteellä () Python 3: ssa ja raw_input () Python 2: ssa. Kirjoita Python 3: een, koska Python 2 vanhenee pian. Lisää seuraava rivi koodiisi tallentaaksesi pelaajan syötteen muuttujaan nimeltä numero:
```
userNum = input ()
```

Vaihe 6. Muuta soittimen syötteet käytettäviksi tietotyypeiksi

Pelaaja on syöttänyt numeron-mitä nyt?

Tee pelaajan syöttämästä numero. Tämä saattaa kuulostaa hämmentävältä, koska he ovat juuri syöttäneet numeron. Mutta siihen on hyvä syy: Python olettaa, että kaikki syötteet ovat tekstiä tai "merkkijonoa", kuten sitä kutsutaan ohjelmoinnissa. Tämä teksti sisältää numeron, jonka haluat saada. Pythonissa on toiminto, joka muuntaa vain numeron sisältävän merkkijonon sisälle. Tyyppi:
```
userNum = int (käyttäjänumero)
```

Vaihe 7. Vertaa pelaajan numeroa oikeaan numeroon

Kun pelaaja on syöttänyt numeronsa, sinun on verrattava sitä satunnaisesti luotuun numeroon. Jos numerot eivät ole samat, peli voi saada pelaajan kokeilemaan toista numeroa. Jos numerot täsmäävät, voit kertoa pelaajalle, että he arvasivat oikein, ja lopettaa ohjelman. Tämä tehdään seuraavalla koodilla:

kun userNum! = rightNum: userNum = int (input ())

Vaihe 8. Anna pelaajalle palautetta

Vaikka olet jo käsitellyt heidän syötteensä, pelaaja ei näe tätä. Sinun on itse tulostettava tulokset pelaajalle, jotta hän ymmärtää mitä tapahtuu.

Voit varmasti kertoa pelaajalle, onko heidän numeronsa oikea vai väärä. Mutta tällä lähestymistavalla pelaaja saattaa joutua arvaamaan 1000 kertaa pahimmassa tapauksessa, mikä olisi erittäin tylsää.
Kerro siis pelaajalle, onko heidän numeronsa liian pieni vai liian suuri. Tämä vähentää heidän arvaustensa määrää merkittävästi. Jos esimerkiksi pelaaja arvaa ensin 500 ja peli vastaa "Liian suuri. Yritä uudelleen", mahdollisia numeroita on vain 500 sijasta 1000. Tämä tehdään if-rakenteilla, joten vaihda tuloste ("Väärä. Yritä uudelleen. ") Yhden kanssa.
Huomaa, että tarkistetaan, ovatko kaksi numeroa samat, käyttämällä ==, ei =. = määrittää oikeanpuoleisen arvon sen vasemmalla puolella olevalle muuttujalle!

if userNum <rightNum: print ("Liian pieni. Yritä uudelleen:") if userNum> rightNum: print ("Liian iso. Yritä uudelleen:")

Vaihe 9. Testaa koodisi

Ohjelmoijana sinun tulee olla varma, että koodisi toimii ennen kuin harkitset sen valmistumista.

Kun ohjelmoit pythonissa, varmista, että sisennykset ovat oikein. Koodisi pitäisi näyttää tältä:

tuoda satunnaista tulosta ("Tervetuloa numeroarvauspeliin!") print ("Anna kokonaisluku väliltä 1 ja 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) kun userNum! = rightNum: jos userNum <rightNum: print ("Liian pieni. Yritä uudelleen:") if userNum> rightNum: print ("Liian iso. Yritä uudelleen:") userNum = int (input ()) print ("Arvasit oikein. ")

Vaihe 10. Tarkista tulo

Pelaajan ei pitäisi voida rikkoa peliäsi yksinkertaisesti syöttämällä väärän asian. "Syötteen vahvistaminen" tarkoittaa, että varmistetaan, että pelaaja on syöttänyt oikein ennen sen käsittelyä.

Avaa peli uudelleen ja yritä syöttää mitään, joka ei ole numero. Peli poistuu ValueError -virheellä. Tämän välttämiseksi voit ottaa käyttöön tavan tarkistaa, onko syöte numero.
Määritä toiminto. Koska syötteen validointi on melko pitkä ja sinun on tehtävä se useita kertoja, sinun on määritettävä toiminto. Se ei vaadi argumentteja ja palauttaa numeron. Kirjoita ensin def numInput (): koodisi yläosaan, suoraan tuontitodistukseen.
Hanki pelaajan panos kerran. Käytä input () -toimintoa ja määritä tulos muuttujalle inp.
Jos pelaajan syöttö ei ole numero, pyydä häntä syöttämään numero. Voit tarkistaa, onko merkkijono numero, käyttämällä isdigit () -funktioita, jotka sallivat vain kokonaisluvun, joten sinun ei tarvitse tarkistaa sitä erikseen.
Jos syöte on luku, muunna se merkkijonosta numeroksi ja palauta tulos. Käytä int () -funktiota merkkijonon muuntamiseen kokonaisluvuksi. Tämä tekee pääkoodin muuntamisesta tarpeettomaksi ja sinun on poistettava se sieltä.
Korvaa kaikki pääkoodin input () -kutsut numInput () -puheluilla.
Funktion numInput () koodi näyttää tältä:

def numInput (): inp = input () kun ei tuloa. isdigit (): print ("Sinua käskettiin syöttämään kokonaisluku! Anna kokonaisluku:") inp = input () return int (inp)

Vaihe 11. Testaa peli uudelleen

Kirjoita väärät asiat tarkoituksella nähdäksesi mitä tapahtuu, ja korjaa sitten mahdolliset virheet.

Kirjoita tekstiä, kun ohjelma pyytää numeroa. Nyt sen sijaan, että poistuttaisiin virheilmoituksella, ohjelma pyytää sinulta numeron uudelleen

Vaihe 12. Ehdota pelin käynnistämistä uudelleen sen päätyttyä

Tällä tavalla pelaaja voi pelata peliäsi pidempään ilman, että sitä tarvitsee käynnistää jatkuvasti uudelleen.

Laita kaikki koodit tuontia ja funktion määritelmää lukuun ottamatta while-silmukkaan. Aseta ehdoksi True: tämä on aina totta, joten silmukka jatkuu ikuisesti.
Kysy pelaajalta, haluavatko he pelata uudelleen sen jälkeen, kun he arvasivat numeron oikein. Käytä print () -toimintoa.
Jos he vastaavat "ei", poistu ilmeestä. Jos he vastaavat muuhun, jatka. Silmukasta poistuminen tapahtuu taukolausekkeella.
Siirrä "Tervetuloa numeroarvauspeliin" -silmukan ulkopuolelle. Pelaaja ei todennäköisesti halua tulla tervetulleeksi joka kerta, kun he pelaavat peliä. Siirrä ohjepainatus ("Tervetuloa numeroarvauspeliin!"), Kun taas Tosi: -kohdan yläpuolella, joten se tulostetaan vain kerran, kun käyttäjä aloittaa ensimmäisen pelin.

Vaihe 13. Testaa peli

Sinun on testattava peli aina, kun otat käyttöön uuden ominaisuuden.

Varmista, että vastaat sekä "kyllä" että "ei" vähintään kerran varmistaaksesi, että molemmat vaihtoehdot toimivat. Koodin pitäisi näyttää tältä:

tuoda satunnaisia määriä ("Tervetuloa numeroarvauspeliin!") Kun True: print ("Anna kokonaisluku väliltä 1 ja 1000:") rightNum = random.randint (0, 1000) userNum = numInput () kun userNum! = RightNum: if userNum <rightNum: print ("Liian pieni. Yritä uudelleen:") if userNum> rightNum: print ("Liian iso. Yritä uudelleen:") userNum = numInput () print ("Arvasit oikein.") print ("Oletko haluatko pelata uudelleen? Lopeta kirjoittamalla Ei. ") if input () ==" No ": break

Vaihe 14. Kirjoita muita tekstipohjaisia pelejä

Entä jos kirjoitat seuraavaksi tekstiseikkailun? Tai tietokilpailu? Ole luova.

Kärki: Joskus on hyödyllistä tutustua asiakirjoihin, jos et ole varma, miten jotain tehdään tai miten toimintoa käytetään. Python 3 -dokumentaatio löytyy osoitteesta https://docs.python.org/3/. Joskus etsiminen kaikesta mitä haluat tehdä Internetissä palauttaa myös hyviä tuloksia.

Osa 2/3: Pelin tekeminen 2D -grafiikalla

Vaihe 1. Valitse grafiikkakirjasto

Grafiikan tekeminen on hyvin monimutkaista, ja useimmat ohjelmointikielet (mukaan lukien Python, C ++, C, JavaScript) tarjoavat vain minimaalisen tuen tai ei lainkaan tukea ydin- tai vakiokirjastojen grafiikalle. Joten sinun on käytettävä ulkoista kirjastoa voidaksesi tehdä grafiikkaa, esimerkiksi Pygame for Python.

Jopa grafiikkakirjaston kanssa sinun on huolehdittava esimerkiksi valikon näyttämisestä, pelaajan napsautuksen tarkistamisesta, ruutujen näyttämisestä ja niin edelleen. Jos haluat keskittyä varsinaisen pelin kehittämiseen, voit käyttää Unityn kaltaista pelimoottorikirjastoa, joka toteuttaa nämä asiat helposti

Tässä artikkelissa käytetään Pythonia Cocos2D: n kanssa yksinkertaisen 2D -tasohyppelyn tekemiseen. Joitakin mainituista käsitteistä ei ehkä ole muissa pelimoottoreissa. Katso lisätietoja heidän asiakirjoistaan.

Vaihe 2. Asenna valitsemasi grafiikkakirjasto

Cocos2D for Python on helppo asentaa. Saat sen osoitteesta https://python.cocos2d.org/index.html tai suorittamalla sudo pip3 install cocos2d, jos käytät Linuxia.

Vaihe 3. Luo uusi hakemisto pelillesi ja mediallesi

Käytät peleissäsi esimerkiksi kuvia ja ääniä. Pidä nämä asiat samassa hakemistossa kuin ohjelma. Tämän hakemiston ei pitäisi sisältää mitään muuta, jotta näet helposti, mitä omaisuutta sinulla on pelissä.

Vaihe 4. Luo uusi kooditiedosto uuteen hakemistoon

Kutsu sitä pääohjelmointikielesi tiedostopääteksi. Jos kirjoitat suuren ja monimutkaisen ohjelman, jossa on järkevää käyttää useita ohjelmatiedostoja, tämä näyttää sinulle, mikä on päätiedosto.

Tässä esimerkissä luomme tiedoston nimeltä main.py, joka sisältää kaiken koodimme

Vaihe 5. Luo peli -ikkuna

Tämä on graafisen pelin perusedellytys.

Tuo tarvittavat cocos2d-alimoduulit: cocos.director, cocos.cene ja cocos.layer. Tämä tehdään subModuleName-tuonnista *, jossa alimoduulin nimi on tuotava alimoduuli. Ero… tuonnista * ja tuonnista… on se, että sinun ei tarvitse laittaa moduulin nimeä kaikkeen, mitä käytät tästä moduulista edellisen kanssa.
Määritä ColorLayerin alaluokka MainMenuBgr. Tämä tarkoittaa pohjimmiltaan sitä, että kaikki luomasi päävalikon tausta käyttäytyy kuin väritaso, mutta joitakin muutoksia teet.
Aloita kookosohjaaja. Tämä antaa sinulle uuden ikkunan. Jos et määritä kuvatekstiä, ikkunassa on sama tekstitys kuin tiedostonimellä (main.py), joka ei näytä ammattimaiselta. Salli ikkunan koon muuttaminen asettamalla sen kooksi Tosi.
Määritä toiminto showMainMenu. Sinun tulee laittaa päävalikon näyttämisen koodi funktioksi, koska sen avulla voit helposti palata päävalikkoon kutsumalla toiminnon uudelleen.
Luo kohtaus. Kohtaus koostuu toistaiseksi yhdestä kerroksesta, joka on määrittämäsi MainMenuBgr -luokan kohde.
Suorita tämä kohtaus ikkunassa.

cocos.director -tuonnista * cocos.scene -tuonnista * cocos.layer -tuonnista * -luokka MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenu, self)._ init _ (0, 200, 255, 255) def showMainMenu (): menuSc = Scene (MainMenuBgr ()) director.run (menuSc) director.init (caption = "IcyPlat - yksinkertainen tasohyppely", resizable = True) showMainMenu ()

Vaihe 6. Lisää päävalikko ikkunaan

Varsinaisen pelin lisäksi sinun on lisättävä valikko, jota pelaaja voi käyttää ikkunan sulkemiseen, muiden myöhemmin lisättävien elementtien joukkoon.

Tuo cocos.valikko (jälleen ohjeiden mukaan) ja pyglet.app (tällä kertaa tuonnin kanssa).
Määritä MainMenu valikon alaluokiksi.
Aseta päävalikon kohdistus. Pysty- ja vaakasuunta on asetettava erikseen.
Luo luettelo valikkokohteista ja lisää ne valikkoon. Sinulla pitäisi olla vähintään valikkokohdat "Aloita peli" ja "Lopeta". Jokainen valikkokohta on sijoitettava hakasulkeisiin. Jokaisessa tuotteessa on oltava tarra ja soittotoiminto, joka määrittää, mitä tapahtuu, kun pelaaja napsauttaa sitä. Käytä "Aloita peli" -kohtaa aloituspeli -funktiolla (kirjoitat sen pian), "Lopeta" -kohdassa "pyglet.app.exit" (jo olemassa). Luo varsinainen valikko soittamalla self.create_menu (menuItems).
Määritä startGame (). Laita vain pass määritelmään nyt, korvaat sen, kun kirjoitat varsinaista peliä.
Siirry koodisi kohtaan, jossa loit menuSc -kohtauksen, ja lisää siihen MainMenu -objekti.

Koko koodisi pitäisi nyt näyttää tältä:

cocos.director -tuonnista * cocos.menu -tuonnista * cocos.scene -tuonnista * cocos.layer -tuonnista * tuontipyglet.app -luokka MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) luokka MainMenu (Menu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Aloita peli) ", startGame)), (MenuItem (" Quit ", pyglet.app.exit))] self.create_menu (menuItems) def startGame (): pass def showMainMenu (): menuSc = Scene (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) director.init (caption = "IcyPlat - yksinkertainen tasohyppely", resizable = True) showMainMenu ()

Vaihe 7. Testaa koodisi

Testaa koodi varhain, vaikka se on vielä lyhyt ja suhteellisen yksinkertainen. Sitten voit tunnistaa ja korjata mahdolliset virheet perusrakenteessa, ennen kuin asiat muuttuvat liian monimutkaisiksi.

Ohjeiden koodin pitäisi avata ikkuna, jossa on teksti "IcyPlat - yksinkertainen tasohyppely." Tausta on vaaleansininen ja voit muuttaa ikkunan kokoa. Kun napsautat valikossa "Aloita peli", mitään ei pitäisi tapahtua (vielä). Kun napsautat "Lopeta", ikkuna sulkeutuu

Vaihe 8. Luo sprite

Sprite on "peliobjekti" tai 2-ulotteinen kuva. Sprites voi olla pelin sisäisiä esineitä, kuvakkeita, taustakoristeita, hahmoja ja kaikkea muuta, mitä voit esittää pelin kuvalla. Aloitamme luomalla sprite hahmolle, jonka kanssa pelaaja voi olla vuorovaikutuksessa.

Tuo cocos.sprite-alimoduuli tuonti-lausekkeella.
Etsi kuva, joka edustaa spriteä. Et voi näyttää spriteä, jos sinulla ei ole kuvaa siitä. Voit piirtää yhden tai voit hankkia sellaisen Internetistä (varo lisenssejä kuitenkin, jos aiot julkaista pelisi). Tässä esimerkissä pääset osoitteeseen https://opengameart.org/content/tux-classic-hero-style ja tallenna juoksemien pingviinien PNG-kuva tietokoneellesi. Leikkaa sitten yksi juoksevista pingviineistä, koska tarvitset vain toista.
Luo kerros ScrollableLayer -luokan uudeksi objektiksi. Luo sitten sprite Sprite -objektiksi ja aseta sen sijainti (8, 250). Vertailun vuoksi piste (0, 0) on vasemmassa alakulmassa. Tämä on melko korkea, mutta se varmistaa, että pingviini ei jää jumiin.
Lisää sprite sprite -kerrokseen.
Luo uusi kohtaus spriten kerroksesta ja suorita se.

def startGame (): figLayer = ScrollableLayer () kuva = Sprite ('pingu.png') kuva. sijainti = (75, 100) figLayer.add (kuva) # gameSc = Kohtaus (figLayer) director.run (gameSc)

Suorita koodi. Sinun pitäisi nähdä pieni pingviinihahmo (tai mitä piirsit) mustalla taustalla napsautuksen jälkeen Aloita peli.

Vaihe 9. Unelmoi maisemastasi

Useimmissa peleissä spritesi eivät saisi vain kellua tyhjässä. Heidän pitäisi itse asiassa seisoa jollakin pinnalla, jotain ympärillään. 2D -peleissä tämä tehdään usein laattajoukolla ja laattakartalla. Laattajoukko kertoo pohjimmiltaan, millaisia pintaruutuja ja taustaneliöitä on olemassa ja miltä ne näyttävät.

Luo laattajoukko. Tämän pelin laatta on hyvin yksinkertainen: yksi laatta jäälle ja yksi laatta taivaalle. Tässä esimerkissä käytetty jäälaatta on peräisin CC-BY-SA 3.0: sta.
Luo laattajoukon kuva. Se on kuva kaikista laattoista, joiden kaikkien on oltava samankokoisia (muokkaa niitä, jos ne eivät ole) ja joiden koko on haluamasi pelissä, vierekkäin. Tallenna kuva nimellä icyTiles.png.
Luo laattajoukon kuvaus. Se on XML -tiedosto. XML -tiedosto sisältää tietoja siitä, kuinka suuret laatat ovat laattajoukon kuvassa, mitä kuvaa käytetään ja mistä ruutu löytyy. Luo XML -tiedosto nimeltä icyTiles.xml alla olevalla koodilla:
```
     
```

Vaihe 10. Tee laattakartta maisemaasi varten

Laattakartta on kartta, joka määrittää, mikä laatta on missä tasosi tasolla. Esimerkissä sinun on määritettävä funktio laattakarttojen luomiseksi, koska laattakarttojen suunnittelu käsin on erittäin työlästä. Kehittyneemmässä pelissä olisi yleensä jonkinlainen tason muokkausohjelma, mutta 2D -pelikehityksen tuntemiseen algoritmi voi tarjota riittävän hyviä tasoja.

Selvitä, kuinka monta riviä ja saraketta tarvitaan. Jaa tätä varten näytön koko laattojen koolla sekä vaakasuunnassa (sarakkeet) että pystysuunnassa (rivit). Pyöristä numero ylöspäin; tarvitset siihen matematiikkamoduulin toiminnon, joten lisää matematiikan tuontikatosta koodin yläosassa olevaan tuontiin.
Avaa tiedosto kirjoittamista varten. Tämä poistaa kaiken tiedoston aiemman sisällön, joten valitse nimi, jolla ei ole vielä yhtään hakemiston tiedostoa, kuten levelMap.xml.
Kirjoita avaustunnisteet tiedostoon.
Luo laattakartta algoritmin mukaan. Käytät alla olevassa koodissa olevaa tai voit keksiä sellaisen itse. Muista tuoda randint -funktio moduulista random: se vaaditaan, jotta alla oleva koodi toimisi, ja mitä keksit, luultavasti tarvitsee myös satunnaisia kokonaislukuja. Varmista myös, että laitat taivaslaatat ja jäälaatat eri kerroksiin: jää on kiinteää, taivas ei.
Kirjoita lopetustagit tiedostoon ja sulje tiedosto.

defgeneTilemap (): colAmount = katto (800/16) * 3 # (näytön leveys / laatan koko) * 3 rowAmount = katto (600/16) # näytön korkeus / laatan koko tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) i: lle alueella (0, colAmount): tileFile.write ('') makeHole = False if randint (0, 50)) == 10 ja i! = 0: # älä salli reikiä spawnpointissa makeHole = True j: lle alueella (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: # rajoittaa laattojen menemistä liian matalalle IceHeight = randint (1, 5) if iceHeight> rowAmount: # limit laatat menemästä liian korkealle iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') i: lle alueella (0, colAmount): tileFile.write ('') j: lle alueella (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Vaihe 11. Näytä ruutukartta

Tuo kaikki osoitteesta cocos.tiles ja siirry sitten siihen startGame -toimintoon.

Luo startGame -toiminnon alussa ruutukartta käyttämällä sille määrittämääsi funktiota.
Luo uusi vierityshallinta. Tee tämä suoraan sen viivan alla, johon lisäät sprite -kerroksen.
Luo uusi kerros, joka sisältää laatat, ja se ladataan generoitava laattafunktiosi luomasta levelMap.xml -laattakartasta.
Lisää ei-kiinteä kerros, kiinteä kerros ja sprite-kerros vierityshallintaan täsmälleen tässä järjestyksessä. Voit halutessasi lisätä z-aseman.
Sen sijaan, että luot kohtauksen sprite -kerroksesta, luo se vierityshallinnasta.

StartGame -toiminnon pitäisi nyt näyttää tältä:

def startGame ():geneTilemap () # fig = Sprite ('pingu.png') Fig.position = (8, 500) figLayer = ScrollableLayer () figLayer.add (kuva) # 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 = Kohtaus (scrMang) director.run (gameSc)

Vaihe 12. Testaa koodisi

Sinun on testattava koodiasi usein varmistaaksesi, että käyttämäsi uudet ominaisuudet todella toimivat.

Esimerkin koodin pitäisi nyt näyttää jäistä maisemaa pingviinin takana. Jos pingviini näyttää leijuvan kauas jään yläpuolella, et tehnyt mitään väärää, ja se korjataan seuraavassa vaiheessa

Vaihe 13. Lisää säätimet

Pelaajalla on paljon enemmän tapoja olla vuorovaikutuksessa ohjelman kanssa 2D-pelissä kuin tekstipohjaisessa pelissä. Yleinen kuva sisältää kuvan siirtämisen, kun oikeaa näppäintä painetaan.

Tuo kaikkea osoitteesta cocos.mapcolliders ja cocos.actions. Tuo myös avain pyglet.windowista.
"Ilmoita" joitain globaaleja muuttujia. Globaalimuuttujat jaetaan toimintojen kesken. Et voi todella ilmoittaa muuttujia Pythonissa, mutta sinun on sanottava, että pääkoodissa on globaali muuttuja ennen sen käyttöä. Voit määrittää arvon 0, koska toiminto huolehtii oikean arvon määrittämisestä myöhemmin. Joten lisää tuontilausekkeiden alle:
```
# "julistetaan" globaalimuuttujat näppäimistö = 0 scrMang = 0
```

StartGame -toiminnon säätäminen:

Oletetaan, että käytät globaalimuuttujien näppäimistöä ja scrMangia. Tee tämä kirjoittamalla yleinen näppäimistö, scrMang toiminnon yläosaan.
Anna ikkunan kuunnella näppäimistön tapahtumia.
Kerro kuvalle, että se toimii PlatformerControllerin perusteella. Otat PlatformerControllerin käyttöön pian.
Luo kartan törmäyslaite, joka käsittelee kiinteiden laattojen ja kuvion välisiä törmäyksiä.

def startGame (): yleinen näppäimistö, scrManggeneTilemap () # fig = Sprite ('pingu.png') kuva.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (kuva) # tileLayer = load ('levelMap.xml ') solidTiles = tileLayer [' solid '] nsoliTiles = tileLayer [' not_solid '] # keyboard = key. KeyStateHandler () director.window.push_handlers (näppäimistö) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on = 'dia') kuva. törmäyksen_käsittelijä = make_collision_handler (karttatekijä, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z =) 1) # gameSc = Kohtaus (scrMang) director.run (gameSc)

Luo tasohyppelyohjain. Tämä siirtää lukua näppäinten painallusten mukaan.
- Määritä tasohyppelyohjain toiminnan alaluokkaan.
- Määritä siirtonopeus, hyppynopeus ja painovoima.
- Määritä käynnistystoiminto. Tätä toimintoa kutsutaan kerran, kun tasohyppelyohjain on liitetty kuvaan. Sen nopeuden tulisi olla 0 sekä x- että y -suunnassa.
- Määritä askeltoiminto. Se toistetaan kohtauksen ollessa käynnissä.
- Käske vaihetoimintoa käyttämään yleisten muuttujien näppäimistöä ja scrMangia.
- Hanki ja muuta nopeutta. Tallenna nopeus x ja y erillisiin muuttujiin. Aseta x -nopeudeksi joko 1 tai -1 (riippuen siitä, onko vasenta tai oikeaa näppäintä painettu) kerrottuna siirtonopeudella. Lisää painovoima y -nopeuteen. Kerro se seisokkeilla, jotta se toimii samalla tavalla hitaammilla laitteilla. Jos välilyöntiä painetaan ja hahmo seisoo maassa, hyppää muuttamalla y -nopeutta hyppynopeudeksi.
- Laske mihin kuva siirtyy. Anna sitten törmäyskäsittelijän säätää tätä asentoa, jos se on kiinteän laatan sisällä. Siirrä lopuksi kuva uuteen säädettyyn asentoon.
- Aseta vierityshallinnan painopiste kuvioon. Tämä saa kameran liikkumaan kohtuullisella tavalla, kun kuva liikkuu.
```
luokan PlatformerController (toiminto): yleinen näppäimistö, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (self, dt): global keyboard, vieritys, jos dt> 0.1: # älä tee mitään seisokkien aikana suurelle paluulle vx, vy = self.target.velocity vx = (näppäimistö [key. RIGHT] - näppäimistö [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt jos self.on_ground ja näppäimistö [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 (viimeinen, uusi, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (*new.center)
```

Vaihe 14. Testaa koodisi

Jos seurasit esimerkkiä, sinun pitäisi nyt pystyä siirtämään pingviiniä nuolinäppäimillä ja hypätä painamalla välilyöntiä. Lisäksi pingviinin pitäisi nyt pudota sen sijaan, että se leijuisi maan päällä.

Vaihe 15. Luo pelille loppu

Jopa peleissä, jotka voivat jatkua loputtomasti, pitäisi olla mahdollisuus hävitä. Koska toiminnolla varustetussa esimerkissä tekemäsi taso on päättynyt, sinun on myös voitava voittaa tulemalla siihen. Muuten pelaaja hyppäisi vain siellä oleville jääpalikoille, mikä kyllästyisi.

Tasohyppelyohjaimen sisällä saat tarkennuksen jälkeen kuvan x- ja y -sijainnin. Jos y -asema on pienempi kuin 0, kutsu funktiota finishGame () (kirjoitat sen myöhemmin) ja "Game Over" on argumentti. Jos x -asema on suurempi kuin näytön koko kerrottuna 3: lla (olit asettanut sen tasokokoon aiemmin).
```
posX, posY = self.target.position if posY <0: finishGame ("Game Over") palaa, jos posX> 800*3: # level size finishGame ("Level Completed") palaa
```
Määritä luokan viimeistelyValikko. Sen pitäisi olla kuten aiemmin määrittämäsi päävalikkoluokka, mutta sen sijaan, että otsikossa olisi tyhjä merkkijono, sen pitäisi käyttää muuttuvaa tekstiä, jota _init_ -funktio käyttää argumenttina. Valikkokohtien tulee olla merkitty "Yritä uudelleen" ja "Lopeta" nyt, mutta niiden kutsumat toiminnot pysyvät ennallaan.
```
class FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Yritä uudelleen", startGame)), (MenuItem ("Lopeta", pyglet.app.exit))] self.create_menu (menuItems)
```
Määrittele toiminto finishGame (). Sen pitäisi ottaa tekstiä argumenttina. Sen pitäisi tehdä kohtaus päävalikon taustasta, FinishMenu, jossa teksti -argumentti siirretään tähän valikkoon. Sen pitäisi sitten suorittaa tämä kohtaus.
```
def finishGame (teksti): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (teksti)) director.run (menuSc)
```

Vaihe 16. Lisää krediittejä

Täällä saat tunnustusta mahtavasta koodistasi sekä luottoa muille, jotka ovat auttaneet sinua matkan varrella. Jos käytit kuvaa toiselta verkkosivustolta (luvalla), muista kohdistaa kuva sen luojalle.

Luo tiedosto CREDITS ja kirjoita kaikki hyvityksesi sinne, kuten tämä:
```
Pingviini: Kelvin Shadewing CC0: n alla
```
Palaa Python -koodisi luo ja tuo Label osoitteesta cocos.text.

Määritä tason Credits of Layer alaluokka. Lue _init_ -toiminnossaan CREDITS -tiedosto ja tee tekstitarra oikeaan kohtaan jokaisen rivin kohdalta.

luokka Laajuus (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") i: lle alueella (0, len (creds)): credLabel = Label (creds , font_size = 32, anchor_x =" left ", anchor_y =" top ") credLabel.position = 25, 500- (i +1)*40 self.add (credLabel)

Siirry päävalikkoluokkaan ja lisää valikkokohta "Luotot", joka kutsuu funktiota showCredits napsautettaessa.
Määritä valikon alaluokka BackToMainMenuButton. Tee tästä valikosta yksi kohta, jonka nimi on "Takaisin" ja joka kutsuu showMainMenu -toiminnon. Tämä "valikko", joka muistuttaa enemmän painiketta, on kohdistettava pystysuoraan alareunaan ja vaakasuoraan yläosaan.
```
class BackToMainMenuButton (Valikko): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self. create_menu (menuItems)
```
Määritä funktio showCredits. Sen pitäisi tehdä kohtaus MainMenuBgr -kerroksesta ja Credits -kerroksesta ja suorittaa kyseinen kohtaus.
```
def showCredits (): credSc = Kohtaus (MainMenuBgr ()) credSc.add (Laajuus ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)
```

Vaihe 17. Tarkista koodi

Kun luulet koodin olevan valmis, sinun on tarkasteltava sitä uudelleen. Tämä voi auttaa sinua huomaamaan, voidaanko jotain optimoida tai unohditko poistaa tarpeettomia rivejä. Jos seurasit esimerkkiä, koko koodisi pitäisi nyt näyttää tältä:

cocos.director -tuonnista * cocos.menu -tuonnista * cocos.scene -tuonnista * cocos.layer -tuonnista * cocos.sprite -tuonnista * cocos.tiles -tuonnista * cocos.mapcolliders -tuonnista * cocos.actions -tuonnista * cocosista.teksti tuonti Label tuonti pyglet.app pyglet.window tuonti avain matematiikan tuontikatosta satunnaisesta tuonnista itse)._ init _ (0, 200, 255, 255) luokka MainMenu (Menu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Aloita peli", startGame)), (MenuItem ("Laajuus", showCredits)), (MenuItem ("Lopeta", pyglet.app.exit))] self.create_menu (menuItems) -luokka Credits (Layer): def _init _ (itse): super (Laajuus, itse)._ init _ () credFile = avoin ("LUOTOT", "r") creds = credFile.read () creds = creds.split ("\ n") i alueella (0, len (creds)): credLabel = Label (creds , font_size = 32, anchor_x = "left", anchor_y = "top") credLabel.position = 25, 500- (i+1)*40 self.add (credLabel) -luokka BackToMainMenuButton (Valikko): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self.create_menu (menuItems) -luokka FinishMenu (Menu): def (_init) self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Yritä uudelleen", startGame)), (MenuItem ("Lopeta", pyglet). app.exit))] self.create_menu (menuItems) -luokka PlatformerController (Action): yleinen näppäimistö, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (itse, dt): yleinen näppäimistö, vieritys, jos dt> 0.1: # älä tee mitään seisokkeissa liian suuri return vx, vy = self.target.velocity vx = (näppäimistö [key. RIGHT] - näppäimistö [key. LEFT]) * self. MOVE_SPEED vy += self. GRAVITY * dt if self.on _maa ja näppäimistö [key. SPACE]: vy = itse. 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 (viimeinen, uusi, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center) posX, posY = self.target.position if posY <0: finishGame ("Game Over") palaa, jos posX> 800*3: # level size finishGame ("Level Completed") return def finishGame (teksti): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (teksti)) director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc) defgeneTilemap (): colAmount = katto (800/16) * 3 # (näytön leveys / laatan koko) * 3 rowAmount = katto (600/16) # näytön korkeus / laatan koko tileFile = open ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) i: lle alueella (0, colAmount): tileFile.write ('') makeHole = Väärä jos rand int (0, 50) == 10 ja i! = 0: # älä salli reikiä spawnpointissa makeHole = True j: lle alueella (0, rowAmount): if makeHole: tileFile.write ('\ n') else: jos j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) if iceHeight <0: # rajoittaa laattojen lähtöä low iceHeight = randint (1, 5) if iceHeight> rowAmount: # limit laatat menemästä liian korkeaksiHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') i: lle alueella (0, colAmount): tileFile.write (' ') j: lle alueella (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): yleinen näppäimistö, scrManggeneTilemap () # fig = Sprite ('pingu.png') kuva.asento = (8, 250) figLayer = ScrollableLayer () figLayer.add (kuva) # tileLayer = load ('levelMap.xml') solidTiles = tileLayer ['solid'] nsoliTiles = tileLayer ['not_solid'] # keyboard = key. KeyStateHandler () director.window.push_handlers (näppäimistö ard) # kuva.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump = 'slide') kuva.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoli -1), z = add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc) def showMainMenu (): menuSc = Scene (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) window = director.init (caption = "IcyPlat - yksinkertainen tasohyppely", resizable = True) showMainMenu ()

Nämä ovat yhteensä 168 riviä ja 152 riviä, jos lasket vain koodin. Tämä vaikuttaa paljon, mutta näin monimutkaisessa pelissä tämä on todella pieni määrä.

Vaihe 18. Valmis

Testaa nyt peli. Kun ohjelmoit jotain, sinun on tarkistettava, toimiiko se aina, kun olet toteuttanut jotain uutta. Voit myös haluta pelata kirjoittamaasi peliä jonkin aikaa.

Osa 3/3: Pelin julkaiseminen

Vaihe 1. Kirjoita riippuvuudet muistiin

Toista tietokonetta käyttävillä ei ole samoja ohjelmistoja ja kirjastoja kuin sinulla. Sinun on siis varmistettava, että kaikki pelin asentaneet tietävät tarkalleen, mitä he tarvitsevat sen suorittamiseen. Sinun ei tarvitse kirjoittaa muistiin kaikkien riippuvuuksien riippuvuuksia ja niin edelleen, mutta sinun tulee ainakin kirjoittaa pakettien riippuvuudet ja niiden riippuvuudet.

Vaihe 2. Varmista, että sinulla on lupa käyttää kaikkia medioita

Tämä koskee kaikkea grafiikkaa, mukaan lukien 3D -mallit, musiikki, dialogi, musiikki, kirjastot ja pelissä käyttämäsi kehykset. Kaikki mitä et itse kirjoittanut.

Usein on joitain ehtoja, kuten joudutaan hyvittämään tekijä tai jakamaan median muutokset samalla lisenssillä. Joskus voit käyttää grafiikkaa määrittelemättä tekijöitä, kunhan et veloita pelistä. Jos sinun on kunnioitettava tekijää, tee se hyvin näkyvässä paikassa, kuten pelisi "Lainat" -välilehdessä.
On myös mediaa, josta on tekijänoikeudet luvattu ja lisenssiä ei ole määritetty, joskus tekstiä, kuten "Kaikki oikeudet pidätetään". Jos näin on, sinun on saatava nimenomainen lupa tekijältä ennen sen sisällyttämistä peliin.
Kirjastot julkaistaan yleensä lisensseillä, jotka sallivat niiden käytön kirjastoina. Huomattava poikkeus on GPL ilman linkityspoikkeusta: Tällainen lisenssi sallii sen käytön vain ohjelmassa, jolla on tiettyjä lisenssejä. Ja sinun tulee aina lukea ainakin lisenssin peruskohdat varmistaaksesi, että kaikki mitä teet median tai kirjaston kanssa, on sallittua.

Varoitus: Median tai kirjastojen käyttäminen tavalla, jota lisenssi ei salli julkaisemassasi pelissä, voi aiheuttaa vakavia oikeudellisia ongelmia. Joten joko kysy kirjoittajalta tai vältä mediaa kokonaan, jos olet epävarma siitä, onko käyttö sallittua.

Vaihe 3. Päätä ehdoista, joissa haluat julkaista pelisi

Myytkö pelisi? Haluatko antaa muiden käyttää kuviasi ja ideoitasi? Vaikka sinun on oltava varovainen projektissasi käyttämässäsi mediassa, voit yleensä päättää, kuinka haluat antaa muiden käyttää peliäsi. Voit käyttää peliäsi julkisesti Creative Commons CC0 -lisenssillä. Jos haluat sallia jakelun ja muokkaamisen tietyin edellytyksin ja samalla säilyttäen joitakin oikeuksia, kokeile Gnu General Public License (GPL) - tai Berkeley Software Distribution (BSD) -lisenssiä. Tai voit tehdä ohjelmistostasi omistusoikeuden, eli kukaan ei saa levittää tai muokata sitä ilman lupaasi.

Vaikka on mahdollista ansaita rahaa myymällä pelejä, on epätodennäköistä, että ihmiset ostavat ensimmäisen pelisi, jossa on yleensä vähän ominaisuuksia eikä mitään erityistä. Lisäksi, jos ilmainen ohjelma ei toimi, sen lataaneet ihmiset ovat vain pettyneitä. Jos he kuitenkin maksoivat siitä, he vaativat rahansa takaisin, aiheuttaen enemmän ongelmia sekä sinulle että käyttäjille. Joten harkitse muutaman ensimmäisen ohjelmansa ilmaista käyttöä

Vaihe 4. Päätä, miten haluat julkaista pelisi

Jokaisella menetelmällä on joitain etuja ja haittoja, joten sinun on päätettävä itse.

Julkaiseminen verkkosivustolla:

Jos sinulla on verkkosivusto, voit ladata pelisi ladattavaksi. Varmista, että annat selkeät ohjeet ohjelmiston asentamisesta sekä kaikki tarvittavat riippuvuudet. Tämän haittana on, että pelaajien on asennettava riippuvuudet manuaalisesti, mikä voi olla vaikeaa joillekin ihmisille.
Paketin tekeminen paketinhallinnalle:

On olemassa erilaisia paketinhallintaohjelmia, kuten apt, Yum ja Homebrew, joiden avulla ihmisten on helppo asentaa sovelluksia Linux- ja Linux-pohjaisiin ympäristöihin. Niillä kaikilla on erilaiset pakkausmuodot. Pakettien hyvä puoli on, että ne asentavat automaattisesti kaikki riippuvuudet (jos määrität ne oikein). Joten pelaajan tarvitsee vain asentaa paketti ja sitten pelata peliä. Ongelmana on, että eri alustoilla on monia erilaisia pakettien hallitsijoita, joten sinun on ponnisteltava tarjoamalla paketteja kaikille yleisimmille.

Vaihe 5. Kiinnitä huomiota ohjelmaan

Harkitse ohjelman lataamista suurelle pakettivarastolle, kuten Ubuntun ja Debianin ylläpitämä, helpon asennuksen mahdollistamiseksi. Julkaise myös sopivilla foorumeilla, kuten GameDevin projektiosassa tai osassa tigSourcea. Mutta älä ole pettynyt, jos ensimmäisistä peleistäsi ei tule kuuluisia. Jos sinulla on käsitys siitä, että monet ihmiset pitävät siitä, pelisi voi tulla tunnetuksi.

Vinkkejä

Ole kärsivällinen ja valmis oppimaan. Ohjelmointi voi olla välillä turhauttavaa!
Jos ihmettelet, miten jotain tehdään toisessa pelissä ja peli on avoimen lähdekoodin, voit katsoa sen lähdekoodia.
Kun etsit mediaa, yritä löytää julkista sisältöä. Hae "Creative Commons" - tai "Public Domain" -kuvia ja -musiikkia ja käytä verkkosivustoja, kuten https://opengameart.org tai
Älä kopioi suuria koodipaloja tarkistamatta lisenssiä. Se on usein kielletty, ja jos ei, se vaatii yleensä nimeämistä.
Älä tee roskapostia tai lähetä sopimattomiin paikkoihin, kun mainostat peliäsi. Tämä todennäköisesti estää sinua sivulta, on yksinkertaisesti ärsyttävää ja vahingoittaa mainettasi.