public SpaceTrackedPoint(Transform unityPosition, Transform trackerRoot, Transform headPosition)
{
m_unityPointOfView = new SpacePoint();
m_trackerPointOfView = new SpacePoint();
m_headPointOfView = new SpacePoint();
SetPoint(unityPosition, trackerRoot, headPosition);
}
private void DrawLineOf(Vector3[] lines, Color color, SpacePoint point)
{
if (point == null)
{
DrawLineOf(lines, color);
return;
}
Vector3 start;
Vector3 end;
if (lines.Length > 1)
{
for (int i = 1; i < lines.Length; i++)
{
start = SpacePoint.GetRelocatedPosition(lines[i - 1], point);
end = SpacePoint.GetRelocatedPosition(lines[i], point);
Debug.DrawLine(start, end, color, m_drawTime);
}
}
start = SpacePoint.GetRelocatedPosition(lines[lines.Length - 1], point);
end = SpacePoint.GetRelocatedPosition(lines[0], point);
Debug.DrawLine(start, end, color, m_drawTime);
}
public void Launch(GameObject launchSite, int count)
{
// DebugScript = DebugCollider.GetComponent<DebugGameScript>();
// DebugScript.Collider = Collider;
MissileCount++;
missileCommnandScript.MissileLaunched();
TargetPoint = MousePosition.ToWorldSpace().ChangeZ(Z);
MarkTarget(TargetPoint);
var shape2d = gameObject.GetComponent <Shapes2D.Shape>();
//shape2d.enabled = false;
var spriteRenderer = gameObject.GetComponent <SpriteRenderer>();
spriteRenderer.enabled = false;
Vector3[] poses1 = new Vector3[2];
lineRenderer.GetPositions(poses1);
var pos = launchSite.transform.position;
pos.z = Z;
LaunchPoint = new SpacePoint(Graphics.Space.World, pos);
poses1[0] = poses1[1] = LaunchPoint.Position;
lineRenderer.SetPositions(poses1);
Delta = Delta(LaunchPoint, TargetPoint);
lineRenderer.enabled = true;
tweener = Tweener2d.LinearTweener(LaunchPoint.Position, TargetPoint.Position, Velocity).GetEnumerator();
State = PlayerMissileState.Traveling;
}
private void MarkTarget(SpacePoint targetPoint)
{
var worldPostion = targetPoint.Position;
worldPostion.z = 0;
TargetCross1 = Instantiate(TargetCross1, worldPostion, TargetCross1.transform.rotation);
TargetCross2 = Instantiate(TargetCross2, worldPostion, TargetCross1.transform.rotation);
var lr1 = TargetCross1.GetComponent <LineRenderer>();
var lr2 = TargetCross2.GetComponent <LineRenderer>();
Vector3[] poses1 = new Vector3[2];
var pos = lr1.GetPositions(poses1);
poses1[0] += worldPostion;
poses1[1] += worldPostion;
lr1.SetPositions(poses1);
lr1.enabled = true;
Vector3[] poses2 = new Vector3[2];
pos = lr2.GetPositions(poses2);
poses2[0] += worldPostion;
poses2[1] += worldPostion;
lr2.SetPositions(poses2);
lr2.enabled = true;
}
private void AppendNewHead <T>(Dimension <T> dimension, SpacePoint <T> sp, float position)
{
var newHead = new DimensionPoint <T>(dimension)
{
Position = position
};
newHead.AddPoint(sp);
newHead.HeadLink = new DimensionLink <T>(0, newHead);
var oldHead = dimension.HeadDimPoint;
dimension.HeadDimPoint = newHead;
newHead.HeadLink.AssignNext(oldHead.HeadLink);
var upper = oldHead.HeadLink.Upper;
newHead.HeadLink.AssignUpper(upper);
oldHead.HeadLink.Upper = null;
newHead.TailLink = oldHead.TailLink.Level == 0 ? newHead.HeadLink : oldHead.TailLink;
oldHead.TailLink = oldHead.HeadLink;
_spaceManager.TryAddLevel(dimension);
var toExtendUp = dimension.HeadDimPoint.HeadLink.NextUntil((n, i) => i == 1);
while (_spaceManager.TryExtendUp(toExtendUp, out toExtendUp))
{
_spaceManager.TryAddLevel(dimension);
}
}
public SpacePoint GetPoint(string query)
{
using (SQLiteConnection connection = new SQLiteConnection($"Data Source={App.DatabasePath}"))
{
SpacePoint point = null;
try
{
connection.Open();
SQLiteCommand command = new SQLiteCommand(query, connection);
SQLiteDataReader reader = command.ExecuteReader();
while (reader.Read())
{
double ra = (double)reader["ra"];
double dec = (double)reader["dec"];
point = new SpacePoint(ra, dec);
}
connection.Close();
} catch (SQLiteException exception)
{
string ErrorMessage = $"Error Connecting to Database. Error: {exception.Message}";
Messenger.Default.Send(ErrorMessage, "DatabaseError");
}
return(point);
}
}
public void SetWith(Vector3 position, Quaternion rotation, Vector3 pointOfViewPosition, Quaternion pointOfViewRotation)
{
SpacePoint pointOfView = new SpacePoint(pointOfViewPosition, pointOfViewRotation);
m_position = GetRelocatedPosition(position, pointOfView);
m_rotation = GetRelocatedRotation(rotation, pointOfView);
}
private static bool RemovePointFromDimensions <T>(SpacePoint <T> sp, int index)
{
var isRemoved = false;
var dPoint = sp.Dimensions[index];
if (dPoint == null)
{
return(false);
}
if (dPoint.NumberPoints > 1)
{
if (dPoint.RemovePoint(sp))
{
isRemoved = true;
}
}
else
{
if (dPoint.RemovePoint(sp))
{
if (RemoveDimensionPoint(dPoint))
{
isRemoved = true;
}
}
}
sp.Dimensions[index] = null;
return(isRemoved);
}
public static SpacePoint GetRelocatedPoint(SpacePoint point, SpacePoint pointOfView)
{
SpacePoint result = new SpacePoint();
result.m_position = GetRelocatedPosition(point.m_position, pointOfView);
result.m_rotation = GetRelocatedRotation(point.m_rotation, pointOfView);
return(result);
}
bool ISpaceManager.TryFindFirstSpacePoint <T>(Space <T> space, out SpacePoint <T> point, params float[] dimensionPositions)
{
HashSet <SpacePoint <T> > set;
_spaceManager.TryFindSpacePoints(space, out set, dimensionPositions);
point = set.FirstOrDefault();
return(point != null);
}
public void SetPoint(Transform unityPosition, Transform trackerRoot, Transform headPosition)
{
m_unityPointOfView = new SpacePoint();
m_trackerPointOfView = new SpacePoint();
m_headPointOfView = new SpacePoint();
m_unityPointOfView.SetWith(unityPosition);
m_trackerPointOfView.SetWith(trackerRoot, trackerRoot);
m_headPointOfView.SetWith(headPosition, headPosition);
}
List <SpacePoint <T> > ISpaceManager.FindAllNearWhere <T>(SpacePoint <T> center, float within, IDimensionSelector dimSelector, Func <SpacePoint <T>, SpacePoint <T>, float, bool> where)
{
if (dimSelector == null)
{
dimSelector = DimensionSelector.Default;
}
var list = new List <SpacePoint <T> >();
var centerDimPoint = center.Dimensions[dimSelector.MainDimensionIndex];
var centerLink = centerDimPoint.HeadLink;
if (centerDimPoint.NumberPoints > 1)
{
foreach (var sp in centerDimPoint.SpaPoints.Where(p => p.ID != center.ID))
{
var dictance = sp.DistanceTo(center, dimSelector);
if (dictance <= within && where (sp, center, dictance))
{
list.Add(sp);
}
}
}
var centerPos = centerDimPoint.Position;
var next = centerLink.Next;
while (next != null && (next.Position - centerPos).Abs() <= within)
{
foreach (var nextSpaPoint in next.DimPoint.SpaPoints)
{
var dictance = nextSpaPoint.DistanceTo(center, dimSelector);
if (dictance <= within && where (nextSpaPoint, center, dictance))
{
list.Add(nextSpaPoint);
}
}
next = next.Next;
}
var prev = centerLink.Prev;
while (prev != null && (prev.Position - centerPos).Abs() <= within)
{
foreach (var prevSpaPoint in prev.DimPoint.SpaPoints)
{
var dictance = prevSpaPoint.DistanceTo(center, dimSelector);
if (dictance <= within && where (prevSpaPoint, center, dictance))
{
list.Add(prevSpaPoint);
}
}
prev = prev.Prev;
}
return(list);
}
TAccumulate ISpaceManager.AggregateWithin <TSource, TAccumulate>(SpacePoint <TSource> center, TAccumulate seed, float within, IDimensionSelector dimSelector, Func <TAccumulate, SpacePoint <TSource>, SpacePoint <TSource>, float, TAccumulate> func)
{
if (dimSelector == null)
{
dimSelector = DimensionSelector.Default;
}
var centerDimPoint = center.Dimensions[dimSelector.MainDimensionIndex];
var centerLink = centerDimPoint.HeadLink;
if (centerDimPoint.NumberPoints > 1)
{
foreach (var sp in centerDimPoint.SpaPoints.Where(p => p.ID != center.ID))
{
var dictance = sp.DistanceTo(center, dimSelector);
if (dictance <= within)
{
seed = func(seed, sp, center, dictance);
}
}
}
var centerPos = centerDimPoint.Position;
var next = centerLink.Next;
while (next != null && (next.Position - centerPos).Abs() <= within)
{
foreach (var nextSpaPoint in next.DimPoint.SpaPoints)
{
var dictance = nextSpaPoint.DistanceTo(center, dimSelector);
if (dictance <= within)
{
seed = func(seed, nextSpaPoint, center, dictance);
}
}
next = next.Next;
}
var prev = centerLink.Prev;
while (prev != null && (prev.Position - centerPos).Abs() <= within)
{
foreach (var prevSpaPoint in prev.DimPoint.SpaPoints)
{
var dictance = prevSpaPoint.DistanceTo(center, dimSelector);
if (dictance <= within)
{
seed = func(seed, prevSpaPoint, center, dictance);
}
}
prev = prev.Prev;
}
return(seed);
}
public static SpacePoint<string> FindNearest(this ISpaceManager sm, SpacePoint<string> center, float within)
{
var pan = new PointNfo<string>(null, Single.MaxValue);
return sm.AggregateWithin(center, pan, within, (aggr, curr, cen, dis) =>
{
if (dis < aggr.Distance)
{
aggr.Point = curr;
aggr.Distance = dis;
}
return aggr;
}).Point;
}
bool ISpaceManager.RemovePoint <T>(SpacePoint <T> sp)
{
var isRemoved = true;
for (var i = 0; i < sp.Dimensions.Length; ++i)
{
if (!RemovePointFromDimensions(sp, i))
{
isRemoved = false;
}
}
return(isRemoved);
}
/// <summary>
/// 从一条犯罪数据中计算出其高斯平面坐标
/// </summary>
/// <returns>空间的二维点</returns>
public PointInfo ParseXY()
{
PointInfo pt = new PointInfo();
SpacePoint spt = new SpacePoint();
spt.B = CoorTran.Algorithm.D2R(latitude);
spt.L = CoorTran.Algorithm.D2R(longitude);
CoorTran.Algorithm.BL2xy(new EarthPara(), spt);
pt.x = spt.x;
pt.y = spt.y;
pt.pointID = incident_id;
return(pt);
}
bool ISpaceManager.Reposition <T>(SpacePoint <T> sp, params float[] dimensionPositions)
{
MustBe.Equal(sp.Dimensions.Length, dimensionPositions.Length, () => "space.Dimensions.Length AND dimensionPositions.Length");
byte r = 0;
for (var d = 0; d < sp.Dimensions.Length; ++d)
{
if (_spaceManager.Reposition(sp.Dimensions[d].Dimension, sp, dimensionPositions[d]))
{
++r;
}
}
return(r > 0);
}
public static SpacePoint <string> FindNearest(this ISpaceManager sm, SpacePoint <string> center, float within)
{
var pan = new PointNfo <string>(null, Single.MaxValue);
return(sm.AggregateWithin(center, pan, within, (aggr, curr, cen, dis) =>
{
if (dis < aggr.Distance)
{
aggr.Point = curr;
aggr.Distance = dis;
}
return aggr;
}).Point);
}
void LaunchMissiles()
{
for (int i = 0; i < 4; i++)
{
var missile = Instantiate(EnemyMissile);
//missile.SetActive(true);
var missileScript = missile.GetComponent <EnemyMissile>();
var launchX = Random.Range(LaunchBounds.min.x, LaunchBounds.max.x);
var targetX = Random.Range(TargetBounds.min.x, TargetBounds.max.x);
var launchPos = new SpacePoint(Graphics.Space.World, new Vector3(launchX, LaunchBounds.center.y, Z));
var targetPos = new SpacePoint(Graphics.Space.World, new Vector3(targetX, TargetBounds.center.y, Z));
missileScript.Launch(launchPos, targetPos);
MissilesToLaunch--;
}
}
private void OnSpacePointMouseDown(Rectangle rect, SpacePoint <int> point, MouseButtonEventArgs e)
{
if (e.ChangedButton == MouseButton.Middle)
{
_manager.RemovePoint(point);
DrawTree();
}
else if (e.ChangedButton == MouseButton.Left)
{
_dragged = new Dragged {
Point = point, Rect = rect
};
return;
}
_dragged = null;
}
bool ISpaceManager.Reposition <T>(SpacePoint <T> sp, float x, float y, float z)
{
MustBe.Equal(sp.Dimensions.Length, 3, () => "space.Dimensions.Length AND x,y,z");
byte r = 0;
if (_spaceManager.Reposition(sp.Dimensions[0].Dimension, sp, x))
{
++r;
}
if (_spaceManager.Reposition(sp.Dimensions[1].Dimension, sp, y))
{
++r;
}
if (_spaceManager.Reposition(sp.Dimensions[2].Dimension, sp, z))
{
++r;
}
return(r > 0);
}
SpacePoint <T> ISpaceManager.AddPoint <T>(Space <T> space, T data, params float[] dimensionPositions)
{
MustBe.NotNull(space, () => "space");
MustBe.NotNull(dimensionPositions, () => "dimensionPositions");
MustBe.Equal(dimensionPositions.Length, space.Dimensions.Length, () => "number of dimensions does not match the number of dimension positions passed when adding point to space");
var sp = new SpacePoint <T>(space)
{
Value = data
};
if (dimensionPositions == null)
{
throw new ArgumentException("Expected dimension positions");
}
for (var i = 0; i < space.Dimensions.Length; ++i)
{
_spaceManager.AddPoint(space.Dimensions[i], sp, dimensionPositions[i]);
}
return(sp);
}
public void Launch(SpacePoint launchPoint, SpacePoint targetPoint)
{
Start();
Debug.Log($"Missile {MissileCount}");
Debug.Log($"Target {targetPoint}");
MissileCount++;
LaunchPoint = launchPoint.ToWorldSpace();
TargetPoint = targetPoint.ToWorldSpace();
Distance = Vector3.Distance(LaunchPoint.Position, TargetPoint.Position);
Counter = 0;
Vector3[] poses = new Vector3[3];
var start = LaunchPoint.Position;
lineRenderer.SetPosition(0, start);
lineRenderer.SetPosition(1, start);
Debug.Log("LineRenderer");
Rigidbody.MovePosition(start);
lineRenderer.enabled = true;
gameObject.SetActive(true);
}
public PointNfo(SpacePoint <T> point, float distance)
{
Point = point;
Distance = distance;
}
private void OnSpacePointMouseUp(Rectangle rect, SpacePoint<int> point, MouseButtonEventArgs e)
{
}
public static Quaternion GetRelocatedRotation(Quaternion rotation, SpacePoint pointOfView)
{
// To verify
return(rotation * Quaternion.Inverse(pointOfView.m_rotation));
}
private void OnSpacePointMouseUp(Rectangle rect, SpacePoint <int> point, MouseButtonEventArgs e)
{
}
List <SpacePoint <T> > ISpaceManager.FindAllNearWhere <T>(SpacePoint <T> center, float within, Func <SpacePoint <T>, SpacePoint <T>, float, bool> where)
{
return(((ISpaceManager)this).FindAllNearWhere <T>(center, within, null, where));
}
private void OnSpacePointMouseDown(Rectangle rect, SpacePoint<int> point, MouseButtonEventArgs e)
{
if (e.ChangedButton == MouseButton.Middle)
{
_manager.RemovePoint(point);
DrawTree();
}
else if (e.ChangedButton == MouseButton.Left)
{
_dragged = new Dragged { Point = point, Rect = rect };
return;
}
_dragged = null;
}
bool ISpaceManager.AddPoint <T>(Dimension <T> dimension, SpacePoint <T> sp, float position)
{
if (dimension == null || sp == null)
{
return(false);
}
MustBe.Null(sp.Dimensions[dimension.Index], () => "space point already has assigned the dimension with index=" + dimension.Index);
if (dimension.HeadDimPoint == null)
{
var dp = new DimensionPoint <T>(dimension)
{
Position = position
};
dp.HeadLink = dp.TailLink = new DimensionLink <T>(0, dp);
dp.AddPoint(sp);
dimension.HeadDimPoint = dimension.TailDimPoint = dp;
dimension.Count = 1;
return(true);
}
// try to find existing dimension point
DimensionPoint <T> left;
DimensionPoint <T> right;
if (_spaceManager.TryFindDimensionPoint(dimension, position, out left, out right))
{
// if found add the space point to it
return(left.AddPoint(sp));
}
// new head
if (left == null)
{
AppendNewHead(dimension, sp, position);
dimension.Count++;
return(true);
}
// new tail
if (right == null)
{
AppendNewTail(dimension, sp, position);
dimension.Count++;
return(true);
}
// new in between
var newPoint = new DimensionPoint <T>(dimension)
{
Position = position
};
newPoint.AddPoint(sp);
var newLink = new DimensionLink <T>(0, newPoint);
newPoint.HeadLink = newLink;
newPoint.TailLink = newLink;
left.HeadLink.AssignNext(newLink);
newLink.AssignNext(right.HeadLink);
// for fast movers do not normalize the tree
if (!sp.IsFastMover)
{
_spaceManager.TryAddLevel(dimension);
var toExtendUp = newLink.GetSiblingExtensionCandidate();
while (_spaceManager.TryExtendUp(toExtendUp, out toExtendUp))
{
_spaceManager.TryAddLevel(dimension);
}
}
dimension.Count++;
return(true);
}
bool ISpaceManager.Reposition <T>(Dimension <T> dimension, SpacePoint <T> sp, float position)
{
var point = sp.Dimensions[dimension.Index];
var next = position;
var prev = point.Position;
// no move
if (dimension.Eq(prev, next))
{
return(false);
}
if (next < prev)
{
if (point.NumberPoints > 1)
{
if (RemovePointFromDimensions(sp, dimension.Index))
{
sp.Dimensions[dimension.Index] = null;
_spaceManager.AddPoint(dimension, sp, next);
}
}
else
{
var link = point.HeadLink;
if (link.Prev == null || link.Prev.DimPoint.Position < next)
{
point.Position = next;
}
else
{
if (RemovePointFromDimensions(sp, dimension.Index))
{
sp.Dimensions[dimension.Index] = null;
_spaceManager.AddPoint(dimension, sp, next);
}
}
}
}
else // THIS IS: if (prev < next)
{
if (point.NumberPoints > 1)
{
if (RemovePointFromDimensions(sp, dimension.Index))
{
sp.Dimensions[dimension.Index] = null;
_spaceManager.AddPoint(dimension, sp, next);
}
}
else
{
var link = point.HeadLink;
if (link.Next == null || link.Next.DimPoint.Position > next)
{
point.Position = next;
}
else
{
if (RemovePointFromDimensions(sp, dimension.Index))
{
sp.Dimensions[dimension.Index] = null;
_spaceManager.AddPoint(dimension, sp, next);
}
}
}
}
return(true);
}
bool ISpaceManager.Any <T>(SpacePoint <T> center, float within, Func <SpacePoint <T>, SpacePoint <T>, float, bool> where)
{
return(((ISpaceManager)this).Any(center, within, null, where));
}
TAccumulate ISpaceManager.AggregateWithin <TSource, TAccumulate>(SpacePoint <TSource> center, TAccumulate seed, float within, Func <TAccumulate, SpacePoint <TSource>, SpacePoint <TSource>, float, TAccumulate> func)
{
return(((ISpaceManager)this).AggregateWithin(center, seed, within, null, func));
}
