Pygame (2 parte)

En esta entrada les mostrare como agregar una pelota a la ventana que habíamos creado en la entrada anterior de pygame, crear dos barritas como si fuera un juego.
Para lograr esto usaremos sprites, los sprites son usados en videojuegos para crear los gráficos de los protagonistas, en este caso nuestro sprite sera una pelota pequeña que rebotara entre la pantalla. Vamo a modificar el codigo que ya teniamos, para no volver a hacer las ventanas ni el fondo.
Para esto cambiaremos el fondo de pantalla que teníamos, ya que usaremos otro mas claro en donde se pueda apreciar la dicha pelota.
El fondo que yo use es este:

Nota: hay que guardar la imagen en la ubicación de nuestro código, así como cambiar el nombre en el código de la imagen para que pueda ser cargada.

Despues de esto descargaremos la imagen de la pelota, esta es la que yo use, pero ustedes pueden poner la que sea, mientras sea pequena:

Después de esto agregaremos las siguientes lineas a nuestro código:
-------------------------------------------------------------------------------------

class Bola(pygame.sprite.Sprite): --> esta función es para declarar las sprites, lo que seria la pelota


def __init__(self): --> aquí solo se inicia la clase de arriba


pygame.sprite.Sprite.__init__(self) -->esa función es parecida a la de arriba que sirve para llamar a la clase para el sprite


self.image = load_image("bola.png", True) -->aquí cargaremos la imagen de la pelota


self.rect = self.image.get_rect() -->en esta función se crean las barras, ya que crear en forma de rectángulo



self.rect.centerx = WIDTH / 2 -->esta linea y la de abajo es para la posición inicial de nuestra pelota, podemos modificar los valores para cambiar su posición.


self.rect.centery = HEIGHT / 2


self.speed = [0.5, -0.5] -->aquí podemos modificar la velocidad de la pelota, solamente cambiamos los valores.
-------------------------------------------------------------------------------------
Despues de agregarle la clase bola a nuestro código, hay que agregarla, para esto ponemos la siguiente linea antes del bucle while:
-------------------------------------------------------------------------------------
bola = Bola()

-------------------------------------------------------------------------------------

Al final el código nos quedaría así:
-------------------------------------------------------------------------------------
import sys, pygame
from pygame.locals import *
WIDTH = 640
HEIGHT = 480

class Bola(pygame.sprite.Sprite):
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.image = load_image("bola.png", True)
self.rect = self.image.get_rect()
self.rect.centerx = WIDTH / 2
self.rect.centery = HEIGHT / 2
self.speed = [0.5, -0.5]
def load_image(filename, transparent=False):
try: image = pygame.image.load(filename)
except pygame.error, message:
raise SystemExit, message
image = image.convert()
if transparent:
color = image.get_at((0,0))
image.set_colorkey(color, RLEACCEL)
return image
def main():
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("lab progra web")
background_image = load_image('pingpong.png')
bola = Bola()
while True:
for eventos in pygame.event.get():
if eventos.type == QUIT:
sys.exit(0)
screen.blit(background_image, (0, 0))
screen.blit(bola.image, bola.rect)
pygame.display.flip()
return 0
if __name__ == '__main__':
pygame.init()
main()
-------------------------------------------------------------------------------------
Nos quedaría así:

Ahora sigue lo bueno, le daremos movimiento a nuestra pelota.Para esto agregaremos las siguientes lineas después de haber declarado la clase bola:
-------------------------------------------------------------------------------------
def actualizar(self, time): -->aquí definimos el método para el tiempo transcurrido.
self.rect.centerx += self.speed[0] * time --->esta linea y la de abajo son complicadas, ya que aqui establecemos la velocidad en la que se mueve la pelota mediante ejes, que serian x, y
self.rect.centery += self.speed[1] * time
if self.rect.left <= 0 or self.rect.right >= WIDTH: ---> esta linea y las otras dos de abajo, indican que si la pelota llegue a cualquier extremo, derecho o izquierdo, rebote.
self.speed[0] = -self.speed[0]
self.rect.centerx += self.speed[0] * time
if self.rect.top <= 0 or self.rect.bottom >= HEIGHT: --->esto es lo mismo de arriba, hace que rebote la pelota al momento de llegar a cualquier extremo.
self.speed[1] = -self.speed[1]
self.rect.centery += self.speed[1] * time
----------------------------------------------------------------------------------------------------------
Después de esto vamos a agregarle un reloj, esto nos servirá para que controle el tiempo en que la pelota rebote en la ventana, para esto agregamos la siguiente linea antes del bucle while
--------------------------------------------------------
clock = pygame.time.Clock()
--------------------------------------------------------

Ahora dentro del bucle while agregamos la siguiente linea para saber cuanto tiempo pasa cada vez que se ejecuta una intersección del bucle
---------------------------------------------------------
time = clock.tick(60)
---------------------------------------------------------

