Respecto a lo segundo, es así como está hecho. El que cambia la escena que maneja el director es la propia escena que esta cargada, es en esta donde se selecciona la que debe ser la nueva escena.

Gracias por los ánimos.

1.- La clase Director la definí mediante un patrón ‘Singleton’, si no sabes nada de patrones software echa un vistazo en la Wikipedia, te resultará muy útil. Este patrón viene a definir lo siguiente: Sólo puede existir una clase Director, en caso de que alguien cree o invoque una clase Director dentro de la misma aplicación, siempre se devuelve el mismo objeto, lo cual es útil para el siguiente punto:

2.- Se dispone de una pila de ‘escenas’. El Director no conoce el orden de las escenas, puesto que estas pueden variar dependiendo de los eventos del juego (pausa, cambio de nivel, nivel secreto…), son las propias escenas las que invocan una instancia del objeto Director y apilan la siguiente escena.

Espero que te sirva de ayuda.

Estás haciendo un gran trabajo con el blog, ¡ánimo!

Por lo que he estado viendo es de lo más completo en cuanto a sonido multimedia para los videojuegos, no en vano los grandes engines lo tienen como biblioteca de audio por defecto.

Yo la verdad de sonido digital no controlo mucho, a ver si un día investigo y aprendo algo.

¿Sabes si integra funcionalidades como caćulo automático de volumen en función de la distancia al objetivo? Puede que eso sea algo de lo que se encarguen los engines que se sitúan por una capa de abstracción más elevada.

Por el momento yo sólo he utilizado SDL_mixer para el sonido por ser libre y cubrir mis necesidades. Supongo que cuando desee algo más grande tendré que recurrir a Fmod o alguna por el estilo.

Saludos.

Saludos.

Primero recorre la lista de vecinos del nodo seleccionado y luego va comprobando.

Primero comprueba si ya está en la lista cerrada, en cuyo caso no hace nada. Luego comprueba si NO está en la lista abierta y si no está lo añade.

Por último comprueba si ya está en la lista abierta, pero la g del nodo seleccionado más 1 es menor que la del nodo vecino que estamos comprobando. Si se cumple simplemente recorre la lista abierta buscando ese nodo en la lista y lo sustituye por el nuevo con los nuevos cálculos hechos.

Para entenderlo supongo que primero te habrás mirado bien el artículo de la teoría, cualquier duda pregunta.

Te animo si puedes a continuar con las traducciones ya que estás haciendo un gran trabajo.

Saludos.

Soy Andrés de Pedro, de Proyecto Iris, muchas gracias por la referencia en este post, la verdad es que tengo bastante parado el tema de la traducción de las lecciones de HobbyGameDev, en gran parte porque me llevan bastante tiempo y desde que comencé las traducciones no he tenido ningún respuesta ni confirmación conforme alguien las lee… por lo que al final he dejado el tema estancado (yo las he seguido leyendo en inglés)

Si alguien por aquí sigue estas lecciones y hay interés en que continue con las traducciones puedo buscar tiempo para ello, por lo que aprovecho para preguntar si alguien de aquí se animó a leerlas :)

Un saludo

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

muchas gracias

Negamax es una pequeña mejora que se hace a la poda alfa y beta asumiendo que el valor óptimo para A es la negación del equivalente en B. Puedes obtener más información del algoritmo aquí:

http://en.wikipedia.org/wiki/Negamax

Saludos.

Si ya de por sí la teoría fuera complicada sería un caos. Para trabajar bien pienso que hay que tener buenos esquemas de lo que se quiero lograr y hacerlo lo más simple posible, luego trabajar en algoritmos intentando mantenerlo siempre lo más simple posible (simple no quiere decir que a su vez no pueda ser complejo), por último cuando se tiene claro pasarlo a código.

Luego ya vienen pruebas, optimización, más pruebas, más optimización, hasta que se consiga algo bueno.

Quizás la idea pueda ser simple pero dudo que la implementación lo sea. En un juego 3D lleno de elementos independientes y complejos cada ciclo de CPU cuenta y los algoritmos deben estar muy cuidados.

Es “increible” lo que se puede conseguir con cosas simples (o relativamente simples).

Saludos.

Saludos.

Puedes ver como he hecho un cambio de diseño, estos días hemos tenido problemas, pero parece que todo se va restaurando poco a poco.

