Os traigo un pack de recursos ideal para hacer prototipos de videojuegos o como el autor los llama Los milagrosamente flexibles gráficos para prototipos de juegos para Mundos Pequeños de Danc. El caso es que se tratan de unos gráfico en formato vectorial de una alta calidad.

Son ideales para que los programadores los usen en prototipos de videojuego, como el autor dice, son muy útiles para juegos tipo cajón de arena, estrategias y demás juegos donde el jugador puede colocar objetos de forma arbitraria. Al ser vectoriales puedes redimensionarlos al tamaño que necesites para adaptarlo a tu proyecto.

Los gráficos están disponibles con una licencia Creative Commons de atribución, así que son gratuitos para su uso y distribución mientras se dé el debido crédito. Los gráficos vienen en SVG, Illustrator, Flash, además de archivo SWF.

• Descargar de la página del autor

Entradas relacionadas

• Pack de gráficos para juegos

Fmod es una api para manejar sonidos multiplataforma ampliamente usada en el mundo de los videojuegos. Su lenguaje principal es C++, pero soporta muchos otros como Visual Basic o Delphi. Fmod se puede usar en los siguientes dispositivos.

• Windows (32 bits y 64 bits)
• Macintosh (PPC, x86)
• iPhone de Apple, IPAD
• Linux (32 bits y 64 bits)
• Sony PS2, PS3 y PSP
• Microsoft Xbox y Xbox 360
• Nintendo Gamecube y Wii

Tiene una gran fama en la creación de audio de grandes videojuegos, por ejemplo, se encarga de toda la saga Halo. Muchos engines profesionales tienen integración con fmod, tales como:

• CryENGINE (FMOD is la api por defecto)
• Unity (FMOD is la api por defecto)
• Unreal Engine 3 (FMOD Designer 2010 tiene una integración muy grande)
• BigWorld (FMOD is la api por defecto)
• Vision Engine
• Scaleform

Fmod se compone de dos parte. La librería en sí y el Fmod designer que es toda una interfaz para la creación de sonidos que luego se usan con la api. Tiene editor visual en los engines sitados arriba, donde el artista del audio se sentirá como pez en al agua sin necesidad de saber programar colocando sonidos.

Es totalmente gratuita para uso no comercial y una biblioteca obligada para todo el que esté interesado en el audio de los videojuegos.

Dejo un pdf que he encontrado con una pequeña introducción a Fmod, es de una versión antigua pero puede valer.

• Descargar introducción

Entradas relacionadas

• Arboles e inteligencia artificial II
• Arboles e inteligencia Artificial
• ORTS. Estrategia en tiempo real OpenSource
• Algoritmo Minimax, un jugador incansable
• Curso Python V – Funciones del usuario

El árbol de los animales

Vamos a crear una I.A. que tratará de adivinar en que animal estamos pensando. El programa irá aprendiendo a medida que jugamos y jugamos conocerá más animales. Lo que vamos a hacer es crear un árbol que vaya creciendo poco a poco.

Veamos una ejecución  del programa para que veáis como funciona.

Estas pensando en un animal? s
Es un pajaro? n
Qué animal era? Raton
Qué diferencia a un pajaro de un Raton? vuela
Si el animal fuera un pajaro cual seria la respuesta? s
Estas pensando en un animal? s
vuela? s
Es un pajaro? n
Qué animal era? Aguila
Qué diferencia a un pajaro de un Aguila? caza
Si el animal fuera un pajaro cual seria la respuesta? n
Estas pensando en un animal? s
vuela? n
Es un Raton? n
Qué animal era? Perro
Qué diferencia a un Raton de un Perro? Ladra
Si el animal fuera un Raton cual seria la respuesta? n
Estas pensando en un animal? s
vuela? n
Ladra? n
Es un Raton? n
Qué animal era? Rinoceronte
Qué diferencia a un Raton de un Rinoceronte? tiene colmillos
Si el animal fuera un Raton cual seria la respuesta? n
Estas pensando en un animal? s
vuela? s
caza? n
Es un pajaro? n
Qué animal era? Buitre
Qué diferencia a un pajaro de un Buitre? come carroña
Si el animal fuera un pajaro cual seria la respuesta? n
Estas pensando en un animal? s
vuela? n
Ladra? n
tiene colmillos? s
Es un Rinoceronte? n
Qué animal era? Elefante
Qué diferencia a un Rinoceronte de un Elefante? tienen trompa
Si el animal fuera un Rinoceronte cual seria la respuesta? n
Estas pensando en un animal? s
vuela? n
Ladra? n
tiene colmillos? s
tienen trompa? n
Es un Rinoceronte? n
Qué animal era? Jabali
Qué diferencia a un Rinoceronte de un Jabali? vive en el agua
Si el animal fuera un Rinoceronte cual seria la respuesta? s
Estas pensando en un animal? s
vuela? n
Ladra? n
tiene colmillos? n
Es un Raton? n
Qué animal era? Jirafa
Qué diferencia a un Raton de un Jirafa? tiene el cuello largo
Si el animal fuera un Raton cual seria la respuesta? n
Estas pensando en un animal? s
vuela? s
caza? n
come carroña? n
Es un pajaro? n
Qué animal era? Mosca
Qué diferencia a un pajaro de un Mosca? es un insecto
Si el animal fuera un pajaro cual seria la respuesta? n
Estas pensando en un animal? s
vuela? n
Ladra? n
tiene colmillos? s
tienen trompa? n
vive en el agua? s
Es un Rinoceronte? s
Soy el más grande!

Como se puede ver inicialmente el programa no “sabe” nada, solo sabe el nodo inicial que es pájaro y pregunta si es un pájaro. Si se le dice que no te preguntará que animal estabas pensando y te pedira que lo diferencies del que te a sugerido él para almacenarlo en su árbol. Así ha medida que se va jugando e introduciendo animales el programa va conociendo más ya que su árbol se va ramificando.

Veamos otra ejecución del programa más corta para anilizarla.

Está pensando en un animal? s
Es un pájaro? n
Cómo se llama el animal? perro
Qué pregunta distinguiría a un perro de un pájaro? Puede volar
Si el animal fuera un perro, cuál sería la respuesta? n
Estás pensando en un animal? s
Puede volar? n
Es un perro? n
Cómo se llama el animal? gato
Qué pregunta distinguiría a un gato de un perro? Ladra
Si el animal fuera un gato, cuál sería la respuesta? n
Estás pensando en un animal? s
Puede volar? n
Ladra? s
Es un perro? s
Soy el más grande!

Esto generaría el siguiente árbol binario.

Como vemos según la información que le damos va generando nuestro árbol. Al principio de cada ronda empieza en lo más alto del árbol y hace la pregunta que contiene el nodo, cuando llega a un nodo hoja trata de adivinar. Date cuenta que todos los animales son nodos hojas y todas las preguntas son nodos ramas. Si falla pide el a usuario el nombre del nuevo animal y una diferencia con el intento fallido, entonces añade el nuevo animal y la nueva pregunta al árbol.

El código a continuación

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos

# Clases
# ---------------------------------------------------------------------

class Arbol:
	def __init__(self, carga=None, izq=None, der=None):
		self.carga = carga
		self.izquierda = izq
		self.derecha = der

	def __str__(self):
		return str(self.carga)

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

def si(preg):
	from string import lower
	resp = lower(raw_input(preg))
	return (resp[0] == 's')

# ---------------------------------------------------------------------

def main():
	bucle = True
	raiz = Arbol("pajaro")
	while bucle:
		if not si("Estas pensando en un animal? "): break

		arbol = raiz
		while arbol.izquierda != None:
			if si(arbol.carga + "? "):
				arbol = arbol.izquierda
			else:
				arbol = arbol.derecha

		#adivinar
		animal = arbol.carga
		if si("Es un " + animal + "? "):
			print "Soy el más grande!"
			continue

		#obtener informacion
		nuevo = raw_input("Qué animal era? ")
		info = raw_input("Qué diferencia a un " + animal + " de un " + nuevo + "? ")
		indicador = "Si el animal fuera un " + animal + " cual seria la respuesta? "
		arbol.carga = info
		if si(indicador):
			arbol.izquierda = Arbol(animal)
			arbol.derecha = Arbol(nuevo)
		else:
			arbol.derecha = Arbol(animal)
			arbol.izquierda = Arbol(nuevo)

	return 0

if __name__ == '__main__':
	main()

La función si() devuelve verdadero si se ha escrito S o s y falso si se ha escrito otra cosa. Es esta función la que interactúa con el usuario.

La condición del bucle externo es 1, lo que significa que seguirá hasta que se ejecute la sentencia break cuando el usuario ya no piense en ningún animal. El bucle while interno recorre el árbol de arriba a abajo, guiado por las respuestas del usuario. Cuando se añade un nuevo nodo al árbol, la pregunta sustituye a la carga y los dos hijos son el animal nuevo y la carga original.

Una carencia del programa es que, al salir, ¡olvida todo lo que le habías enseñado con tanto cuidado! Esto se soluciona almacenando la estructura del árbol en algún archivo o base de datos.

Este código tan simple si se le implementa una base de datos online que vaya haciendo crecer el árbol en cada juego de los usuarios. Al cabo de un tiempo, después de muchos juegos sería capaz de adivinar cualquier animal.

Entradas relacionadas

• Arboles e inteligencia Artificial
• ORTS. Estrategia en tiempo real OpenSource
• Algoritmo Minimax, un jugador incansable
• La Inteligencia Artificial de L4D
• Muestra del Engine de PyIA

Los árboles son una estructura de dato compuesta de nodos que a su vez tienen nodos hijos. Cada nodo está compuesto de una carga y en enlace a sus nodos hijos.

Como vemos en este árbol las cargas son números enteros como 65, 58, 79, etc. Los nodos tienen hijos a los que apuntan, por ejemplo, el nodo 65 tiene 2 nodos hijos 58 y 79. 58 a su vez tiene 3 hijos 25, 96 y 12.

Los árboles se componen de un nodo principal que no tienen padre en nuestro caso es 65 que se llama tronco (por el símil con el árbol) Luego los nodos hijos que van saliendo de él se llaman ramas hasta llegar a nodos que no tienen nodos hijos que son llamados hojas.

Arboles binarios

Vamos a centrarnos en este artículo en los árboles binarios. Los árboles binarios son árboles  que tienen solo dos nodos hijos. Se va bifurcando de dos en dos, por esto lo de binarios.

Como vemos en este árbol hay como máximo dos nodos hijos en cada rama. Esto es un árbol binario.

Creando el tipo de dato

Vamos a proceder a crear este tipo de dato en python:

class Arbol:
	def __init__(self, carga=None, izq=None, der=None):
		self.carga = carga
		self.izquierda = izq
		self.derecha = der

	def __str__(self):
		return str(self.carga)

Como vemos recibe tres valores, la carga y sus dos nodos hijos, en un principio todo definido con None. Para crear un arbol podríamos hacer lo siguiente.

arbol = Arbol(5)

Esto nos dejaría lo siguiente.

Para añadirle dos nodos hijos bastaría con lo siguiente.

arbol = Arbol(5)
arbol.izquierda = Arbol(4)
arbol.derecha = Arbol(3)

Lo que nos dejaría el siguiente diagrama.

Lo anterior se puede resumir en una línea de código.

arbol = Arbol(5, Arbol(4), Arbol(3))

El resultado es el mismo. Como vemos cada llamada a la clase Arbol() solo nos genera un nodo del árbol. Hemos definido el método __str__ que sustituye el valor de print aplicado al objeto, mostrando solo la carga.

Lo más importante para un tipo de dato es tener una manera de recorrerlo, vamos a implementar una función que recorra todos los nodos del árbol y nos devuelva la suma de sus cargas

class Arbol:
	def __init__(self, carga=None, izq=None, der=None):
		self.carga = carga
		self.izquierda = izq
		self.derecha = der

	def __str__(self):
		return str(self.carga)

def suma(arbol):
	if arbol == None: return 0
	return suma(arbol.izquierda) + suma(arbol.derecha) + arbol.carga

arbol = Arbol(5, Arbol(4), Arbol(3))
print suma(arbol)

Como vemos nuestra función suma recibe el nodo padre como parámetro. Tiene la condición base de que si el arbol vale None (esta vacío) pues su valor es 0 si no se cumple se llama recursivamente para calcular el valor de sus hijos más la carga cuando alcanza un nodo que vale None retornará 0 y saldrá de la recursividad.

Los árboles binarios sirven para ir eligiendo entre opciones que se van ramificando. Es útil para comportamientos y toma decisiones de una posible I.A.

En la segunda parte veremos como aplicar los árboles a un problema de Inteligencia Artificial.

Entradas relacionadas

• Arboles e inteligencia artificial II
• ORTS. Estrategia en tiempo real OpenSource
• Algoritmo Minimax, un jugador incansable
• La Inteligencia Artificial de L4D
• Muestra del Engine de PyIA

En Proyecto Iris están llevando a cabo una traducción de estas lecciones al español, merece la pena echarle un vistazo a todo este material teórico que muchas veces pasamos por alto a la hora de crear videojuegos y es incluso más importante el diseño que la parte de programación o gráficos.

• Lecciones traducidas

Entradas relacionadas

• Conceptos de Diseño de Videojuegos
• ORTS. Estrategia en tiempo real OpenSource
• La Inteligencia Artificial de L4D
• Arboles e inteligencia artificial II
• Arboles e inteligencia Artificial

El curso está siendo traducido al español por varios usuarios, van por la mitad de la parte 7, pero parece que lleva un tiempo parado. Quizá cuando tenga algo de tiempo contribuya a traducir, si alguno se anima ya sabe.

Tiene cosas muy interesante un enlace que sin duda se merece ir a favoritos.

Entradas relacionadas

• GameDevLesson – Crear videojuegos
• ORTS. Estrategia en tiempo real OpenSource
• La Inteligencia Artificial de L4D
• Arboles e inteligencia artificial II
• Arboles e inteligencia Artificial

Se trata de un Engine de inteligencia artificial que puede ser aplicado tanto en proyectos simples como un juego de mesa o en algo más complejo como juegos RTS e IA avanzada de shooters y RPG. Electronic Arts y BioWare, han sido algunos de sus usuarios para juegos como FIFA o Baldur´s Gate. Uno de los integrantes Michael Buro, creador de ORTS, es el constructor de un programa de Othello que venció al campeón mundial del juego por 6 a 0.

El proyecto ORTS empieza en el año 2003 con la finalidad de crear un sistema cliente-servidor para el desarrollo de técnicas de Inteligencia Artificial en juegos interactivos de estrategia en tiempo real.

Hay mucha documentación al respecto que podemos encontrar en la red. Además se ha documentado de forma exhaustiva la estructura del código por lo que no es muy difícil empezar a probar algunas cosas.

Hoy todos los interesados en la IA que no conocierais el proyecto acabais de conseguir un juguete muy pero que muy elaborado y tan divertivo o más que cualquier otro que nos pueda caer en navidad.

Entradas relacionadas

• La Inteligencia Artificial de L4D
• Arboles e inteligencia artificial II
• Arboles e inteligencia Artificial
• Algoritmo Minimax, un jugador incansable
• Muestra del Engine de PyIA

1. Estructura del agente

Un agente tiene generalmente una estructura en la que se identifican 4 elementos: capacidad de percepción, capacidad de acción, objetivos y entorno.

1.1 La capacidad de percepción

viene definida por los elementos capaces de reconocer de los que dispone el agente. Pueden ser sistemas sencillos en los que la percepción puede ser la detección o no de intrusos en su área de acción (definida fácilmente con un booleano) o bien mecanismos más complejos como una matriz de NxM que refleje la visión del agente en una orientación y momento concreto del tiempo y que requerirá un proceso más intenso e incluso una abstracción para agilizar cálculos.

1.2 La capacidad de acción

Vendría definida por el conjunto de los movimientos, cálculos o respuestas en general que puede llevar a cabo el agente. Pueden ser tan sencillos como (giro izquierda/giro derecha/avanzar/retroceder) o más complejos como (evadir/emboscar/atacar/confundir).

1.3 Los objetivos

Son la esencia del agente. El comportamiento del mismo irá orientado a la consecución de los mismos.

1.4 El entorno

Es una característica externa al agente pero que condiciona su comportamiento. Puede ser un mundo tridimensional o una abstracción del mismo reducida a eventos. En otros casos puede ser una matriz la que modele el entorno o incluso un grafo que represente una topología concreta.

2 Tipos de agentes

Existe una primera clasificación de los agentes en función de diferentes aspectos como su grado de percepción del entorno o de su capacidad de proceso lógico.

El primero de ellos se basa en reglas sencillas y utiliza aserciones lógicas para llevar a cabo el proceso lógico que decide que acción tomar a cabo. No se tiene en cuenta el entorno donde se desenvuelve más que en la creación de las reglas.

Son rápidos y muy apropiados si el mundo es fácilmente modelable y las acciones generan el resultado apropiado de forma determinista y predecible.

2.2 Agentes bien informados de todo lo que pasa

En este aspecto se requiere un modelo más preciso del entorno donde las acciones que llevamos a cabo produzcan un resultado concreto y podamos observar la evolución del mundo.

2.3 Agentes basados en metas

Este tipo de agentes son más complejos puesto que requieren estructuras más complejas para garantizar comportamientos donde puede ser necesario el uso de técnicas de planificación o de búsqueda complejas que lleven al propio agente a la consecución de sus objetivos.

Se modificará el comportamiento en base a la retroalimentación recibida de aplicar las acciones concretas variando así su planificación o sus parámetros de búsqueda.

2.4 Agentes basados en utilidad

Estos se utilizan cuando no solo es necesario llegar a unos determinados objetivos de forma concreta sino que es necesario llegar de una forma eficiente.

Para ello se utiliza una función de utilidad acotada entre 0 y 1 que determina el grado de acercamiento a la meta que producirá el abanico de acciones disponibles. Distribuyendo dicho contenido en un acercamiento nulo (funcion de utilidad igual a cero) y una consecución de la meta (valor igual a uno).

De la correcta definición de la función de utilidad depende el grado de desempeño del agente.

3. Arquitectura de un agente

Existen diferentes arquitecturas actualmente.

3.1 Basadas en la Lógica.

Conocidos también como agentes deliberativos, toman decisiones basadas en funciones lógicas que caracterizan el comportamiento. Un ejemplo sería: SI sensor_choque == ACTIVADO ENTONCES dirección = atrás.

3.2 Agentes reactivos

Este tipo de agentes actúa en función de los estímulos externos sin tener en cuenta el tiempo pasado del entorno ni el futuro del mismo. Responden de forma directa proporcionando un tiempo de respuesta y de proceso muy alto.

3.3 Arquitectura creencia-deseo-intención.

La toma de decisiones pasa por la interacción y el proceso de los elementos almacenados en las estructuras de creencias, deseos e intenciones. Se basan en deliberar primero que hay que hacer en base a los deseos utilizando las creencias y seleccionando posteriormente las acciones a realizar del grupo de intenciones.

3.4 Arquitecturas híbridas.

Se tienen en cuenta varias capas que utilizan conceptos del resto de arquitecturas. Suelen ser muy eficaces para el entorno concreto en el que se desarrollan pero poco generalizables a problemas que no sean muy similares.

La elección de una o de otra será en base a nuestro entorno por lo que no hay una mejor o peor solución sin la aplicación al problema en concreto.

4. Los tipos de Entornos o Ambientes

A la hora de construir un agente inteligente se tendrá muy en cuenta el entorno para el que se crea. Podemos encontrar varios tipos de entorno.

4.1 Accesibles/No accesibles.

Si a través de los sensores el agente tiene acceso al estado completo del entorno, este es accesible.

4.2 Deterministas/No deterministas.

Si es posible conocer a partir del estado actual y la decisión tomada del agente, el estado futuro del propio entorno y del mismo agente.

4.3 Episódicos/No Episódicos.

Es posible dividir el estado del agente en episodios con características propias.

4.4 Estáticos/Dinámicos.

El ambiente puede cambiar mientras el agente toma una decisión.

4.5 Discretos/Continuos.

Cuando es posible concretar todos los estados del entorno, este es discreto. Cuando no es posible debido a la cantidad y al tipo de variables que intervienen, este será continuo.

Los entornos por lo tanto condicionas en gran medida al agente que queremso construir. De la experiencia dependerá que creemos agentes más precisos y adaptados al entorno y que desempeñen por tanto su trabajo con un mayor grado de precisión y eficiencia.

Nota: He dejado las imágenes de Matrix del autor original porque soy gran fan de la película y me parece una genial manera de ilustrar el artículo con ciencia-ficción.

Entradas relacionadas

• Arboles e inteligencia Artificial
• ORTS. Estrategia en tiempo real OpenSource
• La Inteligencia Artificial de L4D
• Arboles e inteligencia artificial II
• GameDevLesson – Crear videojuegos

En teoría de juegos, Minimax es un método de decisión para minimizar la pérdida máxima esperada en juegos con adversario y con información perfecta. Este cálculo se hace de forma recursiva.

El funcionamiento de Minimax puede resumirse como elegir el mejor movimiento para ti mismo suponiendo que tu contrincante escogerá el peor para ti.

La receta del algoritmo Minimax:

1. Generación del árbol de juego. Se generarán todos los nodos hasta llegar a un estado terminal o determinando una profundidad concreta.

Vamos aplicando el algoritmo por un número fijo de iteraciones hasta alcanzar una determinada profundidad. En estas aplicaciones la profundidad suele ser el número de movimientos o los incluso el resultado de aplicar diversos pasos de planificación en un juego de estrategia.

2. Cálculo de los valores de la función de utilidad para cada nodo terminal.

Para cada resultado final, cómo de beneficioso me resulta si estamos en MAX o cuanto me perjudicará si estamos en MIN.

3. Calcular el valor de los nodos superiores a partir del valor de los inferiores. Alternativamente se elegirán los valores mínimos y máximos representando los movimientos del jugador y del oponente, de ahí el nombre de Minimax.

4 . Elegir la jugada valorando los valores que han llegado al nivel superior.

El algoritmo explorará los nodos del árbol asignándoles un valor numérico mediante una función de utilidad, empezando por los nodos terminales y subiendo hacia la raíz. La función de utilidad como se ha comentado, definirá lo buena que es la posición para un jugador cuando la alcanza.

Versiones más avanzadas como el minimax con poda alfa beta hacen que se reduzca considerablemente el número de nodos a visitar por lo que el tiempo de cálculo se reduce ampliamente.

Y para terminar comentar un ejemplo cásico, el tres en raya (juego del gato, tatetí, triqui, tres en gallo, michi, la vieja o tic tac toe). Se trata de hacer una fila de tres para ganar y evitar que el oponente la haga antes que tu.

Al aplicar el algoritmo, se suceden una serie de estados que se resumen en la fotografía. Un estado -1 significa que MAX gana, 0 empate o -1 pierde.

Se distinguen los nodos terminales con jugada finalizada y los del trayecto. En este juego se puede llegar a la profundidad máxima puesto que se trata de 9 movimientos fijos, en otros como el ajedrez o las damas es muy necesario limitar la profundidad y aplicar medidas que aumenten la eficiencia.

El código se adjunta en python muy comentado. El bloque principal, y a partir de ahi todo lo demás en el documento adjunto, es el siguiente:

b = Board()
turn = 1
while True:
	print “Turno %i.” % turn
	jugadorHumano(b, Jugador_X)
	if b.gameOver():
		break

	jugadorMaquina(b, Jugador_O)
	if b.gameOver():
	break
	turn += 1

Donde se crea una instancia del tablero, necesaria para detallar los elementos que intervienen en juego y e ir aplicando el algoritmo. Se pueden intercambiar jugadores o incluso hacer que jueguen dos máquinas o dos humanos simplemente modificando estas lineas de arriba.

En resumen.

• El minimax aporta una herramienta de proceso recursiva muy útil
• Se pueden aplicar modificaciones al algoritmo para hacerlo más eficiente

En el tres en raya:

• Gana el 1, pierde el -1 y empate 0
• La profundida máxima es de 9, como el número de jugadas posible
• La cota superior de nodos a visitar es en el peor caso (primer movimiento) 9 factoria -A> 9!
• No hay restricciones sobre la validez de un movimiento, simplemente que no se haya hecho antes, por lo que el coste del cálculo es bajo (no hay que aplicar reglas complejas).
• Almacenar las soluciones intermedias no es excesivamente complejo
• Generar los diferentes tableros con las soluciones intermedias a explorar no es costoso pero podría ser un problema en otros juegos y limitar la profundidad por memoria
• La máquina nunca pierde, el juego está completado
• Las partidas entre jugadores máquina siempre quedan en tablas.

El tiempo que tarda un jugador pc en procesar la primera jugada es de 4047,181 ms en un ordenador medio, el que tarda cuando procesa la jugada que lo hace ganador en el último movimiento 0,568 ms y cuando procesa la que lo deja en tablas 0,337. La diferencia de tiempo de cálculo entre los primeros movimientos cuando quedan muchas opciones y el resto es 8000 veces mayor, por lo que el tema de la eficiencia habrá que tocarlo.

Puedes descargar una implementación en el clásico tres en raya.

Fuente

Entradas relacionadas

• Muestra del Engine de PyIA
• Pathfinding A* en Python. Parte I
• El salto del caballo, backtracking
• Arboles e inteligencia artificial II
• Arboles e inteligencia Artificial

Hasta ahora las funciones que hemos visto son funciones que ya están definidas, es decir, que alguien programó y nosotros usamos, pero es posible crear funciones propias que hagan lo que nosotros queramos, la definición de una función en la siguiente.

def NOMBRE (LISTA PARÁMETROS):
    SENTENCIAS

Donde def es la palabra reservada para declarar funciones, NOMBRE es el identificador de nuestra función y cumple las mismas reglas que las nombres de variables. LISTA PARÁMETROS son los datos que necesita nuestra función que puede ser ninguno, uno o varios. Por último SENTENCIAS es el código de nuestra función.

Veamos un ejemplo, supongamos que queremos una función que imprima una nueva linea, es decir, que haga un salto de línea. Podríamos hacer lo siguiente.

def nueva_linea():
    print

La sentencia print si no se le pasa ningún parámetro simplemente deja una línea en blanco. Vamos a verlo.

def nueva_linea():
	print

print "Hola"
nueva_linea()
print "Mundo"

Obtenemos lo siguiente.

Hola

Mundo

El programa anterior es equivalente a escribir

print "Hola"
print
print "Mundo"

Ya que lo que hace es sustituir el nombre de nuestra función por su contenido, pero supongamos que queremos dejar 3 líneas en blanco. Podríamos hacerlo así

print "Hola"
print
print
print
print "Mundo"

Pero si lo vas a usar muchas veces un salto de tres líneas, mejor definir una función que lo haga en una sola.

def tres_lineas():
    print
    print
    print

print "Hola"
tres_lineas()
print "Mundo"

O incluso podríamos usar nuestra función nueva línea para hacerlo.

def nueva_linea():
	print

def tres_lineas():
	nueva_linea()
	nueva_linea()
	nueva_linea()

print "Hola"
tres_lineas()
print "Mundo"

Vamos a hacer un recorrido de este programa, la primera sentencia imprime la palabra Hola. La segunda sentencia llama a la función tres_lineas() así que ahora se va a ejecutar su contenido, la primera línea de esta función es nueva_linea() así que se va a esta y ejecuta lo que hay dentro en este caso la sentencia print, cuando termina de ejecutar lo que hay dentro vuelve a donde lo dejó, es decir, sigue con la siguiente sentencia de tres_lineas() que vuelve a llamar a nueva_linea() y así hasta que termina, cuando no quedan mas sentencias en tres_lineas() vuelve a donde fue llamada, es decir, que sigue con la sentencia print “Mundo”.

Como ejercicio prueba a escribir una función que deje nueve líneas en blanco haciendo uso de tres_lineas().

Las funciones deben declararse antes de usarse, es decir, antes de poder usar tres_lineas() debe haber sido declarada en el programa, si se declara después dará error.

Parámetros

Como vimos al principio a las funciones se les puede pasar parámetros, de hecho las funciones que hemos visto en anteriores entregas recibían parámetros como id(). Los parámetros son datos que recibe nuestra función con los que puede trabajar. Veamos un ejemplo.

def saludar(nombre):
 print "Hola " + nombre

saludar("Adrian")
saludar("Pedro")

nos dará como salida:

Hola Adrian
Hola Pedro

Nuestra función recibe un parámetro llamado nombre que podemos usar dentro de nuestra función, en nuestro caso la unimos a la cadena “Hola ” y la imprimimos en pantalla.

Podemos hacer que nuestras funciones tengan más de un parámetro, puede tener tantos como queremos solo debemos separarlos por comas.

def imprime_suma(num1, num2):
    print num1 + num2

imprime_suma(5, 4)
imptime_suma(4.2, 7)

Como vemos nuestra función recibe dos parámetros e imprime el resultado de la suma.

Retorno de valores

Hasta ahora hemos visto funciones que hacen algo concreto como imprimir un mensaje en pantalla o la suma de dos números, pero ¿Y si queremos almacenar el resultado de la suma en una variable?

Para ello usaremos una nueva palabra reservada return. Se encarga de retornar un valor, veamos un ejemplo.

def suma(num1, num2):
    suma = num1 + num2
    return suma

Esto hace que la función devuelva el resultado de la suma, se podría poner en una sola sentencia, ahorrándonos la variable suma.

def suma(num1, num2):
    return num1 + num2

Ahora podríamos usarla de la siguiente manera.

mi_suma = suma(num1, num2)
print mi_suma

La función devolvería el valor de la sentencia return y con el podemos hacer lo que queramos, en nuestro caso almacenarlo en la variable mi_suma.

Una función puede tener más de una sentencia return, pero debes saber que cuando se alcanza una sentencia return la función termina de ejecutarse y devuelve el control al programa. Lo veremos mejor cuando estudiemos los condicionales.

Entradas relacionadas

• Curso Python IV – Funciones
• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Engine I: Preparándonos para trabajar
• Pygame X: Fuentes tipográficas

Cambiar la escena del juego puede ser algo complicado, recuerda que siempre se debe mantener el bucle de ejecución de los juegos.

Se suele utilizar un bucle infinito que vaya manteniendo esto, pero surge el problema de que en una escena determinada de nuestro juego los eventos, la lógica y las cosas a dibujar serán unas y en otras escenas puede ser otra. Por ejemplo, en un menú habrá que gestionar como eventos si se  acciona algún botón y habrá que dibujar este menú, en otra escena del juego puedes necesitar dibujar otra cosa.

En la imagen superior podemos ver dos escenas diferentes del juego Age of Empires III a la izquierda el menú principal y a la derecha un mapa del juego.

El objeto director y la escena maestra

Nuestras escenas a pesar de lo diferente que puedan ser entre ellas siempre van a tener las características del bucle de arriba. Es decir, deben de inicializarse, actualizarse, gestionar eventos y dibujarse. Por tanto podríamos definir una clase maestra abstracta que se encargara de hacer esto con la escena que tengamos activa independiente de cual sea.

EL objeto director

En lugar de gestionar en nuestro archivo main el bucle del juego lo que vamos a hacer es crear un clase director que será la encargada de gestionar nuestro bucle de juego, este bucle recibirá una escena cualquiera y se encargará de ejecutar sus métodos de actualizar, eventos y dibujar.

# -*- encoding: utf-8 -*-

# Módulos
import pygame
import sys

class Director:
    """Representa el objeto principal del juego.

    El objeto Director mantiene en funcionamiento el juego, se
    encarga de actualizar, dibuja y propagar eventos.

    Tiene que utilizar este objeto en conjunto con objetos
    derivados de Scene."""

    def __init__(self):
        self.screen = pygame.display.set_mode((640, 480))
        pygame.display.set_caption("Nombre Proyecto")
        self.scene = None
        self.quit_flag = False
        self.clock = pygame.time.Clock()

    def loop(self):
        "Pone en funcionamiento el juego."

        while not self.quit_flag:
            time = self.clock.tick(60)

            # Eventos de Salida
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.quit()
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
		        self.quit()

            # detecta eventos
            self.scene.on_event()

            # actualiza la escena
            self.scene.on_update()

            # dibuja la pantalla
            self.scene.on_draw(self.screen)
            pygame.display.flip()

    def change_scene(self, scene):
        "Altera la escena actual."
        self.scene = scene

    def quit(self):
        self.quit_flag = True

Este objeto debe crearse dentro de nuestra función principal main en sustitución del bucle del juego. Vamos a explicarlo:

En el constructor creamos la ventana de Pyagame, le damos título e iniciamos el reloj. También definimos varias variables, por un lado tenemos self.scene = None que será la escena que queremos que represente, de momento ninguna. self.quit_flag = False Es una “bandera” que nos indica si queremos salir.

Luego viene el método loop que es el que contiene el bucle de nuestro juego, tiene como condición para salir del bucle que la variable self.quit_flag sea verdadera, cuando lo sea saldrá del bucle. para hacer esta variable verdadera solo hay que llamar desde cualquier lado del bucle al método quit que como vemos cambia la variable a verdadera.

Ya dentro del bucle lo primero es establecer el framerate, en este caso lo tenemos a 60. Luego ya empezamos con el bucle, comprobamos si se ha producido un evento de salida. En nuestro caso aparte de eso comprobamos también como evento de salida si se ha pulsado la tecla escape (esto a gusto del consumidor y del juego). Si se ha producido un evento de salida como vemos llamamos a self.quit().

