Cómo programar juegos de computadora (con imágenes)

2024 Autor: Robert Blare | [email protected]. Última modificación: 2024-01-31 12:15

¿Tienes una idea para un juego de computadora y quieres hacerla realidad? ¿O te has preguntado alguna vez cómo se escriben los juegos de computadora? Este wikiHow te enseñará a escribir tres juegos de computadora básicos en Python. Necesitarás un conocimiento básico de Python y conceptos generales de programación para desarrollar tu primer juego.

Pasos

Parte 1 de 3: Hacer un juego basado en texto

Paso 1. Elija un lenguaje de programación

Todos los lenguajes de programación son diferentes, por lo que tendrás que decidir cuál usar para escribir tu juego. Todos los lenguajes de programación importantes admiten la entrada de texto, la salida de texto y las construcciones if (las cosas principales que necesita para un juego simple basado en texto), así que explore las opciones y decida con cuál se siente más cómodo y dedicado al aprendizaje. A continuación, se incluyen algunos factores a considerar:

¿Para qué se usa principalmente el idioma?

Algunos lenguajes de programación, como JavaScript, están diseñados para usarse en la web, mientras que otros, como Python, C o C ++, están diseñados para ejecutar programas de computadora. Para su juego, busque un lenguaje con un rango de uso más amplio, como Python, C, C ++ o JavaScript.
¿Qué tan difícil es aprender?

Aunque escribir un programa debería ser bastante fácil después de un poco de práctica en cualquier lenguaje de programación normal (es decir, no uno diseñado específicamente para ser confuso como Malbolge), algunos son más amigables para los principiantes que otros. Java y C, por ejemplo, requerirán que comprenda conceptos de programación más profundos que algo como Python, que es conocido por su sintaxis más accesible y sencilla.
¿Dónde puedo usarlo?

Probablemente quieras que las personas en diferentes sistemas, como Linux, Mac o Windows, puedan jugar a tu juego. Por lo tanto, no debe usar un lenguaje que solo sea compatible con algunos sistemas, como Visual Basic, que solo es compatible con Windows.

Este artículo usará Python para los ejemplos de un juego basado en texto, pero puedes buscar cómo se hacen los conceptos en cualquier otro lenguaje de programación.

Paso 2. Prepare su computadora

Los dos componentes principales que necesitarás son un editor de texto, en el que escribirás tu código, y un compilador, que usarás para convertirlo en un juego. Si desea seguir el ejemplo de este artículo, debe instalar Python y aprender a ejecutar programas. Si lo desea, puede configurar un IDE (entorno de escritorio integrado), que combina la edición, compilación y depuración en un solo programa. El IDE de Python se llama IDLE. Pero también puede usar cualquier editor de texto que admita texto sin formato, como el Bloc de notas para Windows, TextEdit para macOS o Vim para Linux.

Paso 3. Escribe un código para saludar al jugador

El jugador querrá saber qué está pasando y qué tiene que hacer, por lo que debe imprimirle un texto.

Esto se hace con la función print () en Python. Para probarlo, abra un nuevo archivo con la extensión.py, ingrese el siguiente código, guárdelo y ejecútelo:
```
print ("¡Bienvenido al juego de adivinanzas de números!") print ("Ingresa un número entero entre 1 y 1000:")
```

Paso 4. Genere un número aleatorio

Hagamos un juego basado en texto que le pida al jugador que adivine el número correcto. Lo primero que tendremos que hacer es generar un número aleatorio al comienzo del juego para que el jugador no siempre adivine el mismo número. Dado que el número seguirá siendo el mismo durante todo el programa, querrá almacenar el número aleatorio en una variable.

Python no tiene una función de número aleatorio incorporada, pero tiene una biblioteca estándar (esto significa que el usuario no tendrá que instalar nada adicional) que sí la tiene. Así que vaya al principio de su código (antes de las funciones print ()) y escriba la línea import random.
Utilice la función aleatoria. Se llama randint (), está en la biblioteca aleatoria que acaba de importar y toma el valor mínimo y máximo que el número puede tener como argumento. Así que regrese al final de su código e ingrese la siguiente línea:
```
rightNum = random.randint (0, 1000)
```

Paso 5. Obtenga información del jugador

En un juego, el jugador quiere hacer algo o interactuar con algo. En un juego basado en texto, esto es posible ingresando texto. Ahora que tenemos un número aleatorio, nuestras siguientes líneas de código deberían pedirle al jugador que ingrese su mejor suposición.

Dado que el código que ingresó imprime la instrucción para ingresar un número al jugador, también debe leer el número que ingresaron. Esto se hace con input () en Python 3 y raw_input () en Python 2. Debería escribir en Python 3, ya que Python 2 pronto quedará obsoleto. Agregue la siguiente línea a su código para almacenar la entrada del jugador en una variable llamada número:
```
userNum = input ()
```

Paso 6. Convierta la entrada del reproductor en un tipo de datos utilizable

