Jak programovat počítačové hry (s obrázky)

2024 Autor: Robert Blare | [email protected]. Naposledy změněno: 2024-01-31 12:14

Máte nápad na počítačovou hru a chcete ji uskutečnit? Nebo vás někdy zajímalo, jak jsou psány počítačové hry? Tento wikiHow vás naučí psát tři základní počítačové hry v Pythonu. K vývoji první hry budete potřebovat základní znalosti Pythonu a obecné koncepce programování.

Kroky

Část 1 ze 3: Tvorba textové hry

Krok 1. Vyberte programovací jazyk

Všechny programovací jazyky jsou různé, takže se budete muset rozhodnout, který z nich použijete při psaní hry. Každý hlavní programovací jazyk podporuje zadávání textu, textový výstup a konstrukce if (hlavní věci, které potřebujete pro jednoduchou textovou hru), prozkoumejte tedy možnosti a rozhodněte se, ve kterém se cítíte nejpohodlněji a věnujete se učení. Zde je několik faktorů, které je třeba zvážit:

• K čemu se jazyk nejčastěji používá?

  Některé programovací jazyky, jako JavaScript, jsou navrženy pro použití na webu, zatímco jiné, jako Python, C nebo C ++, jsou navrženy pro spouštění počítačových programů. Pro svou hru si dejte za cíl jazyk s širším rozsahem použití, jako je Python, C, C ++ nebo JavaScript.

• Jak těžké je naučit se?

  Ačkoli psaní programu by mělo být po určité praxi v jakémkoli normálním programovacím jazyce (tj. Nikoli konkrétně navrženém jako matoucí jako Malbolge) dostatečně snadné, některé jsou pro začátečníky přívětivější než jiné. Například Java a C budou vyžadovat, abyste porozuměli hlubším konceptům programování než něco jako Python, který je známý svou přístupnější a přímočařejší syntaxí.

• Kde jej mohu použít?

  Pravděpodobně chcete, aby vaši hru mohli hrát lidé z různých systémů, jako je Linux, Mac nebo Windows. Neměli byste tedy používat jazyk, který je podporován pouze na několika systémech, například Visual Basic, který je podporován pouze ve Windows.

Tento článek bude používat Python pro příklady textové hry, ale můžete se podívat, jak jsou koncepty prováděny v jakémkoli jiném programovacím jazyce.

Krok 2. Připravte si počítač

Dvě hlavní součásti, které budete potřebovat, jsou textový editor, ve kterém napíšete kód, a kompilátor, pomocí kterého z něj uděláte hru. Pokud se chcete řídit příkladem v tomto článku, měli byste si nainstalovat Python a naučit se spouštět programy. Pokud chcete, můžete nastavit IDE (Integraded Desktop Environment), které kombinuje úpravy, kompilace a ladění do jednoho programu. IDE v Pythonu se nazývá IDLE. Můžete ale také použít libovolný textový editor, který podporuje prostý text, například Poznámkový blok pro Windows, TextEdit pro macOS nebo Vim pro Linux.

Krok 3. Napište nějaký kód, kterým hráče pozdravíte

Hráč bude chtít vědět, co se děje a co má dělat, takže byste mu měli vytisknout nějaký text.

• To se provádí pomocí funkce print () v Pythonu. Chcete -li to vyzkoušet, otevřete nový soubor s příponou.py, zadejte do něj následující kód, uložte jej a spusťte:

  tisk („Vítejte ve hře na hádání čísel!“) tisk („Zadejte celé číslo od 1 do 1 000:“)
  

Krok 4. Vygenerujte náhodné číslo

Pojďme vytvořit textovou hru, která hráče vyzve, aby uhádl správné číslo. První věc, kterou musíme udělat, je vygenerovat náhodné číslo na začátku hry, aby hráč vždy nehádal stejné číslo. Protože číslo zůstane v celém programu stejné, budete chtít uložit náhodné číslo do proměnné.

• Python nemá vestavěnou funkci náhodných čísel, ale má standardní knihovnu (to znamená, že uživatel nebude muset instalovat nic navíc), která ano. Přejděte tedy na začátek kódu (před funkce print ()) a zadejte náhodný import řádku.

• Použijte náhodnou funkci. Říká se tomu randint (), je v náhodné knihovně, kterou jste právě importovali, a bere jako argument minimální a maximální hodnotu, kterou číslo může mít. Vraťte se tedy na konec kódu a zadejte následující řádek:

  rightNum = random.randint (0, 1000)
  

Krok 5. Získejte vstup od hráče

Ve hře chce hráč něco udělat nebo s něčím komunikovat. V textové hře je to možné zadáním textu. Nyní, když máme náhodné číslo, by naše další řádky kódu měly hráče požádat, aby zadal svůj nejlepší odhad.

• Vzhledem k tomu, že vámi zadaný kód vytiskne pokyn k zadání čísla hráči, měl by také přečíst číslo, které zadá. To se provádí pomocí input () v Pythonu 3 a raw_input () v Pythonu 2. Měli byste psát v Pythonu 3, protože Python 2 bude brzy zastaralý. Chcete -li uložit vstup hráče do proměnné s názvem číslo, přidejte do kódu následující řádek:

  userNum = vstup ()
  

