Kā programmēt datorspēles (ar attēliem)

2024 Autors: Robert Blare | [email protected]. Pēdējoreiz modificēts: 2024-01-31 12:18

Vai jums ir ideja par datorspēli un vēlaties to īstenot? Vai arī esat kādreiz domājuši, kā tiek rakstītas datorspēles? Šis wikiHow iemāca jums rakstīt trīs pamata datorspēles Python. Lai izstrādātu savu pirmo spēli, jums būs nepieciešama pamata izpratne par Python un vispārējām programmēšanas koncepcijām.

Soļi

1. daļa no 3: Teksta spēles izveide

1. solis. Izvēlieties programmēšanas valodu

Visas programmēšanas valodas ir atšķirīgas, tāpēc jums būs jāizlemj, kuru lietot spēles rakstīšanai. Katra lielākā programmēšanas valoda atbalsta teksta ievadi, teksta izvadi un if-konstrukcijas (galvenās lietas, kas nepieciešamas vienkāršai, uz tekstu balstītai spēlei), tāpēc izpētiet iespējas un izlemiet, kura no tām jums šķiet visērtākā un veltīta mācībām. Šeit jāņem vērā daži faktori:

• Kam visbiežāk tiek izmantota valoda?

  Dažas programmēšanas valodas, piemēram, JavaScript, ir paredzētas lietošanai tīmeklī, bet citas, piemēram, Python, C vai C ++, ir paredzētas datorprogrammu palaišanai. Savā spēlē mērķējiet uz valodu ar plašāku lietojumu, piemēram, Python, C, C ++ vai JavaScript.

• Cik grūti ir mācīties?

  Lai gan programmas uzrakstīšanai vajadzētu būt pietiekami vienkāršai pēc kādas prakses jebkurā normālā programmēšanas valodā (t.i., ne vienā, kas īpaši izstrādāta, lai būtu mulsinoša kā Malbolge), dažas ir iesācējiem draudzīgākas nekā citas. Java un C, piemēram, prasīs jums dziļākas programmēšanas koncepcijas nekā kaut kas līdzīgs Python, kas ir pazīstams ar pieejamāku un vienkāršu sintaksi.

• Kur es varu to izmantot?

  Jūs droši vien vēlaties, lai cilvēki, kas darbojas dažādās sistēmās, piemēram, Linux, Mac vai Windows, varētu spēlēt jūsu spēli. Tāpēc jums nevajadzētu izmantot valodu, kas tiek atbalstīta tikai dažās sistēmās, piemēram, Visual Basic, kas tiek atbalstīta tikai sistēmā Windows.

Šajā rakstā teksta spēles piemēriem tiks izmantots Python, taču jūs varat apskatīt, kā jēdzieni tiek veidoti jebkurā citā programmēšanas valodā.

2. Sagatavojiet datoru

Divi galvenie komponenti, kas jums būs nepieciešami, ir teksta redaktors, kurā ierakstīsit savu kodu, un kompilators, kuru izmantosit, lai to pārvērstu par spēli. Ja vēlaties sekot šajā rakstā sniegtajam piemēram, jums jāinstalē Python un jāiemācās palaist programmas. Ja vēlaties, varat iestatīt IDE (Integraded Desktop Environment), kas apvieno rediģēšanu, apkopošanu un atkļūdošanu vienā programmā. Python IDE sauc par IDLE. Bet jūs varat arī vienkārši izmantot jebkuru teksta redaktoru, kas atbalsta vienkāršu tekstu, piemēram, Notepad operētājsistēmai Windows, TextEdit operētājsistēmai MacOS vai Vim Linux.

Solis 3. Uzrakstiet kādu kodu, lai sveicinātu spēlētāju

Spēlētājs vēlēsies uzzināt, kas notiek un kas viņam jādara, tāpēc jums vajadzētu izdrukāt viņiem kādu tekstu.

• Tas tiek darīts, izmantojot funkciju print () programmā Python. Lai to izmēģinātu, atveriet jaunu failu ar paplašinājumu.py, ievadiet tajā šādu kodu, saglabājiet un palaidiet to:

  print ("Laipni lūdzam skaitļu minēšanas spēlē!") print ("Ievadiet veselu skaitli no 1 līdz 1000:")
  

Solis 4. Izveidojiet nejaušu skaitli

Izveidosim teksta spēli, kurā spēlētājam tiek lūgts uzminēt pareizo skaitli. Pirmā lieta, kas mums jādara, ir spēles sākumā ģenerēt nejaušu skaitli, lai spēlētājs ne vienmēr uzminētu vienu un to pašu numuru. Tā kā skaitlis visā programmā paliks nemainīgs, izlases numuru vēlaties saglabāt mainīgajā.

• Python nav iebūvēta nejaušu skaitļu funkcija, taču tai ir standarta bibliotēka (tas nozīmē, ka lietotājam nekas papildus nebūs jāinstalē). Tāpēc dodieties uz sava koda sākumu (pirms drukāšanas () funkcijām) un ierakstiet izlases rindas importēšanu.

• Izmantojiet izlases funkciju. To sauc par randint (), tas ir izlases bibliotēkā, kuru tikko importējāt, un tā izmanto kā minimālo un maksimālo vērtību, kas var būt skaitlis. Tāpēc atgriezieties koda beigās un ievadiet šādu rindu:

  rightNum = random.randint (0, 1000)
  

5. solis. Iegūstiet ievadi no atskaņotāja

Spēlē spēlētājs vēlas kaut ko darīt vai ar kaut ko mijiedarboties. Teksta spēlē tas ir iespējams, ievadot tekstu. Tagad, kad mums ir nejaušs skaitlis, mūsu nākamajām koda rindām vajadzētu lūgt spēlētājam ievadīt savu labāko minējumu.

• Tā kā ievadītais kods izdrukā norādījumu atskaņotājam ievadīt skaitli, tam vajadzētu arī izlasīt ievadīto numuru. Tas tiek darīts ar ievadi () programmā Python 3 un raw_input () programmā Python 2. Jums vajadzētu rakstīt programmā Python 3, jo Python 2 drīz kļūs novecojis. Pievienojiet kodam šādu rindiņu, lai atskaņotāja ievadīto informāciju saglabātu mainīgā, ko sauc par numuru:

  userNum = ievade ()
  

