Daniela González - Programación: 2011

martes, 22 de noviembre de 2011

Entradas puntos extra Clase POO

Entradas puntos extra Taller POO

MapReduce

Este es un elemento estructural por Google en el cual se utilizan mapeos y trabajos que reducen. En eso se basa su modelo de programación.

Manejan una cantidad cercana a 20 Petabytes en sus servidores.

Cuando se "mapea" esto lo que hace es buscar la información en formas pares de valores, y los que "reducen" sólo las unen, simplifican y procesan dichos datos.

MapReduce se encarga de paralelizar tareas, controlar trabajos, mejorar la comunicación que existe entre ellos, y controlar los errores que se lleguen a producir.

Algunas de las utilidades que le dan a MapReduce son:

- Traducción estadística
- Proceso de imágenes de satélite
- Aprendizaje automático
- Análisis de páginas
MapReduce toma el trabajo de cerca de unos 130,000 PCs convencionales. MapReduce está muy enfocado a problemas de escalabilidad, ya que no olvidemos que Google se expande muchísimo a cada segundo que pasa, desde gente que se une al servicio de mail, como para muchas otras cosas.

Fuentes: http://www.lacofa.es/index.php/tecnologias/mapreduce-paralelismo-en-google

Interfaz gráfica videojuegos

Me pareció que muchos de mis compañeros se enfocaron en analizar la interfaz gráfica de sistemas relacionados con bases de datos, y casi nadie le hizo caso a los videojuegos, que por lo menos a mí me encantan y evaluar una interfaz de un videojuego para mí es algo genial y muy divertido.

Analizaré la interfaz gráfica del GTA III.

Este GTA III causó revuelo en el tiempo que salió ya que a diferencia del GTA II el cual es el anterior a este, las gráficas mejoraron considerablemente ya que en el II la vista del usuario era vista aérea, y ahora con la novedad que podías mover al jugador libremente desde tercera persona fue algo fenomenal.

Las letras características del GTA de los títulos es agradable considerando que sólo se lee poco de ella, por ser sólo el título pasa la prueba, pero si se tratara de subtítulos o instrucciones en la pantalla, sería horrible leer en esa fuente todo el tiempo, aparte de incómodo.

La interfaz de los menús es un poco incómoda, ya que combina los colores naranja de las letras tipo el título de la saga, con el gris del fondo, lo bueno es que no se interactúa tanto con ella.

Al poco tiempo de jugar noté que cuando pasaban clips de videos relacionados con la historia, las imágenes se veían un poco corridas cuando se movían, da una sensación de no poder ver bien o de que tu tarjeta de memoria es muy pobre.

Para mí en ese aspecto no pasó la prueba el GTA III

Me gusta la comodidad que proporcionan el pequeño radar del mapa en la esquina superior izquierda, y que te sitúen en el pama como una gota blanca en donde la parte picuda es tu frente. Lo que no me agradó es que en intersecciones de calles a distintos niveles (como puentes) no sabes si cruzan al mismo nivel hasta que ya estás ahí y te hace perder tiempo al tener que encontrar otra ruta para llegar al destino deseado.

Hay oscuridad hasta de día. No sé si fue porque no querían manejar sombras o qué sé yo, pero la falta de sol a veces se extraña, parece como si siempre estuviera nublado aún y cuando no hay ni una sola nube en el cielo. Eso hace querer subirle el brillo a la tele al máximo.

Otra de las cosas que podían haberse mejorado son las manchas de sangre en el piso. Estas van desapareciendo a los pocos segundos de haberse derramado. Le quita el realismo.

Me agrada el menú gráfico (por así decirlo) de las armas, la hora, y las estrellas policíacas.

Documentación técnica

Hablaré sobre diversos generadores de documentación técnica. Espero les sirva para elegir el que mejor se adapte a sus necesidades y sobre todo al lenguaje que estén manejando:

Doxygen:

Lenguajes: C, C++, Objective-C, Java, Python, IDL, PHP, C#, D.

Es muy adaptable, y gracias a eso funciona tanto el Windows como en distribuciones Unix.

JavaDoc

Lenguajes: Java.

Genera documentación HTML a partir de archivos de clases en Java. Deben usarse tags de HTML seguidas por @ un arroba. Se escriben al inicio de cada clase o método del que se quiera documentar. Con comentarios que comienzan con: /** y terminan con */

@autor: Persona que elaboró el código y la documetanción
@deprecated: Indica que esta función es vieja y podría llegar a desaparecer con el paso de las versiones posteriores.
@param: Define parámetros de un método
@return: Informa sobre lo que devuelte dicho método.
@see: Se asocia con otra clase o método
@throw: Arroja excepciones
@version: Versión de la clase o método.

Epydoc

Lenguajes: Python

Autogenera documentación de códigos hechos solamente en Python. Arroja resultados en forma de archivos en HTML, muy parecidos a los de JavaDoc. Sencillo de utilizar, no viene instalado default con Python, si lo queremos descargar, seguimos con la instrucción: sudo apt-get install python-epydoc

Fuentes: http://sudokill.blogspot.com/2011/03/epydoc-como-documentar-en-python-de.html
http://es.wikipedia.org/wiki/Javadoc
http://es.wikipedia.org/wiki/Anexo:Comparativa_de_generadores_de_documentaci%C3%B3n

Cómo mover una imagen en Python

A continuación mostraré código para mover nuestro gatito por la pantalla en el eje horizontal:

#!/usr/bin/python

import pygame

pygame.init()
pantalla=pygame.display.set_mode((600,400))
salir=False
reloj=pygame.time.Clock()
gatito=pygame.image.load("CatMariobien1.png")
(x,y)=(100,100) #Aquí especifico mis coordenadas para que se sitúe ahí mi gatito
vx=0 #Esta es la velocidad que más adelante explico

while salir!=True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            salir=True
        if event.type == pygame.KEYDOWN: #Evento de oprimir tecla
             if event.key == pygame.K_LEFT: #Oprimir tecla LEFT anvazará 10 pix
                 vx-=10
             if event.key == pygame.K_RIGHT: #Oprimir tecla RIGHT avanza 10 pix
                 vx+=10
        if event.type == pygame.KEYUP: #Evento de dejar de oprimir tecla
            if event.key == pygame.K_LEFT: #Cuando se deja de oprimir la vel es 0
                vx=0
            if event.key == pygame.K_RIGHT: #Cuando se deja de oprimir la vel es 0
                vx=0


    x+=vx
    reloj.tick(15)
    pantalla.fill((0,0,0))
    pantalla.blit(gatito,(x,y))
    pygame.display.update()

pygame.quit()

Ponemos eventos de oprimir para que cuando el usuario oprima la tecla el monito avance los pixeles que ya establecimos, y pusimos eventos de dejar de oprimir, porque con lo anterior el monito no dejaba de avanzar, y ya con esto la velocidad que lleva el monito se frena a 0 y deja de avanzar cuando dejamos de oprimir la tecla.

Funciones de pruebas unitarias en Python

A continuación anexo unas funciones que nos sirven para hacer pruebas unitarias en el lenguaje de progrmación. Para esto, debemos tener instalado Epydoc, y al iniciar nuestro código debemos importar "unittest" para poder correrlas apropiadamente.

assertAlmostEqual(first, second, places=7, msg=aquí ponemos lo que queramos desplegar): Comprueba que los objetos pasados como parámetros sean iguales hasta el séptimo decimal (o el número de decimales indicado por places).

assertEqual(first, second, msg=aquí ponemos lo que queramos desplegar): Comprueba que los objetos pasados como parámetros sean iguales

assertFalse(expr, msg=aquí ponemos lo que queramos desplegar): Comprueba que la expresión sea falsa.