Krok 6. Proměňte vstup hráče na použitelný datový typ

Hráč zadal číslo-co teď?

• Udělejte ze vstupu hráče číslo. Může to znít zmateně, protože právě zadali číslo. Existuje však dobrý důvod: Python předpokládá, že veškerý vstup je text nebo „řetězec“, jak se tomu říká v programování. Tento text obsahuje číslo, které chcete získat. Python má funkci, která převádí řetězec, který obsahuje pouze číslo na číslo uvnitř. Typ:

  userNum = int (userNum)
  

Krok 7. Porovnejte číslo hráče se správným číslem

Jakmile hráč zadá své číslo, budete jej muset porovnat s tím, které bylo náhodně vygenerováno. Pokud čísla nejsou stejná, vaše hra může hráče přimět vyzkoušet jiné číslo. Pokud se čísla shodují, můžete hráči říci, že uhodli správně, a ukončit program. To se provádí pomocí následujícího kódu:

zatímco userNum! = rightNum: userNum = int (input ())

Krok 8. Poskytněte hráči zpětnou vazbu

Přestože jste již zpracovali jejich zadání, hráč to neuvidí. Výsledky budete muset hráči skutečně vytisknout, aby pochopili, co se děje.

• Jistě byste mohli hráči jen říci, zda je jeho číslo správné nebo špatné. Ale s tímto přístupem by hráč musel v nejhorším případě hádat 1000krát, což by bylo velmi nudné.
• Řekněte tedy hráči, zda je jejich počet příliš malý nebo příliš velký. Tím se jejich počet odhadů výrazně sníží. Pokud například hráč uhodne 500 nejprve a hra odpoví „Příliš velký. Zkuste to znovu“, místo 1000 bude pouze 500 možných čísel. To se provádí pomocí konstrukcí if-if, proto nahraďte tisk („Špatně. Zkuste to znovu. “) S jedním.
• Uvědomte si, že kontrola, zda jsou dvě čísla stejná, se provádí pomocí ==, nikoli pomocí =. = přiřadí hodnotu vpravo k proměnné vlevo!

if userNum <rightNum: print ("Too small. Try again:") if userNum> rightNum: print ("Too big. Try again:")

Krok 9. Otestujte svůj kód

Jako programátor byste si měli být jisti, že váš kód funguje, než ho považujete za dokončený.

• Při programování v pythonu se ujistěte, že máte správné odsazení. Váš kód by měl vypadat takto:

  import náhodného tisku („Vítejte v hře na hádání čísel!“) tisk („Zadejte celé číslo od 1 do 1000:“) rightNum = random.randint (0, 1000) userNum = vstup () userNum = int (userNum) zatímco userNum! = rightNum: if userNum <rightNum: print ("Too small. Try again:") if userNum> rightNum: print ("Too big. Try again:") userNum = int (input ()) print ("uhádli jste správně.")
  

Krok 10. Ověřte zadání

Hráč by neměl být schopen přerušit vaši hru prostým zadáním špatné věci. „Ověření zadání“znamená zajistit, aby hráč před zpracováním zadal správnou věc.

• Znovu otevřete hru a zkuste zadat cokoli, co není číslo. Hra skončí s ValueError. Abyste tomu zabránili, můžete implementovat způsob, jak zkontrolovat, zda zadané číslo bylo číslo.
• Definujte funkci. Protože ověřování vstupu je poměrně dlouhé a musíte to udělat několikrát, měli byste definovat funkci. Nevyžaduje žádné argumenty a vrátí číslo. Nejprve napište def numInput (): do horní části kódu, přímo pod náhodný import.
• Získejte vstup hráče jednou. Použijte funkci input () a přiřaďte výsledek proměnné inp.
• Pokud hráč nezadá číslo, požádejte ho o zadání čísla. Chcete -li zkontrolovat, zda je řetězec číslo, použijte funkce isdigit (), které umožňují pouze celé číslo, takže je nebudete muset kontrolovat samostatně.
• Pokud je vstup číslo, převeďte ho z řetězce na číslo a vraťte výsledek. K převodu řetězce na celé číslo použijte funkci int (). Díky tomu nebude konverze v hlavním kódu zbytečná a měli byste ji odtud odebrat.
• Nahradit všechna volání input () v hlavním kódu voláními numInput ().
• Kód funkce numInput () bude vypadat takto:

def numInput (): inp = input () while not inp.isdigit (): print ("Bylo vám řečeno, abyste zadali celé číslo! Zadejte celé číslo:") inp = input () return int (inp)

Krok 11. Znovu otestujte hru

Úmyslně zadejte špatné věci, abyste viděli, co se stane, a poté opravte všechny chyby, jakmile se objeví.

Až vás program vyzve k zadání čísla, zkuste zadat nějaký text. Nyní místo ukončení s chybovou zprávou vás program znovu požádá o číslo

