Kuidas programmeerida arvutimänge (piltidega)

2024 Autor: Robert Blare | [email protected]. Viimati modifitseeritud: 2023-12-17 07:37

Kas teil on arvutimängu idee ja soovite selle reaalseks muuta? Või olete kunagi mõelnud, kuidas arvutimänge kirjutatakse? See wikiHow õpetab teile, kuidas kirjutada Pythonis kolme põhilist arvutimängu. Esimese mängu väljatöötamiseks vajate põhiteadmisi Pythoni ja üldiste programmeerimiskontseptsioonide kohta.

Sammud

Osa 1 /3: Tekstipõhise mängu tegemine

Samm 1. Valige programmeerimiskeel

Kõik programmeerimiskeeled on erinevad, seega peate otsustama, millist neist oma mängu kirjutamiseks kasutada. Iga suurem programmeerimiskeel toetab tekstisisestust, tekstiväljundit ja if-konstruktsioone (lihtsa tekstipõhise mängu jaoks peamised asjad), seega uurige võimalusi ja otsustage, milline on teie jaoks kõige mugavam ja õppimisele pühendunud. Siin on mõned tegurid, mida tuleb arvestada:

• Milleks keelt enamasti kasutatakse?

  Mõned programmeerimiskeeled, näiteks JavaScript, on mõeldud kasutamiseks veebis, teised, näiteks Python, C või C ++, arvutiprogrammide käitamiseks. Oma mängu jaoks otsige keelt, mille kasutusvõimalused on laiemad, näiteks Python, C, C ++ või JavaScript.

• Kui raske on õppida?

  Kuigi programmi kirjutamine peaks pärast mõnda tavaprogrammeerimiskeelt (st mitte spetsiaalselt segaseks kujundatud Malbolge) praktiseerimist olema piisavalt lihtne, on mõned algajatele sõbralikumad kui teised. Näiteks Java ja C nõuavad sügavamate programmeerimiskontseptsioonide mõistmist kui midagi sellist nagu Python, mis on tuntud oma ligipääsetavama ja lihtsama süntaksi poolest.

• Kus ma seda kasutada saan?

  Tõenäoliselt soovite, et inimesed, kes töötavad erinevates süsteemides, näiteks Linux, Mac või Windows, saaksid teie mängu mängida. Seetõttu ei tohiks te kasutada keelt, mida toetavad vaid mõned süsteemid, näiteks Visual Basic, mida toetatakse ainult Windowsis.

See artikkel kasutab tekstipõhise mängu näidete jaoks Pythoni, kuid saate vaadata, kuidas mõisteid muudes programmeerimiskeeltes kasutatakse.

Samm 2. Valmistage arvuti ette

Kaks peamist komponenti, mida vajate, on tekstiredaktor, millesse kirjutate oma koodi, ja kompilaator, mille abil saate selle mänguks muuta. Kui soovite järgida selle artikli näidet, peaksite installima Pythoni ja õppima, kuidas programme käivitada. Soovi korral saate seadistada IDE (Integraded Desktop Environment), mis ühendab redigeerimise, kompileerimise ja silumise üheks programmiks. Pythoni IDE -d nimetatakse IDLE -ks. Kuid võite kasutada ka mis tahes tekstiredaktorit, mis toetab lihtteksti, näiteks Notepad Windowsile, TextEdit macOS -ile või Vim Linuxile.

Samm 3. Kirjutage mängija tervitamiseks mõni kood

Mängija soovib teada, mis toimub ja mida ta peab tegema, nii et peaksite nende jaoks teksti printima.

• Seda tehakse Pythonis print () funktsiooniga. Selle proovimiseks avage uus fail laiendiga.py, sisestage sinna järgmine kood, salvestage ja käivitage see:

  print ("Tere tulemast numbrite äraarvamise mängu!") print ("Sisestage täisarv vahemikus 1 kuni 1000:")
  

Samm 4. Loo juhuslik arv

Teeme tekstipõhise mängu, mis palub mängijal ära arvata õige number. Esimene asi, mida peame tegema, on genereerida mängu alguses juhuslik number, et mängija ei arvaks alati sama numbrit. Kuna number jääb kogu programmi jooksul samaks, peaksite juhusliku numbri muutujale salvestama.

• Pythonil ei ole sisseehitatud juhuslike numbrite funktsiooni, kuid sellel on standardne kogu (see tähendab, et kasutaja ei pea midagi täiendavalt installima). Nii et minge oma koodi algusesse (enne printimise () funktsioone) ja tippige rea importimine juhuslikult.

• Kasutage juhuslikku funktsiooni. Seda nimetatakse randint (), see on äsja imporditud juhuslikus teegis ja võtab argumendina minimaalse ja maksimaalse väärtuse. Nii et minge tagasi oma koodi lõppu ja sisestage järgmine rida:

  rightNum = juhuslik.randint (0, 1000)
  

Samm 5. Hankige mängijalt sisend

Mängus soovib mängija midagi teha või millegagi suhelda. Tekstipõhises mängus on see võimalik teksti sisestades. Nüüd, kui meil on juhuslik number, peaksid meie järgmised koodiridad paluma mängijal sisestada oma parim arvamus.

