protected override bool Process(IInteraction parameters)
{
var dataSink = Closest <IOutgoingBodiedInteraction> .From(parameters);
FileInfo file = GetFileInfo(parameters);
if (!file.FullName.StartsWith(this.ValidRootPath))
{
return(FailForException(parameters, new Exception("File not in root path")));
}
IInteraction fileParameters = new SimpleInteraction(
parameters, "contentlength", file.Length);
if (!this.Header.TryProcess(fileParameters))
{
return(FailForException(fileParameters, new Exception("Header failed")));
}
try {
using (FileStream fileStream = file.OpenRead()) {
Task copyTask = fileStream.CopyToAsync(dataSink.OutgoingBody);
Meanwhile.TryProcess(fileParameters);
copyTask.Wait();
}
return((Successful == null) || Successful.TryProcess(fileParameters));
} catch (Exception ex) {
return(FailForException(fileParameters, ex));
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
if (script.movement != null)
{
GUI.enabled = false;
EditorGUILayout.FloatField("movement.moveSpeed", script.movement.moveSpeed);
string points = "";
script.points.ForEach(p => {
points += p.name + (p == script.point ? " (current)" : "") + "\n";
});
if (points.Length == 0)
{
points = "(none)";
}
EditorGUILayout.LabelField("points", points);
// Find the closest one
Closest <PushingPoint> closest = PushingPoint.GetClosest(script.points, script.controller.characterCenter, script.interaction.ignoreYAxis);
if (closest.valid)
{
EditorGUILayout.LabelField("closest", closest.obj.name);
}
GUI.enabled = true;
}
}
protected override bool Process(IInteraction parameters)
{
var dataSource = Closest <IIncomingBodiedInteraction> .From(parameters);
FileInfo file = GetFileInfo(parameters);
if (!file.FullName.StartsWith(this.ValidRootPath))
{
return(FailForException(parameters, new Exception("File not in root path")));
}
if (file.Exists && !MayOverwrite)
{
return(FailForException(parameters, new Exception("File already exists")));
}
try {
using (FileStream fileStream = file.OpenWrite()) {
Task copyTask = dataSource.IncomingBody.CopyToAsync(fileStream);
this.Meanwhile.TryProcess(parameters);
copyTask.Wait();
}
return((Successful == null) || Successful.TryProcess(parameters));
} catch (Exception ex) {
return(FailForException(parameters, ex));
}
}
protected override bool Process(IInteraction parameters)
{
IHttpInteraction httpInteraction = Closest <IHttpInteraction> .From(parameters);
string contentType;
if (this.ContentType.Length > 0)
{
contentType = this.ContentType;
}
else
{
contentType = Fallback <string> .From(parameters, "contenttype");
};
httpInteraction.SetContentType(contentType);
if (this.SendLength)
{
long length = Fallback <long> .From(parameters, "contentlength");
httpInteraction.SetContentLength(length);
}
httpInteraction.PurgeBuffer();
return(WithBranch.TryProcess(parameters));
}
private void AreEqual_ClosestPoint(Segment2 segment, Vector2 point, Vector2 expected)
{
string message = string.Format(format, segment, point.ToString("F8"));
AreEqual(Closest.PointSegment(point, segment.a, segment.b), expected, message);
AreEqual(Closest.PointSegment(point, segment.b, segment.a), expected, message);
}
private void AreEqual_ClosestPoints(Ray2D ray, Circle2 circle, Vector2 expectedRay, Vector2 expectedCircle)
{
string message = string.Format(format, ray, circle);
Closest.RayCircle(ray.origin, ray.direction, circle.center, circle.radius, out Vector2 rayPoint, out Vector2 centerPoint);
AreEqual(rayPoint, expectedRay, message);
AreEqual(centerPoint, expectedCircle, message);
}
private void AreEqual_ClosestPoints(Line2 line, Circle2 circle, Vector2 expectedLine, Vector2 expectedCircle)
{
string message = string.Format(format, line, circle);
Closest.LineCircle(line.origin, line.direction, circle.center, circle.radius, out Vector2 linePoint, out Vector2 centerPoint);
AreEqual(linePoint, expectedLine, message);
AreEqual(centerPoint, expectedCircle, message);
}
private void AreEqual_ClosestPoints(Line2 line, Ray2D ray, Vector2 lineExpected, Vector2 rayExpected)
{
string message = string.Format(format, line, ray.ToString("F8"));
Closest.LineRay(line, ray, out Vector2 linePoint, out Vector2 rayPoint);
AreEqual(linePoint, lineExpected, message);
AreEqual(rayPoint, rayExpected, message);
}
public static Closest getInstance()
{
if (instance == null)
{
instance = new Closest();
}
return(instance);
}
private void AreEqual_ClosestPoints(Line2 lineA, Line2 lineB, Vector2 expectedA, Vector2 expectedB)
{
string message = string.Format(linesFormat, lineA, lineB);
Closest.LineLine(lineA, lineB, out Vector2 pointA, out Vector2 pointB);
AreEqual(pointA, expectedA, message);
AreEqual(pointB, expectedB, message);
}
private void AreEqual_ClosestPoints(Line3 line, Sphere sphere, Vector3 expectedLine, Vector3 expectedSphere)
{
Vector3 linePoint;
Vector3 centerPoint;
Closest.LineSphere(line.origin, line.direction, sphere.center, sphere.radius, out linePoint, out centerPoint);
AreEqual(linePoint, expectedLine);
AreEqual(centerPoint, expectedSphere);
}
private void AreEqual_ClosestPoints(Circle2 circleA, Circle2 circleB, Vector2 expectedA, Vector2 expectedB)
{
Closest.CircleCircle(circleA, circleB, out Vector2 pointA, out Vector2 pointB);
AreEqual(pointA, expectedA);
AreEqual(pointB, expectedB);
Closest.CircleCircle(circleB, circleA, out pointA, out pointB);
AreEqual(pointA, expectedB);
AreEqual(pointB, expectedA);
}
private void AreEqual_ClosestPoints(Ray ray, Sphere sphere, Vector3 expectedRay, Vector3 expectedSphere)
{
Vector3 rayPoint;
Vector3 centerPoint;
Closest.RaySphere(ray.origin, ray.direction, sphere.center, sphere.radius, out rayPoint, out centerPoint);
AreEqual(rayPoint, expectedRay);
AreEqual(centerPoint, expectedSphere);
}
private void AreEqual_ClosestPoints(Sphere sphereA, Sphere sphereB, Vector3 expectedA, Vector3 expectedB)
{
Closest.SphereSphere(sphereA, sphereB, out Vector3 pointA, out Vector3 pointB);
AreEqual(pointA, expectedA);
AreEqual(pointB, expectedB);
Closest.SphereSphere(sphereB, sphereA, out pointA, out pointB);
AreEqual(pointA, expectedB);
AreEqual(pointB, expectedA);
}
private void AreEqual_ClosestPoints(Segment3 segment, Sphere sphere, Vector3 expectedSegment, Vector3 expectedSphere)
{
Vector3 segmentPoint;
Vector3 centerPoint;
Closest.SegmentSphere(segment.a, segment.b, sphere.center, sphere.radius, out segmentPoint, out centerPoint);
AreEqual(segmentPoint, expectedSegment);
AreEqual(centerPoint, expectedSphere);
}
private static string ParseUrlRaw(Closest closest)
{
var waybackUrl = closest.Url;
var waybackUrlHttps = waybackUrl.StartsWith("http:") ? "https" + waybackUrl.Substring(4) : waybackUrl;
var indexOfUrlModification = waybackUrlHttps.GetNthIndexOfChar(5, '/');
const string urlModification = "if_";
return(waybackUrlHttps.Substring(0, indexOfUrlModification) + urlModification +
waybackUrlHttps.Substring(indexOfUrlModification));
}
private void AreEqual_ClosestPoints(Ray2D ray, Segment2 segment, Vector2 expectedRay, Vector2 expectedSegment)
{
string message = string.Format(format, ray.ToString("F8"), segment);
Closest.RaySegment(ray.origin, ray.direction, segment.a, segment.b, out Vector2 rayPoint, out Vector2 segmentPoint);
AreEqual(rayPoint, expectedRay, message);
AreEqual(segmentPoint, expectedSegment, message);
Closest.RaySegment(ray.origin, ray.direction, segment.b, segment.a, out rayPoint, out segmentPoint);
AreEqual(rayPoint, expectedRay, message);
AreEqual(segmentPoint, expectedSegment, message);
}
private void AreEqual_ClosestPoints(Line2 line, Segment2 segment, Vector2 expectedLine, Vector2 expectedSegment)
{
string message = string.Format(format, line, segment);
Closest.LineSegment(line.origin, line.direction, segment.a, segment.b, out Vector2 linePoint, out Vector2 segmentPoint);
AreEqual(linePoint, expectedLine, message);
AreEqual(segmentPoint, expectedSegment, message);
Closest.LineSegment(line.origin, line.direction, segment.b, segment.a, out linePoint, out segmentPoint);
AreEqual(linePoint, expectedLine, message);
AreEqual(segmentPoint, expectedSegment, message);
}
private void AreEqual_ClosestPoints(Ray2D rayA, Ray2D rayB, Vector2 expectedA1, Vector2 expectedB1, Vector2 expectedA2, Vector2 expectedB2)
{
string message = string.Format(format, rayA.ToString("F8"), rayB.ToString("F8"));
Closest.RayRay(rayA, rayB, out Vector2 pointA, out Vector2 pointB);
AreEqual(pointA, expectedA1, message);
AreEqual(pointB, expectedB1, message);
Closest.RayRay(rayB, rayA, out pointA, out pointB);
AreEqual(pointA, expectedA2, message);
AreEqual(pointB, expectedB2, message);
}
private void AreEqual_ClosestPoints(Segment2 segment, Circle2 circle, Vector2 expectedSegmentA, Vector2 expectedSegmentB,
Vector2 expectedCircleA, Vector2 expectedCircleB)
{
string message = string.Format(format, segment, circle);
Closest.SegmentCircle(segment.a, segment.b, circle.center, circle.radius, out Vector2 segmentPoint, out Vector2 circlePoint);
AreEqual(segmentPoint, expectedSegmentA, message);
AreEqual(circlePoint, expectedCircleA, message);
Closest.SegmentCircle(segment.b, segment.a, circle.center, circle.radius, out segmentPoint, out circlePoint);
AreEqual(segmentPoint, expectedSegmentB, message);
AreEqual(circlePoint, expectedCircleB, message);
}
public Closest(Vector3 inRangeFrom, float radius, Vector3 closestTo, bool ignoreY = false)
{
List <T> list = Searchable._ALL.ConvertAll(delegate(Searchable obj) {
return(obj as T);
});
list.RemoveAll(delegate(T obj) {
return(obj == null || obj.GetDistance(inRangeFrom, ignoreY) > radius);
});
this = new Closest <T>(list, closestTo, ignoreY);
}
public Closest(Vector3 from, bool ignoreY = false)
{
List <T> list = Searchable._ALL.ConvertAll(delegate(Searchable obj) {
return(obj as T);
});
list.RemoveAll(delegate(T obj) {
return(obj == null);
});
this = new Closest <T>(list, from, ignoreY);
}
// Interact with the closest thing at point
public static bool InteractAt(PlayerController source, Vector3 point)
{
var list = GetListenersAt(point);
list.RemoveAll(delegate(_ElectricListener obj) {
return(!obj.acceptInteraction);
});
var closest = new Closest <_ElectricListener>(list, point);
if (closest.valid)
{
closest.obj.Interact(source);
}
return(closest.valid);
}
protected override bool Process(IInteraction parameters)
{
var signal = Closest <ShellSignalInteraction> .From(parameters);
if (signal.IsKill)
{
shellProcess.Dispose();
}
else
{
shellProcess = SystemProcess.Start(signal.ProcessInfo);
shellProcess.BeginOutputReadLine();
shellProcess.OutputDataReceived += ShellProcess_OutputDataReceived;
}
return(true);
}
protected static MeshDraft ConstructGableDraft(List <Vector2> skeletonPolygon2, float roofPitch)
{
Vector2 edgeA2 = skeletonPolygon2[0];
Vector2 edgeB2 = skeletonPolygon2[1];
Vector2 peak2 = skeletonPolygon2[2];
Vector2 edgeDirection2 = (edgeB2 - edgeA2).normalized;
float peakHeight = CalculateVertexHeight(peak2, edgeA2, edgeDirection2, roofPitch);
Vector3 edgeA3 = edgeA2.ToVector3XZ();
Vector3 edgeB3 = edgeB2.ToVector3XZ();
Vector3 peak3 = new Vector3(peak2.x, peakHeight, peak2.y);
Vector2 gableTop2 = Closest.PointSegment(peak2, edgeA2, edgeB2);
Vector3 gableTop3 = new Vector3(gableTop2.x, peakHeight, gableTop2.y);
return(new MeshDraft().AddTriangle(edgeA3, edgeB3, gableTop3, true)
.AddTriangle(edgeA3, gableTop3, peak3, true)
.AddTriangle(edgeB3, peak3, gableTop3, true));
}
private void AreEqual_ClosestPoints(Segment2 segment1, Segment2 segment2, Vector2 expected1A, Vector2 expected2A,
Vector2 expected1B, Vector2 expected2B)
{
string message = string.Format(format, segment1, segment2);
Closest.SegmentSegment(segment1.a, segment1.b, segment2.a, segment2.b, out Vector2 point1, out Vector2 point2);
AreEqual(point1, expected1A, message);
AreEqual(point2, expected2A, message);
Closest.SegmentSegment(segment1.a, segment1.b, segment2.b, segment2.a, out point1, out point2);
AreEqual(point1, expected1A, message);
AreEqual(point2, expected2A, message);
Closest.SegmentSegment(segment2.a, segment2.b, segment1.a, segment1.b, out point1, out point2);
AreEqual(point1, expected1B, message);
AreEqual(point2, expected2B, message);
Closest.SegmentSegment(segment2.a, segment2.b, segment1.b, segment1.a, out point1, out point2);
AreEqual(point1, expected1B, message);
AreEqual(point2, expected2B, message);
}
PushingPoint GetClosestPoint()
{
if (hasPoint)
{
return(null);
}
if (inventory && inventory.equipped)
{
return(null);
}
if (interaction && interaction.hover)
{
return(null);
}
// Remove all invalid points. If for some reason they occur.
points.RemoveAll(p => p == null);
// Find the closest one
Closest <PushingPoint> closest = PushingPoint.GetClosest(points, transform.position, interaction.ignoreYAxis);
return(closest.obj);
}
private static DateTime ParseTimestampUtc(Closest closest) => DateTimeOffset.ParseExact(closest.Timestamp, "yyyyMMddHHmmss", null).UtcDateTime;
private void AreEqual_ClosestPoint(Line3 line, Vector3 point, Vector3 expected)
{
AreEqual(Closest.PointLine(point, line), expected);
}
private void AreEqual_ClosestPoint(Ray ray, Vector3 point, Vector3 expected)
{
AreEqual(Closest.PointRay(point, ray), expected);
}
// Interact with the closest thing at point
public static bool InteractAt(PlayerController source, Vector3 point)
{
var list = GetListenersAt(point);
list.RemoveAll(delegate (_ElectricListener obj) {
return !obj.acceptInteraction;
});
var closest = new Closest<_ElectricListener>(list, point);
if (closest.valid)
closest.obj.Interact(source);
return closest.valid;
}