Krok 12. Navrhněte restart hry, až skončí

Hráč tak mohl hrát vaši hru delší dobu, aniž by ji musel neustále restartovat.

• Vložte veškerý kód kromě importu a definice funkce do cyklu while. Jako podmínku nastavte True: toto bude vždy platit, takže smyčka bude pokračovat navždy.
• Po správném uhodnutí čísla se hráče zeptejte, zda chce hrát znovu. Použijte funkci print ().
• Pokud odpoví „Ne“, vypadněte z očí. Pokud odpoví na cokoli jiného, pokračujte. Vylomení smyčky se provádí pomocí příkazu break.
• Přesuňte „Vítejte v hře na hádání čísel“mimo smyčku while. Hráč pravděpodobně nechce být vítán pokaždé, když hru hraje. Přesuňte instrukční tisk („Vítejte v hře s hádáním čísel!“Nad while True:, takže se vytiskne pouze jednou, když uživatel spustí první hru.

Krok 13. Otestujte hru

Svou hru budete muset vyzkoušet pokaždé, když implementujete novou funkci.

• Ujistěte se, že jste alespoň jednou odpověděli „Ano“i „Ne“, abyste se ujistili, že obě možnosti fungují. Zde by měl vypadat váš kód:

  import random def numInput (): inp = input () while not inp.isdigit (): print ("Bylo vám řečeno, abyste zadali celé číslo! Zadejte celé číslo:") inp = vstup () return int (inp) tisk („Vítejte ve hře na hádání čísel!“) Při True: print („Zadejte celé číslo mezi 1 a 1000:“) rightNum = random.randint (0, 1000) userNum = numInput () while userNum! = RightNum: if userNum <rightNum: print ("Too small. Try again:") if userNum> rightNum: print ("Too big. Try again:") userNum = numInput () print ("Uhádli jste správně.") print ("Do you chcete hrát znovu? Chcete -li skončit, zadejte Ne. ") if input () ==" No ": break
  

Krok 14. Napište další textové hry

Co takhle napsat textovou adventuru příště? Nebo kvízová hra? Být kreativní.

Spropitné: Někdy je užitečné nahlédnout do dokumentace, pokud si nejste jisti, jak se něco dělá nebo jak se používá funkce. Dokumentaci k Pythonu 3 najdete na https://docs.python.org/3/. Dobré výsledky někdy přináší i vyhledávání čehokoli, co chcete na internetu dělat.

Část 2 ze 3: Tvorba hry s 2D grafikou

Krok 1. Vyberte grafickou knihovnu

Vytváření grafiky je velmi komplikované a většina programovacích jazyků (včetně Pythonu, C ++, C, JavaScriptu) poskytuje pouze minimální nebo dokonce žádnou podporu grafiky v jádru nebo ve standardních knihovnách. Budete tedy muset použít externí knihovnu, abyste mohli vytvářet grafiku, například Pygame pro Python.

I s grafickou knihovnou si budete muset lámat hlavu s tím, jak zobrazit nabídku, jak zkontrolovat, na co hráč klikl, jak zobrazit dlaždice atd. Pokud byste se raději soustředili na vývoj skutečné hry, můžete použít knihovnu herních motorů, jako je Unity, která tyto věci snadno implementuje

Tento článek pomocí Pythonu s Cocos2D ukáže, jak vytvořit jednoduchou 2D plošinovku. Některé ze zmíněných konceptů nemusí existovat v jiných herních motorech. Další informace najdete v jejich dokumentaci.

Krok 2. Nainstalujte si zvolenou grafickou knihovnu

Cocos2D pro Python se snadno instaluje. Můžete jej získat z https://python.cocos2d.org/index.html, nebo spuštěním sudo pip3 install cocos2d, pokud používáte Linux.

Krok 3. Vytvořte nový adresář pro vaši hru a média

Ve hře budete používat věci jako obrázky a zvuky. Uchovávejte tyto věci ve stejném adresáři jako program. Tento adresář by neměl obsahovat nic jiného, abyste mohli snadno vidět, jaké prostředky ve hře máte.

Krok 4. Vytvořte nový soubor kódu v novém adresáři

Říkejte tomu hlavní s příponou souboru pro váš programovací jazyk. Pokud píšete velký a složitý program, kde má smysl mít více programových souborů, ukáže se vám, který je hlavní soubor.

V tomto příkladu vytvoříme soubor s názvem main.py, který bude obsahovat veškerý náš kód

Krok 5. Vytvořte herní okno

To je základní předpoklad pro hru s grafikou.

• Importujte potřebné dílčí moduly cocos2d: cocos.director, cocos.scene a cocos.layer. To se provádí pomocí importu subModuleName *, kde název submodulu je submodul, který chcete importovat. Rozdíl mezi … import * a import … je ten, že nemusíte dávat název modulu před vše, co používáte z toho modulu s prvním modulem.
• Definujte podtřídu MainMenuBgr ColorLayer. To v podstatě znamená, že jakékoli pozadí hlavní nabídky, které vytvoříte, se bude chovat jako barevná vrstva s některými provedenými změnami.
• Spusťte ředitele cocos. Tím získáte nové okno. Pokud nenastavíte titulek, okno bude mít stejný titulek jako název souboru (main.py), což nebude vypadat profesionálně. Povolte změnu velikosti okna nastavením změny velikosti na True.
• Definujte funkci showMainMenu. Kód pro zobrazení hlavní nabídky byste měli vložit do funkce, protože vám to umožní snadný návrat do hlavní nabídky opětovným voláním funkce.
• Vytvořte scénu. Scéna se prozatím skládá z jedné vrstvy, což je objekt třídy MainMenuBgr, kterou jste definovali.
• Spusťte tuto scénu v okně.

z cocos.director import * z cocos.scene import * z cocos.layer import * třída 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 ()

Krok 6. Přidejte do okna hlavní nabídku

Kromě samotné hry budete muset přidat nabídku, kterou může hráč použít k zavření okna, mezi další prvky, které můžete přidat později.

• Importujte cocos.menu (opět s instrukcí from) a pyglet.app (tentokrát s importem).
• Definujte MainMenu jako podtřídu Menu.
• Nastavte zarovnání hlavní nabídky. Svislé a vodorovné zarovnání musíte nastavit samostatně.
• Vytvořte seznam položek nabídky a přidejte je do nabídky. Měli byste mít přinejmenším položky nabídky „Zahájit hru“a „Ukončit“. Každá položka nabídky by měla být umístěna v závorkách. Každá položka musí mít štítek a funkci zpětného volání, která určuje, co se stane, když na ni hráč klikne. U položky „Start Game“použijte funkci startGame (brzy ji napíšete), u položky „Quit“použijte „pyglet.app.exit“(již existuje). Vytvořte aktuální nabídku voláním self.create_menu (menuItems).
• Definujte startGame (). Prozatím vložte definici, nahradíte ji při psaní skutečné hry.
• Přejděte na místo v kódu, kde jste vytvořili scénu menuSc, a přidejte do ní objekt MainMenu.

• Celý váš kód by nyní měl vypadat následovně:

  z cocos.director import * from cocos.menu import * from cocos.scene import * from cocos.layer import * import pyglet.app class MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) třída 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 - a simple platformer", resizable = True) showMainMenu ()
  

