Kaip programuoti kompiuterinius žaidimus (su paveikslėliais)

2024 Autorius: Robert Blare | [email protected]. Paskutinį kartą keistas: 2024-01-31 12:18

Turite kompiuterinio žaidimo idėją ir norite ją paversti tikra? O gal kada susimąstėte, kaip rašomi kompiuteriniai žaidimai? Šis „wikiHow“moko jus parašyti tris pagrindinius kompiuterinius žaidimus „Python“. Norėdami sukurti pirmąjį žaidimą, jums reikės pagrindinio „Python“supratimo ir bendrų programavimo koncepcijų.

Žingsniai

1 dalis iš 3: Tekstinio žaidimo kūrimas

Žingsnis 1. Pasirinkite programavimo kalbą

Visos programavimo kalbos yra skirtingos, todėl turėsite nuspręsti, kurią iš jų naudoti žaidimui rašyti. Kiekviena pagrindinė programavimo kalba palaiko teksto įvedimą, teksto išvestį ir „if-“konstrukcijas (pagrindiniai dalykai, kurių jums reikia paprastam tekstu pagrįstam žaidimui), todėl ištirkite parinktis ir nuspręskite, kuri jums patogiausia ir skirta mokymuisi. Štai keletas veiksnių, į kuriuos reikia atsižvelgti:

• Kam dažniausiai naudojama kalba?

  Kai kurios programavimo kalbos, pvz., „JavaScript“, yra skirtos naudoti žiniatinklyje, o kitos, pvz., „Python“, „C“ar „C ++“, yra skirtos kompiuterinėms programoms paleisti. Savo žaidime siekite kalbos, kurią būtų galima naudoti plačiau, pvz., „Python“, C, C ++ arba „JavaScript“.

• Kaip sunku išmokti?

  Nors parašyti programą turėtų būti pakankamai paprasta po tam tikros praktinės bet kokios įprastos programavimo kalbos (t. Y. Ne tos, kuri būtų specialiai sukurta taip, kad suklaidintų, kaip Malbolge), kai kurios yra draugiškesnės pradedantiesiems nei kitos. Pavyzdžiui, „Java“ir „C“reikės suprasti gilesnes programavimo sąvokas nei kažkas panašaus į „Python“, žinomą dėl labiau prieinamos ir paprastos sintaksės.

• Kur galiu jį naudoti?

  Tikriausiai norite, kad žmonės, dirbantys skirtingose sistemose, pvz., „Linux“, „Mac“ar „Windows“, galėtų žaisti jūsų žaidimą. Taigi neturėtumėte naudoti kalbos, kuri palaikoma tik keliose sistemose, pvz., „Visual Basic“, kuri palaikoma tik „Windows“.

Šiame straipsnyje teksto žaidimo pavyzdžiams bus naudojamas „Python“, tačiau galite sužinoti, kaip sąvokos atliekamos bet kuria kita programavimo kalba.

Žingsnis 2. Paruoškite kompiuterį

Du pagrindiniai komponentai, kurių jums reikės, yra teksto rengyklė, kurioje įrašysite savo kodą, ir kompiliatorius, kurį panaudosite, kad paverstumėte žaidimu. Jei norite sekti šio straipsnio pavyzdžiu, turėtumėte įdiegti „Python“ir išmokti paleisti programas. Jei norite, galite nustatyti IDE (integruotą darbalaukio aplinką), kuri sujungia redagavimą, kompiliavimą ir derinimą į vieną programą. Python IDE vadinamas IDLE. Tačiau taip pat galite tiesiog naudoti bet kurį teksto redaktorių, palaikantį paprastą tekstą, pvz., „Notepad“, skirtą „Windows“, „TextEdit“, skirtą „MacOS“, arba „Vim“, skirtą „Linux“.

Žingsnis 3. Parašykite kodą pasveikinti žaidėją

Žaidėjas norės žinoti, kas vyksta ir ką jis turi daryti, todėl turėtumėte atspausdinti jiems tekstą.

• Tai daroma naudojant „print“() funkciją „Python“. Norėdami tai išbandyti, atidarykite naują failą su plėtiniu.py, įveskite šį kodą, išsaugokite ir paleiskite:

  print („Sveiki atvykę į skaičių atspėjimo žaidimą!“) print („Įveskite sveikąjį skaičių nuo 1 iki 1000:“)
  

Žingsnis 4. Sukurkite atsitiktinį skaičių

Sukurkime tekstinį žaidimą, kuriame prašoma žaidėjo atspėti teisingą skaičių. Pirmas dalykas, kurį turime padaryti, yra generuoti atsitiktinį skaičių žaidimo pradžioje, kad žaidėjas ne visada atspėtų tą patį skaičių. Kadangi skaičius visoje programoje išliks tas pats, atsitiktinį skaičių norite išsaugoti kintamajame.

• „Python“neturi įmontuotos atsitiktinių skaičių funkcijos, tačiau turi standartinę biblioteką (tai reiškia, kad vartotojui nereikės nieko papildomai įdiegti). Taigi eikite į savo kodo pradžią (prieš spausdinimo () funkcijas) ir įveskite eilutės importavimą atsitiktine tvarka.

• Naudokite atsitiktinę funkciją. Jis vadinamas randint (), yra atsitiktinėje bibliotekoje, kurią ką tik importavote, ir argumentuoja minimalią ir maksimalią reikšmę, kurią gali turėti šis skaičius. Taigi grįžkite į kodo pabaigą ir įveskite šią eilutę:

  rightNum = random.randint (0, 1000)
  

Žingsnis 5. Gaukite įvesties iš grotuvo

Žaidime žaidėjas nori ką nors padaryti ar su kuo nors bendrauti. Teksto žaidime tai įmanoma įvedus tekstą. Dabar, kai turime atsitiktinį skaičių, kitos kodo eilutės turėtų paprašyti žaidėjo įvesti geriausią spėjimą.