Luego llama a self.scene.on_event(), pero, ¿self.scene no valía None? Exacto así que hacemos un inciso aquí en la clase director para explicar la clase scene.

La clase Scene

La clase Scene representa a una clase abstracta del juego. Es una clase padre que debe ser heredada por todas las escenas de nuestro juego, veamos.

class Scene:
    """Representa un escena abstracta del videojuego.

    Una escena es una parte visible del juego, como una pantalla
    de presentación o menú de opciones. Tiene que crear un objeto
    derivado de esta clase para crear una escena utilizable."""

    def __init__(self, director):
        self.director = director

    def on_update(self):
        "Actualización lógica que se llama automáticamente desde el director."
        raise NotImplemented("Tiene que implementar el método on_update.")

    def on_event(self, event):
        "Se llama cuando llega un evento especifico al bucle."
        raise NotImplemented("Tiene que implementar el método on_event.")

    def on_draw(self, screen):
        "Se llama cuando se quiere dibujar la pantalla."
        raise NotImplemented("Tiene que implementar el método on_draw.")

Como vemos es muy sencilla, el constructor solo recibe como parámetro el objeto director. Luego implementa tres métodos. on_update, on_event y on_draw. Cada uno se encarga de hacer las tareas de actualizar, gestionar eventos y dibujar respectivamente. Pero como vemos en el cuerpo de cada uno de los métodos lo que hay es un error de que no de ha implementado ese método, esto es porque Scene es una escena padre que debe ser llamada por las escenas de nuestro juego e implementar estos tres métodos para que hagan las acciones específicas de nuestra escena. Vamos allá.

Creando una escena

Vamos a crear una sencilla escena que no haga nada, simplemente que exista:

class SceneHome(scene.Scene):
    """Escena inicial del juego, esta es la primera que se carga cuando inicia"""

    def __init__(self, director):
        scene.Scene.__init__(self, director)

    def on_update(self):
        pass

    def on_event(self):
        pass

    def on_draw(self, screen):
        pass

Como vemos nuestra escena hereda de Scene (puedes ver que en el código pone scene.Scene, esto es porque yo la tengo en un archivo aparte llamada scene), como vemos en el __init__ lo primero que hacemos es llamar al __init__ de Scene y pasarle el objeto director. Luego implementamos y sustituimos los métodos de la clase padre con los de nuestras escena. En esta caso los tres con la sentencia pass, que no hace nada.

Veamos como inicalizar la escena, volviendo al archivo main.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import pygame
import director
import scene_home

def main():
    dir = director.Director()
    scene = scene_home.SceneHome(dir)
    dir.change_scene(scene)
    dir.loop()

if __name__ == '__main__':
    pygame.init()
    main()

Este es el archivo main de nuestro proyecto, como vemos importa tres módulos, pygame para que pueda ser inicializado, el módulo director que contiene la clase director y el modulo scene_home que contiene la escena con la que queremos iniciar nuestro juego.

Luego ya en la función main creamos el objeto director con dir = director.Director(). Esto llama al constructor del objeto director que como vimos arriba crea la ventana, le pone titulo, crea el reloj y define la variable self.scene = None.

A continuación creamos un objeto scene con nuestra escena: scene = scene_home.SceneHome(dir). y llamamos al método change_scene de la clase director pasándole como parámetro el objeto scene que acabamos de crear, veamos que hace este método.

def change_scene(self, scene):
    "Altera la escena actual."
    self.scene = scene

Pues como era de esperar establece que la variable self.scene del objeto director sea el objeto scene que acabamos de crear. a continuación llama a dir.loop() que es el bucle de nuestro juego que dejamos a medias. Volvamos a él.

Continuando con el objeto director

Nos quedaba por explicar lo siguiente del objeto director.

# detecta eventos
self.scene.on_event()

# actualiza la escena
self.scene.on_update()

# dibuja la pantalla
self.scene.on_draw(self.screen)
pygame.display.flip()

Pues lo que hace es llamar a los tres métodos de nuestra escena cargada que se encarga de gestionar las actualizaciones, los eventos y el dibujado. Por último se llama a pygame.display.flip()
para dibujar la pantalla.

Como vemos ya tenemos la manera de cargar una escena cualquiera desde nuestro objeto director con sus propios métodos de actualización, eventos y dibujado. Ahora para cambiar de scene solo hace falta llamar desde cualquiera parte dentro de nuestra escena activa a director.change_scene(scene) donde scene es la nueva scena que queremos que pase a tener el control ya que esto modificará a self.scene que es la que implementa los métodos.

Puede resultar lioso así de primera, pero a continuación dejo el código de este ejemplo. Si no lo entiendes a la primera el artículo mira el código y trata de probar cosas que puede ser lioso si solo se lee de pasada.

• Descargar ejemplo

Entradas relacionadas

• Muestra del Engine de PyIA
• PyIA – Competición de Inteligencia Artificial en Python
• Avances del Engine RPG: Añadido el Scroll
• Juego de la serpiente paso a paso. Parte 2
• [Pygame] El juego de la serpiente

Os traigo un documento sobre como trabaja la inteligencia artificial del juego Left 4 Dead. Habla de el modo de operar a grandes rasgos, a mi en especial me ha entusiasmado la parte donde explican como utilizan el pathfinding para encontrar caminos cortos y realistas en fin un documento que todo desarrollador de videojuegos no se puede perder.

• Descargar PDF

Podéis encontrar algunas publicaciones más de Valve en: http://www.valvesoftware.com/publications.html

Entradas relacionadas

• ORTS. Estrategia en tiempo real OpenSource
• Arboles e inteligencia artificial II
• Arboles e inteligencia Artificial
• Algoritmo Minimax, un jugador incansable
• Muestra del Engine de PyIA

Ya hemos visto en anteriores entregas la llamada a una función.

>>> type("32")
< type 'string'>

El nombre de la función es type y lo que está entre paréntesis se llama parámetro, las funciones pueden recibir un parámetro, varios parámetros o ningún parámetro. Nuestra función type recibe 1 parámetro, en este caso puede ser cualquier valor. Y cuando es llamada devuelve el tipo de dato que es el que le hemos pasado como parámetro. Esa es su función, valga la redundancia.

Si pusiéramos la función type dentro de un script al ejecutarlo nos dariamos cuenta de que no pasa nada, esto es así porque no le hemos dicho que hacer con ese valor, podríamos imprimirlo en pantalla:

print type("Hola")

O almacenarlo en una variable

tipo_dato = type("Hola")
print tipo_dato

Otra ejemplo de función es la función id() esta función devuelve un identificador único para cada variable o número en la memoria del ordenador.

>>> id(10)
31246556
>>> a = 10
>>> id(a)
31246556
>>> id(4)
31246628

Como vemos tanto el valor 10 como la variable a tienen el mismo identificador, esto es así porque al tener el mismo valor python ahorra memoria usando la misma dirección de memoria ya que contienen lo mismo.

Conversión de tipos

Python posee una funciones muy útiles para la convertir variables de un tipo a otro, siempre que la conversión sea posible.

Tenemos la función int() que convierte un valor pasado en un entero, si se puede.

>>> int("25")
25
>>> int(25.423)
25
>>> int(6.9999)
6
>>> int("Hola")
Traceback (most recent call last):
  File "", line 1, in
ValueError: invalid literal for int() with base 10: 'Hola'

Como vemos podemos convertir la cadena “25″ a tipo int o el número decimal 24.423, pero no podemos convertir la cadena “Hola” a un tipo entero.

Otra función es float() que como imaginaréis convierte a un número decimal.

>>> float(4)
4.0
>>> float("5")
5.0
>>> float("5.25")
5.25

Para python 4 es diferente a 4.0, puede que representen el mismo valor, pero se representan de forma diferente dentro del ordenador.

Por último tenmos la función str() que convierte el valor pasado en una cadena.

>>> str(42)
'42'
>>> str(4.215)
'4.215'

Coerción de tipos

Si queremos saber la fracción de hora que ha pasado, podríamos usar algo como lo siguiente

minutos = 45
fraccion = minutos / 60
print fraccion

Esto en teoría nos devolvería la fracción de hora transcurrida, es decir 0.75 (el 75% de la hora), sin embargo si lo ejecutamos veremos que el resultado es 0, esto ocurre porque estamos haciendo una división de enteros. La solución sería convertir los datos a tipo float.

minutos = 45
fraccion = float(minutos) / 60.0
print fraccion

O directamente aprovecharnos de la coerción de tipos de python que hace que si uno de los valores de la opereción es de tipo float, convierte los demás automáticamente a ese tipo, por lo que podríamos hacer.

minutos = 45
fraccion = minutos/60.0
print fraccion

Funciones y matemáticas

Si tienes una base matemática entender las funciones no te habrá supuesto mucho problema ya que actúan de forma similar a las funciones matemáticas. Por ejemplo si tenemos la siguiente función:

F(x) = Sin(1/2)

Sabemos que primero se evalúa la expresión 1/2 que da 0.5 y luego se halla el seno de 0.5 que sería 0.4794 aproximadamente. También podemos tener funciones dentro de funciones

F(x) = Sin(log(25))

Donde primero se calcularía el logaritmo de 25 y luego el seno del resultado.

En programación sucede igual si tu tienes una función dentro de una función, primero se evalúa la funciones interiores y luego las exteriores.

Por cierto, python dispone de un módulo para las funciones matemáticas más habituales llamado math. Los módulos en python es código ya escrito que contienen clases y funciones listas para ser usada, veamos un ejemplo

>>> import math
>>> math.sin(5)
-0.95892427466313845
>>> math.sin(45)
0.85090352453411844
>>> math.cos(45)
0.52532198881772973
>>> math.sqrt(25)
5.0
>>> math.log(25)
3.2188758248682006

como vemos a través de import math importamos el módulo y para usar lo que contiene ese modulo lo hacemos a través de módulo.funcion(), como por ejemplo math.sqrt(49) que nos devolvería la raiz cuadrada de 49.

Entradas relacionadas

• Curso Python V – Funciones del usuario
• Curso Python III – Scripts y Comentarios
• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Engine I: Preparándonos para trabajar

El intérprete está muy bien para probar pequeños códigos o hacer alguna cosa rápida, pero como norma general querrá guardar sus programas para poder editarlos y ejecutarlos cuando quiera.

Esto se hace a través de un script, un script de Python no son más que sentencias que se le pasan al intérprete una detrás de otra, veamos un ejemplo de script.

a = 5
b = 2
c = (a+b) * (a+b)
mensaje = "Hola Mundo"

print c
print mensaje

Esto se guarda en un fichero de texto plano con la extensión .py y ya tenemos nuestro Script ahora cuando lo ejecutemos el intérprete empezará a leer y ejecutar sentencia por sentencia, dándonos esta salida.

49
Hola Mundo

Como vemos ha hecho las operaciones con las variable y luego a ejecutado las dos sentencias print devolviendo los valores pasados.

A partir de ahora trabajaremos con Scripts y usaremos la consola para probar pequeñas cosas.

Comentarios

Conforme los programas van creciendo de tamaño y complicándose, se vuelven más complicados de leer. Los lenguajes formales son densos y con frecuencia es difícil observar un trozo de código y averiguar lo que hace, o por qué lo hace.

Por ello es una buena idea añadir notas a su programa que expliquen, en un lenguaje natural, qué hace el programa. Estas notas se llaman comentarios y se marcan con el símbolo #:

# calcula el porcentaje de la hora que ha pasado ya
porcentaje = (minuto * 100) / 60

En este caso el comentario ocupa toda una línea, pero también se pueden poner al final de una sentencia:

porcentaje = (minuto * 100) / 60 # ojo: división de enteros

Todo lo que va del # al final de la línea se ignora (no tiene efecto sobre el programa). El mensaje está destinado al programador, o a futuros programadores que podrían tener que usar el código. En este caso avisa al lector sobre el sorprendente comportamiento de la división de enteros.

Usa comentarios a menudo, cuando tus programas sean de miles de líneas de código y lleves unas semanas sin mirarlo me lo agradecerás

Entradas relacionadas

• Curso Python IV – Funciones
• Curso Python II – Tipos y variables
• Curso Python I – Intérprete y scripts
• Curso Python – Presentación
• Curso Python

¿Qué es el tilemapping?

Bueno, asi a lo simple el tilemapping es dividir el terreno (o mapa) de juego en casillas iguales, a las que se les llama“tiles”. Cada una de estas casillas puede tener un gráfico distinto, y juntando muchas casillas se consigue un mapa complejo de una manera sencilla.

Un ejemplo: Hundir la Flota

En este juego, el mapa es una cuadrícula de casillas. Cada casilla puede tener varios estados (agua, barco, barco tocado, barco hundido, etc…). Y cada uno de estos estados se representan en pantalla cambiando el color de la casilla, o usando una imagen distinta.

A la hora de dibujar la cuadrícula usando una librería de programación gráfica 2D como SDL lo que haremos será recorrer todo el mapa, y dibujar el gráfico (o tile) que corresponda dependiendo del estado, en la posición que sea.

Representación

Lo que nos permite este sistema es representar el mundo del juego de una forma muy simple. Lo único que tenemos que hacer es guardar una matriz de casillas. Y por cada casilla, el gráfico que le corresponda. (además de la información que el juego necesite, por supuesto).

De momento. Podemos suponer que sólo tenemos que guardar el gráfico, así que podemos definir el mapa así:

int mapa[ANCHO_MAPA][ALTO_MAPA];

y si mapa[x][y] = 4, eso significa que en la posición (x, y) del mapa hay una casilla con el gráfico número 4 (guardamos simplemente un índice)

Claro, necesitaremos también los gráficos de cada casilla. En vez de crear una superficie para cada uno, como por regla general serán bastante pequeños, lo que hacemos es agrupar muchos en una única superficie. Y a eso es a lo que llamamos Tileset.

Un ejemplo con varios tipos de tiles:

Así que lo que haremos para dibujar el mapa es recorrer la matriz, y por cada casilla, ver que “tile” hay que dibujar, y hacer un blit desde el “tileset” que contenga todos los tiles a la superficie destino (la pantalla).

De momento vamos a suponer que al Tileset solo hace falta indicarle el índice del tile que hay que dibujar, y la posición en la pantalla donde debe aparecer, y él se encarga de hacer el blit.

for (y = 0; y < ANCHO_MAPA; y++) {
   for (x=0; x < ANCHO_MAPA; x++) {
      dibujar mapa[x][y] en (posX, posY)
   }
}

De momento aquí vemos algo curioso: Aparecen dos sistemas de coordenadas distintos:

• (x, y) son las coordenadas de la casilla en la matriz de casillas (el mapa).
• (posX, posY) son las coordenadas en pixels del punto de la pantalla donde dibujaremos la casilla.

Coordenadas

Bueno, lo acabais de ver. Tenemos más de un sistema de coordenadas al convertir nuestra matriz de casillas en algo dibujado en pantalla. Lo que tenemos que ver es cuántos sistemas tenemos, y cómo pasar de uno a otro.

De momento, a (x, y) las vamos a llamar “Coordenadas lógicas” o “Coordenadas de mapa”.

Y a (posX, posY) las llamaremos “World Coordinates”, o en español, “Coordenadas del Mundo”, o“Coordenadas Absolutas”.

Al proceso de pasar de las coordenadas lógicas a las coordenadas absolutas lo vamos a llamar “Plotting”, o más específicamente: “Tile Plotting”.

Al proceso de pasar de pasar de las coordenadas absolutas a las coordenadas lógicas lo vamos a llamar “Mouse Mapping” (lo del Mouse es porque se suele usar para detectar sobre qué casilla ha clickeado el jugador).

En nuestro caso pasar de un sistema de coordenadas a otro es muy sencillo. Suponed que cada tile tiene un ancho y alto de 50 pixels. Entonces:

• La casilla (0, 0) tiene las coordenadas absolutas (0, 0) (esquina superior izquierda)
• La casilla (1, 0) (la siguiente a la derecha) tiene las coordenadas absolutas (50, 0)
• La casilla (2, 0) (la siguiente) tiene las coordenadas abs. (100, 0)
• La casilla (2, 1), tiene las coordenadas abs. (100, 50)
• La casilla (x, y) tiene las coordenadas abs. (50 * x, 50 * y)

Así que:

plot (x, y) = (ANCHO_TILE * x, ALTO_TILE * y)

Y el proceso inverso es igual de sencillo:

mouseMap (x, y) = (x / ANCHO_TILE, y / ALTO_TILE)

Así que el algoritmo de antes se nos queda en esto:

for (y = 0; y < ANCHO_MAPA; y++)
   for (x=0; x < ANCHO_MAPA; x++) {
      tileset->dibuja (mapa[x][y], ANCHO_TILE * x, ALTO_TILE * y, pantalla);
   }

(He supuesto que tileset tiene un método para dibujar los tiles que recibe el índice del tile, las coordenadas, y la superficie destino)

Desde luego, habrá que implementar ese método en tileset, que básicamente consistirá en averiguar qué rectángulo corresponde al tile indicado, y hacer un blit a las coordenadas que nos pasen, nada complicado.

Bueno, pues ya está. Aunque es un poco simple, no? Vamos a darle una vuelta de tuerca más:

Scrolling

Supongo que la mayoría sabréis en que consiste el scroll, pero bueno:

Imaginad que tenemos un mapa muy grande. Al ser tan grande, no cabe dentro de la pantalla, así que no podemos verlo todo de una vez. Lo que hacemos es que la pantalla se convierta en una “ventana” dentro del mundo del juego.

Y por supuesto, el jugador va a ir moviendo esa ventana, desplazándola de un lugar a otro:

El desplazamiento de esa ventana es lo que llamamos “Scroll”, y lo mediremos siempre relativo a las coordenadas absolutas de la casilla (0,0). Así que este desplazamiento se medirá en pixels.

Con esto, introducimos un nuevo sistema de coordenadas. Además de lo que teníamos antes, ahora hay que tener en cuenta que las coordenadas de la casilla en la pantalla dependerán del desplazamiento de la pantalla respecto a la casilla (0,0).

Por ejemplo, la casilla con coordenadas lógicas (4, 1) puede tener las coordenadas absolutas (200, 50), y a la hora de dibujarse en pantalla, teniendo en cuenta el desplazamiento, puede que se dibuje en (451, 37).

A estas nuevas coordenadas las llamaremos “Coordenadas de Pantalla” (Screen Coordinates)

El convertir de coordenadas absolutas a coordenadas de pantalla es tan sencillo que lo podemos hacer como parte del plotting:

plot (x, y) = ((ANCHO_TILE * x) – scroll.x, (ALTO_TILE * y) – scroll.y)

Y al revés:

mouseMap (x, y) = ((x + scroll.x) / ANCHO_TILE, y / (y + scroll.y) ALTO_TILE)

Y por lo tanto el algoritmo se convierte en:

for (y = 0; y < ANCHO_MAPA; y++)
   for (x=0; x < ANCHO_MAPA; x++) {
      tileset->dibuja (mapa[x][y], (ANCHO_TILE * x) – scroll.x,
                       (ALTO_TILE * y) – scroll.y, pantalla);
   }

Ya que hemos llegado hasta aquí, démosle otra vuelta de tuerca más…

Optimizaciones

Vale, volved a imaginar el mapa gigante. Es enorme. Ocupa el equivalente a 8 pantallas de ancho y 5 de alto. Son un montón de casillas. Pero sólo vamos a ver las que “quepan” en pantalla.

Entonces… ¿para qué estamos recorriendo todas las demás y diciéndoles que se dibujen? Si no se van a ver.

En programación gráfica, la primera regla de oro es “No dibujarás nada que no se vaya a ver en pantalla”, así que vamos a ver si podemos optimizar esto un poco, y evitar dibujar siempre todo el mapa.

Lo que está claro es que vamos a dibujar todas las casillas que estén dentro de la pantalla, es decir, estas:

Todas las casillas marcadas en verde azuloide serán las que tengamos que dibujar. Todas las demás no hacen falta.

Asi que lo que tenemos que hacer es limitar el bucle de nuestro algoritmo a ese rectángulo verdi azuloide. Pero para hacer eso, necesitamos conocer cuáles son las casillas de sus esquinas. Necesitamos saber sus coordenadas lógicas, no?

No las tenemos, pero si que tenemos sus coordenadas de Pantalla. Si la pantalla es de 800×600, las coordenadas de pantalla de las esquinas son:

• (0, 0) para la esquina superior izquierda
• (800, 0) para la esquina superior derecha
• (0, 600) para la esquina inferior izquierda
• (800, 600) para la esquina inferior derecha

Si mapeamos estas coordenadas, obtendremos las coordenadas de las casillas que se encuentran en cada una de las esquinas. Es decir, las casillas que delimitan el rectángulo verdi azuloide. Es decir, las que debemos meter en nuestro bucle para dibujar sólo las que realmente son necesarias…

Pues venga:

inicial = mouseMap (0, 0);

limDerecho = mouseMap (800, 0);
limInferior = mouseMap (0, 600);

for (y = inicial.y; y < limInferior.y; y++)
   for (x=inicial.x; x < limDerecho.x; x++) {
      tileset->dibuja (mapa[x][y], (ANCHO_TILE * x) – scroll.x,
                       (ALTO_TILE * y) – scroll.y, pantalla);
   }

Nota: Sería necesario comprobar también si la casilla que vamos a dibujar es “válida”. Es decir, está dentro del mapa, para no dibujar casillas como (-3, 0), por ejemplo.

Por último vamos a ver tratamiento de capas.

Layering

¿Qué es el layering? Pues simplemente, tener varias capas de tiles por cada casilla. Si queremos guardar no sólo el tipo de terreno, sino también si hay un objeto en la casilla, necesitamos más información que un simple entero.

Lo que tenemos entonces son varios “tiles” en una casilla, que se dibujan desde el fondo hacia arriba (primero el suelo, luego los objetos, etc…).

En nuestro caso lo que haremos será que la casilla no sea un “int”, sino una estructura (o clase) Casilla, que guardará el tipo de suelo, pero también el tipo de pared, si tiene algún objeto, etc…

A la hora de dibujarlo, habrá que dibujar todo eso en orden:

tilesetSuelos->dibuja (mapa[x][y].tipoSuelo, (ANCHO_TILE * x) – scroll.x,
                       (ALTO_TILE * y) – scroll.y, pantalla);

tilesetParedes->dibuja (mapa[x][y].tipoPared, (ANCHO_TILE * x) – scroll.x,
                        (ALTO_TILE * y) – scroll.y, pantalla);

tilesetObjetos->dibuja (mapa[x][y].tipoObjeto, (ANCHO_TILE * x) – scroll.x,
                        (ALTO_TILE * y) – scroll.y, pantalla);

Y os podeis imaginar que será algo más complicadillo, ¿verdad?

Fuente

Entradas relacionadas

• Introducción a la programación gráfica 2D (III)
• Introducción a la programación gráfica 2D (II)
• Algoritmo Minimax, un jugador incansable
• Introducción a la programación gráfica 2D (I)
• Juego de la serpiente paso a paso. Parte 2

En realidad el “Blittelado” es algo más complejo que copiar y pegar de una superficie a otra, a lo mejor las superficies no tienen el mismo formato de pixel y hay que convertirlos, por lo general esto será trasparente para el usuario y se encargará de ello la api gráfica, de todos modos esto es mejor consultar sobre la api en particular que se esté usando.

Sistemas de coordenadas

Todas las superficies de las apis gráficas deben de tener un sistema de coordenadas, este se utiliza para saber en que parte se debe copiar una superficie a otra o que tamaño tiene una imagen que al fin y al cabo es lo que van a contener las superficies de nuestras aplicaciones.

El sistema de coordenadas tiene su origen en la esquina superior izquiera de la superficie, siendo ese pixel de la superficie la coordenada (0, 0) de la imagen.

Las superficies son rectangulares siempre

Es muy importante que se entienda que las superficies siempre son rectángulos. Y tu puedes decir, mentira, ¡El mismo Pacman es redondo! y yo te diré tu lo ves redondo, pero internamente no es más que un rectángulo que tiene un colo transparente (más adelante hablaremos del canal alpha, colorkey y demás).

Bien vamos a tratar con una superficie que represente una imagen, pongamos que tenemos esta imagen (No os riáis, no me llevo bien con el dibujo).

Está imagen podría ser la superficie de nuestro juego y tendría su coordenada (0, 0) en la parte superior derecha luego tendría un ancho y un elto en esta caso 98×103 por tanto el pixel inferior derecho tendría la coordenada (98, 103). Otras coordenadas son las superior derecha sería la (98, 0) y la inferior izquierda sería la (0, 103). Creo que se capta la idea.

Ahora supongamos que queremos hacer un blit de nuestra superficie a la superficie screen, en otras palabras, copiar nuestra imagen en la pantalla. ¿Dónde se copiaría), pues en la coordenada que le pasemos a nuestra función que se encargue de hacer el blit.

Supongamos que tenemos una  superficie screen de 320×240 y nuestra imagen y queremos copiarla en la coordenada (50, 47). Pues se copiará de la siguiente manera:

Como vemos la coordenada (0, 0) de la superficie origen se copia en la coordenada que elijamos de la superficie destino, es decir, la coordenada (0, 0) de nuestra superficie imagen la colocamos en la coordenada (50, 47) de la superficie de la pantalla. Por lo que para obtener la posición que ocupa el pixel inferior derecho de la imagen en la pantalla valdría una simple suma. (X+ANCHO_IMAGEN, Y+ALTO_IMAGEN), en nuestro caso sería (50+98, 47+103) que nos daría la coordenada del pixel final de la imagen.

Por lo general las bibliotecas gráficas existentes a parte del inicio se le puede indicar el final de lo que se quiere copar por lo que solo quedaría copiada esta área de la imagen. Vamos a hablar de los clippers.

Clippers

Lo que hace el clipper es definir el área de la superficie destino sobre el que podemos blittear. Todo lo que caiga fuera de ese área, no se dibuja.

El clipper de una superficie solo afecta a los blits que tengan como DESTINO a esa superficie. No afecta para nada al origen.

En la imagen de la izquierda dice “sin clipper”, pero eso no es completamente correcto. En realidad, siempre hay un clipper, sólo que por defecto su área abarca toda la superficie, dejando que bliteemos en todas partes.

La razón de que existan los clippers es sencillamente el evitar que al hacer un blit podamos escribir en zonas de memoria que no corresponden a la superficie. El rectángulo nunca puede extenderse más allá del limite de la superficie, así que ese problema desaparece automáticamente.

Pero además de eso, podemos darle más utilidades para optimizar el dibujado. Si sólo necesitamos actualizar una zona de la superficie destino, pero la región que estamos blitteando es enorme, usando un clipper nos evitamos escribir pixels que no necesitamos (o que no debemos, porque no queremos machacarlos).

Color Keys

Volvamos al problema que teníamos más arriba, donde decíamos que todos las superficies han de ser rectangulares, como el Pacman de más arriba. En realidad lo ideal sería que solo se dibujara nuestro sprite y no el área rosa de alrededor, para ello se usa el colorkey, esto consisten en definir un color de la imagen como transparente. Todo el color de una imagen marcado como colorkey se volverá transparente. Pongamos un ejemplo:

Como vemos el recuadro blanco queda muy mal, la solución es definir que en nuestra superficie de origen el colorkey se la imagen sería el blanco, por lo que nos quedaría:

Como vemos mucho mejor, pero no olvidemos dos cosas importantes.

1. Aunque el rectángulo blanco sea transparente sigue estando ahí y la esquina superior izquieda de nuestra imagen sigue siendo la que era antes, aunque no se vea.
2. El colorkey hace que TODOS los píxeles de ese color se vuelvan transparentes por lo que debes asegurarte de que el color que uses como colorkey no forma parte de la imagen. Se suelen usar colores poco comunes como el (255, 0, 255) que es el rosa chillón de arriba, pero si tu imagen tiene este color basta con usar otro.

Canal Alpha

Por último mencionar el canal Alpha, consiste en definir un grado de transparencia para la imagen.

No voy a explicar mucho más de el porque en apis 2D que no usen tratamiento por gráficos 3D como OpenGL o DirectX usar el canal alpha gasta muchos recursos pues no solo hay que leer la imagen de origen sino también el destino para la mezcla de colores haciendo que en ocasiones pueda ser un verdadero cuello de botella para el rendimiento.

Entradas relacionadas

• Tilemapping – Juegos basados en tiles
• Introducción a la programación gráfica 2D (II)
• Algoritmo Minimax, un jugador incansable
• Introducción a la programación gráfica 2D (I)
• Juego de la serpiente paso a paso. Parte 2

Diferencias entre 3D y 2D

En primer lugar, una API 3D se basa en polígonos. Estos polígonos están formados por vértices con coordenadas en 3D. Lo que hacemos (o lo que hace la API), es “proyectar” estos polígonos sobre un plano (la pantalla, o más concretamente, un trozo de la pantalla al que se llama “viewport”)

Cuando esos polígonos los dibujamos en pantalla, además tenemos la opción de rellenarlos con una imagen, a la que llamamos “textura”. Este proceso se llama “rasterización”.

Entonces, para hacer una aplicación 2D en una librería 3D, bastaría con usar una proyección ortogonal.

Eso es completamente correcto para las librerías 3D, que se basan en el proceso de “proyección + rasterización”. Sin embargo, al usar una librería 2D (SDL, Pygame…), esos conceptos sencillamente no existen.

Para entender cómo es la filosofía de la programación clásica 2D, hay que pensar cómo eran los ordenadores de hace 15 años. En esa época las tarjetas aceleradoras no existían (o costaban una pasta), y todo este proceso de “proyección + rasterización” tenía que hacerse mediante software. Y en aquella época, los procesadores no eran especialmente rápidos, especialmente en operaciones en punto flotante.

Así que es lógico que al programar una aplicación en 2D, se hiciese mediante un sistema en el que las proyecciones y rasterizaciones no existan, y todos los cálculos sean únicamente operaciones enteras, que los procesadores pueden realizar mucho más rápido.

Conceptos básicos de programación 2D

Una librería gráfica 2D se basa en el concepto de SUPERFICIES, y de operaciones entre superficies. Una superficie no es más que un espacio en memoria donde guardar una imagen, y las operaciones que se realizan entre superficies, son copias de trozos de una superficie origen sobre una superficie destino.

Un ejemplo: el Paint.
Al cargar el paint, el lienzo representaría una superficie. Puede tener una imagen cargada desde un archivo, puede estar en blanco, etc…

Ahora imaginad que ejecutamos 2 paints. Cada uno con su lienzo. Eso representa 2 superficies en memoria. Podemos tener una superficie vacía (blanca), y otra con una imagen cargada del archivo.

Y la operación básica entre superficies, sería hacer un “Copy-Paste”. Seleccionar una región en la superficie A, y copiarla sobre algún lugar en la superficie B. Esta operación es a la que se llama “Blit”, y es la más importante en cualquier librería 2D.

Al igual que en Paint, al hacer un Blit, lo que había en la superficie destino en la región que sobreescribimos se pierde para siempre. Al copiar sobre esa posición machacamos los datos anteriores. Esto es importante si tenemos, por ejemplo, un personaje moviéndose sobre un escenario. Al dibujar el personaje destruimos esa región del escenario, así que si el personaje se mueve, tendremos que volver a dibujar de nuevo el escenario por cada fotograma.

También de esto sacamos que el orden en que hagamos los blits importa, y mucho. Si algo tiene que quedar por encima, tiene que ser lo último que bliteemos.

Todo esto está muy bien para copiar imágenes entre superficies. ¿Pero cómo se muestra todo eso en pantalla?. Fácil, tendremos una superficie especial, que represente a la pantalla propiamente dicha. Todo lo que pongamos en esa superficie será lo que aparecerá por pantalla.

Esa superficie suele llamarse screen (Pantalla) y tiene como tamaño la resolución, por ejemplo, si tu aplicación es una ventana de 640×480 pues ese será el tamaño de tu superficie y ahí podras hacer todo los blit que quieras, a diferencia que lo que hay en esta superficie es lo que se muestra.

Flipping

Vale, ahora tenemos una imagen que hemos compuesto sobre el Buffer Primario. Ya tenemos todo listo para que se muestre en el monitor. ¿Como hacemos para “actualizar” el monitor?

Depende, hay dos maneras de hacerlo, la fácil, y la difícil.

La fácil es llamar a la función de nuestra biblioteca que se encargue de  dibujar y actualizar directamente todo a la superficie de nuestra screen. El problema de esto es que el monitor tiene un refresco de actualización, y si llamamos a esta función en el momento en que el monitor está dibujando algo, lo que veremos será un parpadeo bastante molesto.

Lo que queremos es que esa actualización se produzca justo en el momento en que el monitor ha terminado de dibujar un fotograma, y esta preparándose para el siguiente. A esto se le llama “sincronizarlo con el refresco vertical”, o en inglés, “VSYNC”.

Para hacer eso, lo que se usa es una técnica llamada “Double Buffer”. Consiste en que tendremos un buffer Secundario (o “BackBuffer”), además del primario. Nuestra imagen la compondremos en el secundario, y llegado el momento, intercambiaremos ambos buffers para que el secundario pase a ser el primario y viceversa, actualizando la imagen en el monitor. Este intercambio estará sincronizado con el refresco del monitor.

La mayoría de las bibliotecas gráficas modernas tienen funciones o clases que se encargan ellas solas de hacer todo este del doblebuffer y nosotros simplemente tenemos que decir que actualice la pantalla y ella se encarga de crearlo, pero es importante conocer como funciona.

Resumiendo:

• Programación 3D != Programación 2D.
• Programación 3D == Punto Flotante, matrices, proyecciones + rasterizaciones.
• Programación 2D == Operaciones enteras, ints, copias de trozos de memoria de un lado a otro.

• Superficie: Espacio en memoria donde tenemos una imagen.
• Blit: Copy-paste de una región de una superficie sobre otra.
• Buffer Primario: Superficie que contiene lo que se dibuja en pantalla.
• Double Buffer: Algo raro que evita los parpadeos.

Entradas relacionadas

• Tilemapping – Juegos basados en tiles
• Introducción a la programación gráfica 2D (III)
• Algoritmo Minimax, un jugador incansable
• Introducción a la programación gráfica 2D (I)
• Juego de la serpiente paso a paso. Parte 2

Esto no será para ningún lenguaje concreto será teoría aplicable a cualquier lenguaje y biblioteca de gráficos 2D.

Hardware y representación de imágenes

Vamos a comenzar repasando algunos conceptos básicos sobre las imágenes y su representación en un ordenador.

Una imagen puede ser representada como un conjunto de puntos. Cada uno de esos puntos tienen un color asociado. El número de puntos que representa una imagen puede variar segúna la definición que queramos obtener. Con cuantos más puntos sea representada una imagen más calidad tendrá y más espacio necesitaremos para almacenarla. Este aumento de tamaño provocará un aumento de tiempo de computación para que pueda ser mostrada. Esto se traduce en un mayor consumo de espacio de disco y que las transferencias de datos que hace que la imagen se nos muestre en la pantalla de nuestro ordenador estén más cargadas al tener más datos que intercambiar. Por este motivo es fundamental trabajar con una resolución idónea, buscando el equilibrio entre espacio y calidad.

Estos puntos a los que hacemos referencia se conocen como píxeles y determinan la resolución de una imagen. Los monitores tienen una limitación en cuanto al número de píxeles que pueden mostrar. Esta limitación es un máximo ya que siempre podrá mostrar un número menor de píxeles. Cada uno de estos píxeles tendrá asociado un color para los que se destinará un determinado número de bits (bits por píxel o bpp) que determinaran la calidad, medida en profundida de color, de la imagen. Los valores más comunes para el bpp son:

• 8 bits (256 colores)
  • Debemos usar una paleta para establecer los distintos 256 posibles colores.
• 16 bits (65,536 colores o Highcolor)
  • Existen distintas combinaciones para el uso de estos 16 bits. Las más comunes son:
    • 5 bits para rojo, 6 bits para verde y 5 para azul. Se utiliza esta distribución porque el ojo humano distingue más colores verdes que otros.
    • 4 bits para rojo, 4 bits para verde, 4 para azul y 4 para transparencias. Este es un modelo más equitativo.
• 24 bits (16,777,216 colores o Truecolor)
  • Este es el modelo RGB puro. Se destinan 8 bits para cada color que cubren todo el espectro.
• 32 bits (16,777,216 colores)
  • Utiliza RGB más 8 bits destinados a canales alpha o transparencias.

Depende del sistema en el que trabajamos y para el que vaya destinado la aplicación definiran unas resoluciones de trabajo con una profundidad de color bien determinada. Como puedes suponer cuanto mayor sea el número de bits por píxel mayor será el tamaño de la imagen. Este es otro factor a considerar ya que necesitaremos la cantidad de bits indicada por el bpp para almacenar un sólo píxel. SDL nos proporciona funciones que nos permiten establecer estos modos de video así como consultar su compatibilidad con el sistema.

Un concepto importante es el de framebuffer que aparecerá varias veces en el tutorial. El framebuffer no es más que la zona de memoria que se corresponde con la imagen que mostrará el sistema en pantalla. Cada píxel tendrá una concordancia exacta en pantalla en una determinada posición. El formato del framebuffer suele ser un vector para simplificar la escritura sobre él. Al ser un vector unidimensional, a la hora de querer modficiar un píxel dado por unas coordenadas (x, y) tendremos que realizar una conversión de escala.

Subsistema de Vídeo

El subsistema de vídeo es la parte del sistema que nos permite interactuar con los dispositivos de vídeo. Generalmente el hardware de vídeo está compuesto por una tarjeta gráfica y un monitor o pantalla de visualización.

Existen numerosos tipos de tarjetas gráficas en el mercado pero todas ellas tienen características comunes que nos permiten trabajar con ellas independientemente del fabricante o del tipo de chip que monten dichas tarjetas. Poseen una unidad de procesamiento de gráficos y una memoria, ya sea compartida o dedicada, donde almacenar las estructuras o imágenes que se deben mostrar por pantalla.

El número de pantallas existentes en el mercado también es muy amplio pero no es algo que nos afecte a la hora de desarrollar un videojuego actualmente a no ser que lo hagamos para un dispostivo específico. En otros tiempos conocer la cantidad de colores que podía manejar un subsistema de vídeo era fundamental para diseñar cualquier aplicación para dicho sistema. Hoy en día la mayoría de los ordenadores que tenemos en casa son capaces de manejar el conocido como color real o true color a unas resoluciones que son prácticamente estándar.

Los principales aspectos que tenemos que tener encuenta de estos dispositivos son dos:

• La primera es la resolución de ambos dispositivos. Siempre deberemos trabajar a una resolución que sea admisible por el hardware en cuestión. Sería absurdo realizar un videojuego con un tamaño de ventana de 5000 x 5000 para un ordenador personal actual. Algo más avanzado el capítulo presentaremos las resoluciones más habituales.

El concepto de resolución de pantalla es bastante simple. Se trata del número de píxeles que puede ser mostrada por pantalla. Viene presentada, normalmente, por la ecuación x * y donde x hace referencia al número de columnas de píxeles e y indica el número de filas de píxeles. Puedes observar las referencias en la imagen que se muestra a continuación.

• La segunda es la posibilidad de crear superficies en la memoria de la tarjeta gráfica. Algunas tarjetas gráficas tienen la memoria integrada en la placa base del ordenador por lo que comparten memoria con la CPU y emularán este comportamiento aunque almacenen el contenido en la memoria principal del sistema. El poder almacenar en dicha memoria las superficies que queramos mostrar es muy importante ya que concederá un mayor rendimiento a nuestra aplicación. Esta memoria es conocida como RAMDAC.

Entradas relacionadas

• Tilemapping – Juegos basados en tiles
• Introducción a la programación gráfica 2D (III)
• Introducción a la programación gráfica 2D (II)
• Engine VI: El formato TMX
• A* Pathfinding. Camino óptimo

El objetivo de todo nivel es encontrar la E verde que es la salida. Pero habrá trampas como los fosos de pinchos en los que debemos evitar caer.

Los bloques amarillos harán que nuestro personaje salte el triple pudiendo superar grandes alturas.

Los bloques verdes son trampas móviles que van de arriba abajo y los rojos de izquierda a derecha, hay que evitar tocarlas pasando en el momento justo. Vamos como podemos usar los bloques amarillos para superar también grandes distancias.

El juego se controla con las flechas de dirección izquierda-derecha y arriba para saltar.

El Engine aún esta verde y no hay sistema de puntuación, no están todas las trampas y ayudantes creadas y los 3 niveles que hay son de prueba. Pero ya aunque sea es jugable.

Para ejecutarlo abrir el archivo main.py que esta en la carpeta src.

• Descargar pyIA (Corregido error de la tecl enter).

Entradas relacionadas

• PyIA – Competición de Inteligencia Artificial en Python
• Algoritmo Minimax, un jugador incansable
• Avances del Engine RPG: Añadido el Scroll
• Juego de la serpiente paso a paso. Parte 2
• [Pygame] El juego de la serpiente

¿En qué consiste?

La idea es mediante la creación de una IA, manejar a un personaje por una serie de niveles de plataformas superando obstáculos, como muros, pinchos, fosos y demás. El objetivo sería encontrar la salida. Los participantes no juegan, solo programan su IA y está es la que compite por ellos, a parte de superar los obstáculos y  llegar a la meta, se compite con otros participantes por lo que se cronometra el tiempo y quien llega antes, se busca la mejor IA.

Por ahora las normas son un esbozo y actualmente estoy desarrollando el engine base del proyecto. He hecho algunas pruebas de una IA básica que es capaz de saltar muros para encontrar la salida, dejo un video de demostración:

[There is a video that cannot be displayed in this feed. Visit the blog entry to see the video.]

Como se puede ver por ahora solo están implementados los muros y las colisiones con esto, falta implementar en el engine, las trampas, control de tiempos, menús y demas.

Luego habría que definir unas normas de que y que no se puede hacer. En principio la IA sera un Script que solo recibe como parámetros el player y la información del mapa para consultar y solo se podría ejecutar acciones predefinidas como player.move() o player.jump() que son las que llevo implementada de momento, ¿Se os ocurre alguna más?  Tal vez la posibilidad de agacharse.

Bueno, espero opiniones de que les parece el proyecto y de si estarían dispuestos a participar.

La idea está inspirada en un concurso de Game Maker llamado GIA, aquí podéis ver un video de como fue aquella competición:

[There is a video that cannot be displayed in this feed. Visit the blog entry to see the video.]

Entradas relacionadas

• Muestra del Engine de PyIA
• Pathfinding A* en Python. Parte III
• Arboles e inteligencia Artificial
• Algoritmo Minimax, un jugador incansable
• Gestionando Escenas con Pygame

Ya sabía algo de C básico, pero ahora quiero pasar el desarrollo de videojuegos a C++ y me he puesto a aprender Orientación a Objetos en C++ y a usar la STL que es una gran biblioteca estándar de C++ que contiene muchas cosas que nos facilitan el trabajo. Bueno después del salto dejo el código.

#include <iostream>
#include <cstdlib>
#include <vector>
#include <unistd.h>

using namespace std;

class Mapa
{
public:
	int fil;
	int col;
	int vecinos;
	vector<vector<int> > mapa;

	Mapa(int f, int c);
	void dibujar();
	int analizarVecinos(int posf, int posc);
	void ciclo();
};

Mapa::Mapa(int f, int c)
{
	fil = f;
	col = c;
	mapa.resize(fil);
	for(int i=0; i<mapa.size(); i++)
	{
		mapa[i].resize(col);
	}

	for(int f=0; f<fil; f++)
	{
		for(int c=0; c<col; c++)
		{
			mapa[f][c] = rand()%2;
		}
	}
}

void Mapa::dibujar()
{
	for(int f=0; f<fil; f++)
	{
		for(int c=0; c<col; c++)
		{
			if(mapa[f][c] == 1)
				cout << "* ";
			else
				cout << ". ";
		}
		cout << "\n";
	}
}

int Mapa::analizarVecinos(int posf, int posc)
{
	vecinos = 0;
	if(posf-1 >= 0 and posc-1 >= 0)
		if(mapa[posf-1][posc-1] == 1)
			vecinos++;
	if(posf-1 >= 0)
		if(mapa[posf-1][posc] == 1)
			vecinos++;
	if(posf-1 >= 0 and posc+1 <= col-1)
		if(mapa[posf-1][posc+1] == 1)
			vecinos++;
	if(posc-1 >= 0)
		if(mapa[posf][posc-1] == 1)
			vecinos++;
	if(posc+1 <= col-1)
		if(mapa[posf][posc+1] == 1)
			vecinos++;
	if(posf+1 <= fil-1 and posc-1 >= 0)
		if(mapa[posf+1][posc-1] == 1)
			vecinos++;
	if(posf+1 <= fil-1)
		if(mapa[posf+1][posc] == 1)
			vecinos++;
	if(posf+1 <= fil-1 and posc+1 <= col-1)
		if(mapa[posf+1][posc+1] == 1)
			vecinos++;
	return vecinos;
}

void Mapa::ciclo()
{
	vector<vector<int> > nueva_conf = mapa;

	for (int f=0; f<fil; f++)
	{
		for(int c=0; c<col; c++)
		{
			int n_vecinos = analizarVecinos(f, c);
			if(mapa[f][c] == 0)
			{
				if(vecinos == 3)
					nueva_conf[f][c] = 1;
				else
					nueva_conf[f][c] = 0;
			}
			if (mapa[f][c] == 1)
			{
				if(vecinos == 2 || vecinos == 3)
					nueva_conf[f][c] = 1;
				else
					nueva_conf[f][c] = 0;
			}
		}
	}

	mapa = nueva_conf;
}

int main()
{
	srand(time(NULL));
	Mapa mapa(20, 20);
	while(1)
	{
		mapa.dibujar();
		usleep(100000);
		system("clear");
		mapa.ciclo();
	}
}

Entradas relacionadas

• Optimización basada en colonias de hormigas
• El juego de la vida en Python
• El juego de la vida
• Fmod – Audio en los videojuegos
• Arboles e inteligencia artificial II

[There is a video that cannot be displayed in this feed. Visit the blog entry to see the video.]

Entradas relacionadas

• Engine XI: Creando al héroe
• Engine VII: La clase Mapa I
• Haciendo un engine para juegos
• Engine X: La clase mapa III
• Engine IX: Cargando el tileset

[There is a video that cannot be displayed in this feed. Visit the blog entry to see the video.]

Pronto estará lista la wiki con toda la información de esta nueva etapa del proyecto.

Entradas relacionadas

• Avances del Engine RPG: Añadido el Scroll
• Engine XI: Creando al héroe
• Engine X: La clase mapa III
• Engine IX: Cargando el tileset
• Engine VII: La clase Mapa I

• http://github.com/adrigm/Engine-RPG

Para obtener el código y los cambios cuando se produzcan necesitan instalar git y saber usar lo básico para descargar el código y actualizarlo, este es un buen tutorial.

Si tenéis dudas podéis preguntarme en los comentarios.

Entradas relacionadas

• Avances del Engine RPG: Añadido el Scroll
• Video con los avances del nuevo engine
• Futuro del Engine y los tutoriales
• Destacamos del foro
• Razón Artificial Crece

Como es software en desarrollo muchas cosas hay que cambiarlas y adaptarlas y en concreto el engine está algo mal estructurado, porque en su día comencé sin planificar. Ahora lo estoy reescribiendo desde cero, pero esta vez lo estoy documentando todo y planificando para el futuro.

El problema no es el engine, son los tutoriales, ¿Como hago ahora para continuar por donde íbamos si los restructurado todo? Se me ocurren varias soluciones.

1. Desechamos los tutoriales hasta ahora y empiezo una serie nueva.
2. Montar una wiki dedicada al proyecto donde publicar todo lo que voy haciendo y demás. Esta idea me gusta, porque no es solo la parte de código, podría estrurar los tipos de formato y como usar las cosas.
3. No hago restructuración para los tutoriales y sigo una versión con lo que tenemos hasta tener algo jugable. La verdad es que no me motiva mucho sería doble trabajo y encima este jamás sería como el nuevo.

Opinad vosotros que debería hacer, y que preferís. También podéis aportar ideas, alguien ya me ha dicho de montar un servidor SVN para actualizar el proyecto y demás.

Actualización

Muchos en los comentarios creéis que lo mejor sería una wiki, y me planteáis que si no será complicado mantener tantos sistemas. Y puede que un poco así sea, ya que a parte de llevar la web y el foro tengo que escribir contenido para estoys y seguir con el engine.

Es por eso que pregunto si hay alguno de vosotros interesado en gestionar la wiki, encargarse de gestionarla y ponerla a punto y demás cosas necesarias. Porque si me encargo de la wiki también el proyecto va a avanzar más bien poco.

Ya la nueva estructura del engine está y demás información que tengo por aquí, lo que si me dedico a ponerla toda en una wiki pues no avanzo, espero que ya alguno interesado.

Entradas relacionadas

• Repositorio en github para el Engine-RPG
• Destacamos del foro
• Razón Artificial Crece
• ¿Una comunidad?
• Opiniones sobre división

Adaptando a subrutinas

Antes de seguir vamos a mirar al futuro, la idea es que el juego muestre al iniciar un menú donde puedas elegir nuevo juego, opciones, mejores puntuaciones y salir. Por lo que el bucle principal de nuestro juego debería ser este menú y luego según la opción llamar a una función u otra que se encargue de gestionar un sub-bucle propio.

Primero que nada vamos a crear la función que ejecuta el juego que sería la siguiente:

def nuevo_juego(screen):
	background_image = load_image('images/fondo.jpg');

	clock = pygame.time.Clock()

	while True:
		time = clock.tick(60)
		keys = pygame.key.get_pressed()
		salir(keys)

		mapa.dibujar(screen)
		screen.blit(background_image, (0, 0))
		pygame.display.flip()

y el bucle principal entonces nos queda así:

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")

	while True:
		nuevo_juego(screen)
	return 0

Como vemos la ventana (screen) se sigue creando en el bucle principal, pero se la pasamos como parámetro a nuestra sub-rutina nuevo_juego. Por ahora lo único que hacemos dento del bucle principal es llamar a la sub-rutina nuevo_juego y que esta tome el control, por lo que por ahora trabajaremos sobre esta.

Tenemos que crear el objeto mapa dentro de nuestra función nuevo_juego, para ello añadimos la siguiente línea:

mapa = Mapa("mapa.txt")

Dibujando el mapa

Como ya hemos dicho será la clase mapa la encargada de dibujar todo, por lo que será el mapa con los valores de sus casillas los que dibujarán una cosa u otra, así que vamos con el método dibujar de la clase mapa:

def dibujar(self, screen):
	for f in range(self.fil):
		for c in range(self.col):
			if self.mapa[f][c] == 1:
				screen.blit(self.bloque, (self.rect_bloque.w*c, self.rect_bloque.h*f))
			if self.mapa[f][c] == 2 or self.mapa[f][c] == 5:
				screen.blit(self.snake, (self.rect_snake.w*c, self.rect_snake.h*f))
			if self.mapa[f][c] == 3:
				screen.blit(self.comida, (self.rect_comida.w*c, self.rect_comida.h*f))

Muy simple, recorremos el mapa usando self.fil y self.col que definimos en el primer tutorial y comprobamos el valor de la casilla y guiandonos por nuestro esquema de valores que definimos dibujamos una cosa u otra.

Por ejemplo, el 1 representaba un muro por lo que si la casilla vale 1 dibujamos en pantalla un sprite bloque. Especial atencion a que lo dibujo usando su rect (self.rect_bloque.w*c, self.rect_bloque.h*f) es decir que la estoy pasando donde debe colocar la esquina superior izquierda del sprite, en este caso le digo que la coordenada x del punto está en self.rect_bloque.w*c, es decir, el ancho del sprite por la columna en la que se encuentra y la coordenada y en el punto self.rect_bloque.h*f, la altura del sprite por la fila en la que se encuentra por lo que un muro en la fila 2 columna 4 con un sprite de 16×16 píxeles dibujaría su esquina superior izquierda en la coordenada (16×4, 16×2) o lo que es lo mismo (64, 32).

lo único que nos queda es dibujar el mapa en nuestra bucle de la función nuevo_juego, recuerda hacerlo después de dibujar el fondo, sino no verás nada (el fondo siempre es lo primero que se dibuja):

screen.blit(background_image, (0, 0))
mapa.dibujar(screen)

y si ejecutamos veremos lo siguiente:

El juego nos queda así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

class Mapa(pygame.sprite.Sprite):
	def __init__(self, archivo):
		pygame.sprite.Sprite.__init__(self)

		self.bloque = load_image("images/bloque.png")
		self.rect_bloque = self.bloque.get_rect()

		self.snake = load_image("images/snake.png")
		self.rect_snake = self.snake.get_rect()

		self.comida = load_image("images/comida.png", True)
		self.rect_comida = self.comida.get_rect()

		self.mapa = leerMapa(archivo)
		self.fil = len(self.mapa)
		self.col = len(self.mapa[0])

	def dibujar(self, screen):
		for f in range(self.fil):
			for c in range(self.col):
				if self.mapa[f][c] == 1:
					screen.blit(self.bloque, (self.rect_bloque.w*c, self.rect_bloque.h*f))
				if self.mapa[f][c] == 2 or self.mapa[f][c] == 5:
					screen.blit(self.snake, (self.rect_snake.w*c, self.rect_snake.h*f))
				if self.mapa[f][c] == 3:
					screen.blit(self.comida, (self.rect_comida.w*c, self.rect_comida.h*f))

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

# Quita el ultimo caracter de una lista.
def quitarUltimo(lista):
	for i in range(len(lista)):
		lista[i] = lista[i][:-1]
	return lista

# Covierte una cadena en una lista.
def listarCadena(cadena):
	lista = []
	for i in range(len(cadena)):
		if cadena[i] == ".":
			lista.append(0)
		if cadena[i] == "#":
			lista.append(1)
		if cadena[i] == "*":
			lista.append(2)
	return lista

# Lee un archivo de texto y lo convierte en una lista.
def leerMapa(archivo):
	mapa = open(archivo, "r")
	mapa = mapa.readlines()
	mapa = quitarUltimo(mapa)
	for i in range(len(mapa)):
		mapa[i] = listarCadena(mapa[i])
	return mapa

# Carga una imagen a Pygame
def load_image(filename, transparent=False):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at((0,0))
                image.set_colorkey(color, RLEACCEL)
        return image

def salir(keys):
	for eventos in pygame.event.get():
		if eventos.type == QUIT:
			sys.exit(0)
		if keys[K_ESCAPE]:
			sys.exit(0)

def nuevo_juego(screen):
	background_image = load_image('images/fondo.jpg');

	clock = pygame.time.Clock()

	mapa = Mapa("mapa.txt")

	while True:
		time = clock.tick(60)
		keys = pygame.key.get_pressed()
		salir(keys)

		screen.blit(background_image, (0, 0))
		mapa.dibujar(screen)
		pygame.display.flip()

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Serpiente")

	while True:
		nuevo_juego(screen)
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Entradas relacionadas

• Engine II: El archivo principal
• Muestra del Engine de PyIA
• Avances del Engine RPG: Añadido el Scroll
• Juego de la serpiente paso a paso. Parte 1
• [Pygame] El juego de la serpiente

Antes de hacer este tutorial es totalmente recomendable hacer el tutorial del Pong ya que las cosas que explique en él no las voy a volver a explicar y las daré por sabidas.

Directorio Base

Lo primero de todo os dejo el directorio base para trabajar que contiene todo lo necesario para hacer nuestro juego: Imágenes, tipografías y plantilla base de Pygame que ya creamos en el tutorial del pong. También contiene un txt que será el mapa de nuestro juego.

• Descargar Tutorial Serpiente

La clase Mapa

Al ser un juego tan simple no voy a hacer una clase para cada Sprite, sino que será la clase Mapa la que gestione todos los sprites del juego. Solo habrá 3 sprites: Uno que representa a las paredes, otro para la serpiente y otro para la comida.

Así que lo primero que haremos será inicializar la clase mapa y cargar nuestros gráficos con la función load_image que tenemos ya ahí.

class Mapa(pygame.sprite.Sprite):
	def __init__(self, archivo):
		pygame.sprite.Sprite.__init__(self)

		self.bloque = load_image("images/bloque.png")
		self.rect_bloque = self.bloque.get_rect()

		self.snake = load_image("images/snake.png")
		self.rect_snake = self.snake.get_rect()

		self.comida = load_image("images/comida.png", True)
		self.rect_comida = self.comida.get_rect()

El archivo mapa.txt

El archivo mapa.txt será el que usemos para cargar nuestro mapa base, si abrimos el mapa.txt veremos esto:

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . * . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

Las almohadillas representan las paredes, los puntos por donde se puede pasar y el asterísco representa la cabeza de la serpiente (Ojo, los 3 caracteres a la izquierda de la cabeza de la serpiente deben ser puntos porque irá el resto del cuerpo de la serpiente).

Bien, necesitamos convertir este txt en una lista de Python y darle valores según el carácter, yo voy a usar la siguiente combinación para representar los elementos:

• Muros → 1
• Libres → 0
• Serpiente → 2
• Cabeza serpiente → 5
• Comida → 3

Bueno ya teniendo un código lo que hay que hacer es convertir el mapa, lo voy a hacer a través de 3 funciones:

# Quita el ultimo caracter de una lista.
def quitarUltimo(lista):
	for i in range(len(lista)):
		lista[i] = lista[i][:-1]
	return lista

# Covierte una cadena en una lista.
def listarCadena(cadena):
	lista = []
	for i in range(len(cadena)):
		if cadena[i] == ".":
			lista.append(0)
		if cadena[i] == "#":
			lista.append(1)
		if cadena[i] == "*":
			lista.append(2)
	return lista

# Lee un archivo de texto y lo convierte en una lista.
def leerMapa(archivo):
	mapa = open(archivo, "r")
	mapa = mapa.readlines()
	mapa = quitarUltimo(mapa)
	for i in range(len(mapa)):
		mapa[i] = listarCadena(mapa[i])
	return mapa

La que lee el mapa realmente es la última de todas, pero necesita las dos anteriores. Así que explico esta última y las 2 anteriores.

leerMapa recibe como parámetro un archivo de texto, la primera línea abre y lee el archivo, la segunda utiliza la el método readlines() que tienen los archivos abiertos y que lee las lineas de nuestro archivo. Con esto lo que tenemos es una lista que contiene unas cadenas de caracteres por cada línea de nuestro archivo (ojo que contiene al final el carácter de salto de línea también “\n”).

Para solucionar esto último la función quitarUltimo que se encarga de eliminar el último carácter de cada una de las cadenas de la lista. Nada complicado de ver como lo hace.