¡sigue asi!

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.2, -0.2]
	def actualizar(self, time, colisiones, puntos, jugador):
		self.rect.centerx += self.speed[0] * time
		self.rect.centery += self.speed[1] * time

		#chocar con la pala
		for elemento in colisiones:
			if pygame.sprite.collide_rect(self, elemento):
				self.speed[0] = -self.speed[0]
				self.rect.centerx += self.speed[0] * time
				jugador = colisiones.index(elemento)

		#Sumar Punto
		if self.rect.left <= 0 and jugador == 1:
			puntos[1] += 1
		if self.rect.right >= WIDTH and jugador == 0:
			puntos[0] += 1

		#chocar con la pared
		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

		return puntos, jugador

lo único que hay que comprobar quien fue el último que le pegó a la pelota y si fue el contrario sumamos el punto, si no, nones.

Dejo el script completo por pastebin:
http://pastebin.com/4acUCu2F

Felicidades al autor por el tutorial

Respecto de la pregunta, me explico. Si puedo definir un cuadrado de cuatro puntos arbitrarios ej.: (20,20)(20,40)(40,40)(40,20)

Y crear una colisión con esta figura. O dicho de otro modo, que colisione con rects definidos arbitrariamente y no tomados de un archivo.

En cuanto a la pregunta no entiendo bien, ¿te refieres a los rects, a que no sean cuadrados?

La indentación no me la tomó. deberán imaginarla

        def actualizar(self, time, colisiones):
                self.rect.centerx += self.speed[0] * time
                self.rect.centery += self.speed[1] * time
                if self.rect.left = WIDTH:
                        self.speed[0] = -self.speed[0]
                        self.rect.centerx += self.speed[0] * time
                if self.rect.top = HEIGHT:
                        self.speed[1] = -self.speed[1]
                        self.rect.centery += self.speed[1] * time

                for elemento in colisiones:
                        if pygame.sprite.collide_rect(self, elemento):
                                self.speed[0] = -self.speed[0]
                                self.rect.centerx += self.speed[0] * time

luego las colisiones las agregamos en bola:

bola.actualizar(time, [pala_jug, pala_cpu])

y podemos añadir colisiones a veintemil y un elementos:

bola.actualizar(time, [pala_jug, pala_cpu, cosa, que, se, me, ocurra, en, el, array])

¿¿pero una pregunta puedo crear colisiones con límites que yo defina y que no se dibujen en la pantalla??.

PD: El mejor tutorial de pygame que he encontrado. Muy

Prueba a sacar el fondo del bucle y verás.

Me imagino que colocarla fuera del bucle mejoraría ligeramente el rendimiento, y en fin, el fondo no debe actualizarse cada vez

Pero bueno, para gustos colores y sí, siendo un tutorial, esas cosas no se suelen tener muy en cuenta.

De todos modos, gracias por la información sobre el flipping.

De todas maneras no se realmente si estas bibliotecas tratas objetos 2D como 3D o como lo hacen, intentaré documentarme.

Se pueden, y se suelen, hacer animaciones 2D vectoriales para las que es necesario pensar con polígonos y toda la cacharrería.

Es más, se puede usar OpenGL y la tarjeta gráfica para manipular y mostrar esas imágenes y no sobrecargar la CPU. O al menos eso es lo que he entendido después de leer varios tutoriales sobre pyglet ( parecido a pygame ) y OpenGL.

Presentación muy recomendable: http://tartley.com/files/stretching_pyglets_wings/presentation/

fue una buena idea pasar la gia a python :D

Adri, si el año que viene empiezas la carrera, por lo que he visto en todo el blog…

Te aburrirás en clase una barbaridad xDD

Te deberían convalidar asignaturas, al menos las básicas de programación del primer curso.

Saludos!

No me parece el caso de cortar los sprites que puede haber en cada juego de diferentes grados de animación. Porque no pienses solo en el caminar, piensa en uno de saltar tendría varios frames más, yo la verdad prefiero dejarlo si parámetros por defecto.

cortar_chara("a.png"); # Sprite de 4*4
cortar_chara("b.png",5); # Sprite de 5*5
cortar_chara("c.png",3,2); # Sprite de 3*2

Lo de las columnas y filas, supongo que depende de por dónde se mire.