6. solis. Pārvērtiet atskaņotāja ievadīto datu tipu

Spēlētājs ir ievadījis numuru-ko tagad?

• Padariet spēlētāja ievadīto skaitli. Tagad tas var likties mulsinoši, jo viņi tikko ievadīja numuru. Bet ir labs iemesls: Python pieņem, ka visa ievade ir teksts vai "virkne", kā to sauc programmēšanā. Šis teksts satur numuru, kuru vēlaties iegūt. Python ir funkcija, kas pārvērš virkni, kurā ir tikai skaitlis, par skaitli iekšpusē. Tips:

  userNum = int (userNum)
  

7. solis. Salīdziniet spēlētāja numuru ar pareizo numuru

Kad spēlētājs ir ievadījis savu numuru, tas jāsalīdzina ar nejauši ģenerēto numuru. Ja skaitļi nav vienādi, jūsu spēle var likt spēlētājam izmēģināt citu numuru. Ja skaitļi sakrīt, varat pateikt spēlētājam, ka viņi uzminēja pareizi, un iziet no programmas. Tas tiek darīts ar šādu kodu:

kamēr userNum! = rightNum: userNum = int (ievade ())

8. solis. Sniedziet spēlētājam atsauksmes

Kamēr jūs jau esat apstrādājis viņu ievadīto informāciju, atskaņotājs to neredzēs. Jums būs faktiski jāizdrukā rezultāti atskaņotājam, lai viņš saprastu, kas notiek.

• Protams, jūs varētu vienkārši pateikt spēlētājam, vai viņu numurs ir pareizs vai nepareizs. Bet ar šādu pieeju spēlētājam sliktākajā gadījumā var nākties uzminēt 1000 reizes, kas būtu ļoti garlaicīgi.
• Tāpēc pastāstiet spēlētājam, vai viņu skaits ir pārāk mazs vai pārāk liels. Tas ievērojami samazinās viņu minējumu skaitu. Ja, piemēram, spēlētājs vispirms uzminēja 500 un spēle atbildēja "Pārāk liels. Mēģiniet vēlreiz", 1000 vietā būs tikai 500 iespējamie skaitļi. Tas tiek darīts ar if-konstrukcijām, tāpēc nomainiet izdruku ("Nepareizs. Mēģiniet vēlreiz. ") Ar vienu.
• Ņemiet vērā, ka pārbaude, vai divi skaitļi ir vienādi, tiek veikta ar ==, nevis ar =. = piešķir vērtību pa labi no tā mainīgajam pa kreisi!

if userNum <rightNum: print ("Pārāk mazs. Mēģiniet vēlreiz:") if userNum> rightNum: print ("Pārāk liels. Mēģiniet vēlreiz:")

9. darbība. Pārbaudiet savu kodu

Kā programmētājam jums vajadzētu būt pārliecinātam, ka jūsu kods darbojas, pirms uzskatāt, ka tas ir pabeigts.