Bien ahora lo que necesitamos es convertir las cadanas de nuestra lista en listas con los valores que representan cada carácter, para ello recorremos la lista de cadenas y a cada una de ellas le aplicamos la función listarCadena que como vemos lo que hace es crear una lista vacía y recorrer la cadena pasada y si encuantra un punto (.) añade a la lista un 1, si encuentre una almuhadilla (#) un 2 y así con todo, finalmente retorna la nueva lista y en la función leerMapa sustituimos la cadena que había por la nueva lista. Finalmente leerMapa nos retorna el mapa perfectamente convertido a un array bidimensional.

Ahora lo que queda es cargarlo en nuestra clase mapa, añadimos después de la creación de Sprites lo siguiente:

self.mapa = leerMapa(archivo)
self.fil = len(self.mapa)
self.col = len(self.mapa[0])

Recuerda que archivo se lo pasamos como parámetro a nuestro método __init__, es decir cuando se crea la clase. Como vez almacenamos el mapa en self.mapa y creamos también self.fil y seld.col que contiene el tamaño de las filas y columnas del mapa, muy útil para recorrer el mapa.

Bueno con esto ya tenemos los Sprites creadosy el mapa cargado. El juego nos queda por ahora así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

class Mapa(pygame.sprite.Sprite):
	def __init__(self, archivo):
		pygame.sprite.Sprite.__init__(self)

		self.bloque = load_image("images/bloque.png")
		self.rect_bloque = self.bloque.get_rect()

		self.snake = load_image("images/snake.png")
		self.rect_snake = self.snake.get_rect()

		self.comida = load_image("images/comida.png", True)
		self.rect_comida = self.comida.get_rect()

		self.mapa = leerMapa(archivo)
		self.fil = len(self.mapa)
		self.col = len(self.mapa[0])

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

# Quita el ultimo caracter de una lista.
def quitarUltimo(lista):
	for i in range(len(lista)):
		lista[i] = lista[i][:-1]
	return lista

# Covierte una cadena en una lista.
def listarCadena(cadena):
	lista = []
	for i in range(len(cadena)):
		if cadena[i] == ".":
			lista.append(0)
		if cadena[i] == "#":
			lista.append(1)
		if cadena[i] == "*":
			lista.append(2)
	return lista

# Lee un archivo de texto y lo convierte en una lista.
def leerMapa(archivo):
	mapa = open(archivo, "r")
	mapa = mapa.readlines()
	mapa = quitarUltimo(mapa)
	for i in range(len(mapa)):
		mapa[i] = listarCadena(mapa[i])
	return mapa

# Carga una imagen a Pygame
def load_image(filename, transparent=False):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at((0,0))
                image.set_colorkey(color, RLEACCEL)
        return image

def salir(keys):
	for eventos in pygame.event.get():
		if eventos.type == QUIT:
			sys.exit(0)
		if keys[K_ESCAPE]:
			sys.exit(0)

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")
	background_image = load_image('images/fondo.jpg');

	clock = pygame.time.Clock()

	while True:
		time = clock.tick(60)
		keys = pygame.key.get_pressed()
		salir(keys)

		screen.blit(background_image, (0, 0))
		pygame.display.flip()
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Entradas relacionadas

• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Muestra del Engine de PyIA
• Avances del Engine RPG: Añadido el Scroll
• [Pygame] El juego de la serpiente

Los gráficos la verdad es que no son ninguna belleza, parece que los programadores no servimos para el arte gráfico. Quizás se podría completar con un sistema que registre las mejores puntuaciones y el aumento de velocidad según consigas puntos, todo es cuestión de implementarlo, quizás para el tutorial le añada un sistema de puntuaciones para trabajar con archivos.

• Descargar Serpiente

Entradas relacionadas

• Muestra del Engine de PyIA
• Avances del Engine RPG: Añadido el Scroll
• Juego de la serpiente paso a paso. Parte 2
• Engine XI: Creando al héroe
• Engine VII: La clase Mapa I

Los gráficos traen los efectos de sombra y demás, pero estan preparados para que cada uno lo adapte a su sistema. Dejo el pack para descargar.

• Descargar 2D Circle Graphic

Licencia de uso: http://www.lostgarden.com/2007/03/lost-garden-license.html

Entradas relacionadas

• Gráficos para prototipos de juegos

Con la inauguración destacamos:

• Técnicas e ideales de desarrollo de videojuegos
• El diseñador de juegos y el riesgo de las ideas
• Proyectos Hipermedia
• Tips de programación de videojuegos

Entradas relacionadas

• Repositorio en github para el Engine-RPG
• Futuro del Engine y los tutoriales
• Razón Artificial Crece
• ¿Una comunidad?
• Opiniones sobre división

Las novedades son las siguientes:

• Razón Artificial amplia su temática al desarrollo de videojuegos, la intención es cubrir todas las áreas del desarrollo y no solo la parte de programación como veníamos haciendo hasta ahora, trabajaremos con Diseño, gráficos, audio y por supuesto seguiremos con la programación.
• Abrimos un foro de debate. podéis acceder a través de http://razonartificial.com/foro/ en el se encontrará mucha mas información adicional al blog y los usuarios podrán participar y publicar sus propios temas,  tutoriales, proyectos, dudas y demás, para entre todos tener un lugar de desarrollo de videojuegos.
• Cambiamos el diseño acorde a la nueva filosofía de la web. Sigue siendo un tema limpio y claro.
• Intentaré publicar más a menudo y lo más destacado del foro podrá verse en la portada del blog.

Bueno espero que los que han seguido el blog me apoyen en esta nueva etapa de la web y que participen en lo posible, cada uno con lo que pueda aportar. Yo seguiré escribiendo tutoriales y artículos que considere útiles.

Entradas relacionadas

• Repositorio en github para el Engine-RPG
• Futuro del Engine y los tutoriales
• Destacamos del foro
• ¿Una comunidad?
• Opiniones sobre división

El motivo de este post viene para otra consulta, este blog a crecido muy rápido, apenas tiene unos 6 meses de vida y aunque no hay muchos post pienso que lo que hay no son noticias banales sino cosas prácticas y útiles. Hoy me plante ampliar razón artificial a una comunidad. Los comento, la idea es mantener el blog y seguir publicando tutoriales y posiblemente ampliarlo hacia el desarrollo de videojuegos con nuevos temas. Pero también he pensado en abrir un foro de debate en el que vosotros podáis mostrar vuestros proyectos, dudas, códigos y demás cosas relacionadas, podáis también publicar tutoriales y demás que puedan mostrarse en el blog.

Bueno espero vuestros comentarios sobre la idea, ¿Os gustaría que Razón Artificial fuera una comunidad y no solo un blog?

Entradas relacionadas

• Repositorio en github para el Engine-RPG
• Futuro del Engine y los tutoriales
• Destacamos del foro
• Razón Artificial Crece
• Opiniones sobre división

Ya tenemos listo nuestro mapa, preparado para ser puesto en pantalla, pero en un juego RPG la cámara sigue al héroe, es decir, se ve el trozo de mapa alrededor del héroe, por eso necesitamos antes de representar el mapa a nuestro héroe para poder representar la parte que necesitamos del mapa.

Cortando un chareset

Un charaset es una imagen que contiene todas las posiciones de un personaje, que superpuestas crean una animación, como vale más una imagen que mil palabras dejo un ejemplo.

Como vemos, este simula el movimiento de caminar en 4 direcciones, se podría hacer uno de 8 direcciones, pero el nuestro caminará tan solo en cuatro.

Vale lo que tenemos que hacer es parecido a cuando cortamos el tileset, cortat cada uno de los frames de nuestro charaset y almacenarlos en una array, esta vez será bidimensional, así que con solo ir cambiando los índices del array podemos mostrar un frame u otro.

Creamos una funcion en nuestro archivo funciones.py debajo de la función de cortar tilesets.

# Corta un chara en las fil y col indicadas. Array Bidimensional.
def cortar_chara(ruta, fil, col):
	image = load_image(ruta, True)
	rect = image.get_rect()
	w = rect.w / col
	h = rect.h / fil
	sprite = range(fil)
	for i in range(fil):
		sprite[i] = range(col)

	for f in range(fil):
		for c in range(col):
			sprite[f][c] = image.subsurface((rect.left, rect.top, w, h))
			rect.left += w
		rect.top += h
		rect.left = 0

	return sprite

Como vemos muy parecida a la de cortar tilesets, pero esta vez a parte de almacenarlo en un array bidimensional, también le decimos cuantas filas y columnas tiene nuestro charaset. Esto lo hacemos así para que sea mas universal y podamos almacenar todo tipo de charas de cualquier tamaño, solo debemos especificas cuantas filas y columnas y el se encargará de cortarlo.

La clase Actors

Vamos a crear el fichero que se encargará de gestionar a nuestro héroe, ya sabes hacemos una copia del archivo plantilla.py y creamos el archivo actors.py. y creamos la clase Actors.

class Actor:
	def __init__(self, pos):
		self.pos = pos
		self.chara = cortar_chara("graphics/charasets/chara.png", 4, 4)

		self.image = self.chara[0][0]
		self.rect = self.image.get_rect()

	def dibujar(self, screen):
		screen.blit(self.image, self.rect)

De momento para el método de inicialización recibe la posición del charaset. en un futuro debería recibir otra como la imagen y demás, pero ya habrá tiempo de generalizar el código cuando este la base.

Almacenamos la posición inicial en self.pos y creamos un array bidimensional llamado self.chara con la función que acabamos de crear. En nuestro caso tiene 4 filas y 4 columnas.

Luego definimos que frame está activo en self.image en este caso y a modo de prueba cogemos el [0, 0] es decir el de la primera fila y la primera columna de nuestro chara. A continuación obtenemos el rect de esa imagen.

Por último hacemos a modo de esbozo el método dibujar que será el encargado de gestionar el dibujado de nuestro chara. Por ahora es muy simple y solo muestra en pantalla el chara. Atención a que recibe como parámetro la variable screen, esto es nuestra pantalla, porque debe saber donde tiene que dibujarlo.

Dibujando en pantalla

Hasta ahora código, teoría y mas código, alguna salida en consola, pero nuestra ventana sigue en negro. Bueno para los desesperados vamos a mostrar nuestro chara en pantalla para ver que realmente funciona lo que estamos haciendo.

nos vamos a nuestro engine.py, el archivo principal y le añadimos lo siguiente.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

from maps import *
from actors import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

def salir():
	keys = pygame.key.get_pressed()
	for eventos in pygame.event.get():
		if eventos.type == QUIT:
			sys.exit(0)
		if keys[K_ESCAPE]:
			sys.exit(0)

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Engine RPG")

	clock = pygame.time.Clock()

	mapa = Mapa("bosque.tmx")
	heroe = Actor(mapa.start)

	while True:
		time = clock.tick(60)
		salir()

		heroe.dibujar(screen)
		pygame.display.flip()
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Primero importamos nuestro módulo actors después del módulo maps. Creamos un objeto Actor llamado heroe debajo del objeto Mapa. Atención a que tiene que ser despues y no antes porque recibe como parámentro mapa.start como la posición inicial y esta esta dentro de la clase Mapa. por último tenemos que llamar a su método dibujar dentro del bucle principal con heroe.dibujar(screen).

Debería mostrarse el primer frame de nuestro chara en la parte superior izquierda de la pantalla.

Entradas relacionadas

• Avances del Engine RPG: Añadido el Scroll
• Engine VII: La clase Mapa I
• Haciendo un engine para juegos
• Engine X: La clase mapa III
• Engine IX: Cargando el tileset

Ya tenemos una array bidimensional llamada self.capas que contiene unos números que se corresponde con los tiles que ocupa y tenemos un array unidimensional llamado self.tileset que contiene los sptites de nuestro tilesets (los tiles). Pues el siguiente paso será crear un array bidimensional igual a self.capas, pero sustituyendo los valores por nuestros sprites que tenemos en self.tileset.

Esto lo haremos creando la variable de clase self.mapa y lo hacemos con el siguiente método de la clase mapa:

def crear_mapa(self):
	self.mapa = self.capas
	for i in range(len(self.capas)):
		for f in range(self.height):
			for c in range(self.width):
				if self.capas[i][f][c]:
					self.mapa[i][f][c] = self.tileset[self.capas[i][f][c]]
				else:
					self.mapa[i][f][c] = None

Lo primero que hace el metodo es una copia exacta de self.capas en self.mapa, así ya tenemos nuestra array col los valores que hay que sustituir. A continuación empezamos a recorres nuestra array tridimensional, para hacerlo para casa capa, con la variable i recorremos las capas y con las variables f y c las filas y las columnas (observad que sacamos los valores de los datos que extraemos del mapa. y a continuación tenemos un if. Si el valor de esa celda es distinto de none hace lo siguiente.

self.mapa[i][f][c] = self.tileset[self.capas[i][f][c]]

osea sustituye el valor de la variable self.mapa de la casilla que este mirando por self.tileset[indice] donde indice es el valor de self.capa en se lugar, por tanto si en nuestro mapa, teniamos que hay iba el tile número 5 le estamos diciendo que en self.mapa[i][f][ c ] ponga el sprite self.tileset[5].

Si no se entiende decidmelo y lo explico mejor en los comentarios. Por ultimo si no hay nada en ese cuadro añadimos el valor None.

Con esto ya tenemos nuestro mapa creado y estaríamos listos para mostrarlo en pantalla, pero ahora hay que crear la camára, no se puede mostrar el mapa entero pues no cabe en pantalla, ya veremos como hacerlo.

Entradas relacionadas

• Avances del Engine RPG: Añadido el Scroll
• Engine XI: Creando al héroe
• Engine IX: Cargando el tileset
• Engine VII: La clase Mapa I
• Engine I: Preparándonos para trabajar

Antes de empezar con este tema he ordenado un poco el código para que esté todo bien estructurado desde el principio que sino luego es liante saber donde está cada cosa, hay rutinas y funciones que usaremos a menudo, como las que usaremos para cargar imágenes sonidos, etc. Por eso he pensado que sería mejor tener todas estas funciones de uso genérico en un fichero llamado funciones.py y ordenarlas por temas y según en que módulo de nuestro engine nos haga falta una u otra cargarla desde ahí.

Por tanto nuestro maps.py nos queda así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import pygame
from pygame.locals import *
from xml.dom import minidom, Node

from funciones import *
from engine import WIDTH, HEIGHT

# Clases
# ---------------------------------------------------------------------

class Mapa:
	def __init__(self, nombre):
		self.nombre = nombre
		self.capas = []

		self.cargar_mapa() # Inicializa los valores desde el xml.

	# Extrae valores mapa desde XML.
	def cargar_mapa(self):
		xmlMap = minidom.parse("maps/"+self.nombre)
		nPrincipal = xmlMap.childNodes[0]

		# Tamaño mapa
		self.width = int(nPrincipal.attributes.get("width").value)
		self.height = int(nPrincipal.attributes.get("height").value)

		for i in range(len(nPrincipal.childNodes)):
			if nPrincipal.childNodes[i].nodeType == 1:
				if nPrincipal.childNodes[i].nodeName == "tileset":
					if nPrincipal.childNodes[i].attributes.get("name").value != "config":
						width = nPrincipal.childNodes[i].attributes.get("tilewidth").value
						height = nPrincipal.childNodes[i].attributes.get("tileheight").value
						nombre = nPrincipal.childNodes[i].childNodes[1].attributes.get("source").value
						nombre = extraer_nombre(nombre)
						self.tileset = nombre
					self.tam_tiles = (int(width), int(height))
				if nPrincipal.childNodes[i].nodeName == "layer":
					if  nPrincipal.childNodes[i].attributes.get("name").value != "colisiones":
						layer = nPrincipal.childNodes[i].childNodes[1].childNodes[0].data.replace("\n", "").replace(" ", "")
						layer = decodificar(layer) # Decodifica la lista
						layer = convertir(layer, self.width) # Convierta en array bidimensional
						self.capas.append(layer)
				if nPrincipal.childNodes[i].nodeName == "objectgroup":
					x = nPrincipal.childNodes[i].childNodes[1].attributes.get("x").value
					y = nPrincipal.childNodes[i].childNodes[1].attributes.get("y").value
					self.start = (int(x), int(y))

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

# Convierta una array unidimensional en una bidimensional.
def convertir(lista, col):
	nueva = []
	for i in range(0, len(lista), col):
		nueva.append(lista[i:i+col])
	return nueva

# Extra el nombre de un archivo de una ruta.
def extraer_nombre(ruta):
	a = -1
	for i in range(len(ruta)):
		if ruta[i] == "/" or ruta[i] == "\\":
			a = i
	if a == -1:
		return ruta
	return ruta[a+1:]

# ---------------------------------------------------------------------

def main():
	return 0

if __name__ == '__main__':
	main()

y tenemos un archivo funciones.py de la siguiente manera:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import base64
import gzip
import StringIO
import pygame
from pygame.locals import *

# Mapas
# ---------------------------------------------------------------------

def decodificar(cadena):
	# Decodificar.
	cadena = base64.decodestring(cadena)

	# Descomprimir.
	copmressed_stream = StringIO.StringIO(cadena)
	gzipper = gzip.GzipFile(fileobj=copmressed_stream)
	cadena = gzipper.read()

	# Convertir.
	salida = []
	for idx in xrange(0, len(cadena), 4):
		val = ord(str(cadena[idx])) | (ord(str(cadena[idx + 1])) << 8) | \
		(ord(str(cadena[idx + 2])) << 16) | (ord(str(cadena[idx + 3])) << 24)
		salida.append(val)

	return salida

# ---------------------------------------------------------------------

# Pygame
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

Cortando el tileset

Bien ahora necesitamos coger nuestra imagen de tileset, cortar los tiles que la componen y almacenarlos en un array unidimensional y ese índice coincidirá con el que almacena nuestro archivo mapa.

Primero que nada necesitamos una función para la carga de imágenes en Pygame, ya escribimos una bastante buena en el tutorial de Pygame y esa es la que utilizaremos.

# Carga una imagen transparencia y color tranasparente opcionales.
def load_image(filename, transparent=False, pixel=(0,0)):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at(pixel)
                image.set_colorkey(color, RLEACCEL)
        return image

Esta funciión va en nuestro archivo funciones.py pues desde todos lados de nuestro engine vamos a necesitar cargar imágenes, atención al archivo funciones.py que dejé arriba que importa pygame, necesario para esta función y otras.

Bien ya que tenemos la forma de cargar imágenes con python y pygame estamos listos para cortar nuestro tileset. Añadimos una nueva función al funciones.py

# Corta un tilest y lo almacena en un array unidimensional.
def cortar_tileset(ruta, (w, h)):
	image = load_image(ruta, True)
	rect = image.get_rect()
	col = rect.w / w
	fil = rect.h / h
	sprite = [None]

	for f in range(fil):
		for c in range(col):
			sprite.append(image.subsurface((rect.left, rect.top, w, h)))
			rect.left += w
		rect.top += h
		rect.left = 0

	return sprite

Bien analicemos. Recibe 2 parámetros, la ruta del tileset y una tupla (w, h) que es el ancho y el alto de nuestros tiles, recuerda que el tileset que estoy usando de ejemplo usamos tiles de 40×40, pero que lo común es encontrar en internet tilesets con tiles de 32×32. De todas maneras nuestro engine se adapta a cualquier tamaño.

A continuación Carga la imagen con nuestra función anterior estableciendo que tiene color transparente y como no definimos de que pixel lo toma pues lo tomará del pixel (0, 0) Por eso es muy importante que nuestros tilesets para este engine el primer tile sea del color que vamos a usar como transparente (un buen color es el (255, 0, 255) que es un rosa intenso muy poco común en las paletas).

La siguiente línea obtiene el rect de la imagen para poder manipularla. A continuación creamos dos variables fil y col que las obtenemos de dividir el ancho y alto del tileset por el ancho y el alto de los tiles, por ejemplo, nuestro tileset tiene de ancho 320px (lo obtenemos con rect.w) y lo dividimos entre w (recuerda que lo recibe como parámetro y en nuestro caso vale 40) 320/40 nos da 8 que es el numero de columnas que hay en nuestro tileset. Lo mismo para el alto y sacar las filas.

A continuación creamos la array sptrite que contendrá nuestro tileset, una lista unidimensional. Observa que tiene un valor nuestra lista none, ¿Por qué esto? Pues veras nuestro mapa guarda las posiciones de los tiles a partir del 1 y el 0 lo toma como que no hay ningún tile en ese cuadro del mapa, es por esto que para que coincidan los índices el valor 0 de nuestro tileset contendrá none, es decir, nada.

luego recorremos las filas y columnas de nuestro tileset y vamos añadiendo al final de nuestra array sprite una subsurfase, ¿Qué es esto? Pues una imagen que se obtiene a partir de otra, es decir, recortamos de una mas grande un trozo de ella y la guardamos. Mirad el bucle y lo entenderéis, es bueno que vayas sustituyendo las variables por los valores de ejmplo para ver cuanto vale cada cosa en cada momento y ver como funciona.

Con esto ya tenemos un array unidimensional que tiene las imágenes de nuestros tiles. Hacemos que la función retorne esta lista.

Ahora hay que usarla en nuestro archivo maps.py Añadimis la siguiente línea en el método init de la clase mapa, justo después de cargar el mapa

self.tileset = cortar_tileset("graphics/tilesets/"+self.tileset, self.tam_tiles)

Como ves le pasamos valores que extraímos de nuestro mapa, el nombre del tileset (Ahora vemos lo que explique de que solo necesitábamos el nombre del mapa porque la ruta ya se la dábamos nosotros) y le pasamos la tupla self.tam_tiles que en nuestro caso vale (40, 40).

Ya no podemos probar la clase mapa dentro del módulo mapa, sino que debemos de hacerlo en el archivo principal, engine.py esto es porque al estar ya tratando con pygame y conversiones de imagen, Pygame necesita saber cosas como la resolución o la profundidad de color del ordenador para convertir las imágenes.

Basta con importar el archivo maps.py en engine.py

from maps import *

y añadir debajo de la carga del reloj, antes del empezar el bucle del juego:

clock = pygame.time.Clock()

mapa = Mapa("bosque.tmx")
print mapa.tileset

Con esto cargamos el mapa, en este caso el mío se llama bosque.tmx y con print mapa.tileset podemos ver una lista de sprites que guarda nuestro tileset, atendemos como el primer valor es None y el resto ya es los tiles de nuestro tileset.

Puede que este tutorial haya sido algo lioso por numerosos cambios que hemos hecho, así que dejo para descargar el proyecto como lo llevo hasta ahora, incluyo todo menos el tiled que cada uno debe usar su versión y añadirla a la carpeta.

• Descargar Proyecto

Entradas relacionadas

• Avances del Engine RPG: Añadido el Scroll
• Engine XI: Creando al héroe
• Engine X: La clase mapa III
• Engine VII: La clase Mapa I
• Engine I: Preparándonos para trabajar

Por ahora hemos conseguido tener una forma de hacer mapas y extraer su información del archivo XML para poder manejarla con Python, en el anterior tutorial quizás no quedo claro como almecenamos los tiles del mapa y en este tutorial quiero dejar claro como lo hacemos pues es clave para entender la representación del mapa.

A través del método cargar_mapa hemos extraído muchos valores de nuestro XML, que podemos visualizar con unos cuantos prints, pero el más importante de  ellos es el valor de self.capas que es un array tridimensional, es una lista que en su interior contiene todas las listas de las capas de nuestro mapa por orden, es decir, primero la de más abajo, luego la siguiente y así hasta la superior. Esta variable no contiene las listas de objetos, ojo, solo las de tilesets. Si imprimimos el tamaño de nuestra lista veremos que el valor devuelto es 3 porque nuestro mapa esta compuesto de 3 capas.

def main():
	mapa = Mapa("bosque.tmx")
	print len(mapa.capas)
	return 0

cada una de estas 3 listas esta a su ve compuesta en un array bidimensional de filas y columnas, que representan a todo nuestro mapa y a los tileset que hay en esa posición, veamos.

def main():
	mapa = Mapa("bosque.tmx")
	print mapa.capas[0]
	return 0

como ves si imprimimos el primer valor de la lista nos muestra un array bidimensional que contiene unos valores enteros, si miráis vuestro tileset veréis que ese valor se corresponde corresponde con el cuadro de tile de nuestro tileset. por ejemplo, si estás usando el tileset que he subido y tengo toda mi capa inferior cubierta de hierba veremos que nuestra lista arroja una gran capa de 9 y si miramos nuestro tileset veremos que el tile hierba ocupa la posición 9.

Observemos que el tileset se almacena en un array unidimensional, una lista de tiles que es nuestra paleta. En el siguiente tutorial crearemos esa paleta a partir de nuestro tileset.

Entradas relacionadas

• Avances del Engine RPG: Añadido el Scroll
• Engine XI: Creando al héroe
• Engine VII: La clase Mapa I
• Haciendo un engine para juegos
• Video con los avances del nuevo engine

Como este segundo tema también me gusta, había pensado en separarlo de este blog y hacer uno dedicado a la creación y desarrollo de videojuegos y dejar este para lo que era en un principio, la IA, la robótica y demás temas. ¿Qué opinan ustedes? Mejor la división, mejor todo aquí. Se que tengo gente que me lee, pero nunca comenta este es el momento que pido que opinen, muchas gracias.

Entradas relacionadas

• Repositorio en github para el Engine-RPG
• Futuro del Engine y los tutoriales
• Destacamos del foro
• Razón Artificial Crece
• ¿Una comunidad?

Bien ya tenemos generado nuestro mapa de pruebas, ahora necesitamos cargarlo en Python, los próximos artículos van dedicados a interpretar los datos en Python y la manera de almacenar el mapa.

Para empezar vamos a hacer una copia de nuestra plantilla con el nombre de maps.py que es el archivo que va a contener todo lo relacionado con la carga y creación de los mapas de nuestro engine.

A modo de repaso en mi carpeta engine ahora mismo tengo dos carpetas una llamada graphics que contiene una carpeta tilesets que contiene nuestro tileset de ejemplo, y otra maps que contiene un mapa de prueba. Luego tengo el ejecutable del programa tiled y luego 3 scripts de Python plantilla.py, engine.py y maps.py. Eso es lo que deberían de tener todos si hemos seguido los artículos.

Cargando un mapa

Antes de ponernos a escribir código nos preguntamos, ¿Como representamos un mapa? La técnica ya la explique en el capítulo 3, lo que vamos es crear una clase Mapa que contenga toda la información de este en simple variables, el ancho, el alto, el tamaño de los tiles y lo más importante, una array bidimensional que contenga que tile del tileset va en cada lugar.

Te preguntarás, que como hacemos esto si el tileset que tenemos es una simple imagen png, bien tranquilo, lo que haremos será desde Python coger esa imagen y partirla en “cachitos” (los tiles) y almacenarla en una array, cada tile del array tendrá un índice que, oh sorpresa, se corresponderá con los valores de nuestro array bidimensional del mapa. Todo esto puede parecer lioso, pero ya veremos que no lo es.

Bueno pues aclaradas un par de cosas vamos a empezar a escribir nuestra clase mapas, en un principio solo tendrá un par de métodos de inicialización y carga, pero esta clase crecerá a medida que avanza el engine.

Una última cosa, vamos a trabajar con ficheros XML en Python, es un temga largo y tendido que no cabe dentro de estos artículo, pero os dejo este tutorial donde explica muy bien como tratar estos archivos con Python y extraer la información, de todas maneras yo pondré aquí como extraer la información de nuestro mapa para nuestro engine.

La clase Mapa

Lo primero que necesitamos es inicializar la clase y crear un método que lea nuestro fichero XML y extraiga los datos. Todo esto es muy difícil verlo fuera de conjunto así que voy a poner como va el fichero maps.py entero por ahora y lo comentamos paso a paso.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
from xml.dom import minidom, Node
import base64
import gzip
import StringIO

# Clases
# ---------------------------------------------------------------------

class Mapa:
	def __init__(self, nombre):
		self.nombre = nombre
		self.capas = []

		self.cargar_mapa() # Inicializa los valores desde el xml.

	# Extrae valores mapa desde XML.
	def cargar_mapa(self):
		xmlMap = minidom.parse("maps/"+self.nombre)
		nPrincipal = xmlMap.childNodes[0]

		# Tamaño mapa
		self.width = int(nPrincipal.attributes.get("width").value)
		self.height = int(nPrincipal.attributes.get("height").value)

		for i in range(len(nPrincipal.childNodes)):
			if nPrincipal.childNodes[i].nodeType == 1:
				if nPrincipal.childNodes[i].nodeName == "tileset":
					if nPrincipal.childNodes[i].attributes.get("name").value != "config":
						width = nPrincipal.childNodes[i].attributes.get("tilewidth").value
						height = nPrincipal.childNodes[i].attributes.get("tileheight").value
						nombre = nPrincipal.childNodes[i].childNodes[1].attributes.get("source").value
						nombre = extraer_nombre(nombre)
						self.tileset = nombre
					self.tam_tiles = (int(width), int(height))
				if nPrincipal.childNodes[i].nodeName == "layer":
					if  nPrincipal.childNodes[i].attributes.get("name").value != "colisiones":
						layer = nPrincipal.childNodes[i].childNodes[1].childNodes[0].data.replace("\n", "").replace(" ", "")
						layer = decodificar(layer) # Decodifica la lista
						layer = convertir(layer, self.width) # Convierta en array bidimensional
						self.capas.append(layer)
				if nPrincipal.childNodes[i].nodeName == "objectgroup":
					x = nPrincipal.childNodes[i].childNodes[1].attributes.get("x").value
					y = nPrincipal.childNodes[i].childNodes[1].attributes.get("y").value
					self.start = (int(x), int(y))

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

# Convierta una array unidimensional en una bidimensional.
def convertir(lista, col):
	nueva = []
	for i in range(0, len(lista), col):
		nueva.append(lista[i:i+col])
	return nueva

# Decodifica y descomprime un mapa.
def decodificar(cadena):
	# Decodificar.
	cadena = base64.decodestring(cadena)

	# Descomprimir.
	copmressed_stream = StringIO.StringIO(cadena)
	gzipper = gzip.GzipFile(fileobj=copmressed_stream)
	cadena = gzipper.read()

	# Convertir.
	salida = []
	for idx in xrange(0, len(cadena), 4):
		val = ord(str(cadena[idx])) | (ord(str(cadena[idx + 1])) << 8) | \
		(ord(str(cadena[idx + 2])) << 16) | (ord(str(cadena[idx + 3])) << 24)
		salida.append(val)

	return salida

# Extra el nombre de un archivo de una ruta.
def extraer_nombre(ruta):
	a = -1
	for i in range(len(ruta)):
		if ruta[i] == "/" or ruta[i] == "\\":
			a = i
	if a == -1:
		return ruta
	return ruta[a+1:]

# ---------------------------------------------------------------------

def main():
	mapa = Mapa("bosque.tmx")
	print mapa.tileset
	return 0

if __name__ == '__main__':
	main()

En primer lugar importamos todos los módulos que vamos a necesitar: trabajar con XML, descodificar y descomprimir con base64 y gzip y StringIO que nos hace falta también para la descompresión.

Luego creamos la clase Mapa que como vemos de momento tiene dos métodos, el método __init__ que la inicializa, toma como parámetros self (como todas las clases) y nombre, que es el nombre del mapa que queremos cargar. Ojo, que solo le debemos pasar una cadena con el nombre y la extensión tipo “mi_mapa.tmx” ya que más abajo he supuesto que lo busque siempre dentro de la carpeta maps que es donde estarán nuestros mapas.

Luego crea la variables nombre y capas. Esta segunda sera un array que contendrá a su vez varios arrays bidimensionales que representan a cada capa. Más abajo explico como mostrarla y se entenderá mejor.

Por último hacemos una llamada al método cargar_mapa() que hemos definido debajo y que es el que se encarga de extraer los datos del mapa. Vamos con ella.

Recuerda leer el artículo que puse más arriba acerca de como trabajar con XML y mirando el código del método más o menos lo entenderás, cargamos el mapa y extraemos el nodo principal, luego vamos recorriendo los nodos hijos y comprobando que tipo de nodos es (repito, leer el tutorial de XML) y extrayendo la información del árbol XML de nuestro archivo.

Especial atención a la línea 36 donde hace uso de una función que hemos definido más abajo para extraer el nombre del tileset de la ruta completa que se guarda en el archivo. ¿Por qué esto? Pues porque el archivo guarda la ruta absoluta y a nosotros solo nos interesa el nombre del tileset que está usando porque ya nuestro engine sabe en que carpeta buscar los tileset.

Bien llega la línea 41 que es la que obtiene la larga secuencia codificada que teníamos en nuestro archivo, como vemos simplemente cogemos la cadena, le quitamos los saltos de línea y los espacios y la almacenamos en una variable de la clase, luego esa variable la decodificamos y descomprimimos con la función que está más abajo. Explicar esa función sería extendernos demasiado porque es algo complicada, de todas maneras si alguien tiene dudas o interés dejad un comentario y escribiré un artículo sobre ella.

Después de decodificarla y descomprimirla la tenemos almacenada en una array unidimensional, para nuestro mapa mejor la pasamos a una bidimensional con el tamaño del mapa, más abajo está la función que hace esto, nada complicado.

por último, una parte que se tiene que desarrollar, la que obtiene los datos de la capa evento solo esta puesto ahí para sacar el evento que definimos que es el de la posición inicias, esto (y parte de lo de arriba) se ampliará cuando avance el engine.

Por último en la función main() (Para esto es para que la definimos en un módulo) podemos probar creando un objeto mapa con nuestro mapa de ejemplo y podemos probar a imprimir en pantalla los distintos valores que hemos sacado.

Probad a ir paso a paso por el método cargar_mapa y viendo todos los valores que hemos sacado (todos los que son self.algo, son valores del mapa). En el código de arriba he puesto como ejemplo que imprima el nombre del tileset.

Bien con esto ya tenemos algunos datos de nuestro mapa cargados en Python, ahora hay que empezar a trabajar con el tileset y pasar estos datos a Pygame.

Entradas relacionadas

• Avances del Engine RPG: Añadido el Scroll
• Engine XI: Creando al héroe
• Haciendo un engine para juegos
• Engine X: La clase mapa III
• Engine IX: Cargando el tileset

En este artículo vamos a analizar el archivo que nos ha generado el Tiled Map Editor, un fichero con extensión .tmx que hemos guardado en la carpeta maps. Es un archivo XML, para el que no sepa lo que es, es un lenguaje de marcas que guarda información mediante etiquetas (a grandes rasgos, podéis buscar más en la red). Pues bien al ser simple texto plano lo podemos abrir con cualquier editor de textos (El geany que utilizo yo me resalta las etiquetas). Vamos a analizarlo:

<?xml version="1.0" encoding="UTF-8"?>
<map version="1.0" orientation="orthogonal" width="35" height="25" tilewidth="40" tileheight="40">
 <tileset firstgid="1" name="tile_bosque" tilewidth="40" tileheight="40">
  <image source="../graphics/tilesets/tile_bosque.png" trans="#ff00ff"/>
 </tileset>
 <layer name="Base" width="35" height="25">
  <data encoding="base64" compression="gzip">
   H4sIAAAAAAAAA+2Tuw6AIAxFWRl9DaiL+v//KAtJc5NaEismeoczQdtTwo0hh...
  </data>
 </layer>
 <layer name="Montañas" width="35" height="25">
  <data encoding="base64" compression="gzip">
   H4sIAAAAAAAAA+2W2UpDQQyG+...
  </data>
 </layer>
 <layer name="New Layer" width="35" height="25">
  <data encoding="base64" compression="gzip">
   H4sIAAAAAAAAA2NgGHrAH4gDSFC/EYg3AfFmKN+DinaHA3EEEfqQ7dwFxLup4AZ0u...
  </data>
 </layer>
 <objectgroup name="Eventos" width="35" height="25">
  <object name="heroe" x="625" y="544"/>
 </objectgroup>
</map>

La primera línea está en todos los documentos XML e indica que tipo de documentos es y la codificación. Luego comienza el árbol de nuestro mapa, la primera etiqueta “map” contiene la orienteción, los tiles de ancho y largo de nuestro mapa y el tamaño de los tileset. Todos los que definimos cuando creamos el mapa.

A continuación viene la información de los tilesets. Nos indica el número de tileset que es “firstgid” (un mapa puede tener varios tilesets a la vez. Luego el tamaño de los tiles del tilesets y dentro contiene una etiqueta con la dirección de la imagen del tileset y el color transparente (si hemos definido uno).

Luego carga las diferentes capas nos da el nombre, el ancho, dentro contiene una etiqueta data muy extraña. Esta etiqueta data tiene dos atributos encoding=”base64″ y compression=”gzip” esto quiere decir que la cadena que contiene esta codificada en base64 y comprimida con gzip ¿Por qué esto? Pues porque contiene la etiqueta data es una lista de etiquetas por cada uno de los tiles de nuestro mapa que contiene el número de tile del tileset que está usando (y esta lista es enorme) por lo que para que los ficheros de mapa no ocupen tanto se codifican y se comprimen. En el próximo tutorial veremos como decodificarlo y descomprimirlo con Python.

Por último está la capa objectgroup. Esta son las capas de “eventos”, vemos que contiene el nombre que hemos puesto “Eventos” y el ancho y el alto (por defecto como todas es igual al tamaño del mapa). Dentro contiene un solo evento, porque solo uno creamos. Los eventos se llaman object y vemos que contiene el nombre que le pusimos y la posición x e y.

Hay más datos que se guardan que en este mapa no aparecen porque no hemos puesto, pero creo que se capta la idea de como guarda la información de nuestro mapa el archivo tmx. En el siguiente artículo veremos como leer esta información con Python para cargar los mapas.

Entradas relacionadas

• Engine VII: La clase Mapa I
• Engine V: Usando el Tiled Map Editor
• Engine III: Juegos basados en tiles
• Engine I: Preparándonos para trabajar
• Tilemapping – Juegos basados en tiles

https://twitter.com/razonartificial

Entradas relacionadas

• No hay entradas relacionadas.

Una vez descargado dentro de la carpeta graphics creamos una llamada tilesets y lo guardamos dentro. Ahora abrimos el Tiled Map Editor (TME a partir de ahora) y creamos un nuevo mapa le damos un tamaño de por ejemplo 50 tiles de ancho por 50 de alto y muy importante aquí, debemos decirle que los tiles de nuestro mapa serán de 40×40 (por defecto viene 32×32). La orientación la dejamos en ortogonal ya que no vamos a hacer juegos isométricos (de momento).

Lo siguiente que necesitamos es cargar nuestro tileset, elegimos la ruta, podemos poner un color que queramos que sea transparente, esto es opcional, el programa ya lee las transparencias de los archivos png. Y recordamos establecer que los tiles son de 40×40.

Investigad un poco y lo entenderéis enseguida, podéis crear tantas capas como querais y algo muy útil que veremos mas adelante, capas de eventos. Por ahora para seguir los artículos crear una capa de eventos arriba del todo (da igual cuantas capas de tiles tengáis) llamada Eventos y colocar un evento cerca del centro del mapa y ponerle el nombre de heroe (click derecho en el evento y le das propiedades). Click en la imagen para ver a tamaño completo.

Por último guardar en la carpeta maps con la extensión .tmx (esto es muy importante para que lo reconozca el TME.

En el siguiente tutorial analizaremos en fichero que hemos obtenido y aprenderemos a extraer la información.

Entradas relacionadas

• Engine VI: El formato TMX
• Engine VII: La clase Mapa I
• Engine IV: Tiled Map Editor
• Engine III: Juegos basados en tiles
• Avances del Engine RPG: Añadido el Scroll

En esta nueva etapa espero por fin empezar a publicar algo sobre robótica (sigo buscando a alguien que me ayude con esta sección) y seguir publicando tutoriales y artículos que sean útiles para vosotros, recuerdo que la filosofía del blog es publicar artículos útiles, para noticias y avances ya hay periódicos y otros blogs.

Entradas relacionadas

• Repositorio en github para el Engine-RPG
• Futuro del Engine y los tutoriales
• Destacamos del foro
• Razón Artificial Crece
• ¿Una comunidad?

En el anterior artículo explicamos la forma de almacenar un mapa y de como se representa este mapa, obviamente no vamos a rellenar el array que representa nuestro mapa a base de crear el array en el programa esto sería una tarea titánica. Se podría crear un archivo con los valores y cargarlo, pero seguiría siendo muy complicado

Es por eso que vamos a usar un Editor de mapas, el Tiled Map Editor, es un editor de mapas que está bastante bien. Tiene soporte de Capas, de eventos, propiedades para capas y para tileset con valores configurables, etc. Pero lo más importante es que guarda los mapas en formato XML que hacen que sean muy fáciles de leer con Python y extraer la información.

Como vemos tiene una interfaz sencilla e intuitiva, puedes descargarlo de su página Web, es multiplataforma, hay versiones tanto para Windows, MacOS X y Linux, para este último hay que compilarlo, pero no es nada complicado y si tenéis duda dejadme un comentario y os lo explico.

El archivo TMX

El guardar el mapa se genera un archivo tmx que no es mas que un documeno XML que tiene el siguiente formato:

<?xml version="1.0" encoding="UTF-8"?>
<map version="1.0" orientation="orthogonal" width="35" height="30" tilewidth="40" tileheight="40">
 <tileset firstgid="1" name="bosque" tilewidth="40" tileheight="40">
  <image source="../../engine/graphics/tilesets/tile_bosque.png"/>
 </tileset>
 <layer name="Layer 1" width="35" height="30">
  <data encoding="base64" compression="gzip">
   H4sIAAAAAAAAA81WQQ6DMAzrlSNsO2zAYfD...
 </data>
 </layer>
 <layer name="Layer 2" width="35" height="30">
  <data encoding="base64" compression="gzip">
   H4sIAAAAAAAAA9WXh07DMBRF/TvQQhlhRuyC...
  </data>
 </layer>
 <layer name="Layer 3" width="35" height="30">
  <data encoding="base64" compression="gzip">
   H4sIAAAAAAAAA+WWsQ7CMAxE/RWFiTIBG2yw0Q022...
  </data>
 </layer>
 <objectgroup name="Eventos" width="35" height="30">
  <object name="" x="700" y="495"/>
 </objectgroup>
</map>

Como ves almacena gran cantidad de información como el tamaño del mapa, el tamaño de los tiles que utliza, la ruta del tileset, etc. Luego almacena las capas en un formato bastante raro:

<data encoding="base64" compression="gzip">
    H4sIAAAAAAAAA81WQQ6DMAzrlSNsO2zAYfD...
</data>

La cadena entre las etiquetas en realidad es mucho más larga solo que yo la he acortado con puntos suspensivos para que cupiera y esto es lo que contiene nuestra array con la pos del tiled que utiliza, solo que viene cifrado en base64 y comprimido con gzip, pero ya veremos una forma muy fácil de decodificarlo y descomprimirlo con python.

Por ahora trata de hacer pruebas con el Tiled y ver en que va cambiendo el archivo XML generado y que datos va almacenando, en el siguiente tutorial aprenderemos a leer estos datos con Python.

Entradas relacionadas

• Engine VI: El formato TMX
• Engine V: Usando el Tiled Map Editor
• Engine VII: La clase Mapa I
• Engine III: Juegos basados en tiles
• Algoritmo Minimax, un jugador incansable

Nuestro engine va a hacer programado para juegos basados en la técnica del tilemapping, supongo que muchos ya sabrás en que consiste esta técnica, pero este artículo es para el que no lo sepa y para explicar que tipo de “tiles” vamos a usar.

El tilemapping consiste en dividir los mapas de nuestro juego en pequeños “tiles” (casillas) todas iguales, cada casilla puede tener un gráfico distinto y a partir de unir estas casillas se obtiene un mapa complejo.

Un ejemplo: Hundir la Flota. En este juego, el mapa es una cuadrícula de casillas. Cada casilla puede tener varios estados (agua, barco, barco tocado, barco hundido, etc…). Y cada uno de estos estados se representan en pantalla cambiando el color de la casilla, o usando una imagen distinta.

Tileset

Un tileset es una imagen que contiene los gráficos de todos los “tiles” (cuadritos de gráficos) que contiene nuestro mapa, en la imagen superior podemos ver un pequeño ejemplo de mapa a la izquierda y como esta formado usando los “tiles” del tileser de la derecha.

Esta técnica hace que con pocos gráficos podamos tener un mapa muy complejo y detallado y que además son altamente modificables, imagina tener que dibujar los mapas todos entero, sería eterno.

La técnica

La técnica consiste en que nuestro mapa es una simple matriz bidimensional de números enteros cada numero estará asociado a un tile en particular del mapa, por ejemplo el 1 representa a un tile de tierra, el 2 de agua y así sucesivamente.

En la imagen se ve claramente como las casillas con valor 2 son rellenadas de azul, las de 1 con amarillo y las de valor 0 son ignoradas.

Hay diferentes tipos de tilemapping, nosotros vamos a hacer es el más simple que es el ortogonal (visto desde arriba), luego hay otros como el isométrico que crea una sensación de 3D.

Bueno espero haber aclarado el concepto de tile para el que no lo conociera, si hay alguna duda tenéis los comentarios para preguntar.

Entradas relacionadas

• Engine VI: El formato TMX
• Engine V: Usando el Tiled Map Editor
• Engine I: Preparándonos para trabajar
• Tilemapping – Juegos basados en tiles
• Introducción a la programación gráfica 2D (III)

Nuestra forma de trabajar va a ser que los nuevos archivos se crea a partir de la plantilla que ya puse en los tutoriales y en el anterior artículo. Hacemos una copia de esta y la llamamos engine.py, este sera nuestro archivo de entrada y el que usaremos para ejecutar nuestro motor.

Definimos una resolucióm, creamos una función que compruebe si se quiere salir y hacemos el loop de Pygame, repito que si no sabes hacer todo esto puedes mirar el link a los tutoriales de pygame que puse más arriba. En definitiva nuestro engine.py nos queda así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

def salir():
	keys = pygame.key.get_pressed()
	for eventos in pygame.event.get():
		if eventos.type == QUIT:
			sys.exit(0)
		if keys[K_ESCAPE]:
			sys.exit(0)

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Engine RPG")

	clock = pygame.time.Clock()

	while True:
		time = clock.tick(60)
		salir()

		pygame.display.flip()
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Entradas relacionadas

• Avances del Engine RPG: Añadido el Scroll
• Juego de la serpiente paso a paso. Parte 2
• Engine XI: Creando al héroe
• Engine VII: La clase Mapa I
• Engine I: Preparándonos para trabajar

Antes de empezar

Yo voy a programar nuestro engine en un entorno Linux, todo lo aquí explicable puede ser perfectamente aplicable a otros Sistemas Operativos, pero en un principio cosa como las rutas a archivos estarán escritas para sistemas Unix, porque prefiero trabajar así y luego usar el módulo OS para generalizarla pasa todos los SO, tú puedes generalizarlas directamente o usar el sistema de rutas de tu sistema (esto es para los que trabajen con Windows sobre todo que usa la barra invertida (\) para los directorios).

Herramientas Necesarias

• Python. Yo voy a trabajar con la versión 2.6.x de Python, pero pasarlo todo a Python 3.x no creo que sea muy complicado para el que lo conozca.
• Pygame. Obviamente, será nuestra biblioteca gráfica.
• Geany. Este es el IDE que yo voy a usar, tú usa con el que te sientas más a gusto.
• Usaremos más herramientas, pero las iremos viendo a lo largo de los artículos y a medida que avancemos.

Creando un espacio de trabajo

Vamos a necesitar crear un directorio específico para nuestro proyecto donde meteremos todas nuestras carpetas y archivos ordenadamente. Yo he creado un directorio base llamado engine y dentro por el momento tengo dos carpetas: graphics y maps, y también tengo mi archivo plantilla.py para crear nuevos archivos al vuelo con solo copiar y pegar. por tanto mi carpeta base queda de la siguiente manera:

• engine
  • graphics
  • maps
  • plantilla.py

A medida que nuestro proyecto crezca iremos añadiendo carpetas y archivos que debemos siempre mantener organizado para saber en que lugar está cada cosa.

Entradas relacionadas

• Avances del Engine RPG: Añadido el Scroll
• Engine XI: Creando al héroe
• Engine X: La clase mapa III
• Engine IX: Cargando el tileset
• Engine VII: La clase Mapa I

Creando un engine

Un engine es lo que llamamos el motor del juego, es decir, lo que controla los aspectos más básicos del mismo para sobre él crear nuestro juego. Controla cosas como el dibujado de la pantalla, la gestión del sonido, la entradas que hay por teclado, etc. Es decir, es lo que hace que luego programar el juego resulte muy sencillo sobre este motor.

Python no es creo que sea el lenguaje más adecuado para programar un motor de videojuegos, aunque este sea 2D, C++ sería mucho mas apropiado para este propósito y luego ya si se podría usar Python para escribir el juego sobre este, pero como esto lo hacemos por diversión y por aprender las bases, no es cuestión de complicarse la vida con C++ y vamos a hacerlo con Python y Pygame, que con los ordenadores de hoy en día y siendo un juego en 2D las diferencia de rendimiendo no se notarán, además todo lo que aprenderemos aquí en cuanto a técnicas es totalmente aplicable a C++ y una biblioteca como SDL (Pygame solo es un port de SDL a Python).

¿Qué tipo de juego?

Es importante definir para que tipo de juego va a ser nuestro motor, para a partir de ahí enfocar lo que necesitamos. Yo lo que voy a crear es un engine para hacer un RPG (juegos de rol), pero también me interesaba crear uno para RTS (juegos de estrategia) por curiosidad, así que aunque el engine sea para RPG en ocasiones escribiré artículos dedicado a hacer ciertas rutinas para RTS.

Nuestro Engine será para los tipicos juegos RPG en 2D que podemos ver para consolas portátiles y en los famosos RPG Makers, es decir, juegos basados en tiles visto desde arriba con proyección ortogonal.

Entradas relacionadas

• Avances del Engine RPG: Añadido el Scroll
• Engine XI: Creando al héroe
• Engine VII: La clase Mapa I
• Engine X: La clase mapa III
• Engine IX: Cargando el tileset

Una de las partes más lentas del algoritmo A*, es encontrar el cuadro o nodo de la lista abierta con la menor puntación F. Dependiendo del tamaño de tu mapa, podrías tener docenas, cientos o incluso miles de nodos donde buscar en cualquier momento mientras usas el A*. No necesito decir, que buscar repetidamente en una lista que sea grande puede enlentecer mucho las cosas. Sin embargo, la cantidad de tiempo que lleva hacer esto puede ser influenciada por la forma en la que elijas salvar los elementos de tu lista abierta.

Listas abiertas Ordenas y Desordenadas: Una Simple Aproximación

Una forma realmente fácil de almacenar la lista abierta es guardar cada elemento cuando se necesite, y recorrer la lista completa cada vez que necesites sacar algo de la lista buscando el elemento de coste menor. Esto proporciona rápidas inserciones en la lista, pero será posiblemente más lento de quitar ya que necesitas comprobar todos los elementos de la lista para asegurarte de que tienes el elemento de coste F más bajo.

Normalmente puedes mejorar la ejecución de tu programa manteniendo lista ordenada. Lleva un poco más de trabajo; porque cada vez que añades un elemento a la lista, necesitas insertarlo en el lugar adecuado. Sin embargo, eliminar elementos es rápido. Solo sacas el primer elemento que es el que tiene el coste más bajo posible.

Hay muchas formas de mantener tus datos ordenados (selection sorts, bubble sorts, quick sorts, etc.) y puedes encontrar artículos en internet acerca del tema, simplemente incluyendo los términos en tu buscador favorito. De todas formas puede que al menos captes unas ideas aquí. Un enfoque realmente simple sería empezar al principio de tu lista cada vez que necesites añadir un nuevo elemento, y luego comparar sucesivamente el coste F del nodo actual que estás añadiendo a la lista con cada elemento que ya esté en ella. Una vez que hayas encontrado un nodo en la lista con un coste F igual o mayor, podrías insertar el nuevo elemento antes de ese que has encontrado. Dependiendo del lenguaje que estés usando, las listadas enlazadas usando clases o las estructuras (tipos en darkbasic y blitz), son probablemente las mejores opciones.

Este enfoque podría mejorarse  manteniendo la pista del coste F medio de los elementos que ya están en la lista, y usando eso para decidir si empezar al principio de la lista (como se describe más abajo) o empezar al final de la lista y seguir hasta el principio de la lista. En general, las inserciones de nuevos elementos con menor coste que la F media, deberían empezar al principio de la lista y avanzar, mientras que elementos nuevos con una F sobre la media deberían ir al final e ir retrocediendo. Este enfoque acorta el tiempo de búsqueda a la mitad.

Más complicado pero más rápido sería llevando esa idea al siguiente nivel, usando una quick sort (clasificación rápida), que básicamente empieza comparando el coste F del nuevo elemento con el elemento de la mitad de la lista. Si el nuevo elemento tiene un coste menor, deberías compararlo con el elemento que esté a 1/4 de la longitud de la lista, si es menor a 1/8, y así sucesivamente hasta que encuentres el lugar adecuado

Pilas Binarias (Binary Heaps )

Los pilas binarios son muy similares al método quick sort que acabamos de describir, y frecuentemente los usan personas que desean mantener sus funciones A*, tan rápidas como sea posible. En mi experiencia, usar un pila binario ha acelerado la búsqueda de 2 a 3 veces de media, y más aún en mapas mayores con muchos nodos (me refiero a un mapa de 100 x 100 nodos o más). No obstante, he de decir que los pilas binarios son un poco complicados y no deberían ser un dolor de cabeza a menos que estés usando un mapa con muchos nodos, donde ganar velocidad es crucial.

El resto de este artículo se dedica a explicar pilas binarios y su uso en A*. Hay también una sección de Más Información al final de esta página la cual te dará perspectivas adicionales, si la mía te ha dejado totalmente desconcertado.

¿Aún estás interesado? De acuerdo, allá vamos…

En una lista ordenada, cada elemento de la lista está en el orden correcto, de menor a mayor o de mayor a menor. Esto es útil, pero ahora es más de lo que necesitamos realmente. En estos momentos no nos importa si el número 127 es menor que el 128 de la lista. Lo verdaderamente importante es que tengamos el elemento con el coste F menor, al principio de la lista. El resto de la lista puede ser un revoltijo sin sentido. Mantener el resto de la lista debidamente ordenado es solo trabajo innecesario hasta que, por supuesto, necesitemos el siguiente elemento con la F más baja.

Básicamente, lo que andamos buscando es algo llamado “pila” o, más específicamente, una pila binaria. Una pila binaria es un conjunto de elementos donde el elemento menor o el mayor (dependiendo de lo que quieras) está al principio de la pila. Cuando estemos buscando el elemento con el coste F más bajo, lo pondremos en lo más alto de nuestra pila. Este elemento tiene dos hijos, cada uno de los cuales tiene un coste F igual  o un poco mayor que él, y cada uno de esos hijos tienen a su vez dos hijos que tienen un coste igual o un poco mayor que ellos… y así hasta el final. Aquí hay algo que podría ser una pila:

Observa que el el elemento menor de la lista (10) está en todo lo alto y el segundo menor (20) es uno de sus hijos. En esta particular pila binaria, el tercer elemento con el coste menor de la lista es el 24, el cual está a dos pasos del principio y es menor que 30, el cual está solo a un paso del 10 y situado a su izquierda. No importa el valor de los otros elementos de la pila, cada elemento individual, solo necesita ser igual o mayor que su padre, e igual o menor que sus dos hijos. Estas condiciones representan una pila binaria válida.

Llegados a este punto, probablemente estés pensando en el modesto interés de todo esto. ¿Cómo vas a usar esos conceptos de una manera práctica? Una de las cosas interesantes sobre pilas es que puedes guardarlas en matriz unidimensional.

En esta matriz, el elemento al principio de la pila estaría en la primera posición de la matriz (posición 1, no posición 0 cosa posible en una matriz). Sus dos hijos deberían estar en las posiciones 2 y 3. Los 4 hijos de esos 2 elementos estarían en las posiciones 4-7.

En resumen, los dos hijos de cualquier elemento de la pila, pueden localizarse en la matriz, multiplicando la posición del elemento actual en la matriz por dos (para encontrar al primer hijo) y por dos mas uno (para encontrar al segundo). Así, por ejemplo, los 2 hijos del tercer elemento de nuestra pila (con un valor de 20), se encuentran en las posiciones 2×3 = 6, y 2×3 +1=7 de la matriz. En este caso, los números de esas posiciones son 30 y 24 respectivamente, cosa que cobra sentido cuando miras la pila.

Con 7 elementos, se llena completamente cada fila de una pila de 3 niveles. Sin embargo, esto no es obligatorio. Para que nuestra pila sea válida, lo único que necesitamos es llenar cada fila que haya sobre el último nivel. Podemos tener cualquier número de elementos en el nivel inferior y los nuevos elementos se irán añadiendo en ese nivel de izquierda a derecha. El método descrito en este artículo hace esto, así que no necesitas preocuparte por esto.

Añadiendo Elementos Al Montón

Necesitaremos considerar algunas cosas antes de que podamos usar una pila en un pathfinding, pero por ahora solo vamos a aprender lo básico de su uso. Te sugeriría que hojeases esta parte para comprender los principios. Más tarde, te daré una fórmula que te librará de todo esto, pero aún es importante que comprendas como funcionan las cosas.

En general, para añadir elementos a la pila, los colocamos al final de la matriz. Después los comparamos a sus padres, quienes están en la posición (elementos en la pila)/2 redondeando la parte fraccional hacia abajo. Si el coste F del nuevo elemento es menor, no saltamos esos 2 elementos. Luego comparamos el nuevo elemento con su padre que está en la posición (posición actual en la pila)/2, redondeando hacia abajo. Si su valor F es menor, los saltamos de nuevo. Repetimos este proceso hasta que el elemento no se menor que su padre, o hasta que el elemento haya rebasado el principio de la pila, lo que representa la posición 1 de la matriz.

Supongamos que añadimos un elemento con una F de 17 a nuestra pila. En este momento tenemos 7 elementos en ella, así que el nuevo elemento debería situarse en la posición número 8. Así queda la pila; el nuevo elemento está subrayado:

10 30 20 34 38 30 24 17

Luego comparamos este elemento con su padre, el cual esta en la posición 8/2 = posición 4. El valor F del elemento que ahora mismo está en la posición 4 es 34. Ya que 17 es menor que 34 intercambiamos sus respectivas posiciones.

10 30 20 17 38 30 24 34

Después lo comparamos con su nuevo padre. Como está en la posición 4 lo comparamos con el elemento en la posición 2 (4/2=2). Ese elemento tiene una puntuación F de 30. Ya que 17 es menor que 30, y ahora nuestra pila sería así:

10 17 20 30 38 30 24 34

Luego lo comparamos con su nuevo padre. Ahora que está en la posición 2, lo comparamos con la posición 1 (2/2), que es la posición del primer elemento de la pila. En este caso, 17, no es menor que 10, así que nos paramos y dejamos la pila como está.

Quitando Elementos de la Pila

Eliminar elementos de la pila, implica un proceso similar, pero en orden inverso. Primero, quitamos el elemento del hueco 1, que ahora se quedaría vacío. Luego cogemos el último elemento de la pila y lo llevamos al hueco 1. Tomando como ejemplo la pila anterior, ahora tenemos que el que antes fue el último elemento de la pila ahora está subrayado:

34 17 20 30 38 30 24

Lo siguiente es comparar el elemento con cada uno de sus hijos, los cuales están en las posiciones (posición actual x 2) y (posición actual x 2+1). Si tiene una puntuación menor que sus 2 hijos, se queda donde está. Si no, intercambiamos su posición con el menor de sus hijos. Así que, en este caso, los dos hijos del elemento en la posición 1, están en la posición 1×2=2 y 1×2+1=3. Ya que 34 no es menor que sus hijos lo intercambiamos por el menor de ellos, en este caso el 17. La cosa queda así:

17 34 20 30 38 30 24

Ahora comparamos el elemento con sus 2 hijos, que están en la posición 2×2=4, y 2×2+1=5. Como 34 no es menor que sus hijos lo intercambiamos por el menor (el 30 en la posición 4). Ahora nos sale esto:

17 30 20 34 38 30 24

Por último comparamos el elemento con su nuevo hijo. Como ya sabes, están en las posiciones 4×2=8 y 4×2+1=9. Sin embargo, no hay ningún hijo en esas posiciones, esto se debe a que la lista no es tan larga. Hemos alcanzado el último nivel de la pila, así que paramos.

¿Porqué una Pila Binaria es tan Rápida?

Ahora que sabes los principios de la inserción y borrado en una pila, deberías empezar a ver por qué es mucho más rápido, que por ejemplo, un insertion sort. Imagina que tienes una lista abierta con 1000 nodos, cosa que no es imposible en un mapa respetable con muchos nodos (recuerda que un mapa de solo 100 x 100 nodos, tiene 10000). Si hicieses un simple insertion sort, empezarías al principio de la lista, y procederías hasta encontrar la posición adecuada para insertar el nuevo elemento, tendrías que hacer una media de 500 comparaciones antes de insertarlo en el lugar adecuado.

Usando una pila binaria, solo necesitas hacer una media de 1-3 comparaciones para insertarlo en el lugar correcto, empezando desde el final. También necesitarías hacer una media de 9 comparaciones para eliminar de la lista abierta y reordenar la pila apropiadamente. En un A*, normalmente eliminas un nodo en cada paso (el elemento con el coste F más bajo), y usualmente añades en cualquier lugar de 0 a 5 nodos (usando el enfoque 2D descrito en el artículo principal). Esto puede alcanzar más o menos el 1% del tiempo que lleva hacer una insertion sort con el mismo número de nodos. La diferencia se hará geométricamente más importante en mapas mayores (con más nodos). En comparación, mapas más pequeños, ganan paulatinamente menos ventaja, cosa que se debe a que las pilas binarias pierden su importancia cuanto más pequeño sea el mapa y su número de nodos sea menor.

De todas formas, solo porque vayas a usar una pila binaria, no significa que tu algoritmo vaya a ser 100 más rápido (o lo que sea). En un algoritmo A*, hay muchas cosas más importantes que ordenar solamente la lista abierta. Sin embargo, mi experiencia me dice que usar pilas binarias hace que tu algoritmo pathfinding sea en muchos casos, 2 o 3 veces más rápido, tal vez incluso más en caminos largos.

Creando una Lista Abierta

Ahora que sabemos lo que es una pila, ¿Cómo vamos a usarla? Lo primero que necesitamos hacer es dimensionar nuestra matriz mono-dimensional apropiadamente. Para hacer esto, lo primero que necesitamos es hacernos una idea de como será posiblemente de grande. Por norma, la lista no puede ser mayor que el número total de nodos de nuestro mapa (asumiendo en el peor de los casos, un escenario donde el camino se busque teniendo en cuenta todo el mapa). En un cuadrado mapa bidimensional como el que describí en el artículo principal, no tendremos más de AnchoMapa x AltoMapa nodos. Es una indicación de que tan grande será nuestra matriz unidimensional. Por el bien de este ejemplo, nosotros llamaremos a esta matriz listaAbierta(). El elemento superior se guardará en listaAbierta(1), el segundo en la pila estará en listaAbierta(2), y así.

Usando Punteros

Ahora que tenemos una pila/matriz unidimensional con el tamaño adecuado, estamos casi listos para empezar a usarlo para un pathfinding. Antes de que vayamos más lejos, vamos a echar de nuevo un vistazo a nuestra pila original antes de añadir o quitar nada.

Ahora mismo, es solo una lista de valores de F organizados debidamente. Pero olvidamos un elemento importante. Claro que tenemos un grupo de valores F organizados por orden en una pila binaria, pero no tenemos pistas de a que cuadros pertenecen. Básicamente, lo único que sabemos ahora mismo, es que el 10 es el menor valor de la pila. Pero, ¿a qué cuadrado de nuestro mapa hace referencia?

Para solucionar este problema, necesitamos cambiar los valores de los elementos de la matriz. En vez de guardar el valor F en la matriz, necesitamos guardar un único número identificador que nos indique a qué cuadro se refiere. Mi idea es crear un único ID (número identificador) asociado con cada nuevo elemento añadido a la pila, llamado cuadrosComprobados. Cada vez que añadimos un elemento a la lista abierta, incrementamos cuadrosComprobados en uno y lo usamos como único ID para los nuevos elementos añadidos a la lista abierta. El primer elemento añadido es el elemento 1, el segundo el 2,…

Por último, necesitamos guardar el coste actual de ese cuadro en una tabla unidimensional a parte, a la que llamo costeF(). Al igual que la matriz listaAbierta, el tamaño será el mismo,  AnchoMapa x AltoMapa. También guardaremos las coordenadas x e y del nodo en el mapa, en matrices unidimensionales similares, que llamaré abiertoX() y abiertoY(). Se parecería a la siguiente ilustración:

Aunque esto parezca un poco más complicado, es la misma pila que la anterior. La diferencia está en que ahora tenemos mucha más información.

El elemento 5 (con el costeF menor – 10) aún sigue al principio de la pila y en la primera columna de nuestra matriz unidimensional. Pero ahora estamos guardando un ID único de 5 en vez de su coste F en la pila. En otras palabras,  listaAbierta(1) = 5. Este número único se usa luego, para mirar el costeF del elemento y su localización X e Y en el mapa. El costeF de este elemento es costeF(5)=10, su localización en el mapa es,  abiertoX(5)=12 y abiertoY(5)=22.

El elemento superior de la pila tiene 2 hijos, los elementos con el número 2 y el 6, tienen un costeF de 30 y 20 respectivamente y están en las posiciones 2 y 3 de la listaAbierta(), y así hasta el final. En resumen, tenemos exactamente la misma pila que teníamos al principio, solo que con mucha más información, ahora sabemos donde está el elemento en el mapa y su costeF.

Añadiendo Nuevos Elementos a la Pila (Parte 2)

Ahora vamos a aplicar esta técnica para ordenar nuestra lista de una forma que sea útil en un algoritmo de un pathfinding A*. Usaremos exactamente las mismas técnicas explicadas anteriormente.

El primer elemento que añadamos a la lista abierta, es normalmente el nodo principal y se le asigna un ID único, en este caso 1. Luego lo ponemos en la posición 1 de la lista abierta. En otras palabras, listaAbierta(1)=1. También mantenemos un seguimiento al número de elementos de nuestra lista, que es 1 por ahora. Guardamos este número en una variable llamada numeroDeElementosEnListaAbierta.

Así que, añadimos nuevos nodos a la lista abierta, calculando sus puntuaciones G, H y F, como está descrito en el artículo principal. Después los añadimos a la pila binaria como está señalado más arriba.

Primero asignamos el nuevo elemento a un ID único para la variable cuadrosComprobados. Le sumamos 1 cada vez que añadamos un nuevo nodo, y asignamos este número al nuevo nodo. Luego sumamos 1 a numeroDeElementosEnListaAbierta, y después lo añadimos al final de la lista abierta. Todo lo anterior se traduce en lo siguiente:

cuadrosComprobados = cuadrosComprobados +1
numeroDeElementosEnListaAbierta= numeroDeElementosEnListaAbierta+1
listaAbierta(numeroDeElementosEnListaAbierta) = cuadrosComprobados

Después hacemos sucesivas comparaciones con su padre hasta que alcance su lugar apropiado en la pila. Aquí hay algún código que lo hace:

m = numeroDeElementosEnListaAbierta
While m <> 1 ;Mientras que el elemento no ha alcanzado el principio(m=1)

	;Comprueba si el hijo es <= padre. Si es así los intercambia.
	If costF(listaAbierta(m)) <= costF(listaAbierta(m/2)) Then
		temp = listaAbierta(m/2)
		listaAbierta(m/2) = listaAbierta(m)
		listaAbierta(m) = temp
		m = m/2
	Else
		Exit ;sale del bucle while/wend
	End If
Wend

Borrando Elementos de la Pila (Parte 2)

Por supuesto, no solo construimos una pila, también necesitamos borrar elementos de ella cuando ya no los vayamos a utilizar de nuevo. Específicamente en el pathfinding A*, necesitamos borrar el elemento con el coste F menor del principio de la lista después de haberlo comprobado y pasado a la lista cerrada.

Antes describimos como se empieza moviendo el ultimo elemento de la pila hasta la primera posición, y luego reducimos el número de elementos de la lista en uno. En pseudocódigo sería así:

listaAbierta(1) = listaAbierta(numeroDeElementosEnListaAbierta)
numeroDeElementosEnListaAbierta = numeroDeElementosEnListaAbierta - 1

Lo siguiente que necesitamos hacer es sucesivas comparaciones entre este valor y sus dos hijos. Si tiene una puntuación F mayor que alguno de ellos, intercambiaremos su posición con el menor. Luego comparamos el elemento con sus 2 nuevos hijos (ahora que está más abajo en la pila). Si tiene su F es mayor que cualquiera de sus hijos, lo intercambiamos por el menor. Repetimos este proceso hasta que el elemento encuentre su lugar correcto, que podría ser el final de la pila, pero no necesariamente. Aquí tienes el pseudocódigo de lo dicho:

;Repite lo siguiente hasta que el elemento encaje en su lugar adecuado en la pila.
Repeat
	u = v
	If 2*u+1 <= numeroDeElementosEnListaAbierta ;si ambos hijos existen 		;Selecciona el menor hijo de los 2. 		If costF(listaAbierta(u)) >= costF(listaAbierta(2*u)) then v = 2*u ;VER NOTA MÁS ABAJO
		If costF(listaAbierta(v)) >= costF(listaAbierta(2*u+1)) then v = 2*u+1 ;VER NOTA MÁS ABAJO

	Else If 2*u <= numeroDeElementosEnListaAbierta ;si solo el hijo 1 existe 		;Comprueba si el coste F es mayorque el del hijo 		If costF(listaAbierta(u)) >= costF(listaAbierta(2*u)) then v = 2*u
	End If

	If u <> v then ; Si el F del padre > al de uno o al de los dos hijos, los intercambia
		temp = listaAbierta(u)
		listaAbierta(u) = listaAbierta(v)
		listaAbierta(v) = temp
	Else
		Exit ;si el elemento <= que ambos hijos, sale del bucle repeat/forever
	End if
Forever ;Repetir siempre

Por favor, observa en el código, la u y la v en negrita (en rojo) . En la segunda línea, quieres usar v, no u, cosa que podría no ser inmediatamente obvia. Esto te asegura que acabes intercambiando con el menor de los 2 hijos. Fallar haciendo esto, te dará una pila errónea, y joderá tu pathfinding completamente.

Reordenando un Elemento Existente en una Lista Abierta

Tal y como se describió en el artículo principal, llegará un momento en el que te des cuenta que la puntuación F de una lista puede cambiar. Cuando eso ocurre, no necesitas sacar el elemento de la lista y empezar todo de nuevo. Simplemente empiezas en su posición actual, y lo comparas con su padre usando su nueva (y menor) puntuación F. En general, usamos el mismo código descrito en la sección “Añadiendo un Elemento a la Pila” con la siguiente consideración adicional:

Desafortunadamente, debido a que tus datos son una enorme y aparentemente desordenada pila, necesitas recorrerla por completo para encontrar un elemento en su interior. Básicamente estarás buscando el cuadro con las coordenadas x e y correctas, como se indica en abiertoX(listaAbierta()) y abiertoY(listaAbierta()). Sin embargo, después de encontrarlo, puedes proceder normalmente haciendo las comparaciones necesarias y empezando los intercambios desde su posición dentro de la pila.

Notas Finales

Tengo la esperanza de que si has llegado hasta aquí y aún estás leyendo , significa que no estás totalmente confundido. Si no te sientes intimidado, y quieres codificar tu propia pila binaria para tu propio algoritmo de pathfinding, entonces esto es lo que te sugiero:

Primero, olvida las pilas binarias por un momento. Concéntrate en conseguir que tu algoritmo A* funcione correctamente y que esté libre de errores usando un método simple para ordenar. Al principio solo necesitas que funcione, no que vaya rápido.

Segundo, antes de que añadas una pila binaria al código, intenta codificar una pila binaria aparte que haga lo que tu quieras, añadiendo y substrayendo elementos de la pila de una forma correcta. Asegúrate de escribir el programa de forma que puedas reconocer qué función realiza cada paso del proceso, quizá imprimiendo los resultados en la pantalla conforme lo vayas ejecutando. Deberías incluir alguna tecla de escape en el programa que te permita salir si fuera necesario, es muy fácil quedar atrapado en un bucle sin fin si no has escrito la pila binaria correctamente.

Una vez que confíes en que ambos programas funcionan perfectamente, guarda una copia de los 2, y luego empieza a trabajar en unirlos. Amenos que seas mucho más listo que yo, probablemente tendrás problemas al principio. Signos de tus errores serán extraños mensaje de error y misteriosos caminos ilógicos. No desesperes, al final lo conseguirás.

Entradas relacionadas

• Pathfinding A* de 2 niveles
• Heurística para el Pathfinding A*
• Pathfinding A* en Python. Parte III
• Pathfinding A* en Python. Parte I
• Pathfinding A* en Python. Parte II

Considera la siguiente situación en un RPG, donde un guerrero quiere encontrar el camino tras el muro cercano:

Con esta clase de mapa, podrías situar los nodos de muchas maneras, y usar también, cantidad de densidades. En este ejemplo, vamos a usar una red de nodos de densidad alta, tal y como se muestra en la siguiente imagen:

En este gráfico, los nodos blancos son transitables. Las áreas donde no hay nodos son intransitables. También hemos hecho las cosas de manera un poco diferente; este ejemplo  te permite rodear esquinas alrededor de cuadros intransitables. Además, los “cuadros” en sí mismos no existen; debido a que esto es un ejemplo isométrico. Por ello hemos agrupado el doble de nodos en el eje Y (el eje vertical) que en el eje x (horizontal). Esto permite caminos isométricos más apropiados.

Puedes ver que usando esta red de nodos tan densamente comprimida, podemos no solo rodear muros cercanos sino que además podemos pasar entre el muro y el barril en el proceso. Nuestra densa red de nodos también permite rodear la antorcha, donde el nodo de su base es intransitable. Esto es, en suma, un pathfinding preciso.

Eso está bastante bien en situaciones de distancias cortas, pero, ¿qué haremos si necesitamos encontrar el camino a través del todo el mapa? Usar una red de nodos tan densa, podría fácilmente dejarte con una búsqueda de más de 10.000 nodos en un sólo y único paso a través del bucle del A*. Lo más seguro es que ante esta situación, cualquier ordenador tuviese que detenerse a calcularlo.

Veamos una alternativa. ¿Qué ocurre si elegimos crear una red mucho menos densa como la que tenemos abajo?

En este ejemplo, los nodos están en el centro de grandes diamantes isométricos. Los datos sobre transitabilidad entre diamantes son almacenados en la misma matriz a lo largo de los bordes, y están representados en este gráfico con pequeñas manchas rojas. Para moverse desde una baldosa isométrica a una de sus 8 macro-baldosas adyacentes, la baldosa adyacente debe ser transitable, y el camino entre ambas no debe estar bloqueado.

Esta red de nodos es 72 veces menos densa que la anterior. En vez de manejar más de 10.000 nodos en cada momento, aquí solo manejas el 1/72 de eso, es decir, menos de 200. Nuestro ordenador, puede definitivamente manejar eso. Encontrar el camino a través del mapa ya no es un problema.

Uniendo los dos.

Así pues, ¿qué método elegimos? ….Ambos.

En cualquier búsqueda, deberías primero encontrar el camino que atraviesa el mapa usando el macro-buscador. Despues cambiarías al micro-buscador y buscarías un camino desde la localización inicial hasta dos macro-nodos más allá según el camino obtenido con el macro-buscador. Una vez que has entrado en cada nuevo macro-diamante, usarías el micro-buscador para encontrar el camino que llegue hasta el segundo de los 2 macro-nodos siguientes. Esto acaba por desechar la segunda mitad de cada micro-camino, pero necesitas hacer esto para asegurarte de que está correcto – además, tampoco se desecha mucho desde el momento que el micro-buscador atraviesa distancias relativamente cortas. Una vez que llegues a una distancia de 2 o 3 nodos del destino, deberías cambiar definitivamente al micro-buscador, y encontrar el destino final.

Usando esta aproximación, conseguirás mayor velocidad para cruzar el mapa completo, y serás capaz de rodear esquinas, barriles, etc. con un camino realístico, como en el ejemplo anterior del micro-buscador.

Y si eres realmente ambicioso y tuviese un mapa gigantesco, podrías desarrollar 3 buscadores ; uno en un macro-nivel, otro en uno medio y otro en uno micro. Los profesionales han hecho esto para juegos como Age of Empires. Esto solo depende de lo que necesites hacer.

Traducido por Elthan, con el permiso de Patrick.

Entradas relacionadas

• Usando Pilas Binarias en Pathfinding A*
• Heurística para el Pathfinding A*
• Pathfinding A* en Python. Parte III
• Pathfinding A* en Python. Parte I
• Pathfinding A* en Python. Parte II

Método Manhattan

Este es el método usado en el artículo principal. Su principal ventaja es que normalmente alcanzas el objetivo más rápido que en la mayoría de alternativas. Su mayor inconveniente es que está sobrecargado en comparación con G y por lo tanto reducirá cualquier pequeño modificador que intentes añadir al cálculo, es decir, una penalización de giro o un modificador tipo mapa de influencia. Si no vas a tener en cuenta estas cosas, este método es probablemente tu mejor opción. La ecuación, donde abs= valor absoluto, es:

H = 10*(abs(Xactual-Xdestino) + abs(Yactual-Ydestino))

Atajo Diagonal

Este método equilibra H y G. Su principal ventaja es esa, ya que al estar equilibrado, es completamente capaz de considerar pequeños modificadores como penalización de giro o un modificador de mapa de influencia. Es un poco más lento que el método anterior. La ecuación, donde abs= valor absoluto, es:

xDistancia = abs(abs(Xactual-Xdestino)
yDistancia = abs(Yactual-Ydestino)
if xDistancia > yDistancia:
	H = 14*yDistancia + 10*(xDistancia -yDistancia)
else:
	H = 14*xDistancia + 10*(yDistancia -xDistancia)

Hay muchos otros métodos de calcular H, aunque estos sean probablemente de los más comúnmente utilizados. En general, la estimación más cercana es la distancia actual hasta el objetivo, el A* más rápido encontrará esa meta. Si sobreestimas H con respecto a la distancia actual, A* no te garantizará el mejor camino (en el argot del pathfinding, a esto se llama una “heurística inadmisible”). Por lo tanto, el truco consiste en aproximarte tanto a la distancia actual como te sea posible sin sobreestimarlo. Ambos métodos son admisibles.

Para más información: Amit’s Notes on A* Heuristics

Traducido por Elthan, con el permiso de Patrick Lester.

Entradas relacionadas

• Usando Pilas Binarias en Pathfinding A*
• Pathfinding A* de 2 niveles
• Pathfinding A* en Python. Parte III
• Pathfinding A* en Python. Parte I
• Pathfinding A* en Python. Parte II

El juego ha sido hecho usando el algoritmo que preparamos en la parte 1 y 2, se puede ver como funciona perfectamente y encuentra todos los caminos al instante, dejo un vídeo de demostración.

[There is a video that cannot be displayed in this feed. Visit the blog entry to see the video.]

La mecánica es sencilla, se usa el click izquierdo para crear  y borrar muros (en el ejemplo troncos) y click derecho para mover el personaje a un punto determinado. El ejemplo no es perfecto y tiene algunos fallos porque la intención no era mostrar Pygame sino que el algoritmo funciona con un ejemplo más real.

No comento el código porque todo lo nuevo es Pygame puro y duro, que ya haré más tutoriales para mostrar como crear ejemplos de rpg y estrategia.

• Descargar el ejemplo

Entradas relacionadas

• Pathfinding A* en Python. Parte I
• Usando Pilas Binarias en Pathfinding A*
• Pathfinding A* de 2 niveles
• Heurística para el Pathfinding A*
• Pathfinding A* en Python. Parte II

La clase Nodo

Lo primero que necesitamos siguiendo la teoría es tener la forma de crear un nodo. Cada nodo debe de contener la siguiente información.

• Posición – Coordenadas del nodo.
• Padre. Almacena el nodo padre.
• Valor de H. Distancia con el punto objetico.
• Valor de G. Distancia recorrida hasta ese nodo.
• Valor de F. Suma de G más H.

Eso son los datos que contiene un nodo, por lo que la mejor manera de almacenarlos en Python en creando una clase que cree esos datos automáticamente.

class Nodo:
	def __init__(self, pos=[0, 0], padre=None):
		self.pos = pos
		self.padre = padre
		self.h = distancia(self.pos, pos_f)

		if self.padre == None:
			self.g = 0
		else:
			self.g = self.padre.g + 1
		self.f = self.g + self.h

Como vemos recibe dos parámetros la posición y el nodo padre. A partir de ellos obtiene la G que si no tiene padre valdrá 0 y sino le añadirá 1 a la G de su padre. La F la obtiene de la suma de G y H. Dejo la H para el final porque para calcularla usa la siguiente función:

# Distancia entre dos puntos.
def distancia(a, b):
	return abs(a[0] - b[0]) + abs(a[1] - b[1]) #Valor absoluto.

Como ves usa matemáticas básicas para obtener la distancia entre dos puntos, ojo al dato de que la devuelve en valor absoluto, las distancias negativas no existen. Cabe destacar que el punto b (pos_f) es la posición final y es una variable declarada global.

La calcula usando la siguiente función:

def buscarPos(x, mapa):
	for f in range(mapa.fil):
		for c in range(mapa.col):
			if mapa.mapa[f][c] == x:
				return [f, c]
	return 0

La Clase AEstrella

Aquí viene la chicha del algoritmo, la clase que dará nuestro camino a seguir, la dejo entera y la comentamos.

class AEstrella:
	def __init__(self, mapa):
		self.mapa = mapa

		# Nodos de inicio y fin.
		self.inicio = Nodo(buscarPos(2, mapa))
		self.fin = Nodo(buscarPos(3, mapa))

		# Crea las listas abierta y cerrada.
		self.abierta = []
		self.cerrada = []

		# Añade el nodo inicial a la lista cerrada.
		self.cerrada.append(self.inicio)

		# Añade vecinos a la lista abierta
		self.abierta += self.vecinos(self.inicio)

		# Buscar mientras objetivo no este en la lista cerrada.
		while self.objetivo():
			self.buscar()

		self.camino = self.camino()

	# Devuelve una lista con los nodos vecinos transitables.
	def vecinos(self, nodo):
		vecinos = []
		if self.mapa.mapa[nodo.pos[0]+1][nodo.pos[1]] != 1:
			vecinos.append(Nodo([nodo.pos[0]+1, nodo.pos[1]], nodo))
		if self.mapa.mapa[nodo.pos[0]-1][nodo.pos[1]] != 1:
			vecinos.append(Nodo([nodo.pos[0]-1, nodo.pos[1]], nodo))
		if self.mapa.mapa[nodo.pos[0]][nodo.pos[1]-1] != 1:
			vecinos.append(Nodo([nodo.pos[0], nodo.pos[1]-1], nodo))
		if self.mapa.mapa[nodo.pos[0]][nodo.pos[1]+1] != 1:
			vecinos.append(Nodo([nodo.pos[0], nodo.pos[1]+1], nodo))
		return vecinos

	# Pasa el elemento de f menor de la lista abierta a la cerrada.
	def f_menor(self):
		a = self.abierta[0]
		n = 0
		for i in range(1, len(self.abierta)):
			if self.abierta[i].f < a.f:
				a = self.abierta[i]
				n = i
		self.cerrada.append(self.abierta[n])
		del self.abierta[n]

	# Comprueba si un nodo está en una lista.
	def en_lista(self, nodo, lista):
		for i in range(len(lista)):
			if nodo.pos == lista[i].pos:
				return 1
		return 0

	# Gestiona los vecinos del nodo seleccionado.
	def ruta(self):
		for i in range(len(self.nodos)):
			if self.en_lista(self.nodos[i], self.cerrada):
				continue
			elif not self.en_lista(self.nodos[i], self.abierta):
				self.abierta.append(self.nodos[i])
			else:
				if self.select.g+1 < self.nodos[i].g:
					for j in range(len(self.abierta)):
						if self.nodos[i].pos == self.abierta[j].pos:
							del self.abierta[j]
							self.abierta.append(self.nodos[i])
							break

	# Analiza el último elemento de la lista cerrada.
	def buscar(self):
		self.f_menor()
		self.select = self.cerrada[-1]
		self.nodos = self.vecinos(self.select)
		self.ruta()

	# Comprueba si el objetivo objetivo está en la lista abierta.
	def objetivo(self):
		for i in range(len(self.abierta)):
			if self.fin.pos == self.abierta[i].pos:
				return 0
		return 1

	# Retorna una lista con las posiciones del camino a seguir.
	def camino(self):
		for i in range(len(self.abierta)):
			if self.fin.pos == self.abierta[i].pos:
				objetivo = self.abierta[i]

		camino = []
		while objetivo.padre != None:
			camino.append(objetivo.pos)
			objetivo = objetivo.padre
		camino.reverse()
		return camino

Si la estudias un poco puedes ver que sigue las directrices de la teoría, se crean las listas abierta y cerrada, se mete la posición inicial en la lista cerrada y sus vecinos a la abierta. A partir de aquí empieza un bucle que irá haciendo esto con cada uno de los vecinos, eligiendo siempre al de menor coste hasta que el Nodo objetivo sea añadido a la lista abierta, en este momento sale del bucle y llama al método camino. Que a partir del nodo objetivo añadido a la lista puede ir sacando su nodo padre hasta el que no tenga nodo padre que es el nodo inicial. Con esto tenemos un camino inverso entre el nodo objetivo y el nodo inicial.

Ahora si queréis probarlo basta con crear un objeto AEstrella pasandole nuestro mapa como parámetro e invocar a objeto.camino que es la variable que contiene la array con el camino. Si te resulta lioso no te preocupes te dejo el programa entero como va hasta ahora con algunas modificaciones para que muestre el camino a seguir.

• Descargar Pathfinding

Cualquier duda tienes los comentarios para preguntar, en el proximo tutorial haremos una interfaz gráfica en pygame que use el algoritmo.

Entradas relacionadas

• Pathfinding A* en Python. Parte III
• Pathfinding A* en Python. Parte I
• Usando Pilas Binarias en Pathfinding A*
• Pathfinding A* de 2 niveles
• Heurística para el Pathfinding A*

Esta técnica es muy usada en videojuegos de estrategia y en general en todos los videojuegos en donde se trata que la inteligencia artificial encuentre el camino más corto entre dos puntos. También es aplicable a la robótica para controlar los movimientos de un robot y que este supere obstáculos.

Antes de empezar es impresindible leer el artículo A* Pathfinding. Camino óptimo y entenderlo donde se explica el algoritmo, en este artículo usaré esas ideas para implementarlo en Python. He dividido el artículo en tres partes esta primera tratará de la creación de un entorno donde aplicar el algoritmo, la segunda parte es la creación del pathfinding en sí, el buscador del camino óptimo y por último en la tercera parte haré una interfaz gráfica en Pygame donde aplicarlo.

Creando un Mapa

Lo primero que necesitamos es un mapa donde probarlo. Para no complicarnos la vida usaremos un archivo de texto plano, un txt. A continuación un ejemplo:

# # # # # # # # # # # # # # # # #
# T . . . . . . . . . # . # . . #
# # # # # . # # # . . . . # . # #
# . . . . . . . . . # . . . . . #
# . # # # . # . # . # . # . # . #
# . # . # . # . # . # . # . # . #
# . # . # . # . # . . # # . # . #
# . # . . . # . # # . # . # . . #
# . . . # # # . . # . . . . . # #
# . . . . . . . # # . # # . . . #
# # # # . # . . . # . # . . # . #
# . . . . # . # . . . # # . # . #
# . # # . # . # . # . . . . . . #
# # # # # # # # # # # # # # # S #

He usado caracteres que faciliten visualmente el diseño del mapa, en este sencillo ejemplo hay 4 tipos de datos:

• Las almohadillas(#) – Representan los muros, son las zonas no atravesables.
• Los puntos(.) – Son los caminos, la zonas transitables por las que nos podemos mover.
• La T – Representa la posición inicial del jugador.
• La S – Representa el destino, el punto al que ha de llegar.

Con esto ya tenemos un mapa base en el que poder probar nuestro algorimo, lo guardamos en un archivo con el nombre mapa.txt y lo ponemos en el directorio de trabajo. Es hora de empezar con el código.

Leyendo el Mapa

Creamos el archivo principal del proyecto yo lo he llamado buscador.py, puedes llamorlo como quiera y he cargado mi plantilla base.

Lo primero que necesitamos es un método de leer el txt y convertirlo en algo que podamos manejar con Python. Yo lo he convertido en una lista bidimensional que contiene las filas y columnas del mapa y a cada tipo de carácter/bloque le he asignado un valor. Las siguientes tres funciones Hacen todo esto.

# Quita el ultimo caracter de una lista.
def quitarUltimo(lista):
	for i in range(len(lista)):
		lista[i] = lista[i][:-1]
	return lista

# Covierte una cadena en una lista.
def listarCadena(cadena):
	lista = []
	for i in range(len(cadena)):
		if cadena[i] == ".":
			lista.append(0)
		if cadena[i] == "#":
			lista.append(1)
		if cadena[i] == "T":
			lista.append(2)
		if cadena[i] == "S":
			lista.append(3)
	return lista

# Lee un archivo de texto y lo convierte en una lista.
def leerMapa(archivo):
	mapa = open(archivo, "r")
	mapa = mapa.readlines()
	mapa = quitarUltimo(mapa)
	for i in range(len(mapa)):
		mapa[i] = listarCadena(mapa[i])
	return mapa

Como puedes ver he asignado diferentes valores según el carácter quedando la relación así:

• Caminos – 0
• Paredes – 1
• Jugador – 2
• Salida – 3

La clase Mapa:

A continuación creamos una clase que represente el mapa, en principio solo va a tener dos métodos, el constructor y el str que nos servirá para probar que funciona correctamente, la clase es la siguiente:

class Mapa:
	def __init__(self, archivo="mapa.txt"):
		self.mapa = leerMapa(archivo)
		self.fil = len(self.mapa)
		self.col = len(self.mapa[0])

	def __str__(self):
		salida = ""
		for f in range(self.fil):
			for c in range(self.col):
				if self.mapa[f][c] == 0:
					salida += "."
				if self.mapa[f][c] == 1:
					salida += "# "
				if self.mapa[f][c] == 2:
					salida += "T "
				if self.mapa[f][c] == 3:
					salida += "S "
			salida += "\n"
		return salida

Como ves el constructor llama a la funcion leerMapa() que hicimos antes y también almacena el tamaño del mapa en filas y columnas. El método __str__ nos sirve para sustituir a print y ver una representación del mapa.

Por último creamos un mapa dentro de la función main() y lo imprimimos a ver como queda:

def main():
	mapa = Mapa()
	print mapa
	return 0

Con esto ya tenemos todo listo para aplicar el algoritmo pathfinding A* y encontrar el camino más corto entre T y S que veremos en el siguiente artículo.

Si algo no funciona o quieres probarlo directamente puedes descargarlo aquí.

Entradas relacionadas

• Pathfinding A* en Python. Parte III
• Usando Pilas Binarias en Pathfinding A*
• Pathfinding A* de 2 niveles
• Heurística para el Pathfinding A*
• Pathfinding A* en Python. Parte II

El nuevo diseño combina blancos y negros con un toque de azul que hace un constraste muy elegante. Otro cambio importante es en la tipografía, en esta nueva versión se usarán tipografías con serifas, que creo facilitan la lectura.

Como es normal cuando se modifica una web puede a ver fallos, si encuentras algo que este mal o que crees que quedaría mejor de otro manera, por fovor usa los comentarios y comunícamelo, me gustaría saber tu opinión.

Entradas relacionadas

• Repositorio en github para el Engine-RPG
• Futuro del Engine y los tutoriales
• Destacamos del foro
• Razón Artificial Crece
• ¿Una comunidad?

Este artículo no es específico de un lenguaje de programación, así que deberías ser capaz de adaptarlo a cualquier lenguaje ordenador. De todas maneras, pretendo facilitar el código escrito en Python para que lo puedas probar.

De acuerdo, empecemos.

Introducción: El Área de Búsqueda

Vamos a asumir que tenemos a alguien que quiere ir desde el punto A hasta el punto B. Asumamos también que un muro separa estos dos puntos. El ejemplo queda ilustrado en el gráfico siguiente, donde el recuadro verde es el punto de inicio A, el rojo es el punto de destino B y la zona azul el muro que hay entre ambos.

Lo primero que deberías advertir es que hemos dividido nuestro área de búsqueda en una rejilla cuadrada. Simplificar el área, tal y como hemos hecho, es el primer paso en un pathfinding. Este particular método reduce nuestro área de búsqueda a una simple matriz bidimensional. Cada elemento de la matriz representa uno de los cuadrados de la rejilla, y su estado se almacena como transitable o intransitable. El camino se elige calculando qué cuadros deberíamos pisar para ir desde A hasta B. Una vez que el camino haya sido encontrado, el personaje de nuestro juego (o lo que sea) se moverá desde el centro de un cuadrado hacia el centro del siguiente hasta que el objetivo haya sido alcanzado.

A esos puntos centrales se les llama “nodos”. Cuando leas en cualquier otro sitio sobre pathfinding, a menudo verás a gente hablando sobre nodos. ¿Acaso no es más fácil referirse a ellos como cuadrados? Esto se debe a que es posible dividir nuestro área en otras cosas aparte de cuadrados. Podrían ser rectangulares, hexagonales, o de cualquier otra forma; y podrían situarse en cualquier lugar dentro de esas formas – en el centro, por los bordes, o en cualquier lugar. Nosotros usamos este sistema porque es el más simple.

Iniciando la Búsqueda

Una vez que hemos simplificado nuestro área de búsqueda en un número de nodos asequible, tal y como hemos hecho con la rejilla de la figura anterior, el siguiente paso es dirigir una búsqueda para encontrar el camino más corto. En el pathfinding A*, lo hacemos empezando desde el punto A, comprobando los cuadros adyacentes y generalmente buscando hacia fuera hasta que encontremos nuestro destino.

Empezamos la búsqueda haciendo lo siguiente:

1) Empieza en el punto inicial A y añádelo a una “lista abierta” de cuadrados a tener en cuenta. La lista abierta es como una lista de la compra. Ahora mismo solo tenemos un elemento en la lista, pero más tarde tendremos más. La lista contiene los cuadrados que podrían formar parte del camino que queremos tomar, pero que quizás no lo hagan. Básicamente, esta es una lista de los cuadrados que necesitan ser comprobados.

2) Mira en todos los cuadrados alcanzables o transitables adyacentes al punto de inicio, ignorando cuadrados con muros, agua u otros terrenos prohibidos. Añádelos a la lista abierta también. Por cada uno de esos cuadrados, guarda el punto A como su “cuadrado padre”. El cuadrado padre es muy importante para trazar nuestro camino. Lo explicaré más tarde.

3) Saca el cuadro inicial A desde tu lista abierta y añádelo a una “lista cerrada” de cuadrados que no necesitan, por ahora, ser mirados de nuevo.

En este punto, deberías tener algo como la siguiente ilustración. En este diagrama, el cuadrado verde oscuro del centro es tu cuadrado de inicio. Esta bordeado el azul claro para indicar que el cuadrado ha sido añadido a la lista cerrada. Todos los cuadros adyacentes están ahora en la lista abierta para ser comprobados, están bordeados con verde claro. Cada uno tiene un puntero gris que señala a su padre, el cual es el cuadro inicial.

Después, elegimos uno de los cuadrados adyacentes de la lista abierta y más o menos repetimos el proceso anterior como se describe un poco más abajo. Pero, ¿cual cuadro debemos elegir? Aquel que tenga el coste F más bajo.

Puntuando el camino

La clave para determinar que cuadrados usaremos para resolver el camino está en la siguiente ecuación:

F = G + H

Donde:

• G = el coste de movimiento para ir desde el punto inicial A a un cierto cuadro de la rejilla, siguiendo el camino generado para llegar allí.
• H= el coste de movimiento estimado para ir desde ese cuadro de la rejilla hasta el destino final, el punto B. Esto es a menudo nombrado como la heurística, la cual puede ser un poco confusa. La razón por la cual es llamada así, se debe a que es una suposición. Realmente no sabemos la distancia actual hasta que encontramos el camino, ya que toda clase de cosas pueden estar en nuestro camino (muros, agua, etc.) En este tutorial, estás viendo una forma de calcular H, pero hay muchas otras que puedes encontrar en otros artículos de la red.

Nuestro camino se genera por ir repetidamente a través de nuestra lista abierta y eligiendo el cuadrado con la puntuación F más baja. Este proceso se describirá con más detalle un poco más adelante. Primero veamos más de cerca cómo calculamos la ecuación.

Tal y como está descrito más arriba, G es el coste de movimiento para ir desde el punto de inicio a un cierto cuadro usando el camino generado para llegar allí. En este ejemplo asignaremos un coste de 10 a cada cuadro vertical u horizontal hacia el que nos movamos, y un coste de 14 para un movimiento diagonal. Usamos estos números porque la distancia actual para mover diagonalmente es el cuadrado de la raíz de 2 ( no temas), o mas o menos 1,414 veces el coste del movimiento horizontal o vertical. Usamos 10 y 14 con el fin de simplificar. El rango es bastante bueno, y así nos libramos de tener que calcular raíces cuadradas y sus decimales. Esto no es solo porque seamos idiotas y no nos gusten las matemáticas; usar números enteros también es mucho más rápido para el ordenador. Pronto descubrirás que el pathfinding puede ser muy lento si no usas atajos como este.

Ahora que hemos calculado el coste G mediante un camino específico hasta cierto cuadrado, la forma de resolver el coste G del cuadrado es coger el coste G de su padre, y luego añadirle 10 o 14 dependiendo de si está en diagonal u ortogonal (no diagonal) con respecto a ese cuadro padre. Este método se hará más claro cuando llevemos este ejemplo un poco más allá y nos alejemos un cuadro del inicial.

H puede ser estimado de diferentes maneras. El método que hemos usado aquí se llama el método Manhattan, donde calculas el número total de cuadros movidos horizontalmente y verticalmente para alcanzar el cuadrado destino desde el cuadro actual, sin hacer uso de movimientos diagonales. Luego multiplicamos el total por 10. Se llama método Manhattan porque es como calcular el número de manzanas que hay desde un lugar a otro, donde no puedes acortar atravesando en diagonal una manzana. Cabe señalar que cuando calculamos H, ignoramos cualquier obstáculo que intervenga. Es una estimación de la distancia que queda, no de la distancia actual, es por eso que se llama heurística.

F se calcula sumando G y H. El resultado del primer paso en nuestra búsqueda puede ver se en la ilustración inferior. Las puntuaciones F, G y H están escritas en cada cuadrado. En el cuadro inmediatamente a la derecha de cuadro inicial, la F está impresa arriba a la izquierda, la G abajo a la izquierda y la H abajo la derecha.

Así pues, vamos a mirar algunos ejemplos de estos cuadros. En el cuadrado con letras, G =10. Esto es debido a que está solo a un cuadro del cuadrado inicial en dirección horizontal. Los cuadrados inmediatamente encima, abajo y a la izquierda del cuadrado inicial; tienen todos el mismo valor G de 10. Los cuadros diagonales tienen un valor G de 14.

Las puntuaciones H se calculan estimando la distancia Manhattan hasta el cuadrado rojo objetivo, moviéndose solo horizontal y verticalmente e ignorando el muro que está en el camino. Usando este método, el cuadro de la derecha del inicial, está a 3 cuadros del cuadrado rojo con una puntuación H de 30. El cuadrado está a solo 4 cuadros de distancia (recuerda que solo nos movemos en horizontal y vertical) con una puntuación H de 40. Probablemente comprendas como se calculan las puntuaciones H para los demás cuadros.

De nuevo, la puntuación F de cada cuadro se calcula simplemente sumando G y H.

Continuando la búsqueda

Para continuar la búsqueda, simplemente elegimos la puntuación F más baja de todos aquellos que estén en la lista abierta. Después hacemos lo siguiente con el cuadro seleccionado:

4) Sácalo de la lista abierta y añádelo a la lista cerrada.

5) Comprueba todos los cuadrados adyacentes, ignorando aquellos que estén en la lista cerrada o que sean intransitables terrenos con muros, agua, o cualquier terreno prohibido), añade los cuadros a la lista abierta si no están ya en esa lista. Haz al cuadro seleccionado el “padre” de los nuevos cuadros.

