Comportamiento de IA y Sistema de Puntuación - Pygame

Hola gente, hoy les voy a mostrar como hacer que podamos jugar contra la PC en nuetro juego de Pong, lo cual, es bastante sencillo.

Crear una pala para la PC

Antes que nada, tenemos que crear otra "raqueta", para esto primeramente debemos colocar en nuestro codigo:

 raq_pc = Raqueta(640 - 30)

En el anterior post le dimos a raq_jug el valor 30 porque, queriamos que estuviera a 30 pixeles de el lado izquierdo de la pantalla, ahora lo que hacemos, es que este a 30 pixeles del lado derecho la pantalla.

 pantalla.blit(raq_pc.imagen, raq_pc.rect)

Con esto, ya tenemos listo nuestro sprite para la pc. Lo siguiente ahora, es hacer tambien detecte las colisiones, para ello debemos volver a actualizar nuestra funcion actualizar.

def actualizar(self, time, raq_jug, raq_pc):
 self.rect.centerx += self.speed[0] * time
 self.rect.centery += self.speed[1] * time
 if self.rect.left <= 0 or self.rect.right >= 640:
  self.speed[0] = -self.speed[0]
  self.rect.centerx += self.speed[0] * time
 if self.rect.top <= 0 or self.rect.bottom >= 480:
  self.speed[1] = -self.speed[1]
  self.rect.centery += self.speed[1] * time
 if pygame.sprite.collide_rect(self, raq_jug):
  self.speed[0] = -self.speed[0]
  self.rect.centerx += self.speed[0] * time
        if pygame.sprite.collide_rect(self, raq_pc):
                self.speed[0] = -self.speed[0]
                self.rect.centerx += self.speed[0] * time

Ahora le agregamos raq_pc y le agregamos la misma condicion que raq_jug para verificar si ha colisionado con la pelota.

Recuerden pasarle el parametro nuevo a la línea que llama a la función actualizar de la pelota en el bucle del juego. Así:

pelota.actualizar(time, raq_jug, raq_pc)

Dandole "inteligencia" a la raqueta de la PC

Ahora viene lo nuevo, vamos a darle un comportamiento a la raqueta de la pc para que podamos jugar contra ella. Para ello, crearemos la funcion ia (inteligencia artificial)

def ia(self, time, pelota):
    if pelota.speed[0] >= 0 and pelota.rect.centerx >= 640/2:
        if self.rect.centery < pelota.rect.centery:
            self.rect.centery += self.speed * time
        if self.rect.centery > pelota.rect.centery:
            self.rect.centery -= self.speed * time

En la línea 1 vemos que recibe como siempre self y time y aparte recibe pelota que es la pelota (duh), pero es necesario porque la funcion necesita conocer donde está la pelota.

En la línea 2 comprobamos que pelota.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 rqueta de la pc) y tambien comprueba que pelota.rect.centerx >= 640/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 raqueta de la cpu y que este en su campo, sino, que no se mueva. Esto se hace para que la PC 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 raqueta, es decir si la raqueta 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 hay que llamar a la ia junto con las llamadas actualizar de la pelota y mover de la raqueta de la cpu.

raq_pc.ia(time, pelota)

Con esto, el juego se vuelve jugable, pero no contamos ni con sistema de puntuacion, ni con sonidos, asi que...

Sistema de Puntuacion

en la proxima entrada ;D

Control del teclado y Colisiones - Pygame

Hola gente, hoy les voy a mostrar como revisar la entrada del teclado para usarla en el juego y tambien estaremos revisando las colisiones.

Continuaremos haciendo nuestro juego Pong, y lo que vamos a controlar por teclado, van a ser las "raquetas" del juego. para ello, crearemos la clase para ella y haremos su sprite:

 class Raqueta(pygame.sprite.Sprite):

     def __init__(self, x):
           pygame.sprite.Sprite.__init__(self)
           self.imagen = cargar_imagen("datos/raqueta.png")
           self.rect = self.imagen.get_rect()

           self.rect.centerx = x
           self.rect.centery = 480 / 2
           self.speed = 0.5

Para la imagen voy a usar esta.
Como vemos en el codigo, es igualito a la de la pelota, pero ahora le pasamos x en vez de 640 / 2 , esto es para que podamos variar la altura de la raqueta, y para que mas tarde coloquemos a que distancia de la pared izquerda este, y el otro cambio, es que solo le pasamos un valor para speed porque solo se movera por el eje x.

Para crear la raqueta, ya saben como es:

 raq_jug = Raqueta(30)
 

