public void Disparar()
    {
        /* if (disparoPrefab != null)
         * {
         *
         * Debug.Log("disparoPrefab", disparoPrefab);
         * }
         * if (puntoDisparo != null)
         * {
         *
         * Debug.Log("puntoDisparo", puntoDisparo);
         * }
         * if (disparo != null)
         * {
         *
         * Debug.Log("disparo", disparo);
         * }*/

        if (disparoPrefab != null && puntoDisparo != null && disparo != null)
        {
            GameObject misDisparos       = Instantiate(disparoPrefab, puntoDisparo.position, Quaternion.identity) as GameObject;
            Disparos   disparosComponent = misDisparos.GetComponent <Disparos>();

            if (disparo.transform.localScale.x < 0f)
            {
                disparosComponent.direction = Vector2.left;//instanciamos nuevo vector para que marque la dirección del disparo
                audioBala.Play();
            }
            else
            {
                disparosComponent.direction = Vector2.right;
                audioBala.Play();
            }
        }
    }
Example #2
0
        public void Renderizar(float tiempoRenderizado, List <TgcMesh> obstaculos)
        {
            SaltaHiperEspacio();
            this.Movimiento(tiempoRenderizado, obstaculos);
            if (!Saltando)
            {
                this.Disparar(tiempoRenderizado);
            }
            if (Disparos != null)
            {
                foreach (Disparo disparo in Disparos)
                {
                    disparo.Actualizar(tiempoRenderizado, obstaculos);
                    if (disparo.TiempoDeVida - tiempoRenderizado <= 0)
                    {
                        disparo.EnJuego = false;
                        disparo.TestDisparo.dispose();
                    }
                }

                Disparos.RemoveAll(x => x.EnJuego == false);
            }
            //la flotacion requiere mejoras. Agustin S.
            //this.FlotacionEspacial(tiempoRenderizado);
            Modelo.render();
        }
Example #3
0
 public void Disparar(float tiempoRenderizado)
 {
     if (TiempoParado == 0 || TiempoParado >= TiempoRecarga)
     {
         TgcD3dInput input = GuiController.Instance.D3dInput;
         if (GuiController.Instance.D3dInput.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT))
         {
             Disparo disparo = new Disparo(Modelo, new Matrix());
             Disparos.Add(disparo);
         }
         TiempoParado = 0f;
     }
     TiempoParado = TiempoParado + tiempoRenderizado * 4;
 }
Example #4
0
        public void Renderizar(float tiempoRenderizado, List <TgcMesh> obstaculos)
        {
            if (Disparos != null)
            {
                foreach (Disparo disparo in Disparos)
                {
                    disparo.Actualizar(tiempoRenderizado, obstaculos);
                    if (disparo.TiempoDeVida - tiempoRenderizado <= 0)
                    {
                        disparo.EnJuego = false;
                        disparo.TestDisparo.dispose();
                    }
                }

                Disparos.RemoveAll(x => x.EnJuego == false);
            }
            Modelo.render();
        }
