Beispiel #1
0
 private void initialize()
 {
     Program.GAME.ComponentManager.addUpdateableOnly(this);
     // crea la entidad
     this.collisionEntity = new Entity(GlobalIDs.CAMERA_ENTITY_ID);
     // crea body de colision
     // para que quede justo en el centro de focus
     float x = (viewportWidth / 2) - (initCollisionWidth / 2);
     float y = (viewportHeight / 2) - (initCollisionHeight / 2);
     this.cameraCollisionBody = ShapeFactory.CreateRectangle(GlobalIDs.CAMERA_COLLISION_BODY_ID, collisionEntity, true, false/*, viewportWidth - 80, viewportHeight - 80, new Vector2(40, 40)*/, viewportWidth, viewportHeight, Vector2.Zero, false, GameLayers.FRONT_HUD_AREA);
     // componente de colision basico
     this.collisionEntity.addComponent(new AnimatedCollisionComponent(collisionEntity, this.cameraCollisionBody));
     // asigna x y y
     this.collisionEntity.addVectorProperty(EntityProperty.Position, new Vector2(x, y));
     // registrar listener
     EventManager.Instance.addListener(EventType.POSITION_CHANGED_EVENT, collisionEntity, this);
 }
Beispiel #2
0
        /// <summary>
        /// Verifica si este poligono esta colisionando o va a colisionar
        /// con una caja (rectangulo) dada
        /// Esta verificación se realiza utilizando SAT (Separating Axis Theorem) la cual explica
        /// que, si existe una linea en el plano que pueda separar dos distintas figuras en diferentes
        /// lados por completo, entonces estas figuras no están colisionando.
        /// Nota: Este teorema solo debería aplicarse ante poligonos concavos, de otra forma el algoritmo
        /// no daria una respuesta correcta ante poligonos convexos.
        /// </summary>
        /// <param name="box">Caja con la cual se hará la verificacion</param>
        /// <param name="distance">Distancia por la cual se movera este poligono</param>
        /// <param name="result">Referencia del objeto que contendrá la información necesaria sobre 
        /// si se esta intersectando, si se intersectará y la distancia necesaria 
        /// para evitar una intersección</param>
        protected override CollisionResult IntersectWithBox(Box box, ref Vector2 distance)
        {
            CollisionResult result = new CollisionResult();
            result.triggeringBody = this;
            result.affectedBody = box;
            // Se asume que ambas figuras intersectan hasta que
            // se pueda demostrar lo contrario
            result.intersect = true;
            result.willIntersect = true;
            // Se obtiene la cantidad de lados del poligono y del
            // rectangulo (Para el rectangulo solo es necesario estudiar dos lados)
            int sideCountPolygon = this.sides.Count;
            int sideCountRectangle = 2;
            float minIntervalDistance = float.PositiveInfinity;
            Vector2 translationAxis = new Vector2();
            // Lado actual a analizar
            Line currentSide;

            // Se realiza una verificacion por cada uno de los lados del poligono y por dos lados
            // perpendiculares del rectangulo hasta que pueda encontrarse alguna separación entre
            // ambas o hasta que se hayan verificado todos los lados
            for (int sideIndex = 0; sideIndex < sideCountPolygon + sideCountRectangle; sideIndex++)
            {
                if (sideIndex < sideCountPolygon)
                {
                    currentSide = this.sides[sideIndex];
                }
                else
                {
                    if (sideIndex - sideCountPolygon == 0)
                    {
                        currentSide = box.Sides[0];
                    }
                    else
                    {
                        currentSide = box.Sides[1];
                    }
                }

                // Se obtiene un Vector perpendicular al lado actual con valores unitarios,
                // esto servira para obtener el eje sobre el cual deben hacerse las proyecciones
                Vector2 axis = new Vector2(-currentSide.Edge.Y, currentSide.Edge.X);
                axis.Normalize();

                // Se proyectan ambas figuras sobre el mismo eje
                float minA = 0; float minB = 0; float maxA = 0; float maxB = 0;
                this.Project(ref axis, out minA, out maxA);
                box.Project(ref axis, out minB, out maxB);

                // Se obtiene el intervalo entre ambas figuras sobre el eje,
                // si el intervalo (separación) es mayor a 0 entonces las figuras
                // no están intersectando
                float intervalDistance = IntervalDistance(minA, maxA, minB, maxB);
                if (intervalDistance > 0) result.intersect = false;

                // Luego se realizan los mismos calculos pero sumando el vector
                // de velocidad al poligono en (posible) movimiento
                float velocityProjection = Vector2.Dot(axis, distance);

                //if (velocityProjection < 0)
                //{
                    minA += velocityProjection;
                //}
                //else
                //{
                    maxA += velocityProjection;
                //}

                // Si el intervalo de distancia es menor a 0 con el poligono en movimiento,
                // entonces las figuras tambien intersectaran al moverse
                intervalDistance = IntervalDistance(minA, maxA, minB, maxB);
                if (intervalDistance > 0) result.willIntersect = false;

                // Si ya sabemos que las figuras estan intersectando y van a intersectar,
                // no hay mucho mas que hacer aquí asi que terminamos las verificaciones
                if (result.intersect == false && result.willIntersect == false)
                {
                    break;
                }

                // Si el intervalo de distancia es el minimo, se guarda
                // junto con el eje donde fue encontrado para asi poder separar
                // a las figuras en esa dirección
                intervalDistance = Math.Abs(intervalDistance);
                if (intervalDistance < minIntervalDistance)
                {
                    minIntervalDistance = intervalDistance;
                    translationAxis = axis;

                    Vector2 d = this.Center - box.Center;
                    if (Vector2.Dot(d, translationAxis) < 0)
                    {
                        translationAxis = -translationAxis;
                    }
                }
            }

            // El vector minimo de transición
            // servira para separar ambas figuras en caso de que colisionen.
            if (result.willIntersect)
            {
                result.minimumTranslationVector =
                       translationAxis * minIntervalDistance;
            }

            result.translationAxis = translationAxis;
            return result;
        }
