예제 #1
0
 def load_game(self):
     pygame.init()
     self.screen = pygame.display.set_mode(self.size_window)
     pygame.display.set_caption("breakout")
     self.escenario = Escenario(self.screen)
     self.collision = Collision(5)
     self.pelota = Pelota(self.screen, 16, 16, "sprites/pelota_white.png")
     self.pelota.set_velocity(2, 5)
     self.raquet = Raqueta(self.screen, 74, 12, "sprites/raquet_white.png")
     self.raquet.set_position(300, 550)
     self.bricks = self.load_bricks(12, self.nivel)
     self.tam_list = len(self.bricks)
     self.loop()
예제 #2
0
def game():
      pygame.init()
      pygame.mixer.init()
      screen = pygame.display.set_mode( (SCREEN_WIDTH,SCREEN_HEIGHT) )
      jugando = True
      pygame.display.set_caption( "Pelota" )
      background_image = util.cargar_imagen('imagenes/fondo.jpg');
      fuente = pygame.font.Font(None, 30)
      pygame.mouse.set_visible( False )
      temporizador = pygame.time.Clock()
      pelota = Pelota()      
      while jugando:
          pelota.update()
          for event in pygame.event.get():
              if event.type == pygame.QUIT:
                  sys.exit()
          screen.blit(background_image, (0,0))
          screen.blit(pelota.imagen, pelota.rect)

          pygame.display.update()
          pygame.time.delay(20)
예제 #3
0
def main():
    # Crea la ventana:
    fuente = pygame.font.Font(None, 300)
    fuente2 = pygame.font.Font(None, 70)
    cont1 = 0
    cont2 = 0
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("Cabezones 1.0")
    arcoIzq = Arco.Arco(38, HEIGHT / 2)
    arcoDer = Arco.Arco(WIDTH - 38, HEIGHT / 2)
    arcoDer.imagen = pygame.transform.flip(arcoDer.imagen, True, False)
    personaje1 = Personaje.Cabeza(900, 210, 0.5, 0.5, personajes[0], K_DOWN,
                                  K_UP, K_RIGHT, K_LEFT, K_RCTRL)
    personaje2 = Personaje.Cabeza(100, 210, 0.5, 0.5, personajes[1], K_s, K_w,
                                  K_d, K_a, K_c)
    personaje2.imagen = pygame.transform.flip(personaje2.imagen, True, False)

    pelota1 = Pelota.Pelota(WIDTH / 2, HEIGHT / 2, 0.5)
    clock = pygame.time.Clock()
    a = True

    while a == True:
        time = clock.tick(60)
        keys = pygame.key.get_pressed()

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit(0)

        personaje1.mover(keys, time, HEIGHT, WIDTH, pelota1.rectangulo)
        personaje2.mover(keys, time, HEIGHT, WIDTH, pelota1.rectangulo)

        #validar Gol--------------------------------------------------------
        if pelota1.rectangulo.centerx < 30:
            if pelota1.rectangulo.top > arcoDer.rectangulo.top:
                if pelota1.rectangulo.bottom < arcoDer.rectangulo.bottom:
                    cont1 = cont1 + 1

                    pelota1.rectangulo.centerx = WIDTH / 2
                    pelota1.rectangulo.centery = HEIGHT / 2
        if pelota1.rectangulo.centerx > WIDTH - 30:
            if pelota1.rectangulo.top > arcoDer.rectangulo.top:
                if pelota1.rectangulo.bottom < arcoDer.rectangulo.bottom:
                    cont2 = cont2 + 1

                    pelota1.rectangulo.centerx = WIDTH / 2
                    pelota1.rectangulo.centery = HEIGHT / 2