Vamos a hacer que se pueda jugar contra la pc, por eso le puse raq_jug, porque despues voy a poner raq_cpu, y le pase el parametro 30 (que va a ir como valor de x), para que este a una distancia de 30 px del borde derecho de la ventana.

Por ultimo, dentro del bucle, lo de siempre, despues de actualizar el fondo y la pelota, actualizamos la raqueta

 pantalla.blit(raq_jug.imagen, raq_jug.rect)

Moviendo la Raqueta

Para controlar la raqueta, definiremos la funcion mover dentro de la clase Raqueta:

 def mover(self, time, teclas):
     if self.rect.top >= 0:
         if teclas[K_UP]:
             self.rect.centery -= self.speed * time
     if self.rect.bottom <= 480:
         if teclas[K_DOWN]:
             self.rect.centery += self.speed * time

Esta funcion, hereda los parametros self y time como la funcion actualizar de la pelota, y tambien recibe el parametro teclas, que luego definiremos, y que sera una lista con el valor de las teclas pulsadas.

La línea 2 y 5 comprueban que la raqueta no se salga 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 raqueta se mueva hacia arriba.

La línea 6 y 7 hacen lo mismo, pero para abajo y aumentando el valor de centery.

Ahora solo tenemos que saber que teclas se estan pulsando, creando la variable teclas, esto se hace de la siguiente forma (despues de comprobar el tiempo transcurrido con time)

 teclas = pygame.key.get_pressed()

Esto nos devuelve las teclas pulsadas en una lista.

Por ultimo, debemos llamar a la funcion mover en el bucle, justo despues de actualizar la pelota, con la linea:

 raq_jug.mover(time, teclas)

Bien, entonces, si ejecutan su programa ahora, lo que van a tener, es una pala moviendose de arriba a abajo y una pelota que la atravieza, pero no se preocupen, ahora vamos a controlar la colision.

Actualizando la funcion actualizar de la clase Pelota

Para saber si un sprite choca con otro es facil, solo hay que ejecutar la funcion:

 pygame.sprite.collide_rect(objeto1, objeto2)

Esto comprueba si el rectangulo del Sprite objeto1 esta colisionando con el rectangulo de objeto 2,
entonces, solo basta con agregarle una condicional a la funcion actualizar (y tambien le decimos que herede de raq_jug) dentro de la clase pelota:

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

Como vemos, hacemos que cuando la pelota "choque" con la pala, esta cambie de direccion/
No tenemos que olvidarnos de agregarle el parametro raq_jug cuando llamamos la funcion, raqueta.actualizar(time, raq_jug)
y con esto, ya logramos que la pelota choque contra la raqueta y que valla hacia el otro lado.
El código, nos quedaria asi:

#importamos librerias
import pygame
from pygame.locals import *

#iniciamos pygame
pygame.init()

#definimos constantes
pantalla = pygame.display.set_mode((640, 480))
pygame.display.set_caption('Titulo de ventana')

reloj = pygame.time.Clock()

#definimos clases
class Pelota(pygame.sprite.Sprite):
 def __init__(self):
  pygame.sprite.Sprite.__init__(self)
  self.imagen = cargar_imagen("datos/pelota.png", True)
  self.rect = self.imagen.get_rect()
  self.rect.centerx = 640 / 2
  self.rect.centery = 480 / 2
  self.speed = [0.2, -0.2]
 def actualizar(self, time, raq_jug):
  self.rect.centerx += self.speed[0] * time
  self.rect.centery += self.speed[1] * time
  if self.rect.left <= 0 or self.rect.right >= 640:
   self.speed[0] = -self.speed[0]
   self.rect.centerx += self.speed[0] * time
  if self.rect.top <= 0 or self.rect.bottom >= 480:
   self.speed[1] = -self.speed[1]
   self.rect.centery += self.speed[1] * time
  if pygame.sprite.collide_rect(self, raq_jug):
   self.speed[0] = -self.speed[0]
   self.rect.centerx += self.speed[0] * time


class Raqueta(pygame.sprite.Sprite):
 def __init__(self, x):
  pygame.sprite.Sprite.__init__(self)
  self.imagen = cargar_imagen("datos/raqueta.png")   
                self.rect = self.imagen.get_rect()
  self.rect.centerx = x
  self.rect.centery = 480 / 2
  self.speed = 0.5
 def mover(self, time, teclas):
  if self.rect.top >= 0:
   if teclas[K_UP]:
    self.rect.centery -= self.speed * time
  if self.rect.bottom <= 480:
   if teclas[K_DOWN]:
    self.rect.centery += self.speed * time



