Actualización del juego tank a la versión actual 1.4.12 de pilas-engine

Buen día a todos, es cierto que hace falta un poco de material para poder expandir los conocimientos en programación de videojuegos.

Uno de mis estudiantes quiso replicar este proyecto tank de @fsalamero y @quiqueporta en versiones anteriores y que lo menciona en otro post @jordinur.

He intentado en el poco tiempo libre que tengo actualizar el código a la actual versión de pilasengine y este resultado tengo hasta el momento.

Paso 1

# -*- encoding: utf-8 -*-
#
# Creamos las escenas y el menú del juego

import pilasengine

pilas = pilasengine.iniciar()

class Escena_Juego(pilasengine.escenas.Escena):
    """ Escena principal del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        self.imagen = pilas.fondos.Pasto()


class Escena_Menu(pilasengine.escenas.Escena):
    """ Escena del menú del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        pilas.fondos.Tarde()
        menu = pilas.actores.Menu(
        [
        (u'Iniciar Juego', self.iniciar_juego),
        (u'Salir', self.salir_del_juego),
        ]
        )

    def salir_del_juego(self):
        pilas.terminar()

    def iniciar_juego(self):
        pilas.escenas.Escena_Juego()


pilas.escenas.vincular(Escena_Menu)
pilas.escenas.vincular(Escena_Juego)

pilas.escenas.Escena_Menu()


pilas.ejecutar()

Paso 2

# -*- encoding: utf-8 -*-
#
# Creamos las escenas y el menú del juego

import pilasengine

pilas = pilasengine.iniciar()

teclas2 = {
            pilas.simbolos.a: 'izquierda',
            pilas.simbolos.d: 'derecha',
            pilas.simbolos.w: 'arriba',
            pilas.simbolos.s: 'abajo',
            pilas.simbolos.ALTGR: 'boton',
        }

class Tanque(pilasengine.actores.Actor):

    def iniciar(self):
        self.aprender("Disparar", frecuencia_de_disparo=2)
        self.aprender("LimitadoABordesDePantalla")
        self.aprender("PuedeExplotar")

    def actualizar(self):
        pass


class Escena_Juego(pilasengine.escenas.Escena):
    """ Escena principal del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        self.imagen = pilas.fondos.Pasto()
        tanque1= pilas.actores.Tanque()
        tanque1.x = 200
        tanque1.imagen = "images/tanque.png"
        tanque1.rotacion = 90
        mi_control = pilas.control.Control(teclas2)
        tanque1.aprender("MoverseComoCoche", control=mi_control,velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)

        tanque2 = pilas.actores.Tanque()
        tanque2.x = -200
        tanque2.imagen = "images/tanque2.png"
        tanque2.aprender("MoverseComoCoche", velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)


class Escena_Menu(pilasengine.escenas.Escena):
    """ Escena del menú del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        pilas.fondos.Tarde()
        menu = pilas.actores.Menu(
        [
        (u'Iniciar Juego', self.iniciar_juego),
        (u'Salir', self.salir_del_juego),
        ]
        )

    def salir_del_juego(self):
        pilas.terminar()

    def iniciar_juego(self):
        pilas.escenas.Escena_Juego()


pilas.escenas.vincular(Escena_Menu)
pilas.escenas.vincular(Escena_Juego)

pilas.actores.vincular(Tanque)

pilas.escenas.Escena_Menu()


pilas.ejecutar()

Paso 3
# -- encoding: utf-8 --
#
# Creamos las escenas y el menú del juego

import random
import pilasengine

pilas = pilasengine.iniciar()
pilas.reiniciar_si_cambia(__file__)

teclas2 = {
            pilas.simbolos.a: 'izquierda',
            pilas.simbolos.d: 'derecha',
            pilas.simbolos.w: 'arriba',
            pilas.simbolos.s: 'abajo',
            pilas.simbolos.ALTGR: 'boton',
        }

class Tanque(pilasengine.actores.Actor):

    def iniciar(self):
        self.aprender("LimitadoABordesDePantalla")
        self.aprender("PuedeExplotar")

    def actualizar(self):
        pass

    def definir_enemigo(self, enemigo):
        self.aprender("Disparar", frecuencia_de_disparo=2, angulo_salida_disparo=90)
        self.enemigo = enemigo

    def impacto(self, proyectil, enemigo):
        proyectil.eliminar()
        pilas.actores.Humo(proyectil.x, proyectil.y)