Si no me dices que error te da, no puedo decirte más.

Precisamente como lo que se mide ante es el ancho por convención primero deben ir las filas, se toma una fila y se recorren sus columnas, se toma la siguiente file y se recorren sus columnas. Yo al menos trabajo así.

def cortar_chara(ruta,col=4,fil=0):
	if fil==0:
		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;

porque supongo que generalmente los charasets son de 4*4, y así no hay que especificarlo si es el caso. Al mismo tiempo, si se quiere poner un charaset de otro tamaño, es probable que el número de filas y columnas sea el mismo, y así sólo hay que especificar el número de columnas y el número de filas se obtiene automáticamente.

Además, el número de columnas debería ir antes, porque por convención lo que tiene que ver con ancho va antes de lo que tiene que ver con alto.

Sin ella yo no hubiese sabido de este tipo de competición

En cuando a lo de tu ejemplo, más que pasarmelo, te invito a escribir un artículo sobre el método y como lo realizaste que se podría compartir en el blog, así aprenderíamos todos el método.

Un saludo.

En cuanto al engine RPG, sin palabras. Muy bueno.

Pero bueno, cuando este hecho hay buenas posibilidades que participe ;)

Todo dependerá de la facultad jeje

Un saludo.

¡Ánimo con el proyecto!

Vas a continuar con el curso de Python?

Un amigo me mandó el link a este artículo porque sabía que me iba a interesar. Ya te estoy siguiendo para estar al tanto de este proyecto. Espero que salga.

Me imaginaba que era para pruebas, pero hay mejore y mas elegantes formas de hacerlas. Hay una cosa que se llaman “pruebas unitarias” (http://es.wikipedia.org/wiki/Prueba_unitaria) que sirven para comprobar que todas las funcionalidades de un módulo sean correctas. En la biblioteca estándar de Python está ‘unittest’ que sirve para eso.

Si estás empezando a programar o llevas poco tiempo, puede ser un concepto un poco complicado, además de pesado, pero creeme, ahora que llevas “poco” desarrollo es el momento de usarlo.

Una lástima lo de GitHub, es una gran forma de mantener un equipo de desarrollo distribuido.

Lo de la función main en cada modulo es para probarlos y ejecutarlos de manera independiente en pruebas. Solo se ejecutan si son cargados como principal y no como módulos.

En cuanto a lo del idioma, empecé sin tenerlo en cuenta, pero luego decidí hacerlo todo con nombres en inglés y poco a poco voy cambiando, como trabajaba solo y era un proyecto personal no le di importancia, pero ahora sí. De todas maneras con la gente que esta colaborando tenemos el convenio de que las cosas provisionales o que no estan terminadas o en pruebas las ponemos con nombres en español y la definitiva o cuando ya se vaya a usar en inglés.

El programa es GPL3, pero, sí tengo que añadirle la licencia al código.

En cuanto al repositorio he abandonado Github por google codes, prefiero usar svn, puedes seguir el proyecto desde aquí:

http://code.google.com/p/engine-rpg/

en github no está actualizado y no se actualizará.

De todas formas, hay cosas en el código que no son del todo correcto conceptualmente, y si te parece te pongo algunas críticas constructivas :)

Por ejemplo, no es bueno / necesario que todos los .py sean ejecutables y tengan su “main”. ¿Para que necesitas un main() en la clase Actor?

Otra cosa, te recomiendo que seas coherente con el idioma. Es decir, que si usas español, usa español, y si usas inglés, usa inglés, pero no pongas algunas cosas en inglés y otras en español, porque puede provocar confusiones.

Para terminar, para evitarte problemas, deberías añadirle una licencia de software al engine, como por ejemplo GPL.

Y bueno, enhorabuena otra vez, me parece un trabajo magnífico. Si saco algo de tiempo, forkearé el proyecto en GitHub para algunas mejoras que se me ocurren :)

(escribe en minúscula, por favor).

ahí pone muchas de las cosas que utilizo, aunque está algo obsoleto hasta que esté lista la wiki.

El formato XML viene muy bien. ¿Utilizas alguna herramienta para crear los mapas? Yo he utilizado en varias ocasiones Tiled, un editor de escenarios basados en tiles. Es open source y multiplataforma (con versiones en Qt y Java). Los mapas se guardan en un formato XML fácilmente parseable. Quizás te venga bien.

