Com programar jocs d'ordinador (amb imatges)

2024 Autora: Robert Blare | [email protected]. Última modificació: 2024-01-31 12:14

Tens una idea per a un joc d'ordinador i el vols fer real? O us heu preguntat mai com s’escriuen els jocs d’ordinador? Aquest wikiHow us ensenya a escriure tres jocs bàsics d’ordinador a Python. Necessitareu una comprensió bàsica de Python i conceptes generals de programació per desenvolupar el vostre primer joc.

Passos

Primera part de 3: fer un joc basat en text

Pas 1. Trieu un llenguatge de programació

Tots els llenguatges de programació són diferents, de manera que haurà de decidir quin utilitzar per escriure el seu joc. Tots els llenguatges de programació principals admeten l’entrada de text, la sortida de text i les construccions de si (les coses principals que necessiteu per a un simple joc basat en text), així que exploreu les opcions i decidiu amb què us sentiu més còmode i dedicat a l’aprenentatge. A continuació, es detallen alguns factors:

Per a què serveix l'idioma més utilitzat?

Alguns llenguatges de programació, com JavaScript, estan dissenyats per utilitzar-se al web, mentre que d'altres, com Python, C o C ++, estan dissenyats per executar programes d'ordinador. Per al vostre joc, busqueu un llenguatge amb un rang d’ús més ampli, com ara Python, C, C ++ o JavaScript.
Què costa aprendre?

Tot i que escriure un programa hauria de ser prou fàcil després de practicar qualsevol llenguatge de programació normal (és a dir, no un dissenyat específicament per confondre com Malbolge), alguns són més simpàtics per a principiants que altres. Java i C, per exemple, requeriran que entengueu conceptes de programació més profunds que alguna cosa com Python, que és conegut per la seva sintaxi més accessible i directa.
On puc utilitzar-lo?

Probablement voleu que la gent de diferents sistemes, com Linux, Mac o Windows, pugui jugar al vostre joc. Per tant, no heu d’utilitzar un llenguatge que només s’admeti en alguns sistemes, com Visual Basic, que només s’admet al Windows.

En aquest article s'utilitzarà Python per als exemples d'un joc basat en text, però podeu consultar com es fan els conceptes en qualsevol altre llenguatge de programació.

Pas 2. Prepareu l'ordinador

Els dos components principals que necessiteu són un editor de text, en el qual escrivireu el vostre codi, i un compilador, que us servirà per convertir-lo en un joc. Si voleu seguir l’exemple d’aquest article, heu d’instal·lar Python i aprendre a executar programes. Si voleu, podeu configurar un IDE (Integraded Desktop Environment), que combina l'edició, la compilació i la depuració en un sol programa. L’IDE de Python s’anomena IDLE. Però també podeu utilitzar qualsevol editor de text que admeti text pla, com ara Bloc de notes per a Windows, TextEdit per a macOS o Vim per a Linux.

Pas 3. Escriviu un codi per saludar el reproductor

El jugador voldrà saber què està passant i què han de fer, així que hauríeu d’imprimir algun text per a ells.

Això es fa amb la funció print () a Python. Per provar-lo, obriu un fitxer nou amb l'extensió.py, introduïu-hi el codi següent, deseu-lo i executeu-lo:
```
print ("Benvingut al joc d'endevinalles!") print ("Introduïu un número enter entre 1 i 1000:")
```

Pas 4. Generar un número aleatori

Fem un joc basat en text que demana al jugador que endevini el número correcte. El primer que haurem de fer és generar un número aleatori al començament del joc, de manera que el jugador no sempre endevina el mateix nombre. Com que el número seguirà sent el mateix a tot el programa, voldreu emmagatzemar el número aleatori en una variable.

Python no té una funció de número aleatori integrada, però sí que té una biblioteca estàndard (això significa que l'usuari no haurà d'instal·lar res addicional) que sí. Aneu al principi del codi (abans de les funcions print ()) i escriviu la importació de línia aleatòriament.
Utilitzeu la funció aleatòria. Es diu randint (), es troba a la biblioteca aleatòria que acabeu d’importar i pren el valor mínim i màxim que el número pot tenir com a argument. Torneu al final del vostre codi i introduïu la línia següent:
```
rightNum = random.randint (0, 1000)
```

Pas 5. Obteniu informació del reproductor

En un joc, el jugador vol fer alguna cosa o interactuar amb alguna cosa. En un joc basat en text, això és possible introduint text. Ara que tenim un número aleatori, les nostres properes línies de codi haurien de demanar al jugador que introdueixi la seva millor conjectura.

Com que el codi que heu introduït imprimeix la instrucció per introduir un número al reproductor, també hauria de llegir-lo. Això es fa amb input () a Python 3 i raw_input () a Python 2. Heu d’escriure a Python 3, ja que Python 2 quedarà obsolet aviat. Afegiu la línia següent al vostre codi per emmagatzemar l'entrada del jugador en una variable anomenada número:
```
userNum = input ()
```

Pas 6. Converteix l'entrada del reproductor en un tipus de dades útil