Example #5
0
        public void MoverHaciaObjetivo(float tiempoRenderizado, Vector3 posicionObjetivo)
        {
            if (this.Modelo.Enabled)
            {
                //Resto los dos vectores para hallar el vector distancia
                Vector3 Distancia = Vector3.Subtract(posicionObjetivo, this.Modelo.Position);

                //Otro vector, con valores absolutos para hallar la componente maxima
                Vector3 DistanciaAbs = TgcVectorUtils.abs(Distancia);

                //Calculo matriz de rotacion
                Vector3 DireccionObjetivo = Vector3.Normalize(posicionObjetivo - this.Modelo.Position);
                float   angulo            = FastMath.Acos(Vector3.Dot(RotacionOriginal, DireccionObjetivo));
                Vector3 axisRotation      = Vector3.Cross(this.Modelo.Rotation, DireccionObjetivo);
                MatrizRotacion = Matrix.RotationAxis(axisRotation, angulo);

                float cantidadDeMovimiento = this.VelocidadMovimiento * tiempoRenderizado;
                float giro = this.Modelo.Rotation.Y - angulo;
                if (giro < -0.1)
                {
                    this.Modelo.rotateY(Geometry.DegreeToRadian(-giro * 100 * tiempoRenderizado));
                    return;
                }
                else if (giro > 0.1)
                {
                    this.Modelo.rotateY(Geometry.DegreeToRadian(-giro * 100 * tiempoRenderizado));
                    return;
                }
                if (DistanciaAbs.X + DistanciaAbs.Y + DistanciaAbs.Z > 700f)
                {
                    //Hallo la componente de mayor valor y me muevo en esa direccion. VER SENTIDO.
                    if (DistanciaAbs.X >= DistanciaAbs.Y)
                    {
                        if (DistanciaAbs.X >= DistanciaAbs.Z)
                        {
                            // MOVER EN X
                            if (Distancia.X > cantidadDeMovimiento)
                            {
                                this.Modelo.move(cantidadDeMovimiento, 0, 0);
                            }
                            else
                            {
                                this.Modelo.move(cantidadDeMovimiento * -1, 0, 0);
                            }
                        }
                        else
                        {
                            // MOVER EN Z
                            if (Distancia.Z > 0)
                            {
                                this.Modelo.move(0, 0, cantidadDeMovimiento);
                            }
                            else
                            {
                                this.Modelo.move(0, 0, cantidadDeMovimiento * -1);
                            }
                        }
                    }
                    else
                    {
                        if (DistanciaAbs.Y >= DistanciaAbs.Z)
                        {
                            // MOVER EN Y
                            if (Distancia.Y > 0)
                            {
                                this.Modelo.move(0, cantidadDeMovimiento, 0);
                            }
                            else
                            {
                                this.Modelo.move(0, cantidadDeMovimiento * -1, 0);
                            }
                        }
                        else
                        {
                            // MOVER EN Z
                            if (Distancia.Z > 0)
                            {
                                this.Modelo.move(0, 0, cantidadDeMovimiento);
                            }
                            else
                            {
                                this.Modelo.move(0, 0, cantidadDeMovimiento * -1);
                            }
                        }
                    }
                }
                else
                {
                    //Disparar. Tambien deberia rotar para que el disparo vaya bien

                    if (TiempoParado == 0 || TiempoParado >= TiempoRecarga)
                    {
                        Disparo disparo = new Disparo(this.Modelo, MatrizRotacion);
                        Disparos.Add(disparo);
                        TiempoParado = 0f;
                    }
                    TiempoParado = TiempoParado + tiempoRenderizado * 4;
                }
            }
        }
Example #6
0
        // Dibuja disparos y elimina disparos fuera de rango
        public override void Dibujarse()
        {
            if (Disparos.Count > 0)
            {
                int incrementoVertical   = 0;
                int incrementoHorizontal = 0;

                List <Disparo> disparosFueraRango = new List <Disparo>();

                if (this.Direccion == ObjetosComunes.Direccion.Superior)
                {
                    incrementoVertical = Velocidad * -1;
                }
                else
                {
                    if (this.Direccion == ObjetosComunes.Direccion.Inferior)
                    {
                        incrementoVertical = Velocidad;
                    }
                    else
                    {
                        if (this.Direccion == ObjetosComunes.Direccion.InferiorIzquierda)
                        {
                            if (incrementosVerticalesSucesivos == 1)
                            {
                                incrementoVertical             = 0;
                                incrementoHorizontal           = -1;
                                incrementosVerticalesSucesivos = 0;
                            }
                            else
                            {
                                incrementoVertical              = Velocidad * 2;
                                incrementosVerticalesSucesivos += 1;
                            }
                        }
                        else
                        {
                            if (this.Direccion == ObjetosComunes.Direccion.InferiorDerecha)
                            {
                                if (incrementosVerticalesSucesivos == 1)
                                {
                                    incrementoVertical             = 0;
                                    incrementoHorizontal           = 1;
                                    incrementosVerticalesSucesivos = 0;
                                }
                                else
                                {
                                    incrementoVertical              = Velocidad * 2;
                                    incrementosVerticalesSucesivos += 1;
                                }
                            }
                        }
                    }
                }

                foreach (Disparo disparo in Disparos)
                {
                    // Mover disparo
                    disparo.Posicion.PosicionY += incrementoVertical;
                    disparo.Posicion.PosicionX += incrementoHorizontal;
                    disparo.Dibujarse();

                    if (disparo.Posicion.PosicionY < 0 - disparo.Dimenciones.Largo || disparo.Posicion.PosicionY > Canvas.Height + disparo.Dimenciones.Largo)
                    {
                        Canvas.Children.Remove(disparo.SpriteSheet);
                        disparosFueraRango.Add(disparo);
                    }
                }

                foreach (Disparo disparoFueraRango in disparosFueraRango)
                {
                    Disparos.Remove(disparoFueraRango);
                    disparoFueraRango.Removerse();
                }
            }

            PeriodoDesdeUltimoDisparo += 1;
        }