Exemplo n.º 1
0
 public static void CheckCurrent(PhysObj obj, int x, int y)
 {
     if (!IsLegalXY(x, y)) return;
     if (environmentData[x, y].airCurrent != Vector2.Zero)
         obj.nextForce = environmentData[x, y].airCurrent;
     //if (obj.nextForce.X != 0) obj.terminalSpeed.X = 10;
     //else obj.terminalSpeed.X = 6;
 }
Exemplo n.º 2
0
 public void GetPickedUp(Player parent)
 {
     if (this.parent == null)
     {
         this.parent = parent;
         position = parent.position;
         parent.pickUp = this;
     }
 }
Exemplo n.º 3
0
 public AABB(PhysObj obj, float x1, float y1, float x2, float y2)
 {
     this.physObj = obj;
     this.x1 = x1;
     this.x2 = x2;
     this.y1 = y1;
     this.y2 = y2;
     omitTop = false;
     omitLeft = false;
     omitRight = false;
     omitBottom = false;
     incline = false;
 }
Exemplo n.º 4
0
 public AABB(PhysObj obj, Vector2 Position, Vector2 Size)
     : this(obj, Position.X, Position.Y, Position.X + Size.X, Position.Y + Size.Y)
 {
 }
Exemplo n.º 5
0
 public CollisionBox(PhysObj physObj, float Size)
     : this(physObj, new Vector2(Size, Size))
 {
 }
Exemplo n.º 6
0
        public CollisionBox(PhysObj physObj, Vector2 Size)
        {
            this.physObj = physObj;

            WorldCornerMin = Vector2.Zero;
            WorldCornerMax = Vector2.Zero;
            LocalCornerMin = Vector2.Zero;
            LocalCornerMax = Vector2.Zero;
            Position = Vector2.Zero;
            Offset = Vector2.Zero;
            this.Size = Size;

            CalculateCorners();
        }