class Escena_Juego(pilasengine.escenas.Escena):
    """ Escena principal del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        self.imagen = pilas.fondos.Pasto()

        tanque1= pilas.actores.Tanque()
        tanque1.x = 200
        tanque1.imagen = "images/tanque.png"
        tanque1.rotacion = 90
        mi_control = pilas.control.Control(teclas2)
        tanque1.aprender("MoverseComoCoche", control=mi_control,velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)

        tanque1.aprender("Disparar", frecuencia_de_disparo=2, angulo_salida_disparo=90)
        tanque1_vidas = pilas.actores.Puntaje(x=250, y=200, color="blanco")

        tanque2 = pilas.actores.Tanque()
        tanque2.x = -200
        tanque2.imagen = "images/tanque2.png"
        tanque1.rotacion = 90
        tanque2.aprender("MoverseComoCoche", velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)
        #tanque2.aprender("Disparar", frecuencia_de_disparo=2, angulo_salida_disparo=90)
        tanque2_vidas = pilas.actores.Puntaje(x=-250, y=200, color="blanco")

    def actualizar(self):
        pass

class Escena_Menu(pilasengine.escenas.Escena):
    """ Escena del menú del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        pilas.fondos.Tarde()
        menu = pilas.actores.Menu(
        [
        (u'Iniciar Juego', self.iniciar_juego),
        (u'Salir', self.salir_del_juego),
        ]
        )

    def salir_del_juego(self):
        pilas.terminar()

    def iniciar_juego(self):
        pilas.escenas.Escena_Juego()


pilas.escenas.vincular(Escena_Menu)
pilas.escenas.vincular(Escena_Juego)

pilas.actores.vincular(Tanque)

pilas.escenas.Escena_Menu()


pilas.ejecutar()

No puedo hacer que dispare el 2do tank y tampoco que se detecte como enemigos entre ellos, no logro comprender lo que hizo @fsalamero y @quiqueporta cuando lo crearon pero creo para poder solicitar que se agreguen las actualizaciones debería terminarlo.

El repositorio oficial esta por acá, desde ya les agradezco su colaboración

Buenas, @Statick !

Qué buena iniciativa querer actualizar este juego :smile:

Aún no he podido entrar a fondo en el código, a ver si este domingo puedo ponerme unas horas y lo analizo más a fondo…

De todas formas a “primera vista” no entiendo estas dos funciones, ya que no veo en qué momento son llamadas. Es decir, las funciones están escritas, pero no veo que se activen en ningún momento

Quizás son funciones ya implementadas en Pilas-Engine que desconozco?

Yo, que soy más “chapucero” seguramente habría optado por crear dos clases, una para cada tanque, cada una con su control y con su propio proyectil, y pogramado las colisiones de cada proyectil con el tanque contrario. Creo recordar que hace un tiempo alguien posteó su juego de tanques y tambien optó por este método… voy a ver si lo encuentro y le pongo un link aquí.

De todas formas, lo mejor sería que los propios autores del juego original nos dieran su opinión, ya que sin duda su método de programación es más “elegante” y conciso. Aunque a mi parecer esta misma elegancia puede causar tambien que personas con pocos conocimientos de python (como yo) se pierdan en ese código “avanzado” y no lleguemos a entender la lógica de algunos pasos. :blush:

Un abrazo y hasta muy pronto :wink:

Saludos @jordinur cree un clon de el repo anterior en github para tener el código a la mano y todos los archivos en este link GitHub - statick88/tank: Juego de tanque para dos personas

los métodos definir_enemigos e impacto son parte de la lógica del juego anterior, aunque actualmente en personajes como la Nave o NaveRoja tienen este método dentro de la construcción de sus clases, en aquel entonces me imagino que no existía esta posibilidad y la crearon como un método propio de las clases.

Supongo (es malo suponer) que estos métodos eran llamados en la escena del juego para que se produzca la colisión entre los 2 tanques.

Utilizo parte de un post (en este mismo foro) en el que se trata un poco el manejo de disparos de forma independiente (teclas a, s, d, w, y altgr), sin embargo aun no consigo que dispare el 2do tanque. Ni que este se detecte como enemigo, intente utilizar como herencia los personajes antes mencionados sin mucho éxito

Buenas, @Statick !

Aún no me pude poner a fondo, pero pude ver que para que te dispare el tanke_1 hay que definirle que use “mi_control” al aprender a disparar:

def iniciar(self):
# Cargamos el fondo del juego.
self.imagen = pilas.fondos.Pasto()

    tanque1= pilas.actores.Tanque()
    tanque1.x = 200
    tanque1.imagen = "images/tanque.png"
    tanque1.rotacion = 90
    mi_control = pilas.control.Control(teclas2)
    tanque1.aprender("MoverseComoCoche", control=mi_control,velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)

    tanque1.aprender("Disparar", control=mi_control, frecuencia_de_disparo=2, angulo_salida_disparo=90)
    tanque1_vidas = pilas.actores.Puntaje(x=250, y=200, color="blanco")

    tanque2 = pilas.actores.Tanque()
    tanque2.x = -200
    tanque2.imagen = "images/tanque2.png"
    tanque1.rotacion = 90
    tanque2.aprender("MoverseComoCoche", velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)
    tanque2.aprender("Disparar", frecuencia_de_disparo=2, angulo_salida_disparo=90)
    tanque2_vidas = pilas.actores.Puntaje(x=-250, y=200, color="blanco")

