Curso Python. Volumen XXI: Pygame, videojuegos en python. Parte VIII

Escrito por Javier Ceballos Fernández

Bienvenidos un día más al curso de Python. En el capítulo anterior mejoramos la experiencia de usuario mejorando los controles de nuestro videojuego. En este capítulo, vamos crear un jugador ficticio de manera que podamos tener a un oponente en el videojuego que estamos realizando con la popular librería Pygame. Así que pongámonos manos a la obra.

Jugador Ficticio

Para crear a este jugador ficticio, que será el ordenador, vamos a modificar la clase Paleta añadiéndole un método que llamaremos “cpu”. A continuación os mostramos el código:

def cpu(self, objetivo):
    self.rect.centery = objetivo.rect.centery
    if self.rect.bottom >= SCREEN_HEIGHT:
        self.rect.bottom = SCREEN_HEIGHT
    elif self.rect.top <= 0:
        self.rect.top = 0

Lo que hemos  definido dentro de la clase Paleta es una función, que hemos llamado “def cpu(self, objetivo)”, dentro de esta función indicamos a la paleta que siga la posición de la pelota, es decir, que se mueva junto con ella. Para ello hemos añadido la siguiente instrucción “self.rect.centery = objetivo.rect.centery”, esta instrucción lo que viene a decir es que la posición vertical de la paleta es igual a la posición vertical de la pelota, y también comprobamos que la paleta no se salga de la pantalla.

Para finalizar lo único que tendremos que hacer es crear y mostrar la paleta del jugador 2, que será controlada por el ordenador. Esto se realiza del mismo modo que hicimos anteriormente, el código quedaría del siguiente modo:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# ---------------------------
# Importacion de los módulos
# ---------------------------

import pygame
from pygame.locals import *
import os
import sys

# -----------
# Constantes
# -----------

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
IMG_DIR = "imagenes"

# ------------------------------
# Clases y Funciones utilizadas
# ------------------------------


def load_image(nombre, dir_imagen, alpha=False):
    # Encontramos la ruta completa de la imagen
    ruta = os.path.join(dir_imagen, nombre)
    try:
        image = pygame.image.load(ruta)
    except:
        print("Error, no se puede cargar la imagen: " + ruta)
        sys.exit(1)
    # Comprobar si la imagen tiene "canal alpha" (como los png)
    if alpha is True:
        image = image.convert_alpha()
    else:
        image = image.convert()
    return image


# -----------------------------------------------
# Creamos los sprites (clases) de los objetos del juego:


class Pelota(pygame.sprite.Sprite):
    "La bola y su comportamiento en la pantalla"

    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("bola.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = SCREEN_WIDTH / 2
        self.rect.centery = SCREEN_HEIGHT / 2
        self.speed = [3, 3]

    def update(self):
        if self.rect.left < 0 or self.rect.right > SCREEN_WIDTH:
            self.speed[0] = -self.speed[0]
        if self.rect.top < 0 or self.rect.bottom > SCREEN_HEIGHT:
            self.speed[1] = -self.speed[1]
        self.rect.move_ip((self.speed[0], self.speed[1]))

    def colision(self, objetivo):
        if self.rect.colliderect(objetivo.rect):
            self.speed[0] = -self.speed[0]


class Paleta(pygame.sprite.Sprite):
    "Define el comportamiento de las paletas de ambos jugadores"

    def __init__(self, x):
        pygame.sprite.Sprite.__init__(self)
        self.image = load_image("paleta.png", IMG_DIR, alpha=True)
        self.rect = self.image.get_rect()
        self.rect.centerx = x
        self.rect.centery = SCREEN_HEIGHT / 2

    def humano(self):
        # Controlar que la paleta no salga de la pantalla
        if self.rect.bottom >= SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT
        elif self.rect.top <= 0: self.rect.top = 0 def cpu(self, objetivo): self.rect.centery = objetivo.rect.centery if self.rect.bottom >= SCREEN_HEIGHT:
            self.rect.bottom = SCREEN_HEIGHT
        elif self.rect.top <= 0:
            self.rect.top = 0

# ------------------------------
# Funcion principal del juego
# ------------------------------


def main():
    pygame.init()
    # creamos la ventana y le indicamos un titulo:
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption("Pong")

    # cargamos los objetos
    fondo = load_image("fondo.jpg", IMG_DIR, alpha=False)
    bola = Pelota()
    jugador1 = Paleta(40)
    jugador2 = Paleta(SCREEN_WIDTH - 40)

    clock = pygame.time.Clock()
    pygame.key.set_repeat(1, 25)  # Activa repeticion de teclas
    pygame.mouse.set_visible(False)

    # el bucle principal del juego
    while True:
        clock.tick(60)
        # Obtenemos la posicion del raton
        pos_mouse = pygame.mouse.get_pos()
        mov_mouse = pygame.mouse.get_rel()

        # Actualizamos los objetos en pantalla
        jugador1.humano()
        jugador2.cpu(bola)
        bola.update()

        # Comprobamos si colisionan los objetos
        bola.colision(jugador1)
        bola.colision(jugador2)

        # Posibles entradas del teclado y raton
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)
            elif event.type == pygame.KEYDOWN:
                if event.key == K_UP:
                    jugador1.rect.centery -= 5
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 5
                elif event.key == K_ESCAPE:
                    sys.exit(0)
            elif event.type == pygame.KEYUP:
                if event.key == K_UP:
                    jugador1.rect.centery += 0
                elif event.key == K_DOWN:
                    jugador1.rect.centery += 0
            # Si el raton no esta quieto mover la paleta a su posicion
            elif mov_mouse[1] != 0:
                jugador1.rect.centery = pos_mouse[1]

        # actualizamos la pantalla
        screen.blit(fondo, (0, 0))
        screen.blit(bola.image, bola.rect)
        screen.blit(jugador1.image, jugador1.rect)
        screen.blit(jugador2.image, jugador2.rect)
        pygame.display.flip()


if __name__ == "__main__":
    main()

Ahora ya tendréis un contrincante, pero os habréis dado cuenta que éste es invencible ya que su paleta sigue siempre a la pelota por lo que como mucho podréis jugar a ver cuántas veces sois capaces de devolver la pelota.

Aquí lo dejamos por hoy, os recomendamos que hagáis un repaso de lo aprendido por el momento y que experimentéis. En el próximo capítulo haremos que nuestro videojuego tenga efectos de sonido para hacerlo algo más atractivo al usuario.

Comentaros como siempre, que todos los que se acaban de incorporar al curso tienen un índice con todos los capítulos del curso, ya que nunca es tarde para empezar.

Fuente > GitHub dbfuentes

Últimos análisis

Valoración RZ
10
Valoración RZ
8
Valoración RZ
9
Valoración RZ
9
Valoración RZ
10
Valoración RZ
9
Valoración RZ
10
Valoración RZ
7