Crea tus juegos

Juegos para navegadores II

2009-08-05T15:00:00.002-04:00

A pasado ya mas de un año de la ultima vez que escribi en este tema, pero he estado trabajando principalmente en diseño web y aprendido algún par de cosas interesantes de mencionar.

En primer lugar debo mencionar que asi como existen frameworks para python y ruby que son lenguajes sencillos de aprender, tambien existen frameworks para php que simplifican mucho el trabajo, yo se que antes dije que php era lenguaje un tanto criptico, pero la verdad es que es cosa de costumbres y la mayoria de los frameworks te hacen la mayor parte del trabajo.

actualmente existen muchos y cada dia salen nuevos frameworks, la mayoria de ellos inclusive son gratis y de licencias libres, en particular debo mencionar los dos que mas me gustan, estos son codeigniter, y cakephp .

Las diferencias de estos dos son enormes, el primero es muy liviano, pero no cuenta con demasiadas herramientas, sin embargo la curva de aprendizaje es casi indolora, sabiendo php aprender codeigniter es cosa de una o dos horas, el segundo cakephp es completamente lo contrario, cuenta con muchas herramientas, pero tambien tiene muchas convenciones que lo hacen dificil de seguir, sin embargo la mayor gracia de cake es un script que se llama bake, que te construye paginas crud (Create, Update & Delete) para cada una de las tablas de tu base de datos.

Existen muchos mas, pero no tengo experiencia con ellos, por ejemplo esta zend y symfony, que tambien estan muy valorados dentro del mercado.

Algunos se preguntaran que tiene que ver todo esto con juegos de video, la respuesta es que la mayoria de estos juegos de navegador consisten en insertar y recuperar valores de una base de datos, mas un par de imagenes que se muestran en el navegador, y para hacer este tipo de paginas un framework ayuda mucho, y si se espera que corra para mucha gente jugando al mismo tiempo un framework liviano es la solucion.

Pygame 1.9 esta listo

2009-08-05T14:52:00.002-04:00

Han sacado una nueva version de pygame, la version 1.9, esta incluye varios cambios, pero los mas relevantes de mencionar son lejos soporte para webcams y soporte para midi, con esto se pueden hacer varias cosas interesantes. Otro cambios incluyen mejor soporte para OSX y soporte para el celular nokia s60

Backtracking ( Busqueda En Profundidad )

2008-11-22T21:58:00.006-03:00

Backtracking es una tecnica para resolver problemas de diversos tipos, por ejemplo:
generación de numeros y encontrar salidas de laberintos.

La tecnica consiste en recorrer todas las soluciones posibles ordenadamente,
asi si estuviesemos hablando de generar todos los numeros posibles de 4 digitos
tendriamos:

1 1 1 1
2 1 1 1
3 1 1 1
...
9 1 1 1
1 2 1 1

Ahora si estuviesemos hablando de encontrar la salida en un laberinto, lo que tendriamos que hacer es recorrer todas las habitaciones del laberinto pero en profundidad esto quiere decir, que una vez que se entra en una pieza, se busca una nueva salida que no sea por donde tu entraste y no te devuelves hasta que llegues a una habitacion sin salida

imaginemosnos el siguiente mapa

......
....xf
sxx...

donde:

s es el punto de partida
f el punto de llegada
x un muro
. un camino accesible
* un camino ya transitado

ademas dijimos que backtracking funciona generando soluciones ordenadas, de ahora
en adelante le llamaremos a esto generar nuevos candidatos, los nuevos candidatos son aquellas
posiciones que no han sido transitadas previamente.

Para este ejemplo usaremos el siguiente criterio:
primero se recorre para arriba si es posible
sino a la derecha
sino abajo
sino la izquierda.

con este criterio la salida encontrada seria:

******
*...x*
*xx...

Es importante destacar que backtracking no se preocupa de encontrar la mejor solucion, le
basta con la primera.

Recapitulando, se necesita
1) un mapa
2) un orden de movimiento ( para la generación de nuevos candidatos )
3) un criterio de llegada, normalmente que la posicion de un personaje este en cierta posicion

el pseudocodigo es el siguiente


listo = falso
backtrack(mapa, camino_recorrido, posicion_nueva)
si llegaste al final:
agregas la posicion a recorrido
listo = verdadero
retornas el camino_recorrido

si no:
agregas el nuevo punto a camino_recorrido
por cada posicion adyacentes
  si es un movimiento legal y no esta en camino_recorrido
    backtrack(mapa, camino_recorrido, posicion adyacente)
    si esta listo retornas el camino_recorrido

Para empezar simplemte le pasas la posicion de origen.

Sabes que llegasta al final cuando tu posicion es la posicion de destino
el camino de recorrido puede ser una lista, pero cuidado tienes que copiar la lista
y no pasarlo por referencia.

actualizacion

2008-07-08T01:03:00.002-04:00

Hace tiempo que no me quedaba tiempo para programar, pero hoy sali de vacaciones, asi que actualize la pagina de codigos, subi un par de ejemplos muy simples hechos en C, y pienso seguir subiendo un monton de codigos.

2008-05-21T01:57:00.003-04:00

He decidido dejar de postear los codigos en la pagina debido a la extension de ellos, para eso cree una nueva pagina donde voy a ir poniendo todos los tutoriales.

La direccion por ahora es:
http://www.alumnos.utfsm.cl/~gonzalo.sanchez/

2008-05-14T23:31:00.002-04:00

Hoy dia por fin me hice el tiempo para volver a programar en python, en esta ocacion les traigo un pequeño programa en python que dibuja un cuadrado que se puede mover por la pantalla cuando uno presiona las flechas del teclado, en el codigo se combinan las librerias pygame y pyopenGL.

Aqui viene lo interesante, el codigo


import pygame
from pygame import *
from OpenGL.GL import *

class Character:
  def __init__(self):
    #--Position
    self.posX = 0.0
    self.posY = 0.0
    self.posZ = 0.0
    
    #--Movement
    self.rot = 0.0    
    self.speed_left = 0.0
    self.speed_right = 0.0
    self.speed_top = 0.0
    self.speed_down = 0.0
    
    #--General
    self.color = (1.0, 0.0, 0.0)
    self.size = 0.2
  
  def Update(self):
    self.posX -= self.speed_left
    self.posX += self.speed_right
    self.posY += self.speed_top
    self.posY -= self.speed_down

  def Draw(self):
    glBegin(GL_QUADS)
    glColor3f(self.color[0], self.color[1], self.color[2])
    
    glVertex3f(self.posX - self.size , self.posY - self.size , self.posZ)
    glVertex3f(self.posX - self.size , self.posY + self.size , self.posZ)
    glVertex3f(self.posX + self.size , self.posY + self.size , self.posZ)
    glVertex3f(self.posX + self.size , self.posY - self.size , self.posZ)
    
    glEnd()

    
def UpdateScreen ():  
  glClearColor(0.0, 0.0, 0.0, 0.0)
  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)

  # Select GL_MODELVIEW matrix
  glMatrixMode(GL_MODELVIEW)  
  glLoadIdentity()
  
  character.Draw();
  # Save current GL_MODELVIEW matrix state
  glPushMatrix()              
       
  # Restore last GL_MODELVIEW matrix state
  glPopMatrix()                             
  
  # Flush everything to screen
  glFlush()                                                    
  
  # Flip the double-buffer
  pygame.display.flip()                    


def SetUp():
  pygame.init()  

  # we want a fullscreen, 1280x1024, SDL surface that supports doublebuffered OpenGL
  pygame.display.set_mode((500,500),OPENGL|DOUBLEBUF)

  # Select GL_PROJECTION matrix
  glMatrixMode(GL_PROJECTION)             
  
  # Reset GL_PROJECTION matrix
  glLoadIdentity()