El jugador ha introducido un número, ¿y ahora qué?

Haga que la entrada del jugador sea un número. Ahora, esto puede sonar confuso porque solo ingresaron un número. Pero hay una buena razón: Python asume que toda la entrada es texto, o una "cadena", como se llama en programación. Este texto contiene el número que desea obtener. Python tiene una función que convierte una cadena que solo contiene un número al número dentro. Escribe:
```
userNum = int (userNum)
```

Paso 7. Compare el número del jugador con el número correcto

Una vez que el jugador ingrese su número, deberá compararlo con el que se generó al azar. Si los números no son los mismos, su juego puede hacer que el jugador pruebe con otro número. Si los números coinciden, puede decirle al jugador que adivinó correctamente y salir del programa. Esto se hace con el siguiente código:

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

Paso 8. Dale retroalimentación al jugador

Si bien ya ha procesado su entrada, el jugador no verá esto. Deberá imprimir los resultados al jugador para que comprenda lo que está sucediendo.

Seguramente, podría decirle al jugador si su número es correcto o incorrecto. Pero con ese enfoque, el jugador podría tener que adivinar 1000 veces en el peor de los casos, lo que sería muy aburrido.
Así que dile al jugador si su número es demasiado pequeño o demasiado grande. Esto reducirá significativamente su número de conjeturas. Si, por ejemplo, el jugador adivina 500 primero y el juego responde "Demasiado grande. Inténtalo de nuevo", solo habrá 500 números posibles en lugar de 1000. Esto se hace con construcciones if, así que reemplaza el print ("Incorrecto. Vuelve a intentarlo. ") Con uno.
Tenga en cuenta que comprobar si dos números son iguales se hace con ==, no con =. = asigna el valor a la derecha de la variable a la izquierda.

if userNum <rightNum: print ("Demasiado pequeño. Inténtalo de nuevo:") if userNum> rightNum: print ("Demasiado grande. Inténtalo de nuevo:")

Paso 9. Pruebe su código

Como programador, debe asegurarse de que su código funcione antes de considerarlo terminado.

Cuando programe en Python, asegúrese de obtener las sangrías correctas. Tu código debería verse así:

import random print ("¡Bienvenido al juego de adivinanzas de números!") print ("Ingresa un número entero entre 1 y 1000:") rightNum = random.randint (0, 1000) userNum = input () userNum = int (userNum) while userNum! = rightNum: if userNum <rightNum: print ("Demasiado pequeño. Inténtalo de nuevo:") if userNum> rightNum: print ("Demasiado grande. Inténtalo de nuevo:") userNum = int (input ()) print ("Adivinaste correctamente.")

Paso 10. Valide la entrada

El jugador no debería poder romper tu juego simplemente ingresando lo incorrecto. "Validar la entrada" significa asegurarse de que el jugador haya introducido lo correcto antes de procesarlo.

Vuelve a abrir el juego e intenta ingresar cualquier cosa que no sea un número. El juego saldrá con ValueError. Para evitar esto, puede implementar una forma de verificar si la entrada fue un número.
Defina una función. Dado que la validación de la entrada es bastante larga y debe hacerlo varias veces, debe definir una función. No tomará argumentos y devolverá un número. Primero, escriba def numInput (): en la parte superior de su código, directamente debajo de la importación aleatoria.
Obtenga la entrada del jugador una vez. Utilice la función input () y asigne el resultado a la variable inp.
Cuando la entrada del jugador no sea un número, pídale que ingrese un número. Para verificar si una cadena es un número, use las funciones isdigit (), que solo permiten un número entero, por lo que no tendrá que verificarlo por separado.
Si la entrada es un número, conviértalo de cadena en número y devuelva el resultado. Utilice la función int () para convertir la cadena en un número entero. Esto hará que la conversión en el código principal sea innecesaria y debe eliminarla de allí.
Reemplaza todas las llamadas a input () en el código principal con llamadas a numInput ().
El código de la función numInput () se verá así:

def numInput (): inp = input () while not inp.isdigit (): print ("¡Se le dijo que ingresara un número entero! Ingrese un número entero:") inp = input () return int (inp)

Paso 11. Prueba el juego de nuevo

Ingrese las cosas incorrectas a propósito para ver qué sucede y luego corrija los errores a medida que surjan.

Intente ingresar texto cuando el programa le pida un número. Ahora, en lugar de salir con un mensaje de error, el programa le pedirá un número nuevamente

Paso 12. Sugiera reiniciar el juego cuando termine

De esta manera, el jugador podría jugar su juego durante más tiempo sin tener que reiniciarlo constantemente.