El jugador ha introduït un número, ara què?

Feu que l’entrada del jugador sigui un número. Ara pot semblar confús perquè acaben d’introduir un número. Però hi ha una bona raó: Python assumeix que totes les entrades són text o una "cadena", com es diu a la programació. Aquest text conté el número que voleu obtenir. Python té una funció que converteix una cadena que només conté un número al número que hi ha a dins. Tipus:
```
userNum = int (UserNum)
```

Pas 7. Compareu el número del jugador amb el número correcte

Un cop el jugador hagi introduït el seu número, l’haureu de comparar amb el que es va generar aleatòriament. Si els números no són els mateixos, el vostre joc pot fer que el jugador provi un altre número. Si els números coincideixen, podeu dir al jugador que ho va endevinar correctament i deixar el programa. Això es fa amb el codi següent:

mentre que UserNum! = rightNum: userNum = int (input ())

Pas 8. Doneu comentaris al jugador

Tot i que ja heu processat la seva entrada, el reproductor no ho veurà. Haureu d'imprimir els resultats al reproductor perquè entenguin què passa.

Segurament, podríeu dir al jugador si el seu número és correcte o incorrecte. Però amb aquest enfocament, és possible que el jugador hagi d’endevinar 1000 vegades en el pitjor dels casos, cosa que seria molt avorrit.
Per tant, digueu al jugador si el seu número és massa petit o massa gran. Això reduirà significativament el seu nombre d’endevinalles. Si, per exemple, el jugador endevina 500 primer i el joc respon "Massa gran. Torneu-ho a provar", només hi haurà 500 números possibles en lloc de 1000. Això es fa amb construccions if-if, per tant, substituïu la lletra ("incorrecta." Torneu-ho a provar. ") Amb un.
Tingueu en compte que comprovar si dos números són iguals es fa amb ==, no amb =. = assigna el seu valor dret a la variable que hi ha a l'esquerra.

si userNum <rightNum: print ("Massa petit. Torneu-ho a provar:") si userNum> rightNum: print ("Massa gran. Torneu-ho a provar:")

Pas 9. Proveu el vostre codi

Com a programador, heu d'estar segur que el vostre codi funciona abans de considerar-lo acabat.

Quan programeu en python, assegureu-vos que obteniu les sagnies correctes. El vostre codi hauria de ser així:

importa imprimir aleatòriament ("Benvingut al joc d'endevinalles!") imprimir ("Introduïu un nombre enter entre 1 i 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) mentre userNum! = rightNum: si userNum <rightNum: print ("Massa petit. Torneu-ho a provar:") si userNum> rightNum: print ("Massa gran. Torneu-ho a provar:") userNum = int (input ()) print ("Heu endevinat correctament.")

Pas 10. Valideu l'entrada

El jugador no hauria de ser capaç de trencar el vostre joc simplement introduint una cosa equivocada. "Validar l'entrada" significa assegurar-se que el reproductor ha introduït el correcte abans de processar-la.

Obre de nou el joc i intenta introduir qualsevol cosa que no sigui un número. El joc sortirà amb un ValueError. Per evitar-ho, podeu implementar una manera de comprovar si l'entrada era un número.
Definiu una funció. Com que validar l'entrada és bastant llarg i heu de fer-ho diverses vegades, haureu de definir una funció. No necessitarà arguments i retornarà un número. En primer lloc, escriviu def numInput (): a la part superior del codi, directament a sota de la importació aleatòria.
Obteniu les aportacions del jugador una vegada. Utilitzeu la funció input () i assigneu el resultat a la variable inp.
Quan l'entrada del jugador no és un número, demaneu-li que introdueixi un número. Per comprovar si una cadena és un número, utilitzeu les funcions isdigit (), que només permeten un nombre enter, de manera que no haureu de comprovar-ho per separat.
Si l'entrada és un número, converteix-lo de cadena a número i torna el resultat. Utilitzeu la funció int () per convertir la cadena en un enter. Això farà que la conversió del codi principal sigui innecessària i que l’haureu d’eliminar.
Substituïu totes les trucades a input () del codi principal per trucades a numInput ().
El codi de la funció numInput () serà així:

def numInput (): inp = input () mentre que no inp.isdigit (): print ("Se us va dir que introduïu un nombre enter! Introduïu un número enter:") inp = input () return int (inp)

Pas 11. Torneu a provar el joc

Introduïu les coses equivocades a propòsit per veure què passa i, a continuació, corregiu els errors a mesura que apareguin.

Intenteu introduir text quan el programa us demani un número. Ara, en lloc de sortir amb un missatge d'error, el programa us tornarà a demanar un número

Pas 12. Suggeriu reiniciar el joc quan acabi

D’aquesta manera, el jugador podria jugar el vostre joc durant més temps sense haver de reiniciar-lo constantment.

Poseu tot el codi excepte la importació i la definició de la funció en un bucle mentre. Establiu True com a condició: això sempre serà cert, de manera que el bucle continuarà per sempre.
Pregunteu al jugador si vol tornar a jugar després d’haver endevinat el número correctament. Utilitzeu la funció print ().
Si responen "No", sortiu de la imatge. Si responen a qualsevol altra cosa, continueu. El trencament d’un bucle es fa amb la sentència break.
Mou el "Benvingut al joc d'endevinalles numèriques" fora del bucle while. Probablement, el jugador no vol ser rebut cada vegada que juga. Mou la instrucció d'impressió ("Benvingut al joc d'endevinalles numèriques!" Per sobre de True, mentre que només s'imprimirà una vegada quan l'usuari comenci el primer joc.

Pas 13. Proveu el joc

Haureu de provar el joc cada vegada que implementeu una nova funció.

Assegureu-vos de respondre "Sí" i "No" almenys una vegada per assegurar-vos que les dues opcions funcionin. A continuació s’explica el vostre codi:

import aleatori defInput (): inp = input () mentre no inp.isdigit (): print ("Se us va dir que introduïu un nombre enter! Introduïu un número enter:") inp = input () return int (inp) print ("Benvingut al joc d'endevinalles!") Mentre és True: print ("Introduïu un nombre enter entre 1 i 1000:") rightNum = random.randint (0, 1000) userNum = numInput () mentre userNum! = RightNum: si userNum <rightNum: print ("Massa petit. Torneu-ho a provar:") si userNum> rightNum: print ("Massa gran. Torneu-ho a provar:") userNum = numInput () print ("Heu endevinat correctament.") voleu tornar a jugar? Introduïu No per sortir. ") if input () ==" No ": break

Pas 14. Escriviu altres jocs basats en text

Què tal escriure una aventura de text? O un joc de preguntes? Sigues creatiu.

Consell: De vegades és útil consultar la documentació si no esteu segur de com es fa alguna cosa o de com s’utilitza una funció. La documentació de Python 3 es troba a https://docs.python.org/3/. De vegades, la cerca del que vulgueu fer a Internet també proporciona bons resultats.

Part 2 de 3: Fer un joc amb gràfics 2D

Pas 1. Trieu una biblioteca de gràfics

Fer gràfics és molt complicat i la majoria de llenguatges de programació (inclosos Python, C ++, C, JavaScript) només ofereixen suport mínim o fins i tot nul per als gràfics del nucli o de les biblioteques estàndard. Per tant, haureu d’utilitzar una biblioteca externa per poder crear gràfics, per exemple Pygame for Python.

Fins i tot amb una biblioteca de gràfics, us haureu de preocupar de coses com mostrar un menú, com comprovar en què ha fet clic el reproductor, com mostrar les fitxes, etc. Si preferiu centrar-vos en el desenvolupament del joc real, podeu utilitzar una biblioteca de motors de jocs com Unity, que implementa aquestes coses fàcilment

En aquest article s’utilitzarà Python amb Cocos2D per mostrar com fer un simple plataformes 2D. És possible que alguns dels conceptes esmentats no existeixin en altres motors de jocs. Consulteu la seva documentació per obtenir més informació.

Pas 2. Instal·leu la biblioteca de gràfics que trieu

Cocos2D per a Python és fàcil d'instal·lar. Podeu obtenir-lo a https://python.cocos2d.org/index.html o executant sudo pip3 install cocos2d si utilitzeu Linux.

Pas 3. Feu un directori nou per al vostre joc i suports

Utilitzaràs coses com imatges i sons al joc. Conserveu aquestes coses al mateix directori que el programa. Aquest directori no hauria de contenir res més perquè pugueu veure fàcilment quins recursos teniu al joc.

Pas 4. Creeu un fitxer de codi nou al directori nou

Anomeneu-lo principal, amb l'extensió de fitxer del vostre llenguatge de programació. Si escriviu un programa gran i complex on té sentit tenir diversos fitxers de programa, us mostrarà quin és el fitxer principal.

En aquest exemple, crearem un fitxer anomenat main.py que contindrà tot el nostre codi

Pas 5. Creeu la finestra del joc

Aquest és el requisit previ bàsic per a un joc amb gràfics.

Importeu els sub-mòduls cocos2d necessaris: cocos.director, cocos.scene i cocos.layer. Això es fa amb importació subModuleName *, on el nom del sub-mòdul és el submòdul que voleu importar. La diferència entre des de … importa * i importa … és que no haureu de posar el nom del mòdul davant de tot el que utilitzeu des del mòdul amb el primer.
Definiu una subclassa MainMenuBgr de ColorLayer. Això significa bàsicament que qualsevol fons del menú principal que creeu es comportarà com una capa de color amb alguns canvis que feu.
Comença el director de cocos. Això us donarà una nova finestra. Si no definiu cap títol, la finestra tindrà el mateix títol que el nom del fitxer (main.py), que no semblarà professional. Permet canviar la mida de la finestra mitjançant el canvi de mida a True.
Definiu una funció showMainMenu. Haureu de posar el codi per mostrar el menú principal en una funció perquè això us permetrà tornar fàcilment al menú principal tornant a trucar a la funció.
Crea una escena. L'escena consta d'una capa per ara, que és un objecte de la classe MainMenuBgr que heu definit.
Executeu aquesta escena a la finestra.

de cocos.director import * de cocos.scene import * de cocos.layer import * class MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenu, self)._ init _ (0, 200, 255, 255) def showMainMenu (): menuSc = Scene (MainMenuBgr ()) director.run (menuSc) director.init (caption = "IcyPlat - a simple platformer", redimensionable = True) showMainMenu ()

Pas 6. Afegiu un menú principal a la finestra

A més del joc real, haureu d’afegir un menú que el jugador pot utilitzar per tancar la finestra, entre altres elements que podeu afegir més endavant.

Importeu cocos.menu (de nou amb la instrucció from) i pyglet.app (aquesta vegada amb importació).
Definiu MainMenu com a subclase de Menú.
Definiu l'alineació del menú principal. Heu d’establir l’alineació vertical i horitzontal per separat.
Creeu una llista d'elements del menú i afegiu-los al menú. Com a mínim, haureu de tenir els elements del menú "Inicia el joc" i "Surt". Tots els elements del menú s’han de col·locar dins de claudàtors. Cada element ha de tenir una etiqueta i una funció de devolució de trucada que determini què passa quan el jugador hi fa clic. Per a l'element "Inicia el joc", utilitzeu la funció startGame (l'escrivireu aviat), per a l'element "Surt", utilitzeu "pyglet.app.exit" (ja existeix). Creeu el menú real trucant a self.create_menu (menuItems).
Definiu startGame (). Només cal que introduïu la definició per ara, la substituireu quan escriviu el joc real.
Aneu al lloc del codi on heu creat l’escena menuSc i afegiu-hi un objecte MainMenu.

Ara el codi sencer hauria de tenir el següent aspecte:

de cocos.director import * de cocos.menu import * de cocos.scene import * de cocos.layer import * import pyglet.app class MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) class MainMenu (Menu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTRE self.menu_halign = CENTRE 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: un simple joc de plataformes", redimensionable = True) showMainMenu ()

Pas 7. Proveu el vostre codi

Proveu el codi abans d’hora, encara que és curt i relativament senzill. A continuació, podeu identificar i corregir qualsevol error a l’estructura bàsica abans que les coses es compliquin massa.

El codi de les instruccions hauria d'obrir una finestra amb el títol "IcyPlat: un simple joc de plataformes". El fons és de color blau clar i podeu canviar la mida de la finestra. Quan feu clic a "Inici del joc" al menú, no hauria de passar res (encara). Quan feu clic a "Surt", la finestra es tancarà

Pas 8. Creeu un sprite

Un sprite és un "objecte de joc" o una imatge bidimensional. Els sprites poden ser objectes del joc, icones, decoracions de fons, personatges i qualsevol altra cosa que pugueu representar amb una imatge del joc. Començarem creant un sprite per a un personatge amb el qual el jugador pugui interactuar.

Importeu el submòdul cocos.sprite amb l’expressió from-import.
Cerqueu una imatge que representi el sprite. No podeu mostrar un sprite si no en teniu cap. Podeu dibuixar-ne una o obtenir-ne una d’Internet (tingueu en compte les llicències, però, si teniu previst publicar el vostre joc). Per a aquest exemple, aneu a https://opengameart.org/content/tux-classic-hero-style i deseu la imatge-p.webp" />
Creeu una capa com a objecte nou de la classe ScrollableLayer. A continuació, creeu el sprite com a objecte Sprite i configureu la seva posició a (8, 250). Com a referència, el punt (0, 0) es troba a l'extrem inferior esquerre. Això és força elevat, però s’assegurarà que el pingüí no s’enganxi al gel.
Afegiu el sprite a la capa del sprite.
Creeu una nova escena fora de la capa del sprite i executeu-la.

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

Executeu el codi. Després de fer clic, hauríeu de veure una petita figura de pingüí (o qualsevol cosa que hàgiu dibuixat) sobre un fons negre Començar el joc.

Pas 9. Somia el teu paisatge

A la majoria de jocs, els vostres sprites no només haurien de surar al buit. De fet, haurien de situar-se sobre alguna superfície, amb alguna cosa al seu voltant. Als jocs 2D, això es fa sovint amb un joc de fitxes i un mapa de fitxes. El conjunt de rajoles diu bàsicament quin tipus de quadrats superficials i quadrats de fons existeixen i com són.

Creeu un conjunt de rajoles. El conjunt de fitxes per a aquest joc serà molt bàsic: una fitxa per al gel i una fitxa per al cel. La rajola de gel que s’utilitza en aquest exemple és d’aquí, sota CC-BY-SA 3.0.
Creeu una imatge del conjunt de mosaics. Aquesta és una imatge de totes les fitxes, que han de tenir totes la mateixa mida (editeu-les si no ho són) i tenen la mida que voleu veure al joc, una al costat de l’altra. Deseu la vostra imatge com a icyTiles.png.
Creeu la descripció del conjunt de mosaics. Es tracta d’un fitxer XML. El fitxer XML conté informació sobre la mida de les rajoles a la imatge del conjunt de rajoles, quina imatge heu d’utilitzar i on podeu trobar quina rajola hi ha. Creeu un fitxer XML anomenat icyTiles.xml amb el codi següent:
```
     
```

Pas 10. Feu un mapa de rajoles per al vostre paisatge

Un mapa de rajoles és un mapa que defineix quina rajola es troba en quina posició del vostre nivell. A l'exemple, hauríeu de definir una funció per generar mapes de rajoles perquè dissenyar manualment mapes de rajoles és molt tediós. Un joc més avançat sol tenir algun tipus d’editor de nivell, però per familiaritzar-se amb el desenvolupament de jocs en 2D, un algorisme pot proporcionar nivells prou bons.

Esbrineu quantes files i columnes calen. Per a això, dividiu la mida de la pantalla per la mida de la rajola tant horitzontalment (columnes) com verticalment (files). Arrodoneix el número cap amunt; necessiteu una funció del mòdul matemàtic per a això, així que afegiu des del límit d'importació matemàtica a les importacions de la part superior del codi.
Obriu un fitxer per escriure. Això esborrarà tot el contingut anterior del fitxer, així que trieu un nom que encara no tingui cap fitxer al directori, com ara levelMap.xml.
Escriviu les etiquetes d'obertura al fitxer.
Generar un mapa de mosaics segons l'algorisme. Utilitzeu el que apareix al codi següent o podeu obtenir-ne un tot sol. Assegureu-vos d'importar la funció randint des del mòdul aleatori: és necessari que funcioni el codi següent i, probablement, tot el que tingueu també necessitarà enters aleatoris. A més, assegureu-vos de posar rajoles de cel i rajoles de gel en diferents capes: el gel és sòlid, el cel no.
Escriviu les etiquetes de tancament al fitxer i tanqueu-lo.

def generateTilemap (): colAmount = ceil (800/16) * 3 # (amplada de pantalla / mida de rajola) * 3 rowAmount = ceil (600/16) # altura de pantalla / mida de rajola tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) per a l'interval (0, colAmount): tileFile.write ('') makeHole = False si randint (0, 50) == 10 i i! = 0: # no permet forats al punt de generació makeHole = True per a j dins de l'interval (0, rowAmount): si makeHole: tileFile.write ('\ n') else: si j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight + 5) si iceHeight <0: # limita les fitxes per anar massa baix IceHeight = randint (1, 5) if iceHeight> rowAmount: # limite the tiles from going too high iceHeight = randint (int (rowAmount / 2) -5, int (rowAmount / 2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') per a i en l'interval (0, colAmount): tileFile.write ('') per a j en l'interval (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Pas 11. Mostra el mapa de rajoles

Importeu-ho tot des de cocos.tiles i, a continuació, aneu a la funció startGame.

Al començament de la funció startGame, genereu un mapa de mosaics mitjançant la funció que hàgiu definit.
Creeu un nou gestor de desplaçament. Feu-ho directament sota la línia on afegiu el sprite a la seva capa.
Creeu una capa nova que contingui les rajoles, que es carregaran des del mapa de rajoles levelMap.xml que ha generat la funció generateTilemap.
Afegiu la capa no sòlida, la capa sòlida i la capa sprite al gestor de desplaçament, exactament en aquest ordre. Podeu afegir una posició z si voleu.
En lloc de crear l’escena a partir de la capa sprite, creeu-la des del gestor de desplaçament.

La funció startGame ara hauria de ser així:

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

Pas 12. Proveu el vostre codi

Haureu de provar el vostre codi sovint per assegurar-vos que les noves funcions que heu implementat funcionen realment.

El codi de l’exemple ara hauria de mostrar un paisatge gelat darrere del pingüí. Si el pingüí sembla que planeja molt sobre el gel, no heu fet res dolent i es solucionarà al següent pas

Pas 13. Afegiu els controls

El jugador té moltes més maneres d’interactuar amb el programa en un joc 2D que en un joc basat en text. Un de comú inclou moure la seva figura quan es prem la tecla correcta.

Importeu tot de cocos.mapcolliders i de cocos.actions. Importeu també la clau des de pyglet.window.
"Declareu" algunes variables globals. Les variables globals es comparteixen entre funcions. Realment no es poden declarar variables a Python, però heu de dir que existeix una variable global al codi principal abans d’utilitzar-la. Podeu assignar 0 com a valor perquè una funció s'encarregarà d'assignar el valor correcte més endavant. Per tant, afegiu a les expressions d’importació:
```
# "declarant" variables globals teclat = 0 scrMang = 0
```

Ajusteu la funció startGame:

Digueu que feu servir les variables globals teclat i scrMang. Feu-ho escrivint un teclat global, scrMang a la part superior de la funció.
Feu que la finestra escolti els esdeveniments del teclat.
Digueu a la figura que actuï basant-se en un PlatformerController. Aviat implementareu PlatformerController.
Creeu un col·lisionador de mapes per gestionar les col·lisions entre les rajoles massisses i la figura.

def startGame (): teclat global, scrMang generateTilemap () # 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)

Creeu un controlador de plataformes. Això és el que mourà la figura segons les pulsacions de tecla.
- Definiu el controlador de plataformes com una subclasse d'Acció.
- Definiu la velocitat de moviment, la velocitat de salt i la gravetat.
- Definiu la funció d'inici. Aquesta funció s'anomena una vegada, quan el controlador de plataformes està connectat a la figura. Hauria d’establir la seva velocitat a 0 tant en direcció x com en direcció y.
- Definiu la funció de pas. Es repetirà mentre l’escena s’executa.
- Digueu a la funció de pas que utilitzi les variables globals teclat i scrMang.
- Obtenir i canviar la velocitat. Deseu la velocitat x i la y en variables separades. Estableix la velocitat x a 1 o -1 (depenent de si es va prémer la tecla esquerra o dreta) multiplicada per la velocitat de moviment. Afegiu la gravetat a la velocitat y. Multipliqueu-lo amb temps d'inactivitat perquè funcioni de la mateixa manera en dispositius més lents. Si es prem la tecla espaiadora i la figura està de peu a terra, salteu canviant la velocitat y a la velocitat de salt.
- Calculeu fins on s’hauria de moure la figura. A continuació, deixeu que el controlador de col·lisions ajusti aquesta posició si es troba dins d’una rajola massissa. Finalment, moveu la figura a la nova posició ajustada.
- Estableix el focus del gestor de desplaçament a la figura. Això fa que la càmera es mogui de manera raonable quan es mou la figura.
```
class PlatformerController (Action): teclat global, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (auto): self.target.velocity = (0, 0) def step (self, dt): teclat global, desplaçador si dt> 0,1: # no feu res durant el temps d'inactivitat per tornar vx gran, vy = self.target.velocity vx = (teclat [tecla. RIGHT] - teclat [tecla. ESQUERRA]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground and 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)
```

Pas 14. Proveu el vostre codi

Si heu seguit l'exemple, ara hauríeu de poder moure el pingüí amb les tecles de fletxa i saltar prement la barra espaiadora. A més, ara el pingüí hauria de caure en lloc de volar sobre el terra.

Pas 15. Creeu un final per al joc

Fins i tot els jocs que poden continuar sense parar haurien de tenir la possibilitat de perdre. Com que el nivell que heu fet a l'exemple amb una funció ha finalitzat, també haureu de fer possible guanyar arribant a aquest fi. En cas contrari, el jugador només saltaria pels blocs de gel allà, cosa que s’avorriria.

Dins del controlador de plataformes, després de fixar el focus, obteniu la posició x i y de la figura. Si la posició y és inferior a 0, truqueu a la funció finishGame () (l'escrivireu més endavant) amb "Game Over" com a argument. Si la posició x és més gran que la mida de la pantalla multiplicada per 3 (ja ho havíeu definit com a mida de nivell).
```
posX, posY = self.target.position si posY <0: finishGame ("Game Over") torna si posX> 800 * 3: # nivell mida finishGame ("Nivell completat") torna
```
Definiu una classe finishMenu. Ha de ser com la classe de menú principal que heu definit abans, però en lloc de tenir una cadena buida com a títol, hauria d’utilitzar un text variable que la funció _init_ pren com a argument. Els elements del menú haurien d'etiquetar-se "Torna-ho a provar" i "Surt" ara, però les funcions que anomenen continuen sent les mateixes.
```
class FinishMenu (Menu): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTRE self.menu_halign = CENTRE menuItems = [(MenuItem ("Torna-ho a provar", startGame)), (MenuItem ("Surt", pyglet.app.exit))] self.create_menu (menuItems)
```
Definiu la funció finishGame (). Hauria de prendre el text com a argument. Ha de fer una escena del fons del menú principal, un FinishMenu amb l'argument de text que es transmet a aquest menú. Aleshores hauria d’executar aquesta escena.
```
def finishGame (text): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (text)) director.run (menuSc)
```

Pas 16. Afegiu crèdits

Aquí és on obtindràs crèdit pel teu increïble codi, a més de donar crèdit a qualsevol altra persona que t’hagi ajudat en el camí. Si heu utilitzat una imatge d’un altre lloc web (amb permís), assegureu-vos d’atribuir-la al seu creador.

Creeu un fitxer CRÈDITS i introduïu-hi tots els vostres crèdits, així:

Pingüí: Kelvin Shadewing, sota CC0 Bloc de gel: Michał Banas digit1024 a opengameart.org sota CC-BY-SA 3.0

Torneu al vostre codi Python i importeu l'etiqueta des de cocos.text.

Definiu una subclasse Crèdits de capa. A la seva funció _init_, llegiu el fitxer CREDITS i creeu una etiqueta de text a la posició correcta de cada línia.

class Crèdits (Layer): def _init _ (self): super (Crèdits, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") per a a l'interval (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)

Aneu a la classe del menú principal i afegiu un element de menú anomenat "Crèdits" que crida a la funció showCredits quan es fa clic.
Definiu una subclassa BackToMainMenuButton del menú. Feu d'aquest un menú amb un element, anomenat "Enrere", que crida a la funció showMainMenu. Aquest "menú", que s'assembla més a un botó, hauria d'estar alineat verticalment a la part inferior i horitzontalment a la part superior.
```
class 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)
```

Definiu la funció showCredits. Hauria de fer una escena d'una capa MainMenuBgr i una capa Crèdits i executar aquesta escena.

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

Pas 17. Comproveu el vostre codi

Quan creieu que heu acabat el codi, hauríeu de revisar-lo tot de nou. Això us pot ajudar a notar si es pot optimitzar alguna cosa o si hi ha línies innecessàries que heu oblidat de suprimir. Si heu seguit l'exemple, ara el codi sencer hauria de tenir el següent aspecte:

d'importació cocos.director * d'importació cocos.menu * d'importació cocos.scene * d'importació cocos.layer * d'importació cocos.sprite * d'importació cocos.tiles * d'importació cocos.mapcolliders * d'importació cocos.actions * de cocos.text importació Etiqueta importació pyglet.app des de pyglet.window importació clau des del límit d’importació matemàtica d’importació aleatòria randint # variables "globals" teclat = 0 scrMang = 0 classe MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) class MainMenu (Menu): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTRE self.menu_halign = CENTRE menu Elements = [(MenuItem ("Start Game", startGame)), (MenuItem ("Crèdits", showCredits)), (MenuItem ("Quit", pyglet.app.exit))] self.create_menu (menuItems) Crèdits (capa): def _init _ (self): super (Crèdits, self)._ init _ () credFile = obert ("CRÈDITS", "r") creds = credFile.read () creds = creds.split ("\ n") per a i en el rang (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) class 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): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTRE self.menu_halign = CENTRE menuItems = [(MenuItem ("Torna-ho a provar", startGame)), (MenuItem ("Surt", pyglet. app.exit))] self.create_menu (menuItems) class PlatformerController (Action): keyboard global, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) pas def (self, dt): teclat global, desplaçador si dt> 0.1: # no feu res mentre el temps d'inactivitat és massa gran vx, vy = self.target.velocity vx = (keyboard [key. RIGHT] - keyboard [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt si self.on _ground i teclat [tecla. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect () new = last.copy () new.x + = dx new.y + = dy self.target.velocity = self.target.collision_handler (last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* new.center) posX, posY = self.target.position if posY <0: finishGame ("Game Over") return if posX> 800 * 3: # level size finishGame ("Level Completed") return def finishGame (text): menuSc = Scene (MainMenuBgr ()) menuSc.add (FinishMenu (text)) director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc) def generateTilemap (): colAmount = ceil (800/16) * 3 # (amplada de la pantalla / mida del mosaic) * 3 rowAmount = ceil (600/16) # altura de la pantalla / mida del mosaic tileFile = obert ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) for i in range (0, colAmount): tileFile.write ('') makeHole = Fals si rand int (0, 50) == 10 i i! = 0: # no permet forats al punt de generació makeHole = True per a j en el rang (0, rowAmount): si makeHole: tileFile.write ('\ n') més: si j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight + 5) if iceHeight <0: # limita les fitxes iceHeight baixa = randint (1, 5) si iceHeight> rowAmount: # límit de rajoles per anar massa alt iceHeight = randint (int (rowAmount / 2) -5, int (rowAmount / 2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') per a i en l'interval (0, colAmount): tileFile.write (' ') per a j en l'interval (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): teclat global, scrMang generateTilemap () # 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) scr. add (solidTiles, z = 0) scrMang.add (figLayer, z = 1) # gameSc = Scene (scrMang) director.run (gameSc) def showMainMenu (): menuSc = Scene (MainMenuBgr ()) menuSc.add (MainMenu ()) director.run (menuSc) window = director.init (caption = "IcyPlat: un plataforma simple", redimensionable = True) showMainMenu ()

Són 168 línies totalment i 152 línies si només es compta el codi. Això fa que sembli molt, però per a un joc tan complex, en realitat és una quantitat petita.

Pas 18. Finalitzat

Ara proveu el joc. Quan programes alguna cosa, has de comprovar si funciona sempre que hagis implementat alguna cosa nova. A més, potser us agradaria jugar al joc que vau escriure durant algun temps.

Part 3 de 3: Publicació d'un joc

Pas 1. Escriviu les dependències

Qualsevol persona que faci servir un altre equip no tindrà instal·lat el mateix programari i les mateixes biblioteques que vosaltres. Per tant, us heu d’assegurar que tothom que instal·li el vostre joc sàpiga exactament el que necessitarà per executar-lo. No cal que anoteu totes les dependències de totes les dependències de totes les dependències, etc., però almenys heu d'escriure les dependències dels vostres paquets i les seves dependències.

Pas 2. Assegureu-vos que teniu permís per utilitzar tots els suports

Això s'aplica a tots els gràfics, inclosos els models 3D, la música, el diàleg, la música, les biblioteques i els marcs que heu utilitzat per al vostre joc. Tot el que no hagis escrit tu mateix.

Sovint hi ha algunes condicions, com haver d’acreditar l’autor o compartir modificacions dels suports amb la mateixa llicència. De vegades, podreu utilitzar gràfics sense atribuir-los als creadors sempre que no cobreu el joc. Si heu d'abonar l'autor, feu-ho en un lloc ben visible, com ara la pestanya "Crèdits" del joc.
També hi ha mitjans amb drets d'autor reclamats i sense llicència especificada, de vegades amb algun text com "Tots els drets reservats". Si és així, heu d'obtenir el permís explícit de l'autor abans d'incloure'l al vostre joc.
Les biblioteques solen alliberar-se sota llicències que permeten utilitzar-les com a biblioteca. Una excepció notable és la GPL sense excepció d’enllaç: aquesta llicència només permet utilitzar-la en un programa amb certes llicències. I sempre heu de llegir com a mínim els punts bàsics de la llicència per assegurar-vos que es permeti tot el que feu amb el suport o la biblioteca.

Advertiment: L'ús de mitjans o biblioteques d'una manera que la llicència no permet en un joc que publiqueu us pot provocar greus problemes legals. Per tant, pregunteu a l’autor o eviteu completament el material si no esteu segur de si es permet el vostre ús.

Pas 3. Decidiu les condicions en què voleu publicar el vostre joc

Vindràs el teu joc? Voleu permetre que altres usuaris facin servir les vostres imatges i idees? Tot i que heu de tenir cura dels mitjans que utilitzeu al vostre projecte, normalment podeu decidir com voleu permetre que altres facin servir el vostre joc. Podeu utilitzar una llicència Creative Commons CC0 per alliberar el vostre joc al domini públic. Per permetre la distribució i la modificació sota algunes condicions mentre es conserven alguns drets, proveu la llicència Gnu General Public License (GPL) o la llicència Berkeley Software Distribution (BSD). O bé, podeu fer que el vostre programari sigui propietari, és a dir, que ningú no pot distribuir-lo ni modificar-lo sense el vostre permís.

Tot i que és possible guanyar diners amb la venda de jocs, és poc probable que la gent compri el vostre primer joc que normalment té poques funcions i res d’especial. A més, si un programa gratuït no funciona, les persones que el descarregaran quedaran decebudes. No obstant això, si ho paguen, exigiran la devolució dels seus diners, cosa que provocarà més problemes tant per a vosaltres com per als usuaris. Penseu, doncs, en la possibilitat de fer els vostres primers programes disponibles de forma gratuïta

Pas 4. Decidiu com voleu publicar el vostre joc

Tots els mètodes tenen alguns avantatges i desavantatges, de manera que heu de decidir vosaltres mateixos.

Publicació en un lloc web:

Si teniu un lloc web, podeu penjar el joc perquè el pugueu descarregar. Assegureu-vos de proporcionar instruccions clares sobre com instal·lar el programari, així com de totes les dependències necessàries. L’inconvenient d’això és que els jugadors hauran d’instal·lar dependències manualment, cosa que pot ser difícil per a algunes persones.
Creació d'un paquet per a un gestor de paquets:

Hi ha diferents gestors de paquets, com apt, Yum i Homebrew, que faciliten la instal·lació d’aplicacions en entorns basats en Linux i Linux. Tots tenen diferents formats de paquet. El millor dels paquets és que instal·len automàticament totes les dependències (si les configureu correctament). Per tant, el jugador només ha d’instal·lar el paquet i després pot jugar al joc. El problema és que hi ha molts gestors de paquets diferents en diferents plataformes, de manera que haureu de dedicar una mica a proporcionar paquets per a tots els més comuns.

Pas 5. Dirigiu l'atenció al vostre programa

Penseu en la possibilitat de carregar el programa a un repositori de paquets important, com ara el que mantenen Ubuntu i Debian, per permetre les instal·lacions fàcils. A més, publiqueu en fòrums adequats, com ara la secció de projectes de GameDev o una part de tigSource. Però no us decebueu si els vostres primers jocs no es fan famosos. Si teniu la idea que els agrada a molta gent, el vostre joc es pot fer conegut.

Consells

Sigues pacient i disposat a aprendre. La programació pot ser frustrant de vegades.
Si us pregunteu com es fa alguna cosa en un altre joc i el joc és de codi obert, podeu mirar-ne el codi font.
Quan cerqueu contingut multimèdia, proveu de trobar contingut de domini públic. Cerqueu imatges i música "Creative Commons" o "Domini públic" i utilitzeu llocs web com https://opengameart.org o
No copieu trossos principals de codi sense comprovar la llicència. Sovint està prohibit i, si no, sol requerir atribució.
No publiqueu correu brossa ni publiqueu en llocs inadequats quan promocioneu el vostre joc. És probable que això us bloquegi a la pàgina, és simplement molest i perjudicarà la vostra reputació.