Beispiel #3
0
        /// <summary>
        /// Construye un rectangulo según las opciones dadas
        /// </summary>
        /// <param name="id">Id del body</param>
        /// <param name="owner">Owner del body</param>
        /// <param name="isSolid">Si el body es sólido</param>
        /// <param name="relativeToFacing">Determina si se debe tomar en cuenta la dirección 
        /// a la que está mirando la entidad para posicionar el body 
        /// relativo a esa dirección</param>
        /// <param name="width">Ancho del rectangulo</param>
        /// <param name="height">Alto del rectangulo</param>
        /// <param name="startPosition">Coordenadas de inicio del body</param>
        /// <param name="startCenter">Determina si las coordenadas de inicio se refieren 
        /// al primer punto del body o al centro de este</param>
        /// <param name="layer">Capa de colisión donde se encontrará el body</param>
        /// <param name="colorTag">Tag de color especifico para responses que solo se activen ante dicho Tag</param>
        /// <returns>Rectangulo generado</returns>
        public static Box CreateRectangle(string id, IEntity owner, bool isSolid, bool relativeToFacing, float width, float height, Vector2 startPosition, bool startCenter, float layer, Color colorTag)
        {
            if (startCenter)
            {
                startPosition.X -= width / 2;
                startPosition.Y -= height / 2;
            }

            Box box = new Box(id, startPosition.X, startPosition.Y, width, height, owner, isSolid);
            box.Layer = layer;
            box.ColorTag = colorTag;

            if (relativeToFacing)
            {
                bool facingRight = owner.getState(EntityState.FacingRight);
                if (facingRight != true)
                {
                    box.MirrorHorizontal(owner.getVectorProperty(EntityProperty.Position));
                }
            }

            return box;
        }
Beispiel #4
0
        /// <summary>
        /// Construye un rectangulo según las opciones dadas
        /// </summary>
        /// <param name="id">Id del body</param>
        /// <param name="owner">Owner del body</param>
        /// <param name="isSolid">Si el body es sólido</param>
        /// <param name="relativeToFacing">Determina si se debe tomar en cuenta la dirección 
        /// a la que está mirando la entidad para posicionar el body 
        /// relativo a esa dirección</param>
        /// <param name="width">Ancho del rectangulo</param>
        /// <param name="height">Alto del rectangulo</param>
        /// <returns>Rectangulo generado</returns>
        public static Box CreateRectangle(string id, IEntity owner, bool isSolid, bool relativeToFacing, float width, float height)
        {
            Box box = new Box(id, 0, 0, width, height, owner, isSolid);

            if (relativeToFacing)
            {
                bool facingRight = owner.getState(EntityState.FacingRight);
                if (facingRight != true)
                {
                    box.MirrorHorizontal(owner.getVectorProperty(EntityProperty.Position));
                }
            }

            return box;
        }
