Juego Invasores con Menú

# coding: utf-8
import pilasengine

pilas = pilasengine.iniciar()
fondo = pilas.fondos.Noche() #fondo que recibirá por defecto la ventana del menú mientras se permanezca en el

def iniciar_juego(): #función que iniciará el juego cuando comience
    pilas.escenas.Normal() #cambio de fondo de pantalla que recibe el programa
    puntos = pilas.actores.Puntaje(x=-280, y=200, color=pilas.colores.blanco)
    avisar=pilas.avisar("Tete dale a las flechas y al espacio pa'jugar")   

    class PlanetaEnemigo(pilasengine.actores.Actor):
        def iniciar (self):
            self.imagen = "planeta_azul.png"
            self.escala=0.25
            self.escala =[0.5],5
            self.aprender(pilas.habilidades.PuedeExplotarConHumo)
            self.x = pilas.azar(-200,200)
            self.y=290
            self.velocidad=pilas.azar(10,40)/10.0

        def actualizar(self):
            self.rotacion+=10   
            self.y-=self.velocidad  
            if self.y <-300:
               self.eliminar

    def crear_enemigo():
        actor=PlanetaEnemigo(pilas)
        enemigo.agregar(actor)

    def fin_juego():
        texto = pilas.actores.Texto("Perdiste bro, pulsa cualquier tecla para salir")
        pilas.evento.pulsa_tecla.conectar(salir_de_juego) #definición que determina la salida del juego por parte de la función de salir_de_juego explicada más abajo al clickar en la pantalla

    def salir_de_juego(evento): #función anclada al juego
        pilas.terminar() #instrucción para terminar el juego

  #Programa principal
    pilas.fondos.Galaxia()
    enemigo=pilas.actores.Grupo()
    pilas.tareas.siempre(0.5, crear_enemigo)
    nave=pilas.actores.NaveRoja(y=-200)
    nave.aprender(pilas.habilidades.LimitadoABordesDePantalla)
    nave.definir_enemigos(enemigo,puntos.aumentar)
    pilas.colisiones.agregar(nave, enemigo, nave.eliminar)
    pilas.colisiones.agregar(nave, enemigo, fin_juego) 

def salir_del_juego(): #definición de que ocurrirá en caso de que el jugador lo seleccione en el menú principal
      pilas.terminar() #se termina pilasengine

pilas.actores.Menu( #función que determina al Menú como un actor a fin de poder agregarle elementos que aparecerán en el juego

        [
            ('Iniciar Juego', iniciar_juego), #nombre de la función que el jugador verá

            ('Salir', salir_del_juego), #nombre de la función que el jugador verá
        ])

pilas.ejecutar()

Juego Invasores

En esta ocasión, he creado con la ayuda de mi profesora y mis compañeros un juego estilo retro de una nave al puro estilo asteroids pero con un mejor diseño gráfico.

# -*- coding: utf-8

import pilasengine #se cargan todos los datos de pilasengine

pilas = pilasengine.iniciar() #iniciamos el programa

puntos=pilas.actores.Puntaje(x=-280, y=200, color=pilas.colores.blanco) #determinamos la posición y color del marcador que indicará los puntos obtenidos al jugador a lo largo de la partida

avisar = pilas.avisar("Tete, dale a las flechas y el espacio pa' jugar") #mensaje al jugador de que herramientas puede utilizar para jugar (de forma basta en mi caso)

class PlanetaEnemigo(pilasengine.actores.Actor): #instrución que determinará los parámetros de el actor PlanetaEnemigo

def iniciar(self): #función para crear el actor

self.imagen = "planeta_azul.png" #imagen que usará el actor enemigo

self.escala = 0.25 #instrucción que determina el tamaño del actor

self.escala=[0.5],5 #instrucción que aumentará el tamaño a lo largo de 5 segundos hasta llegar al punto deseado, en este caso el tamaño deseado es 0.5

self.aprender(pilas.habilidades.PuedeExplotarConHumo)#esta instrucción determina que el actor es dotado de la habilidad de explotar con humo

