Sådan programmeres computerspil (med billeder)

2024 Forfatter: Robert Blare | [email protected]. Sidst ændret: 2023-12-17 07:33

Har du en idé til et computerspil og vil gøre det virkeligt? Eller har du nogensinde undret dig over, hvordan computerspil er skrevet? Denne wikiHow lærer dig, hvordan du skriver tre grundlæggende computerspil i Python. Du skal bruge en grundlæggende forståelse af Python og generelle programmeringskoncepter for at udvikle dit første spil.

Trin

Del 1 af 3: Lav et tekstbaseret spil

Trin 1. Vælg et programmeringssprog

Alle programmeringssprog er forskellige, så du bliver nødt til at beslutte, hvilket du vil bruge til at skrive dit spil. Hvert større programmeringssprog understøtter tekstinput, tekstoutput og if-konstruktioner (de vigtigste ting, du har brug for til et enkelt tekstbaseret spil), så udforsk mulighederne, og beslut, hvilken du føler dig mest tryg ved og dedikeret til at lære. Her er nogle faktorer, der skal overvejes:

• Hvad bruges sproget mest til?

  Nogle programmeringssprog, som JavaScript, er designet til at blive brugt til internettet, mens andre, som Python, C eller C ++, er designet til at køre computerprogrammer. Til dit spil skal du sigte mod et sprog med et bredere anvendelsesområde, f.eks. Python, C, C ++ eller JavaScript.

• Hvor svært er det at lære?

  Selvom det skal være let nok at skrive et program efter lidt øvelse i ethvert normalt programmeringssprog (dvs. ikke et specifikt designet til at være forvirrende som Malbolge), er nogle venligere for begyndere end andre. Java og C for eksempel vil kræve, at du forstår dybere programmeringskoncepter end noget som Python, som er kendt for sin mere tilgængelige og ligetil syntaks.

• Hvor kan jeg bruge det?

  Du vil sandsynligvis have, at folk på forskellige systemer, såsom Linux, Mac eller Windows, alle kan spille dit spil. Så du bør ikke bruge et sprog, der kun understøttes på nogle få systemer, f.eks. Visual Basic, som kun understøttes på Windows.

Denne artikel vil bruge Python til eksemplerne på et tekstbaseret spil, men du kan slå op, hvordan begreberne gøres i ethvert andet programmeringssprog.

Trin 2. Gør din computer klar

De to hovedkomponenter, du skal bruge, er en tekstredigerer, hvor du skriver din kode og en kompilator, som du vil bruge til at gøre den til et spil. Hvis du vil følge eksemplet i denne artikel, skal du installere Python og lære at køre programmer. Hvis du vil, kan du oprette et IDE (Integraded Desktop Environment), som kombinerer redigering, kompilering og fejlfinding i et enkelt program. Pythons IDE kaldes IDLE. Men du kan også bare bruge en hvilken som helst tekstredigerer, der understøtter almindelig tekst, f.eks. Notesblok til Windows, TextEdit til macOS eller Vim til Linux.

Trin 3. Skriv en kode for at hilse på afspilleren

Spilleren vil gerne vide, hvad der foregår, og hvad de skal gøre, så du skal udskrive noget tekst til dem.

• Dette gøres med funktionen print () i Python. For at prøve det skal du åbne en ny fil med.py -udvidelsen, indtaste følgende kode i den, gemme og køre den:

  print ("Velkommen til antallet af gættespil!") print ("Indtast et helt tal mellem 1 og 1000:")
  

Trin 4. Generer et tilfældigt tal

Lad os lave et tekstbaseret spil, der beder spilleren om at gætte det korrekte nummer. Den første ting, vi skal gøre, er at generere et tilfældigt tal i starten af spillet, så spilleren ikke altid vil gætte det samme nummer. Da tallet forbliver det samme i hele programmet, vil du gerne gemme det tilfældige tal i en variabel.

• Python har ikke en indbygget tilfældig tal-funktion, men det har et standardbibliotek (det betyder, at brugeren ikke skal installere noget ekstra), der gør det. Så gå til begyndelsen af din kode (før print () -funktionerne), og indtast linjeimport tilfældig.

• Brug tilfældig funktion. Det kaldes randint (), er i det tilfældige bibliotek, som du lige har importeret, og tager den minimale og maksimale værdi, som tallet kan have som argument. Så gå tilbage til slutningen af din kode og indtast følgende linje:

  rightNum = random.randint (0, 1000)
  

Trin 5. Få input fra afspilleren

I et spil vil spilleren gøre noget eller interagere med noget. I et tekstbaseret spil er dette muligt ved at indtaste tekst. Nu hvor vi har et tilfældigt tal, bør vores næste kodelinjer bede spilleren om at indtaste deres bedste gæt.