• Programmējot programmā python, pārliecinieties, vai ievilkumi ir pareizi. Jūsu kodam vajadzētu izskatīties šādi:

  importēt izlases drukāšanu ("Laipni lūdzam skaitļu minēšanas spēlē!") print ("Ievadiet veselu skaitli no 1 līdz 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum), kamēr userNum! = rightNum: ja userNum <rightNum: print ("Pārāk mazs. Mēģiniet vēlreiz:") ja userNum> rightNum: print ("Pārāk liels. Mēģiniet vēlreiz:") userNum = int (input ()) print ("Jūs uzminējāt pareizi. ")
  

10. solis. Apstipriniet ievadi

Spēlētājam nevajadzētu pārtraukt jūsu spēli, vienkārši ievadot nepareizu lietu. "Ievades apstiprināšana" nozīmē pārliecināties, vai spēlētājs ievadīja pareizo lietu pirms tās apstrādes.

• Atveriet spēli vēlreiz un mēģiniet ievadīt visu, kas nav skaitlis. Spēle tiks aizvērta ar ValueError. Lai no tā izvairītos, varat ieviest veidu, kā pārbaudīt, vai ievade ir skaitlis.
• Definējiet funkciju. Tā kā ievades pārbaude ir diezgan ilga un tā ir jādara vairākas reizes, jums vajadzētu definēt funkciju. Tam nebūs nepieciešami argumenti un tiks atgriezts skaitlis. Vispirms uzrakstiet def numInput (): koda augšdaļā, tieši zem nejaušās importēšanas.
• Vienu reizi iegūstiet spēlētāja ieguldījumu. Izmantojiet ievades () funkciju un piešķiriet rezultātu mainīgajam inp.
• Ja spēlētāja ievade nav skaitlis, palūdziet viņam ievadīt skaitli. Lai pārbaudītu, vai virkne ir skaitlis, izmantojiet funkcijas isdigit (), kas atļauj tikai veselu skaitli, tāpēc jums tas nebūs jāpārbauda atsevišķi.
• Ja ievade ir skaitlis, pārveidojiet to no virknes uz skaitli un atgrieziet rezultātu. Izmantojiet funkciju int (), lai pārvērstu virkni par veselu skaitli. Tas padarīs reklāmguvumu galvenajā kodā nevajadzīgu, un jums tas ir jānoņem no turienes.
• Aizstājiet visus zvanus uz ievadi () galvenajā kodā ar zvaniem uz numInput ().
• Funkcijas numInput () kods izskatīsies šādi:

def numInput (): inp = input (), kamēr nav inp.isdigit (): print ("Jums lika ievadīt veselu skaitli! Ievadiet veselu skaitli:") inp = input () return int (inp)

Solis 11. Pārbaudiet spēli vēlreiz

Apzināti ievadiet nepareizās lietas, lai redzētu, kas notiek, un pēc tam labojiet visas kļūdas, kad tās rodas.

Mēģiniet ievadīt tekstu, kad programma pieprasa numuru. Tagad tā vietā, lai izietu ar kļūdas ziņojumu, programma jums atkal prasīs numuru

12. solis. Iesakiet restartēt spēli, kad tā ir pabeigta

Tādā veidā spēlētājs varētu spēlēt jūsu spēli ilgāku laiku, nepārtraukti to restartējot.

• Ievietojiet visu kodu, izņemot importēšanu un funkcijas definīciju, cikla ciklā. Iestatiet True kā nosacījumu: tas vienmēr būs taisnība, tāpēc cikls turpināsies mūžīgi.
• Pajautājiet spēlētājam, vai viņi vēlas spēlēt vēlreiz, kad viņi pareizi uzminēja numuru. Izmantojiet funkciju print ().
• Ja viņi atbild "nē", izlauzties no izskata. Ja viņi atbild uz kaut ko citu, turpiniet. Izlaušanās no cilpas tiek veikta ar pārtraukuma paziņojumu.
• Pārvietojiet “Laipni lūdzam skaitļu uzminēšanas spēlē” ārpus cikla cikla. Spēlētājs, iespējams, nevēlas, lai viņu uzņemtu katru reizi, kad viņš spēlē spēli. Pārvietojiet instrukciju izdruku ("Laipni lūdzam skaitļu uzminēšanas spēlē!"), Bet virs True, tāpēc tā tiks izdrukāta tikai vienu reizi, kad lietotājs sāks pirmo spēli.

Solis 13. Pārbaudiet spēli

Jums būs jāpārbauda spēle katru reizi, kad ieviešat jaunu funkciju.

• Noteikti atbildiet gan "jā", gan "nē" vismaz vienu reizi, lai pārliecinātos, ka abas iespējas darbojas. Jūsu kodam vajadzētu izskatīties šādi:

  importēt izlases def numInput (): inp = input (), kamēr nav inp.isdigit (): print ("Jums tika lūgts ievadīt veselu skaitli! Ievadiet veselu skaitli:") inp = input () return int (inp) print ("Laipni lūdzam skaitļu minēšanas spēlē!"), Kamēr True: print ("Ievadiet veselu skaitli no 1 līdz 1000:") rightNum = random.randint (0, 1000) userNum = numInput (), kamēr userNum! = RightNum: ja userNum <rightNum: print ("Pārāk mazs. Mēģiniet vēlreiz:") if userNum> rightNum: print ("Pārāk liels. Mēģiniet vēlreiz:") userNum = numInput () print ("Jūs uzminējāt pareizi.") print ("Vai jūs vai vēlaties spēlēt vēlreiz? Ievadiet Nē, lai izietu. ") if input () ==" No ": break
  

14. solis. Uzrakstiet citas teksta spēles

Kā būtu rakstīt teksta piedzīvojumu tālāk? Vai viktorīnas spēle? Esi radošs.

Padoms: Dažreiz ir noderīgi ieskatīties dokumentācijā, ja neesat pārliecināts, kā kaut kas tiek darīts vai kā tiek izmantota funkcija. Python 3 dokumentācija ir pieejama vietnē https://docs.python.org/3/. Dažreiz, meklējot visu, ko vēlaties darīt internetā, tiek atgriezti arī labi rezultāti.

2. daļa no 3: Spēles veidošana ar 2D grafiku

1. solis. Izvēlieties grafikas bibliotēku

Grafikas izveide ir ļoti sarežģīta, un lielākā daļa programmēšanas valodu (ieskaitot Python, C ++, C, JavaScript) nodrošina tikai minimālu vai pat nekādu atbalstu grafikai kodolā vai standarta bibliotēkās. Tātad, lai izveidotu grafiku, jums jāizmanto ārēja bibliotēka, piemēram, Pygame for Python.

Pat ar grafikas bibliotēku jums būs jāuztraucas par tādām lietām kā izvēlnes parādīšana, kā pārbaudīt, uz ko spēlētājs noklikšķināja, kā parādīt flīzes utt. Ja vēlaties koncentrēties uz faktiskās spēles izstrādi, varat izmantot tādu spēļu dzinēju bibliotēku kā Unity, kas šīs lietas viegli īsteno

Šajā rakstā tiks izmantots Python ar Cocos2D, lai parādītu, kā izveidot vienkāršu 2D platformas veidotāju. Daži no minētajiem jēdzieniem var nebūt citos spēļu dzinējos. Plašāku informāciju skatiet viņu dokumentācijā.

2. solis. Instalējiet izvēlēto grafikas bibliotēku

Cocos2D for Python ir viegli uzstādīt. To var iegūt vietnē https://python.cocos2d.org/index.html vai palaižot sudo pip3 instalēt cocos2d, ja izmantojat Linux.

3. Izveidojiet jaunu spēles un multivides direktoriju

Spēlē izmantosit tādas lietas kā attēli un skaņas. Saglabājiet šīs lietas tajā pašā direktorijā kā programma. Šajā direktorijā nedrīkst būt nekas cits, lai jūs varētu viegli redzēt, kādi līdzekļi jums ir spēlē.

4. solis. Izveidojiet jaunu koda failu jaunajā direktorijā

Sauciet to par galveno, ar jūsu programmēšanas valodas faila paplašinājumu. Ja rakstāt lielu un sarežģītu programmu, kur ir jēga izmantot vairākus programmas failus, tas parādīs, kurš ir galvenais fails.

Šajā piemērā mēs izveidosim failu ar nosaukumu main.py, kurā būs viss mūsu kods

Solis 5. Izveidojiet spēles logu

Tas ir pamatnosacījums spēlei ar grafiku.

• Importējiet nepieciešamos cocos2d apakšmoduļus: cocos.director, cocos.cene un cocos.layer. Tas tiek darīts ar importēšanu no subModuleName *, kur apakšmoduļa nosaukums ir apakšmodulis, kuru vēlaties importēt. Atšķirība starp importēšanu un importēšanu ir tāda, ka jums nav jānorāda moduļa nosaukums visam, ko izmantojat no šī moduļa kopā ar pirmo.
• Definējiet ColorLayer apakšklasi MainMenuBgr. Tas būtībā nozīmē, ka jebkurš jūsu izveidotās galvenās izvēlnes fons darbosies kā krāsu slānis, veicot dažas izmaiņas.
• Sāciet kokosu direktoru. Tas dos jums jaunu logu. Ja neiestatīsit parakstu, logam būs tāds pats paraksts kā faila nosaukumam (main.py), kas neizskatīsies profesionāli. Ļaujiet mainīt loga izmērus, iestatot maināmu lielumu uz True.
• Definējiet funkciju showMainMenu. Galvenās izvēlnes parādīšanas kods jāievada funkcijā, jo tas ļaus jums viegli atgriezties galvenajā izvēlnē, vēlreiz izsaucot funkciju.
• Izveidojiet ainu. Sižets pagaidām sastāv no viena slāņa, kas ir jūsu definētās MainMenuBgr klases objekts.
• Palaidiet šo ainu logā.

no cocos.director importēšanas * no cocos.scene importa * no cocos.layer importa * klases 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 - a simple platformer", resizable = True) showMainMenu ()

6. solis. Pievienojiet logam galveno izvēlni

Papildus faktiskajai spēlei jums būs jāpievieno izvēlne, kuru spēlētājs var izmantot, lai aizvērtu logu, kā arī citi elementi, kurus varat pievienot vēlāk.

• Importējiet izvēlni cocos.men (atkal ar instrukciju) un pyglet.app (šoreiz ar importēšanu).
• Definējiet MainMenu kā izvēlnes apakšklasi.
• Iestatiet galvenās izvēlnes līdzinājumu. Jums ir atsevišķi jāiestata vertikālā un horizontālā izlīdzināšana.
• Izveidojiet izvēlnes vienumu sarakstu un pievienojiet tos izvēlnei. Jums vajadzētu būt vismaz izvēlnes vienumiem "Sākt spēli" un "Iziet". Katrs izvēlnes vienums jāievieto iekavās. Katram vienumam ir jābūt etiķetei un atzvanīšanas funkcijai, kas nosaka, kas notiek, kad spēlētājs uz tā noklikšķina. Vienumam "Sākt spēli" izmantojiet funkciju startGame (drīz to uzrakstīsit), vienumam "Iziet" izmantojiet "pyglet.app.exit" (jau pastāv). Izveidojiet faktisko izvēlni, zvanot uz self.create_menu (menuItems).
• Definējiet startGame (). Vienkārši ievietojiet definīciju pagaidām, jūs to aizstāsit, rakstot faktisko spēli.
• Dodieties uz kodu savā vietā, kur izveidojāt menuSc ainu, un pievienojiet tam MainMenu objektu.

• Visam jūsu kodam tagad vajadzētu izskatīties šādi:

  no cocos.director importa * no cocos.menu importēšanas * no cocos.scene importa * no cocos.layer importēšanas * importēšanas pyglet.app klases MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) klases MainMenu (izvēlne): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Sākt spēli) ", 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 - a simple platformer", resizable = True) showMainMenu ()
  

