SGDE.Physics.Collision.CollisionUnit.GetWidth C# (CSharp) Method

GetWidth() public method

For box based collisions, get the width of the box. For circle based collisions, get the circle diameter.
public GetWidth ( ) : int
return int
        public int GetWidth()
        {
            if (mCollisionType == CollisionType.COLLISION_CIRCLE)
            {
                return mCircleRadius * 2;
            }
            else if (mCollisionType == CollisionType.COLLISION_BOX)
            {
                return (int)(mPoint2.X - mPoint1.X);
            }
            else
            {
                return 0;
            }
        }

Usage Example

Exemplo n.º 1
0
        /// <summary>
        /// Scale a CollisionUnit by the given amount.
        /// </summary>
        /// <param name="unit">The CollisionUnit to scale.</param>
        /// <param name="scale">The delta scale to perform on the CollisionUnit.</param>
        public void ScaleCollisionUnit(CollisionUnit unit, Vector2 scale)
        {
            int oldCircleRadius;
            int newCircleRadius;
            Vector2 circleCenter;
            Vector2 oldLineStart;
            Vector2 oldLineEnd;
            Point oldTopLeftCell;
            Point oldBottomRightCell;
            Point newTopLeftCell;
            Point newBottomRightCell;
            bool scaleFromCenter = false;

            if (unit.GetCollisionType() == CollisionUnit.CollisionType.COLLISION_CIRCLE || unit.GetCollisionType() == CollisionUnit.CollisionType.COLLISION_BOX)
            {
                if (unit.GetCollisionType() == CollisionUnit.CollisionType.COLLISION_CIRCLE)
                {
                    oldCircleRadius = unit.GetCircleRadius();
                    //newCircleRadius = (int)(unit.GetCircleRadius() * ((scale.X + scale.Y) / 2));
                    //newCircleRadius = (int)(unit.GetCircleRadius() + unit.GetCircleRadius() * ((scale.X + scale.Y) / 2));
                    newCircleRadius = (int)(unit.GetCircleRadius() + ((scale.X + scale.Y) / 2));
                    circleCenter = unit.GetCircleCenter();

                    // calculate containing cells
                    oldTopLeftCell = CalculateCircleTopLeftCell(circleCenter, oldCircleRadius);
                    oldBottomRightCell = CalculateCircleBottomRightCell(circleCenter, oldCircleRadius);

                    newTopLeftCell = CalculateCircleTopLeftCell(circleCenter, newCircleRadius);
                    newBottomRightCell = CalculateCircleBottomRightCell(circleCenter, newCircleRadius);
                }
                else
                {
                    Vector2 point1 = unit.GetUpperLeft();
                    Vector2 point2 = unit.GetLowerRight();
                    int oldWidth = unit.GetWidth();
                    int oldHeight = unit.GetHeight();
                    //int xChange = (int)(((oldWidth * scale.X) - oldWidth) / 2);
                    //int yChange = (int)(((oldHeight * scale.Y) - oldHeight) / 2);
                    //int xChange = (int)(oldWidth * scale.X / 2);
                    //int yChange = (int)(oldHeight * scale.Y / 2);
                    int xChange = (int)scale.X;
                    int yChange = (int)scale.Y;

                    // scale from center
                    if (scaleFromCenter)
                    {
                        point1.X -= xChange;
                        point1.Y -= yChange;

                        point2.X += xChange;
                        point2.Y += yChange;
                    }
                    else
                    {
                        // scale with top left stationary
                        point2.X += xChange * 2;
                        point2.Y += yChange * 2;
                    }

                    oldTopLeftCell = CalculateCellPosition(unit.GetUpperLeft());
                    oldBottomRightCell = CalculateCellPosition(unit.GetLowerRight());

                    newTopLeftCell = CalculateCellPosition(point1);
                    newBottomRightCell = CalculateCellPosition(point2);
                }

                //if (scale.X < 1)
                if (scale.X < 0)
                {
                    for (int j = oldTopLeftCell.Y; j <= oldBottomRightCell.Y; j++)
                    {
                        // remove left
                        for (int i = oldTopLeftCell.X; i < newTopLeftCell.X; i++)
                        {
                            mCollisionGrid.Cells[i, j].RemoveCollisionUnit(unit);
                        }

                        // remove right
                        for (int i = newBottomRightCell.X + 1; i <= oldBottomRightCell.X; i++)
                        {
                            mCollisionGrid.Cells[i, j].RemoveCollisionUnit(unit);
                        }
                    }

                    //if (scale.Y < 1)
                    if (scale.Y < 0)
                    {
                        for (int i = newTopLeftCell.X; i <= newBottomRightCell.X; i++)
                        {
                            // remove top
                            for (int j = oldTopLeftCell.Y; j < newTopLeftCell.Y; j++)
                            {
                                mCollisionGrid.Cells[i, j].RemoveCollisionUnit(unit);
                            }

                            // remove bottom
                            for (int j = newBottomRightCell.Y + 1; j <= oldBottomRightCell.Y; j++)
                            {
                                mCollisionGrid.Cells[i, j].RemoveCollisionUnit(unit);
                            }
                        }
                    }
                    //else if (scale.Y > 1)
                    else if (scale.Y > 0)
                    {
                        for (int i = newTopLeftCell.X; i <= newBottomRightCell.X; i++)
                        {
                            // add top
                            for (int j = newTopLeftCell.Y; j < oldTopLeftCell.Y; j++)
                            {
                                mCollisionGrid.Cells[i, j].AddCollisionUnit(unit);
                            }

                            // add bottom
                            for (int j = oldBottomRightCell.Y + 1; j <= newBottomRightCell.Y; j++)
                            {
                                mCollisionGrid.Cells[i, j].AddCollisionUnit(unit);
                            }
                        }
                    }
                }
                //else if (scale.X > 1)
                else if (scale.X > 0)
                {
                    for (int j = newTopLeftCell.Y; j <= newBottomRightCell.Y; j++)
                    {
                        // add left
                        for (int i = newTopLeftCell.X; i < oldTopLeftCell.X; i++)
                        {
                            mCollisionGrid.Cells[i, j].AddCollisionUnit(unit);
                        }

                        // add right
                        for (int i = oldBottomRightCell.X + 1; i <= newBottomRightCell.X; i++)
                        {
                            mCollisionGrid.Cells[i, j].AddCollisionUnit(unit);
                        }
                    }

                    //if (scale.Y < 1)
                    if (scale.Y < 0)
                    {
                        for (int i = oldTopLeftCell.X; i <= oldBottomRightCell.X; i++)
                        {
                            // remove top
                            for (int j = oldTopLeftCell.Y; j < newTopLeftCell.Y; j++)
                            {
                                mCollisionGrid.Cells[i, j].RemoveCollisionUnit(unit);
                            }

                            // remove bottom
                            for (int j = newBottomRightCell.Y + 1; j <= oldBottomRightCell.Y; j++)
                            {
                                mCollisionGrid.Cells[i, j].RemoveCollisionUnit(unit);
                            }
                        }
                    }
                    //else if (scale.Y > 1)
                    else if (scale.Y > 0)
                    {
                        for (int i = oldTopLeftCell.X; i <= oldBottomRightCell.X; i++)
                        {
                            // add top
                            for (int j = newTopLeftCell.Y; j < oldTopLeftCell.Y; j++)
                            {
                                mCollisionGrid.Cells[i, j].AddCollisionUnit(unit);
                            }

                            // add bottom
                            for (int j = oldBottomRightCell.Y + 1; j <= newBottomRightCell.Y; j++)
                            {
                                mCollisionGrid.Cells[i, j].AddCollisionUnit(unit);
                            }
                        }
                    }
                }
            }
            else if (unit.GetCollisionType() == CollisionUnit.CollisionType.COLLISION_LINE)
            {
                oldLineStart = unit.GetLineStart();
                oldLineEnd = unit.GetLineEnd();

                // TODO: put in appropriate cells

            }
        }