Har du en idé til et dataspill og vil gjøre det ekte? Eller har du noen gang lurt på hvordan dataspill skrives? Denne wikiHow lærer deg hvordan du skriver tre grunnleggende dataspill i Python. Du trenger en grunnleggende forståelse av Python og generelle programmeringskonsepter for å utvikle ditt første spill.
Trinn
Del 1 av 3: Lag et tekstbasert spill
Trinn 1. Velg et programmeringsspråk
Alle programmeringsspråk er forskjellige, så du må bestemme hvilket du vil bruke for å skrive spillet ditt. Hvert stort programmeringsspråk støtter tekstinndata, tekstutskrifter og if-konstruksjoner (de viktigste tingene du trenger for et enkelt tekstbasert spill), så utforsk alternativene og avgjør hvilke du føler deg mest komfortabel med og dedikert til å lære. Her er noen faktorer du bør vurdere:
-
Hva brukes språket mest til?
Noen programmeringsspråk, som JavaScript, er designet for å bli brukt på nettet, mens andre, som Python, C eller C ++, er designet for å kjøre dataprogrammer. For spillet ditt, sikte på et språk med et bredere bruksområde, for eksempel Python, C, C ++ eller JavaScript.
-
Hvor vanskelig er det å lære?
Selv om det å skrive et program burde være enkelt nok etter litt øvelse i et vanlig programmeringsspråk (dvs. ikke et spesielt designet for å være forvirrende som Malbolge), er noen vennligere for nybegynnere enn andre. Java og C, for eksempel, vil kreve at du forstår dypere programmeringskonsepter enn noe som Python, som er kjent for sin mer tilgjengelige og rett fram syntaks.
-
Hvor kan jeg bruke den?
Du vil sannsynligvis at folk på forskjellige systemer, for eksempel Linux, Mac eller Windows, skal kunne spille spillet ditt. Så du bør ikke bruke et språk som bare støttes på noen få systemer, for eksempel Visual Basic, som bare støttes på Windows.
Denne artikkelen vil bruke Python for eksemplene på et tekstbasert spill, men du kan slå opp hvordan konseptene gjøres på ethvert annet programmeringsspråk.
Trinn 2. Gjør datamaskinen klar
De to hovedkomponentene du trenger er en tekstredigerer, der du skriver koden din, og en kompilator, som du vil bruke til å gjøre den til et spill. Hvis du vil følge eksemplet i denne artikkelen, bør du installere Python og lære hvordan du kjører programmer. Hvis du vil, kan du sette opp en IDE (Integraded Desktop Environment), som kombinerer redigering, kompilering og feilsøking til et enkelt program. Pythons IDE kalles IDLE. Men du kan også bare bruke hvilken som helst tekstredigerer som støtter ren tekst, for eksempel Notisblokk for Windows, TextEdit for macOS eller Vim for Linux.
Trinn 3. Skriv noen kode for å hilse på spilleren
Spilleren vil vite hva som skjer og hva de må gjøre, så du bør skrive ut litt tekst for dem.
-
Dette gjøres med print () -funksjonen i Python. For å prøve det, åpne en ny fil med.py -utvidelsen, skriv inn følgende kode i den, lagre og kjør den:
print ("Welcome to the number guessing game!") print ("Skriv inn et helt tall mellom 1 og 1000:")
Trinn 4. Generer et tilfeldig tall
La oss lage et tekstbasert spill som ber spilleren gjette riktig nummer. Det første vi må gjøre er å generere et tilfeldig tall i begynnelsen av spillet, slik at spilleren ikke alltid vil gjette det samme tallet. Siden tallet forblir det samme gjennom hele programmet, vil du lagre det tilfeldige tallet i en variabel.
- Python har ikke en innebygd tilfeldig tallfunksjon, men den har et standard bibliotek (dette betyr at brukeren ikke trenger å installere noe ekstra) som gjør det. Så gå til begynnelsen av koden din (før print () -funksjonene) og skriv inn linjen import tilfeldig.
-
Bruk tilfeldig funksjon. Den kalles randint (), er i det tilfeldige biblioteket du nettopp importerte, og tar den minimale og maksimale verdien som tallet kan ha som argument. Så gå tilbake til slutten av koden din og skriv inn følgende linje:
rightNum = random.randint (0, 1000)
Trinn 5. Få innspill fra spilleren
I et spill vil spilleren gjøre noe eller samhandle med noe. I et tekstbasert spill er dette mulig ved å skrive inn tekst. Nå som vi har et tilfeldig tall, bør våre neste kodelinjer be spilleren om å skrive inn sitt beste gjetning.
-
Siden koden du skrev inn, skriver ut instruksjonen for å angi et nummer til spilleren, bør den også lese nummeret de skriver inn. Dette gjøres med input () i Python 3, og raw_input () i Python 2. Du bør skrive i Python 3, da Python 2 snart blir utdatert. Legg til følgende linje i koden for å lagre spillerens input i en variabel som heter nummer:
userNum = input ()
Trinn 6. Gjør spillerens input til en brukbar datatype
Spilleren har lagt inn et tall-nå hva?
-
Gjør spillerens input til et tall. Dette kan høres forvirrende ut fordi de nettopp skrev inn et tall. Men det er en god grunn: Python antar at all input er tekst, eller en "streng", som det kalles i programmering. Denne teksten inneholder nummeret du vil få. Python har en funksjon som konverterer en streng som bare inneholder et tall til tallet inne. Type:
userNum = int (userNum)
Trinn 7. Sammenlign spillerens nummer med riktig nummer
Når spilleren har lagt inn nummeret sitt, må du sammenligne det med det som ble generert tilfeldig. Hvis tallene ikke er de samme, kan spillet få spilleren til å prøve et annet nummer. Hvis tallene stemmer overens, kan du fortelle spilleren at de gjettet riktig, og avslutte programmet. Dette gjøres med følgende kode:
mens userNum! = rightNum: userNum = int (input ())
Trinn 8. Gi spilleren tilbakemelding
Mens du allerede har behandlet inputene deres, vil ikke spilleren se dette. Du må faktisk skrive ut resultatene til spilleren slik at de forstår hva som skjer.
- Sikkert, du kan bare fortelle spilleren om nummeret deres er riktig eller feil. Men med den tilnærmingen må spilleren kanskje gjette 1000 ganger i verste fall, noe som ville være veldig kjedelig.
- Så fortell spilleren om antallet deres er for lite eller for stort. Dette vil redusere antall gjetninger betydelig. Hvis for eksempel spilleren gjetter 500 først, og spillet svarer "For stort. Prøv igjen," vil det bare være 500 mulige tall i stedet for 1000. Dette gjøres med if-konstruksjoner, så bytt utskriften ("Feil. Prøv igjen. ") Med en.
- Vær oppmerksom på at det å kontrollere om to tall er like er gjort med ==, ikke med =. = tildeler verdien til høyre for variabelen til venstre for den!
hvis userNum <rightNum: print ("For liten. Prøv igjen:") hvis userNum> rightNum: print ("For stor. Prøv igjen:")
Trinn 9. Test koden din
Som programmerer bør du være sikker på at koden din fungerer før du vurderer den ferdig.
-
Når du programmerer i python, må du kontrollere at innrykkene er riktige. Koden din skal se slik ut:
importer tilfeldig utskrift ("Velkommen til tallgjettespillet!") print ("Skriv inn et helt tall mellom 1 og 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) mens userNum! = rightNum: if userNum <rightNum: print ("For liten. Prøv igjen:") hvis userNum> rightNum: print ("For stor. Prøv igjen:") userNum = int (input ()) print ("Du gjettet riktig. ")
Trinn 10. Valider inngangen
Spilleren bør ikke kunne bryte spillet ditt ved å skrive inn feil ting. "Validering av inngangen" betyr å sørge for at spilleren skrev inn riktig før han behandlet den.
- Åpne spillet igjen og prøv å skrive inn noe som ikke er et tall. Spillet avsluttes med en ValueError. For å unngå dette kan du implementere en måte å kontrollere om inngangen var et tall.
- Definer en funksjon. Siden validering av inngangen er ganske lang, og du må gjøre det flere ganger, bør du definere en funksjon. Det tar ingen argumenter og returnerer et tall. Skriv først def numInput (): øverst i koden, direkte under tilfeldig import.
- Få spillerens innspill en gang. Bruk input () -funksjonen og tilordne resultatet til variabelen inp.
- Når spillerens inngang ikke er et tall, kan du be dem angi et tall. For å sjekke om en streng er et tall, bruk funksjonene isdigit (), som bare tillater et helt tall, så du trenger ikke å sjekke det separat.
- Hvis inndata er et tall, konverter det fra streng til tall og returner resultatet. Bruk int () -funksjonen for å konvertere strengen til et heltall. Dette vil gjøre konverteringen i hovedkoden unødvendig, og du bør fjerne den derfra.
- Bytt alle anrop til input () i hovedkoden med anrop til numInput ().
- Koden for funksjonen numInput () vil se slik ut:
def numInput (): inp = input () mens ikke inp.isdigit (): print ("Du ble bedt om å skrive inn et helt tall! Skriv inn et helt tall:") inp = input () return int (inp)
Trinn 11. Test spillet igjen
Skriv inn feil ting med vilje for å se hva som skjer, og fikser deretter eventuelle feil når de kommer opp.
Prøv å skrive inn litt tekst når programmet ber deg om et tall. Nå, i stedet for å avslutte med en feilmelding, vil programmet be deg om et nummer igjen
Trinn 12. Foreslå omstart av spillet når det er ferdig
På denne måten kan spilleren spille spillet ditt over lengre tid uten å måtte starte det på nytt.
- Sett all koden bortsett fra importen og funksjonsdefinisjonen i en while-loop. Sett True som betingelse: dette vil alltid være sant, så løkken vil fortsette for alltid.
- Spør spilleren om de vil spille igjen etter at de har gjettet tallet riktig. Bruk funksjonen print ().
- Hvis de svarer "Nei", bryter du ut av utseendet. Hvis de svarer noe annet, fortsett. Bryte ut av en sløyfe gjøres med bruddsetningen.
- Flytt "Welcome to the number guessing game" utenfor while -løkken. Spilleren vil sannsynligvis ikke bli ønsket velkommen hver gang de spiller spillet. Flytt instruksjonsutskriften ("Welcome to the number guessing game!" Over while True:, så den skrives ut bare én gang når brukeren starter det første spillet.
Trinn 13. Test spillet
Du må teste spillet ditt hver gang du implementerer en ny funksjon.
-
Sørg for å svare både "Ja" og "Nei" minst én gang for å være sikker på at begge alternativene fungerer. Slik skal koden din se ut:
importer tilfeldig def numInput (): inp = input () mens ikke inp.isdigit (): print ("Du ble bedt om å skrive inn et helt tall! Skriv inn et helt tall:") inp = input () return int (inp) print ("Velkommen til tallgjettespillet!") Mens True: print ("Skriv inn et helt tall mellom 1 og 1000:") rightNum = random.randint (0, 1000) userNum = numInput () mens userNum! = RightNum: if userNum <rightNum: print ("For liten. Prøv igjen:") hvis userNum> rightNum: print ("For stor. Prøv igjen:") userNum = numInput () print ("Du gjettet riktig.") print ("Do you vil du spille igjen? Angi Nei for å avslutte. ") if input () ==" No ": break
Trinn 14. Skriv andre tekstbaserte spill
Hva med å skrive et teksteventyr neste? Eller et quiz -spill? Vær kreativ.
Tips: Noen ganger er det nyttig å se i dokumentasjonen hvis du ikke er sikker på hvordan noe gjøres eller hvordan en funksjon brukes. Python 3 -dokumentasjonen finnes på https://docs.python.org/3/. Noen ganger gir det også gode resultater å søke etter det du vil gjøre på internett.
Del 2 av 3: Lag et spill med 2D -grafikk
Trinn 1. Velg et grafikkbibliotek
Å lage grafikk er veldig komplisert, og de fleste programmeringsspråk (inkludert Python, C ++, C, JavaScript) gir bare minimal eller ingen støtte for grafikk i kjernen eller standardbibliotekene. Så du må bruke et eksternt bibliotek for å kunne lage grafikk, for eksempel Pygame for Python.
Selv med et grafisk bibliotek, må du bekymre deg for ting som hvordan du viser en meny, hvordan du sjekker hva spilleren klikket på, hvordan du viser brikkene og så videre. Hvis du heller vil fokusere på å utvikle selve spillet, kan du bruke et spillmotorbibliotek som Unity, som enkelt implementerer disse tingene
Denne artikkelen vil bruke Python med Cocos2D for å vise hvordan du lager en enkel 2D -plattformspill. Noen av de nevnte konseptene eksisterer kanskje ikke i andre spillmotorer. Se dokumentasjonen for mer informasjon.
Trinn 2. Installer grafikkbiblioteket du valgte
Cocos2D for Python er enkel å installere. Du kan få det fra https://python.cocos2d.org/index.html, eller ved å kjøre sudo pip3 install cocos2d hvis du bruker Linux.
Trinn 3. Lag en ny katalog for spillet og media
Du vil bruke ting som bilder og lyder i spillet ditt. Hold disse tingene i samme katalog som programmet. Denne katalogen bør ikke inneholde noe annet, slik at du enkelt kan se hvilke eiendeler du har i spillet.
Trinn 4. Opprett en ny kodefil i den nye katalogen
Kall det main, med filtypen for programmeringsspråket. Hvis du skriver et stort og komplekst program der det er fornuftig å ha flere programfiler, vil dette vise deg hvilken som er hovedfilen.
I dette eksemplet oppretter vi en fil som heter main.py som inneholder all koden vår
Trinn 5. Lag spillvinduet
Dette er den grunnleggende forutsetningen for et spill med grafikk.
- Importer nødvendige cocos2d-delmoduler: cocos.director, cocos.scene og cocos.layer. Dette gjøres med fra subModuleName import *, der undermodulnavn er delmodulen du vil importere. Forskjellen mellom fra … import * og import … er at du ikke trenger å sette modulnavnet foran alt du bruker fra den modulen med førstnevnte.
- Definer en underklasse MainMenuBgr for ColorLayer. Dette betyr i utgangspunktet at enhver hovedmenybakgrunn du lager vil oppføre seg som et fargelag med noen endringer du gjør.
- Start kokosdirektøren. Dette vil gi deg et nytt vindu. Hvis du ikke angir en bildetekst, vil vinduet ha samme bildetekst som filnavnet (main.py), som ikke vil se profesjonelt ut. Tillat størrelsen på vinduet ved å sette resizable til True.
- Definer en funksjon showMainMenu. Du bør sette koden for å vise hovedmenyen i en funksjon fordi dette lar deg enkelt gå tilbake til hovedmenyen ved å ringe funksjonen igjen.
- Lag en scene. Scenen består av ett lag for nå, som er et objekt i MainMenuBgr -klassen du definerte.
- Kjør denne scenen 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 enkel plattformspill", resizable = True) showMainMenu ()
Trinn 6. Legg til en hovedmeny i vinduet
I tillegg til selve spillet, må du legge til en meny spilleren kan bruke til å lukke vinduet, blant andre elementer du kan legge til senere.
- Importer cocos.meny (igjen med instruksjonene fra) og pyglet.app (denne gangen med import).
- Definer MainMenu som en underklasse av Meny.
- Still inn justeringen av hovedmenyen. Du må stille den vertikale og horisontale justeringen separat.
- Lag en liste over menyelementer og legg dem til på menyen. Du bør i det minste ha menyelementene "Start Game" og "Quit". Hvert menyelement bør plasseres inne i parenteser. Hvert element må ha en etikett og en tilbakeringingsfunksjon som bestemmer hva som skjer når spilleren klikker på den. For "Start Game" -elementet, bruk startGame -funksjonen (du skriver det snart), for "Quit" -elementet, bruk "pyglet.app.exit" (eksisterer allerede). Lag den faktiske menyen ved å ringe til self.create_menu (menuItems).
- Definer startGame (). Bare legg inn definisjonen for nå, du erstatter det når du skriver selve spillet.
- Gå til stedet i koden din der du opprettet menuSc -scenen, og legg til et MainMenu -objekt i den.
-
Hele koden din skal nå se slik ut:
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 (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 - a simple platformer", resizable = True) showMainMenu ()
Trinn 7. Test koden din
Test koden tidlig, mens den fremdeles er kort og relativt enkel. Deretter kan du identifisere og korrigere eventuelle feil i grunnstrukturen før ting blir for kompliserte.
Koden fra instruksjonene skal åpne et vindu med tittelen "IcyPlat - en enkel plattformspill." Bakgrunnen er lyseblå, og du kan endre størrelsen på vinduet. Når du klikker på "Start spillet" på menyen, bør ingenting skje (ennå). Når du klikker "Avslutt", lukkes vinduet
Trinn 8. Lag en sprite
En sprite er et "spillobjekt" eller et todimensjonalt bilde. Sprites kan være objekter i spillet, ikoner, bakgrunnsdekorasjoner, karakterer og alt annet du kan representere med et bilde i spillet. Vi starter med å lage en sprite for et tegn som spilleren kan samhandle med.
- Importer submodulen cocos.sprite med fra-import-uttrykket.
- Finn et bilde for å representere sprite. Du kan ikke vise en sprite hvis du ikke har et bilde for det. Du kan tegne en, eller du kan få en fra internett (pass på lisensene hvis du planlegger å publisere spillet ditt). For dette eksemplet, gå til https://opengameart.org/content/tux-classic-hero-style og lagre PNG-bildet av pingviner som kjører på datamaskinen din. Beskjær deretter en av de løpende pingvinene, siden du bare trenger en for nå.
- Lag et lag som et nytt objekt i ScrollableLayer -klassen. Lag deretter sprite som et Sprite -objekt og sett posisjonen til (8, 250). For referanse er punktet (0, 0) nederst i venstre hjørne. Dette er ganske høyt, men det vil sørge for at pingvinen ikke setter seg fast i isen.
- Legg sprite til sprite lag.
- Lag en ny scene ut av sprite -laget og kjør den.
def startGame (): figLayer = ScrollableLayer () fig = Sprite ('pingu.png') fig.position = (75, 100) figLayer.add (fig) # gameSc = Scene (figLayer) director.run (gameSc)
Trinn 9. Drøm om landskapet ditt
I de fleste spill bør sprites ikke bare flyte i tomrommet. De burde faktisk stå på en eller annen overflate, med noe rundt seg. I 2D -spill gjøres dette ofte med et flisesett og et flisekart. Flisesettet sier i utgangspunktet hva slags overflatefirkanter og bakgrunnsfirkanter som finnes, og hvordan de ser ut.
- Lag et flisesett. Brikkesettet for dette spillet vil være veldig grunnleggende: en flis for is og en flis for himmel. Isflisen som brukes i dette eksemplet er herfra, under CC-BY-SA 3.0.
- Lag et bilde med fliser. Det er et bilde av alle fliser, som alle må ha samme størrelse (rediger dem hvis de ikke er det) og ha størrelsen du vil se i spillet, ved siden av hverandre. Lagre bildet ditt som icyTiles.png.
-
Lag beskrivelsen av flisesettet. Det er en XML -fil. XML -filen inneholder informasjon om hvor store flisene er i flisbildet, hvilket bilde du skal bruke og hvor du kan finne hvilken flis der. Lag en XML -fil som heter icyTiles.xml med koden nedenfor:
Trinn 10. Lag et flisekart for landskapet ditt
Et flisekart er et kart som definerer hvilken flis som er på hvilken posisjon i ditt nivå. I eksemplet bør du definere en funksjon for å generere flisekart fordi det er veldig kjedelig å designe fliskart for hånd. Et mer avansert spill vil vanligvis ha en slags nivåredigerer, men for å bli kjent med 2D -spillutvikling kan en algoritme gi gode nok nivåer.
- Finn ut hvor mange rader og kolonner som trengs. For dette, del skjermstørrelsen med flisstørrelsen både horisontalt (kolonner) og vertikalt (rader). Rund tallet oppover; du trenger en funksjon av matemodulen for det, så legg til fra matematikkimporttak til importen øverst i koden.
- Åpne en fil for skriving. Dette vil slette alt tidligere innhold i filen, så velg et navn som ingen fil i katalogen har ennå, for eksempel levelMap.xml.
- Skriv åpningskodene inn i filen.
- Lag et fliskart i henhold til algoritmen. Du bruker den i koden nedenfor, eller du kan finne på en på egen hånd. Sørg for å importere randint -funksjonen fra modulen random: det er nødvendig for at koden nedenfor skal fungere, og det du kommer med vil trolig også trenge tilfeldige heltall. Sørg også for å sette himmelfliser og isfliser i forskjellige lag: is er solid, himmelen er ikke.
- Skriv avsluttende koder i filen og lukk filen.
def generereTilemap (): colAmount = tak (800 /16) * 3 # (skjermbredde / flisestørrelse) * 3 rowAmount = tak (600 /16) # skjermhøyde / flisstø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 = False if randint (0, 50) == 10 og i! = 0: # ikke tillat hull på spawnpoint makeHole = Sant for j i området (0, rowAmount): hvis makeHole: tileFile.write ('\ n') annet: hvis j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) if iceHeight <0: # begrens fliser fra å gå for lav iceHeight = randint (1, 5) if iceHeight> rowAmount: # begrens fliser fra å gå for høy 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 ()
Trinn 11. Vis flisekartet
Importer alt fra cocos.tiles og gå deretter inn i startGame -funksjonen for det.
- I begynnelsen av startGame -funksjonen, generer du et flisekart ved hjelp av funksjonen du definerte for det.
- Lag en ny rullebehandler. Gjør dette direkte under linjen der du legger sprite til laget.
- Lag et nytt lag som inneholder flisene, som vil bli lastet fra levelMap.xml -fliskartet som genererer generereTilemap -funksjonen din.
- Legg til det ikke-solide laget, det solide laget og sprite-laget til rullebehandleren, akkurat i denne rekkefølgen. Du kan legge til en z-posisjon hvis du vil.
- I stedet for å lage scenen fra sprite -laget, kan du lage den fra rullebehandleren.
-
StartGame -funksjonen din skal nå se slik ut:
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)
Trinn 12. Test koden din
Du bør teste koden din ofte for å sikre at de nye funksjonene du implementerte virkelig fungerer.
Koden i eksemplet skal nå vise noe isete landskap bak pingvinen. Hvis pingvinen ser ut som den svever langt over isen, har du ikke gjort noe galt, og det blir løst i neste trinn
Trinn 13. Legg til kontrollene
Spilleren har mange flere måter å samhandle med programmet i et 2D-spill enn i et tekstbasert spill. En vanlig inkluderer å flytte figuren når den riktige tasten trykkes.
- Importer alt fra cocos.mapcolliders og fra cocos. actions. Importer også nøkkel fra pyglet.window.
-
"Erklær" noen globale variabler. Globale variabler deles mellom funksjonene. Du kan egentlig ikke deklarere variabler i Python, men du må si at det finnes en global variabel i hovedkoden før du bruker den. Du kan tildele 0 som verdien fordi en funksjon vil ta seg av å tildele den riktige verdien senere. Så legg til under importuttrykkene:
# "erklærer" globale variabler tastatur = 0 scrMang = 0
-
Juster startGame -funksjonen:
- Si at du bruker det globale variabeltastaturet og scrMang. Gjør dette ved å skrive globalt tastatur, scrMang øverst i funksjonen.
- Få vinduet til å lytte til tastaturhendelser.
- Fortell figuren å handle basert på en PlatformerController. Du implementerer den PlatformerController snart.
- Lag en kartkollider for å håndtere kollisjoner mellom de solide flisene 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 (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)
-
Lag en plattformspillkontroller. Dette er det som vil flytte figuren i henhold til tastetrykkene.
- Definer plattformspilleren som en underklasse av handling.
- Definer bevegelseshastigheten, hopphastigheten og tyngdekraften.
- Definer startfunksjonen. Denne funksjonen kalles en gang når plattformspilleren kontrolleren er koblet til figuren. Den bør sette hastigheten til 0 både i x og i y -retning.
- Definer trinnfunksjonen. Det vil gjentas mens scenen er i gang.
- Fortell trinnfunksjonen om å bruke tastaturet til globale variabler og scrMang.
- Få og endre hastigheten. Lagre x og y -hastigheten i separate variabler. Sett x -hastigheten til enten 1 eller -1 (avhengig av om venstre eller høyre tast ble trykket) multiplisert med bevegelseshastigheten. Legg tyngdekraften til y -hastigheten. Multipliser det med nedetid, så det fungerer på samme måte på tregere enheter. Hvis mellomromstasten trykkes og figuren står på bakken, hopper du ved å endre y -hastigheten til hopphastighet.
- Beregn hvor figuren skal bevege seg. La deretter kollisjonsbehandleren justere den posisjonen hvis den er inne i en solid flis. Til slutt flytter du figuren til den nye justerte posisjonen.
- Still fokus for rullende leder på figuren. Dette får kameraet til å bevege seg på en rimelig måte når figuren beveger seg.
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, ruller hvis dt> 0,1: # ikke gjør noe mens nedetid for stor retur vx, vy = self.target.velocity vx = (tastatur [tast. RIGHT] - tastatur [tast. 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 (*nytt.senter)
Trinn 14. Test koden din
Hvis du fulgte eksemplet, skal du nå kunne flytte pingvinen med piltastene og hoppe ved å trykke på mellomromstasten. Også pingvinen skulle nå falle ned i stedet for å sveve over bakken.
Trinn 15. Lag en avslutning på spillet
Selv de spillene som kan fortsette i det uendelige bør ha muligheten til å tape. Siden nivået du gjorde i eksemplet med en funksjon har en slutt, må du også gjøre det mulig å vinne ved å komme til den enden. Ellers ville spilleren bare hoppe rundt på isblokkene der, noe som ville bli kjedelig.
-
Inne i plattformspilleren kontrolleren, etter fokus satt, få figurens x og y posisjon. Hvis y -posisjonen er mindre enn 0, kaller du funksjonen finishGame () (du skriver det senere) med "Game Over" som argument. Hvis x -posisjonen er større enn størrelsen på skjermen multiplisert med 3 (du hadde angitt den som nivåstø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 finishMeny. Det skal være som hovedmenyklassen du definerte før, men i stedet for å ha en tom streng som tittel, bør den bruke en variabel tekst som _init_ -funksjonen tar som argument. Menyelementene skal merkes med "Prøv igjen" og "Avslutt" nå, men funksjonene de kaller forblir de samme.
class FinishMenu (Meny): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Prøv igjen", startGame)), (MenuItem ("Avslutt", pyglet.app.exit))] self.create_menu (menuItems)
-
Definer funksjonen finishGame (). Det bør ta tekst som et argument. Det bør lage en scene ut av hovedmenyens bakgrunn, en FinishMenu med tekstargumentet som sendes videre til denne menyen. Da burde den kjøre denne scenen.
def finishGame (tekst): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (tekst)) director.run (menuSc)
Trinn 16. Legg til studiepoeng
Det er her du får ta æren for den fantastiske koden din, i tillegg til å gi æren til alle andre som hjalp deg på veien. Hvis du brukte et bilde fra et annet nettsted (med tillatelse), må du tilskrive bildet til skaperen.
-
Lag en fil KREDITTER og skriv inn alle kredittene dine der, slik:
Pingvin: Kelvin Shadewing, under CC0 Isblokk: Michał Banas digit1024 på opengameart.org under CC-BY-SA 3.0
- Gå tilbake til Python -koden og importer etiketten fra cocos.text.
-
Definer en underklasse Credits of Layer. I funksjonen _init_, les CREDITS -filen og lag en tekstetikett i riktig posisjon ut av 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 =" left ", anchor_y =" top ") credLabel.position = 25, 500- (i +1)*40 self.add (credLabel)
- Gå til hovedmenyklassen og legg til et menyelement merket "Credits" som kaller funksjonen showCredits når det klikkes.
-
Definer en underklasse BackToMainMenuButton of Menu. Gjør dette til en meny med ett element, merket "Tilbake", som kaller showMainMenu -funksjonen. Denne "menyen", som mer ligner en knapp, bør være vertikalt justert til bunnen og horisontalt til toppen.
class BackToMainMenuButton (Meny): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem ("Back"), showMainMu.) create_menu (menyelementer)
-
Definer funksjonen showCredits. Det bør lage en scene av et MainMenuBgr -lag og et Credits -lag og kjøre den scenen.
def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc)
Trinn 17. Sjekk koden din
Når du tror du er ferdig med koden din, bør du se over alt igjen. Dette kan hjelpe deg med å legge merke til om noe kan optimaliseres, eller om det er noen unødvendige linjer du glemte å slette. Hvis du fulgte eksemplet, skal hele koden din se slik ut:
fra cocos.director import * fra cocos.menu import * fra cocos.scene import * fra cocos.layer import * fra cocos.sprite import * fra cocos.flies import * fra cocos. mapcolliders import * fra cocos. actions import * fra cocos.text import Etikett import pyglet.app fra pyglet.window importnøkkel fra matematisk importtak fra tilfeldig import randint # "deklarerer" globale variabler tastatur = 0 scrMang = 0 klasse MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) klasse 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) 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 (cred)): credLabel = Label (creds , font_size = 32, anchor_x = "left", anchor_y = "top") credLabel.position = 25, 500- (i+1)*40 self.add (credLabel) klasse BackToMainMenuButton (Meny): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = VENSTRE 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 ("Prøv igjen", 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 trinn (selv, dt): globalt tastatur, ruller hvis dt> 0,1: # ikke gjør noe mens nedetid er for stor tilbake vx, vy = self.target.velocity vx = (tastatur [key. RIGHT] - tastatur [key. LEFT]) * self. MOVE_SPEED vy += self. GRAVITY * dt if self.on _ground 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 = roof (800/16) * 3 # (skjermbredde / flisestørrelse) * 3 rowAmount = roof (600/16) # skjermhøyde / flisestørrelse tileFile = åpen ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) for i i området (0, colAmount): tileFile.write ('') makeHole = Falske hvis rand int (0, 50) == 10 og i! = 0: # ikke tillat hull på spawnpoint makeHole = Sant for j i området (0, rowAmount): if makeHole: tileFile.write ('\ n') annet: if j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight+5) if iceHeight <0: # begrens fliser fra å gå for lav iceHeight = randint (1, 5) hvis iceHeight> rowAmount: # begrens fliser fra å gå for høy iceHeight = randint (int (rowAmount/2) -5, int (rowAmount/2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') for i in range (0, colAmount): tileFile.write (' ') for j in range (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 (nsoliTiles, z = -1) legg til (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 ()
Trinn 18. Ferdig
Test spillet nå. Når du programmerer noe, må du sjekke om det fungerer når du har implementert noe nytt. Det kan også være lurt å spille spillet du skrev en stund.
Del 3 av 3: Publisering av et spill
Trinn 1. Skriv ned avhengighetene
Alle som bruker en annen datamaskin vil ikke ha samme programvare og bibliotek installert som deg. Så du må sørge for at alle som installerer spillet vet nøyaktig hva de trenger for å kjøre det. Du trenger ikke å skrive ned alle avhengigheter av alle avhengigheter av alle avhengigheter og så videre, men du bør i det minste skrive avhengighetene til pakkene dine og deres avhengigheter.
Trinn 2. Kontroller at du har tillatelse til å bruke alle medier
Dette gjelder all grafikk, inkludert 3D -modeller, musikk, dialog, musikk, biblioteker og rammer du brukte for spillet ditt. Alt du ikke skrev selv.
- Ofte er det noen betingelser, som å måtte kreditere forfatteren eller dele endringer av media under samme lisens. Noen ganger kan du bruke grafikk uten å tilskrive skaperne så lenge du ikke tar betalt for spillet. Hvis du må kreditere forfatteren, gjør du det på et godt synlig sted, som en "Credits" -kategori i spillet ditt.
- Det er også medier med krav på opphavsrett og ingen lisens spesifisert, noen ganger med tekst som "Alle rettigheter forbeholdt". Hvis det er tilfelle, må du få eksplisitt tillatelse fra forfatteren før du inkluderer det i spillet ditt.
- Biblioteker blir vanligvis utgitt under lisenser som gjør at de kan brukes som bibliotek. Et bemerkelsesverdig unntak er GPL uten å koble unntak: En slik lisens tillater bare å bruke den i et program med visse lisenser. Og du bør alltid lese minst de grunnleggende punktene i lisensen for å være sikker på at det du gjør med media eller bibliotek er tillatt.
Advarsel: Bruk av medier eller biblioteker på en måte som lisensen ikke tillater i et spill du publiserer, kan få deg til alvorlige juridiske problemer. Så enten spør forfatteren eller unngå mediebiten helt hvis du er usikker på om bruken din er tillatt.
Trinn 3. Bestem deg for vilkårene du vil publisere spillet ditt på
Vil du selge spillet ditt? Vil du la andre bruke bildene og ideene dine? Selv om du må være forsiktig med mediene du bruker i prosjektet, kan du vanligvis bestemme hvordan du vil la andre bruke spillet ditt. Du kan bruke en Creative Commons CC0 -lisens for å frigjøre spillet ditt i det offentlige domene. For å tillate distribusjon og modifikasjon under visse betingelser, mens du beholder noen rettigheter, kan du prøve Gnu General Public License (GPL) eller Berkeley Software Distribution (BSD) -lisensen. Eller du kan gjøre programvaren din proprietær, noe som betyr at ingen har lov til å distribuere eller endre den uten din tillatelse.
Selv om det er mulig å tjene penger ved å selge spill, er det lite sannsynlig at folk vil kjøpe ditt første spill som vanligvis har få funksjoner og ikke noe spesielt. Hvis et gratis program ikke fungerer, vil folk som lastet det ned, bare bli skuffet. Hvis de betalte for det, vil de imidlertid kreve pengene tilbake, noe som forårsaker flere problemer for både deg og brukerne. Så vurder å gjøre de første programmene dine tilgjengelige gratis
Trinn 4. Bestem hvordan du vil publisere spillet ditt
Hver metode har noen fordeler og ulemper, så du må bestemme selv.
-
Publisering på et nettsted:
Hvis du har et nettsted, kan du laste opp spillet ditt for å gjøre det tilgjengelig for nedlasting. Sørg for å gi klare instruksjoner om hvordan du installerer programvaren, samt alle nødvendige avhengigheter. Ulempen med dette er at spillere må installere avhengigheter manuelt, noe som kan være vanskelig for noen mennesker.
-
Lage en pakke for en pakkeleder:
Det er forskjellige pakkebehandlere, som apt, Yum og Homebrew, som gjør det enkelt for folk å installere apper i Linux- og Linux-baserte miljøer. De har alle forskjellige pakkeformater. Det gode med pakker er at de automatisk installerer alle avhengigheter (hvis du konfigurerer dem riktig). Så spilleren trenger bare å installere pakken din og kan deretter spille spillet. Problemet er at det er mange forskjellige pakkebehandlere på forskjellige plattformer, så du må jobbe litt med å tilby pakker for alle de vanligste.
Trinn 5. Direkte oppmerksomhet til programmet ditt
Vurder å laste opp programmet ditt til et stort pakkeoppbevaringssted, som de som Ubuntu og Debian vedlikeholder, for å gjøre det enkelt å installere. Post også i passende fora, for eksempel prosjektdelen av GameDev eller en del av tigSource. Men ikke bli skuffet hvis dine første kamper ikke blir berømte. Hvis du har en ide om at mange liker det, kan spillet ditt bli kjent.
Tips
- Vær tålmodig og villig til å lære. Programmering kan til tider være frustrerende!
- Hvis du lurer på hvordan noe gjøres i et annet spill, og spillet er åpen kildekode, kan du se på kildekoden.
- Når du leter etter medier, kan du prøve å finne innhold som er i det offentlige området. Søk etter "Creative Commons" eller "Public Domain" bilder og musikk, og bruk nettsteder som https://opengameart.org eller
- Ikke kopier store biter av kode uten å sjekke lisensen. Det er ofte forbudt, og hvis ikke, krever det vanligvis attribusjon.
- Ikke lag spam eller legg ut på upassende steder når du markedsfører spillet ditt. Dette vil sannsynligvis blokkere deg fra siden, er ganske enkelt irriterende og vil skade omdømmet ditt.