Coloque todo el código excepto la importación y la definición de función en un ciclo while. Establezca Verdadero como condición: esto siempre será cierto, por lo que el ciclo continuará para siempre.
Pregúntele al jugador si quiere volver a jugar después de haber adivinado el número correctamente. Utilice la función de impresión ().
Si responden "No", sal de la mirada. Si responden algo más, continúe. La ruptura de un bucle se realiza con la instrucción break.
Mueva el "Bienvenido al juego de adivinanzas de números" fuera del bucle while. El jugador probablemente no quiera ser bienvenido cada vez que juega. Mueva la instrucción print ("¡Bienvenido al juego de adivinanzas de números!" Encima de while True:, por lo que se imprimirá solo una vez, cuando el usuario inicie el primer juego.

Paso 13. Prueba el juego

Deberá probar su juego cada vez que implemente una nueva función.

Asegúrese de responder "Sí" y "No" al menos una vez para asegurarse de que ambas opciones funcionan. Así es como debería verse su código:

import random def numInput (): inp = input () while not inp.isdigit (): print ("¡Te dijeron que ingreses un número entero! Ingresa un número entero:") inp = input () return int (inp) print ("¡Bienvenido al juego de adivinanzas de números!") While True: print ("Ingresa un número entero entre 1 y 1000:") rightNum = random.randint (0, 1000) userNum = numInput () while userNum! = RightNum: if userNum <rightNum: print ("Demasiado pequeño. Inténtalo de nuevo:") if userNum> rightNum: print ("Demasiado grande. Inténtalo de nuevo:") userNum = numInput () print ("Adivinaste correctamente.") print ("¿No quieres volver a jugar? Ingresa No para salir. ") if input () ==" No ": break

Paso 14. Escribe otros juegos basados en texto

¿Qué tal escribir una aventura de texto a continuación? ¿O un juego de preguntas? Ser creativo.

Propina: A veces es útil buscar en la documentación si no está seguro de cómo se hace algo o cómo se usa una función. La documentación de Python 3 se encuentra en https://docs.python.org/3/. A veces, buscar lo que quiera hacer en Internet también arroja buenos resultados.

Parte 2 de 3: Hacer un juego con gráficos 2D

Paso 1. Elija una biblioteca de gráficos

Hacer gráficos es muy complicado, y la mayoría de los lenguajes de programación (incluidos Python, C ++, C, JavaScript) proporcionan solo un soporte mínimo o incluso nulo para gráficos en el núcleo o las bibliotecas estándar. Entonces tendrás que usar una biblioteca externa para poder hacer gráficos, por ejemplo Pygame para Python.

Incluso con una biblioteca de gráficos, tendrá que preocuparse por cosas como cómo mostrar un menú, cómo verificar en qué hizo clic el jugador, cómo mostrar los mosaicos, etc. Si prefiere concentrarse en desarrollar el juego real, puede usar una biblioteca de motor de juego como Unity, que implementa estas cosas fácilmente

Este artículo usará Python con Cocos2D para mostrar cómo hacer un simple juego de plataformas en 2D. Es posible que algunos de los conceptos mencionados no existan en otros motores de juegos. Consulte su documentación para obtener más información.

Paso 2. Instale la biblioteca de gráficos que eligió

Cocos2D para Python es fácil de instalar. Puede obtenerlo en https://python.cocos2d.org/index.html, o ejecutando sudo pip3 install cocos2d si está usando Linux.

Paso 3. Cree un nuevo directorio para su juego y medios

Usarás cosas como imágenes y sonidos en tu juego. Mantenga estas cosas en el mismo directorio que el programa. Este directorio no debe contener nada más para que puedas ver fácilmente qué activos tienes en el juego.

Paso 4. Cree un nuevo archivo de código en el nuevo directorio

Llámelo principal, con la extensión de archivo de su lenguaje de programación. Si escribe un programa grande y complejo donde tiene sentido tener varios archivos de programa, esto le mostrará cuál es el archivo principal.

En este ejemplo, crearemos un archivo llamado main.py que contendrá todo nuestro código

Paso 5. Crea la ventana del juego

Este es el requisito previo básico para un juego con gráficos.

Importe los submódulos cocos2d necesarios: cocos.director, cocos.scene y cocos.layer. Esto se hace con subModuleName import *, donde el nombre del submódulo es el submódulo que desea importar. La diferencia entre from… import * e import… es que no tienes que poner el nombre del módulo delante de todo lo que usas de ese módulo con el primero.
Defina una subclase MainMenuBgr de ColorLayer. Esto básicamente significa que cualquier fondo del menú principal que cree se comportará como una capa de color con algunos cambios que realice.
Inicie el director de cocos. Esto le dará una nueva ventana. Si no establece un título, la ventana tendrá el mismo título que el nombre del archivo (main.py), que no se verá profesional. Permita que se cambie el tamaño de la ventana estableciendo el tamaño de redimensionable en Verdadero.
Defina una función showMainMenu. Debe poner el código para mostrar el menú principal en una función porque esto le permitirá volver fácilmente al menú principal llamando a la función nuevamente.
Crea una escena. La escena consta de una capa por ahora, que es un objeto de la clase MainMenuBgr que definiste.
Ejecute esta escena en la ventana.

desde cocos.director import * desde cocos.scene import * desde 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 - un juego de plataformas simple", resizable = True) showMainMenu ()

Paso 6. Agregue un menú principal a la ventana

Además del juego real, deberás agregar un menú que el jugador puede usar para cerrar la ventana, entre otros elementos que puedes agregar más tarde.

Importe cocos.menu (nuevamente con la instrucción from) y pyglet.app (esta vez con import).
Defina MainMenu como una subclase de Menu.
Establece la alineación del menú principal. Debe establecer la alineación vertical y horizontal por separado.
Cree una lista de elementos del menú y agréguelos al menú. Debería tener los elementos del menú "Iniciar juego" y "Salir" como mínimo. Cada elemento del menú debe colocarse entre corchetes. Cada elemento debe tener una etiqueta y una función de devolución de llamada que determina qué sucede cuando el jugador hace clic en él. Para el elemento "Iniciar juego", usa la función startGame (la escribirás pronto), para el elemento "Salir", usa "pyglet.app.exit" (ya existe). Cree el menú real llamando a self.create_menu (menuItems).
Defina startGame (). Simplemente ponga pase en la definición por ahora, lo reemplazará cuando escriba el juego real.
Vaya al lugar en su código donde creó la escena menuSc y agréguele un objeto MainMenu.

Su código completo ahora debería verse de la siguiente manera:

desde cocos.director importar * desde cocos.menu importar * desde cocos.scene importar * desde cocos.layer importar * importar pyglet.app clase MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) class MainMenu (Menú): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Iniciar juego ", startGame)), (MenuItem (" Salir ", 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 juego de plataformas simple", resizable = True) showMainMenu ()

