viernes, 31 de mayo de 2013

Tutorial Pygame parte 2

En esta ocasión aprenderemos un poco de gravedad en un videojuego,o mejor dicho mas especifico  simular la gravedad en pygame,primero que nada vamos a simular el rebote de una pelota,como ya es bien conocido en pygame,luego usaremos esas mismas teorías para emular la gravedad.

Parte 1

Primero que nada usaremos esta funcion de pygame,(move) mas en especifico rect.move:

mover rectángulos

En pygame usamos mucho los rectángulos,en el tutorial pasado y en este solo hemos usado y usaremos rectángulos,que son imágenes con alfa y por eso no se ve el rectángulo,existen muchas funciones de los rectángulos que en teoría es lo que crea todo el juego,manipulación de rectángulos(imágenes):

Mas informancion

Primero que nada debemos tener una plantilla para realizar la programación de nuestro juego(que hasta ahora son solo ejercicios de entendimiento),la cual puede ser así:

Enlace

Bien,esa plantilla la pueden usar,es la mas común pero en este caso usaremos la que usamos en el tutorial pasado:

Primero que nada vamos a usar esta función de pygame move(),a la cual se le pasan dos parámetros:

rect.move(x,y) # Horizontal vertical

Para ello crearemos una lista para pasar el valor de x,y:

xy = [0,5]:

0 es el movimiento en horizontal y 5 en vertical,ya que solo quiero emular la caída de un objeto.

También definimos una lista con el valor de nuestro fondo en RGB:

Hasta ahora va así:

 #!/usr/bin/env python  
 #-*- coding:utf-8 -*-  
 size = alto,ancho = 400,400  
 xy = [0,5]  
 color = [119,255,221]  

Vamos a usar la función de cargar imágenes abajo de eso:

 def cargar_imagen(nombre,alfa=False):   
   imagen = pygame.image.load(nombre)   
   if alfa == True:   
     imagen = imagen.convert_alpha()   
   else:   
     imagen = imagen.convert()   
   return imagen   

Y vamos a crear una clase para poder definir la pelota:

 class Pelota(pygame.sprite.Sprite):  
   def __init__(self):  
     pygame.sprite.Sprite.__init__(self)  
     self.imagen = cargar_imagen("objeto.png",alfa=True)  
     self.rect = self.imagen.get_rect()  
     self.rect.centerx = alto / 2  
     self.rect.centery = ancho / 2  

Eso nos crea una clase para poder crear pelotas,una en esta ocasión que estará en la mitad de la pantalla(como vimos en la parte uno de los tutoriales):

Abajo de la clase iniciamos pygame,la pantalla,instanciamos la pelota y cargamos la imagen(lo vimos en la primera parte del tutorial):

 screen = pygame.display.set_mode(size)  
 pygame.display.set_caption("Ejemplo 2")  
 pelota = Pelota()  
 imagen_pelota = pelota.imagen  
 jugando = True  

Ademas de eso,abajo vamos a añadir:

clock = pygame.time.Clock()

La función tiem.Clock de pygame manipula los framerate(FPS[imágenes en movimiento]) del juego,ya que al mover las imágenes se puede ver un poco trabado,usando FPS de 50 o 60 se vera muy bien.

Ahora añadimos lo que falta:


 while jugando:  
   clock.tick(60)  
   for event in pygame.event.get():  
     if event.type == pygame.QUIT:  
       jugando = False  
   pelota.rect = pelota.rect.move(xy)  
   if pelota.rect.top < 0 or pelota.rect.bottom > ancho:  
     xy[1] = -xy[1]  
   screen.fill(color)  
   screen.blit(imagen_pelota, pelota.rect)  
   pygame.display.flip()  
 else:  
   sys.exit()  

Con la funcion tick(60) estamos diciendo que vamos a usar 60 FPS.

Con pelota.rect.move(xy) estamos diciendo que mueva la pelota en xy que es 0,5 en este caso solo funciona el movimiento y(vertical) al cual sumara 5 y creara un efecto de atraccion a lo que seria el suelo(hacia abajo):

Con :

if pelota.rect.top < 0 or pelota.rect.bottom > ancho:  
Estamos diciendo que si la localización de la pelota,toca la parte superior(top) o toca la parte inferior(bottom) le reste su mismo valor al item numero 1 de la lista que mueve la pelota(5) y así crear un efecto de rebote al tocar alguna de los dos partes de la pantalla:

Así queda el código final:

Enlace


Si no tienen una pelota pueden usar esta:


Solo coloquen-la donde esta el script que acabamos de crear.




Ahora vamos a hacerlo mas interesante,vamos a eliminar el código que hace rebotar.

Ahora vamos a crear una clase para crear rectangulos,los cuales vamos a tomar de una imagen,esta:



Descarguen y guardenla donde esta el script:

Ahora creamos la clase que va ha hacer que ese rectangulo entre en el juego:

 class Rect(pygame.sprite.Sprite):   
   def __init__(self,x,y):  
     self.x = x  
     self.y = y  
     pygame.sprite.Sprite.__init__(self)   
     self.imagen = cargar_imagen("rectangulo.png",alfa=True)   
     self.rect = self.imagen.get_rect()  
     self.rect.centerx = self.x   
     self.rect.centery = self.y  

Le pasamos dos parametros,(x,y) para poder posicionarlos en la pantalla,se los pasaremos al constructor(__init__) para poder crear varios rectangulos de esta clase:

Los instanciamos y cargamos la imagen de dos rectángulos:

 rect1 = Rect(75,90)  
 rect2 = Rect(150,140)  
 imagen_rect1 = rect1.imagen  
 imagen_rect2 = rect2.imagen  