• Kuna teie sisestatud kood prindib juhised mängijale numbri sisestamiseks, peaks see lugema ka nende sisestatud numbri. Seda tehakse Python 3 sisendiga () ja Python 2 -s raw_input (). Python 3 -s peaksite kirjutama, kuna Python 2 vananeb peagi. Lisage oma koodile järgmine rida, et salvestada mängija sisend muutuja nimega number:

  userNum = sisend ()
  

Samm 6. Muutke mängija sisend kasutatavaks andmetüübiks

Mängija on sisestanud numbri-mis nüüd?

• Muutke mängija sisestatud number. See võib tunduda segane, sest nad sisestasid just numbri. Kuid sellel on hea põhjus: Python eeldab, et kogu sisend on tekst või "string", nagu seda programmeerimisel nimetatakse. See tekst sisaldab numbrit, mida soovite saada. Pythonil on funktsioon, mis teisendab ainult numbrit sisaldava stringi sees olevaks numbriks. Tüüp:

  userNum = int (kasutaja number)
  

Samm 7. Võrrelge mängija numbrit õige numbriga

Kui mängija on oma numbri sisestanud, peate seda võrdlema juhuslikult loodud numbriga. Kui numbrid pole samad, võib teie mäng panna mängija proovima mõnda muud numbrit. Kui numbrid kattuvad, võite mängijale öelda, et nad arvasid õigesti, ja sulgeda programm. Seda tehakse järgmise koodiga:

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

Samm 8. Andke mängijale tagasisidet

Kuigi olete nende sisendi juba töödelnud, ei näe mängija seda. Peate tulemused tegelikult mängijale printima, et ta saaks aru, mis toimub.

• Kindlasti võiksite mängijale lihtsalt öelda, kas tema number on õige või vale. Kuid sellise lähenemise korral võib mängija halvimal juhul arvata 1000 korda, mis oleks väga igav.
• Nii et öelge mängijale, kas nende arv on liiga väike või liiga suur. See vähendab nende oletuste arvu oluliselt. Kui näiteks mängija arvab kõigepealt 500 ja mäng vastab "Liiga suur. Proovige uuesti", on 1000 asemel vaid 500 võimalikku numbrit. Seda tehakse if-konstruktsioonidega, seega asendage print ("Vale. Proovige uuesti. ") Ühega.
• Pidage meeles, et kontrollides, kas kaks numbrit on samad, tehakse ==, mitte =. = omistab sellest paremal oleva väärtuse sellest vasakule jäävale muutujale!

if userNum <rightNum: print ("Liiga väike. Proovige uuesti:") if userNum> rightNum: print ("Liiga suur. Proovige uuesti:")

Samm 9. Testige oma koodi

Programmeerijana peaksite olema kindel, et teie kood töötab enne selle lõpetamist.

• Pythonis programmeerides veenduge, et taanded oleksid õiged. Teie kood peaks välja nägema selline:

  import juhuslikku printimist ("Tere tulemast numbrimõistmismängu!") print ("Sisestage täisarv vahemikus 1 kuni 1000:") rightNum = juhuslik.randint (0, 1000) userNum = input () userNum = int (userNum) samas userNum! = rightNum: if userNum <rightNum: print ("Liiga väike. Proovi uuesti:") if userNum> rightNum: print ("Liiga suur. Proovi uuesti:") userNum = int (input ()) print ("Sa arvasid õigesti. ")
  

Samm 10. Valideerige sisend

Mängija ei tohiks teie mängu murda, sisestades lihtsalt vale asja. "Sisendi valideerimine" tähendab enne selle töötlemist veendumist, et mängija sisestas õige asja.

• Avage mäng uuesti ja proovige sisestada kõik, mis pole number. Mäng väljub ValueErroriga. Selle vältimiseks saate rakendada viisi, kuidas kontrollida, kas sisend oli number.
• Määrake funktsioon. Kuna sisendi valideerimine on üsna pikk ja seda tuleb teha mitu korda, peaksite funktsiooni määratlema. See ei nõua argumente ja tagastab numbri. Esiteks kirjuta koodi ülaossa, otse impordi juhuse alla def numInput ():.
• Hankige mängija sisend üks kord. Kasutage funktsiooni input () ja määrake tulemus muutujale inp.
• Kui mängija sisend ei ole number, paluge tal sisestada number. Et kontrollida, kas string on number, kasutage funktsioone isdigit (), mis lubab ainult täisarvu, nii et te ei pea seda eraldi kontrollima.
• Kui sisend on number, teisendage see stringist numbriks ja tagastage tulemus. Stringi täisarvuks teisendamiseks kasutage funktsiooni int (). See muudab põhikoodi teisendamise tarbetuks ja peaksite selle sealt eemaldama.
• Asendage kõik põhikoodi sisend () kõned numInput () kõnedega.
• Funktsiooni numInput () kood näeb välja selline:

def numInput (): inp = input () samas kui inp.isdigit (): print ("Teil paluti sisestada täisarv! Sisestage täisarv:") inp = input () return int (inp)