Saludos.

Para la carga de mapas y demás utilizo ficheros XML y para otrás configuraciones también, no descarto en un futuro usar otros formatos.

Pienso hacerlo todo con Python, ya he probado algunos algoritmos de IA como el Pathfinding y van bastante bien.

Un saludo

El desarrollo de videojuegos es mi pasión y ya he hecho algunas cositas de pequeño y mediano tamaño. Ahora mismo estoy metido en mi Proyecto Fin de Carrera que también está relacionado con ese mundo.

Sigue así y documenta mucho todo lo que hagas, si no lo haces nadie usará tu engine. Aunque veo que la wiki está en mente.

Tengo algunas preguntas sobre tu motor RPG. ¿Qué usas o tienes pensado usar para los datos? Podrías usar una base de datos con la información de los niveles y atributos de los personajes o simplemente ficheros xml. ¿Cómo cargas los mapas del juego? ¿Utilizas algún otro lenguaje para definir las rutinas de los enemigos o de la IA?

Saludos y sigue así.

Porque no vaya nadie a usarlos y no poner en los créditos del juego el texto:
“Art Collection Title” art by Daniel Cook (Lostgarden.com)

Saludos.

Es lo que pasa por venir de barrapunto y directamente al listado de artículos del engine.

Gracias por tu tiempo y dedicación.

Olimpiodoro, abrir cualquier cosa como append siempre es para añadir algo al final, es decir, que el puntero de escritura se pone al final tras el último elemento, eso para todos los lenguajes en sus funciones de apertura de ficheros (aquí listas pero es el mismo principio). Pues los modos de apertura write (escribir) o read (leer) en una función open() abren el fichero y situan el puntero al principio.

append es un método que tienen todas las listas para añadirle un elemento al final.

Por ejemplo:

lista = [4, 6, 8]
lista.append(5)

eso hace que nuestra lista ahora sea:

[4, 6, 8, 5]

Saludos (PD, cuando tenga algo lo publico en mi Web, saludos)

Saludos

por sierto, yo quiero trabajar tambien en un RPG pero tactico.
Saludos

Es la primera vez que escribo, pero quería felicitarte por tu trabajo en el blog, y por lo bien que me lo has “vendido” ;).

Intentaré ayudar en lo que pueda.

Para eso será la wiki, para aprender.

Saludos!

Sigue así, que se necesita y se agradece la experiencia de otros.

Saludos.

ó.ò

Un abrazo.

Abrazo y muchas gracias por la info, se valora mucho!

Saludos desde Canarias

Estas haciendo un trabajo muy bueno e interesante

Cualquiera de las dos primeras opciones seria muy buena. Debes mirar tu si estas dispuesto como te comentan arriba a mantener tantas cosas, puede ser un exceso de trabajo.

Cualquier aportacion nueva sera bienvenida

Mira por ejemplo http://softwarelibre.uca.es/wikijuegos/ es un wiki para aprender SDL desarrollando un plataformas sencillo.

Si hicieras un wiki, yo personalmente intentaría ayudar con los conocimientos que tengo tanto de Python como de Pygame.

mas info aquí: http://razonartificial.com/2010/01/curso-python-i-interprete-y-scripts/

Obviamente es la línea 4.

la única diferencia sería la barra invertida propia del sistema de Microsoft.

Quedo pendiente a nuevas entregas, gracias por compartirlo con todos :).-

Gracias, y excelente sitio!

Te animo con tu proyecto y todo es cuestión de ganas y paciencia, yo hace un año no sabía mas que hacer programas en la consola y ahora mira.

Un saludo.

Es uno de los tutoriales que mas me han gustado, aunque no tenga intencion de hacer un videojuego, solamente leyendo el tutorial(que por ahora me lo he pimplao enterito!) entran ganas de hacer uno! xD

Me alegro muchsimo que haya gente que quieran superarse y hacer que la gente aprenda de lo aprendido y te animo a que sigas indagando sobre el tema.

A mi me anda rondando la idea de montar un sistema base sobre php para creacion de paginas web con gestor de contenido, en lo que todo sea automatizado y a la vez gestionado por el propio usuario (con los quebraderos de cabeza que eso conlleva… xD).. algun dia de estos caera la breba pero hasta entonces, me encantara leer articulos como el tuyo!