self.x = pilas.azar(-200,200) #instrucción que dará un valor aleatorio al actor para aparecer en la pantalla

self.y = 290 #esta instrucción determinamos que la ordenada de aparición del actor, siendo esta ordenada invariable

self.velocidad = pilas.azar(10,40)/10.0 #velocidad del actor

def actualizar(self): #función para actualizar el movimiento que hace el actor

self.rotacion+=10 #instrucción que determina la rotación del actor

self.y-=self.velocidad #instrucción para aminorar la velocidad del actor

if self.y<-300:

self.eliminar #si el actor llega a estas coordenadas es eliminado

def crear_enemigo(): #función para crear al enemigo

actor = PlanetaEnemigo(pilas) 

enemigo.agregar(actor) #instrucción que determina que el actor es un enemigo

#Programa Principal#

pilas.fondos.Galaxia() #fondo que usaremos para el juego

enemigo=pilas.actores.Grupo() #instrucción para que se creen enemigos

pilas.tareas.siempre(0.5,crear_enemigo) #tarea que hará que mientras el juego continué, se crearan enemigos

nave=pilas.actores.NaveRoja(y=-200) #localización de aparición de la nave

nave.aprender(pilas.habilidades.LimitadoABordesDePantalla) #instrucción que dota a la nave de la habilidad de no salirse de los bordes de la pantalla

nave.definir_enemigos(enemigo, puntos.aumentar) #instrucción que aumentará los puntos del jugador por cada planeta destruido, dado que no damos valor alguno se queda por defecto en 1

pilas.colisiones.agregar(nave,enemigo,nave.eliminar) #instrucción que permite las colisiones entre los asteroides y la nave, en caso de ocurrir durante la patida esta terminaria, significando el fin de la partida

pilas.ejecutar()

Función Perder

Ahora, el último paso a seguir será determinar cuando acaba. El fin del juego se dará cuando un mono colisione con la torreta esta desaparecerá, y esto significará que el juego se ha acabado. A esto también le añadiremos un mensaje en el cual aparezca la cantidad de puntos logrados junto con un mensaje bien grande de que el juego esta acabado.

def perder(torreta, enemigo):

# Indicar fin de juego y eliminar lo que ya no se necesita

global fin_de_juego

enemigo.sonreir()

torreta.eliminar()

pilas.tareas.eliminar_todas()

fin_de_juego = True

pilas.avisar("GAME OVER. Conseguiste %d puntos" % (puntos.obtener()))

Dado que el juego se ha acabado todos los procesos que se estaban dando lugar terminarán. Y para frustrar al jugador a fin de que lo vuelva a intentar los monos sonreirán en forma de burla.

Mono Destruido

A continuación determinaremos los parámetros que permitirán la destrucción del mono y la puntuación por ello.

# Eliminar el mono alcanzado

enemigo.eliminar() 
disparo.eliminar()

# Actualizar el marcador con un efecto bonito

puntos.escala = 0

puntos.escala = pilas.utils.interpolar(puntos, 'escala', 1, duracion=0.5)

puntos.aumentar(1)

En primer lugar esta instrucción determina que elimina al enemigo.
enemigo.eliminar()

Esta, determina que son los disparos los encargados de eliminar a los enemigos.
disparo.eliminar()

Las siguientes instrucciones aumentarán los puntos del marcador a medida que los monos son destruidos, estableciendo así una meta al juagador.

puntos.escala = 0

puntos.escala = pilas.utils.interpolar(puntos, 'escala', 1, duracion=0.5)

puntos.aumentar(1)

Agregar Tarea

pilas.tareas.agregar(1, crear_mono)

Este es el siguiente paso a seguir. Gracias a este comando seremos capaces de crear un mono cada segundo. El cual es la base del juego (pues va de disparar a monos). Ahora quedaría destruirlos y determinar que ocurre cuando se pierde.

Class Sonido

def iniciar(self, x=0, y=0): #se inicia el juego y el objeto es situado en una posición

self.x = x concreta, esta obviamente es modificable

self.y = y

self.ruta_normal = 'iconos/sonido_on.png' #ruta para abrir el archivo en su estado normal