def Main():
  SetUp()
  
  global character
  character = Character()
      
  while True:
    character.Update()
    UpdateScreen()
    
    for event in pygame.event.get():
      
      if event.type == QUIT:
        return

      if event.type == KEYDOWN:
        if event.key == K_LEFT:
          character.speed_left += 0.01
        if event.key == K_RIGHT:
          character.speed_right += 0.01
        if event.key == K_DOWN:
          character.speed_down += 0.01
        if event.key == K_UP:
          character.speed_top += 0.01
          
      if event.type == KEYUP:
        if event.key == K_LEFT:
          character.speed_left = 0
        if event.key == K_RIGHT:
          character.speed_right = 0
        if event.key == K_DOWN:
          character.speed_down = 0
        if event.key == K_UP:
          character.speed_top = 0

Main()

Voy a seguir trabajando en este mismo tema, asi que cualquier comentario es bienvenido.

Pygame y openGL juntos: lo mejor de 2 mundos

2008-05-13T23:53:00.003-04:00

La idea de combinar Pygame y openGL es conseguir lo mejor de ambos, o sea utilizar openGL como motor grafico, y Pygame para manejar los eventos y el sonido, les voy a mostrar un codigo bien sencillo donde se dibuja un triangulo pero sobre una ventana de pygame.

La clave esta en usar la siguiente linea:
pygame.display.set_mode((width,height),OPENGL|DOUBLEBUF)

de esa manera le permitimos a la ventana principal de pygame, mostrar lo que podria mostrar una ventana de OpenGL.

A continuacion el ejemplo.


#---Codigo de pygame junto con pyopengl---
#Working with pygame instead of GLUT
#Using pygame events

import pygame
from pygame import *
from OpenGL.GL import *
from OpenGL.GLU import *


def triangle():
 glBegin(GL_TRIANGLES)
 glColor3f(1.0,0.0,0.0)
 glVertex3f(0.0,0.8,0.0)
 glColor3f(0.0,1.0,0.0)
 glVertex3f(-0.6,-0.2,0.0)
 glColor3f(0.0,0.0,1.0)
 glVertex3f(0.6,-0.2,0.0)
 glEnd()


def display():
 glClearColor(0.0,0.0,0.0,0.0)
 glClear(GL_COLOR_BUFFER_BIT)
 glMatrixMode(GL_PROJECTION)
 glLoadIdentity()
 glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0)
 triangle()
 glMatrixMode(GL_MODELVIEW)
 glFlush()


def windowInit(width,height):
 pygame.init()
 pygame.display.set_mode((width,height),OPENGL|DOUBLEBUF)   
 glViewport(0,0,width,height)
 glMatrixMode(GL_PROJECTION)
 glLoadIdentity()
 gluPerspective(45,1.0*width/height,0.1,100.0)
 glMatrixMode(GL_MODELVIEW)
 glLoadIdentity()


def main():
   windowInit(640,480)
   while True:  
       display()
       pygame.display.flip()
       for event in pygame.event.get():
   if event.type==QUIT:
    return
      
main()

El unico problema de combinarlos es que el framerate que se obtiene, es menor que el que se obtendria ocupando directamente la ventana de Glut, o ventanas de windows/linux/otros. De todas maneras el framerate obtenido es suficiente para desarrollar un juego comercial.

Como Compilar en python

2008-04-20T01:56:00.002-04:00

Ya habiamos hablado que Python era un lenguaje interpretado y que por lo tanto no tenia necesidad de ser compilado, pero eso no quiere decir que sea incapaz de hacerlo. Existe una herramienta para compilar tus codigos hechos en python, se llama py2exe. descargalo desde http://www.py2exe.org/. Un ejemplo muy sencillo de como compilar el codigo es:


from distutils.core import setup
import py2exe

setup(console=['mi_archivo.py'])

el codigo anterior lo guardas en un archivo, digamos makeExe.py, y luego lo llamas desde la consola makeExe.py py2exe, y voila se compila el codigo.

Nota: Si tu codigo depende de librerias como pygame, py2exe las compilara solo, asi que no te preocupes, con el codigo anterior basta para compilar tu codigo.

Dirty Rects

2008-03-23T23:00:00.002-03:00

Dirty Rects es una tecninca muy usada en la programacion 2d, consiste en solo dibujar lo que este sucio, de esa manera se evita procesar informacion innecesariamente, un ejemplo sencillo de la tecnica seria


global dirty
dirty = True

def draw() :
  #Aqui va el codigo de ploteo y de dibujo
  global dirty
  dirty = False # Como recien fue dibujado ya no esta sucio

def main():
  while True
     if dirty:
        draw()

Es tan facil como esto, ahora como ejemplo final voy a reescribir el codigo del ploteo isometrico ocupando dirty rects


#-------Empieza Codigo-----------
#Isometric Plot
import pygame
from pygame import *

global dirty
dirty = True

TILESIZE = 64
SCREEN = pygame.display.set_mode((800, 600))
BLUE = (0, 0, 200)
GROUND_IMAGE = pygame.image.load('grass.png')

def plot():
 SCREEN.fill((0, 200 , 0))

 """Aqui en el range es donde vamos a poner cuantos tiles queremos dibujar
 En este caso son 15 tiles en la direccion y, y 10 tiles en la direccion x
 y por lo tanto vamos a dibujar 150 tiles"""

 for y in range(0, 15):
    for x in range(0, 10):
       """tenemos 2 tipos de posiciones en este ploteo,
       posiciones de pixeles y posiciones de tiles,
       la posiciones de pixeles se incrementan de 1 en 1,
       las de tile depende del ploteo que queramos,
       en este caso nuestra imagen mide 64*32 pixeles,
       por lo tanto cada posicion horizontal esta a 64 pixeles
       de la siguiente, pero en el caso vertical,
       las imagenes estan distanciadas por 32 pixeles
       y dijimos que habia que moverse desde
       la mitad de la imagen para abajo
       o sea: imagen/4 para abajo
       """
     
       tile_x = x * TILESIZE
       tile_y = y * TILESIZE/4
  
       if y % 2 == 0: # si estamos en una fila par(partiendo desde 0 seria la fila 0,2,4,6,8)
          SCREEN.blit(GROUND_IMAGE, (tile_x, tile_y))
  
       else:
          tile_x += 32 # corregimos la posicion para las filas impares
          SCREEN.blit(GROUND_IMAGE, (tile_x, tile_y))

 global dirty
 dirty = False

def main():
 clock  = pygame.time.Clock()
 fps = 40

 ready = False
 while not(ready):
    clock.tick(fps)
    print clock.get_fps()
    if dirty:
      plot()
     
    pygame.display.update()
  
    events = pygame.event.get()    
    for event in events:
       if event.type == QUIT:
          return
       if event.type == KEYDOWN:
          ready = True

main()
#-------Termina Codigo-----------

Ploteo Isometrico

2008-03-21T11:25:00.002-03:00

Hoy les traigo un codigo sencillo para ploteos isometricos, pero primero deben poner el codigo en la misma carpeta que la imagen que les dejo a continacion

Esta imagen tiene una carecteristica muy especial, y es que es el doble de ancha que de alta, en este caso tiene 64 pixeles de ancho y 32 de alto, aunque el canvas de la imagen es de 32*32, el resto que no es visible es transparente, tambien pudimos haber ocupado un fondo blanco y usar colorkey pero no este caso preferi ocupar el canal alpha que traen los png's