El conocimiento no ocupa lugar, y en nuestra profesion… es nuestro principal arma!!!!

Un abrazo! :D

De Python no tengo ni idea, pero lo mismo un día me pongo y lo hago en Java que es lo mio.

En todo caso ánimo, te está quedando un tutorial muy en condiciones ^^.

Emlett, puedes usar el foro para exponer tu proyecto así entre todos podemos ayudarte y demás.

Muchas gracias y sigue asi, tienes todo nuestro apollo!!!! =)

Luego tener un foro que haga esto más grande, donde vosotros podáis participar.

gracias!

Hay varias cosas para hacer una I.A. mucho más realista, pero no entran en este tutorial en el que se pretende enseñar la base de Pygame y no técnicas de I.A.

Un saludo.

A nivel amateur como es nuestro caso, yo que me siento programador pues prefiero hacerlo así porque lo que me gusta es resolver problemas y ver como puedo hacer las cosas por mí mismo. No espero que este proyecto compita con el maker, pero si divertirme haciéndolo y aprender como se hacen videojuegos desde 0. Y si de paso al poner mi experiencia aquí a alguien le sirve pues mejor que mejor.

Gracias por seguir los artículos, con que haya alguien interesado en él ya es un motivo para exponer aquí los avances, ya estoy trabajando en nuevas entregas.

Saludos!

En cuando a lo que dices con el uso de xrange, pues no lo sabía que python optimizaba su uso. Es algo a tener en cuenta, sobre todo para juegos donde es importante optimizar.

Por cierto, puedes usar las etiquetas ["python"] (sin comillas) para poner código.

En cuando a lo que propones, en cuanto corrija el comentario comento.

mapa, x, y, z = self.capas, xrange(len(self.capas)), xrange(self.height), xrange(self.width)
evalua = lambda x: self.tileset(x) if x else None
for i in x:
    for f in y:
        for c in z:
            mapa[i][f][c] = evalua(self.capas[i][f][c])
self.mapa = mapa

El modo mas “procedimental” queda así:

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

Que diferencia hay? Pues bueno, primero que utilizo XRANGE y no RANGE. Cual es la diferencia? Pues es algo substancial.

Si yo hago un range(10000000) se computan todos sus elementos [1,2,3,4,5...1000000], y después se itera por cada uno de los elementos. Pero si lo hago con un XRANGE: xrange(1000000), tansolo se computa el elemento que necesita el FOR, osea, no se computa toda la lista entera, sinó que va creando elementos a medida que el FOR los va necesitando.

Parece una tontería, pero así se optimiza el código. Estos procesos se llaman “lazy”. Y por otra parte, antes de llegar a la condición he guardado el valor de “element”. Esto se puede hacer así, otra vez, por un tema de rendimiento. Como “self.capas[i][f][ c ]” está repetido dos veces, Python tendrá que iterar dos veces para encontrar esta posición, en cambio si la guardamos, tan solo tiene que iterar la primera vez para tener el valor deseado. Esta segunda optimización no creo que se note demasiado ( a diferencia del RANGE o XRANGE ), pero seguro que también ayuda.

Tan solo dejo ideas para resolver el mismo problema con diferentes enfoques. Saludos!!

data {
____”nombre”:”admin”
____”apellido”:”istrador”
____”telefonos”:["75566", "+34-887744"]
}

Si queremos ampliar los datos, se puede hacer de este modo:
data["edad"] = 20

Así nos quedaría algo así:
data {
____”nombre”:”admin”
____”apellido”:”istrador”
____”telefonos”:["75566", "+34-887744"]
____”edad”:20
}

La ventaja es que con JSON, se convierten estos datos a string, y así se persisten el el disco, de modo que podemos prescindir de utilizar estructuras “complejas” como el XML.

Sobre el “coste” que tu dices, es algo irrelevante. Me explico: Si tu tienes un XML, cuando se lee de disco y se envía a “minidom.parse()”, se tiene que parsear todo el fichero. Osea, que lo tienes que cargar todo en memória igual. Parsear XML no es ( computacionalmente hablando ) algo barato. Mucho mas rapido el “eval” de Python.

