pilas-engine

Contador de monedas como lo agrego o como lo realizo.


import pilasengine
import subprocess
from pilasengine.comportamientos.comportamiento import Comportamiento
from pilasengine.actores.actor import Actor
import time
import math
pilas = pilasengine.iniciar()
vidas=3

def iniciar():
    pilas.escenas.Normal()
    
    #DEFINIMOS LA MUNICION
    class laser(Actor):
        def iniciar(self, x=0, y=0, rotacion=0, velocidad=10, imagen="bola_amarilla.png"):
            self.x = x
            self.y = y
            self.rotacion = rotacion
            self.velocidad = velocidad
            self.imagen = imagen
            self._calcular_movimiento_desde_rotacion(velocidad)
            self.aprender(self.pilas.habilidades.EliminarseSiSaleDePantalla)
            self.cuando_se_elimina = None
	           
        def actualizar(self):
            self.x += self.dx
            self.y += self.dy
	        

        def _calcular_movimiento_desde_rotacion(self, velocidad):
            rotacion_en_radianes = math.radians(self.rotacion)
            self.dx = math.cos(rotacion_en_radianes) * velocidad
            self.dy = math.sin(rotacion_en_radianes) * velocidad

        def eliminar(self):
            if self.cuando_se_elimina:
                self.cuando_se_elimina(self)
                Actor.eliminar(self)
	            


	#DEFINIMOS AL PERSONAJE PRINCIPAL
    class principal(pilasengine.actores.Actor):
        def iniciar(self, x=0, y=0, r=0):
            self.x = x
            self.y = y
            self.radio_de_colision=55
            self.hacer_inmediatamente(Parado)
            self.r = r
            self.disparos = []
            self._contador_demora = 6
            self.demora_entre_disparos = 5
            self.disparo_doble = True
            self.cuando_elimina_enemigo = False
            self.aprender(self.pilas.habilidades.PuedeExplotarConHumo)
            self.altura_del_salto = 0
            self.figura = pilas.fisica.Rectangulo(100, 100, 70,130, dinamica=False)
            self.figura.escala_de_gravedad = 50
            self.escala=0.8         
            self.figura_de_colision = self.figura
	    
        def disparar(self):
            self.intenta_disparar()

        def terminar(self):
            pass

        def intenta_disparar(self):
            if self._contador_demora > self.demora_entre_disparos:
                self._contador_demora = 0
                self.crear_disparo()

        def crear_disparo(self):
            if self.disparo_doble:
                disparo1 = self.pilas.actores.laser(x=self.izquierda + 10, y=self.y, rotacion=self.r)
                self.disparos.append(disparo1)
                disparo1.cuando_se_elimina = self._cuando_elimina_disparo

                disparo2 = self.pilas.actores.laser(x=self.derecha - 10, y=self.y, rotacion=self.r)
                self.disparos.append(disparo2)
                disparo2.cuando_se_elimina = self._cuando_elimina_disparo
                disparo1.z = self.z + 1
                disparo2.z = self.z + 1
            else:
                disparo1 = self.pilas.actores.laser(x=self.x, y=self.y, rotacion=90)
                self.disparos.append(disparo1)
                disparo1.z = self.z + 1
                disparo1.cuando_se_elimina = self._cuando_elimina_disparo
        def _cuando_elimina_disparo(self, disparo):
            if disparo in self.disparos:
                self.disparos.remove(disparo)

        def definir_enemigos(self, grupo, cuando_elimina_enemigo=None):
            """Hace que una nave tenga como enemigos a todos los actores del grupo."""
            self.cuando_elimina_enemigo = cuando_elimina_enemigo
            self.pilas.colisiones.agregar(self.disparos, grupo, self.hacer_explotar_al_enemigo)

        def hacer_explotar_al_enemigo(self, mi_disparo, el_enemigo):
            """Es el método que se invoca cuando se produce una colisión 'tiro <-> enemigo'
            """
            mi_disparo.eliminar()
            el_enemigo.eliminar()
            if self.cuando_elimina_enemigo:
                self.cuando_elimina_enemigo
                
        def eliminarse(mi_disparo):
            if mi_disparo.x > guerrero.x + 500:
                    mi_disparo.eliminar()

	           
	            
    class Parado(Comportamiento):
        def iniciar(self, receptor):
            """Inicializa el comportamiento.
	:param receptor: La referencia al actor.
	        """
            self.receptor = receptor
            self.control = receptor.pilas.control
            self.receptor.imagen = self.pilas.imagenes.cargar_grilla("shaolin/parado.png", 4, 1)
	    
        def actualizar(self):
            self.receptor.imagen.avanzar(10)
            # Si pulsa a los costados comienza a caminar.
            if self.receptor.figura_de_colision.figuras_en_contacto:
                if self.control.derecha:
                    self.receptor.hacer_inmediatamente(Caminar)
            if self.receptor.figura_de_colision.figuras_en_contacto:
                if self.control.izquierda:
                    self.receptor.hacer_inmediatamente(Caminar)
	            
            # Si pulsa hacia arriba salta.
            if self.receptor.figura_de_colision.figuras_en_contacto:
                if self.control.arriba:
                    self.receptor.transparencia =20
                    self.receptor.hacer_inmediatamente(Saltar)
	            
            if pilas.control.boton:
                self.receptor.intenta_disparar()
            self.receptor._contador_demora += 1
	        
            if pilas.control.izquierda:
                self.receptor.r=180
            elif pilas.control.derecha:
                self.receptor.r=0
	            
            self.receptor.eliminarse()     
	            
            self.receptor.x = self.receptor.figura.x
            self.receptor.y = self.receptor.figura.y

    class Caminar(Comportamiento):
        	    
        def iniciar(self, receptor):
            self.receptor = receptor
            self.control = receptor.pilas.control
            self.receptor.imagen = self.pilas.imagenes.cargar_grilla("shaolin/camina.png", 4, 1)
        def actualizar(self):
            self.receptor.imagen.avanzar(10)
            # Si pulsa a los costados se puede mover.
            if self.control.derecha:
                self.receptor.x += 5
                self.receptor.figura.x=self.receptor.x
                self.receptor.figura.y=self.receptor.y
                self.receptor.espejado = False
            elif self.control.izquierda:
                self.receptor.x -= 5
                self.receptor.figura.x=self.receptor.x
                self.receptor.figura.y=self.receptor.y
                self.receptor.espejado = True
            # Si pulsa hacia arriba salta.
            if self.control.arriba:
                self.receptor.hacer_inmediatamente(Saltar)
                self.receptor.figura.x=self.receptor.x
                self.receptor.figura.y=self.receptor.y
	            
            # Si suelta las teclas regresa al estado inicial.
            if not self.control.derecha and not self.control.izquierda:
                self.receptor.hacer_inmediatamente(Parado) 
	            
    class Saltar(Comportamiento):
	    
        def iniciar(self, receptor):
            self.receptor = receptor
            self.control = receptor.pilas.control
            self.receptor.imagen = self.pilas.imagenes.cargar_grilla("shaolin/salta.png", 3, 1)
	      
            self.y_inicial = self.receptor.y
            self.vy = 15
            self.receptor.figura.y=self.receptor.y
	        
        def actualizar(self):
            self.receptor.y += self.vy
            self.receptor.figura.y=self.receptor.y
            self.vy -= 0.9

            distancia_al_suelo = self.receptor.y - self.y_inicial
            self.receptor.altura_del_salto = distancia_al_suelo

            # Cuando llega al suelo, regresa al estado inicial.
	        
            if distancia_al_suelo < 0:
                self.receptor.y = self.y_inicial -5
                self.receptor.figura.y=self.receptor.y
                self.receptor.altura_del_salto = 0
                self.receptor.hacer_inmediatamente(Parado)
	          
            # Si pulsa a los costados se puede mover.
            if self.control.derecha:
                self.receptor.x += 5
                self.receptor.figura.x=self.receptor.x
                self.receptor.espejado = False
            elif self.control.izquierda:
                self.receptor.x -= 5
                self.receptor.figura.x=self.receptor.x
                self.receptor.espejado = True
	          
    #DEFINIMOS A LAS PLATAFORMAS 
    class Paleta(pilasengine.actores.Actor):

        def iniciar(self,x=0 ,y=0 ,l=0, a=0):
            self.imagen = 'pasto.png'
            self.x = x
            self.y = y
            self.l=l
            self.a=a
	        
            self.figura_de_colision= pilas.fisica.Rectangulo(0,0, self.l, self.a,False)
            self.escala=0.3

    class Paleta_movil(pilasengine.actores.Actor):
        def iniciar(self, limite1=0, p2=0, p1=0, l=0,a=0, x=0,y=0):
            self.imagen = 'pasto.png'
            self.x = x
            self.y = y
            self.l=l
            self.a=a
            self.limite1=0
            self.p1=self.y -100
            self.p2=self.y +100
            self.figura_de_colision= pilas.fisica.Rectangulo(0,0, self.l, self.a,False)
            self.escala=0.3
        def actualizar(self):
            self.imagen.avanzar()       
            if self.limite1==0:
                self.limite1=2
            if self.limite1==2:
                self.y -= 1
            elif self.limite1==1:
                self.y+=1
	            
            if self.y == self.p1:
                self.limite1=1
            elif self.y==self.p2:
                self.limite1=2
	    
    class Paleta_trampa(pilasengine.actores.Actor):

        def iniciar(self,x=0 ,y=0):
            self.imagen = 'pasto.png'
            self.x = x
            self.y = y
	   
            self.figura = pilas.fisica.Rectangulo(100, 100, 200,30, dinamica=False)
            self.escala=0.3
            self.figura.escala_de_gravedad =0
            self.figura.y=self.y
            self.figura.x = self.x
        def actualizar(self):
            self.x = self.figura.x
            self.y = self.figura.y
	        
    class Paleta_fatal(pilasengine.actores.Actor):

        def iniciar(self,x=0 ,y=0):
            self.imagen = 'trampa.png'
            self.x = x
            self.y = y
            self.radio_de_colision=20
            self.escala=0.3
	           
	 

	#CREAMOS ENEMIGOS

    class enemigo(pilasengine.actores.Actor):

        def iniciar(self, limite1=0, p2=0, p1=0, r=0,x=0,y=0):
            self.x=x
            self.y=y
            self.limite1=0
            self.p1=self.x -100
            self.p2=self.x +100
            animacion = pilas.imagenes.cargar_animacion('alien.png', 1)
            self.imagen = animacion
            self.radio_de_colision=45
            self.r = r

            self.disparos = []
            self._contador_demora = 6
            self.demora_entre_disparos = 50
            self.disparo_doble = True
            self.cuando_elimina_enemigo = False

            self.aprender(self.pilas.habilidades.PuedeExplotar) 
	    
        def disparar(self):
            self.intenta_disparar()
        def terminar(self):
            pass
        def intenta_disparar(self):
            if self._contador_demora > self.demora_entre_disparos:
                self._contador_demora = 0
                self.crear_disparo()

        def crear_disparo(self):
            if self.disparo_doble:
                disparo1 = self.pilas.actores.laser(x=self.izquierda + 10, y=self.y, rotacion=self.r)
                self.disparos.append(disparo1)
                disparo1.cuando_se_elimina = self._cuando_elimina_disparo
                disparo2 = self.pilas.actores.laser(x=self.derecha - 10, y=self.y, rotacion=self.r)
                self.disparos.append(disparo2)
                disparo2.cuando_se_elimina = self._cuando_elimina_disparo
                disparo1.z = self.z + 1
                disparo2.z = self.z + 1
            else:
                disparo1 = self.pilas.actores.laser(x=self.x, y=self.y, rotacion=90)
                self.disparos.append(disparo1)
                disparo1.z = self.z + 1
                disparo1.cuando_se_elimina = self._cuando_elimina_disparo
        def _cuando_elimina_disparo(self, disparo):
            if disparo in self.disparos:
                self.disparos.remove(disparo)

        def definir_enemigos(self, grupo, cuando_elimina_enemigo=None):
            """Hace que una nave tenga como enemigos a todos los actores del grupo."""
            self.cuando_elimina_enemigo = cuando_elimina_enemigo
            self.pilas.colisiones.agregar(self.disparos, grupo, self.hacer_explotar_al_enemigo)

        def hacer_explotar_al_enemigo(self, mi_disparo, el_enemigo):
            """Es el método que se invoca cuando se produce una colisión 'tiro <-> enemigo'
            """
            mi_disparo.eliminar()
            el_enemigo.eliminar()
            if self.cuando_elimina_enemigo:
                self.cuando_elimina_enemigo()
        def eliminarse(mi_disparo):
            if mi_disparo.x > guerrero.x + 500:
                mi_disparo.eliminar()
	                
        def actualizar(self):
            self.imagen.avanzar()
            if self.limite1==0:
                self.limite1=2
            if self.limite1==2:
                self.x -= 1
                self.intenta_disparar()
                self._contador_demora += 1
                self.r=180
                self.espejado = True
            elif self.limite1==1:
                self.x+=1
                self.intenta_disparar()
                self._contador_demora += 1
                self.r=0
	  
            if self.x == self.p1:
                self.limite1=1
                self.espejado = False
            elif self.x==self.p2:
                self.limite1=2



    #MONEDAS
    class monedas(pilasengine.actores.Actor):
        def iniciar(self, x=0 , y=0):
            self.x=x
            self.y=y
            self.imagen = self.pilas.imagenes.cargar_grilla("moneda.png", 8, 1)
        def actualizar(self):
            self.imagen.avanzar(10)

    #CREANDO MONEDAS
    pilas.actores.vincular(monedas)
    money=[]
    e=0
    for i in range(0,5):
        e+=30
        money.append(pilas.actores.monedas(x=e, y=30))
    e=400
    for i in range(0,5):
        e+=40
        money.append(pilas.actores.monedas(x=e, y=-75))

    e=1000
    for i in range(0,10):
        e+=40
        money.append(pilas.actores.monedas(x=e, y=-135))    
	  

    #FUNCIONES
    puntos = pilas.actores.Puntaje(x= 250,y=200)
    puntos.valor_inicial = 0

    def sumar_puntos(principal, monedas):
        monedas.eliminar()
        puntos.aumentar(1)
  

	#BLOQUES SOLIDOS
    pilas.actores.vincular(Paleta)
    block1 = pilas.actores.Paleta(x=100,y=-200, l=200, a=20)
    block2 = pilas.actores.Paleta(x=400,y=-150, l=200, a=20)
    block3 = pilas.actores.Paleta(x=650,y=-90, l=200, a=20)
    block4 = pilas.actores.Paleta(x=850,y=-150, l=200, a=20)
    block5 = pilas.actores.Paleta(x=900,y=-30, l=200, a=20)
    block6 = pilas.actores.Paleta(x=1050,y=-150, l=200, a=20)
    block7 = pilas.actores.Paleta(x=1350,y=-110, l=200, a=20)
    block8 = pilas.actores.Paleta(x=1200,y=30, l=200, a=20)
	    

    #BLOQUES_MOVIL  
    pilas.actores.vincular(Paleta_movil)      
    block10 = pilas.actores.Paleta_movil(x=1600,y=1, l=200, a=20)

    #BLOQUES_TRAMPA
    pilas.actores.vincular(Paleta_trampa)      
    block11 = pilas.actores.Paleta_trampa(x=1850, y=0)


    #BLOQUES_FATALES
    pilas.actores.vincular(Paleta_fatal)      
    bloques_fatal=[]  

    block12 = pilas.actores.Paleta_fatal(x=1850, y=-150)
    block13 = pilas.actores.Paleta_fatal(x=1830, y=-150)
    block13 = pilas.actores.Paleta_fatal(x=1880, y=-150)
    bloques_fatal.append(block12)
    bloques_fatal.append(block13)

    pilas.actores.vincular(enemigo)
    enemigo = pilas.actores.enemigo(x=500,y=-150)
    enemigo1 = pilas.actores.enemigo(x=1350,y=-70)
    mis_enemigos=[enemigo,enemigo1]


    guerrero=principal(pilas)
    guerrero.definir_enemigos(mis_enemigos)
    enemigo.definir_enemigos(guerrero, restar_vida)

    #COLISIONES

    pilas.colisiones.agregar(guerrero,mis_enemigos, restar_vida)
    pilas.colisiones.agregar(guerrero,bloques_fatal, restar_vida)
    pilas.colisiones.agregar('principal', 'monedas', sumar_puntos)

    fondo=pilas.fondos.FondoMozaico()  
    fondo.imagen="fondo 0.jpg"
    bloques=[]
    pilas.actores.vincular(principal)
    pilas.actores.vincular(laser)
	#SEGUIMIENTO DE CAMARA AL ACTOR
    pilas.eventos.pulsa_tecla.conectar(seguir_actor)
	     