Paso 7. Pruebe su código

Pruebe el código temprano, aunque aún sea corto y relativamente simple. Luego, puede identificar y corregir cualquier error en la estructura básica antes de que las cosas se compliquen demasiado.

El código de las instrucciones debería abrir una ventana titulada "IcyPlat: un juego de plataformas simple". El fondo es azul claro y puede cambiar el tamaño de la ventana. Cuando haces clic en "Iniciar juego" en el menú, no debería suceder nada (todavía). Al hacer clic en "Salir", la ventana se cerrará

Paso 8. Crea un objeto

Un objeto es un "objeto de juego" o una imagen bidimensional. Los sprites pueden ser objetos del juego, íconos, decoraciones de fondo, personajes y cualquier otra cosa que puedas representar con una imagen en el juego. Comenzaremos creando un objeto para un personaje con el que el jugador pueda interactuar.

Importe el submódulo cocos.sprite con la expresión from-import-expression.
Encuentra una imagen para representar el sprite. No puedes mostrar un objeto si no tienes una imagen. Puedes dibujar uno, o puedes obtener uno de Internet (aunque ten cuidado con las licencias si planeas publicar tu juego). Para este ejemplo, diríjase a https://opengameart.org/content/tux-classic-hero-style y guarde la imagen-p.webp" />
Cree una capa como un nuevo objeto de la clase ScrollableLayer. Luego, crea el sprite como un objeto Sprite y establece su posición en (8, 250). Como referencia, el punto (0, 0) está en la esquina inferior izquierda. Esto es bastante alto, pero se asegurará de que el pingüino no se quede atascado en el hielo.
Agrega el objeto a la capa del objeto.
Crea una nueva escena a partir de la capa del sprite y ejecútala.

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

Ejecute el código. Debería ver una pequeña figura de pingüino (o lo que sea que haya dibujado) sobre un fondo negro después de hacer clic en Empezar juego.

Paso 9. Imagina tu paisaje

En la mayoría de los juegos, tus sprites no deberían simplemente flotar en el vacío. En realidad, deberían pararse sobre alguna superficie, con algo a su alrededor. En los juegos 2D, esto se hace a menudo con un conjunto de mosaicos y un mapa de mosaicos. El conjunto de mosaicos básicamente dice qué tipo de cuadrados de superficie y cuadrados de fondo existen, y cómo se ven.

Crea un conjunto de mosaicos. El juego de fichas para este juego será muy básico: una ficha para el hielo y una ficha para el cielo. La placa de hielo utilizada en este ejemplo es de aquí, bajo CC-BY-SA 3.0.
Crea una imagen de conjunto de mosaicos. Esa es una imagen de todos los mosaicos, que deben ser del mismo tamaño (edítelos si no lo son) y del tamaño que desea ver en el juego, uno al lado del otro. Guarde su imagen como icyTiles.png.
Cree la descripción del conjunto de mosaicos. Eso es un archivo XML. El archivo XML contiene información sobre el tamaño de los mosaicos en la imagen del conjunto de mosaicos, qué imagen usar y dónde encontrar qué mosaico allí. Cree un archivo XML llamado icyTiles.xml con el siguiente código:
```
     
```

Paso 10. Haz un mapa de mosaicos para tu paisaje