• Da den indtastede kode udskriver instruktionen om at indtaste et nummer til afspilleren, skal den også læse det nummer, de indtaster. Dette gøres med input () i Python 3 og raw_input () i Python 2. Du skal skrive i Python 3, da Python 2 snart bliver forældet. Tilføj følgende linje til din kode for at gemme spillerens input i en variabel kaldet nummer:

  userNum = input ()
  

Trin 6. Gør spillerens input til en brugbar datatype

Spilleren har indtastet et nummer-hvad nu?

• Lav spillerens input til et tal. Nu kan det lyde forvirrende, fordi de lige har indtastet et tal. Men der er en god grund: Python antager, at alt input er tekst eller en "streng", som det kaldes i programmering. Denne tekst indeholder det nummer, du ønsker at få. Python har en funktion, der konverterer en streng, der kun indeholder et tal til tallet inde. Type:

  userNum = int (userNum)
  

Trin 7. Sammenlign spillerens nummer med det korrekte nummer

Når spilleren indtaster deres nummer, skal du sammenligne det med det, der blev genereret tilfældigt. Hvis tallene ikke er de samme, kan dit spil få spilleren til at prøve et andet nummer. Hvis tallene stemmer overens, kan du fortælle spilleren, at de gættede korrekt, og afslutte programmet. Dette gøres med følgende kode:

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

Trin 8. Giv spilleren feedback

Mens du allerede har behandlet deres input, kan afspilleren ikke se dette. Du skal faktisk udskrive resultaterne til spilleren, så de forstår, hvad der sker.

• Sikkert kunne du bare fortælle spilleren, om deres nummer er rigtigt eller forkert. Men med den tilgang skal spilleren måske gætte 1000 gange i værste fald, hvilket ville være meget kedeligt.
• Så fortæl spilleren, om deres antal er for lille eller for stort. Dette vil reducere deres antal gæt betydeligt. Hvis f.eks. Spilleren gætter 500 først, og spillet svarer "For stort. Prøv igen," vil der kun være 500 mulige tal i stedet for 1000. Dette gøres med if-konstruktioner, så udskift udskriften ("Forkert. Prøv igen. ") Med en.
• Vær opmærksom på, at kontrollen af, om to tal er det samme, udføres med ==, ikke med =. = tildeler værdien til højre for variablen til venstre for det!

hvis userNum <rightNum: print ("For lille. Prøv igen:") hvis userNum> rightNum: print ("For stor. Prøv igen:")

Trin 9. Test din kode

Som programmerer bør du være sikker på, at din kode fungerer, før du overvejer den færdig.

