C# 计算游戏技能攻击区域

最新推荐文章于 2020-03-28 22:19:44 发布

q414620221

最新推荐文章于 2020-03-28 22:19:44 发布

阅读量622

点赞数 1

分类专栏： unity 技能攻击范围 C#语言特性

C#语言特性同时被 2 个专栏收录

22 篇文章 0 订阅

订阅专栏

unity 技能攻击范围

1 篇文章 0 订阅

订阅专栏

尊重原著成果： http://blog.csdn.net/u010019717/article/details/78313392

1、判断一个点是否在与坐标平行的矩形内

public struct AAB2 {
public Vector2 Min;
public Vector2 Max;
public static AAB2 CreateAAB2(Transform point0, Transform point1)
{
// Creates aab from two unsorted points, if you know min and max use constructor
return CreateFromTwoPoints(point0.position, point1.position);
}
public static AAB2 CreateFromTwoPoints(Vector2 point0, Vector2 point1)
{
AAB2 aab;
if (point0.x < point1.x)
{
aab.Min.x = point0.x;
aab.Max.x = point1.x;
}
else
{
aab.Min.x = point1.x;
aab.Max.x = point0.x;
}
if (point0.y < point1.y)
{
aab.Min.y = point0.y;
aab.Max.y = point1.y;
return aab;
}
aab.Min.y = point1.y;
aab.Max.y = point0.y;
return aab;
}
public bool Contains(ref Vector2 point)
{
if (point.x < this.Min.x)
{
return false;
}
if (point.x > this.Max.x)
{
return false;
}
if (point.y < this.Min.y)
{
return false;
}
if (point.y > this.Max.y)
{
return false;
}
return true;
}
public void CalcVertices(out Vector2 vertex0, out Vector2 vertex1, out Vector2 vertex2, out Vector2 vertex3)
{
vertex0 = this.Min;
vertex1 = new Vector2(this.Max.x, this.Min.y);
vertex2 = this.Max;
vertex3 = new Vector2(this.Min.x, this.Max.y);
}
}

[ExecuteInEditMode]
public class Test_ContPoint2AAB2 : MonoBehaviour
{
public Transform Point;
public Transform Box_Point0, Box_Point1;
private const float _pointRadius = .11f;
private void OnDrawGizmos()
{
Vector2 point = Point.position;
AAB2 box = AAB2.CreateAAB2(Box_Point0, Box_Point1);
bool cont = box.Contains(ref point);
FiguresColor();
DrawAAB(ref box);
if (cont) ResultsColor();
DrawPoint(point);
LogInfo(cont);
}
protected void DrawPoint(Vector2 position)
{
Gizmos.DrawSphere(position, _pointRadius);
}
protected void ResultsColor()
{
Gizmos.color = Color.blue;
}
protected void FiguresColor()
{
Gizmos.color = Color.gray;
}
protected void LogInfo(object value)
{
Debug.Log(value);
}
protected void DrawAAB(ref AAB2 box)
{
Vector2 v0, v1, v2, v3;
box.CalcVertices(out v0, out v1, out v2, out v3);
Gizmos.DrawLine(v0, v1);
Gizmos.DrawLine(v1, v2);
Gizmos.DrawLine(v2, v3);
Gizmos.DrawLine(v3, v0);
}
}

2、判断是否在矩形内

矩形就是 Box 对象决定，自己是原点，旋转决定了两个轴， Scale决定了宽高！

[ExecuteInEditMode]
public class Test_ContPoint2Box2 : MonoBehaviour
{
public Transform Point;
public Transform Box;
private const float _pointRadius = .11f;
private void OnDrawGizmos()
{
Vector2 point = Point.position;
Box2 box = Box2.CreateBox2(Box);
bool cont = box.Contains(ref point);
FiguresColor();
DrawBox(ref box);
if (cont) ResultsColor();
DrawPoint(point);
LogInfo(cont);
}
protected void DrawPoint(Vector2 position)
{
Gizmos.DrawSphere(position, _pointRadius);
}
protected void ResultsColor()
{
Gizmos.color = Color.blue;
}
protected void FiguresColor()
{
Gizmos.color = Color.gray;
}
protected void LogInfo(object value)
{
Debug.Log(value);
}
protected void DrawBox(ref Box2 box)
{
Vector2 v0, v1, v2, v3;
box.CalcVertices(out v0, out v1, out v2, out v3);
Gizmos.DrawLine(v0, v1);
Gizmos.DrawLine(v1, v2);
Gizmos.DrawLine(v2, v3);
Gizmos.DrawLine(v3, v0);
}
}

