Как да програмирате компютърни игри (със снимки)

2024 Автор: Robert Blare | [email protected]. Последно модифициран: 2024-01-31 12:13

Имате ли идея за компютърна игра и искате да я реализирате? Или някога сте се чудили как се пишат компютърни игри? Това wikiHow ви учи как да пишете три основни компютърни игри в Python. Ще ви е необходимо основно разбиране на Python и общи концепции за програмиране, за да разработите първата си игра.

Стъпки

Част 1 от 3: Създаване на текстово базирана игра

Стъпка 1. Изберете език за програмиране

Всички езици за програмиране са различни, така че ще трябва да решите кой да използвате, за да напишете играта си. Всеки основен език за програмиране поддържа въвеждане на текст, извеждане на текст и if-конструкции (основните неща, от които се нуждаете за проста текстово базирана игра), така че проучете опциите и решете с кой се чувствате най-удобно и посветен на ученето. Ето някои фактори, които трябва да имате предвид:

За какво най -често се използва езикът?

Някои езици за програмиране, като JavaScript, са предназначени за използване в мрежата, докато други, като Python, C или C ++, са предназначени за изпълнение на компютърни програми. За вашата игра се стремете към език с по -широк спектър на употреба, като Python, C, C ++ или JavaScript.
Колко е трудно да се научи?

Въпреки че писането на програма би трябвало да бъде достатъчно лесно след известно упражнение на всеки нормален език за програмиране (т.е. не такъв, специално проектиран да бъде объркващ като Malbolge), някои са по -приятелски настроени към начинаещите от други. Java и C например ще изискват от вас да разберете по-дълбоки концепции за програмиране, отколкото нещо като Python, който е известен с по-достъпен и ясен синтаксис.
Къде мога да го използвам?

Вероятно искате хората в различни системи, като Linux, Mac или Windows, всички да могат да играят вашата игра. Така че не трябва да използвате език, който се поддържа само в няколко системи, като Visual Basic, който се поддържа само в Windows.

Тази статия ще използва Python за примерите на текстово базирана игра, но можете да потърсите как се правят концепциите във всеки друг език за програмиране.

Стъпка 2. Подгответе компютъра си

Двата основни компонента, от които се нуждаете, са текстов редактор, в който ще напишете кода си, и компилатор, който ще използвате, за да го превърнете в игра. Ако искате да следвате примера в тази статия, трябва да инсталирате Python и да научите как да стартирате програми. Ако искате, можете да настроите IDE (интегрирана среда на работния плот), която комбинира редактиране, компилиране и отстраняване на грешки в една програма. IDE на Python се нарича IDLE. Но можете също така просто да използвате всеки текстов редактор, който поддържа обикновен текст, като Notepad за Windows, TextEdit за macOS или Vim за Linux.

Стъпка 3. Напишете код, за да поздравите играча

Играчът ще иска да знае какво се случва и какво трябва да направи, така че трябва да отпечатате текст за тях.

Това става с функцията print () в Python. За да го изпробвате, отворете нов файл с разширението.py, въведете следния код в него, запазете го и го стартирайте:
```
print ("Добре дошли в играта за отгатване на числа!") print ("Въведете цяло число между 1 и 1000:")
```

Стъпка 4. Генерирайте произволно число

Нека направим текстово базирана игра, която иска от играча да отгатне правилното число. Първото нещо, което трябва да направим, е да генерираме произволно число в началото на играта, така че играчът да не отгатва винаги едно и също число. Тъй като номерът ще остане същият в цялата програма, ще искате да съхранявате случайното число в променлива.

Python няма вградена функция за произволни числа, но има стандартна библиотека (това означава, че потребителят няма да трябва да инсталира нищо допълнително), което прави. Така че отидете в началото на вашия код (преди функциите print ()) и въведете ред за импортиране на ред.
Използвайте случайната функция. Той се нарича randint (), е в случайната библиотека, която току -що сте импортирали, и приема минималната и максималната стойност, която броят може да има като аргумент. Така че се върнете в края на кода си и въведете следния ред:
```
rightNum = random.randint (0, 1000)
```

Стъпка 5. Получете информация от плейъра

В играта играчът иска да направи нещо или да взаимодейства с нещо. В текстово базирана игра това е възможно чрез въвеждане на текст. Сега, когато имаме случайно число, следващите ни редове код трябва да помолят играча да въведе най -доброто си предположение.

Тъй като въведеният от вас код отпечатва инструкцията за въвеждане на номер на плейъра, той също трябва да прочете номера, който въвежда. Това се прави с input () в Python 3 и raw_input () в Python 2. Трябва да пишете в Python 3, тъй като Python 2 скоро ще остарее. Добавете следния ред към кода си, за да запазите входа на плейъра в променлива, наречена номер:
```
userNum = вход ()
```