Nuestro bucle while va a quedar así:

 while jugando:  
   clock.tick(50)  
   for eventos in pygame.event.get():  
     if eventos.type == pygame.QUIT:  
       jugando = False  
     elif eventos.type == pygame.KEYDOWN:  
       if eventos.key == pygame.K_q or eventos.key == pygame.K_ESCAPE:   
         jugando = False  
       elif eventos.key == pygame.K_LEFT:   
         pelota.rect.centerx -= 5   
       elif eventos.key == pygame.K_RIGHT:   
         pelota.rect.centerx += 5  
   pelota.rect = pelota.rect.move(xy)  
   pelota.update()  
   screen.fill(color)  
   screen.blit(imagen_pelota, pelota.rect)  
   screen.blit(imagen_rect1, rect1.rect)  
   screen.blit(imagen_rect2, rect2.rect)  
   pygame.display.flip()  
 else:  
   sys.exit()  

Si vieron el tutorial pasado observaran que con ese código podemos mover la pelota de izquierda a derecha y que podemos salir del juego pulsando esc o q,otra cosas que cabe mencionar es que donde estaba la estructura que hacia rebotar la pelota esta vez esta un metodo de la pelota(update()) el cual aun no creamos,aunque la funcion que mueve la pelota aun se encuentra,esto es para que la pelota caiga al suelo creando un efecto de gravedad basico,mas abajo se muestra que añadimos los dos rectangulos al juego.

Para poder ejecutar el codigo vamos a añadir el metodo update a la clase Pelota:


   def update(self):  
     if self.rect.colliderect(rect1.rect):  
       self.rect.centery = rect1.rect.centery - 15  
     if self.rect.colliderect(rect2.rect):  
       self.rect.centery = rect2.rect.centery - 15  
     if self.rect.centerx <= 10:  
       self.rect.centerx = 10  
     if self.rect.centery >= alto - 10:  
       self.rect.centery = alto - 10  
     if self.rect.centerx >= ancho - 10:  
       self.rect.centerx = ancho - 10  

Lo explico:

Este update son solo estructuras selectivas que verifican si la pelota choco con un objeto de la pantalla,en este caso puede ser el rectángulo 1 o 2 y también que no se salga de la pantalla,ya que en la entrada pasada si se salia la pelota que creamos para ver la ubicación de un objeto:

Todo esto se logra con la función colliderect,que verifica una colisión de dos objetos,el cual es:

objeto.rect.colliderect(x,y): # x,y posicion del otro objeto
Las variables que dicen:

self.rect.centerx = numero
Estamos diciendo que le asignamos un nuevo valor a la posicion (x,y) vertical(centery) o horizontal(centerx).

El código entero queda así,ya que no explique cosas que teniamos que añadir que explique en el tutorial pasado:

Enlace
Eso es todo,también les dejo un código mas avanzado en el cual agrego un elevador que sube la pelota de nuevo(usando lo que se aprendió en esta entrada),estúdienlo,compréndalo,modifiquen lo,mejorenlo:

Enlace
Eso es todo :D

Leer más...

miércoles, 29 de mayo de 2013

[Shell] cd Unix/Linux

Tutorial cd Linux/Unix

No se porque no hago tutoriales de Unix,osea el uso de comandos,lo intente un tiempo pero me dio vagancia,en fin comenzare una serie de tutoriales,que les llamare Shell,en los cuales pondré tutoriales sobre los comandos internos de la shell o de programas de tipo consola.

¿?

Y no es lo mismo?

NO.

Un comando interno de la shell es una función programada en el código de la misma, y un programa tipo consola es un añadido a la shell pero función con sus propias sources(algoritmos en x código),por ejemplo cd es una orden interna:

Abrimos una terminal y escribimos:

type cd



Y nos dice que tipo de ejecutable es,ahora por ejemplo ls

type ls

Puede que a muchos o a todos nos diga(a mi incluido) que es una alias,si es así lo desasociamos al alias:

unalias ls

Y de nueva cuenta:

type ls

Y nos dice que esta en /bin,osea que es un ejecutable instalado en /bin ya que si lo buscamos con el comando which,nos da la ruta

which ls

Y si buscamos cd:

which cd

No nos da nada,al estar en el código fuente de la shell al igual que type.

type type

Bien esa es la introducción y es en bash :D.

Cd quiere decir Change Directory,cambio de directorio,para navegar en la shell de Unix,ya que en la shell no tenemos botones para regresar ni para accesar a carpetas,para accesar a una carpeta usamos este comando:

cd Carpeta

Hay que tener en cuenta que no es lo mismo que :

cd  /Carpeta

Ya que al usar  la diagonal estamos diciendo que vaya a la raíz del sistema(root),por ejemplo:

cd /etc
Si queremos usar la diagonal sin que vayamos a root debemos indicarlo con un punto (.) que quiere decir,aquí(directorio actual):

cd ./Descargas

Para acceder a una carpeta pero sin tener ganas de escribir todo,hay dos formas(tal vez mas):

Primera forma:

Con Wildcard unix (*):

cd Carp*

Forma dos:

Tabulador(tecla tab):

cd Carp<tab>

Ver las carpetas disponibles:

ls --color=auto # Son las azules
Forma dos:

cd <tab><tab>

Regresar un directorio,para regresar se usa un doble punto seguido(..),que indica anterior(en las ramas del sistema):

cd ..

Por ejemplo tenemos estas carpetas:

 Home-|  
      |-Descargas  
      |-Documentos  
      |-Imagenes  

Estamos en la carpeta Descargas, y queremos volver al Home,eso es lo que dice arriba:

cd ..

Ahora estamos en Descargas,pero queremos ir a Documentos:

cd ../Documentos

Mas avanzado:

 Home-|           |-Imagenes-|Gentoo  
      |-Descargas-|-Musica-|mp3  
      |-Documentos  
      |-Imagenes-|-Fotos-|Linux  
      |  

Estamos en Descargas/Imagenes/Gentoo y queremos ir a Imagenes/Fotos/Linux:

cd ../../../Imagenes/Fotos/Linux 

Se ve complicado,pero es simple:

 Descargas/Imagenes/Gentoo  
 cd    ../      ../     ../Imagenes/Fotos/Linux  

Cada regreso(..) es una carpeta.