public struct Box2 {
public Vector2 Center;
public Vector2 Axis0;
public Vector2 Axis1;
public Vector2 Extents;
public Box2(Vector2 center, Vector2 axis0, Vector2 axis1, Vector2 extents)
{
this.Center = center;
this.Axis0 = axis0;
this.Axis1 = axis1;
this.Extents = extents;
}
public static Box2 CreateBox2(Transform box)
{
return new Box2(box.position, box.right, box.up, box.localScale);
}
public bool Contains(ref Vector2 point)
{
Vector2 vector;
vector.x = point.x - this.Center.x;
vector.y = point.y - this.Center.y;
float num = vector.Dot(ref this.Axis0);
if (num < -this.Extents.x)
{
return false;
}
if (num > this.Extents.x)
{
return false;
}
num = vector.Dot(ref this.Axis1);
if (num < -this.Extents.y)
{
return false;
}
if (num > this.Extents.y)
{
return false;
}
return true;
}
public void CalcVertices(out Vector2 vertex0, out Vector2 vertex1, out Vector2 vertex2, out Vector2 vertex3)
{
Vector2 vector = (Vector2)(this.Axis0 * this.Extents.x);
Vector2 vector2 = (Vector2)(this.Axis1 * this.Extents.y);
vertex0 = (this.Center - vector) - vector2;
vertex1 = (this.Center + vector) - vector2;
vertex2 = (this.Center + vector) + vector2;
vertex3 = (this.Center - vector) + vector2;
}
}
public static class Vector2ex
{
public static float Dot(this Vector2 vector, ref Vector2 value)
{
return ((vector.x * value.x) + (vector.y * value.y));
}
}

3、判断一个点是否在园内部

[ExecuteInEditMode]
public class Test_ContPoint2Circle2 : MonoBehaviour
{
public Transform Point;
public Transform Circle;
private const float _pointRadius = .11f;
private void OnDrawGizmos()
{
Vector2 point = Point.position;
Circle2 circle = Circle2.CreateCircle2(Circle);
bool cont = circle.Contains(ref point);
FiguresColor();
DrawCircle(ref circle);
if (cont) ResultsColor();
DrawPoint(point);
LogInfo(cont);
}
protected void DrawPoint(Vector2 position)
{
Gizmos.DrawSphere(position, _pointRadius);
}
protected void ResultsColor()
{
Gizmos.color = Color.blue;
}
protected void FiguresColor()
{
Gizmos.color = Color.gray;
}
protected void LogInfo(object value)
{
Debug.Log(value);
}
protected void DrawCircle(ref Circle2 circle)
{
int count = 40;
float delta = 2f * Mathf.PI / count;
Vector3 prev = circle.Eval(0);
for (int i = 1; i <= count; ++i)
{
Vector3 curr = circle.Eval(i * delta);
Gizmos.DrawLine(prev, curr);
prev = curr;
}
}
}

public struct Circle2
{
public Vector2 Center;
public float Radius;
public Circle2(Vector2 center, float radius)
{
this.Center = center;
this.Radius = radius;
}
public bool Contains(ref Vector2 point)
{
Vector2 vector = point - this.Center;
return (vector.SqrMagnitude() <= (this.Radius * this.Radius));
}
public Vector2 Eval(float t)
{
return new Vector2(this.Center.x + (this.Radius * Mathf.Cos(t)), this.Center.y + (this.Radius * Mathf.Sin(t)));
}
public static Circle2 CreateCircle2(Transform circle)
{
return new Circle2(circle.position, circle.localScale.x);
}
}

4、三角形内