6) Si el cuadro adyacente ya está en la lista abierta, comprueba si el camino a ese cuadro es mejor que este. En otras palabras, comprueba que la G de ese cuadro sea más baja que la del que estamos usando para ir allí. Si no es así, no hagas nada. Por otro lado, si el coste G del nuevo camino es más bajo, cambia el padre del cuadro adyacente al cuadro seleccionado (en el diagrama superior, cambia la dirección del puntero para que señale al cuadro seleccionado). Finalmente, recalcula la F y la G de ese cuadrado. Si esto te parece confuso, podrás verlo ilustrado más abajo.

Ahora vamos a ver como funciona. De nuestros 9 cuadros iniciales, dejamos 8 en la lista abierta después de que el cuadrado inicial fuera incluido en la lista cerrada. De estos, el que tiene el coste F más bajo es el de inmediatamente a la derecha del cuadro inicial, con una F de 40. Así que seleccionamos este cuadrado como nuestro siguiente cuadrado. Está resaltado en azul en la siguiente ilustración.

Primero, lo sacamos de nuestra lista abierta y lo añadimos a nuestra lista cerrada (por que ahora está resaltado en azul). Luego comprobamos los cuadros adyacentes. Todos los que hay a la derecha son cuadros de muro, así que no los tenemos en cuenta. El de la izquierda es el cuadrado inicial; ese está en la lista cerrada, así que lo ignoramos también.

