Paano Mag-Program ng Mga Laro sa Computer (na may Mga Larawan)

2024 May -akda: Robert Blare | [email protected]. Huling binago: 2024-01-31 12:20

Mayroon ka bang ideya para sa isang laro sa computer at nais mong gawin itong totoo? O naisip mo ba kung paano nakasulat ang mga laro sa computer? Itinuturo sa iyo ng wikiHow na ito kung paano magsulat ng tatlong pangunahing mga laro sa computer sa Python. Kakailanganin mo ng isang pangunahing pag-unawa sa Python at pangkalahatang mga konsepto ng programa upang mabuo ang iyong unang laro.

Mga hakbang

Bahagi 1 ng 3: Paggawa ng Laro na Batay sa Teksto

Hakbang 1. Pumili ng isang wika ng programa

Ang lahat ng mga wika sa programa ay magkakaiba, kaya kakailanganin mong magpasya kung alin ang gagamitin upang isulat ang iyong laro. Sinusuportahan ng bawat pangunahing wika ng programa ang pag-input ng teksto, output ng teksto at mga if-konstruksyon (ang mga pangunahing bagay na kailangan mo para sa isang simpleng larong batay sa teksto), kaya galugarin ang mga pagpipilian at magpasya kung saan sa palagay mo ay mas komportable ka at nakatuon sa pag-aaral. Narito ang ilang mga kadahilanan upang isaalang-alang:

Para saan ginagamit ang wika?

Ang ilang mga wika ng programa, tulad ng JavaScript, ay idinisenyo upang magamit para sa web, habang ang iba, tulad ng Python, C, o C ++, ay idinisenyo upang magpatakbo ng mga programa sa computer. Para sa iyong laro, hangarin ang isang wika na may mas malawak na hanay ng paggamit, tulad ng Python, C, C ++, o JavaScript.
Gaano kahirap matuto?

Bagaman ang pagsulat ng isang programa ay dapat na sapat na madali pagkatapos ng ilang pagsasanay sa anumang normal na wika ng programa (ibig sabihin, hindi isa na partikular na idinisenyo upang maging nakalilito tulad ng Malbolge), ang ilan ay mas kaibig-ibig sa mga nagsisimula kaysa sa iba. Ang Java at C, halimbawa, ay hihilingin sa iyo na maunawaan ang mas malalim na mga konsepto ng programa kaysa sa isang bagay tulad ng Python, na kilala sa mas madaling ma-access at straight-forward na syntax.
Saan ko ito magagamit?

Marahil ay nais mo ang mga tao sa iba't ibang mga system, tulad ng Linux, Mac o Windows, na lahat ay makapaglaro ng iyong laro. Kaya't hindi ka dapat gumamit ng isang wika na sinusuportahan lamang sa ilang mga system, tulad ng Visual Basic, na sinusuportahan lamang sa Windows.

Ang artikulong ito ay gagamit ng Python para sa mga halimbawa ng isang larong batay sa teksto, ngunit maaari mong tingnan kung paano ginagawa ang mga konsepto sa anumang iba pang wika sa pagprograma.

Hakbang 2. Ihanda ang iyong computer

Ang dalawang pangunahing sangkap na kakailanganin mo ay isang text editor, kung saan isusulat mo ang iyong code, at isang tagatala, na gagamitin mo upang gawing isang laro. Kung nais mong sundin ang halimbawa sa artikulong ito, dapat mong i-install ang Python at alamin kung paano magpatakbo ng mga programa. Kung nais mo, maaari kang mag-set up ng isang IDE (Integraded Desktop Environment), na pinagsasama ang pag-edit, pag-compile, at pag-debug sa isang solong programa. Ang IDE ng Python ay tinatawag na IDLE. Ngunit maaari mo ring gamitin ang anumang text editor na sumusuporta sa simpleng teksto, tulad ng Notepad para sa Windows, TextEdit para sa macOS, o Vim para sa Linux.

Hakbang 3. Sumulat ng ilang code upang batiin ang manlalaro

Gustong malaman ng manlalaro kung ano ang nangyayari at kung ano ang dapat nilang gawin, kaya dapat mong i-print ang ilang teksto para sa kanila.

Ginagawa ito sa pag-print () na pagpapaandar sa Python. Upang subukan ito, buksan ang isang bagong file na may.py extension, ipasok ang sumusunod na code dito, i-save at patakbuhin ito:
```
i-print ("Maligayang pagdating sa laro ng paghula ng numero!") i-print ("Magpasok ng isang buong numero sa pagitan ng 1 at 1000:")
```

Hakbang 4. Bumuo ng isang random na numero

Gumawa tayo ng larong batay sa teksto na hinihiling sa manlalaro na hulaan ang tamang numero. Ang unang bagay na kailangan naming gawin ay makabuo ng isang random na numero sa simula ng laro upang ang manlalaro ay hindi palaging hulaan ang parehong numero. Dahil ang numero ay mananatiling pareho sa buong programa, gugustuhin mong iimbak ang random na numero sa isang variable.

Ang Python ay walang built-in na random na pagpapaandar ng numero, ngunit mayroon itong isang karaniwang silid-aklatan (nangangahulugan ito na ang gumagamit ay hindi na kailangang mag-install ng anumang labis) na ginagawa. Kaya pumunta sa simula ng iyong code (bago ang pag-print () na mga pag-andar) at i-type ang linya na i-import nang random.
Gamitin ang random function. Tinawag itong randint (), ay nasa random library na ngayon mo lang na-import, at kinukuha ang pinakamaliit at pinakamataas na halaga na maaaring magkaroon ng bilang pagtatalo. Kaya bumalik sa dulo ng iyong code at ipasok ang sumusunod na linya:
```
rightNum = random.randint (0, 1000)
```

Hakbang 5. Kumuha ng input mula sa player

Sa isang laro, nais ng manlalaro na gumawa ng isang bagay o makipag-ugnay sa isang bagay. Sa isang larong batay sa teksto, posible ito sa pamamagitan ng pagpasok ng teksto. Ngayon na mayroon kaming isang random na numero, ang aming mga susunod na linya ng code ay dapat hilingin sa manlalaro na ipasok ang kanilang pinakamahusay na hulaan.