def seguir_actor(tecla):
    if tecla.codigo == 2:
        pilas.camara.x=[guerrero.x]

    

def restar_vida():
        
        if vidas>0:
            vidas -=1
            pilas.avisar('Vidas restantes = ' + str(vidas))
        else:
            text = pilas.actores.Texto('GAME OVER',magnitud = 50)
            textpuntos = pilas.actores.Texto(u'Tu puntuación es: '+ str(puntos.valor))
            textpuntos.y = -50
                
     
    
def salir_del_juego():
    print("Tengo que salir...")
    pilas.terminar()

def iniciar_juego():
    p = subprocess.Popen("pantalla2.py", stdout=subprocess.PIPE, shell=True)
    out, err =p.communicate()
	
pilas.actores.Menu(
        [
            ('iniciar juego', iniciar_juego),
            ('salir', salir_del_juego),
        ])

pilas.ejecutar()

Hola @Emerson !!! para tener un contador de monedas podes usar el actor Puntaje, fijate que entre los ejemplos de pilas hay uno que usa este actor para mostrar la cantidad de enemigos eliminados:

En tu caso sería igual, solo que tendríasque incrementar ese contador cuando recolectás monedas.

Ah, por cierto, para cambiar de una escena a otra te conviene seguir las instrucciones del manual y no usar subprocess (http://manual.pilas-engine.com.ar/escenas/) subprocess consume muchos recursos, y si el proceso falla puede quedar en ejecución consumiendo memoria, te conviene no usarlo directamente.

¡abrazo!