Volviendo al tema interesante, el ploteo isometrico consiste en poner esta imagen u otras de las mismas caracteristicas a lo largo de la pantalla, para lograr esto debes poner sucesivamente las imagenes a lo largo del eje x, pero cuando lleguemos al final del eje y nos toque empezar a rellenar la segunda fila, la imagen la pones solo la mitad de un imagen mas abajo que la anterior, y una imagen mas a la derecha que la anterior y solo la mitad de la imagen mas abajo, despues cuando terminemos esa fila empezamos llenando el eje x desde el principio y el eje y de nuevo la mitad de la imagen en pixeles mas abajo, esta estructura se repite cuantas veces quieras.

Aqui les dejo un codigo para que puedan ver como funciona


#-------Empieza Codigo-----------
#Isometric Plot
import pygame
from pygame import *

TILESIZE = 64
SCREEN = pygame.display.set_mode((800, 600))
BLUE = (0, 0, 200)
GROUND_IMAGE = pygame.image.load('grass.png')

def plot():
 SCREEN.fill((0, 200 , 0))

 """Aqui en el range es donde vamos a poner cuantos tiles queremos dibujar
 En este caso son 15 tiles en la direccion y, y 10 tiles en la direccion x
 y por lo tanto vamos a dibujar 150 tiles"""

 for y in range(0, 15):
    for x in range(0, 10):
       """tenemos 2 tipos de posiciones en este ploteo,
       posiciones de pixeles y posiciones de tiles,
       la posiciones de pixeles se incrementan de 1 en 1,
       las de tile depende del ploteo que queramos,
       en este caso nuestra imagen mide 64*32 pixeles,
       por lo tanto cada posicion horizontal esta a 64 pixeles
       de la siguiente, pero en el caso vertical,
       las imagenes estan distanciadas por 32 pixeles
       y dijimos que habia que moverse desde
       la mitad de la imagen para abajo
       o sea: imagen/4 para abajo
       """
     
       tile_x = x * TILESIZE
       tile_y = y * TILESIZE/4
  
       if y % 2 == 0: # si estamos en una fila par(partiendo desde 0 seria la fila 0,2,4,6,8)
          SCREEN.blit(GROUND_IMAGE, (tile_x, tile_y))
  
       else:
          tile_x += 32 # corregimos la posicion para las filas impares
          SCREEN.blit(GROUND_IMAGE, (tile_x, tile_y))


def main():
 clock  = pygame.time.Clock()
 fps = 40

 ready = False
 while not(ready):
    clock.tick(fps)
    print clock.get_fps()
  
    plot()
     
    pygame.display.update()
  
    events = pygame.event.get()    
    for event in events:
       if event.type == QUIT:
          return
       if event.type == KEYDOWN:
          ready = True

main()
#-------Termina Codigo-----------

Hay otros tipos de ploteo y todavia nos queda mucho por hablar acerca de este.
Nos vemos.

Juegos para navegadores

2008-03-18T23:39:00.004-03:00

Existen muchos juegos en linea que se juegan simplemente con el navegador, como por ejemplo Ogame, el cual es un juego donde debes colonizar el espacio, tambien hay de otros temas como Travian donde puedes jugar con romanos, galos o germanos y debes fundar pueblos y defenderlos de tus enemigos y tambien hay juegos de futbol como es el caso de Hattrick.

Para poder jugar estos juegos solo necesitas un navegador como por ejemplo IExplorer o Firefox.

Estos tipos de juegos no estan hechos en html plano, puesto que el html es un lenguaje estatico y por lo mismo no sirve para hacer juegos, puesto que no se puede actualizar la pagina mientras el usuario no presione actualizar, y tenga que cargar la pagina completamente desde cero.
Existen algunas herramientas para poder generar codigo ligeramente dinamico como por ejemplo javascript y DOM, pero para poder crear un juego donde se deba interaccionar con otras personas que estan jugando se necesita un fuente de datos (variables como por ejemplo niveles o cantidades de recursos) fija y que no dependa del cliente (la persona que esta usando el navegador). Para tener una fuente de datos fijas necesitamos una base de datos, esta puede ser un simple archivo al que el cliente envie informacion, el servidor modifique el archivo con la informacion nueva y envie el archivo a cada uno de los clientes conectados, o bien puede ser una herramienta mas sofisticada como una base de datos con un lenguaje propio de consultas como por ejemplo MySQL y Oracle, estas ultimas tienen la ventajas de poder recuperar la informacion rapidamente y con mucho menos trabajo que programarlo manualmente

Como solucion a la enorme cantidad de problemas mencionados anteriormente nacen los frameworks, estos son un conjunto de herramientas como por ejemplo una libreria para el manejo de las bases de datos, un router el cual permite redirrecionar la pagina web (y asi poder actualizar la pagina), y un template el cual permite poner codigo dinamico en nuestra pagina web

Muchos de los juegos en linea actualmente no estan hechos en frameworks sino que usan php, el cual es un lenguaje dinamico pero no muy bueno, de por si es un poco criptico y con criptico quiero decir que alguien que no sabe php no puede leer el codigo, a diferencia que casi cualquier persona que sepa programar puede leer un codigo diseñado en python, bueno volviendo al analisis de los juegos, ogame el cual a mi gusto es el mejor de los juegos de este tipo, esta hecho en php, y si mal no recuerdo travian tambien.

Si te interesa programar este tipo de juegos existe una alternativa bastante buena al php y son los frameworks, existen principalmente tres frameworks para python y son django, pylons y turbogears.

Yo hasta el momento solo he trabajdo con los dos primeros, con django y con pylons, y comparandolos diria que django es mas facil de aprender, pero es mejor pylons, si quieren diseñar un juego sencillo o una pagina estilo fotolog o myspace o youtube con django podrian hacerlo perfectamente, aunque yo personalmente me inclino por pylons que permite mucha mayor configuracion.

Lamentablemente toda la buena documentacion de estos frameworks esta en ingles.

Bueno si todavia estan interesados, les recomendaria The Django Book como punto de partida.

Buena Suerte.

Cargar imagenes con pygame

2008-03-03T23:20:00.002-03:00

Si en lugar de dibujar utilizando los comando de pygame quieres cargar imagenes tuyas o de tus personajes puedes usar la funcion image.load que viene en la libreria de pygame, esta funcion devuelve una superficie con la imagen. Se usa de la siguiente manera:

superficie1 = image.load("nombre_imagen")

Pero tenemos que darnos el trabajo de verificar si la imagen existe, ya que podria no estar en el programa y entonces el juego fallaria al intentar correrlo, para eso validamos si se puede abrir el archivo de la siguiente manera

#---cargando imagenes
import pygame
from sys import exit

def loadImage(filename):
try:
    image = pygame.image.load(filename)
except:
    print "error al cargar la imagen desde ", filename
    sys.exit()
return image
#-----

De esta manera el programa avisara que hubo un fallo a la hora de intentar abrir el archivo

Transparencia en pygame

2008-03-03T23:15:00.003-03:00

En pygame hay 2 tipos de transparencias, la transparencia alpha y la de colorkey:

Transparencia alfa (alpha) :
Se aplica a toda la imagen, es un valor que va desde 0 a 255 donde 0 es opaco y 255 es transparente, se puede hacer una imagen borrosa dandole valores intermedios

Tranparencia colorkey :
Se aplica solo a un color de la imagen y hace ese color invisible.

Advertencia: la transparencia alpha suele ser bastante lenta.

Deteccion de colisiones 3d

2008-02-29T02:38:00.002-03:00

A mi juicio lo mas dificil de hacer un juego 3d es la deteccion de colisiones, ahora en lugar de explicar un monton de calculo vectorial les voy a dar la solucion facil al problema y es utilizar la libreria ODE (Open Dynamics Engines) existe un binding de esa libreria para python llamado pyODE, es bastante sencillo de usar pero combinarlo con openGL y a la vez con pygame puede ser levemente complicado, otro dia voy a explicar bien los detalles de como se hace, por lo demas la pagina web de pyODE y la de ODE tienen las documentaciones oficiales respectivas y unos tutoriales para empezar desde cero.

