Comportamiento de IA y Sistema de Puntuación - Pygame

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

Crear una pala para la PC

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

 raq_pc = Raqueta(640 - 30)

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

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

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

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

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

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

pelota.actualizar(time, raq_jug, raq_pc)

Dandole "inteligencia" a la raqueta de la PC

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

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

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

En la línea 2 comprobamos que pelota.speed[0] >= 0, es decir, que la velocidad en el eje x de la pelota sea positiva, es decir, que la pelota se este moviendo hacia la derecha (hacia la rqueta de la pc) y tambien comprueba que pelota.rect.centerx >= 640/2 es decir que el centro x de la pelota sea mayor o igual que el centro del tablero, es decir, que la pelota este en el campo de la cpu.
Por tanto la línea 2 es un condicional que comprueba que la pelota vaya hacia donde está la raqueta de la cpu y que este en su campo, sino, que no se mueva. Esto se hace para que la PC no sea invencible y no llegue a todas las pelotas.

La línea 3 comprueba si el centery de la pelota es menor que el centery de la raqueta, es decir si la raqueta está más arriba que que la pelota en cullo caso, ejecuta la línea 4 que mueve la pala de la cpu hacia abajo.

Las líneas 5 y 6 hacen lo mismo, pero a la inversa como se ve a simple vista.

Ahora solo hay que llamar a la ia junto con las llamadas actualizar de la pelota y mover de la raqueta de la cpu.

raq_pc.ia(time, pelota)

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

Sistema de Puntuacion

en la proxima entrada ;D