7. solis. Pārbaudiet savu kodu

Pārbaudiet kodu agri, lai gan tas joprojām ir īss un salīdzinoši vienkāršs. Tad jūs varat identificēt un labot visas kļūdas pamata struktūrā, pirms lietas kļūst pārāk sarežģītas.

Norādījumos norādītajam kodam vajadzētu atvērt logu ar uzrakstu "IcyPlat - vienkāršs platformas veidotājs". Fons ir gaiši zils, un jūs varat mainīt loga izmēru. Izvēlnē noklikšķinot uz "Sākt spēli", nekas nedrīkst notikt (vēl). Noklikšķinot uz "Iziet", logs tiks aizvērts

8. solis. Izveidojiet sprite

Sprite ir "spēles objekts" vai divdimensiju attēls. Sprites var būt spēles objekti, ikonas, fona rotājumi, rakstzīmes un jebkas cits, ko jūs varat attēlot ar attēlu spēlē. Mēs sāksim, izveidojot sprite personāžam, ar kuru spēlētājs var mijiedarboties.

• Importējiet cocos.sprite apakšmoduli ar izteiksmi no importa.
• Atrodiet attēlu, kas attēlo spritu. Jūs nevarat parādīt spritu, ja jums tam nav attēla. Jūs varat uzzīmēt vienu vai iegūt to no interneta (tomēr, ja plānojat publicēt savu spēli, uzmanieties licencēm). Šajā piemērā dodieties uz vietni https://opengameart.org/content/tux-classic-hero-style un saglabājiet datorā skrienošo pingvīnu-p.webp" />
• Izveidojiet slāni kā jaunu ScrollableLayer klases objektu. Pēc tam izveidojiet sprite kā Sprite objektu un iestatiet tā pozīciju uz (8, 250). Atsaucei punkts (0, 0) atrodas apakšējā kreisajā stūrī. Tas ir diezgan augsts, taču tas nodrošinās, ka pingvīns neiesprūst ledū.
• Pievienojiet sprite sprite slānim.
• Izveidojiet jaunu ainu no sprite slāņa un palaidiet to.

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

• Palaidiet kodu. Pēc noklikšķināšanas uz melna fona vajadzētu redzēt nelielu pingvīna figūriņu (vai visu, ko uzzīmējāt) Sākt spēli.

9. solis. Sapņojiet savu ainavu

Lielākajā daļā spēļu jūsu spritiem nevajadzētu vienkārši peldēt tukšumā. Viņiem faktiski vajadzētu stāvēt uz kādas virsmas, kaut kam apkārt. 2D spēlēs tas bieži tiek darīts ar flīžu komplektu un flīžu karti. Flīžu komplekts būtībā norāda, kādi virsmas laukumi un fona laukumi pastāv un kā tie izskatās.

