Si të programoni lojëra kompjuterike (me fotografi)

2024 Autor: Robert Blare | [email protected]. E modifikuara e fundit: 2024-01-31 12:20

A keni një ide për një lojë kompjuterike dhe doni ta bëni atë të vërtetë? Apo keni menduar ndonjëherë se si shkruhen lojërat kompjuterike? Ky wikiHow ju mëson se si të shkruani tre lojëra kompjuterike bazë në Python. Ju do të keni nevojë për një kuptim bazë të Python dhe koncepteve të përgjithshme të programimit për të zhvilluar lojën tuaj të parë.

Hapa

Pjesa 1 nga 3: Krijimi i një loje të bazuar në tekst

Hapi 1. Zgjidhni një gjuhë programimi

Të gjitha gjuhët e programimit janë të ndryshme, kështu që ju do të duhet të vendosni se cilën do të përdorni për të shkruar lojën tuaj. Çdo gjuhë kryesore programimi mbështet futjen e tekstit, daljen e tekstit dhe konstruksionet nëse (gjërat kryesore që ju nevojiten për një lojë të thjeshtë të bazuar në tekst), kështu që eksploroni opsionet dhe vendosni se me kë ndiheni më komod dhe të përkushtuar ndaj mësimit. Këtu janë disa faktorë që duhen marrë parasysh:

Për çfarë përdoret më së shumti gjuha?

Disa gjuhë programimi, si JavaScript, janë krijuar për t'u përdorur në internet, ndërsa të tjerat, si Python, C, ose C ++, janë krijuar për të drejtuar programe kompjuterike. Për lojën tuaj, synoni një gjuhë me një gamë më të gjerë përdorimi, të tilla si Python, C, C ++, ose JavaScript.
Sa e vështirë është të mësosh?

Edhe pse shkrimi i një programi duhet të jetë mjaft i lehtë pas disa praktikave në çdo gjuhë programimi normale (d.m.th., jo një e krijuar posaçërisht për të qenë konfuze si Malbolge), disa janë më miqësorë për fillestarët se të tjerët. Java dhe C, për shembull, do t'ju kërkojnë të kuptoni koncepte më të thella programimi sesa diçka si Python, i cili është i njohur për sintaksën e tij më të arritshme dhe të drejtpërdrejtë.
Ku mund ta përdor?

Ju ndoshta dëshironi që njerëzit në sisteme të ndryshme, të tilla si Linux, Mac ose Windows, të gjithë të jenë në gjendje të luajnë lojën tuaj. Pra, nuk duhet të përdorni një gjuhë që mbështetet vetëm në disa sisteme, si Visual Basic, e cila mbështetet vetëm në Windows.

Ky artikull do të përdorë Python për shembujt e një loje të bazuar në tekst, por mund të shikoni se si bëhen konceptet në çdo gjuhë tjetër programimi.

Hapi 2. Bëjeni gati kompjuterin tuaj

Dy përbërësit kryesorë që do t'ju nevojiten janë një redaktues teksti, në të cilin do të shkruani kodin tuaj dhe një përpilues, të cilin do ta përdorni për ta kthyer atë në një lojë. Nëse doni të ndiqni shembullin në këtë artikull, duhet të instaloni Python dhe të mësoni se si të ekzekutoni programe. Nëse dëshironi, mund të krijoni një IDE (Integraded Desktop Environment), e cila kombinon redaktimin, përpilimin dhe korrigjimin në një program të vetëm. IDE e Python quhet IDLE. Por gjithashtu mund të përdorni çdo redaktues teksti që mbështet tekst të thjeshtë, të tilla si Notepad për Windows, TextEdit për macOS ose Vim për Linux.

Hapi 3. Shkruani një kod për të përshëndetur lojtarin

Lojtari do të dojë të dijë se çfarë po ndodh dhe çfarë duhet të bëjnë, kështu që ju duhet të printoni ndonjë tekst për ta.

Kjo bëhet me funksionin print () në Python. Për ta provuar, hapni një skedar të ri me shtesën.py, futni kodin e mëposhtëm në të, ruani dhe ekzekutoni atë:
```
print ("Mirë se vini në lojën e supozimit të numrave!") print ("Fut një numër të plotë midis 1 dhe 1000:")
```

Hapi 4. Gjeneroni një numër të rastit

Le të bëjmë një lojë të bazuar në tekst që i kërkon lojtarit të gjejë numrin e saktë. Gjëja e parë që duhet të bëjmë është të gjenerojmë një numër të rastësishëm në fillim të lojës, kështu që lojtari nuk do ta marrë me mend gjithmonë të njëjtin numër. Meqenëse numri do të mbetet i njëjtë gjatë gjithë programit, do të dëshironi të ruani numrin e rastit në një ndryshore.

Python nuk ka një funksion të integruar të numrave të rastit, por ka një bibliotekë standarde (kjo do të thotë që përdoruesi nuk do të duhet të instalojë asgjë shtesë) që ka. Pra, shkoni në fillim të kodit tuaj (para funksioneve të printimit ()) dhe shtypni importimin e linjës rastësisht.
Përdorni funksionin e rastësishëm. Quhet randint (), është në bibliotekën e rastësishme që sapo keni importuar dhe merr vlerën minimale dhe maksimale që numri mund të ketë si argument. Pra, kthehuni në fund të kodit tuaj dhe futni rreshtin e mëposhtëm:
```
rightNum = rast.randint (0, 1000)
```

Hapi 5. Merrni informacion nga luajtësi

Në një lojë, lojtari dëshiron të bëjë diçka ose të ndërveprojë me diçka. Në një lojë të bazuar në tekst, kjo është e mundur duke futur tekst. Tani që kemi një numër të rastësishëm, linjat tona të ardhshme të kodit duhet t'i kërkojnë lojtarit të japë supozimin e tij më të mirë.

Meqenëse kodi që keni futur shtyp udhëzimin për të futur një numër në luajtës, ai gjithashtu duhet të lexojë numrin që ata futin. Kjo bëhet me input () në Python 3, dhe raw_input () në Python 2. Duhet të shkruani në Python 3, pasi Python 2 do të vjetrohet së shpejti. Shtoni rreshtin e mëposhtëm në kodin tuaj për të ruajtur hyrjen e luajtësit në një ndryshore të quajtur numër:
```
userNum = input ()
```

Hapi 6. Ktheni hyrjen e luajtësit në një lloj të dhënash të përdorshme