Un mapa de mosaicos es un mapa que define qué mosaico está en qué posición en su nivel. En el ejemplo, debe definir una función para generar mapas de mosaicos porque diseñar mapas de mosaicos a mano es muy tedioso. Un juego más avanzado normalmente tendría algún tipo de editor de niveles, pero para familiarizarse con el desarrollo de juegos en 2D, un algoritmo puede proporcionar niveles suficientemente buenos.

Descubra cuántas filas y columnas se necesitan. Para ello, divida el tamaño de la pantalla por el tamaño del mosaico tanto horizontalmente (columnas) como verticalmente (filas). Redondea el número hacia arriba; necesita una función del módulo matemático para eso, así que agregue del ceil de importación matemática a las importaciones en la parte superior de su código.
Abra un archivo para escribir. Esto borrará todo el contenido anterior del archivo, así que elija un nombre que aún no tenga ningún archivo en el directorio, como levelMap.xml.
Escriba las etiquetas de apertura en el archivo.
Genere un mapa de mosaicos de acuerdo con el algoritmo. Use el que está en el código a continuación, o puede crear uno por su cuenta. Asegúrese de importar la función randint del módulo al azar: es necesario para que el código siguiente funcione, y lo que sea que se le ocurra probablemente también necesitará números enteros aleatorios. Además, asegúrese de colocar los mosaicos del cielo y los mosaicos de hielo en diferentes capas: el hielo es sólido, el cielo no.
Escriba las etiquetas de cierre en el archivo y ciérrelo.

def generateTilemap (): colAmount = ceil (800/16) * 3 # (ancho de pantalla / tamaño de mosaico) * 3 rowAmount = ceil (600/16) # altura de pantalla / tamaño de mosaico tileFile = open ("levelMap.xml", " w ") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) para i en el rango (0, colAmount): tileFile.write ('') makeHole = False si randint (0, 50) == 10 e i! = 0: # no permitir agujeros en el punto de generación makeHole = True para j en el rango (0, rowAmount): if makeHole: tileFile.write ('\ n') else: if j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight + 5) if iceHeight <0: # límite de fichas para que no bajen demasiado iceHeight = randint (1, 5) if iceHeight> rowAmount: # límite de fichas para que no suban demasiado iceHeight = randint (int (rowAmount / 2) -5, int (rowAmount / 2) +5) tileFile.write ('\ n') tileFile.write ('\ n / n') para i en el rango (0, colAmount): tileFile.write ('') para j en el rango (0, rowAmount): tileFile.write ('\ n') tileFile.write ('\ n ') tileFile.write (' / n / n ') tileFile.close ()

Paso 11. Muestre el mapa de mosaicos

Importe todo de cocos.tiles y luego vaya a la función startGame para eso.

Al comienzo de su función startGame, genere un mapa de mosaicos usando la función que definió para eso.
Crea un nuevo administrador de desplazamiento. Haz esto directamente debajo de la línea donde agregas el sprite a su capa.
Cree una nueva capa que contenga los mosaicos, que se cargarán desde el mapa de mosaicos levelMap.xml que generó la función generateTilemap.
Agregue la capa no sólida, la capa sólida y la capa de sprites al administrador de desplazamiento, exactamente en este orden. Puede agregar una posición z si lo desea.
En lugar de crear la escena a partir de la capa de sprites, créala desde el administrador de desplazamiento.

Su función startGame ahora debería verse así:

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 = Escena (scrMang) director.run (gameSc)

Paso 12. Pruebe su código

Debe probar su código con frecuencia para asegurarse de que las nuevas funciones que implementó realmente funcionen.

El código del ejemplo debería mostrar ahora un paisaje helado detrás del pingüino. Si parece que el pingüino está flotando sobre el hielo, no hiciste nada malo y se solucionará en el siguiente paso

Paso 13. Agregue los controles

El jugador tiene muchas más formas de interactuar con el programa en un juego 2D que en un juego basado en texto. Uno común incluye mover su figura cuando se presiona la tecla correcta.

Importe todo de cocos.mapcolliders y de cocos.actions. También importe la clave de pyglet.window.
"Declare" algunas variables globales. Las variables globales se comparten entre funciones. Realmente no puede declarar variables en Python, pero debe decir que existe una variable global en el código principal antes de usarla. Puede asignar 0 como valor porque una función se encargará de asignar el valor correcto más adelante. Así que agregue debajo de las expresiones de importación:
```
# "declarando" variables globales keyboard = 0 scrMang = 0
```

Ajusta tu función startGame:

Digamos que usa el teclado de variables globales y scrMang. Haga esto escribiendo teclado global, scrMang en la parte superior de la función.
Haga que la ventana escuche los eventos del teclado.
Dile a la figura que actúe basándose en un PlatformerController. Pronto implementará ese PlatformerController.
Cree un colisionador de mapas para manejar las colisiones entre los mosaicos sólidos y la figura.

def startGame (): teclado 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 (teclado) # 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 = Escena (scrMang) director.run (gameSc)