self.ruta_press = 'iconos/sonido_off.png' #ruta para abrir el archivo en función de si se 
aprieta un botón o no

self.imagen = self.ruta_normal #ruta para abrir el archivo de la imágen

self.radio_de_colision = 15 #determinación de el espacio del que dispone un objeto 
para su interacción con otros

self.cuando_hace_click = self.cuando_pulsa #cuando el usuario pulsa el botón uno del ratón se considerará de una determinada manera, en este caso se considerará pulsar

# Colocamos el boton en la esquina inferior derecha de la pantalla.

self._ancho_mundo, self._alto_mundo = self.pilas.widget.obtener_area()

self.x = (self._ancho_mundo / 2) - self.ancho

self.y = -1 * (self._alto_mundo / 2) + self.alto
#determinación de la ubicación del botón de sonido

self.activado = True #esta activado de base el botón anterior

def cuando_pulsa(self): #esta acción determina que el botón ha 
sido pulsado y pasa al modo contrario

"""Alterna entre sonido habilitado o deshabilitado."""

if self.activado:

self.pilas.deshabilitar_musica() #instrucciones de las acciones que desactivan la musica

self.pilas.deshabilitar_sonido() y el sonido

self.imagen = self.ruta_press #imagen del botón que aparecerá indicando que no hay sonido

self.pilas.avisar("Sonido deshabilitado") #se avisa de que ha desactivado el volumen

self.activado = False #determinación del estado de la acción

else:

self.pilas.deshabilitar_musica(estado=False) #se desactivan las funciones de la acción

self.pilas.deshabilitar_sonido(estado=False) por lo tanto se activan la musica y el sonido

self.imagen = self.ruta_normal #la imágen pasará a indicar que hay sonido

self.pilas.avisar("Sonido habilitado") #se avisa de que ha activado el volumen

self.activado = True #determinación del estado de la acción

ç

En Python hemos codificado un programa básico que realiza divisiones al introducir un dividendo y un divisor. Si el resultado es exacto el programa lo comunica junto con el resultado. Y si el resultado sin embargo contiene resto, el programa indica cuanto.

Practica de Python numero 2

1ª Imágen
En este caso he programado en el Python un sistema de instrucciones que calcula el área de círculos y de triángulos. Para ello es imprescindible que usar la instrucción denominada como "raw_input" la cual solo permite el uso de letras. Por lo demás son todo instrucciones lógicas para calcular las áreas del triangulo y el circulo.

2ªImágen
En este caso se trata de dividir he indicar si el resultado de la operación es exacto o si por el contrario la operación da lugar a un resultado más el resto.




3ª Imágen

En esta ocasión he programado un sistema de instrucciones que de determinan cuanto tiempo falta para un año previamente introducido. Se basa íntegramente en una resta.

Aprendiendo a programar con Python

Que es la programación?

Si la programación fuese enseñar a un ordenador a tener una conversación con un ser vivo, sería más conveniente enseñarle a a hablar. Por ello, sera primordial que esta comunicación se controle al máximo y será una de las herramientas a la hora de programar.

Instrumentos para programar