Krok 7. Otestujte svůj kód

Otestujte kód brzy, přestože je stále krátký a relativně jednoduchý. Poté můžete identifikovat a opravit všechny chyby v základní struktuře, než se věci příliš zkomplikují.

Kód z pokynů by měl otevřít okno s titulkem „IcyPlat - jednoduchá plošinovka“. Pozadí je světle modré a můžete změnit velikost okna. Když v nabídce kliknete na „Spustit hru“, nemělo by se (zatím) nic stát. Když kliknete na „Ukončit“, okno se zavře

Krok 8. Vytvořte sprite

Sprite je „herní objekt“nebo 2-dimenzionální obrázek. Skřítci mohou být objekty ve hře, ikony, dekorace na pozadí, postavy a cokoli jiného, co můžete ve hře reprezentovat obrázkem. Začneme vytvořením sprite pro postavu, se kterou může hráč komunikovat.

• Importujte submodul cocos.sprite s výrazem from-import-expression.
• Najděte obrázek, který bude představovat sprite. Nemůžete zobrazit sprite, pokud pro něj nemáte obrázek. Můžete si jednu nakreslit, nebo si ji můžete pořídit na internetu (pozor však na licence, pokud plánujete vydat svoji hru). V tomto případě přejděte na https://opengameart.org/content/tux-classic-hero-style a uložte obrázek-p.webp" />
• Vytvořte vrstvu jako nový objekt třídy ScrollableLayer. Poté vytvořte sprite jako objekt Sprite a nastavte jeho polohu na (8, 250). Pro informaci je bod (0, 0) v levém dolním rohu. To je docela vysoko, ale postará se o to, aby tučňák neuvízl v ledu.
• Přidejte sprite do vrstvy sprite.
• Vytvořte novou vrstvu z vrstvy sprite a spusťte ji.

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

• Spusťte kód. Po kliknutí byste na malém pozadí měli vidět malou tučňákovou figurku (nebo cokoli jste nakreslili) Začít hru.

Krok 9. Sníte o své krajině

Ve většině her by vaši skřítci neměli jen plavat v prázdnotě. Ve skutečnosti by měli stát na nějakém povrchu a mít něco kolem sebe. Ve 2D hrách se to často provádí pomocí sady dlaždic a mapy dlaždic. Sada dlaždic v podstatě říká, jaký druh čtverců povrchu a čtverců na pozadí existuje a jak vypadají.

• Vytvořte sadu dlaždic. Sada dlaždic pro tuto hru bude velmi základní: jedna dlaždice na led a jedna dlaždice na oblohu. Ledová destička použitá v tomto příkladu je odsud, pod CC-BY-SA 3.0.
• Vytvořte obrázek sady dlaždic. To je obrázek všech dlaždic, které musí mít všechny stejnou velikost (upravte je, pokud nejsou) a musí mít velikost, kterou chcete ve hře vidět, vedle sebe. Uložte obrázek jako icyTiles.png.