A ver si mañana tengo más tiempo y hacemos que se definan bien como enemigos :wink:

Hay algo que no entiendo, aunque le asigne al tanque1, la variable mi_control

mi_control = pilas.control.Control(teclas2)

al momento de aprender a disparar

tanque1.aprender("MoverseComoCoche" control=mi_control,velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)

el disparo sigue saliendo con la tecla Espacio

Sin embargo la variable teclas2 tiene asignada la tecla ALTGR

Debe haber algo que estoy omitiendo, o no estoy tomando en cuenta, ¿Alguna sugerencia?

LOL

tienes que asignarle el control tanto en el “moversecomocoche” como en el “disparar”,

Seguramente le tienes puesto el aprender(“disparar”) en algún punto de la class tanque, cuando no hace falta ya que se le da esa habilidad en la escena_juego en el momento de crear cada tanque…

Te paso tu código que he retocado en mis pruebas, a mi me funciona perfecto :smile:

# -*- encoding: utf-8 -*-

import random
import pilasengine

pilas = pilasengine.iniciar()
pilas.reiniciar_si_cambia(__file__)

teclas2 = {
            pilas.simbolos.a: 'izquierda',
            pilas.simbolos.d: 'derecha',
            pilas.simbolos.w: 'arriba',
            pilas.simbolos.s: 'abajo',
            pilas.simbolos.CTRL: 'boton',
        }

class Tanque(pilasengine.actores.Actor):

    def iniciar(self):
        self.aprender("LimitadoABordesDePantalla")
        self.aprender("PuedeExplotar")

    def actualizar(self):
        pass

    def definir_enemigo(self, enemigo):
        #self.aprender("Disparar", frecuencia_de_disparo=2, angulo_salida_disparo=90)
        self.enemigo = enemigo
        
pilas.actores.vincular(Tanque)

class Escena_Juego(pilasengine.escenas.Escena):
    """ Escena principal del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        self.imagen = pilas.fondos.Pasto()
        
        mono = pilas.actores.Mono()

        tanque1= pilas.actores.Tanque()
        tanque1.x = 200
        tanque1.imagen = "images/tanque.png"
        tanque1.rotacion = 90
        mi_control = pilas.control.Control(teclas2)
        tanque1.aprender("MoverseComoCoche", control=mi_control,velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)

        tanque1.aprender("Disparar", control=mi_control, frecuencia_de_disparo=2, angulo_salida_disparo=90)
        tanque1_vidas = pilas.actores.Puntaje(x=250, y=200, color="blanco")
        tanque1.definir_enemigo(mono)
        
        tanque2 = pilas.actores.Tanque()
        tanque2.x = -200
        tanque2.imagen = "images/tanque2.png"
        tanque1.rotacion = 90
        tanque2.aprender("MoverseComoCoche", velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)
        tanque2.aprender("Disparar", frecuencia_de_disparo=2, angulo_salida_disparo=90)
        tanque2_vidas = pilas.actores.Puntaje(x=-250, y=200, color="blanco")
        
        pilas.colisiones.agregar("proyectil","enemigo", self.impacto)
        
        
    def impacto(self, proyectil, enemigo):
        proyectil.eliminar()
        pilas.actores.Humo(proyectil.x, proyectil.y)
        print("IMPACTO")
        

    def actualizar(self):
        pass

class Escena_Menu(pilasengine.escenas.Escena):
    """ Escena del menú del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        pilas.fondos.Tarde()
        menu = pilas.actores.Menu(
        [
        (u'Iniciar Juego', self.iniciar_juego),
        (u'Salir', self.salir_del_juego),
        ]
        )

    def salir_del_juego(self):
        pilas.terminar()

    def iniciar_juego(self):
        pilas.escenas.Escena_Juego()


pilas.escenas.vincular(Escena_Menu)
pilas.escenas.vincular(Escena_Juego)

pilas.escenas.Escena_Menu()

PD: No hagas caso del mono y la definición de enemigos, son pruebas que estoy haciendo aunque aún sin éxito :smile:

Genial, muchas gracias, sigo probando que detecte como enemigo un tanque al otro

# -*- encoding: utf-8 -*-

import random
import pilasengine

pilas = pilasengine.iniciar()
pilas.reiniciar_si_cambia(__file__)