Al escribir cosas en Python, estamos suministrando un bloque de texto que queremos que se iescriba. El texto en Python se considera un tipo específico de datos llamado cadena. Una cadena, llamada así porque son una serie de letras, números o símbolos conectados en orden, como si estuvieran unidos por una cuerda. Las cadenas se pueden definir de diferentes maneras.
Mientras las comillas dobles (") y las comillas simples (') son formas aceptables de definir una cadena, una cadena debe abrirse y cerrarse con el mismo tipo de comillas. Podemos combinar múltiples cadenas usando ( + ).

Los errores

A medida que nos familiarizamos con el lenguaje de programación Python, nos topamos con errores y excepciones. Estas son quejas que hace Python cuando no entiende lo que queremos que haga. Es normal encontrarse con estos errores. 
Si las comillas no coinciden, Python notará esto e informará que el código tiene un error en su sintaxis. Si esto pasase el programa dejará de funcionar instantáneamente.

Esto significa que una cadena no se cerró, o no se cerró con el mismo carácter de comillas que la inició.  
Otro problema con el que puede encontrarse es intentar crear una cadena sin comillas. Python trata las palabras que no están entre comillas como comandos, como la declaración de impresión. Si no reconoce estas palabras como se define (en Python o por su programa en otro lugar) Python se quejará de que el código tiene un NameError. Esto significa que Python encontró lo que cree que es un comando, pero no sabe lo que significa porque no está definido en ninguna parte.

Variables

En Python, y cuando se programa en general, necesitamos construir sistemas para manejar los datos que cambian con el tiempo. Esa información podría ser la ubicación de un avión, o la hora del día, o el programa de televisión que está viendo actualmente. Lo único importante es que puede ser diferente en diferentes momentos. Python usa variables para definir cosas que están sujetas a cambios. 

Aritmética

Una cosa que las computadoras son capaces de hacer excepcionalmente bien es realizar aritmética. La suma, la resta, la multiplicación, la división y otros cálculos numéricos son fáciles de hacer en la mayoría de los lenguajes de programación, y Python no es una excepción.
 
Las combinaciones de operadores aritméticos siguen el orden usual de operaciones. Python también ofrece un compañero para la división llamado operador de módulo. El operador de módulo se indica mediante% y devuelve el resto después de realizar la división.

Actualizando variables

Cambiar el contenido de una variable es una de las operaciones esenciales. A medida que el flujo de un programa progresa, los datos deben actualizarse para reflejar los cambios que han sucedido. La actualización de una variable sumando o restando un número al contenido original de la variable tiene su propia forma abreviada para hacerlo más rápido y fácil de leer.

Comentarios

La mayoría de las veces, el código debe escribirse de tal manera que sea fácil de entender por sí mismo. Sin embargo, si desea incluir una información para explicar una parte de su código, puede usar el signo #. Una línea de texto precedida de un # se llama comentario. Python no ejecuta este código, solo  los humanos lo lean. Cuando revises tu código más tarde, los comentarios pueden ayudarte a descubrir lo que se pretendía hacer.

Números

Las variables también pueden contener valores numéricos. El tipo más simple de número en Python es el entero, que es un número entero sin punto decimal.
Un número con un punto decimal se llama float. Puede definir floats con números después del punto decimal o simplemente incluyendo un punto decimal al final. 

Dos tipos de división

En Python, cuando dividimos dos enteros, obtenemos un número entero como resultado. Sin embargo, si los números no se dividen de manera uniforme, el resultado de la división se trunca en un número entero. En otras palabras, el cociente se redondea a un número entero. 

Cuerdas multilínea

Hemos visto cómo definir una cadena con comillas simples y comillas dobles. Si queremos que una cadena abarque varias líneas, también podemos usar comillas triples. Cuando una cadena como esta no está asignada a una variable, funciona como un comentario de varias líneas. Esto puede ser útil a medida que su código se vuelve más complejo:

Verdadero o Falso

A veces necesitamos variables que sean verdaderas o falsas. Este tipo de datos, que solo puede tomar uno de dos valores, se denomina booleano. En Python, definimos booleanos usando las palabras clave "True" y "False". Un boolean es en realidad un caso especial de un entero. Un valor de True corresponde a un valor entero de 1 y se comportará igual. Un valor de False corresponde a un valor entero de 0.

Valor Erroneo

Python asigna automáticamente una variable al tipo de datos apropiado en función del valor que se le da. A veces querremos convertir variables a diferentes tipos de datos. Por ejemplo, si quisiéramos imprimir un entero como parte de una cadena, primero querríamos convertir ese entero en una cadena. Podemos hacer eso usando el comando "str ()"


Aquí se encuentra un "examen final" de la web Code Academy donde se pone en práctica todo lo que se enseña (o su mayoría):  

Para todos aquellos interesados en practicar o aprender pueden usar estos enlaces desde los cuales he extraído y sintetizado toda esta información:
https://www.codecademy.com/learn 
https://es.wikipedia.org/wiki/Python 
https://librosweb.es/libro/python/