Example #1
0
        public override void update(float Tiempo)
        {
            ControladorJuego instanciaControlador = ControladorJuego.getInstance();

            this.mantenerseEnAtaque(instanciaControlador.personaje, Tiempo, instanciaControlador.objetosColisionablesDinamicos.FindAll(x => !x.Equals(this.mesh4.BoundingBox)));

            PosicionActual = mesh4.Position;
            mesh4.Scale    = C_Altura;
            xTiempo++;
            if (!disparando)
            {
                disparando    = true;
                TiempoDisparo = xTiempo;
                frenteTanque  = new Vector3(0 - 13 * (FastMath.Sin(this.mesh4.Rotation.Y)),
                                            0,
                                            0 - 13 * (FastMath.Cos(this.mesh4.Rotation.Y)));

                misil.PosicionDisparo(this.mesh4.Position, frenteTanque);
                misil.update(Tiempo);
            }

            if ((disparando) && (xTiempo >= TiempoDisparo * 100))
            {
                disparando = false;
                xTiempo    = 1;
            }

            misil.update(Tiempo);

            //misil.setPosicionInicial(GuiController.Instance.ThirdPersonCamera.getPosition());
        }
Example #2
0
        //====================================
        // Renderiza las imagenes
        //====================================
        public override void render(float Tiempo)
        {
            if ((ControladorJuego.getInstance().SoldadosVivos != 0 || calcularDistancia(mesh.Position, ControladorJuego.getInstance().heli.mesh2.Position) > 50) && !huyo)
            {
                if (cDisparando)
                {
                    disparo.update(Tiempo);
                    disparo.render(Tiempo);
                }


                //Camara sigue al personaje
                if (vida > 0)
                {
                    Camara.Actualizar(this);
                }
                else
                {
                    GuiController.Instance.FpsCamera.Enable         = true;
                    GuiController.Instance.ThirdPersonCamera.Enable = false;
                }

                mesh.animateAndRender();
                bool showBB = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
                if (showBB)
                {
                    characterSphere.render();
                }
            }
            else
            {
                huyo = true;
            }
        }
Example #3
0
        //====================================
        // Actualiza posiciones y estados
        //====================================

        public override void update(float Tiempo)
        {
            ControladorJuego instanciaControlador = ControladorJuego.getInstance();

            this.Perseguir(instanciaControlador.personaje, Tiempo, instanciaControlador.objetosColisionablesDinamicos.FindAll(x => !x.Equals(this.mesh.BoundingBox)));

            PosicionActual = mesh.Position;
            mesh.Scale     = C_Altura;
            mesh.playAnimation(C_Accion, true);
        }
Example #4
0
        public void Bajar()
        {
            int  cantSoldados  = ControladorJuego.getInstance().SoldadosVivos;
            bool personajeHuyo = ControladorJuego.getInstance().personaje.huyo;

            //seleccionamos la camara para la huida
            if (!personajeHuyo)
            {
                GuiController.Instance.FpsCamera.Enable         = false;
                GuiController.Instance.ThirdPersonCamera.Enable = true;
            }


            // Baja el Helicoptero
            if ((PosicionHeli >= 0) && (estado == "Alto") && !personajeHuyo)
            {
                // GuiController.Instance.ThirdPersonCamera.setCamera(new Vector3(0, 0, 0), PosicionHeli - 1, -100f);
                PosicionHeli   = PosicionHeli - 1f;
                mesh2.Position = new Vector3(0, PosicionHeli, 0);
            }

            if (PosicionHeli == 12 && cantSoldados > 0)
            {
                // GuiController.Instance.ThirdPersonCamera.Target = new Vector3(0, 0, 0); ;
                estado = "Bajo";
            }

            if (PosicionHeli >= 300 && cantSoldados == 0 && !personajeHuyo)
            {
                // GuiController.Instance.ThirdPersonCamera.Target = new Vector3(0, 0, 0); ;
                estado = "Alto";
            }

            if ((PosicionHeli <= 300 || personajeHuyo) && estado == "Bajo")
            {
                if (personajeHuyo)
                {
                    GuiController.Instance.ThirdPersonCamera.setCamera(new Vector3(0, 0, 0), PosicionHeli + 50f, -100f);
                }
                PosicionHeli   = PosicionHeli + 1f;
                mesh2.Position = new Vector3(0, PosicionHeli, 0);
            }

            if (calcularDistancia(this.mesh2.Position, ControladorJuego.getInstance().personaje.mesh.Position) < 50 && cantSoldados == 0)
            {
                estado = "Bajo";
            }
        }