Стъпка 6. Превърнете входа на плейъра в използваем тип данни

Играчът е въвел номер-сега какво?

Направете въвеждането на плейъра номер. Това може да звучи объркващо, защото току -що са въвели номер. Но има основателна причина: Python приема, че целият вход е текст или "низ", както се нарича в програмирането. Този текст съдържа номера, който искате да получите. Python има функция, която преобразува низ, който съдържа само число, във вътрешното число. Тип:
```
userNum = int (userNum)
```

Стъпка 7. Сравнете номера на играча с правилния номер

След като плейърът въведе своя номер, ще трябва да го сравните с този, който е генериран на случаен принцип. Ако числата не са еднакви, играта ви може да накара играча да опита друг номер. Ако числата съвпадат, можете да кажете на играча, че е отгатнал правилно, и да напуснете програмата. Това става със следния код:

докато userNum! = rightNum: userNum = int (вход ())

Стъпка 8. Дайте обратна връзка на играча

Докато вече сте обработили въведеното от тях, плейърът няма да види това. Всъщност ще трябва да отпечатате резултатите на плейъра, за да разберат какво се случва.

Разбира се, можете просто да кажете на играча дали броят им е правилен или грешен. Но с този подход играчът може да се наложи да отгатне 1000 пъти в най -лошия случай, което би било много скучно.
Затова кажете на играча дали техният брой е твърде малък или твърде голям. Това значително ще намали броя на техните предположения. Ако например играчът отгатне първо 500 и играта отговори „Твърде голям. Опитайте отново“, ще има само 500 възможни числа вместо 1000. Това се прави с if-конструкции, затова заменете отпечатъка („Грешно. Опитайте отново. ") С един.
Имайте предвид, че проверката дали две числа са еднакви се прави с ==, а не с =. = присвоява стойността вдясно от нея на променливата вляво от нея!

if userNum <rightNum: print ("Твърде малък. Опитайте отново:") if userNum> rightNum: print ("Твърде голям. Опитайте отново:")

Стъпка 9. Тествайте кода си

Като програмист трябва да сте сигурни, че кодът ви работи, преди да го считате за завършен.

Когато програмирате в python, уверете се, че правите отстъпите правилно. Вашият код трябва да изглежда така:

импортиране на произволен печат ("Добре дошли в играта за отгатване на числа!") print ("Въведете цяло число между 1 и 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) while userNum! = rightNum: if userNum <rightNum: print ("Твърде малък. Опитайте отново:") if userNum> rightNum: print ("Твърде голям. Опитайте отново:") userNum = int (input ()) print ("Предположихте правилно.")

Стъпка 10. Потвърдете входа

Играчът не трябва да може да наруши играта ви, като просто въведе грешното нещо. „Потвърждаване на входа“означава да се уверите, че играчът е въвел правилното нещо, преди да го обработи.

Отворете играта отново и опитайте да въведете всичко, което не е число. Играта ще излезе с ValueError. За да избегнете това, можете да приложите начин да проверите дали въведеното е число.
Определете функция. Тъй като валидирането на входа е доста дълго и трябва да го направите няколко пъти, трябва да дефинирате функция. Той няма да отнеме аргументи и ще върне число. Първо напишете def numInput (): в горната част на кода си, директно под random random.
Вземете въвеждането на плейъра веднъж. Използвайте функцията input () и присвойте резултата на променливата inp.
Когато въведеното от играча не е число, помолете го да въведе номер. За да проверите дали низ е число, използвайте функциите isdigit (), които позволяват само цяло число, така че няма да се налага да проверявате това отделно.
Ако входът е число, преобразувайте го от низ в число и върнете резултата. Използвайте функцията int () за преобразуване на низ в цяло число. Това ще направи преобразуването в основния код ненужно и трябва да го премахнете от там.
Заменете всички повиквания към input () в основния код с повиквания към numInput ().
Кодът на функцията numInput () ще изглежда така:

def numInput (): inp = input (), докато не inp.isdigit (): print ("Казано ви е да въведете цяло число! Въведете цяло число:") inp = input () return int (inp)

Стъпка 11. Тествайте играта отново

Въведете нарочно грешните неща, за да видите какво се случва, и след това поправете всички грешки, когато се появят.

Опитайте да въведете текст, когато програмата ви поиска номер. Сега, вместо да излезете със съобщение за грешка, програмата отново ще поиска номер

Стъпка 12. Предложете рестартиране на играта, когато приключи

По този начин играчът може да играе играта ви за по -дълго време, без да се налага постоянно да я рестартирате.

Поставете целия код с изключение на импорта и дефиницията на функцията в цикъл while. Задайте True като условие: това винаги ще бъде вярно, така че цикълът ще продължи завинаги.
Попитайте играча дали иска да играе отново, след като отгатне правилно номера. Използвайте функцията print ().
Ако отговорят с „Не“, избягайте от погледа. Ако отговорят на нещо друго, продължете. Излизането от цикъл се извършва с оператора break.
Преместете „Добре дошли в играта за отгатване на числа“извън цикъла while. Играчът вероятно не иска да бъде посрещнат всеки път, когато играе играта. Преместете инструкцията за печат („Добре дошли в играта за отгатване на числа!“Над „while“: така че тя ще бъде отпечатана само веднъж, когато потребителят стартира първата игра.

Стъпка 13. Тествайте играта

Ще трябва да тествате играта си всеки път, когато внедрите нова функция.

Не забравяйте да отговорите поне с „Да“и „Не“поне веднъж, за да се уверите, че и двете опции работят. Ето как трябва да изглежда вашият код:

import random def numInput (): inp = input (), докато не inp.isdigit (): print ("Казано ви е да въведете цяло число! Въведете цяло число:") inp = input () return int (inp) print ("Добре дошли в играта за отгатване на числа!") While True: print ("Въведете цяло число между 1 и 1000:") rightNum = random.randint (0, 1000) userNum = numInput () while userNum! = RightNum: if userNum <rightNum: print ("Твърде малък. Опитайте отново:"), ако userNum> rightNum: print ("Твърде голям. Опитайте отново:") userNum = numInput () print ("Правилно предположихте.") print ("Дали искате да играете отново? Въведете No, за да излезете. ") ако input () ==" No ": break

Стъпка 14. Напишете други текстово базирани игри

Какво ще кажете за следващото текстово приключение? Или игра с викторина? Бъди креативен.

Бакшиш: Понякога е полезно да погледнете в документацията, ако не сте сигурни как се прави нещо или как се използва функция. Документацията за Python 3 се намира на https://docs.python.org/3/. Понякога търсенето на каквото и да искате да правите в интернет също дава добри резултати.

Част 2 от 3: Създаване на игра с 2D графики

Стъпка 1. Изберете библиотека с графики

Създаването на графики е много сложно и повечето езици за програмиране (включително Python, C ++, C, JavaScript) предоставят само минимална или дори никаква поддръжка за графики в ядрото или стандартните библиотеки. Така че ще трябва да използвате външна библиотека, за да можете да правите графики, например Pygame за Python.

Дори с графична библиотека ще трябва да се притеснявате за неща като как да покажете меню, как да проверите какво е щракнал плейърът, как да покажете плочките и т.н. Ако предпочитате да се съсредоточите върху разработването на действителната игра, можете да използвате библиотека с двигател за игри като Unity, която лесно реализира тези неща

Тази статия ще използва Python с Cocos2D, за да покаже как да направите прост 2D платформер. Някои от споменатите концепции може да не съществуват в други двигатели за игри. Обърнете се към тяхната документация за повече информация.

Стъпка 2. Инсталирайте избраната от вас графична библиотека

Cocos2D за Python е лесен за инсталиране. Можете да го получите от https://python.cocos2d.org/index.html или като изпълните sudo pip3 install cocos2d, ако използвате Linux.

Стъпка 3. Направете нова директория за вашата игра и медии

Ще използвате неща като изображения и звуци в играта си. Съхранявайте тези неща в същата директория като програмата. Тази директория не трябва да съдържа нищо друго, за да можете лесно да видите какви активи имате в играта.

Стъпка 4. Създайте нов кодов файл в новата директория

Наречете го основно, с разширението на файла за вашия език за програмиране. Ако пишете голяма и сложна програма, където има смисъл да имате множество програмни файлове, това ще ви покаже кой е основният файл.

В този пример ще създадем файл, наречен main.py, който ще съдържа целия ни код

Стъпка 5. Създайте прозореца на играта

Това е основната предпоставка за игра с графика.

Импортирайте необходимите подмодули cocos2d: cocos.director, cocos.scene и cocos.layer. Това се прави с импортиране на subModuleName *, където името на подмодула е подмодулът, който искате да импортирате. Разликата между от … import * и import … е, че не е нужно да поставяте името на модула пред всичко, което използвате от този модул с първия.
Определете подклас MainMenuBgr на ColorLayer. Това основно означава, че всеки фон на основното меню, който създавате, ще се държи като цветен слой с някои промени, които правите.
Стартирайте кокосовия директор. Това ще ви даде нов прозорец. Ако не зададете надпис, прозорецът ще има същия надпис като името на файла (main.py), което няма да изглежда професионално. Позволете на прозореца да бъде преоразмерен, като зададете resizible на True.
Определете функция showMainMenu. Трябва да поставите кода за показване на главното меню във функция, защото това ще ви позволи лесно да се върнете в главното меню, като извикате функцията отново.
Създайте сцена. Сцената засега се състои от един слой, който е обект на определения от вас клас MainMenuBgr.
Пуснете тази сцена в прозореца.

от cocos.director import * от cocos.scene import * от 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 - прост платформер", с преоразмеряване = True) showMainMenu ()

Стъпка 6. Добавете главно меню към прозореца

Освен действителната игра, ще трябва да добавите меню, което играчът може да използва, за да затвори прозореца, наред с други елементи, които можете да добавите по -късно.

Импортирайте cocos.menu (отново с инструкцията from) и pyglet.app (този път с import).
Определете MainMenu като подклас на Меню.
Задайте подравняване на главното меню. Трябва да зададете вертикално и хоризонтално подравняване отделно.
Създайте списък с елементи от менюто и ги добавете към менюто. Трябва да имате най -малко елементите от менюто „Старт на играта“и „Изход“. Всеки елемент от менюто трябва да бъде поставен в скоби. Всеки елемент трябва да има етикет и функция за обратно повикване, която определя какво се случва, когато плейърът кликне върху него. За елемента „Старт игра“използвайте функцията startGame (скоро ще го напишете), за елемента „Изход“използвайте „pyglet.app.exit“(вече съществува). Създайте действителното меню, като извикате self.create_menu (menuItems).
Определете startGame (). Просто поставете пропуск в дефиницията засега, ще го замените, когато пишете действителната игра.
Отидете на мястото във вашия код, където сте създали менюSc сцената, и добавете към нея обект MainMenu.

Целият ви код сега трябва да изглежда така:

от cocos.director import * от cocos.menu импортиране * от cocos.scene внос * от cocos.layer внос * импортиране pyglet.app клас MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) class MainMenu (Menu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Старт на играта" ", 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 - прост платформер", с преоразмеряване = True) showMainMenu ()

Стъпка 7. Тествайте кода си

Тествайте кода рано, докато все още е кратък и сравнително прост. След това можете да идентифицирате и коригирате всички грешки в основната структура, преди нещата да станат твърде сложни.

Кодът от инструкциите трябва да отвори прозорец с надпис „IcyPlat - прост платформер“. Фонът е светло син и можете да промените размера на прозореца. Когато кликнете върху „Стартиране на играта“в менюто, нищо не трябва да се случи (все още). Когато кликнете върху „Quit“, прозорецът ще се затвори

Стъпка 8. Създайте спрайт

Спрайт е „игрален обект“или двуизмерно изображение. Спрайтовете могат да бъдат обекти в играта, икони, фонови декорации, герои и всичко друго, което можете да представите с изображение в играта. Ще започнем със създаването на спрайт за герой, с който играчът може да взаимодейства.

Импортирайте подмодула cocos.sprite с израза from-import.
Намерете изображение, което да представлява спрайта. Не можете да покажете спрайт, ако нямате снимка за него. Можете да нарисувате такъв или да го получите от интернет (все пак внимавайте за лицензите, ако планирате да публикувате играта си). За този пример отидете на https://opengameart.org/content/tux-classic-hero-style и запазете-p.webp" />
Създайте слой като нов обект от класа ScrollableLayer. След това създайте спрайта като Sprite обект и задайте позицията му на (8, 250). За справка, точката (0, 0) е в долния ляв ъгъл. Това е доста високо, но ще се погрижи пингвинът да не се забие в леда.
Добавете спрайта към слоя на спрайта.
Създайте нова сцена от слоя на спрайта и я стартирайте.

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

Пуснете кода. Трябва да видите малка фигурка на пингвин (или каквото и да сте нарисували) на черен фон, след като щракнете Започни игра.

Стъпка 9. Измислете своя пейзаж

В повечето игри вашите спрайтове не трябва просто да се носят в празнотата. Те всъщност трябва да стоят на някаква повърхност, с нещо около тях. В 2D игрите това често се прави с набор от плочки и карта с плочки. Комплектът плочки основно казва какъв вид повърхностни квадрати и квадратни фонове съществуват и как изглеждат.

Създайте набор от плочки. Комплектът плочки за тази игра ще бъде много основен: една плочка за лед и една плочка за небе. Ледената плочка, използвана в този пример, е от тук, под CC-BY-SA 3.0.
Създайте картина с набор от плочки. Това е снимка на всички плочки, които трябва да са с еднакъв размер (редактирайте ги, ако не са) и да имат размера, който искате да видите в играта, един до друг. Запазете снимката си като icyTiles.png.
Създайте описание на набора плочки. Това е XML файл. XML файлът съдържа информация за това колко големи са плочките в картината с набор от плочки, коя картина да се използва и къде да се намери коя плочка там. Създайте XML файл с име icyTiles.xml с кода по -долу:
```
     
```

Стъпка 10. Направете карта с плочки за вашия пейзаж

Карта с плочки е карта, която определя коя плочка е на кое място във вашето ниво. В примера трябва да дефинирате функция за генериране на карти с плочки, защото ръчното проектиране на карти с плочки е много досадно. Една по -напреднала игра обикновено би имала някакъв редактор на нива, но за да се запознаете с разработката на 2D игри, алгоритъм може да осигури достатъчно добри нива.

Разберете колко редове и колони са необходими. За целта разделете размера на екрана на размера на плочките хоризонтално (колони) и вертикално (редове). Закръглете числото нагоре; имате нужда от функция на математическия модул за това, така че добавете от тавана за математически импорти към импортирането в горната част на кода си.
Отворете файл за писане. Това ще изтрие цялото предишно съдържание на файла, така че изберете име, което все още няма файл в директорията, като levelMap.xml.
Запишете началните маркери във файла.
Генерирайте карта с плочки според алгоритъма. Използвате този в кода по -долу или можете да го измислите сами. Не забравяйте да импортирате функцията randint от модула на случаен принцип: това е необходимо, за да работи кодът по -долу, и каквото и да измислите, вероятно също ще се нуждае от случайни цели числа. Също така не забравяйте да поставите небесни плочки и ледени плочки в различни слоеве: ледът е твърд, небето не.
Запишете затварящите тагове във файла и затворете файла.

def generateTilemap (): colAmount = ceil (800/16) * 3 # (ширина на екрана / размер на плочките) * 3 rowAmount = таван (600 /16) # височина на екрана / размер на плочки tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) за i в обхват (0, colAmount): tileFile.write ('') makeHole = False, ако randint (0, 50) == 10 и i! = 0: # не позволявайте дупки в точката на хвърляне makeHole = True за j в диапазон (0, rowAmount): if makeHole: tileFile.write ('\ n') else: if j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5), ако iceHeight <0: # ограничава плочките да не са твърде ниски iceHeight = randint (1, 5) if iceHeight> rowAmount: # ограничение на плочките да не са твърде високи iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') за i в диапазон (0, colAmount): tileFile.write ('') за j в диапазон (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Стъпка 11. Покажете картата с плочки

Импортирайте всичко от cocos.tiles и след това отидете във функцията startGame за това.

В началото на вашата функция startGame генерирайте карта с плочки, като използвате функцията, която сте определили за това.
Създайте нов мениджър за превъртане. Направете това директно под линията, където добавяте спрайта към неговия слой.
Създайте нов слой, съдържащ плочките, който ще бъде зареден от картата с плочки levelMap.xml, генерирана от функцията ви geneTilemap.
Добавете несъвършения слой, плътния слой и слоя спрайт към мениджъра за превъртане, точно в този ред. Можете да добавите z-позиция, ако искате.
Вместо да създавате сцената от слоя спрайт, създайте я от мениджъра за превъртане.

Вашата функция startGame сега трябва да изглежда така:

def startGame (): generatedTilemap () # 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 = Сцена (scrMang) director.run (gameSc)

Стъпка 12. Тествайте кода си

Трябва да тествате кода си често, за да се уверите, че новите функции, които сте внедрили, наистина работят.

Кодът в примера сега трябва да показва леден пейзаж зад пингвина. Ако пингвинът изглежда сякаш виси далеч над леда, не сте направили нищо лошо и ще бъде поправено в следващата стъпка

Стъпка 13. Добавете контролите

Играчът има много повече начини да взаимодейства с програмата в 2D игра, отколкото в текстово базирана игра. Често срещан включва преместването на фигурата им при натискане на правилния клавиш.

Импортирайте всичко от cocos.mapcolliders и от cocos.actions. Също така импортирайте ключ от pyglet.window.
„Декларирайте“някои глобални променливи. Глобалните променливи се споделят между функциите. Всъщност не можете да декларирате променливи в Python, но трябва да кажете, че глобална променлива съществува в основния код, преди да я използвате. Можете да зададете 0 като стойност, защото функция ще се погрижи за присвояването на правилната стойност по -късно. Затова добавете под изразите за импортиране:
```
# "деклариране" на глобални променливи клавиатура = 0 scrMang = 0
```
Регулирайте функцията startGame:
- Кажете, че използвате глобалната променлива клавиатура и scrMang. Направете това, като напишете глобална клавиатура, scrMang в горната част на функцията.
- Накарайте прозореца да слуша събития от клавиатурата.
- Кажете на фигурата да действа въз основа на PlatformerController. Скоро ще внедрите този PlatformerController.
- Създайте сблъсък на карта, за да се справите с сблъсъци между плътните плочки и фигурата.
```
def startGame (): глобална клавиатура, scrMang generatedTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml ') solidTiles = tileLayer [' solid '] nsoliTiles = tileLayer [' not_solid '] # клавиатура = key. KeyStateHandler () director.window.push_handlers (клавиатура) # fig.do (PlatformerController ()) mapcollider = RectMapCollider = 'слайд') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLay 1) # gameSc = Сцена (scrMang) director.run (gameSc)
```
Създайте платформен контролер. Това е, което ще премести фигурата според вашите клавиши.
- Определете контролера на платформата като подклас на действие.
- Определете скоростта на движение, скоростта на скок и гравитацията.
- Определете стартовата функция. Тази функция се извиква веднъж, когато контролерът на платформата е свързан към фигурата. Той трябва да зададе скоростта си на 0 както в посока x, така и в посока y.
- Определете стъпковата функция. Това ще се повтори, докато сцената работи.
- Кажете на стъпковата функция да използва клавиатурата на глобалните променливи и scrMang.
- Вземете и променете скоростта. Запазете скоростта x и y в отделни променливи. Задайте скоростта x на 1 или -1 (в зависимост от това дали е натиснат левия или десния клавиш), умножена по скоростта на движение. Добавете гравитацията към скоростта y. Умножете го с престой, така че да работи по същия начин на по -бавни устройства. Ако бутонът за интервал е натиснат и фигурата стои на земята, скочете, като промените y скоростта, за да скочите скоростта.
- Изчислете до къде трябва да се премести фигурата. След това оставете манипулатора на сблъсък да коригира тази позиция, ако е вътре в плътна плочка. Накрая преместете фигурата в новото коригирано положение.
- Задайте фокуса на мениджъра за превъртане върху фигурата. Това кара камерата да се движи по разумен начин, когато фигурата се движи.
```
клас PlatformerController (действие): глобална клавиатура, 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, скролер, ако dt> 0.1: # не правете нищо, докато престой до голямо връщане vx, vy = self.target.velocity vx = (клавиатура [key. RIGHT] - клавиатура [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt, ако self.on_ground и клавиатура [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 (последен, нов, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (*new.center)
```

Стъпка 14. Тествайте кода си

Ако сте последвали примера, сега би трябвало да можете да преместите пингвина с клавишите със стрелки и да скочите, като натиснете интервала. Също така, пингвинът сега трябва да падне, вместо да виси над земята.

Стъпка 15. Създайте завършек за играта

Дори игрите, които могат да продължават безкрайно, трябва да имат възможност за загуба. Тъй като нивото, което сте направили в примера с функция, има край, вие също ще трябва да направите възможно да спечелите, като стигнете до този край. В противен случай играчът би скачал само по ледените блокове там, което би станало скучно.

Вътре в контролера на платформера, след зададения фокус, вземете позицията x и y на фигурата. Ако позицията y е по -малка от 0, извикайте функцията finishGame () (ще я напишете по -късно) с "Game Over" като аргумент. Ако позицията x е по -голяма от размера на екрана, умножен с 3 (преди това сте го задали като размер на ниво).
```
posX, posY = self.target.position if posY <0: finishGame ("Game Over") връщане, ако posX> 800*3: # ниво на завършванеGame ("Level Completed") връщане
```
Определете клас finishMenu. Той трябва да е като основния клас меню, който сте дефинирали преди, но вместо да има празен низ като заглавие, той трябва да използва променлив текст, който функцията _init_ приема като аргумент. Елементите от менюто трябва да бъдат означени с „Опитайте отново“и „Излез“сега, но функциите, които наричат, остават същите.
```
class FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Опитайте отново", startGame)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems)
```
Определете функцията finishGame (). Трябва да приема текст като аргумент. Той трябва да направи сцена от фона на главното меню, FinishMenu с текстов аргумент, който се предава на това меню. След това трябва да стартира тази сцена.
```
def finishGame (текст): menuSc = Сцена (MainMenuBgr ()) menuSc.add (FinishMenu (текст)) director.run (menuSc)
```

Стъпка 16. Добавете кредити

Тук можете да вземете кредит за страхотния си код, както и да дадете кредит на всеки друг, който ви е помогнал по пътя. Ако сте използвали изображение от друг уебсайт (с разрешение), не забравяйте да приписвате това изображение на създателя му.

Създайте файл КРЕДИТИ и въведете всички кредити там, по следния начин:
```
Пингвин: Kelvin Shadewing, под CC0 Ice block: Michał Banas digit1024 на opengameart.org под CC-BY-SA 3.0
```
Върнете се към вашия код на Python и импортирайте Label от cocos.text.

Определете подклас Кредити на слой. Във функцията _init_ прочетете файла CREDITS и направете текстов етикет на правилната позиция от всеки ред в него.

class Credits (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") за i в обхват (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)

Отидете в основния си клас меню и добавете елемент от менюто с надпис „Credits“, който извиква функцията showCredits при щракване.
Определете подклас BackToMainMenuButton на Menu. Направете това меню с един елемент, обозначен с „Назад“, който извиква функцията showMainMenu. Това "меню", което е по -скоро като бутон, трябва да бъде вертикално подравнено до дъното и хоризонтално отгоре.
```
class BackToMainMenuButton (Menu): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = НАЛЯВО menuItems = [(MenuItem ("Назад", showMainMenu))] self. create_menu (елементи от менюто)
```
Определете функцията showCredits. Той трябва да направи сцена от слой MainMenuBgr и слой Credits и да стартира тази сцена.
```
def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)
```

Стъпка 17. Проверете кода си

Когато мислите, че сте завършили кода си, трябва да го прегледате отново. Това може да ви помогне да забележите дали нещо може да бъде оптимизирано или има някои ненужни редове, които сте забравили да изтриете. Ако сте последвали примера, целият ви код сега трябва да изглежда така:

от cocos.director внос * от cocos.menu внос * от cocos.scene внос * от cocos.layer внос * от cocos.sprite внос * от cocos.tiles внос * от cocos.mapcolliders внос * от cocos.actions внос * от кокос.text import Label импортиране pyglet.app от pyglet.window ключ за импортиране от математически импорт таван от произволен импорт randint # "деклариране" глобални променливи клавиатура = 0 scrMang = 0 клас 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) клас Кредити (слой): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n") за i в обхвата (0, len (creds)): credLabel = Етикет (creds , font_size = 32, anchor_x = "left", anchor_y = "top") credLabel.position = 25, 500- (i+1)*40 self.add (credLabel) клас BackToMainMenuButton (Меню): def _init _ (self): супер (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self.create_menu (menuItems) клас FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Опитайте отново", startGame)), (MenuItem ("Изход", пиглет. app.exit))] self.create_menu (menuItems) клас PlatformerController (действие): глобална клавиатура, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (self, dt): глобална клавиатура, превъртане, ако dt> 0.1: # не правете нищо, докато престоят е твърде голям return vx, vy = self.target.velocity vx = (keyboard [key. RIGHT] - клавиатура [key. LEFT]) * self. MOVE_SPEED vy += self. GRAVITY * dt, ако self.on _ground и клавиатура [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 (последен, нов, 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") връщане, ако posX> 800*3: # ниво размер finishGame ("Ниво завършено") return def finishGame (текст): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (текст)) director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc) def createTilemap (): colAmount = ceil (800/16) * 3 # (ширина на екрана / размер на плочките) * 3 rowAmount = таван (600 /16) # височина на екрана / размер на плочкиFile = отворен ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) за i в диапазон (0, colAmount): tileFile.write ('') makeHole = False if rand int (0, 50) == 10 и i! = 0: # не допускайте дупки в точката на хвърляне makeHole = True за j в диапазон (0, rowAmount): if makeHole: tileFile.write ('\ n') else: if j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5), ако iceHeight <0: # ограничаване на плочките ниска iceHeight = randint (1, 5), ако iceHeight> rowAmount: # ограничаване на плочките от прекалено висок iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') за i в обхват (0, colAmount): tileFile.write (' ') за j в диапазон (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): глобална клавиатура, scrMang generatedTilemap () # 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, add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc) def showMainMenu (): menuSc = Scene (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) window = director.init (caption = "IcyPlat - прост платформер", с преоразмеряване = True) showMainMenu ()

Това са общо 168 реда и 152 реда, ако броите само кода. Това изглежда като много, но за такава сложна игра това всъщност е малка сума.

Стъпка 18. Готово

Сега тествайте играта. Когато програмирате нещо, трябва да проверите дали работи, когато сте внедрили нещо ново. Също така може да искате да играете играта, която сте написали за известно време.

Част 3 от 3: Публикуване на игра

Стъпка 1. Запишете зависимости

Всеки, който използва друг компютър, няма да има същия софтуер и библиотеки, инсталирани като вас. Така че ще трябва да се уверите, че всеки, който инсталира вашата игра, знае точно какво ще е необходимо за стартирането й. Не е нужно да записвате всички зависимости на всички зависимости на всички зависимости и така нататък, но поне трябва да напишете зависимостите на вашите пакети и техните зависимости.

Стъпка 2. Уверете се, че имате разрешение да използвате всички носители

Това се отнася за всички графики, включително 3D модели, музика, диалог, музика, библиотеки и рамки, които сте използвали за вашата игра. Всичко, което не сте написали сами.

Често има някои условия, като например да се налага кредитиране на автора или споделяне на модификации на медиите под същия лиценз. Понякога ще можете да използвате графики, без да приписвате създателите, стига да не таксувате играта. Ако трябва да кредитирате автора, направете го на добре видимо място, като например раздел „Кредити“във вашата игра.
Има и медии със заявени авторски права и без посочен лиценз, понякога с текст като „Всички права запазени“. Ако случаят е такъв, трябва да получите изрично разрешение от автора, преди да го включите в играта си.
Библиотеките обикновено се издават под лицензи, които им позволяват да се използват като библиотеки. Забележително изключение е GPL без изключение за свързване: Такъв лиценз позволява само да се използва в програма с определени лицензи. Винаги трябва да прочетете поне основните точки на лиценза, за да сте сигурни, че всичко, което правите с медиите или библиотеката, е позволено.

Внимание: Използването на медии или библиотеки по начин, който лицензът не позволява в игра, която публикувате, може да ви вкара в сериозни правни проблеми. Така че или попитайте автора, или избягвайте изцяло медията, ако не сте сигурни дали използването ви е разрешено.

Стъпка 3. Решете условията, на които искате да публикувате играта си

Ще продавате ли играта си? Искате ли да позволите на другите да използват вашите изображения и идеи? Въпреки че трябва да внимавате за медиите, които използвате в проекта си, обикновено можете да решите как искате да позволите на другите да използват вашата игра. Можете да използвате лиценз Creative Commons CC0, за да пуснете играта си в публичното пространство. За да разрешите разпространение и промяна при някои условия, като запазите някои права, опитайте лиценза Gnu General Public License (GPL) или Berkeley Software Distribution (BSD). Или можете да направите софтуера си патентован, което означава, че никой няма право да го разпространява или променя без ваше разрешение.

Въпреки че е възможно да печелите пари от продажба на игри, малко вероятно е хората да купят първата ви игра, която обикновено има малко функции и нищо особено. Също така, ако безплатна програма не работи, хората, които са я изтеглили, просто ще бъдат разочаровани. Ако обаче са платили за това, те ще поискат парите си обратно, причинявайки повече проблеми както на вас, така и на потребителите. Затова помислете дали да направите първите си няколко програми достъпни безплатно

Стъпка 4. Решете как искате да публикувате играта си

Всеки метод има някои предимства и недостатъци, така че трябва да решите сами.

Публикуването му на уебсайт:

Ако имате уебсайт, можете да качите играта си, за да я направите достъпна за изтегляне. Не забравяйте да предоставите ясни инструкции как да инсталирате софтуера, както и всички необходими зависимости. Недостатъкът на това е, че играчите ще трябва да инсталират зависимости ръчно, което може да е трудно за някои хора.
Изготвяне на пакет за мениджър на пакети:

Има различни мениджъри на пакети, като apt, Yum и Homebrew, които улесняват хората да инсталират приложения в Linux и Linux базирани среди. Всички те имат различни формати на пакети. Хубавото на пакетите е, че те автоматично инсталират всички зависимости (ако ги конфигурирате правилно). Така че играчът трябва само да инсталира вашия пакет и след това може да играе играта. Проблемът е, че има много различни мениджъри на пакети на различни платформи, така че ще трябва да положите малко усилия за предоставяне на пакети за всички най -често срещани.

Стъпка 5. Насочете вниманието към вашата програма

Помислете за качване на вашата програма в голямо хранилище на пакети, като тези, които поддържат Ubuntu и Debian, за да се даде възможност за лесни инсталации. Също така публикувайте в подходящи форуми, като секцията за проекти на GameDev или част от tigSource. Но не се разочаровайте, ако първите ви игри не станат известни. Ако имате идея, че много хора я харесват, играта ви може да стане добре позната.

Съвети

Бъдете търпеливи и готови да се научите. Програмирането понякога може да бъде разочароващо!
Ако се чудите как се прави нещо в друга игра и играта е с отворен код, можете да разгледате нейния изходен код.
Когато търсите медии, опитайте се да намерите съдържание, което е обществено достояние. Търсете изображения и музика от „Creative Commons“или „Public Domain“и използвайте уебсайтове като https://opengameart.org или
Не копирайте големи парчета код, без да проверявате лиценза. Често е забранено, а ако не, обикновено изисква приписване.
Не правете спам и не публикувайте на неподходящи места, когато популяризирате играта си. Това вероятно ще ви блокира от страницата, просто е досадно и ще навреди на репутацията ви.