Dahil ang code na ipinasok mo ay naglilimbag ng tagubilin upang magpasok ng isang numero sa manlalaro, dapat ding basahin nito ang bilang na ipinasok nila. Ginagawa ito sa pag-input () sa Python 3, at raw_input () sa Python 2. Dapat kang magsulat sa Python 3, dahil ang Python 2 ay magiging lipas na sa lalong madaling panahon. Idagdag ang sumusunod na linya sa iyong code upang maiimbak ang input ng manlalaro sa isang variable na tinawag na numero:
```
userNum = input ()
```

Hakbang 6. Gawing isang magagamit na uri ng data ang input ng manlalaro

Ang manlalaro ay nagpasok ng isang numero-ngayon ano?

Gawin ang bilang ng player ng bilang. Ngayon, maaaring malito ito sapagkat kakapasok lang nila ng isang numero. Ngunit mayroong isang magandang dahilan: Ipinapalagay ng Python na ang lahat ng pag-input ay teksto, o isang "string," tulad ng tawag sa pagprograma. Naglalaman ang text na ito ng numero na nais mong makuha. Ang Python ay may isang function na nagko-convert ng isang string na naglalaman lamang ng isang numero sa bilang sa loob. Uri:
```
userNum = int (userNum)
```

Hakbang 7. Ihambing ang numero ng manlalaro sa tamang numero

Kapag na-input na ng player ang kanilang numero, kakailanganin mong ihambing ito sa isa na sapalarang nabuo. Kung ang mga numero ay hindi pareho, ang iyong laro ay maaaring gumawa ng player na sumubok ng isa pang numero. Kung tumutugma ang mga numero, maaari mong sabihin sa manlalaro na nahulaan nila nang tama, at umalis sa programa. Ginagawa ito sa sumusunod na code:

habang ang userNum! = rightNum: userNum = int (input ())

Hakbang 8. Bigyan ang feedback ng manlalaro

Habang naproseso mo na ang kanilang input, hindi ito makikita ng manlalaro. Kakailanganin mong i-print talaga ang mga resulta sa player upang maunawaan nila kung ano ang nangyayari.

Tiyak, masasabi mo lang sa manlalaro kung tama o mali ang kanilang numero. Ngunit sa pamamaraang iyon, maaaring hulaan ng manlalaro ng 1000 beses sa pinakamasamang kaso, na magiging mainip.
Kaya sabihin sa manlalaro kung ang kanilang numero ay masyadong maliit o masyadong malaki. Bawasan nito nang malaki ang kanilang mga hula. Kung, halimbawa, hinuhulaan muna ng manlalaro ang 500, at ang laro ay tumugon sa "Masyadong malaki. Subukang muli," magkakaroon lamang ng 500 mga posibleng numero sa halip na 1000. Ginagawa ito sa mga if-konstruksyon, kaya palitan ang print ("Mali. Subukan ulit. ") With one.
Magkaroon ng kamalayan na ang pagsuri kung ang dalawang numero ay pareho ay tapos na sa ==, hindi sa =. = itinalaga ang halaga ng karapatan nito sa variable na kaliwa nito!

kung userNum <rightNum: print ("Masyadong maliit. Subukang muli:") kung userNum> rightNum: print ("Masyadong malaki. Subukang muli:")

Hakbang 9. Subukan ang iyong code

Bilang isang programmer, dapat mong siguraduhin na gumagana ang iyong code bago isaalang-alang na natapos ito.

Kapag nagprograma sa sawa, siguraduhin na nakukuha mo ang wasto ng mga indentasyon. Dapat ganito ang hitsura ng iyong code:

i-import ang random na pag-print ("Maligayang pagdating sa laro ng paghula ng numero!") print ("Magpasok ng isang buong numero sa pagitan ng 1 at 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) habang userNum! = rightNum: kung userNum <rightNum: print ("Masyadong maliit. Subukang muli:") kung userNum> rightNum: print ("Masyadong malaki. Subukang muli:") userNum = int (input ()) i-print ("Nahulaan mo tama. ")

Hakbang 10. Patunayan ang input

Hindi dapat masira ng manlalaro ang iyong laro sa pamamagitan ng simpleng pagpasok sa maling bagay. Ang "pagpapatunay ng pag-input" ay nangangahulugang siguraduhin na ipinasok ng manlalaro ang wastong bagay bago ito iproseso.

Buksan muli ang laro at subukang ipasok ang anumang hindi numero. Ang laro ay lalabas sa isang ValueError. Upang maiwasan ito, maaari kang magpatupad ng isang paraan upang suriin kung ang input ay isang numero.
Tukuyin ang isang pagpapaandar. Dahil ang pagpapatunay ng input ay medyo mahaba, at kailangan mong gawin ito ng maraming beses, dapat mong tukuyin ang isang pagpapaandar. Hindi ito kukuha ng mga argumento at ibabalik ang isang numero. Una, isulat ang def numInput (): sa tuktok ng iyong code, direkta sa ilalim ng random na pag-import.
Kunin ang input ng manlalaro nang isang beses. Gamitin ang function na input () at italaga ang resulta sa variable inp.
Kapag ang input ng manlalaro ay hindi isang numero, hilingin sa kanila na maglagay ng isang numero. Upang suriin kung ang isang string ay isang numero, gamitin ang mga pagpapaandar ng isdigit (), na nagpapahintulot lamang sa isang buong numero, kaya't hindi mo na susuriing hiwalay iyon.
Kung ang input ay isang numero, i-convert ito mula sa string sa numero at ibalik ang resulta. Gamitin ang int () function para sa pag-convert ng string sa isang integer. Gagawin nitong hindi kinakailangan ang conversion sa pangunahing code, at dapat mo itong alisin mula doon.
Palitan ang lahat ng mga tawag sa input () sa pangunahing code ng mga tawag sa numInput ().
Ang code ng function na numInput () ay magiging ganito:

def numInput (): inp = input () habang hindi inp.isdigit (): print ("Sinabihan kang magpasok ng isang buong numero! Magpasok ng isang buong numero:") inp = input () return int (inp)

Hakbang 11. Subukan muli ang laro

Nilalayon mong ipasok ang mga maling bagay upang makita kung ano ang nangyayari, at pagkatapos ay ayusin ang anumang mga error sa paglabas nito.

Subukang ipasok ang ilang teksto kapag ang programa ay humihiling sa iyo ng isang numero. Ngayon, sa halip na lumabas na may isang mensahe ng error, hihilingin sa iyo muli ng programa para sa isang numero

Hakbang 12. Magmungkahi ng pag-restart ng laro kapag natapos ito

Sa ganitong paraan, maaaring i-play ng manlalaro ang iyong laro para sa isang mas mahabang oras nang hindi kinakailangang i-restart ito muli.

Ilagay ang lahat ng code maliban sa pag-import at ang kahulugan ng pagpapaandar sa isang habang-loop. Itakda ang Totoo bilang kondisyon: palagi itong magiging totoo, kaya't ang loop ay magpapatuloy magpakailanman.
Tanungin ang manlalaro kung nais nilang maglaro muli pagkatapos nilang hulaan nang tama ang numero. Gamitin ang pagpapaandar na naka-print ().
Kung sasagutin nila ang "Hindi", huwag nang tingnan. Kung may sasagutin pa sila, magpatuloy. Ang pag-break out ng isang loop ay tapos na sa pahayag ng pahinga.
Ilipat ang "Maligayang pagdating sa laro ng paghula ng numero" sa labas ng habang loop. Marahil ay hindi nais ng manlalaro na malugod silang tinanggap tuwing naglalaro sila ng laro. Ilipat ang print ng pagtuturo ("Maligayang pagdating sa laro ng paghula ng numero!" Sa itaas ng habang Totoo:, kaya i-print ito nang isang beses lamang, kapag sinimulan ng gumagamit ang unang laro.

Hakbang 13. Subukan ang laro

Kakailanganin mong subukan ang iyong laro sa tuwing nagpapatupad ka ng isang bagong tampok.

Siguraduhing sagutin ang parehong "Oo" at "Hindi" kahit isang beses upang matiyak na gagana ang parehong pagpipilian. Narito kung ano ang dapat magmukhang iyong code:

import random def numInput (): inp = input () habang hindi inp.isdigit (): print ("Sinabihan kang ipasok ang isang buong numero! Magpasok ng isang buong numero:") inp = input () return int (inp) print ("Maligayang pagdating sa laro ng paghula ng numero!") Habang Tama: i-print ("Ipasok ang isang buong numero sa pagitan ng 1 at 1000:") rightNum = random.randint (0, 1000) userNum = numInput () habang ang userNum! = RightNum: kung userNum <rightNum: print ("Masyadong maliit. Subukang muli:") kung userNum> rightNum: print ("Masyadong malaki. Subukang muli:") userNum = numInput () print ("Nahulaan mo nang tama.") i-print ("Mayroon ka bang nais na maglaro muli? Ipasok ang Hindi upang umalis. ") kung input () ==" Hindi ": break

Hakbang 14. Sumulat ng iba pang mga larong batay sa teksto

Paano ang pagsusulat ng isang pakikipagsapalaran sa teksto sa susunod? O isang laro ng pagsusulit? Maging malikhain.

Tip: Minsan kapaki-pakinabang upang tumingin sa dokumentasyon kung hindi ka sigurado kung paano tapos ang isang bagay o kung paano ginagamit ang isang pagpapaandar. Ang dokumentasyon ng Python 3 ay matatagpuan sa https://docs.python.org/3/. Minsan ang paghahanap para sa anumang nais mong gawin sa internet ay nagbabalik din ng magagandang resulta.

Bahagi 2 ng 3: Paggawa ng isang Laro na may 2D Graphics

Hakbang 1. Pumili ng isang library ng graphics

Ang paggawa ng mga graphic ay napaka-kumplikado, at ang karamihan sa mga wika ng programa (kasama ang Python, C ++, C, JavaScript) ay nagbibigay lamang ng minimal o kahit na walang suporta para sa mga graphic sa core o sa karaniwang mga aklatan. Kaya kakailanganin mong gumamit ng isang panlabas na library upang makagawa ng mga graphic, halimbawa Pygame para sa Python.

Kahit na may isang library ng graphics, mag-aalala ka tungkol sa mga bagay tulad ng kung paano ipakita ang isang menu, kung paano suriin kung ano ang na-click ng manlalaro, kung paano ipakita ang mga tile, at iba pa. Kung mas gugustuhin mong ituon ang pagbuo ng aktwal na laro, maaari mong gamitin ang isang game engine library tulad ng Unity, na madaling ipatupad ang mga bagay na ito

Gagamitin ng artikulong ito ang Python na may Cocos2D upang maipakita kung paano gumawa ng isang simpleng 2D platformer. Ang ilan sa mga nabanggit na konsepto ay maaaring wala sa iba pang mga engine ng laro. Sumangguni sa kanilang dokumentasyon para sa karagdagang impormasyon.

Hakbang 2. I-install ang graphics library na iyong pinili

Ang Cocos2D para sa Python ay madaling mai-install. Maaari mo itong makuha mula sa https://python.cocos2d.org/index.html, o sa pamamagitan ng pagpapatakbo ng sudo pip3 i-install ang cocos2d kung gumagamit ka ng Linux.

Hakbang 3. Gumawa ng isang bagong direktoryo para sa iyong laro at media

Gagamitin mo ang mga bagay tulad ng mga imahe at tunog sa iyong laro. Itago ang mga bagay na ito sa parehong direktoryo ng programa. Ang direktoryo na ito ay hindi dapat maglaman ng anupaman upang madali mong makita kung anong mga assets ang mayroon ka sa laro.

Hakbang 4. Lumikha ng isang bagong file ng code sa bagong direktoryo

Tawagin itong pangunahing, kasama ang extension ng file para sa iyong wika ng programa. Kung sumulat ka ng isang malaki at kumplikadong programa kung saan makatuwiran na magkaroon ng maraming mga file ng programa, ipapakita nito sa iyo kung alin ang pangunahing file.

Sa halimbawang ito, lilikha kami ng isang file na tinatawag na main.py na naglalaman ng lahat ng aming code

Hakbang 5. Lumikha ng window ng laro

Ito ang pangunahing kinakailangan para sa isang laro na may graphics.

I-import ang kinakailangang mga sub-module ng cocos2d: cocos.director, cocos.scene at cocos.layer. Ginagawa ito gamit ang mula sa subModuleName import *, kung saan ang pangalan ng sub-Module ay ang submodule na nais mong i-import. Ang pagkakaiba sa pagitan ng mula sa… i-import * at i-import … ay hindi mo kailangang ilagay ang pangalan ng module sa harap ng lahat ng iyong ginagamit mula sa modyul na iyon kasama ang nauna.
Tukuyin ang isang subclass na MainMenuBgr ng ColorLayer. Karaniwang nangangahulugan ito na ang anumang pangunahing background ng menu na iyong nilikha ay kikilos tulad ng isang layer ng kulay na may ilang mga pagbabago na iyong ginawa.
Simulan ang cocos director. Bibigyan ka nito ng isang bagong window. Kung hindi ka magtatakda ng isang caption, ang window ay magkakaroon ng parehong caption sa pangalan ng file (main.py), na hindi magmukhang propesyonal. Payagan ang window na baguhin ang laki sa pamamagitan ng pagtatakda ng resizable sa True.
Tukuyin ang isang function showMainMenu. Dapat mong ilagay ang code para sa pagpapakita ng pangunahing menu sa isang pagpapaandar dahil papayagan ka nitong madaling bumalik sa pangunahing menu sa pamamagitan ng pagtawag muli sa pagpapaandar.
Lumikha ng isang eksena. Ang tagpo ay binubuo ng isang layer sa ngayon, na kung saan ay isang bagay ng klase ng MainMenuBgr na iyong tinukoy.
Patakbuhin ang eksenang ito sa bintana.

mula sa cocos.director import * mula sa cocos.scene import * mula sa cocos.layer import * class 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 - isang simpleng platformer", resizable = True) showMainMenu ()

Hakbang 6. Magdagdag ng isang pangunahing menu sa window

Bukod sa aktwal na laro, kakailanganin mong magdagdag ng isang menu na maaaring magamit ng player upang isara ang window, bukod sa iba pang mga elemento na maaari mong idagdag sa paglaon.

I-import ang cocos.menu (muli kasama ang mula sa tagubilin) at pyglet.app (oras na ito na may pag-import).
Tukuyin ang MainMenu bilang isang subclass ng Menu.
Itakda ang pagkakahanay ng pangunahing menu. Kailangan mong itakda nang hiwalay ang patayo at pahalang na pagkakahanay.
Lumikha ng isang listahan ng mga item sa menu at idagdag ang mga ito sa menu. Dapat ay mayroon kang mga item sa menu na "Start Game" at "Quit" na pinakamaliit. Ang bawat menu item ay dapat na mailagay sa loob ng mga braket. Ang bawat item ay dapat may isang label at isang function ng callback na tumutukoy kung ano ang mangyayari kapag na-click ito ng player. Para sa item na "Start Game", gamitin ang function ng startGame (isusulat mo ito sa lalong madaling panahon), para sa item na "Quit", gamitin ang "pyglet.app.exit" (mayroon na). Lumikha ng aktwal na menu sa pamamagitan ng pagtawag sa self.create_menu (menuItems).
Tukuyin ang startGame (). Ilagay lamang sa kahulugan ang ngayon, papalitan mo iyon kapag isinulat mo ang aktwal na laro.
Pumunta sa lugar sa iyong code kung saan mo nilikha ang tanawin ng menuSc, at magdagdag ng isang bagay na MainMenu dito.

Ang iyong buong code ay dapat na magmukhang sumusunod:

mula sa cocos.director import * mula sa cocos.menu import * mula sa cocos.scene import * mula sa cocos.layer import * import pyglet.app class 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 - isang simpleng platformer", resizable = True) showMainMenu ()

Hakbang 7. Subukan ang iyong code

Subukan ang code nang maaga, habang ito ay maikli pa at medyo simple. Pagkatapos ay maaari mong makilala at maitama ang anumang mga pagkakamali sa pangunahing istraktura bago maging masyadong kumplikado ang mga bagay.

Ang code mula sa mga tagubilin ay dapat buksan ang isang window na may caption na "IcyPlat - isang simpleng platformer." Ang background ay light blue at maaari mong baguhin ang laki sa window. Kapag na-click mo ang "Start Game" sa menu, wala nang dapat mangyari (ngayon). Kapag na-click mo ang "Quit," isasara ang window

Hakbang 8. Lumikha ng isang sprite

Ang sprite ay isang "object ng laro," o isang 2-dimensional na imahe. Ang mga Sprite ay maaaring mga in-game na bagay, icon, dekorasyon sa background, character, at anupaman na maaari mong representahan ng isang imahe sa laro. Magsisimula kami sa pamamagitan ng paglikha ng isang sprite para sa isang character na maaaring makipag-ugnay ng manlalaro.

I-import ang cocos.sprite submodule gamit ang mula sa pag-import-expression.
Maghanap ng isang imahe upang kumatawan sa sprite. Hindi ka maaaring magpakita ng isang sprite kung wala kang larawan para rito. Maaari kang gumuhit ng isa, o maaari kang makakuha ng isa mula sa internet (magbantay para sa mga lisensya, kahit na, kung nagpaplano kang mai-publish ang iyong laro). Para sa halimbawang ito, magtungo sa https://opengameart.org/content/tux-classic-hero-style at i-save ang-p.webp" />
Lumikha ng isang layer bilang isang bagong object ng klase ng ScrollableLayer. Pagkatapos, likhain ang sprite bilang isang Sprite na bagay at itakda ang posisyon nito sa (8, 250). Para sa sanggunian, ang punto (0, 0) ay nasa ibabang kaliwang sulok. Ito ay medyo mataas, ngunit titiyakin nito na ang penguin ay hindi makaalis sa yelo.
Idagdag ang sprite sa layer ng sprite.
Lumikha ng isang bagong eksena mula sa layer ng sprite at patakbuhin ito.

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

Patakbuhin ang code. Dapat mong makita ang isang maliit na pigura ng penguin (o kung ano ang iginuhit mo) sa isang itim na background pagkatapos mong mag-click Simulan ang Laro.

Hakbang 9. Pangarapin ang iyong tanawin

Sa karamihan ng mga laro, ang iyong mga sprite ay hindi dapat lumutang lamang sa walang bisa. Dapat talaga silang tumayo sa ilang mga ibabaw, na may isang bagay sa kanilang paligid. Sa mga laro ng 2D, madalas itong ginagawa gamit ang isang tile set at isang tile map. Karaniwang sinasabi ng tile set kung anong uri ng mga square square at background square ang mayroon, at kung ano ang hitsura nila.

Lumikha ng isang tile set. Ang tile na itinakda para sa larong ito ay magiging napaka-basic: isang tile para sa yelo at isang tile para sa kalangitan. Ang ice tile na ginamit sa halimbawang ito ay nagmula rito, sa ilalim ng CC-BY-SA 3.0.
Lumikha ng larawan ng isang tile set. Iyon ay isang larawan ng lahat ng mga tile, na dapat lahat ay may parehong laki (i-edit ang mga ito kung hindi) at magkaroon ng laki na nais mong makita sa laro, sa tabi ng bawat isa. I-save ang iyong larawan bilang icyTiles.png.
Lumikha ng paglalarawan ng tile set. Iyon ay isang XML file. Naglalaman ang file ng XML ng impormasyon tungkol sa kung gaano kalaki ang mga tile sa tile set na larawan, kung aling larawan ang gagamitin, at kung saan hahanapin kung aling tile ang naroroon. Lumikha ng isang XML file na pinangalanang icyTiles.xml kasama ang code sa ibaba:
```
     
```

Hakbang 10. Gumawa ng isang tile na mapa para sa iyong landscape

Ang isang mapang tile ay isang mapa na tumutukoy sa aling tile ang nasa aling posisyon sa iyong antas. Sa halimbawa, dapat mong tukuyin ang isang pagpapaandar upang makabuo ng mga tile ng tile dahil ang pagdidisenyo ng mga mapa ng tile sa pamamagitan ng kamay ay nakakapagod. Ang isang mas advanced na laro ay karaniwang may ilang uri ng antas ng editor, ngunit para sa pamilyar sa pagbuo ng 2D na laro, ang isang algorithm ay maaaring magbigay ng sapat na mga antas.

Alamin kung gaano karaming mga hilera at haligi ang kinakailangan. Para sa mga ito, hatiin ang laki ng screen ng laki ng tile parehong pahalang (mga haligi) at patayo (mga hilera). Bilugan ang numero pataas; kailangan mo ng isang pagpapaandar ng module ng matematika para doon, kaya magdagdag mula sa ceil ng pag-import ng matematika sa mga pag-import sa tuktok ng iyong code.
Magbukas ng isang file para sa pagsusulat. Burahin nito ang lahat ng nakaraang nilalaman ng file, kaya pumili ng isang pangalan na wala pang file sa direktoryo, tulad ng levelMap.xml.
Isulat ang mga pambungad na tag sa file.
Bumuo ng isang tile na mapa alinsunod sa algorithm. Ginagamit mo ang isa sa code sa ibaba, o maaari kang makabuo ng isa nang mag-isa. Tiyaking i-import ang randint function mula sa random na module: kinakailangan ito upang gumana ang code sa ibaba, at kung anuman ang makakaisip mo ay kailangan din ng mga random integer. Gayundin, tiyaking ilagay ang mga tile ng kalangitan at mga tile ng yelo sa iba't ibang mga layer: ang yelo ay solid, ang langit ay hindi.
Isulat ang mga pansarang tag sa file at isara ang file.

def generateTilemap (): colAmount = ceil (800/16) * 3 # (lapad ng screen / laki ng tile) * 3 rowAmount = ceil (600/16) # taas ng screen / laki ng tile tileFile = bukas ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) para sa i in range (0, colAmount): tileFile.write ('') makeHole = Mali kung randint (0, 50) == 10 at i! = 0: # huwag payagan ang mga butas sa spawnpoint makeHole = Totoo para sa j sa saklaw (0, rowAmount): kung makeHole: tileFile.write ('\ n') iba pa: kung j <= iceHeight: tileFile.write ('\ n') iba pa: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight + 5) kung iceHeight <0: # limitahan ang mga tile mula sa masyadong mababang iceHeight = randint (1, 5) kung iceHeight> rowAmount: # limitahan ang mga tile mula sa sobrang taas ng iceHeight = randint (int (rowAmount / 2) -5, int (rowAmount / 2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') para sa i sa saklaw (0, colAmount): tileFile.write ('') para sa j sa saklaw (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Hakbang 11. Ipakita ang tile map

I-import ang lahat mula sa cocos.tiles at pagkatapos ay pumunta sa pagpapaandar ng startGame para doon.

Sa simula ng iyong pag-andar ng startGame, bumuo ng isang tile na mapa gamit ang pagpapaandar na tinukoy mo para doon.
Lumikha ng isang bagong manager ng pag-scroll. Direkta itong gawin sa ilalim ng linya kung saan mo idaragdag ang sprite sa layer nito.
Lumikha ng isang bagong layer na naglalaman ng mga tile, na mai-load mula sa levelMap.xml tile na mapa na nabuo ng pagpapaandar na function naTilemap.
Idagdag ang hindi solidong layer, ang solidong layer at ang sprite layer sa pag-scroll manager, eksakto sa pagkakasunud-sunod na ito. Maaari kang magdagdag ng isang z-posisyon kung nais mo.
Sa halip na likhain ang eksena mula sa layer ng sprite, likhain ito mula sa pag-scroll manager.

Ang iyong function ng startGame ay dapat na ganito ganito:

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)

Hakbang 12. Subukan ang iyong code

Dapat mong subukan ang iyong code nang madalas upang matiyak na gagana ang mga bagong tampok na ipinatupad mo.

Ang code sa halimbawa ay dapat na magpakita ngayon ng ilang nagyeyelong tanawin sa likod ng penguin. Kung ang penguin ay mukhang lumilipas sa ibabaw ng yelo, wala kang ginawang mali, at maaayos ito sa susunod na hakbang

Hakbang 13. Idagdag ang mga kontrol

Ang manlalaro ay may maraming iba pang mga paraan upang makipag-ugnay sa programa sa isang 2D na laro kaysa sa isang larong batay sa teksto. Kasama sa isang pangkaraniwan ang paglipat ng kanilang pigura kapag ang tamang key ay pinindot.

I-import ang lahat mula sa cocos.mapcolliders at mula sa cocos.actions. Mag-import din ng susi mula sa pyglet.window.
"Ipahayag" ang ilang mga pandaigdigang variable. Ang mga pandaigdigang variable ay ibinabahagi sa pagitan ng mga pagpapaandar. Hindi mo talaga maaaring ideklara ang mga variable sa Python, ngunit sasabihin mo na ang isang pandaigdigang variable ay mayroon sa pangunahing code bago ito gamitin. Maaari kang magtalaga ng 0 bilang ang halaga dahil ang isang pagpapaandar ay mag-aalaga ng pagtatalaga ng tamang halaga sa paglaon. Kaya idagdag sa ilalim ng mga expression ng pag-import:
```
# "pagdedeklara" ng mga pandaigdigang variable na keyboard = 0 scrMang = 0
```

Ayusin ang iyong pag-andar ng startGame:

Sabihin na gumagamit ka ng pandaigdigang mga variable na keyboard at scrMang. Gawin ito sa pamamagitan ng pagsulat ng pandaigdigang keyboard, scrMang sa tuktok ng pagpapaandar.
Pakinggan ang window sa mga kaganapan sa keyboard.
Sabihin sa figure na kumilos batay sa isang PlatformerController. Ipatupad mo na ang PlatformerController sa lalong madaling panahon.
Lumikha ng isang collider ng mapa upang mahawakan ang mga banggaan sa pagitan ng mga solidong tile at ng pigura.

def startGame (): global keyboard, 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)