assertNotAlmostEqual(first, second, places=7, msg=aquí ponemos lo que queramos desplegar): Comprueba que los objetos pasados como parámetros no sean iguales hasta el séptimo decimal (o hasta el número de decimales indicado por places).

assertNotEqual(first, second, msg=aquí ponemos lo que queramos desplegar): Comprueba que los objetos pasados como parámetros no sean iguales.

assertRaises(excClass, callableObj, *args, **kwargs): Comprueba que al llamar al objeto callableObj con los parámetros definidos por *args y **kwargs se lanza una excepción de tipo excClass.

assertTrue(expr, msg=aquí ponemos lo que queramos desplegar): Comprueba que la expresión sea cierta.

assert_(expr, msg=aquí ponemos lo que queramos desplegar): Comprueba que la expresión sea cierta.

fail(msg=None): Falla inmediatamente.

failIf(expr, msg=aquí ponemos lo que queramos desplegar): Falla si la expresión es cierta.

failIfAlmostEqual(first, second, places=7, msg=aquí ponemos lo que queramos desplegar): Falla si los objetos pasados como parámetros son iguales hasta el séptimo decimal (o hasta el número de decimales indicado por places).

failIfEqual(first, second, msg=aquí ponemos lo que queramos desplegar): Falla si los objetos pasados como parámetros son iguales.

failUnless(expr, msg=None): Falla a menos que la expresión sea cierta.

failUnlessAlmostEqual(first, second, places=7, msg=aquí ponemos lo que queramos desplegar): Falla a menos que los objetos pasados como parámetros sean iguales hasta el séptimo decimal (o hasta el número de decimales indicado por places).

failUnlessEqual(first, second, msg=aquí ponemos lo que queramos desplegar): Falla a menos que los objetos pasados como parámetros sean iguales.

failUnlessRaises(excClass, callableObj, *args, **kwargs): Falla a menos que al llamar al objeto callableObj con los parámetros definidos por *args y **kwargs se lance una excepción de tipo excClass.

Fuente: http://mundogeek.net/archivos/2008/09/17/pruebas-en-python/

Hacer orientado a objetos programas en Python

Python es un lenguaje de programación híbrido, en el cual no se necesita trabajar con clases para sólo programar (como lo es en Java)

A continuación pondré un código que extraje del manual Python para todos, y analizaremos el código.

class Coche:

“””Abstraccion de los objetos coche.”””

def __init__(self, gasolina):

self.gasolina = gasolina

print “Tenemos”, gasolina, “litros”

def arrancar(self):

if self.gasolina > 0:

print “Arranca”

else:

print “No arranca”

def conducir(self):

if self.gasolina > 0:

self.gasolina -= 1

print “Quedan”, self.gasolina, “litros”

else:

print “No se mueve”

Tenemos nuestra clase Coche, con los métodos "arrancar" y "conducir" y vemos que después de inicializar nuestra clase tenemos "__init__" esto nos quiere decir que se ejecuta justo después de crear un nuevo objeto a partir de la clase, a esta función se le llama: intanciación.

Vemos que el programa no dice que si hay más de 0 en gasolina en auto puede arrancar, y por lo tanto tenemos permiso a conducirlo, y si el carro tiene menor o igual a cero de gasolina no podemos arrancar y mucho menos conducirlo. También podemos apreciar que tenemos unos print que nos advierte cuánta gasolina tiene o nos queda y si no se mueve nuestro vehículo.

Fuente: http://mundogeek.net/tutorial-python/ Aquí pueden descargar la guía "Python para todos"

Cargar imágenes en Python

Al principio que no sabía cómo cargar imágenes se me hacía algo muy difícil el sólo pensar en cómo cargar una. Pero despúes de ver tutoriales de Python, me di cuenta que es sumamente sencillo.