• Kadangi įvestas kodas spausdina nurodymą įvesti grotuvą, jis taip pat turėtų perskaityti jų įvestą numerį. Tai daroma naudojant įvestį () „Python 3“ir raw_input () „Python 2“. Turėtumėte rašyti „Python 3“, nes „Python 2“netrukus pasens. Pridėkite šią eilutę prie savo kodo, kad išsaugotumėte žaidėjo įvestį kintamajame, vadinamame skaičiumi:

  userNum = įvestis ()
  

Žingsnis 6. Paverskite grotuvo įvestį tinkamu naudoti duomenų tipu

Žaidėjas įvedė numerį-ką daryti?

• Padarykite žaidėjo įvestą skaičių. Dabar tai gali atrodyti painu, nes jie ką tik įvedė numerį. Tačiau yra gera priežastis: „Python“daro prielaidą, kad visa įvestis yra tekstas arba „eilutė“, kaip tai vadinama programuojant. Šiame tekste yra numeris, kurį norite gauti. „Python“turi funkciją, kuri paverčia eilutę, kurioje yra tik skaičius, į skaičių viduje. Tipas:

  userNum = int (vartotojo numeris)
  

Žingsnis 7. Palyginkite žaidėjo numerį su teisingu numeriu

Kai žaidėjas įveda savo numerį, turėsite jį palyginti su atsitiktinai sugeneruotu numeriu. Jei skaičiai nesutampa, jūsų žaidimas gali priversti žaidėją išbandyti kitą skaičių. Jei skaičiai sutampa, galite pasakyti žaidėjui, kad jie atspėjo teisingai, ir išeiti iš programos. Tai daroma naudojant šį kodą:

o userNum! = rightNum: userNum = int (įvestis ())

Žingsnis 8. Pateikite žaidėjui atsiliepimą

Kol jau apdorojote jų įvestį, žaidėjas to nematys. Turėsite iš tikrųjų atsispausdinti rezultatus grotuvui, kad jis suprastų, kas vyksta.

• Žinoma, galite tiesiog pasakyti žaidėjui, ar jų numeris yra teisingas, ar neteisingas. Tačiau tokiu būdu žaidėjas blogiausiu atveju gali spėti 1000 kartų, o tai būtų labai nuobodu.
• Taigi pasakykite žaidėjui, ar jų skaičius yra per mažas, ar per didelis. Tai žymiai sumažins jų spėjimų skaičių. Jei, pavyzdžiui, žaidėjas pirmiausia atspėja 500, o žaidimas atsako „Per didelis. Bandykite dar kartą“, vietoj 1000 galimų skaičių bus tik 500. Tai daroma naudojant „if-“konstrukcijas, todėl pakeiskite spaudinį („Neteisinga. Bandykite dar kartą. ") Su vienu.
• Atminkite, kad patikrinti, ar du skaičiai yra vienodi, reikia naudojant ==, o ne naudojant =. = priskiria vertę dešinėje nuo kintamojo kairėje!

if userNum <rightNum: print ("Per mažas. Bandykite dar kartą:") if userNum> rightNum: print ("Per didelis. Bandykite dar kartą:")

9. Išbandykite savo kodą

Kaip programuotojas, turėtumėte įsitikinti, kad jūsų kodas veikia, prieš manydami, kad jis baigtas.

• Kai programuojate „python“, įsitikinkite, kad įterpimai yra teisingi. Jūsų kodas turėtų atrodyti taip:

  importuoti atsitiktinį spausdinimą („Sveiki atvykę į skaičių atspėjimo žaidimą!“) print („Įveskite sveikąjį skaičių nuo 1 iki 1000:“) rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) while userNum! = rightNum: if userNum <rightNum: print ("Per mažas. Bandykite dar kartą:") if userNum> rightNum: print ("Per didelis. Bandykite dar kartą:") userNum = int (input ()) print ("Jūs atspėjote teisingai.")
  

Žingsnis 10. Patikrinkite įvestį

Žaidėjas neturėtų sugriauti jūsų žaidimo tiesiog įvedęs neteisingą dalyką. „Įvesties patvirtinimas“reiškia, kad prieš apdorodamas žaidėjas įvedė teisingą dalyką.

• Vėl atidarykite žaidimą ir pabandykite įvesti viską, kas nėra skaičius. Žaidimas išeis su „ValueError“. Norėdami to išvengti, galite įdiegti būdą, kaip patikrinti, ar įvestis buvo skaičius.
• Apibrėžkite funkciją. Kadangi įvesties patvirtinimas yra gana ilgas ir jūs turite tai padaryti kelis kartus, turėtumėte apibrėžti funkciją. Tai nereikalauja jokių argumentų ir grąžina skaičių. Pirmiausia įveskite def numInput (): kodo viršuje, tiesiai po atsitiktinio importavimo parinktimi.
• Vieną kartą gaukite žaidėjo indėlį. Naudokite įvesties () funkciją ir priskirkite rezultatą kintamajam inp.
• Kai žaidėjo įvestis nėra skaičius, paprašykite jo įvesti skaičių. Norėdami patikrinti, ar eilutė yra skaičius, naudokite funkcijas isdigit (), kuri leidžia tik sveiką skaičių, todėl nereikės to atskirai tikrinti.
• Jei įvestis yra skaičius, konvertuokite ją iš eilutės į skaičių ir grąžinkite rezultatą. Norėdami konvertuoti eilutę į sveiką skaičių, naudokite funkciją int (). Dėl to pagrindinio kodo konvertavimas bus nereikalingas, todėl turėtumėte jį pašalinti.
• Visus pagrindinio kodo įvesties () skambučius pakeiskite skambučiais į numInput ().
• Funkcijos numInput () kodas atrodys taip:

def numInput (): inp = input (), o ne inp.isdigit (): print ("Jums buvo liepta įvesti sveiką skaičių! Įveskite visą skaičių:") inp = input () return int (inp)

Žingsnis 11. Iš naujo išbandykite žaidimą

Tyčia įveskite neteisingus dalykus, kad pamatytumėte, kas atsitiks, ir ištaisykite visas klaidas, kai jos atsiranda.

Pabandykite įvesti tekstą, kai programa prašo numerio. Dabar, užuot išėjusi su klaidos pranešimu, programa vėl paprašys jūsų numerio

Žingsnis 12. Pasiūlykite iš naujo paleisti žaidimą, kai jis bus baigtas

Tokiu būdu žaidėjas galėtų žaisti jūsų žaidimą ilgiau, jo nereikėtų nuolat paleisti iš naujo.

• Įdėkite visą kodą, išskyrus importavimą ir funkcijos apibrėžimą, į ciklo ciklą. Nustatykite „True“kaip sąlygą: tai visada bus tiesa, todėl ciklas tęsis amžinai.
• Paklauskite žaidėjo, ar jie nori vėl žaisti, kai teisingai atspėjo skaičių. Naudokite funkciją print ().
• Jei jie atsako „ne“, išsisukite. Jei jie ką nors atsakys, tęskite. Išsiveržimas iš kilpos atliekamas su fraze break.
• Perkelkite „Sveiki atvykę į skaičių atspėjimo žaidimą“už ciklo ribų. Žaidėjas tikriausiai nenori būti laukiamas kiekvieną kartą žaidžiant žaidimą. Perkelkite instrukcijų spausdinimą („Sveiki atvykę į skaičių atspėjimo žaidimą!“), O „True:“, todėl jis bus atspausdintas tik vieną kartą, kai vartotojas pradės pirmąjį žaidimą.

Žingsnis 13. Išbandykite žaidimą

Turėsite išbandyti savo žaidimą kiekvieną kartą, kai įdiegsite naują funkciją.

• Būtinai bent kartą atsakykite „Taip“ir „Ne“, kad įsitikintumėte, jog abi galimybės veikia. Štai kaip turėtų atrodyti jūsų kodas:

  importuoti atsitiktinį skaičių ("Sveiki atvykę į skaičių atspėjimo žaidimą!"), O tiesa: print ("Įveskite sveiką skaičių nuo 1 iki 1000:") rightNum = atsitiktinis.randint (0, 1000) userNum = numInput (), o userNum! = RightNum: if userNum <rightNum: print ("Per mažas. Bandykite dar kartą:") if userNum> rightNum: print ("Per didelis. Bandykite dar kartą:") userNum = numInput () print ("Jūs atspėjote teisingai.") print ("Ar jūs norite žaisti dar kartą? Jei norite išeiti, įveskite No. ") if input () ==" No ": break
  

Žingsnis 14. Rašykite kitus tekstinius žaidimus

Kaip toliau rašyti nuotykių tekstą? Arba viktorinos žaidimas? Būk kūrybingas.

Patarimas: Kartais naudinga pažvelgti į dokumentus, jei nesate tikri, kaip kažkas daroma ar kaip naudojama funkcija. „Python 3“dokumentaciją rasite adresu https://docs.python.org/3/. Kartais ieškant to, ką norite padaryti internete, taip pat gaunami geri rezultatai.

2 dalis iš 3: Žaidimo kūrimas naudojant 2D grafiką

Žingsnis 1. Pasirinkite grafikos biblioteką

Grafikos kūrimas yra labai sudėtingas, o dauguma programavimo kalbų (įskaitant „Python“, „C ++“, „C“, „JavaScript“) tik minimaliai arba visai nepalaiko grafikos pagrindinėje ar standartinėje bibliotekoje. Taigi, norėdami kurti grafiką, turėsite naudoti išorinę biblioteką, pavyzdžiui, „Pygame for Python“.

Net ir turėdami grafikos biblioteką, turėsite nerimauti, pavyzdžiui, kaip rodyti meniu, kaip patikrinti, ką žaidėjas spustelėjo, kaip rodyti plyteles ir pan. Jei norėtumėte sutelkti dėmesį į tikrojo žaidimo kūrimą, galite naudoti žaidimų variklio biblioteką, tokią kaip „Unity“, kuri lengvai įgyvendina šiuos dalykus

Šiame straipsnyje bus naudojamas „Python“su „Cocos2D“, kad būtų parodyta, kaip padaryti paprastą 2D platformingą. Kai kurių iš minėtų sąvokų gali nebūti kituose žaidimų varikliuose. Daugiau informacijos rasite jų dokumentuose.

2 veiksmas. Įdiekite pasirinktą grafikos biblioteką

„Cocos2D for Python“lengva įdiegti. Ją galite gauti iš https://python.cocos2d.org/index.html arba paleisdami sudo pip3 įdiegti cocos2d, jei naudojate „Linux“.

Žingsnis 3. Sukurkite naują savo žaidimo ir medijos katalogą

Žaidime naudosite tokius dalykus kaip vaizdai ir garsai. Laikykite šiuos dalykus tame pačiame kataloge kaip ir programa. Šiame kataloge neturėtų būti nieko kito, kad galėtumėte lengvai pamatyti, kokį turtą turite žaidime.

Žingsnis 4. Sukurkite naują kodo failą naujame kataloge

Pavadinkite jį pagrindiniu, naudodami jūsų programavimo kalbos failo plėtinį. Jei rašote didelę ir sudėtingą programą, kur prasminga turėti kelis programos failus, tai parodys, kuris yra pagrindinis failas.

Šiame pavyzdyje sukursime failą pavadinimu main.py, kuriame bus visas mūsų kodas