Lumikha ng isang platformer controller. Ito ang lilipat sa figure ayon sa iyong mga keypress.
- Tukuyin ang platformer controller bilang isang subclass ng Aksyon.
- Tukuyin ang bilis ng paglipat, ang bilis ng pagtalon at ang gravity.
- Tukuyin ang pag-andar sa pagsisimula. Ang pagpapaandar na ito ay tinatawag na isang beses, kapag ang platformer controller ay konektado sa figure. Dapat nitong itakda ang bilis nito sa 0 pareho sa x at sa y direksyon.
- Tukuyin ang pagpapaandar ng hakbang. Mauulit ito habang tumatakbo ang eksena.
- Sabihin ang pagpapaandar ng hakbang upang magamit ang pandaigdigang mga variable na keyboard at scrMang.
- Kunin at baguhin ang bilis. I-save ang x at ang y bilis sa magkakahiwalay na mga variable. Itakda ang x tulin sa alinman sa 1 o -1 (depende sa kung ang kaliwa o kanang pindutan ay pinindot) pinarami ng bilis ng paglipat. Magdagdag ng grabidad sa bilis ng y. I-multiply ito sa downtime kaya gumagana ito sa parehong paraan sa mas mabagal na mga aparato. Kung ang space key ay pinindot at ang figure ay nakatayo sa lupa, tumalon sa pamamagitan ng pagbabago ng y bilis upang tumalon ang bilis.
- Kalkulahin kung saan dapat lumipat ang pigura. Pagkatapos ay hayaan ang handler ng banggaan na ayusin ang posisyon na iyon kung nasa loob ito ng isang solidong tile. Panghuli, ilipat ang numero sa bagong nababagay na posisyon.
- Itakda ang pokus ng scrolling manager sa figure. Ito ay sanhi ng camera upang ilipat sa isang makatwirang paraan kapag ang figure ilipat.
```
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 (self, dt): global keyboard, scroller kung dt> 0.1: # huwag gumawa ng anumang bagay habang downtime upang malaki ang return vx, vy = self.target.velocity vx = (keyboard [key. RIGHT] - keyboard [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt kung self.on_ground at keyboard [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () bago = last.copy () bago.x + = dx new.y + = dy self.target.velocity = self.target.collision_handler (huling, bago, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center)
```