teclas2 = {
            pilas.simbolos.a: 'izquierda',
            pilas.simbolos.d: 'derecha',
            pilas.simbolos.w: 'arriba',
            pilas.simbolos.s: 'abajo',
            pilas.simbolos.CTRL: 'boton',
        }
        
class Municion1(pilasengine.actores.Actor):
	
	def iniciar(self):
		self.imagen="aceituna.png"
		
pilas.actores.vincular(Municion1)

class Tanque1(pilasengine.actores.Actor):

    def iniciar(self):
        self.aprender("LimitadoABordesDePantalla")
        self.aprender("PuedeExplotar")

    def actualizar(self):
        pass
        
pilas.actores.vincular(Tanque1)


class Tanque2(pilasengine.actores.Actor):

    def iniciar(self):
        self.aprender("LimitadoABordesDePantalla")
        self.aprender("PuedeExplotar")

    def actualizar(self):
        pass
        
pilas.actores.vincular(Tanque2)


class Escena_Juego(pilasengine.escenas.Escena):
    """ Escena principal del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        self.imagen = pilas.fondos.Pasto()

        tanque1= pilas.actores.Tanque1()
        tanque1.x = 200
        tanque1.imagen = "images/tanque.png"
        tanque1.rotacion = 90
        
        tanque1.aprender("MoverseComoCoche", velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)

        tanque1.aprender("Disparar", frecuencia_de_disparo=2, angulo_salida_disparo=90, municion='Municion1')
        tanque1_vidas = pilas.actores.Puntaje(x=250, y=200, color="blanco")
                
        mi_control = pilas.control.Control(teclas2)
        
        tanque2 = pilas.actores.Tanque2()
        tanque2.x = -200
        tanque2.imagen = "images/tanque2.png"
        tanque2.rotacion = 270
        tanque2.aprender("MoverseComoCoche", control=mi_control, velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)
        tanque2.aprender("Disparar", control=mi_control, frecuencia_de_disparo=2, angulo_salida_disparo=90)
        tanque2_vidas = pilas.actores.Puntaje(x=-250, y=200, color="blanco")
        
        pilas.colisiones.agregar("Municion1", "Tanque2", self.impacto)
        
        
    def impacto(self, proyectil, enemigo):
        proyectil.eliminar()
        pilas.actores.Humo(proyectil.x, proyectil.y)
        print("IMPACTO")
        

    def actualizar(self):
        pass

class Escena_Menu(pilasengine.escenas.Escena):
    """ Escena del menú del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        pilas.fondos.Tarde()
        menu = pilas.actores.Menu(
        [
        (u'Iniciar Juego', self.iniciar_juego),
        (u'Salir', self.salir_del_juego),
        ]
        )

    def salir_del_juego(self):
        pilas.terminar()

    def iniciar_juego(self):
        pilas.escenas.Escena_Juego()


pilas.escenas.vincular(Escena_Menu)
pilas.escenas.vincular(Escena_Juego)

pilas.escenas.Escena_Menu()


pilas.ejecutar()

Ahí te dejé un ejemplo en el que el tanque2 dispara un proyectil “aceituna” e impacta en el tanque1.

Fíjate que le he pasado el mi_control al tanque2, y que para mis pruebas el boton de disparo es CTRL y no ALTGR como usas tu.

Lo que veo es que en el juego original los tanques “soltaban” bombas que quedaban en el suelo, y en esta versión los tanques se disparan el uno al otro.

Creo que es mejor (y más claro para una persona que se inicie en Pilas-Engine) que cada tanque tenga definidas su propia clase y su propia munición, porque queda mucho más claro el tema de como se producen las colisiones.

Cualquier duda aquí estaré para intentar ayudarte en lo que pueda :wink:

Si lo mismo pienso, unas cuantas horas termino de actualizar este paso con las sugerencias que tienes, lo subo a github y proceso con los pasos siguientes, según veo este vídeojuego sirvió para una charla y/o taller por las diapositivas que existen (por ello el paso1.py, paso2.py, etc)

Una vez terminado el juego actualizo las diapositivas para que se puedan reutilizar en cualquier taller y/o charla siempre y cuando me lo permitan @quiqueporta y @fsalamero

1 Like

¡Por supuesto! En efecto, fue una charla/taller que dimos en la PyConES de Zaragoza, el 2014. Supongo que Quique también estará encantado del trabajo que estáis haciendo.
Un abrazo.

Genial, entonces a darle, ya estoy a un archivo de terminar la actualización, de hecho pido su colaboración 1 vez más.

En el archivo paso6b.py la los métodos aumentar_velocidad() y reducir_velocidad() no comprendo si esta bien la lógica, entiendo que se produce la colisión entre las estrellas (el tiempo es corto por pruebas) permite que aumente la velocidad del tanque que la atrape a 4 y una que otra le reduce la velocidad a 2.