Samm 11. Testige mängu uuesti

Sisestage meelega valed asjad, et näha, mis juhtub, ja parandage seejärel vead, kui need ilmuvad.

Proovige sisestada teksti, kui programm küsib teilt numbrit. Nüüd küsib programm veateatega väljumise asemel uuesti numbrit

Samm 12. Soovitage mängu lõpetamist uuesti käivitada

Nii saaks mängija teie mängu mängida kauem, ilma et peaksite seda pidevalt taaskäivitama.

• Pange kogu kood, välja arvatud import ja funktsiooni määratlus, mõnda aega. Määrake tingimuseks Tõene: see on alati tõsi, nii et tsükkel jätkub igavesti.
• Küsige mängijalt, kas ta soovib uuesti mängida pärast seda, kui ta on numbri õigesti ära arvanud. Kasutage printimise () funktsiooni.
• Kui nad vastavad "ei", murra välja. Kui nad midagi muud vastavad, jätkake. Silmusest välja murdmine toimub lausega break.
• Liigutage "Tere tulemast numbrimõistmismängu" väljapoole samas ringi. Mängija ilmselt ei taha, et teda iga kord mängides tervitataks. Liigutage käsu trükk („Tere tulemast numbrimõistmismängu!“), Samal ajal kui tõene:, nii et see prinditakse ainult üks kord, kui kasutaja esimest mängu alustab.

Samm 13. Testige mängu

Peate oma mängu iga kord uue funktsiooni rakendamisel testima.

• Veenduge, et vastate vähemalt üks kord nii "jah" kui ka "ei", veendumaks, et mõlemad valikud toimivad. Siin peaks teie kood välja nägema:

  import juhuslik def numInput (): inp = input () samas kui inp.isdigit (): print ("Teil paluti sisestada täisarv! Sisestage täisarv:") inp = input () return int (inp) print ("Tere tulemast numbrite äraarvamise mängu!") Samas True: print ("Sisestage täisarv vahemikus 1 kuni 1000:") rightNum = random.randint (0, 1000) userNum = numInput () samas userNum! = RightNum: if userNum <rightNum: print ("Liiga väike. Proovige uuesti:") if userNum> rightNum: print ("Liiga suur. Proovige uuesti:") userNum = numInput () print ("Arvasite õigesti.") print ("Kas te tahad uuesti mängida? Väljumiseks sisesta Ei. ") if input () ==" No ": break
  

Samm 14. Kirjutage muid tekstipõhiseid mänge

Kuidas oleks järgmisena kirjutada tekstiseiklus? Või viktoriinimäng? Ole loominguline.

Nõuanne: Mõnikord on kasulik vaadata dokumentatsiooni, kui te pole kindel, kuidas midagi tehakse või kuidas funktsiooni kasutatakse. Python 3 dokumentatsiooni leiate aadressilt https://docs.python.org/3/. Mõnikord annab Internetist otsida kõike, mida soovite teha, ka häid tulemusi.

Osa 2/3: 2D graafikaga mängu tegemine

Samm 1. Valige graafikakogu

Graafika tegemine on väga keeruline ja enamik programmeerimiskeeli (sh Python, C ++, C, JavaScript) pakuvad tuuma või standardraamatukogude graafikale minimaalset tuge või isegi mitte. Seega peate graafika tegemiseks kasutama välist raamatukogu, näiteks Pygame for Python.

Isegi graafikakogu puhul peate muretsema selliste asjade pärast nagu menüü kuvamine, kuidas kontrollida, mida mängija klõpsas, kuidas plaate kuvada jne. Kui soovite pigem keskenduda tegeliku mängu arendamisele, võite kasutada mängumootoriteeki nagu Unity, mis neid asju hõlpsasti rakendab

See artikkel kasutab Pythoni koos Cocos2D -ga, et näidata, kuidas lihtsat 2D -platvormi teha. Mõnda mainitud mõistet ei pruugi teistes mängumootorites olla. Lisateavet leiate nende dokumentatsioonist.

Samm 2. Installige valitud graafikakogu

Cocos2D for Python on lihtne paigaldada. Selle saate aadressilt https://python.cocos2d.org/index.html või käivitades sudo pip3 installige cocos2d, kui kasutate Linuxit.

Samm 3. Looge oma mängule ja meediale uus kataloog

Mängus kasutate selliseid asju nagu pildid ja helid. Hoidke need asjad programmiga samas kataloogis. See kataloog ei tohiks sisaldada midagi muud, et saaksite hõlpsalt näha, millised varad teil mängus on.

Samm 4. Looge uude kataloogi uus koodifail

Nimetage seda peamiseks, koos teie programmeerimiskeele faililaiendiga. Kui kirjutate suure ja keeruka programmi, kus on mõttekas omada mitut programmifaili, näitab see teile, milline on põhifail.

Selles näites loome faili nimega main.py, mis sisaldab kogu meie koodi

Samm 5. Looge mänguaken

See on graafikaga mängu põhieeldus.