Žingsnis 5. Sukurkite žaidimo langą

Tai yra pagrindinė žaidimo su grafika sąlyga.

• Importuokite reikiamus „cocos2d“submodulius: „cocos.director“, „cocos.sene“ir „cocos.layer“. Tai daroma naudojant subModuleName import *, kur submodulio pavadinimas yra submodulis, kurį norite importuoti. Skirtumas tarp… importo * ir importo… yra tas, kad jums nereikia nurodyti modulio pavadinimo priešais viską, ką naudojate iš to modulio su pirmuoju.
• Apibrėžkite „ColorLayer“poklasį „MainMenuBgr“. Tai iš esmės reiškia, kad bet koks jūsų sukurtas pagrindinio meniu fonas elgsis kaip spalvotas sluoksnis su kai kuriais pakeitimais.
• Pradėkite kokosų direktorių. Tai suteiks jums naują langą. Jei nenustatysite antraštės, lange bus tokia pati antraštė kaip ir failo pavadinime (main.py), kuris neatrodys profesionaliai. Leiskite pakeisti lango dydį nustatydami dydį pakeisti į „True“.
• Nustatykite funkciją showMainMenu. Pagrindinio meniu rodymo kodą turėtumėte įdėti į funkciją, nes tai leis jums lengvai grįžti į pagrindinį meniu dar kartą paskambinus funkcijai.
• Sukurkite sceną. Sceną šiuo metu sudaro vienas sluoksnis, kuris yra jūsų apibrėžtos „MainMenuBgr“klasės objektas.
• Vykdykite šią sceną lange.

iš cocos.director importo * iš cocos.scene importo * iš cocos.layer importo * klasės MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenu, self)._ init _ (0, 200, 255, 255) def showMainMenu (): menuSc = Scena (MainMenuBgr ()) director.run (menuSc) director.init (caption = "IcyPlat - a simple platformer", resizable = True) showMainMenu ()

Žingsnis 6. Prie lango pridėkite pagrindinį meniu

Be tikrojo žaidimo, be kitų elementų, kuriuos galėsite pridėti vėliau, turėsite pridėti meniu, kurį žaidėjas gali naudoti langui uždaryti.

• Importuokite „cocos.menu“(vėl su instrukcija) ir „pyglet.app“(šį kartą su importu).
• Apibrėžkite „MainMenu“kaip meniu poklasį.
• Nustatykite pagrindinio meniu derinimą. Vertikalų ir horizontalų derinimą turite nustatyti atskirai.
• Sudarykite meniu elementų sąrašą ir pridėkite juos prie meniu. Turėtumėte turėti bent meniu elementus „Pradėti žaidimą“ir „Baigti“. Kiekvienas meniu elementas turėtų būti skliausteliuose. Kiekvienas elementas turi turėti etiketę ir atgalinio ryšio funkciją, kuri nustato, kas atsitinka, kai žaidėjas jį spustelėja. Elementui „Pradėti žaidimą“naudokite „startGame“funkciją (netrukus ją parašysite), o elementui „Baigti“- „pyglet.app.exit“(jau yra). Sukurkite tikrąjį meniu paskambinę self.create_menu (menuItems).
• Apibrėžkite „startGame“(). Tiesiog dabar įtraukite į apibrėžimą, jį pakeisite rašydami tikrąjį žaidimą.
• Eikite į savo kodo vietą, kurioje sukūrėte „menuSc“sceną, ir pridėkite prie jos „MainMenu“objektą.

• Visas jūsų kodas dabar turėtų atrodyti taip:

  iš cocos.director importo * iš cocos.menu importo * iš cocos.scene importo * iš cocos.layer importo * importo pyglet.app klasės MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) klasės MainMenu (meniu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Pradėti žaidimą) ", startGame)), (MenuItem (" Quit ", pyglet.app.exit))] self.create_menu (menuItems) def startGame (): pass def showMainMenu (): menuSc = Scena (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) director.init (caption = "IcyPlat - a simple platformer", resizable = True) showMainMenu ()
  

Žingsnis 7. Išbandykite savo kodą

Išbandykite kodą anksti, kol jis vis dar trumpas ir gana paprastas. Tada galite nustatyti ir ištaisyti visas pagrindinės struktūros klaidas, kol viskas darosi pernelyg sudėtinga.

Kodas iš instrukcijų turėtų atidaryti langą su užrašu „IcyPlat - paprasta platformingo priemonė“. Fonas yra šviesiai mėlynas ir galite pakeisti lango dydį. Kai meniu spustelėsite „Pradėti žaidimą“, nieko neturėtų įvykti (dar). Spustelėjus „Baigti“, langas bus uždarytas

Žingsnis 8. Sukurkite spritą

„Sprite“yra „žaidimo objektas“arba 2 matmenų vaizdas. Sprites gali būti žaidimo objektai, piktogramos, fono dekoracijos, simboliai ir visa kita, ką galite vaizduoti žaidime. Pradėsime nuo veikėjo, su kuriuo žaidėjas gali bendrauti, sukūrimo.

• Importuokite „cocos.sprite“submodulį su išraiška „iš importo“.
• Raskite vaizdą, atspindintį spritą. Negalite rodyti „sprite“, jei neturite jo nuotraukos. Galite nupiešti vieną arba gauti iš interneto (tačiau, jei planuojate paskelbti savo žaidimą, saugokitės licencijų). Šiame pavyzdyje eikite į https://opengameart.org/content/tux-classic-hero-style ir išsaugokite savo kompiuteryje bėgančių pingvinų-p.webp" />
• Sukurkite sluoksnį kaip naują „ScrollableLayer“klasės objektą. Tada sukurkite sprite kaip „Sprite“objektą ir nustatykite jo padėtį (8, 250). Pavyzdžiui, taškas (0, 0) yra apatiniame kairiajame kampe. Tai gana aukšta, tačiau tai užtikrins, kad pingvinas neįstrigtų lede.
• Pridėkite sprite prie sprite sluoksnio.
• Sukurkite naują sceną iš „Sprite“sluoksnio ir paleiskite ją.

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