Claro está que todo tiene inconvenientes. Entre ellos, que no te da la facilidad de enviar los datos a otro programa hecho con Java, o PHP, por ejemplo, ya que XML ( desgraciadamente ) está mas “estandarizado”. Aún así existen librerías de JSON en la mayoría de los lenguajes.

Pero bueno, si solo se va a trabajar en Python, es una muy buena elección. Saludos!

Miraré esto y veré si es mejor para el engine. Sí es así, lo implementamos.

Muchas gracias por colaborar, que bonito sería que este engine fuera un poquito de todos.

Un saludo.

maps = {
____”width”:22,
____”heigth”:44,
____”data”: {
________”tileset”: {
____________”width”:3,
____________”height”:3,
____________”nombre”:”nombre1″,
________},
________”layer”:”datos de layer”
________”objectgroup”: {
____________”x”: 44,
____________”y”: 22,
________}
____}
}

Par guardar:
import simplejson as json
f = open(‘mapa1.tmx’, ‘w’)
f.save(json.dumps(maps))
f.close()

Para leer:
f = open(‘mapa1.tmx’, ‘r’)
data = eval(f.save(json.loads(f.read())))
f.close()

Y así tienes una estructura facilmente accesible, de modo que aciendo un
“data['width']” tienes el with, o haciendo un:
“data['data']['objectgroup']['x']” tienes “44″

Todo tipos de datos nativos en python, facilmente manejables. Es solo un humilde comentario, sin ánimo de cambiar nada, solo dar otro enfoque al mismo problema. Saludos!

Podría poner las salidas de consola, pero ocuparían muchas las largas listas y creo que el que esté siguiendo el tutorial en serio no tendrá problema en verlos.

De todas maneras si tienes curiosidad, por como trabajo y lo que estoy viendo yo ahora mismo, aquí te dejo una captura: http://img41.imageshack.us/img41/3339/pantallazoyz.png

Por cierto, gran representación y ejemplo que has puesto, puede que así quede más claro para el que no lo entienda bien. Muchas gracias por colaborar, vuestros comentarios mejoran los tutoriales.