Sin embargo esta funcionando bien pero parece que uno de los métodos (reducir_velocidad) lo estoy comprendiendo mal.

El error debe estar en una de estas lineas de código

Sugerencias???

La actualización esta en el mismo repositorio

Sí, en la línea 157 (de la captura de código que has enviado) quita los corchetes entorno a tanque, que en esta versión es innecesario y no deja acceder luego al tanque; por eso te da el error de que el objeto lista no tiene atributo aprender,

Buenas, @Statick !

Que bueno ver cómo avanza este proyecto :smile:!

A ver si entre esta noche y mañana le puedo echar un vistazo a fondo, porque a primera prueba veo algunas cosas que no me acaban de convencer, por ejemplo que el tanque 2 pierde el mi_control al tocar una estrella. Tampoco acabo de ver claro que se cree una colisión cada vez que se cree una estrella… me parece mejor declarar dos colisiones, una para cada tanque, en la class iniciar de la escena y usando etiquetas:

pilas.colisiones.agregar(“Tanque1”, “Estrella”, self.ganar_velocidad)
pilas.colisiones.agregar(“Tanque2”, “Estrella”, self.ganar_velocidad)

En mis pruebas voy a intentar que las funciones para aumentar y perder velocidad sean propias de cada class tanque y no de la escena, porque esto lleva a un tanto de confusión (sobre a qué tanque hay que aplicarle el cambio). De paso así liberaríamos a la escena_juego de esa sobrecarga de funciones, a mi parecer un tanto confusa para los principiantes…

En cuanto tenga algo más conciso y que funcione minimamente bien te expongo el código :blush:

Un abrazo y gracias por este gran trabajo!

Mi mujer me va a matar por que en vez de limpiar la casa me he estado dedicando a esto, pero ahí pude hacerte unos cuantos remiendos… :smile:

He usado como base el fichero “paso6b.py”

Aún veo algún pequeño fallo (al ganar el verde no se activa el efecto_ganador) pero creo que ya tú podrás pulirlo para que quede perfecto. Tambien en vez de que cada vez tenga que “aprender” a “moverse como coche” se podría crear una función en la def actualizar para variar la velocidad de movimiento, pero creo que de de momento y como tema introductorio para personas sin conocimientos previos de pilas-engine queda mucho más claro de entender de esta manera.

Espero que te sirva!!! :wink:

# -*- encoding: utf-8 -*-

import random
import pilasengine

pilas = pilasengine.iniciar()
pilas.reiniciar_si_cambia(__file__)

teclas2 = {
            pilas.simbolos.a: 'izquierda',
            pilas.simbolos.d: 'derecha',
            pilas.simbolos.w: 'arriba',
            pilas.simbolos.s: 'abajo',
            pilas.simbolos.CTRL: 'boton',
        }

class Municion1(pilasengine.actores.Actor):

	def iniciar(self):
		self.imagen=pilas.imagenes.cargar_grilla("disparo.png", 2)

class Municion2(pilasengine.actores.Actor):

	def iniciar(self):
		self.imagen=pilas.imagenes.cargar_grilla("disparo.png", 2)

class Tanque1(pilasengine.actores.Actor):

    def iniciar(self):
        self.aprender("LimitadoABordesDePantalla")
        self.aprender("PuedeExplotar")
        #x = random.randrange(-320, 320)
        y = random.randrange(-240, 160)
        #self.x = x
        self.y = y
        
        self.imagen = "images/tanque.png"
        self.rotacion = 90
        self.aprender("MoverseComoCoche", velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)
        self.aprender("Disparar", frecuencia_de_disparo=2, angulo_salida_disparo=90, municion='Municion1')

    def aumentar_velocidad(self):
		self.aprender("MoverseComoCoche", velocidad_maxima=8, deceleracion=0.05, velocidad_rotacion=0.5)		
    
    def reducir_velocidad(self):
		self.aprender("MoverseComoCoche", velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)
    
    def actualizar(self):
        pass


class Tanque2(pilasengine.actores.Actor):
	
	def iniciar(self):
		self.mi_control = pilas.control.Control(teclas2)
		self.aprender("LimitadoABordesDePantalla")
		self.aprender("PuedeExplotar")
		self.y = random.randrange(-240, 160)
		self.imagen = "images/tanque2.png"
		self.rotacion = 270
		self.aprender("MoverseComoCoche", control=self.mi_control, velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)
		self.aprender("Disparar", control=self.mi_control, frecuencia_de_disparo=2, angulo_salida_disparo=90, municion='Municion2')
        
	def aumentar_velocidad(self):
		self.aprender("MoverseComoCoche", control= self.mi_control, velocidad_maxima=4, deceleracion=0.05, velocidad_rotacion=0.5)
	
	def reducir_velocidad(self):
		self.aprender("MoverseComoCoche", control= self.mi_control, velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)
    
	def actualizar(self):
		pass