Example #5
0
        public override void update(float elapsedTime)
        {
            Personaje personaje         = ControladorJuego.getInstance().personaje;
            Vector3   posicionPersonaje = personaje.PosicionActual;

            this.direccion = new Vector3(posicionPersonaje.X, posicionPersonaje.Y + 10, posicionPersonaje.Z) - this.mesh3.Position;
            this.direccion.Normalize();
            rotar(this.mesh3, personaje.PosicionActual, this.mesh3.Position);
            PosicionActual = this.mesh3.Position;
            Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
            if (TgcCollisionUtils.testSphereAABB(personaje.characterSphere, this.mesh3.BoundingBox))
            {
                personaje.dañar(0.02f);
                colisiono = true;
                Random random = new Random();
                foreach (FuegoShaders fuego in explosiones)
                {
                    fuego.mesh.Scale    = new Vector3(0.03f * (random.Next() % 5), 0.03f * (random.Next() % 5), 0.03f * (random.Next() % 5));
                    fuego.FuegoPosicion = new Vector3(personaje.mesh.Position.X, 1, personaje.mesh.Position.Z);
                }
            }

            this.mesh3.move(direccion * velocidad * elapsedTime);
        }
Example #6
0
        //=======================================
        // Actualizo estados
        //=======================================
        public override void update(float Tiempo)
        {
            Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;

            //obtener velocidades de Modifiers
            bool  showBB            = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
            float velocidadCaminar  = 160 * Tiempo;
            float velocidadRotacion = 70 * Tiempo;
            float fuerzaSalto       = (float)GuiController.Instance.Modifiers.getValue("FuerzaSalto");


            //Calcular proxima posicion de personaje segun Input
            TgcD3dInput d3dInput           = GuiController.Instance.D3dInput;
            float       moveForward        = 0f;
            float       rotate             = 0;
            float       jumpingElapsedTime = 0;
            bool        moving             = false;
            bool        rotating           = false;
            bool        pegando            = false;
            bool        saltando           = false;
            bool        pateando           = false;

            #region inputs

            //Adelante
            if (d3dInput.keyDown(Key.W))
            {
                moveForward = -velocidadCaminar;
                moving      = true;
                sonido.render(Tiempo);
            }

            //Atras
            if (d3dInput.keyDown(Key.S))
            {
                moveForward = velocidadCaminar;
                moving      = true;
                sonido.render(Tiempo);
            }

            //Derecha
            if (d3dInput.keyDown(Key.D))
            {
                rotate   = velocidadRotacion;
                rotating = true;
            }

            //Izquierda
            if (d3dInput.keyDown(Key.A))
            {
                rotate   = -velocidadRotacion;
                rotating = true;
            }

            //Golpe
            if (d3dInput.keyDown(Key.Q))
            {
                pegando = true;
            }

            //Patada
            if (d3dInput.keyDown(Key.E))
            {
                pateando = true;
            }

            //Disparando
            if (d3dInput.keyDown(Key.P))
            {
                cDisparando = true;

                Vector3 frentePersonaje = new Vector3(0 - 13 * (FastMath.Sin(this.mesh.Rotation.Y)),
                                                      0,
                                                      0 - 13 * (FastMath.Cos(this.mesh.Rotation.Y)));

                disparo.explotando = false;
                disparo.explota    = 0;
                disparo.PosicionDisparo(this.mesh.Position, frentePersonaje);

                disparo.setPosicionInicial(GuiController.Instance.ThirdPersonCamera.getPosition());
                sonido2.render(Tiempo);
                disparo.inicioDisparo = mesh.Position;
                disparo.explota       = 0;
            }
            #endregion

            #region salto
            ///////////////////JUMP///////////////////
            //DESLIGAR DEL TIEMPO DE PROCESAMIENTO
            if (jump > 0)
            {
                jumpingElapsedTime += Tiempo;
                // 1/2 de gravedad * tiempo al cuadrado
                //jump -= 4.9f * jumpingElapsedTime * jumpingElapsedTime;
                jump    -= 150f * jumpingElapsedTime * jumpingElapsedTime;
                moving   = true;
                saltando = true;
                if (jump <= 0)
                {
                    jump = 0;
                }
            }
            else
            {
                //bloqueo de varios saltos sucesivos, sin el jumpingElapsedTime <= 0 salta indefinidamente al mantener apretada la barra
                //se asume que el personaje tarda en bajar lo mismo que en subir
                if (jumpingElapsedTime > 0)
                {
                    jumpingElapsedTime -= Tiempo;
                }
                else
                {
                    if (d3dInput.keyDown(Key.Space))
                    {
                        jump               = fuerzaSalto;
                        moving             = true;
                        saltando           = true;
                        jumpingElapsedTime = 0;
                    }
                }
            }
            ///////////////////JUMP//////////////////
            #endregion


            //Si hubo rotacion
            if (rotating)
            {
                //Rotar personaje y la camara, hay que multiplicarlo por el tiempo transcurrido para no atarse a la velocidad el hardware
                float rotAngle = Geometry.DegreeToRadian(rotate);
                mesh.rotateY(rotAngle);
                RotacionPersonaje = rotAngle;
                GuiController.Instance.ThirdPersonCamera.rotateY(rotAngle);
            }

            //Si hubo desplazamiento
            if (moving)
            {
                if (saltando)
                {
                    //Activar animacion de salto
                    mesh.playAnimation("MatrixJump", true);
                }
                else
                {
                    //Activar animacion de caminando
                    mesh.playAnimation("Walk", true);
                }
            }

            else if (pegando)
            {
                mesh.playAnimation("ComboPunch", true);
            }

            else if (pateando)
            {
                mesh.playAnimation("HighKick", true);
            }

            else if (saltando)
            {
                mesh.playAnimation("MatrixJump", true);
            }


            //Si no se esta moviendo, activar animacion de Parado
            else
            {
                mesh.playAnimation("StandBy", true);
            }

            #region personaje
            //Mover personaje con detección de colisiones, sliding y gravedad
            Vector3 movementVector = Vector3.Empty;
            if (moving)
            {
                //Aplicar movimiento, desplazarse en base a la rotacion actual del personaje
                movementVector = new Vector3(
                    FastMath.Sin(mesh.Rotation.Y) * moveForward,
                    jump,
                    FastMath.Cos(mesh.Rotation.Y) * moveForward
                    );
            }

            //Actualizar valores de gravedad
            collisionManager.GravityEnabled = (bool)GuiController.Instance.Modifiers["HabilitarGravedad"];
            collisionManager.GravityForce   = (Vector3)GuiController.Instance.Modifiers["Gravedad"];
            collisionManager.SlideFactor    = (float)GuiController.Instance.Modifiers["SlideFactor"];

            //Mover personaje con detección de colisiones, sliding y gravedad

            Vector3 realMovement = collisionManager.moveCharacter(characterSphere, movementVector, ControladorJuego.getInstance().objetosColisionablesDinamicos);
            PosicionActual = mesh.Position;
            mesh.move(realMovement);
            #endregion

            #region camara

            // GuiController.Instance.ThirdPersonCamera.Target = mesh.Position;
            // GuiController.Instance.ThirdPersonCamera.OffsetForward = -700f;
            #endregion
        }