Ahora estamos en la carpeta Linux,pero como regresamos a Gentoo(si quisieramos),pues eso lo hace la variable de entorno OLDPWD:

En Linux/Unix existe una variable de entorno al usar bash,que se llama PWD($PWD),esta nos muestra donde estamos,actualmente:

echo $PWD

Además de esta existe una variable llamada OLDPWD($OLDPWD),que nos muestra el directorio anterior(en el que estábamos):

echo $OLDPWD

Podemos regresar de esta manera:

cd $OLDPWD

o

cd -

Eso es todo,también podemos definir variables de entorno,por ejemplo:

Imagenes Linux:

imlinux=~/Imagenes/Fotos/Linux

Y luego

cd $imlinux

Pero hay algunos problemas de seguridad,por lo cual no recomiendo hacer esto,pero si lo hacemos debe ir en el bashrc:

echo 'imlinux=~/Imagenes/Fotos/Linux' >> ~/.bashrc

También queda recordar que hay varias formas de ir a nuestro Home:

1.Variable de entorno:

cd $HOME

2.Wildcard Unix (~)

cd ~

3. Parámetro:

cd -P
cd -L 

4. (--)

cd --

Eso es todo :D
Leer más...

martes, 28 de mayo de 2013

Abrir directorio con Perl Linux

Muchas veces necesitamos abrir un directorio desde Perl para un script o un programa,esto lo podemos hacer desde las funciones de perl con los comandos opendir,readdir y closedir.

Bien,primero que nada para abrir un archivo necesitamos decir la carpeta que vamos a usar,en este caso vamos a definir el usuario así:

my $user = getlogin();

Ahora el Directorio,por ejemplo nuestro Home:

my $dir = "/home/" . $user;

Ahora vamos a abrir el directorio con la función opendir:

Definimos una variable que usaremos para leer el directorio,en este caso $recorrer:

opendir(my $recorrer, $dir) || die "Error :( $! \n";  

Ahora iniciamos un bucle while para que recorra el directorio,usando la variable que creamos al abrir el directorio:

 while(readdir $recorrer) {  
 # Codigo  
 }  

Cuando terminemos de recorrer y usar el directorio lo cerramos con el comando:

closedir $recorrer;

Eso es todo,al recorrer con un bucle while los archivos del directorio los guarda en su recorrido en la variable especial $_ ,veamos un ejemplo de como guardar los datos de un directorio en dos arrays:

#!/usr/bin/env perl  
my $user = getlogin();  
my $dir = "/home/" . $user;  
my (@archivos,@dirs) = ((),()); # Creamos dos arrays vacios  
opendir(my $recorrer, $dir) || die "Error :( $! \n";  
while(readdir $recorrer)  
 {  
   if (-d $dir . "/" . $_) { # Vemos si es un directorio  
     push (@dirs,$_); # Si es asi llenamos el array de directorios  
   }  
   if (-f $dir . "/" . $_) { # Hacemos lo mismo con los archivos  
     push (@archivos,$_);  
   }  
 }  
=pod  
 Aclaraciones  
 $dir . "/" . $_ # concatenamos los archivos del directorio para poder saber de que archivo trata  
 -d # Es para saber si es un directorio  
 -f # Es para saber si es un archivo  
 push # Añade un valor a un array  
=cut  
closedir $recorrer;  
foreach my $files(@archivos) { # Recorremos los arrays  
   print "Archivos : $files\n";  
}  
foreach my $directorios(@dirs) {  
   print "Directorios : $directorios\n";  
} # O hacemos lo que queramos con ellos  



Otra forma de hacer esto es con el modulo DirHandle,veamos:

#!/usr/bin/perl  
use DirHandle;  
my $user = getlogin();  
my (@archivos,@dirs) = ((),()); # Creamos dos arrays vacíos  
my $dir = "/home/" . $user;  
$directorio = DirHandle->new("$dir"); # Definimos directorio  
while ($_ = $directorio->read) { # Lo leemos  
   if (-d $dir . "/" . $_) {  
     push (@dirs,$_);  
   }  
   if (-f $dir . "/" . $_) {  
     push (@archivos,$_);  
   }  
 }  
undef $directorio; # Indefinidos el valor para cerrar el archivo  
foreach my $files(@archivos) {  
   print "Archivos : $files\n";  
}  
foreach my $directorios(@dirs) {  
   print "Directorios : $directorios\n";  
}  

Bien,eso es todo,use foreach para recorrer el array,pero podemos usar for,while ademas de que podemos usar las funciones de array,pop,push,sort,etc.

Eso es todo :D
Leer más...

lunes, 27 de mayo de 2013

Como instalar recovery en motorola dext desde Linux

El motorola dext es un smartphone viejo que tengo desde hace un tiempo ,aunque los android de antes no tenían mucho potencial ni el sistema ni el hardware,con los android de esa época aun les podemos dar un poco de vida instalando una rom, en estos momentos en el motorola dext tengo CM7.2 (Android 2.3.7) y aunque le falta hardware para poder hacer buen uso del sistema,funciona muy bien.

También como no hay muchas entradas de Android en el sitio le vendría bien,que hable de Android y de GNU/Linux.

Tutorial


1.Bajamos lo necesario:

Necesitamos el SDK de android para poder usar adb:

Web:

http://developer.android.com/sdk/index.html

Desde terminal:

cd ~; wget -c http://dl.google.com/android/android-sdk_r22-linux.tgz && tar xvf android-sdk*.tar

También necesitamos Java o Open JDK,instalarlo en tu sistema dependiendo la distribución que uses.

Debemos descomprimir el paquete en nuestro Home(de preferencia),si usaste el comando de terminal ya debe estar en el Home,pero si no extraerlo en el Home.

2.Ahora debemos exportar la carpeta donde esta el adb para poder usarlo al solo escribir adb(como en windows) y no tener que ir a la carpeta donde esta cada vez que lo usemos:

En terminal:

 echo 'export PATH=${PATH}:/home/$LOGNAME/android-sdk/platform-tools ' >> ~/.bashrc   