[ExecuteInEditMode]
public class Test_ContPoint2Triangle2 : MonoBehaviour
{
public Transform Point;
public Transform V0, V1, V2;
private const float _pointRadius = .11f;
private void OnDrawGizmos()
{
Vector2 point = Point.position;
Triangle2 triangle = Triangle2.CreateTriangle2(V0, V1, V2);
Orientations orientation = triangle.CalcOrientation();
if (orientation == Orientations.CCW)
{
bool cont = triangle.Contains(ref point);
bool cont1 = triangle.ContainsCCW(ref point); // 如果你知道三角形方向(顶点顺序方向)，就用这个
FiguresColor();
DrawTriangle(ref triangle);
if (cont) ResultsColor();
DrawPoint(point);
LogInfo("Orientation: " + orientation + " Contained: " + cont);
if (cont != cont1)
Debug.LogError("cont != cont1");
}
else if (orientation == Orientations.CW)
{
bool cont = triangle.Contains(ref point);
bool cont1 = triangle.ContainsCW(ref point); // 如果你知道三角形方向(顶点顺序方向)，就用这个
FiguresColor();
DrawTriangle(ref triangle);
if (cont) ResultsColor();
DrawPoint(point);
LogInfo("Orientation: " + orientation + " Contained: " + cont);
if (cont != cont1)
Debug.LogError("cont != cont1");
}
else // Degenerate
{
Debug.LogError("Triangle is degenerate");
}
}
void DrawTriangle(ref Triangle2 triangle)
{
Gizmos.DrawLine(triangle.V0, triangle.V1);
Gizmos.DrawLine(triangle.V1, triangle.V2);
Gizmos.DrawLine(triangle.V2, triangle.V0);
}
protected void DrawPoint(Vector2 position)
{
Gizmos.DrawSphere(position, _pointRadius);
}
protected void ResultsColor()
{
Gizmos.color = Color.blue;
}
protected void FiguresColor()
{
Gizmos.color = Color.gray;
}
protected void LogInfo(object value)
{
Debug.Log(value);
}
}

public enum Orientations
{
CW,
CCW,
None
}
public struct Triangle2 {
public Vector2 V0;
public Vector2 V1;
public Vector2 V2;
public static Triangle2 CreateTriangle2(Transform v0, Transform v1, Transform v2)
{
return new Triangle2(v0.position, v1.position, v2.position);
}
public Triangle2(Vector2 v0, Vector2 v1, Vector2 v2)
{
this.V0 = v0;
this.V1 = v1;
this.V2 = v2;
}
public Orientations CalcOrientation(float threshold = 1E-05f)
{
float num = this.CalcDeterminant();
if (num > threshold)
{
return Orientations.CCW;
}
if (num < -threshold)
{
return Orientations.CW;
}
return Orientations.None;
}
public float CalcDeterminant()
{
return ((((((this.V1.x * this.V2.y) + (this.V0.x * this.V1.y)) + (this.V2.x * this.V0.y)) - (this.V1.x * this.V0.y)) - (this.V2.x * this.V1.y)) - (this.V0.x * this.V2.y));
}
public bool Contains(ref Vector2 point)
{
bool flag = (((point.x - this.V1.x) * (this.V0.y - this.V1.y)) - ((point.y - this.V1.y) * (this.V0.x - this.V1.x))) < 0f;
bool flag2 = (((point.x - this.V2.x) * (this.V1.y - this.V2.y)) - ((point.y - this.V2.y) * (this.V1.x - this.V2.x))) < 0f;
if (flag != flag2)
{
return false;
}
bool flag3 = (((point.x - this.V0.x) * (this.V2.y - this.V0.y)) - ((point.y - this.V0.y) * (this.V2.x - this.V0.x))) < 0f;
return (flag2 == flag3);
}
/// <summary>
/// 当已经知道三个顶点的顺序是逆时针方向的时候使用
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public bool ContainsCCW(ref Vector2 point)
{
if ((((point.x - this.V0.x) * (this.V1.y - this.V0.y)) - ((point.y - this.V0.y) * (this.V1.x - this.V0.x))) > 0f)
{
return false;
}
if ((((point.x - this.V1.x) * (this.V2.y - this.V1.y)) - ((point.y - this.V1.y) * (this.V2.x - this.V1.x))) > 0f)
{
return false;
}
if ((((point.x - this.V2.x) * (this.V0.y - this.V2.y)) - ((point.y - this.V2.y) * (this.V0.x - this.V2.x))) > 0f)
{
return false;
}
return true;
}
/// <summary>
/// 当已经知道三个顶点的顺序是顺时针方向的时候使用
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public bool ContainsCW(ref Vector2 point)
{
if ((((point.x - this.V0.x) * (this.V1.y - this.V0.y)) - ((point.y - this.V0.y) * (this.V1.x - this.V0.x))) < 0f)
{
return false;
}
if ((((point.x - this.V1.x) * (this.V2.y - this.V1.y)) - ((point.y - this.V1.y) * (this.V2.x - this.V1.x))) < 0f)
{
return false;
}
if ((((point.x - this.V2.x) * (this.V0.y - this.V2.y)) - ((point.y - this.V2.y) * (this.V0.x - this.V2.x))) < 0f)
{
return false;
}
return true;
}
}

