Столкновение 2D объектов

 if ((ball.ballPosition.Y <= platform.platformPosition.Y + platform.platformSize.Y) && //граница платформы снизу
                    (ball.ballPosition.Y + ball.ballSize.Y >= platform.platformPosition.Y) &&         //граница платформы сверху
                    (ball.ballPosition.X + ball.ballSize.X >= platform.platformPosition.X) &&         //граница платформы слева
                    (ball.ballPosition.X <= platform.platformPosition.X + platform.platformSize.X))   //граница платформы справа
                {
                    if ((ball.ballPosition.Y <= platform.platformPosition.Y + platform.platformSize.Y) && (ball.ballPosition.Y + ball.ballSize.Y >= platform.platformPosition.Y))
                    {
                        ball.ballVelocity.Y = -r.Next(0, 6);
                    }
                    else if ((ball.ballPosition.X + ball.ballSize.X >= platform.platformPosition.X) && (ball.ballPosition.X <= platform.platformPosition.X + platform.platformSize.X))
                    {
                        ball.ballVelocity.X = -r.Next(0, 6);
                    }
                }

 public class Cube
    {
        Texture2D cubeTexture;
        public Rectangle rect;
        int dx = 5;
        int dy = 5;
        Cube1 cube1;
        public BoundingBox bbCube;
    public Cube()
    {
        rect = new Rectangle(340, 150, 40, 40);
        cube1 = new Cube1();
     }
    public void Load(ContentManager Content, string cube)
    {
        cubeTexture = Content.Load<Texture2D>(cube);
    }
    public void Update(GameTime gameTime)
    {
        rect.Offset(dx * gameTime.ElapsedGameTime.Milliseconds / 30,
        dy * gameTime.ElapsedGameTime.Milliseconds / 30);
 
        if (rect.Right > 640)
            dx = -Math.Abs(dx);
        if (rect.Bottom > 480)
            dy = -Math.Abs(dy);
        if (rect.Left < 0)
            dx = Math.Abs(dx);
        if (rect.Top < 0)
            dy = Math.Abs(dy);
 
        if((rect.Bottom == cube1.rect1.Top)&&(rect.Width+rect.Left>cube1.rect1.Left)&&(rect.Right-rect.Width<cube1.rect1.Right))
            dy = -Math.Abs(dy);
        if ((rect.Left == cube1.rect1.Right)&&(rect.Height+rect.Top>cube1.rect1.Top)&&(rect.Bottom-rect.Height<cube1.rect1.Bottom))
            dx = Math.Abs(dx);
        if ((rect.Top == cube1.rect1.Bottom) && (rect.Width + rect.Left > cube1.rect1.Left) && (rect.Right - rect.Width < cube1.rect1.Right))
            dy = Math.Abs(dy);
        if ((rect.Right == cube1.rect1.Left) && (rect.Height + rect.Top > cube1.rect1.Top) && (rect.Bottom - rect.Height < cube1.rect1.Bottom))
            dx = -Math.Abs(dx);
    }
    public void Collision(GameTime gameTime)
    {
    }
    public void Draw(SpriteBatch SpriteBatch)
    {
        SpriteBatch.Draw(cubeTexture, rect, Color.White);
    }
    }