Los otros 4 cuadrados ya están en la lista abierta, así que necesitamos comprobar si alguno de los caminos hasta esos cuadros es mejor que el del cuadrado actual hasta ellos. Para eso usaremos la puntuación G como punto de referencia. Miremos debajo de nuestro cuadrado seleccionado; su G actual es 14. Si fuésemos a través del cuadro actual hasta allí, la G sería igual a 20 (10, la G del cuadro actual, más 10 de un movimiento vertical hacia el cuadro superior). Una G de 20 es mayor que una de 14, así que no es un buen camino. Todo eso debería cobrar sentido si miras el diagrama. Es más directo llegar a ese cuadro desde el cuadro inicial moviéndote un cuadro en diagonal, que moverte horizontalmente un cuadro y luego verticalmente otro.

Cuando repetimos este proceso para los otros 4 cuadros adyacentes que ya están en la lista abierta, descubrimos que ninguno de los caminos ha mejorado por ir a través del cuadro actual (el de la derecha bordeado de azul), así que pasamos de él. Ahora que hemos mirado en todos los cuadros adyacentes y ya nos hemos hecho con este nuevo cuadro, estamos listos para movernos al siguiente cuadrado.

Recorremos el grupo de cuadros de nuestra lista abierta, ahora ha bajado a 7 cuadrados, cogemos el que tenga el coste F más bajo. Interesante…, en este caso hay dos cuadros que tienen una puntuación de 54. Así que, ¿cual elegimos? La verdad es que no importa. Para propósitos de velocidad, puede ser más rápido elegir el último que añadimos a la lista abierta. Esto influencia a la búsqueda en favor de cuadros que fueron encontrados más tarde justo cuando estés más cerca de alcanzar tu objetivo. De todas formas no es verdaderamente importante.

Así pues, y ya que lo elegimos anteriormente, escogemos el cuadro justo debajo del cuadrado que desechamos antes. La siguiente ilustración lo aclara:

Esta vez, cuando comprobamos los cuadrados adyacentes encontramos que el de la izquierda y el superior a este son cuadros de muro así que los ignoramos. Tampoco tenemos en cuenta el cuadro que está debajo del muro. ¿Por qué? Porque no puedes llegar a ese cuadrado sin que tu personaje se raspe el hombro con la esquina al intentar pasar en diagonal; lo mejor es dar un pequeño rodeo, primero bajando y luego yendo hacia la derecha. (Nota: Esta regla de bordear esquinas es opcional. Su uso depende de como estén situados tus nodos.)

Eso nos deja otros 5 cuadros. Los otros 2 cuadros bajo el actual no están en la lista abierta así que los añadimos y el cuadro actual se convierte en su padre. De esos otros 3 cuadros, 2 ya están en la lista cerrada (el cuadro inicial, y el cuadro que hay encima del actual, ambos resaltados en azul en el diagrama) así que los ignoramos. El último cuadro, el de la izquierda del cuadro actual, se comprueba para ver si el coste G hasta él desde el cuadro actual, es menor que llegando directamente desde el cuadro inicial. Lo hacemos y no hay suerte, así que ya estamos listos para comprobar el siguiente cuadro de nuestra lista abierta.

Repetimos este proceso hasta que añadimos el cuadro objetivo a la lista abierta, en ese momento parecería algo como la ilustración inferior:

Observa que el cuadro padre para el cuadrado dos cuadros por debajo del cuadro inicial ha cambiado desde la ilustración anterior. Antes tenía un coste G de 28 y apuntaba al cuadrado encima suya y a la derecha. Ahora tiene una puntuación de 20 y apunta al cuadrado encima suya. Esto ocurrió en algún momento por la forma en la que se ejecuta nuestra búsqueda, donde la puntuación G fue comprobada y devuelta más baja usando un nuevo camino – el padre cambió y G y F fueron recalculadas. A pesar de que este cambio no parece demasiado importante en este ejemplo, hay muchas posibles situaciones donde este constante control significará la diferencia en la determinación del mejor camino hasta tu objetivo.

Pero, ¿cómo determinamos el camino actual en si mismo? Fácil, sólo empiezas desde el cuadro objetivo rojo, y vas hacia atrás de un cuadrado a su padre, siguiendo las flechas. Eso te llevará de vuelta al cuadrado inicial y tus movimientos serán el camino a seguir. Debería parecerse a la siguiente ilustración. Moverse desde el cuadro inicial A hasta el cuadro destino B es solo cuestión de ir moviéndose desde el centro de un cuadro (el nodo) al siguiente hasta alcanzar el objetivo. Sencillo!

Sumario del Método A*

Ahora que has leído la explicación, vamos a resumir el método paso a aso:

1. Añade el cuadro inicial a la lista abierta.
2. Repite lo siguiente:
   1. Busca el cuadro con el coste F más bajo en la lista abierta. Nos referimos a este como el cuadro actual.
   2. Cámbialo a la lista cerrada.
   3. Para cada uno de los 8 cuadros adyacentes al cuadro actual …
      • Si no es transitable o si está en la lista cerrada, ignóralo. En cualquier otro caso haz lo siguiente.
      • Si no está en la lista abierta, añádelo a la lista abierta. Haz que el cuadro actual sea el padre de este cuadro. Almacena los costes F, G y H del cuadro.
      • Si ya está en la lista abierta, comprueba si el camino para ese es mejor usando el coste G como baremo. Un coste G menor significa que este es un mejor camino. Si es así, cambia el padre del cuadrado al cuadro actual y recalcula G y F del cuadro. Si estás manteniendo la lista abierta por orden de puntuación F, podrías necesitar reordenar la lista para llevar cuenta del cambio.
   4. Para cuando:
      • añadas el cuadro objetivo a la lista abierta en cuyo caso el camino ha sido encontrado, o
      • falles en encontrar el cuadro objetivo y la lista abierta esté vacía. En este caso no hay camino.
3. Guarda el camino. Muévete hacia atrás desde el cuadro objetivo, ve desde cada cuadro a su padre hasta que alcances el cuadro inicial. El camino seguido es el que buscas.

Un poco de charlatanería