Crea un controlador de plataformas. Esto es lo que moverá la figura de acuerdo con sus pulsaciones de teclas.
- Defina el controlador de plataformas como una subclase de Acción.
- Defina la velocidad de movimiento, la velocidad de salto y la gravedad.
- Defina la función de inicio. Esta función se llama una vez, cuando el controlador de plataformas está conectado a la figura. Debería establecer su velocidad en 0 tanto en la dirección x como en la y.
- Defina la función de paso. Se repetirá mientras se ejecuta la escena.
- Dile a la función de paso que use el teclado de variables globales y scrMang.
- Obtén y cambia la velocidad. Guarde la velocidad xey en variables separadas. Establezca la velocidad x en 1 o -1 (dependiendo de si se presionó la tecla izquierda o derecha) multiplicada por la velocidad de movimiento. Agregue gravedad a la velocidad y. Multiplíquelo por el tiempo de inactividad para que funcione de la misma manera en dispositivos más lentos. Si se presiona la tecla espaciadora y la figura está de pie en el suelo, salte cambiando la velocidad y a la velocidad del salto.
- Calcula hacia dónde debería moverse la figura. Luego, deje que el controlador de colisiones ajuste esa posición si está dentro de una loseta sólida. Finalmente, mueva la figura a la nueva posición ajustada.
- Establezca el enfoque del administrador de desplazamiento en la figura. Esto hace que la cámara se mueva de manera razonable cuando la figura se mueve.
```
class PlatformerController (Acción): teclado global, 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, desplazamiento si dt> 0.1: # no haga nada durante el tiempo de inactividad para obtener un gran retorno vx, vy = self.target.velocity vx = (keyboard [key. RIGHT] - keyboard [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground y teclado [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 (último, nuevo, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus (* nuevo.center)
```

Paso 14. Pruebe su código

Si siguió el ejemplo, ahora debería poder mover el pingüino con las teclas de flecha y saltar presionando la barra espaciadora. Además, el pingüino ahora debería caer en lugar de flotar sobre el suelo.

Paso 15. Crea un final para el juego

Incluso los juegos que pueden continuar interminablemente deberían tener la posibilidad de perder. Dado que el nivel que alcanzó en el ejemplo con una función tiene un final, también deberá hacer posible ganar llegando a ese final. De lo contrario, el jugador solo saltaría sobre los bloques de hielo allí, lo que se volvería aburrido.

Dentro del controlador de plataformas, después del conjunto de enfoque, obtenga la posición xey de la figura. Si la posición y es menor que 0, llama a la función finishGame () (la escribirás más adelante) con "Game Over" como argumento. Si la posición x es más grande que el tamaño de la pantalla multiplicado por 3 (lo había establecido como tamaño de nivel antes).
```
posX, posY = self.target.position if posY <0: finishGame ("Game Over") return if posX> 800 * 3: # level size finishGame ("Level Completed") return
```
Defina una clase finishMenu. Debería ser como la clase del menú principal que definiste antes, pero en lugar de tener una cadena vacía como título, debería usar un texto variable que la función _init_ toma como argumento. Los elementos del menú deberían estar etiquetados como "Intentar de nuevo" y "Salir" ahora, pero las funciones a las que llaman siguen siendo las mismas.
```
class FinishMenu (Menú): def _init _ (self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Intentar de nuevo", startGame)), (MenuItem ("Salir", pyglet.app.exit))] self.create_menu (menuItems)
```
Defina la función finishGame (). Debe tomar el texto como argumento. Debería hacer una escena del fondo del menú principal, un FinishMenu con el argumento de texto que se pasa a este menú. Entonces debería ejecutar esta escena.
```
def finishGame (texto): menuSc = Escena (MainMenuBgr ()) menuSc.add (FinishMenu (texto)) director.run (menuSc)
```

Paso 16. Agregue créditos

Aquí es donde se le atribuye el mérito de su increíble código, así como a cualquier otra persona que le haya ayudado en el camino. Si usó una imagen de otro sitio web (con permiso), asegúrese de atribuir esa imagen a su creador.

Cree un archivo CRÉDITOS e ingrese todos sus créditos allí, así:

Pingüino: Kelvin Shadewing, bajo CC0 Bloque de hielo: Michał Banas digit1024 en opengameart.org bajo CC-BY-SA 3.0

Regrese a su código Python e importe Label desde cocos.text.

Defina una subclase Créditos de capa. En su función _init_, lee el archivo CREDITS y crea una etiqueta de texto en la posición correcta de cada línea en él.