Paso 1: Sería una buena idea que tengamos una plantilla como la siguiente, ya que es muy básica para cuando queremos comenzar un juego en pygame:

Este pedazo de código lo que hace es lo siguiente: Carga la librería "Pygame" con "import pygame" después inicializa todas las funciones de esta con "pygame.init()"
Después nos carga una pantalla de 600x400 pixeles. En el ciclo While nos despliega la pantalla que indica que hasta que se ponga la tacha no se cerrará. Saliendo del while ponemos a 15 frames por segundo las actualizaciones de la pantalla, en la siguiente lína llenamos la pantalla de color negro.

Paso 2: Guardamos los cambios de nuestra plantilla y la cargamos para ver que nos despliega lo siguiente:

Paso 3: Ahora ya es tiempo de cargar nuestra imagen en la superficie de la pantalla que ya creamos anteriormente: Escribimos "gatito=pygame.image.load("CatMariobien1.png")" lo que nos hace esta línea de código es asignar la imagen CatMariobien1.png a nuestra nueva función llamada "gatito" la cual la ponemos para no tener que escribir toda la instrucción del otro lado de la igualdad cada vez que queramos llamar a nuestra imagen. Después la pintaremos en nuestra pantalla con la instrucción: "pygame.blit(gatito,(20,20))" lo que hace es pintar a nuestro gatito en las coordenadas 20,20 de nuestra pantalla.

Paso 4: Recordemos que la instrucción para pintar a nuestro gatito en la pantalla debe ser después de cuando establecimos nuestro fondo, ya que si lo hacemos antes no aparecerá en la pantalla porque primero se pintará a nuestro gatito y después nuestro fondo. Corremos nuestro programa y esto es lo que obtenemos:

Es todo por esta entrada, espero les haya servido.

#!/usr/bin/python

import pygame

pygame.init()

pantalla=pygame.display.set_mode((600,400))

salir=False

reloj=pygame.time.Clock()

gatito=pygame.image.load("CatMariobien1.png")

while salir!=True:

    for event in pygame.event.get():

        if event.type == pygame.QUIT:

            salir=True

    reloj.tick(15)

    pantalla.fill((0,0,0))

    pantalla.blit(gatito,(20,20))

    pygame.display.update()

pygame.quit()

Usar editor de imágenes GIMP

GIMP es un editor de imágenes como el Adobe Photoshop, pero no tan profesional.

En este tutorial quiero enfocarme a cómo utilizar GIMP para imágenes de videojuegos, ya que mi imagen yo la hice en ese editor, tanto la imagen de mi monito, como el de mi escenario.

Ahora haremos la imagen de Cat Mario, que es un juego muy parecido al Super Mario de super nintendo.

Para instalar GIMP en nuestro sistema operativo Ubuntu, usaremos esta instrucción en el terminal:

sudo aptitude install gimp

Ya que está instalado, lo abrimos y en la barra de herramientas de arriba seleccionamos "File" -> "New"

A continuación se nos despliega una venta para elegir las dimensiones de nuestra ventana nueva.