Perdóname por divagar pero es importante señalar que cuando leas varias discusiones sobre el pathfinding A* en la web y en diferentes foros, alguna vez verás que alguien se refiere a cierto código como A* cuando en realidad no lo es. Para el método A* necesitas incluir los elementos que hemos explicado arriba – específicamente listas cerradas y abiertas y puntuación del camino usando F,G y H. Hay muchos otros algoritmos de pathfinding, pero esos otros métodos no son A*, el cual es generalmente considerado como el mejor. Bryan Stout habla sobre muchos de ellos en el artículo al que se hace referencia al final de este, incluyendo algunos de sus pros y contras. Algunas veces las alternativas son mejores bajo determinadas circunstancias, pero deberías comprender en lo que te estás metiendo. Bueno, suficiente rollo por hoy, volvamos al artículo.

Traducido por Elthan, con el permiso de Patrick Lester.

Entradas relacionadas

• Usando Pilas Binarias en Pathfinding A*
• Pathfinding A* de 2 niveles
• Heurística para el Pathfinding A*
• Pathfinding A* en Python. Parte III
• Pathfinding A* en Python. Parte II

Cargando tipografías

Pygame puede cargar las tipografías del sistema en el que se está ejecutando y si no la encuentra cargar la tipografía por defecto, yo prefiero proporcionar incluir mi propia fuente en el juego y así me aseguro de que todo se ve como quiero.

Para este juego usaré la tipografía DroidSans.ttf descargarla y meterla en la carpeta images. No es una imagen propiamente dicha, pero para una sola fuente no voy a crear una carpeta llamada fonts.

Hay que tener en cuenta cuando se trabaja con textos en Pygame es que este a última instancia trata a todos los textos como Sprites, una vez puesto se pueden manipular como si de una Sprite más se tratara, esto tiene muchas ventajas como veremos.

Lo primero que vamos a hacer es crear una función que nos facilite el trabajar con textos y nos automatice el proceso.

def texto(texto, posx, posy, color=(255, 255, 255)):
	fuente = pygame.font.Font("images/DroidSans.ttf", 25)
	salida = pygame.font.Font.render(fuente, texto, 1, color)
	salida_rect = salida.get_rect()
	salida_rect.centerx = posx
	salida_rect.centery = posy
	return salida, salida_rect

En la línea 1 creamos la función, vemos que recibe 4 parámetros: texto que debe ser una string, posx y posy que serán las coordenadas del centro de nuestro texto y color que es una tupla con los valores RGB, color es opcional y si no se define, por defecto será blanco.

La línea 2 asigna una tipografía a la variable fuente como vemos lo hacemos con pygame.font.Font() al que le pasamos como primer parámetro la ruta de la tipografía que queremos usar y como segundo el tamaño de la tipografía.

En la linea 3 creamos la variable salida asignandole pygame.font.Font.render() este método lo que hace es convertir un texto en un Sprite, como vemos como primer parámetro recibe una fuente tipográfica, le pasamos la creada en la línea anterior, como segundo recibe el texto a mostrar, el tercer parámetro es el antialias y puede ser verdadero o falso (con o sin antialias), por último recibe el color.

En la línea 4 obtenemos el rect como si de un Sprite más se tratare y lo almacenamos en salida_rect.

Las líneas 5 y 6 modifican el centro del Sprite en función de los valores posx y posy.

Por último la línea 7 retorna una tupla con el Sprite y su correspondiente rect. Ojo a la ahora de utlizarla, recordad que retorna dos valores y no uno.

Con esta función poner texto es muy fácil, vamos a utilizarla para mostrar nuestras puntuaciones, añadimos las siguientes líneas en el bucle del juego:

p_jug, p_jug_rect = texto(str(puntos[0]), WIDTH/4, 40)
p_cpu, p_cpu_rect = texto(str(puntos[1]), WIDTH-WIDTH/4, 40)

Esto nos crea dos Sprites con sus respectivos rects. El primero recibe como texto puntos[0], es decir los puntos del jugador (ojo con la conversión str(), recodad que debe de ser una string), como parámetro posx recibe WIDTH/4 es decir la WIDTH/2/2 que es la mitad de la mitad de la pantalla (para centrarlo en el campo del jugador) y como parámetro posy he situado a 40px del norde superior.

El otro Sprite exactamente lo mismo, pero para los puntos de la CPU y centrado en el campo de la CPU el posx (WIDTH-WIDTH/4).

por último solo debemos actualizarlo en pantalla como hacemos siempre.

screen.blit(p_jug, p_jug_rect)
screen.blit(p_cpu, p_cpu_rect)

Yo recomiendo ponerlas justo después del blit del fondo, porque si los ponemos al final la pelota pasara por “debajo” de los marcadores y eso queda algo feo.

El juego nos queda de la siguiente manera:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

class Bola(pygame.sprite.Sprite):
	def __init__(self):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/ball.png", True)
		self.rect = self.image.get_rect()
		self.rect.centerx = WIDTH / 2
		self.rect.centery = HEIGHT / 2
		self.speed = [0.5, -0.5]

	def actualizar(self, time, pala_jug, pala_cpu, puntos):
		self.rect.centerx += self.speed[0] * time
		self.rect.centery += self.speed[1] * time

		if self.rect.left <= 0:
			puntos[1] += 1
		if self.rect.right >= WIDTH:
			puntos[0] += 1

		if self.rect.left <= 0 or self.rect.right >= WIDTH:
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time
		if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
			self.speed[1] = -self.speed[1]
			self.rect.centery += self.speed[1] * time

		if pygame.sprite.collide_rect(self, pala_jug):
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time

		if pygame.sprite.collide_rect(self, pala_cpu):
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time

		return puntos

class Pala(pygame.sprite.Sprite):
	def __init__(self, x):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/pala.png")
		self.rect = self.image.get_rect()
		self.rect.centerx = x
		self.rect.centery = HEIGHT / 2
		self.speed = 0.5

	def mover(self, time, keys):
		if self.rect.top >= 0:
			if keys[K_UP]:
				self.rect.centery -= self.speed * time
		if self.rect.bottom <= HEIGHT:
			if keys[K_DOWN]:
				self.rect.centery += self.speed * time

	def ia(self, time, ball):
		if ball.speed[0] >= 0 and ball.rect.centerx >= WIDTH/2:
			if self.rect.centery < ball.rect.centery:
				self.rect.centery += self.speed * time
			if self.rect.centery > ball.rect.centery:
				self.rect.centery -= self.speed * time

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

def load_image(filename, transparent=False):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at((0,0))
                image.set_colorkey(color, RLEACCEL)
        return image

def texto(texto, posx, posy, color=(255, 255, 255)):
	fuente = pygame.font.Font("images/DroidSans.ttf", 25)
	salida = pygame.font.Font.render(fuente, texto, 1, color)
	salida_rect = salida.get_rect()
	salida_rect.centerx = posx
	salida_rect.centery = posy
	return salida, salida_rect

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")

	background_image = load_image('images/fondo_pong.png')
	bola = Bola()
	pala_jug = Pala(30)
	pala_cpu = Pala(WIDTH - 30)

	clock = pygame.time.Clock()

	puntos = [0, 0]

	while True:
		time = clock.tick(60)
		keys = pygame.key.get_pressed()
		for eventos in pygame.event.get():
			if eventos.type == QUIT:
				sys.exit(0)

		puntos = bola.actualizar(time, pala_jug, pala_cpu, puntos)
		pala_jug.mover(time, keys)
		pala_cpu.ia(time, bola)

		p_jug, p_jug_rect = texto(str(puntos[0]), WIDTH/4, 40)
		p_cpu, p_cpu_rect = texto(str(puntos[1]), WIDTH-WIDTH/4, 40)

		screen.blit(background_image, (0, 0))
		screen.blit(p_jug, p_jug_rect)
		screen.blit(p_cpu, p_cpu_rect)
		screen.blit(bola.image, bola.rect)
		screen.blit(pala_jug.image, pala_jug.rect)
		screen.blit(pala_cpu.image, pala_cpu.rect)
		pygame.display.flip()
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Ya tenemos nuestros marcadores, pero el juego ni se inmuta cuando marcas un punto, lo solucionaremos en próximas entregas.

Entradas relacionadas

• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Engine I: Preparándonos para trabajar
• Pygame IX: Sistema de puntuación
• Pygame VIII: Inteligencia artificial

Creando un sistema de puntuación

Lo primero es crear un sistema que controle los puntos, es decir, comprobar si la bola traspasa las palas y toca el borde de la ventana que tiene detrás. Esto lo controlará como siempre la bola y su método actualizar.

def update(self, time, pala_jug, pala_cpu, puntos):
	self.rect.centerx += self.speed[0] * time
	self.rect.centery += self.speed[1] * time

	if self.rect.left <= 0:
		puntos[1] += 1
	if self.rect.right >= WIDTH:
		puntos[0] += 1

	if self.rect.left <= 0 or self.rect.right >= WIDTH:
		self.speed[0] = -self.speed[0]
		self.rect.centerx += self.speed[0] * time
	if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
		self.speed[1] = -self.speed[1]
		self.rect.centery += self.speed[1] * time

	if pygame.sprite.collide_rect(self, pala_jug):
		self.speed[0] = -self.speed[0]
		self.rect.centerx += self.speed[0] * time

	if pygame.sprite.collide_rect(self, pala_cpu):
		self.speed[0] = -self.speed[0]
		self.rect.centerx += self.speed[0] * time

	return puntos

Como vemos le añadimos un nuevo parámetro llamado puntos, puntos es una lista que contiene los puntos de los dos jugadores en el el puntos[0] los puntos del jugador y en el puntos[1] los puntos de la cpu.

Luego añadimos las líneas de la 5 a la 8 que controlan si la parte izquierda de la pelota (línea 5) toca el el borde izquierdo de la ventana en cuyo caso aumenta puntos[1] (el marcador de la cpu) en 1 (línea 6). La líneas 7 y 8 hacen lo mismo, pero a la inversa.

Por último al final del método se retorna puntos, necesario para almacenarla en una variable.

Ahora debemos crear la lista puntos en nuestra función principal, yo la he creado justo antes de entrar en el bucle del juego:

puntos = [0, 0]

Ahora tenemos que modificar la llamada a bola.actualizar dentro del bucle del juego para pasarle nuestra lista puntos y recuperarla de nuevo con los posibles nuevos valores.

puntos = bola.actualizar(time, pala_jug, pala_cpu, puntos)

Por lo que el código nos queda así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

class Bola(pygame.sprite.Sprite):
	def __init__(self):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/ball.png", True)
		self.rect = self.image.get_rect()
		self.rect.centerx = WIDTH / 2
		self.rect.centery = HEIGHT / 2
		self.speed = [0.5, -0.5]

	def actualizar(self, time, pala_jug, pala_cpu, puntos):
		self.rect.centerx += self.speed[0] * time
		self.rect.centery += self.speed[1] * time

		if self.rect.left <= 0:
			puntos[1] += 1
		if self.rect.right >= WIDTH:
			puntos[0] += 1

		if self.rect.left <= 0 or self.rect.right >= WIDTH:
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time
		if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
			self.speed[1] = -self.speed[1]
			self.rect.centery += self.speed[1] * time

		if pygame.sprite.collide_rect(self, pala_jug):
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time

		if pygame.sprite.collide_rect(self, pala_cpu):
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time

		return puntos

class Pala(pygame.sprite.Sprite):
	def __init__(self, x):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/pala.png")
		self.rect = self.image.get_rect()
		self.rect.centerx = x
		self.rect.centery = HEIGHT / 2
		self.speed = 0.5

	def mover(self, time, keys):
		if self.rect.top >= 0:
			if keys[K_UP]:
				self.rect.centery -= self.speed * time
		if self.rect.bottom <= HEIGHT:
			if keys[K_DOWN]:
				self.rect.centery += self.speed * time

	def ia(self, time, ball):
		if ball.speed[0] >= 0 and ball.rect.centerx >= WIDTH/2:
			if self.rect.centery < ball.rect.centery:
				self.rect.centery += self.speed * time
			if self.rect.centery > ball.rect.centery:
				self.rect.centery -= self.speed * time

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

def load_image(filename, transparent=False):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at((0,0))
                image.set_colorkey(color, RLEACCEL)
        return image

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")

	background_image = load_image('images/fondo_pong.png')
	bola = Bola()
	pala_jug = Pala(30)
	pala_cpu = Pala(WIDTH - 30)

	clock = pygame.time.Clock()

	puntos = [0, 0]

	while True:
		time = clock.tick(60)
		keys = pygame.key.get_pressed()
		for eventos in pygame.event.get():
			if eventos.type == QUIT:
				sys.exit(0)

		puntos = bola.actualizar(time, pala_jug, pala_cpu, puntos)
		pala_jug.mover(time, keys)
		pala_cpu.ia(time, bola)
		screen.blit(background_image, (0, 0))
		screen.blit(bola.image, bola.rect)
		screen.blit(pala_jug.image, pala_jug.rect)
		screen.blit(pala_cpu.image, pala_cpu.rect)
		pygame.display.flip()
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Esto como vemos no hace “nada” en el juego, ahora tenemos que buscar la manera de mostrar los puntos en nuestro juego. En el próximo tutorial trataremos con Fuentes tipográficas.

Entradas relacionadas

• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Engine I: Preparándonos para trabajar
• Pygame X: Fuentes tipográficas
• Pygame VIII: Inteligencia artificial

Creando la pala de la CPU

Esto se hace igual que como creamos la pala_jug o la bola, ponemos la siguiente línea en la función principal debajo de pala_jug.

pala_cpu = Pala(WIDTH - 30)

En su momento pala_jug le pasamos como parámetro el valor 30 que quería decir que el centerx estaba a 30 píxeles de el borde izquierdo, ahora le pasamos WIDTH – 30, es decir a 30 píxeles del borde derecho.

También debemos añadir la línea:

screen.blit(pala_cpu.image, pala_cpu.rect)

En el bucle principal, debajo de los demas blit, como siempre. Con esto ya tenemos nuestro Sprite puesto en pantalla.

Ahora vamos a hacer que detecte también las colisiones, para ello volvemos a actualizar el método actualizar de la clase Bola:

def actualizar(self, time, pala_jug, pala_cpu):
	self.rect.centerx += self.speed[0] * time
	self.rect.centery += self.speed[1] * time
	if self.rect.left <= 0 or self.rect.right >= WIDTH:
		self.speed[0] = -self.speed[0]
		self.rect.centerx += self.speed[0] * time
	if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
		self.speed[1] = -self.speed[1]
		self.rect.centery += self.speed[1] * time

	if pygame.sprite.collide_rect(self, pala_jug):
		self.speed[0] = -self.speed[0]
		self.rect.centerx += self.speed[0] * time

	if pygame.sprite.collide_rect(self, pala_cpu):
		self.speed[0] = -self.speed[0]
		self.rect.centerx += self.speed[0] * time

Como podemos ver añadimos otro párametro al método pala_cpu que servirá para añadirle el Sprite pala_cpu como hicimos con pala_jug y añadimos las tres últimas líneas que son idénticas a las anteriores salvo que ahora para pala_cpu.

Recordad pasarle el parametro nuevo a la línea que llama a la función actualizar de la bola en el bucle del juego. Así:

ball.update(time, pala_jug, pala_cpu)

Dotando de Inteligencia Artificial a la Pala

Bueno ahora viene lo interesante, lograr que la pala se mueva para golpear la bola, esto se hace definiendo otro método en la clase Pala al método lo llamaré ia.

def ia(self, time, ball):
	if ball.speed[0] >= 0 and ball.rect.centerx >= WIDTH/2:
		if self.rect.centery < ball.rect.centery:
			self.rect.centery += self.speed * time
		if self.rect.centery > ball.rect.centery:
			self.rect.centery -= self.speed * time

En la línea 1 vemos que recibe como siempre self y time y aparte recibe ball que es la bola, es necesario pues el método necesita conocer donde está la bola.

En la línea 2 comprobamos que ball.speed[0] >= 0, es decir, que la velocidad en el eje x de la pelota sea positiva, es decir, que la pelota se este moviendo hacia la derecha (hacia la pala de la cpu) y tambien comprueba que ball.rect.centerx >= WIDTH/2 es decir que el centro x de la pelota sea mayor o igual que el centro del tablero, es decir, que la pelota este en el campo de la cpu.

Por tanto la línea 2 es un condicional que comprueba que la pelota vaya hacia donde está la pala de la cpu y que este en su campo, sino, que no se mueva. Esto se hace para que la CPU no sea invencible y no llegue a todas las pelotas.

La línea 3 comprueba si el centery de la pelota es menor que el centery de la bola, es decir si la pala está más arriba que que la pelota en cullo caso, ejecuta la línea 4 que mueve la pala de la cpu hacia abajo.

Las líneas 5 y 6 hacen lo mismo, pero a la inversa como se ve a simple vista.

Ahora solo nos queda llamar a la ia junto con las llamadas actualizar de la bola y mover de la pala_cpu.

pala_cpu.ia(time, bola)

El código nos queda de la siguiente manera:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

class Bola(pygame.sprite.Sprite):
	def __init__(self):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/ball.png", True)
		self.rect = self.image.get_rect()
		self.rect.centerx = WIDTH / 2
		self.rect.centery = HEIGHT / 2
		self.speed = [0.5, -0.5]

	def actualizar(self, time, pala_jug, pala_cpu):
		self.rect.centerx += self.speed[0] * time
		self.rect.centery += self.speed[1] * time
		if self.rect.left <= 0 or self.rect.right >= WIDTH:
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time
		if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
			self.speed[1] = -self.speed[1]
			self.rect.centery += self.speed[1] * time

		if pygame.sprite.collide_rect(self, pala_jug):
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time

		if pygame.sprite.collide_rect(self, pala_cpu):
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time

class Pala(pygame.sprite.Sprite):
	def __init__(self, x):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/pala.png")
		self.rect = self.image.get_rect()
		self.rect.centerx = x
		self.rect.centery = HEIGHT / 2
		self.speed = 0.5

	def mover(self, time, keys):
		if self.rect.top >= 0:
			if keys[K_UP]:
				self.rect.centery -= self.speed * time
		if self.rect.bottom <= HEIGHT:
			if keys[K_DOWN]:
				self.rect.centery += self.speed * time

	def ia(self, time, ball):
		if ball.speed[0] >= 0 and ball.rect.centerx >= WIDTH/2:
			if self.rect.centery < ball.rect.centery:
				self.rect.centery += self.speed * time
			if self.rect.centery > ball.rect.centery:
				self.rect.centery -= self.speed * time

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

def load_image(filename, transparent=False):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at((0,0))
                image.set_colorkey(color, RLEACCEL)
        return image

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")

	background_image = load_image('images/fondo_pong.png')
	bola = Bola()
	pala_jug = Pala(30)
	pala_cpu = Pala(WIDTH - 30)

	clock = pygame.time.Clock()

	while True:
		time = clock.tick(60)
		keys = pygame.key.get_pressed()
		for eventos in pygame.event.get():
			if eventos.type == QUIT:
				sys.exit(0)

		bola.actualizar(time, pala_jug, pala_cpu)
		pala_jug.mover(time, keys)
		pala_cpu.ia(time, bola)
		screen.blit(background_image, (0, 0))
		screen.blit(bola.image, bola.rect)
		screen.blit(pala_jug.image, pala_jug.rect)
		screen.blit(pala_cpu.image, pala_cpu.rect)
		pygame.display.flip()
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Ahora el juego es jugable, pero no tiene ni sistema de puntuación, ni sonidos ni nada de nada. Lo solucionaremos en los próximos tutoriales.

Entradas relacionadas

• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Engine I: Preparándonos para trabajar
• Pygame X: Fuentes tipográficas
• Pygame IX: Sistema de puntuación

Actualizando el método actualizar de la clase Bola

Saber si un Sprite colisiona con otro es muy fácil en Python, basta con ejecutar el siguiente método:

pygame.sprite.collide_rect(objeto1, objeto2)

Esto comprueba si el rectángulo del Sprite objeto1 está en contacto con el rectángulo de objeto2, por lo que es tan fácil como mejorar el método actualizar de la clase Bola para que lo tenga en cuenta:

def actualizar(self, time, pala_jug):
	self.rect.centerx += self.speed[0] * time
	self.rect.centery += self.speed[1] * time
	if self.rect.left <= 0 or self.rect.right >= WIDTH:
		self.speed[0] = -self.speed[0]
		self.rect.centerx += self.speed[0] * time
	if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
		self.speed[1] = -self.speed[1]
		self.rect.centery += self.speed[1] * time

	if pygame.sprite.collide_rect(self, pala_jug):
		self.speed[0] = -self.speed[0]
		self.rect.centerx += self.speed[0] * time

Como vemos todo igual, salvo que ahora recibe un parámetro más que es pala_jug por el que pasaremos el Sprite con el que queremos comprobar si colisiona, en este caso pala_jug.

Luego al final añadimos 3 líneas con un nuevo condicional con el que comprobamos si la pelota choca contra la pala, en caso afirmativo cambiamos la dirección de la bola como cuando choca con el borde izquierdo de la ventana.

Por último solo actualizamos la llamada a la función actualizar que hacemos desde el bucle para pasarle la pala_jug.

bola.actualizar(time, pala_jug)

Y con esto ya hemos logrado que nuestra bola detecte si ha chocado contra la pala del jugador en caso afirmativo “rebota”.

Asi nos queda el código:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

class Bola(pygame.sprite.Sprite):
	def __init__(self):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/ball.png", True)
		self.rect = self.image.get_rect()
		self.rect.centerx = WIDTH / 2
		self.rect.centery = HEIGHT / 2
		self.speed = [0.5, -0.5]

	def actualizar(self, time, pala_jug):
		self.rect.centerx += self.speed[0] * time
		self.rect.centery += self.speed[1] * time
		if self.rect.left <= 0 or self.rect.right >= WIDTH:
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time
		if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
			self.speed[1] = -self.speed[1]
			self.rect.centery += self.speed[1] * time

		if pygame.sprite.collide_rect(self, pala_jug):
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time

class Pala(pygame.sprite.Sprite):
	def __init__(self, x):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/pala.png")
		self.rect = self.image.get_rect()
		self.rect.centerx = x
		self.rect.centery = HEIGHT / 2
		self.speed = 0.5

	def mover(self, time, keys):
		if self.rect.top >= 0:
			if keys[K_UP]:
				self.rect.centery -= self.speed * time
		if self.rect.bottom <= HEIGHT:
			if keys[K_DOWN]:
				self.rect.centery += self.speed * time

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

def load_image(filename, transparent=False):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at((0,0))
                image.set_colorkey(color, RLEACCEL)
        return image

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")

	background_image = load_image('images/fondo_pong.png')
	bola = Bola()
	pala_jug = Pala(30)

	clock = pygame.time.Clock()

	while True:
		time = clock.tick(60)
		keys = pygame.key.get_pressed()
		for eventos in pygame.event.get():
			if eventos.type == QUIT:
				sys.exit(0)

		bola.actualizar(time, pala_jug)
		pala_jug.mover(time, keys)
		screen.blit(background_image, (0, 0))
		screen.blit(bola.image, bola.rect)
		screen.blit(pala_jug.image, pala_jug.rect)
		pygame.display.flip()
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

En el siguiente tutorial crearemos la pala del jugador de la CPU y la dotaremos de Inteligencia Artificial para que golpee la pelota.

Entradas relacionadas

• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Engine I: Preparándonos para trabajar
• Pygame X: Fuentes tipográficas
• Pygame IX: Sistema de puntuación

Creando el Sprite Pala

Lo primero que necesitamos es una imagen que la represente, descargarla aquí y como siempre, al directorio images. Como ves la pala no es más que un rectángulo blanco, no es cuestión de complicarse.

La clase Pala es casi idéntica a la clase Bola, salvo por unos pequeños cambios:

class Pala(pygame.sprite.Sprite):
	def __init__(self, x):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/pala.png")
		self.rect = self.image.get_rect()
		self.rect.centerx = x
		self.rect.centery = HEIGHT / 2
		self.speed = 0.5

Como vemos es idéntica salvo que ahora le pasamos el parámetro x para usarlo en self.rect.centerx, esto es debido a que necesitamos dos palas una en la parte izquierda y otra en la derecha, con el parámetro x definimos a que altura del eje x queremos colocar el Sprite.

Otro cambio es la velocidad, como la pala del Pong solo se mueve en el eje y no definimos velocidad para el eje x.

para crear la pala del jugador ya sabéis, debajo de donde habéis creado la bola ponéis la siguiente línea:

pala_jug = Pala(30)

La llamo pala_jug porque habrá otra que será la pala_cpu que será la que maneje el ordenador. Como ves le paso como valor de x = 30, esto quiere decir que centerx estará a 30 px del borde derecho de la ventana.

Por último dentro del bucle lo de siempre, despues de actualizar el fondo y la bola actualizamos la pala:

screen.blit(pala_jug.image, pala_jug.rect)

Moviendo la pala

Para mover la pala definimos el método mover dentro de la clase Pala:

def mover(self, time, keys):
	if self.rect.top >= 0:
		if keys[K_UP]:
			self.rect.centery -= self.speed * time
	if self.rect.bottom <= HEIGHT:
		if keys[K_DOWN]:
			self.rect.centery += self.speed * time

Recibe los parámetros self y time como el método actualizar de la bola y además recibe el parámetro keys que luego definiremos y que es una lista con el valor booleano de las teclas pulsadas.

La línea 2 y 5 comprueban que la parte superior (en el caso de la linea 2) de la pala sea mayor o igual a 0 y que la parte inferior de la pala (línea 5) sea menor o igual que que la altura de la ventana. Resumiendo comprueban que la pala no se sale de la ventana.

La línea 3 comprueba si la constante K_UP de keys es 1, lo que querría decir que tenemos presionada la tecla de la flecha hacia arriba del teclado.

La línea 5 en caso de tener la tecla presionada disminuye el valor de centery haciendo que la pala se mueva hacia arriba.

La línea 6 y 7 hacen lo mismo, pero para abajo y aumentando el valor de centery.

Ahora solo debemos saber que teclas se están pulsando creando la variable keys, esto se consigue añadiendo la siguiente línea en el bucle principal, justo despues de comprobar el tiempo transcurrido con time.

keys = pygame.key.get_pressed()

Esto nos devuelve las teclas pulsadas en una lista como explicamos arriba.

Por ultimo debemos llamar al método mover en el bucle justo después de actualizar la bola, con la línea:

pala_jug.mover(time, keys)

El código nos queda así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

class Bola(pygame.sprite.Sprite):
	def __init__(self):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/ball.png", True)
		self.rect = self.image.get_rect()
		self.rect.centerx = WIDTH / 2
		self.rect.centery = HEIGHT / 2
		self.speed = [0.5, -0.5]

	def actualizar(self, time):
		self.rect.centerx += self.speed[0] * time
		self.rect.centery += self.speed[1] * time
		if self.rect.left <= 0 or self.rect.right >= WIDTH:
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time
		if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
			self.speed[1] = -self.speed[1]
			self.rect.centery += self.speed[1] * time

class Pala(pygame.sprite.Sprite):
	def __init__(self, x):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/pala.png")
		self.rect = self.image.get_rect()
		self.rect.centerx = x
		self.rect.centery = HEIGHT / 2
		self.speed = 0.5

	def mover(self, time, keys):
		if self.rect.top >= 0:
			if keys[K_UP]:
				self.rect.centery -= self.speed * time
		if self.rect.bottom <= HEIGHT:
			if keys[K_DOWN]:
				self.rect.centery += self.speed * time

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

def load_image(filename, transparent=False):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at((0,0))
                image.set_colorkey(color, RLEACCEL)
        return image

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")

	background_image = load_image('images/fondo_pong.png')
	bola = Bola()
	pala_jug = Pala(30)

	clock = pygame.time.Clock()

	while True:
		time = clock.tick(60)
		keys = pygame.key.get_pressed()
		for eventos in pygame.event.get():
			if eventos.type == QUIT:
				sys.exit(0)

		bola.actualizar(time)
		pala_jug.mover(time, keys)
		screen.blit(background_image, (0, 0))
		screen.blit(bola.image, bola.rect)
		screen.blit(pala_jug.image, pala_jug.rect)
		pygame.display.flip()
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Ya tenemos nuestra pala que podemos controlar con el teclado, pero la bola como vemos para olímpicamente de ella y la atraviesa. En el siguiente tutorial aprenderemos a crear colisiones entre Sprites

Entradas relacionadas

• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Engine I: Preparándonos para trabajar
• Pygame X: Fuentes tipográficas
• Pygame IX: Sistema de puntuación

El método actualizar

Para mover la pelota crearemos un metodo llamado actualizar dentro de la clase Bola que controle el movimiento de la pelota y si choca contra los bordes de la ventana, el método es el siguiente:

def actualizar(self, time):
	self.rect.centerx += self.speed[0] * time
	self.rect.centery += self.speed[1] * time
	if self.rect.left <= 0 or self.rect.right >= WIDTH:
		self.speed[0] = -self.speed[0]
		self.rect.centerx += self.speed[0] * time
	if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
		self.speed[1] = -self.speed[1]
		self.rect.centery += self.speed[1] * time

La linea 1 define el método, recibe el parámetro self (como siempre) y el parámetro time que es el tiempo transcurrido, más adelante lo explicamos.

La línea 2 y 3 usa la física básica de espacio es igual a la velocidad por el tiempo (e = v*t), por tanto establecemos que el centro de nuestro rectangulo en x es el valor que tenía (self.rect.centerx) más (+=) la valocidad a la que se mueve en el eje x (self.speed[0]) por (*) el tiempo transcurrido (time). Lo mismo se aplica al eje y en la línea 3.

La linea 4, 5 y 6 establece que si la parte izquierda del rectángulo de la bola es menor o igual a 0 ó mayor o igual a el ancho de la pantalla (WIDTH), es decir,  que este en el extremo izquierdo o derecho, la velocidad de x (self.speed[0]) cambie de signo (-self.speed[0]) con esto conseguiremos que vaya hacia el otro lado.

Las líneas 7, 8 y 9 es lo mismo pero en el eje y como se puede ver.

Creando un reloj

Ahora vamos a crear un reloj que controle el tiempo del juego, esto es importante para el movimiento, pues sabemos cuanto tiempo a pasado desde la ultima actualización de la pelota y con ello poder situarla en el espacio.

clock = pygame.time.Clock()

Esta línea va justo antes de entrar en el bucle del juego y sirve para crear el reloj con el que gestionar el tiempo.

Ahora necesitamos saber cuanto tiempo pasa cada vez que se ejecuta una interección del bucle, para ello dentro del bucle ponemos como primera línea:

time = clock.tick(60)

El 60 que se le pasa como parámetro es el framerate, con él nos aseguramos de que el juego no va a más de la velocidad estipulada. Con ello conseguimos que el juego corra igual en todos los ordenadores. Aquí más inftomación.

Por último debemos actualizar la posición de la bola antes de actualizarla en la ventana, es decir antes de los screen.blit.

bola.actualizar(time)

Como ves le pasamos el parametro time que es el tiempo que ha pasado desde la última vez que se ejecuto.

El juego queda así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

class Bola(pygame.sprite.Sprite):
	def __init__(self):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/ball.png", True)
		self.rect = self.image.get_rect()
		self.rect.centerx = WIDTH / 2
		self.rect.centery = HEIGHT / 2
		self.speed = [0.5, -0.5]

	def actualizar(self, time):
		self.rect.centerx += self.speed[0] * time
		self.rect.centery += self.speed[1] * time
		if self.rect.left <= 0 or self.rect.right >= WIDTH:
			self.speed[0] = -self.speed[0]
			self.rect.centerx += self.speed[0] * time
		if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
			self.speed[1] = -self.speed[1]
			self.rect.centery += self.speed[1] * time

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

def load_image(filename, transparent=False):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at((0,0))
                image.set_colorkey(color, RLEACCEL)
        return image

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")

	background_image = load_image('images/fondo_pong.png')
	bola = Bola()

	clock = pygame.time.Clock()

	while True:
		time = clock.tick(60)
		for eventos in pygame.event.get():
			if eventos.type == QUIT:
				sys.exit(0)

		bola.actualizar(time)
		screen.blit(background_image, (0, 0))
		screen.blit(bola.image, bola.rect)
		pygame.display.flip()
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Ya nuestra pelota se mueve y rebota contra las paredes. En el próximo tutorial crearemos el Sprite pala y aprenderemos a moverlo con el teclado.

Entradas relacionadas

• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Engine I: Preparándonos para trabajar
• Pygame X: Fuentes tipográficas
• Pygame IX: Sistema de puntuación

Ahora empieza lo divertido, vamos a crear nuestro primer juego, y como no será un clon del clásico Pong. Lo primero que necesitamos es hacer una copia de nuestra plantilla creada en los anteriores tutoriales y guardarla con el nombre pong.py que será sobre el archivo que trabajaremos. Lo primero que haremos será descargar este fondo, mucho más apropiado y guardarlo en la carpeta images de nuestro directorio base.

Recordad cambiar el nombre de la imagen en el programa.

background_image = load_image('images/fondo_pong.png')

La clase Bola

Para crear la pelota de nuestro Pong lo primero que necesitamos es la imagen de la pelota, descargar esta y guardarla como siempre en el directorio images.

Ahora vamos a crear una clase para la pelota, que será el Sprite de nuestra pelota, un Sprite es más que una imagen, es una superficie que puede interactuar, moverse y demás.

