win8 开发之旅(18) 足球游戏揭秘4

这节，我们介绍一下DiscoidPosition,TableBorder,Vector2D  这三个类吧.你别开只有这三个类，对这个项目有着至关重要的作用。

①DiscoidPosition——物体的位置的坐标，标记物体的x，y坐标的位置。源代码如下所示：

    ///<summary>
   /// 物体的位置
    /// </summary>
    public class DiscoidPosition
    {
        /// <summary>
        /// x坐标
        /// </summary>
        public double X { get; set; }
        /// <summary>
        /// y坐标
        /// </summary>
        public double Y { get; set; }
    }

  这样子，能够定位物体的相应的坐标了，具体情况如图所示：

②TableBorder——字面意思，表面边框的类。这里隐身的意思是，相应物体的边框的类。干什么， 用于碰撞检测和碰撞冲突解决的类，相应的源代码如下：

    /// <summary>
    /// 表格的边框的属性  边框的属性，用于碰撞检测的类
    /// </summary>
    public class TableBorder
    {
        #region attributes
        /// <summary>
        /// 相应的消息
        /// </summary>
        public static string message;
        //IBallObserver observer;
        /// <summary>
        /// x坐标
        /// </summary>
        double x;
        /// <summary>
        /// y坐标
        /// </summary>
        double y;
        /// <summary>
        /// 宽度
        /// </summary>
        double width;
        /// <summary>
        /// 高度
        /// </summary>
        double height;
        /// <summary>
        /// 位置的向量
        /// </summary>
        Vector2D position;
        /// <summary>
        /// 此村的向量
        /// </summary>
        Vector2D size;
        #endregion attributes
        /// <summary>
        /// 构造函数 进行数据的初始化
        /// </summary>
        /// <param name="x">x坐标</param>
        /// <param name="y">y坐标</param>
        /// <param name="width">宽度</param>
        /// <param name="height">高度</param>
        #region constructor
        public TableBorder(int x, int y, int width, int height)
        {
            //this.observer = observer;
            //位置向量的赋值
            this.position = new Vector2D(x, y);
            //尺寸向量的赋值
            this.size = new Vector2D(width, height);
        }
        #endregion constructor

        #region properties
        /// <summary>
        /// x坐标
        /// </summary>
        public double X
        {
            get { return x; }
            set { x = value; }
        }
        /// <summary>
        /// y坐标
        /// </summary>
        public double Y
        {
            get { return y; }
            set { y = value; }
        }
        /// <summary>
        /// 宽度
        /// </summary>
        public double Width
        {
            get { return width; }
            set { width = value; }
        }
        /// <summary>
        /// 高度
        /// </summary>
        public double Height
        {
            get {  return height; }
            set { height = value; }
        }
        #endregion properties

        #region functions
        /// <summary>
        /// 进行碰撞检测及碰撞冲突解决的方法
        /// </summary>
        /// <param name="discoid"></param>
        /// <returns></returns>
        public RectangleCollision Colliding(Discoid discoid)
        {
            //默认是没有任何矩形的相交的
          RectangleCollision collision = RectangleCollision.None;
            //x 距离
            double mediumX = (discoid.LastX + discoid.Position.X) / 2.0;
           //y距离
            double mediumY = (discoid.LastY + discoid.Position.Y) / 2.0;

            //if (!discoid.IsBallInGoal)
            //{
            //bool insideWidth = (discoid.X > position.X) && (discoid.X < position.X + size.X);
            //bool insideHeight = (discoid.Y > position.Y) && (discoid.Y < position.Y + size.Y);
            //是否在里面的内部
            bool insideWidth = ((discoid.Position.X > position.X) && (discoid.Position.X < position.X + size.X));
            //是否在里面的外部
            bool insideHeight = (discoid.Position.Y > position.Y) && (discoid.Position.Y < position.Y + size.Y);

            //if ((discoid.X < position.X) && (discoid.X + discoid.Radius > position.X) && (discoid.X - discoid.Radius < position.X + size.X) && insideHeight && (discoid.TranslateVelocity.X + discoid.VSpinVelocity.X > 0))
            //左方向
            if ((discoid.LastX < position.X) && (discoid.Position.X + discoid.Radius > position.X) && (discoid.Position.X - discoid.Radius < position.X + size.X) && insideHeight && (discoid.TranslateVelocity.X + discoid.VSpinVelocity.X > 0))
            {
                collision = RectangleCollision.Left;
            }
            //else if ((discoid.X > (position.X + size.X)) && (discoid.X - discoid.Radius < position.X + size.X) && (discoid.X + discoid.Radius > position.X) && insideHeight && (discoid.TranslateVelocity.X + discoid.VSpinVelocity.X < 0))
             //有方向
            else if ((discoid.LastX + discoid.Radius > position.X + size.X) && (discoid.Position.X - discoid.Radius < position.X + size.X) && (discoid.Position.X + discoid.Radius > position.X) && insideHeight && (discoid.TranslateVelocity.X + discoid.VSpinVelocity.X < 0))
            {
                collision = RectangleCollision.Right;
            }

            //if ((discoid.Y < position.Y) && (discoid.Y + discoid.Radius > position.Y) && (discoid.Y - discoid.Radius < position.Y + size.Y) && insideWidth && (discoid.TranslateVelocity.Y + discoid.VSpinVelocity.Y > 0))
             //顶端的方向
            if ((discoid.LastY < position.Y) && (discoid.Position.Y + discoid.Radius > position.Y) && (discoid.Position.Y - discoid.Radius < position.Y + size.Y) && insideWidth && (discoid.TranslateVelocity.Y + discoid.VSpinVelocity.Y > 0))
            {
                collision = RectangleCollision.Top;
            }
                //末尾的方向
            else if ((discoid.Position.Y + discoid.Radius > position.Y + size.Y) && (discoid.Position.Y - discoid.Radius < position.Y + size.Y) && (discoid.Position.Y + discoid.Radius > position.Y) && insideWidth && (discoid.TranslateVelocity.Y + discoid.VSpinVelocity.Y < 0))
            //else if ((discoid.LastY > (position.Y + size.Y)) && (discoid.Y - discoid.Radius < position.Y + size.Y) && (discoid.Y + discoid.Radius > position.Y) && insideWidth && (discoid.TranslateVelocity.Y + discoid.VSpinVelocity.Y < 0))
            {
                collision = RectangleCollision.Bottom;
            }
            //}
            //最终碰撞的矩形方向
            return collision;
       }

        /// <summary>
        ///  处理碰撞检测的方法
        /// </summary>
        /// <param name="discoid">当前的圆圈的对象</param>
        /// <param name="collision">碰撞检测的矩形对象</param>
        public void ResolveCollision(Discoid discoid, RectangleCollision collision)
        {
            //合并  的   方缩量
            double absorption = 0.9f;
            //  判断上下方向
            switch (collision)
            {
                case RectangleCollision.Right:
                case RectangleCollision.Left:
                    //dx量
                    double dX = 0;
                    //方向是左方
                    if (collision == RectangleCollision.Left)
                    {
                        //  dx=x1+r-x2     相应坐标只差
                        dX = (discoid.X + discoid.Radius) - this.position.X;
                    }
                    else
                    {
                         //dx=x1+s-x2-r
                        dX = (this.position.X + this.size.X ) - (discoid.X + discoid.Radius);
                    }
                       //位置x坐标 =x-只差
                    discoid.Position.X = this.position.X - dX;
                      //传递的  向量 x坐标  圆圈的xz坐标  坐标大于0的话
                    if (Math.Sign(discoid.TranslateVelocity.X) == Math.Sign(discoid.VSpinVelocity.X) && discoid.VSpinVelocity.X > 0.0)
                    {
                        //圆圈的传递的向量
                        discoid.TranslateVelocity = discoid.TranslateVelocity.Add(new Vector2D(discoid.VSpinVelocity.X, 0));
                        //圆圈的spin的  向量
                        discoid.VSpinVelocity = discoid.VSpinVelocity.Add(new Vector2D(0, discoid.VSpinVelocity.Y));
                    }
                    //传递向量的x坐标
                    discoid.TranslateVelocity.X = discoid.TranslateVelocity.X * (-1.0f * absorption);
                    break;
                    //跳出  switch 条件
                case RectangleCollision.Bottom:
                case RectangleCollision.Top:
                    //dy循环
                    double dY = 0;
                    //如果是顶部
                    if (collision == RectangleCollision.Top)
                    {
                        //dy=y1+r-y2;
                        dY = (discoid.Y + discoid.Radius) - this.position.Y;
                    }
                        //dy=y1-y2-r
                    else
                    {
                        dY = this.position.Y - (discoid.Y + discoid.Radius);
                    }
                    //y的距离
                    discoid.Position.Y = this.position.Y - dY;
                   //速度相对的话 就赋值给相应传递的 向量
                    if (Math.Sign(discoid.TranslateVelocity.Y) == Math.Sign(discoid.VSpinVelocity.Y) && discoid.VSpinVelocity.Y > 0.0)
                    {
                        discoid.TranslateVelocity = discoid.TranslateVelocity.Add(new Vector2D(0, discoid.VSpinVelocity.Y));
                        discoid.VSpinVelocity = discoid.VSpinVelocity.Add(new Vector2D(discoid.VSpinVelocity.X, 0));
                    }
                    //向量的y轴  的赋值
                    discoid.TranslateVelocity.Y = discoid.TranslateVelocity.Y * (-1.0f * absorption);
                    break;

            }
        }
        /// <summary>
        /// 重写了tostring的方法
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return string.Format("TableBorder({0}, {1}, {2}, {3})", position.X, position.Y, position.X + size.X, position.Y + size.Y);
        }

        //public override void Draw(SpriteBatch spriteBatch, Vector2D offset)
        //{
        //    Vector2D position = new Vector2D(this.position.X + offset.X, this.position.Y + offset.Y);
        //    Color color = new Color(255, 255, 255, 255);
        //    spriteBatch.Draw(texture, position, new Rectangle(0, 0, (int)size.X, (int)size.Y), color, 0f, new Vector2D(0, 0), (1.0f / 1.0f), SpriteEffects.None, 0f);
        //}

        #endregion functions
    }