class Cube1
    {
        Texture2D cubeTexture1;
        public Rectangle rect1;
        KeyboardState kbState;
        public Cube1()
        {
            rect1 = new Rectangle(180, 200, 40, 40);
        }
        public void Load(ContentManager Content, string cube1)
        {
            cubeTexture1 = Content.Load<Texture2D>(cube1);
        }
        public void Move()
        {
            kbState = Keyboard.GetState();
            if (kbState.IsKeyDown(Keys.Up)&&(rect1.Top>0))
                rect1.Offset(0, -5);
            if (kbState.IsKeyDown(Keys.Down) && (rect1.Bottom < 480))
                rect1.Offset(0, 5);
            if (kbState.IsKeyDown(Keys.Left) && (rect1.Left > 0))
                rect1.Offset(-5, 0);
            if (kbState.IsKeyDown(Keys.Right) && (rect1.Right < 640))
                rect1.Offset(5, 0);
        }
        public void Draw(SpriteBatch spriteBatch)
        {
            spriteBatch.Draw(cubeTexture1, rect1, Color.White);
        }
    }

        public override void Update(GameTime gameTime)
        {
            p = BlockPos;
            if (hasGrav && !isStanding)
                vel = Vector2.Add(vel, TheGame.grav);
            TraceMove(ref pos, ref vel, gameTime, p);
            if (vel.Length()!=0)
            {
                vel = Vector2.Multiply(vel, 0.8f);
                if (vel.LengthSquared() < 0.01f)
                    vel = new Vector2(0, 0);
            }
            base.Update(gameTime);
        }
 
        public static void TraceMove(ref Vector2 pos, ref Vector2 svel, GameTime gTime, Int2 sp)
        {
            if (svel.Length() == 0)
                return;
            if (!CBlock.ValidP(sp.x, sp.y))
            {
                pos = new Vector2(0, CBlock.GetHeight(0)); 
                return;
            }
            Vector2 vel = Vector2.Multiply(svel, (float)gTime.ElapsedGameTime.TotalMilliseconds / 1000.0f);
            Vector2 target = Vector2.Add(pos, vel);
            Int2 ptarget = new Int2(target);
            if (sp.x == ptarget.x && sp.y == ptarget.y)
            {
                pos = Vector2.Add(pos, vel);
                return;
            }
            Vector2 delta = Vector2.Normalize(vel);
            Int2 p = sp;
            bool stX = (svel.X == 0);
            bool stY = (svel.Y == 0);
            while (true)
            {
                p = new Int2(pos);
                if (p.x == ptarget.x && p.y == ptarget.y)
                {
                    pos = Vector2.Add(pos, vel);
                    return;
                }
                
                if (delta.X > 0 && !stX)
                {
                    if (pos.X > target.X)
                    {
                        pos.X = target.X;
                        stX = true;
                        continue;
                    }
                    if (CBlock.GetID_RightBlock(p.x, p.y) == 0)
                    {
                        pos = Vector2.Add(pos, delta);
                    }
                    else
                    {
                        svel.X = svel.X / (-10f);
                        pos.X = (p.x - CBlock.widthD2) * 32;//TODO:SIZE
                        ptarget.x = p.x;
                        stX = true;
                    }
                }
                if (delta.X < 0 && !stX)
                {
                    if (pos.X < target.X)
                    {
                        pos.X = target.X;
                        stX = true;
                        continue;
                    }
                    if (CBlock.GetID_LeftBlock(p.x, p.y) == 0)
                    {
                        pos = Vector2.Add(pos, delta);
                    }
                    else
                    {
                        svel.X = svel.X / (-10f);
                        pos.X = (p.x + 0.9f - CBlock.widthD2) * 32;//TODO:SIZE
                        ptarget.x = p.x;
                        stX = true;
                    }
                }
                if (delta.Y > 0 && !stY)
                {
                    if (pos.Y > target.Y)
                    {
                        pos.Y = target.Y;
                        stY = true;
                        continue;
                    }
                    if (CBlock.GetID_UpperBlock(p.x, p.y) == 0)
                    {
                        pos = Vector2.Add(pos, delta);
                    }
                    else
                    {
                        //svel.Y = svel.Y / (-10f);
                        pos.Y = p.y * 32;//TODO:SIZE
                        ptarget.y = p.y;
                        stY = true;
                    }
                }
                if (delta.Y < 0 && !stY)
                {
                    if (pos.Y < target.Y)
                    {
                        pos.Y = target.Y;
                        stY = true;
                        continue;
                    }
                    if (CBlock.GetID_UnderBlock(p.x, p.y) == 0)
                    {
                        pos = Vector2.Add(pos, delta);
                    }
                    else
                    {
                        svel.Y = 0;// -svel.Y;
                        pos.Y = (p.y+0.5f) * 32;//TODO:SIZE
                        ptarget.y = p.y;
                        stY = true;
                    }
                }
            }
        }

public static bool IntersectPixels(Rectangle rectangleA, Color[] dataA, Rectangle rectangleB, Color[] dataB) 
{ 
     // Find the bounds of the rectangle intersection 
     int top = Math.Max(rectangleA.Top, rectangleB.Top); 
     int bottom = Math.Min(rectangleA.Bottom, rectangleB.Bottom); 
     int left = Math.Max(rectangleA.Left, rectangleB.Left); 
     int right = Math.Min(rectangleA.Right, rectangleB.Right); 
   
     // Check every point within the intersection bounds 
     for (int y = top; y < bottom; y++) 
     { 
            for (int x = left; x < right; x++) 
         { 
             // Get the color of both pixels at this point 
             Color colorA = dataA[(x - rectangleA.Left) + 
                    (y - rectangleA.Top) * rectangleA.Width]; 
             Color colorB = dataB[(x - rectangleB.Left) + 
                    (y - rectangleB.Top) * rectangleB.Width]; 
   
             // If both pixels are not completely transparent, 
             if (colorA.A != 0 && colorB.A != 0) 
             { 
                 // then an intersection has been found 
                 return true; 
             } 
         } 
     } 
   
     // No intersection found 
     return false; 
}

class Sprite { 
 
     [...] 
 
     public bool CollidesWith(Sprite other) 
     { 
         // Default behavior uses per-pixel collision detection 
         return CollidesWith(other, true); 
     } 
 