Elegimos si queremos pixeles (yo estaré usando pixeles) unos 70x70 para poder hacer al Cat Mario (es un monito de un videojuego muy parecido al Super Mario.

Se nos despliega la nueva imagen de 70x70 y le damos un zoom de 800% para poder maniobrar bien con la imagen. Antes de comenzar a hacer la imagen, haremos una copia de esta:

Ya que tenemos abierto GIMP, comenzamos a copiarlo pixel por pixel para que nos salga igual.

En mi opinión quedó muy parecido al real. Recuerden que siempre utilizamos esta herramienta, la del lapiz.

Ahora, lo haremos una imagen sin fondo.

Primero, haremos el fondo de un color distinto al Cat Mario. Como éste es blanco, tendrá que ser diferente a blanco, lo pondré verde. (Utilizando la herramienta de relleno de color)

Ahora, coloreamos el fondo de verde completo

Ahora, nos vamos a la herramienta "Layer" de la barra de herramientas de arriba, elegimos "Transparency" y a continuacón seleccionamos "Add Alfa Chanel"

Ahora nos vamos a la barra de herramientas de arriba de nuestra  ventana principal y elegimos Select y seleccionamos "By color" que nos  indica que elegiremos una capa de un solo color.

Seleccionamos con el mouse la parte de la imagen que queremos cortar, en mi caso quiero cortar el fondo así que le doy clic al fondo. Ahora nos vamos a la pestaña de la barra de herramientas llamada "Edit" y seleccionamos "Cut"

Y como resultado tenemos esto:

Ahora ya solamente tenemos a nuestro Cat Mario solo sin el fondo. Lo que sigue es guardar la imagen en un tipo de archivo .png para que lo pueda leer posteriormente Python.

Fuentes: http://elescaparatederosa.blogspot.com/2008/04/imagen-con-fondo-transparente-usando.html

sábado, 19 de noviembre de 2011

Pruebas unitarias Python Videojuego medieval

Las pruebas unitarias nos sirven para cuando queremos saber si nuestro software tiene fallos y poder resolverlos antes de distribuirlo.

Primero correré la prueba estándar, es decir pondré este código como una clase aparte en mi código del videojuego y lo correré:

class EjemploPruebas(unittest.TestCase):
    def test(sel):
        pass

if __name__ == "__main__":
    unittest.main()

Vemos que la prueba obtuvo un "OK" es decir que todo está en orden.
Nota: Recordemos importar unittest, con la siguiente línea al comienzo de nuestro código: "import unittest"

Ahora probemos que los parámetros que nosotros pongamos en la prueba sean los mismos con el comando: "assertEqual"

Aquí establecí que los parámetros de x sean iguales a los que después especifiqué.

Ahora vamos con nuestra siguiente prueba

Comprobaré que cierto valor que yo tecleo, sea el mismo al anteriormente mencionado. En este caso probaré la velocidad.

En este caso utilicé la función "assertTrue()" y mi resultado fue el siguiente:

A continuación haremos que una prueba falle. Con la función: failIf. Esta expresión manda un mensaje de fallido si la expresión es igual.

Y nos manda un mensaje de fallido como el que muestro a continuación

Hasta aquí llegan las pruebas.

Fuentes: http://mundogeek.net/archivos/2008/09/17/pruebas-en-python/

Cómo correr pruebas unitarias en Python

Estuve buscando un poco en la web sobre cómo correr pruebas unitarias en Python, y me encontré con un estupendo tutorial que facilita mucho la realización de dichas pruebas.

Creo que al inicio no me di cuenta de que, como todos mis compañeros de taller de POO están codificando en Java, tendría algunas dificultades al yo utilizar Python. Digo esto porque mis compañeros se pueden ayudar entre sí al momento de enfrentarse con algún problema, pero al ser yo la única programando en Python, pienso que eso dificulta para mí un poco las cosas.

Espero estas entrada pueda facilitar a compañeros que llevarán POO y quieren hacer su proyecto en Python, un lenguaje que a mí me gusta mucho.

Lo primero que haremos es abrir en el terminal y escribir: "emacs pruebauni1.py" emacs es por el editor de texto que utilizaremos y "pruebauni1.py" es el nombre del archivo junto con la extensión .py que pertenece a archivos de Python.

Damos Enter y se abrirá una nueva ventana de emacs lista para empezar a programar. Escribimos lo siguiente para correr nuestra prueba:

!/usr/bin/python
import unittest

class EjemploPruebas(unittest.TestCase):
    def test(sel):
        pass

if __name__ == "__main__":
    unittest.main()

Hacemos la combinación de teclas Ctrl-x y Ctrl-s para guardarlo e irnos a la terminal. Ya que estemos de vuelta en la terminal, escribimos: "chmod u+x pruebauni1.py" para poder tener permisos para ejecutarlo, damos Enter y escribimos ./pruebauni1.py para poder ejecutar.

Damos Enter y recibiremos esto en nuestra terminal:

Vemos que ya pudimos correr la prueba y que salió "OK" como respuesta, es decir que todo esta bien.

Para poder ver qué sucede cuando se corre una prueba cuyo resultado no es aprobado, cambiaremos el "pass" de nuestro código por lo siguiente: raise AssertionError()

Guardamos los cambios, volvemos al terminal y corremos nuestra prueba de nuevo.

Vemos que obtuvimos un error.

Fuentes: http://mundogeek.net/archivos/2008/09/17/pruebas-en-python/

viernes, 18 de noviembre de 2011

Documentación técnica (código)

Al comienzo quise hacer mi documentación técnica con Doxygen, pero se me dificultó un poco encontrar información relacionada con Python (lenguaje que estoy utilizando para mi programa) y me decidí mejor por Epydoc, que es la documentación especialmente para Python. Es muy sencilla de utilizar, aquí los pasos que me llevaron a conseguirla:

Paso 1: Una vez generados los códigos de los diagramas de clases elaborados en uml, debemos tener instalado Epydoc. En el terminal escribimos: sudo apt-get install python-epydoc

Paso 2: Damos Enter y se instalará en nuestra computadora el Epydoc, es un poco pesado así que se tardará un tiempo. Ya que lo tenemos instalado nos situaremos en la carpeta donde tenemos nuestro código generado, y ya que estemos ahí, ejecutamos cada archivo de nuestras clases con "epydoc Jugador.py" es decir, primero "epydoc" ya que es nuestro programa para elaborar la documentación seguida de un espacio y el nombre de nuestro archivo con la extensión .py

Lo hacemos con todas las clases que se hayan generado en nuestro diagrama de clases y ya tendremos una carpeta llamada "html" y ahí se encuentra nuestra documentación.

Es todo por esta entrada, espero les haya servido a todos aquellos que les guste programar en Python tanto como a mí.

______________________________________________________-

_______________________________________________________________________

Nota: Se generaron más archivos con extensión .html pero consideré que estos fueron los más importantes, ya que son los principales de mis clases.

Fuentes: http://mundogeek.net/archivos/2008/07/07/documentacion-en-python/
http://epydoc.sourceforge.net/
http://preguntas.barrapunto.com/article.pl?sid=04/10/14/0914213

Autogeneración de código a partir de uml.

Después de realizar mi diagrama de clases, aquí presento el código que autogeneró dicho diagrama.

Para mi clase de Jugador, este fue el resultado:

from Fierro import *
from Double import *

class Jugador(object):

  """
   

  :version:
  :author:
  """

  """ ATTRIBUTES

   

  sprite  (private)

   

  ancho  (private)

   

  largo  (private)

   

  posicionX  (private)

   

  posicionY  (private)

  """

  def colisionar(self, f):
    """
     

    @param Fierro f : 
    @return  :
    @author
    """
    pass

  def mover(self, x, y):
    """
     

    @param double x : 
    @param double y : 
    @return  :
    @author
    """
    pass

  def setLargo(self, l):
    """
     

    @param double l : 
    @return  :
    @author
    """
    pass

  def setAncho(self, a):
    """
     

    @param double a : 
    @return  :
    @author
    """
    pass

  def getLargo(self):
    """
     

    @return double :
    @author
    """
    pass

  def getAncho(self):
    """
     

    @return double :
    @author
    """
    pass

Y este es el código generado por la clase Fierro

class Fierro(object):

  """
   

  :version:
  :author:
  """

  """ ATTRIBUTES

   

  tamanio  (private)

   

  velocidad  (private)

   

  color  (private)

   

  estado  (private)

  """

  def calcularVelocidad(self):
    """
     

    @return  :
    @author
    """
    pass

  def calcularTamanio(self):
    """
     

    @return  :
    @author
    """
    pass

  def aparecer(self):
    """
     

    @return bool :
    @author
    """
    pass

  def desaparecer(self):
    """
     

    @return bool :
    @author
    """
    pass

Cómo generar código a partir de diagrama uml

Una vez que tengamos bien hecho nuestro diagrama uml, tenemos la opción de también autogenerar código, lo cual se nos hará mucho más sencillo a la hora de programar nuestro proyecto. En mi caso hice el diagrama en Umbrello, un software libre no muy estable, pero funciona considerablemente bien.

Paso 1: Ya que tenemos nuestro diagrama de clases elaborado en Umbrello (como el que se muestra en la foto) nos iremos a la pestaña Code.

Paso 2: Damos clic en "Code" y nos vamos a la opción "Code Generation Wizard..."

Paso 3: Damos clic en la opción de "Code Generation Wizard..." y nos aparece una ventana nueva como esta:

Paso 4: Debemos dar clic y ponerle en el botón "Remove" a todos los elemenos que no sean nuestras clases, para que las clases queden del lado derecho solas. En mi caso, mis clases son Fierro y Jugador, las demás irán del otro lado de la pantalla.

Paso 5: Damos clic en "Next" y le damos clic al cuadro desplegable donde nos aparecerán distintos lenguajes de programación. Aquí elegimos el que nosotros vayamos a utilizar para programar. En mi caso elijo "Python" y damos clic en "Next"

Paso 6: Nos aparece una ventana como la siguiente y damos clic en el botón "Generate" donde nos generará en una carpeta algunos esqueletos de nuestras clases seleccionadas.

Espero esta entrada haya servido a la gente que quiere generar código apartir de su diagrama uml, lo cual facilita enormemente el trabajo.

jueves, 17 de noviembre de 2011

Cómo hacer un ejecutable de Python

En esta entrada quiero explicar cómo hacer un archivo de python ejecutable. Yo lo necesité para poder hacer un archivo ejecutable de mi videjuego "Juego Medieval" para que mis amigos que no tienen Python instalado en sus computadoras lo puedan jugar.

Nota: Tenemos que tener instalado Python 2.5 ya que este maneja muy bien la librería "pygame" (se muestran algunos problemas si utilizamos la versión de Python 2.7) también debemos tener instalado "pygame", "py2exe" y "pygame2exe" el respectivo para la versión Python 2.5

Paso 1: Necesitamos añadir Python a nuestro PATH. Lo primero que haremos es ir a Inicio, y en donde dice "Equipo" damos clic derecho y seleccionamos "Propiedades"

Paso 2: Ya que estamos en las propiedades nos vamos a "Configuración avanzada del sistema"

Paso 3: Después de haber dado clic en "Configuración avanzada del sistema" y nos aparece una ventana como esta, y damos clic en "Variables de entorno"

Paso 4: Estando ya en "variables de entorno" nos aparece una ventana como la siguiente:

Paso 5: En la parte de abajo, que dice: "Variables del sistema" buscamos una variable llamda "Path" le damos clic.

Paso 6: Una vez seleccionada damos clic en el botón que aparece abajo "Editar" y escribimos lo que está selesccionado en azul en la pantalla siguiente: ;C:\Python25;C:\Python25\Scripts (con todo y el ; ya que este separa de otras instrucciones que ya están ahí)

Paso 7: Damos clic en aceptar y ahora nos vamos al CMD y tecleamos "Python" y debe darnos estas instrucciones indicando que lo que hicimos estuvo bien

Paso 8: Ya que todo está bien, crearemos una carpeta llamda "mycode" en C:

Paso 9: Ya que tenemos nuestra carpeta creada, abrimos el IDLE de Python y abrimos una nueva ventana.

Paso 10: Escribimos en nuestro programa lo siguiente:

print "Hello py2exe"
raw_input("Close Window to Finish")

y lo llamaremos "hello.py" y lo guardamos en la carpeta que acabamos de crear "mycode" en C:

Paso 11: Ahora abrimos otra ventana del IDLE y escribimos un programa que lo llamaremos "setup.py" con el siguiente código

from distutils.core import setup
import py2exe
setup(
console = [{"script":"hello.py"}]
)

Paso 12: Guardamos el programa también en la carpeta "mycode" y nos vamos al cmd y tecleamos esto: CD C:\mycode para poder cambiarnos al directorio "mycode"

Paso 13: Tecleamos en el cdm "python setup.py py2exe" y veremos que nos despliega el archivo hello.py que himos al comienzo.

Después de esto checamos en nuestra carpeta "mycode" que se generaron 2 nuevas carpetas, una de ellas es la que nos importa, llamda "dist" y esta contiene nuestro archivo ejecutable "hello"

En mi caso para el videojuego que hice, modificaré el archivo de "setup.py" poniéndole esto:

from distutils.core import setup
import py2exe
setup(
    windows = [{"script":"juego4.py"}],
    data_files = [(".", ["monito1.png", "monitopierde.png", "escenario.png"])]
    )

Yo le puse "juego4.py" porque es el nombre de mi archivo que quiero hacer ejecutable, y en "data_files" van los archivos que ocupa el programa, en mi caso son 3 imágenes.

Hacemos el mismo procedimiento que hicimos anteriormente con el setup.py de hello.py en el cmd.

Descargamos la plantilla de pygame2exe en pygame.org http://pygame.org/wiki/Pygame2exe y la copiamos en una ventana del IDLE de Python y lo guardamos en la misma carpeta que tengamos nuestro juego, en mi caso lo pondré en la carpeta de "mycode"

Como podemos ver en la imagen hay que modificar algunas cosas de la clase "Build" lo demás no hay que tocarlo porque si no ya no funcionará nuestro ejecutable. Como pueden ver donde dice self.project_name va el nombre que tú quieres para el proyecto, en mi caso le puse "Juego Medieval"

En self.script va el nombre de nuestro archivo que queremos hacer ejecutable, en mi caso es juego4.py

En self.project_url podemos poner el url de nuestra página web, en mi caso puse el de mi blog.

En self.project_version escribimos la versión de nuestro juego, en mi caso lo dejé sin modificar

En self.extra_datas van entre comillas y separadas por comas nuestras imágenes o archivos de audio que utilizamos en nuestro programa o también podemos poner el nombre de la carpeta, aunque no lo recomiendo ya que tuve problemas para que la detectara como carpeta, así que es mejor si ponemos cada archivo individualmente. *Es importante que los archivos estén en la misma carpeta que el código del juego y que la plantilla que estamos haciendo*

En self.extra_modules escribimos las librerías que importamos al inicio de nuestro programa, en mi caso sólo utilicé la de "random"

Después guardamos nuestro código en la misma carpeta donde están las imágenes y el código del juego. En seguida nos vamos al cmd y tecleamos:

python mygame2exe.py py2exe

Y nos empezará a llenar la pantalla de instrucciones hasta que nos pide que oprimamos una tecla y ya estará nuestro archivo ejecutable en la carpeta que se generó llamda "dist"

Recordemos que para poder pasarla a nuestros amigos que quieran el juego debemos pasar toda la carpeta de "dist" ya que si pasamos sólo el ejecutable nos dirá que no encuetra las imágenes solicitadas por el programa.

Fuentes: http://www.daniweb.com/software-development/python/threads/194102
http://www.netveloper.com/2009/11/anadir-ruta-al-path-de-windows-7/

Etiquetas

martes, 22 de noviembre de 2011

sábado, 19 de noviembre de 2011

viernes, 18 de noviembre de 2011

jueves, 17 de noviembre de 2011