5、凸多边形内

public class Test_ContPoint2ConvexPolygon2 : MonoBehaviour {
public Transform Point;
public Transform[] ConvexPolygon;
private const float _pointRadius = .11f;
private void OnDrawGizmos()
{
Vector2 point = Point.position;
Polygon2 convexPolygon = Polygon2.CreatePolygon2(ConvexPolygon);
Orientations orientation;
// 判断是凸状的不？
bool convex = convexPolygon.IsConvex(out orientation);
if (convex)
{
bool cont;
if (orientation == Orientations.CCW)
{
cont = convexPolygon.ContainsConvexCCW(ref point);
//cont = convexPolygon.ContainsConvexQuadCCW(point); // 如果你知道方向(顶点顺序方向)，就用这个
}
else // CW
{
cont = convexPolygon.ContainsConvexCW(ref point);
//cont = convexPolygon.ContainsConvexQuadCW(point);
}
FiguresColor();
DrawPolygon(convexPolygon);
if (cont) ResultsColor();
DrawPoint(point);
LogInfo("Orientation: " + orientation + " Contained: " + cont);
}
else
{
FiguresColor();
DrawPolygon(convexPolygon);
DrawPoint(point);
Debug.LogError("polygon is non-convex");
}
}
protected void DrawPolygon(Polygon2 polygon)
{
for (int i0 = 0, i1 = polygon.VertexCount - 1; i0 < polygon.VertexCount; i1 = i0, ++i0)
{
Gizmos.DrawLine(polygon[i0], polygon[i1]);
}
}
protected void DrawPoint(Vector2 position)
{
Gizmos.DrawSphere(position, _pointRadius);
}
protected void ResultsColor()
{
Gizmos.color = Color.blue;
}
protected void FiguresColor()
{
Gizmos.color = Color.gray;
}
protected void LogInfo(object value)
{
Debug.Log(value);
}
}