source ~/.bashrc

Listo,ahora vamos a añadir nuestro android a udev,como es un motorla,en terminal:

Entramos a root:

su 

Escribimos:

 echo 'SUBSYSTEM=="usb|usb_device", SYSFS{idVendor}=="22b8",SYMLINK+="android_adb", MODE="0666", USER="root"' >> /etc/udev/rules.d/51-android.rules  


Reiniciamos udev

/etc/init.d/udev restart

Y tambien añadimos la ruta de adb

cat <<EOD>> ~/.bashrc
export  PATH=${PATH}:/home/usuario_donde_tienes_adb/android-sdk/platform-tools
EOD

Iniciamos o reiniciamos adb server:

adb kill-server && adb start-server 

Salimos de root:

exit

Listo Linux Pc,ahora Linux Android.

En el smartphone,vamos a:

Ajustes -> Aplicaciones -> Desarrollo 

Y palomeamos Depuración USB

Lo conectamos a la Pc.

Y en la pc:

adb devices



Eso es todo para poder usar la shell de Unix de Android desde Linux/Pc.

3.Instalamos el recovery a la antigua:

Bajamos la .img

http://www.mediafire.com/?78bhnap98l2n7oo

En la terminal de Linux/Pc:

Nos pasamos a la carpeta de descargas:

cd ~/Descargas

Copiamos la imagen del custom recovery:

adb push recovery.img /sdcard/recovery.img

Entramos a la shell de android:

adb shell

Entramos a root:

su # (Le damos permiso desde el smartphone)

Flasheamos la revery

flash_image recovery /sdcard/recovery.img

Eso es todo,ahora hacemos limpieza

cd system

mount -o rw,remount /dev/block/mtdblock1 /system

pwd # Deben estar en system



Vemos si hay otra imagen

ls *.img

Si da error no importa,si no da error,ejecutamos:

rm recovery.img

Remontamos(ambos casos):

mount -o ro,remount /dev/block/mtdblock1 /system

Y salimos

exit

exit

Eso es todo :D



,bueno el hecho es que ya con un recovery,pueden instalar CM o una rom para darle vida a este telefono,que aunque es del 2009(creo) ya esta muy antiguo y con root y una rom como CyanogenMod le podemos dar nueva vida(o alargarla).

Leer más...

viernes, 24 de mayo de 2013

Tutorial Pygame parte 1

Bien,vamos a comenzar los tutoriales de creación de Juegos con Python usando la librería de pygame :D,algo que mas me gusta a la hora de programa es programar script's para sistemas Unix en Python,Perl,Bash,Lua,etc y últimamente estoy viendo pygame,una librería que conocía desde hace tiempo pero que no había probado muy a fondo,he tenido alguna experiencia programando juegos en lua para Windows y no se me complico tanto para entender el funcionamiento de pygame,así que les comparto lo que he aprendido y lo haré lo mas detalladamente posible y iremos al grano de programación (0 teoría) ,la teoría o las cuestiones mas técnicas fácilmente las pueden googlear así que iniciemos.

Tutorial

Este tutorial tiene previsto que ya sabes python, así que si no entiendes las partes fundamentales del lenguaje hecha un vistazo al espacio de python en Tiempo de Tux esta todo lo necesario sobre este lenguaje para entender este y los futuros tutoriales de pygame.

Enlace

Primero que nada yo uso Linux en especifico Gentoo/Debian/Arch, así que si usas windows ve la documentación de instalación de python en la pagina oficial, pero el tutorial de programación te funcionara.

Instalación:

En Debian:

sudo aptitude install pygame

En Gentoo

sudo emerge -av dev-python/pygame

Archlinux

sudo pacman -S python-pygame

Para otros sistemas googlen la instalación de pygame.

Creamos un documento de texto con nombre ejemplo1 y extension .py,ahora lo abrimos con nuestro editor de texto favorito,en mi caso uso Vim o Gedit.

1.Primero que nada vamos a importar lo necesario y definir lo necesario:

# el hash

! el bang

/usr/bin/env la ruta de env

python y el nombre de python

Nota. Si usas una distro muy actual como Arch (por ejemplo) python ya es python 3 y aquí usaremos python 2.7 así que en el nombre usaremos python2

Ve en terminal:

python -V

Si sale 3.x usa python2 en el nombre de python,si dice 2.x  usa solo python en el nombre.

Asi queda el hashbang:

#!/usr/bin/env python2

Enseguida definimos la codificación utf-8 para poder usar caracteres especiales:

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

Por ultimo importamos pygame en el espacio de las importaciones:

import pygame

Tambien sys para poder salir del juego cuando este en ejecución:

import sys

Bien,se recomienda usar una función main para el bloque principal de pygame,en mi caso y en estos tutoriales no ya que no es necesario.

Iniciamos definiendo las constantes del programa:

Primero nuestra pantalla:

La pantalla del videojuego es una ventana común y corriente en tamaño así que lleva las medidas alto y ancho:

Definiremos una tupla con las medidas y al mismo tiempo dos variables para poder usarlas:

size = alto,ancho = 400,400

Abajo de las constantes debemos inicializar todos los eventos de pygame con su función init:

pygame.init()

Con esto llamamos a pygame a la acción.

En un juego al igual que en la mayoría de los programas debemos crear un bucle principal que lo mantenga abierto en lo que ejecutamos su contenido,para hacer mas legible el código vamos a definir una variable que diga que estamos jugando:

jugando = True

Ahora iniciamos el bucle con la condición de la variable jugando:

while jugando:

Ahora completamos la condición while con else(while/else):

Debe quedar así:

 while jugando:  
   #juego  
 else:  
   sys.exit(0) # Para cuando dejemos de jugar cierre el juego  

Bien,en el bloque while vamos a anidar un bucle for que recorra los eventos de la lista que nos regresa pygame.event.get():

for eventos in pygame.event.get():

Pygame se manipula a base de eventos,estos son desde la entrada del teclado hasta posibles ocurrencias del sistema.