Asi que no queda otra que empezar a leer.
Suerte con sus juegos 3D.

Variables locales y variables globales

2008-02-28T11:06:00.007-03:00

Ya vimos anteriormente que las variables se pueden clasificar segun su tipo, ejemplo entero (integer), decimal (float), cadena de caracteres (string) pero los variables tambien se pueden clasificar segun su ambito, o sea desde donde son visibles. Una variable definida dentro de una funcion suele ser visible solo desde esa funcion.

Supongamos la siguiente situacion:


#---Caso 1
a = 5
print a
def funcion():
  print a

function()
#fin codigo

Este codigo lo que hace es imprimer 5 dos veces en la pantalla, ahora observemos otro caso
En este primer caso como la variable a esta definida fuera de la funcion es visible dentro de la funcion, pero en el caso contrario no sucede lo mismo, para eso veamos el siguiente ejemplo


#---Caso 2
def otra_funcion():
  b = 5

otra_funcion()
print b
#fin codigo

En este caso obtenenmos un error puesto que la variable b fue definida dentro de una funcion y la estamos llamando desde fuera, una solucion a este problemas es declarar la variable como variable global, en ese caso la variable es visible en cualquier parte del codigo.

Solucion al caso 2:


#---Solucion al caso 2
def solucion():
  global b
  b = 6

solucion()
print b
#fin codigo

A modo de advertencia dejo claro que las variables globales quedan tapadas por las locales, pero este comentario probablemente no sea muy clara asi que pongamoslo un ejemplo de esto


#---codigo
a = 5
def funcion():
  a = 7

funcion()
print a

La pregunta que deberias estar haciendote es: ¿que imprime?.

La respuesta es 5, y la razon es porque cuando definimos la variable a en la funcion tapamos la definida anteriormente, hay que tener cuidado con esto, este tipo de errores son muy dificiles de rastrear.

La explicacion de porque esto sucede es dificil explicarla sin dibujitos pera la idea es la siguiente, el programa principal imaginalo como un bloque que en la parte superior tiene escrita informacion, ahora cuando en el programa llama a una funcion
se pone otro bloque pero de menor tamaño, que tapa la mayor parte de lo que estaba en el bloque anterior excepto aquellas cosas que fueron escritas en la periferia, de esta manera se va construyendo una especie de piramide que realmente es mas parecida a una columna que recibe como nombre tecnico pila (stock). Espero que entienda que esto es una metafora y no es del todo correcto.

Para completar me gustaria comentarles que en python se puede conocer cuales son las variables locales que actualmente estan en uso, para acceder a ellas se usa la funcion locals(), esta devuelve un diccionario con todas las variables locales, de la misma forma es posible conocer que variables globales estan en uso a traves de la funcion globals().

Recursividad

2008-02-24T01:53:00.002-03:00

Las funciones recursivas son funciones que se llaman a si misma:

ej:

def funcion_hola():
funcion_hola()

Bueno, y esto para que sirve?.

Existen un monton de algoritmos dentro del mundo de los video juegos que estan escritos en forma recursiva, como son los del tipo backtracking, los cuales entre sus aplicaciones sirven para crear laberintos y tambien para encontrar sus soluciones. Tambien hay algoritmos del tipo divide and conquer como por ejemplo el quicksort.

El limite de la recursividad:

La principal restriccion de la recursividad es que no puede ser infinita, o sea el primer ejemplo que les di viola esta restriccion y por lo tanto esta malo, de hecho si intentamos hacer correr un algoritmo asi obtendremos un error del tipo "se ha superado la profundidad maxima de la recursion". Ahora el limite exacto de la recursividad depende de los interpretes o de los compiladores pero es bastante profundo asi que mientras el limite de la funcion este claro, veamos ejemplos

Factorial:
-El factorial de un numero N, natural (o sea un entero > 0) se anota como N!
y esta definido asi:
N! = (N - 1)!

-El factorial de 0, esta definido como 1.

En base a estas 2 definiciones podemos programar una funcion recursiva que calcule el factorial de un numero


#---codigo
def recursive_factorial( n ):
  if n == 0:
    return 1
  else:    
    return n * recursive_factorial( n - 1 )
#---fin codigo

Crear un triangulo con pyopengl

2008-02-21T15:45:00.003-03:00

para dibujar un triangulo usando opengl en python basta con agregar glBegin(GL_TRIANGLES) luego 3 vertices que se dan a partir de la funcion glVertex3f(x,y,z) y por ultimo glEnd(), veamos un codigo completo.


#Codigo ---------
from OpenGL.GL import *
from OpenGL.GLUT import *

def draw_triangle():
 glBegin(GL_TRIANGLES)
 glVertex3f(0.0, 0.6, 0.0)
 glVertex3f(0.6, -0.6, 0.0)
 glVertex3f(-0.6, -0.6, 0.0)
 glEnd()

def display():
 glClear(GL_COLOR_BUFFER_BIT) # Pinta la pantalla de color negro
 draw_triangle()
 glFlush()

glutInitWindowSize(800, 600)
glutCreateWindow("HELLO WORLD")
glutDisplayFunc(display)
glutMainLoop()
#------------

la unica diferencia de este codigo con el anterior es que este mientras esta dibujando (funcion display), llama a la funcion draw_triangle, este define una primitiva en base a tres vertices, los vertices tienen coordenadas x,y,z. donde cada uno de los ejes tiene un valor minimo de -1, y un valor maximo de 1, el punto 0 esta en el centro de la pantalla.

Crear una ventana con pyopengl

2008-02-21T00:47:00.002-03:00


from OpenGL.GL import *
from OpenGL.GLUT import *

def display():
 glClear(GL_COLOR_BUFFER_BIT) # Pinta la pantalla de color negro


glutInitWindowSize(800, 600)
glutCreateWindow("HELLO WORLD")
glutDisplayFunc(display)
glutMainLoop()

las primeras 2 lineas importan las funciones de la libreria.

glutInitWindowSize(800, 600): crea una ventana de ancho 800 pixeles y alto 600 pixeles

glutCreateWindow("HELLO WORLD"): crea la ventana con titulo HELLO WORLD

glutDisplayFunc(display): llama a la funcion display mientras corre el bucle principal de glut

glutMainLoop(): llama a correr el bucle principal de openGL.

Para correr el codigo en windows necesitas el dll de glut, el cual se llama glut32.dll

Usando el mouse en pygame

2008-02-19T15:06:00.003-03:00

Buenas tardes, hoy dia voy a explicar como utilizar el mouse en pygame, en especial como utilizarlo cuando se trata de juegos estrategias.

Primero: Para poder hacerlo visible o invisible el cursor del mouse:
pygame.mouse.set_visible(bool)

bool puede ser True o False segun se desee hacer visible o invisible el cursor

Segundo: para poder saber en que posicion de la pantalla esta el cursor utilizamos:
pygame.mouse.get_pos()

esta funcion devuelve un par de datos con las coordenadas x,y del cursor, por lo tanto la deberiamos llamar asi:

mouse_pos = pygame.mouse.get_pos()
o tambien:

mouse_pos_x, mouse_pos_y = pygame.mouse.get_pos()

Estos nombres son arbitrarios, los puedes cambiar, lo que debes saber es que: pygame.mouse.get_pos() te devuelve una tupla con las posiciones del mouse.

Tercero: Para saber si se esta presionando algun boton del mouse:
pygame.mouse.get_pressed()
devuelve un tupla de tres valores, que son los tres botones del mouse, los valores se encuentran en el mismo orden que los botones del mouse, o sea el valor de mas a la izquierda es el boton izquierdo del mouse y asi sucesivamente, si el boton se encuentra presionado, el valor es 1, en caso contrario es 0.

