单人图像 Map 上的玩家碰撞

我遇到的问题是围绕如何使用一个名为_844446的单个png包围我的大脑：

屏幕周围有黑色边框，玩家可以通过较小的踩踏块来测试碰撞 . 我通过使用一个玩家类和主类 Game1.cs 来引力和更新游戏 . 我用这个球：

这是我在屏幕上移动的精灵 .

这是 player.cs ：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

namespace Gravity_Test_V2
{
    class Player
    {
        public Texture2D Texture;

        public Vector2 Velocity;
        public Vector2 Position;
        public float ground;
        private float Speed;

        private Rectangle screenBound;

        public bool isJumping; //are we jumping or not
        public bool goingUp; //if going up or not 

        public float initialVelocity; //initial velocity
        private float jumpU; //How high the player can jump
        private float g; //gravity
        public float t; //time

        private KeyboardState prevKB;

        public Player(Texture2D Texture, Vector2 Position, float Speed, Rectangle screenBound)
        {
            this.Texture = Texture;
            this.Position = Position;
            ground = Position.Y;
            this.Speed = Speed;
            this.screenBound = screenBound;
            Velocity = Vector2.Zero;
            isJumping = goingUp = true;
            jumpU = 2.5f;
            g = -9.8f;
            t = 0;
        }

        public void Update(GameTime gameTime)
        {
            Position.X += (Velocity.X * Speed);
            //Set the Y position to be subtracted so that the upward movement would be done by decreasing the Y value
            Position.Y -= (Velocity.Y * Speed);

            goingUp = (Velocity.Y > 0);

            // TODO: Add your update logic here
            if (isJumping == true)
            {
                //motion equation using velocity: v = u + at
                Velocity.Y = (float)(initialVelocity + (g * t));
                //Increase the timer
                t += (float)gameTime.ElapsedGameTime.TotalSeconds;
            }
            if (isJumping == true && Position.Y > screenBound.Height - Texture.Height)
            {
                Position.Y = ground = screenBound.Height - Texture.Height;
                Velocity.Y = 0;
                isJumping = false;
                t = 0;
            }

            if (Position.X < 0)
            {
                //if Texture touches left side of the screen, set the position to zero and the velocity to zero.
                Position.X = 0;
                Velocity.X = 0;
            }
            else if (Position.X + Texture.Width > screenBound.Width)
            {
                //if Texture touches left side of the screen, set the position to zero and the velocity to zero.
                Position.X = screenBound.Width - Texture.Width;
                Velocity.X = 0;
            }
            if (Position.Y < 0)
            {
                //if the Texture touches the top of the screen, reset the timer and set the initial velocity to zero.
                Position.Y = 0;
                t = 0;
                initialVelocity = 0;
            }
        }

        public void Input(KeyboardState keyState)
        {
            if (keyState.IsKeyDown(Keys.Space) && (isJumping == false || Position.Y == ground))
            {
                isJumping = true;
                initialVelocity = jumpU;
            }
            if (keyState.IsKeyDown(Keys.Left) && !keyState.IsKeyDown(Keys.Right))
            {

                if (Velocity.X > -1.0f)
                {
                    Velocity.X -= (1.0f / 10);
                }
                else
                {
                    Velocity.X = -1.0f;
                }
            }
            else if (!keyState.IsKeyDown(Keys.Left) && keyState.IsKeyDown(Keys.Right))
            {
                if (Velocity.X < 1.0f)
                {
                    Velocity.X += (1.0f / 10);
                }
                else
                {
                    Velocity.X = 1.0f;
                }
            }
            else
            {
                if (Velocity.X > 0.05 || Velocity.X < -0.05)
                    Velocity.X *= 0.70f;
                else
                    Velocity.X = 0;
            }

            prevKB = keyState;
        }

        public void Fall()
        {
            t = 0;
            initialVelocity = 0;
        }

        public void Draw(SpriteBatch spriteBatch)
        {
            spriteBatch.Draw(Texture, new Rectangle((int)Position.X, (int)Position.Y, Texture.Width, Texture.Height), Color.White);
        }
    }
}

是否有一些简单的方法可以使玩家在测试图的纹理内部与 Test Map.png 碰撞？

EDIT: 1/21/2014 9 AM 'ish'

一级：

EDIT: 1/21/2014 10:27

我使用了一个基于pixle的系统来测试玩家是否与一个对象相关，但是我试图将该对象从游戏中分解为类，它将停止工作 . 我将我的动作和碰撞项目混合在一起，试着让它发挥作用 . 我拿了 player.cs （女巫我没有改变）并将基于像素的碰撞添加到 Game1.cs 我需要知道如何制作播放器，女巫正在被 player.cs 类控制，被 Game1.cs 类看到并在被调用时使用由 player.cs 班 .

注意*我也改变了它，以便游戏使用基于像素的系统提供的下降三角形 . 当我能够完成这项工作时，我将添加测试图像 .

此刻玩家可以移动和跳跃，但不会被重新考虑为碰撞 .

EDIT: 1/21/2014 10:34

我使用了2个项目：

碰撞：http://xbox.create.msdn.com/en-US/education/catalog/tutorial/collision_2d_perpixel

动力系统：http://gamepopper.co.uk/academic-projects/2012-2/jumping-platformer-example/

我把它们混合在一起并用它们来制作我自己的平台 .