Añadimos una estructura selectiva en el bloque for,para manipular el evento QUIT de pygame,que es cuando cerramos la ventana desde el window manager(al darle a la x de la ventana):

if eventos.type == QUIT:
    jugando = False

Creamos un elif para el mismo grupo de eventos,esta vez sera para ver si un botón esta presionado ya que hay dos posibles eventos para los botones:

KEYDOWN # Cuando apretamos un botón
KEYUP # Cuando soltamos un botón (primero debemos presionarlo)

Así que esa estructura va asi:

elif eventos.type == pygame.KEYDOWN:

Ahora anidamos en esa estructura otra estructura,para ver que tecla presionamos,en este caso vamos a usar la tecla q para salir y la tecla esc:

if eventos.key == pygame.K_q or eventos.key == pygame.K_ESCAPE:
    jugando = False

Abajo de pygame.init() llamamos la ventana:

Para llamar la ventana o abrirla mejor dicho, debemos usar la función display.set_mode(tupla) pasandole una tupla o lista como parámetro de alto y ancho,como ya la definimos anteriormente, la abrimos definiendo una variable que usaremos en el futuro, así:

sreen = pygame.display.set_mode(size)

Y le podemos poner nombre a la ventana con la función pygame.display.set_caption(nombre)

pygame.display.set_caption("Ejemplo 1")

De momento solo vamos a ver como cerrar la pantalla,no necesitamos otro bloque de selección:

Esto va así en este momento:
 #!/usr/bin/env python2  
 # -*- coding: utf-8 -*-  
   
 import pygame  
 import sys  
   
 size = alto,ancho = 400,400  
   
 pygame.init()  
   
 sreen = pygame.display.set_mode(size)  
 pygame.display.set_caption("Ejemplo 1")  
   
 jugando = True  
   
 while jugando:  
   for eventos in pygame.event.get():  
     if eventos.type == pygame.QUIT:  
       jugando = False  
     elif eventos.type == pygame.KEYDOWN:  
       if eventos.key == pygame.K_q or eventos.key == pygame.K_ESCAPE:  
         jugando = False  
 else:  
   sys.exit(0)  
   

   
Es hora de ejecutarlo:

python ejemplo1.py
Nota: La misma advertencia de python,si python ya es 3.x ejecuta:
python2 ejemplo1.py


Es tiempo de colocar una imagen que a la ves nos servirá para analizar la ruta de una imagen en la posición x(horizontal) y y(vertical) :

Añadimos esta función arriba de pygame.init() :

 def cargar_imagen(nombre,alfa=False):  
   imagen = pygame.image.load(nombre)  
   if alfa == True:  
     imagen = imagen.convert_alpha()  
   else:  
     imagen = imagen.convert()  
   return imagen  

Esa función recibe dos parámetros la ruta o nombre de la imagen y si necesita transparencia,las imágenes con transparencia son los objetos que moveremos en el juego,en este caso no usare fondo pero para el fondo se usa:

imagen = imagen.convert()

Y para los objetos:

imagen = imagen.convert_alpha()

Pero para ambos siempre iniciando la variable imagen con el valor de pygame.image.load(nombre) (donde nombre,es el nombre o ruta a partir de la carpeta actual).

imagen = pygame.image.load("objeto.png")

Abajo de la función vamos a crear una clase (que heredara pygame.sprite.Sprite), que sera el objeto que moveremos:

Los sprites son la forma de tratar con los objetos en pygame(googlear para mas info)

 class Objeto(pygame.sprite.Sprite):  
   def __init__(self):  
     pygame.sprite.Sprite.__init__(self)  

Adentro de la clase cargaremos la imagen con la función que creamos anteriormente:

self.imagen = cargar_imagen("objeto.png",alfa=True)

Le añadimos el rect que es la posición en la que se encontrara al iniciar:

Primero hacemos un get a la imagen y luego lo definimos:

 self.rect = self.imagen.get_rect()  
 self.rect.centerx = alto / 2  
 self.rect.centery = ancho / 2 # De esta manera lo colocara en medio de la pantalla  

Asi queda nuestro programa hasta ahora

 #!/usr/bin/env python2  
 # -*- coding: utf-8 -*-  
   
 import pygame  
 import sys  
   
 size = alto,ancho = 400,400  
   
 def cargar_imagen(nombre,alfa=False):  
   imagen = pygame.image.load(nombre)  
   if alfa == True:  
     imagen = imagen.convert_alpha()  
   else:  
     imagen = imagen.convert()  
   return imagen  
   
 class Objeto(pygame.sprite.Sprite):  
   def __init__(self):  
     pygame.sprite.Sprite.__init__(self)  
     self.imagen = cargar_imagen("objeto.png",alfa=True)  
     self.rect = self.imagen.get_rect()  
     self.rect.centerx = alto / 2  
     self.rect.centery = ancho / 2  
   
 pygame.init()  
   
 screen = pygame.display.set_mode(size)  
 pygame.display.set_caption("Ejemplo 1")  
   
 jugando = True  
   
 while jugando:  
   for eventos in pygame.event.get():  
     if eventos.type == pygame.QUIT:  
       jugando = False  
     elif eventos.type == pygame.KEYDOWN:  
       if eventos.key == pygame.K_q or eventos.key == pygame.K_ESCAPE:  
         jugando = False  
 else:  
   sys.exit(0)  

Arriba del bucle while vamos a cargar las imagenes,primero instanciamos el objeto:

objeto = Objeto()

Luego cargamos su imagen definiendola en una variable,para poder trabajar con ella en el futuro:

imagen_objeto = objeto.imagen

Adentro del bloque del buble while,abajo del for hacemos un blit sobre la pantalla,que sera lo que cargara la imagen:

Le tenemos que pasar dos valores(en este caso),la imagen(Surface) y una lista o tupla con la posición X y Y:

Para la imagen(Surface) usamos la variable de la imagen y para la posición usamos la lista de clase (rect) del objeto objeto:

screen.blit(imagen_objeto,objeto.rect)

Ahora redibujamos la pantalla haciendo flip:

pygame.display.flip()

Ahora ejecutamos:

python ejemplo1.py

Si da error es porque no tenemos un objeto.png en esa carpeta,usen este :



Guardalo en la carpeta del juego



Ahora vamos a añadir un texto para saber donde se encuentra,en posición x y (y)

Pero primero vamos a cargar un fondo de color,en la zona de las constantes añadimos una lista con el color rgb:

color = [119,255,221]

Si no saben colores RGB o no recuerdan pueden visitar esta web:

http://coloreminder.com

Cargamos un font arriba del bucle while:

Se le pasan dos parámetros el nombre de la fuente y el tamaño,en mi caso si uso None carga la fuente por defecto y el tamaño le daremos 15:

font = pygame.font.Font(None,15)

Definimos una constante en la parte de las constantes con las variables que serán la posición del objeto:

vertical,horizontal = 0,0

En el bloque del bucle while añadimos el texto al font:

Primero definimos un texto,que en este caso sera la posición del objeto:

posicion = "x : %d y : %d" % (horizontal,vertical)

Se le pasan tres parámetros,el primero es el texto,el segundo es un boleano para definir los bordes lisos,el tercero es el color del texto en RGB:

text = font.render(posicion,1,(255,255,255))

Dibujamos la pantalla,abajo del bucle for fuera de este:

screen.fill(color)

Hacemos un blit al texto:

screen.blit(text,(20,20))

Por ultimo en la clase Objeto definimos las variables globales horizontal y vertical en un método update para que cambie:

 def update(self):  
   global horizontal,vertical  
   horizontal = self.rect.centerx  
   vertical = self.rect.centery  

Ahora debajo del bucle while añadimos el update del objeto:

objeto.update()

En estos momentos el script va asi:

 #!/usr/bin/env python2  
 # -*- coding: utf-8 -*-  
   
 import pygame  
 import sys  
   
 size = alto,ancho = 400,400  
 vertical,horizontal = 0,0  
 color = [119,255,221]  
   
 def cargar_imagen(nombre,alfa=False):  
   imagen = pygame.image.load(nombre)  
   if alfa == True:  
     imagen = imagen.convert_alpha()  
   else:  
     imagen = imagen.convert()  
   return imagen  
   
 class Objeto(pygame.sprite.Sprite):  
   def __init__(self):  
     pygame.sprite.Sprite.__init__(self)  
     self.imagen = cargar_imagen("objeto.png",alfa=True)  
     self.rect = self.imagen.get_rect()  
     self.rect.centerx = alto / 2  
     self.rect.centery = ancho / 2  
   def update(self):  
     global horizontal,vertical  
     horizontal = self.rect.centerx  
     vertical = self.rect.centery  
   
 pygame.init()  
   
 screen = pygame.display.set_mode(size)  
 pygame.display.set_caption("Ejemplo 1")  
   
 jugando = True  
 objeto = Objeto()  
 imagen_objeto = objeto.imagen  
   
 font = pygame.font.Font(None,30)  
   
 while jugando:  
   objeto.update()  
   posicion = "x : %d y : %d" % (horizontal,vertical)  
   text = font.render(posicion,1,(255,255,255))  
   for eventos in pygame.event.get():  
     if eventos.type == pygame.QUIT:  
       jugando = False  
     elif eventos.type == pygame.KEYDOWN:  
       if eventos.key == pygame.K_q or eventos.key == pygame.K_ESCAPE:  
         jugando = False  
   screen.fill(color)   
   screen.blit(text,(20,20))  
   screen.blit(imagen_objeto,objeto.rect)  
   pygame.display.flip()  
 else:  
   sys.exit(0)  

Ya podemos ejecutarlo:

python ejemplo1.py



Vamos a mover el objeto en la pantalla,para ello vamos a añadir los eventos necesarios:

En el bucle for en la estructura (elif eventos.type == pygame.KEYDOWN:)

Añadimos los sigiuentes elif's para manegar los eventos:

 elif eventos.key == pygame.K_LEFT:  
   objeto.rect.centerx -= 5  
 elif eventos.key == pygame.K_RIGHT:  
   objeto.rect.centerx += 5  
 elif eventos.key == pygame.K_UP:  
   objeto.rect.centery -= 5  
 elif eventos.key == pygame.K_DOWN:  
   objeto.rect.centery += 5  

Con eso manejaremos las pulsaciones de las cuatro direcciones,añadiendo 5 o disminuyendo 5 en la posición del objeto,recuerda que x es horizontal y (y) vertical.

Arriba del bucle while añadimos la repetición de las pulsaciones del teclado,que funcionaran para el movimiento o autofire en un juego de disparos:

pygame.key.set_repeat(1,20)

Con eso ya tenemos una buena herramienta para ver donde esta un objeto en la pantalla,vamos a hacerlo mas interesante,vamos a cambiar el color de la pantalla con la pulsación de la tecla (c)

Primero que nada creamos un modulo,que nos encuentre los colores RGB,yo programe este que usa colores grises,pueden modificarlo pero de momento así funciona:

 # -*- encoding: utf-8 -*-  
   
from random import randint  
   
def colores():  
  colors = 0  
  col = []  
  rgb = []  
  while (colors < 256):  
    col.append(colors)  
    colors += 8  
  col.append(255)  
  n = randint(0, len(col) - 1)  
  for i in range(0,3):  
    rgb.append(col[n])  
  return rgb  
   

Lo metemos en un archivo con nombre (colores.py) en la carpeta donde esta ejemplo1.py

Ahora en el ejemplo importamos los colores:

import colores

Y en la estructura de pulsacion de teclas añadimos este elif:

 elif eventos.key == pygame.K_c:  
   pygame.key.set_repeat(1,40) # Esto para detener las multiples pulsaciones(autofire)  
   color = colores.colores()  
   pygame.key.set_repeat(1,20) # Esto para devolver las pulsaciones de movimiento  