class Escena_Juego(pilasengine.escenas.Escena):
    """ Escena principal del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        self.imagen = pilas.fondos.Pasto()

        tanque1= pilas.actores.Tanque1()
        self.tanque1 = tanque1
        tanque1.x = 200

        texto_t1 = pilas.actores.Texto("Rojo:", x=-250, y=200)
        texto_t1.definir_color(pilas.colores.blanco)
        vidas1 = pilas.actores.Puntaje(x=-210, y=200)
        vidas1.aumentar("3")
        self.vidas1 = vidas1

        #mi_control = pilas.control.Control(teclas2)

        tanque2 = pilas.actores.Tanque2()
        self.tanque2 = tanque2
        tanque2.x = -200
        #cambiado a la def iniciar de la class Tanque

        texto_t2 = pilas.actores.Texto("Verde:", x=210, y=200)
        texto_t2.definir_color(pilas.colores.blanco)
        vidas2 = pilas.actores.Puntaje(x=260, y=200)
        vidas2.aumentar("3")
        self.vidas2 = vidas2

        pilas.colisiones.agregar("Municion1", "Tanque2", self.impacto1)
        pilas.colisiones.agregar("Municion2", "Tanque1", self.impacto2)

        
        ###colisiones entre tanques y estrellas cambiadas aquí###
        pilas.colisiones.agregar("Tanque1", "Estrella", self._aumentar_velocidad)
        pilas.colisiones.agregar("Tanque2", "Estrella", self._aumentar_velocidad)
        
        tarea_estrella = pilas.tareas.siempre(3, self.crear_estrella)
        
        
        

    def crear_tanque1(self):
        tanque1= pilas.actores.Tanque1()
        tanque1.x = 200
        ###Trasladado a la def iniciar de la class Tanque1###

    def crear_tanque2(self):
        #mi_control = pilas.control.Control(teclas2)
        tanque2 = pilas.actores.Tanque2()
        tanque2.x = -200
        #tanque2.imagen = "images/tanque2.png"
        #tanque2.rotacion = 270
        #tanque2.aprender("MoverseComoCoche", control=mi_control, velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)
        #tanque2.aprender("Disparar", control=mi_control, frecuencia_de_disparo=2, angulo_salida_disparo=90, municion='Municion2')

    def impacto1(self, proyectil1, enemigo1):
        proyectil1.eliminar()
        pilas.actores.Humo(proyectil1.x, proyectil1.y)
        enemigo1.eliminar()
        if self.vidas1.obtener() > 0:
            self.vidas1.reducir()
            self.crear_tanque2()
        if self.vidas1.obtener() == 0:
            self.tanque2.eliminar()
            self.efecto_ganador(self.tanque1)


    def impacto2(self, proyectil2, enemigo2):
        proyectil2.eliminar()
        pilas.actores.Humo(proyectil2.x, proyectil2.y)
        enemigo2.eliminar()
        if self.vidas2.obtener() > 0:
            self.vidas2.reducir()
            self.crear_tanque1()
        if self.vidas2.obtener() == 0:
            self.tanque1.eliminar()
            self.efecto_ganador(self.tanque2)

    def efecto_ganador(self, ganador):
        ganador.x = [0]
        ganador.y = [0]
        ganador.escala = [3]
        ganador.rotacion = [360]

    def crear_estrella(self):
        x = random.randrange(-320, 320)
        y = random.randrange(-240, 240)
        estrella = pilas.actores.Estrella(x, y)
        estrella.escala = 0.4
        
        ###cambiada a la def iniciar de la escena###
        """self.colisiones.agregar(
        [self.tanque1, self.tanque2],
        estrella,
        self.aumentar_velocidad)"""
        #############################################

    def _aumentar_velocidad(self, tanque, estrella):
        estrella.eliminar()
        tanque.aumentar_velocidad()
        #tanque.aprender("MoverseComoCoche", velocidad_maxima=4)
        pilas.tareas.agregar(5, tanque.reducir_velocidad)
	
	#def reducir_velocidad cambiada a cada una de las class Tanque
		
    def actualizar(self):
        pass

class Escena_Menu(pilasengine.escenas.Escena):
    """ Escena del menú del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        pilas.fondos.Tarde()
        menu = pilas.actores.Menu(
        [
        (u'Iniciar Juego', self.iniciar_juego),
        (u'Salir', self.salir_del_juego),
        ]
        )

    def salir_del_juego(self):
        pilas.terminar()

    def iniciar_juego(self):
        pilas.escenas.Escena_Juego()


pilas.escenas.vincular(Escena_Menu)
pilas.escenas.vincular(Escena_Juego)