• Importige vajalikud alammoodulid cocos2d: cocos.director, cocos.cene ja cocos.layer. Seda tehakse alammooduli nime impordi *abil, kus alammooduli nimi on alammoodul, mida soovite importida. Erinevus alates… impordist * ja impordist… seisneb selles, et te ei pea panema mooduli nime kõige ette, mida kasutate sellest moodulist koos esimese versiooniga.
• Määrake ColorLayeri alamklass MainMenuBgr. See tähendab põhimõtteliselt seda, et teie loodud peamenüü taust käitub teatud muudatustega nagu värvikiht.
• Alustage kookose direktorit. See annab teile uue akna. Kui te subtiitreid ei määra, on aknal sama pealkiri kui failinimel (main.py), mis ei tundu professionaalne. Lubage akna suurust muuta, määrates suuruse muutmise väärtuseks Tõene.
• Määrake funktsioon showMainMenu. Peate sisestama funktsiooni peamenüü kuvamiseks, kuna see võimaldab teil uuesti menüüsse naasta, helistades sellele uuesti.
• Loo stseen. Stseen koosneb praegu ühest kihist, mis on teie määratletud klassi MainMenuBgr objekt.
• Käivitage see stseen aknas.

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

Samm 6. Lisage aknale peamenüü

Lisaks tegelikule mängule peate lisama menüü, mida mängija saab akna sulgemiseks kasutada.

• Importige menüü cocos.un (jällegi koos juhistega) ja pyglet.app (seekord koos impordiga).
• Määrake MainMenu menüü alamklassiks.
• Seadistage peamenüü joondus. Peate eraldi seadistama vertikaalse ja horisontaalse joonduse.
• Looge menüüelementide loend ja lisage need menüüsse. Teil peaks olema vähemalt menüükäsud "Alusta mängu" ja "Lõpeta". Kõik menüüelemendid tuleks paigutada sulgude sisse. Igal üksusel peab olema silt ja tagasihelistamisfunktsioon, mis määrab, mis juhtub, kui mängija sellel klõpsab. Üksuse "Alusta mängu" jaoks kasutage funktsiooni startGame (kirjutate selle varsti), üksuse "Lõpeta" jaoks "pyglet.app.exit" (juba olemas). Looge tegelik menüü, helistades ise.create_menu (menuItems).
• Määrake startGame (). Pange nüüd lihtsalt määratlusse pass, asendate selle tegeliku mängu kirjutamisel.
• Minge oma koodi kohta, kus lõite menuSc stseeni, ja lisage sellele MainMenu objekt.

• Kogu teie kood peaks nüüd välja nägema järgmine:

  from cocos.director import * alates cocos.menu import * alates cocos.scene import * alates cocos.layer import * impordi pyglet.app klass MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) klassi MainMenu (menüü): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Start Game) ", startGame)), (MenuItem (" Quit ", pyglet.app.exit))] self.create_menu (menuItems) def startGame (): pass def showMainMenu (): menuSc = Stseen (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) director.init (caption = "IcyPlat - a simple platformer", resizable = True) showMainMenu ()
  

Samm 7. Testige oma koodi

Testige koodi varakult, kuigi see on endiselt lühike ja suhteliselt lihtne. Siis saate tuvastada ja parandada kõik põhistruktuuri vead, enne kui asjad liiga keeruliseks lähevad.

Juhendis olev kood peaks avama akna pealkirjaga "IcyPlat - lihtne platvormimisseade". Taust on helesinine ja saate akna suurust muuta. Kui klõpsate menüüs nuppu "Alusta mängu", ei tohiks midagi juhtuda (veel). Kui klõpsate nupul "Lõpeta", sulgub aken

Samm 8. Loo sprite

Sprite on "mänguobjekt" või kahemõõtmeline pilt. Sprites võivad olla mängusisesed objektid, ikoonid, taustakaunistused, tegelased ja kõik muu, mida saate mängus kujutisega kujutada. Alustuseks loome tegelasele sprite, millega mängija saab suhelda.

• Importige alammoodul cocos.sprite impordiväljendiga.
• Leidke pilt, mis esindab sprite'i. Sprite ei saa kuvada, kui teil pole selle jaoks pilti. Saate selle joonistada või Internetist hankida (olge litsentside osas ettevaatlik, kui plaanite oma mängu avaldada). Selle näite jaoks minge aadressile https://opengameart.org/content/tux-classic-hero-style ja salvestage jooksvate pingviinide PNG-pilt arvutisse. Seejärel lõigake välja üks jooksvatest pingviinidest, sest praegu vajate ainult ühte.
• Loo kiht ScrollableLayer klassi uue objektina. Seejärel looge sprite Sprite objektina ja määrake selle asukoht (8, 250). Võrdluseks: punkt (0, 0) asub vasakus alanurgas. See on üsna kõrge, kuid see tagab, et pingviin ei jää jäässe kinni.
• Lisage sprite kihile.
• Looge sprite kihist uus stseen ja käivitage see.

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

• Käivitage kood. Pärast klõpsamist peaksite mustal taustal nägema väikest pingviinikuju (või mida iganes te joonistasite) Alusta mängu.

