Ai o idee pentru un joc pe computer și vrei să-l faci real? Sau v-ați întrebat vreodată cum sunt scrise jocurile pe computer? Acest wikiHow vă învață cum să scrieți trei jocuri de bază pe computer în Python. Veți avea nevoie de o înțelegere de bază a Python și a conceptelor generale de programare pentru a vă dezvolta primul joc.
Pași
Partea 1 din 3: Realizarea unui joc bazat pe text
Pasul 1. Alegeți un limbaj de programare
Toate limbajele de programare sunt diferite, deci va trebui să decideți pe care să îl utilizați pentru a vă scrie jocul. Fiecare limbaj major de programare acceptă introducerea textului, ieșirea textului și construcțiile if (principalele lucruri de care aveți nevoie pentru un joc simplu bazat pe text), deci explorați opțiunile și decideți cu care vă simțiți cel mai confortabil și dedicat învățării. Iată câțiva factori de luat în considerare:
-
La ce se folosește cel mai mult limba?
Unele limbaje de programare, cum ar fi JavaScript, sunt concepute pentru a fi utilizate pentru web, în timp ce altele, cum ar fi Python, C sau C ++, sunt proiectate pentru a rula programe pentru computer. Pentru jocul dvs., vizați un limbaj cu o gamă mai largă de utilizare, cum ar fi Python, C, C ++ sau JavaScript.
-
Cât de greu este să înveți?
Deși scrierea unui program ar trebui să fie suficient de ușoară după o anumită practică în orice limbaj de programare normal (adică nu unul conceput special pentru a fi confuz ca Malbolge), unele sunt mai prietenoase cu începătorii decât altele. Java și C, de exemplu, vă vor cere să înțelegeți concepte de programare mai profunde decât ceva de genul Python, care este cunoscut pentru sintaxa sa mai accesibilă și mai directă.
-
Unde îl pot folosi?
Probabil doriți ca oamenii de pe diferite sisteme, cum ar fi Linux, Mac sau Windows, să vă poată juca jocul. Deci, nu ar trebui să utilizați un limbaj care este acceptat numai pe câteva sisteme, cum ar fi Visual Basic, care este acceptat numai pe Windows.
Acest articol va folosi Python pentru exemplele unui joc bazat pe text, dar puteți căuta modul în care conceptele sunt realizate în orice alt limbaj de programare.
Pasul 2. Pregătiți computerul
Cele două componente principale de care aveți nevoie sunt un editor de text, în care vă veți scrie codul, și un compilator, pe care îl veți folosi pentru a-l transforma într-un joc. Dacă doriți să urmați exemplul din acest articol, ar trebui să instalați Python și să aflați cum să rulați programe. Dacă doriți, puteți configura un IDE (Integraded Desktop Environment), care combină editarea, compilarea și depanarea într-un singur program. IDE-ul Python se numește IDLE. Dar puteți utiliza, de asemenea, orice editor de text care acceptă text simplu, cum ar fi Notepad pentru Windows, TextEdit pentru macOS sau Vim pentru Linux.
Pasul 3. Scrieți un cod pentru a saluta jucătorul
Jucătorul va dori să știe ce se întâmplă și ce trebuie să facă, așa că ar trebui să tipăriți un text pentru ei.
-
Acest lucru se face cu funcția print () din Python. Pentru a încerca, deschideți un fișier nou cu extensia.py, introduceți următorul cod în el, salvați și rulați-l:
print ("Bine ați venit la jocul de ghicit cu numărul!") print ("Introduceți un număr întreg între 1 și 1000:")
Pasul 4. Generați un număr aleatoriu
Să facem un joc bazat pe text care îi cere jucătorului să ghicească numărul corect. Primul lucru pe care trebuie să-l facem este să generăm un număr aleatoriu la începutul jocului, astfel încât jucătorul să nu ghicească întotdeauna același număr. Deoarece numărul va rămâne același pe tot parcursul programului, veți dori să stocați numărul aleatoriu într-o variabilă.
- Python nu are o funcție de număr aleatoriu încorporată, dar are o bibliotecă standard (aceasta înseamnă că utilizatorul nu va trebui să instaleze nimic suplimentar) care are. Deci, mergeți la începutul codului (înainte de funcțiile print ()) și tastați importul de linie aleatoriu.
-
Folosiți funcția aleatorie. Se numește randint (), se află în biblioteca aleatorie pe care tocmai ați importat-o și ia valoarea minimă și maximă pe care numărul o poate avea ca argument. Deci, reveniți la sfârșitul codului dvs. și introduceți următoarea linie:
dreapta = random.randint (0, 1000)
Pasul 5. Obțineți informații de la player
Într-un joc, jucătorul vrea să facă ceva sau să interacționeze cu ceva. Într-un joc bazat pe text, acest lucru este posibil prin introducerea textului. Acum că avem un număr aleatoriu, următoarele rânduri de cod ar trebui să ceară jucătorului să introducă cea mai bună presupunere.
-
Deoarece codul pe care l-ați introdus tipărește instrucțiunea de a introduce un număr jucătorului, acesta ar trebui să citească și numărul pe care îl introduc. Acest lucru se face cu input () în Python 3 și raw_input () în Python 2. Ar trebui să scrieți în Python 3, deoarece Python 2 va deveni învechit în curând. Adăugați următoarea linie în codul dvs. pentru a stoca intrarea jucătorului într-o variabilă numită număr:
userNum = input ()
Pasul 6. Transformați intrarea playerului într-un tip de date utilizabil
Jucătorul a introdus un număr - acum ce?
-
Faceți intrarea jucătorului un număr. Acum, s-ar putea să pară confuz deoarece tocmai au introdus un număr. Dar există un motiv întemeiat: Python presupune că toate intrările sunt text sau un „șir”, așa cum se numește în programare. Acest text conține numărul pe care doriți să îl obțineți. Python are o funcție care convertește un șir care conține doar un număr la numărul din interior. Tip:
userNum = int (userNum)
Pasul 7. Comparați numărul jucătorului cu numărul corect
Odată ce jucătorul își introduce numărul, va trebui să îl comparați cu cel care a fost generat aleatoriu. Dacă numerele nu sunt aceleași, jocul tău îl poate determina pe jucător să încerce un alt număr. Dacă numerele se potrivesc, îi puteți spune jucătorului că au ghicit corect și să părăsească programul. Acest lucru se face cu următorul cod:
în timp ce UserNum! = rightNum: userNum = int (input ())
Pasul 8. Dă feedback jucătorului
Deși deja le-ați procesat intrarea, playerul nu va vedea acest lucru. Va trebui să imprimați efectiv rezultatele jucătorului, astfel încât să înțeleagă ce se întâmplă.
- Cu siguranță, ai putea spune jucătorului dacă numărul lor este corect sau greșit. Dar cu această abordare, jucătorul ar putea fi nevoit să ghicească de 1000 de ori în cel mai rău caz, ceea ce ar fi foarte plictisitor.
- Deci, spune-i jucătorului dacă numărul lor este prea mic sau prea mare. Acest lucru le va reduce semnificativ numărul de presupuneri. Dacă, de exemplu, jucătorul ghicește mai întâi 500, iar jocul răspunde „Prea mare. Încercați din nou”, vor exista doar 500 de numere posibile în loc de 1000. Acest lucru se face cu construcții if, deci înlocuiți tipăritul („Greșit. Încercați din nou. ") Cu unul.
- Rețineți că verificarea dacă două numere sunt aceleași se face cu ==, nu cu =. = atribuie valoarea dreaptă a acesteia variabilei din stânga acesteia!
dacă userNum <rightNum: print ("Prea mic. Încercați din nou:") dacă userNum> rightNum: print ("Prea mare. Încercați din nou:")
Pasul 9. Testați codul
În calitate de programator, ar trebui să vă asigurați că codul dvs. funcționează înainte de a-l considera finalizat.
-
Când programați în python, asigurați-vă că obțineți indentările corecte. Codul dvs. ar trebui să arate astfel:
import print aleatoriu („Bine ați venit la jocul de ghicit!”) print („Introduceți un număr întreg între 1 și 1000:”) rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) în timp ce userNum! = rightNum: if userNum <rightNum: print ("Prea mic. Încercați din nou:") if userNum> rightNum: print ("Prea mare. Încercați din nou:") userNum = int (input ()) print ("Ați ghicit corect.")
Pasul 10. Validați intrarea
Jucătorul nu ar trebui să-ți poată rupe jocul, introducând pur și simplu un lucru greșit. „Validarea intrării” înseamnă asigurarea faptului că jucătorul a introdus ceea ce este corect înainte de al procesa.
- Deschide din nou jocul și încearcă să introduci orice nu este un număr. Jocul va ieși cu un ValueError. Pentru a evita acest lucru, puteți implementa o modalitate de a verifica dacă intrarea a fost un număr.
- Definiți o funcție. Deoarece validarea intrării este destul de lungă și trebuie să o faceți de mai multe ori, ar trebui să definiți o funcție. Nu va fi nevoie de argumente și va returna un număr. Mai întâi, scrie def numInput (): în partea de sus a codului, direct sub importul aleatoriu.
- Obțineți inputul jucătorului o dată. Utilizați funcția input () și atribuiți rezultatul variabilei inp.
- Când intrarea jucătorului nu este un număr, cereți-i să introducă un număr. Pentru a verifica dacă un șir este un număr, utilizați funcțiile isdigit (), care permite doar un număr întreg, deci nu va trebui să verificați separat acest lucru.
- Dacă intrarea este un număr, convertiți-l din șir în număr și returnați rezultatul. Utilizați funcția int () pentru conversia șirului într-un număr întreg. Acest lucru va face inutilă conversia din codul principal și ar trebui să o eliminați de acolo.
- Înlocuiți toate apelurile către input () din codul principal cu apeluri către numInput ().
- Codul funcției numInput () va arăta astfel:
def numInput (): inp = input () în timp ce nu inp.isdigit (): print ("Vi s-a spus să introduceți un număr întreg! Introduceți un număr întreg:") inp = input () return int (inp)
Pasul 11. Testați din nou jocul
Introduceți lucrurile greșite intenționat pentru a vedea ce se întâmplă, apoi remediați eventualele erori pe măsură ce apar.
Încercați să introduceți text când programul vă solicită un număr. Acum, în loc să ieșiți cu un mesaj de eroare, programul vă va cere din nou un număr
Pasul 12. Sugerați să reporniți jocul când acesta se termină
În acest fel, jucătorul îți poate juca jocul pentru o perioadă mai lungă de timp, fără a fi nevoie să îl repornești în mod constant.
- Puneți tot codul, cu excepția importului și definiția funcției într-o buclă de timp. Setați True ca condiție: acest lucru va fi întotdeauna adevărat, astfel încât bucla va continua pentru totdeauna.
- Întrebați-l pe jucător dacă vrea să joace din nou după ce a ghicit corect numărul. Utilizați funcția print ().
- Dacă răspund „Nu”, ieși din privire. Dacă răspund la altceva, continuați. Ieșirea dintr-o buclă se face cu instrucțiunea break.
- Mutați „Bun venit la jocul de ghicire a numărului” în afara buclei while. Probabil că jucătorul nu vrea să fie întâmpinat de fiecare dată când joacă jocul. Deplasați instrucțiunea de imprimare („Bine ați venit la jocul de ghicire a numărului!” Deasupra timpului Adevărat:, deci va fi tipărită o singură dată, când utilizatorul începe primul joc.
Pasul 13. Testați jocul
Va trebui să vă testați jocul de fiecare dată când implementați o nouă funcție.
-
Asigurați-vă că răspundeți atât „Da”, cât și „Nu” cel puțin o dată pentru a vă asigura că ambele opțiuni funcționează. Iată cum ar trebui să arate codul dvs.:
import aleator def numInput (): inp = input () în timp ce nu inp.isdigit (): print ("Vi s-a spus să introduceți un număr întreg! Introduceți un număr întreg:") inp = input () return int (inp) print („Bine ați venit la jocul de ghicit!”) În timp ce True: print („Introduceți un număr întreg între 1 și 1000:”) rightNum = random.randint (0, 1000) userNum = numInput () în timp ce userNum! = RightNum: if userNum <rightNum: print ("Prea mic. Încearcă din nou:") dacă userNum> rightNum: print ("Prea mare. Încearcă din nou:") userNum = numInput () print ("Ai ghicit corect") print ("Do you doriți să redați din nou? Introduceți Nu pentru a ieși. ") if input () ==" No ": break
Pasul 14. Scrie alte jocuri bazate pe text
Ce zici de scrierea unei aventuri text în continuare? Sau un joc de test? Fii creativ.
Bacsis: Uneori este util să căutați în documentație dacă nu sunteți sigur cum se face ceva sau cum este utilizată o funcție. Documentația Python 3 se găsește la https://docs.python.org/3/. Uneori, căutarea a ceea ce doriți să faceți pe internet oferă, de asemenea, rezultate bune.
Partea 2 din 3: Realizarea unui joc cu grafică 2D
Pasul 1. Alegeți o bibliotecă grafică
Realizarea graficelor este foarte complicată și majoritatea limbajelor de programare (inclusiv Python, C ++, C, JavaScript) oferă doar suport minim sau chiar deloc pentru grafică în bibliotecile de bază sau standard. Deci va trebui să utilizați o bibliotecă externă pentru a putea realiza grafică, de exemplu Pygame pentru Python.
Chiar și cu o bibliotecă grafică, va trebui să vă faceți griji cu privire la lucruri precum modul de afișare a unui meniu, modul de verificare a clicului jucătorului, modul de afișare a plăcilor etc. Dacă preferați să vă concentrați asupra dezvoltării jocului real, puteți utiliza o bibliotecă de motoare de jocuri precum Unity, care implementează aceste lucruri cu ușurință
Acest articol va folosi Python cu Cocos2D pentru a arăta cum să faci un platformer 2D simplu. Este posibil ca unele dintre conceptele menționate să nu existe în alte motoare de joc. Consultați documentația lor pentru mai multe informații.
Pasul 2. Instalați biblioteca grafică pe care ați ales-o
Cocos2D pentru Python este ușor de instalat. Puteți să-l obțineți de la https://python.cocos2d.org/index.html sau executând sudo pip3 install cocos2d dacă utilizați Linux.
Pasul 3. Creați un director nou pentru jocul și materialele dvs. media
Veți folosi lucruri precum imagini și sunete în jocul dvs. Păstrați aceste lucruri în același director cu programul. Acest director nu ar trebui să conțină altceva, astfel încât să puteți vedea cu ușurință ce active aveți în joc.
Pasul 4. Creați un nou fișier de cod în noul director
Apelați-l principal, cu extensia de fișier pentru limbajul dvs. de programare. Dacă scrieți un program mare și complex în care are sens să aveți mai multe fișiere de program, acesta vă va arăta care este fișierul principal.
În acest exemplu, vom crea un fișier numit main.py care va conține tot codul nostru
Pasul 5. Creați fereastra jocului
Aceasta este premisa de bază pentru un joc cu grafică.
- Importați sub-modulele cocos2d necesare: cocos.director, cocos.scene și cocos.layer. Acest lucru se face cu importul subModuleName *, unde numele sub-modul este submodulul pe care doriți să-l importați. Diferența dintre de la … import * și import … este că nu trebuie să puneți numele modulului în fața a tot ceea ce utilizați din acel modul cu primul.
- Definiți o subclasă MainMenuBgr din ColorLayer. Aceasta înseamnă practic că orice fundal al meniului principal pe care îl creați se va comporta ca un strat de culoare, cu unele modificări pe care le faceți.
- Porniți directorul cocos. Aceasta vă va oferi o fereastră nouă. Dacă nu setați o legendă, fereastra va avea aceeași legendă ca numele fișierului (main.py), care nu va arăta profesional. Permiteți redimensionarea ferestrei prin setarea redimensionării la True.
- Definiți o funcție showMainMenu. Ar trebui să puneți codul pentru afișarea meniului principal într-o funcție, deoarece acest lucru vă va permite să reveniți cu ușurință la meniul principal apelând din nou funcția.
- Creați o scenă. Scena constă, deocamdată, dintr-un singur strat, care este un obiect al clasei MainMenuBgr definite de dvs.
- Rulați această scenă în fereastră.
din import cocos.director * din import cocos.scene * din import cocos.layer * clasă 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 - un platformer simplu", redimensionabil = True) showMainMenu ()
Pasul 6. Adăugați un meniu principal la fereastră
Pe lângă jocul real, va trebui să adăugați un meniu pe care jucătorul îl poate folosi pentru a închide fereastra, printre alte elemente pe care le puteți adăuga ulterior.
- Importați cocos.menu (din nou cu instrucțiunea de la) și pyglet.app (de data aceasta cu import).
- Definiți MainMenu ca o subclasă de meniu.
- Setați alinierea meniului principal. Trebuie să setați alinierea verticală și orizontală separat.
- Creați o listă de elemente de meniu și adăugați-le la meniu. Ar trebui să aveți cel puțin elementele de meniu „Start Game” și „Quit”. Fiecare element de meniu trebuie plasat în paranteze. Fiecare articol trebuie să aibă o etichetă și o funcție de apel invers care determină ce se întâmplă atunci când jucătorul face clic pe ea. Pentru elementul „Start Game”, utilizați funcția startGame (o veți scrie în curând), pentru elementul „Quit”, utilizați „pyglet.app.exit” (există deja). Creați meniul real apelând self.create_menu (menuItems).
- Definiți startGame (). Doar puneți trecerea în definiție pentru moment, o veți înlocui atunci când scrieți jocul propriu-zis.
- Mergeți la locul din codul dvs. în care ați creat scena menSc și adăugați un obiect MainMenu.
-
Întregul cod ar trebui să arate acum după cum urmează:
din import cocos.director * din import cocos.menu * din import cocos.scene * din import cocos.layer * import clasa pyglet.app MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) class MainMenu (Menu): 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 = Scene (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) director.init (caption = "IcyPlat - un platformer simplu", redimensionabil = True) showMainMenu ()
Pasul 7. Testați codul
Testați codul devreme, în timp ce este încă scurt și relativ simplu. Apoi, puteți identifica și corecta orice greșeli din structura de bază înainte ca lucrurile să devină prea complicate.
Codul din instrucțiuni ar trebui să deschidă o fereastră cu titlul „IcyPlat - un platformer simplu”. Fundalul este albastru deschis și puteți redimensiona fereastra. Când faceți clic pe „Începeți jocul” din meniu, nu ar trebui să se întâmple nimic (încă). Când faceți clic pe „Ieșiți”, fereastra se va închide
Pasul 8. Creați un sprite
Un sprite este un „obiect de joc” sau o imagine bidimensională. Spritele pot fi obiecte din joc, icoane, decorațiuni de fundal, personaje și orice altceva pe care îl puteți reprezenta cu o imagine din joc. Vom începe prin a crea un sprite pentru un personaj cu care jucătorul poate interacționa.
- Importați submodulul cocos.sprite cu expresia from-import.
- Găsiți o imagine care să reprezinte sprite-ul. Nu puteți afișa un sprite dacă nu aveți o imagine pentru el. Puteți desena una sau puteți obține una de pe internet (aveți grijă de licențe, totuși, dacă intenționați să vă publicați jocul). Pentru acest exemplu, accesați https://opengameart.org/content/tux-classic-hero-style și salvați imaginea-p.webp" />
- Creați un strat ca obiect nou al clasei ScrollableLayer. Apoi, creați sprite-ul ca obiect Sprite și setați poziția sa la (8, 250). Pentru referință, punctul (0, 0) se află în colțul din stânga jos. Acest lucru este destul de mare, dar se va asigura că pinguinul nu se blochează în gheață.
- Adăugați spritul la stratul spritei.
- Creați o nouă scenă din stratul spritei și rulați-o.
def startGame (): figLayer = ScrollableLayer () fig = Sprite ('pingu.png') fig.position = (75, 100) figLayer.add (fig) # gameSc = Scene (figLayer) director.run (gameSc)
Pasul 9. Visează-ți peisajul
În majoritatea jocurilor, spritele tale nu ar trebui să plutească doar în gol. De fapt, ar trebui să stea pe o anumită suprafață, cu ceva în jurul lor. În jocurile 2D, acest lucru se face adesea cu un set de plăci și o hartă de plăci. Setul de plăci spune practic ce fel de pătrate de suprafață și pătrate de fundal există și cum arată.
- Creați un set de plăci. Setul de plăci pentru acest joc va fi foarte de bază: o placă pentru gheață și o placă pentru cer. Plăcile de gheață utilizate în acest exemplu provin de aici, sub CC-BY-SA 3.0.
- Creați o imagine a setului de plăci. Aceasta este o imagine a tuturor plăcilor, care trebuie să fie toate de aceeași dimensiune (editați-le dacă nu sunt) și au dimensiunea pe care doriți să o vedeți în joc, una lângă alta. Salvați imaginea ca icyTiles.png.
-
Creați descrierea setului de plăci. Acesta este un fișier XML. Fișierul XML conține informații despre cât de mari sunt plăcile în imaginea setului de plăci, ce imagine să folosiți și unde să găsiți ce placă. Creați un fișier XML numit icyTiles.xml cu codul de mai jos:
Pasul 10. Realizați o hartă a plăcilor pentru peisajul dvs
O hartă a țiglelor este o hartă care definește ce țiglă este în ce poziție în nivelul dvs. În exemplu, ar trebui să definiți o funcție pentru a genera hărți de dale, deoarece proiectarea manuală a hărților de dale este foarte plictisitoare. Un joc mai avansat ar avea de obicei un fel de editor de nivel, dar pentru familiarizarea cu dezvoltarea jocului 2D, un algoritm poate oferi niveluri suficient de bune.
- Aflați câte rânduri și coloane sunt necesare. Pentru aceasta, împărțiți dimensiunea ecranului la dimensiunea plăcilor atât pe orizontală (coloane), cât și pe verticală (rânduri). Rotunjește numărul în sus; aveți nevoie de o funcție a modulului matematic pentru asta, așa că adăugați din plafonul de import matematic la importurile din partea de sus a codului.
- Deschideți un fișier pentru scriere. Aceasta va șterge tot conținutul anterior al fișierului, așa că alegeți un nume pe care niciun fișier din director nu îl are încă, cum ar fi levelMap.xml.
- Scrieți etichetele de deschidere în fișier.
- Generați o hartă a plăcilor conform algoritmului. O folosiți pe cea din codul de mai jos sau puteți veni cu una singură. Asigurați-vă că importați funcția randint din modulul aleatoriu: este necesar ca codul de mai jos să funcționeze și orice aveți la dispoziție va avea probabil nevoie și de numere întregi aleatorii. De asemenea, asigurați-vă că puneți plăci cereale și plăci de gheață în diferite straturi: gheața este solidă, cerul nu.
- Scrieți etichetele de închidere în fișier și închideți fișierul.
def generateTilemap (): colAmount = ceil (800/16) * 3 # (lățimea ecranului / dimensiunea țiglelor) * 3 rowAmount = ceil (600/16) # înălțimea ecranului / dimensiunea țiglelor tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) for i in range (0, colAmount): tileFile.write ('') makeHole = False if randint (0, 50) == 10 și i! = 0: # nu permite găuri la spawnpoint makeHole = Adevărat pentru j în intervalul (0, rowAmount): dacă makeHole: tileFile.write ('\ n') altceva: dacă j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight + 5) if iceHeight <0: # limita țiglelor de a merge prea jos iceHeight = randint (1, 5) if iceHeight> rowAmount: # limitează plăcile pentru a merge prea mare iceHeight = randint (int (rowAmount / 2) -5, int (rowAmount / 2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') pentru i în intervalul (0, colAmount): tileFile.write ('') pentru j în intervalul (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()
Pasul 11. Afișați harta plăcilor
Importați totul din cocos.tiles și apoi intrați în funcția startGame pentru asta.
- La începutul funcției startGame, generați o hartă a plăcilor folosind funcția pe care ați definit-o pentru aceasta.
- Creați un nou manager de defilare. Faceți acest lucru direct sub linia în care adăugați sprite la stratul său.
- Creați un strat nou care conține dale, care va fi încărcat din harta de dale levelMap.xml generată de funcția generateTilemap.
- Adăugați stratul non-solid, stratul solid și stratul sprite în managerul de derulare, exact în această ordine. Puteți adăuga o poziție z dacă doriți.
- În loc să creați scena din stratul sprite, creați-o din managerul de derulare.
-
Funcția dvs. startGame ar trebui să arate acum:
def startGame (): generateTilemap () # 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)
Pasul 12. Testați codul
Ar trebui să vă testați codul des pentru a vă asigura că noile funcții pe care le-ați implementat funcționează cu adevărat.
Codul din exemplu ar trebui să arate acum un peisaj înghețat din spatele pinguinului. Dacă pinguinul pare că pluteste mult peste gheață, nu ați făcut nimic greșit și va fi remediat în pasul următor
Pasul 13. Adăugați comenzile
Jucătorul are mult mai multe moduri de a interacționa cu programul într-un joc 2D decât într-un joc bazat pe text. Unul obișnuit include mutarea figurii lor atunci când este apăsată tasta corectă.
- Importați totul din cocos.mapcolliders și din cocos.actions. De asemenea, importați cheia din pyglet.window.
-
„Declarați” unele variabile globale. Variabilele globale sunt partajate între funcții. Nu puteți declara cu adevărat variabile în Python, dar trebuie să spuneți că există o variabilă globală în codul principal înainte de a o utiliza. Puteți atribui 0 ca valoare, deoarece o funcție se va ocupa de atribuirea valorii corecte ulterior. Așadar, adăugați sub expresiile de import:
# variabile globale "declarante" tastatură = 0 scrMang = 0
-
Reglați funcția startGame:
- Spuneți că utilizați variabilele globale tastatură și scrMang. Faceți acest lucru scriind tastatura globală, scrMang în partea de sus a funcției.
- Faceți ca fereastra să asculte evenimentele de pe tastatură.
- Spuneți cifrei să acționeze pe baza unui PlatformerController. Veți implementa acel PlatformerController în curând.
- Creați un colizor de hărți pentru a face față coliziunilor dintre dale solide și figură.
def startGame (): tastatură globală, scrMang generateTilemap () # 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)
-
Creați un controler platformer. Aceasta este ceea ce va muta figura în funcție de apăsarea tastelor.
- Definiți controlerul platformer ca o subclasă de acțiune.
- Definiți viteza de mișcare, viteza de salt și gravitația.
- Definiți funcția de pornire. Această funcție se numește o singură dată, când controlerul platformer este conectat la figură. Ar trebui să-și seteze viteza la 0 atât în direcția x, cât și în direcția y.
- Definiți funcția pas. Se va repeta în timp ce scena rulează.
- Spuneți funcției de pas să utilizeze variabilele globale tastatură și scrMang.
- Obțineți și modificați viteza. Salvați viteza x și y în variabile separate. Setați viteza x la 1 sau -1 (în funcție de apăsarea tastei stânga sau dreapta) înmulțită cu viteza de deplasare. Adăugați gravitația la viteza y. Înmulțiți-l cu timpii morți, astfel încât să funcționeze la fel pe dispozitivele mai lente. Dacă se apasă tasta spațială și figura stă pe pământ, sari schimbând viteza y la viteza de săritură.
- Calculați unde ar trebui să se miște figura. Apoi lăsați dispozitivul de manipulare a coliziei să regleze acea poziție dacă se află în interiorul unei plăci solide. În cele din urmă, mutați figura în noua poziție ajustată.
- Setați focalizarea managerului de derulare pe figură. Acest lucru determină mișcarea camerei într-un mod rezonabil atunci când figura se mișcă.
clasă PlatformerController (Acțiune): tastatură globală, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (self, dt): tastatură globală, scroll dacă dt> 0,1: # nu face nimic în timpul opririi pentru a reveni mare vx, vy = self.target.velocity vx = (tastatură [key. RIGHT] - tastatură [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 (last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center)
Pasul 14. Testați codul
Dacă ați urmat exemplul, ar trebui să puteți muta pinguinul cu tastele săgeți și săriți apăsând bara de spațiu. De asemenea, pinguinul ar trebui să cadă acum în loc să plutească deasupra solului.
Pasul 15. Creați un final pentru joc
Chiar și jocurile care pot continua la nesfârșit ar trebui să aibă posibilitatea de a pierde. Deoarece nivelul pe care l-ați făcut în exemplul cu o funcție are un sfârșit, va trebui, de asemenea, să faceți posibil să câștigați venind în acest scop. În caz contrar, jucătorul ar sări doar pe blocurile de gheață de acolo, ceea ce ar deveni plictisitor.
-
În interiorul controlerului platformer, după setarea focalizării, obțineți poziția x și y a figurii. Dacă poziția y este mai mică de 0, apelați funcția finishGame () (o veți scrie mai târziu) cu „Game Over” ca argument. Dacă poziția x este mai mare decât dimensiunea ecranului înmulțită cu 3 (ați stabilit ca dimensiune de nivel înainte).
posX, posY = self.target.position if posY <0: finishGame ("Game Over") returnează dacă posX> 800 * 3: # level size finishGame ("Level Completed") returnează
-
Definiți o clasă finishMenu. Ar trebui să fie ca clasa meniului principal pe care ați definit-o anterior, dar în loc să aibă un șir gol ca titlu, ar trebui să utilizeze un text variabil pe care funcția _init_ îl ia ca argument. Elementele de meniu ar trebui să fie etichetate „Încercați din nou” și „Ieșiți” acum, dar funcțiile pe care le numesc rămân aceleași.
class FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Încercați din nou", startGame)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems)
-
Definiți funcția finishGame (). Ar trebui să ia textul ca argument. Ar trebui să facă o scenă din fundalul meniului principal, un FinishMenu cu argumentul text fiind trecut în acest meniu. Atunci ar trebui să ruleze această scenă.
def finishGame (text): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (text)) director.run (menuSc)
Pasul 16. Adăugați credite
Aici primiți credit pentru codul dvs. minunat, precum și acordați credit oricui altcineva care v-a ajutat pe parcurs. Dacă ați folosit o imagine de pe un alt site web (cu permisiunea), asigurați-vă că atribuiți imaginea respectivă creatorului său.
-
Creați un fișier CREDITE și introduceți toate creditele acolo, astfel:
Pinguin: Kelvin Shadewing, sub CC0 Bloc de gheață: Michał Banas digit1024 pe opengameart.org sub CC-BY-SA 3.0
- Reveniți la codul dvs. Python și importați eticheta din cocos.text.
-
Definiți o subclasă Credite ale stratului. În funcția sa _init_, citiți fișierul CREDITS și creați o etichetă text în poziția corectă din fiecare linie din acesta.
class Credits (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") pentru i în intervalul (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)
- Accesați clasa de meniu principal și adăugați un element de meniu etichetat „Credite” care apelează funcția showCredits atunci când faceți clic.
-
Definiți o subclasă Buton BackToMainMenuMenu din meniu. Faceți din acesta un meniu cu un singur articol, etichetat „Înapoi”, care apelează funcția showMainMenu. Acest „meniu”, care seamănă mai mult cu un buton, ar trebui să fie aliniat vertical la partea de jos și orizontal la partea de sus.
class BackToMainMenuButton (Menu): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self. create_menu (menuItems)
-
Definiți funcția showCredits. Ar trebui să facă o scenă dintr-un strat MainMenuBgr și un strat Credite și să ruleze scena respectivă.
def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)
Pasul 17. Verificați codul
Când credeți că ați terminat codul, ar trebui să vă uitați din nou la toate. Acest lucru vă poate ajuta să observați dacă ceva poate fi optimizat sau dacă există câteva linii inutile pe care ați uitat să le ștergeți. Dacă ați urmat exemplul, întregul cod ar trebui să arate acum după cum urmează:
din import cocos.director * din import cocos.menu * din import cocos.scene * din import cocos.layer * din import cocos.sprite * din import cocos.tiles * din cocos.mapcolliders import * din cocos.actions import * din cocos.text import Etichetă import pyglet.app din pyglet.window cheie de import din matematica import plafon din import aleatoriu randint # "declarare" variabile globale tastatură = 0 scrMang = 0 clasă MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) class MainMenu (Menu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menu Elemente = [(MenuItem ("Start Game", startGame)), (MenuItem ("Credits", showCredits)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems) class Credits (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n") for 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) class BackToMainMenuButton (Menu): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self.create_menu (menuItems) class FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Încercați din nou", startGame)), (MenuItem ("Quit", pyglet. app.exit))] self.create_menu (menuItems) class PlatformerController (Action): global keyboard, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (auto, dt): tastatură globală, scroller dacă dt> 0,1: # nu face nimic în timp de oprire prea mare returnează vx, vy = self.target.velocity vx = (tastatură [tastă. DREAPTA] - tastatură [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on _ground și tastatură [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 (last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center) posX, posY = self.target.position if posY <0: finishGame ("Game Over") returnează dacă posX> 800 * 3: # level size finishGame ("Level Completed") returnează def finishGame (text): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (text)) director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc) def generateTilemap (): colAmount = ceil (800/16) * 3 # (lățimea ecranului / dimensiunea țiglelor) * 3 rowAmount = tavan (600/16) # înălțimea ecranului / dimensiunea țiglelor tileFile = deschis ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) for i in range (0, colAmount): tileFile.write ('') makeHole = Fals dacă rand int (0, 50) == 10 și i! = 0: # nu permite găuri la spawnpoint makeHole = Adevărat pentru j în intervalul (0, rowAmount): dacă makeHole: tileFile.write ('\ n') altceva: if j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight + 5) if iceHeight <0: # limitează țiglele iceHeight low = randint (1, 5) if iceHeight> rowAmount: # limitează plăcile pentru a merge prea mare iceHeight = randint (int (rowAmount / 2) -5, int (rowAmount / 2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') pentru i în intervalul (0, colAmount): tileFile.write (' ') pentru j în intervalul (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): tastatură globală, scrMang generateTilemap () # 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 (nsoliTiles, z = -1) scr. add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc) def showMainMenu (): menuSc = Scene (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) window = director.init (subtitrare = "IcyPlat - un platformer simplu", redimensionabil = Adevărat) showMainMenu ()
Pasul 18. Finalizat
Acum testează jocul. Când programați ceva, trebuie să verificați dacă funcționează ori de câte ori ați implementat ceva nou. De asemenea, s-ar putea să vă place să jucați jocul pe care l-ați scris de ceva timp.
Partea 3 din 3: Publicarea unui joc
Pasul 1. Notați dependențele
Oricine folosește un alt computer nu va avea aceleași software și biblioteci instalate ca dvs. Deci, va trebui să vă asigurați că toți cei care vă instalează jocul știu exact de ce vor avea nevoie pentru a-l rula. Nu trebuie să notați toate dependențele tuturor dependențelor tuturor dependențelor și așa mai departe, dar ar trebui să scrieți cel puțin dependențele pachetelor dvs. și dependențele acestora.
Pasul 2. Asigurați-vă că aveți permisiunea de a utiliza toate mediile
Acest lucru se aplică tuturor graficelor, inclusiv modelelor 3D, muzicii, dialogului, muzicii, bibliotecilor și cadrelor pe care le-ați folosit pentru jocul dvs. Orice nu ai scris singur.
- Adesea există anumite condiții, cum ar fi să fie nevoie să acordați credit autorului sau să partajați modificări ale mass-media sub aceeași licență. Uneori veți putea folosi grafică fără a atribui creatorii atâta timp cât nu percepeți jocul. Dacă trebuie să-l acreditați pe autor, faceți-l într-un loc bine vizibil, cum ar fi o filă „Credite” din joc.
- Există, de asemenea, conținut media cu drepturi de autor revendicat și nu este specificată nicio licență, uneori cu un text precum „Toate drepturile rezervate”. În acest caz, trebuie să obțineți permisiunea explicită de la autor înainte de a o include în joc.
- Bibliotecile sunt de obicei eliberate sub licențe care le permit să fie utilizate ca bibliotecă. O excepție notabilă este GPL, fără excepție de legătură: o astfel de licență permite doar utilizarea acesteia într-un program cu anumite licențe. Și ar trebui să citiți întotdeauna cel puțin punctele de bază ale licenței pentru a vă asigura că orice lucru pe care îl faceți cu media sau biblioteca este permis.
Avertizare: Utilizarea mass-media sau a bibliotecilor într-un mod în care licența nu permite într-un joc pe care îl publicați vă poate duce la probleme legale grave. Deci, fie întrebați autorul, fie evitați cu totul materialul dacă nu sunteți sigur dacă este permisă utilizarea dvs.
Pasul 3. Decideți condițiile în care doriți să vă publicați jocul
Vei vinde jocul tău? Doriți să permiteți altora să vă folosească imaginile și ideile? Deși trebuie să fii atent cu privire la mass-media pe care o folosești în proiectul tău, de obicei poți decide cum vrei să permiți altor persoane să-ți folosească jocul. Puteți utiliza o licență Creative Commons CC0 pentru a vă lansa jocul în domeniul public.. Pentru a permite distribuirea și modificarea în anumite condiții, păstrând în același timp anumite drepturi, încercați licența Gnu General Public License (GPL) sau licența Berkeley Software Distribution (BSD). Sau, puteți face software-ul proprietar, ceea ce înseamnă că nimănui nu i se permite să îl distribuie sau să îl modifice fără permisiunea dvs.
Deși este posibil să câștigi bani prin vânzarea de jocuri, este puțin probabil ca oamenii să îți cumpere primul joc care are de obicei puține caracteristici și nimic special. De asemenea, dacă un program gratuit nu funcționează, oamenii care l-au descărcat vor fi doar dezamăgiți. Dacă au plătit pentru asta, totuși, își vor cere banii înapoi, provocând mai multe probleme atât dvs., cât și utilizatorilor. Așadar, luați în considerare punerea la dispoziție gratuită a primelor dvs. programe
Pasul 4. Decideți cum doriți să vă publicați jocul
Fiecare metodă are unele avantaje și dezavantaje, așa că trebuie să vă decideți.
-
Publicarea pe un site web:
Dacă aveți un site web, puteți încărca jocul pentru a-l face disponibil pentru descărcare. Asigurați-vă că furnizați instrucțiuni clare despre cum să instalați software-ul, precum și toate dependențele necesare. Dezavantajul este că jucătorii vor trebui să instaleze dependențe manual, ceea ce ar putea fi dificil pentru unii oameni.
-
Realizarea unui pachet pentru un manager de pachete:
Există diferiți manageri de pachete, cum ar fi apt, Yum și Homebrew, care facilitează instalarea aplicațiilor în Linux și în medii bazate pe Linux. Toate au diferite formate de pachete. Lucrul bun despre pachete este că instalează automat toate dependențele (dacă le configurați corect). Deci, jucătorul trebuie doar să instaleze pachetul dvs. și apoi poate juca jocul. Problema este că există mulți manageri de pachete diferiți pe diferite platforme, deci va trebui să puneți ceva de lucru în furnizarea de pachete pentru toate cele mai comune.
Pasul 5. Direcționați atenția asupra programului dvs
Luați în considerare încărcarea programului dvs. într-un depozit principal de pachete, cum ar fi cele pe care le mențin Ubuntu și Debian, pentru a permite instalări ușoare. De asemenea, postați pe forumuri adecvate, cum ar fi secțiunea de proiecte din GameDev sau o parte din tigSource. Dar nu fi dezamăgit dacă primele tale jocuri nu devin celebre. Dacă ai o idee că mulți oameni îi plac, jocul tău poate deveni cunoscut.
sfaturi
- Fii răbdător și dispus să înveți. Programarea poate fi uneori frustrantă!
- Dacă vă întrebați cum se face ceva într-un alt joc și jocul este open-source, puteți privi codul său sursă.
- Când căutați conținut media, încercați să găsiți conținut care este în domeniul public. Căutați imagini și muzică „Creative Commons” sau „Domeniu public” și utilizați site-uri web precum https://opengameart.org sau
- Nu copiați bucăți majore de cod fără a verifica licența. Este adesea interzis și, dacă nu, necesită de obicei atribuire.
- Nu faceți spam sau postați în locuri neadecvate atunci când vă promovați jocul. Acest lucru vă va bloca probabil din pagină, este pur și simplu enervant și vă va afecta reputația.