• Paleiskite kodą. Spustelėję turėtumėte pamatyti mažą pingvino figūrą (ar bet ką, ką nupiešėte) juodame fone Pradėti žaidimą.

Žingsnis 9. Svajokite apie savo kraštovaizdį

Daugelyje žaidimų jūsų spritai neturėtų tiesiog plaukti tuštumoje. Jie iš tikrųjų turėtų stovėti ant kažkokio paviršiaus, su kažkuo aplink juos. 2D žaidimuose tai dažnai daroma naudojant plytelių rinkinį ir plytelių žemėlapį. Plytelių rinkinys iš esmės nurodo, kokie paviršiaus kvadratai ir fono kvadratai egzistuoja ir kaip jie atrodo.

• Sukurkite plytelių rinkinį. Šio žaidimo plytelių rinkinys bus labai paprastas: viena plytelė ledui ir viena plytelė dangui. Šiame pavyzdyje naudojama ledo plytelė yra iš čia, pagal CC-BY-SA 3.0.
• Sukurkite plytelių rinkinio paveikslėlį. Tai yra visų plytelių, kurios turi būti vienodo dydžio (jas redaguokite, jei jos nėra), nuotraukos ir šalia tokio dydžio, kokį norite matyti žaidime. Išsaugokite savo paveikslėlį kaip icyTiles.png.

• Sukurkite plytelių rinkinio aprašą. Tai XML failas. XML faile yra informacijos apie tai, kokio dydžio plytelės yra plytelių rinkinio paveikslėlyje, kurią nuotrauką naudoti ir kur rasti kokią plytelę. Sukurkite XML failą pavadinimu icyTiles.xml naudodami žemiau esantį kodą:

10. Padarykite savo kraštovaizdžio plytelių žemėlapį

Plytelių žemėlapis yra žemėlapis, kuriame apibrėžiama, kuri plytelė yra jūsų lygio padėtyje. Pavyzdyje turėtumėte apibrėžti plytelių žemėlapių generavimo funkciją, nes plytelių žemėlapių kūrimas rankomis yra labai varginantis. Pažangesnis žaidimas paprastai turi tam tikrą lygių redaktorių, tačiau norint susipažinti su 2D žaidimų kūrimu, algoritmas gali suteikti pakankamai gerų lygių.

• Sužinokite, kiek eilučių ir stulpelių reikia. Norėdami tai padaryti, padalinkite ekrano dydį iš plytelių dydžio tiek horizontaliai (stulpeliai), tiek vertikaliai (eilutės). Suapvalinkite skaičių aukštyn; tam jums reikia matematikos modulio funkcijos, todėl pridėkite nuo matematikos importo viršutinės ribos prie importo kodo viršuje.
• Atidarykite failą rašymui. Tai ištrins visą ankstesnį failo turinį, todėl pasirinkite pavadinimą, kurio dar nėra jokiame kataloge esančiame faile, pvz., LevelMap.xml.
• Į failą įrašykite pradžios žymas.
• Sukurkite plytelių žemėlapį pagal algoritmą. Jūs naudojate tą, kuris pateiktas žemiau esančiame kode, arba galite sugalvoti vieną. Būtinai importuokite „randint“funkciją iš atsitiktinio modulio: ji reikalinga, kad toliau pateiktas kodas veiktų, ir viskam, ką sugalvosite, greičiausiai reikės ir atsitiktinių sveikųjų skaičių. Taip pat būtinai padėkite dangaus plyteles ir ledo plyteles skirtingais sluoksniais: ledas yra kietas, o dangus - ne.
• Į failą įrašykite uždarymo žymas ir uždarykite failą.

defgeneTilemap (): colAmount = lubos (800/16) * 3 # (ekrano plotis / plytelių dydis) * 3 rowAmount = lubos (600/16) # ekrano aukštis / plytelių dydis tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) i diapazone (0, colAmount): tileFile.write ('') makeHole = Netiesa, jei randint (0, 50)) == 10 ir i! = 0: # neleisti skylių neršto taške makeHole = Tiesa, jei diapazonas (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: # apriboti plyteles nuo per žemo ledoHeight = randint (1, 5) if iceHeight> rowAmount: # limito plytelės nuo per didelio ledo aukščio ('\ n / n') i diapazone (0, colAmount): tileFile.write ('') j diapazone (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Žingsnis 11. Parodykite plytelių žemėlapį

Importuokite viską iš „cocos.tiles“ir tada eikite į „startGame“funkciją.

• Funkcijos „startGame“pradžioje sugeneruokite plytelių žemėlapį, naudodami tam nustatytą funkciją.
• Sukurkite naują slinkties tvarkyklę. Padarykite tai tiesiai po linija, kur pridedate sprite prie jo sluoksnio.
• Sukurkite naują sluoksnį su plytelėmis, kuris bus įkeltas iš jūsų sukurtos funkcijos generatorTilemap iš levelMap.xml plytelių žemėlapio.
• Į slinkimo tvarkyklę tiksliai tokia tvarka pridėkite ne kietą sluoksnį, kietą sluoksnį ir sprite sluoksnį. Jei norite, galite pridėti z poziciją.
• Užuot sukūrę sceną iš „Sprite“sluoksnio, sukurkite ją iš slinkties tvarkyklės.

• Dabar jūsų „startGame“funkcija turėtų atrodyti taip:

  def startGame ():geneTilemap () # fig = Sprite ('pingu.png') pav.pozicija = (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 = Scena (scrMang) director.run (gameSc)
  

