コード例 #1
0
        private void inicializarBarriles()
        {
            string alumnoMediaFolder = GuiController.Instance.AlumnoEjemplosMediaDir;
            Random rand1 = new Random();
            //Cargar modelo de palmera original
            TgcSceneLoader loader1 = new TgcSceneLoader();
            scene = loader1.loadSceneFromFile(GuiController.Instance.ExamplesMediaDir + "MeshCreator\\Meshes\\Objetos\\BarrilPolvora\\BarrilPolvora-TgcScene.xml");
            barril = scene.Meshes[0];
            //barril.AlphaBlendEnable = true;

            //Crear varias instancias del modelo original, pero sin volver a cargar el modelo entero cada vez
            int rows = 2;
            int cols = 5;
            barriles = new List<Barril>();
            explosiones = new List<TgcMesh>();
            //bool moverFila=false;

            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < cols; j++)
                {
                    //Crear instancia de modelo
                    TgcMesh instance = barril.createMeshInstance(barril.Name + i + "_" + j);
                    instance.AlphaBlendEnable = true;
                    TgcMesh instanceExplosion = esferaExplosion.createMeshInstance(i + "_" + j);
                    instanceExplosion.AlphaBlendEnable = true;

                    //Desplazarlo
                    instance.move(rand1.Next(-5000, 5000), 0, rand1.Next(-5000, 5000));
                    instance.Scale = new Vector3(4f, 4f, 4f);

                    instanceExplosion.Position = instance.Position;
                    instanceExplosion.move(new Vector3(0f, 100f, 0f));
                    instanceExplosion.Scale = new Vector3(6f, 6f, 6f);

                    Effect fx = TgcShaders.loadEffect(GuiController.Instance.AlumnoEjemplosMediaDir + "Shaders\\explosion.fx");
                    instanceExplosion.Effect = fx;
                    instanceExplosion.Technique = "explosion";

                    Barril instanciaBarril = new Barril(instance);
                    barriles.Add(instanciaBarril);
                    explosiones.Add(instanceExplosion);
                }
            }
        }