Resumiendo con codigo:


botones_mouse = pygame.mouse.get_pressed()
if botones_mouse[0] == 1: # o sea
  print "hola"

Cuarto: tambien queremos poder saber si con el mouse estamos o no haciendo click sobre algo, para esto hay varias formas, una de ellas es aprovechar el rect de lo que estamos clickeando, eso seria mas o menos asi:


mouse_x, mouse_y = pygame.mouse.get_pos()
for objeto in objetos_del_juego:
  if objeto.collidepoint(mouse_x, mouse_y):
    print "algo"

una segunda opcion es construir un rect con la posicion del mouse, dandole un ancho y alto
y utilizando ese rect para detectar colisiones como explique en un post anterior

Para los que se entusiasmaron, buena suerte programando su primer RTS.

Pong Online 0.1

2008-02-17T14:44:00.002-03:00

Acabo de subir la primera version del pong online que estoy haciendo, hasta el momento tiene un par de fallas en la deteccion de colisiones pero ya arreglare eso.

es.geocities.com/war_chocobo/pong_online_0.1.zip

Hay 2 archivos, un servidor y un cliente, el servidor no muestra informacion grafica solo hace calculos como por ejemplo la deteccion de colisiones, por el otro lado los clientes hacen la menor cantidad de calculos posibles solo muestran la informacion grafica.

En este juego se nesecita que esten conectados los 2 jugadores para poder jugar, a modo de prueba uno puede hacer correr los 2 clientes en el mismo computador.

El servidor es facilmente ampliable a mas a jugadores lo que serviria para hacer un mmorpg que debe ser el objetivo de muchos de los programadores de video juegos.

Les dejo el codigo a modo de tutoriales, sugerencias respecto al codigo son bienvenidas.

Tipos de datos

2008-02-15T17:02:00.002-03:00

En python los tipos de datos no son muchos, para vale la pena conocerlos

int:
abreviación de integer, son números enteros o sea números sin decimales, como por ejemplo: -50

float:
abreviación de floating point, con coma flotante o sea números con decimales, como por ejemplo: 2.5

character:
son caracteres, como por ejemplo 'h'

advertencia:
'1' es un caracter
1 es un integer
cuidado al hacer comparaciones puesto que
1 es distinto de '1'

se puede convertir un tipo de dato a otro, por ejemplo
str(1) convierte el integer 1 al caracter '1'
int('1') convierte el caracter '1' al numero 1

Advertencia:
1 + 1 = 2
'1' + '1' = '11'

Tenga cuidado en python los operadores están sobrecargados, eso quiere decir que dependen del tipo de dato, no es lo mismo 1+1, que '1' + '1', en el primer caso el operador mas hace de suma, en el segundo de concatenación.

Hacer juegos multijugador online

2008-02-14T15:08:00.002-03:00

He estado programando un pong multijugador online, a penas lo tenga listo lo voy a poner en la pagina, tambien estoy pensando en poner tutoriales de como programar juegos en linea utilizando la libreria Twisted para python, ya que es bastante dificil encontrar documentacion en linea respecto al tema.

Aqui les dejo el link para que descarguen la libreria

http://twistedmatrix.com/trac/

Tutorial de POO

2008-02-12T10:36:00.000-03:00

Para los que les gusta profundizar, encontre un buen tutorial sobre programacion orientada a objetos, esta en español, es bien claro y preciso, la direccion es:

http://blog.rvburke.com/2006/11/22/programacion-orientada-a-objetos-en-python/

Programacion Orientada a Objetos II : Herencia

2008-02-12T00:50:00.000-03:00

La herencia es uno de los grandes beneficios de trabajar con objetos, consiste en crear un nuevo objeto al que llamaremos hijo, el cual adquiere automicamente todos los atributos y metodos que contenga su padre. Veamos un ejemplo


#Codigo----
class Padre:
  def __init__(self):
    self.valor1 = 5
    self.valor2 = 9

class Hijo(padre):
  def __init__(self):
    Padre.__init__(self)
  def  mostrar(self):
    print "valor1: ", self.valor1
    print "valor2: ", self.valor2

luego instanciamos el objeto hijo, no es necesario instanciar el padre ya que el hijo contiene todos los atributos y metodos del padre


hijo = Hijo()
hijo.mostrar

mostraria en la pantalla:
valor1: 5
valor2: 9

en C++ habria mucho mas que hablar de herencia, pues ahi los datos se pueden proteger del exterior dandoles el caracter de privado, y existen distintos niveles de proteccion, pero en python todos los datos siempre son de caracter publico, aun asi el programa siempre debe ser escrito considerando siempre en lo posible el principio de encapsulacion, el cual consiste en que cada objeto es cerrado en si, o sea no cambia los valores de los otros objetos y estos valores solo se modifican mandandose mensajes a traves del codigo principal.

Programacion Orientada a Objetos

2008-02-10T19:31:00.004-03:00

Lo programacion orientada a objetos de ahora en adelante POO por ser esa su sigla, nos brinda un mundo de oportunidades, entre las mas entendibles estan la capacidad de reutilizar codigo, (similar a las funciones en ese aspecto) y la capacidad que tiene para ordenarlo, imaginate que tienes un codigo de unas 5000 lineas, encontrar algo ahi puede ser complicado.

En los terminos mas sencillos posibles un objeto es un grupo de datos y funciones. En terminos un poco mas tecnicos un objeto es un enfoque abstracto de un problema. un ejemplo practico seria el objeto personaje


#Codigo----
class Personaje:
 def __init__(self):
  self.posX = 400
  self.posY = 300
  self.color = (255, 255, 255)
  self.radio = 50
 
 def draw(self):
  pygame.draw.circle(SCREEN, self.color,\
  (self.posX, self.posY), self.radio)
  pygame.display.update()

La palabra class se ocupa para avisarle al compilador que hemos empezado a escribir un objeto.

La funcion __init__ recibe el nombre tecnico de constructor, en terminos practicos simplemente lo que este puesto ahi seran los valores iniciales de nuestro objeto.

La funcion draw dibuja al personaje en la pantalla, el \ que hay ahi es simpelemente para escribir en 2 lineas, no cumple ningun rol a la hora de correr el juego.

Repasemos el vocabulario antes de seguir:
argumento = valor que recibe una funcion.
clase = abstraccion del objeto.
atributo = cualquier variable o constante definido dentro de la clase.
metodo = cualquier funcion definida dentro de la variable que contenga el argumento self.
constructor = metodo que permite asignar valores iniciales a un objeto.

advertencia:
A todos los atributos de un objeto los debe preceder un self. , es esto lo que los convierte en atributos


class miclase:
 def __init__(self):
  a = 0 # Esto no es atributo y no se puede hacer nada con el desde fuera del codigo
  self.a = 0 # Esto si es un atributo

Ahora volviendo a nuestro personaje, que ventajas tiene?, como lo usamos?.

Para que esto quede claro voy a juntar la clase personaje con el codigo anterior, y ahi notaran la utilidad, pero antes me falta por explicar un solo concepto que es el de instancia, una instancia es cuando se crea un objeto, esto se hace asi

mi_instancia = mi_objeto()

aqui va el codigo:


#Codigo----
import pygame
from sys import exit
SCREEN = pygame.display.set_mode((800, 600))
clock = pygame.time.Clock()

class Personaje:
 def __init__(self):
  self.posX = 400
  self.posY = 300
  self.color = (255, 255, 255)
  self.radio = 50
 def draw(self):
  pygame.draw.circle(SCREEN, self.color,\
  (self.posX, self.posY), self.radio)
  pygame.display.update()

personaje = Personaje()