Žingsnis 12. Išbandykite savo kodą

Turėtumėte dažnai tikrinti savo kodą, kad įsitikintumėte, jog naujos įdiegtos funkcijos tikrai veikia.

Pavyzdyje pateiktas kodas dabar turėtų parodyti ledinį peizažo peizažą. Jei pingvinas atrodo tvyrantis toli virš ledo, nieko blogo nepadarėte ir tai bus ištaisyta kitame žingsnyje

Žingsnis 13. Pridėkite valdiklių

Žaidėjas turi daug daugiau būdų bendrauti su programa 2D žaidime nei teksto žaidime. Dažnas apima figūros perkėlimą, kai paspaudžiamas teisingas klavišas.

• Importuokite viską iš cocos.mapcolliders ir iš cocos.actions. Taip pat importuokite raktą iš pyglet.window.

• „Paskelbkite“kai kuriuos pasaulinius kintamuosius. Visuotiniai kintamieji yra bendrinami tarp funkcijų. Jūs tikrai negalite deklaruoti kintamųjų „Python“, tačiau prieš naudodami turite pasakyti, kad visuotinis kintamasis yra pagrindiniame kode. Galite priskirti 0 kaip vertę, nes funkcija pasirūpins, kad vėliau priskirtų teisingą vertę. Taigi prie importo išraiškų pridėkite:

  # "deklaruojantys" visuotiniai kintamieji klaviatūra = 0 scrMang = 0
  

• „StartGame“funkcijos koregavimas:

  • Tarkime, kad naudojate pasaulinių kintamųjų klaviatūrą ir „scrMang“. Padarykite tai rašydami visuotinę klaviatūrą, „scrMang“funkcijos viršuje.
  • Priverskite langą klausytis klaviatūros įvykių.
  • Pasakykite figūrai, kad ji veiktų remdamasi „PlatformerController“. Netrukus įdiegsite tą „PlatformerController“.
  • Sukurkite žemėlapio greitintuvą, kad galėtumėte susidoroti tarp kietų plytelių ir figūros.

  def startGame (): visuotinė klaviatūra, scrManggeneTilemap () # fig = Sprite ('pingu.png') pav.pozicija = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml ') solidTiles = tileLayer [' solid '] nsoliTiles = tileLayer [' not_solid '] # klaviatūra = key. KeyStateHandler () director.window.push_handlers (klaviatūra) # pav.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on = 'skaidrė') pav. 1) # gameSc = Scena (scrMang) director.run (gameSc)
  

• Sukurkite platformingo valdiklį. Tai pakeis figūrą pagal jūsų klavišų paspaudimus.

  • Apibrėžkite platformingo valdiklį kaip veiksmų pogrupį.
  • Nustatykite judėjimo greitį, šokinėjimo greitį ir gravitaciją.
  • Apibrėžkite paleidimo funkciją. Ši funkcija iškviečiama vieną kartą, kai platformos valdiklis prijungtas prie figūros. Jis turėtų nustatyti greitį iki 0 tiek x, tiek y kryptimi.
  • Apibrėžkite žingsnio funkciją. Scena bus kartojama, kol scena bus rodoma.
  • Nurodykite žingsnio funkcijai naudoti pasaulinių kintamųjų klaviatūrą ir „scrMang“.
  • Gaukite ir pakeiskite greitį. Išsaugokite x ir y greitį atskirais kintamaisiais. Nustatykite x greitį 1 arba -1 (priklausomai nuo to, ar buvo paspaustas kairysis ar dešinysis klavišas) padauginus iš judėjimo greičio. Prie y greičio pridėkite gravitaciją. Padauginkite jį su prastovomis, kad lėčiau veikiančiuose įrenginiuose jis veiktų taip pat. Jei paspaudžiamas tarpo klavišas ir figūra stovi ant žemės, šokinėkite, pakeisdami y greitį į šuolio greitį.
  • Apskaičiuokite, kur figūra turėtų judėti. Tada leiskite susidūrimo tvarkytojui pakoreguoti šią padėtį, jei ji yra vientisos plytelės viduje. Galiausiai perkelkite figūrą į naują sureguliuotą padėtį.
  • Nustatykite slinkties tvarkyklės dėmesį į figūrą. Dėl to fotoaparatas protingai juda, kai figūra juda.

  klasės „PlatformerController“(veiksmas): visuotinė klaviatūra, 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 klaviatūra, slinkties klavišą, jei dt> 0,1: # nieko nedarykite, kol prastovos prie didelės grąžos vx, vy = self.target.velocity vx = (klaviatūra [key. RIGHT] - klaviatūra [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground ir klaviatūra [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 (paskutinis, naujas, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (*new.center)
  

Žingsnis 14. Išbandykite savo kodą

Jei sekėte pavyzdžiu, dabar turėtumėte sugebėti perkelti pingviną rodyklių klavišais ir šokinėti paspausdami tarpo klavišą. Be to, pingvinas dabar turėtų nukristi, o ne pakibti virš žemės.

Žingsnis 15. Sukurkite žaidimo pabaigą

Net ir žaidimai, kurie gali tęstis be galo, turėtų turėti galimybę pralaimėti. Kadangi lygis, kurį padarėte pavyzdyje su funkcija, baigiasi, taip pat turėsite sudaryti sąlygas laimėti tuo tikslu. Priešingu atveju žaidėjas tik šokinėtų ant ledo luitų, o tai būtų nuobodu.

• Platformos valdiklio viduje po fokusavimo nustatykite figūros x ir y padėtį. Jei y pozicija yra mažesnė nei 0, iškvieskite funkciją finishGame () (ją parašysite vėliau), argumentuodami „Game Over“. Jei x padėtis yra didesnė už ekrano dydį, padaugintą iš 3 (anksčiau tai nustatėte kaip lygio dydį).

  posX, posY = self.target.position if posY <0: finishGame ("Game Over") grįžta, jei posX> 800*3: # level size finishGame ("Level Complete") grąžina
  