#definimos funciones
def cargar_imagen(nombre,transparente=False):
     try: imagen = pygame.image.load(nombre)

     except pygame.error, message:
          raise SystemExit, message
     imagen = imagen.convert()
     if transparente:
          color = imagen.get_at((0,0))
          imagen.set_colorkey(color, RLEACCEL)
     return imagen
  
fondo = cargar_imagen('datos/fondo.png')
pelota = Pelota()
raq_jug = Raqueta(30)
 
#Bucle principal del juego
while 1:
 time = reloj.tick(200)
 pelota.actualizar(time, raq_jug)
 teclas = pygame.key.get_pressed()
 raq_jug.mover(time, teclas)
 
 for event in pygame.event.get():
  if event.type == QUIT:
   pygame.quit()
   sys.exit()
  elif event.type == KEYDOWN:
   if event.type == K_ESCAPE:
    pygame.quit()
    sys.exit()
 pantalla.blit(fondo, (0, 0)) 
 pantalla.blit(pelota.imagen, pelota.rect)
 pantalla.blit(raq_jug.imagen, raq_jug.rect)
 pygame.display.flip()

Mañana le agregaremos raq_cpu para que podamos jugar contra la pc :D

Colocando sprites y darles movimiento - Pygame

Hola gente, hoy les voy a mostrar como colocar un sprite en la pantalla, posicionarlo, y darle movimiento.

Vamos a apuntar hacia hacer un juego simple, el clasico pong, y utilizaremos el codigo de mi anterior post, pero cambiaremos el fondo, colocandole uno mas apropiado, yo utilizare la siguiente imagen:

y para la pelota esta imagen:




ok, entonces tenemos nuestras imagenes (no se olviden de ponerlas en la carpeta del juego y cambiarle el nombre al fondo en el codigo).

La clase pelota

Lo siguiente es crear una clase que contenga la pelota y sus propiedades de sprite:

class Pelota(pygame.sprite.Sprite):
      def __init__(self):
          pygame.sprite.Sprite.__init__(self)
          self.imagen = cargar_imagen("datos/pelota.png", True)
          self.rect = self.imagen.get_rect()
          self.rect.centerx = 640 / 2
          self.rect.centery = 480 / 2
          self.speed = [0.5, -0.5]

La línea 1 crea la clase pelota 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 la funcion (o metodo)  __init__ que inicializa la clase.

La línea 3 invoca a la funcion init de la clase heredada, muy importante también y difícil de explicar.

La línea 4 ya nos suena más y lo que hace es cargar con nuestra función cargar_imagen() 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

Aqui quiero comentar sobre los parametros utiles con los que cuenta get_rect(), ellos 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.

Volviendo al codigo, en la linea 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.

La linea 8 define la velocidad que queremos para la pelota, separamos la velocidad en dos, para los ejes x y, luego veremos porque.

Colocando la pelota en la ventana

Ya que tenemos una clase creada para la pelota, vamos a crear la pelota

pelota = Pelota()

Ahora solo tenemos que "pegarla" en nuestra ventana con el siguiente comando

pantalla.blit(pelota.imagen, pelota.rect)

Como se puede ver no le pasamos la imagen ahora, y en vez de unas coordenadas como con el fondo, le pasamos el rect de la pelota, con esto conseguiremos que cada vez que movamos el rect, moveremos la pelota.

Es muy importante "ponerla en pantalla despues que el fondo" porque si primero colocamos la pelota y luego el fondo, esta no se veria porque quedaria detras del fondo.

Con esto, ya tenemos a nuestra pelota colocada encima de nuestro fondo, pero todo esta estatico.
Para cambiar eso, le agregaremos movimiento

El metodo actualizar

Para mover la pelota, crearemos un metodo llamado actualizar dentro de la clase Pelota, y esto controlara el movimiento de la pelota, y si choca contra los bordes de la ventana.
La funcion es la 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 >= 640:
  self.speed[0] = -self.speed[0]
  self.rect.centerx += self.speed[0] * time
 if self.rect.top <= 0 or self.rect.bottom >= 480:
  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.

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, 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.

Debemos actualizar la posicion de la pelota a medida que transcurre el juego, esto es simple, solo basta con poner

pelota.actualizar(time)

Entonces, ahora nuestro codigo quedaria asi

#importamos librerias
import pygame
from pygame.locals import *

#iniciamos pygame
pygame.init()