while True:
 clock.tick(60)
 SCREEN.fill((0,0,0))
 personaje.draw()

 for event in pygame.event.get():
  if event.type == pygame.QUIT:
   exit()
  elif event.type == pygame.KEYDOWN:
   if event.key == pygame.K_LEFT:
    personaje.posX = personaje.posX - 10
   elif event.key == pygame.K_RIGHT:
    personaje.posX = personaje.posX + 10

Espero que haya quedado claro puesto que la programacion orientada objetos es muy util a la hora de desarrollar video juegos, en especial aquellos en 3D.

Controlar la velocidad del juego

2008-02-10T02:35:00.000-03:00

Dentro del bucle principal el codigo se lee miles de veces por segundo, y si dibujamos al personaje dentro del bucle principal, el personaje se estaria dibujando miles de veces por segundo, mucho mas de lo que necesitamos, ademas el gasto de recursos de dibujar mil elementos cada segundo es monstruoso, y ya que estamos en la onda ecologica y gastar menos corriente electrica para disminuir el calentamiento global o bien si eso no te interesa y quieres asegurarte que tu juego corra a la misma velocidad independiente si es un pentium de 400 MHz o un pentium 4 de 2.0 GHz entonces debes agregar un reloj al juego, y esto se hace de la siguiente forma:

clock = pygame.time.Clock()

ahora que ya tienes un reloj, dentro del ciclo principal tienes que hacerlo marcar a la velocidad que quieres que corra tu juego, o sea si quieres que tu juego corra a 60 ciclos por segundo, o mejor dicho 60 cuadros por segundo, entonces escribes dentro del bucle principal

clock.tick(60)

y eso seria todo.

Retomando el ejemplo anterior donde dibujabamos un circulo en la pantalla, agregando un reloj el codigo quedaria asi:


#Codigo----
import pygame
from sys import exit

SCREEN = pygame.display.set_mode((800, 600))
clock = pygame.time.Clock()
posX = 400
posY = 300


while True:
  clock.tick(60)
  SCREEN.fill((0,0,0))
  pygame.draw.circle(SCREEN, (255,255,255), (posX, posY), 50)
  pygame.display.update()

  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      exit()
    elif event.type == pygame.KEYDOWN:
      if event.key == pygame.K_LEFT:
        posX = posX - 10
      elif event.key == pygame.K_RIGHT:
        posX = posX + 10

#-------

Los dejo por hoy, que tengan buenas noches.

Postear codigos fuentes en html

2008-02-10T02:05:00.001-03:00

Hace ya varios meses que el tema de como postear los codigo en html me estaba volviendo loco, debido a que el uso de espacios antes de un texto cualquiera es ignorado, no podia respetar la identacion que debe tener cada bucle, en algunos lenguajes como C/C++, la identacion puede ser ignorada, es simplemente buena practica, pero en lenguajes como Python es obligatoria.

La solucion que estaba ocupando era usar la etiquita div, y de esa manera darle a cada bloque un margen de 10 pixeles mas respecto al anterior, lo hacia de la siguiente manera:

div style="margin-left: 10px;"
obiamente entre <> pero si los pongo en el ejemplo se formatea mi texto y queda invisible.

pero el problema de esta solucion es que los espacios son virtuales, realmente no existen, son solo una capa de estilo y si deseascopiar el codigo de la pagina y pegarlo en otra parte la identacion se suprime.

Hoy por fin encontre la solucion. Es ocupando la etiqueta pre.

De esta manera se respeta al 100% el codigo que tu escribas, pero cuidado si escribes una linea muy larga la pagina puede adquirir un scroll horizontal muy grande y eso es incomodo para los lectores, de hecho de por si el scroll horizontal para un texto es mala idea, evitalo.

aqui va una prueba para que lo vean funcionando

sin etiqueta pre:
hola
hola
hola
hola


con etiqueta pre:
 hola
  hola
   hola
    hola

Saludos.

Diccionarios

2008-02-08T20:58:00.000-03:00

Los diccionarios son otra de las claves para hacer juegos en python, funcionan muy parecido a las listas, pero en lugar de ordenarse los terminos a traves de un indice, se ordenan a traves de una clave, la clave la pones tu.

Para crear un diccionario vacio:
mi_diccionario = {}

Para agregar un elemento al diccionario:
mi_diccionario[clave1] = un_valor

para sacar un elemento de un diccionario:
mi_diccionario.pop(clave)

Supongamos que queremos cargar imagenes al juego, podriamos cargarlas todas en variables separadas, tambien podriamos cargarlas todas a una lista, pero definitivamente la mejor manera es administrarlas a traves de un diccionario de la siguiente manera:

images = {}
images["Heroe"] = pygame.image.load("heroe.png")
images["Enemigo"] = pygame.image.load("enemigo.png")