#Validar Afuera.------------------------------------------------------
        if pelota1.rectangulo.left < 7:
            pelota1.rectangulo.centerx = WIDTH / 2
            pelota1.rectangulo.centery = HEIGHT / 2
        if pelota1.rectangulo.right > WIDTH - 7:
            pelota1.rectangulo.centerx = WIDTH / 2
            pelota1.rectangulo.centery = HEIGHT / 2

        gol1 = fuente.render(str(cont1), 0, (255, 255, 255))
        gol2 = fuente.render(str(cont2), 0, (255, 255, 255))
        ganador1 = fuente2.render("EL Jugador 1 es el Ganador", 0,
                                  (255, 255, 255))
        ganador2 = fuente2.render("EL Jugador 2 es el Ganador", 0,
                                  (255, 255, 255))

        if cont1 == 10:
            screen.blit(ganador1, (200, 180))
            screen.blit(gol1, (WIDTH - 400, HEIGHT / 2))
            screen.blit(gol2, (280, HEIGHT / 2))
        elif cont2 == 10:
            screen.blit(ganador2, (200, 180))
            screen.blit(gol1, (WIDTH - 400, HEIGHT / 2))
            screen.blit(gol2, (280, HEIGHT / 2))
        else:
            #actualiza objeto screen

            screen.blit(fondo1, (0, 0))
            screen.blit(gol1, (WIDTH - 400, HEIGHT / 2))
            screen.blit(gol2, (280, HEIGHT / 2))
            screen.blit(pelota1.imagen, pelota1.rectangulo)
            screen.blit(personaje1.imagen, personaje1.rectangulo)
            screen.blit(personaje2.imagen, personaje2.rectangulo)
            screen.blit(arcoIzq.imagen, arcoIzq.rectangulo)
            screen.blit(arcoDer.imagen, arcoDer.rectangulo)

    # Imprimimos los cambios en la pantalla:
        pygame.display.flip()
        pygame.display.update()
        screen.blit(fondo1, (0, 0))
예제 #4
0
def main():
    pygame.init()
    pygame.mixer.init()
    pygame.mixer.music.load(soundDir + "/musica.ogg")
    pygame.mixer.music.play(loops=0)

    screen = pygame.display.set_mode((width, height))
    pygame.display.set_caption("Pong para 2 jugadores")

    fondo = load_image("fondo.jpg", imgDir, alpha=False).convert()
    sonidoGolpe = loadSound("pelota.ogg", soundDir)
    sonidoPunto = loadSound("punto.ogg", soundDir)

    bola = Pelota(sonidoGolpe, sonidoPunto)
    jugador1 = Palas(15)
    jugador2 = Palas(625)

    reloj = pygame.time.Clock(
    )  #Creamos un reloj que controla el tiempo de juego
    pygame.key.set_repeat(
        1, 12
    )  # Activa repeticion de teclas, primer argumento tiempo de retraso segundo argumento, seungo argumento tiempo entre cada envio en milisegundos
    pygame.mouse.set_visible(
        False)  #Desactiva el cursor dentro de la ventana del juego

    puntos = [0, 0]
    while True:
        #Condicion de victoria
        if (puntos[0] == 5):
            messagebox.showinfo("Victoria", "Ganador el jugador 1")
            sys.exit()
        elif (puntos[1] == 5):
            messagebox.showinfo("Victoria", "Ganador el jugador 2")
            sys.exit()

        reloj.tick(60)  #Seleccionamos los fps en este caso 60

        jugador1.humano(
        )  #Actualizamos la posicion de la paleta del jugador 1 y 2
        jugador2.humano()
        puntos = bola.actualizar(
        )  #Al inicio del bucle actualizamos la posicion de la bola

        bola.colision(jugador1)  #Control de colisiones de la bola
        bola.colision(jugador2)

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:  #Cuando se pulsa una tecla
                if event.key == K_UP:  #Si se pulsa la tecla arriba
                    jugador2.rect.centery -= 5
                elif event.key == K_DOWN:  #Si se pula la tecla abajo
                    jugador2.rect.centery += 5
                elif event.key == K_w:
                    jugador1.rect.centery -= 5
                elif event.key == K_s:
                    jugador1.rect.centery += 5
            elif event.type == pygame.KEYUP:  #Cuando se suelta una tecla
                if event.key == K_UP:  #Si se suelta la tecla arriba
                    jugador2.rect.centery += 0
                elif event.key == K_DOWN:  #Si se suelta la tecla abajo
                    jugador2.rect.centery += 0
                elif event.key == K_w:
                    jugador1.rect.centery += 0
                elif event.key == K_s:
                    jugador1.rect.centery += 0
        #Nombre de jugadores
        n_jug1, n_jug1_rect = texto("Jugador 1", width / 4, height / 2,
                                    60)  #Texto, posicionx, posiciony, tamaño
        n_jug2, n_jug2_rect = texto("Jugador 2", width - width / 4, height / 2,
                                    60)

        #Sistema de puntuacion
        p_jug1, p_jug1_rect = texto(str(puntos[0]), width / 4, 40, 60)
        p_jug2, p_jug2_rect = texto(str(puntos[1]), width - width / 4, 40, 60)

        #Actualiza la pantalla por cada iteracion del bucle
        screen.blit(fondo, (0, 0))
        screen.blit(p_jug1, p_jug1_rect)
        screen.blit(p_jug2, p_jug2_rect)
        screen.blit(n_jug1, n_jug1_rect)
        screen.blit(n_jug2, n_jug2_rect)
        screen.blit(bola.image, bola.rect)
        screen.blit(jugador1.image, jugador1.rect)
        screen.blit(jugador2.image, jugador2.rect)
        #Guarda los cambios
        pygame.display.flip()
