public override TgcBoundingAxisAlignBox ColisionConPiso(TgcBoundingAxisAlignBox boundingBox)
 {
     if (Escenario.testAABBAABB(PisoSelva.BoundingBox, boundingBox))
     {
         return(PisoSelva.BoundingBox);
     }
     return(null);
 }
        public override void Render(Escenario.Escenario esc)
        {
            var ElapsedTime = Env.ElapsedTime;

            Mesh.Transform = TGCMatrix.Scaling(Mesh.Scale)
                             * TGCMatrix.RotationYawPitchRoll(Mesh.Rotation.Y, Mesh.Rotation.X, Mesh.Rotation.Z)
                             * TGCMatrix.Translation(Mesh.Position);
            esc.RenderObject(Mesh);
            //IMPORTANTE PARA PERMITIR ESTE EFECTO.
            D3DDevice.Instance.ParticlesEnabled = true;
            D3DDevice.Instance.EnableParticles();
            if (Mesh.CurrentAnimation.Name == "Run")
            {
                emitter.render(ElapsedTime);
            }
        }
        public override TgcBoundingAxisAlignBox ColisionY(TgcBoundingAxisAlignBox boundingBox)
        {
            TgcBoundingAxisAlignBox Colisionador = null;

            foreach (var plataforma in Plataformas)
            {
                if (Escenario.testAABBAABB(plataforma.Mesh.BoundingBox, boundingBox))
                {
                    if (plataforma.Mesh.BoundingBox.PMin.Y < Env.Personaje.Mesh.BoundingBox.PMax.Y && plataforma.Mesh.BoundingBox.PMin.Y + (plataforma.Mesh.BoundingBox.PMax.Y - plataforma.Mesh.BoundingBox.PMin.Y) * 0.5f > Env.Personaje.Mesh.BoundingBox.PMax.Y)
                    {
                        Env.Personaje.setposition(plataforma.Mesh.BoundingBox.PMin - (Env.Personaje.Mesh.BoundingBox.PMax - Env.Personaje.Mesh.BoundingBox.PMin));
                        Env.Personaje.SetTipoColisionActual(TiposColision.Techo);
                    }
                    else
                    {
                        if (plataforma.Mesh.BoundingBox.PMin.Y < Env.Personaje.Mesh.Position.Y)
                        {
                            Colisionador = plataforma.Mesh.BoundingBox;
                        }

                        Env.Personaje.setposition(plataforma.deltaPosicion());
                        Env.Personaje.SetTipoColisionActual(TiposColision.Caja);
                    }
                }
            }
            foreach (var escalon in ListaEscalones)
            {
                if (Escenario.testAABBAABB(escalon.BoundingBox, boundingBox))
                {
                    //Env.Personaje.SetTipoColisionActual(TiposColision.Escalon);
                    Colisionador = escalon.BoundingBox;
                }
            }
            foreach (var caja in ListaCajasEmpujables)
            {
                var colision = caja.ColisionY(Env.Personaje, Env.ElapsedTime);
                if (colision != null)
                {
                    Colisionador = colision;
                }
            }
            if (Colisionador != null)
            {
                return(Colisionador);
            }
            var piso = ColisionConPiso(boundingBox);

            if (piso != null)
            {
                bool agujero = false;
                foreach (var pozo in ListaPozos)
                {
                    if (Escenario.testAABBAABBXZIn(boundingBox, pozo.BoundingBox))
                    {
                        Env.Personaje.SetTipoColisionActual(TiposColision.Pozo);
                        agujero = true;
                        break;
                    }
                }
                if (!agujero)
                {
                    Colisionador = piso;
                }
            }
            return(Colisionador);
        }
        public override TgcBoundingAxisAlignBox ColisionXZ(TgcBoundingAxisAlignBox boundingBox)
        {
            // null => no hay colision
            TgcBoundingAxisAlignBox Colisionador = null;

            foreach (var Mesh in Scene.Meshes.FindAll(m => m.Enabled))
            {
                if (!ListaMeshesSinColision.Contains(Mesh) && Escenario.testAABBAABB(Mesh.BoundingBox, boundingBox))
                {
                    if (ListaPozos.Contains(Mesh))
                    {
                        Env.Personaje.SetTipoColisionActual(TiposColision.Pozo);
                        break;
                    }
                    else if (ListaPlataformas.Contains(Mesh))
                    {
                        if (Mesh.BoundingBox.PMax.Y > Env.Personaje.Mesh.Position.Y || Mesh.BoundingBox.PMin.Y < Env.Personaje.Mesh.Position.Y)
                        {
                            Colisionador = Mesh.BoundingBox;

                            break;
                        }
                    }
                    else if (ListaPisosResbalosos.Contains(Mesh))
                    {
                        Env.Personaje.SetTipoColisionActual(TiposColision.PisoResbaloso);
                        break;
                    }
                    else if (ListaEscalones.Contains(Mesh))
                    {
                        var c    = Mesh.BoundingBox;
                        var aabb = Env.Personaje.Mesh.BoundingBox;
                        Env.Personaje.setposition(new TGCVector3(0, c.PMax.Y - Env.Personaje.Position().Y, 0));
                        Env.Personaje.SetTipoColisionActual(TiposColision.Caja);
                        break;
                    }
                    else if (ListaLogos.Contains(Mesh))
                    {
                        ListaLogosQuitados.Add(Mesh);
                        Scene.Meshes.Remove(Mesh);
                        //Mesh.Enabled = false; //Deberia dejar de mostrarse
                        ListaLogos.Remove(Mesh); //lo quito de la lista asi no se contabiliza
                        CantLogos = ListaLogos.Count;
                        break;
                    }

                    else
                    {
                        Colisionador = Mesh.BoundingBox;
                    }
                    break;
                }
            }
            foreach (var caja in ListaCajasEmpujables)
            {
                var aabb = caja.Mesh.BoundingBox;
                if (!Escenario.testAABBAABB(aabb, boundingBox))
                {
                    continue;
                }
                var oldCajaPos = caja.Mesh.Position;
                caja.ColisionXZ(Env.Personaje);
                bool colisionDeCaja = false;
                foreach (var Mesh in Scene.Meshes.FindAll(m => m.Enabled))
                {
                    if (Escenario.testAABBAABB(aabb, Mesh.BoundingBox))
                    {
                        colisionDeCaja = true;
                        continue;
                    }
                }
                if (colisionDeCaja)
                {
                    Colisionador       = aabb;
                    caja.Mesh.Position = oldCajaPos;
                    break;
                }
                foreach (var pozo in ListaPozos)
                {
                    if (Escenario.testAABBAABBXZIn(aabb, pozo.BoundingBox))
                    {
                        caja.caer();
                        continue;
                    }
                }
            }
            foreach (var Mesh in MeshConMovimiento)
            {
                if (!ListaMeshesSinColision.Contains(Mesh) && Escenario.testAABBAABB(Mesh.BoundingBox, boundingBox))
                {
                    if (ListaPozos.Contains(Mesh))
                    {
                        Env.Personaje.SetTipoColisionActual(TiposColision.Pozo);
                    }
                    else if (ListaPlataformas.Contains(Mesh))
                    {
                        if (PlataformaY.Equals(Mesh))
                        {
                            posMuerte = -255;
                        }

                        if (Mesh.BoundingBox.PMax.Y > Env.Personaje.Mesh.Position.Y || (Mesh.BoundingBox.PMin.Y < Env.Personaje.Mesh.BoundingBox.PMax.Y && Mesh.BoundingBox.PMax.Y > Env.Personaje.Mesh.BoundingBox.PMax.Y))
                        {
                            Colisionador = Mesh.BoundingBox;
                        }
                    }
                    else if (ListaPisosResbalosos.Contains(Mesh))
                    {
                        Env.Personaje.SetTipoColisionActual(TiposColision.PisoResbaloso);
                    }
                    else
                    {
                        Colisionador = Mesh.BoundingBox;
                    }
                    break;
                }
            }
            return(Colisionador);
        }
Пример #5
0
 public abstract void Render(Escenario.Escenario esc);