• Når du programmerer i python, skal du sørge for at få indrykningerne korrekte. Din kode skal se sådan ud:

  importer tilfældig udskrivning ("Velkommen til talgættespil!") print ("Indtast et helt tal mellem 1 og 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) mens userNum! = rightNum: hvis userNum <rightNum: print ("For lille. Prøv igen:") hvis userNum> rightNum: print ("For stor. Prøv igen:") userNum = int (input ()) print ("Du gættede korrekt. ")
  

Trin 10. Valider input

Spilleren burde ikke være i stand til at bryde dit spil ved blot at indtaste den forkerte ting. "Validering af input" betyder at sikre, at spilleren indtastede den korrekte ting, før den behandlede den.

• Åbn spillet igen, og prøv at indtaste noget, der ikke er et tal. Spillet afsluttes med en ValueError. For at undgå dette kan du implementere en måde at kontrollere, om input var et tal.
• Definer en funktion. Da validering af input er ret lang, og du skal gøre det flere gange, bør du definere en funktion. Det tager ingen argumenter og returnerer et tal. Skriv først def numInput (): øverst i din kode, direkte under tilfældig import.
• Få spillerens input en gang. Brug funktionen input () og tildel resultatet variablen inp.
• Når spillerens input ikke er et tal, skal du bede dem om at indtaste et nummer. For at kontrollere, om en streng er et tal, skal du bruge funktionerne isdigit (), som kun tillader et helt tal, så du ikke behøver at kontrollere det separat.
• Hvis input er et tal, skal du konvertere det fra streng til tal og returnere resultatet. Brug funktionen int () til at konvertere strengen til et helt tal. Dette vil gøre konverteringen i hovedkoden unødvendig, og du bør fjerne den derfra.
• Udskift alle opkald til input () i hovedkoden med opkald til numInput ().
• Koden for funktionen numInput () vil se sådan ud:

def numInput (): inp = input () mens ikke inp.isdigit (): print ("Du blev bedt om at indtaste et helt tal! Indtast et helt tal:") inp = input () return int (inp)

Trin 11. Test spillet igen

Indtast de forkerte ting med vilje for at se, hvad der sker, og ret derefter eventuelle fejl, når de kommer op.

Prøv at indtaste tekst, når programmet beder dig om et nummer. Nu, i stedet for at afslutte med en fejlmeddelelse, vil programmet bede dig om et nummer igen

Trin 12. Foreslå genstart af spillet, når det er færdigt

På denne måde kunne spilleren spille dit spil i længere tid uden konstant at skulle genstarte det.

• Sæt al kode undtagen importen og funktionsdefinitionen i en while-loop. Indstil True som betingelse: dette vil altid være sandt, så sløjfen vil fortsætte for evigt.
• Spørg spilleren, om de vil spille igen, efter at de har gættet tallet korrekt. Brug funktionen print ().
• Hvis de svarer "Nej", skal du bryde ud af udseendet. Hvis de svarer noget andet, skal du fortsætte. At bryde ud af en sløjfe sker med break -sætningen.
• Flyt "Welcome to the number guessing game" uden for while -løkken. Spilleren ønsker sandsynligvis ikke at blive budt velkommen hver gang de spiller spillet. Flyt instruktionsudskrivningen ("Velkommen til nummergættespil!" Over mens True:, så det udskrives kun én gang, når brugeren starter det første spil.

Trin 13. Test spillet

Du skal teste dit spil, hver gang du implementerer en ny funktion.

• Sørg for at svare både "Ja" og "Nej" mindst én gang for at sikre, at begge muligheder fungerer. Sådan skal din kode se ud:

  import random def numInput (): inp = input () while not inp.isdigit (): print ("Du blev bedt om at indtaste et helt tal! Indtast et helt tal:") inp = input () return int (inp) print ("Velkommen til antallet af gætte -spil!") Mens True: print ("Indtast et helt tal mellem 1 og 1000:") rightNum = random.randint (0, 1000) userNum = numInput () mens userNum! = RightNum: if userNum <rightNum: print ("For lille. Prøv igen:") hvis userNum> rightNum: print ("For stor. Prøv igen:") userNum = numInput () print ("Du gættede korrekt.") print ("Gør du vil spille igen? Indtast Nej for at afslutte. ") hvis input () ==" Nej ": pause
  

Trin 14. Skriv andre tekstbaserede spil

Hvad med at skrive et teksteventyr næste? Eller et quizspil? Vær kreativ.

Tip: Det er nogle gange nyttigt at kigge i dokumentationen, hvis du ikke er sikker på, hvordan noget gøres, eller hvordan en funktion bruges. Python 3 -dokumentationen findes på https://docs.python.org/3/. Nogle gange giver det også gode resultater at søge efter det, du vil gøre på internettet.

Del 2 af 3: Lav et spil med 2D -grafik

Trin 1. Vælg et grafisk bibliotek

At lave grafik er meget kompliceret, og de fleste programmeringssprog (herunder Python, C ++, C, JavaScript) giver kun minimal eller endda ingen understøttelse af grafik i kernen eller standardbibliotekerne. Så du bliver nødt til at bruge et eksternt bibliotek for at kunne lave grafik, for eksempel Pygame til Python.

Selv med et grafisk bibliotek skal du bekymre dig om ting som f.eks. Hvordan du viser en menu, hvordan du kontrollerer, hvad afspilleren har klikket på, hvordan du viser brikkerne og så videre. Hvis du hellere vil fokusere på at udvikle det egentlige spil, kan du bruge et spilmotorbibliotek som Unity, som let implementerer disse ting

Denne artikel vil bruge Python med Cocos2D til at vise, hvordan man laver en simpel 2D platformer. Nogle af de nævnte begreber findes muligvis ikke i andre spilmotorer. Se deres dokumentation for mere information.

Trin 2. Installer det grafikbibliotek, du valgte

Cocos2D til Python er let at installere. Du kan få det fra https://python.cocos2d.org/index.html, eller ved at køre sudo pip3 installer cocos2d, hvis du bruger Linux.

Trin 3. Lav en ny bibliotek til dit spil og dine medier

Du vil bruge ting som billeder og lyde i dit spil. Opbevar disse ting i samme bibliotek som programmet. Denne mappe bør ikke indeholde andet, så du nemt kan se, hvilke aktiver du har i spillet.

Trin 4. Opret en ny kodefil i det nye bibliotek

Kald det main med filtypen til dit programmeringssprog. Hvis du skriver et stort og komplekst program, hvor det er fornuftigt at have flere programfiler, viser dette dig, hvilken der er hovedfilen.

I dette eksempel opretter vi en fil kaldet main.py, der indeholder hele vores kode

Trin 5. Opret spilvinduet

Dette er den grundlæggende forudsætning for et spil med grafik.

• Importer de nødvendige cocos2d-undermoduler: cocos.director, cocos.scene og cocos.layer. Dette gøres med fra subModuleName import *, hvor undermodulnavn er den submodul, du vil importere. Forskellen mellem… import * og import… er, at du ikke behøver at sætte modulnavnet foran alt, hvad du bruger fra det modul med det tidligere.
• Definer en underklasse MainMenuBgr for ColorLayer. Dette betyder dybest set, at enhver hovedmenubaggrund, du opretter, vil opføre sig som et farvelag med nogle ændringer, du foretager.
• Start kokosdirektøren. Dette giver dig et nyt vindue. Hvis du ikke angiver en billedtekst, har vinduet den samme billedtekst som filnavnet (main.py), hvilket ikke ser professionelt ud. Tillad ændring af størrelsen på vinduet ved at indstille resizable til True.
• Definer en funktion showMainMenu. Du bør sætte koden til visning af hovedmenuen i en funktion, fordi dette giver dig mulighed for let at vende tilbage til hovedmenuen ved at kalde funktionen igen.
• Opret en scene. Scenen består nu af et lag, som er et objekt i MainMenuBgr -klassen, du definerede.
• Kør denne scene i vinduet.

fra cocos.director import * fra cocos.scene import * fra cocos.layer import * klasse 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 simpel platformspiller", resizable = True) showMainMenu ()

Trin 6. Føj en hovedmenu til vinduet

Udover selve spillet skal du tilføje en menu, spilleren kan bruge til at lukke vinduet, blandt andre elementer, du kan tilføje senere.

• Importer cocos.menu (igen med fra instruktionen) og pyglet.app (denne gang med import).
• Definer MainMenu som en underklasse i menuen.
• Indstil justeringen af hovedmenuen. Du skal indstille den lodrette og vandrette justering separat.
• Opret en liste over menupunkter, og tilføj dem til menuen. Du skal mindst have menupunkterne "Start spil" og "Afslut". Hvert menupunkt skal placeres inde i parenteser. Hvert element skal have en etiket og en tilbagekaldsfunktion, der bestemmer, hvad der sker, når spilleren klikker på det. For elementet "Start spil" skal du bruge startGame -funktionen (du skriver det snart), for elementet "Afslut" skal du bruge "pyglet.app.exit" (findes allerede). Opret den aktuelle menu ved at kalde self.create_menu (menuItems).
• Definer startGame (). Indsæt bare pass i definitionen for nu, du erstatter det, når du skriver det egentlige spil.
• Gå til det sted i din kode, hvor du oprettede menuSc -scenen, og tilføj et MainMenu -objekt til det.

• Hele din kode skal nu se sådan ud:

  fra cocos.director import * fra cocos.menu import * fra cocos.scene import * fra cocos.layer import * import pyglet.app klasse MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) klasse MainMenu (Menu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Start spil) ", 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 ()
  

Trin 7. Test din kode

Test koden tidligt, mens den stadig er kort og relativt enkel. Derefter kan du identificere og rette eventuelle fejl i grundstrukturen, før tingene bliver for komplicerede.

Koden fra instruktionerne skal åbne et vindue med overskriften "IcyPlat - en simpel platformspiller." Baggrunden er lyseblå, og du kan ændre størrelsen på vinduet. Når du klikker på "Start spil" i menuen, bør der ikke ske noget (endnu). Når du klikker på "Afslut", lukkes vinduet

Trin 8. Opret en sprite

En sprite er et "spilobjekt" eller et 2-dimensionelt billede. Sprites kan være objekter i spillet, ikoner, baggrundsdekorationer, karakterer og alt andet, du kan repræsentere med et billede i spillet. Vi starter med at oprette en sprite til en karakter, som spilleren kan interagere med.

• Importer submodulen cocos.sprite med fra-import-udtrykket.
• Find et billede, der repræsenterer sprite. Du kan ikke vise en sprite, hvis du ikke har et billede til det. Du kan tegne en, eller du kan få en fra internettet (pas dog på licenserne, hvis du planlægger at udgive dit spil). For dette eksempel skal du gå til https://opengameart.org/content/tux-classic-hero-style og gemme PNG-billedet af kørende pingviner på din computer. Beskær derefter en af de løbende pingviner, da du kun har brug for en i øjeblikket.
• Opret et lag som et nyt objekt i ScrollableLayer -klassen. Opret derefter sprite som et Sprite -objekt og sæt dens position til (8, 250). Til reference er punktet (0, 0) i nederste venstre hjørne. Dette er ret højt, men det vil sikre, at pingvinen ikke sætter sig fast i isen.
• Tilføj sprite til sprite lag.
• Opret en ny scene ud af sprites lag og 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 skal se en lille pingvinfigur (eller hvad du nu har tegnet) på en sort baggrund, når du klikker Start Spil.

Trin 9. Drøm dit landskab op

I de fleste spil bør dine sprites ikke bare flyde i tomrummet. De burde faktisk stå på en eller anden overflade, med noget omkring dem. I 2D -spil gøres dette ofte med et flisesæt og et flisekort. Flisesættet siger dybest set, hvilken slags overfladekvadrater og baggrundsfirkanter der findes, og hvordan de ser ud.

• Opret et flisesæt. Flisens sæt til dette spil vil være meget grundlæggende: en flise til is og en flise til himmel. Isflisen, der bruges i dette eksempel, er herfra, under CC-BY-SA 3.0.
• Opret et billede med fliser. Det er et billede af alle brikker, der alle skal have samme størrelse (rediger dem, hvis de ikke er det) og have den størrelse, du vil se i spillet, ved siden af hinanden. Gem dit billede som icyTiles.png.

• Opret beskrivelsen af flisesættet. Det er en XML -fil. XML -filen indeholder oplysninger om, hvor store fliserne er i flisebilledet, hvilket billede der skal bruges, og hvor man finder hvilken flise der. Opret en XML -fil ved navn icyTiles.xml med koden herunder:

Trin 10. Lav et flisekort til dit landskab

Et flisekort er et kort, der definerer, hvilken flise der er på hvilken position i dit niveau. I eksemplet bør du definere en funktion til at generere flisekort, fordi det er meget kedeligt at designe flisekort. Et mere avanceret spil ville normalt have en form for level editor, men for at blive fortrolig med 2D -spiludvikling kan en algoritme levere gode nok niveauer.

• Find ud af, hvor mange rækker og kolonner der er brug for. Til dette skal du dele skærmstørrelsen med flisestørrelsen både vandret (kolonner) og lodret (rækker). Rund tallet opad; du har brug for en funktion af matematikmodulet til det, så tilføj fra matematikimportlofter til importen øverst i din kode.
• Åbn en fil til skrivning. Dette vil slette alt tidligere indhold i filen, så vælg et navn, som ingen fil i biblioteket endnu har, f.eks. LevelMap.xml.
• Skriv åbningskoderne ind i filen.
• Generer et flisekort i henhold til algoritmen. Du bruger den i koden herunder, eller du kan komme med en på egen hånd. Sørg for at importere randint -funktionen fra modulet random: det er påkrævet for nedenstående kode at fungere, og uanset hvad du finder på, vil det sandsynligvis også have brug for tilfældige heltal. Sørg også for at lægge himmelfliser og isfliser i forskellige lag: is er solid, himmel ikke.
• Skriv lukkemærkerne ind i filen, og luk filen.

def generereTilemap (): colAmount = loft (800 /16) * 3 # (skærmbredde / flisestørrelse) * 3 rowAmount = loft (600 /16) # skærmhøjde / flisestørrelse tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) for i i området (0, colAmount): tileFile.write ('') makeHole = Falsk hvis randint (0, 50) == 10 og i! = 0: # tillader ikke huller ved spawnpoint makeHole = Sandt for j i området (0, rowAmount): hvis makeHole: tileFile.write ('\ n') ellers: hvis j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) hvis iceHeight <0: # begrænser fliser fra at gå for lav iceHeight = randint (1, 5) hvis iceHeight> rowAmount: # begræns fliser fra at gå for høj iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') for i i området (0, colAmount): tileFile.write ('') for j i området (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Trin 11. Vis flisekortet

Importer alt fra cocos.tiles og gå derefter til startGame -funktionen til det.

• I begyndelsen af din startGame -funktion skal du generere et flisekort ved hjælp af den funktion, du har defineret til det.
• Opret en ny rulleadministrator. Gør dette direkte under den linje, hvor du tilføjer sprite til sit lag.
• Opret et nyt lag, der indeholder fliserne, som indlæses fra levelMap.xml -flisekortet, som din genereretTilemap -funktion genererede.
• Tilføj det ikke-solide lag, det faste lag og sprite-laget til rulleadministratoren, præcis i denne rækkefølge. Du kan tilføje en z-position, hvis du vil.
• I stedet for at oprette scenen fra sprite -laget, skal du oprette den fra rullende manager.

• Din startGame -funktion skal nu se sådan ud:

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

Trin 12. Test din kode

Du bør teste din kode ofte for at sikre, at de nye funktioner, du har implementeret, virkelig fungerer.

Koden i eksemplet skulle nu vise noget iskoldt landskab bag pingvinen. Hvis pingvinen ser ud til at svæve langt over isen, gjorde du ikke noget forkert, og det bliver rettet i næste trin

Trin 13. Tilføj kontrollerne

Spilleren har mange flere måder at interagere med programmet i et 2D-spil end i et tekstbaseret spil. En almindelig inkluderer at flytte deres figur, når der trykkes på den korrekte tast.

• Importer alt fra cocos. Mapcolliders og fra cocos. Actions. Importer også nøgle fra pyglet.window.

• "Deklarér" nogle globale variabler. Globale variabler deles mellem funktioner. Du kan ikke rigtig erklære variabler i Python, men du må sige, at der findes en global variabel i hovedkoden, før du bruger den. Du kan tildele 0 som værdien, fordi en funktion sørger for at tildele den korrekte værdi senere. Så tilføj under importudtrykkene:

  # "erklærer" globale variabler tastatur = 0 scrMang = 0
  

• Juster din startGame -funktion:

  • Sig, at du bruger tastaturet til globale variabler og scrMang. Gør dette ved at skrive globalt tastatur, scrMang øverst i funktionen.
  • Få vinduet til at lytte til tastaturhændelser.
  • Fortæl figuren at handle ud fra en PlatformerController. Du implementerer snart den PlatformerController.
  • Opret en kortkollider for at håndtere kollisioner mellem de massive fliser og figuren.

  def startGame (): globalt tastatur, scrMang generereTilemap () # 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 (tastatur) # 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)
  

• Opret en platformspilcontroller. Dette er det, der vil flytte figuren i henhold til dine tastetryk.

  • Definer platformspilkontrolleren som en underklasse af handling.
  • Definer flyttehastigheden, springhastigheden og tyngdekraften.
  • Definer startfunktionen. Denne funktion kaldes én gang, når platformspilkontrolleren er forbundet til figuren. Den skal sætte sin hastighed til 0 både i x og i y -retning.
  • Definer trinfunktionen. Det vil blive gentaget, mens scenen kører.
  • Fortæl trinfunktionen om at bruge tastaturet til globale variabler og scrMang.
  • Få og ændre hastigheden. Gem x og y -hastigheden i separate variabler. Indstil x -hastigheden til enten 1 eller -1 (afhængigt af om der blev trykket på venstre eller højre tast) multipliceret med flyttehastigheden. Tilføj tyngdekraften til y -hastigheden. Multiplicer det med nedetid, så det fungerer på samme måde på langsommere enheder. Hvis der trykkes på mellemrumstasten, og figuren står på jorden, skal du springe ved at ændre y -hastigheden til springhastighed.
  • Beregn til, hvor tallet skal bevæge sig. Lad derefter kollisionshandleren justere denne position, hvis den er inde i en massiv flise. Til sidst flyttes figuren til den nye justerede position.
  • Indstil rullehåndteringens fokus på figuren. Dette får kameraet til at bevæge sig på en rimelig måde, når figuren bevæger sig.

  klasse PlatformerController (Action): globalt tastatur, 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 hvis dt> 0,1: # ikke gør noget, mens nedetid er til stor tilbagevenden vx, vy = self.target.velocity vx = (tastatur [key. RIGHT] - tastatur [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground og 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 (*new.center)
  

Trin 14. Test din kode

Hvis du fulgte eksemplet, skulle du nu kunne flytte pingvinen med piletasterne og hoppe ved at trykke på mellemrumstasten. Også pingvinen skulle nu falde ned i stedet for at svæve over jorden.

Trin 15. Opret en afslutning på spillet

Selv de spil, der kan fortsætte i det uendelige, burde have mulighed for at tabe. Da det niveau, du lavede i eksemplet med en funktion, har en ende, skal du også gøre det muligt at vinde ved at komme til den ende. Ellers ville spilleren kun hoppe rundt på isblokkene der, hvilket ville blive kedeligt.

• Inde i platformspilkontrollen, efter fokusindstillingen, får du figurens x- og y -position. Hvis y -positionen er mindre end 0, skal du kalde funktionen finishGame () (du skriver det senere) med "Game Over" som argument. Hvis x -positionen er større end skærmens størrelse multipliceret med 3 (du havde indstillet den som niveaustørrelse før).

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

• Definer en klasse finishMenu. Det skal være som hovedmenuklassen, du definerede før, men i stedet for at have en tom streng som titel, bør den bruge en variabel tekst, som _init_ -funktionen tager som argument. Menupunkterne skal mærkes "Prøv igen" og "Afslut" nu, men de funktioner, de kalder, forbliver de samme.

  class FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Prøv igen", startGame)), (MenuItem ("Afslut", pyglet.app.exit))] self.create_menu (menuItems)
  

• Definer funktionen finishGame (). Det skal tage tekst som et argument. Det skal lave en scene ud af hovedmenuens baggrund, en FinishMenu med tekstargumentet videregivet til denne menu. Så skulle den køre denne scene.

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

Trin 16. Tilføj credits

Det er her, du får tag æren for din fantastiske kode, samt giver kredit til alle andre, der hjalp dig på vej. Hvis du brugte et billede fra et andet websted (med tilladelse), skal du sørge for at tilskrive billedet til dets skaber.

• Opret en fil KREDITER og indtast alle dine kreditter der, sådan her:

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

• Gå tilbage til din Python -kode, og importer etiketten fra cocos.text.

• Definer en underklasse Credits of Layer. I dens _init_ -funktion skal du læse CREDITS -filen og lave en tekstetiket på den korrekte position ud af hver linje i den.

  class Credits (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") for i i området (0, len (creds)): credLabel = Label (creds , font_size = 32, anchor_x =" venstre ", anchor_y =" top ") credLabel.position = 25, 500- (i +1)*40 self.add (credLabel)
  

• Gå til din hovedmenuklasse, og tilføj et menupunkt mærket "Credits", der kalder funktionen showCredits, når der klikkes på det.

• Definer en underklasse BackToMainMenuButton i menuen. Gør dette til en menu med et element, mærket "Tilbage", der kalder showMainMenu -funktionen. Denne "menu", der mere ligner en knap, skal være lodret justeret til bunden og vandret til toppen.

  klasse BackToMainMenuButton (Menu): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Tilbage"), showMainMu.) create_menu (menuItems)
  

• Definer funktionen showCredits. Det skal lave en scene ud af et MainMenuBgr -lag og et Credits -lag og køre den scene.

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

Trin 17. Kontroller din kode

Når du tror, at du er færdig med din kode, skal du kigge på det hele igen. Dette kan hjælpe dig med at bemærke, om noget kan optimeres, eller om der er nogle unødvendige linjer, du har glemt at slette. Hvis du fulgte eksemplet, skulle hele din kode nu se sådan ud:

fra cocos.director import * fra cocos.menu import * fra cocos.scene import * fra cocos.layer import * fra cocos.spite import * fra cocos.flies import * fra cocos. mapcolliders import * fra cocos. actions import * fra cocos.text import Etiket import pyglet.app fra pyglet.window importnøgle fra matematisk importloft fra tilfældig import randint # "deklarering" globale variabler tastatur = 0 scrMang = 0 klasse MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) klasse MainMenu (Menu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Start spil", startGame)), (MenuItem ("Credits", showCredits)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems) klasse Credits (Layer): def _init _ (self): super (Credits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n") for i inden for rækkevidde (0, len (creds)): credLabel = Label (creds , font_size = 32, anchor_x = "venstre", anchor_y = "top") credLabel.position = 25, 500- (i+1)*40 self.add (credLabel) klasse BackToMainMenuButton (Menu): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back", showMainMenu))] self.create_menu (menuItems) class FinishMenu (Menu): _ self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Prøv igen", startGame)), (MenuItem ("Quit", pyglet. app.exit))] self.create_menu (menuItems) klasse PlatformerController (Action): globalt tastatur, 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 tastatur, scroller hvis dt> 0.1: # gør ikke noget, mens nedetid for stor returnerer vx, vy = self.target.velocity vx = (tastatur [key. RIGHT] - tastatur [key. LEFT]) * self. MOVE_SPEED vy += self. GRAVITY * dt if self.on _grund og tastatur [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") returnerer hvis posX> 800*3: # level size finishGame ("Level Completed") return def finishGame (text): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (tekst)) director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc) def generereTilemap (): colAmount = loft (800/16) * 3 # (skærmbredde / flisestørrelse) * 3 rowAmount = loft (600/16) # skærmhøjde / flisestørrelse tileFile = åben ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) for i i området (0, colAmount): tileFile.write ('') makeHole = Falsk hvis rand int (0, 50) == 10 og i! = 0: # tillader ikke huller ved spawnpoint makeHole = Sandt for j i området (0, rowAmount): if makeHole: tileFile.write ('\ n') andet: hvis j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) if iceHeight <0: # begrænser fliser fra at gå for lav iceHeight = randint (1, 5) hvis iceHeight> rowAmount: # begræns fliser fra at gå for høj iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') for i i området (0, colAmount): tileFile.write (' ') for j i området (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): globalt tastatur, scrMang generereTilemap () # 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 (nsoliTilesM, n = -1) tilføj (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 simpel platformspiller", resizable = True) showMainMenu ()

• Det er 168 linjer totalt og 152 linjer, hvis du kun tæller koden. Dette ser ud til at være meget, men for et så komplekst spil er dette faktisk en lille mængde.

Trin 18. Færdig

Test nu spillet. Når du programmerer noget, skal du kontrollere, om det virker, når du har implementeret noget nyt. Du vil måske også gerne spille det spil, du skrev i nogen tid.

Del 3 af 3: Udgivelse af et spil

Trin 1. Skriv afhængighederne ned

Enhver, der bruger en anden computer, har ikke den samme software og biblioteker installeret som dig. Så du skal sørge for, at alle, der installerer dit spil, ved præcis, hvad de skal bruge for at køre det. Du behøver ikke at nedskrive alle afhængigheder af alle afhængigheder af alle afhængigheder og så videre, men du bør i det mindste skrive afhængighederne for dine pakker og deres afhængigheder.

Trin 2. Sørg for, at du har tilladelse til at bruge alle medier

Dette gælder for al grafik, herunder 3D -modeller, musik, dialog, musik, biblioteker og rammer, du brugte til dit spil. Noget du ikke selv skrev.

• Ofte er der nogle betingelser, f.eks. At skulle kreditere forfatteren eller dele ændringer af medierne under den samme licens. Nogle gange kan du bruge grafik uden at tilskrive skaberne, så længe du ikke opkræver betaling for spillet. Hvis du skal kreditere forfatteren, skal du gøre det på et godt synligt sted, som en fane "Credits" i dit spil.
• Der er også medier med krav på ophavsret og ingen licens angivet, nogle gange med noget tekst som "Alle rettigheder forbeholdt". Hvis det er tilfældet, skal du få eksplicit tilladelse fra forfatteren, før du inkluderer det i dit spil.
• Biblioteker frigives normalt under licenser, der gør det muligt at bruge dem som bibliotek. En bemærkelsesværdig undtagelse er GPL uden at forbinde undtagelse: Sådan en licens tillader kun at bruge den i et program med visse licenser. Og du bør altid læse mindst de grundlæggende punkter i licensen for at sikre, at uanset hvad du laver med medierne eller biblioteket er tilladt.

Advarsel: Brug af medier eller biblioteker på en måde, som licensen ikke tillader i et spil, du udgiver, kan få dig til alvorlige juridiske problemer. Så enten spørg forfatteren eller undgå mediestykket helt, hvis du er usikker på, om din brug er tilladt.

Trin 3. Beslut dig for de betingelser, du vil udgive dit spil på

Vil du sælge dit spil? Vil du tillade andre at bruge dine billeder og ideer? Selvom du skal være forsigtig med de medier, du bruger i dit projekt, kan du normalt beslutte, hvordan du vil tillade andre at bruge dit spil. Du kan bruge en Creative Commons CC0 -licens til at frigive dit spil i det offentlige domæne. For at tillade distribution og ændring under visse betingelser, med forbehold af nogle rettigheder, kan du prøve Gnu General Public License (GPL) eller Berkeley Software Distribution (BSD) -licensen. Eller du kan gøre din software proprietær, hvilket betyder, at ingen må distribuere eller ændre den uden din tilladelse.

Selvom det er muligt at tjene penge ved at sælge spil, er det usandsynligt, at folk vil købe dit første spil, der normalt har få funktioner og ikke noget særligt. Hvis et gratis program ikke virker, vil folk, der downloadede det, bare blive skuffede. Hvis de betalte for det, kræver de dog deres penge tilbage, hvilket forårsager flere problemer for både dig og brugerne. Så overvej at gøre dine første få programmer gratis tilgængelige

Trin 4. Beslut, hvordan du vil udgive dit spil

Hver metode har nogle fordele og ulemper, så du skal selv bestemme.

• Udgivelse på et websted:

  Hvis du har et websted, kan du uploade dit spil for at gøre det tilgængeligt for download. Sørg for at give klare instruktioner om, hvordan du installerer softwaren, samt alle nødvendige afhængigheder. Ulempen ved dette er, at spillerne bliver nødt til at installere afhængigheder manuelt, hvilket kan være svært for nogle mennesker.

• Oprettelse af en pakke til en pakkeleder:

  Der er forskellige pakkeledere, som apt, Yum og Homebrew, der gør det let for folk at installere apps i Linux- og Linux-baserede miljøer. De har alle forskellige pakkeformater. Det gode ved pakker er, at de automatisk installerer alle afhængigheder (hvis du konfigurerer dem korrekt). Så afspilleren skal kun installere din pakke og kan derefter spille spillet. Problemet er, at der er mange forskellige pakkeledere på forskellige platforme, så du bliver nødt til at lægge noget arbejde i at levere pakker til alle de mest almindelige.

Trin 5. Direkte opmærksomhed på dit program

Overvej at uploade dit program til et større pakkeopbevaringssted, som dem, Ubuntu og Debian vedligeholder, for at gøre det let at installere. Send også indlæg i passende fora, f.eks. Projektsektionen i GameDev eller en del af tigSource. Men vær ikke skuffet, hvis dine første spil ikke bliver berømte. Hvis du har en idé om, at mange mennesker kan lide det, kan dit spil blive kendt.

Tips

• Vær tålmodig og villig til at lære. Programmering kan til tider være frustrerende!
• Hvis du undrer dig over, hvordan noget gøres i et andet spil, og spillet er open-source, kan du se på dets kildekode.
• Når du leder efter medier, skal du prøve at finde indhold, der er i det offentlige domæne. Søg efter "Creative Commons" eller "Public Domain" billeder og musik, og brug websteder som https://opengameart.org eller
• Kopier ikke store bidder af kode uden at kontrollere licensen. Det er ofte forbudt, og hvis ikke, kræver det normalt tilskrivning.
• Lav ikke spam eller opslag på upassende steder, når du promoverer dit spil. Dette vil sandsynligvis få dig blokeret fra siden, er simpelthen irriterende og vil skade dit omdømme.