#definimos constantes
pantalla = pygame.display.set_mode((640, 480))
pygame.display.set_caption('Titulo de ventana')

reloj = pygame.time.Clock()

#definimos clases
class Pelota(pygame.sprite.Sprite):
 def __init__(self):
  pygame.sprite.Sprite.__init__(self)
  self.imagen = cargar_imagen("datos/pelota.png", True)
  self.rect = self.imagen.get_rect()
  self.rect.centerx = 640 / 2
  self.rect.centery = 480 / 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 >= 640:
   self.speed[0] = -self.speed[0]
   self.rect.centerx += self.speed[0] * time
  if self.rect.top <= 0 or self.rect.bottom >= 480:
   self.speed[1] = -self.speed[1]
   self.rect.centery += self.speed[1] * time



#definimos funciones
def cargar_imagen(nombre,transparente=False):
     try: imagen = pygame.image.load(nombre)

     except pygame.error, message:
          raise SystemExit, message
     imagen = imagen.convert()
     if transparente:
          color = imagen.get_at((0,0))
          imagen.set_colorkey(color, RLEACCEL)
     return imagen

fondo = cargar_imagen('datos/fondo.png')
pelota = Pelota()

#Bucle principal del juego
while 1:
 time = reloj.tick(60)
 pelota.actualizar(time)
 for event in pygame.event.get():
  if event.type == QUIT:
   pygame.quit()
   sys.exit()
  elif event.type == KEYDOWN:
   if event.type == K_ESCAPE:
    pygame.quit()
    sys.exit()
 pantalla.blit(fondo, (0, 0)) 
 pantalla.blit(pelota.imagen, pelota.rect)
 pygame.display.flip()

Y listo!  ahora ya tenemos una pelota que se mueve por la pantalla :) , en los proximos tutoriales iremos completando este juego.

Poniendo un fondo a la pantalla - Pygame

Continuando con mi anterior post, hoy les voy a mostrar como colocarle un fondo a la pantalla.

Para cargar un archivo de imagen, definiremos una funcion que nos facilite el trabajo

def cargar_imagen(nombre,trasnparent=False):
     try: imagen = pygame.image.load(nombre)

     except pygame.error, message:
          raise SystemExit, message
     imagen = imagen.convert()
     if transparent:
          color = imagen.get_at((0,0))
          imagen.set_colorkey(color, RLEACCEL)
     return imagen

Ahora lo explicare línea por línea:

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 quedaría asi:

#importamos librerias
import pygame
from pygame.locals import *

#iniciamos pygame
pygame.init()

#definimos constantes
pantalla = pygame.display.set_mode((640, 480))
pygame.display.set_caption('Titulo de ventana')

reloj = pygame.time.Clock()

#definimos funciones
def cargar_imagen(nombre,transparente=False):
     try: imagen = pygame.image.load(nombre)

     except pygame.error, message:
          raise SystemExit, message
     imagen = imagen.convert()
     if transparente:
          color = imagen.get_at((0,0))
          imagen.set_colorkey(color, RLEACCEL)
     return imagen

#Aqui es donde colocamos el fondo a la pantalla
fondo = cargar_imagen('datos/fondo.jpg')
pantalla.blit(fondo, (0, 0)) #es para esto que nos sirvio poner en una 
                             #variable los datos de la pantalla
pygame.display.flip()

#Bucle principal del juego
while 1:
 for event in pygame.event.get():
  if event.type == QUIT:
   pygame.quit()
   sys.exit()
  elif event.type == KEYDOWN:
   if event.type == K_ESCAPE:
    pygame.quit()
    sys.exit()

 pygame.display.update()
 reloj.tick(60)

Y aqui tenemos ya nuestro programa con un fondo, ustedes pueden poner el que guste, yo use éste.
La imagen tienen que ponerla en una carpeta llamada datos, en la carpeta donde tienen guardado el programa para que éste codigo les funcione, osino tienen que quitar 'datos/fondo.jgp' y dejar solo 'fondo.jpg' para que no tengan que crear esa carpeta.

Pregunten cualquier duda que tengan ^_^

Comenzando a programar juegos con python y pygame

Buenas Gente!

Hola a todos, este es mi primer blog y sepan que estoy aprendiendo. Estaré muy agradecido por cualquier recomendacion y/o crítica constructiva que tengan para mejorar este blog.

Ah que bien, entonces... De que va a ir el blog?

Éste blog tratará sobre programación. Mis primeras entradas serán acerca de
Pygame, ya que estoy trabajando en un proyecto para el bachillerato, el cual es hacer un
videojuego. Y como tengo un conocimiento aceptable sobre python, he decidido usar este
lenguaje.