Game1.cs ：

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace Collision_Test
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        KeyboardState prevKB;

        Player player;

        SpriteFont font;

        Texture2D personTexture;
        Texture2D blockTexture;

        // The color data for the images; used for per pixel collision
        Color[] personTextureData;
        Color[] blockTextureData;

        Vector2 personPosition;
        const int PersonMoveSpeed = 5;

        public static int screenWidth = 800;
        public static int screenHeight = 500;

        // Blocks
        List<Vector2> blockPositions = new List<Vector2>();
        float BlockSpawnProbability = 0.01f;
        const int BlockFallSpeed = 1;

        Random random = new Random();

        // For when a collision is detected
        bool personHit = false;

        // The sub-rectangle of the drawable area which should be visible on all TVs
        Rectangle safeBounds;
        // Percentage of the screen on every side is the safe area
        const float SafeAreaPortion = 0.05f;


        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";

            this.graphics.PreferredBackBufferWidth = screenWidth;
            this.graphics.PreferredBackBufferHeight = screenHeight;

            this.graphics.ApplyChanges();
        }

        protected override void Initialize()
        {
            base.Initialize();
            // Calculate safe bounds based on current resolution
            Viewport viewport = graphics.GraphicsDevice.Viewport;
            safeBounds = new Rectangle(
                (int)(viewport.Width * SafeAreaPortion),
                (int)(viewport.Height * SafeAreaPortion),
                (int)(viewport.Width * (1 - 2 * SafeAreaPortion)),
                (int)(viewport.Height * (1 - 2 * SafeAreaPortion)));
            // Start the player in the center along the bottom of the screen
            personPosition.X = (safeBounds.Width - personTexture.Width) / 2;
            personPosition.Y = safeBounds.Height - personTexture.Height;
        }


        /// <summary>
        /// Load your graphics content.
        /// </summary>
        protected override void LoadContent()
        {
            blockTexture = Content.Load<Texture2D>("Block");
            personTexture = Content.Load<Texture2D>("Person");

            font = Content.Load<SpriteFont>("Font");

            player = new Player(personTexture, Vector2.Zero, 6.0f, new Rectangle(0, 0,
                this.graphics.PreferredBackBufferWidth,
                this.graphics.PreferredBackBufferHeight));

            // Extract collision data
            blockTextureData =
                new Color[blockTexture.Width * blockTexture.Height];
            blockTexture.GetData(blockTextureData);
            personTextureData =
                new Color[personTexture.Width * personTexture.Height];
            personTexture.GetData(personTextureData);

            // Create a sprite batch to draw those textures
            spriteBatch = new SpriteBatch(graphics.GraphicsDevice);
        }

        void HandleInput(KeyboardState keyState)
        {
            player.Input(keyState);
            if (prevKB.IsKeyUp(Keys.F) && keyState.IsKeyDown(Keys.F))
            {
                this.graphics.ToggleFullScreen();
                this.graphics.ApplyChanges();
            }
        }

        protected override void Update(GameTime gameTime)
        {
            // Get input
            KeyboardState keyboard = Keyboard.GetState();
            GamePadState gamePad = GamePad.GetState(PlayerIndex.One);

            HandleInput(Keyboard.GetState());
            player.Update(gameTime);

            prevKB = Keyboard.GetState();

            // Allows the game to exit
            if (gamePad.Buttons.Back == ButtonState.Pressed ||
                keyboard.IsKeyDown(Keys.Escape))
            {
                this.Exit();
            }

            // Spawn new falling blocks
            if (random.NextDouble() < BlockSpawnProbability)
            {
                float x = (float)random.NextDouble() *
                    (Window.ClientBounds.Width - blockTexture.Width);
                blockPositions.Add(new Vector2(x, -blockTexture.Height));
            }

            // Get the bounding rectangle of the person
            Rectangle personRectangle =
                new Rectangle((int)personPosition.X, (int)personPosition.Y,
                personTexture.Width, personTexture.Height);

            // Update each block
            personHit = false;
            for (int i = 0; i < blockPositions.Count; i++)
            {
                // Animate this block falling
                blockPositions[i] =
                    new Vector2(blockPositions[i].X,
                                blockPositions[i].Y + BlockFallSpeed);

                // Get the bounding rectangle of this block
                Rectangle blockRectangle =
                    new Rectangle((int)blockPositions[i].X, (int)blockPositions[i].Y,
                    blockTexture.Width, blockTexture.Height);

                // Check collision with person
                if (IntersectPixels(personRectangle, personTextureData,
                                    blockRectangle, blockTextureData))
                {
                    personHit = true;
                }

                // Remove this block if it have fallen off the screen
                if (blockPositions[i].Y > Window.ClientBounds.Height)
                {
                    blockPositions.RemoveAt(i);

                    // When removing a block, the next block will have the same index
                    // as the current block. Decrement i to prevent skipping a block.
                    i--;
                }
            }

            base.Update(gameTime);
        }


        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice device = graphics.GraphicsDevice;

            // Change the background to red when the person was hit by a block
            if (personHit)
            {
                device.Clear(Color.Red);
            }
            else
            {
                device.Clear(Color.CornflowerBlue);
            }


            spriteBatch.Begin();

            player.Draw(spriteBatch);

            // Draw blocks
            foreach (Vector2 blockPosition in blockPositions)
                spriteBatch.Draw(blockTexture, blockPosition, Color.White);

            spriteBatch.End();


            base.Draw(gameTime);
        }


        /// <summary>
        /// Determines if there is overlap of the non-transparent pixels
        /// between two sprites.
        /// </summary>
        /// <param name="rectangleA">Bounding rectangle of the first sprite</param>
        /// <param name="dataA">Pixel data of the first sprite</param>
        /// <param name="rectangleB">Bouding rectangle of the second sprite</param>
        /// <param name="dataB">Pixel data of the second sprite</param>
        /// <returns>True if non-transparent pixels overlap; false otherwise</returns>
        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;
        }
    }
}