Samm 9. Unistage oma maastikku

Enamikus mängudes ei tohiks teie spritid lihtsalt tühjuses hõljuda. Nad peaksid tegelikult seisma mingil pinnal, millegi ümber. 2D mängudes tehakse seda sageli plaatide komplekti ja plaatide kaardiga. Plaatide komplektis on põhimõtteliselt kirjas, millised pinnaväljakud ja taustaväljakud eksisteerivad ning millised need välja näevad.

• Loo plaatide komplekt. Selle mängu plaatide komplekt on väga lihtne: üks plaat jää jaoks ja üks plaat taeva jaoks. Selles näites kasutatud jääplaat on siit, CC-BY-SA 3.0 all.
• Looge plaatide komplekti pilt. See on pilt kõigist plaatidest, mis peavad kõik olema ühesuurused (muutke neid, kui neid pole) ja nende suurus on selline, nagu soovite mängus näha, kõrvuti. Salvestage oma pilt nimega icyTiles.png.

• Looge paanikomplekti kirjeldus. See on XML -fail. XML -fail sisaldab teavet selle kohta, kui suured on plaadid plaadikomplekti pildil, millist pilti kasutada ja kust sealt leida. Looge XML -fail nimega icyTiles.xml, kasutades järgmist koodi:

Samm 10. Tehke oma maastiku jaoks plaatide kaart

Paanikaart on kaart, mis määratleb, milline plaat teie tasemel millises kohas asub. Näites peaksite määratlema paanikaartide genereerimise funktsiooni, kuna plaatide kaartide käsitsi kujundamine on väga tüütu. Arenenumal mängul oleks tavaliselt mingi tasemeredaktor, kuid 2D -mängude arendamisega tutvumiseks võib algoritm pakkuda piisavalt häid tasemeid.

• Uurige, kui palju ridu ja veerge on vaja. Selleks jagage ekraani suurus plaatide suurusega nii horisontaalselt (veerud) kui ka vertikaalselt (read). Ümardage number ülespoole; selleks vajate matemaatikamooduli funktsiooni, nii et lisage matemaatika impordi ülemmäärast koodi ülaosas olev import.
• Avage kirjutamiseks fail. See kustutab faili kogu varasema sisu, seega valige nimi, mida ühelgi kataloogifailil veel pole, näiteks levelMap.xml.
• Kirjutage avamärgendid faili.
• Loo paanikaart vastavalt algoritmile. Kasutate allolevas koodis olevat või võite selle ise välja mõelda. Impordi kindlasti randinti funktsioon moodulist juhuslikult: see on vajalik alltoodud koodi toimimiseks ja kõik, mida välja mõtled, vajab tõenäoliselt ka juhuslikke täisarvu. Samuti pange kindlasti taevaplaadid ja jääplaadid erinevatesse kihtidesse: jää on tahke, taevas mitte.
• Kirjutage lõppsildid faili ja sulgege fail.

defgeneTilemap (): colAmount = ülemmäär (800/16) * 3 # (ekraani laius / plaatide suurus) * 3 ridaAmount = lagi (600/16) # ekraani kõrgus / plaatide suurus tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) i jaoks vahemikus (0, colAmount): tileFile.write ('') makeHole = Vale, kui randint (0, 50)) == 10 ja i! = 0: # ei luba auke kudemispunktis makeHole = Tõene j jaoks vahemikus (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: # piira plaatide liiga madalale jääle minekutHeight = randint (1, 5) if iceHeight> rowAmount: # limiitplaadid liiga kõrgele jääle minemastHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') i jaoks vahemikus (0, colAmount): tileFile.write ('') j jaoks vahemikus (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Samm 11. Kuvage paanikaart

Importige kõik saidilt cocos.tiles ja minge selle jaoks startGame funktsiooni.

• Funktsiooni startGame alguses genereerige paanikaart, kasutades selleks määratud funktsiooni.
• Looge uus kerimishaldur. Tehke seda otse joone all, kuhu lisate sprite oma kihile.
• Looge uus kiht, mis sisaldab paane, mis laaditakse teie loodud genereeritud funktsiooni MapTxmax kaardilt levelMap.xml.
• Lisage kerimishaldurile mittesiduv kiht, tahke kiht ja spritekiht täpselt selles järjekorras. Soovi korral saate lisada z-positsiooni.
• Selle asemel, et luua stseen sprite kihist, looge see kerimishaldurist.

• Teie funktsioon StartGame peaks nüüd välja nägema selline:

  def startGame ():geneTilemap () # 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 = ScrollManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Stseen (scrMang) director.run (gameSc)
  

Samm 12. Testige oma koodi

Peaksite oma koodi sageli testima, et veenduda, kas uued rakendatud funktsioonid tõesti töötavad.

Näite kood peaks nüüd näitama pingviini taga mingit jäist maastikku. Kui pingviin näib hõljuvat kaugele jää kohale, ei teinud te midagi valesti ja see parandatakse järgmisel sammul

Samm 13. Lisage juhtelemendid