pilas.actores.vincular(Municion1)
pilas.actores.vincular(Municion2)
pilas.actores.vincular(Tanque1)
pilas.actores.vincular(Tanque2)

pilas.escenas.Escena_Menu()


pilas.ejecutar()

Jajaja que gracioso, pude corregir lo del control cuando se colisiona con la estrella mediante una sentencia verificando si es tanque2 asignando el control respectivo.

def _aumentar_velocidad(self, tanque, estrella):
    tanque.aumentar_velocidad()
    #tanque.aprender("MoverseComoCoche", velocidad_maxima=4)
    pilas.tareas.agregar(5, tanque.reducir_velocidad)
    estrella.eliminar()
    if tanque == self.tanque2:
        self.tanque.mi_control= self.mi_control

Pero no se elimina el Tanque Rojo cuando se asigna el efecto_ganador(), sin embargo con pilas.avisar(“texto”) puedo comprobar que si ingresa a la sentencia

A ratos ingresa y a ratos no ¿raro?

Subido el cambio de mi_control a github

Ummm… si estás usando mi último código realmente no necesitas esa sentencia, ya que en las def aumentar y disminuir del tanque2 ya se incluye el mi_control…

Voy a darle un vistazo a ese tema del ganador, ya que es realmente raro lo que dices que a veces entra y a veces no :cold_sweat:

Bueno, varios cambios:

Lo principal es sacar del if el " vidas.reducir ", por que sino había que matar 4 veces al otro tanque, pero a la tercera muerte se detectaba que las vidas eran 0 y se activava la def efecto_ganador.

Para mí ahora está bien y funciona correctamente… échale un vistazo a ver si el código te convence :slight_smile:

Un abrazo.

# -*- encoding: utf-8 -*-

import random
import pilasengine

pilas = pilasengine.iniciar()
pilas.reiniciar_si_cambia(__file__)

teclas2 = {
            pilas.simbolos.a: 'izquierda',
            pilas.simbolos.d: 'derecha',
            pilas.simbolos.w: 'arriba',
            pilas.simbolos.s: 'abajo',
            pilas.simbolos.CTRL: 'boton',
        }

class Municion1(pilasengine.actores.Actor):

	def iniciar(self):
		self.imagen=pilas.imagenes.cargar_grilla("disparo.png", 2)

class Municion2(pilasengine.actores.Actor):

	def iniciar(self):
		self.imagen=pilas.imagenes.cargar_grilla("disparo.png", 2)

class Tanque1(pilasengine.actores.Actor):

    def iniciar(self):
        self.aprender("LimitadoABordesDePantalla")
        self.aprender("PuedeExplotar")
        #x = random.randrange(-320, 320)
        y = random.randrange(-240, 160)
        #self.x = x
        self.y = y

        self.imagen = "images/tanque.png"
        self.rotacion = 90
        self.aprender("MoverseComoCoche", velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)
        self.aprender("Disparar", frecuencia_de_disparo=2, angulo_salida_disparo=90, municion='Municion1')

    def aumentar_velocidad(self):
		self.aprender("MoverseComoCoche", velocidad_maxima=8, deceleracion=0.05, velocidad_rotacion=0.5)

    def reducir_velocidad(self):
		self.aprender("MoverseComoCoche", velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)

    def actualizar(self):
        pass


class Tanque2(pilasengine.actores.Actor):

	def iniciar(self): 

		self.mi_control = pilas.control.Control(teclas2)
		self.aprender("LimitadoABordesDePantalla")
		self.aprender("PuedeExplotar")
		self.y = random.randrange(-240, 160)
		self.imagen = "images/tanque2.png"
		self.rotacion = 270
		self.aprender("MoverseComoCoche", control=self.mi_control, velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)
		self.aprender("Disparar", control=self.mi_control, frecuencia_de_disparo=2, angulo_salida_disparo=90, municion='Municion2')

	def aumentar_velocidad(self):
		self.aprender("MoverseComoCoche", control= self.mi_control, velocidad_maxima=8, deceleracion=0.05, velocidad_rotacion=0.5)

	def reducir_velocidad(self):
		self.aprender("MoverseComoCoche", control= self.mi_control, velocidad_maxima=2, deceleracion=0.05, velocidad_rotacion=0.5)

	def actualizar(self):
		pass



