Ayuda ejercicios unidad 22: Juegos

Ejercicio 1: Proyectiles

  1. Abre el archivo arma.fla que encontrarás en la carpeta ejercicios/arma del curso.
  2. Selecciona el objeto arma de la Biblioteca, haz clic derecho sobre él y selecciona Propiedades
  3. Si no se ven todas las propiedades, pulsa en Avanzadas.
  4. Activa la opción Exportar para ActionScript.
  5. En Clase, dale el nombre Arma y pulsa Aceptar.
  6. Nos aparecerá un mensaje de aviso, pulsamso Aceptar.
  7. Selecciona el objeto bloque de la Biblioteca, haz clic derecho sobre él y seleccionaPropiedades.
  8. Activa la opción Exportar para ActionScript, dale la clase Bloque y pulsa Aceptar.
  9. Selecciona el objeto bonus de la Biblioteca, haz clic derecho sobre él y selecciona Propiedades.
  10. Activa la opción Exportar para ActionScript, dale la clase BloqueBonus y pulsa Aceptar.
  11. Selecciona el objeto cursor de la Biblioteca, haz clic derecho sobre él y selecciona Propiedades.
  12. Activa la opción Exportar para ActionScript, dale la clase Cursor y pulsa Aceptar.
  13. Selecciona el objeto proyectil1 de la Biblioteca, haz clic derecho sobre él y selecciona Propiedades.
  14. Activa la opción Exportar para ActionScript, dale la clase Proyectil1 y pulsa Aceptar.
  15. Selecciona el objeto proyectil2 de la Biblioteca, haz clic derecho sobre él y seleccionaPropiedades.
  16. Activa la opción Exportar para ActionScript, dale la clase Proyectil2 y pulsa Aceptar.
  17. Selecciona el objeto proyectil3 de la Biblioteca, haz clic derecho sobre él y seleccionaPropiedades.
  18. Activa la opción Exportar para ActionScript, dale la clase Proyectil3 y pulsa Aceptar.
  19. Selecciona el objeto rayo de la Biblioteca, haz clic derecho sobre él y selecciona Propiedades.
  20. Activa la opción Exportar para ActionScript, dale la clase Disparo y pulsa Aceptar.

    Ahora que hemos preparado todos los objetos para poder tratarlos desde ActionScript pasaremos a escribir el código.
    Lo primero que haremos serla crear las clases que utilizaremos, en archivos ActionScript.
  21. Haz clic en el menú ArchivoNuevo, selecciona Archivo ActionScript y pulsa Aceptar.
  22. Se abre un archivo en blanco. Escribe el siguiente código para crear la clase que tendrá los métodos para los disparos:
    package 
    { //Importamos las clases necesarias
    import flash.display.MovieClip;
    import flash.display.DisplayObject;
    //Y creamos nuestra clase como una subclacse (extends) de MovieClip,
    //para que disponga de sus métodos

    public class Disparo extends flash.display.MovieClip
    {
    public function disparar(arma:Arma){
    //Este método asigna al disparo la rotación y posición del arma que lo disparará
    this.rotation= arma.rotation;
    this.x=arma.x;
    this.y=arma.y;
    }
    public function avanzar (){
    //Este método mueve el disparo por la pantalla, con el ángulo de rotación
    var radianes:Number = Math.PI/180*this.rotation;
    this.x += Math.sin(radianes)*13;
    this.y -= Math.cos(radianes)*13;
    }
    public function esta_dentro (alto:Number, ancho:Number){
    //Este método indica si el disparo sigue dentro de la pantalla,
    //Si no se ha salido ni por arriba, ni abajo, ni por la izquierda o derecha

    return !(this.x < 0 || this.y < 0 || this.x > ancho || this.y > alto)
    }
    }
    }
  23. Guarda el archivo junto a arma.fla, llamándolo Disparo.as. Es importante que el nombre sea el de la clase.
  24. Crea otro nuevo archivo ActionScript para la clase que llevará los métodos y propiedades de los proyectiles.
  25. Escribe el siguiente código:
    package
    
    {	//Importamos las clases necesarias
    
    	import flash.display.MovieClip;
    
    	import flash.display.DisplayObject;
    
    	//Y creamos nuestra clase como una subclase (extends) de MovieClip, para que disponga de sus métodos
    
    	public class Proyectil extends flash.display.MovieClip
    
    	{
    
    		private static var velocidad_base:Number = 3; //Velocidad base de los proyectiles
    
    		private  var velocidad:Number; // Velocidad del proyectil
    
    		private var _explotando:Boolean = false; //Indica si ha comenzado a explotar
    
    		
    
    		public function disparar(nivel:Number, ancho:Number, alto:Number){
    
    			//Le pasamos como argumentos el nivel actual del juego, y el ancho y alto del área de disparo
    
    			//Crearemos, para cada tipo de proyectil, tres escalas posibles, de forma aleatoria.
    
    			var escala:Number = num_aleatorio(0, 2); //escala influirá en el tamaño y la velocidad
    
    			//Calculamos la velocidad, sumando la velocidad base + la parte que depende del nivel + la
    
    			// que depende de la escala
    
    			velocidad = velocidad_base+nivel*1.5+(2-escala);
    
    			//calculamos el nuevo tamaño en función de la escala (0 = tamaño original, 2= 80%)
    
    			this.width = this.width*((10-escala)/10);
    
    			this.height =  this.height*((10-escala)/10);
    
    			//Calcualmos, de forma aleatoria el punto de salida del proyectil en la parte superior
    
    			//Dejamos la mitad del ancho del proyectil como margen para que no salga una parte fuera de la pantalla
    
    			var puntoSalida:Number = num_aleatorio(this.width/2, ancho-this.width/2); //Zona de salida
    
    			//Asignamos al proyectil su posición inicial
    
    			this.x=puntoSalida;
    
    			this.y = 0;
    
    			//Calculamos, de forma aleatoria, el punto de impacto. Limitamos la zona de posible impacto, dejando
    
    			//1/4 del ancho de margen a cada lado, para que la mayoría de proyectiles vayan hacia el arma
    
    			var puntoImpacto:Number = num_aleatorio(ancho*(1/4), ancho*(3/4));
    
    			//Sabiendo las coordenadas de salida e impacto, podemos utilizar calcular el ángulo con Math.atan2
    
    			//Como el resultado es en radianes, lo convertimos a grados (radianes*180/Math.Pi)
    
    			//Esos grados son la rotación que daremos al objeto
    
    			this.rotation= 270+(Math.atan2( alto - this.y,puntoImpacto- puntoSalida) * 180/Math.PI);
    
    		}
    
    		
    
    		public function avanzar (){
    
    			//Este método avanza el proyectil por la pantalla
    
    			//Convertimos el ángulo de rotación a radianes
    
    			var radianes:Number = Math.PI/180*this.rotation;
    
    			//Y ayudándosnos de fórmulas triginométricas, sumamos la velocidad la posición
    
    			this.x -= Math.sin(radianes)*(velocidad);
    
    			this.y += Math.cos(radianes)*(velocidad);
    
    		}
    
    		
    
    		public function esta_dentro (alto:Number){
    
    		//averiguaremos si el proyectil sigue de la pantalla, si no ha llegado abajo
    
    			return (this.y < alto);
    
    		}		
    
    		public function explotar (){
    
    			//Este método reproduce la animación de la explosión del proyectil
    
    			if (!_explotando){
    
    			this.gotoAndPlay("hit");
    
    			//Cuando comienza a explotar, cambia _explotando
    
    			_explotando = true;
    
    			}
    
    		}		
    
    		public function explotando():Boolean{
    
    			//Devuelve True si el proyectil está explotando
    
    			return _explotando;
    
    		}		
    
    		private function num_aleatorio (min:Number ,max:Number){
    
    		//Genera un númeor aleatorio dentro de un rango
    
    			max++;
    
    			max = max-min;
    
    			return min+(Math.floor((Math.random()*(max*10)))%max);
    
    		}
    
    	}
    
    }
  26. Guarda el archivo llamándolo Proyectil.as, en la misma carpeta que arma.fla y Disparo.as.
  27. En la biblioteca tenemos tres tipos de proyectil, proyectil1, proyectil2 y proyectil3, cada uno con una clase distinta. Vamos a hacer que todos compartan los métodos de la clase Disparo. Para ello, accede a sus Propiedades haciendo clic derecho sobre proyectil1.
  28. En el campo Clase base, cambia flash.display.MovieClip por Disparo y pulsa Aceptar.
     
  29. Vamos a comenzar con el primer fotograma. En la capa fondo, selecciona el botón jugar, y en el panel de Propiedades dale btn_jugar como Nombre de instancia.
  30. Haz clic sobre el primer fotograma de la capa acciones y abre el Panel Acciones (tecla F9).
  31. Escribe el siguiente evento para que al pulsar el botón, comience la partida:
    stop()
    
    
    
    btn_jugar.addEventListener(MouseEvent.MOUSE_UP,empezar);
    
    function empezar(event:MouseEvent):void{
    
    	gotoAndStop("jugar");
    
    }
  32. Haz clic sobre el primer fotograma de la capa acciones y abre el Panel Acciones.
  33. Escribe el siguiente bloque de código para inicializar las variables que utilizaremos y declarar los objetos generales:
    //Parámetros generales del juego
    
    var hits:Number = 0; //Impactos, proyectiles destruidos
    
    var level:Number = 1; // Nivel
    
    var num_bonus:Number = 4; //Cada cuantos hits aparece el bonus
    
    var num_bloques:Number = 12; //número de bloques iniciales
    
    var numRayos:Number = 0; // número de rayos disparados
    
    var maxRayos:Number = 3; //Número máximo de rayos a la vez
    
    var fingame:Boolean = false; //Indica si ha acabado el juego
    
    
    
    var alto:Number = 580; //Alto del área de juego
    
    var ancho:Number = 550; //Ancho del área de juego
    
    
    
    //Objetos generales
    
    var arma:Arma = new Arma; // arma (objeto de la calse Arma)
    
    var cursor:Cursor = new Cursor; //movieClip que se mostrará como cursor
    
    
    
    var zonaJuego:Sprite = new Sprite; //Contenedor en que mostraremos
    
    									                 //Los elementos del juego
  34. Escribe el siguiente bloque de código para crear la función que inicia el proceso:
    function comenzarPartida() { //Función que comienza la partida
    
    	Mouse.hide(); //Ocultamos el cursor
    
    	zonaJuego.addChild(cursor);
    
    	cursor.addEventListener(Event.ENTER_FRAME,seguirCursor);
    
    	//Cada vez que cursor entre en un frame, hacemos que siga al ratón
    
    
    
    	//Añadimos los objetos:
    
    	//Añadimos los bloques iniciales
    
    	//Lo hacemos los primeros para que queden por debajo del resto
    
    	bloques_iniciales(); 
    
    	//Asignamos la posición inical al arma y la generamos.
    
    	arma.x = ancho/2;
    
    	arma.y = alto-30;
    
    	zonaJuego.addChild(arma);
    
    	//Hacemos que cada vez que se mueva el cursor, el arpa apunte hacia él
    
    	addEventListener(MouseEvent.MOUSE_MOVE,apuntarCursor);
    
    		
    
    	//Agragamos a la escena el evnto que disparará cunado se pulse espacio
    
    	stage.addEventListener(KeyboardEvent.KEY_DOWN,disparar);
    
    	
    
    	//E iniciamos el lanzamiento de proyectiles
    
    	zonaJuego.addEventListener(Event.ENTER_FRAME,lanzarProyectil);
    
    	//Utilizamos el evento Enter_Frame para que se repita constantemente
    
    	
    
    	//Añadimos el contenedor en el que se mostrarán los elementos de la partida.
    
    	//Lo hacemos en la posición 1 para que quede enciam del fondo, pero debajo
    
    	//de la banda superior.
    
    	this.addChildAt(zonaJuego, 1);
    
    	
    
    	//Actualizamos las estadísticas para que se muestre el marcador a 0
    
    	actualizarEstadisticas();
    
    }
  35. Hemos asignado a ciertos eventos las funciones seguirCursor, y apuntarCursor, que harán que el cursor siga al ratón y que el arma apunte al cursor. Las definimos con este bloque de código:
    function seguirCursor(event):void{ 
    
    	cursor.x=mouseX; //Nuestro cursor toma las coordenadas del ratón
    
    	cursor.y=mouseY;
    
    }
    
    function apuntarCursor(event:MouseEvent):void{
    
    	//Calcula el ángulo de rotación del arma para que apunte al cursor
    
    	var xdif:Number = mouseX - arma.x;
    
    	var ydif:Number = mouseY - arma.y;
    
        var radianes:Number = Math.atan2(ydif, xdif);
    
    	//El resultado obtenido es en radianes. Lo convertimos a grados
    
    	var angulo:Number = radianes*180/Math.PI;
    
    	angulo = angulo + 90;
    
    	arma.rotation = angulo;
    
    }
  36. Definimos la función que crea los bloques iniciales (bloques_iniciales(). Y de paso, por tener el código ordenado, creamos también las que tratan los bloques bonus. Escribe el siguiente código:
    //Bloques
    
    function añadir_bloque (x:Number, y:Number):void {	
    
    		//Crea un nuevo bloque en las coordenadas dadas
    
    		var bloque:Bloque = new Bloque;
    
    		bloque.x = x;
    
    		bloque.y = y;
    
    		zonaJuego.addChild(bloque);
    
    }
    
    	
    
    function bloques_iniciales ():void{
    
    	//Genera los bloques iniciales
    
    	var x:Number;
    
    	var y:Number;
    
    	for (var i:Number =0; i<num_bloques; i++) {
    
    		x =0; //calculamos x
    
    		y =0; //calculamos y
    
    		if (i<3) {
    
    			y = 550;
    
    			x = i*50+200;
    
    		} else if (i<7) {
    
    			y = 525;
    
    			x = (i-3)*50+175;
    
    		} else if (i<10) {
    
    			y = 500;
    
    			x = (i-7)*50+200;
    
    		} else if (i<=11) {
    
    			y = 475;
    
    			x = (i-10)*50+225;
    
    		} //Y lo añadimos
    
    		añadir_bloque(x, y);
    
    	}
    
    }
    
    
    
    function bonus() {
    
    	//Crea un bloque Bonus en la esquina inferior izquierda de la pantalla
    
    	var bloque:BloqueBonus = new BloqueBonus;
    
    	bloque.x = 0;
    
    	bloque.y = 550;
    
    	bloque.addEventListener(MouseEvent.MOUSE_DOWN, arrastrar);
    
    	bloque.addEventListener(MouseEvent.MOUSE_UP, soltar);	
    
    	zonaJuego.addChildAt(bloque,zonaJuego.getChildIndex(arma));
    
    }
    
    
    
    function arrastrar(event:Event):void {
    
    	//Al hacer clic sobre un BloqueBonus, comenzamos a arrastralo
    
    	event.target.startDrag()
    
    }
    
    
    
    function soltar(event:Event):void {
    
    	//Al soltar el botón del ratón del BloqueBonus que estamos arrastrando
    
    	var bloque:BloqueBonus = BloqueBonus(event.target);
    
    	//Dejamos de arrastrar
    
    	bloque.stopDrag()
    
    	//Y corregimos su posición para que queden alineados
    
    	var correccion_par:Number = 0;	
    
    	if (bloque.y<487) {
    
    		bloque.y = 475;
    
    		correccion_par = 25;
    
    	} else if (bloque.y<=512) {
    
    		bloque.y = 500;
    
    	} else if (bloque.y<=538) {
    
    		bloque.y = 525;
    
    		correccion_par = 25;
    
    	} else {
    
    		bloque.y = 550;
    
    	}
    
    	var aux_coc:Number = Math.round(bloque.x/50);
    
    
    
    	bloque.x = aux_coc*50-correccion_par;	
    
    }
    
    
    
    function quitar_bloqueBonus (bloque:BloqueBonus) {
    
      //Quita los eventos del bloque bonus
    
    	bloque.removeEventListener(MouseEvent.MOUSE_DOWN, arrastrar);
    
    	bloque.removeEventListener(MouseEvent.MOUSE_UP, soltar);
    
    	if(contains(bloque)) { //Y lo quita
    
    		zonaJuego.removeChild(bloque);
    
    	}
    
    }
  37. Escribe la función que actualizará las estadísticas :
    //Estadísticas
    
    function actualizarEstadisticas(){ 
    
    	if (hits>0) {
    
    		if ((hits%40) == 0) {
    
    			level++; //aumentamos el nivel cada 40 aciertos
    
    		}
    
    		if ((hits%num_bonus) == 0) {
    
    			bonus(); //Creamos un bloque cada num_bonus aciertos
    
    		}
    
    	}
    
    	//Actualizamos el marcador de estadísticas
    
    	estadisticas_txt.text="Aciertos: "+hits+"\t"+"Nivel:"+level;
    
    }
  38. Ahora escribe el código que nos permitirá disparar el arma, mover el disparo y quitarlo cuando sea necesario.
    //DISPAROS DEL ARMA
    
    function disparar(tecla:KeyboardEvent):void{
    
    	//El evento capturado se produce al pulsar el teclado (cualquier tecla)
    
    	if (tecla.keyCode == Keyboard.SPACE) { //Comprobamos si la tecla es Espacio
    
    		if (numRayos < maxRayos) {//Si no hemos alcanzado el número max. de rayos
    
    			var miRayo:Disparo = new Disparo; //Creamos un Disparo
    
    			miRayo.disparar(arma); //Lo disparamos
    
    			//Y lo añdimos a nuestro contenedor, para que se muestre
    
    			zonaJuego.addChildAt(miRayo, zonaJuego.getChildIndex(arma));
    
    			numRayos++; //Aumentamos el número de rayos disparados
    
    			//Y en el evento ENTER_FRAME del rayo le asignamos la función que lo moverá	
    
    			miRayo.addEventListener(Event.ENTER_FRAME, mover_disparo);
    
    		}
    
    	}
    
    }
    
    function mover_disparo(event:Event):void{
    
    	//Esta función se encarga de desplazar el rayo por la pantalla
    
    	//event.target es el objeto que ha producido el evento que llama a esta función
    
    	//Lo convertimos a un objeto Disparo para tratarlo como tal
    
    	var rayo:Disparo = Disparo(event.target);
    
    	//Comprobamos, con el método esta_dentro(), si sique en la pantalla
    
    	if (rayo.esta_dentro(alto,ancho)){
    
    		//Si está dentro, lo movemos
    
    		rayo.avanzar();
    
    	} else {
    
    		//Si no, ha salido de la pantalla. Lo borramos con quitar_disparo();
    
    		quitar_disparo(rayo);
    
    	}
    
    }
    
    function quitar_disparo (disparo:Disparo){
    
    	//Esta función elimina el Disparo que le pasemos como argumento
    
    	//Quitamos sus eventos
    
    	disparo.removeEventListener(Event.ENTER_FRAME, mover_disparo);
    
    	//Comprobamos que no se haya borrado ya, para evitar posibles errores
    
    	if (zonaJuego.contains(disparo)) { 
    
    		zonaJuego.removeChild(disparo); //Y lo eliminamos de su contenedor
    
    		numRayos--; //Restamos 1 al número de rayos disparados
    
    	}
    
    }
  39. Ahora, escribe el código que lanzará de forma aleatoria los proyectiles. Recuerda que llamábamos a esta función en el evento ENTER_FRAME del contenedor de los elementos del juego:
     //PROYECTILES
    
    function num_aleatorio (min:Number ,max:Number){
    
     //Esta función genera un número aleatorio dentro de un rango
    
    	return (Math.floor(Math.random()*(max-min+1))+min);
    
    }
    
    
    
    function lanzarProyectil(event):void{ 
    
    	//Se ejecuta en el evento ENTER_FRAME de zonaJuego.
    
    	// Comprobamos que el juego no haya acabado ya
    
    	if (!fingame){ //Si no ha acabado
    
    		//No vamos a lanzar un proyectil cada vez, serían demadiados
    
    		//Generamos un número aleatorio entre 0 y 20, y disparamos sólo cuando sea 0
    
    		//Así los proyectiles apareceran de forma irregular, unas veces más y otras menos
    
    		if (num_aleatorio(0, 20) == 0){
    
    			//Si disparamos, creamos un Proyectil
    
    			var miProyectil:Proyectil;
    
    			//Decidimos que tipo de los tres proyectiles será.
    
    			//Lo hacemos aleatoriamente
    
    			switch (num_aleatorio(1, 3)){
    
    					case 1:
    
    						miProyectil = new Proyectil1;
    
    					break;
    
    					case 2:
    
    						miProyectil = new Proyectil2;
    
    					break;
    
    					case 3:
    
    						miProyectil = new Proyectil3;
    
    					break;
    
    			}
    
    			//Lo configuramos con el método dosparar()
    
    			miProyectil.disparar(level, ancho, alto);
    
    			//Y lo mosramso en zonaJuego
    
    			zonaJuego.addChild(miProyectil);
    
    			//Al nuevo proyectil, le asignamos la función que lo moverá y 
    
    			//comprobará si ha impactado contra algo en el evneto ENTER_FRAME.
    
    			miProyectil.addEventListener(Event.ENTER_FRAME, mover_proyectil);
    
    				
    
    		}
    
    
    
    	} else { // Si es fin de juego (fingame==True) es porque el proyectil
    
    			// ha impactado contra el arma, y está está reproduciendo la animación
    
    			//que la hace explotar. Comprobamos si ha acabado esa animación, para
    
    			//que se vea completa.
    
    		if (arma.currentFrame == arma.totalFrames){
    
    			//Si ha llegado al último frame es que la animación ha acabado
    
    			//Quitamos zonaJuego para borrar todos sus elementos hijos.
    
    			zonaJuego.removeEventListener(Event.ENTER_FRAME,lanzarProyectil)
    
    			stage.removeEventListener(KeyboardEvent.KEY_DOWN,disparar);
    
    			this.removeChild(zonaJuego);
    
    			//Y mostramos la pantalla de fin de juego
    
    			gotoAndStop("fin");
    
    		}
    
    	}
    
    } 
  40. Escribe el siguiente bloque de código para crear la función mover_proyectil, que se encargará de mover el proyectil y de comprobar si ha impactado contra lago:
    function mover_proyectil(event:Event):void{
    //Esta función mueve el proyectil y comprueba si ha impactado con algo
    //Se produce llama en el evento ENTER_FRAME del proyectil

    var proyectil:Proyectil = Proyectil(event.target);
    //Comprobamos si está explotando
    if (proyectil.explotando()){
    // Nos aseguramos de que se haya reproducido completa
    //la animación de la explosión

    if(proyectil.currentFrame == proyectil.totalFrames){
    //Si ha llegado al último frame, es que ha acabado
    //la animación de la explosión. Lo quitamos.

    quitar_proyectil(proyectil);
    }
    //Comprobamos si no ha explotado, y si sigue dentreo de la pantalla
    } else if (proyectil.esta_dentro(alto+proyectil.height)){
    //Si el proyectil está dentro del área del juego
    proyectil.avanzar(); //Lo avanzamos
    for (var i:Number = 0; i<zonaJuego.numChildren;i++){
    //Recorremos todos los elementos que hemos agregado
    // a la zonaJuego, tomando el elemnto con getChildAt(i).
    //Comprobamos el tipo de objeto

    switch (zonaJuego.getChildAt(i).toString()){
    case "[object Disparo]": //Si es un disparo del arma
    var disparo:Disparo = Disparo(zonaJuego.getChildAt(i));
    //Comprobamos si ha impactado con el proyectil
    if (proyectil.hitTestObject(disparo)){
    //Si es así, lo hacemos explotar y quitamos el disparo.
    proyectil.explotar();
    quitar_disparo(disparo);
    //Al explotar, proyectil.explotando() = True
    //Lo comprobábamos al principio. No lo quitamos ya para
    //que se vea la animación.

    hits++; //sumamos a los impactos
    actualizarEstadisticas() //Y actualizamos las estadísticas
    }
    break;
    case "[object BloqueBonus]": //Si es un BloqueBonus
    //Comprobamos si ha impactado con el proyectil
    if (proyectil.hitTestObject(zonaJuego.getChildAt(i))){
    //Y si ha impactado, quitamos el bloque y el proyectil
    quitar_bloqueBonus(BloqueBonus(zonaJuego.getChildAt(i)));
    //y quitamos el proyectil
    quitar_proyectil(proyectil);
    }
    break;
    case "[object Bloque]": //Si es un Bloque
    //Comprobamos si ha impactado con el proyectil
    if (proyectil.hitTestObject(zonaJuego.getChildAt(i))){
    //Y si ha impactado, quitamos el bloque y el proyectil
    zonaJuego.removeChild(zonaJuego.getChildAt(i));
    //y quitamos el proyectil
    quitar_proyectil(proyectil);
    }
    break;
    case "[object Arma]": //Si es el Arma
    //Comprobamos el impacto, y que no haya acabado ya el juego, para que
    //el arma no explote dos veces si impactan dos proyectiles a la vez

    if (proyectil.hitTestObject(zonaJuego.getChildAt(i)) && !fingame){
    //Si impacta contra el arma, la hacemos explotar
    Arma(zonaJuego.getChildAt(i)).gotoAndPlay("hit");
    //Y marcamos el fin del juego
    fingame = true;
    }
    break;
    }
    }
    } else{
    //Si se ha salido de la pantalla (proyectil.esta_dentro()==False, lo quitamos
    quitar_proyectil(proyectil);
    }
    }
    function quitar_proyectil (proyectil:Proyectil){
    //Esta función quita un proyectil de la pantalla, pasado como parámetro
    //Quita el escuchador del evento ENTER_FRAME

    proyectil.removeEventListener(Event.ENTER_FRAME, mover_proyectil);
    //Y borra el objeto, si no se ha eliminato ya.
    if (zonaJuego.contains(proyectil)) {
    zonaJuego.removeChild(DisplayObject(proyectil));

    }
    }
  41. Para acabar con este fotograma, sólo nos queda llamar a la función comenzarPartida();. Podemos hacerlo en cualquier parte del código, después de haber definido las variables iniciales. Por ejemplo, colóca este código al final:
    comenzarPartida();
  42. Por último, haz clic en la capa acciones del tercer fotograma, y en el panel Acciones introduce el siguiente código:
    //Mostramos las estadísticas
    
    estadisticas_txt.text="Aciertos: "+hits+"\t"+"Nivel:"+level;
    
    //Volvemos a mostrar el cursor normal
    
    Mouse.show();
    
    //Y asociamos al botón la función empezar() del primer fotograma
    
    btn_volveraJugar.addEventListener(MouseEvent.MOUSE_UP,empezar);

Y con esto tenemos nuestro juego listo para entretenernos en nuestros ratos libres.

   Inicio