Exemplo n.º 7
0
        public static void CheckEnvironment(PhysObj obj)
        {
            Point cornerTopLeft = PositionToGrid(new Vector2(obj.hitBox.Left(), obj.hitBox.Top()));
            Point cornerBottomRight = PositionToGrid(new Vector2(obj.hitBox.Right(), obj.hitBox.Bottom()));
            bool collision = false;
            float friction = obj.frictionMultiplier;
            List<AABB> collisionList = new List<AABB>();
            List<float> frictionList = new List<float>();
            for (int y = cornerTopLeft.Y; y <= cornerBottomRight.Y; y++)
            {
                for (int x = cornerTopLeft.X; x <= cornerBottomRight.X; x++)
                {
                    if (CheckCollision(new Point(x, y)))
                    {
                        AABB aabb = new AABB(null, GridToPosition(new Point(x, y)), new Vector2(collisionSize));
                        if (environmentData[x, y].inclineType != InclineType.Flat)
                        {
                            aabb = SolveIncline(obj, x, y);

                        }
                        if (environmentData[x, y].oneWayPlatform)
                        {
                            aabb.omitLeft = true;
                            aabb.omitRight = true;
                            aabb.omitBottom = true;
                            if (obj.speed.Y < 0 || obj.ignoreOneWay)
                            {
                                aabb.omitTop = true;
                            }
                        }

                        if ((CheckCollision(x - 1, y) && !environmentData[x - 1, y].oneWayPlatform) || environmentData[x, y].omitLeft) aabb.omitLeft = true;
                        if ((CheckCollision(x + 1, y) && !environmentData[x + 1, y].oneWayPlatform) || environmentData[x, y].omitRight) aabb.omitRight = true;
                        if ((CheckCollision(x, y + 1) && !environmentData[x, y + 1].oneWayPlatform) || environmentData[x, y].omitBottom) aabb.omitBottom = true;
                        if ((CheckCollision(x, y - 1) && !environmentData[x, y - 1].oneWayPlatform) || environmentData[x, y].omitTop) aabb.omitTop = true;

                        //if (CheckCollision(x - 1, y) && environmentData[x,y].inclineType == InclineType.Flat)
                        //{
                        //    if (environmentData[x - 1, y].inclineType != InclineType.Flat && (obj.position.X > aabb.x1 && obj.position.X < aabb.x2)) aabb.omitTop = true;
                        //}

                        collisionList.Add(aabb);
                        collision = true;
                        frictionList.Add(GetFriction(obj, environmentData[x, y]));
                    }

                    CheckCurrent(obj, x, y);

                    if (IsLegalXY(x,y) && environmentData[x, y].killZone)
                    {
                        obj.Die();
                    }

                }
            }

            Point checkBelow = PositionToGrid(new Vector2(obj.position.X, obj.hitBox.Bottom() + 1));
            if (CheckCollision(checkBelow))
            {
                if (environmentData[checkBelow.X, checkBelow.Y].inclineType != InclineType.Flat)
                {
                    //Trace.WriteLine("Barf!");
                    if (!obj.jumpingLegacy)
                    {
                        //AABB aabb = new AABB(null, GridToPosition(checkBelow), new Vector2(collisionSize));
                        //aabb = SolveIncline(obj, checkBelow.X, checkBelow.Y);
                        //obj.hitBox.SetPosition(obj.hitBox.GetPosition() + new Vector2(0, aabb.y2 - obj.hitBox.Bottom()));
                        //collisionList.Add(aabb);
                        //frictionList.Add(GetFriction(obj, environmentData[checkBelow.X, checkBelow.Y]));
                        obj.nextForce.Y += 20;
                    }
                }
            }

            //int y1 = cornerBottomRight.Y + 1;
            //for (int x = cornerTopLeft.X; x <= cornerBottomRight.X; x++)
            //{
            //    if (CheckCollision(x, y1))
            //    {
            //        AABB aabb = new AABB(null, GridToPosition(new Point(x, y1)), new Vector2(collisionSize));
            //        if (environmentData[x, y1].inclineType != InclineType.Flat)
            //        {
            //            obj.position += new Vector2(0, 32);
            //            collisionList.Add(aabb);
            //            frictionList.Add(GetFriction(obj, environmentData[x, y1]));
            //        }
            //    }
            //}

            //if (collision == false)
            //{
            //    if (obj.state == PhysState.Grounded)
            //{ //check to see if there's ground beneath the object:

            //Point under = PositionToGrid(obj.tempPosition);
            //under.Y += 1;
            //if (CheckCollision(under.X, under.Y))
            //{
            //    collision = true;
            //}
            //if (!collision) obj.state = PhysState.Air;

            //int y = cornerBottomRight.Y + 1;
            //for (int x = cornerTopLeft.X; x < cornerBottomRight.X; x++)
            //{
            //    if (CheckCollision(x, y))
            //    {
            //        collision = true;
            //        break;
            //    }
            //}
            //if (!collision) obj.state = PhysState.Air;
            //    }
            //    return;
            //}

            foreach (AABB aabb in collisionList)
            {
                Vector2 solution = aabb.SolveCollision(obj.hitBox.GetAABB());
                obj.hitBox.SetPosition(obj.hitBox.GetPosition() + solution);
                if (solution.Y < 0)
                {
                    friction = frictionList.ElementAt(collisionList.IndexOf(aabb));
                }
            }
            Vector2 newpos = obj.hitBox.GetPosition();
            if (newpos.Y != obj.tempPosition.Y) obj.speed.Y = SolveBounce(obj, true);
            if (newpos.X != obj.tempPosition.X) obj.speed.X = SolveBounce(obj, false);
            if (newpos.Y < obj.tempPosition.Y)
            {
                obj.state = PhysState.Grounded;
            }

            obj.tempPosition = newpos;

            if (obj.state == PhysState.Grounded)
            {
                obj.frictionMultiplier = friction;
                if (friction == EnvironmentData.NORMAL)
                {
                    obj.moveForce = 1;
                }
                else if (friction == EnvironmentData.ICE)
                {
                    obj.moveForce = .2f;
                }
            }
            else
            {
                obj.frictionMultiplier = EnvironmentData.AIR;
                obj.moveForce = .2f;
            }
        }
