public static TOutput[] ConvertAll <TInput, TOutput>(this TInput[] a, System.Converter <TInput, TOutput> c)
{
if (a.IsNull())
{
throw new System.NullReferenceException();
}
return((a.Length > 0) ? System.Array.ConvertAll(a, c) : new TOutput[0]);
}
/// <summary>
/// Convert an array of elements
/// </summary>
/// <typeparam name="TInput">The input array type</typeparam>
/// <typeparam name="TOutput">The output array type</typeparam>
/// <param name="array">The array to be converted</param>
/// <param name="converter">The converter</param>
/// <returns>The converted array</returns>
public static TOutput[] ConvertAll <TInput, TOutput>(TInput[] array, System.Converter <TInput, TOutput> converter)
{
TOutput[] result = new TOutput[array.Length];
for (int i = 0; i < result.Length; i++)
{
result[i] = converter(array[i]);
}
return(result);
}
public static List <TOutput> ConvertIListItems <TInput, TOutput>(IList list, System.Converter <TInput, TOutput> function)
{
var outputList = new List <TOutput>();
foreach (var input in list)
{
outputList.Add(function((TInput)input));
}
return(outputList);
}
/** Update and return old, new and side result
* NO GUARANTEE THAT update_meth IS ONLY CALLED ONCE!!!!
* update_meth should return a pair that has the new state, and a side
* result
* the returned value gives the old state, new state and that side value
*/
public Triple <T, T, R> Update <R>(System.Converter <T, Pair <T, R> > update_meth)
{
T old_state = _state;
T state;
Pair <T, R> res;
do
{
state = old_state;
res = update_meth(state);
old_state = Interlocked.CompareExchange(ref _state, res.First, state);
} while(old_state != state);
return(new Triple <T, T, R>(state, res.First, res.Second));
}
/** Update and return old and new state
* NO GUARANTEE THAT update_meth IS ONLY CALLED ONCE!!!!
* update_meth should return a new state based on the old state
*/
public Pair <T, T> Update(System.Converter <T, T> update_meth)
{
T old_state = _state;
T state;
T new_state;
do
{
state = old_state;
new_state = update_meth(state);
old_state = Interlocked.CompareExchange <T>(ref _state, new_state, state);
} while(old_state != state);
return(new Pair <T, T>(state, new_state));
}
// -----------------------------------------------------------------------------------
public void RedrawPath(int x, int y)
{
Clear();
PathBuilder pb = new PathBuilder();
List <List <Point> > segments = pb.GetSegments(playArea.mask, x, y, pathValue);
// add play area edges, if needed
if (type == Type.Safe)
{
AddPlayAreaEdges(segments);
}
System.Converter <Point, Vector3> Point2Vec3 = (Point pt) => { return((Vector2)pt); };
System.Converter <Point, Vector2> Point2Vec2 = (Point pt) => { return(pt); };
foreach (List <Point> segment in segments)
{
// create a new line renderer for the segment
LineRenderer newLine = CreateLineRenderer();
lineRenderers.Add(newLine);
newLine.positionCount = segment.Count;
newLine.SetPositions(segment.ConvertAll(Point2Vec3).ToArray());
// check if the segment is looping (first and last position are 1 px apart)
if (Vector2.Distance(segment[0], segment[segment.Count - 1]) == 1)
{
newLine.loop = true;
}
// add a collider for the segment
if (segment.Count >= 2)
{
EdgeCollider2D col = gameObject.AddComponent <EdgeCollider2D>();
col.edgeRadius = 1;
col.points = segment.ConvertAll(Point2Vec2).ToArray();
col.isTrigger = type == Type.Cut && !isShielded;
colliders.Add(col);
}
}
}
private void FunctionToPoints(System.Drawing.PointF[] points, System.Converter <double, double> func)
{
for (int x = 0; x < points.Length; x++)
{
double y = this.originY - this.scaleX * func((x - this.originX) / this.scaleY);
if (y < 0)
{
y = -1;
}
else if (double.IsNaN(y))
{
y = 0;
}
else if (y > this.Height)
{
y = this.Height + 1;
}
points[x] = new System.Drawing.PointF(x, (float)y);
}
}
// -----------------------------------------------------------------------------------
/// <summary>
/// Find the difference between the safe path before and after cutting,
/// then returning the center of that difference plus the difference path
/// </summary>
static public bool FindDifference(Vector3 [] pointsBefore, Vector3 [] pointsAfter, out Vector3 [] result, out Vector3 centroid)
{
result = null;
centroid = Vector3.zero;
System.Converter <Vector3, IntPoint> converter = (pt) => { return(new IntPoint(pt.x, pt.y)); };
List <IntPoint> before = new List <IntPoint>(System.Array.ConvertAll(pointsBefore, converter));
List <IntPoint> after = new List <IntPoint>(System.Array.ConvertAll(pointsAfter, converter));
List <List <IntPoint> > solution = new List <List <IntPoint> >();
Clipper clipper = new Clipper();
clipper.AddPath(before, PolyType.ptClip, true);
clipper.AddPath(after, PolyType.ptSubject, true);
if (!clipper.Execute(ClipType.ctDifference, solution))
{
return(false);
}
result = System.Array.ConvertAll(solution[0].ToArray(), (pt) => { return(new Vector3(pt.X, pt.Y, 0)); });
centroid = FindCentroid(result);
return(true);
}
public static void DrawSelector <T>(string title, Color elementColor, T[] variants, System.Converter <T, string> converter, System.Action <T> selectionCallback, params GUILayoutOption[] options)
{
var values = new[] { title }.Concat(variants.ConvertAll(converter));
var color = GUI.backgroundColor;
GUI.backgroundColor = elementColor;
var newIndex = EditorGUILayout.Popup(0, values, options);
if (newIndex > 0)
{
selectionCallback.SafeInvoke(variants[newIndex - 1]);
}
GUI.backgroundColor = color;
}
public static TOutput[] FindAndConvert <TInput, TOutput>(this System.Collections.Generic.IEnumerable <TInput> e, System.Predicate <TInput> m, System.Converter <TInput, TOutput> c)
{
if (e.IsNull())
{
throw new System.NullReferenceException();
}
if (m.IsNull())
{
throw new System.NullReferenceException();
}
var list = new System.Collections.Generic.List <TInput>(e);
var finded = list.FindAll(m);
var converted = finded.ConvertAll(c);
var result = converted.ToArray();
list.Clear();
finded.Clear();
converted.Clear();
return(result);
}
public WrappedArray <U> ConvertAll <U>(System.Converter <T, U> converter)
{
return(new WrappedArray <U>((array.Length > 0) ? System.Array.ConvertAll(array, converter) : new U[0]));
}
static List <tOutput> ConvertToList <t, tOutput>(this IEnumerable <t> thisEnumerable, System.Converter <t, tOutput> converter)
{
Throw <System.ArgumentNullException> .If(thisEnumerable == null, "IndexOfLast cannot be executed against a null enumerable list.");
Throw <System.ArgumentNullException> .If(converter == null, "IndexOfLast cannot be executed with a null converter.");
List <tOutput> returnList = new List <tOutput>();
foreach (t item in thisEnumerable)
{
returnList.Add(converter(item));
}
return(returnList);
}
public bool tryFetch <T>(int pos, System.Converter <JSONNode, T> converter, out T resp)
{
resp = converter(this[pos]);
return(resp != null);
}
public CommandSet(string suite, System.IO.TextWriter output, System.IO.TextWriter error, System.Converter <string, string> localizer = null)
{
}
public CommandSet(string suite, System.Converter <string, string> localizer = null)
{
}
public OptionSet(System.Converter <string, string> localizer)
{
}
public OptionSet(System.Converter <string, string> localizer, System.StringComparer comparer)
{
}
public T[] ConvertAll <T>(System.Converter <ValueStream, T> converter)
{
return(System.Array.ConvertAll(_items, converter));
}
public Function(System.Converter <double, double> func, System.Drawing.Pen pen)
{
this.Calculate = func;
this.pen = pen;
}
public void AddFunction(System.Converter <double, double> func, System.Drawing.Pen pen)
{
this.funcs.Add(new Function(func, pen));
}