我这里解决的碰撞检测的类，是通过x,y方法来判断他是否碰撞。具体情况如图所示：判断他的坐标之差与其相应的方向的坐标进行比较，最终来获取相应的方向，最后进行了碰撞解决的方案，就是赋给其向量值（其实物理的中和速度的概念），这里有两个合速度，一个运行的合速度，一个是旋转的合速度。具体情况，如图所示:

③Vector2D——向量类，判断相应合速度的类，具体源代码如下：

    /// <summary>
    /// 2D画图的类
    /// </summary>
    public class Vector2D
    {
        #region attributes
        /// <summary>
        /// x坐标
        /// </summary>
        private double x;
        /// <summary>
        /// y坐标
        /// </summary>
        private double y;
        #endregion attributes

        /// <summary>
        /// 构造函数 进行数据的初始化
        /// </summary>
        /// <param name="vx">x轴的速度</param>
        /// <param name="vy">y轴的速度</param>
        #region constructor
        public Vector2D(double vx, double vy)
        {
            //x轴的速度
            this.x = vx;
            //y轴的速度
            this.y = vy;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="v">向量的对象</param>
        public Vector2D(Vector2D v)
        {
            //x轴的速度
            this.x = v.x;
            //y轴的速度
            this.y = v.y;
        }
        #endregion constructor

        #region properties
        /// <summary>
        /// x轴速度的多少
        /// </summary>
        public double X
        {
            get { return x; }
            set
            {
                //x小于150000
                if (x<=15000)
                {
                    x = value;
                }

             
            }
        }
        /// <summary>
        /// y轴速度的多少
        /// </summary>
        public double Y
        {
            get {  return y; }
            set { y = value; }
        }
        #endregion properties

        #region functions
        /// <summary>
        /// 添加的方法 
        /// </summary>
        /// <param name="lhs">lhs向量</param>
        /// <param name="rhs">rhs向量</param>
        /// <returns>向量的方法</returns>
        public Vector2D Add(Vector2D lhs, Vector2D rhs)
        {
            Vector2D result = new Vector2D(lhs);
            //x  轴变化
            result.x = result.x + rhs.x;
            //y轴 的变化
            result.y = result.y + rhs.y;
            //返回结果
            return (result);
        }
        /// <summary>
        /// 进行添加的方法
        /// </summary>
        /// <param name="v">第一个向量对象</param>
        /// <returns>当前向量的对象</returns>
        public Vector2D Add(Vector2D v)
        {
             //当前的向量的对象 
             Vector2D result = new Vector2D(this);
            //x轴的变化
            result.X = result.X + v.X;
            //y轴的变化
            result.Y = result.Y + v.Y;
            //返回结果
            return (result);
        }
        /// <summary>
        /// 进行添加的方法
        /// </summary>
        /// <param name="f">当前的值</param>
        /// <returns>当前向量的对象</returns>
        public Vector2D Add(float f)
        {
            //当前的向量的对象
            Vector2D result = new Vector2D(this);
            //x轴的变化
            result.x = result.x + f;
            //Y轴的变化
            result.y += f;
            //返回结果
            return (result); 
        }

        /// <summary>
        /// 进行的相减的方法
        /// </summary>
        /// <param name="lhs">向量1</param>
        /// <param name="rhs">向量2</param>
        /// <returns>当前向量的对象</returns>
        public Vector2D Subtract(Vector2D lhs, Vector2D rhs)
        {
            //当前的向量的对象
            Vector2D result = new Vector2D(lhs);
            //x轴的变化
            result.x = result.x - rhs.x;
            //y周的变化
            result.y = result.y - rhs.y;
            //返回结果
            return(result);
        }

        /// <summary>
        /// 进行相见的方法
        /// </summary>
        /// <param name="v">向量</param>
        /// <returns>当前向量的对象</returns>
        public Vector2D Subtract(Vector2D v)
        {
            //向量的对象
            Vector2D result = new Vector2D(this);
            //x轴变化
            result.X = result.X - v.X;
            //y周的变化
            result.Y = result.Y - v.Y;
            //返回结果
            return (result);
        }

        /// <summary>
        /// 想成的方法
        /// </summary>
        /// <param name="lhs">lh的浮点数</param>
        /// <param name="rhs">向量的方法</param>
        /// <returns>想成的方法</returns>
        public Vector2D Multiply(double lhs, Vector2D rhs)
        {
            //向量对象
            Vector2D result = new Vector2D(rhs);
            //x坐标变化
            result.x = result.x * lhs;
            //y坐标的变化
            result.Y = result.Y * lhs;
           //返回结果
            return (result);
        }
        /// <summary>
        /// 进行象呈的方法
        /// </summary>
        /// <param name="lhs">向量对象</param>
        /// <param name="rhs">浮点变量</param>
        /// <returns>最后的对象</returns>
        public Vector2D Multiply(Vector2D lhs, double rhs)
        {
            //向量的对象
            Vector2D result = new Vector2D(lhs);
            //香橙的方法
            result.x *= rhs;
            result.y *= rhs;
            //返回对象
            return (result);
        }


        public Vector2D Multiply(double d)
        {
            Vector2D result = new Vector2D(this);
            result.x *= d;
            result.y *= d;
            return (result);
        }
        /// <summary>
        /// 相应的长度
        /// </summary>
        /// <returns></returns>
        public float Length()
        {
            //长度
            float ret = (float)(Math.Sqrt(Math.Pow(this.x, 2) + Math.Pow(this.y, 2)));
            //最后的结果
            return ret;
        }
        /// <summary>
        /// 最终的结果
        /// </summary>
        /// <param name="v"></param>
        /// <returns></returns>
        public float Dot(Vector2D v)
        {
            //最终的结果
            return ((float)(x * v.X + y * v.Y));
        }
        /// <summary>
        /// 普通的放缩
        /// </summary>
        /// <returns></returns>
        public Vector2D Normalize()
        {
            //长度
            float l = Length();
            Vector2D result = new Vector2D(this);
           
            result.x = result.x / l;
            result.y = result.y / l;
            //最终的结果
            return result;
        }
        #endregion functions
    }

 这是一个模拟数据中的向量加减乘除的类，你会问我向量的加减乘除对这个游戏有什么作用。

加——两个向量的x坐标，y坐标相加生成新的向量。  进行静态物体碰撞有重要的作用。

减——两个向量的x坐标，y坐标相间生成新的向量。进行反响向量碰撞有重要作用。

乘——向量的x坐标，y坐标相乘生成新的向量。 在踢球的过程中有重要的作用。

除——两个向量的x坐标，y坐标相除生成新的向量。

今天，我们把这几个类学习完了，其他的类后面再说。源代码地址：http://51aspx.com/Code/ZCWWorldCupV10