Exemplo n.º 8
0
 public static AABB SolveIncline(PhysObj obj, int x, int y)
 {
     bool omitTop = false;
     Vector2 cornerTopLeft = GridToPosition(new Point(x, y));
     Vector2 cornerBottomRight = cornerTopLeft + new Vector2(collisionSize);
     float thirdSize = collisionSize / 3;
     float halfSize = collisionSize / 2;
     switch (environmentData[x, y].inclineType)
     {
         case InclineType.ThreeTileRight1:
             float ratio = (cornerTopLeft.X - obj.tempPosition.X) / collisionSize;
             if (ratio > 0 || ratio < -1) omitTop = true;
             cornerTopLeft.Y = cornerBottomRight.Y + ratio * (thirdSize);
             break;
         case InclineType.ThreeTileRight2:
             ratio = (cornerTopLeft.X - obj.tempPosition.X) / collisionSize;
             cornerTopLeft.Y = cornerBottomRight.Y - (thirdSize) + ratio * (thirdSize);
             if (ratio > 0 || ratio < -1) omitTop = true;
             break;
         case InclineType.ThreeTileRight3:
             ratio = (cornerTopLeft.X - obj.tempPosition.X) / collisionSize;
             if (ratio > 0 || ratio < -1) omitTop = true;
             cornerTopLeft.Y = cornerBottomRight.Y - (2 * thirdSize) + ratio * (thirdSize);
             break;
         case InclineType.ThreeTileLeft1:
             ratio = (cornerTopLeft.X - obj.tempPosition.X) / collisionSize;
             if (ratio > 0 || ratio < -1) omitTop = true;
             cornerTopLeft.Y = cornerTopLeft.Y - ratio * (thirdSize);
             break;
         case InclineType.ThreeTileLeft2:
             ratio = (cornerTopLeft.X - obj.tempPosition.X) / collisionSize;
             //if (ratio > 0 || ratio < -1) omitTop = true;
             cornerTopLeft.Y = cornerTopLeft.Y + (thirdSize) - ratio * (thirdSize);
             break;
         case InclineType.ThreeTileLeft3:
             ratio = (cornerTopLeft.X - obj.tempPosition.X) / collisionSize;
             if (ratio > 0 || ratio < -1) omitTop = true;
             cornerTopLeft.Y = cornerTopLeft.Y + (2 * thirdSize) - ratio * (thirdSize);
             break;
         case InclineType.TwoTileRight1:
             ratio = (cornerTopLeft.X - obj.tempPosition.X) / collisionSize;
             if (ratio > 0 || ratio < -1) omitTop = true;
             cornerTopLeft.Y = cornerBottomRight.Y + ratio * (halfSize);
             break;
         case InclineType.TwoTileRight2:
             ratio = (cornerTopLeft.X - obj.tempPosition.X) / collisionSize;
             if (ratio > 0 || ratio < -1) omitTop = true;
             cornerTopLeft.Y = cornerBottomRight.Y - (halfSize) + ratio * (halfSize);
             break;
         case InclineType.TwoTileLeft1:
             ratio = (cornerTopLeft.X - obj.tempPosition.X) / collisionSize;
             if (ratio > 0 || ratio < -1) omitTop = true;
             cornerTopLeft.Y = cornerTopLeft.Y - ratio * (halfSize);
             break;
         case InclineType.TwoTileLeft2:
             ratio = (cornerTopLeft.X - obj.tempPosition.X) / collisionSize;
             if (ratio > 0 || ratio < -1) omitTop = true;
             cornerTopLeft.Y = cornerTopLeft.Y + (halfSize) - ratio * (halfSize);
             break;
     }
     AABB aabb = new AABB(null, cornerTopLeft.X, cornerTopLeft.Y, cornerBottomRight.X, cornerBottomRight.Y);
     aabb.omitLeft = true;
     aabb.omitRight = true;
     if (omitTop)
     {
         aabb.omitTop = true;
         aabb.omitBottom = true;
     }
     aabb.incline = true;
     return aabb;
 }
Exemplo n.º 9
0
 public static float SolveBounce(PhysObj obj, bool bounceVertical)
 {
     if (obj.canBounce)
     {
         if (bounceVertical) return -obj.speed.Y * obj.bounceMultiplier;
         else return -obj.speed.X / 2;
     }
     return 0;
 }
Exemplo n.º 10
0
 public static float GetFriction(PhysObj obj, EnvironmentData data)
 {
     switch (data.frictionType)
     {
         case FrictionType.Normal:
             return EnvironmentData.NORMAL;
         case FrictionType.Ice:
             return EnvironmentData.ICE;
     }
     return 1;
 }
Exemplo n.º 11
0
 public void GetDropped(Vector2 throwForce)
 {
     nextForce += throwForce;
     parent = null;
 }
Exemplo n.º 12
0
 public override void AdjustCollision(PhysObj obj)
 {
     base.AdjustCollision(obj);
     grabBox.SetPosition(position);
 }
Exemplo n.º 13
0
        public virtual void AdjustCollision(PhysObj obj)
        {
            if (playerTangible != PlayerObjectMode.None && obj.playerTangible != PlayerObjectMode.None)
            {
                if (playerTangible != obj.playerTangible) return;
            }
            if (!obj.isSolidObject || !hitBox.CheckCollision(obj.hitBox))
            {
                return;
            }
            AABB aabb = obj.hitBox.GetAABB();
            Vector2 solution = aabb.SolveCollision(hitBox.GetAABB());
            hitBox.SetPosition(hitBox.GetPosition() + solution);

            Vector2 newpos = hitBox.GetPosition();
            if (newpos.Y != position.Y) speed.Y = Level.SolveBounce(this, true);
            if (newpos.X != position.X) speed.X = Level.SolveBounce(this, false);
            if (newpos.Y < position.Y)
            {
                state = PhysState.Grounded;
                frictionMultiplier = EnvironmentData.NORMAL;
                obj.currentMass += currentMass;
                if (obj.affectsResident && !obj.residentList.Contains(this)) obj.residentList.Add(this);
            }
            if (newpos.Y > position.Y)
            {
                speed.Y = obj.speed.Y;
                if (speed.Y < 0) speed.Y = 0;
            }
            Vector2 prevPosition = position;
            position = newpos;

            Vector2 dPos = position - prevPosition;
            foreach (PhysObj resident in residentList)
            {
                resident.position += dPos;
                resident.hitBox.SetPosition(resident.position);
            }
        }
Exemplo n.º 14
0
 public virtual bool CheckCollision(PhysObj obj)
 {
     return false;
 }