Hakbang 14. Subukan ang iyong code

Kung sinundan mo ang halimbawa, dapat mo na ngayong ilipat ang penguin gamit ang mga arrow key at tumalon sa pamamagitan ng pagpindot sa space bar. Gayundin, ang penguin ay dapat na ngayon ay mahulog sa halip na umikot sa lupa.

Hakbang 15. Lumikha ng isang pagtatapos para sa laro

Kahit na ang mga laro na maaaring magpatuloy nang walang katapusan ay dapat magkaroon ng posibilidad na matalo. Dahil ang antas na ginawa mo sa halimbawa na may pag-andar ay may pagtatapos, kakailanganin mo ring gawing posible na manalo sa pamamagitan ng pag-abot sa puntong iyon. Kung hindi man, tatalon lamang ang manlalaro sa mga bloke ng yelo doon, na kung saan ay magsasawa.

Sa loob ng platformer controller, pagkatapos ng set ng pagtuon, kunin ang posisyon ng x at y ng figure. Kung ang posisyon na y ay mas mababa sa 0, tawagan ang function na finishGame () (isusulat mo ito sa paglaon) na may "Game Over" bilang isang pagtatalo. Kung ang posisyon ng x ay mas malaki kaysa sa laki ng screen na pinarami ng 3 (itinakda mo na bilang laki ng antas dati).
```
posX, posY = self.target.position kung posY <0: finishGame ("Game Over") bumalik kung posX> 800 * 3: # level size finishGame ("Level Level") bumalik
```
Tukuyin ang isang klase mataposMenu. Ito ay dapat na katulad ng pangunahing uri ng menu na tinukoy mo dati, ngunit sa halip na magkaroon ng isang walang laman na string bilang pamagat, dapat itong gumamit ng isang variable na teksto na kung saan ang _init_ function ay tatagal bilang pagtatalo. Ang mga item sa menu ay dapat na may label na "Subukang muli" at "Quit" ngayon, ngunit ang mga pagpapaandar na tinatawag nila ay mananatiling pareho.
```
class FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Subukang muli", startGame)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems)
```
Tukuyin ang pag-andar finishGame (). Dapat itong kumuha ng teksto bilang isang pagtatalo. Dapat itong gumawa ng isang eksena mula sa pangunahing background ng menu, isang FinishMenu na may text argument na naipapasa sa menu na ito. Pagkatapos ay dapat itong patakbuhin ang eksenang ito.
```
def finishGame (text): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (text)) director.run (menuSc)
```

