Hoe om rekenaarspeletjies te programmeer (met foto's)

2024 Outeur: Robert Blare | [email protected]. Laas verander: 2023-12-17 07:24

Het u 'n idee vir 'n rekenaarspeletjie en wil u dit werklik maak? Of het u al ooit gewonder hoe rekenaarspeletjies geskryf word? Hierdie wikiHow leer u hoe u drie basiese rekenaarspeletjies in Python skryf. U benodig 'n basiese begrip van Python en algemene programmeringskonsepte om u eerste spel te ontwikkel.

Stappe

Deel 1 van 3: Maak 'n teksgebaseerde spel

Stap 1. Kies 'n programmeertaal

Alle programmeertale is anders, dus u moet besluit watter een u wil gebruik om u speletjie te skryf. Elke groot programmeertaal ondersteun teksinvoer, teksuitvoer en if-konstruksies (die belangrikste dinge wat u nodig het vir 'n eenvoudige teksgebaseerde spel), dus ondersoek die opsies en besluit waarmee u die gemaklikste en toegewyde leerprogram voel. Hier is 'n paar faktore wat u moet oorweeg:

Waarvoor word die taal meestal gebruik?

Sommige programmeertale, soos JavaScript, is ontwerp om op die internet gebruik te word, terwyl ander, soos Python, C of C ++, ontwerp is om rekenaarprogramme uit te voer. Vir u spel, streef u na 'n taal met 'n groter toepassingsgebied, soos Python, C, C ++ of JavaScript.
Hoe moeilik is dit om te leer?

Alhoewel die skryf van 'n program maklik genoeg moet wees na 'n paar oefeninge in 'n normale programmeertaal (dit wil sê nie een wat spesifiek bedoel is om verwarrend soos Malbolge te wees nie), is sommige vriendeliker vir beginners as ander. Java en C, byvoorbeeld, sal van u vereis om dieper programmeerkonsepte te verstaan as iets soos Python, wat bekend is vir sy meer toeganklike en reguit sintaksis.
Waar kan ek dit gebruik?

U wil waarskynlik hê dat mense op verskillende stelsels, soos Linux, Mac of Windows, almal u speletjie kan speel. U moet dus nie 'n taal gebruik wat slegs op enkele stelsels ondersteun word nie, soos Visual Basic, wat slegs op Windows ondersteun word.

Hierdie artikel gebruik Python vir die voorbeelde van 'n teksgebaseerde spel, maar u kan kyk hoe die konsepte in enige ander programmeertaal gedoen word.

Stap 2. Maak u rekenaar gereed

Die twee hoofkomponente wat u benodig, is 'n teksredakteur waarin u u kode skryf, en 'n samesteller waarmee u dit in 'n speletjie kan verander. As u die voorbeeld in hierdie artikel wil volg, moet u Python installeer en leer hoe om programme uit te voer. As u wil, kan u 'n IDE (Integraded Desktop Environment) opstel wat redigering, samestelling en ontfouting in 'n enkele program kombineer. Python se IDE word IDLE genoem. Maar u kan ook enige teksredakteur gebruik wat gewone teks ondersteun, soos Notepad vir Windows, TextEdit vir macOS of Vim vir Linux.

Stap 3. Skryf 'n kode om die speler te groet

Die speler sal wil weet wat aan die gang is en wat hulle moet doen, dus moet u 'n paar teks daarvoor druk.

Dit word gedoen met die print () -funksie in Python. Om dit te probeer, maak 'n nuwe lêer oop met die.py -uitbreiding, voer die volgende kode daarin, stoor en voer dit uit:
```
print ("Welcome to the number guessing game!") print ("Tik 'n heelgetal tussen 1 en 1000:")
```

Stap 4. Genereer 'n ewekansige getal

Kom ons maak 'n teksgebaseerde speletjie wat die speler vra om die regte nommer te raai. Die eerste ding wat ons moet doen, is om 'n ewekansige getal aan die begin van die spel te genereer, sodat die speler nie altyd dieselfde nommer sal raai nie. Aangesien die getal gedurende die program dieselfde sal bly, wil u die ewekansige getal in 'n veranderlike stoor.

Python het nie 'n ingeboude ewekansige getalfunksie nie, maar wel 'n standaardbiblioteek (dit beteken dat die gebruiker niks ekstra hoef te installeer nie). Gaan dus aan die begin van u kode (voor die druk () -funksies) en tik die lyninvoer ewekansig in.
Gebruik die ewekansige funksie. Dit word randint () genoem, is in die ewekansige biblioteek wat u pas ingevoer het, en neem die minimale en maksimum waarde wat die getal kan hê as argument. Gaan dus terug na die einde van u kode en voer die volgende reël in:
```
rightNum = random.randint (0, 1000)
```

Stap 5. Kry insette van die speler

In 'n spel wil die speler iets doen of interaksie hê met iets. In 'n teksgebaseerde spel is dit moontlik deur teks in te voer. Noudat ons 'n ewekansige getal het, moet ons volgende reëls kode die speler vra om sy beste raaiskoot in te voer.

Aangesien die kode wat u ingevoer het, die instruksie om 'n nommer by die speler in te voer, afdruk, moet dit ook die nommer lees wat hulle ingevoer het. Dit word gedoen met invoer () in Python 3 en raw_input () in Python 2. U moet in Python 3 skryf, aangesien Python 2 binnekort verouderd sal word. Voeg die volgende reël by u kode om die invoer van die speler in 'n veranderlike met die naam nommer te stoor:
```
userNum = invoer ()
```

Stap 6. Verander die invoer van die speler in 'n bruikbare datatipe

Die speler het 'n nommer ingevoer-wat nou?

Maak die invoer van die speler 'n nommer. Dit klink miskien verwarrend omdat hulle net 'n nommer ingevoer het. Maar daar is 'n goeie rede: Python veronderstel dat alle invoer teks is, of 'n 'string', soos dit in programmering genoem word. Hierdie teks bevat die nommer wat u wil kry. Python het 'n funksie wat 'n string wat slegs 'n getal bevat, omskakel na die getal binne. Tipe:
```
userNum = int (userNum)
```

Stap 7. Vergelyk die speler se nommer met die korrekte nommer

Sodra die speler hul nommer ingevoer het, moet u dit vergelyk met die een wat lukraak gegenereer is. As die getalle nie dieselfde is nie, kan u spel 'n ander nommer laat probeer. As die getalle ooreenstem, kan u die speler vertel wat hulle reg geraai het en die program verlaat. Dit word gedoen met die volgende kode:

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

Stap 8. Gee die speler terugvoer

Terwyl u hul insette reeds verwerk het, sal die speler dit nie sien nie. U moet die resultate eintlik aan die speler druk, sodat hulle kan verstaan wat gebeur.

U kan die speler beslis vertel of die nommer reg of verkeerd is. Maar met hierdie benadering moet die speler in die ergste geval moontlik 1000 keer raai, wat baie vervelig sou wees.
Sê dus vir die speler of hul getal te klein of te groot is. Dit sal hul aantal raaiskote aansienlik verminder. As die speler byvoorbeeld eers 500 raai en die spel antwoord "Te groot. Probeer weer," is daar slegs 500 moontlike getalle in plaas van 1000. Dit word gedoen met if-konstruksies, dus vervang die afdruk ("Verkeerd. Probeer weer. ") Met een.
Hou in gedagte dat die kontrole of twee getalle dieselfde is, gedoen word met ==, nie met = nie. = ken die waarde regs daarvan toe aan die veranderlike links daarvan!

as userNum <rightNum: print ("Te klein. Probeer weer:") as userNum> rightNum: print ("Te groot. Probeer weer:")

Stap 9. Toets u kode

As programmeerder moet u seker wees dat u kode werk voordat u dit oorweeg.

As u in python programmeer, moet u seker maak dat die inkepings korrek is. Jou kode moet so lyk:

invoer ewekansige druk ("Welkom by die getal -raaisel!") druk ("Tik 'n heelgetal tussen 1 en 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) terwyl userNum! = rightNum: as userNum <rightNum: print ("Te klein. Probeer weer:") as userNum> rightNum: print ("Te groot. Probeer weer:") userNum = int (input ()) print ("U raai korrek. ")

Stap 10. Valideer die invoer

Die speler behoort nie u spel te kan breek deur eenvoudig die verkeerde ding in te voer nie. "Die invoer bekragtig" beteken om seker te maak dat die speler die regte ding ingevoer het voordat hy dit verwerk.

Maak die speletjie weer oop en probeer om iets in te voer wat nie 'n nommer is nie. Die spel sal met 'n ValueError afgesluit word. Om dit te vermy, kan u 'n manier implementeer om te kontroleer of die invoer 'n nommer was.
Definieer 'n funksie. Aangesien die invoer redelik lank is en u dit verskeie kere moet doen, moet u 'n funksie definieer. Dit neem geen argumente nie en gee 'n nommer terug. Skryf eers def numInput (): bo -aan u kode, direk onder die invoer ewekansig.
Kry die speler se insette een keer. Gebruik die input () -funksie en ken die resultaat toe aan die veranderlike inp.
As die speler se invoer nie 'n nommer is nie, vra hulle om 'n nommer in te voer. Om te kontroleer of 'n string 'n getal is, gebruik die funksies isdigit (), wat slegs 'n heelgetal toelaat, sodat u dit nie apart hoef te kontroleer nie.
As die invoer 'n getal is, skakel dit om van string na getal en gee die resultaat terug. Gebruik die funksie int () om die string om te skakel na 'n heelgetal. Dit sal die omskakeling in die hoofkode onnodig maak, en u moet dit daarvandaan verwyder.
Vervang alle oproepe na input () in die hoofkode met oproepe na numInput ().
Die kode van die funksie numInput () sal so lyk:

def numInput (): inp = input () terwyl nie inp.isdigit (): print ("U is aangesê om 'n heelgetal in te voer! Tik 'n heelgetal:") inp = input () return int (inp)

Stap 11. Toets die spel weer

Voer doelbewus die verkeerde dinge in om te sien wat gebeur, en los dan die foute op as dit opduik.

Probeer teks invoer as die program u 'n nommer vra. In plaas daarvan om met 'n foutboodskap af te sluit, sal die program u weer 'n nommer vra

Stap 12. Stel voor om die spel weer te begin wanneer dit klaar is

Op hierdie manier kan die speler u spel langer speel sonder om dit voortdurend te herbegin.

Plaas alle kode behalwe die invoer en die funksie-definisie in 'n while-lus. Stel Waar as die voorwaarde: dit sal altyd waar wees, so die lus sal vir ewig voortduur.
Vra die speler of hy weer wil speel nadat hy die nommer reg geraai het. Gebruik die print () funksie.
As hulle 'Nee' antwoord, breek uit die voorkoms. As hulle nog iets antwoord, gaan voort. Om uit 'n lus te breek, word gedoen met die breekverklaring.
Beweeg die 'Welkom by die getal -raaispel' buite die terwyl -lus. Die speler wil waarskynlik nie verwelkom word elke keer as hy die speletjie speel nie. Beweeg die instruksiedruk ("Welkom by die nommer -raaisel!" Bo die terwyl dit waar is: dit word slegs een keer gedruk wanneer die gebruiker die eerste wedstryd begin.

Stap 13. Toets die spel

U moet u spel toets elke keer as u 'n nuwe funksie implementeer.

Maak seker dat u ten minste een keer 'Ja' en 'Nee' antwoord om seker te maak dat beide opsies werk. Hier is hoe u kode moet lyk:

import random def numInput (): inp = input () while not inp.isdigit (): print ("U is aangesê om 'n heelgetal in te voer! Tik 'n heelgetal:") inp = input () return int (inp) print ("Welkom by die getal -raaisel!") Terwyl True: print ("Tik 'n heelgetal tussen 1 en 1000:") rightNum = random.randint (0, 1000) userNum = numInput () terwyl userNum! = RightNum: if userNum <rightNum: print ("Te klein. Probeer weer:") as userNum> rightNum: print ("Te groot. Probeer weer:") userNum = numInput () print ("U het reg geraai.") print ("Do you wil u weer speel? Tik Nee om op te hou. ") as input () ==" Nee ": breek

Stap 14. Skryf ander teksgebaseerde speletjies

Hoe gaan dit met die volgende om 'n teksavontuur te skryf? Of 'n vasvra -speletjie? Wees kreatief.

Wenk: Dit is soms handig om in die dokumentasie te kyk as u nie seker is hoe iets gedoen word of hoe 'n funksie gebruik word nie. Die Python 3 -dokumentasie kan gevind word op https://docs.python.org/3/. Soms lewer dit ook goeie resultate as u soek na wat u op die internet wil doen.

Deel 2 van 3: Maak 'n speletjie met 2D -grafika

Stap 1. Kies 'n grafiese biblioteek

Die maak van grafika is baie ingewikkeld, en die meeste programmeertale (insluitend Python, C ++, C, JavaScript) bied slegs minimale of selfs geen ondersteuning vir grafika in die kern of die standaardbiblioteke nie. U moet dus 'n eksterne biblioteek gebruik om grafika te kan maak, byvoorbeeld Pygame for Python.

Selfs met 'n grafiese biblioteek, moet u bekommerd wees oor dinge soos hoe u 'n spyskaart moet vertoon, hoe u kan kyk waarop die speler geklik het, hoe die teëls vertoon word, ens. As u eerder wil konsentreer op die ontwikkeling van die werklike spel, kan u 'n biblioteek vir speletjiesmotors soos Unity gebruik, wat hierdie dinge maklik implementeer

Hierdie artikel gebruik Python met Cocos2D om te wys hoe u 'n eenvoudige 2D -platform kan maak. Sommige van die genoemde konsepte bestaan moontlik nie in ander spelmotors nie. Raadpleeg hul dokumentasie vir meer inligting.

Stap 2. Installeer die grafiese biblioteek wat u gekies het

Cocos2D vir Python is maklik om te installeer. U kan dit kry by https://python.cocos2d.org/index.html, of deur sudo pip3 uit te voer, installeer cocos2d as u Linux gebruik.

Stap 3. Maak 'n nuwe gids vir u spel en media

U sal dinge soos beelde en klanke in u spel gebruik. Hou hierdie dinge in dieselfde gids as die program. Hierdie gids moet niks anders bevat nie, sodat u maklik kan sien watter bates u in die spel het.

Stap 4. Skep 'n nuwe kode lêer in die nuwe gids

Noem dit main, met die lêeruitbreiding vir u programmeertaal. As u 'n groot en ingewikkelde program skryf waar dit sinvol is om verskeie programlêers te hê, sal dit u wys watter die hooflêer is.

In hierdie voorbeeld skep ons 'n lêer genaamd main.py wat al ons kode bevat

Stap 5. Skep die spelvenster

Dit is die basiese voorvereiste vir 'n speletjie met grafika.

Voer die nodige submodules cocos2d in: cocos.director, cocos.scene en cocos.layer. Dit word gedoen met subModuleName import *, waar sub-module naam die submodule is wat u wil invoer. Die verskil tussen… invoer * en invoer… is dat u nie die module -naam hoef te plaas voor alles wat u uit die module met die voormalige gebruik nie.
Definieer 'n subklas MainMenuBgr van die ColorLayer. Dit beteken basies dat enige agtergrond van die hoofkieslys wat u skep, sal gedra soos 'n kleurlaag met 'n paar veranderinge wat u aanbring.
Begin die kokosdirekteur. Dit gee u 'n nuwe venster. As u nie 'n onderskrif stel nie, het die venster dieselfde onderskrif as die lêernaam (main.py), wat nie professioneel lyk nie. Laat die grootte van die venster verander deur die grootte aan te pas op True.
Definieer 'n funksie showMainMenu. U moet die kode vir die vertoon van die hoofmenu in 'n funksie plaas, want dit sal u toelaat om maklik terug te keer na die hoofkieslys deur weer die funksie te skakel.
Skep 'n toneel. Die toneel bestaan tans uit een laag, wat 'n voorwerp is van die MainMenuBgr -klas wat u gedefinieer het.
Begin hierdie toneel in die venster.

vanaf cocos.director invoer * vanaf cocos.scene invoer * vanaf cocos.layer invoer * klas 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 - 'n eenvoudige platform", resizable = True) showMainMenu ()

Stap 6. Voeg 'n hoofkieslys by die venster

Benewens die werklike spel, moet u 'n spyskaart byvoeg wat die speler kan gebruik om die venster te sluit, onder andere elemente wat u later kan byvoeg.

Voer cocos.menu in (weer met die van instruksie) en pyglet.app (hierdie keer met import).
Definieer MainMenu as 'n subklas van Menu.
Stel die belyning van die hoofkieslys in. U moet die vertikale en horisontale belyning afsonderlik instel.
Maak 'n lys met spyskaartitems en voeg dit by die spyskaart. U moet ten minste die menu -items "Start Game" en "Quit" hê. Elke spyskaartitem moet binne hakies geplaas word. Elke item moet 'n etiket en 'n terugbelfunksie hê wat bepaal wat gebeur as die speler daarop klik. Gebruik die 'Start Game' -item, gebruik die startGame -funksie (u skryf dit binnekort), as u' Stop ', gebruik' pyglet.app.exit '(bestaan reeds). Skep die werklike spyskaart deur self.create_menu (menuItems) te bel.
Definieer startGame (). Gee nou eers die definisie, u vervang dit as u die werklike spel skryf.
Gaan na die plek in u kode waar u die menuSc -toneel geskep het, en voeg 'n MainMenu -voorwerp daarby.

U hele kode moet nou soos volg lyk:

vanaf cocos.director invoer * vanaf cocos.menu invoer * vanaf cocos.scene invoer * vanaf cocos.layer invoer * import pyglet.app klas MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) klas MainMenu (Menu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTRE self.menu_halign = CENTER menuItems = [(MenuItem ("Start Game) ", 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 - 'n eenvoudige platform", resizable = True) showMainMenu ()

Stap 7. Toets u kode

Toets die kode vroeg, terwyl dit nog kort en relatief eenvoudig is. Dan kan u enige foute in die basiese struktuur identifiseer en regstel voordat dinge te ingewikkeld raak.

Die kode uit die instruksies moet 'n venster oopmaak met die opskrif "IcyPlat - 'n eenvoudige platform". Die agtergrond is ligblou en u kan die grootte van die venster verander. As u op 'Start Game' in die spyskaart klik, behoort (nog) niks te gebeur nie. As u op "Stop" klik, sal die venster toemaak

Stap 8. Skep 'n sprite

'N Sprite is 'n' spelvoorwerp 'of 'n 2-dimensionele beeld. Sprites kan voorwerpe in die spel, ikone, agtergrondversierings, karakters en enigiets anders wees wat u met 'n beeld in die spel kan voorstel. Ons begin met 'n sprite vir 'n karakter waarmee die speler kan kommunikeer.

Voer die submodule cocos.sprite in met die van-import-uitdrukking.
Soek 'n prentjie om die sprite voor te stel. U kan nie 'n sprite vertoon as u nie 'n prentjie daarvoor het nie. U kan een teken, of u kan een van die internet kry (pas op vir die lisensies as u van plan is om u speletjie te publiseer). Gaan na hierdie voorbeeld na https://opengameart.org/content/tux-classic-hero-style en stoor die PNG-prent van lopende pikkewyne op u rekenaar. Sny dan een van die lopende pikkewyne uit, want u benodig slegs een vir eers.
Skep 'n laag as 'n nuwe voorwerp van die ScrollableLayer -klas. Skep dan die sprite as 'n Sprite -voorwerp en stel sy posisie op (8, 250). Ter verwysing is die punt (0, 0) in die linker onderste hoek. Dit is redelik hoog, maar dit sal verseker dat die pikkewyn nie in die ys vasval nie.
Voeg die sprite by die sprite -laag.
Skep 'n nuwe toneel uit die sprite -laag en voer dit uit.

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

Begin die kode. U moet 'n klein pikkewynfiguur (of wat u ook al geteken het) op 'n swart agtergrond sien nadat u geklik het Begin die spel.

Stap 9. Droom jou landskap op

In die meeste wedstryde moet u sprites nie net in die leemte dryf nie. Hulle moet eintlik op een of ander oppervlak staan, met iets om hulle. In 2D -speletjies word dit dikwels gedoen met 'n teëlstel en 'n teëlkaart. Die teëlstel sê basies watter soort vierkante en agtergrondvierkante bestaan, en hoe dit lyk.

Skep 'n teëlstel. Die teëlstel vir hierdie speletjie is baie basies: een teël vir ys en een teël vir lug. Die ysteël wat in hierdie voorbeeld gebruik word, is van hier af onder CC-BY-SA 3.0.
Skep 'n teëlstel. Dit is 'n foto van alle teëls, wat almal dieselfde grootte moet hê (wysig dit as dit nie die geval is nie) en die grootte wat u in die spel wil sien, langs mekaar. Stoor u prent as icyTiles.png.
Skep die teëlstelbeskrywing. Dit is 'n XML -lêer. Die XML -lêer bevat inligting oor hoe groot die teëls in die prentjie van die teëls is, watter prent u moet gebruik en waar u die teël kan vind. Skep 'n XML -lêer met die naam icyTiles.xml met die onderstaande kode:
```
     
```

Stap 10. Maak 'n teëlkaart vir u landskap

'N Teëlkaart is 'n kaart wat bepaal watter teël op watter posisie in u vlak is. In die voorbeeld moet u 'n funksie definieer om teëlkaarte te genereer, omdat die ontwerp van teëlkaarte baie vervelig is. 'N Meer gevorderde spel het gewoonlik 'n soort vlakredakteur, maar as u vertroud is met 2D -spelontwikkeling, kan 'n algoritme goed genoeg vlakke bied.

Vind uit hoeveel rye en kolomme benodig word. Om dit te doen, verdeel die skermgrootte horisontaal (kolomme) en vertikaal (rye) deur die teëlgrootte. Rond die getal opwaarts af; Hiervoor benodig u 'n funksie van die wiskundige module, dus voeg by die invoerplafon vir wiskunde by die invoer bo -aan u kode.
Maak 'n lêer oop om te skryf. Dit sal alle vorige inhoud van die lêer uitvee, dus kies 'n naam wat nog geen lêer in die gids het nie, soos levelMap.xml.
Skryf die openingsetikette in die lêer.
Genereer 'n teëlkaart volgens die algoritme. U gebruik die een in die onderstaande kode, of u kan dit self opstel. Maak seker dat u die randint -funksie van die ewekansige module invoer: dit is nodig vir die onderstaande kode om te werk, en wat u ook al benodig, het waarskynlik ewekansige heelgetalle nodig. Maak ook seker dat u lugteëls en ysteëls in verskillende lae sit: ys is solied, die lug is nie.
Skryf die sluitingsetikette in die lêer en maak die lêer toe.

def genereerTilemap (): colAmount = plafon (800/16) * 3 # (skermwydte / teëlgrootte) * 3 ryBedrag = plafon (600/16) # skermhoogte / teëlgrootte tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) vir i in reeks (0, colAmount): tileFile.write ('') makeHole = Onwaar as randint (0, 50) == 10 en i! = 0: # moenie gate toelaat by die spawnpoint makeHole = Waar vir j in reeks (0, rowAmount): as makeHole: tileFile.write ('\ n') anders: as j <= iceHeight: tileFile.write ('\ n') anders: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) as iceHeight <0: # beperk teëls om te laag te gaan iceHeight = randint (1, 5) as iceHeight> rowAmount: # beperk teëls om te hoog te gaan iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') vir i in reeks (0, colAmount): tileFile.write ('') vir j in reeks (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Stap 11. Vertoon die teëlkaart

Voer alles uit cocos.tiles in en gaan dan daarvoor in die startGame -funksie.

Genereer aan die begin van u startGame -funksie 'n teëlkaart met die funksie wat u daarvoor gedefinieer het.
Skep 'n nuwe blaaibestuurder. Doen dit direk onder die lyn waar u die sprite by sy laag voeg.
Skep 'n nuwe laag met die teëls, wat afgelaai sal word vanaf die levelMap.xml -teëlkaart wat u genereerTilemap -funksie gegenereer het.
Voeg die nie-soliede laag, die vaste laag en die sprite-laag by die blaai-bestuurder, presies in hierdie volgorde. U kan 'n z-posisie byvoeg as u wil.
In plaas daarvan om die toneel uit die sprite -laag te skep, kan u dit vanaf die blaaibestuurder skep.

U startGame -funksie moet nou so lyk:

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

Stap 12. Toets u kode

U moet u kode gereeld toets om seker te maak dat die nuwe funksies wat u geïmplementeer het, werklik werk.

Die kode in die voorbeeld moet nou 'n ysige landskap agter die pikkewyn toon. As die pikkewyn lyk asof dit ver oor die ys sweef, het u niks verkeerd gedoen nie, en dit sal in die volgende stap opgelos word

Stap 13. Voeg die kontroles by

Die speler het baie meer maniere om met die program in 'n 2D-speletjie te kommunikeer as in 'n teksgebaseerde spel. 'N Algemene een sluit in die verskuiwing van hul figuur as die regte sleutel ingedruk word.

Voer alles in van cocos.mapcolliders en van cocos. actions. Voer ook sleutel uit pyglet.window in.
'Verklaar' 'n paar globale veranderlikes. Globale veranderlikes word tussen funksies gedeel. U kan nie regtig veranderlikes in Python verklaar nie, maar u moet sê dat 'n globale veranderlike in die hoofkode bestaan voordat u dit gebruik. U kan 0 as die waarde toeken, omdat 'n funksie later die korrekte waarde sal toeken. Voeg dus onder die invoeruitdrukkings by:
```
# "verklaar" globale veranderlikes sleutelbord = 0 scrMang = 0
```

Pas u startGame -funksie aan:

Sê dat u die sleutelbord en scrMang van die globale veranderlikes gebruik. Doen dit deur 'n globale sleutelbord te skryf, aan die bokant van die funksie scrMang.
Laat die venster na sleutelbordgebeurtenisse luister.
Vertel die figuur om op te tree op grond van 'n PlatformerController. U implementeer daardie PlatformerController binnekort.
Skep 'n kaartbotser om botsings tussen die soliede teëls en die figuur te hanteer.

def startGame (): globale sleutelbord, scrMang generatedTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml ') solidTiles = tileLayer [' solid '] nsoliTiles = tileLayer [' not_solid '] # keyboard = key. KeyStateHandler () director.window.push_handlers (keyboard) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump) = 'slide') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc)

Skep 'n platform -beheerder. Dit is wat die figuur sal skuif volgens u druk.
- Definieer die platformbeheerder as 'n subklas van aksie.
- Definieer die bewegingsnelheid, die springspoed en die swaartekrag.
- Definieer die beginfunksie. Hierdie funksie word een keer genoem wanneer die platform -beheerder aan die figuur gekoppel is. Dit moet sy snelheid in 0 en in y -rigting op 0 stel.
- Definieer die stapfunksie. Dit sal herhaal word terwyl die toneel aan die gang is.
- Vertel die stapfunksie om die globale veranderlike sleutelbord en scrMang te gebruik.
- Kry en verander die snelheid. Stoor die x- en die y -snelheid in afsonderlike veranderlikes. Stel die x -snelheid op 1 of -1 (afhangende van of die linker- of regterknop ingedruk is) vermenigvuldig met die bewegingsnelheid. Voeg swaartekrag by die y -snelheid. Vermenigvuldig dit met stilstand, sodat dit op dieselfde manier werk op stadiger toestelle. As die spasiesleutel ingedruk word en die figuur op die grond staan, spring deur die y -snelheid te verander na die spoed.
- Bereken waarheen die syfer moet beweeg. Laat die botsingshanteerder dan die posisie aanpas as dit binne -in 'n soliede teël is. Beweeg laastens die figuur na die nuwe aangepaste posisie.
- Stel die fokus van die blaai -bestuurder op die figuur. Dit veroorsaak dat die kamera op 'n redelike manier beweeg wanneer die figuur beweeg.
```
klas PlatformerController (Aksie): globale sleutelbord, 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, scroller as dt> 0.1: # doen niks terwyl u stilstaan om groot terug te keer vx, vy = self.target.velocity vx = (sleutelbord [key. RIGHT] - sleutelbord [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground and 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 (laaste, nuwe, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (*new.center)
```

Stap 14. Toets u kode

As u die voorbeeld gevolg het, moet u die pikkewyn met die pyltjie sleutels kan beweeg en spring deur op die spasiebalk te druk. Ook moet die pikkewyn nou val in plaas daarvan om oor die grond te sweef.

Stap 15. Skep 'n einde vir die spel

Selfs die speletjies wat eindeloos kan aangaan, behoort die moontlikheid te hê om te verloor. Aangesien die vlak wat u in die voorbeeld met 'n funksie gemaak het, 'n einde het, moet u dit ook moontlik maak om te wen deur dit te bereik. Andersins sou die speler net op die ysblokke daar rondspring, wat vervelig sou raak.

Binne die platformbeheerder, na die fokusstel, kry u die x- en y -posisie van die figuur. As die y -posisie minder as 0 is, bel die funksie finishGame () (u sal dit later skryf) met "Game Over" as 'n argument. As die x -posisie groter is as die grootte van die skerm vermenigvuldig met 3 (u het dit voorheen as vlakgrootte gestel).
```
posX, posY = self.target.position as posY <0: finishGame ("Game Over") terugkeer as posX> 800*3: # level size finishGame ("Level Completed") return
```
Definieer 'n klasafwerkingmenu. Dit moet soos die hoofkieslysklas wees wat u voorheen gedefinieer het, maar in plaas van 'n leë string as titel, moet dit 'n veranderlike teks gebruik wat die _init_ -funksie as argument gebruik. Die spyskaartitems moet nou gemerk wees "Probeer weer" en "Stop", maar die funksies wat hulle noem, bly dieselfde.
```
class FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Probeer weer", startGame)), (MenuItem ("Stop", pyglet.app.exit))] self.create_menu (menuItems)
```
Definieer die funksie finishGame (). Dit moet teks as 'n argument neem. Dit moet 'n toneel uit die agtergrond van die hoofkieslys maak, 'n FinishMenu met die teksargument wat na hierdie spyskaart oorgedra word. Dan moet dit hierdie toneel uitvoer.
```
def finishGame (teks): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (teks)) director.run (menuSc)
```

Stap 16. Voeg krediete by

Dit is waar u krediet kry vir u wonderlike kode, en krediet kan gee aan enigiemand anders wat u op die pad gehelp het. As u 'n prent van 'n ander webwerf (met toestemming) gebruik het, moet u die prent aan die skepper toeskryf.

Skep 'n lêer KREDIETE en voer al u krediete daar in, soos volg:

Penguin: Kelvin Shadewing, onder CC0 Ice block: Michał Banas digit1024 op opengameart.org onder CC-BY-SA 3.0

Gaan terug na u Python -kode en voer Label uit cocos.text in.

Definieer 'n subklas Credits of Layer. Lees in die _init_ -funksie die CREDITS -lêer en maak 'n teksetiket op die regte posisie uit elke reël daarin.

klas Krediete (Laag): def _init _ (self): super (Krediete, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") vir i in range (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)

Gaan na u hoofkieslysklas en voeg 'n spyskaartitem by met die naam "Krediete" wat die funksie showCredits noem as u daarop klik.
Definieer 'n subklas BackToMainMenuButton van Menu. Maak dit 'n spyskaart met een item met die naam "Terug", wat die funksie showMainMenu noem. Hierdie "spyskaart", wat meer soos 'n knoppie lyk, moet vertikaal in lyn met die onderkant en horisontaal na bo wees.
```
klas BackToMainMenuButton (spyskaart): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = ONDER self.menu_halign = LEFT menuItems = [(MenuItem ("Back"), showMainMu.) create_menu (menuItems)
```

Definieer die funksie showCredits. Dit moet 'n toneel uit 'n MainMenuBgr -laag en 'n Credits -laag maak en die toneel uitvoer.

def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)

Stap 17. Gaan u kode na

As u dink dat u u kode voltooi het, moet u dit alles weer ondersoek. Dit kan u help om agter te kom of iets geoptimaliseer kan word, of daar onnodige reëls is wat u vergeet het om uit te vee. As u die voorbeeld gevolg het, moet u hele kode nou soos volg lyk:

van cocos.director invoer * van cocos.menu invoer * van cocos.scene invoer * van cocos.layer invoer * van cocos.sprite invoer * van cocos.tiles invoer * van cocos.mapcolliders invoer * van cocos. actions invoer * van cocos.text invoer Etiket invoer pyglet.app vanaf pyglet.window invoer sleutel vanaf wiskundige invoer plafon vanaf ewekansige invoer randint # "verklaar" globale veranderlikes sleutelbord = 0 scrMang = 0 klas MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) klas MainMenu (Menu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Start Game", startGame)), (MenuItem ("Credits", showCredits)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems) klas Credits (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n") vir i in range (0, len (geloofsbriewe)): credLabel = Etiket (krediete , font_size = 32, anchor_x = "links", anchor_y = "top") credLabel.position = 25, 500- (i+1)*40 self.add (credLabel) klas BackToMainMenuButton (spyskaart): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = ONDER self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self.create_menu (menuItems) klas FinishMenu (Menu): _ self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTRE self.menu_halign = CENTER menuItems = [(MenuItem ("Probeer weer", startGame)), (MenuItem ("Stop", pyglet. app.exit))] self.create_menu (menuItems) klas PlatformerController (Aksie): globale sleutelbord, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (self, dt): globale sleutelbord, scroller as dt> 0.1: # doen niks terwyl die stilstand te groot terugkeer vx, vy = self.target.velocity vx = (keyboard [key. RIGHT] - sleutelbord [key. LEFT]) * self. MOVE_SPEED vy += self. GRAVITY * dt if self.on _grond en sleutelbord [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 (laaste, nuwe, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center) posX, posY = self.target.position as posY <0: finishGame ("Game Over") terugkeer as posX> 800*3: # level size finishGame ("Level Completed") return def finishGame (text): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (teks)) director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc) def generatedTilemap (): colAmount = plafon (800/16) * 3 # (skermwydte / teëlgrootte) * 3 ryAantal = plafon (600/16) # skermhoogte / teëlgrootte tileFile = oop ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) vir i in reeks (0, colAmount): tileFile.write ('') makeHole = Onwaar as rand int (0, 50) == 10 en i! = 0: # moenie gate toelaat by die spawnpoint makeHole = Waar vir j in reeks (0, rowAmount): as makeHole: tileFile.write ('\ n') anders: as j <= iceHeight: tileFile.write ('\ n') anders: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) as iceHeight <0: # beperk teëls om ook te gaan lae iceHeight = randint (1, 5) as iceHeight> rowAmount: # beperk teëls om te hoog te gaan iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') vir i in range (0, colAmount): tileFile.write (' ') vir j in range (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): globale sleutelbord, scrMang generatedTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml') solidTiles = tileLayer ['solid'] nsoliTiles = tileLayer ['not_solid'] # keyboard = key. KeyStateHandler () director.window.push_handlers (keybo ard) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump = 'slide') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoliTilesM, z = -1) 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) venster = director.init (caption = "IcyPlat - 'n eenvoudige platform", resizable = True) showMainMenu ()

Dit is 168 reëls in totaal en 152 reëls as u slegs die kode tel. Dit lyk baie, maar vir so 'n komplekse spel is dit eintlik 'n klein hoeveelheid.

Stap 18. Klaar

Toets nou die spel. As u iets programmeer, moet u kyk of dit werk as u iets nuuts geïmplementeer het. U kan ook die speletjie wat u geskryf het, 'n geruime tyd speel.

Deel 3 van 3: Publisering van 'n speletjie

Stap 1. Skryf die afhanklikhede neer

Almal wat 'n ander rekenaar gebruik, sal nie dieselfde sagteware en biblioteke as u geïnstalleer hê nie. U moet dus seker maak dat almal wat u speletjie installeer, presies weet wat hulle nodig het om dit te kan uitvoer. U hoef nie alle afhanklikhede van alle afhanklikhede van alle afhanklikhede ensovoorts neer te skryf nie, maar u moet ten minste die afhanklikhede van u pakkette en hul afhanklikes neerskryf.

Stap 2. Maak seker dat u toestemming het om alle media te gebruik

Dit geld vir alle grafika, insluitend 3D -modelle, musiek, dialoog, musiek, biblioteke en raamwerke wat u vir u spel gebruik het. Enigiets wat jy nie self geskryf het nie.

Daar is dikwels 'n paar voorwaardes, soos om die skrywer te moet krediteer of wysigings van die media onder dieselfde lisensie te deel. Soms kan u grafika gebruik sonder om die skeppers toe te skryf, solank u nie vir die spel hef nie. As u die skrywer moet erken, doen dit op 'n goed sigbare plek, soos 'n oortjie 'Krediete' in u spel.
Daar is ook media met aanspraak op kopiereg en geen lisensie gespesifiseer nie, soms met teks soos 'Alle regte voorbehou'. As dit die geval is, moet u uitdruklike toestemming van die outeur kry voordat u dit by u speletjie kan insluit.
Biblioteke word gewoonlik vrygestel onder lisensies waarmee hulle as biblioteek gebruik kan word. 'N Opmerklike uitsondering is die GPL sonder om uitsondering te koppel: Met so 'n lisensie kan u dit slegs in 'n program met sekere lisensies gebruik. En u moet altyd ten minste die basiese punte van die lisensie lees om seker te maak dat alles wat u met die media of biblioteek doen, toegelaat word.

Waarskuwing: Deur media of biblioteke te gebruik op 'n manier wat die lisensie nie toelaat in 'n speletjie wat u publiseer nie, kan u ernstige regsprobleme ondervind. Vra dus die skrywer of vermy die stuk geheel en al as u nie seker is of u dit mag gebruik nie.

Stap 3. Besluit op die voorwaardes waarop u u speletjie wil publiseer

Sal u u speletjie verkoop? Wil u ander toelaat om u beelde en idees te gebruik? Alhoewel u versigtig moet wees vir die media wat u in u projek gebruik, kan u gewoonlik besluit hoe u ander wil toelaat om u spel te gebruik. U kan 'n Creative Commons CC0 -lisensie gebruik om u speletjie in die publieke domein vry te stel. Probeer die Gnu General Public License (GPL) of die Berkeley Software Distribution (BSD) lisensie om onder sekere voorwaardes verspreiding en wysiging toe te laat. Of u kan u sagteware eie maak, wat beteken dat niemand dit sonder u toestemming mag versprei of wysig nie.

Alhoewel dit moontlik is om geld te verdien deur speletjies te verkoop, is dit onwaarskynlik dat mense u eerste speletjie sal koop wat gewoonlik min funksies het en niks besonders nie. As 'n gratis program nie werk nie, sal mense wat dit afgelaai het, teleurgesteld wees. As hulle daarvoor betaal het, eis hulle egter hul geld terug, wat meer probleme vir u en die gebruikers veroorsaak. Oorweeg dus om u eerste paar programme gratis beskikbaar te stel

Stap 4. Besluit hoe u u speletjie wil publiseer

Elke metode het 'n paar voordele en nadele, dus u moet self besluit.

Publiseer dit op 'n webwerf:

As u 'n webwerf het, kan u u speletjie oplaai om dit af te laai. Gee duidelike instruksies oor die installering van die sagteware, asook alle vereiste afhanklikhede. Die nadeel hiervan is dat spelers afhanklikes met die hand moet installeer, wat vir sommige mense moeilik kan wees.
Maak 'n pakket vir 'n pakketbestuurder:

Daar is verskillende pakketbestuurders, soos apt, Yum en Homebrew, wat dit vir mense maklik maak om programme in Linux- en Linux-gebaseerde omgewings te installeer. Hulle het almal verskillende pakketformate. Die goeie ding met pakkette is dat dit alle afhanklikes outomaties installeer (as u dit korrek opstel). Die speler hoef dus slegs u pakket te installeer en kan dan die speletjie speel. Die probleem is dat daar baie verskillende pakketbestuurders op verskillende platforms is, dus u sal moeite moet doen om pakkette vir al die mees algemene pakkette te verskaf.

Stap 5. Rig aandag aan u program

Oorweeg dit om u program op te laai na 'n groot pakketbewaarplek, soos dié wat Ubuntu en Debian onderhou, om maklike installasies moontlik te maak. Plaas ook in gepaste forums, soos die projek -afdeling van GameDev of 'n deel van tigSource. Maar moenie teleurgesteld wees as u eerste wedstryde nie bekend word nie. As u 'n idee het dat baie mense daarvan hou, kan u spel bekend word.

Wenke

Wees geduldig en bereid om te leer. Programmering kan soms frustrerend wees!
As u wonder hoe iets in 'n ander speletjie gedoen word, en die spel open source is, kan u na die bronkode daarvan kyk.
As u op soek is na media, probeer om inhoud te vind wat in die publieke domein is. Soek beelde en musiek van "Creative Commons" of "Public Domain" en gebruik webwerwe soos https://opengameart.org of
Moenie groot stukke kode kopieer sonder om die lisensie na te gaan nie. Dit is dikwels verbode, en indien nie, vereis dit gewoonlik toeskrywing.
Moenie spam maak of op onvanpaste plekke plaas wanneer u u speletjie bevorder nie. Dit sal u waarskynlik van die bladsy blokkeer, is eenvoudig irriterend en kan u reputasie benadeel.