Mängijal on 2D-mängus programmiga suhtlemiseks palju rohkem võimalusi kui tekstipõhises mängus. Tavaline hõlmab nende figuuri liigutamist õige klahvi vajutamisel.

• Importige kõike saidilt cocos.mapcolliders ja cocos.actions. Importige võti ka saidilt pyglet.window.

• "Deklareerige" mõned globaalsed muutujad. Globaalsed muutujad on funktsioonide vahel jagatud. Pythonis ei saa tegelikult muutujaid deklareerida, kuid peate ütlema, et põhikoodis on enne selle kasutamist globaalne muutuja. Saate väärtuseks määrata 0, kuna funktsioon hoolitseb õige väärtuse määramise eest hiljem. Nii et lisage impordiväljendite alla:

  # globaalsete muutujate "deklareerimine" klaviatuur = 0 scrMang = 0
  

• StartGame funktsiooni reguleerimine:

  • Oletame, et kasutate globaalsete muutujate klaviatuuri ja scrMangi. Tehke seda, kirjutades globaalse klaviatuuri, funktsiooni ülaosas scrMang.
  • Pane aken kuulama klaviatuuri sündmusi.
  • Ütle joonisele PlatformerController põhinev tegevus. Varsti rakendate selle PlatformerControlleri.
  • Tahke plaatide ja joonise vaheliste kokkupõrgete käsitlemiseks looge kaardipõrke.

  def startGame (): globaalne klaviatuur, scrManggeneTilemap () # 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 (klaviatuur) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on = 'slaid') joonis.kokkupõrkehaldur = make_collision_handler (kaardikollider, solidTiles) # scrMang = ScrollManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z =) 1) # gameSc = Stseen (scrMang) director.run (gameSc)
  

• Looge platvormikontroller. See muudab figuuri vastavalt klahvivajutustele.

  • Määratlege platvormingu kontroller toimingute alamklassina.
  • Määrake liikumiskiirus, hüppekiirus ja gravitatsioon.
  • Määrake käivitusfunktsioon. Seda funktsiooni kutsutakse üks kord, kui platformerikontroller on joonisega ühendatud. See peaks seadma kiiruseks 0 nii x kui ka y suunas.
  • Määrake sammufunktsioon. Seda korratakse stseeni töötamise ajal.
  • Ütle samm -funktsioonile, et kasutada globaalsete muutujate klaviatuuri ja scrMangi.
  • Hankige ja muutke kiirust. Salvestage kiirus x ja y eraldi muutujateks. Seadke x -kiiruseks 1 või -1 (sõltuvalt sellest, kas vasak- või paremklahvi vajutati), korrutatuna liikumiskiirusega. Lisage y kiirusele gravitatsioon. Korrutage see seisakutega, nii et see toimib aeglasematel seadmetel samamoodi. Kui tühikuklahvi vajutatakse ja joonis seisab maapinnal, hüpata, muutes y kiirust hüppe kiiruseks.
  • Arvutage, kuhu näitaja peaks liikuma. Seejärel laske kokkupõrke käitlejal seda asendit reguleerida, kui see asub kindla plaadi sees. Lõpuks viige joonis uude reguleeritud asendisse.
  • Seadke kerimishalduri fookus joonisele. See paneb kaamera kuju liigutamisel mõistlikult liikuma.

  klassi PlatformerController (tegevus): globaalne klaviatuur, 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, kerige, kui dt> 0,1: # ärge tehke midagi, kui seisakud suurele tagasivoolule vx, vy = self.target.velocity vx = (klaviatuur [klahv. RIGHT] - klaviatuur [klahv. LEFT]) * ise. MOVE_SPEED vy + = self. GRAVITY * dt kui self.on_ground ja klaviatuur [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () new = last.copy () uus.x += dx new.y += dy self.target.velocity = self.target.collision_handler (viimane, uus, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (*new.center)
  

Samm 14. Testige oma koodi

Kui te eeskuju järgisite, peaksite nüüd saama pingviini nooleklahvidega liigutada ja tühikuklahvi vajutades hüpata. Samuti peaks pingviin nüüd maapinna kohal hõljumise asemel alla kukkuma.

Samm 15. Looge mängule lõpp

Isegi mängudel, mis võivad lõputult kesta, peaks olema võimalus kaotada. Kuna tasemel, mille te tegite näites koos funktsiooniga, on lõpp, peate ka selle eesmärgi saavutamiseks võimaldama võita. Vastasel juhul hüppaks mängija seal ainult jääklotsidel ringi, mis muutuks igavaks.

• Platvormingukontrolleri sees saate pärast fookuse seadmist figuuri x ja y positsiooni. Kui positsioon y on väiksem kui 0, helistage funktsioonile finishGame () (kirjutate selle hiljem), argumendina lisades "Game Over". Kui x -positsioon on suurem kui ekraani suurus korrutatuna 3 -ga (olite selle enne taseme suuruseks määranud).

  posX, posY = self.target.position if posY <0: finishGame ("Game Over") tagastab, kui posX> 800*3: # level size finishGame ("Level Completed") tagastab
  

