Hur man programmerar dataspel (med bilder)

2024 Författare: Robert Blare | [email protected]. Senast ändrad: 2023-12-17 08:04

Har du en idé för ett dataspel och vill göra det verkligt? Eller har du någonsin undrat hur datorspel skrivs? Denna wikiHow lär dig hur du skriver tre grundläggande dataspel i Python. Du behöver en grundläggande förståelse för Python och allmänna programmeringskoncept för att utveckla ditt första spel.

Steg

Del 1 av 3: Gör ett textbaserat spel

Steg 1. Välj ett programmeringsspråk

Alla programmeringsspråk är olika, så du måste bestämma vilket du vill använda för att skriva ditt spel. Varje stort programmeringsspråk stöder textinmatning, textutmatning och if-konstruktioner (de viktigaste sakerna du behöver för ett enkelt textbaserat spel), så utforska alternativen och bestäm vilka du känner dig bekvämast med och dedikerad till inlärning. Här är några faktorer att tänka på:

• Vad används språket mest till?

  Vissa programmeringsspråk, som JavaScript, är utformade för att användas för webben, medan andra, som Python, C eller C ++, är utformade för att köra datorprogram. För ditt spel, sikta på ett språk med ett bredare användningsområde, till exempel Python, C, C ++ eller JavaScript.

• Hur svårt är det att lära sig?

  Även om det ska vara lätt nog att skriva ett program efter lite träning i något vanligt programmeringsspråk (dvs inte ett specifikt utformat för att vara förvirrande som Malbolge), är vissa vänligare för nybörjare än andra. Java och C, till exempel, kommer att kräva att du förstår djupare programmeringskoncept än något som Python, som är känt för sin mer tillgängliga och rakt framåt syntax.

• Var kan jag använda den?

  Du vill förmodligen att människor på olika system, som Linux, Mac eller Windows, alla ska kunna spela ditt spel. Så du bör inte använda ett språk som bara stöds på några få system, som Visual Basic, som bara stöds på Windows.

Den här artikeln kommer att använda Python för exemplen på ett textbaserat spel, men du kan leta upp hur koncepten görs i alla andra programmeringsspråk.

Steg 2. Gör din dator redo

De två huvudkomponenterna du behöver är en textredigerare där du skriver din kod och en kompilator som du använder för att göra den till ett spel. Om du vill följa exemplet i den här artikeln bör du installera Python och lära dig hur du kör program. Om du vill kan du skapa en IDE (Integraded Desktop Environment) som kombinerar redigering, kompilering och felsökning till ett enda program. Pythons IDE kallas IDLE. Men du kan också bara använda alla textredigerare som stöder vanlig text, till exempel Anteckningar för Windows, TextEdit för macOS eller Vim för Linux.

Steg 3. Skriv en kod för att hälsa spelaren

Spelaren vill veta vad som händer och vad de måste göra, så du bör skriva ut lite text för dem.

• Detta görs med funktionen print () i Python. För att prova, öppna en ny fil med filtillägget.py, ange följande kod i den, spara och kör den:

  print ("Welcome to the number guessing game!") print ("Ange ett heltal mellan 1 och 1000:")
  

Steg 4. Generera ett slumpmässigt tal

Låt oss göra ett textbaserat spel som ber spelaren att gissa rätt antal. Det första vi behöver göra är att generera ett slumpmässigt tal i början av spelet så att spelaren inte alltid gissar samma nummer. Eftersom antalet kommer att förbli detsamma under hela programmet, vill du lagra det slumpmässiga numret i en variabel.

• Python har inte en inbyggd slumpmässig nummerfunktion, men det har ett standardbibliotek (det betyder att användaren inte behöver installera något extra) som gör det. Så gå till början av din kod (innan print () -funktionerna) och skriv raden import slumpmässig.

• Använd slumpfunktionen. Det kallas randint (), finns i det slumpmässiga biblioteket som du just importerade och tar det minimala och maximala värdet som antalet kan ha som argument. Så gå tillbaka till slutet av din kod och ange följande rad:

  rightNum = random.randint (0, 1000)
  

Steg 5. Få input från spelaren

I ett spel vill spelaren göra något eller interagera med något. I ett textbaserat spel är detta möjligt genom att ange text. Nu när vi har ett slumpmässigt tal bör våra nästa kodrader be spelaren att ange sin bästa gissning.

• Eftersom koden du angav skriver ut instruktionen för att ange ett nummer till spelaren, bör det också läsa det nummer de anger. Detta görs med input () i Python 3 och raw_input () i Python 2. Du bör skriva i Python 3, eftersom Python 2 snart kommer att bli föråldrad. Lägg till följande rad i din kod för att lagra spelarens inmatning i en variabel som heter nummer:

  userNum = input ()
  