• Nustatykite klasės pabaigą Meniu. Ji turėtų būti panaši į pagrindinę meniu klasę, kurią apibrėžėte anksčiau, tačiau vietoj tuščios eilutės pavadinimo ji turėtų naudoti kintamą tekstą, kurį funkcija _init_ laiko argumentu. Meniu elementai dabar turėtų būti pažymėti „Bandyti dar kartą“ir „Baigti“, tačiau funkcijos, kurias jie vadina, išlieka tos pačios.

  class FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Bandyti dar kartą", startGame)), („MenuItem“(„Baigti“, pyglet.app.exit))] self.create_menu (menuItems)
  

• Apibrėžkite funkciją finishGame (). Tai turėtų būti tekstas kaip argumentas. Tai turėtų padaryti sceną iš pagrindinio meniu fono, „FinishMenu“su teksto argumentu, kuris bus perkeltas į šį meniu. Tada ji turėtų paleisti šią sceną.

  def finishGame (tekstas): menuSc = Scena (MainMenuBgr ()) menuSc.add (FinishMenu (tekstas)) director.run (menuSc)
  

Žingsnis 16. Pridėkite kreditų

Čia gausite pripažinimą už nuostabų kodą, taip pat ir kitus, kurie jums padėjo. Jei naudojote vaizdą iš kitos svetainės (su leidimu), būtinai priskirkite tą vaizdą jos kūrėjui.

• Sukurkite failą CREDITS ir įveskite ten visus savo kreditus, pavyzdžiui:

  Pingvinas: Kelvinas Shadewingas, pagal CC0 Ledo blokas: Michał Banas skaitmuo1024 opengameart.org pagal CC-BY-SA 3.0
  

• Grįžkite prie savo „Python“kodo ir importuokite etiketę iš „cocos.text“.

• Apibrėžkite poklasį „Sluoksnio kreditai“. Atlikdami funkciją _init_, perskaitykite failą CREDITS ir iš kiekvienos jo eilutės sukurkite teksto etiketę teisingoje vietoje.

  klasės kreditai (sluoksnis): def _init _ (self): super (kreditai, savarankiškai)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") i diapazone (0, len (creds))): credLabel = Etiketė (creds , font_size = 32, anchor_x =" left ", anchor_y =" top ") credLabel.position = 25, 500- (i +1)*40 self.add (credLabel)
  

• Eikite į pagrindinio meniu klasę ir pridėkite meniu elementą „Kreditai“, kuris spustelėjus iškviečia funkciją „showCredits“.

• Nustatykite meniu poklasį „BackToMainMenuButton“. Padarykite tai meniu su vienu elementu, pažymėtu „Atgal“, kuris iškviečia „showMainMenu“funkciją. Šis „meniu“, labiau panašus į mygtuką, turėtų būti vertikaliai išlygintas apačioje, o horizontaliai - viršuje.

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

• Apibrėžkite funkciją showCredits. Ji turėtų sukurti sceną iš „MainMenuBgr“sluoksnio ir „Credits“sluoksnio ir paleisti tą sceną.

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

Žingsnis 17. Patikrinkite savo kodą

Kai manote, kad baigėte savo kodą, turėtumėte dar kartą jį peržiūrėti. Tai gali padėti pastebėti, ar galima ką nors optimizuoti, ar nepamiršote ištrinti nereikalingų eilučių. Jei sekėte pavyzdžiu, visas jūsų kodas dabar turėtų atrodyti taip:

iš cocos.director importas * iš cocos.menu importas * iš cocos.scene importas * iš cocos.layer importas * iš cocos.sprite importas * iš cocos.tiles importas * iš cocos.mapcolliders importas * iš cocos.actions importas * iš kokoso.teksto importavimas Etikečių importavimas pyglet.app iš matematikos importo viršutinės ribos iš atsitiktinio importo randint # "deklaruojantis" pasaulinius kintamuosius klaviatūra = 0 scrMang = 0 klasė MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) klasės pagrindinis meniu (meniu): def _init _ (self): super (pagrindinis meniu, savarankiškas)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems =

• Tai yra 168 eilutės ir 152 eilutės, jei tik suskaičiuosite kodą. Tai atrodo daug, tačiau tokiam sudėtingam žaidimui tai iš tikrųjų yra nedidelė suma.

Žingsnis 18. Baigta

Dabar išbandykite žaidimą. Kai ką nors programuojate, turite patikrinti, ar jis veikia, kai tik įdiegėte ką nors naujo. Be to, galbūt norėsite kurį laiką žaisti tą žaidimą, kurį parašėte.

3 dalis iš 3: Žaidimo leidimas

Žingsnis 1. Užsirašykite priklausomybes

Visi, kurie naudojasi kitu kompiuteriu, neturės tos pačios programinės įrangos ir bibliotekų, kaip jūs. Taigi, jūs turite įsitikinti, kad visi, įdiegę jūsų žaidimą, tiksliai žino, ko jiems reikės paleisti. Jūs neprivalote užsirašyti visų priklausomybių visų priklausomybių ir pan., Bet bent jau turėtumėte parašyti savo paketų priklausomybes ir jų priklausomybes.

Žingsnis 2. Įsitikinkite, kad turite leidimą naudoti visas laikmenas

Tai taikoma visai grafikai, įskaitant 3D modelius, muziką, dialogą, muziką, bibliotekas ir rėmus, kuriuos naudojote žaidimui. Viskas, ko pats neparašei.