コード例 #2
0
        private void jugar(TgcD3dInput input, float t)
        {
            camaraQ3.LockCam = true;
            camaraQ3.updateCamera();

            // Cargar variables de shader, por ejemplo el tiempo transcurrido.
            effect.SetValue("time", time);

            //El personaje es una caja, uso su bounding box para detectar colisiones
            personaje.Position = camaraQ3.getPosition();
            personaje.move(new Vector3(0f, -30f, 0f));
            //personaje.render();
            //personaje.BoundingBox.render();

            foreach (TgcBoundingBox item in obtenerListaZona(ultimaPosCamara))
            {
                if (TgcCollisionUtils.testAABBAABB(personaje.BoundingBox, item))
                {
                    camaraQ3.setPosition(ultimaPosCamara);
                    //camaraQ3.setCamera(ultimaPosCamara, camaraQ3.getLookAt() + ultimaPosCamara);
                }
            }

            if (GuiController.Instance.D3dInput.keyDown(Microsoft.DirectX.DirectInput.Key.C))
            {
                velocidadEnemigos = velocidadEnemigos + 0.4f;
                if (velocidadEnemigos >= 0f)
                {
                    velocidadEnemigos = 0f;
                }
            }
            if (GuiController.Instance.D3dInput.keyDown(Microsoft.DirectX.DirectInput.Key.V))
            {
                velocidadEnemigos = velocidadEnemigos - 0.4f;
            }

            ajustarZoom();
            ajustarVelocidad();

            renderizarBarriles(t);
            renderizarPiedras();

            //Renderizar suelo y skybox
            piso.render();
            //terreno.render();
            skyBox.render();

            //Emitir un disparo
            if (input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
            {
                posicionRayBala = camaraQ3.getPosition();
                unaBala.velocidadVectorial = camaraQ3.getLookAt() - camaraQ3.getPosition();
                unaBala.ray = new TgcRay(posicionRayBala, unaBala.velocidadVectorial);
                huboDisparo = true;
                disparo.SoundBuffer.SetCurrentPosition(0);
                disparo.play(false);
            }
            //Reviso si colisiono contra un barril si hubo disparo
            if (huboDisparo)
            {
                foreach (Barril b in barriles)
                {
                    if (!b.fueDisparado && TgcCollisionUtils.intersectRayAABB(unaBala.ray, b.mesh.BoundingBox, out col))
                    {

                        boundingBarril = new TgcBoundingSphere(b.mesh.BoundingBox.calculateBoxCenter(), 400f);
                        disparoBarril = true;
                        barrilDisparado = b;
                        b.fueDisparado = true;
                        if (barriles.TrueForAll(fueDisparado))
                        {
                            reproducirSorpresa = true;
                        }
                        explosion.SoundBuffer.SetCurrentPosition(0);
                        explosion.play(false);
                        huboDisparo = false;
                        break;
                    }
                }
                if (barrilDisparado!=null)
                {
                    //barriles.Remove(barrilDisparado);
                    barrilDisparado = null;
                }
            }

            //Se dibuja siempre al principio, habria que hacer instancias y dibujarlas cada vez que se disparo a un barril en esa posicion

            //Renderizar original e instancias (no dibujo original, solo instancias)
            foreach (Enemigo enemigo in instanciasEnemigos)
            {
                enemigo.meshEnemigo.animateAndRender();
                if (enemigo.estaVivo)
                {
                    rotarMesh(enemigo.meshEnemigo);
                    enemigo.meshEnemigo.moveOrientedY(velocidadEnemigos);
                    enemigo.ultimaPosicion = enemigo.meshEnemigo.Position;
                    foreach (Barril item in barriles)
                    {
                        if (TgcCollisionUtils.testAABBAABB(enemigo.meshEnemigo.BoundingBox, item.mesh.BoundingBox))
                        {
                            enemigo.meshEnemigo.rotateY(FastMath.PI_HALF);
                            enemigo.meshEnemigo.moveOrientedY(velocidadEnemigos);
                        }
                    }
                    foreach (TgcBoundingBox bb in obtenerListaZona(enemigo.meshEnemigo.Position))
                    {
                        if (TgcCollisionUtils.testAABBAABB(enemigo.meshEnemigo.BoundingBox, bb))
                        {
                            enemigo.meshEnemigo.rotateY(FastMath.PI_HALF);
                            enemigo.meshEnemigo.moveOrientedY(velocidadEnemigos);
                        }
                    }

                    //enemigo colisiona contra personaje
                    if(TgcCollisionUtils.classifyBoxBox(enemigo.meshEnemigo.BoundingBox,personaje.BoundingBox) != TgcCollisionUtils.BoxBoxResult.Afuera)
                    {
                        //golpe.SoundBuffer.SetCurrentPosition(0);
                        golpe.play(false);
                        enemigo.meshEnemigo.moveOrientedY(-velocidadEnemigos*5);
                        camaraQ3.setPosition(ultimaPosCamara);
                        numVida -= 20f * t;
                        barraVida.Scaling = new Vector2(0.3f*0.01f * numVida, 0.3f);
                        //Muerte del personaje
                        if (numVida<=0)
                        {
                            camaraQ3.LockCam = false;
                            muerte.SoundBuffer.SetCurrentPosition(0);
                            muerte.play(false);
                            player.stop();
                            //player.closeFile();
                            estadoJuego = estado.muerto;
                        }
                    }

                    if (huboDisparo || disparoBarril)
                    {
                        if (disparoBarril)
                        {
                            if (TgcCollisionUtils.testSphereAABB(boundingBarril,enemigo.meshEnemigo.BoundingBox))
                            {
                                matarEnemigo(enemigo);
                            }
                        }
                        if (TgcCollisionUtils.intersectRayAABB(unaBala.ray, enemigo.meshEnemigo.BoundingBox, out col))
                        {
                            Vector3 p = enemigo.meshEnemigo.BoundingBox.calculateBoxCenter();
                            p.Y = 0f;
                            TgcBoundingBox cuerpoChico = enemigo.meshEnemigo.BoundingBox.clone();
                            cuerpoChico.scaleTranslate(p, new Vector3(1.8f, 3.2f, 1.8f));
                            //se evalua si la bala dio contra el enemigo
                            if (TgcCollisionUtils.intersectRayAABB(unaBala.ray, cuerpoChico, out col))
                            {
                                TgcBoundingBox head = enemigo.meshEnemigo.BoundingBox.clone();
                                head.scaleTranslate(enemigo.meshEnemigo.BoundingBox.calculateBoxCenter() + new Vector3(0.0f, 60f, 5.0f), new Vector3(0.5f, 0.5f, 0.5f));
                                //se evalua si fue un headshot
                                if (TgcCollisionUtils.intersectRayAABB(unaBala.ray, head, out col))
                                {
                                    headshot.SoundBuffer.SetCurrentPosition(0);
                                    headshot.play(false);
                                    puntaje += 20; //el headshot me da 20 puntos mas que un disparo normal
                                }
                                matarEnemigo(enemigo);
                                huboDisparo = false;
                            }
                        }

                    }
                }
                else
                {
                    enemigo.tiempo += t;
                    enemigo.efecto.SetValue("time", enemigo.tiempo);
                }

            }
            huboDisparo = false;
            disparoBarril = false;

            if (instanciasEnemigos.TrueForAll(estaMuerto))
            {
                if (puntaje > Int32.Parse(System.IO.File.ReadAllText(alumnoMediaFolder + "\\record.txt")))
                {
                    textoPuntajeFinal.Text = "Nuevo Record! Tu puntaje fue: " + puntaje.ToString();
                    System.IO.File.WriteAllText(alumnoMediaFolder + "\\record.txt", puntaje.ToString());
                    //textoPuntajeRecord.Text = "Tu puntaje record es: " + puntaje.ToString();
                }
                else
                {
                    textoPuntajeFinal.Text = "Tu puntaje fue: " + puntaje.ToString();
                }
                player.stop();
                camaraQ3.LockCam = false;
                ganador.SoundBuffer.SetCurrentPosition(0);
                ganador.play(false);
                player.stop();
                estadoJuego = estado.ganador;

            }

            //enemigoEffect.SetValue("time", time);

            //Renderizar instancias
            //renderizarTodosLosArboles();
            //renderizarPasto();
            qt.render(GuiController.Instance.Frustum, false);
            ultimaPosCamara = camaraQ3.getPosition();

            //DIBUJOS 2D
            renderSprites(input);
        }
コード例 #3
0
 private bool fueDisparado(Barril b)
 {
     return b.fueDisparado;
 }