Ahora solo ponemos esta linea para actualizar la posición de la pelota antes de actualizarla con la ventana.
--------------------------------------------------------
bola.actualizar(time)
--------------------------------------------------------

Al final nuestro código quedaría de esta forma:
--------------------------------------------------------------------------------
import sys, pygame
from pygame.locals import *
WIDTH = 640
HEIGHT = 480

class Bola(pygame.sprite.Sprite):
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.image = load_image("bola.png", True)
self.rect = self.image.get_rect()
self.rect.centerx = WIDTH / 2
self.rect.centery = HEIGHT / 2
self.speed = [0.5, -0.5]
def actualizar(self, time):
self.rect.centerx += self.speed[0] * time
self.rect.centery += self.speed[1] * time
if self.rect.left <= 0 or self.rect.right >= WIDTH:
self.speed[0] = -self.speed[0]
self.rect.centerx += self.speed[0] * time
if self.rect.top <= 0 or self.rect.bottom >= HEIGHT:
self.speed[1] = -self.speed[1]
self.rect.centery += self.speed[1] * time

def load_image(filename, transparent=False):
try: image = pygame.image.load(filename)
except pygame.error, message:
raise SystemExit, message
image = image.convert()
if transparent:
color = image.get_at((0,0))
image.set_colorkey(color, RLEACCEL)
return image
def main():
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("lab progra web")
background_image = load_image('pingpong.png')
bola = Bola()
clock = pygame.time.Clock()
while True:
time = clock.tick(60)
for eventos in pygame.event.get():
if eventos.type == QUIT:
sys.exit(0)
bola.actualizar(time)
screen.blit(background_image, (0, 0))
screen.blit(bola.image, bola.rect)
pygame.display.flip()
return 0
if __name__ == '__main__':
pygame.init()
main()
--------------------------------------------------------------------------------

Pondré imágenes .jpg ya que nose como capturar imágenes gif para mostrar la pelota en movimiento.

Eso es todo, mas adelante continuare de como agregar las barras en los costados.

Fuente: http://miprogramacionenjuegos.wordpress.com/2007/05/15/la-clase-sprite/
http://razonartificial.com/2010/02/pygame-5-moviendo-sprites/







¿Java o Pyhton?

En esta entrada les mostrare ventajas y desventajas de estos dos potentes lenguajes de programacion, ya que para hacer el proyecto final tenemos que tener en cuenta muchas cosas al momento de escoger el lenguaje usado para hacer la aplicación.

Pyhton

Pyhton es un lenguaje de alto nivel, puede soportar programacion orientada a objetos, programacion imperativa y programacion funcional, Pyhton es un lenguaje interpretado, esto quiere decir que sus instrucciones se ejecutan a partir de su codigo fuente. Varias empresas que usan este lenguaje son Google, NASA, ILM y Yahoo, viendolo como un lenguaje muy poderoso.

Ventajas de python:

• Python herencia soporte multiple, lo que java no lo puede hacer.
• Puede manejar por defecto listas, diccionarios, conjuntos, etc.
• Creacion de interfaz grafica de manera rapida.
• Contiene frameworks para trabajar con web como django
• Incluye documentacion detallada, aparte de tutoriales.
• Tiene una gran cantidad de librerias estandar
• Es portable a distintos sistemas operativos

Desventajas de Pyhton

• Puede ser un poco lento por ser un lenguaje interpretado

Ahora veamos en Java

Java

Java es un lenguaje de programacion orientada a objetos, que tambien permite la ejecucion de un mismo programa en multiples sistemas operativos. Java es usado en diversos sistemas inteligentes, como puede ser celulares, computadoras, estereos, ipod, etc. lo que lo hace ver un lenguaje mas usado por python.

Ventajas de Java:

• El jdk es una herramienta libre de licensias, lo que quiere decir que es gratuito.
• Tiene soporte dado por SUN.
• Tiene muchas librerias graficas como "awt" y "swing".
• Es muy usado en el mercado.
• Tiene facil acceso a bases de datos con JDBC.
• Es dinamico, por ejemplo que no requiere que compiles todas las clases de un programa para que este funcione.

Desventajas de Java:

• Para el manejo de bajo nivel, se deben de usar metodos nativos, lo que lo limita a la portabilidad.
• El diseño con las librerias ya mencionadas para interfaz grafica es un poco complicado.
• Algunas herramientas para Java no son gratuitas.

Eso es todo, mas adelante vere si puedo publicar una aplicacion de cada uno de estos lenguajes.

Fuente: http://www.monografias.com/trabajos/lengprog/lengprog.shtml
http://www.forosdelweb.com/f130/python-frente-otros-lenguajes-623669/