• Dažnai yra tam tikrų sąlygų, pvz., Pagal tą pačią licenciją reikia pripažinti autorių arba bendrinti žiniasklaidos pakeitimus. Kartais galėsite naudoti grafiką nepriskirdami kūrėjams, kol už žaidimą nemokėsite. Jei turite pripažinti autorių, darykite tai gerai matomoje vietoje, pvz., Žaidimo skirtuke „Kreditai“.
• Taip pat yra žiniasklaidos, kuriai pateiktos autorių teisės ir licencija nenurodyta, kartais su tam tikru tekstu, pvz., „Visos teisės saugomos“. Jei taip yra, prieš įtraukdami jį į žaidimą, turite gauti aiškų autoriaus leidimą.
• Bibliotekos paprastai išleidžiamos pagal licencijas, leidžiančias jas naudoti kaip biblioteką. Reikšminga išimtis yra GPL be susiejimo išimties: tokia licencija leidžia ją naudoti tik programoje su tam tikromis licencijomis. Ir visada turėtumėte perskaityti bent pagrindinius licencijos punktus, kad įsitikintumėte, jog viskas, ką darote su žiniasklaida ar biblioteka, yra leidžiama.

Įspėjimas: Naudodami žiniasklaidą ar bibliotekas tokiu būdu, kurio neleidžia licencija jūsų skelbiamame žaidime, galite patirti rimtų teisinių problemų. Taigi, jei abejojate, ar jūsų naudojimas leidžiamas, paklauskite autoriaus arba visiškai venkite žiniasklaidos.

3 žingsnis. Nuspręskite, kokiomis sąlygomis norite paskelbti savo žaidimą

Ar parduosite savo žaidimą? Ar norite leisti kitiems naudoti jūsų vaizdus ir idėjas? Nors jūs turite būti atsargūs dėl žiniasklaidos, kurią naudojate savo projekte, paprastai galite nuspręsti, kaip norite leisti kitiems naudoti jūsų žaidimą. Galite naudoti „Creative Commons CC0“licenciją, kad išleistumėte savo žaidimą viešai. Jei norite tam tikromis sąlygomis platinti ir keisti, išlaikydami tam tikras teises, išbandykite „Gnu General Public License“(GPL) arba „Berkeley Software Distribution“(BSD) licenciją. Arba galite padaryti savo programinę įrangą nuosavybės teise, tai reiškia, kad niekam neleidžiama jos platinti ar keisti be jūsų leidimo.

Nors parduodant žaidimus galima užsidirbti, mažai tikėtina, kad žmonės pirks jūsų pirmąjį žaidimą, kuris paprastai turi mažai funkcijų ir nieko ypatingo. Be to, jei nemokama programa neveikia, ją atsisiuntę žmonės tiesiog nusivils. Tačiau jei jie už tai sumokėjo, jie pareikalaus pinigų, sukeldami daugiau problemų tiek jums, tiek vartotojams. Taigi apsvarstykite galimybę padaryti savo pirmąsias programas nemokamas

Žingsnis 4. Nuspręskite, kaip norite paskelbti savo žaidimą

Kiekvienas metodas turi tam tikrų privalumų ir trūkumų, todėl jūs turite nuspręsti pats.

• Paskelbkite jį svetainėje:

  Jei turite svetainę, galite įkelti žaidimą, kad jį būtų galima atsisiųsti. Būtinai pateikite aiškias instrukcijas, kaip įdiegti programinę įrangą, taip pat nurodykite visas reikalingas priklausomybes. Trūkumas yra tas, kad žaidėjai turės rankiniu būdu įdiegti priklausomybes, o tai kai kuriems žmonėms gali būti sunku.

• Pakuotės kūrimas paketų tvarkytojui:

  Yra įvairių paketų tvarkyklių, tokių kaip „apt“, „Yum“ir „Homebrew“, kurios palengvina žmonių diegimą programose „Linux“ir „Linux“aplinkoje. Visi jie turi skirtingus paketų formatus. Geras dalykas apie paketus yra tas, kad jie automatiškai įdiegia visas priklausomybes (jei teisingai sukonfigūravote). Taigi žaidėjas turi tik įdiegti jūsų paketą ir tada žaisti žaidimą. Problema ta, kad skirtingose platformose yra daug skirtingų paketų tvarkytojų, todėl turėsite įdėti šiek tiek pastangų, kad pateiktumėte paketus visoms labiausiai paplitusioms.

Žingsnis 5. Atkreipkite dėmesį į savo programą

Apsvarstykite galimybę įkelti programą į pagrindinę paketų saugyklą, pvz., „Ubuntu“ir „Debian“, kad būtų galima lengvai įdiegti. Taip pat paskelbkite atitinkamuose forumuose, pvz., „GameDev“projektų skiltyje arba „tigSource“dalyje. Tačiau nenusiminkite, jei pirmieji jūsų žaidimai netaps žinomi. Jei turite idėją, kad tai patinka daugeliui žmonių, jūsų žaidimas gali tapti gerai žinomas.

Patarimai

• Būkite kantrūs ir pasiruošę mokytis. Programavimas kartais gali būti varginantis!
• Jei įdomu, kaip kažkas daroma kitame žaidime, o žaidimas yra atvirojo kodo, galite pažvelgti į jo šaltinio kodą.
• Ieškodami žiniasklaidos, pabandykite rasti viešojo turinio turinį. Ieškokite „Creative Commons“arba „Public Domain“vaizdų ir muzikos ir naudokite tokias svetaines kaip https://opengameart.org arba
• Nekopijuokite didelių kodo dalių, nepatikrinę licencijos. Dažnai tai draudžiama, o jei ne, paprastai reikia priskirti.
• Reklamuodami savo žaidimą nedarykite šlamšto ir neskelbkite netinkamų vietų. Tikėtina, kad tai jus užblokuos iš puslapio, tai tiesiog erzina ir pakenks jūsų reputacijai.