Hakbang 16. Magdagdag ng mga kredito

Dito ka makakakuha ng kredito para sa iyong kahanga-hangang code, pati na rin magbigay ng kredito sa sinumang iba pa na tumulong sa iyo. Kung gumamit ka ng isang imahe mula sa isa pang website (may pahintulot), tiyaking iugnay ang imaheng iyon sa tagalikha nito.

Lumikha ng isang CREDITS file at ipasok doon ang lahat ng iyong mga kredito, tulad nito:

Penguin: Kelvin Shadewing, sa ilalim ng JavaScript Ice block: Michał Banas digit1024 sa opengameart.org sa ilalim ng CC-BY-SA 3.0

Bumalik sa iyong Python code at i-import ang Label mula sa cocos.text.

Tukuyin ang isang subclass Credits of Layer. Sa pagpapaandar na _init_, basahin ang file na CREDITS at gumawa ng isang label ng teksto sa tamang posisyon sa bawat linya dito.

class Credits (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") para sa ako sa saklaw (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)

Pumunta sa iyong pangunahing klase sa menu at magdagdag ng isang item sa menu na may label na "Mga Kredito" na tumatawag sa mga function na showCredit kapag na-click.
Tukuyin ang isang subclass BackToMainMenu Button ng Menu. Gawin itong isang menu na may isang item, na may label na "Bumalik", na tumatawag sa pagpapaandar ng showMainMenu. Ang "menu" na ito, na mas katulad ng isang pindutan, ay dapat na patayo na nakahanay sa ibaba at pahalang sa tuktok.
```
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)
```
Tukuyin ang mga pag-andar showCredit. Dapat itong gumawa ng isang eksena mula sa isang layer ng MainMenuBgr at isang layer ng Credits at patakbuhin ang eksenang iyon.
```
def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)
```

Hakbang 17. Suriin ang iyong code

Kapag sa palagay mo natapos mo na ang iyong code, dapat mong tingnan muli ang lahat ng ito. Matutulungan ka nitong mapansin kung ang isang bagay ay maaaring ma-optimize, o kung may ilang mga hindi kinakailangang linya na nakalimutan mong tanggalin. Kung sinundan mo ang halimbawa, ang iyong buong code ay dapat na magmukhang sumusunod:

mula sa cocos.director import * mula sa cocos.menu import * mula sa cocos.scene import * mula sa cocos.layer import * mula sa cocos.sprite import * mula sa cocos.tiles import * mula sa cocos.mapcolliders import * mula sa cocos.actions import * mula sa cocos.text import Label import pyglet.app mula sa pyglet.window import key mula sa ceil ng pag-import ng matematika mula sa random na pag-import ng randint # "pagdedeklara" na mga variable na global keyboard = 0 scrMang = 0 class 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 ("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") para sa 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 _ self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Subukang muli", startGame)), (MenuItem ("Quit", pyglet. app.exit))] sarili 0) def step (sarili, dt): pandaigdigan keyboard, scroller kung dt> 0.1: # huwag gumawa ng anumang bagay habang downtime masyadong malaki return vx, vy = self.target.velocity vx = (keyboard [key. RIGHT] - keyboard [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt kung self.on _ground at keyboard [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () bago = last.copy () new.x + = dx new.y + = dy self.target.velocity = self.target.collision_handler (huling, bago, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center) posX, posY = self.target.position kung posY <0: finishGame ("Game Over") bumalik kung posX> 800 * 3: # level size finishGame ("Level Level") return def finishGame (text): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (text)) director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenu Button ()) director.run (credSc) def generateTilemap (): colAmount = ceil (800/16) * 3 # (laki ng screen / laki ng tile) * 3 rowAmount = ceil (600/16) # taas ng screen / laki ng tile tileFile = bukas ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) para sa i sa saklaw (0, colAmount): tileFile.write ('') makeHole = Mali kung rand int (0, 50) == 10 at i! = 0: # huwag payagan ang mga butas sa spawnpoint makeHole = Totoo para sa j sa saklaw (0, rowAmount): kung makeHole: tileFile.write ('\ n') iba pa: kung j <= iceHeight: tileFile.write ('\ n') iba pa: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight + 5) kung iceHeight <0: # limitahan ang mga tile mula sa pagpunta rin mababang iceHeight = randint (1, 5) kung iceHeight> rowAmount: # limitasyon ng mga tile mula sa sobrang taas ng iceHeight = randint (int (rowAmount / 2) -5, int (rowAmount / 2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') para sa i sa saklaw (0, colAmount): tileFile.write (' ') para sa j sa saklaw (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): global keyboard, 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 (nsoliTilesang, z = magdagdag (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 (caption = "IcyPlat - isang simpleng platformer", resizable = True) showMainMenu ()

Iyon ay ganap na 168 na linya, at 152 na linya kung bibilangin mo lang ang code. Ang paggawa nito ay tila tulad ng marami, ngunit para sa isang kumplikadong laro, ito ay talagang isang maliit na halaga.

Hakbang 18. Tapos na

Ngayon subukan ang laro. Kapag nag-program ka ng isang bagay, kailangan mong suriin kung gagana ito sa tuwing nagpatupad ka ng bago. Gayundin, baka gusto mong i-play ang larong isinulat mo nang ilang oras.

Bahagi 3 ng 3: Pag-publish ng isang Laro

Hakbang 1. Isulat ang mga dependency

Ang sinumang gumagamit ng ibang computer ay hindi magkakaroon ng parehong software at aklatan na naka-install tulad mo. Kaya, kakailanganin mong tiyakin na ang lahat na nag-install ng iyong laro ay alam mismo kung ano ang kakailanganin nila upang mapatakbo ito. Hindi mo kailangang isulat ang lahat ng mga dependency ng lahat ng mga dependency ng lahat ng mga dependency at iba pa, ngunit dapat mo man lang isulat ang mga dependency ng iyong mga package at kanilang mga dependency.

Hakbang 2. Tiyaking mayroon kang pahintulot na magamit ang lahat ng media

Nalalapat ito sa lahat ng mga graphic, kabilang ang mga modelo ng 3D, musika, dayalogo, musika, aklatan, at mga balangkas na ginamit mo para sa iyong laro. Anumang hindi mo isinulat ang iyong sarili.

Kadalasan mayroong ilang mga kundisyon, tulad ng pag-credit sa may-akda o pagbabahagi ng mga pagbabago ng media sa ilalim ng parehong lisensya. Minsan makakagamit ka ng mga graphic nang hindi maiuugnay ang mga tagalikha hangga't hindi ka naniningil para sa laro. Kung kailangan mong i-credit ang may-akda, gawin ito sa isang kilalang lugar, tulad ng isang tab na "Mga Kredito" sa iyong laro.
Mayroon ding media na may copyright na inaangkin at walang tinukoy na lisensya, kung minsan ay may ilang teksto tulad ng "All rights reserved". Kung iyon ang kaso, dapat kang makakuha ng tahasang pahintulot mula sa may-akda bago isama ito sa iyong laro.
Karaniwang inilalabas ang mga aklatan sa ilalim ng mga lisensya na pinapayagan silang magamit bilang silid-aklatan. Ang isang pambihirang pagbubukod ay ang GPL nang walang pag-uugnay sa pagbubukod: Pinapayagan lamang ng nasabing isang lisensya na gamitin ito sa isang programa na may ilang mga lisensya. At dapat mong palaging basahin ang hindi bababa sa mga pangunahing punto ng lisensya upang matiyak na pinapayagan ang anumang ginagawa mo sa media o silid-aklatan.

Babala: Ang paggamit ng media o mga aklatan sa isang paraan na hindi pinapayagan ng lisensya sa isang laro na iyong nai-publish ay maaaring makakuha sa iyo sa malubhang ligal na ligal. Kaya't tanungin ang may-akda o iwasan ang kabuuan ng media kung hindi ka sigurado tungkol sa kung pinapayagan ang iyong paggamit.

Hakbang 3. Magpasya sa mga kundisyon na nais mong mai-publish ang iyong laro

Ibebenta mo ba ang iyong laro? Nais mo bang payagan ang iba na gamitin ang iyong mga imahe at ideya? Habang kailangan mong mag-ingat tungkol sa media na ginagamit mo sa iyong proyekto, karaniwang maaari kang magpasya sa kung paano mo nais na payagan ang iba na gamitin ang iyong laro. Maaari kang gumamit ng lisensya ng Creative Commons CC0 upang palabasin ang iyong laro sa pampublikong domain.. Upang payagan ang pamamahagi at pagbabago sa ilalim ng ilang mga kundisyon habang pinapanatili ang ilang mga karapatan, subukan ang lisensya ng Gnu General Public (GPL) o ang lisensya ng Berkeley Software Distribution (BSD). O kaya, maaari mong gawing pagmamay-ari ang iyong software, nangangahulugang walang sinumang pinapayagan na ipamahagi o baguhin ito nang wala ang iyong pahintulot.

Bagaman posible na kumita ng pera sa pamamagitan ng pagbebenta ng mga laro, malamang na hindi bibili ang mga tao ng iyong unang laro na karaniwang may ilang mga tampok at walang espesyal. Gayundin, kung ang isang libreng programa ay hindi gagana, ang mga taong na-download ito ay mabibigo lamang. Kung binayaran nila ito, gayunpaman, hihilingin nila na ibalik ang kanilang pera, na magdudulot ng mas maraming problema para sa iyo at sa mga gumagamit. Kaya isaalang-alang ang gawing libre ang iyong unang mga programa

Hakbang 4. Magpasya kung paano mo nais na mai-publish ang iyong laro

Ang bawat pamamaraan ay may ilang mga pakinabang at kawalan, kaya kailangan mong magpasya sa iyong sarili.

Paglathala nito sa isang website:

Kung mayroon kang isang website, maaari mong i-upload ang iyong laro upang magamit itong ma-download. Tiyaking magbigay ng malinaw na mga tagubilin sa kung paano i-install ang software, pati na rin ang lahat ng kinakailangang mga dependency. Ang kawalan nito ay ang mga manlalaro ay kailangang mag-install ng mga dependency nang manu-mano, na maaaring mahirap para sa ilang mga tao.
Gumagawa ng isang pakete para sa isang manager ng package:

Mayroong iba't ibang mga tagapamahala ng package, tulad ng apt, Yum, at Homebrew, na ginagawang madali para sa mga tao na mag-install ng mga app sa mga kapaligiran sa Linux at Linux. Lahat sila ay may magkakaibang mga format ng package. Ang magandang bagay tungkol sa mga pakete ay awtomatiko nilang na-install ang lahat ng mga dependency (kung i-configure mo nang tama ang mga ito). Kaya kailangang i-install lamang ng manlalaro ang iyong pakete at maaaring i-play ang laro. Ang problema ay maraming iba't ibang mga tagapamahala ng package sa iba't ibang mga platform, kaya kakailanganin mong maglagay ng ilang trabaho sa pagbibigay ng mga pakete para sa lahat ng mga pinakakaraniwan.

Hakbang 5. Idirekta ang pansin sa iyong programa

Isaalang-alang ang pag-upload ng iyong programa sa isang pangunahing lalagyan ng package, tulad ng pinapanatili ng Ubuntu at Debian, upang payagan ang madaling pag-install. Gayundin, mag-post sa naaangkop na mga forum, tulad ng seksyon ng mga proyekto ng GameDev o isang bahagi ng tigSource. Ngunit huwag mabigo kung ang iyong mga unang laro ay hindi sumikat. Kung mayroon kang isang ideya na gusto ng maraming tao, ang iyong laro ay maaaring maging kilalang-kilala.

Mga Tip

Maging mapagpasensya at handang matuto. Ang pagprograma ay maaaring nakakainis kung minsan!
Kung nagtataka ka kung paano nagawa ang isang bagay sa isa pang laro, at ang laro ay open-source, maaari mong tingnan ang source code nito.
Kapag naghahanap ng media, subukang maghanap ng nilalaman na nasa pampublikong domain. Maghanap ng mga imahe at musika na "Creative Commons" o "Public Domain", at gumamit ng mga website tulad ng https://opengameart.org o
Huwag kopyahin ang mga pangunahing chunks ng code nang hindi sinusuri ang lisensya. Ito ay madalas na ipinagbabawal, at kung hindi, karaniwang nangangailangan ng pagpapatungkol.
Huwag gumawa ng spam o mag-post sa mga hindi naaangkop na lugar kapag isinusulong ang iyong laro. Ito ay malamang na ma-block ka mula sa pahina, simpleng nakakainis, at makakasira sa iyong reputasyon.