예제 #5
0
tablero = pygame.display.set_mode([600, 600])
# Recuperamos el tablero de juego para poder operar con él
tableroJuego = pygame.Surface(tablero.get_size())

# Creamos las variables responsable de controlar la salida y fin del juego
gameOver = False
exitJuego = False

# Creamos el reloj que controlará el tiempo de juego
reloj = pygame.time.Clock()

# Cargamos los componentes visuales del juego
spTotal = pygame.sprite.Group()

spPelota = pygame.sprite.Group()
valorPelota = Pelota()
spPelota.add(valorPelota)
spTotal.add(valorPelota)

spPortero = pygame.sprite.Group()
valorPortero = Portero()
spPortero.add(valorPortero)
spTotal.add(valorPortero)

spLadrillo = pygame.sprite.Group()

# Definimos la altura inicial de los bloques
topLadrillo = 80
# Generamos todos los cuadros del panel superior
# 5 filas con 25 ladrillos cada una [600 / 24 = 25] siendo 24 = 23 del ancho del ladrillo + 1 de separación
for fila in range(5):
from glew_wish import *
import glfw
from math import *
import random
from enum import Enum
from Marco import *
from Pelota import *
from Jugador1 import *
from Jugador2 import *

# El desfase es debido a que en 0 grados se voltea hacia arriba y no hacia la derecha

tiempo_anterior = 0

marco = Marco()
pelota = Pelota()
jugador1 = Jugador1()
jugador2 = Jugador2()


def actualizar(window):
    global tiempo_anterior

    tiempo_actual = glfw.get_time()
    tiempo_delta = tiempo_actual - tiempo_anterior

    pelota.checar_colisiones(jugador1, jugador2)
    pelota.actualizar(tiempo_delta)
    jugador1.actualizar(window, tiempo_delta, pelota)
    jugador2.actualizar(window, tiempo_delta, pelota)
    tiempo_anterior = tiempo_actual
예제 #7
0
from Pelota import *
from Jugador import *
import random

pelota = Pelota(random.random(), random.random(), random.randint(
    0,
    8,
), random.randint(0, 4), 1, random.uniform(0.9, 0.1), random.uniform(0.9, 0.1),
                random.uniform(0.9, 0.1), random.uniform(0.9, 0.1))

vector_x = pelota.estado_get()
print(vector_x)
print("-----")
prediccion = Jugador(pelota.Xt, pelota.O, pelota.G)