Example #7
0
 //*********************************************
 // Inicializa Objetos
 //*********************************************
 public override void init()
 {
     ControladorPrincipal = ControladorJuego.getInstance();;
     ControladorPrincipal.init();
 }
Example #8
0
        public void render(float time)
        {
            d3dDevice.RenderState.AlphaBlendEnable = false;
            skyBox.render();
            sonido.render(time);
            sonido2.render(time);

            bool showQuadtree = (bool)GuiController.Instance.Modifiers["showQuadtree"];
            bool showTerrain  = (bool)GuiController.Instance.Modifiers["showTerrain"];

            if (showTerrain)
            {
                foreach (TgcMesh mesh in terrenoMesh)
                {
                    mesh.render();
                }
            }
            bool    showBB = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
            bool    frustumCullingEnabled = (bool)GuiController.Instance.Modifiers["culling"];
            bool    disparando            = ControladorJuego.getInstance().personaje.cDisparando;
            Vector3 lightPosition         = ControladorJuego.getInstance().personaje.disparo.PosicionActual;
            Vector3 initialPosition       = ControladorJuego.getInstance().personaje.disparo.getPosicionInicial();

            //solo aplico shader cuando estoy a cierta distancia del disparo y este existe
            Vector3 posicionDisparo = ControladorJuego.getInstance().personaje.disparo.PosicionActual;

            quadtree.render(GuiController.Instance.Frustum, showQuadtree);

            //Analizar cada malla contra el Frustum - con fuerza bruta
            int totalMeshes = 0;

            foreach (TgcMeshShader mesh in terreno.Meshes)
            {
                if (disparando /*&& calcularDistancia(mesh.Position ,posicionDisparo) >500*/)
                {
                    //Cargar variables de shader globales a todos los objetos
                    mesh.Effect.SetValue("fvLightPosition", TgcParserUtils.vector3ToFloat3Array(lightPosition));
                    mesh.Effect.SetValue("fvEyePosition", TgcParserUtils.vector3ToFloat3Array(initialPosition));
                    mesh.Effect.SetValue("fvAmbient", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["AmbientColor"]));
                    mesh.Effect.SetValue("fvDiffuse", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["DiffuseColor"]));
                    mesh.Effect.SetValue("fvSpecular", ColorValue.FromColor((Color)GuiController.Instance.Modifiers["SpecularColor"]));
                    mesh.Effect.SetValue("fSpecularPower", (float)GuiController.Instance.Modifiers["SpecularPower"]);
                }
                mesh.render();
            }



            //Render meshes
            if (showBB)
            {
                foreach (TgcMesh mesh in terreno.Meshes)
                {
                    mesh.BoundingBox.render();
                }
            }

            camera.Acercar();

            //foreach (TgcMesh mesh in meshes2)
            //{
            //    mesh.render();


            //}

            //foreach (TgcMesh mesh in meshes3)
            //{
            //    mesh.render();


            //}
        }