• Vytvořte popis sady dlaždic. To je soubor XML. Soubor XML obsahuje informace o tom, jak velké jsou dlaždice na obrázku sady dlaždic, který obrázek použít a kde najít dlaždici. Vytvořte soubor XML s názvem icyTiles.xml pomocí níže uvedeného kódu:

Krok 10. Vytvořte pro svou krajinu dlaždičkovou mapu

Dlaždičková mapa je mapa, která definuje, která dlaždice je na které pozici ve vaší úrovni. V tomto příkladu byste měli definovat funkci pro generování map dlaždic, protože ruční navrhování map dlaždic je velmi únavné. Pokročilejší hra by obvykle měla nějaký editor úrovní, ale aby se seznámil s vývojem 2D her, může algoritmus poskytnout dostatečně dobré úrovně.

• Zjistěte, kolik řádků a sloupců je potřeba. Za tímto účelem vydělte velikost obrazovky velikostí dlaždic horizontálně (sloupce) a vertikálně (řádky). Zaokrouhlete číslo nahoru; k tomu potřebujete funkci matematického modulu, takže přidejte z matematického importního stropu k importům v horní části kódu.
• Otevřete soubor pro zápis. Tím se smaže veškerý předchozí obsah souboru, proto zvolte název, který zatím žádný soubor v adresáři nemá, například levelMap.xml.
• Zapište úvodní značky do souboru.
• Vygenerujte mapu dlaždic podle algoritmu. Používáte ten v níže uvedeném kódu, nebo si na něj můžete přijít sami. Ujistěte se, že importujete funkci randint z modulu náhodně: je vyžadováno, aby níže uvedený kód fungoval, a cokoli, s čím přijdete, bude pravděpodobně také potřebovat náhodná celá čísla. Nezapomeňte také dát obklady a ledové kameny do různých vrstev: led je pevný, obloha ne.
• Zapište závěrečné značky do souboru a zavřete soubor.

def generateTilemap (): colAmount = ceil (800/16) * 3 # (šířka obrazovky / velikost dlaždice) * 3 rowAmount = ceil (600/16) # výška obrazovky / velikost dlaždice tileFile = otevřená ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) pro i v rozsahu (0, colAmount): tileFile.write ('') makeHole = False if randint (0, 50) == 10 a i! = 0: # nepovolit otvory v místě spawn makeHole = True pro j v rozsahu (0, rowAmount): if makeHole: tileFile.write ('\ n') else: if j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) if iceHeight <0: # limit dlaždic from too too low iceHeight = randint (1, 5) if iceHeight> rowAmount: # limit tiles from being too high iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') pro i v rozsahu (0, colAmount): tileFile.write ('') pro j v rozsahu (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Krok 11. Zobrazte mapu dlaždic

Importujte vše z cocos.tiles a poté přejděte do funkce startGame.

• Na začátku funkce startGame vygenerujte mapu dlaždic pomocí funkce, kterou jste pro to definovali.
• Vytvořte nového správce posouvání. Udělejte to přímo pod čarou, kde přidáte sprite do jeho vrstvy.
• Vytvořte novou vrstvu obsahující dlaždice, která se načte z mapy dlaždic levelMap.xml, kterou vygenerovala vaše funkce generateTilemap.
• Přidejte nepevnou vrstvu, plnou vrstvu a vrstvu sprite do správce posouvání, přesně v tomto pořadí. Pokud chcete, můžete přidat polohu z.
• Místo vytváření scény z vrstvy sprite ji vytvořte pomocí správce posouvání.

• Vaše funkce startGame by nyní měla vypadat takto:

  def startGame (): generateTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 500) figLayer = ScrollableLayer () figLayer.add (obr) # 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)
  

Krok 12. Otestujte svůj kód

Měli byste svůj kód často testovat, abyste se ujistili, že nové funkce, které jste implementovali, opravdu fungují.

Kód v příkladu by nyní měl ukazovat ledovou krajinu za tučňákem. Pokud tučňák vypadá, že se vznáší daleko nad ledem, neudělal jste nic špatného a v dalším kroku to bude opraveno

Krok 13. Přidejte ovládací prvky

Hráč má mnohem více způsobů interakce s programem ve 2D hře než v textové hře. K běžnému patří přesun jejich figury po stisknutí správné klávesy.

• Importujte vše z cocos.mapcolliders a from cocos.actions. Importujte také klíč z pyglet.window.

• „Deklarujte“některé globální proměnné. Globální proměnné jsou sdíleny mezi funkcemi. V Pythonu opravdu nemůžete deklarovat proměnné, ale musíte říci, že v hlavním kódu existuje globální proměnná, než ji použijete. Jako hodnotu můžete přiřadit 0, protože funkce se postará o přiřazení správné hodnoty později. Přidejte tedy pod výrazy importu:

  # "deklarování" globálních proměnných klávesnice = 0 scrMang = 0
  