Lojtari ka futur një numër-tani çfarë?

Bëni hyrjen e lojtarit një numër. Tani, kjo mund të tingëllojë konfuze sepse ata sapo kanë futur një numër. Por ka një arsye të mirë: Python supozon se të gjitha hyrjet janë tekst, ose një "varg", siç quhet në programim. Ky tekst përmban numrin që dëshironi të merrni. Python ka një funksion që konverton një varg që përmban vetëm një numër në numrin brenda. Lloji:
```
userNum = int (userNum)
```

Hapi 7. Krahasoni numrin e lojtarit me numrin e saktë

Pasi lojtari fut numrin e tyre, do t'ju duhet ta krahasoni atë me atë që është krijuar rastësisht. Nëse numrat nuk janë të njëjtë, loja juaj mund ta bëjë lojtarin të provojë një numër tjetër. Nëse numrat përputhen, ju mund t'i thoni lojtarit që e ka marrë me mend dhe të lërë programin. Kjo bëhet me kodin e mëposhtëm:

ndërsa userNum! = rightNum: userNum = int (input ())

Hapi 8. Jepni reagime lojtarit

Ndërsa ju tashmë keni përpunuar të dhënat e tyre, lojtari nuk do ta shohë këtë. Ju do të duhet të printoni rezultatet në lojtar në mënyrë që ata të kuptojnë se çfarë po ndodh.

Me siguri, ju thjesht mund t'i thoni lojtarit nëse numri i tyre është i drejtë apo i gabuar. Por me atë qasje, lojtari mund të duhet të hamendësojë 1000 herë në rastin më të keq, gjë që do të ishte shumë e mërzitshme.
Pra, tregoni lojtarit nëse numri i tyre është shumë i vogël ose shumë i madh. Kjo do të zvogëlojë ndjeshëm numrin e supozimeve të tyre. Nëse, për shembull, lojtari merr me mend 500 së pari dhe loja përgjigjet "Shumë e madhe. Provo përsëri", do të ketë vetëm 500 numra të mundshëm në vend të 1000. Kjo bëhet me konstruksionet if, kështu që zëvendësoni printimin ("E gabuar Provo përsëri. ") Me një.
Kini parasysh se kontrollimi nëse dy numra janë të njëjtë bëhet me ==, jo me =. = cakton vlerën e djathtë të saj në ndryshoren e majtë të saj!

nëse userNum <rightNum: print ("Shumë e vogël. Provo përsëri:") nëse userNum> rightNum: print ("Shumë e madhe. Provo përsëri:")

Hapi 9. Testoni kodin tuaj

Si programues, duhet të jeni të sigurt që kodi juaj punon para se ta konsideroni të përfunduar.

Kur programoni në python, sigurohuni që indentacionet të jenë të sakta. Kodi juaj duhet të duket kështu:

import print i rastësishëm ("Mirë se vini në lojën e hamendësimit të numrave!") print ("Futni një numër të plotë midis 1 dhe 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) ndërsa userNum! = rightNum: nëse userNum <rightNum: print ("Shumë e vogël. Provo përsëri:") nëse userNum> rightNum: print ("Shumë e madhe. Provo përsëri:") userNum = int (input ()) print ("E keni menduar saktë. ")

Hapi 10. Validoni hyrjen

Lojtari nuk duhet të jetë në gjendje të prishë lojën tuaj thjesht duke futur gjënë e gabuar. "Vlerësimi i hyrjes" do të thotë të sigurohesh që lojtari ka futur sendin e duhur para se ta përpunojë atë.

Hapeni lojën përsëri dhe provoni të futni gjithçka që nuk është numër. Loja do të dalë me një ValueError. Për të shmangur këtë, mund të zbatoni një mënyrë për të kontrolluar nëse hyrja ishte një numër.
Përcaktoni një funksion. Meqenëse vërtetimi i hyrjes është mjaft i gjatë, dhe ju duhet ta bëni atë disa herë, duhet të përcaktoni një funksion. Nuk do të marrë asnjë argument dhe do të kthejë një numër. Së pari, shkruani def numInput (): në krye të kodit tuaj, drejtpërdrejt nën rastësinë e importit.
Merrni kontributin e lojtarit një herë. Përdorni funksionin input () dhe caktojeni rezultatin ndryshores inp.
Kur hyrja e lojtarit nuk është një numër, kërkoni që ata të fusin një numër. Për të kontrolluar nëse një varg është një numër, përdorni funksionet isdigit (), të cilat lejojnë vetëm një numër të plotë, kështu që nuk do të keni nevojë ta kontrolloni atë veç e veç.
Nëse hyrja është një numër, shndërrojeni atë nga vargu në numër dhe ktheni rezultatin. Përdorni funksionin int () për shndërrimin e vargut në një numër të plotë. Kjo do ta bëjë konvertimin në kodin kryesor të panevojshëm, dhe ju duhet ta hiqni nga atje.
Zëvendësoni të gjitha thirrjet për hyrjen () në kodin kryesor me thirrjet në numInput ().
Kodi i funksionit numInput () do të duket kështu:

def numInput (): inp = input () ndërsa nuk është inp.isdigit (): print ("Të është thënë të futësh një numër të plotë! Fut një numër të plotë:") inp = input () ktheje int (inp)

Hapi 11. Provoni përsëri lojën

Futni gjërat e gabuara me qëllim për të parë se çfarë ndodh dhe pastaj rregulloni çdo gabim kur ato dalin.

Provoni të futni ndonjë tekst kur programi ju kërkon një numër. Tani, në vend që të dilni me një mesazh gabimi, programi do t'ju kërkojë përsëri një numër

Hapi 12. Sugjero rinisjen e lojës kur të përfundojë

Në këtë mënyrë, lojtari mund të luajë lojën tuaj për një kohë më të gjatë pa pasur nevojë ta rifillojë vazhdimisht atë.

Vendosni të gjithë kodin përveç importit dhe përcaktimit të funksionit në një lak while. Vendosni True si kusht: kjo do të jetë gjithmonë e vërtetë, kështu që lakja do të vazhdojë përgjithmonë.
Pyetni lojtarin nëse duan të luajnë përsëri pasi e kanë kuptuar saktë numrin. Përdorni funksionin print ().
Nëse ata përgjigjen "Jo", dilni nga pamja. Nëse ata përgjigjen për ndonjë gjë tjetër, vazhdoni. Thyerja nga një lak bëhet me thënien break.
Zhvendosni "Mirësevini në lojën e supozimit të numrave" jashtë lakut while. Lojtari ndoshta nuk dëshiron të mirëpritet sa herë që luajnë lojën. Zhvendosni printimin e udhëzimeve ("Mirë se vini në lojën e supozimit të numrave!" Mbi ndërsa True:, kështu që do të printohet vetëm një herë, kur përdoruesi të fillojë lojën e parë.

Hapi 13. Provoni lojën

Ju do të duhet të testoni lojën tuaj sa herë që zbatoni një veçori të re.

Sigurohuni që të përgjigjeni të dyja "Po" dhe "Jo" të paktën një herë për t'u siguruar që të dyja opsionet funksionojnë. Ja se si duhet të duket kodi juaj:

importo def të rastësishëm numInput (): inp = input () ndërsa nuk është inp.isdigit (): print ("Të është thënë të futësh një numër të plotë! Fut një numër të plotë:") inp = input () kthe int (inp) print ("Mirë se vini në lojën e supozimit të numrave!") Ndërsa True: print ("Fut një numër të plotë midis 1 dhe 1000:") rightNum = random.randint (0, 1000) userNum = numInput () ndërsa userNum! = RightNum: nëse userNum <rightNum: print ("Shumë e vogël. Provo përsëri:") nëse userNum> rightNum: print ("Shumë e madhe. Provo sërish:") userNum = numInput () print ("E ke menduar saktë.") print ("A po doni të luani përsëri? Shkruani Jo për të lënë. ") nëse futni () ==" Jo ": pushim

Hapi 14. Shkruani lojëra të tjera të bazuara në tekst

Po në lidhje me shkrimin e një aventure teksti tjetër? Apo një lojë kuizi? Behu krijues.

Këshillë: Ndonjëherë është e dobishme të shikoni në dokumentacion nëse nuk jeni të sigurt se si bëhet diçka ose si përdoret një funksion. Dokumentacioni Python 3 gjendet në https://docs.python.org/3/. Ndonjëherë kërkimi i gjithçkaje që dëshironi të bëni në internet gjithashtu jep rezultate të mira.

Pjesa 2 nga 3: Krijimi i një loje me grafikë 2D

Hapi 1. Zgjidhni një bibliotekë grafike

Bërja e grafikave është shumë e ndërlikuar dhe shumica e gjuhëve programuese (përfshirë Python, C ++, C, JavaScript) ofrojnë vetëm mbështetje minimale ose madje aspak për grafikë në bërthamat ose bibliotekat standarde. Pra, do të duhet të përdorni një bibliotekë të jashtme për të qenë në gjendje të bëni grafikë, për shembull Pygame për Python.

Edhe me një bibliotekë grafike, do të duhet të shqetësoheni për gjëra të tilla si si të shfaqni një menu, si të kontrolloni se çfarë klikoi luajtësi, si të shfaqni pllakat, etj. Nëse preferoni të përqendroheni në zhvillimin e lojës aktuale, mund të përdorni një bibliotekë të motorit të lojërave si Unity, e cila i zbaton këto gjëra me lehtësi

Ky artikull do të përdorë Python me Cocos2D për të treguar se si të bëni një platformer të thjeshtë 2D. Disa nga konceptet e përmendura mund të mos ekzistojnë në motorët e tjerë të lojërave. Referojuni dokumentacionit të tyre për më shumë informacion.

Hapi 2. Instaloni bibliotekën grafike që keni zgjedhur

Cocos2D për Python është i lehtë për tu instaluar. Mund ta merrni nga https://python.cocos2d.org/index.html, ose duke ekzekutuar sudo pip3 install cocos2d nëse jeni duke përdorur Linux.

Hapi 3. Krijoni një drejtori të re për lojën dhe median tuaj

Ju do të përdorni gjëra si imazhe dhe tinguj në lojën tuaj. Mbani këto gjëra në të njëjtin drejtori me programin. Ky drejtori nuk duhet të përmbajë asgjë tjetër në mënyrë që të shihni lehtësisht se çfarë pasurie keni në lojë.

Hapi 4. Krijo një skedar të ri të kodit në drejtorinë e re

Thirrni atë kryesore, me shtesën e skedarit për gjuhën tuaj të programimit. Nëse shkruani një program të madh dhe kompleks ku ka kuptim të keni skedarë të shumtë programi, kjo do t'ju tregojë se cili është skedari kryesor.

Në këtë shembull, ne do të krijojmë një skedar të quajtur main.py që do të përmbajë të gjithë kodin tonë

Hapi 5. Krijoni dritaren e lojës

Ky është parakushti themelor për një lojë me grafikë.

Importoni nën-modulet e nevojshme të cocos2d: cocos.director, cocos.scene dhe cocos.layer. Kjo bëhet me nga subModuleName import *, ku emri i nën-modulit është nënmoduli që dëshironi të importoni. Dallimi midis … importit * dhe importit … është se nuk keni pse ta vendosni emrin e modulit para gjithçkaje që përdorni nga ai modul me të parën.
Përcaktoni një nënklasë MainMenuBgr të ColorLayer. Kjo në thelb do të thotë që çdo sfond i menysë kryesore që krijoni do të sillet si një shtresë ngjyrash me disa ndryshime që bëni.
Filloni drejtorin cocos. Kjo do t'ju japë një dritare të re. Nëse nuk vendosni një titull, dritarja do të ketë të njëjtin mbishkrim si emri i skedarit (main.py), i cili nuk do të duket profesional. Lejoni që madhësia e dritares të ndryshojë me të, duke e vendosur të ndryshojë në të Vërtetë.
Përcaktoni një funksion showMainMenu. Ju duhet të vendosni kodin për shfaqjen e menysë kryesore në një funksion sepse kjo do t'ju lejojë të ktheheni lehtësisht në menunë kryesore duke e thirrur përsëri funksionin.
Krijoni një skenë. Skena përbëhet nga një shtresë tani për tani, e cila është një objekt i klasës MainMenuBgr që keni përcaktuar.
Drejtojeni këtë skenë në dritare.

nga cocos.director import * nga cocos.scene import * nga cocos.layer import * klasa MainMenuBgr (ColorLayer): def _init _ (vet): super (MainMenu, vetë)._ init _ (0, 200, 255, 255) def showMainMenu (): menuSc = Skena (MainMenuBgr ()) Director.run (menuSc) Director.init (caption = "IcyPlat - një platformer i thjeshtë", resizable = True) showMainMenu ()

Hapi 6. Shtoni një menu kryesore në dritare

Përveç lojës aktuale, do t'ju duhet të shtoni një menu që lojtari mund të përdorë për të mbyllur dritaren, ndër elementët e tjerë që mund të shtoni më vonë.

Importoni cocos.menu (përsëri me udhëzimet nga) dhe pyglet.app (këtë herë me import).
Përcaktoni MainMenu si një nënklasë të Menusë.
Vendosni shtrirjen e menysë kryesore. Ju duhet të vendosni shtrirjen vertikale dhe horizontale veç e veç.
Krijoni një listë të artikujve të menysë dhe shtojini ato në menu. Ju duhet të keni artikujt e menysë "Filloni lojën" dhe "Quit" të paktën. Çdo artikull i menysë duhet të vendoset brenda kllapave. Çdo artikull duhet të ketë një etiketë dhe një funksion thirrjeje që përcakton se çfarë ndodh kur luajtësi e klikon atë. Për artikullin "Fillo lojën", përdorni funksionin startGame (do ta shkruani së shpejti), për artikullin "Quit", përdorni "pyglet.app.exit" (tashmë ekziston). Krijoni menunë aktuale duke thirrur self.create_menu (menuItems).
Përcaktoni startGame (). Thjesht vendosni kalimin në përkufizimin tani për tani, ju do ta zëvendësoni atë kur të shkruani lojën aktuale.
Shkoni në vendin në kodin tuaj ku keni krijuar skenën menuSc dhe shtoni një objekt MainMenu në të.

I gjithë kodi juaj tani duhet të duket si më poshtë:

nga cocos.director import * nga cocos.menu import * nga cocos.scene import * nga cocos.layer import * import pyglet.app class MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, vetja)._ init _ (0, 200, 255, 255) klasa MainMenu (Menyja): def _init _ (vetja): super (MainMenu, vetja)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Fillimi i lojës ", startGame)), (MenuItem (" Quit ", pyglet.app.exit))] self.create_menu (menuItems) def startGame (): kalo def showMainMenu (): menuSc = Skena (MainMenuBgr ()) menuSc.add (MainMenu ()) Director.run (menuSc) Director.init (caption = "IcyPlat - një platformer i thjeshtë", resizable = True) showMainMenu ()

Hapi 7. Testoni kodin tuaj

Testoni kodin herët, ndërsa është akoma i shkurtër dhe relativisht i thjeshtë. Atëherë mund të identifikoni dhe korrigjoni çdo gabim në strukturën bazë para se gjërat të komplikohen shumë.

Kodi nga udhëzimet duhet të hapë një dritare të titulluar "IcyPlat - një platformer i thjeshtë." Sfondi është blu i hapur dhe mund të ndryshoni madhësinë e dritares. Kur klikoni "Filloni lojën" në meny, asgjë nuk duhet të ndodhë (akoma). Kur klikoni "Quit", dritarja do të mbyllet

Hapi 8. Krijo një sprite

Një sprite është një "objekt loje" ose një imazh 2-dimensional. Spritet mund të jenë objekte në lojë, ikona, dekorime në sfond, personazhe dhe gjithçka tjetër që mund të përfaqësoni me një imazh në lojë. Ne do të fillojmë duke krijuar një sprite për një personazh me të cilin lojtari mund të ndërveprojë.

Importoni nën-modulin cocos.sprite me shprehjen nga-import.
Gjeni një imazh që përfaqëson sprite. Ju nuk mund të shfaqni një sprite nëse nuk keni një fotografi për të. Ju mund të vizatoni një, ose mund të merrni një nga interneti (megjithatë kujdes për licencat, nëse planifikoni të publikoni lojën tuaj). Për këtë shembull, shkoni te https://opengameart.org/content/tux-classic-hero-style dhe ruani imazhin-p.webp" />
Krijo një shtresë si një objekt i ri i klasës ScrollableLayer. Pastaj, krijoni sprite si një objekt Sprite dhe vendosni pozicionin e tij në (8, 250). Për referencë, pika (0, 0) është në këndin e poshtëm të majtë. Kjo është mjaft e lartë, por do të sigurohet që pinguini të mos ngec në akull.
Shtoni sprite në shtresën e sprite.
Krijoni një skenë të re nga shtresa e Sprite dhe drejtojeni atë.

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

Drejtoni kodin. Ju duhet të shihni një figurë të vogël pinguini (ose çfarëdo që vizatuat) në një sfond të zi pasi të klikoni Fillo lojen.

Hapi 9. Dreamndërroni peizazhin tuaj

Në shumicën e lojërave, shpifjet tuaja nuk duhet të notojnë vetëm në zbrazëti. Ata në fakt duhet të qëndrojnë në një sipërfaqe, me diçka rreth tyre. Në lojërat 2D, kjo shpesh bëhet me një grup pllakash dhe një hartë të pllakave. Kompleti i pllakave në thelb thotë se çfarë lloj katrorësh sipërfaqësor dhe sheshe sfondi ekzistojnë, dhe si duken ato.

Krijoni një grup pllakash. Pllaka e vendosur për këtë lojë do të jetë shumë themelore: një pllakë për akullin dhe një tjegull për qiellin. Pllaka e akullit e përdorur në këtë shembull është nga këtu, nën CC-BY-SA 3.0.
Krijoni një fotografi të vendosur në pllaka. Kjo është një fotografi e të gjitha pllakave, të cilat duhet të jenë të të njëjtës madhësi (modifikojini nëse nuk janë) dhe kanë madhësinë që dëshironi të shihni në lojë, pranë njëra -tjetrës. Ruajeni foton tuaj si icyTiles.png.
Krijoni përshkrimin e grupit të pllakave. Ky është një skedar XML. Skedari XML përmban informacione se sa të mëdha janë pllakat në figurën e vendosur të pllakave, cilën fotografi të përdorni dhe ku ta gjeni cilën pllakë atje. Krijoni një skedar XML të quajtur icyTiles.xml me kodin më poshtë:
```
     
```

Hapi 10. Bëni një hartë të pllakave për peizazhin tuaj

Harta e pllakave është një hartë që përcakton se cila pllakë është në cilën pozicion në nivelin tuaj. Në shembull, ju duhet të përcaktoni një funksion për të gjeneruar harta të pllakave sepse dizajnimi i hartave të pllakave me dorë është shumë i lodhshëm. Një lojë më e avancuar zakonisht do të ketë një lloj redaktuesi niveli, por për t'u njohur me zhvillimin e lojës 2D, një algoritëm mund të sigurojë nivele mjaft të mira.

Zbuloni sa rreshta dhe kolona nevojiten. Për këtë, ndani madhësinë e ekranit me madhësinë e pllakës si horizontalisht (kolonat) ashtu edhe vertikalisht (rreshtat). Rrumbullakoni numrin lart; ju keni nevojë për një funksion të modulit të matematikës për këtë, kështu që shtoni nga kufiri i importit të matematikës në importet në krye të kodit tuaj.
Hapni një skedar për të shkruar. Kjo do të fshijë të gjithë përmbajtjen e mëparshme të skedarit, kështu që zgjidhni një emër që asnjë skedar në drejtori nuk e ka ende, si levelMap.xml.
Shkruani etiketat e hapjes në skedar.
Krijoni një hartë të pllakave sipas algoritmit. Ju përdorni atë në kodin më poshtë, ose mund të dilni me një vetë. Sigurohuni që të importoni funksionin randint nga moduli i rastësishëm: kërkohet që kodi më poshtë të funksionojë, dhe çfarëdo që të dalë me siguri do të ketë nevojë gjithashtu për numra të plotë. Gjithashtu, sigurohuni që të vendosni pllaka qielli dhe pllaka akulli në shtresa të ndryshme: akulli është i fortë, qielli jo.
Shkruani etiketat mbyllëse në skedar dhe mbyllni skedarin.

def generateTilemap (): colAmount = ceil (800 /16) * 3 # (gjerësia e ekranit / madhësia e pllakës) * 3 rowAmount = tavani (600 /16) # lartësia e ekranit / madhësia e pllakës tjegullFile = hapur ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) për i në rang (0, colAmount): tileFile.write ('') makeHole = False nëse randint (0, 50) == 10 dhe i! = 0: # nuk lejojnë vrima në pikën e pjelljes makeHole = E vërtetë për j në rang (0, rowAmount): if makeHole: tileFile.write ('\ n') tjetër: nëse j <= iceHeight: tileFile.write ('\ n') tjetër: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) nëse iceHeight <0: # kufizoni pllakat nga akulli shumë i ulëtHeight = randint (1, 5) if iceHeight> rowAmount: # kufizo pllakat nga akulli shumë i lartëHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') për i në rang (0, colAmount): tileFile.write ('') për j në rang (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Hapi 11. Shfaqni hartën e pllakave

Importoni gjithçka nga cocos.tiles dhe pastaj futuni në funksionin startGame për këtë.

Në fillim të funksionit tuaj startGame, krijoni një hartë të pllakave duke përdorur funksionin që keni përcaktuar për këtë.
Krijoni një menaxher të ri rrotullimi. Bëni këtë direkt nën vijën ku shtoni sprite në shtresën e saj.
Krijoni një shtresë të re që përmban pllakat, e cila do të ngarkohet nga harta e pllakave levelMap.xml që gjeneroni funksionin tuaj të gjeneruarTilemap.
Shtoni shtresën jo të ngurtë, shtresën e ngurtë dhe shtresën sprite tek menaxheri i rrotullimit, pikërisht në këtë mënyrë. Nëse dëshironi, mund të shtoni një pozicion z.
Në vend që të krijoni skenën nga shtresa sprite, krijojeni atë nga menaxheri i lëvizjes.

Funksioni juaj startGame tani duhet të duket kështu:

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 = Skena (scrMang) Director.run (gameSc)

Hapi 12. Testoni kodin tuaj

Ju duhet ta testoni kodin tuaj shpesh për t'u siguruar që veçoritë e reja që keni zbatuar funksionojnë vërtet.

Kodi në shembull tani duhet të tregojë një peizazh të akullt pas pinguinit. Nëse pinguini duket sikur po fluturon mbi akull, ju nuk keni bërë asgjë të keqe dhe do të rregullohet në hapin tjetër

Hapi 13. Shtoni kontrollet

Lojtari ka shumë më tepër mënyra për të bashkëvepruar me programin në një lojë 2D sesa në një lojë të bazuar në tekst. Një e zakonshme përfshin lëvizjen e figurës së tyre kur shtypet çelësi i duhur.

Importoni gjithçka nga cocos.mapcolliders dhe nga cocos.actions. Gjithashtu importoni çelësin nga pyglet.window.
"Deklaroni" disa ndryshore globale. Variablat globale ndahen midis funksioneve. Ju nuk mund të deklaroni vërtet ndryshore në Python, por duhet të thoni që një ndryshore globale ekziston në kodin kryesor para se ta përdorni. Ju mund të caktoni 0 si vlerë sepse një funksion do të kujdeset për caktimin e vlerës së saktë më vonë. Pra, shtoni nën shprehjet e importit:
```
# "duke deklaruar" ndryshoret globale tastiera = 0 scrMang = 0
```

Rregulloni funksionin tuaj startGame:

Thuaj që përdorni tastierën globale dhe scrMang. Bëni këtë duke shkruar tastierën globale, scrMang në krye të funksionit.
Bëni dritaren të dëgjojë ngjarjet e tastierës.
Thuajini figurës të veprojë bazuar në një PlatformerController. Së shpejti do ta zbatoni atë PlatformerController.
Krijoni një përplasës hartash për të trajtuar përplasjet midis pllakave të ngurta dhe figurës.

def startGame (): tastiera globale, scrMang gjeneronTilemap () # 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 = 'rrëshqitje') 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 = Skena (scrMang) Director.run (gameSc)

Krijoni një kontrollues platformer. Kjo është ajo që do të lëvizë figurën sipas shtypjeve të tua.
- Përcaktoni kontrolluesin e platformerit si një nënklasë të Veprimit.
- Përcaktoni shpejtësinë e lëvizjes, shpejtësinë e kërcimit dhe gravitetin.
- Përcaktoni funksionin e fillimit. Ky funksion quhet një herë, kur kontrolluesi i platformerit është i lidhur me figurën. Duhet të vendosë shpejtësinë e tij në 0 si në drejtimin x ashtu edhe në y.
- Përcaktoni funksionin e hapit. Do të përsëritet derisa skena të jetë në punë.
- Thuaji funksionit të hapit të përdorë ndryshoret globale të tastierës dhe scrMang.
- Merrni dhe ndryshoni shpejtësinë. Ruani shpejtësinë x dhe y në ndryshore të veçanta. Vendosni shpejtësinë x në 1 ose -1 (në varësi të faktit nëse është shtypur butoni i majtë ose i djathtë) shumëzuar me shpejtësinë e lëvizjes. Shtoni gravitetin në shpejtësinë y. Shumëzojeni atë me kohën e ndërprerjes në mënyrë që të funksionojë në të njëjtën mënyrë në pajisjet më të ngadalta. Nëse tasti i hapësirës shtypet dhe figura qëndron në tokë, hidheni duke ndryshuar shpejtësinë y në shpejtësinë e kërcimit.
- Llogaritni se ku duhet të lëvizë figura. Pastaj lërini mbajtësin e përplasjes të rregullojë atë pozicion nëse është brenda një pllake të fortë. Më në fund, zhvendoseni figurën në pozicionin e ri të rregulluar.
- Vendosni fokusin e menaxherit të lëvizjes në figurë. Kjo bën që kamera të lëvizë në një mënyrë të arsyeshme kur figura lëviz.
```
klasa PlatformerController (Veprimi): tastiera globale, scrMang on_ground = E vërtetë MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def hap (vetja, dt): tastiera globale, rrotullues nëse dt> 0,1: # mos bëni asgjë gjatë kohës së joproduktive në kthimin e madh vx, vy = self.target.velocity vx = (tastiera [çelësi. E DREJTA] - tastiera [key. LEFT]) * vetë. MOVE_SPEED vy + = vet. GRAVITY * dt nëse self.on_ground dhe tastiera [kyç. 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 (i fundit, i ri, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (*new.center)
```

Hapi 14. Testoni kodin tuaj

Nëse ndiqni shembullin, tani duhet të jeni në gjendje të lëvizni pinguinin me çelësat e shigjetave dhe të kërceni duke shtypur hapësirën. Gjithashtu, pinguini tani duhet të bjerë poshtë në vend që të rri pezull mbi tokë.

Hapi 15. Krijoni një fund për lojën

Edhe lojërat që mund të vazhdojnë pafundësisht duhet të kenë mundësinë e humbjes. Meqenëse niveli që keni bërë në shembullin me një funksion ka një fund, gjithashtu do t'ju duhet të bëni të mundur fitimin duke arritur në atë qëllim. Përndryshe, lojtari do të hidhej vetëm në blloqet e akullit atje, gjë që do të bëhej e mërzitshme.

Brenda kontrolluesit të platformerit, pas vendosjes së fokusit, merrni pozicionin x dhe y të figurës. Nëse pozicioni y është më pak se 0, thirrni funksionin finishGame () (do ta shkruani më vonë) me "Game Over" si argument. Nëse pozicioni x është më i madh se madhësia e ekranit shumëzuar me 3 (ju e kishit vendosur atë si madhësi të nivelit më parë).
```
posX, posY = self.target.position nëse posY <0: finishGame ("Game Over") kthehet nëse posX> 800*3: # madhësia e nivelit të përfundimitLoja ("Niveli i Përfunduar") kthehet
```
Përcaktoni një përfundim të klasësMenu. Duhet të jetë si klasa e menysë kryesore që keni përcaktuar më parë, por në vend që të ketë një varg bosh si titull, duhet të përdorë një tekst të ndryshueshëm të cilin funksioni _init_ e merr si argument. Artikujt e menysë duhet të etiketohen "Provo përsëri" dhe "Quit" tani, por funksionet që ata i quajnë mbeten të njëjta.
```
klasa FinishMenu (Menu): def _init _ (vetja, teksti): super (FinishMenu, vetja)._ init _ (teksti) self.menu_valign = CENTER self.menu_halign = Menuja CENTERItems = [(MenuItem ("Provo përsëri", fillo Lojë)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems)
```
Përcaktoni funksionin finishGame (). Duhet të marrë tekstin si argument. Duhet të krijojë një skenë nga sfondi i menysë kryesore, një FinishMenu me argumentin e tekstit që kalon në këtë meny. Atëherë duhet ta drejtojë këtë skenë.
```
def finishGame (tekst): menuSc = Skena (MainMenuBgr ()) menuSc.add (FinishMenu (tekst)) Director.run (menuSc)
```

Hapi 16. Shtoni kredite

Këtu ju merrni merita për kodin tuaj të mrekullueshëm, si dhe i jepni merita kujtdo tjetër që ju ka ndihmuar gjatë rrugës. Nëse keni përdorur një imazh nga një faqe në internet (me leje), sigurohuni që t'i atribuoni atë imazh krijuesit të tij.

Krijoni një skedar KREDIT dhe futni të gjitha kreditet tuaja atje, si kjo:

Penguin: Kelvin Shadewing, nën bllokun CC0 Ice: Michał Banas shifra1024 në opengameart.org nën CC-BY-SA 3.0

Kthehuni te kodi juaj Python dhe importoni Etiketën nga cocos.text.

Përcaktoni një nënklasë Kreditë e Shtresës. Në funksionin e tij _init_, lexoni skedarin CREDITS dhe bëni një etiketë teksti në pozicionin e duhur nga çdo rresht në të.

Kredite e klasës (Shtresa): def _init _ (vetja): super (Kredite, vetja)._ init _ () credFile = hapur ("Kreditë", "r") creds = credFile.read () creds = creds.split ("\ n ") për i në rang (0, len (kredi)): credLabel = Etiketë (kreds , font_size = 32, anchor_x =" majtas ", anchor_y =" top ") credLabel.position = 25, 500- (i +1)*40 vetë.shto (credLabel)

Shkoni në klasën tuaj të menusë kryesore dhe shtoni një artikull menuje të etiketuar "Kredite" që thërret funksionin showCredits kur klikohet.
Përcaktoni një nënklasë BackToMainMenuButton të menysë. Bëjeni këtë një menu me një artikull, të etiketuar "Prapa", që thërret funksionin showMainMenu. Kjo "menu", e cila është më shumë si një buton, duhet të rreshtohet vertikalisht në fund dhe horizontalisht në krye.
```
klasa BackToMainMenuButton (Menu): def _init _ (vetja): super (BackToMainMenuButton, vetja)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = Menyja e majtëItems = [(MenuItem ("vetë"), showMainMen,] krijoni menunë (artikujt e menysë)
```
Përcaktoni funksionin showCredits. Duhet të bëjë një skenë nga një shtresë MainMenuBgr dhe një shtresë Credits dhe ta drejtojë atë skenë.
```
def showCredits (): credSc = Skena (MainMenuBgr ()) credSc.add (Kredite ()) credSc.add (BackToMainMenuButton ()) Director.run (credSc)
```

Hapi 17. Kontrolloni kodin tuaj

Kur mendoni se keni përfunduar kodin tuaj, duhet ta shikoni përsëri të gjithë. Kjo mund t'ju ndihmojë të vini re nëse diçka mund të optimizohet, ose nëse ka disa linja të panevojshme që keni harruar t'i fshini. Nëse ndiqni shembullin, i gjithë kodi juaj tani duhet të duket si më poshtë:

nga cocos.direktori import * nga cocos.menu import * nga cocos.scene import * nga cocos.layer import * nga cocos.sprite import * nga cocos.tiles import * nga cocos.mapcolliders import * nga cocos.actions import import * nga cocos.text import Label import pyglet.app from pyglet.window key import import from matematikë ceil import from import random randomint # "deklarim" variablat globale keyboard = 0 scrMang = 0 class MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, vet)._ init _ (0, 200, 255, 255) klasa MainMenu (Menu): def _init _ (vetja): super (Menuja kryesore, vetja)._init _ ("") vetja.menu_valign = CENTER self.menu_halign = Menuja QENDRAItems = [(MenuItem ("Fillo lojën", startGame)), (MenuItem ("Kredite", showCredits)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems) Kredite e klasës (Shtresa): def _init _ (vetja): super (Kredite, vetja)._ init _ () credFile = hapur ("KREDITAT", "r") creds = credFile.read () creds = creds.split ("\ n") për i në rang (0, len (kreds)): credLabel = Etiketë (creds , font_size = 32, anchor_x = "majtas", anchor_y = "lart") credLabel.position = 25, 500- (i+1)*40 self.add (credLabel) class BackToMainMenuButton (Menu): def _init _ (vetja): super (BackToMainMenuButton, vetë)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = Menu e majtëItems = [(MenuItem ("Kthehu", showMainMenu))] self.create_menu (menuItems) klasa FinishMenu (Menu) vetja, teksti): super (FinishMenu, vetja)._ init _ (tekst) self.menu_valign = CENTER self.menu_halign = Menuja CENTERItems = [(MenuItem ("Provo përsëri", startGame)), (MenuItem ("Quit", pyglet) app.exit))] self.create_menu (menuItems) klasa PlatformerController (Veprimi): tastiera globale, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def hap (vetja, dt): tastiera globale, rrotulluesi nëse dt> 0.1: # mos bëni asgjë ndërsa koha e joproduktive kthehet shumë e madhe vx, vy = self.target.velocity vx = (tastiera [key. RIGHT] - tastierë [key. LEFT]) * vetë. MOVE_SPEED vy += vetja. RRANDVSIA * dt nëse vetë.në _tokë dhe tastierë [kyç. SPACE]: vy = vetë. JUMP_SPEED dx = vx * dt dy = vy * dt fundit = vet.target.get_rect () new = last.copy () new.x += dx new.y + = dy self.target.velocity = self.target.collision_handler (e fundit, e re, 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") kthehet nëse posX> 800*3: # madhësia e nivelit të përfundimitLoja ("Level Completed") kthehet def finishGame (tekst): menuSc = Skena (MainMenuBgr ()) menuSc.add (FinishMenu (tekst)) Director.run (menuSc) def showCredits (): credSc = Skena (MainMenuBgr ()) credSc.add (Kredite ()) credSc.add (BackToMainMenuBenu)) Director.run (credSc) def generateTilemap (): colAmount = tavan (800 /16) * 3 # (gjerësia e ekranit / madhësia e pllakës) * 3 rreshtAmount = tavan (600 /16) # lartësia e ekranit / madhësia e pllakës tjegullFile = hapur ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) për i në rang (0, colAmount): tileFile.write ('') makeHole = E rreme nëse rand int (0, 50) == 10 dhe i! = 0: # mos lejoni vrima në pikën e pjelljes makeHole = E vërtetë për j në rang (0, rowAmount): if makeHole: tileFile.write ('\ n') tjetër: nëse j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) nëse iceHeight <0: # kufizo pllakat që të shkojnë gjithashtu i ulët akulliHeight = randint (1, 5) nëse iceHeight> rowAmount: # kufizo pllakat nga akulli shumë i lartëHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') për i në rang (0, colAmount): tileFile.write (' ') për j në rang (0, rowAmount): tileFile.write (' / n ') tileFile.shkruaj ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): tastiera globale, scrMang gjeneronTilemap () # fig = Sprite ('pingu.png') fig.pozicion = (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 (tastierë ard) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump = 'slide') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoli) shto (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Skena (scrMang) Director.run (gameSc) def showMainMenu (): menuSc = Skena (MainMenuBgr ()) menuSc.add (MainMenu ()) Director.run (menuSc) dritare = Director.init (caption = "IcyPlat - një platformer i thjeshtë", resizable = True) showMainMenu ()

Këto janë 168 rreshta totalisht, dhe 152 rreshta nëse llogarisni vetëm kodin. Kjo duket shumë, por për një lojë kaq komplekse, kjo në të vërtetë është një sasi e vogël.

Hapi 18. Përfundoi

Tani provoni lojën. Kur programoni diçka, duhet të kontrolloni nëse funksionon sa herë që keni zbatuar diçka të re. Gjithashtu, ju mund të dëshironi të luani lojën që keni shkruar për ca kohë.

Pjesa 3 nga 3: Publikimi i një loje

Hapi 1. Shkruani varësitë

Kushdo që përdor një kompjuter tjetër nuk do të ketë të njëjtin softuer dhe biblioteka të instaluar si ju. Pra, do të duhet të siguroheni që të gjithë ata që instalojnë lojën tuaj e dinë saktësisht se çfarë do t'ju duhet për ta drejtuar atë. Ju nuk keni nevojë të shkruani të gjitha varësitë e të gjitha varësive të të gjitha varësive dhe kështu me radhë, por duhet të paktën të shkruani varësitë e paketave tuaja dhe varësitë e tyre.

Hapi 2. Sigurohuni që keni leje për të përdorur të gjitha mediat

Kjo vlen për të gjitha grafikat, përfshirë modelet 3D, muzikën, dialogun, muzikën, bibliotekat dhe kornizat që keni përdorur për lojën tuaj. Çdo gjë që nuk e keni shkruar vetë.

Shpesh ka disa kushte, si për shembull nevoja për të kredituar autorin ose për të ndarë modifikimet e mediave nën të njëjtën licencë. Ndonjëherë do të jeni në gjendje të përdorni grafikë pa i atribuar krijuesit për sa kohë që nuk paguani për lojën. Nëse duhet të vlerësoni autorin, bëjeni atë në një vend të dukshëm, si një skedë "Kredite" në lojën tuaj.
Ekziston gjithashtu media me të drejtën e autorit të kërkuar dhe pa licencë të specifikuar, ndonjëherë me ndonjë tekst si "Të gjitha të drejtat e rezervuara". Nëse është kështu, duhet të merrni leje të qartë nga autori para se ta përfshini në lojën tuaj.
Bibliotekat zakonisht lëshohen sipas licencave që i lejojnë ato të përdoren si bibliotekë. Një përjashtim i dukshëm është GPL pa përjashtim lidhës: Një licencë e tillë lejon vetëm përdorimin e saj në një program me licenca të caktuara. Dhe gjithmonë duhet të lexoni të paktën pikat themelore të licencës për t'u siguruar që çdo gjë që bëni me median ose bibliotekën është e lejuar.

Paralajmërim: Përdorimi i mediave ose bibliotekave në një mënyrë që licenca nuk lejon në një lojë që ju publikoni mund t'ju sjellë probleme serioze ligjore. Pra, ose pyesni autorin ose shmangni krejtësisht pjesën e mediave nëse nuk jeni të sigurt nëse përdorimi juaj është i lejuar.

Hapi 3. Vendosni për kushtet në të cilat dëshironi të publikoni lojën tuaj

A do ta shisni lojën tuaj? A doni t'i lejoni të tjerët të përdorin imazhet dhe idetë tuaja? Ndërsa duhet të jeni të kujdesshëm në lidhje me median që përdorni në projektin tuaj, zakonisht mund të vendosni se si dëshironi t'i lejoni të tjerët të përdorin lojën tuaj. Ju mund të përdorni një licencë Creative Commons CC0 për të lëshuar lojën tuaj në domenin publik. Për të lejuar shpërndarjen dhe modifikimin nën disa kushte duke ruajtur disa të drejta, provoni Licencën e Përgjithshme Publike të Gnu (GPL) ose licencën e Berkeley Software Distribution (BSD). Ose, ju mund ta bëni programin tuaj pronësor, që do të thotë se askush nuk lejohet ta shpërndajë ose modifikojë atë pa lejen tuaj.

Edhe pse është e mundur të fitoni para duke shitur lojëra, nuk ka gjasa që njerëzit të blejnë lojën tuaj të parë që zakonisht ka pak veçori dhe asgjë të veçantë. Gjithashtu, nëse një program falas nuk funksionon, njerëzit që e shkarkuan atë thjesht do të zhgënjehen. Nëse ata paguajnë për të, megjithatë, ata do të kërkojnë paratë e tyre mbrapa, duke shkaktuar më shumë probleme si për ju ashtu edhe për përdoruesit. Kështu që merrni parasysh që programet tuaja të para të jenë në dispozicion falas

Hapi 4. Vendosni se si dëshironi të publikoni lojën tuaj

Çdo metodë ka disa avantazhe dhe disavantazhe, kështu që ju duhet të vendosni vetë.

Publikimi i tij në një faqe në internet:

Nëse keni një faqe në internet, mund ta ngarkoni lojën tuaj për ta bërë të disponueshme për shkarkim. Sigurohuni që të jepni udhëzime të qarta se si të instaloni softuerin, si dhe të gjitha varësitë e kërkuara. Disavantazhi i kësaj është se lojtarët do të duhet të instalojnë varësi me dorë, gjë që mund të jetë e vështirë për disa njerëz.
Bërja e një pakete për menaxherin e paketave:

Ekzistojnë menaxherë të ndryshëm të paketave, si apt, Yum dhe Homebrew, që e bëjnë të lehtë për njerëzit të instalojnë aplikacione në mjedise me bazë Linux dhe Linux. Ata të gjithë kanë formate të ndryshme paketash. E mira e paketave është se ato instalojnë automatikisht të gjitha varësitë (nëse i konfiguroni ato në mënyrë korrekte). Pra, lojtari duhet vetëm të instalojë paketën tuaj dhe më pas mund të luajë lojën. Problemi është se ka shumë menaxherë të ndryshëm të paketave në platforma të ndryshme, kështu që ju do të duhet të bëni pak punë në sigurimin e paketave për të gjitha ato më të zakonshme.

Hapi 5. Drejtojini vëmendjen programit tuaj

Merrni parasysh ngarkimin e programit tuaj në një depo të madhe të paketave, si ato që mbajnë Ubuntu dhe Debian, për të lejuar instalime të lehta. Gjithashtu, postoni në forume të përshtatshme, si pjesa e projekteve të GameDev ose një pjesë e tigSource. Por mos u zhgënjeni nëse lojërat tuaja të para nuk bëhen të famshme. Nëse keni një ide që u pëlqen shumë njerëzve, loja juaj mund të bëhet e njohur.

Këshilla

Jini të durueshëm dhe të gatshëm për të mësuar. Programimi ndonjëherë mund të jetë zhgënjyes!
Nëse pyesni veten se si bëhet diçka në një lojë tjetër, dhe loja është me burim të hapur, mund të shikoni kodin burimor të saj.
Kur kërkoni media, përpiquni të gjeni përmbajtje që është në domenin publik. Kërkoni imazhe dhe muzikë "Creative Commons" ose "Domain Publik" dhe përdorni faqe në internet si https://opengameart.org ose
Mos kopjoni pjesë të mëdha të kodit pa kontrolluar licencën. Shpesh është e ndaluar, dhe nëse jo, zakonisht kërkon atribuim.
Mos bëni spam ose postoni në vende të papërshtatshme kur promovoni lojën tuaj. Kjo ka të ngjarë të ju bllokojë nga faqja, është thjesht e bezdisshme dhe do të dëmtojë reputacionin tuaj.