• Izveidojiet flīžu komplektu. Šīs spēles flīžu komplekts būs ļoti vienkāršs: viena flīze ledum un viena flīze debesīm. Šajā piemērā izmantotā ledus dakstiņa ir no šejienes, zem CC-BY-SA 3.0.
• Izveidojiet flīžu komplekta attēlu. Tas ir attēls ar visām flīzēm, kurām visām ir jābūt vienāda izmēra (rediģējiet tās, ja tādas nav), un tām jābūt tādām, kādas vēlaties redzēt spēlē blakus. Saglabājiet attēlu kā icyTiles.png.

• Izveidojiet flīžu kopas aprakstu. Tas ir XML fails. XML failā ir informācija par to, cik lielas ir flīzes flīžu kopas attēlā, kuru attēlu izmantot un kur atrast, kura flīze ir. Izveidojiet XML failu ar nosaukumu icyTiles.xml ar šādu kodu:

10. solis. Izveidojiet flīzes karti savai ainavai

Flīžu karte ir karte, kas nosaka, kura flīze atrodas jūsu līmeņa pozīcijā. Šajā piemērā jums vajadzētu definēt funkciju flīžu karšu ģenerēšanai, jo flīžu karšu projektēšana ar rokām ir ļoti garlaicīga. Uzlabotākajai spēlei parasti būtu sava veida līmeņa redaktors, bet, lai iepazītos ar 2D spēļu izstrādi, algoritms var nodrošināt pietiekami labu līmeni.

• Uzziniet, cik rindu un kolonnu ir nepieciešams. Lai to izdarītu, sadaliet ekrāna izmēru ar flīžu izmēru gan horizontāli (kolonnas), gan vertikāli (rindas). Noapaļojiet skaitli uz augšu; jums ir nepieciešama matemātikas moduļa funkcija, tāpēc pievienojiet no matemātikas importa griestiem importam koda augšdaļā.
• Atveriet failu rakstīšanai. Tas izdzēsīs visu iepriekšējo faila saturu, tāpēc izvēlieties nosaukumu, kāds vēl nav direktorijā esošam failam, piemēram, levelMap.xml.
• Ierakstiet failā sākuma tagus.
• Izveidojiet flīžu karti saskaņā ar algoritmu. Jūs izmantojat to, kas norādīts zemāk esošajā kodā, vai arī varat to izdomāt pats. Pārliecinieties, ka importējat randint funkciju no moduļa izlases: tas ir nepieciešams, lai zemāk esošais kods darbotos, un, lai arī ko jūs izdomātu, iespējams, būs nepieciešami arī nejauši veseli skaitļi. Pārliecinieties arī, ka debess flīzes un ledus flīzes ievietojat dažādos slāņos: ledus ir ciets, debesis nav.
• Ierakstiet failā noslēguma tagus un aizveriet failu.

defgeneTilemap (): colAmount = griesti (800/16) * 3 # (ekrāna platums / flīžu izmērs) * 3 rowAmount = griesti (600/16) # ekrāna augstums / flīžu izmērs tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) i diapazonā (0, colAmount): tileFile.write ('') makeHole = Nepareizi, ja randint (0, 50)) == 10 un i! = 0: # nepieļaut caurumus nārsta punktā makeHole = True attiecībā uz j diapazonā (0, rowAmount): if makeHole: tileFile.write ('\ n') else: ja j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) if iceHeight <0: # ierobežo flīzes no pārāk zemas ledusHeight = randint (1, 5) if iceHeight> rowAmount: # limits flīzes no pārāk augsta ledusHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') i diapazonā (0, colAmount): tileFile.write ('') j diapazonā (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

11. solis. Parādiet flīžu karti

Importējiet visu no cocos.tiles un pēc tam dodieties uz startGame funkciju.

• Funkcijas startGame sākumā ģenerējiet flīžu karti, izmantojot tam definēto funkciju.
• Izveidojiet jaunu ritināšanas pārvaldnieku. Dariet to tieši zem līnijas, kur spritei pievienojat slāni.
• Izveidojiet jaunu slāni, kurā ir flīzes, un tas tiks ielādēts no levelMap.xml karšu kartes, kurā tiks ģenerēta funkcija generatorTilemap.
• Ritināšanas pārvaldniekam pievienojiet neslīdošo slāni, cieto slāni un sprite slāni tieši šādā secībā. Ja vēlaties, varat pievienot z pozīciju.
• Tā vietā, lai izveidotu ainu no sprite slāņa, izveidojiet to no ritināšanas pārvaldnieka.

• Funkcijai startGame tagad vajadzētu izskatīties šādi:

  def startGame ():geneTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 500) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml') solidTiles = tileLayer ['solid'] nsoliTiles = tileLayer ['not_solid'] # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc)
  

12. solis. Pārbaudiet savu kodu

Jums bieži jāpārbauda kods, lai pārliecinātos, vai jaunās ieviestās funkcijas patiešām darbojas.

Piemēra kodam tagad vajadzētu parādīt kādu ledus ainavu aiz pingvīna. Ja pingvīns izskatās tā, ka tas lidinās tālu virs ledus, jūs neko sliktu neesat izdarījis, un tas tiks novērsts nākamajā darbībā

13. solis. Pievienojiet vadīklas

Spēlētājam ir daudz vairāk veidu, kā mijiedarboties ar programmu 2D spēlē nekā teksta spēlē. Parasti tiek pārvietota figūra, nospiežot pareizo taustiņu.

• Importējiet visu no cocos.mapcolliders un no cocos.actions. Importējiet arī atslēgu no pyglet.window.

• "Deklarēt" dažus globālos mainīgos. Globālie mainīgie tiek sadalīti starp funkcijām. Jūs nevarat īsti deklarēt mainīgos Python, bet jums jāsaka, ka globālais mainīgais pastāv galvenajā kodā pirms tā lietošanas. Jūs varat piešķirt 0 kā vērtību, jo funkcija parūpēsies par pareizas vērtības piešķiršanu vēlāk. Tāpēc pievienojiet zem importa izteicieniem:

  # "deklarējot" globālos mainīgos tastatūra = 0 scrMang = 0
  