class Bola(pygame.sprite.Sprite):
	def __init__(self):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/ball.png", True)
		self.rect = self.image.get_rect()
		self.rect.centerx = WIDTH / 2
		self.rect.centery = HEIGHT / 2
		self.speed = [0.5, -0.5]

La línea 1 crea la clase Bola que hereda los métodos de la clase pygame.sprite.Sprite, esto es muy importante debido a que contiene métodos necesarios para el manejo de Sprites.

La línea 2 crea el método __init__ que inicializa la clase.

La línea 3 invoca al método init de la clase heredada, muy importante también y difícil de explicar para comenzar.

La línea 4 ya nos suena más y lo que hace es cargar con nuestra función load_image() la imagen de la pelota, como vemos tenemos puesto True porque la pelota si tiene zonas transparentes.

La línea 5 es de las cosas más útiles de pygame la función self.image.get_rect() obtiene un rectangulo con las dimensiones y posición de la imagen (en este caso self.image) y se lo asignamos a self.rect

Aquí hago un inciso para comentar que get_rect() tiene unos parámetros muy útiles que podemos modificar para posicionar y redimensionar nuestra imagen, son los siguientes:

• top, left, bottom, right
• topleft, bottomleft, topright, bottomright
• midtop, midleft, midbottom, midright
• center, centerx, centery
• size, width, height
• w, h

Así que podemos acceder a los diferentes valores como self.rect.centerx que nos devuelve la posición central de la pelota respecto al ancho de la pantalla, y así con todos es cuestión de probarlos, pero más o menos se entiende lo que devuelve cada uno. Lo mejor de todos ellos es que si cambias el valor de alguno el resto se actualiza. Aquí lo tenéis mejor expliado.

En la línea 6 y 7 usamos las propiedades de rect y con centerx y centery definimos el centro de la pelota en el centro de la pantalla. (aquí vemos porque pusimos WIDTH y HEIGHT como constantes globales).

La línea 8 define la velocidad que queremos para la pelota, separamos la velocidad en dos, la velocidad en el eje x y la velocidad en el eje y, luego veremos porqué.

Poniendo una Bola en nuestro juego

Bien una vez creada la clase Bola vamos a crear una bola, para ello como cuando cargamos el fondo, debemos cargarla antes del bucle del juego, con la siguiente línea:

bola = Bola()

Ahora solo debemos "ponerla" en nuestra ventana, ejecutando la siguiente sentencia, después de la sentencia idéntica a la del fondo.

screen.blit(bola.image, bola.rect)

Como puedes ver ahora no le pasamos la imagen y en vez de unas coordenadas como en el fondo (entonces le pasamos (0, 0)) le pasamos el rect de la bola, con esto conseguiremos más tarde que cada vez que movamos el rect, moveremos la pelota de sitio.

Es muy importante "ponerla en pantalla después y no antes que el fondo porque si pones la pelota y luego pones el fondo encima esta no se verá, como es lógico.

El programa nos queda así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

class Bola(pygame.sprite.Sprite):
	def __init__(self):
		pygame.sprite.Sprite.__init__(self)
		self.image = load_image("images/ball.png", True)
		self.rect = self.image.get_rect()
		self.rect.centerx = WIDTH / 2
		self.rect.centery = HEIGHT / 2
		self.speed = [0.5, -0.5]

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

def load_image(filename, transparent=False):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at((0,0))
                image.set_colorkey(color, RLEACCEL)
        return image

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")

	background_image = load_image('images/fondo_pong.png')
	bola = Bola()

	while True:
		for eventos in pygame.event.get():
			if eventos.type == QUIT:
				sys.exit(0)

		screen.blit(background_image, (0, 0))
		screen.blit(bola.image, bola.rect)
		pygame.display.flip()
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Ahora tenemos una pelota en el centro de nuestra pantalla lo siguiente es conseguir que se mueva e interactúe con los bordes. Todo eso en el próximo tutorial.

Entradas relacionadas

• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Engine I: Preparándonos para trabajar
• Pygame X: Fuentes tipográficas
• Pygame IX: Sistema de puntuación

Cargando imagenes

Para cargar una imagen en Pygame vamos a usar una función que está muy bien y facilita mucho el cargar imágenes al vuelo, pongo la función y la explicamos línea por línea:

def load_image(filename, transparent=False):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at((0,0))
                image.set_colorkey(color, RLEACCEL)
        return image

La línea 1 define la función, recibe dos parámetros el nombre/ruta del archivo y la segunda si tiene parte transparente (por defecto definida como falso).

La línea 2 asigna a la variable imagen la imagen a través de la función de Pygame pygame.image.load() si se puede sino, en la líneas 3 y 4 manejan el error y salen del programa.

La línea 5 convierte la imagen al tipo interno de Pygame que hace que sea mucho más eficiente.

Las línea 6 es un condicional que controla si el parámetro transparent es verdadero y en caso afirmativo ejecuta las líneas 7 y 8, la primera obtiene el color del pixel (0, 0) de la imagen (esquina superior izquierda) y la la línea 8 lo define como color transparente de la imagen. Es decir que si quieres una imagen con transparencia, el color que actúa como transparente se toma del pixel superior izquierdo, así que asegúrate que este color no está en la imagen.

Por último la línea 9 retorna la imagen después de todo el proceso.

El programa nos queda así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

def load_image(filename, transparent=False):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at((0,0))
                image.set_colorkey(color, RLEACCEL)
        return image

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")
	while True:
		for eventos in pygame.event.get():
			if eventos.type == QUIT:
				sys.exit(0)
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Poniendo un fondo

Vamos a poner un fondo a nuestra ventana usando nuestra función load_image. Lo primero es descargar el fondo y guardarlo en la carpeta images del directorio de trabajo.

Para cargar la imagen usaremos la siguiente línea, la ponemos justo antes de entrar en el bucle del juego:

background_image = load_image('images/fondo.jpg')

Como ves no definimos color transparente, porque para el fondo no es necesario.

Ahora necesitamos "ponerla en la ventana" para ello dentro del bucle principal debemos definir que imagen poner y en que posición:

screen.blit(background_image, (0, 0))

Esto es lo que hace es poner la imagen la pantalla sobre las que había, recibe dos parámetros (en realidad algunos más), la imagen a poner y en que lugar situar la esquina superior izquierda de la imagen, en este caso (0, 0), es decir, queremos que la esquina superior izquierda de la imagen este en la posición (0, 0), con esto conseguimos que el fondo ocupe toda la ventana (si la imagen es mayor o superior a la ventana, claro está).

por último, como última línea del bucle debemos incluir la siguiente línea:

pygame.display.flip()

Esto lo que hace es actualizar toda la ventana para que se muestren los cambios que han sucedido.

El programa nos queda de la siguiente manera:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

def load_image(filename, transparent=False):
        try: image = pygame.image.load(filename)
        except pygame.error, message:
                raise SystemExit, message
        image = image.convert()
        if transparent:
                color = image.get_at((0,0))
                image.set_colorkey(color, RLEACCEL)
        return image

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")

	background_image = load_image('images/fondo.jpg')

	while True:
		for eventos in pygame.event.get():
			if eventos.type == QUIT:
				sys.exit(0)

		screen.blit(background_image, (0, 0))
		pygame.display.flip()
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Bien con esto hemos conseguido poner una imagen de fondo y tener una forma fácil de cargar imagenes en Pygame. Aconsejo guardar esto como plantilla base de Pygame, pues en casi todos los juegos necesitaremos cargar imagenes y establecer un fondo por defecto.

En el siguiente tutorial empezaremos a crear nuestro primer juego, un Pong, utilizando sptrites (imagenes con movimientos), colisiones entradas por teclado y demás cosas.

Entradas relacionadas

• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Engine I: Preparándonos para trabajar
• Pygame X: Fuentes tipográficas
• Pygame IX: Sistema de puntuación

Creando una ventana

Lo primero que necesitamos es definir las constantes del ancho y alto de la ventana, yo estas las defino como constantes porque de momento no vas a hacer cosas complicadas con cambios de resolución ni nada por el estilo y tenerlas como constantes ayuda a trabajar con ellas desde cualquier clase o función.

WIDTH = 640
HEIGHT = 480

Ahora pasamos a crear la ventana, se debe crear dentro de la función main(), es tan fácil como lo siguiente:

screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Pruebas Pygame")

La primera linea crea una ventana, date cuenta que la pasamos la tupla (WIDTH, HEIGHT) para definir las dimensiones de la ventana. La segunda línea sirve para definir el título de la ventana.

El programa nos queda así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

Si lo ejecutas te darás cuenta que se crea una ventana, pero esta desaparece al instante. Esto es debido a que necesitamos crear un bucle infinito, que será el bucle del juego. Lo creamos justo después de la creación de la ventana.

while True:
	pass

Como vemos es un bucle infinito vacío que se ejecuta eternamente y hace que la ventana no se cierra, pero ¡sorpresa!, ahora no hay forma de cerrar la ventana si no es matando el proceso. La solución consiste en que el bucle infinito compruebe si queremos cerrar la ventana y en ese caso que deje de ejecutarse. Sustituimos las dos líneas anteriores por:

while True:
	for eventos in pygame.event.get():
		if eventos.type == QUIT:
			sys.exit(0)

La primera línea del bucle recorre con un for pygame.event.get() que es una lista interna de Pygame con los eventos que se están ejecutando. En la siguiente línea comprobamos que si el tipo de evento es igual a QUIT, es decir, que si le estamos dando a la crucesita de cerrar ventana. En caso de que sí, invoca a sys.exit(0), para el que necesitamos haber importado el módulo sys, y cierra el programa. Ya tenemos la manera de crear una ventana y controlar cuando cerrarla.

El código nos queda así:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import sys, pygame
from pygame.locals import *

# Constantes
WIDTH = 640
HEIGHT = 480

# Clases
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

def main():
	screen = pygame.display.set_mode((WIDTH, HEIGHT))
	pygame.display.set_caption("Pruebas Pygame")
	while True:
		for eventos in pygame.event.get():
			if eventos.type == QUIT:
				sys.exit(0)
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

En el próximo tutorial aprenderemos a cargar imágenes y ponerlas en nuestra ventana.

Entradas relacionadas

• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Engine I: Preparándonos para trabajar
• Pygame X: Fuentes tipográficas
• Pygame IX: Sistema de puntuación

Requesitos previos

• Conocimientos de Python. Se da por hecho que se manejan con soltura la creación de clases, funciones y demás.
• Algo de matemáticas y física básica. Para empezar con conceptos básicos de lo que es un punto matemática y algunas formulas básicas de física tenemos de sobra.

Qué necesitamos

• Tener Python y Pygame instalados.
• Un IDE o editor de texto a elección.
• Un directorio base donde trabajar. Yo he creado una carpeta llamada pygame con dos carpetas en el interior llamadas images y sound.

El documento base

Mi método de trabajo es tener todo organizado para que el código sea fácil de leer, es por eso que antes de empezar voy a compartir mi plantilla base que podéis guardar como plantilla.py. A partir de ella escribo mis programas y es desde donde comenzare estos tutoriales.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos

# Constantes

# Clases
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

def main():
	return 0

if __name__ == '__main__':
	main()

Importar e inicializar

Lo primero que hay que hacer para trabajar con Pygame es importarlo e inicializarlo. Para importarlo basta con las líneas:

import pygame
from pygame.locals import *

La primera línea importa pygame y la segunda carga las constantes para poder utilizar, por ejemplo, K_ESCAPE, en lugar de estar de tener que llamarla a través del módulo Pygame.

Una vez importado pasamos a inicializar. Se puede inicializar cualquiera de los módulos de Python por separado, pero para no complicarnos por ahora inicializaremos todo pygame con la línea:

pygame.init()

Esta se debe ejecutar antes de empezar a usar Pygame, un buen lugar es antes de llamar a la función main(), justo aquí:

if __name__ == '__main__':
	pygame.init()
	main()

Con esto ya tenemos importado e inicializado Pygame y estamos listos para trabajar, dejo como se debe tener el archivo hasta ahora:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Módulos
import pygame
from pygame.locals import *

# Constantes

# Clases
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

# ---------------------------------------------------------------------

def main():
	return 0

if __name__ == '__main__':
	pygame.init()
	main()

En el siguiente tutorial aprenderemos a crear una ventana y poner en ella una imagen.

Entradas relacionadas

• Juego de la serpiente paso a paso. Parte 2
• Engine II: El archivo principal
• Engine I: Preparándonos para trabajar
• Pygame X: Fuentes tipográficas
• Pygame IX: Sistema de puntuación

Las Hormigas en la naturaleza

Las hormigas son ciegas y salen del hormiguero en busca de comida sin nada que las oriente, van caminando a ciegas en busca de alimento hasta que lo encuentran, luego regresan al hormiguero y “comunica” al resto de las hormigas el camino hacia la comida y no solo eso, sino que ha medida que van más hormigas consiguen optimizarse para encontrar el camino más corto del hormiguero a la fuente de alimento. ¿Cómo es esto posible si son ciegas y no tienen un medio de comunicación entre ellas? La clave está en las feromonas.

Las hormigas al caminar van dejando tras de sí una sustancia llamada feromonas que aparte de servirle para encontrar el camino de regreso al hormiguero sirve para orientar a otras hormigas hacia la comida. Las hormigas tienden a seguir el rastro de feromonas de otros individuos de su especie. Las hormigas solo detectan las feromonas cuando están en contancto directo con ella, es decir, es un contacto local.

Optimizando el resultado

¿Y como pueden encontrar el camino más corto con este método? Fácil, las feromonas es una sustancia química que al pasar otra hormiga por el mismo lugar intensifica y si no pasa ninguna con el tiempo se evapora. Esto hace que entre más hormigas pasan por un lugar más feromonas tendrá ese camino y más deseable será para otras hormigas, en cambio en los caminos menos trancitados se van evaporando las feromonas haciendo que sean menos deseables.

En la imagen superior podemos ver dos caminos para llegar desde el hormiguero hasta la comida, en principio, las hormigas a ciegas elegirán aleatoriamente uno de las dos caminos como podemos ver en B. Es obvio que el camino superior es mucho más corto, esto produce que las hormigas que han optado por el camino superior lleguen y vuelvan más rápido a la comida que las que eligen el camino inferior, al ir y venir más rápido la cantidad de feromonas se verá reforzada más rápidamente y se evaporará mucho más despacio. Con esto se conseguirá que próximas hormigas a la hora de decidir uno de los dos caminos elijan el camino con más feromonas, reforzando el camino superior y hacienda cada vez menos atractivo el camino inferior.

Al cabo de un tiempo casi todas las hormigas irán por el camino superior como podemos ver en D.

Aquí hemos visto como las hormigas en la naturaleza sin comunicarse entre ellas son capaces de organizarse como una colonia para lograr un objetivo común. Los individuos por si solo no son nada, pero la suma de los agentes hacen un sistema muy eficaz, en el próximo artículo veremos como aplicar esto en un programa informático para encontrar el camino más corto.

Entradas relacionadas

• Usando Pilas Binarias en Pathfinding A*
• Pathfinding A* de 2 niveles
• Heurística para el Pathfinding A*
• Pathfinding A* en Python. Parte III
• Pathfinding A* en Python. Parte I

En el capítulo anterior vimos dos tipos de datos: Las cadenas de caracteres, que son un conjunto de letras, “Hola Mundo” y también vimos enteros que no son más que números.

Anteriormente usamos la sentencia print para imprimir una cadena de caracteres, pero también puedes imprimir otros tipos de datos con print, como enteros.

>>> print 5
5

Para saber de qué tipo es un dato en concreto puede usar la siguiente función, todavía no se preocupe por el concepto de función más adelante lo trataremos:

>>> type(5)
<type 'int'>
>>> type("Hola Mundo")
<type 'str'>
>>> type(4.2)
<type 'float'>
>>> type("6")
<type 'str'>
>>> type("8.45")
<type 'str'>

Como vemos la función type() devuelve el tipo de dato que se encuentra entre paréntesis, vamos a ir línea por línea para ver que tipos de datos son:

En el primero como vemos al poner 5 devuelve int (integer es entero en inglés). “Hola Mundo” devuelve str de string (cadena en inglés). Ahora viene un tipo de dato nuevo 4.2 es un número decimal y en python se les llama float.

Los dos últimos son casos especiales “6″ y “8.45″ parecen de tipo int y float respectivamente, pero como están entre comillas para python son cadena de caracteres como lo era “Hola Mundo”, no son números y no se deben tratar como tal.

Otra cosa a tener en cuenta es que para imprimir un entero largo como por ejemplo 1000000 usted podría usar la “,” para separar los miles 1,000,000 con esto lo que estaría diciendo a python es que imprima 3 enteros: 1, 0, 0. Por tanto no use la coma para separar los miles.

>>> print 1000000

1000000
>>> print 1,000,000
1 0 0

Variables

Las variables son una de las características más importante de la programación y las encontrará en todos los lenguajes. Una variable en programación no dista mucho de una variable matemática es una palabra o letra que hace referencia a un valor en concreto.

>>> a = 5
>>> mensaje = "Me gusta Python"
>>> pi = 3.1415

Como vemos mediante el signo “=” asignamos el valor que queramos a una variable. a vale 5, mensaje contiene “Me gusta Python” y pi el valor 3.1415.

Las sentencias anteriores también funcionan con variables, por ejemplo la sentencia print:

>>> print a
5
>>> print mensaje
Me gusta Python
>>> print pi
3.1415

y también la función type(), en general en cualquier sitio donde puede ir un valor puede ir una variable que represente ese valor:

>>> type(a)
<type 'int'>
>>> type(mensaje)
<type 'str'>
>>> type(pi)
<type 'float'>

como vemos el tipo que devuelve type() se corresponde con el tipo de dato que contiene cada una de las variables pasadas.

Nombres de variable

En general python acepta cualquier conjunto de letras y número como nombre de variable, pero hay una serie de reglas a tener en cuenta:

• Puedes usar números y letras pero debe comenzar con una letra.
• Puedes usar mayúsculas y minúsculas, por convenio se suelen usar las minúsculas.
• Python distingue entre mayúsculas y minúsculas no es la misma variable número que Número.
• También es válido el guión bajo “_”, por ejemplo, numero_lapices.
• Totalmente prohibido el uso de tildes en los nombres de variable.
• tampoco puedes usar como nombres de variable las palabras reservadas de Python, son las siguientes: and, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try y while.

Procura usar nombres de variables descriptivos, que no sean ambiguos y que definan claramente lo que contienen, por ejemplo si quieres almacenar el número de caramelos no uses c = 20, sino, num_caramelos = 20.

Operadores y expresiones

En el primer capítulo ya vimos que podíamos usar python para resolver operaciones matemáticas como 5+4, no es difícil averiguar que estas operaciones se pueden realizar también con variables, veamos algunos ejemplos:

>>> a = 2
>>> b = 5
>>> a*b
10
>>> c = a + b
>>> b*c+a
37
>>> -a
-2

Como vemos podemos usar las variables como si de números se trataran y asignar a una variable el resultado es una operación ya sea entre variables, o números y variables.

Los operadores que encontrarás en Python son los típicos matemáticos +, -, *, / son los símbolos de suma, resta, multiplicación y división el operador ** es el operador de potencia y uno no tan común es el % que devuelve el resto de una división, ejemplos de uso:

>>> 5+4
9
>>> 5-4
1
>>> 5*4
20
>>> 5/4
1
>>> 5%4
1
>>> 5.0/4.0
1.25
>>> 5**4
625

De todos parecen resultados lógicos menos 5/4 que devuelve 1 cuando el resultado es 1.25, esto es así porque estas dividiendo dos enteros y por tanto devuelve un entero, para que el resultado se nos dé en decimales alguno de los operandos debe ser de tipo float como hemos hecho en 5.0/4.0 que en este caso si devuelve 1.25.

No olvide que el operador % no tiene nada que ver con el porcentaje y que lo que devuelve es el resto de una división.

Si ha sido un poco curioso verá que python evalúa más que operaciones simples, expresiones como las siguientes:

>>> a = 6
>>> b = 4.53
>>> c = a + b * 8 ** 5 / a
>>> print c
24745.84

En Python hay unas reglas para decidir que operaciones se hacen primero como ya dijimos, sinceramente yo nunca las aprendí, pienso que cuando se duda es más fácil aplicar paréntesis, aparte de que propicia menos errores el programa quedará más fácil de leer.

Operaciones con cadenas

Hasta ahora hemos visto operaciones que actúan sobre los tipos de datos int y float, pero ¿Qué pasa con las cadenas? en general es ilógico hacer una opereación sobre una cadena, pero algunas sí se pueden, eso sí, el resultado no será el esperado.

>>> a = "Hola"
>>> b = "Mundo"
>>> c = a + b
>>> print c
HolaMundo
>>> a*3
'HolaHolaHola'
>>> c*2
'HolaMundoHolaMundo'
>>> a + " " + b
'Hola Mundo'

Como vemos el operador “+” sirve para unir dos cadenas de caracteres y el operador “*” multiplica el valor de la cadena por el número pasado.

Entradas relacionadas

• Curso Python IV – Funciones
• Curso Python III – Scripts y Comentarios
• Curso Python I – Intérprete y scripts
• Curso Python – Presentación
• Curso Python

Python tiene dos modos de ejecución, mediante scripts o interactivamente en el intérprete. A la hora de escribir programas serios usará la modalidad script, pero el modo intérprete es genial para probar pequeños código y para aprender.

Para abrir el intérprete de Python en linux basta con escribir en la consola “python”, sin comillas. En Windows basta con buscar en el menú de inicio el programa. En cualquier caso se abrirá una ventana de consola con lo siguiente:

Python 2.6.2 (r262:71605, Apr 14 2009, 22:40:02) [MSC v.1500 32 bit (Intel)]
on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

En este caso es la versión 2.6.2 para Windows, pero en Linux será algo parecido. Lo importante es ese “>>>” es la entrada de datos de Python. Puedes usarlo como calculadora, por ejemplo:

>>> 5+4
9
>>> 8*3
24
>>> 2+4*3
14
>>> (2+4)*3
18
>>> _+2
20

Como puedes ver funciona como una calculadora. Algunas cosas a tener en cuenta que se pueden ver aquí:

• Python sigue el orden matemático establecido para realizar operaciones, es decir, multiplicaciones y divisiones antes que sumas y restas, paréntesis antes que todo. Por ejemplo fíjese que en el 2+4*3, Python primero hace la multiplicación y a continuación la suma, dando como resultado 14, pero para (2+4)*3, al ir los paréntesis antes según las reglas matemáticas primero suma 2+4 y a continuación lo multiplica por 3 dando 18.
• el “_”, hace referencia a la última salida de datos del intérprete. Fíjese en el “_+2″, la salida anterior había sido 18 más 2 da como resultado 20.

El primer programa

Tradicionalmente, cuando se aprende un lenguaje de programación el primer programa que se enseña es el “Hola Mundo”, que consiste en mostrar en pantalla el texto “Hola Mundo”, en otros lenguajes suele tener sentido pues sirve para explicar cosas básicas del lenguaje, pero en Python es tan simple como escribir en consola lo siguiente:

>> print "Hola Mundo"
Hola Mundo

Ya ves, nada del otro mundo, pero sirve para que aprendamos la primera palabra clave de python: print. print es la salida estándar en Python y su sintáxi es print más un valor, en este caso el valor es la cadena de caracteres “Hola Mundo”, pero no te preocupes por esto, ya trataremos las cadenas más adelante.

Scripts

El intérprete está muy bien para probar cosas y como calculadora(en realidad el intérprete es más potente de lo que parece, pero ya lo veremos), pero seguramente querrás guardar tus programas para ejecutarlos cuando tu quieras. Para ello deberás crear un script de Python que no es más que un fichero de texto plano con la extensión .py. Así que abre tu editor de texto plano favorito o el IDE que vayas a usar para programar en python y escribe ahí:

print "Hola Mundo"

Guarda el archivo y desde la consola, situando en la ruta donde hayas guardado el archivo escribe, si estas en linux:

python nombreArchivo.py

Y si estas en Windows, escribe simplemente:

nombreArchivo.py

Y ya puedes ejecutar tu script en Python, siempre que quieras de esta forma.

Bueno está ha sido la primera entrega del curso que sirve para ponernos en situación. Ahora que sabemos usar el intérprete y crear scripts en Python empieza lo bueno.

Entradas relacionadas

• Curso Python IV – Funciones
• Curso Python III – Scripts y Comentarios
• Curso Python II – Tipos y variables
• Curso Python – Presentación
• Curso Python

Requesitos previos

No es necesario haber programado nunca antes en algún lenguaje de programación, el curso partirá desde cero por lo que cualquier podrá seguirlo. Aún que no es necesario haber programado nunca, el curso presupondrá unas nociones básicas sobre que es una variable o una constante, para esto no hace falta saber programación sino unas nociones básicas de matemáticas serán suficientes. También necesitará concer lo básico del manejo de ordenadores: crear ficheros, directorios, instalar programas, etc.

Herramientas necesarias

• Un sistema operativo, pueda usar el que quiera, pero recomendamos usar alguno de los Unix libre como Linux o BSD.
• Intérprete Python. Lo puede obtener de http://python.org. Si usted usa una distribución linux probablemente ya lo tenga instalado.
• Un editor de texto plano. puede usar el que quiera, yo recomiendo Geany, es un IDE libre, multiplataforma, y sencillo, además tiene resaltodo y autocompletado de código. Si lo usas desde tiene una consola integrada perfecta para probar el código que vayas aprendiendo.
• Ganas de aprender.

Guía de estilo

El código de ejemplo se mostrará de la siguiente manera:

def multiplicar(x):
	n = 1
	while n <= 10:
		r = n*x
		print x, "x", n, "=", r
		n += 1

num = input("Introduce un numero: ")
multiplicar(num)

La salida en consola se mostrará de la siguiente manera:

Introduce un numero: 7
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63
7 x 10 = 70

El siguiente recuadro amarillo es usado para mostrar advertencias y cosas a tener en cuenta:

Esto es un recuadro de advertencia, tenlos muy en cuenta a lo largo del curso.

Por último, los recuadros verdes son usados para consejos, tips y trucos.

Esto es un recuadro de consejos. Échales un vistazo para que tu código sea mejor y eficaz.

Entradas relacionadas

• Curso Python IV – Funciones
• Curso Python III – Scripts y Comentarios
• Curso Python II – Tipos y variables
• Curso Python I – Intérprete y scripts
• Curso Python

Está página va dedicada la Inteligencia Artificial, la Vida Artificial y la Robótica, todo a un nivel principiante y experimental para gente “normal” no para expertos, es por eso que todo lo que porgramo he decidido hacerlo con un lenguaje sencillo, claro y que no complique más las cosas. El lenguaje perfecto para esto para mi es Python y aprenderlo no cuesta nada, es perfecto para quien se quiera iniciar en la programación.

Es por eso que he decidido continuar un curso que empecé hace tiempo sobre Python, para que la gente que se quiera iniciar en este mundo.

El curso se presentará de una manera amena, con ejemplos prácticos. Es decir, no me limitaré a dar la sintaxis de Python, tipos de datos y ya está, sino que después de explicar las cosas haré ejemplos prácticos y propondré ejercicios sobre la aprendido.

A través de los comentarios podrás preguntar todo tipo de dudas e incluso puedes mandarme los ejercicios para corregirlos.

Entradas relacionadas

• Curso Python IV – Funciones
• Curso Python III – Scripts y Comentarios
• Curso Python II – Tipos y variables
• Curso Python I – Intérprete y scripts
• Curso Python – Presentación

Crear laberintos es muy fácil, solo hay que modificar el fichero laberinto.txt que viene de ejemplo y puedes hacer el laberinto que quieras para poner a prueba la IA.

# # # # # # # # # # # # # # # # #
# T . . . . . . . . . # . # . . #
# # # # # # # # # . . . . # . # #
# . . . . . . . . . # . . . . . #
# . # # # . # . # . # . # . # . #
# . # . # . # . # . # . # . # . #
# . # . # . # . # . . # # . # # #
# . # . . . # . # # . # . . . . #
# # . . # # # . . # . # . . # # #
# . . # . . . . # # . # # . . . #
# # # # . # . . . # . # . . # # #
# . . . . # . # . # . # # . # . #
# . # # . # . # . # . . # . . . #
# # # # # # # # # # # # # # # S #

Ahi podemos ver el mapa de ejemplo donde los “#” representan las paredes, los “.” los caminos, la “T” es la pelota y la “S” es la salida. Puedes modificar paredes la posición de la salida o la pelota o hacer laberintos mucho más grandes.

La salida gráfica de la aplicación la he hecho con GASP, los gráficos se encuentran en la carpeta del programa y se pueden modificar.

• Descargar Buscador de Caminos

Entradas relacionadas

• El salto del caballo, backtracking
• Arboles e inteligencia Artificial
• Algoritmo Minimax, un jugador incansable
• Muestra del Engine de PyIA
• PyIA – Competición de Inteligencia Artificial en Python

1. Aleatoria. Donde se debe introducir el numero de filas y columnas del mapa y se rellenan de forma aleatoria.
2. Cargar Mapa. Donde se debe indicar la ruta de un mapa en formato txt con la configuración inicial, se incluye un ejemplo de mapa con el juego.

El juego es muy mejorable y se recomienda no usar mapas de más de 900 casillas (30×30), porque la API gráfica no es la mejor y va un poco mal. La configuración del juego se hace a través de consola, pero este se ejecuta en una ventana gráfica. Por defecto esta es de 640×480, pero se puede cambiar muy facilmente en el programa.

El programa necesita el paquete python-gasp que podéis encontrar en las repositorios de la distribuciones basadas en Debian, para otros sistemas consultar la página oficial. El código después del salto.

• Descargar Juego de la Vida

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# ---------------------------------------------------------------------
# Programa: EL juego de la vida.
# Autor: Adrián Guerra Marrero (adrigm).
# Web: www.razonartificial.com
# Licencia: GNU/GPL
# ---------------------------------------------------------------------

# Módulos
from gasp import *
import time, os, random

# CONSTANTES
width = 640
height = 480

# Clases
# ---------------------------------------------------------------------

class Juego:
	def __init__(self, opcion=1, archivo="mapa.txt", fil=10, col=10):
		if opcion == 2:
			self.mapa = leerMapa(archivo)
		else:
			self.mapa = range(fil)
			for i in range(fil):
				self.mapa[i] = range(col)

			for f in range(fil):
				for c in range(col):
					self.mapa[f][c] = random.randint(0, 1)

		self.filas = len(self.mapa)
		self.columnas = len(self.mapa[0])

	def __str__(self):
		mapa = ""
		for f in range(self.filas):
			for c in range(self.columnas):
				if self.mapa[f][c] == 0:
					mapa += ". "
				if self.mapa[f][c] == 1:
					mapa += "* "
			mapa += "\n"
		return mapa

	def analizarVecinos(self, fil, col):
		vecinos = 0
		if fil-1 >= 0 and col-1 >= 0:
			if self.mapa[fil-1][col-1] == 1:
				vecinos += 1
		if fil-1 >= 0:
			if self.mapa[fil-1][col] == 1:
				vecinos += 1
		if fil-1 >= 0 and col+1 <= self.columnas-1:
			if self.mapa[fil-1][col+1] == 1:
				vecinos += 1
		if col-1 >= 0:
			if self.mapa[fil][col-1] == 1:
				vecinos += 1
		if col+1 <= self.columnas-1:
			if self.mapa[fil][col+1] == 1:
				vecinos += 1
		if fil+1 <= self.filas-1 and col-1 >= 0:
			if self.mapa[fil+1][col-1] == 1:
				vecinos += 1
		if fil+1 <= self.filas-1:
			if self.mapa[fil+1][col] == 1:
				vecinos += 1
		if fil+1 <= self.filas-1 and col+1 <= self.columnas-1:
			if self.mapa[fil+1][col+1] == 1:
				vecinos += 1
		return vecinos

	def ciclo(self):
		nueva_conf = []
		for f in range(self.filas):
			columna = []
			for c in range(self.columnas):
				vecinos = self.analizarVecinos(f, c)
				if self.mapa[f][c] == 0:
					if vecinos == 3:
						columna.append(1)
					else:
						columna.append(0)
				if self.mapa[f][c] == 1:
					if vecinos == 2 or vecinos == 3:
						columna.append(1)
					else:
						columna.append(0)
			nueva_conf.append(columna)

		self.mapa = nueva_conf

	def dibujar(self):
		dist_lv = width/self.columnas
		dist_lh = height/self.filas
		for i in range(self.columnas):
			Line((dist_lv*i, 0), (dist_lv*i, height))
		for n in range(self.filas):
			Line((0, dist_lh*n), (width, dist_lh*n))

		for f in range(self.filas):
			y = height-dist_lh - ((dist_lh)*f)+(dist_lh/2)
			for c in range(self.columnas):
				x = ((dist_lv)*c)+(dist_lv/2)
				if self.mapa[f][c] == 1:
					Circle((x, y), ((dist_lh/2)-((dist_lh/2)*0.2)))

# ---------------------------------------------------------------------

# Funciones
# ---------------------------------------------------------------------

# Quita el ultimo caracter de una lista.
def quitarUltimo(lista):
	for i in range(len(lista)):
		lista[i] = lista[i][:-1]
	return lista

# Covierte una cadena en una lista.
def listarCadena(cadena):
	lista = []
	for i in range(len(cadena)):
		if cadena[i] == ".":
			lista.append(0)
		if cadena[i] == "*":
			lista.append(1)
	return lista

# Lee un archivo de texto y lo convierte en una lista.
d