     public bool CollidesWith(Sprite other, bool calcPerPixel) 
     { 
         // Get dimensions of texture 
         int widthOther = other.Texture.Width; 
         int heightOther = other.Texture.Height; 
         int widthMe = Texture.Width; 
         int heightMe = Texture.Height; 
 
         if ( calcPerPixel &&                    // if we need per pixel 
             (( Math.Min(widthOther, heightOther) > 100) ||  // at least avoid doing it 
             ( Math.Min(widthMe, heightMe) > 100)))          // for small sizes (nobody will notice :P) 
         { 
             return Bounds.Intersects(other.Bounds) // If simple intersection fails, don't even bother with per-pixel 
                 && PerPixelCollision(this, other); 
         } 
 
         return Bounds.Intersects(other.Bounds); 
     } 
 
     static bool PerPixelCollision(Sprite a, Sprite b) 
     { 
         // Get Color data of each Texture 
         Color[] bitsA = new Color[a.Texture.Width * a.Texture.Height]; 
         a.Texture.GetData(bitsA); 
         Color[] bitsB = new Color[b.Texture.Width * b.Texture.Height]; 
         b.Texture.GetData(bitsB); 
 
         // Calculate the intersecting rectangle 
         int x1 = Math.Max(a.Bounds.X, b.Bounds.X); 
         int x2 = Math.Min(a.Bounds.X + a.Bounds.Width, b.Bounds.X + b.Bounds.Width); 
 
         int y1 = Math.Max(a.Bounds.Y, b.Bounds.Y); 
         int y2 = Math.Min(a.Bounds.Y + a.Bounds.Height, b.Bounds.Y + b.Bounds.Height); 
 
          // For each single pixel in the intersecting rectangle 
          for (int y = y1; y < y2; ++y) 
          { 
              for (int x = x1; x < x2; ++x) 
              { 
                  // Get the color from each texture 
                  Color a = bitsA[(x - a.Bounds.X) + (y - a.Bounds.Y)*a.Texture.Width]; 
                  Color b = bitsB[(x - b.Bounds.X) + (y - b.Bounds.Y)*b.Texture.Width]; 
 
                  if (a.A != 0 && b.A != 0) // If both colors are not transparent (the alpha channel is not 0), then there is a collision 
                  { 
                      return true; 
                  } 
              } 
          } 
         // If no collision occurred by now, we're clear. 
         return false; 
     } 
 
     private Rectangle bounds = Rectangle.Empty; 
     public virtual Rectangle Bounds 
     { 
         get 
         { 
             return new Rectangle( 
                 (int)Position.X - Texture.Width, 
                 (int)Position.Y - Texture.Height, 
                 Texture.Width, 
                 Texture.Height); 
         } 
 
     }

public void UpdateBullet()
        {
            for (int j = 0; j < bulletList.Count; j++)
            {
                BulletList curentBullet = bulletList[j];
                Vector2 pos = new Vector2(bulletList[j].rectangle.X + bulletList[j].g.X, bulletList[j].rectangle.Y + bulletList[j].g.Y);
                curentBullet.rectangle = new Rectangle(Convert.ToInt32(pos.X), Convert.ToInt32(pos.Y), 5, 5);
                bulletList[j] = curentBullet;
                Intersects();
            }
        }
 
 public void Intersects()
        {
                foreach (BulletList bullet in bulletList)
                {
                    foreach (BoxList box in boxList)
                    {
                        if (bullet.rectangle.Contains(box.rectangle))
                            bulletList.Remove(bullet);
                }
            }
        }

ublic void UpdateBullet()
        {
 
            for (int j = 0; j < bulletList.Count; j++)
            {
                BulletList curentBullet = bulletList[j];
                Vector2 pos = new Vector2(bulletList[j].rectangle.X + bulletList[j].g.X, bulletList[j].rectangle.Y + bulletList[j].g.Y);
                curentBullet.rectangle = new Rectangle(Convert.ToInt32(pos.X), Convert.ToInt32(pos.Y), 5, 5);
                bulletList[j] = curentBullet;
                //Создал прямоугольник 
                Rectangle rect = new Rectangle(20,20,50,50);
               //Проверяю  попадает пуля в rect
                if (curentBullet.rectangle.Intersects(rect))
                    bulletList.Remove(curentBullet);
 
            }
 
        }

Convert.ToInt32

(int)

Texture2D box_Texture;
Rectangle box_Rectangle;
 
Texture2D player_Texture;
Rectangle player_Rectangle;
 
...
 
void Update()
{
player_Rectangle.X += 1; // player будет ВСЕГДА идти вправо (можно сделать по нажатию клавиши)
 
  if(player_Rectangle.Intersects(box_Rectangle))
  {
     player_Rectangle.X = 0; // player остановится если соприкоснётся с box-ом
  }
}