Steg 6. Förvandla spelarens ingång till en användbar datatyp

Spelaren har angett ett nummer-nu vad?

• Gör spelarens inmatning till ett nummer. Nu kan det låta förvirrande eftersom de just skrivit in ett nummer. Men det finns en bra anledning: Python antar att all inmatning är text, eller en "sträng", som det kallas i programmering. Denna text innehåller det nummer du vill få. Python har en funktion som konverterar en sträng som bara innehåller ett tal till numret inuti. Typ:

  userNum = int (userNum)
  

Steg 7. Jämför spelarens nummer med rätt nummer

När spelaren har matat in sitt nummer måste du jämföra det med det som genererades slumpmässigt. Om siffrorna inte är desamma kan ditt spel få spelaren att prova ett annat nummer. Om siffrorna stämmer kan du berätta för spelaren att de gissade rätt och avsluta programmet. Detta görs med följande kod:

medan userNum! = rightNum: userNum = int (input ())

Steg 8. Ge spelaren feedback

Medan du redan har bearbetat deras inmatning ser spelaren inte detta. Du måste faktiskt skriva ut resultaten till spelaren så att de förstår vad som händer.

• Visst kan du bara berätta för spelaren om deras nummer är rätt eller fel. Men med det tillvägagångssättet kan spelaren behöva gissa 1000 gånger i värsta fall, vilket skulle vara väldigt tråkigt.
• Så berätta för spelaren om deras antal är för litet eller för stort. Detta kommer att minska deras gissningar betydligt. Om spelaren till exempel gissar 500 först och spelet svarar "För stort. Försök igen", det kommer bara att finnas 500 möjliga nummer istället för 1000. Detta görs med if-konstruktioner, så byt ut utskriften ("Fel. Försök igen. ") Med en.
• Var medveten om att du kontrollerar om två nummer är desamma med ==, inte med =. = tilldelar värdet till höger till variabeln till vänster om det!

if userNum <rightNum: print ("För liten. Försök igen:") om userNum> rightNum: print ("För stort. Försök igen:")

Steg 9. Testa din kod

Som programmerare bör du vara säker på att din kod fungerar innan du anser att den är klar.