Beispiel #5
0
 /// <summary>
 /// Verifica si este cuerpo esta colisionando o va a colisionar
 /// con una caja (rectangulo) dada
 /// </summary>
 /// <param name="box">Caja con la cual se hará la verificacion</param>
 /// <param name="distance">Distancia por la cual se movera este cuerpo</param>
 /// <param name="result">Referencia del objeto que contendrá la información necesaria sobre 
 /// si se esta intersectando, si se intersectará y la distancia necesaria 
 /// para evitar una intersección</param>
 protected abstract CollisionResult IntersectWithBox(Box box, ref Vector2 distance);
Beispiel #6
0
        /// <summary>
        /// Verifica si esta esfera esta colisionando o va a colisionar
        /// con una caja (rectangulo) dada
        /// </summary>
        /// <param name="box">Caja con la cual se hará la verificacion</param>
        /// <param name="distance">Distancia por la cual se movera esta esfera</param>
        /// <param name="result">Referencia del objeto que contendrá la información necesaria sobre 
        /// si se esta intersectando, si se intersectará y la distancia necesaria 
        /// para evitar una intersección</param>
        protected override CollisionResult IntersectWithBox(Box box, ref Vector2 distance)
        {
            CollisionResult result = new CollisionResult();
            result.triggeringBody = this;
            result.affectedBody = box;
            // Empezamos asumiendo que las dos figuras no
            // se encuentran intersectando
            result.intersect = false;
            result.willIntersect = false;
            int sideCountRectangle = 4;
            int pointCountRectangle = 4;
            // Dos valores distintos para guardar
            float minIntervalDistanceAfterMove = float.PositiveInfinity;
            float minIntervalDistance = float.PositiveInfinity;
            Vector2 translationAxis = new Vector2();

            // Ahora se estudia cada lado del rectangulo para verificar si el centro
            // de la esfera se encuentra perpendicular a algun punto de ese lado
            for (int sideIndex = 0; sideIndex < sideCountRectangle; sideIndex++)
            {
                Line currentSide = box.Sides[sideIndex];

                // Se crea un vector paralelo al lado donde puedan proyectase
                // ambos puntos del lado actual mas el centro de la esfera
                Vector2 axis = new Vector2(currentSide.Edge.X, currentSide.Edge.Y);
                axis.Normalize();

                float centerA = Vector2.Dot(axis, this.Center);
                float minB = Vector2.Dot(axis, currentSide.StartPoint);
                float maxB = Vector2.Dot(axis, currentSide.EndPoint);

                float velocityProjection = Vector2.Dot(axis, distance);

                // Se realiza un chequeo preliminar antes de sumar el vector
                // de distancia
                #region Verificaciones de intersección actual

                // Si el punto centro se encuentra perpendicular a algun
                // punto del lado actual, entonces la esfera puede encontrarse en esa region
                if (minB <= centerA && maxB >= centerA)
                {
                    // Creamos un eje perpendicular a la linea para obtener la distancia
                    // entre un punto de la linea y el centro de la esfera
                    axis = new Vector2(-currentSide.Edge.Y, currentSide.Edge.X);
                    axis.Normalize();

                    // Ya que el eje es perpendicular, tanto el punto inicial de la linea
                    // como el final terminan en la misma posicion al ser proyectados
                    float pointA = Vector2.Dot(axis, this.Center);
                    float pointB = Vector2.Dot(axis, currentSide.EndPoint);

                    // Se obtiene el intervalo y se guarda en caso de que sea menor
                    // al intervalo anterior (La esfera se encontrara en la region de voronoi
                    // que tenga el punto mas cercano desde la esfera hacia el rectangulo)
                    float intervalDistance = Math.Abs(pointA - pointB);
                    if (intervalDistance < minIntervalDistance)
                    {
                        minIntervalDistance = intervalDistance;
                    }
                }
                #endregion

                // Aplicamos la proyeccion de velocidad a el lado actual
                centerA += velocityProjection;

                // Si el punto centro se encuentra perpendicular a algun
                // punto del lado actual, entonces la esfera puede encontrarse en esa region
                if (minB <= centerA && maxB >= centerA)
                {
                    // Creamos un eje perpendicular a la linea para obtener la distancia
                    // entre un punto de la linea y el centro de la esfera
                    axis = new Vector2(-currentSide.Edge.Y, currentSide.Edge.X);
                    axis.Normalize();

                    // Volvemos a aplicar la proyeccion de velocidad puesto que
                    // esta vez estamos proyectando en un diferente eje
                    velocityProjection = Vector2.Dot(axis, distance);
                    // Ya que el eje es perpendicular, tanto el punto inicial de la linea
                    // como el final terminan en la misma posicion al ser proyectados
                    float pointA = Vector2.Dot(axis, this.Center) + velocityProjection;
                    float pointB = Vector2.Dot(axis, currentSide.EndPoint);

                    // Se obtiene el intervalo y se guarda en caso de que sea menor
                    // al intervalo anterior (La esfera se encontrara en la region de voronoi
                    // que tenga el punto mas cercano desde la esfera hacia el rectangulo)
                    float intervalDistance = Math.Abs(pointA - pointB);
                    if (intervalDistance < minIntervalDistanceAfterMove)
                    {
                        minIntervalDistanceAfterMove = intervalDistance;
                        translationAxis = axis;

                        Vector2 d = this.Center - box.Center;
                        if (Vector2.Dot(d, translationAxis) < 0)
                        {
                            translationAxis = -translationAxis;
                        }
                    }
                }
            }

            // Luego se estudia la distancia entre cada vertice del rectangulo
            // contra el centro de la esfera, si se encuentra alguna distancia
            // menor que las ya guardadas entonces se guarda
            for (int pointIndex = 0; pointIndex < pointCountRectangle; pointIndex++)
            {
                Vector2 currentPoint = box.Points[pointIndex];
                // Creamos una linea que vaya desde el vertice hasta el centro
                // de la esfera, sumandole el vector de distancia al vertice
                Line line = new Line(this.Center + distance, currentPoint);

                Vector2 axis = new Vector2(line.Edge.X, line.Edge.Y);
                axis.Normalize();

                if (line.Lenght < minIntervalDistanceAfterMove)
                {
                    minIntervalDistanceAfterMove = line.Lenght;
                    translationAxis = axis;

                    Vector2 d = this.Center - box.Center;
                    if (Vector2.Dot(d, translationAxis) < 0)
                    {
                        translationAxis = -translationAxis;
                    }
                }

                // Misma verificacion sin sumar el vector de distancia
                #region Verificaciones de intersección actual
                line = new Line(this.Center, currentPoint);

                axis = new Vector2(line.Edge.X, line.Edge.Y);
                axis.Normalize();

                if (line.Lenght < minIntervalDistance)
                {
                    minIntervalDistance = line.Lenght;
                }
                #endregion
            }

            // Se verifica si el poligono intersecta
            bool isInside = box.PointInBody(this.Center);
            if (isInside || minIntervalDistance < this.Radius)
            {
                result.intersect = true;
            }

            // Se verifica si intersectaran y aplica un vector de transicion
            // diferente dependiendo de si el centro de la esfera se encuentra
            // dentro o fuera del rectangulo
            isInside = box.PointInBody(this.Center - distance);
            if (isInside)
            {
                result.minimumTranslationVector =
                       translationAxis * (this.Radius + minIntervalDistanceAfterMove);
                result.willIntersect = true;
            }
            else if (minIntervalDistanceAfterMove < this.Radius)
            {
                result.minimumTranslationVector =
                       translationAxis * Math.Abs(this.Radius - minIntervalDistanceAfterMove);
                result.willIntersect = true;
            }

            result.translationAxis = translationAxis;
            return result;
        }
