使用旋转在XNA中绘制二维线

我试图把玩家和目标小行星划一条线作为“抓钩”，我在xna的2D中找到了一些这样做的例子，但我的“位置”和“原点”矢量2似乎会根据使用的人和时间而改变。在这些线的情况下，它们在目标的相反方向上向上和向右绘制位置（大约100像素），并在玩家移动时围绕目标左侧的某个原点旋转

这是玩家代码，包括抓斗代码和目标分配

namespace Sparatius.Sprites
{
    public class PlayerSprite : BaseSprite
    {
        ControlInput controlInput;

        Texture2D Grapple;

        SpriteFont font;

        bool LeftGrapple = false, RightGrapple = false;

        int GrappleRange = 300;

        Sprites.AsteroidSprite LeftTarget, RightTarget;

        public BoundingSphere grappleHitBox
        {
            get { return new BoundingSphere(new Vector3(Position.X + Origin.X, Position.Y + Origin.Y, 0), GrappleRange); }
        }

        public float speed
        {
            get { return Speed; }
        }

        public PlayerSprite(Vector2 spriteLocal)
            :base(spriteLocal)
        {
            this.Rotation = 0;
            this.Speed = 0;
            this.FrameCount = new Point(4, 2);
            this.ColorTint = Color.White;
            this.controlInput = new ControlInput();
        }

        public void LoadContent(ContentManager content)
        {
            Texture = content.Load<Texture2D>("Sprites/PinballSpin");
            font = content.Load<SpriteFont>("Fonts/Font1");
            Grapple = content.Load<Texture2D>("Sprites/Grapple");
            FrameSize = new Point((int)Texture.Width / FrameCount.X, (int)Texture.Height / FrameCount.Y);
            Origin = new Vector2(FrameSize.X / 2, FrameSize.Y / 2);

            Animation = new Animation(Texture, FrameSize);
        }

        public override void Update(GameTime gameTime)
        {
            base.Update(gameTime);

            controlInput.GetControlStates();

            if (controlInput.JustPressed(Keys.W))
                Speed += 2;
            else if (controlInput.JustPressed(Keys.S))
                Speed -= 2;

            if (controlInput.IsHeld(Keys.A))
                Rotation -= 0.05f;
            if (controlInput.IsHeld(Keys.D))
                Rotation += 0.05f;

            if (LeftTarget != null)
            {
                LeftTarget.Distance = Vector2.Distance(Position, LeftTarget.Position);
                if (LeftTarget.Distance > GrappleRange)
                {
                    LeftTarget.isTarget = false;
                    LeftTarget = null;
                }
                if (controlInput.IsHeld(Keys.Q))
                {
                    LeftGrapple = true;
                }
                else
                    LeftGrapple = false;
            }
            if (RightTarget != null)
            {
                RightTarget.Distance = Vector2.Distance(Position, RightTarget.Position);
                if (RightTarget.Distance > GrappleRange)
                {
                    RightTarget.isTarget = false;
                    RightTarget = null;
                }
                if (controlInput.IsHeld(Keys.E))
                {
                    RightGrapple = true;
                }
                else
                    RightGrapple = false;
            }
        }

        public override void Draw(SpriteBatch spriteBatch)
        {
            base.Draw(spriteBatch);

            if (LeftGrapple)
            {
                float leftRotation = (float)Math.Atan2(LeftTarget.Position.Y - Position.Y, LeftTarget.Position.X - Position.X);
                //spriteBatch.Draw(Texture, Position, null, ColorTint, leftRotation, Position, 1f, SpriteEffects.None, 0f);
                spriteBatch.Draw(Grapple,
                    new Rectangle((int)Position.X, (int)Position.Y, 2, (int)LeftTarget.Distance),
                    null, Color.Blue, leftRotation, Position, SpriteEffects.None, 0f);
            }
            if (RightGrapple)
            {
                float rightRotation = (float)Math.Atan2(RightTarget.Position.Y - Position.Y, RightTarget.Position.X - Position.X);
                //spriteBatch.Draw(Texture, Position, null, ColorTint, rightRotation, Position, 1f, SpriteEffects.None, 0f);
                spriteBatch.Draw(Grapple,
                    new Rectangle((int)Position.X, (int)Position.Y, 2, (int)RightTarget.Distance),
                    null, Color.Blue, rightRotation, Position, SpriteEffects.None, 0f);
            }

            spriteBatch.DrawString(font, "Player Rotation: " + Rotation, Position, Color.Red);
            spriteBatch.DrawString(font, "Player RoationDegree: " + (int)MathHelper.ToDegrees(Rotation), origin, Color.Blue);
        }

        public void GrappleCheck(AsteroidSprite target)
        {
            float targetTragectory = (float)Math.Atan2(Position.Y - target.Position.Y, Position.X - target.Position.X);

            if ((targetTragectory < (rotation - (float)MathHelper.PiOver4)) && ((targetTragectory > (rotation - (float)MathHelper.Pi + (float)MathHelper.PiOver4))))
            {
                target.Distance = Vector2.Distance(Position, target.Position);
                if (LeftTarget != null)
                {
                    if (LeftTarget.Distance > target.Distance)
                    {
                        LeftTarget.isTarget = false;
                        LeftTarget = target;
                        LeftTarget.isTarget = true;
                    }
                }
                else
                {
                    LeftTarget = target;
                    LeftTarget.isTarget = true;
                }
            }

            if ((targetTragectory > (rotation + (float)MathHelper.PiOver4)) && ((targetTragectory < (rotation + (float)MathHelper.Pi - (float)MathHelper.PiOver4))))
            {
                target.Distance = Vector2.Distance(Position, target.Position);
                if (RightTarget != null)
                {
                    if (RightTarget.Distance > target.Distance)
                    {
                        RightTarget.isTarget = false;
                        RightTarget = target;
                        RightTarget.isTarget = true;
                    }
                }
                else
                {
                    RightTarget = target;
                    RightTarget.isTarget = true;
                }
            }
        }
    }
}

