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

  1. 云栖社区>
  2. 博客>
  3. 正文

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

laozhu1124 2016-04-15 12:34:15 浏览935

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

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


 1     ///<summary>
 2    /// 物体的位置
 3     /// </summary>
 4     public class DiscoidPosition
 5     {
 6         /// <summary>
 7         /// x坐标
 8         /// </summary>
 9         public double X { get; set; }
10         /// <summary>
11         /// y坐标
12         /// </summary>
13         public double Y { get; set; }
14     }

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

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


 1     /// <summary>
  2     /// 表格的边框的属性  边框的属性,用于碰撞检测的类
  3     /// </summary>
  4     public class TableBorder
  5     {
  6         #region attributes
  7         /// <summary>
  8         /// 相应的消息
  9         /// </summary>
 10         public static string message;
 11         //IBallObserver observer;
 12         /// <summary>
 13         /// x坐标
 14         /// </summary>
 15         double x;
 16         /// <summary>
 17         /// y坐标
 18         /// </summary>
 19         double y;
 20         /// <summary>
 21         /// 宽度
 22         /// </summary>
 23         double width;
 24         /// <summary>
 25         /// 高度
 26         /// </summary>
 27         double height;
 28         /// <summary>
 29         /// 位置的向量
 30         /// </summary>
 31         Vector2D position;
 32         /// <summary>
 33         /// 此村的向量
 34         /// </summary>
 35         Vector2D size;
 36         #endregion attributes
 37         /// <summary>
 38         /// 构造函数 进行数据的初始化
 39         /// </summary>
 40         /// <param name="x">x坐标</param>
 41         /// <param name="y">y坐标</param>
 42         /// <param name="width">宽度</param>
 43         /// <param name="height">高度</param>
 44         #region constructor
 45         public TableBorder(int x, int y, int width, int height)
 46         {
 47             //this.observer = observer;
 48             //位置向量的赋值
 49             this.position = new Vector2D(x, y);
 50             //尺寸向量的赋值
 51             this.size = new Vector2D(width, height);
 52         }
 53         #endregion constructor
 54 
 55         #region properties
 56         /// <summary>
 57         /// x坐标
 58         /// </summary>
 59         public double X
 60         {
 61             get { return x; }
 62             set { x = value; }
 63         }
 64         /// <summary>
 65         /// y坐标
 66         /// </summary>
 67         public double Y
 68         {
 69             get { return y; }
 70             set { y = value; }
 71         }
 72         /// <summary>
 73         /// 宽度
 74         /// </summary>
 75         public double Width
 76         {
 77             get { return width; }
 78             set { width = value; }
 79         }
 80         /// <summary>
 81         /// 高度
 82         /// </summary>
 83         public double Height
 84         {
 85             get {  return height; }
 86             set { height = value; }
 87         }
 88         #endregion properties
 89 
 90         #region functions
 91         /// <summary>
 92         /// 进行碰撞检测及碰撞冲突解决的方法
 93         /// </summary>
 94         /// <param name="discoid"></param>
 95         /// <returns></returns>
 96         public RectangleCollision Colliding(Discoid discoid)
 97         {
 98             //默认是没有任何矩形的相交的
 99           RectangleCollision collision = RectangleCollision.None;
101             //x 距离
102             double mediumX = (discoid.LastX + discoid.Position.X) / 2.0;
103            //y距离
104             double mediumY = (discoid.LastY + discoid.Position.Y) / 2.0;
105 
106             //if (!discoid.IsBallInGoal)
107             //{
108             //bool insideWidth = (discoid.X > position.X) && (discoid.X < position.X + size.X);
109             //bool insideHeight = (discoid.Y > position.Y) && (discoid.Y < position.Y + size.Y);
110             //是否在里面的内部
111             bool insideWidth = ((discoid.Position.X > position.X) && (discoid.Position.X < position.X + size.X));
112             //是否在里面的外部
113             bool insideHeight = (discoid.Position.Y > position.Y) && (discoid.Position.Y < position.Y + size.Y);
114 
115             //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))
116             //左方向
117             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))
118             {
119                 collision = RectangleCollision.Left;
120             }
121             //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))
122              //有方向
123             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))
124             {
125                 collision = RectangleCollision.Right;
126             }
127 
128             //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))
129              //顶端的方向
130             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))
131             {
132                 collision = RectangleCollision.Top;
133             }
134                 //末尾的方向
135             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))
136             //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))
137             {
138                 collision = RectangleCollision.Bottom;
139             }
140             //}
141             //最终碰撞的矩形方向
142             return collision;
143        }
144 
145         /// <summary>
146         ///  处理碰撞检测的方法
147         /// </summary>
148         /// <param name="discoid">当前的圆圈的对象</param>
149         /// <param name="collision">碰撞检测的矩形对象</param>
150         public void ResolveCollision(Discoid discoid, RectangleCollision collision)
151         {
152             //合并  的   方缩量
153             double absorption = 0.9f;
154             //  判断上下方向
155             switch (collision)
156             {
157                 case RectangleCollision.Right:
158                 case RectangleCollision.Left:
159                     //dx量
160                     double dX = 0;
161                     //方向是左方
162                     if (collision == RectangleCollision.Left)
163                     {
164                         //  dx=x1+r-x2     相应坐标只差
165                         dX = (discoid.X + discoid.Radius) - this.position.X;
166                     }
167                     else
168                     {
169                          //dx=x1+s-x2-r
170                         dX = (this.position.X + this.size.X ) - (discoid.X + discoid.Radius);
171                     }
172                        //位置x坐标 =x-只差
173                     discoid.Position.X = this.position.X - dX;
174                       //传递的  向量 x坐标  圆圈的xz坐标  坐标大于0的话
175                     if (Math.Sign(discoid.TranslateVelocity.X) == Math.Sign(discoid.VSpinVelocity.X) && discoid.VSpinVelocity.X > 0.0)
176                     {
177                         //圆圈的传递的向量
178                         discoid.TranslateVelocity = discoid.TranslateVelocity.Add(new Vector2D(discoid.VSpinVelocity.X, 0));
179                         //圆圈的spin的  向量
180                         discoid.VSpinVelocity = discoid.VSpinVelocity.Add(new Vector2D(0, discoid.VSpinVelocity.Y));
181                     }
182                     //传递向量的x坐标
183                     discoid.TranslateVelocity.X = discoid.TranslateVelocity.X * (-1.0f * absorption);
184                     break;
185                     //跳出  switch 条件
186                 case RectangleCollision.Bottom:
187                 case RectangleCollision.Top:
188                     //dy循环
189                     double dY = 0;
190                     //如果是顶部
191                     if (collision == RectangleCollision.Top)
192                     {
193                         //dy=y1+r-y2;
194                         dY = (discoid.Y + discoid.Radius) - this.position.Y;
195                     }
196                         //dy=y1-y2-r
197                     else
198                     {
199                         dY = this.position.Y - (discoid.Y + discoid.Radius);
200                     }
201                     //y的距离
202                     discoid.Position.Y = this.position.Y - dY;
203                    //速度相对的话 就赋值给相应传递的 向量
204                     if (Math.Sign(discoid.TranslateVelocity.Y) == Math.Sign(discoid.VSpinVelocity.Y) && discoid.VSpinVelocity.Y > 0.0)
205                     {
206                         discoid.TranslateVelocity = discoid.TranslateVelocity.Add(new Vector2D(0, discoid.VSpinVelocity.Y));
207                         discoid.VSpinVelocity = discoid.VSpinVelocity.Add(new Vector2D(discoid.VSpinVelocity.X, 0));
208                     }
209                     //向量的y轴  的赋值
210                     discoid.TranslateVelocity.Y = discoid.TranslateVelocity.Y * (-1.0f * absorption);
211                     break;
212 
213             }
214         }
215         /// <summary>
216         /// 重写了tostring的方法
217         /// </summary>
218         /// <returns></returns>
219         public override string ToString()
220         {
221             return string.Format("TableBorder({0}, {1}, {2}, {3})", position.X, position.Y, position.X + size.X, position.Y + size.Y);
222         }
223 
224         //public override void Draw(SpriteBatch spriteBatch, Vector2D offset)
225         //{
226         //    Vector2D position = new Vector2D(this.position.X + offset.X, this.position.Y + offset.Y);
227         //    Color color = new Color(255, 255, 255, 255);
228         //    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);
229         //}
230 
231         #endregion functions
232     }

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

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


 1     /// <summary>
  2     /// 2D画图的类
  3     /// </summary>
  4     public class Vector2D
  5     {
  6         #region attributes
  7         /// <summary>
  8         /// x坐标
  9         /// </summary>
 10         private double x;
 11         /// <summary>
 12         /// y坐标
 13         /// </summary>
 14         private double y;
 15         #endregion attributes
 16 
 17         /// <summary>
 18         /// 构造函数 进行数据的初始化
 19         /// </summary>
 20         /// <param name="vx">x轴的速度</param>
 21         /// <param name="vy">y轴的速度</param>
 22         #region constructor
 23         public Vector2D(double vx, double vy)
 24         {
 25             //x轴的速度
 26             this.x = vx;
 27             //y轴的速度
 28             this.y = vy;
 29         }
 30 
 31         /// <summary>
 32         /// 构造函数
 33         /// </summary>
 34         /// <param name="v">向量的对象</param>
 35         public Vector2D(Vector2D v)
 36         {
 37             //x轴的速度
 38             this.x = v.x;
 39             //y轴的速度
 40             this.y = v.y;
 41         }
 42         #endregion constructor
 43 
 44         #region properties
 45         /// <summary>
 46         /// x轴速度的多少
 47         /// </summary>
 48         public double X
 49         {
 50             get { return x; }
 51             set
 52             {
 53                 //x小于150000
 54                 if (x<=15000)
 55                 {
 56                     x = value;
 57                 }
 58 
 59              
 60             }
 61         }
 62         /// <summary>
 63         /// y轴速度的多少
 64         /// </summary>
 65         public double Y
 66         {
 67             get {  return y; }
 68             set { y = value; }
 69         }
 70         #endregion properties
 71 
 72         #region functions
 73         /// <summary>
 74         /// 添加的方法 
 75         /// </summary>
 76         /// <param name="lhs">lhs向量</param>
 77         /// <param name="rhs">rhs向量</param>
 78         /// <returns>向量的方法</returns>
 79         public Vector2D Add(Vector2D lhs, Vector2D rhs)
 80         {
 81             Vector2D result = new Vector2D(lhs);
 82             //x  轴变化
 83             result.x = result.x + rhs.x;
 84             //y轴 的变化
 85             result.y = result.y + rhs.y;
 86             //返回结果
 87             return (result);
 88         }
 89         /// <summary>
 90         /// 进行添加的方法
 91         /// </summary>
 92         /// <param name="v">第一个向量对象</param>
 93         /// <returns>当前向量的对象</returns>
 94         public Vector2D Add(Vector2D v)
 95         {
 96              //当前的向量的对象 
 97              Vector2D result = new Vector2D(this);
 98             //x轴的变化
 99             result.X = result.X + v.X;
100             //y轴的变化
101             result.Y = result.Y + v.Y;
102             //返回结果
103             return (result);
104         }
105         /// <summary>
106         /// 进行添加的方法
107         /// </summary>
108         /// <param name="f">当前的值</param>
109         /// <returns>当前向量的对象</returns>
110         public Vector2D Add(float f)
111         {
112             //当前的向量的对象
113             Vector2D result = new Vector2D(this);
114             //x轴的变化
115             result.x = result.x + f;
116             //Y轴的变化
117             result.y += f;
118             //返回结果
119             return (result); 
120         }
121 
122         /// <summary>
123         /// 进行的相减的方法
124         /// </summary>
125         /// <param name="lhs">向量1</param>
126         /// <param name="rhs">向量2</param>
127         /// <returns>当前向量的对象</returns>
128         public Vector2D Subtract(Vector2D lhs, Vector2D rhs)
129         {
130             //当前的向量的对象
131             Vector2D result = new Vector2D(lhs);
132             //x轴的变化
133             result.x = result.x - rhs.x;
134             //y周的变化
135             result.y = result.y - rhs.y;
136             //返回结果
137             return(result);
138         }
139 
140         /// <summary>
141         /// 进行相见的方法
142         /// </summary>
143         /// <param name="v">向量</param>
144         /// <returns>当前向量的对象</returns>
145         public Vector2D Subtract(Vector2D v)
146         {
147             //向量的对象
148             Vector2D result = new Vector2D(this);
149             //x轴变化
150             result.X = result.X - v.X;
151             //y周的变化
152             result.Y = result.Y - v.Y;
153             //返回结果
154             return (result);
155         }
156 
157         /// <summary>
158         /// 想成的方法
159         /// </summary>
160         /// <param name="lhs">lh的浮点数</param>
161         /// <param name="rhs">向量的方法</param>
162         /// <returns>想成的方法</returns>
163         public Vector2D Multiply(double lhs, Vector2D rhs)
164         {
165             //向量对象
166             Vector2D result = new Vector2D(rhs);
167             //x坐标变化
168             result.x = result.x * lhs;
169             //y坐标的变化
170             result.Y = result.Y * lhs;
171            //返回结果
172             return (result);
173         }
174         /// <summary>
175         /// 进行象呈的方法
176         /// </summary>
177         /// <param name="lhs">向量对象</param>
178         /// <param name="rhs">浮点变量</param>
179         /// <returns>最后的对象</returns>
180         public Vector2D Multiply(Vector2D lhs, double rhs)
181         {
182             //向量的对象
183             Vector2D result = new Vector2D(lhs);
184             //香橙的方法
185             result.x *= rhs;
186             result.y *= rhs;
187             //返回对象
188             return (result);
189         }
190 
191 
192         public Vector2D Multiply(double d)
193         {
194             Vector2D result = new Vector2D(this);
195             result.x *= d;
196             result.y *= d;
197             return (result);
198         }
199         /// <summary>
200         /// 相应的长度
201         /// </summary>
202         /// <returns></returns>
203         public float Length()
204         {
205             //长度
206             float ret = (float)(Math.Sqrt(Math.Pow(this.x, 2) + Math.Pow(this.y, 2)));
207             //最后的结果
208             return ret;
209         }
210         /// <summary>
211         /// 最终的结果
212         /// </summary>
213         /// <param name="v"></param>
214         /// <returns></returns>
215         public float Dot(Vector2D v)
216         {
217             //最终的结果
218             return ((float)(x * v.X + y * v.Y));
219         }
220         /// <summary>
221         /// 普通的放缩
222         /// </summary>
223         /// <returns></returns>
224         public Vector2D Normalize()
225         {
226             //长度
227             float l = Length();
228             Vector2D result = new Vector2D(this);
229            
230             result.x = result.x / l;
231             result.y = result.y / l;
232             //最终的结果
233             return result;
234         }
235         #endregion functions
236     }

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

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

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

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

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

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