sábado, 14 de noviembre de 2020

cubo vs cubo

 import pygame

import sys

import random


#Constantes

ANCHO = 800

ALTO = 600

color_rojo = (255,0,0)

color_negro = (0,0,0)

color_azul = (0,0,255)


#jugador

jugador_size = 50

jugador_pos = [ANCHO / 2, ALTO - jugador_size * 2]


#Enemigo(s)

enemigo_size = 50

enemigo_pos = [random.randint(0,ANCHO - enemigo_size),0]

#ventana

ventana = pygame.display.set_mode((ANCHO,ALTO))


game_over = False

clock = pygame.time.Clock()

#Funciones

def detectar_colision(jugador_pos,enemigo_pos):

jx = jugador_pos[0]

jy = jugador_pos[1]

ex = enemigo_pos[0]

ey = enemigo_pos[1]


if (ex >= jx and ex <(jx + jugador_size)) or (jx >= ex and jx < (ex + enemigo_size)):

if (ey >= jy and ey <(jy + jugador_size)) or (jy >= ey and jy < (ey + enemigo_size)):

return True

return False



while not game_over:

for event in pygame.event.get():

if event.type == pygame.QUIT:

sys.exit()


if event.type == pygame.KEYDOWN:

x = jugador_pos[0]

if event.key == pygame.K_LEFT:

x -= jugador_size

if event.key == pygame.K_RIGHT:

x += jugador_size


jugador_pos[0] = x

ventana.fill(color_negro)


if enemigo_pos[1] >= 0 and enemigo_pos[1] < ALTO:

enemigo_pos[1] += 20

else:

enemigo_pos[0] = random.randint(0,ANCHO - enemigo_size)

enemigo_pos[1] = 0

#Colisiones

if detectar_colision(jugador_pos,enemigo_pos):

game_over = True


#Dibujar enemigo

pygame.draw.rect(ventana, color_azul,

(enemigo_pos[0],enemigo_pos[1],

enemigo_size, enemigo_size))

#Dibujar jugador

pygame.draw.rect(ventana, color_rojo,

(jugador_pos[0],jugador_pos[1],

jugador_size,jugador_size))

clock.tick(30)

pygame.display.update()







marcianitos vs naves

 import pygame

import random

WIDTH=800

HEIGHT=600

BLACK=(0,0,0)

WHITE=(255,255,255)

#INICIALIZAR

pygame.init()

screen = pygame.display.set_mode((WIDTH, HEIGHT))

#nombre de ventana

pygame.display.set_caption("aliens vs  aviones")

#reloj para controlar

Clock= pygame.time.Clock()

#funcion que permite dibujar texto en la ventana

def draw_text(surface, text, size, x, y):#surface=donde  se dibujara el texto

font = pygame.font.SysFont("serif", size)#fuente

text_surface = font.render(text, True, (WHITE))#el lugar donde se pondra el texto

text_rect = text_surface.get_rect()

text_rect.midtop = (x, y)#posicionarlo (x,y)

surface.blit(text_surface, text_rect)#ver pantalla



#clase jugador


class Player(pygame.sprite.Sprite):

    #inicializar clase

    def __init__(self):

        #definimos  con super clase (sprite)

        super().__init__()

        #imagen jugador nave

        self.image=pygame.image.load('player.png').convert()

        #remover la parte negra de la nave

        self.image.set_colorkey(BLACK)

        #definimos  recta

        self.rect= self.image.get_rect()

        #pantalla de ancho ala mitad

        self.rect.centerx= WIDTH//2

        self.rect.bottom=HEIGHT-10

        #velocidad con la cual se movera inicializa a cero

        self.speed_x=0


        #funcion

    def update(self):

        # velocidad sera igual a cero

        self.speed_x=0

        #si se presiona alguna tecla keystate

        keystate=pygame.key.get_pressed()

        #si la tecla presionada  es  izquierda

        if keystate[pygame.K_LEFT]:

            #la velocidad se disminuira a 5

            self.speed_x=-5

        # si la tecla presionada es  derecha

        if keystate[pygame.K_RIGHT]:

             self.speed_x=5

            #suma la velocidad

        self.rect.x += self.speed_x

        #colisiones  right es mas ancho que la ventana no permite salir la nave de las orillas

        if self.rect.right > WIDTH:

            self.rect.right = WIDTH

        if self.rect.left < 0:

            self.rect.left = 0


    def shoot(self):

        #creacion de bala y le damos una posicion desde el centro

        bullet = Bullet(self.rect.centerx, self.rect.top)

        #agregado alos sprits

        all_sprites.add(bullet)

        #se agrega ala lista

        bullets.add(bullet)