class Escena_Juego(pilasengine.escenas.Escena):
    """ Escena principal del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        self.imagen = pilas.fondos.Pasto()

        tanque1= pilas.actores.Tanque1()
        self.tanque1 = tanque1
        tanque1.x = 200

        texto_t1 = pilas.actores.Texto("Rojo:", x=-250, y=200)
        texto_t1.definir_color(pilas.colores.blanco)
        vidas1 = pilas.actores.Puntaje(x=-210, y=200)
        vidas1.aumentar("3")
        self.vidas1 = vidas1

        tanque2 = pilas.actores.Tanque2()
        self.tanque2 = tanque2
        tanque2.x = -200

        texto_t2 = pilas.actores.Texto("Verde:", x=210, y=200)
        texto_t2.definir_color(pilas.colores.blanco)
        vidas2 = pilas.actores.Puntaje(x=260, y=200)
        vidas2.aumentar("3")
        self.vidas2 = vidas2

        pilas.colisiones.agregar("Municion1", "Tanque2", self.impacto1)
        pilas.colisiones.agregar("Municion2", "Tanque1", self.impacto2)


        ###colisiones entre tanques y estrellas cambiadas aquí###
        pilas.colisiones.agregar("Tanque1", "Estrella", self._aumentar_velocidad)
        pilas.colisiones.agregar("Tanque2", "Estrella", self._aumentar_velocidad)

        self.tarea_estrella = pilas.tareas.siempre(3, self.crear_estrella)




    def crear_tanque1(self):

        tanque1= pilas.actores.Tanque1()
        tanque1.x = 200

    def crear_tanque2(self):

        tanque2 = pilas.actores.Tanque2()
        tanque2.x = -200

    def impacto1(self, proyectil1, enemigo1):
        proyectil1.eliminar()
        pilas.actores.Humo(proyectil1.x, proyectil1.y)
        enemigo1.eliminar()
        
        self.vidas1.reducir()
        
        if self.vidas1.obtener() > 0:
            #self.vidas1.reducir()
            self.crear_tanque2()
        elif self.vidas1.obtener() == 0:
            self.efecto_ganador(self.tanque1)
            #self.tanque2.eliminar()
        

    def impacto2(self, proyectil2, enemigo2):
        proyectil2.eliminar()
        pilas.actores.Humo(proyectil2.x, proyectil2.y)
        enemigo2.eliminar()
        
        self.vidas2.reducir()
        
        if self.vidas2.obtener() > 0:
            #self.vidas2.reducir()
            self.crear_tanque1()
        elif self.vidas2.obtener() == 0:
            self.efecto_ganador(self.tanque2)
            #self.tanque1.eliminar()

    def efecto_ganador(self, ganador):

        ganador.x = [0]
        ganador.y = [0]
        ganador.escala = [3]
        ganador.rotacion = [360]

    def crear_estrella(self):
        x = random.randrange(-320, 320)
        y = random.randrange(-240, 240)
        estrella = pilas.actores.Estrella(x, y)
        estrella.escala = 0.4

    def _aumentar_velocidad(self, tanque, estrella):
        tanque.aumentar_velocidad()
        #tanque.aprender("MoverseComoCoche", velocidad_maxima=4)
        pilas.tareas.agregar(5, tanque.reducir_velocidad)
        estrella.eliminar()

    def actualizar(self):
        pass

class Escena_Menu(pilasengine.escenas.Escena):
    """ Escena del menú del juego. """

    def iniciar(self):
        # Cargamos el fondo del juego.
        pilas.fondos.Tarde()
        menu = pilas.actores.Menu(
        [
        (u'Iniciar Juego', self.iniciar_juego),
        (u'Salir', self.salir_del_juego),
        ]
        )

    def salir_del_juego(self):
        pilas.terminar()

    def iniciar_juego(self):
        pilas.escenas.Escena_Juego()


pilas.escenas.vincular(Escena_Menu)
pilas.escenas.vincular(Escena_Juego)

pilas.actores.vincular(Municion1)
pilas.actores.vincular(Municion2)
pilas.actores.vincular(Tanque1)
pilas.actores.vincular(Tanque2)

pilas.escenas.Escena_Menu()


pilas.ejecutar()

EDITO PARA AÑADIR:

Habría que finalizar la tarea de creación de estrellas al acabar el juego con self.tarea_estrella.terminar() tanto en impacto1 como en impacto2:

def impacto1(self, proyectil1, enemigo1):
        proyectil1.eliminar()
        pilas.actores.Humo(proyectil1.x, proyectil1.y)
        enemigo1.eliminar()
        
        self.vidas1.reducir()
        
        if self.vidas1.obtener() > 0:
            #self.vidas1.reducir()
            self.crear_tanque2()
        elif self.vidas1.obtener() == 0:

            self.tarea_estrella.terminar()# terminamos la tarea crear estrellas

            self.efecto_ganador(self.tanque1)
            #self.tanque2.eliminar()

Creo que así queda mejor, voy a ver si consigo algunos sonidos y efectos para mejorar un poco la versión del videojuego y me meto con las diapositivas

Muchas gracias por el apoyo @jordinur

1 Like