• Määrake klassi viimistlusmenüü. See peaks olema nagu peamenüü klass, mille olete varem määratlenud, kuid selle asemel, et pealkirjaks oleks tühi string, peaks see kasutama muutuvat teksti, mida funktsioon _init_ kasutab argumendina. Menüüelementidel peaksid olema sildid "Proovi uuesti" ja "Lõpeta" kohe, kuid funktsioonid, mida nad nimetavad, jäävad samaks.

  class FinishMenu (Menüü): def _init _ (ise, tekst): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Proovi uuesti", startGame)), (MenuItem ("Välju", pyglet.app.exit))] self.create_menu (menuItems)
  

• Määrake funktsioon finishGame (). See peaks teksti võtma argumendina. See peaks tegema stseeni peamenüü taustast, FinishMenu koos teksti argumendiga, mis edastatakse sellele menüüle. Siis peaks see stseen jooksma.

  def finishGame (tekst): menuSc = Stseen (MainMenuBgr ()) menuSc.add (FinishMenu (tekst)) director.run (menuSc)
  

Samm 16. Lisa krediiti

Siin saate tunnustust oma suurepärase koodi eest ja tunnustust kõigile teistele, kes teid sellel teel aitasid. Kui kasutasite teise veebisaidi pilti (loaga), omistage see pilt kindlasti selle loojale.

• Looge fail CREDITS ja sisestage sinna kõik oma krediidid järgmiselt.

  Pingviin: Kelvin Shadewing, CC0 all Jääplokk: Michał Banas number1024 saidil opengameart.org CC-BY-SA 3.0 all
  

• Minge tagasi oma Pythoni koodi juurde ja importige silt siltist cocos.text.

• Määrake alamklass Kihi krediidid. Funktsioonis _init_ lugege CREDITS -faili ja tehke selle igast reast õigele kohale tekstisilt.

  klassi autorid (kiht): def _init _ (ise): super (krediidid, ise)._ init _ () credFile = avatud ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") i jaoks vahemikus (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)
  

• Minge oma peamenüü klassi ja lisage menüüelement „Autorid”, mis kutsub klõpsates funktsiooni showCredits.

• Määrake menüü alamklass BackToMainMenuButton. Tehke sellest menüü, kus on üks element "Tagasi", mis kutsub üles funktsiooni showMainMenu. See "menüü", mis sarnaneb pigem nupuga, peaks olema vertikaalselt joondatud põhja ja horisontaalselt ülespoole.

  class BackToMainMenuButton (Menüü): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Tagasi", showMainMenu))] ise create_menu (menuItems)
  

• Määrake funktsioon showCredits. See peaks tegema stseeni MainMenuBgr kihist ja Credits kihist ning käivitama selle stseeni.

  def showCredits (): credSc = Stseen (MainMenuBgr ()) credSc.add (Autorid ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)
  

Samm 17. Kontrollige oma koodi

Kui arvate, et olete oma koodi lõpetanud, peaksite selle uuesti üle vaatama. See aitab teil märgata, kas midagi saab optimeerida või on mõni ebavajalik rida, mille unustasite kustutada. Kui järgisite eeskuju, peaks kogu teie kood nüüd välja nägema järgmine:

alates cocos.director import * alates cocos.menu import * alates cocos.scene import * alates cocos.layer import * alates cocos.sprite import * alates cocos.tiles import * cocos.mapcolliders import * cocos.actions import * cocos.text import Label import pyglet.app from pyglet.window matemaatika impordi ülemmäära importimise võti juhuslikust impordist randint # "deklareeriv" globaalsed muutujad klaviatuur = 0 scrMang = 0 klass MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, ise)._ init _ (0, 200, 255, 255) klassi MainMenu (menüü): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems =

• See on kokku 168 rida ja 152 rida, kui loete ainult koodi. See tundub palju, kuid sellise keeruka mängu puhul on see tegelikult väike summa.

Samm 18. Valmis

Nüüd testige mängu. Midagi programmeerides peate alati kontrollima, kas see töötab, kui olete midagi uut rakendanud. Samuti võiksite mõnda aega mängida mängu, mille kirjutasite.

Osa 3/3: Mängu avaldamine

Samm 1. Kirjutage sõltuvused üles

Igaüks, kes kasutab teist arvutit, ei saa installida sama tarkvara ja teeke nagu teie. Seega peate veenduma, et kõik, kes teie mängu installivad, teavad täpselt, mida nad mängu käivitamiseks vajavad. Te ei pea kirja panema kõikide sõltuvuste kõiki sõltuvusi ja nii edasi, kuid peaksite vähemalt kirjutama oma pakettide sõltuvused ja nende sõltuvused.

Samm 2. Veenduge, et teil oleks luba kasutada kogu meediumit

See kehtib kogu graafika kohta, sealhulgas 3D -mudelid, muusika, dialoog, muusika, raamatukogud ja mängu jaoks kasutatud raamistikud. Kõik, mida sa pole ise kirjutanud.