#clase  alien (invasores)

class Alien(pygame.sprite.Sprite):

    #inicializamos la clase

    def __init__(self):

        #inicializamos la super clase

        super().__init__()

        #imagen invasores

        self.image=pygame.image.load('alienrosa.ico').convert()

        #quitamos el fondo de la imagen

        self.image.set_colorkey(BLACK)

        #creamos la recta de la imagen

        self.rect=self.image.get_rect()

        #valor de inicio y random que aparezca en cualquier lugar

        self.rect.x=random.randrange(WIDTH - self.rect.width)

        self.rect.y=random.randrange(-100, -40)

        #definimos velocidad(para que cada alien se muestre en  velocidad diferente)

        self.speedy=random.randrange(1,10)

        self.speedx = random.randrange(-5, 5)



    #creamos nueva clase update

    def update(self):

        #velocidad

        self.rect.x +=self.speedx

        self.rect.y += self.speedy

        #si el tope del alien  ya revaso el borde de la ventana, se aumenta y si salio por la Der

        if self.rect.top > HEIGHT + 10 or self.rect.left < -25 or self.rect.right > WIDTH + 22:

            #regresa el alien aleatorio con la velocidad en x y y

            self.rect.x = random.randrange(WIDTH - self.rect.width)

            self.rect.y = random.randrange(-100, -40)

            self.speedy= random.randrange(1, 10)

#laser

class Bullet(pygame.sprite.Sprite):

    # inicio  y parametros de colicion

def __init__(self, x, y):

        # inicializamos super clase

super().__init__()

        # imagen de balas o lacer

self.image = pygame.image.load('laser1.png')

        # remover le fondo de las bala

self.image.set_colorkey(BLACK)

self.rect = self.image.get_rect()

self.rect.y = y

        # centro del objecto

self.rect.centerx = x

        # velocidad y negativo porque va para abajo

self.speedy = -10


def update(self):

        #hacer que suba en automatico la bala

self.rect.y += self.speedy

        #elimanos las balas para que no ocupe mucho espacio

if self.rect.bottom < 0:

            #metodo se elimina la instacias de la lista en este caso las balas

self.kill()



#fondo de pantalla

fondo=pygame.image.load('background.png').convert()


  #crear un grupo

all_sprites=pygame.sprite.Group()

alien_lista=pygame.sprite.Group()

bullets=pygame.sprite.Group()


#estancia jugador/agragado ala lista

player = Player()

all_sprites.add(player)


#creamos 10 aliens

for i in range(8):

alien= Alien()

all_sprites.add(alien)

alien_lista.add(alien)

#Marcador del juego

score = 0



#bucle principal

running=True