Beispiel #7
0
        /// <summary>
        /// Verifica si este rectangulo esta colisionando o va a colisionar
        /// con otro rectangulo dado.
        /// Esta verificación se realiza utilizando SAT (Separating Axis Theorem) la cual explica
        /// que, si existe una linea en el plano que pueda separar dos distintas figuras en diferentes
        /// lados por completo, entonces estas figuras no están colisionando.
        /// Nota: Este teorema solo debería aplicarse ante poligonos concavos, de otra forma el algoritmo
        /// no daria una respuesta correcta ante poligonos convexos.
        /// </summary>
        /// <param name="box">Segundo rectangulo con el cual se hará la verificacion</param>
        /// <param name="distance">Distancia por la cual se movera el rectangulo principal (this)</param>
        /// <param name="result">Referencia del objeto que contendrá la información necesaria sobre 
        /// si se esta intersectando, si se intersectará y la distancia necesaria 
        /// para evitar una intersección</param>
        protected override CollisionResult IntersectWithBox(Box box, ref Vector2 distance)
        {
            CollisionResult result = new CollisionResult();
            result.triggeringBody = this;
            result.affectedBody = box;
            // Se asume que ambos rectangulos intersectan hasta que
            // se pueda demostrar lo contrario
            result.intersect = true;
            result.willIntersect = true;
            float minIntervalDistance = float.PositiveInfinity;
            Vector2 translationAxis = new Vector2();
            Line currentSide;
            Vector2 axis = Vector2.Zero;

            // Se realiza una verificacion por dos lados perpendiculares de cada rectangulo
            // hasta que pueda encontrarse alguna separación entre ambos o hasta que se hayan
            // verificado todos los lados
            for (int edgeIndex = 0; edgeIndex < 4; edgeIndex++)
            {
                if (edgeIndex < 2)
                {
                    if (edgeIndex == 0)
                    {
                        currentSide = this.sides[0];
                    }
                    else
                    {
                        currentSide = this.sides[1];
                    }
                }
                else
                {
                    if (edgeIndex - 2 == 0)
                    {
                        currentSide = box.sides[0];
                    }
                    else
                    {
                        currentSide = box.sides[1];
                    }
                }

                // Se obtiene un Vector perpendicular al lado actual con valores unitarios,
                // esto servira para obtener el eje sobre el cual deben hacerse las proyecciones
                axis.X = -currentSide.Edge.Y;
                axis.Y = currentSide.Edge.X;
                axis.Normalize();

                // Se proyectan ambos rectangulos sobre el mismo eje
                float minA = 0; float minB = 0; float maxA = 0; float maxB = 0;
                this.Project(ref axis, out minA, out maxA);
                box.Project(ref axis, out minB, out maxB);

                // Se obtiene el intervalo entre ambos rectangulos sobre el eje,
                // si el intervalo (separación) es mayor a 0 entonces los rectangulos
                // no están intersectando
                float intervalDistance = IntervalDistance(minA, maxA, minB, maxB);
                if (intervalDistance > 0) result.intersect = false;

                // Luego se realizan los mismos calculos pero sumando el vector
                // de velocidad al rectangulo en (posible) movimiento
                float velocityProjection;
                Vector2.Dot(ref axis, ref distance, out velocityProjection);

                //if (velocityProjection < 0)
                //{
                    minA += velocityProjection;
                //}
                //else
                //{
                    maxA += velocityProjection;
                //}

                // Si el intervalo de distancia es menor a 0 con el rectangulo en movimiento,
                // entonces las rectangulos tambien intersectaran al moverse
                intervalDistance = IntervalDistance(minA, maxA, minB, maxB);
                if (intervalDistance > 0) result.willIntersect = false;

                // Si ya sabemos que los rectangulos estan intersectando y van a intersectar,
                // no hay mucho mas que hacer aquí asi que terminamos las verificaciones
                if (result.intersect == false && result.willIntersect == false)
                {
                    break;
                }

                // Si el intervalo de distancia es el minimo, se guarda
                // junto con el eje donde fue encontrado para asi poder separar
                // a los rectangulos en esa dirección
                intervalDistance = Math.Abs(intervalDistance);
                if (intervalDistance < minIntervalDistance)
                {
                    minIntervalDistance = intervalDistance;
                    translationAxis = axis;

                    Vector2 d;
                    Vector2 secondBodyCenter = box.Center;
                    Vector2.Subtract(ref this.center, ref secondBodyCenter, out d);

                    float dot;
                    Vector2.Dot(ref d, ref translationAxis, out dot);
                    if (dot < 0)
                    {
                        Vector2.Multiply(ref translationAxis, -1, out translationAxis);
                    }
                }
            }

            // El vector minimo de transición
            // servira para separar ambos rectangulos en caso de que colisionen.
            if (result.willIntersect)
            {
                Vector2.Multiply(ref translationAxis, minIntervalDistance, out result.minimumTranslationVector);
            }

            result.translationAxis = translationAxis;
            return result;
        }