public struct Edge2
{
public Vector2 Point0;
public Vector2 Point1;
public Vector2 Direction;
public Vector2 Normal;
public float Length;
}
public static class Vector3ex
{
public static Vector2 ToVector2XY(this Vector3 vector)
{
return new Vector2(vector.x, vector.y);
}
}
public struct Polygon2 {
private Edge2[] _edges;
private Vector2[] _vertices;
public Polygon2(int vertexCount)
{
this._vertices = new Vector2[vertexCount];
this._edges = new Edge2[vertexCount];
}
public Vector2 this[int vertexIndex]
{
get
{
return this._vertices[vertexIndex];
}
set
{
this._vertices[vertexIndex] = value;
}
}
public int VertexCount
{
get
{
return this._vertices.Length;
}
}
public static Polygon2 CreatePolygon2(Transform[] polygon)
{
Polygon2 result = new Polygon2(polygon.Length);
for (int i = 0; i < polygon.Length; ++i)
{
result[i] = polygon[i].position.ToVector2XY();
}
result.UpdateEdges();
return result;
}
public void UpdateEdges()
{
int length = this._vertices.Length;
int index = length - 1;
for (int i = 0; i < length; i++)
{
Vector2 vector = (this._edges[index].Point1 = this._vertices[i]) - (this._edges[index].Point0 = this._vertices[index]);
this._edges[index].Length = Vector2ex.Normalize(ref vector, 1E-05f);
this._edges[index].Direction = vector;
this._edges[index].Normal = vector.Perp();
index = i;
}
}
/// <summary>
/// 判断当前是不是凸状的
/// </summary>
/// <param name="orientation"></param>
/// <param name="threshold"></param>
/// <returns></returns>
public bool IsConvex(out Orientations orientation, float threshold = 1E-05f)
{
orientation = Orientations.None;
int length = this._edges.Length;
int num2 = 0;
int index = length - 1;
for (int i = 0; i < length; i++)
{
Vector2 vector = -this._edges[index].Direction;
Vector2 direction = this._edges[i].Direction;
float num5 = vector.DotPerp(ref direction);
int num6 = ((num5 < -threshold) || (num5 > threshold)) ? ((num5 > 0f) ? 1 : -1) : 0;
if (num6 != 0)
{
if (num2 != 0)
{
if (((num2 > 0) && (num6 < 0)) || ((num2 < 0) && (num6 > 0)))
{
return false;
}
}
else
{
num2 += num6;
}
}
index = i;
}
orientation = (num2 == 0) ? Orientations.None : ((num2 > 0) ? Orientations.CW : Orientations.CCW);
return (orientation != Orientations.None);
}
public bool ContainsConvexCCW(ref Vector2 point)
{
return this.SubContainsPointCCW(ref point, 0, 0);
}
public bool ContainsConvexCW(ref Vector2 point)
{
return this.SubContainsPointCW(ref point, 0, 0);
}
private bool SubContainsPointCCW(ref Vector2 p, int i0, int i1)
{
float num2;
float num3;
float num4;
float num5;
int num7;
int length = this._vertices.Length;
int num6 = i1 - i0;
if ((num6 == 1) || ((num6 < 0) && ((num6 + length) == 1)))
{
num2 = this._vertices[i1].y - this._vertices[i0].y;
num3 = this._vertices[i0].x - this._vertices[i1].x;
num4 = p.x - this._vertices[i0].x;
num5 = p.y - this._vertices[i0].y;
return (((num2 * num4) + (num3 * num5)) <= 0f);
}
if (i0 < i1)
{
num7 = (i0 + i1) >> 1;
}
else
{
num7 = ((i0 + i1) + length) >> 1;
if (num7 >= length)
{
num7 -= length;
}
}
num2 = this._vertices[num7].y - this._vertices[i0].y;
num3 = this._vertices[i0].x - this._vertices[num7].x;
num4 = p.x - this._vertices[i0].x;
num5 = p.y - this._vertices[i0].y;
if (((num2 * num4) + (num3 * num5)) > 0f)
{
return this.SubContainsPointCCW(ref p, i0, num7);
}
return this.SubContainsPointCCW(ref p, num7, i1);
}
private bool SubContainsPointCW(ref Vector2 p, int i0, int i1)
{
float num2;
float num3;
float num4;
float num5;
int num7;
int length = this._vertices.Length;
int num6 = i1 - i0;
if ((num6 == 1) || ((num6 < 0) && ((num6 + length) == 1)))
{
num2 = this._vertices[i1].y - this._vertices[i0].y;
num3 = this._vertices[i0].x - this._vertices[i1].x;
num4 = p.x - this._vertices[i0].x;
num5 = p.y - this._vertices[i0].y;
return (((num2 * num4) + (num3 * num5)) >= 0f);
}
if (i0 < i1)
{
num7 = (i0 + i1) >> 1;
}
else
{
num7 = ((i0 + i1) + length) >> 1;
if (num7 >= length)
{
num7 -= length;
}
}
num2 = this._vertices[num7].y - this._vertices[i0].y;
num3 = this._vertices[i0].x - this._vertices[num7].x;
num4 = p.x - this._vertices[i0].x;
num5 = p.y - this._vertices[i0].y;
if (((num2 * num4) + (num3 * num5)) < 0f)
{
return this.SubContainsPointCW(ref p, i0, num7);
}
return this.SubContainsPointCW(ref p, num7, i1);
}
}

public static class Vector2ex
{
public static float Dot(this Vector2 vector, ref Vector2 value)
{
return ((vector.x * value.x) + (vector.y * value.y));
}
public static float Normalize(ref Vector2 vector, float epsilon = 1E-05f)
{
float num = Mathf.Sqrt((vector.x * vector.x) + (vector.y * vector.y));
if (num >= epsilon)
{
float num2 = 1f / num;
vector.x *= num2;
vector.y *= num2;
return num;
}
vector.x = 0f;
vector.y = 0f;
return 0f;
}
public static float DotPerp(this Vector2 vector, ref Vector2 value)
{
return ((vector.x * value.y) - (vector.y * value.x));
}
public static Vector2 Perp(this Vector2 vector)
{
return new Vector2(vector.y, -vector.x);
}
}

6、直接判断是否在多边形内。凹多边形内（其实不管是凹还是凸了）