while running:

    #velocidad del bucle

    Clock.tick(30)

    #procesos (eventos)

    for event in  pygame.event.get():

        if event.type == pygame.QUIT:

            running=False

            #cuando presione la barra espaciadora pueda tirar

        elif event.type == pygame.KEYDOWN:

            #barra espaciadora

            if event.key == pygame.K_SPACE:

                #jugador dispare

                player.shoot()


    # actualiza la pantalla

    all_sprites.update()

    # Colisiones ALIEN- laser

    #variable hits,metodo groupcpllide =checa las coliciones de un grupo y otro

    hits = pygame.sprite.groupcollide(alien_lista, bullets, True, True)

    #True =desaparesca las balas

    for hit in hits:

        #aumentara el marcador cada vez que  el aliens le toque una bala

        score +=10


        #creamos obj

        alien = Alien()

        #sprites

        all_sprites.add(alien)

        #añade ala lista de aliens

        alien_lista.add(alien)




    # Colisiones jugador - ALIEN

    #variable hits

    #comparamos el jugador con el alien y si un alien pega con  la nave=verdadero

    hits = pygame.sprite.spritecollide(player, alien_lista,True)

    if hits:

        #si ya pego el metorio se sale del juego

        running = False


    #vista de fondo con cordenada inical

    screen.blit(fondo,[0,0])

    #marcador dibujado ,color del marcador,posicion (x,y)

    draw_text( screen, str(score), 25, WIDTH // 2, 10)

    #dibujar para que aparezca en  la pantalla

    all_sprites.draw(screen)

    # voltea la pantalla, despues de dibujar

    pygame.display.flip()


pygame.quit()










marcianito que movemos con el con el control de mouse

 import pygame,sys


# Iniciación de Pygame

pygame.init()

#Fondo del juego

size=(800,500)

screen=pygame.display.set_mode([800,600])

clock=pygame.time.Clock()

done=False

#Fondo del juego

fondo=pygame.image.load('marcifondo.jpg').convert()

#alien imagen

alien=pygame.image.load('alien2_96114.ico').convert()

#quitar fondo negro de imagen alien color(formato RGB)

alien.set_colorkey([0,0,0])



while not  done:

    for  event in pygame.event.get():

        if event.type==pygame.QUIT:

            done=True

    mouse_pos=pygame.mouse.get_pos()

    x=mouse_pos[0]

    y=mouse_pos[1]

    #imagen

    screen.blit(fondo,[0,0])

    screen.blit(alien,[x,y])



    pygame.display.flip()

    clock.tick(60)


pygame.quit()





JUEGO PING-PONG.PY

 import pygame

pygame.init()


#Colores


Azul=(0,0,240)

white = (255, 255, 255)

screen_size = (800, 600)

player_width = 15

player_height = 90


screen = pygame.display.set_mode(screen_size)

clock = pygame.time.Clock()


#Coordenadas y velocidad del jugador 1

player1_x_coor = 50

player1_y_coor = 300 - 45

player1_y_speed = 0


#Coordenadas y velocidad del jugador 2

player2_x_coor = 750 - player_width

player2_y_coor = 300 - 45

player2_y_speed = 0


# Coordenadas de la pelota

pelota_x = 400

pelota_y = 300

pelota_speed_x = 3

pelota_speed_y = 3


game_over = False


while not game_over:

for event in pygame.event.get():

if event.type == pygame.QUIT:

game_over = True

if event.type == pygame.KEYDOWN:

# Jugador 1

if event.key == pygame.K_w:

player1_y_speed = -3

if event.key == pygame.K_s:

player1_y_speed = 3

# Jugador 2

if event.key == pygame.K_UP:

player2_y_speed = -3

if event.key == pygame.K_DOWN:

player2_y_speed = 3


if event.type == pygame.KEYUP:

# Jugador 1

if event.key == pygame.K_w:

player1_y_speed = 0

if event.key == pygame.K_s:

player1_y_speed = 0

# Jugador 2

if event.key == pygame.K_UP:

player2_y_speed = 0

if event.key == pygame.K_DOWN:

player2_y_speed = 0


if pelota_y > 590 or pelota_y < 10:

pelota_speed_y *= -1


# Revisa si la pelota sale del lado derecho

if pelota_x > 800:

pelota_x = 400

pelota_y = 300

# Si sale de la pantalla, invierte direccion

pelota_speed_x *= -1

pelota_speed_y *= -1


# Revisa si la pelota sale del lado izquierdo

if pelota_x < 0:

pelota_x = 400

pelota_y = 300

# Si sale de la pantalla, invierte direccion

pelota_speed_x *= -1

pelota_speed_y *= -1



# Modifica las coordenadas para dar mov. a los jugadores/ pelota

player1_y_coor += player1_y_speed

player2_y_coor += player2_y_speed

# Movimiento pelota

pelota_x += pelota_speed_x

pelota_y += pelota_speed_y


screen.fill(Azul)

#Zona de dibujo

jugador1 = pygame.draw.rect(screen, white, (player1_x_coor, player1_y_coor, player_width, player_height))

jugador2 = pygame.draw.rect(screen, white, (player2_x_coor, player2_y_coor, player_width, player_height))

pelota = pygame.draw.circle(screen, white, (pelota_x, pelota_y), 10)


# Colisiones

if pelota.colliderect(jugador1) or pelota.colliderect(jugador2):

pelota_speed_x *= -1


pygame.display.flip()

clock.tick(60)

pygame.quit()






CUBOS.PY

 ALTO=600

color_rojo = (255,0,0)

color_negro = (0,0,0)

color_azul = (0,0,255)


#jugador

jugador_size = 50

jugador_pos=[ANCHO/2,ALTO - jugador_size * 2 ] #cordenadas en x y y del jugador


#Enemigo(s)

enemigo_size=50

enemigo_pos = [random.randint(0,ANCHO - enemigo_size

                              ),0]


ventana = pygame.display.set_mode((ANCHO,ALTO))


game_over = False


while not game_over:

    for event in pygame.event.get():

        #print(event) se pueden ver todos los eventos

        if event.type == pygame.QUIT:

            sys.exit()

        #TECLA ABAJO PRESIONADA

        if event.type == pygame.KEYDOWN:

            x= jugador_pos[0] #posicion en la que este el jugador

            if event.key == pygame.K_LEFT:

                x -= jugador_size

            if event.key == pygame.K_RIGHT:

                x += jugador_size

            jugador_pos[0] = x

    ventana.fill(color_negro)

    #dibujar enemigo

    pygame.draw.rect(ventana, color_azul,

                     (enemigo_pos[0], enemigo_pos[1],

                      enemigo_size, enemigo_size))

    #dibujar jugador

    pygame.draw.rect(ventana,color_rojo,

                    (jugador_pos[0],jugador_pos[1],

                    jugador_size,jugador_size))

    pygame.display.update()





CUBOS Y MARCIANITO.PY

 ANCHO=800

ALTO=600

color_rojo = (255,0,0)

color_negro = (0,0,0)

color_azul = (0,0,255)


#jugador

jugador_size = 50

jugador_pos=[ANCHO/2,ALTO - jugador_size * 2 ] #cordenadas en x y y del jugador


#Enemigo(s)

enemigo_size=50

enemigo_pos = [random.randint(0,ANCHO - enemigo_size

                              ),0]


ventana = pygame.display.set_mode((ANCHO,ALTO))


xAlien=20

yAlien=500

game_over = False


def Alien(xAlien,yAlien):

    y=yAlien

    x=xAlien


    pygame.draw.polygon(ventana, '#58F106', [[x, y], [x + 10, y],

                                              [x + 10, y + 10], [x + 20, y + 10], [x + 20, y + 20],

                                              [x + 30, y + 20], [x + 30, y + 10], [x + 40, y + 10],

                                              [x + 40, y], [x + 50, y], [x + 50, y + 10], [x + 40, y + 10],

                                              [x + 40, y + 20], [x + 50, y + 20], [x + 50, y + 30], [x + 60, y + 30],

                                              [x + 60, y + 40], [x + 70, y + 40], [x + 70, y + 80],

                                              [x + 60, y + 80], [x + 60, y + 50], [x + 50, y + 50], [x + 50, y + 80],

                                              [x + 30, y + 80], [x + 30, y + 70], [x + 40, y + 70], [x + 40, y + 60],

                                              [x + 10, y + 60], [x + 10, y + 70], [x + 20, y + 70], [x + 20, y + 80],

                                              [x, y + 80], [x, y + 50], [x - 10, y + 50], [x - 10, y + 80],

                                              [x - 20, y + 80], [x - 20, y + 40], [x - 10, y + 40], [x - 10, y + 30],

                                              [x, y + 30], [x, y + 20], [x + 10, y + 20], [x + 10, y + 10],

                                              [x, y + 10]])


while not game_over:

    for event in pygame.event.get():

        #print(event) se pueden ver todos los eventos

        if event.type == pygame.QUIT:

            sys.exit()

        #TECLA ABAJO PRESIONADA

        if event.type == pygame.KEYDOWN:

            x= jugador_pos[0] #posicion en la que este el jugador

            if event.key == pygame.K_LEFT:

                x -= jugador_size

            if event.key == pygame.K_RIGHT:

                x += jugador_size

            jugador_pos[0] = x

        if event.type == pygame.KEYDOWN:

            x= jugador_pos[0] #posicion en la que este el jugador

            if event.key == pygame.K_a:

                xAlien -= jugador_size

            if event.key == pygame.K_d:

                xAlien += jugador_size


    ventana.fill(color_negro)

    #dibujar enemigo

    pygame.draw.rect(ventana, color_azul,

                     (enemigo_pos[0], enemigo_pos[1],

                      enemigo_size, enemigo_size))

    #dibujar jugador cuadro rojo

    pygame.draw.rect(ventana,color_rojo,

                    (jugador_pos[0],jugador_pos[1],

                    jugador_size,jugador_size))

    #dibujar alien

    Alien(xAlien,yAlien)

    pygame.display.update()



TUTORIALDEACEROCAPITULO5.PY

 import  pygame

from pygame.locals import *

import  sys




# Iniciación de Pygame

pygame.init ()


#Pantalla - ventana

W , H  =  1000,600

PANTALLA=  pygame.display.set_mode((W,H))

pygame.display.set_caption ( 'Exterminador')

icono = pygame.image.load("icon.png")

pygame.display.set_icon (icono)



#Fondo del juego

fondo=pygame.image.load('ciudad.png')


# Música de fondo

#pygame.mezclador. la música . load ( 'intergalactic_odyssey.ogg' )

#pygame.mezclador. la música . jugar ( - 1 )



#Personaje

quieto =pygame.image.load('idle1.png' )


#si el personaje camina a la derecha se cargaran todas estas imagenes

caminaDerecha  = [pygame.image.load('run1.png'),

                  pygame.image.load('run2.png'),

                  pygame.image.load('run3.png'),

                  pygame.image.load('run4.png'),

                  pygame.image.load('run5.png'),

                  pygame.image.load('run6.png' )]

#si camina a la izquierda se cargaran todas estas imagenes

caminaIzquierda  = [pygame.image.load ('run1-izq.png'),

                    pygame.image.load ('run2-izq.png'),

                    pygame.image.load ('run3-izq.png'),

                    pygame.image.load ('run4-izq.png'),

                    pygame.image.load ('run5-izq.png'),

                    pygame.image.load ('run6-izq.png')]


salta  = [pygame.image.load ('jump1.png' ),

          pygame.image.load ('jump2.png' )]


#Sonido

#sonido_arriba = pygame.image.load ( 'sonido / volume_up.png' )

#sonido_abajo = pygame . imagen . load ( 'sonido / volume_down.png' )

#sonido_mute = pygame . imagen . load ( 'sonido / volume_muted.png' )

#sonido_max = pygame . imagen . load ( 'sonido / volume_max.png' )


X = 0

px  =  50

py  =  200

ancho  =  40

velocidad  =  20


#Control de FPS

reloj  =  pygame.time.Clock()


#Variables salto

salto=False #el personaje esta en False porque no esta saltando

#Contador de salto

cuentaSalto=10


#Variables dirección

izquierda=False

derecha=False


#Pasos

cuentaPasos=0


#Movimiento

def  recargaPantalla():

    #Variables Globales

     global cuentaPasos

     global  X


     # fondo en movimiento

     X_relativa = X % fondo.get_rect().width

     PANTALLA.blit(fondo, (X_relativa - fondo.get_rect().width,0))

     if X_relativa < W:

         PANTALLA.blit(fondo,(X_relativa,0))

     X -= 5


    #Contador de pasos

     if  cuentaPasos + 1 >=6 :

        cuentaPasos  =  0

     #Movimiento a la izquierda

     if  izquierda :

        PANTALLA . blit ( caminaIzquierda [ cuentaPasos  //  1 ], ( int ( px ), int ( py )))

        cuentaPasos  +=  1


        # Movimiento a la derecha

     elif  derecha :

        PANTALLA . blit ( caminaDerecha [ cuentaPasos  //  1 ], ( int ( px ), int ( py )))

        cuentaPasos  +=  1


     elif  salto  +  1  >=  2 :

        PANTALLA . blit ( salta [ cuentaPasos  //  1 ], ( int ( px ), int ( py )))

        cuentaPasos  +=  1


     else :

        PANTALLA . blit ( quieto , ( int ( px ), int ( py )))


ejecuta  =  True


#Bucle de acciones y controles

while  ejecuta :

     #FPS

     reloj.tick( 18 )


     #Bucle del juego

     for  event  in  pygame.event.get():

        if  event.type  ==  pygame.QUIT :

            ejecuta  =  False


     # Opción tecla pulsada

     keys  = pygame.key.get_pressed()


     #Tecla A - Moviemiento a la izquierda

     if  keys [ pygame . K_a ] and  px  >  velocidad :

        px  -=  velocidad

        izquierda  =  True

        derecha  =  False


     #Tecla D - Moviemiento a la derecha

     elif [ pygame . K_d ] and  px  <  900  -  velocidad  -  ancho :

        px  +=  velocidad

        izquierda  =  False

        derecha  =  True


     #Personaje quieto

     else :

        izquierda  =  False

        derecha  =  False

        cuentaPasos  =  0


     #Tecla W - Moviemiento hacia arriba

     if  keys[ pygame . K_w ] and  py  >  100 :

        py  -=  velocidad


     #Tecla S - Moviemiento hacia abajo

     if  keys[ pygame . K_s ] and  py  <  300 :

        py  +=  velocidad

    #Tecla ESPACIO - Salto

     if not ( salto ):

        if  keys [ pygame . K_SPACE ]:

            salto  =  True

            izquierda  =  False

            derecha  =  False

            cuentaPasos  =  0

     else :

        if  cuentaSalto  >= -10 :

            py -= ( cuentaSalto  *  abs ( cuentaSalto )) *  0.5

            cuentaSalto -=  1

        else :

            cuentaSalto  =  10

            salto  =  False

     recargaPantalla()

     pygame.display.update()

     #RELOJ.tick(FPS)

#Salida del juego

pygame.quit()

PANTALLA DE SALIDA