[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
[[0, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Que ordenado sería equivalente a la representación de las casillas en las 2 capas del siguiente modo:

Capa 1 ( todo relleno con el elemento [1] )
[1, 1, 1, 1]
[1, 1, 1, 1]
[1, 1, 1, 1]
[1, 1, 1, 1]

Capa 2 ( todo vacío salvo el elemento 3x,2y que era el objeto en el tile nº2 )
[0, 0, 0, 0]
[0, 0, 2, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]

Me imagino que el siguiente paso en el engine será hacer el sistema que cargue la imagen del tile e imprima la sección entre los puntos:

[elemento-1]*tamañoX , [elemento-1]*tamaño2X
[elemento-1]*tamañoY , [elemento-1]*tamaño2Y

que darían las coordenadas de los 4 puntos para extraer el segmento de la imagen correspondiente.

Espero al menos haber ayudado un poco a pesar de ser un mero comentario de aficionado que no tiene ( de momento ) ni puta idea de python salvo a nivel básico de consola xD

Gracias a todos.

Otro abrazo desde Gran Canaria ;)

Un abrazo desde Tenerife ;-)

Donde puedo bajar el fuente completo ?

gracias.

Un saludo.

Están muy muy bien estos tutoriales, he visto muchos por diversos sitios, pero tu lo haces muy bien paso a paso.

Me he llevado un chasco, no me esperaba que el engine fuese “tan reciente” que aun no se ha terminado, jeje. Bueno, pues nada, a esperar, asi voy practicando por mi cuenta

Un saludo

De todas maneras cualquier duda sobre ellos comenta y tratare de resolverla.

Por cierto, donde podría encontrar algo más de información sobre los rects?

Para grillas de Nodos no tan grande obviamente no es tan determinante.

Yo he usado un A* para realizar el juego del Wumpus por lo que la velocidad no es algo que se notara (apenas unos pocos nodos).

Haces fácil lo difícil xD.

Saludos.

En próximas cosas que haga intentaré usar gráficos libres.

PD: Gráficos RPG Maker XP, no me lo esperaba xD

muy buen diseño. Pero hay un fallo en el apartado de licencia, ya que el título pone “Lecencia”

Un saludo,

Se intentará que lo que haya en el blog sea útil y de aplicación real.

Ojala haya mas artículos como este xD.

Si ejecutas el código con doble click se te abrirá y cuando termine de ejecutarse el script se cierra, por eso que no dura más de un segundo, la solución es ejecutarlo desde consola para que no se cierre.

bueno sigue con el tutorial que esta bastante bueno.

1. con el wordpad: escribi (print “hola mundo”)
2. lo guarde con la extencion .py.
3. luego fui donde tenia el archi llamado hola.py y le di doble click. se abría una ventana y rapidamente se cerraba, osea menos de un segundo pero no decia hola mundo.

escribi en la consola hola.py y obtuve el error traceback.
creyendo que podia ser el wordpad. decidi utilizar el idle que biene con el programa python 2.6.4
pero al guardarlo con la extencion .py nada cambio.

¿que hice mal?

Vas a continuar con el curso de Python?

solo quería felicitarte por el tutorial, he llegado a él a través de la página de pygame.org y me ha parecido estupendo.

¡Gracias!

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.direccion = self.aleatorio(1, 1, 4)
if self.direccion == 1:
self.speed = [0.3, -0.1]
elif self.direccion == 2:
self.speed = [-0.3, 0.1]
elif self.direccion == 3:
self.speed = [-0.3, -0.1]
elif self.direccion == 4:
self.speed = [0.3, 0.1]

def aleatorio(self, rango, a, b):
for i in range(rango):
return random.randint(a, b)

def actualizar(self, tiempo, pala_jug, pala_cpu, puntos):
self.rect.centerx += self.speed[0] * tiempo
self.rect.centery += self.speed[1] * tiempo

if self.rect.left = WIDTH:
puntos[0] += 1
self.__init__()

if self.rect.left = WIDTH:
self.speed[0] = -self.speed[0]
self.rect.centerx += self.speed[0] * tiempo
if self.rect.top = HEIGHT:
self.speed[1] = -self.speed[1]
self.rect.centery += self.speed[1] * tiempo

if pygame.sprite.collide_rect(self, pala_jug):
self.speed[0] = -self.speed[0]
self.rect.centerx += self.speed[0] * tiempo

if pygame.sprite.collide_rect(self, pala_cpu):
self.speed[0] = -self.speed[0]
self.rect.centerx += self.speed[0] * tiempo

return puntos

sabes pork puede pasar esto?

Es mejor que cuando detecte la pared añadas esto:

self.rect = (WIDH/2, HEIGHT/2)

esto hace que el rect de la bola tenga las coordenadas del centro de la ventana.

Hago la comprobación dos veces porque ahorra código porque la línea 33 cambia la dirección de la pelota independientemente de que sea la pared izquierda o derecha, sin embargo, para los puntos necesitamos controlar en que pared da para asignárselos a uno u otro.

es algo lioso pero cuando le pillas el truco va bastante bien

:)

A modo de comentario, decir que sobran las líneas 33, 34 y 35 ya que la comprobación se hace en las líneas anteriores, donde se aumenta la puntuación.

también me gustaría hacer una pregunta… ¿alguien sabe como crear un ejecutable del juego en mac?

Pero si saco esas líneas, no cambia nada cuando ejecuto el programa, aunque use eñes y tildes…

Y sí tengo un directorio images con un archivo fondo.jpg dentro, pero tengo que escribir la ruta completa en la función. “C:\\Python26\\proyectos\\pygame\\images\\fondo.jpg”, si pongo eso funciona (el archivo está en el directorio pygame). Creo que si el directorio estuviera en C:\ funcionaría sólo poniendo “images\\fondo.jpg”.

La Segunda es la codificación de caracteres, utf-8, para poder poner tildes, eñes y demás.

Eso es porque no tienes la carpeta imágenes dentro del directorio del archivo.

Y segundo, tengo que poner el path entero en el load_image, si pongo sólo “images\\fondo.jpg” tira error (uso windows).

# -*- coding: utf-8 -*-

porque el tipo de codificación depende del editor que se esté usando y no del comentario que le quieras poner.

Mientras tanto hice unas pruebitas y logré que la pelota vuelva al centro y salga para el lado del que sumó el punto, pero igual es muy repentino, lo tengo que revisar…

Gracias por todo! ;)

La idea era que al anotar un punto la pelota vuelve automáticamente al centro y no hay posibilidad de que rebote otra vez, pero todavía no esta implementado en el juego, en próximos tutoriales lo haré.

