Exemple #1
0
        public static Vector3[] computeCorners(ObstaculoRigido obstaculo)
        {
            TgcObb obb = obstaculo.obb;

            Vector3[] corners = new Vector3[8];
            Vector3   extents;

            Vector3[] orientation = obb.Orientation;
            Vector3   center      = obb.Center;

            extents = obstaculo.mesh.BoundingBox.calculateAxisRadius();
            extents = TgcVectorUtils.abs(extents);

            Vector3 eX = extents.X * orientation[0];
            Vector3 eY = extents.Y * orientation[1];
            Vector3 eZ = extents.Z * orientation[2];

            corners[0] = center - eX - eY - eZ;
            corners[1] = center - eX - eY + eZ;

            corners[2] = center - eX + eY - eZ;
            corners[3] = center - eX + eY + eZ;

            corners[4] = center + eX - eY - eZ;
            corners[5] = center + eX - eY + eZ;

            corners[6] = center + eX + eY - eZ;
            corners[7] = center + eX + eY + eZ;

            return(corners);
        }
        public static Vector3[] computeCorners(ObstaculoRigido obstaculo)
        {
            TgcObb obb = obstaculo.obb;
            Vector3[] corners = new Vector3[8];
            Vector3 extents;
            Vector3[] orientation = obb.Orientation;
            Vector3 center = obb.Center;

            extents = obstaculo.mesh.BoundingBox.calculateAxisRadius();
            extents = TgcVectorUtils.abs(extents);

            Vector3 eX = extents.X * orientation[0];
            Vector3 eY = extents.Y * orientation[1];
            Vector3 eZ = extents.Z * orientation[2];

            corners[0] = center - eX - eY - eZ;
            corners[1] = center - eX - eY + eZ;

            corners[2] = center - eX + eY - eZ;
            corners[3] = center - eX + eY + eZ;

            corners[4] = center + eX - eY - eZ;
            corners[5] = center + eX - eY + eZ;

            corners[6] = center + eX + eY - eZ;
            corners[7] = center + eX + eY + eZ;

            return corners;
        }
        public void render(float elapsedTime)
        {
            //moverse y rotar son variables que me indican a qué velocidad se moverá o rotará el mesh respectivamente.
            //Se inicializan en 0, porque por defecto está quieto.

            float moverse = 0f;
            float rotar = 0f;

            habilitarDecremento = true;

            GuiController.Instance.UserVars.setValue("Velocidad", Math.Abs(auto.velocidadActual));
            GuiController.Instance.UserVars.setValue("Vida", escalaVida.X);
            GuiController.Instance.UserVars.setValue("AngCol", Geometry.RadianToDegree(anguloColision));
            GuiController.Instance.UserVars.setValue("AngRot", Geometry.RadianToDegree(anguloARotar));

            //aumento de la velocidad de rotacion al derrapar
            modificarVelocidadRotacion(auto);

            //Procesa las entradas del teclado.
            if (entrada.keyDown(Key.Q))
            {
                finDeJuego = true;
                salirConQ = true;
            }

            if (entrada.keyDown(Key.S))
            {
                moverse = auto.irParaAtras(elapsedTime);
            }
            if (entrada.keyDown(Key.W))
            {
                moverse = auto.irParaAdelante(elapsedTime);
            }
            if (entrada.keyDown(Key.A) && (auto.velocidadActual > 0.5f || auto.velocidadActual < -0.5f)) //izquierda
            {
                rotar = -auto.velocidadRotacion;
            }
            if (entrada.keyDown(Key.D) && (auto.velocidadActual > 0.5f || auto.velocidadActual < -0.5f)) //derecha
            {
                rotar = auto.velocidadRotacion;
            }
            if (entrada.keyPressed(Key.M))
            {
                musica.muteUnmute();
                auto.mutearSonido();
            }
            if (entrada.keyPressed(Key.R)) //boton de reset, el mesh vuelve a la posicion de inicio y restaura todos sus parametros
            {
                auto.reiniciar();
                auto.mesh.move(new Vector3(0, 0, -3100));
                auto.mesh.rotateY(-1.57f);
                EjemploAlumno.instance.activar_efecto = false;
                nivel.reiniciar();
                this.reiniciar();
                GuiController.Instance.ThirdPersonCamera.resetValues();
                GuiController.Instance.ThirdPersonCamera.rotateY(-1.57f);

            }
            if (entrada.keyPressed(Key.B)) //Modo debug para visualizar BoundingBoxes entre otras cosas que nos sirvan a nosotros
            {
                Shared.debugMode = !Shared.debugMode;
            }
            if (entrada.keyPressed(Key.I))
            {
                modoDios = !modoDios;
            }

            //Frenado por inercia
            if (!entrada.keyDown(Key.W) && !entrada.keyDown(Key.S) && auto.velocidadActual != 0)
            {
                moverse = auto.frenarPorInercia(elapsedTime);
            }
            if (moverse > auto.velocidadMaxima)
            {
                auto.velocidadActual = auto.velocidadMaxima;
            }
            if (moverse < (-auto.velocidadMaxima))
            {
                auto.velocidadActual = -auto.velocidadMaxima;
            }

            int sentidoRotacion = 0; //sentido de rotacion del reajuste de camara
            float rotCamara = GuiController.Instance.ThirdPersonCamera.RotationY;
            float rotAuto = auto.mesh.Rotation.Y;
            float deltaRotacion = rotAuto - rotCamara;
            float dif = FastMath.Abs(Geometry.RadianToDegree(deltaRotacion));
            float rapidez = 5f; //aceleracion de reajuste de camara

            if (rotar != 0)
            {
                habilitarDecremento = false;
                habilitarContador = true;
            }
            if (dif < 40)
            {
                if (dif < 30)
                {
                    if (dif < 20) rapidez = 0.8f;
                    else rapidez = 2f;
                }
                else rapidez = 3f;
            }

            if (habilitarContador) pasaronSegundos += elapsedTime;

            if (deltaRotacion < 0) sentidoRotacion = -1;
            else sentidoRotacion = 1;

            if (deltaRotacion != 0 && pasaronSegundos > 0.5f)
            {
                ajustar = true;
                pasaronSegundos = 0f;
                habilitarContador = false;
            }

            float rotAngle = Geometry.DegreeToRadian(rotar * elapsedTime);

            if (ajustar) GuiController.Instance.ThirdPersonCamera.rotateY(sentidoRotacion * rapidez * elapsedTime);

            if (deltaRotacion < 0) sentidoRotacion = -1;
            else sentidoRotacion = 1;
            incrementarTiempo(this, elapsedTime, habilitarDecremento);
            auto.mesh.rotateY(rotAngle);
            auto.obb.rotate(new Vector3(0, rotAngle, 0));
            if (FastMath.Abs(Geometry.RadianToDegree(deltaRotacion)) % 360 < 3)
            {
                GuiController.Instance.ThirdPersonCamera.RotationY = rotAuto;
                ajustar = false;
            }

            if (habilitarDecremento) incrementarTiempo(this, elapsedTime, habilitarDecremento);

            if (moverse != 0 || auto.velocidadActual != 0) //Si hubo movimiento
            {
                Vector3 lastPos = auto.mesh.Position;
                auto.mesh.moveOrientedY(moverse * elapsedTime);
                Vector3 position = auto.mesh.Position;
                Vector3 posDiff = position - lastPos;
                auto.obb.move(posDiff);
                Vector3 direccion = new Vector3(FastMath.Sin(auto.mesh.Rotation.Y) * moverse, 0, FastMath.Cos(auto.mesh.Rotation.Y) * moverse);
                auto.direccion.PEnd = auto.obb.Center + Vector3.Multiply(direccion, 50f);

                //Detectar colisiones de BoundingBox utilizando herramienta TgcCollisionUtils
                bool collide = false;
                Vector3[] cornersAuto;
                Vector3[] cornersObstaculo;
                foreach (ObstaculoRigido obstaculo in nivel.obstaculos)
                {
                    if (Colisiones.testObbObb2(auto.obb, obstaculo.obb)) //chequeo obstáculo por obstáculo si está chocando con auto
                    {
                        collide = true;
                        obstaculoChocado = obstaculo;
                        Shared.mostrarChispa = true;
                        if (FastMath.Abs(auto.velocidadActual) > 800)
                        {
                            auto.reproducirSonidoChoque(FastMath.Abs(auto.velocidadActual));
                            auto.deformarMesh(obstaculo.obb, FastMath.Abs(auto.velocidadActual));
                        }
                        if (FastMath.Abs(auto.velocidadActual) > 800 && !modoDios)
                        {

                            escalaVida.X -= 0.00003f * Math.Abs(auto.velocidadActual) * escalaInicial.X;
                            if (escalaVida.X > 0.03f)
                            {
                                vida.setEscala(new Vector2(escalaVida.X, escalaVida.Y));
                            }
                            else
                            {
                                finDeJuego = true;
                                muerte = true;
                            }
                        }
                        break;
                    }
                }
                //Si hubo colision, restaurar la posicion anterior (sino sigo de largo)
                if (collide)
                {
                    auto.mesh.Position = lastPos;
                    auto.obb.updateValues();
                    moverse = auto.chocar(elapsedTime);

                    if (FastMath.Abs(auto.velocidadActual) > 0)
                    {
                        cornersAuto = CalculosVectores.computeCorners(auto);
                        cornersObstaculo = CalculosVectores.computeCorners(obstaculoChocado);
                        List<Plane> carasDelObstaculo = CalculosVectores.generarCaras(cornersObstaculo);
                        Vector3 NormalAuto = direccion;
                        caraChocada = CalculosVectores.detectarCaraChocada(carasDelObstaculo, auto.puntoChoque);
                        Vector3 NormalObstaculo = new Vector3(caraChocada.A, caraChocada.B, caraChocada.C);
                        GuiController.Instance.UserVars.setValue("NormalObstaculoX", NormalObstaculo.X);
                        GuiController.Instance.UserVars.setValue("NormalObstaculoZ", NormalObstaculo.Z);

                        float desplazamientoInfinitesimal = 5f;
                        float constanteDesvio = 1.3f;
                        //Calculo el angulo entre ambos vectores
                        anguloColision = CalculosVectores.calcularAnguloEntreVectoresNormalizados(NormalAuto, NormalObstaculo);//Angulo entre ambos vectores
                        //rota mesh
                        if (FastMath.Abs(auto.velocidadActual) > 800)
                        {
                            if (Geometry.RadianToDegree(anguloColision) < 25) //dado un cierto umbral, el coche rebota sin cambiar su direccion
                            {
                                auto.velocidadActual = -auto.velocidadActual;
                            }
                            else //el coche choca y cambia su direccion
                            {

                                if (NormalObstaculo.Z > 0 && direccion.X > 0 && direccion.Z > 0)
                                {
                                    anguloARotar = constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
                                    auto.mesh.move(new Vector3(0, 0, -10));
                                    colorDeColision = Color.Red;
                                }

                                if (NormalObstaculo.X > 0 && direccion.X > 0 && direccion.Z > 0)
                                {
                                    anguloARotar = -constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
                                    auto.mesh.move(new Vector3(-5, 0, 0));
                                    colorDeColision = Color.Salmon;
                                }

                                if (NormalObstaculo.X > 0 && direccion.X > 0 && direccion.Z < 0)
                                {

                                    anguloARotar = constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
                                    colorDeColision = Color.Blue;
                                    auto.mesh.move(new Vector3(-desplazamientoInfinitesimal, 0, 0));
                                }

                                if (NormalObstaculo.Z < 0 && direccion.X > 0 && direccion.Z < 0)
                                {
                                    anguloARotar = -constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
                                    auto.mesh.move(new Vector3(0, 0, desplazamientoInfinitesimal));
                                    colorDeColision = Color.Green;
                                }

                                if (NormalObstaculo.Z < 0 && direccion.X < 0 && direccion.Z < 0)
                                {
                                    anguloARotar = constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
                                    auto.mesh.move(new Vector3(0, 0, desplazamientoInfinitesimal));
                                    colorDeColision = Color.Pink;
                                }

                                if (NormalObstaculo.X < 0 && direccion.X < 0 && direccion.Z < 0)
                                {
                                    anguloARotar = -constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
                                    auto.mesh.move(new Vector3(desplazamientoInfinitesimal, 0, 0));
                                    colorDeColision = Color.Silver;
                                }

                                if (NormalObstaculo.X < 0 && direccion.X < 0 && direccion.Z > 0)
                                {
                                    anguloARotar = constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
                                    auto.mesh.move(new Vector3(desplazamientoInfinitesimal, 0, 0));
                                    colorDeColision = Color.Aquamarine;
                                }

                                if (NormalObstaculo.Z > 0 && direccion.X < 0 && direccion.Z > 0)
                                {
                                    anguloARotar = -constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
                                    auto.mesh.move(new Vector3(0, 0, -desplazamientoInfinitesimal));
                                    colorDeColision = Color.Yellow;
                                }

                                auto.mesh.rotateY(anguloARotar);

                            }
                        }

                    }
                }

                foreach (Recursos recurso in nivel.recursos)
                {
                    TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(auto.mesh.BoundingBox, recurso.modelo.BoundingBox);
                    if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
                    {
                        nivel.recursos.Remove(recurso); //Saca el recurso de la lista para que no se renderice más
                        float puntos = Convert.ToSingle(this.puntos.Text) + 100f;
                        this.puntos.Text = Convert.ToString(puntos);
                        break;
                    }
                }
                //Chequeo si el auto agarro el checkpoint actual
                if (Colisiones.testObbObb2(auto.obb, nivel.checkpointActual.obb))
                {
                    if (nivel.checkpointsRestantes.Text != "1")
                    {
                        nivel.checkpoints.Remove(nivel.checkpointActual); //Saca el checkpoint de la lista para que no se renderice más
                        int restantes = (Convert.ToInt16(nivel.checkpointsRestantes.Text) - 1);
                        nivel.checkpointsRestantes.Text = restantes.ToString(); //Le resto uno a los restantes
                        this.tiempoRestante.Text = (Convert.ToSingle(this.tiempoRestante.Text) + 10f).ToString();
                        nivel.checkpointActual = nivel.checkpoints.ElementAt(0);
                    }
                    else
                    {
                        finDeJuego = true;
                    }
                }

                //Efecto blur
                if (FastMath.Abs(auto.velocidadActual) > (auto.velocidadMaxima * 0.5555))
                {
                    EjemploAlumno.instance.activar_efecto = true;
                    EjemploAlumno.instance.blur_intensity = 0.003f * (float)Math.Round(FastMath.Abs(auto.velocidadActual) / (auto.velocidadMaxima), 5);
                }
                else
                {
                    EjemploAlumno.instance.activar_efecto = false;
                }
            }
            GuiController.Instance.ThirdPersonCamera.Target = auto.mesh.Position;

            //actualizo cam
            Vector2 vectorCam = (Vector2)GuiController.Instance.Modifiers["AlturaCamara"];
            GuiController.Instance.ThirdPersonCamera.setCamera(auto.mesh.Position, vectorCam.X, vectorCam.Y);

            float tope = 1f;
            float constanteDerrape = ((tiempoTrans / 2) < tope) ? (tiempoTrans / 2) : tope;
            float proporcion = FastMath.Abs(auto.velocidadActual / auto.velocidadMaxima);
            if (sentidoAnterior != sentidoRotacion && tiempoTrans != 0) incrementarTiempo(this, elapsedTime * 5, true);
            if (tiempoTrans == 0) sentidoAnterior = sentidoRotacion;

            auto.mesh.rotateY(constanteDerrape * sentidoAnterior * proporcion);

            auto.render();

            auto.obb = TgcObb.computeFromAABB(auto.mesh.BoundingBox);
            auto.obb.setRotation(auto.mesh.Rotation);
            auto.obb.setRenderColor(colorDeColision);

            auto.mesh.rotateY(-constanteDerrape * sentidoAnterior * proporcion);

            //dibuja el nivel
            nivel.render(elapsedTime);

            //AJUSTE DE CAMARA SEGUN COLISION
            ajustarCamaraSegunColision(auto, nivel.obstaculos);

            //Dibujo checkpoints restantes
            nivel.checkpointsRestantes.render();

            //Dibujo el puntaje del juego
            this.puntos.render();

            //CUENTA REGRESIVA
            if (this.tiempoRestante.Text == "1")
            {
                uno.render();
            }
            if (this.tiempoRestante.Text == "2")
            {
                dos.render();
            }

            if (this.tiempoRestante.Text == "3")
            {
                tres.render();
            }

            //Actualizo y dibujo el relops
            if ((DateTime.Now.Subtract(this.horaInicio).TotalSeconds) > segundosAuxiliares && !modoDios)
            {
                this.tiempoRestante.Text = (Convert.ToDouble(tiempoRestante.Text) - 1).ToString();
                if (this.tiempoRestante.Text == "0") //Si se acaba el tiempo, me muestra el game over y reseetea todo
                {
                    finDeJuego = true;
                    muerte = true;
                }
                segundosAuxiliares++;
            }
            this.tiempoRestante.render();

            //Si se le acabo el tiempo o la vida, o apretó "Q"
            if (finDeJuego)
            {
                //corta la música al salir
                TgcMp3Player player = GuiController.Instance.Mp3Player;
                player.closeFile();
                GuiController.Instance.UserVars.clearVars();
                //saca el blur
                EjemploAlumno.instance.activar_efecto = false;
                //reinicia los valores de las cosas del juego
                auto.reiniciar();
                nivel.reiniciar();
                this.reiniciar();
                //reinicia la camara
                GuiController.Instance.ThirdPersonCamera.resetValues();
                if (muerte)
                {
                    EjemploAlu.setPantalla(EjemploAlu.getPantalla(1));
                }
                else if (salirConQ)
                {
                    EjemploAlumno.getInstance().setPantalla(new PantallaInicio());
                }
                else
                {
                    EjemploAlu.setPantalla(EjemploAlu.getPantalla(2));
                }
            }

            if (comienzoNivel)
            {
                if (DateTime.Now.Subtract(this.horaInicio).TotalSeconds < 3)
                {
                    if (auto.nombre == "Luigi")
                    {
                        misionLuigi.render();
                    }
                    else
                    {
                        misionMario.render();
                    }
                }
                else
                {
                    comienzoNivel = false;
                }
            }
            else
            {
                //Dibujo barrita
                if (auto.nombre == "Luigi")
                {
                    barra2.render();
                }
                else
                {
                    barra.render();
                }
                vida.render();

            }
            //renderizo utilidades del debugMode
            if (Shared.debugMode)
            {
                Vector2 vectorModifier = (Vector2)GuiController.Instance.Modifiers["PosicionFlechaDebug"];
                Vector3 vectorPosicion = new Vector3(vectorModifier.X, 10, vectorModifier.Y);
                debugArrow.PStart = vectorPosicion + new Vector3(0, 400f, 0);
                debugArrow.PEnd = vectorPosicion;
                debugArrow.updateValues();
                debugArrow.render();

                //renderizo normal al plano chocado
                if (obstaculoChocado != null)
                {
                    collisionNormalArrow.PStart = obstaculoChocado.obb.Center;
                    collisionNormalArrow.PEnd = obstaculoChocado.obb.Center + Vector3.Multiply(new Vector3(caraChocada.A, caraChocada.B, caraChocada.C), 500f);
                    collisionNormalArrow.updateValues();
                    collisionNormalArrow.render();
                }
            }
        }