名称空间Sparatius.Sprites
{
公共级玩家Prite:BaseSprite
{
控制输入控制输入；
纹理2d抓斗；
SpriteFont字体；
bool LeftGrapple=false，RightGrapple=false；
int-GrappleRange=300；
精灵。精灵左目标，右目标；
公共边界球体抓图框
{
获取{return new BoundingSphere（新向量3（Position.X+Origin.X，Position.Y+Origin.Y，0），grapleRange）；}
}
公共浮动速度
{
获取{返回速度；}
}
公共播放机Prite（Vector2 spriteLocal）
：基本（spriteLocal）
{
这个。旋转=0；
这个。速度=0；
this.FrameCount=新点（4,2）；
this.ColorTint=Color.White；
this.controlInput=新的controlInput（）；
}
公共void加载内容（ContentManager内容）
{
纹理=content.Load（“精灵/PinballSpin”）；
font=content.Load（“字体/Font1”）；
抓斗=content.Load（“精灵/抓斗”）；
FrameSize=新点（（int）Texture.Width/FrameCount.X，（int）Texture.Height/FrameCount.Y）；
原点=新矢量2（FrameSize.X/2，FrameSize.Y/2）；
动画=新动画（纹理、帧大小）；
}
公共覆盖无效更新（游戏时间游戏时间）
{
更新（游戏时间）；
controlInput.getControlState（）；
如果（controlInput.Just按下（W键））
速度+=2；
else if（controlInput.JustPressed（按键））
速度-=2；
if（controlInput.IsHeld（键A））
旋转-=0.05f；
if（controlInput.IsHeld（键D））
旋转+=0.05f；
if（LeftTarget！=null）
{
LeftTarget.Distance=Vector2.Distance（位置，LeftTarget.Position）；
如果（LeftTarget.Distance>抓取范围）
{
LeftTarget.isTarget=false；
LeftTarget=null；
}
if（controlInput.IsHeld（key.Q））
{
LeftGrapple=true；
}
其他的
LeftGrapple=false；
}
if（RightTarget！=null）
{
RightTarget.Distance=Vector2.Distance（位置，RightTarget.Position）；
如果（RightTarget.Distance>抓取范围）
{
RightTarget.isTarget=false；
RightTarget=null；
}
if（controlInput.IsHeld（键E））
{
RightGrapple=true；
}
其他的
右格斗=假；
}
}
公共覆盖无效绘图（SpriteBatch SpriteBatch）
{
基础绘制（spriteBatch）；
如果（左抓斗）
{
float leftRotation=（float）Math.Atan2（LeftTarget.Position.Y-Position.Y，LeftTarget.Position.X-Position.X）；
//spriteBatch.Draw（纹理、位置、空值、着色、左旋转、位置、1f、SpriteTeffects.None、0f）；
抓斗，
新矩形（（int）Position.X，（int）Position.Y，2，（int）LeftTarget.Distance），
空值，颜色。蓝色，左旋转，位置，精灵效果。无，0f）；
}
如果（右抓斗）
{
float rightRotation=（float）Math.Atan2（rightarget.Position.Y-Position.Y，rightarget.Position.X-Position.X）；
//spriteBatch.Draw（纹理、位置、空值、着色、右旋转、位置、1f、SpriteEffects.None、0f）；
抓斗，
新矩形（（int）Position.X，（int）Position.Y，2，（int）RightTarget.Distance），
空值，颜色。蓝色，右旋转，位置，精灵效果。无，0f）；
}
spriteBatch.DrawString（字体，“玩家旋转：+旋转，位置，颜色.红色）；
spriteBatch.DrawString（字体，“播放器旋转度：”+（int）MathHelper.ToDegrees（旋转）、原点、颜色、蓝色）；
}
公共空间抓斗检查（精灵目标）
{
float targettragetory=（float）Math.Atan2（Position.Y-target.Position.Y，Position.X-target.Position.X）；
如果（（targetTragetory<（旋转-（浮点）MathHelper.PiOver4））&&（（targetTragetory>（旋转-（浮点）MathHelper.Pi+（浮点）MathHelper.PiOver4）））
{
target.Distance=Vector2.Distance（位置，target.Position）；
if（LeftTarget！=null）
{
如果（LeftTarget.Distance>target.Distance）
{
LeftTarget.isTarget=false；
LeftTarget=目标；
LeftTarget.isTarget=true；
}
}
其他的
{
LeftTarget=目标；
LeftTarget.isTarget=true；
}
}
如果（（targetTragetory>（rotation+（float）MathHelper.PiOver4））&（（targetTragetory<（rotation+（float）MathHelper.Pi-（float）MathHelper.PiOver4）））
{
public static void DrawLine(SpriteBatch spriteBatch, Vector2 begin, Vector2 end, Color color, int width = 1)
    {
        Rectangle r = new Rectangle((int)begin.X, (int)begin.Y, (int)(end - begin).Length()+width, width);
        Vector2 v = Vector2.Normalize(begin - end);
        float angle = (float)Math.Acos(Vector2.Dot(v, -Vector2.UnitX));
        if (begin.Y > end.Y) angle = MathHelper.TwoPi - angle;
        spriteBatch.Draw(Pixel, r, null, color, angle, Vector2.Zero, SpriteEffects.None, 0);
    }