• Pielāgojiet startGame funkciju:

  • Pieņemsim, ka izmantojat globālo mainīgo tastatūru un scrMang. Lai to izdarītu, ierakstiet globālo tastatūru, funkcijas augšdaļā - scrMang.
  • Lieciet logā klausīties tastatūras notikumus.
  • Pasakiet skaitlim rīkoties, pamatojoties uz PlatformerController. Drīz jūs ieviesīsit šo PlatformerController.
  • Izveidojiet karšu sadursmi, lai tiktu galā ar sadursmēm starp cietajām flīzēm un figūru.

  def startGame (): globālā tastatūra, scrManggeneTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml ') solidTiles = tileLayer [' solid '] nsoliTiles = tileLayer [' not_solid '] # tastatūra = key. KeyStateHandler () director.window.push_handlers (tastatūra) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on = 'slaids') att. 1) # gameSc = Scene (scrMang) director.run (gameSc)
  

• Izveidojiet platformas kontrolieri. Tas pārvietos skaitli atbilstoši taustiņu nospiešanai.

  • Definējiet platformas kontrolieri kā darbības apakšklasi.
  • Definējiet kustības ātrumu, lēciena ātrumu un smagumu.
  • Definējiet sākuma funkciju. Šī funkcija tiek izsaukta vienu reizi, kad platformas kontrolieris ir pievienots attēlam. Tam jāiestata ātrums uz 0 gan x, gan y virzienā.
  • Definējiet soļa funkciju. Tā tiks atkārtota sižeta darbības laikā.
  • Pastāstiet soļa funkcijai, lai izmantotu globālo mainīgo tastatūru un scrMang.
  • Iegūstiet un mainiet ātrumu. Saglabājiet x un y ātrumu atsevišķos mainīgos. Iestatiet x ātrumu uz 1 vai -1 (atkarībā no tā, vai tika nospiests kreisais vai labais taustiņš), kas reizināts ar pārvietošanās ātrumu. Pievienojiet gravitāciju y ātrumam. Reiziniet to ar dīkstāvi, lai tas darbotos tāpat kā lēnākās ierīcēs. Ja tiek nospiests atstarpes taustiņš un figūra stāv uz zemes, lēkt, mainot y ātrumu uz lēciena ātrumu.
  • Aprēķiniet, kur figūrai jāpārvietojas. Pēc tam ļaujiet sadursmes apstrādātājam pielāgot šo pozīciju, ja tā atrodas cietas flīzes iekšpusē. Visbeidzot pārvietojiet figūru uz jauno pielāgoto pozīciju.
  • Ritināšanas pārvaldnieka fokusu iestatiet uz figūru. Tas liek kamerai saprātīgi pārvietoties, kad figūra pārvietojas.

  klases PlatformerController (darbība): globālā tastatūra, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (self, dt): globālā tastatūra, ritiniet, ja dt> 0.1: # nedariet neko, kamēr dīkstāves laikā atgriežas vx, vy = self.target.velocity vx = (tastatūra [key. RIGHT] - tastatūra [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt, ja self.on_ground un tastatūra [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () new = last.copy () new.x += dx new.y += dy self.target.velocity = self.target.collision_handler (pēdējā, jaunā, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (*jauns.centrs)
  

14. darbība. Pārbaudiet savu kodu

Ja jūs sekojāt piemēram, jums tagad vajadzētu būt iespējai pārvietot pingvīnu ar bulttaustiņiem un pāriet, nospiežot atstarpes taustiņu. Tāpat pingvīnam tagad vajadzētu nokrist, nevis lidināties virs zemes.

Solis 15. Izveidojiet spēles beigu

Pat spēlēm, kuras var turpināties bezgalīgi, vajadzētu būt iespējai zaudēt. Tā kā līmenim, ko veidojāt piemērā ar funkciju, ir beigas, jums būs arī jāļauj uzvarēt, sasniedzot šo mērķi. Pretējā gadījumā spēlētājs tikai lektu pa ledus klucīšiem, kas kļūtu garlaicīgi.

• Platformas kontrollerī pēc fokusa iestatīšanas iegūstiet figūras x un y pozīciju. Ja y pozīcija ir mazāka par 0, izsauciet funkciju finishGame () (jūs to uzrakstīsit vēlāk), kā argumentu norādot "Game Over". Ja pozīcija x ir lielāka par ekrāna izmēru, kas reizināts ar 3 (iepriekš to iestatījāt kā līmeņa izmēru).

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

• Klases apdares definēšana Izvēlne. Tai vajadzētu būt kā galvenajai izvēlnes klasei, kuru jūs iepriekš definējāt, bet tā vietā, lai nosaukumā būtu tukša virkne, tai jāizmanto mainīgs teksts, ko funkcija _init_ izmanto kā argumentu. Izvēlnes vienumiem vajadzētu būt ar norādi “Mēģināt vēlreiz” un “Iziet” tūlīt, taču funkcijas, ko tās sauc, paliek nemainīgas.

  klases FinishMenu (izvēlne): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Mēģināt vēlreiz", startGame)), (MenuItem ("Iziet", pyglet.app.exit))] self.create_menu (menuItems)
  

• Definējiet funkciju finishGame (). Tam vajadzētu uztvert tekstu kā argumentu. Tam vajadzētu izveidot ainu no galvenās izvēlnes fona, FinishMenu ar teksta argumentu, kas tiek nodots šai izvēlnei. Tad tai vajadzētu vadīt šo ainu.

  def finishGame (teksts): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (teksts)) director.run (menuSc)
  

16. solis. Pievienojiet kredītus

Šeit jūs saņemat atzinību par savu satriecošo kodu, kā arī piešķirat kredītu ikvienam citam, kas jums palīdzēja šajā ceļā. Ja izmantojāt attēlu no citas vietnes (ar atļauju), noteikti attieciniet to uz tā veidotāju.

• Izveidojiet failu CREDITS un ievadiet tur visus savus kredītus, piemēram:

  Pingvīns: Kelvins Šedings, zem CC0 Ledus bloks: Mihala Banasa cipars1024 vietnē opengameart.org saskaņā ar CC-BY-SA 3.0
  