De esta manera si quisieramos dibujar al heroe en la pantalla bastaria con:
SCREEN.blit(images["Heroe"], (posicion_X, posicion_Y).

De la misma manera podemos usar los diccionarios para administrar los sonidos, y como resultado tener un codigo limpio y ordenado y facil de mantener.

Ballons Beta

2008-02-07T03:15:00.001-03:00

He trabajado todo el dia pero ya tengo un adelanto listo, esta en version beta todavia, falta poner la introduccion, el final, hacer las etapas, en fin, falta todo. pero por lo menos ya es "jugable".

Hagan click en la imagen para descargar el codigo fuente, necesitan python y pygame para correr el juego

Si lo de la imagen no resulta por alguna misteriosa razon, y quieres descargar el codigo, la direccion donde lo puedes descargar es la siguiente:

http://es.geocities.com/war_chocobo/balloonsV8.zip

Ojala les guste, espero su opinion.

Balloons

2008-02-06T23:19:00.007-03:00

El primer juego que hice se llamaba Balloons, es ese que esta en la foto de alla abajo, consiste en agarrar los globos los cuales salen de las cajas antes de que ellos salgan de la pantalla, el codigo es relativamente sencillo y por lo demas el juego es muy tierno, tiene tres niveles distintos (mañanta, tarde y noche) y la diferencias es que iban apareciendo globos de distintos colores que eran mas rapidos. Para hacer mas entretenido el juego quise agregarle plataformas sobre las que tu pudieras saltar, y asi darle un toque mas de destresa al juego, pero como la caida del personaje tiene aceleracion y por lo tanto la velocidad cambiaba cada frame no lograba detectar si debajo del personaje habia o no plataforma, y por ende el personaje a veces las atravesaba o quedaba metido entre medio de ellas, al final opte por remover las plataformas del juego, pero por el mismo motivo el juego quedó tan simple que aburria muy rapido puesto que lo unico que habia que hacer era agarrar los globos antes de que estos se escaparan.

Ayer rehice el juego ocupando algunas tecnicas nuevas aprendidas, como por ejemplo una matriz que guarda la informacion del escenario de la cual hablare en un futuro post. Ademas ocupe tecnicas de sprite por lo que mejore el rendimiento del juego, ahora por cada cuadro solo se actualiza el personaje y no todo el escenario. De lo anterior tambien hablare mas adelante aunque en los links que publique se trata bien a fondo el tema de los sprites.

Pronto publicare el juego asi que paciencia.
Buena suerte y buenas noches.

Tutorial sobre Pygame

2008-02-06T01:20:00.001-03:00

Siempre es mejor que sobre informacion a que falte, en esta ocasion voy a poner un link a una blog que contiene bastante informacion respecto a temas que todavia no he tratado, como por ejemplo el uso de los sprites y como hacer scroll de un fondo de pantalla, asi que para los que estan muy ansioso por aprenderlo todo y aprenderlo ya, aqui les dejo el link

http://miprogramacionenjuegos.wordpress.com/category/pygame/

Suerte y gracias por su tiempo.

Deteccion de Colisiones

2008-02-05T14:13:00.000-03:00

Ya hablamos anteriormente acerca de como dibujar tu personaje en la pantalla, aunque solo fuera un circulo, y de la misma manera podemos poner otros personajes en la pantalla, el problema que tenemos ahora es como saber si dos o mas de los personajes estan tocandose, para solucionar esto existen los Rects, un rect (un rectangulo) el cual es una especie de contenedor de la superficie, para crear uno basta con:

mi_rectangulo = pygame.Rect(posicion_izquierda, posicion_derecha, ancho, alto)

Donde todas las medidas estan en pixeles, o sea si quiero crear un rectangulo de ancho 100 y de alto 100 en el extremo superior izquierdo de la pantala seria:

mi_rectangulo = pygame.Rect(0, 0, 100, 100)

Advertencia para los matematicos: la pantalla no es igual al plano cartesiano, en el sentido de que si quieres dibujar algo mas abajo en la pantalla, son mas pixeles, puesto que todo se mide en distancias de pixeles desde el extremos superior derecho de la superficie principal creada.

Aprovecho el tema y la oportunidad para explicar como dibujar un cuadrado en la pantalla, esto se hace muy parecido a los circulos, se hace asi:

pygame.draw(superficie, color, rect)

o sea si la superficie principal es SCREEN, el color azul, y el rectangulo el que declaramos anteriormente, entonces para dibujar el cuadrado seria:

pygame.draw(SCREEN, (0, ,0, 255), mi_rectangulo)

Ahora viene la parte importante, ¿como sabemos si 2 rectangulos estan sobrepuestos?, puesto que nos gustaria saber si nuestra paleta golpeo la pelota, o si una bala dio con un blanco, o si estamos chocando contra una pared.

Para solucionar eso existe la funcion colliderect, y se usa de la siguiente manera mi_rectangulo.colliderect(otro_rectangulo).

La funcion retornara verdadero o falso segun corresponda.

Mas adelante entrare mas en el tema de las colisiones que es uno de los puntos criticos a la hora de crear juegos.

Tutorial sobre SDL para C/C++

2008-02-04T19:29:00.000-03:00

Para todos aquellos que son mas amigos de C/C++ encontre un tutorial muy bueno sobre programacion de juegos con SDL, a continuacion les dejo el link.

http://www.javielinux.com/articulos/sdln1/sdl-n1/book1.html

Tutorial de linuxjuegos

2008-02-04T14:32:00.000-03:00

Encontre un tutorial muy bueno sobre programacion de video juegos en español usando python y pygame, vale la pena verlo asi que no si les interesa aprender a programar juegos, no se lo pierdan.

Los tutoriales pertenecen a la comunidad de Linux Juegos, la cual tiene mucha informacion importante, parece que voy a pasar varias horas leyendo antes de seguir escribiendo.

Aqui les dejo los links.
tutorial parte 1
tutorial parte 2

Buena lectura.

Listas

2008-02-04T13:14:00.001-03:00

Las listas son una de las claves para hacer juegos, una lista es una especie de contenedor que sirve para agrupar datos, una especie de lo que vendria siendo un array en otro en lenguaje pero altamente dinamico. Una lista se declara de la siguiente manera:

nombre_de_lista = []

Se le puede asignar valores iniciales y estos valores no tienen porque ser del mismo tipo

cosas = ["mesas", "comida", 23, 2]

Si quisieramos acceder a los elementos de una lista, podemos accederlo a traves de su indice, tal como si fuera un array, o sea si escribimos cosas[0], obtendriamos como resultado el string mesas.

si quisieramos recorrer completamente la lista lo podemos hacer de la siguiente manera:

#Codigo---
for elemento in cosas:

print elemento

#-----

con ese codigo podemos escribir toda la informacion que hay en la lista.

Si quisieras cambiar algun valor en la lista basta con saber su indice, o sea el lugar en que esta en la lista, debes recordar que la enumeracion empieza desde 0 y no de 1 y que por lo tanto el ultimo valor es el tamaño de la lista menos uno. Pues si intentas acceder a un valor que no existe el programa se cerrar. Supongamos que queremos cambiar el tercer elemento de la lista, entonces basta con cosas[2] = "nuevo elemento"

Existe otro tipo de contenedor que se llama tupla, las tuplas o mas genericamente conocidas como n-plas, son mas livianas que las listas, pero no soportan reasignacion, si la idea simplemente es contener datos utiliza una tupla, pero si quieres estar cambiando los valores, utiliza una lista.

Como ultimo me falta explicar como se agregan y se sacan datos de las listas, esto se hace a traves de la funcion append, para agregar un dato seria cosas.append("nueva cosa").
Para remover el dato basta con cosas.remove("nueva cosa"), tambien es posible remover el ultimo valor utilizando al funcion pop, o sea cosas.pop(), nos retornaria el ultimo valor, veamos un ultimo ejemplo para ver si quedo todo claro.

#Codigo---
a = [] # Creamos una lista vacia
a.append(1) # Agregamos un elemento
a.append(2)
print a # Esto nos mostraria en la pantalla [1,2]
print a[0] # Esto nos mostraria el numero 1 en la pantalla
b = a.pop
print b # Esto nos mostraria el numero 2 en la pantalla
#---------------

Tambien es posible copiar una lista a otra lista, se hace de la siguiente forma:

a = [1,2,3,4,5]
b = a

Este tipo de copia tiener una caracteristica especial, se llama copia por referencia, es muy rapido pero como consecuencia tiene que si yo modifico a o b, tambien modifico la otra lista, ejemplo:

a = [1,2,3,4,5]
b = a
a[0] = 5
print b
>>> [5,1,2,3,4,5]

Hay una segunda forma de copiar una lista, y es haciendolo por valor, aunque podrias poner los elementos 1 a 1, iterando la primera lista y haciendo appends a la segunda vacia, hay una forma aun mas comoda y es la siguiente

b = a[:]

Los dejo hasta aca, mucha suerte que tengan un buen dia.

Funciones

2008-02-04T12:43:00.000-03:00

Las funciones sirven para no tener que reescribir codigo y a su vez para mantenerlo ordenado.

¿Como se crea una funcion en python?

def nombre_funcion(arg1, arg2, .....)

aqui se pone el codigo de la funcion
aqui va el retorno de la funcion

Una vez que la funcion llega al retorno, o se encuentra sin mas codigo debajo se devuelve a leer donde estaba antes, en caso que desees que la funcion no reciba ningun argumento simplemente no pongas nada entre los parentesis.

veamos un ejemplo concreto por ejemplo la funcion suma.

#Codigo ---
def suma(a, b):

c=a+b
return a+b

En el ejemplo anterior a es el primer argumento, y b el segundo argumento y por ultimo el retorno de la funcion es la suma de ambos argumentos, ahora en adelante para sumar dos valores podriamos ocupar la funcion suma y simplemente escribir suma(4, 7) y obtendriamos como resultado 11.

una funcion como retorno puede hacer un llamado a otra funcion o asi misma, en este ultimo caso se llama funcion recursiva pero ese es un tema que trataremos mas adelante.

Crear una ventana con pygame

2008-02-03T20:20:00.000-03:00

El hola mundo de los video juegos, o sea el codigo mas sencillo posible consiste en crear una ventana donde pondremos los objetos de nuestro juego, como el heroe y los escenarios, aqui les escribo el codigo


#Codigo ----
import pygame
from sys import exit

SCREEN = pygame.display.set_mode((800, 600))
SCREEN.fill((0,0,0))

while True:
  pygame.display.update()
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      exit()

Aqui no hay mucho que explciar, se importa primero la libreria pygame y luego la funcion exit para salir del programa desde la libreria sys.

Luego se crea una ventana a traves del comando pygame.display.set_mode(), la cual como parametro recibe una tupla, o sea 2 datos, los cuales son el ancho y el alto.

Luego pintamos esa pantalla de negro, los colores estan dados en el sistema RGB, eso quiere decir que cada uno de los valores es un numero entre 0 y 255 que corresponde a la cantidad de color de los colores respectivos, la R es de RED, la G de GREEN y la B de BLUE. Si quisieramos pintar la pantalla de rojo deberias pasar el parametro (255, 0, 0).

Cada vez que hagamos un cambio en la pantalla para poder visualizarlo tenemos que actualizarla, eso se hace a travez del comando pygame.display.update()

Una vez lista la pantalla entramos al bucle principal y nuestro programa queda esperando hasta que alguien lo cierre.

ahora veamos un poco mas, como hacer un personaje, digamos que nuestro heroe es un circulo, y que solo se puede mover horizontalmente con las teclas flecha derecha y flecha izquierda, el codigo para hacer eso seria el siguiente:


#Codigo----
import pygame
from sys import exit

SCREEN = pygame.display.set_mode((800, 600))
posX = 400
posY = 300


while True:
  SCREEN.fill((0,0,0))
  pygame.draw.circle(SCREEN, (255,255,255), (posX, posY), 50)
  pygame.display.update()

  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      exit()
    elif event.type == pygame.KEYDOWN:
      if event.key == pygame.K_LEFT:
        posX = posX - 10
      elif event.key == pygame.K_RIGHT:
        posX = posX + 10

#-------

Ahora el codigo se parece mucho al anterior, las diferencias son que este programa responde a 2 eventos mas, que son presionar la tecla izquierda y presionar la tecla derecha, ademas de lo anterior se dibuja un circulo de color blanco en la posicion posX, posY las cuales podemos variar a medida que vamos presionando las teclas flecha izquierda y flecha derecha.

La funcion dibujar circulo recibe los siguientes parametros:

Superficie de destino, en este caso la pantalla
Color, tiene que estar en RGB
Posicion del centro
Radio

Bueno ya hicimos una introduccion a pygame, mas rato o mañana escribire un poco mas respecto al tema, como por ejemplo como dibujar cosas mas complejas que circulos.

Enlace interesante

2008-02-03T17:38:00.001-03:00

Navegando por ahi encontre una blog de programacion de video juegos usando python y pygame que tiene varios enlaces a informacion y tutoriales, inclusive contiene un video de mas de media hora sobre una conferencia sobre el tema de la programacion de video juegos, los enlaces pueden ser vistos en http://kalans.wordpress.com/category/programacion/python/

Importar librerias en python

2008-02-03T15:19:00.000-03:00

La filosofia python para resolver un problema es el siguiente.

Importar algo de la libreria para resolver tal problema
Resolver tal problema

Ahora pongamonos un problema real para solucionarlo con python, digamos que calcular la raiz cuadrada de 2, entonces el codigo seria algo asi:

#Codigo ---
import math
math.sqrt(2)
-----

hay 2 formas comunes de importar librerias en python, la primera es como ya lo explique, o sea importar toda la libreria, la otra es importar solo parte de ella, eso en el ejemplo anterior seria:

#Codigo ----
from math import sqrt
sqrt(2)
#----

En el segundo caso solo importamos la funcion sqrt.
Ahora para importar las funciones de pygame hacemos lo siguiente

#Codigo -----
from pygame import *
#----

O sea importamos todas las funciones, tambien podriamos hacerlo una por una, pero la filosofia de python es codigo claro sin trabajar de mas.

Conceptos basico de un juego de pc

2008-02-03T14:58:00.001-03:00

Bueno, al parecer hasta la fecha he hablado mucho y no he explicado nada, asi que para empezar explicare como es el pseudocodigo en terminos muy generales de un juego de computador.

Primero se necesita crear una ventana principal que es donde pondremos todos los escenarios y personajes

Luego ponemos los escenarios y los personajes dentro de la ventana principal

Luego hacemos un bucle que corra mientras el juego no termine, algo asi como while (finnish == False) o while True, la idea es que el bucle corra hasta que un evento externo termine con el juego, normalmente este ciclo infinito se le llama bucle principal.

Ahora que ya esta corriendo el juego, ponemos el escenario en la ventana principal, y luego al personaje puesto que no queremos que el escenario quede sobre el personaje

Por ultimo verificamos todos los eventos que se estan generando, por ejemplo clicks del mouse o teclas del keyboard, podriamos poner una condicion de que si se presiona la tecla ESC la variable finnish sea igual True y en ese caso el programa terminiria, o simplemente podriamos llamar a una funcion del sistema que cierre el juego, en python seria sys.exit().

A continuacion deje un pequeño pseudo codigo a modo de resumen.

#Pseudo Codigo----------

crear una ventana
cargar un personaje
cargar un escenario

mientras el juego no termine:
dibujar el escenario
dibujar el personaje
verificar si hay eventos (por ejemplo si se presiona una tecla que mueve al personaje)

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

Librerias para hacer juegos con python

2008-02-03T04:06:00.000-03:00

Una libreria es un conjunto de funciones que permiten hacer la vida de los programadores mas faciles y librerias para hacer juegos existen por miles, para python aunque existen muchas mencionare por mientras solo 2, pygame, la cual es una excelente libreria para programar juegos 2d, y pyopenGL la cual es probablemente la mejor libreria para hacer juegos 3d en python.

la libreria pygame la puedes descargar desde la pagina oficial www.pygame.org

la libreria pyopenGL la puedes descargar en www.pyopengl.sourceforge.net

Primeros pasos

2008-02-01T20:10:00.001-03:00

Los codigos de los juegos de videos, asi como de los programas de computadores se asemejan mucho a los diagramas de flujo, o poniendolo en terminos mas sencillos, a las recetas de cocina. uego, cuando uno ya tiene listo un codigo lo compila, o sea lo convierte a instrucciones que el computador entiende y luego lo ejecuta o sea lo hace correr.

Existen distintos tipos de lenguajes de programacion, que es como decir que hay distintas formas de escribir las recetas, cada uno de estos lenguajes necesita de un compilador distinto. Como excepcion a la regla Hay algunos lengujes de programacion que no se compilan y algunos que se pseudocompilan, o sea que se compilan solo parte del codigo, este tipo de lenguajes se llama interpretado.

A mi preferencia el mejor lenguaje para prototipear (o sea para desarrollar rapido los programas) es python, pero si se quiere desarrollar un potente motor 3d para juegos de videos es mejor ocupar un lenguaje como c++, voy a dejar para mas adelante las explicaciones del porque uno y no los otros, por ahora recomiendo que si quieren hacer un video juego desde 0, creado por ustedes mismo haganlo en python.

Si ya sabes programar en algun lenguaje te recomiendo el tutorial de python instantaneo el cual puedes encontrar haciendo click aqui

Hola mundo

2008-02-01T19:20:00.001-03:00

Me llamo Gonzalo Sanchez, estudio informatica en la universidad Federico Santa Maria, y hace ya un buen tiempo que estoy abordando el tema de programacion de video juegos, he empezado ya a hacer varios juegos de diversas tipos entre los cuales se encuentran juegos de simulacion, rpg y plataforma entre otros, aunque solo unos pocos estan terminados debido a la cantidad de esfuerzo que se necesita en acabar los minuciosos detalles de un juego y que por lo general son la parte fome.

Empiezo este blog con el motivo de intentar formar una comunidad hispana de desarrollo de video juegos y, aunque principalmente mis planes son discutir acerca de algoritmos relacionados con video juegos ej: colision con plataforma, camino mas corto entre 2 puntos (a*, dijkstra) y otros, tambien esta en mis planes escribir acercar de como desarrollar video juegos desde 0 con solo un block de notas y un compilador.