Example #9
0
        public override void update(float elapsedTime)
        {
            cSoldados      = ControladorJuego.getInstance().soldados;
            PosicionActual = this.mesh3.Position;
            Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
            this.mesh3.move(direccion * velocidad * elapsedTime);

            float distancia;

            distancia = calcularDistancia(posicionInicial, this.PosicionActual);

            foreach (Soldado Sold in cSoldados)
            {
                if (calcularColisionPersonaje(mesh3, Sold.mesh) && explota < 3)
                {
                    explotando = true;
                    ExplotoX   = Sold.mesh.Position.X;
                    ExplotoZ   = Sold.mesh.Position.Z;
                    break;
                }
            }

            if (explota >= 3)
            {
                explotando = false;
                explota    = 0;
            }

            if (explotando)
            {
                explota += elapsedTime;
            }

            foreach (Soldado Sold in cSoldados)
            {
                if (Sold.vive())
                {
                    if (!calcularColisionPersonaje(mesh3, Sold.mesh))
                    {
                        this.mesh3.move(direccion * velocidad * elapsedTime);
                    }
                    else
                    {
                        acerto      = true;
                        meshSoldado = Sold;
                        Sold.matar();

                        i++;
                        break;
                    }
                }
            }
            // Cuando el misil le da a un soldado lo mata y deja rastros de fuego
            if (acerto && meshSoldado.Persigue)
            {
                Random r = new Random(DateTime.Now.Millisecond);
                meshSoldado.matar();

                meshSoldado.mesh.rotateZ(250);

                meshSoldado.Persigue = false;
                acerto = false;
            }
            //Elimino la bola al colisionar con el terreno
            List <TgcMesh> meshesTerreno = ControladorJuego.getInstance().Escenario.terreno.Meshes;


            //meshSoldado.moveOrientedY(8);
            // meshSoldado.Position = new Vector3(meshSoldado.Position.X, meshSoldado.Position.Y + 15, meshSoldado.Position.Z) * elapsedTime;
            //
            //meshSoldado.p
            //meshSoldado.Position = new Vector3 (meshSoldado.Position.X, meshSoldado.Position.Y, meshSoldado.Position.Z);
            acerto = false;
        }
Example #10
0
 public void matar()
 {
     C_Accion = "StandBy";
     vivo     = false;
     ControladorJuego.getInstance().objetosColisionablesDinamicos.Remove(this.mesh.BoundingBox);
 }