• Atgriezieties pie sava Python koda un importējiet etiķeti no vietnes cocos.text.

• Definējiet apakšklasi Kredīta slāņi. Funkcijā _init_ izlasiet CREDITS failu un izveidojiet teksta etiķeti pareizajā vietā no katras rindiņas.

  klases kredīti (slānis): def _init _ (self): super (kredīti, sevis)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") i diapazonā (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)
  

• Dodieties uz savu galvenās izvēlnes klasi un pievienojiet izvēlnes vienumu ar nosaukumu "Kredīti", kurā noklikšķinot tiek izsaukta funkcija showCredits.

• Izvēlnes apakšklases BackToMainMenuButtine definēšana. Padariet šo izvēlni ar vienu vienumu ar nosaukumu "Atpakaļ", kas izsauc funkciju showMainMenu. Šai "izvēlnei", kas vairāk līdzinās pogai, jābūt vertikāli izlīdzinātai ar apakšu un horizontāli uz augšu.

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

• Definējiet funkciju showCredits. Tam vajadzētu izveidot ainu no MainMenuBgr slāņa un kredītu slāņa un palaist šo ainu.

  def showCredits (): credSc = aina (MainMenuBgr ()) credSc.add (kredīti ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)
  

17. darbība. Pārbaudiet savu kodu

Kad domājat, ka esat pabeidzis kodu, jums tas vēlreiz jāpārbauda. Tas var palīdzēt pamanīt, vai kaut ko var optimizēt, vai arī ir dažas nevajadzīgas rindiņas, kuras esat aizmirsis izdzēst. Ja sekojāt šim piemēram, visam jūsu kodam vajadzētu izskatīties šādi:

no cocos.director importa * no cocos.menu importa * no cocos.scene importa * no cocos.layer importa * no cocos.sprite importa * no cocos.tiles importa * no cocos.mapcolliders importa * no cocos.actions importa * no cocos.teksta importēšana Iezīmju importēšana pyglet.app no pyglet.window importēšanas atslēga no matemātikas importa griestiem no nejaušas importēšanas randint # "deklarējot" globālos mainīgos self)._ init _ (0, 200, 255, 255) klases MainMenu (izvēlne): 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) klases Kredīti (Layer): def _init _ (self): super (kredīti, sevis)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n") i diapazonā (0, len (creds)): credLabel = Label (creds , font_size = 32, anchor_x = "pa kreisi", anchor_y = "top") credLabel.position = 25, 500- (i+1)*40 self.add (credLabel) klases BackToMainMenuButton (izvēlne): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self.create_menu (menuItems) klase FinishMenu (Menu): def (_init) self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Try again", startGame)), (MenuItem ("Quit", pyglet). app.exit))] self.create_menu (menuItems) klases PlatformerController (darbība): globālā tastatūra, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def solis (sevis, dt): globālā tastatūra, ritiniet, ja dt> 0,1: # nedariet neko, kamēr dīkstāve ir pārāk liela atgriešanās vx, vy = self.target.velocity vx = (tastatūra [key. RIGHT] - tastatūra [key. LEFT]) * self. MOVE_SPEED vy += self. GRAVITY * dt if self.on _ zeme un tastatūra [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () new = last.copy () new.x += dx new.y + = dy self.target.velocity = self.target.collision_handler (pēdējā, jaunā, 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") atgriežas, ja posX> 800*3: # level size finish finishGame ("Level Completed") atgriežas def finishGame (teksts): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (teksts)) director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc) defgeneTilemap (): colAmount = griesti (800/16) * 3 # (ekrāna platums / flīžu izmērs) * 3 rowAmount = griesti (600/16) # ekrāna augstums / flīžu izmērs tileFile = open ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) i diapazonā (0, colAmount): tileFile.write ('') makeHole = Nepareizi, ja rand int (0, 50) == 10 un i! = 0: # neļaut caurumus nārsta punktā makeHole = True attiecībā uz j diapazonā (0, rowAmount): if makeHole: tileFile.write ('\ n') else: ja j <= ledusAugstums: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) if iceHeight <0: # ierobežo flīzes arī iet zems ledusHeight = randint (1, 5) if iceHeight> rowAmount: # limits flīzes no pārāk augsta ledusHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') i diapazonā (0, colAmount): tileFile.write (' ') j diapazonā (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): globālā tastatūra, scrManggeneTilemap () # fig = Sprite ('pingu.png') att. = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml') solidTiles = tileLayer ['solid'] nsoliTiles = tileLayer ['not_solid'] # tastatūra = key. KeyStateHandler () director.window.push_handlers (tastatūra ard) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump = 'slide') att.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoli -1. pievienot (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) logs = director.init (caption = "IcyPlat - vienkāršs platformas veidotājs", maināms izmērs = True) showMainMenu ()

• Tas ir 168 rindas un 152 rindas, ja skaitāt tikai kodu. Tas liekas daudz, bet tik sarežģītai spēlei tas patiesībā ir neliels daudzums.

18. solis. Pabeigts

Tagad pārbaudiet spēli. Kad jūs kaut ko programmējat, jums jāpārbauda, vai tas darbojas, kad esat ieviesis kaut ko jaunu. Tāpat jūs, iespējams, vēlētos kādu laiku spēlēt rakstīto spēli.

3. daļa no 3: Spēles publicēšana

1. solis. Pierakstiet atkarības

Ikvienam, kurš izmanto citu datoru, nebūs instalēta tāda pati programmatūra un bibliotēkas kā jums. Tātad, jums jāpārliecinās, ka visi, kas instalē jūsu spēli, precīzi zina, kas viņiem būs nepieciešams, lai to palaistu. Jums nav jāpieraksta visu atkarību visu atkarību atkarības un tā tālāk, bet jums vajadzētu vismaz uzrakstīt savu pakotņu atkarības un to atkarības.

2. solis. Pārliecinieties, vai jums ir atļauja izmantot visus datu nesējus