• Upravte svou funkci startGame:

  • Řekněme, že používáte klávesnici globálních proměnných a scrMang. Udělejte to tak, že napíšete globální klávesnici, scrMang v horní části funkce.
  • Nechte okno poslouchat události klávesnice.
  • Řekněte obrázku, aby jednal na základě PlatformerController. Brzy implementujete tento PlatformerController.
  • Vytvořte mapový urychlovač, který zvládne kolize mezi plnými dlaždicemi a postavou.

  def startGame (): globální klávesnice, scrMang generateTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (obr) # tileLayer = načíst ('levelMap.xml ') solidTiles = tileLayer [' solid '] nsoliTiles = tileLayer [' not_solid '] # klávesnice = key. KeyStateHandler () director.window.push_handlers (klávesnice) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump = 'snímek') 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)
  

• Vytvořte řadič platformy. To bude pohybovat figurou podle vašich stisknutí kláves.

  • Definujte řadič plošinovky jako podtřídu akce.
  • Definujte rychlost pohybu, rychlost skoku a gravitaci.
  • Definujte funkci spuštění. Tato funkce se nazývá jednou, když je ovladač plošinovky připojen k obrázku. Mělo by nastavit jeho rychlost na 0 jak ve směru x, tak ve směru y.
  • Definujte krokovou funkci. Bude se to opakovat, zatímco scéna běží.
  • Řekněte funkci step, aby používala klávesnici globálních proměnných a scrMang.
  • Získejte a změňte rychlost. Uložte rychlost x a y do samostatných proměnných. Nastavte rychlost x na 1 nebo -1 (v závislosti na tom, zda byla stisknuta levá nebo pravá klávesa) vynásobená rychlostí pohybu. Přidejte k rychlosti y gravitaci. Znásobte to prostojem, aby to fungovalo stejně na pomalejších zařízeních. Pokud stisknete mezerník a postava stojí na zemi, přeskočte změnou rychlosti y na rychlost skoku.
  • Vypočítejte, kam by se měla postava přesunout. Poté nechejte obsluhu kolize upravit tuto pozici, pokud je uvnitř plné dlaždice. Nakonec přesuňte figurku do nové upravené polohy.
  • Nastavte zaměření správce posouvání na obrázek. To způsobí, že se kamera při pohybu postavy pohybuje přiměřeným způsobem.

  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 pokud dt> 0,1: # nedělejte nic, když jsou prostoje do velké návratnosti vx, vy = self.target.velocity vx = (klávesnice [key. RIGHT] - klávesnice [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground a klávesnice [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () new = last.copy () new.x += dx new.y += dy self.target.velocity = self.target.collision_handler (last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (*new.center)
  

Krok 14. Otestujte svůj kód

Pokud jste následovali příkladu, měli byste nyní tučňáka přesouvat pomocí kláves se šipkami a skákat stisknutím mezerníku. Také tučňák by nyní měl spadnout dolů, místo aby se vznášel nad zemí.

Krok 15. Vytvořte konec hry

I hry, které mohou pokračovat donekonečna, by měly mít možnost prohrát. Vzhledem k tomu, že úroveň, kterou jste v příkladu vytvořili s funkcí, má konec, budete také muset umožnit výhru tím, že se dostanete na tento konec. Jinak by tam hráč jen skákal po ledových blocích, což by byla nuda.

• Uvnitř ovladače plošinovky, po zaostření, získejte pozici x a y figury. Pokud je poloha y menší než 0, zavolejte funkci finishGame () (napíšete ji později) jako argument „Game Over“. Pokud je pozice x větší než velikost obrazovky vynásobená 3 (dříve jste ji nastavili jako velikost úrovně).

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

• Definujte nabídku třídy. Mělo by to být jako třída hlavní nabídky, kterou jste definovali dříve, ale místo toho, aby měl jako název prázdný řetězec, měl by použít proměnný text, který funkce _init_ bere jako argument. Položky nabídky by nyní měly mít označení „Zkusit znovu“a „Ukončit“, ale funkce, které nazývají, zůstávají stejné.

  třída FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Try again", startGame)), (Položka nabídky („Ukončit“, pyglet.app.exit))] self.create_menu (položky nabídky)
  

• Definujte funkci finishGame (). Mělo by to brát text jako argument. Měl by vytvořit scénu z pozadí hlavní nabídky, FinishMenu s textovým argumentem předávaným do této nabídky. Pak by měla spustit tuto scénu.

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

Krok 16. Přidejte kredity

Zde získáte kredit za svůj úžasný kód a kredit komukoli dalšímu, kdo vám na této cestě pomohl. Pokud jste použili obrázek z jiného webu (se svolením), nezapomeňte jej přiřadit jeho tvůrci.

• Vytvořte soubor ÚVĚRY a zadejte všechny své kredity takto:

  Penguin: Kelvin Shadewing, pod CC0 Ice block: Michał Banas digit1024 na opengameart.org pod CC-BY-SA 3.0
  

• Vraťte se ke svému kódu Pythonu a importujte Label z cocos.text.

