public override void AI()
{
dims.Y = 0;
for (int k = 0; 1 == 1; k++)
{
dims.Y++;
if (Main.tileSolid[Main.tile[((int)projectile.position.X + 4) / 16, (int)(projectile.position.Y + k) / 16].type] && Main.tile[(int)projectile.position.X / 16, (int)(projectile.position.Y + k) / 16].active())
{
break;
}
}
foreach (Player player in Main.player.Where(player => player.active))
{
if (Collision.CheckAABBvAABBCollision(projectile.position, dims, player.position, player.Hitbox.Size()) && !player.GetModPlayer <AbilityHandler>().wisp.Active)
{
player.Hurt(PlayerDeathReason.ByCustomReason(player.name + " was zapped to death."), 50, 0);
player.velocity.X = (player.velocity.Length() <= 8) ? (-Vector2.Normalize(player.velocity) * 8).X : player.velocity.X * -1;
player.velocity.Y = 0.1f;
Projectile proj = Main.projectile.FirstOrDefault(p => p.owner == player.whoAmI && Main.projHook[p.type]);
if (proj != null)
{
proj.timeLeft = 0;
}
player.GetModPlayer <AbilityHandler>().dash.Active = false;
}
}
projectile.timeLeft = 2;
if (!parent.active())
{
projectile.timeLeft = 0;
}
//Dust
if (Main.time % 15 == 0)
{
Vector2 startpos = projectile.Center + new Vector2(8, -8);
Vector2[] joints = new Vector2[(int)dims.Y / 20 + 1];
joints[0] = startpos;
joints[(int)dims.Y / 20] = startpos + new Vector2(0, dims.Y);
for (int k = 1; k < joints.Count(); k++)
{
if (k < joints.Count() - 1)
{
joints[k].X = startpos.X + Main.rand.NextFloat(-16, 16);
joints[k].Y = startpos.Y + k * 20 + Main.rand.NextFloat(-5, 5);
}
for (float k2 = 0; k2 <= 1; k2 += 0.1f)
{
Dust.NewDustPerfect(Vector2.Lerp(joints[k], joints[k - 1], k2), DustType <Dusts.Gold>(), null, 0, default, 0.5f);
private static void Merge(Vector2[] UnsortedArray, int left, int mid, int right, Vector2 house)
{
Vector2[] tempArray = new Vector2[right - left + 1];
int tempPosition = 0;
int startOfRightSide = mid + 1;
int initialLeft = left;
while (tempPosition < tempArray.Count())
{
if (DistanceBetween(house, UnsortedArray[left]) < DistanceBetween(house, UnsortedArray[startOfRightSide]))
{
tempArray[tempPosition] = UnsortedArray[left];
tempPosition++;
if (left < mid)
{
left++;
}
else
{
for (int s = startOfRightSide; s <= right; s++)
{
tempArray[tempPosition] = UnsortedArray[s];
tempPosition++;
}
}
}
else
{
tempArray[tempPosition] = UnsortedArray[startOfRightSide];
tempPosition++;
if (startOfRightSide < right)
{
startOfRightSide++;
}
else
{
for (int l = left; l <= mid; l++)
{
tempArray[tempPosition] = UnsortedArray[l];
tempPosition++;
}
}
}
}
for (int i = 0; i < tempArray.Count(); i++)
{
UnsortedArray[initialLeft] = tempArray[i];
initialLeft++;
}
}
static void OpenSurrounding(Tile t, int parent, Vector2 e)
{
Vector2[] Dir = new Vector2[] { new Vector2(0, 1), new Vector2(0, -1), new Vector2(1, 0), new Vector2(-1, 0) };
for (int i = 0; i < Dir.Count(); i++)
{
double ia = t.Position.X + Dir[i].X + (t.Position.Y + Dir[i].Y) * w.MapSize.X;
if (Open.Exists(x => x.Position.X == t.Position.X + Dir[i].X && x.Position.Y == t.Position.Y + Dir[i].Y))
{
Tile nt = Open.Find(x => x.ID == ia);
Open.Remove(nt);
int newg = t.G + 1;
if (newg < nt.G)
{
nt.G = newg;
nt.F = nt.G + nt.H;
nt.ParentID = parent;
}
Open.Add(nt);
continue;
}
if (Null.Exists(x => x.Position.X == t.Position.X + Dir[i].X && x.Position.Y == t.Position.Y + Dir[i].Y))
{
Tile nt = Null.Find(x => x.ID == ia);
Null.Remove(nt);
nt.H = (int)Math.Abs(e.X + e.Y - nt.Position.X - nt.Position.Y);
nt.G = t.G + 1;
nt.F = nt.H + nt.G;
nt.ParentID = parent;
Open.Add(nt);
}
}
}
public Vector2[] GetVertices()
{
Vector2[] ToReturn = new Vector2[vertices.Count];
for (int i = 0; i < ToReturn.Count <Vector2>(); i++)
{
ToReturn[i] = new Vector2(vertices[i].Position.X, vertices[i].Position.Y);
}
return(ToReturn);
}
public static void DrawElectricity(Vector2 point1, Vector2 point2, int dusttype, float scale = 1, int armLength = 30, Color color = default)
{
int nodeCount = (int)Vector2.Distance(point1, point2) / armLength;
Vector2[] nodes = new Vector2[nodeCount + 1];
nodes[nodeCount] = point2; //adds the end as the last point
for (int k = 1; k < nodes.Count(); k++)
{
//Sets all intermediate nodes to their appropriate randomized dot product positions
nodes[k] = Vector2.Lerp(point1, point2, k / (float)nodeCount) +
(k == nodes.Count() - 1 ? Vector2.Zero : Vector2.Normalize(point1 - point2).RotatedBy(1.58f) * Main.rand.NextFloat(-armLength / 2, armLength / 2));
//Spawns the dust between each node
Vector2 prevPos = k == 1 ? point1 : nodes[k - 1];
for (float i = 0; i < 1; i += 0.05f)
{
Dust.NewDustPerfect(Vector2.Lerp(prevPos, nodes[k], i), dusttype, Vector2.Zero, 0, color, scale);
}
}
}
private WallIndexMap CreateMap(params float[] coords)
{
var vertices = new Vector2[coords.Length / 2];
for (int i = 0; i < coords.Length / 2; i++) vertices[i] = new Vector2(coords[i * 2], coords[i * 2 + 1]);
var bounds = Rectangle.FromVector2(vertices);
var indices = Enumerable.Range(0, vertices.Count()).Select(i => (short)i).ToArray();
return new WallIndexMap(_removedTriangles.Add, bounds, vertices, indices);
}
public static void FillPolygon(this Texture2D texture, Vector2[] points, Color color)
{
// http://alienryderflex.com/polygon_fill/
var IMAGE_BOT = (int)points.Max(p => p.y);
var IMAGE_TOP = (int)points.Min(p => p.y);
var IMAGE_LEFT = (int)points.Min(p => p.x);
var IMAGE_RIGHT = (int)points.Max(p => p.x);
var MAX_POLY_CORNERS = points.Count();
var polyCorners = MAX_POLY_CORNERS;
var polyY = points.Select(p => p.y).ToArray();
var polyX = points.Select(p => p.x).ToArray();
int[] nodeX = new int[MAX_POLY_CORNERS];
int nodes, pixelX, i, j, swap;
// Loop through the rows of the image.
for (int pixelY = IMAGE_TOP; pixelY <= IMAGE_BOT; pixelY++)
{
// Build a list of nodes.
nodes = 0;
j = polyCorners - 1;
for (i = 0; i < polyCorners; i++)
{
if (polyY[i] < (float)pixelY && polyY[j] >= (float)pixelY || polyY[j] < (float)pixelY && polyY[i] >= (float)pixelY)
{
nodeX[nodes++] = (int)(polyX[i] + (pixelY - polyY[i]) / (polyY[j] - polyY[i]) * (polyX[j] - polyX[i]));
}
j = i;
}
// Sort the nodes, via a simple “Bubble” sort.
i = 0;
while (i < nodes - 1)
{
if (nodeX[i] > nodeX[i + 1])
{
swap = nodeX[i]; nodeX[i] = nodeX[i + 1]; nodeX[i + 1] = swap; if (i != 0) i--;
}
else
{
i++;
}
}
// Fill the pixels between node pairs.
for (i = 0; i < nodes; i += 2)
{
if (nodeX[i] >= IMAGE_RIGHT)
break;
if (nodeX[i + 1] > IMAGE_LEFT)
{
if (nodeX[i] < IMAGE_LEFT)
nodeX[i] = IMAGE_LEFT;
if (nodeX[i + 1] > IMAGE_RIGHT)
nodeX[i + 1] = IMAGE_RIGHT;
for (j = nodeX[i]; j < nodeX[i + 1]; j++)
texture.SetPixel(j, pixelY, color);
}
}
}
}
public Vector2[] GetVertices()
{
Vector2[] ToReturn = new Vector2[vertices.Count];
for (int i = 0; i < ToReturn.Count<Vector2>(); i++)
{
ToReturn[i] = new Vector2(vertices[i].Position.X, vertices[i].Position.Y);
}
return ToReturn;
}
public void CreateMesh(Vector2[] vertsToCopy, Transform transform,int triangleIndex)
{
List<Vector3> resultsLocal = new List<Vector3>();
List<int> resultsTriIndexesLocal = new List<int>();
List<int> resultsTriIndexesReversedLocal = new List<int>();
List<Vector2> uvsLocal = new List<Vector2>();
List<Vector3> normalsLocal = new List<Vector3>();
Sprite spr = transform.GetComponent<SpriteRenderer>().sprite;
Rect rec = spr.rect;
Vector3 bound = transform.GetComponent<Renderer>().bounds.max- transform.GetComponent<Renderer>().bounds.min ;
TextureImporter textureImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(spr)) as TextureImporter;
List<PolygonPoint> p2 = new List<PolygonPoint>();
if (triangleIndex > 0)
{
vertsToCopy = CreateSubVertPoints (spr.bounds,vertsToCopy.ToList(), triangleIndex).ToArray();
}
int i = 0;
for (i = 0; i < vertsToCopy.Count(); i ++)
{
p2.Add(new PolygonPoint(vertsToCopy [i].x, vertsToCopy [i].y));
}
Polygon _polygon = new Polygon(p2);
if (triangleIndex > 0)
{
List<TriangulationPoint> triPoints = GenerateGridPoints (spr.bounds, triangleIndex, _polygon);
_polygon.AddSteinerPoints (triPoints);
}
P2T.Triangulate(_polygon);
int idx = 0;
foreach (DelaunayTriangle triangle in _polygon.Triangles)
{
Vector3 v = new Vector3();
foreach (TriangulationPoint p in triangle.Points)
{
v = new Vector3((float)p.X, (float)p.Y,0);
if(!resultsLocal.Contains(v))
{
resultsLocal.Add(v);
resultsTriIndexesLocal.Add(idx);
Vector2 newUv = new Vector2((v.x/bound.x) + 0.5f, (v.y /bound.y) + 0.5f);
newUv.x *= rec.width/ spr.texture.width;
newUv.y *= rec.height/ spr.texture.height;
newUv.x += (rec.x)/ spr.texture.width;
newUv.y += (rec.y) / spr.texture.height;
SpriteMetaData[] smdArray = textureImporter.spritesheet;
Vector2 pivot = new Vector2(.0f,.0f);;
for (int k = 0; k < smdArray.Length; k++)
{
if (smdArray[k].name == spr.name)
{
switch(smdArray[k].alignment)
{
case(0):
smdArray[k].pivot = Vector2.zero;
break;
case(1):
smdArray[k].pivot = new Vector2(0f,1f) -new Vector2(.5f,.5f);
break;
case(2):
smdArray[k].pivot = new Vector2(0.5f,1f) -new Vector2(.5f,.5f);
break;
case(3):
smdArray[k].pivot = new Vector2(1f,1f) -new Vector2(.5f,.5f);
break;
case(4):
smdArray[k].pivot = new Vector2(0f,.5f) -new Vector2(.5f,.5f);
break;
case(5):
smdArray[k].pivot = new Vector2(1f,.5f) -new Vector2(.5f,.5f);
break;
case(6):
smdArray[k].pivot = new Vector2(0f,0f) -new Vector2(.5f,.5f);
break;
case(7):
smdArray[k].pivot = new Vector2(0.5f,0f) -new Vector2(.5f,.5f);
break;
case(8):
smdArray[k].pivot = new Vector2(1f,0f) -new Vector2(.5f,.5f);
break;
case(9):
smdArray[k].pivot -= new Vector2(.5f,.5f);
break;
}
pivot = smdArray[k].pivot ;
}
}
if(textureImporter.spriteImportMode == SpriteImportMode.Single)
pivot = textureImporter.spritePivot-new Vector2(.5f,.5f);
newUv.x += ((pivot.x)*rec.width)/ spr.texture.width;
newUv.y += ((pivot.y)*rec.height)/ spr.texture.height;
uvsLocal.Add(newUv);
normalsLocal.Add(new Vector3(0,0,-1));
idx++;
}
else
{
resultsTriIndexesLocal.Add(resultsLocal.LastIndexOf(v));
}
}
}
for (int j = resultsTriIndexesLocal.Count-1; j >=0; j--)
{
resultsTriIndexesReversedLocal.Add(resultsTriIndexesLocal[j]);
}
results.AddRange(resultsLocal);
resultsTriIndexes.AddRange(resultsTriIndexesLocal);
resultsTriIndexesReversed.AddRange(resultsTriIndexesReversedLocal);
uvs.AddRange(uvsLocal);
normals.AddRange(normalsLocal);
resultsLocal.Clear();
resultsTriIndexesLocal.Clear();
resultsTriIndexesReversedLocal.Clear();
uvsLocal.Clear();
normalsLocal.Clear();
finalVertices = results.ToArray();
finalNormals = normals.ToArray();
finalUvs= uvs.ToArray();
finalTriangles = resultsTriIndexesReversed.ToArray();
}
UIImage DrawShape(ShapeType shapeType, CGSize size, UIColor strokeColor, UIColor fillColor)
{
float width = (float)size.Width;
float height = (float)size.Height;
var stroke = 1;
var scale = (width / 2) - (stroke * 2);
var center = new Vector2(width / 2, height / 2);
UIImage starImage;
UIGraphics.BeginImageContext(new CGSize(width, height));
using (CGContext g = UIGraphics.GetCurrentContext())
{
g.SetLineWidth(stroke);
FillColor.ToUIColor().SetFill();
StrokeColor.ToUIColor().SetStroke();
var shapePoints = new Vector2[0];
switch (shapeType)
{
case ShapeType.Oval:
var radiusX = (width / 3) - stroke;
var radiusY = (height / 2) - stroke;
g.AddEllipseInRect(new CGRect(0, 0, radiusX * 2, radiusY * 2));
break;
case ShapeType.Circle:
var radius = Math.Min(width, height) / 2 - stroke;
g.AddEllipseInRect(new CGRect(0, 0, radius * 2, radius * 2));
break;
case ShapeType.Line:
shapePoints = CreateLineGeometry(scale, center);
break;
case ShapeType.Hexagon:
shapePoints = CreateHexagonGeometry(scale, center);
break;
case ShapeType.Rectangle:
shapePoints = CreateRectangleGeometry(scale, center);
break;
case ShapeType.Square:
shapePoints = CreateSquareGeometry(scale, center);
break;
case ShapeType.Trapezoid:
shapePoints = CreateTrapezoidGeometry(scale, center);
break;
case ShapeType.Triangle:
shapePoints = CreateTriangleGeometry(scale, center);
break;
case ShapeType.Star:
shapePoints = CreateStarGeometry(scale, center);
break;
default:
break;
}
if (shapePoints.Count() > 0)
{
var points = new List <CGPoint>();
foreach (var item in shapePoints)
{
points.Add(new CGPoint(item.X, item.Y));
}
var path = new CGPath();
path.AddLines(points.ToArray());
path.CloseSubpath();
g.AddPath(path);
}
g.DrawPath(CGPathDrawingMode.FillStroke);
starImage = UIGraphics.GetImageFromCurrentImageContext();
}
return(starImage);
}
public HitboxPolygon(Vector2[] arg_corners)
{
corners = arg_corners;
count = arg_corners.Count();
segment_normals = new float[count];
corner_normals = new float[count];
Vector2 lower = Vector2.Zero;
Vector2 upper = Vector2.Zero;
for (int i = 0; i < count; i++)
{
Vector2 segment_p1 = corners[i];
Vector2 segment_p2 = (i == count - 1) ? corners[0] : corners[i + 1];
float segment_angle = Utility.Angle(segment_p2 - segment_p1);
segment_normals[i] = Utility.WrapAngle(segment_angle - MathHelper.PiOver2);
float dist_sq = corners[i].LengthSquared();
if (dist_sq > radius_sq)
{
radius_sq = dist_sq;
}
if (segment_p1.X < lower.X) { lower.X = segment_p1.X; }
if (segment_p1.Y < lower.Y) { lower.Y = segment_p1.Y; }
if (segment_p1.X > upper.X) { upper.X = segment_p1.X; }
if (segment_p1.Y > upper.Y) { upper.Y = segment_p1.Y; }
}
radius = Utility.Sqrt(radius_sq);
size = upper - lower;
// this must be after the previous loop, as the first corner needs the last segment normal
for (int i = 0; i < count; i++)
{
float prev_segment = (i == 0) ? segment_normals[count - 1] : segment_normals[i - 1];
float c_normal = ((segment_normals[i] - prev_segment) / 2.0f) + prev_segment;
corner_normals[i] = Utility.WrapAngle(c_normal);
}
}