Python es un lenguaje escrito en C y es bastante sencillo leerlo, es un lenguaje de alto nivel y no cuesta nada aprenderlo, a mi me parecio agradable, y cuando me enteré de que existía Pygame, me decidí a investigar para hacer videojuegos. El proyecto en cuanto a historia esta casi completo, y estoy trabajando junto con otras 2 personas que son mis condiscipulos en el bachillerato, los cuales me ayudan con la documentacion y el diseño de los personajes. Pero antes de llegar a ese nivel, tenemos que comenzar con cosas simples no? :)  Asi que explicare todas las cosas que aprendí y las que voy aprendiendo a medida que me profundizo en este lenguaje.

Ahora bien,

Qué es Pygame?

Pygame es un conjunto de módulos de Python diseñado para escribir juegos, y está publicado
bajo la licencia GPL.  Agrega funcionalidad de la librería SDL y además, esta bien documentado, y se pueden encontrar tutoriales y preguntar con facilidad (siempre que uno sepa inglés). Para más información acerca de pygame, visiten la página oficial de Pygame (está en inglés :p).

Yo voy a usar Python 2.7 porque me gusta más, si quieres usar Python 3 no hay ningún problema, solo recuerda usar la versión de pygame indicada para tu versión de python, tambien revisa si utilizas la versión de 32 bits o de 64 bits.

Ya veran que aprender a usar pygame es muy sencillo, y como me voy a concentrar en eso, les voy a decir que si no saben python, tomense un ratito al dia y aprendanlo, porque es muy facil.

Creando una ventana en pygame.

Ok, comenzemos!

import pygame 

from pygame.locals import *

pygame.init() 

pantalla = pygame.display.set_mode((640, 480))

pygame.display.set_caption('Titulo de ventana')

reloj = pygame.time.Clock() 

while 1:

     for event in pygame.event.get():

          if event.type == QUIT:

             pygame.quit() 

             sys.exit()

          elif event.type == KEYDOWN:

             if event.key == K_ESCAPE:

                pygame.quit()

                sys.exit()

     pygame.display.update()

     reloj.tick(60) 

Bien, voy a explicar el codigo, con "import pygame" importamos la libreria que les mencione al comienzo del post. Y si vamos a usar comandos para leer entradas por teclado o mouse del usuario, debemos poner tambien "from pygame.locals import * " porque es alli donde estan esas constantes, de otra forma, nos daria un error diciendo que las constantes QUIT, MOUSEMOTION, KEYDOWN, etc. no estan definidas.

Luego iniciamos pygame con la funcion 'pygame.init()', es necesario que hagamos esto, antes de que utilizemos algun comando de pygame. Con 'pygame.display.set_mode' le damos un tamaño a la ventana, y este valor lo guardamos en 'pantalla' esto de momento no nos es de utilidad, pero mas adelante ya veremos que esto nos sera util. 'pygame.display.set_caption' (como es obvio) es un comando que nos sirve para ponerle un titulo a la ventana. 'pygame.time.Clock' es un comando muy importante, ya que nos sirve para controlar la velocidad del juego.

Ahora iniciamos el bucle principal del juego, y ponemos otro bucle para revisar la lista de eventos de pygame y comprobar si el usuario ha presionado la tecla Escape, o la X (QUIT) para cerrar la ventana y asi poder salir. Seguidamente, afuera del bucle mostramos la escena con 'pygame.display.update' y decimos a cuantos fps queremos que ande el juego.

Bien, mañana estare publicando una entrada nueva, y voy a hablar sobre como poner un fondo y como interactuar con el. :)

Aqui un pensamiento mio sobre este lenguaje:

Segun tengo entendido, cada fps es una vuelta del bucle principal del juego, esto supone que si tengo que hacer un videojuego muy complicado, la velocidad de este se veria reducida. Entonces, cual es la solucion?. Pues no hacer el videojuego en python, porque hay lenguajes que manejan mejor los objetos y con mas precision y con alocacion de memoria a mano, etc. En si, un juego con comandos mas complicados y explicitos que python y pygame no nos los piden, para facilitarnos el trabajo (esto a cambio de rendimiento). Pero para lo que voy a hacer no es necesario, no tengo pensado hacer algo en 3D o que muuuuchos objetos diferentes interactuen entre si al mismo tiempo con caracteristicas distintas cada uno. En fin, no es lo que busco, y ademas es mas facil aprender python y pygame.