La razón de eso es que el juego primero lo programe yo entero con las variables en inglés y luego lo fui montando poco a poco en otro archivo para hacer el tutorial y en este decidí poner las variables en español para mayos compresión, pero a la hora de pones el código se me paso por lo que veo.

En la línea que indicas que hay que agregar

ball = Ball()

debería ser

bola = Bola()

lo mismo en

screen.blit(ball.image, ball.rect)

debería ser

screen.blit(bola.image, bola.rect)

en el código del programa completo está bien.

Otro problema es que cuando la pelotita queda atrapada entre la pared y la pala, rebota y le suma muchos puntos de golpe al adversario, supongo que podría solucionarse con ponerle un tiempo mínimo de espera al sumado de puntos y que no sea inmediato…

Además al final de cada tutorial pongo todo el código para que con solo ejecutarlo lo veas funcionar.

De hecho estoy haciendo ahora un motor de un rpg en pygame con ese estilo, pronto publicaré algo del tema en el blog.

Paco.

PD: Una imagen vale mas que mil palabras…

Por ejemplo un robot que calcula la distancia que hay con una pared para no chocarse, realmente lo que esta haciendo es enviar un ultrasonido y según lo que tarde en llegarle el rebote sabe lo cerca que está de la pared, es decir, el robot solo sabe que si el parámetro tal es menor que un valor preestablecido no debe continuar, pero no entiende el por qué.

Luego lo que dices del aprendizaje, realmente por eso se llaman Sistemas Expertos, porque son hechos por expertos en la materia. Es un sistema experto por que un humano experto o otra máquina experta (programada esta por un humano siempre) la programo.

Le he estado dando vueltas al tema. Si quieres hacer una aplicacions que haga calculos de física, deberás ser un físico. Si quieres hacer calculos económicos, deberás saber muchísima economia. De momento, no hay ningún sistema de programación o ningún lenguaje que nos permita crear una base para que el que mismo programa aprenda el solo, con tansolo ir “guiando” el proceso de aprendizaje… Igual me guste demasiado la ciencia ficción, pero encuentro un campo muy interesante todo lo que se refiere a crear programas que dan siempre una solución diferente al problema ( GA ).

Haber si tengo tiempo de leerme todos los artículos que has publicado. Estaremos en contacto en breve. Por cierto, estoy reescribiendo tu codigo de el ejercicio de los “caballos” pero haciendo uso de la programación funcional. Cuando acabe si quieres te mando el codigo. Saludos!

Una máquina dudo que algún día llegue a tener conciencia de sí misma, al menos maquinas basadas en lo que hoy conocemos, basadas en 1s y 0s. Y para mi esa es la clave, algo que no puede ser consciente de si mismo no puede poseer verdadera inteligencia.

Un saludo desde Gran Canaria.

Yo he jugado solamente con Algoritmos Genéticos. Calcular la ruta más optima, el problema de la mochila, problema de las N reinas… y estos algoritmos geneticos tan simples, *solo* hacen lo que se les ha programado. Única y exclusivamente. No siempre dan el mismo resultado, cierto. Pero esto es una característica de los GA. Aunque es un tema que encuentro muy interesante, me pregunto si realmente se puede programar una maquina creando “inteligencia” y no haciendo programas muy complejor que “aparentan” ser inteligentes.

Me encataría saber tu opinión al respecto. Saludos desde Mallorca ;)

Aunque en realidad no está bien claro lo que se entiende por inteligencia artificial, te dejo un artículo que escribí hace tiempo con hasta 8 definiciones del concepto IA.

http://razonartificial.com/2010/01/que-es-inteligencia-artificial/

Es esta http://razonartificial.com/wp-content/uploads/2010/02/pala.png

Por ejemplo imagina que yo en el archivo ese tengo un montón de clases y funciones que quiero usar en otro programa y lo importo, en tal caso al comprobar que no se está ejecutando como principal no me ejecuta la función main(), ni inicializa python.

No lo comento en el tutorial porque que es un tema acerca de Python y no de pygame.

Un saludo.

if __name__ == ‘__main__’:

¿Podrías comentar lo que hace esa línea en el código o en algún comentario del post? No entiendo si se trata de constantes, variables o qué…

En cualquier caso buen trabajo y gracias por el recurso.