• Definujte podtřídu Kredity vrstvy. Ve své funkci _init_ si přečtěte soubor CREDITS a z každého řádku v něm vytvořte textový štítek na správné pozici.

  třída Kredity (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") pro i v rozsahu (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)
  

• Přejděte do třídy hlavní nabídky a přidejte položku nabídky s názvem „Kredity“, která po kliknutí vyvolá funkci showCredits.

• Definujte podtřídu BackToMainMenuButton of Menu. Vytvořte z této nabídky nabídku s jednou položkou s názvem „Zpět“, která volá funkci showMainMenu. Toto „menu“, které je spíše jako tlačítko, by mělo být svisle zarovnané dolů a vodorovně nahoru.

  třída BackToMainMenuButton (Menu): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self. create_menu (položky nabídky)
  

• Definujte funkci showCredits. Mělo by vytvořit scénu z vrstvy MainMenuBgr a vrstvy Credits a spustit tuto scénu.

  def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)
  

Krok 17. Zkontrolujte svůj kód

Když si myslíte, že jste kód dokončili, měli byste se na něj znovu podívat. Díky tomu si můžete všimnout, zda lze něco optimalizovat, nebo zda jste zapomněli odstranit některé nepotřebné řádky. Pokud jste následovali příklad, celý váš kód by nyní měl vypadat následovně:

z cocos.director import * from cocos.menu import * from cocos.scene import * from cocos.layer import * from cocos.sprite import * from cocos.tiles import * from cocos.mapcolliders import * from cocos.actions import * from cocos.text import Štítek import pyglet.app z pyglet.window klíč importu z matematické úrovně importu z náhodného importu randint # "deklarace" globálních proměnných klávesnice = 0 scrMang = 0 třída MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) třída 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) třída Kredity (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n") pro i v dosahu (0, len (creds)): credLabel = Label (creds , font_size = 32, anchor_x = "vlevo", anchor_y = "nahoru") credLabel.position = 25, 500- (i+1)*40 self.add (credLabel) třída 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) třída 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) třída PlatformerController (Akce): globální klávesnice, 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ální klávesnice, scroller, pokud dt> 0,1: # nedělejte nic, když je doba výpadku příliš velká návratnost vx, vy = self.target.velocity vx = (klávesnice [key. RIGHT] - klávesnice [key. LEFT]) * self. MOVE_SPEED vy += self. GRAVITY * dt if self.on _země a klávesnice [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () new = last.copy () new.x += dx new.y + = dy self.target.velocity = self.target.collision_handler (last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center) posX, posY = self.target.position if posY <0: finishGame ("Game Over") return if posX> 800*3: # level size finishGame ("Level Completed") return def finishGame (text): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (text)) director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc) def generateTilemap (): colAmount = ceil (800/16) * 3 # (šířka obrazovky / velikost dlaždice) * 3 rowAmount = ceil (600/16) # výška obrazovky / velikost dlaždice dlaždiceSoubor = otevřený ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) pro i v rozsahu (0, colAmount): tileFile.write ('') makeHole = False if rand int (0, 50) == 10 a i! = 0: # nepovolit otvory v místě spawn makeHole = True pro j v rozsahu (0, rowAmount): if makeHole: tileFile.write ('\ n') else: if j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) if iceHeight <0: # limit dlaždic from too too low iceHeight = randint (1, 5) if iceHeight> rowAmount: # limit tiles from being too high iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') pro i v rozsahu (0, colAmount): tileFile.write (' ') pro j v rozsahu (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): globální klávesnice, scrMang generateTilemap () # fig = Sprite ('pingu.png') obr. pozice = (8, 250) figLayer = ScrollableLayer () figLayer.add (obr) # tileLayer = zatížení ('levelMap.xml') solidTiles = tileLayer ['solid'] nsoliTiles = tileLayer ['not_solid'] # klávesnice = key. KeyStateHandler () director.window.push_handlers (keybo ard) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump = 'slide') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) 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 - a simple platformer", resizable = True) showMainMenu ()

• To je celkem 168 řádků a 152 řádků, pokud počítáte pouze kód. Zdá se to být hodně, ale pro tak složitou hru je to ve skutečnosti malá částka.

Krok 18. Hotovo

Nyní si hru vyzkoušejte. Když něco programujete, musíte zkontrolovat, zda to funguje, kdykoli jste implementovali něco nového. Také byste si nějakou dobu rádi zahráli hru, kterou jste napsali.

Část 3 ze 3: Publikování hry

Krok 1. Zapište si závislosti

Každý, kdo používá jiný počítač, nebude mít nainstalován stejný software a knihovny jako vy. Budete tedy muset zajistit, aby každý, kdo si vaši hru nainstaluje, přesně věděl, co k jejímu spuštění bude potřebovat. Nemusíte zapisovat všechny závislosti všech závislostí všech závislostí atd., Ale měli byste alespoň napsat závislosti vašich balíčků a jejich závislosti.

Krok 2. Ujistěte se, že máte oprávnění používat všechna média