Tas attiecas uz visu grafiku, ieskaitot 3D modeļus, mūziku, dialogu, mūziku, bibliotēkas un ietvarus, ko izmantojāt savai spēlei. Viss, ko pats nerakstīji.

• Bieži vien ir daži nosacījumi, piemēram, jāpievieno autors vai jāapmainās ar multivides modifikācijām saskaņā ar to pašu licenci. Dažreiz jūs varēsit izmantot grafiku, nepiešķirot satura veidotājiem attiecīgus nosacījumus, ja vien par spēli nemaksāsit. Ja jums ir jāpieskaita autors, dariet to labi redzamā vietā, piemēram, spēles cilnē “Kredīti”.
• Ir arī plašsaziņas līdzekļi ar autortiesībām un licence nav norādīta, dažreiz ar tekstu, piemēram, “Visas tiesības aizsargātas”. Ja tas tā ir, pirms tā iekļaušanas spēlē jums jāsaņem skaidra autora atļauja.
• Bibliotēkas parasti tiek izdotas saskaņā ar licencēm, kas ļauj tās izmantot kā bibliotēku. Ievērojams izņēmums ir GPL bez saistīšanas izņēmuma: šāda licence ļauj to izmantot tikai programmā ar noteiktām licencēm. Un vienmēr izlasiet vismaz licences pamatpunktus, lai pārliecinātos, ka viss, ko darāt ar plašsaziņas līdzekļiem vai bibliotēku, ir atļauts.

Brīdinājums: Izmantojot multividi vai bibliotēkas tādā veidā, kas nav atļauts jūsu publicētajā spēlē, var rasties nopietnas juridiskas problēmas. Tāpēc, ja neesat pārliecināts par to, vai jūsu lietošana ir atļauta, jautājiet autoram vai izvairieties no plašsaziņas līdzekļa.

3. solis. Izlemiet, kādos apstākļos vēlaties publicēt savu spēli

Vai jūs pārdosit savu spēli? Vai vēlaties ļaut citiem izmantot jūsu attēlus un idejas? Lai gan jums jābūt uzmanīgiem attiecībā uz projektā izmantotajiem datu nesējiem, jūs parasti varat izlemt, kā vēlaties ļaut citiem izmantot jūsu spēli. Jūs varat izmantot Creative Commons CC0 licenci, lai savu spēli publiskotu. Lai atļautu izplatīšanu un modificēšanu noteiktos apstākļos, vienlaikus saglabājot dažas tiesības, izmēģiniet Gnu General Public License (GPL) vai Berkeley Software Distribution (BSD) licenci. Vai arī jūs varat padarīt savu programmatūru patentētu, kas nozīmē, ka nevienam nav atļauts to izplatīt vai modificēt bez jūsu atļaujas.

Lai gan ir iespējams nopelnīt, pārdodot spēles, maz ticams, ka cilvēki iegādāsies jūsu pirmo spēli, kurai parasti ir maz funkciju un nekas īpašs. Turklāt, ja bezmaksas programma nedarbojas, cilvēki, kuri to lejupielādēja, vienkārši būs vīlušies. Tomēr, ja viņi par to samaksāja, viņi prasīs naudu atpakaļ, radot vairāk problēmu gan jums, gan lietotājiem. Tāpēc apsveriet iespēju dažas pirmās programmas padarīt pieejamas bez maksas

4. solis. Izlemiet, kā vēlaties publicēt savu spēli

Katrai metodei ir savas priekšrocības un trūkumi, tāpēc jums ir jāizlemj pašam.

• Publicējot to vietnē:

  Ja jums ir vietne, varat augšupielādēt savu spēli, lai tā būtu pieejama lejupielādei. Noteikti sniedziet skaidrus norādījumus par programmatūras instalēšanu, kā arī visas nepieciešamās atkarības. Tā trūkums ir tāds, ka spēlētājiem atkarības būs jāinstalē manuāli, kas dažiem cilvēkiem var būt grūti.

• Iepakojuma izveide iepakojuma pārvaldniekam:

  Ir dažādi pakotņu pārvaldnieki, piemēram, apt, Yum un Homebrew, kas cilvēkiem ļauj viegli instalēt lietotnes Linux un Linux vidē. Viņiem visiem ir dažādi iepakojuma formāti. Pakotņu labā lieta ir tā, ka tās automātiski instalē visas atkarības (ja tās pareizi konfigurējat). Tātad spēlētājam ir tikai jāinstalē jūsu pakete un pēc tam var spēlēt spēli. Problēma ir tā, ka dažādās platformās ir daudz dažādu pakotņu pārvaldnieku, tāpēc jums būs jāpieliek pūles, lai nodrošinātu paketes visām visbiežāk sastopamajām.

Solis 5. Pievērsiet uzmanību savai programmai

Apsveriet iespēju augšupielādēt savu programmu lielā pakotņu krātuvē, piemēram, Ubuntu un Debian, lai varētu viegli instalēt. Publicējiet arī piemērotos forumos, piemēram, GameDev projektu sadaļā vai tigSource daļā. Bet nelieciet vilties, ja jūsu pirmās spēles nekļūs slavenas. Ja jums ir ideja, ka daudziem tas patīk, jūsu spēle var kļūt plaši pazīstama.

Padomi

• Esiet pacietīgs un gatavs mācīties. Programmēšana reizēm var būt nomākta!
• Ja domājat, kā kaut kas tiek darīts citā spēlē un spēle ir atvērtā koda, varat apskatīt tās avota kodu.
• Meklējot medijus, mēģiniet atrast publiski pieejamu saturu. Meklējiet attēlus un mūziku “Creative Commons” vai “Public Domain” un izmantojiet tādas vietnes kā https://opengameart.org vai
• Nekopējiet galvenos koda gabalus, nepārbaudot licenci. Tas bieži ir aizliegts, un, ja nē, tas parasti ir jāpiešķir.
• Neveidojiet surogātpastu un nepublicējiet neatbilstošās vietās, reklamējot savu spēli. Tas, visticamāk, bloķēs jūs no lapas, būs vienkārši kaitinoši un kaitēs jūsu reputācijai.