Exemple #4
0
        private void crearNivel1(  )
        {
            //Construcción del escenario del nivel 1
            int cantVueltas = 1;    //este nivel va tener una vuelta para que se pueda ganar
            TgcBox piso;

            // ----- PÉRGOLA ----- //
            TgcSimpleTerrain terrain;
            string currentHeightmap;
            string currentTexture;
            float currentScaleXZ;
            float currentScaleY;

            //Path de Heightmap default del terreno y Modifier para cambiarla
            currentHeightmap = Shared.mediaPath + "\\otros\\heighmap.jpg";
            currentScaleXZ = 12f;
            currentScaleY = 2.2f;
            currentTexture = Shared.mediaPath + "\\otros\\block02.png";

            //Cargar terreno: cargar heightmap y textura de color
            terrain = new TgcSimpleTerrain();
            terrain.loadHeightmap(currentHeightmap, currentScaleXZ, currentScaleY, new Vector3(0, 0, -300));
            terrain.loadTexture(currentTexture);

            //elementos.Add(hongo);
            List<TgcScene> arboles = EjemploAlumno.getInstance().getArboles();
            float separacionEntreArboles = 0f;
            float inclinacionFila = 0f;
            foreach (TgcScene escenaArbol in arboles)
            {
                TgcMesh arbol = escenaArbol.Meshes[0];
                arbol.Position= new Vector3(600+separacionEntreArboles, 0, 2400+inclinacionFila);
                arbol.Scale = new Vector3(23f, 23f,23f);
                elementos.Add(arbol);
                separacionEntreArboles += 500f;
                inclinacionFila += 60f;
            }

            TgcTexture textura = TgcTexture.createTexture(GuiController.Instance.D3dDevice, GuiController.Instance.AlumnoEjemplosMediaDir + "LosBorbotones\\escenario\\pista3.jpg");
            piso = TgcBox.fromSize(new Vector3(0, 0, 0), new Vector3(15000, 0, 10000), textura); //es un cubo plano con una textura (foto de la pista)

            cielo = new TgcSkyBox(); //Se crea el cielo, es como un cubo grande que envuelve todo y sirve de límite
            cielo.Center = new Vector3(0, 0, 0);
            cielo.Size = new Vector3(20000, 9000, 18000);
            cielo.setFaceTexture(TgcSkyBox.SkyFaces.Up, Shared.mediaPath + "\\escenario\\cielo.jpg");
            cielo.setFaceTexture(TgcSkyBox.SkyFaces.Down, Shared.mediaPath + "\\escenario\\cielo.jpg");
            cielo.setFaceTexture(TgcSkyBox.SkyFaces.Left, Shared.mediaPath + "\\escenario\\cielo.jpg");
            cielo.setFaceTexture(TgcSkyBox.SkyFaces.Right, Shared.mediaPath + "\\escenario\\cielo.jpg");
            cielo.setFaceTexture(TgcSkyBox.SkyFaces.Front, Shared.mediaPath + "\\escenario\\cielo.jpg");
            cielo.setFaceTexture(TgcSkyBox.SkyFaces.Back, Shared.mediaPath + "\\escenario\\cielo.jpg");
            cielo.updateValues();

            cajas.Add(piso);

            //CARGAR OBSTÁCULOS
            obstaculos.Add(new ObstaculoRigido(-100, 0, -1800, 3700, 300, 80, Shared.mediaPath + "\\otros\\block01.jpg"));
            obstaculos.Add(new ObstaculoRigido(-1300, 0, -100, 80, 300, 3200, Shared.mediaPath + "\\otros\\block01.jpg"));
            obstaculos.Add(new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\columna\\columna-TgcScene.xml", new Vector3(5650, 0, -3000), new Vector3(15f, 15f, 15f)));
            obstaculos.Add(new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\columna\\columna-TgcScene.xml", new Vector3(5500, 0, -3250), new Vector3(10f, 10f, 10f)));
            obstaculos.Add(new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\columna\\columna-TgcScene.xml", new Vector3(5850, 0, -3000), new Vector3(5f, 5f, 5f)));
            obstaculos.Add(new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\carnivora\\carnivora-TgcScene.xml", new Vector3(2000, 0, 0), new Vector3(7f, 7f, 7f)));
            ObstaculoRigido p = new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\carnivora\\carnivora-TgcScene.xml", new Vector3(2200, 0, 100), new Vector3(5f, 5f, 5f));
            p.mesh.rotateY(0.5f);
            obstaculos.Add(p);

            //guardabarros
            obstaculos.Add(new ObstaculoRigido(7625, -400, 0, 250, 1100, 10000, Shared.mediaPath + "\\otros\\block01.jpg"));
            obstaculos.Add(new ObstaculoRigido(-7625, -400, 0, 250, 1100, 10000, Shared.mediaPath + "\\otros\\block01.jpg"));
            obstaculos.Add(new ObstaculoRigido(0, -400, 5125, 15000, 1100, 250, Shared.mediaPath + "\\otros\\block01.jpg"));
            obstaculos.Add(new ObstaculoRigido(0, -400, -5125, 15000, 1100, 250, Shared.mediaPath + "\\otros\\block01.jpg"));

            //Checkpoints
            for (int m = 0; m < cantVueltas; m++)
            {
                this.PosicionesCheckpoints.Add(new Vector3(5300, -4000, 0));
                this.PosicionesCheckpoints.Add(new Vector3(0, 0, 0));
                this.PosicionesCheckpoints.Add(new Vector3(6000, 2500, 0));
                this.PosicionesCheckpoints.Add(new Vector3(-5000, 4500, 0));
                this.PosicionesCheckpoints.Add(new Vector3(-5000, 1750, 0));
                this.PosicionesCheckpoints.Add(new Vector3(-2500, -500, 0));
                this.PosicionesCheckpoints.Add(new Vector3(-5500, -2500, 0));
                this.PosicionesCheckpoints.Add(new Vector3(-5000, -4500, 0));
                this.PosicionesCheckpoints.Add(new Vector3(0, -2500, 0));
            }

            this.agregarCheckpoints();

            checkpointActual = checkpoints.ElementAt(0);
            checkpointsRestantes = new TgcText2d();
            checkpointsRestantes.Text = checkpoints.Count().ToString();
            checkpointsRestantes.Color = Color.DarkRed;
            checkpointsRestantes.Align = TgcText2d.TextAlign.RIGHT;
            checkpointsRestantes.Position = new Point(630, 30);
            checkpointsRestantes.Size = new Size(100, 50);
            checkpointsRestantes.changeFont(new System.Drawing.Font("TimesNewRoman", 25, FontStyle.Bold));

               ObstaculoRigido hV = new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\HongoVerde\\HongoVerde-TgcScene.xml", new Vector3(-4300, 0, -300), new Vector3(2f, 2f, 2f));
               hV.mesh.rotateY(0.2f);
            obstaculos.Add(hV);
            obstaculos.Add(new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\HongoRojo\\HongoRojo-TgcScene.xml", new Vector3(-4200, 0, -300), new Vector3(0.5f, 0.5f, 0.5f)));
            obstaculos.Add(new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\HongoRojo\\HongoRojo-TgcScene.xml", new Vector3(-4300, 0, -400), new Vector3(1.2f, 1.2f, 1.2f)));

            obstaculos.Add(new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\HongoRojo\\HongoRojo-TgcScene.xml", new Vector3(-5000, 0, 3000), new Vector3(2f, 2f, 2f)));
            obstaculos.Add(new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\HongoVerde\\HongoVerde-TgcScene.xml", new Vector3(-5100, 0, 3000), new Vector3(0.5f, 0.5f, 0.5f)));
            obstaculos.Add(new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\HongoVerde\\HongoVerde-TgcScene.xml", new Vector3(-5100, 0, 3000), new Vector3(1.5f, 1.5f, 1.5f)));
            obstaculos.Add(new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\HongoVerde\\HongoVerde-TgcScene.xml", new Vector3(-4900, 0, 3100), new Vector3(0.2f, 0.2f, 0.2f)));

            ObstaculoRigido b = new ObstaculoRigido(Shared.mediaPath + "\\ambientacion\\bar\\bar-TgcScene.xml", new Vector3(2300, 0, 2600), new Vector3(67f, 15f, 20f));
            obstaculos.Add(b);

            foreach (ObstaculoRigido obstaculo in obstaculos)
            {
                objetos.Add(obstaculo.mesh);
            }
            foreach (TgcMesh elemento in elementos)
            {
                objetos.Add(elemento);
            }
            foreach (Recursos recurso in recursos)
            {
                objetos.Add(recurso.modelo);
            }

            //Crear grilla
            quadtree = new Quadtree();
            quadtree.create(objetos, escenarioBB);
            quadtree.createDebugQuadtreeMeshes();

            GuiController.Instance.Modifiers.addBoolean("showQuadtree", "Show Quadtree", false);

            terrenos.Add(terrain);
        }