To platí pro veškerou grafiku, včetně 3D modelů, hudby, dialogů, hudby, knihoven a rámců, které jste ve hře použili. Cokoli, co jsi sám nenapsal.

• Často existují určité podmínky, například povinnost připsat autora nebo sdílet úpravy média pod stejnou licencí. Někdy budete moci použít grafiku, aniž byste přisoudili tvůrce, pokud za hru nebudete účtovat poplatky. Pokud musíte autorovi připsat kredit, udělejte to na dobře viditelném místě, jako je karta „Kredity“ve vaší hře.
• K dispozici jsou také média s nárokovanými autorskými právy a bez licence, někdy s textem jako „Všechna práva vyhrazena“. Pokud tomu tak je, musíte před zařazením do hry získat výslovné povolení od autora.
• Knihovny jsou obvykle vydávány na základě licencí, které jim umožňují používat je jako knihovny. Významnou výjimkou je GPL bez výjimky pro propojení: Taková licence jej umožňuje používat pouze v programu s určitými licencemi. A měli byste si vždy přečíst alespoň základní body licence, abyste se ujistili, že vše, co děláte s médiem nebo knihovnou, je povoleno.

Varování: Používání médií nebo knihoven způsobem, který licence ve hře, kterou vydáváte, nedovoluje, vás může dostat do vážných právních problémů. Pokud si nejste jisti, zda je vaše použití povoleno, zeptejte se autora nebo se dílu úplně vyhněte.

Krok 3. Rozhodněte se, za jakých podmínek chcete hru publikovat

Budete svoji hru prodávat? Chcete umožnit ostatním používat vaše obrázky a nápady? I když si musíte dávat pozor na média, která ve svém projektu používáte, obvykle se můžete rozhodnout, jak chcete umožnit ostatním používat vaši hru. K vydání hry ve veřejné doméně můžete použít licenci Creative Commons CC0. Chcete -li za určitých podmínek povolit distribuci a úpravy a přitom si ponechat některá práva, vyzkoušejte licenci Gnu General Public License (GPL) nebo licenci Berkeley Software Distribution (BSD). Nebo můžete svůj software upravit na vlastní účet, což znamená, že nikdo jej nesmí distribuovat ani upravovat bez vašeho svolení.

Ačkoli je možné vydělat peníze prodejem her, je nepravděpodobné, že by si lidé koupili vaši první hru, která má obvykle málo funkcí a nic zvláštního. Také pokud nefunguje bezplatný program, lidé, kteří si jej stáhli, budou jen zklamáni. Pokud to však zaplatili, budou požadovat vrácení peněz, což způsobí další problémy vám i uživatelům. Zvažte proto zpřístupnění prvních několika programů zdarma

Krok 4. Rozhodněte se, jak chcete hru publikovat

Každá metoda má nějaké výhody a nevýhody, takže se musíte rozhodnout sami.

• Publikování na webu:

  Pokud máte webové stránky, můžete svou hru nahrát a zpřístupnit ji ke stažení. Nezapomeňte poskytnout jasné pokyny k instalaci softwaru a také všechny požadované závislosti. Nevýhodou je, že hráči budou muset instalovat závislosti ručně, což může být pro některé lidi obtížné.

• Vytvoření balíčku pro správce balíčků:

  Existují různí správci balíčků, jako jsou apt, Yum a Homebrew, kteří lidem usnadňují instalaci aplikací v prostředí Linuxu a Linuxu. Všechny mají různé formáty balíčků. Dobrá věc na balíčcích je, že automaticky instalují všechny závislosti (pokud je správně nakonfigurujete). Hráč si tedy musí nainstalovat pouze váš balíček a poté může hru hrát. Problém je v tom, že na různých platformách existuje mnoho různých správců balíků, takže si budete muset dát práci s poskytováním balíčků pro všechny nejběžnější.

Krok 5. Přímá pozornost k vašemu programu

Zvažte nahrání svého programu do velkého úložiště balíčků, jako jsou ta, která udržují Ubuntu a Debian, aby bylo možné snadné instalace. Také zveřejňujte příspěvky na příslušných fórech, jako je sekce projektů GameDev nebo část tigSource. Nebuďte ale zklamaní, pokud se vaše první hry nestanou slavnými. Pokud máte představu, že se to líbí mnoha lidem, vaše hra se může stát známou.

Tipy

• Buďte trpěliví a ochotní se učit. Programování může být někdy frustrující!
• Pokud vás zajímá, jak se něco dělá v jiné hře, a hra je open-source, můžete se podívat na její zdrojový kód.
• Při hledání médií zkuste najít obsah, který je veřejně dostupný. Vyhledejte obrázky a hudbu „Creative Commons“nebo „Public Domain“a použijte webové stránky jako https://opengameart.org nebo
• Nekopírujte velké části kódu bez kontroly licence. Je často zakázáno, a pokud ne, obvykle vyžaduje uvedení zdroje.
• Při propagaci své hry nevytvářejte spam ani neposílejte příspěvky na nevhodná místa. Pravděpodobně vás to zablokuje na stránce, je to prostě otravné a poškodí to vaši pověst.