• Sageli on teatud tingimused, näiteks autori tunnustamine või meedia muudatuste jagamine sama litsentsi alusel. Mõnikord saate graafikat kasutada loojaid omistamata, kui te mängu eest tasu ei võta. Kui peate autorit tunnustama, tehke seda hästi nähtavas kohas, näiteks oma mängu vahekaardil „Autorid”.
• Samuti on meediat, mille autoriõigused on esitatud ja litsentsi pole täpsustatud, mõnikord tekstiga, nagu „Kõik õigused kaitstud”. Kui see nii on, peate enne selle mängu lisamist saama autorilt selgesõnalise loa.
• Raamatukogud antakse tavaliselt välja litsentside alusel, mis võimaldavad neid raamatukoguna kasutada. Märkimisväärne erand on GPL ilma linkimiseta: selline litsents võimaldab seda kasutada ainult teatud litsentsidega programmis. Ja alati peaksite lugema vähemalt litsentsi põhipunkte, veendumaks, et kõik, mida meedia või raamatukoguga teete, on lubatud.

Hoiatus: Meedia või raamatukogude kasutamine viisil, mida litsents ei võimalda teie avaldatud mängus, võib teid tõsiste juriidiliste probleemideni viia. Nii et küsige autorilt või vältige meediat, kui te pole kindel, kas teie kasutamine on lubatud.

Samm 3. Otsustage, millistel tingimustel soovite oma mängu avaldada

Kas müüte oma mängu? Kas soovite lubada teistel teie pilte ja ideid kasutada? Kuigi peate oma projektis kasutatava meedia suhtes olema ettevaatlik, saate tavaliselt otsustada, kuidas soovite teistele oma mängu kasutada. Mängu avalikult avaldamiseks võite kasutada Creative Commons CC0 litsentsi. Teatud tingimustel levitamise ja muutmise lubamiseks, säilitades samas mõned õigused, proovige Gnu üldist avalikku litsentsi (GPL) või Berkeley tarkvara levitamise (BSD) litsentsi. Või võite oma tarkvara muuta omandiks, mis tähendab, et kellelgi ei ole lubatud seda ilma teie loata levitada ega muuta.

Kuigi mängude müümisega on võimalik raha teenida, on ebatõenäoline, et inimesed ostavad teie esimese mängu, millel on tavaliselt vähe funktsioone ja mis pole midagi erilist. Samuti, kui tasuta programm ei tööta, on selle alla laadinud inimesed lihtsalt pettunud. Kui nad selle eest maksid, nõuavad nad aga raha tagasi, põhjustades nii teile kui ka kasutajatele rohkem probleeme. Nii et kaaluge oma esimeste programmide tasuta kättesaadavaks tegemist

Samm 4. Otsustage, kuidas soovite oma mängu avaldada

Igal meetodil on oma eelised ja puudused, nii et peate ise otsustama.

• Selle avaldamine veebisaidil:

  Kui teil on veebisait, saate oma mängu alla laadida ja selle alla laadida. Kindlasti esitage selged juhised tarkvara installimise kohta ning kõik vajalikud sõltuvused. Selle puuduseks on see, et mängijad peavad sõltuvused käsitsi installima, mis võib mõne inimese jaoks olla keeruline.

• Paketihalduri jaoks paketi tegemine:

  On erinevaid paketihaldureid, nagu apt, Yum ja Homebrew, mis hõlbustavad inimestel rakenduste installimist Linuxi ja Linuxi-põhistesse keskkondadesse. Neil kõigil on erinevad pakendivormingud. Pakettide hea külg on see, et need installivad automaatselt kõik sõltuvused (kui need õigesti konfigureerida). Seega peab mängija ainult teie paketi installima ja seejärel mängu mängima. Probleem on selles, et erinevatel platvormidel on palju erinevaid paketihaldureid, nii et peate kõigi kõige tavalisemate pakettide pakkumiseks natuke vaeva nägema.

Samm 5. Pöörake tähelepanu oma programmile

Lihtsaks installimiseks kaaluge oma programmi üleslaadimist suuremasse pakettide hoidlasse, nagu Ubuntu ja Debian. Samuti postitage asjakohastesse foorumitesse, näiteks GameDevi projektide sektsiooni või mõnda tigSource'i osa. Kuid ärge pettuge, kui teie esimesed mängud kuulsaks ei saa. Kui teil on idee, et see meeldib paljudele, võib teie mäng saada tuntuks.

Näpunäiteid

• Ole kannatlik ja valmis õppima. Programmeerimine võib kohati masendav olla!
• Kui te ei tea, kuidas teises mängus midagi tehakse ja mäng on avatud lähtekoodiga, saate vaadata selle lähtekoodi.
• Meediat otsides proovige leida üldkasutatavat sisu. Otsige pilte ja muusikat "Creative Commons" või "Public Domain" ning kasutage veebisaite nagu https://opengameart.org või
• Ärge kopeerige suuri kooditükke ilma litsentsi kontrollimata. See on sageli keelatud ja kui mitte, nõuab see tavaliselt omistamist.
• Ärge tehke oma mängu reklaamimisel rämpsposti ega postitage sobimatutesse kohtadesse. Tõenäoliselt blokeeritakse see lehelt, see on lihtsalt tüütu ja kahjustab teie mainet.