Eso es todo en este tutorial,el código final queda así:



Si tienen problemas de identacion/sangria identen manualmente el código.



Leer más...

lunes, 20 de mayo de 2013

Como mostrar archivos en árbol desde la terminal Linux

Así es en linux se puede mostrar las carpetas y archivos en modo Arbol,el modo Arbol es muy conocido en el explorador por defecto de Windows XP,por ejemplo,lo menciono porque es lo primero que me recuerda esta vista,bueno si no saben o no recuerdan que es la vista Arbol es esta (por ejemplo en nautilus):



Muy bueno,aunque me gusta mas la vista normal la llamada Lugares, en La shell de Linux en Bash,Sh,etc la vista lugares seria el equivalente a :

ls --color


Y la vista de Arbol es el comando Arbol en ingles:

tree


Para instalar en una terminal

sudo aptitude install tree

O el equivalente de tu distro.

Y veamos un poco:

Para mostrar solo directorios:

tree -d

Para mostrar permisos:

tree -p
Para mostrar tamaño de los directorios en bytes:

tree -s

Para mostrar tamaño legible para humanos:

tree -h
Ordenar por fecha de modificación:


tree -t

Ordenar por nombre:


tree -v
También se pueden hacer combinaciones,por  ejemplo directorios y permisos:

tree -dp
Tamaño y fecha de modificación:

tree -th
Etc.

También si tenemos muchos archivos o hacemos tree en nuestro Home de mas de 100gb puedes usar este pipe para ver tus archivos:

tree -C  | less -r
Mas info :

tree --help

Eso es todo :D
Leer más...

viernes, 17 de mayo de 2013

Como instalar plymouth en Debian wheezy

El plymouth es un splash screen en nuestro sistema operativo que inicia de manera gráfica el mismo,en muchos sistemas Linux no es necesario ya que inician demasiado rápido como es el caso de Arch con systemd,en Debian nos queda muy bien un inicio gráfico ya que demora un poco en encender.

A mi en lo personal me gusta un inicio grafico ya que ya paso el tiempo en que me gustaba ver los logs y los scripts de carga,ahora mismo prefiero un inicio grafico y aqui un tutorial para hacerlo en Debian wheezy.

Tutorial

1.Entramos en modo root:

su

2.Instalamos lo necesario:

aptitude install plymouth plymouth-dev

3.Instalamos lo necesario para nuestra Pc(controlador):

Intel:


aptitude install libdrm-intel1


Para driver libre Nouveau (nVidia):

aptitude install libdrm-nouveau1


Para drivers libres ATI Radeon:

aptitude install libdrm-radeon1
Ahora configuramos /etc/initramfs-tools/modules:

nano /etc/initramfs-tools/modules

Y añadimos:

Intel:

# KMS
intel_agp
drm
i915 modeset=1


Para drivers libres Nouveau (nVidia):

# KMS
drm
nouveau modeset=1

4.Configuramos el grub:

nano  /etc/default/grub

Y añadimos o editamos la variable GRUB_CMDLINE_LINUX_DEFAULT:

GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"


Actualizamos el grub:

update-grub2
Eso es todo :D

Para cambiar el tema ejecutamos:

plymouth-set-default-theme --list



Para ver los temas disponibles y :

plymouth-set-default-theme nombre_tema

Cambiarlo,por ultimo solo actualizamos initramfs:


update-initramfs -u

Reiniciamos y listo.

Nota: Puede que no sirvan algunos temas,esto se debe a que puede que tu tarjeta de video no este soportada y plymouth use el modo texto.

Referencia y mas informacion: wiki.debian.org/es/plymouth
Leer más...

miércoles, 15 de mayo de 2013

Como adelantar/atrasar la canción del iPhone desde el lockscreen

Algo que he encontrado muy útil en un tweak que instale de cydia es el poder adelantar y retrasar la canción que estemos escuchando en nuestro iPhone,iPod,iPad desde el lockscreen con una barra similar a la del volumen:

Vean:



Como se puede ver sale una barra de transcurso similar a la del volumen,desde ahí podemos adelantar y retrasar la canción.

El propósito del tweak no era justamente ese ya que hace mas cosas,como crear una lista rápida de musica para escuchar, tocando el botón de la derecha que esta al lado del volumen(en mi caso ya que se puede configurar lo posición).

El tweak esta en cydia así que necesitamos jailbreak,solo entramos y lo buscamos como

pluck
Instalamos y configuramos en la app de ajustes:



Luego disfrutamos :D,eso es todo.

Leer más...

Instalar firewall en Debian wheezy

Algo que tenemos que hacer principalmente al instalar un sistema operativo es asegurar las conexiones de red,ya que por ahí se puede ver afectada la seguridad de nuestro sistema y nuestros datos se pueden ver comprometidos. Como sabemos siempre hay o puede haber personas que exploten o logren explotar nuestra Pc como se dice comúnmente hackear,existen muchas formas de hacer esto de manera local o remota y en Linux no es la excepción,en este caso solo instalaremos un firewall con configuración normal,ya que directamente podemos usar ip tables,pero es un poco mas complicado asi que instalaremos UFW y GUFW para una fácil configuración de nuestro Firewall.

Tutorial

1. Instalar UFW(Uncomplicated Firewall) este programa nos comunica con ip tables de una manera mas sencilla,en otra palabras accede a las configuraciones de ip tables para Humanos :P.

Instalamos:

sudo apt-get update && sudo apt-get install ufw
Ahora configuramos con linea de comandos,en seguida instalaremos una interfaz gráfica,para que sea aun mas facil la configuracion pero ahora lanzamos los comandos:

Vemos el estado con:

sudo ufw status


Activamos con:


sudo ufw enable
Desactivamos con :

sudo ufw disable

Eso es lo mas importante,para crear reglas copy pasteo de wikipedia:

Muestra estatus detalladosudo ufw status verbose
Muestra Lista de Reglas Numeradasudo ufw status numbered
Bloquea todo el tráfico de entradasudo ufw default deny incomingEsto detendrá por defecto todo el tráfico entrante LAN desde Internet a menos que se especifique lo contrario en una regla
Permite todo el tráfico de entradasudo ufw default allow incomingEsto permitirá por defecto todo el tráfico entrante LAN a menos que se especifique lo contrario en una regla
Bloquea todo el tráfico salientesudo ufw default deny outgoingEsto detendrá por defecto todo el tráfico saliente hacia Internet LAN a menos que se especifique lo contrario en una regla
Permite todo el tráfico salientesudo ufw default allow outgoingEsto permitirá por defecto todo el tráfico saliente hacia Internet LAN a menos que se especifique lo contrario en una regla
Bloquea elpuerto 22sudo ufw deny port 22Esto detendrá a cualquiera en Internet que intente conectarse a dispositivos en el LAN usando SSH
Permite el puerto 22sudo ufw allow port 22Esto permitirá a cualquiera en Internet conectarse a dispositivos en elLAN usando SSH
Bloquea el puerto 22 solo para una persona específicasudo ufw deny from 220.60.90.55 to port 22Esto detendrá a la dirección IP 220.60.90.55 conectarse a dispositivos en el LAN usando SSH
Permite el puerto 22 solo para una persona específicasudo ufw allow from 220.60.90.55 to port 22Esto permitirá a la dirección IP 220.60.90.55 conectarse a dispositivos en el LAN usando SSH
Bloquea el puerto 22 solo para una red específicasudo ufw deny from 220.60.90.0/24 to port 22Esto detendrá a cualquiera usando una dirección IP en el rango 220.60.90.1 - 220.60.90.254 conectarse a dispositivos en el LAN usandoSSH
Permite el puerto 22 solo para una red específicasudo ufw allow from 220.60.90.0/24 to port 22Esto permitirá a cualquiera usando una dirección IP en el rango 220.60.90.1 - 220.60.90.254 conectarse a dispositivos en el LAN usandoSSH
Bloquea el puerto 53 en el UDPsudo ufw deny port 53Esto detendrá a cualquiera en Internet usando un DNS buscar dispositivos en el LAN
Permite el puerto 53 en el UDPsudo ufw allow port 53Esto permitirá a cualquiera en Internet hacer transacciones DNS sobre dispositivos en el LAN
Permite un rango de puertos TCPsudo ufw allow 2500:5000/tcpEsto permitirá a cualquiera en Internet comunicarse a cualquier puerto en el rango 2500 - 5000 en dispositivos en el LAN
Elimina un número de reglasudo ufw delete 1Esto borrará la primera regla en la lista de reglas
 Fuente : es.wikipedia.org/wiki/Uncomplicated_Firewall

Ahora si no nos gusta la linea de comandos,podemos instalar GUFW una interfaz gráfica para UFW:

Instalamos :

sudo apt-get install gufw

Lanzamos con :

gksu gufw

o con

dbus-launch gufw
En la terminal o en ejecutor (fn + alt + F2 )si no nos sale en el menu o dash de nuestro entorno de escritorio:


Para ver reglas vean Editar de GUFW,eso es todo :D


Leer más...

lunes, 13 de mayo de 2013

Uso avanzado de print python 3 (2/2)

Hace un tiempo coloque una entrada de el uso de print de manera avanzada o mejor dicho de manera correcta,ya tiene tiempo que lo realice y para terminar con estas dos partes vamos a ver la segunda:

Parte 1

Primero que nada vamos a ver las secuencias de escape en Python 3:

Retroceder un espacio :


\b
 Nueva linea :

\n 

Retorno de carro :


\r 

Avance de hoja :

\f
Tabulador horizontal


\t
Tabulador vertical

\v 
Cualquiera de esas secuencias las podemos probar de esta manera:

print ("\nHola \tMundo\n") 


Ahora veremos las Expresiones de Formato:

Cadena :

%s

Entero:

%d

Flotante:

%f

Flotante notación científica:

%e

Decimal negativo:

%u
Cualquiera de las Expresiones de formato se pueden usar de esta manera:

print ("Entero : %d\nTexto : %s" %(1,"T"))

También podemos usar valores de variables,por ejemplo:

cadena = "Hola esto es un texto"

flotante = 3.14

print  ("Flotante : %f\nTexto : %s" %(flotante,cadena))


Se recomienda ver el tipo de dato que estamos usando con el comando

type()

En la consola de python:


Eso es lo mas importante otra cosa curiosa es dar color a la shell,pero se necesitan usar caracteres similares a la de la shell como los que vimos en el tutorial del PS1 de Unix SH,pero no los conosco bien en python :(.

En python existe un modulo que se llama colorama,pero es para python2 :(

pypi.python.org/pypi/colorama
Leer más...

sábado, 11 de mayo de 2013

Como instalar Google Chrome en Debian 7.0 wheezy


Si bien un navegador me gusta es chrome,digan lo que digan,en Debian tambien contamos con Iceweasel y me gusta mas que firefox,pero me gusta mas chrome.

Tutorial

1.Entramos como root

su

2.Añadimos el repo de Google:

Editamos los repos con :

nano /etc/apt/sources.list

Y añadimos esta repo:

# Google Chome :D
deb http://dl.google.com/linux/chrome/deb/ stable main

Guardamos

ctrl + o

ctrl + x


3.Ahora hacemos un update

aptitude update

Nota si da error de llaves gpg(que es lo mas seguro) quedarse, si no da error pasar al paso 4.

Bien,si da error copiar la llave y escribir junto con esto:

gpg --keyserver subkeys.pgp.net –recv-keys llave

gpg --export --armor llave | apt-key add -

aptitude update 
La llave son números y nos los muestra en la terminal.

4.Instalar Chrome

Para instalar estable:

aptitude install google-chrome-stable

Para Beta:

aptitude install google-chrome-beta

Para unstable:

aptitude google-chrome-unstable

Esperamos y listo :D



Leer más...