class Créditos (Capa): def _init _ (self): super (Créditos, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n ") para i en el rango (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)

Vaya a su clase de menú principal y agregue un elemento de menú con la etiqueta "Créditos" que llama a la función showCredits cuando se hace clic.
Defina una subclase BackToMainMenuButton of Menu. Haga de este un menú con un elemento, etiquetado "Atrás", que llame a la función showMainMenu. Este "menú", que es más como un botón, debe estar alineado verticalmente hacia abajo y horizontalmente hacia arriba.
```
class BackToMainMenuButton (Menú): def _init _ (self): super (BackToMainMenuButton, self)._ init _ ("") self.menu_valign = BOTTOM self.menu_halign = IZQUIERDA menuItems = [(MenuItem ("Atrás", showMainMenu))] self. create_menu (menuItems)
```

Defina la función showCredits. Debería hacer una escena a partir de una capa MainMenuBgr y una capa Credits y ejecutar esa escena.

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

Paso 17. Verifique su código

Cuando crea que terminó su código, debe revisarlo todo nuevamente. Esto puede ayudarlo a notar si algo se puede optimizar o si hay algunas líneas innecesarias que olvidó eliminar. Si siguió el ejemplo, todo su código debería tener el siguiente aspecto:

de cocos.director importar * de cocos.menu importar * de cocos.scene importar * de cocos.layer importar * de cocos.sprite importar * de cocos.tiles importar * de cocos.mapcolliders importar * de cocos.actions importar * de cocos.text import Label import pyglet.app from pyglet.window import key from math import ceil from random import randint # "declarando" variables globales keyboard = 0 scrMang = 0 class MainMenuBgr (ColorLayer): def _init _ (self): super (MainMenuBgr, self)._ init _ (0, 200, 255, 255) class MainMenu (Menú): def _init _ (self): super (MainMenu, self)._ init _ ("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Start Game", startGame)), (MenuItem ("Credits", showCredits)), (MenuItem ("Salir", pyglet.app.exit))] self.create_menu (menuItems) clase Créditos (Capa): def _init _ (self): super (Créditos, self)._ init _ () credFile = open ("CREDITS", "r") creds = credFile.read () creds = creds.split ("\ n") para i dentro del rango (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 (Menú): 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 (Menú): def (_init self, text): super (FinishMenu, self)._ init _ (text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem ("Intentar de nuevo", startGame)), (MenuItem ("Salir", pyglet. app.exit))] self.create_menu (menuItems) class PlatformerController (Acción): teclado global, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (self): self.target.velocity = (0, 0) def step (self, dt): teclado global, scroller si dt> 0.1: # no haga nada mientras el tiempo de inactividad es demasiado grande return vx, vy = self.target.velocity vx = (keyboard [key. RIGHT] - keyboard [key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt si self.on _ground y teclado [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 (último, nuevo, 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 (texto): menuSc = Escena (MainMenuBgr ()) menuSc.add (FinishMenu (texto)) director.run (menuSc) def showCredits (): credSc = Scene (MainMenuBgr ()) credSc.add (Credits ()) credSc.add (BackToMainMenuButton ()) director.run (credSc) def generateTilemap (): colAmount = ceil (800/16) * 3 # (ancho de pantalla / tamaño de mosaico) * 3 rowAmount = ceil (600/16) # altura de pantalla / tamaño de mosaico tileFile = open ("levelMap.xml", "w") tileFile.write ('\ n / n / n') iceHeight = randint (1, 10) para i en el rango (0, colAmount): tileFile.write ('') makeHole = Falso si rand int (0, 50) == 10 y i! = 0: # no permiten agujeros en el punto de generación makeHole = True para j en el rango (0, rowAmount): if makeHole: tileFile.write ('\ n') else: if j <= iceHeight: tileFile.write ('\ n') else: tileFile.write ('\ n') iceHeight = randint (iceHeight-5, iceHeight + 5) if iceHeight <0: # límite de fichas para que no vayan también low iceHeight = randint (1, 5) if iceHeight> rowAmount: # límite de fichas de ir demasiado alto iceHeight = randint (int (rowAmount / 2) -5, int (rowAmount / 2) +5) tileFile.write ('\ n ') tileFile.write (' / n / n ') para i en rango (0, colAmount): tileFile.write (' ') para j en rango (0, rowAmount): tileFile.write (' / n ') tileFile.write ('\ n') tileFile.write ('\ n / n') tileFile.close () def startGame (): teclado 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. 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 juego de plataformas simple", resizable = True) showMainMenu ()

Eso son 168 líneas en total y 152 líneas si solo cuenta el código. Esto parece mucho, pero para un juego tan complejo, en realidad es una pequeña cantidad.

Paso 18. Terminado

Ahora prueba el juego. Cuando programa algo, debe verificar si funciona siempre que haya implementado algo nuevo. Además, es posible que te guste jugar al juego que escribiste durante algún tiempo.

Parte 3 de 3: Publicar un juego

Paso 1. Anote las dependencias

Cualquiera que use otra computadora no tendrá el mismo software y bibliotecas instaladas que usted. Por lo tanto, deberá asegurarse de que todos los que instalen su juego sepan exactamente lo que necesitarán para ejecutarlo. No tiene que escribir todas las dependencias de todas las dependencias de todas las dependencias y así sucesivamente, pero al menos debería escribir las dependencias de sus paquetes y sus dependencias.

Paso 2. Asegúrese de tener permiso para utilizar todos los medios

Esto se aplica a todos los gráficos, incluidos los modelos 3D, la música, los diálogos, las bibliotecas y los marcos que utilizó para su juego. Cualquier cosa que no hayas escrito tú mismo.

A menudo existen algunas condiciones, como tener que acreditar al autor o compartir modificaciones del medio bajo la misma licencia. A veces podrás usar gráficos sin atribuir a los creadores siempre que no cobre por el juego. Si tienes que dar crédito al autor, hazlo en un lugar bien visible, como una pestaña de "Créditos" en tu juego.
También hay medios con derechos de autor reclamados y sin licencia especificada, a veces con algún texto como "Todos los derechos reservados". Si ese es el caso, debes obtener el permiso explícito del autor antes de incluirlo en tu juego.
Las bibliotecas generalmente se publican bajo licencias que les permiten ser utilizadas como biblioteca. Una excepción notable es la GPL sin excepción de vinculación: dicha licencia solo permite usarla en un programa con ciertas licencias. Y siempre debe leer al menos los puntos básicos de la licencia para asegurarse de que todo lo que esté haciendo con los medios o la biblioteca esté permitido.

Advertencia: Usar medios o bibliotecas de una manera que la licencia no permite en un juego que publique puede causarle serios problemas legales. Por lo tanto, pregúntele al autor o evite el medio por completo si no está seguro de si su uso está permitido.

Paso 3. Decide las condiciones en las que quieres publicar tu juego

¿Venderás tu juego? ¿Quiere permitir que otros usen sus imágenes e ideas? Si bien debe tener cuidado con los medios que usa en su proyecto, generalmente puede decidir cómo desea permitir que otros usen su juego. Puedes usar una licencia Creative Commons CC0 para lanzar tu juego en el dominio público. Para permitir la distribución y modificación bajo algunas condiciones mientras retienes algunos derechos, prueba la Licencia Pública General Gnu (GPL) o la Licencia de Distribución de Software Berkeley (BSD). O puede hacer que su software sea propietario, lo que significa que nadie puede distribuirlo o modificarlo sin su permiso.

Aunque es posible ganar dinero vendiendo juegos, es poco probable que la gente compre su primer juego que normalmente tiene pocas funciones y nada especial. Además, si un programa gratuito no funciona, las personas que lo descargaron se sentirán decepcionadas. Sin embargo, si lo pagaron, exigirán que se les devuelva el dinero, lo que provocará más problemas tanto para usted como para los usuarios. Así que considere hacer que sus primeros programas estén disponibles de forma gratuita

Paso 4. Decide cómo quieres publicar tu juego

Cada método tiene algunas ventajas y desventajas, por lo que debes decidirlo tú mismo.

Publicarlo en un sitio web:

Si tiene un sitio web, puede cargar su juego para que esté disponible para su descarga. Asegúrese de proporcionar instrucciones claras sobre cómo instalar el software, así como todas las dependencias necesarias. La desventaja de esto es que los jugadores tendrán que instalar las dependencias manualmente, lo que puede resultar difícil para algunas personas.
Hacer un paquete para un administrador de paquetes:

Existen diferentes administradores de paquetes, como apt, Yum y Homebrew, que facilitan a las personas la instalación de aplicaciones en Linux y entornos basados en Linux. Todos tienen diferentes formatos de paquete. Lo bueno de los paquetes es que instalan automáticamente todas las dependencias (si las configura correctamente). Entonces, el jugador solo tiene que instalar su paquete y luego puede jugar el juego. El problema es que hay muchos administradores de paquetes diferentes en diferentes plataformas, por lo que tendrá que esforzarse un poco para proporcionar paquetes para todos los más comunes.

Paso 5. Dirija la atención a su programa

Considere cargar su programa en un repositorio de paquetes importante, como los que mantienen Ubuntu y Debian, para permitir instalaciones fáciles. Además, publique en foros apropiados, como la sección de proyectos de GameDev o una parte de tigSource. Pero no se decepcione si sus primeros juegos no se vuelven famosos. Si tienes la idea de que a mucha gente le gusta, tu juego puede llegar a ser conocido.

Consejos

Sea paciente y esté dispuesto a aprender. ¡La programación puede ser frustrante a veces!
Si te preguntas cómo se hace algo en otro juego, y el juego es de código abierto, puedes mirar su código fuente.
Cuando busque medios, intente encontrar contenido que sea de dominio público. Busque imágenes y música de "Creative Commons" o "Dominio público", y use sitios web como https://opengameart.org o
No copie grandes fragmentos de código sin verificar la licencia. A menudo está prohibido y, en caso contrario, suele requerir atribución.
No hagas spam ni publiques en lugares inapropiados cuando promocionas tu juego. Es probable que esto lo bloquee de la página, es simplemente molesto y dañará su reputación.