• När du programmerar i python, se till att du får indragningarna korrekta. Din kod ska se ut så här:

  importera slumpmässigt tryck ("Välkommen till antalet gissningsspel!") print ("Ange ett heltal mellan 1 och 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) medan userNum! = rightNum: if userNum <rightNum: print ("För liten. Försök igen:") om userNum> rightNum: print ("För stort. Försök igen:") userNum = int (input ()) print ("Du gissade korrekt.")
  

Steg 10. Validera ingången

Spelaren borde inte kunna bryta ditt spel genom att helt enkelt ange fel sak. "Validera ingången" innebär att se till att spelaren angav rätt sak innan han bearbetade den.

• Öppna spelet igen och försök att ange något som inte är ett nummer. Spelet avslutas med en ValueError. För att undvika detta kan du implementera ett sätt att kontrollera om ingången var ett tal.
• Definiera en funktion. Eftersom valideringen av inmatningen är ganska lång och du måste göra det flera gånger, bör du definiera en funktion. Det tar inga argument och returnerar ett nummer. Skriv först def numInput (): högst upp i koden, direkt under slumpmässig import.
• Få spelarens input en gång. Använd funktionen input () och tilldela variabeln inp resultatet.
• När spelarens inmatning inte är ett nummer, be dem att ange ett nummer. För att kontrollera om en sträng är ett tal, använd funktionerna isdigit (), som bara tillåter ett helt tal, så du behöver inte leta efter det separat.
• Om inmatningen är ett tal, konvertera det från sträng till tal och returnera resultatet. Använd funktionen int () för att konvertera strängen till ett heltal. Detta gör konverteringen i huvudkoden onödig, och du bör ta bort den därifrån.
• Ersätt alla samtal till ingång () i huvudkoden med samtal till numInput ().
• Koden för funktionen numInput () kommer att se ut så här:

def numInput (): inp = input () medan inte inp.isdigit (): print ("Du fick besked om att ange ett heltal! Ange ett heltal:") inp = input () return int (inp)

Steg 11. Testa spelet igen

Ange fel saker med avsikt för att se vad som händer och åtgärda sedan eventuella fel när de dyker upp.

Prova att skriva in text när programmet ber dig om ett nummer. I stället för att avsluta med ett felmeddelande kommer programmet att be dig om ett nummer igen

Steg 12. Föreslå att spelet startas om när det är klart

På så sätt kan spelaren spela ditt spel under en längre tid utan att ständigt behöva starta om det.

• Lägg all kod utom importen och funktionsdefinitionen i en while-loop. Ange True som villkor: detta kommer alltid att vara sant, så slingan kommer att fortsätta för alltid.
• Fråga spelaren om de vill spela igen efter att de gissat siffran korrekt. Använd funktionen print ().
• Om de svarar "Nej" bryter du ut ur utseendet. Om de svarar på något annat, fortsätt. Att bryta ut ur en slinga görs med break -satsen.
• Flytta "Welcome to the number guessing game" utanför while -slingan. Spelaren vill förmodligen inte välkomnas varje gång de spelar spelet. Flytta instruktionstrycket ("Välkommen till nummergissningsspelet!" Ovanför medan True:, så skrivs det ut bara en gång när användaren startar det första spelet.

Steg 13. Testa spelet

Du måste testa ditt spel varje gång du implementerar en ny funktion.

• Se till att svara både "Ja" och "Nej" minst en gång för att se till att båda alternativen fungerar. Så här ska din kod se ut:

  importera slumpmässigt def numInput (): inp = input () medan inte inp.isdigit (): print ("Du fick besked om att ange ett heltal! Ange ett heltal:") inp = input () return int (inp) print ("Välkommen till numret att gissa!") Medan True: print ("Ange ett heltal mellan 1 och 1000:") rightNum = random.randint (0, 1000) userNum = numInput () medan userNum! = RightNum: if userNum <rightNum: print ("För liten. Försök igen:") om userNum> rightNum: print ("För stort. Försök igen:") userNum = numInput () print ("Du gissade rätt.") print ("Gör du vill spela igen? Ange Nej för att avsluta. ") om input () ==" No ": break
  

Steg 14. Skriv andra textbaserade spel

Vad sägs om att skriva ett textäventyr härnäst? Eller ett frågespel? Vara kreativ.

Dricks: Det är ibland bra att titta i dokumentationen om du inte är säker på hur något görs eller hur en funktion används. Python 3 -dokumentationen finns på https://docs.python.org/3/. Ibland ger det också bra resultat att söka efter vad du vill göra på internet.

Del 2 av 3: Gör ett spel med 2D -grafik

Steg 1. Välj ett grafikbibliotek

Att göra grafik är mycket komplicerat, och de flesta programmeringsspråk (inklusive Python, C ++, C, JavaScript) ger endast minimalt eller till och med inget stöd för grafik i kärnan eller standardbiblioteken. Så du måste använda ett externt bibliotek för att kunna skapa grafik, till exempel Pygame för Python.

Även med ett grafikbibliotek måste du oroa dig för saker som hur du visar en meny, hur du kontrollerar vad spelaren klickade på, hur du visar brickorna och så vidare. Om du hellre vill fokusera på att utveckla själva spelet kan du använda ett spelmotorsbibliotek som Unity, som enkelt implementerar dessa saker

Denna artikel kommer att använda Python med Cocos2D för att visa hur man gör en enkel 2D -plattformsspelare. Några av de nämnda koncepten kanske inte finns i andra spelmotorer. Se deras dokumentation för mer information.

Steg 2. Installera det grafikbibliotek du valde

Cocos2D för Python är lätt att installera. Du kan hämta det från https://python.cocos2d.org/index.html, eller genom att köra sudo pip3 installera cocos2d om du använder Linux.

Steg 3. Skapa en ny katalog för ditt spel och media

Du kommer att använda saker som bilder och ljud i ditt spel. Förvara dessa saker i samma katalog som programmet. Den här katalogen bör inte innehålla något annat så att du enkelt kan se vilka tillgångar du har i spelet.

Steg 4. Skapa en ny kodfil i den nya katalogen

Kalla det main, med filtillägget för ditt programmeringsspråk. Om du skriver ett stort och komplext program där det är vettigt att ha flera programfiler, visar detta dig vilken är huvudfilen.

I det här exemplet skapar vi en fil som heter main.py som innehåller all vår kod

Steg 5. Skapa spelfönstret

Detta är grundförutsättningen för ett spel med grafik.

• Importera nödvändiga cocos2d-delmoduler: cocos.director, cocos.scene och cocos.layer. Detta görs med från subModuleName import *, där submodulnamn är den submodul du vill importera. Skillnaden mellan från … import * och import … är att du inte behöver lägga modulnamnet framför allt du använder från den modulen med det förra.
• Definiera en underklass MainMenuBgr för ColorLayer. Detta betyder i princip att alla huvudmenybakgrunder du skapar kommer att bete sig som ett färglager med några ändringar du gör.
• Starta kokosdirektören. Detta ger dig ett nytt fönster. Om du inte anger en bildtext kommer fönstret att ha samma bildtext som filnamnet (main.py), vilket inte kommer att se professionellt ut. Tillåt att storleken på fönstret ändras genom att ställa in resizable till True.
• Definiera en funktion showMainMenu. Du bör sätta in koden för att visa huvudmenyn i en funktion eftersom det gör att du enkelt kan återgå till huvudmenyn genom att ringa funktionen igen.
• Skapa en scen. Scenen består av ett lager för närvarande, vilket är ett objekt i MainMenuBgr -klassen som du definierade.
• Kör denna scen i fönstret.

från cocos.director import * från cocos.scene import * från cocos.layer import * klass 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 - en enkel plattformsspelare", resizable = True) showMainMenu ()

Steg 6. Lägg till en huvudmeny i fönstret

Förutom själva spelet måste du lägga till en meny som spelaren kan använda för att stänga fönstret, bland andra element som du kan lägga till senare.

• Importera cocos.meny (igen med från instruktionen) och pyglet.app (denna gång med import).
• Definiera MainMenu som en underklass av Meny.
• Ställ in justeringen av huvudmenyn. Du måste ställa in den vertikala och horisontella inriktningen separat.
• Skapa en lista med menyalternativ och lägg till dem i menyn. Du bör åtminstone ha menyalternativen "Starta spel" och "Avsluta". Varje menyalternativ bör placeras inuti parenteser. Varje objekt måste ha en etikett och en återuppringningsfunktion som avgör vad som händer när spelaren klickar på den. För objektet "Starta spel", använd funktionen startGame (du skriver det snart), för "Avsluta", använd "pyglet.app.exit" (finns redan). Skapa den aktuella menyn genom att ringa till self.create_menu (menuItems).
• Definiera startGame (). Lägg bara in definitionen för tillfället, du kommer att ersätta det när du skriver själva spelet.
• Gå till den plats i koden där du skapade menyn Sc -scenen och lägg till ett MainMenu -objekt i den.

• Hela din kod ska nu se ut så här:

  från cocos.director import * från cocos.menu import * från cocos.scene import * från cocos.layer import * import pyglet.app klass MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) klass MainMenu (Meny): 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 - en enkel plattformsspelare", resizable = True) showMainMenu ()
  

Steg 7. Testa din kod

Testa koden tidigt, medan den fortfarande är kort och relativt enkel. Sedan kan du identifiera och korrigera eventuella misstag i grundstrukturen innan saker blir för komplicerade.

Koden från instruktionerna ska öppna ett fönster med rubriken "IcyPlat - en enkel plattformsspelare." Bakgrunden är ljusblå och du kan ändra storlek på fönstret. När du klickar på "Starta spel" på menyn ska ingenting hända (ännu). När du klickar på "Avsluta" stängs fönstret

Steg 8. Skapa en sprite

En sprite är ett "spelobjekt" eller en tvådimensionell bild. Sprites kan vara spelobjekt, ikoner, bakgrundsdekorationer, karaktärer och allt annat du kan representera med en bild i spelet. Vi börjar med att skapa en sprite för en karaktär som spelaren kan interagera med.

• Importera submodulen cocos.sprite med uttrycket från-import.
• Hitta en bild som representerar spriten. Du kan inte visa en sprite om du inte har en bild för den. Du kan rita en, eller så kan du få en från internet (se upp för licenserna om du planerar att publicera ditt spel). För det här exemplet, gå till https://opengameart.org/content/tux-classic-hero-style och spara PNG-bilden av pingviner som körs till din dator. Skär sedan ut en av de springande pingvinerna, eftersom du bara behöver en för tillfället.
• Skapa ett lager som ett nytt objekt i ScrollableLayer -klassen. Skapa sedan spriten som ett Sprite -objekt och ställ in dess position på (8, 250). Som referens finns punkten (0, 0) i nedre vänstra hörnet. Detta är ganska högt, men det kommer att se till att pingvinen inte fastnar i isen.
• Lägg till spriten i spriteslagret.
• Skapa en ny scen av sprites lager och kör den.

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

• Kör koden. Du bör se en liten pingvinfigur (eller vad du nu ritade) på en svart bakgrund när du klickar Starta spelet.

Steg 9. Dröm upp ditt landskap

I de flesta spel ska dina sprites inte bara flyta i tomrummet. De borde faktiskt stå på någon yta, med något runt dem. I 2D -spel görs detta ofta med en kakeluppsättning och en kakelkarta. Kakeluppsättningen säger i princip vilken typ av ytrutor och bakgrundsrutor som finns och hur de ser ut.

• Skapa en kakeluppsättning. Kakeluppsättningen för det här spelet kommer att vara mycket grundläggande: en kakel för is och en kakel för himmel. Isbrickan som används i detta exempel är härifrån, under CC-BY-SA 3.0.
• Skapa en kakelbild. Det är en bild av alla brickor, som alla måste ha samma storlek (redigera dem om de inte är det) och ha den storlek du vill se i spelet, bredvid varandra. Spara din bild som icyTiles.png.

• Skapa kakeluppsättningsbeskrivningen. Det är en XML -fil. XML -filen innehåller information om hur stora brickorna är i kakeluppsättningsbilden, vilken bild som ska användas och var man hittar vilken kakel där. Skapa en XML -fil med namnet icyTiles.xml med koden nedan:

Steg 10. Gör en kakelkarta för ditt landskap

En kakelkarta är en karta som definierar vilken kakel som är på vilken position i din nivå. I exemplet bör du definiera en funktion för att generera kakelkartor eftersom det är väldigt tråkigt att designa kakelkartor för hand. Ett mer avancerat spel skulle vanligtvis ha någon form av nivåredigerare, men för att bli bekant med 2D -spelutveckling kan en algoritm ge tillräckligt bra nivåer.

• Ta reda på hur många rader och kolumner som behövs. För detta, dela skärmstorleken med kakelstorleken både horisontellt (kolumner) och vertikalt (rader). Avrunda talet uppåt; du behöver en funktion i matematikmodulen för det, så lägg till från matematikimporttak till importen högst upp i din kod.
• Öppna en fil för att skriva. Detta raderar allt tidigare innehåll i filen, så välj ett namn som ingen fil i katalogen har ännu, som levelMap.xml.
• Skriv in öppningstaggarna i filen.
• Skapa en kakelkarta enligt algoritmen. Du använder den i koden nedan, eller så kan du hitta på en på egen hand. Se till att importera randint -funktionen från modulen random: det krävs för att koden nedan ska fungera, och vad du än kommer på kommer troligen också att behöva slumpmässiga heltal. Se också till att placera himmelplattor och isplattor i olika lager: is är fast, himlen inte.
• Skriv stängningstaggarna i filen och stäng filen.

def genereraTilemap (): colAmount = tak (800 /16) * 3 # (skärmbredd / kakelstorlek) * 3 radAnge = tak (600 /16) # skärmhöjd / kakelstorlek tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) för i inom intervallet (0, colAmount): tileFile.write ('') makeHole = False if randint (0, 50) == 10 och i! = 0: # tillåt inte hål vid spawnpoint makeHole = True för j i intervallet (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: # begränsa brickor från att gå för lågt iceHeight = randint (1, 5) if iceHeight> rowAmount: # begränsa brickor från att gå för hög iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') för i i intervallet (0, colAmount): tileFile.write ('') för j i intervallet (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Steg 11. Visa kakelkartan

Importera allt från cocos.tiles och gå sedan in i startGame -funktionen för det.

• I början av din startGame -funktion, generera en kakelkarta med den funktion du definierade för det.
• Skapa en ny rullningshanterare. Gör detta direkt under linjen där du lägger till spriten i dess lager.
• Skapa ett nytt lager som innehåller brickorna som laddas från levelMap.xml -kakelkartan som genererar din genereraTilemap -funktion.
• Lägg till det icke-fasta lagret, det fasta lagret och sprite-lagret till rullningshanteraren, exakt i denna ordning. Du kan lägga till en z-position om du vill.
• Istället för att skapa scenen från sprite -lagret, skapa den från rullningshanteraren.

• Din startGame -funktion ska nu se ut så här:

  def startGame (): createTilemap () # 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)
  

Steg 12. Testa din kod

Du bör testa din kod ofta för att se till att de nya funktioner du implementerade verkligen fungerar.

Koden i exemplet ska nu visa lite isigt landskap bakom pingvinen. Om pingvinen ser ut att sväva långt över isen gjorde du inget fel, och det kommer att åtgärdas i nästa steg

Steg 13. Lägg till kontrollerna

Spelaren har många fler sätt att interagera med programmet i ett 2D-spel än i ett textbaserat spel. En vanlig inkluderar att flytta sin figur när man trycker på rätt knapp.

• Importera allt från cocos.mapcolliders och från cocos. actions. Importera också nyckeln från pyglet.window.

• "Deklarera" några globala variabler. Globala variabler delas mellan funktioner. Du kan inte riktigt deklarera variabler i Python, men du måste säga att det finns en global variabel i huvudkoden innan du använder den. Du kan tilldela 0 som värdet eftersom en funktion tar hand om att tilldela rätt värde senare. Så lägg till under importuttrycken:

  # "deklarerar" globala variabler tangentbord = 0 scrMang = 0
  

• Justera din startGame -funktion:

  • Säg att du använder tangentbordet för globala variabler och scrMang. Gör detta genom att skriva globalt tangentbord, scrMang högst upp i funktionen.
  • Låt fönstret lyssna på tangentbordshändelser.
  • Säg att figuren ska agera baserat på en PlatformerController. Du kommer att implementera den PlatformerController snart.
  • Skapa en kartkollider för att hantera kollisioner mellan de fasta brickorna och figuren.

  def startGame (): globalt tangentbord, scrMang genereraTilemap () # fig = Sprite ('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer () figLayer.add (fig) # tileLayer = load ('levelMap.xml ') solidTiles = tileLayer [' solid '] nsoliTiles = tileLayer [' not_solid '] # keyboard = key. KeyStateHandler () director.window.push_handlers (keyboard) # fig.do (PlatformerController ()) mapcollider = RectMapCollider (velocity_on_bump) = 'slide') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (nsoliTiles, z = -1) scrMang.add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc)
  

• Skapa en plattformsspelare. Detta är vad som kommer att flytta figuren enligt dina knapptryckningar.

  • Definiera plattformsspelarens kontroller som en underklass av åtgärder.
  • Definiera rörelsehastigheten, hopphastigheten och gravitationen.
  • Definiera startfunktionen. Denna funktion kallas en gång när plattformsspelarenheten är ansluten till figuren. Den bör ställa in sin hastighet till 0 både i x och i y -riktning.
  • Definiera stegfunktionen. Det kommer att upprepas medan scenen pågår.
  • Berätta för stegfunktionen att använda tangentbordet för globala variabler och scrMang.
  • Få och ändra hastigheten. Spara x och y -hastigheten i separata variabler. Ställ in x -hastigheten till antingen 1 eller -1 (beroende på om vänster eller höger knapp trycktes) multiplicerat med flytthastigheten. Lägg till tyngdkraften till y -hastigheten. Multiplicera det med stillestånd så det fungerar på samma sätt på långsammare enheter. Om mellanslagstangenten trycks in och figuren står på marken hoppar du genom att ändra y -hastigheten till hopphastighet.
  • Beräkna vart figuren ska flytta. Låt sedan kollisionshanteraren justera den positionen om den är inuti en solid platta. Slutligen, flytta figuren till det nya justerade läget.
  • Ställ in rullningshanterarens fokus på figuren. Detta gör att kameran rör sig på ett rimligt sätt när figuren rör sig.

  klass PlatformerController (Action): globalt tangentbord, 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 om dt> 0,1: # gör inget under stillestånd till stor återkomst vx, vy = self.target.velocity vx = (keyboard [key. RIGHT] - keyboard [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground och keyboard [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 (*nytt.center)
  

Steg 14. Testa din kod

Om du följde exemplet ska du nu kunna flytta pingvinen med piltangenterna och hoppa genom att trycka på mellanslagstangenten. Pingvinen borde också falla ner istället för att sväva över marken.

Steg 15. Skapa ett slut för spelet

Även de spel som kan fortsätta i det oändliga bör ha möjlighet att förlora. Eftersom nivån du gjorde i exemplet med en funktion har ett slut, måste du också göra det möjligt att vinna genom att komma till det ändamålet. Annars skulle spelaren bara hoppa runt på isblocken där, vilket skulle bli tråkigt.

• Inne i plattformsspelaren, efter fokusuppsättningen, får du figurens x- och y -position. Om y -positionen är mindre än 0, ring funktionen finishGame () (du skriver det senare) med "Game Over" som argument. Om positionen x är större än skärmens storlek multiplicerat med 3 (du hade ställt in den som nivåstorlek tidigare).

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

• Definiera en klass finishMeny. Det ska vara som huvudmenyklassen du definierade tidigare, men istället för att ha en tom sträng som titel, bör den använda en variabeltext som _init_ -funktionen tar som argument. Menyalternativen bör märkas "Försök igen" och "Avsluta" nu, men de funktioner de kallar förblir desamma.

  class FinishMenu (Meny): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Försök igen", startGame)), (MenuItem ("Avsluta", pyglet.app.exit))] self.create_menu (menuItems)
  

• Definiera funktionen finishGame (). Det borde ta text som ett argument. Det ska göra en scen av huvudmenyens bakgrund, en FinishMenu med textargumentet som skickas vidare till den här menyn. Då borde den köra den här scenen.

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

Steg 16. Lägg till poäng

Det är här du får ta kredit för din fantastiska kod, samt ge kredit till alla andra som hjälpte dig på vägen. Om du använde en bild från en annan webbplats (med tillstånd), se till att tillskriva bilden till dess skapare.

• Skapa en fil KREDITER och ange alla dina krediter där, så här:

  Pingvin: Kelvin Shadewing, under CC0 Ice block: Michał Banas digit1024 på opengameart.org under CC-BY-SA 3.0
  

• Gå tillbaka till din Python -kod och importera etikett från cocos.text.

• Definiera en underklass Credits of Layer. I dess _init_ -funktion, läs CREDITS -filen och gör en textetikett på rätt plats av varje rad i den.

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

• Gå till din huvudmenyklass och lägg till ett menyalternativ märkt "Credits" som kallar funktionen showCredits när du klickar på det.

• Definiera en underklass BackToMainMenuButton of Menu. Gör detta till en meny med ett objekt, märkt "Tillbaka", som kallar showMainMenu -funktionen. Denna "meny", som mer liknar en knapp, bör vara vertikalt inriktad mot botten och horisontellt upptill.

  class BackToMainMenuButton (Meny): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back"), showMainMen.) skapa_meny (menuItems)
  

• Definiera funktionen showCredits. Det bör göra en scen av ett MainMenuBgr -lager och ett Credits -lager och köra den scenen.

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

Steg 17. Kontrollera din kod

När du tror att du har slutfört din kod bör du titta över allt igen. Detta kan hjälpa dig att märka om något kan optimeras, eller om det finns några onödiga rader du glömde att ta bort. Om du följde exemplet ska hela koden se ut så här:

från cocos.director import * från cocos.menu import * från cocos.scene import * från cocos.layer import * från cocos.spite import * från cocos.tiles import * från cocos.mapcolliders import * från cocos. actions import * från cocos.text import Etikett import pyglet.app från pyglet.window importnyckel från matematisk importtak från slumpmässig import randint # "deklarerar" globala variabler tangentbord = 0 scrMang = 0 klass MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) klass MainMenu (Meny): 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) klass Credits (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n") för i inom intervallet (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) klass BackToMainMenuButton (Meny): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self.create_menu (menuItems) class FinishMenu (Menu): def_ (_) self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Försök igen", startGame)), (MenuItem ("Quit", pyglet. app.exit))] self.create_menu (menuItems) klass PlatformerController (Action): globalt tangentbord, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (self, dt): globalt tangentbord, scroller om dt> 0.1: # gör inget medan stillestånd för stor avkastning vx, vy = self.target.velocity vx = (keyboard [key. RIGHT] - tangentbord [key. LEFT]) * self. MOVE_SPEED vy += self. GRAVITY * dt if self.on _grund och tangentbord [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") returnerar om 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 genereraTilemap (): colAmount = tak (800/16) * 3 # (skärmbredd / kakelstorlek) * 3 radAnge = tak (600/16) # skärmhöjd / kakelstorlek tileFile = öppen ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) för i i intervall (0, colAmount): tileFile.write ('') makeHole = Falskt om rand int (0, 50) == 10 och i! = 0: # tillåt inte hål vid spawnpoint makeHole = Sant för j i intervallet (0, rowAmount): if makeHole: tileFile.write ('\ n') else: om j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) if iceHeight <0: # begränsar brickor från att gå för låg iceHeight = randint (1, 5) if iceHeight> rowAmount: # begränsa brickor från att gå för hög iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') för i i intervall (0, colAmount): tileFile.write (' ') för j i intervall (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): globalt tangentbord, scrMang genereraTilemap () # 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 (nsoliTiles, z = -1) lägg till (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 - en enkel plattformsspelare", resizable = True) showMainMenu ()

• Det är totalt 168 rader och 152 rader om du bara räknar koden. Det här verkar som mycket, men för ett så komplext spel är det faktiskt en liten summa.

Steg 18. Avslutad

Testa nu spelet. När du programmerar något måste du kontrollera om det fungerar när du har implementerat något nytt. Du kanske också vill spela spelet du skrev en tid.

Del 3 av 3: Publicera ett spel

Steg 1. Skriv ner beroenden

Alla som använder en annan dator har inte samma programvara och bibliotek installerade som du. Så du måste se till att alla som installerar ditt spel vet exakt vad de behöver för att köra det. Du behöver inte skriva ner alla beroenden av alla beroenden av alla beroenden och så vidare, men du bör åtminstone skriva beroenden för dina paket och deras beroenden.

Steg 2. Se till att du har behörighet att använda alla medier

Detta gäller all grafik, inklusive 3D -modeller, musik, dialog, musik, bibliotek och ramar som du använde för ditt spel. Allt du inte skrev själv.

• Ofta finns det vissa villkor, som att behöva tillgodoräkna sig författaren eller dela ändringar av media under samma licens. Ibland kan du använda grafik utan att tillskriva skaparna så länge du inte tar betalt för spelet. Om du måste tillgodoräkna dig författaren, gör det på en väl synlig plats, som en flik "Credits" i ditt spel.
• Det finns också media med upphovsrättsanspråk och ingen licens specificerad, ibland med text som "Alla rättigheter förbehållna". Om så är fallet måste du få uttryckligt tillstånd från författaren innan du inkluderar det i ditt spel.
• Bibliotek släpps vanligtvis under licenser som gör att de kan användas som bibliotek. Ett anmärkningsvärt undantag är GPL utan att länka undantag: En sådan licens tillåter bara att använda den i ett program med vissa licenser. Och du bör alltid läsa åtminstone de grundläggande punkterna i licensen för att vara säker på att allt du gör med media eller bibliotek är tillåtet.

Varning: Att använda media eller bibliotek på ett sätt som licensen inte tillåter i ett spel som du publicerar kan få dig till allvarliga juridiska problem. Så fråga antingen författaren eller undvik media helt om du är osäker på om din användning är tillåten.

Steg 3. Bestäm vilka villkor du vill publicera ditt spel på

Kommer du att sälja ditt spel? Vill du tillåta andra att använda dina bilder och idéer? Medan du måste vara försiktig med media du använder i ditt projekt, kan du vanligtvis bestämma hur du vill låta andra använda ditt spel. Du kan använda en Creative Commons CC0 -licens för att släppa ditt spel i det offentliga området. För att tillåta distribution och modifiering under vissa förutsättningar samtidigt som du behåller vissa rättigheter, prova Gnu General Public License (GPL) eller Berkeley Software Distribution (BSD) -licensen. Eller så kan du göra din mjukvara proprietär, vilket innebär att ingen får distribuera eller ändra den utan ditt tillstånd.

Även om det är möjligt att tjäna pengar genom att sälja spel, är det osannolikt att folk kommer att köpa ditt första spel som vanligtvis har få funktioner och inget speciellt. Om ett gratis program inte fungerar kommer personer som laddade ner det bara att bli besvikna. Om de betalade för det kommer de dock att kräva tillbaka sina pengar, vilket orsakar fler problem för både dig och användarna. Så överväg att göra dina första program tillgängliga gratis

Steg 4. Bestäm hur du vill publicera ditt spel

Varje metod har vissa fördelar och nackdelar, så du måste bestämma själv.

• Publicera den på en webbplats:

  Om du har en webbplats kan du ladda upp ditt spel för att göra det tillgängligt för nedladdning. Se till att ge tydliga instruktioner om hur du installerar programvaran, samt alla nödvändiga beroenden. Nackdelen med detta är att spelare måste installera beroenden manuellt, vilket kan vara svårt för vissa människor.

• Skapa ett paket för en pakethanterare:

  Det finns olika pakethanterare, som apt, Yum och Homebrew, som gör det enkelt för människor att installera appar i Linux- och Linux-baserade miljöer. De har alla olika paketformat. Det som är bra med paket är att de automatiskt installerar alla beroenden (om du konfigurerar dem korrekt). Så spelaren behöver bara installera ditt paket och kan sedan spela spelet. Problemet är att det finns många olika pakethanterare på olika plattformar, så du måste lägga lite arbete på att tillhandahålla paket för alla de vanligaste.

Steg 5. Direkt uppmärksamhet på ditt program

Överväg att ladda upp ditt program till ett större paketförråd, som de som Ubuntu och Debian underhåller, för att möjliggöra enkla installationer. Posta också i lämpliga forum, som projektdelen i GameDev eller en del av tigSource. Men bli inte besviken om dina första spel inte blir kända. Om du har en idé om att många gillar det kan ditt spel bli välkänt.

Tips

• Var tålmodig och villig att lära. Programmering kan ibland vara frustrerande!
• Om du undrar hur något görs i ett annat spel och spelet har öppen källkod kan du titta på dess källkod.
• När du letar efter media kan du försöka hitta innehåll som är offentligt. Sök efter "Creative Commons" eller "Public Domain" bilder och musik och använd webbplatser som https://opengameart.org eller
• Kopiera inte stora bitar kod utan att kontrollera licensen. Det är ofta förbjudet, och om inte, kräver det vanligtvis tillskrivning.
• Skapa inte skräppost eller posta på olämpliga platser när du marknadsför ditt spel. Detta kommer sannolikt att få dig blockerad från sidan, är helt enkelt irriterande och kommer att skada ditt rykte.