public struct Edge2
{
public Vector2 Point0;
public Vector2 Point1;
public Vector2 Direction;
public Vector2 Normal;
public float Length;
}
public static class Vector3ex
{
public static Vector2 ToVector2XY(this Vector3 vector)
{
return new Vector2(vector.x, vector.y);
}
}
public struct Polygon2 {
private Edge2[] _edges;
private Vector2[] _vertices;
public Polygon2(int vertexCount)
{
this._vertices = new Vector2[vertexCount];
this._edges = new Edge2[vertexCount];
}
public Vector2 this[int vertexIndex]
{
get
{
return this._vertices[vertexIndex];
}
set
{
this._vertices[vertexIndex] = value;
}
}
public int VertexCount
{
get
{
return this._vertices.Length;
}
}
public static Polygon2 CreatePolygon2(Transform[] polygon)
{
Polygon2 result = new Polygon2(polygon.Length);
for (int i = 0; i < polygon.Length; ++i)
{
result[i] = polygon[i].position.ToVector2XY();
}
result.UpdateEdges();
return result;
}
public void UpdateEdges()
{
int length = this._vertices.Length;
int index = length - 1;
for (int i = 0; i < length; i++)
{
Vector2 vector = (this._edges[index].Point1 = this._vertices[i]) - (this._edges[index].Point0 = this._vertices[index]);
this._edges[index].Length = Vector2ex.Normalize(ref vector, 1E-05f);
this._edges[index].Direction = vector;
this._edges[index].Normal = vector.Perp();
index = i;
}
}
public bool ContainsSimple(ref Vector2 point)
{
bool flag = false;
int length = this._vertices.Length;
int index = 0;
int num3 = length - 1;
while (index < length)
{
float num4;
float num5;
Vector2 vector = this._vertices[index];
Vector2 vector2 = this._vertices[num3];
if (point.y < vector2.y)
{
if (vector.y <= point.y)
{
num5 = (point.y - vector.y) * (vector2.x - vector.x);
num4 = (point.x - vector.x) * (vector2.y - vector.y);
if (num5 > num4)
{
flag = !flag;
}
}
}
else if (point.y < vector.y)
{
num5 = (point.y - vector.y) * (vector2.x - vector.x);
num4 = (point.x - vector.x) * (vector2.y - vector.y);
if (num5 < num4)
{
flag = !flag;
}
}
num3 = index;
index++;
}
return flag;
}
}

[ExecuteInEditMode]
public class Test_ContPoint2Polygon2 : MonoBehaviour
{
public Transform Point;
public Transform[] Polygon;
private const float _pointRadius = .11f;
private void OnDrawGizmos()
{
Vector2 point = Point.position;
Polygon2 polygon = Polygon2.CreatePolygon2(Polygon);
bool cont = polygon.ContainsSimple(ref point);
FiguresColor();
DrawPolygon(polygon);
if (cont) ResultsColor();
DrawPoint(point);
LogInfo(cont);
}
protected void DrawPolygon(Polygon2 polygon)
{
for (int i0 = 0, i1 = polygon.VertexCount - 1; i0 < polygon.VertexCount; i1 = i0, ++i0)
{
Gizmos.DrawLine(polygon[i0], polygon[i1]);
}
}
protected void DrawPoint(Vector2 position)
{
Gizmos.DrawSphere(position, _pointRadius);
}
protected void ResultsColor()
{
Gizmos.color = Color.blue;
}
protected void FiguresColor()
{
Gizmos.color = Color.gray;
}
protected void LogInfo(object value)
{
Debug.Log(value);
}
}

public static class Vector2ex
{
public static float Normalize(ref Vector2 vector, float epsilon = 1E-05f)
{
float num = Mathf.Sqrt((vector.x * vector.x) + (vector.y * vector.y));
if (num >= epsilon)
{
float num2 = 1f / num;
vector.x *= num2;
vector.y *= num2;
return num;
}
vector.x = 0f;
vector.y = 0f;
return 0f;
}
public static Vector2 Perp(this Vector2 vector)
{
return new Vector2(vector.y, -vector.x);
}
}

q414620221

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C# 计算游戏技能攻击区域

尊重原著成果： http://blog.csdn.net/u010019717/article/details/783133921、判断一个点是否在与坐标平行的矩形内public struct AAB2 { public Vector2 Min; public Vector2 Max;
复制链接

扫一扫