private void ProcessSnapPointsInTrigger()
{
if (collidedSnapPoints.Count == 0)
{
return;
}
if (parentMovableObject.ShouldSnapToObject == false || !parentMovableObject.IsPlacing)
{
return;
}
closestSnapPointDetected = GetClosestSnapPoint(collidedSnapPoints.ToArray());
if (closestSnapPointDetected != null)
{
if (sphereIndicator == null)
{
sphereIndicator = Instantiate(sphereIndicatorPrefab, closestSnapPointDetected.transform);
}
else if (sphereIndicator != null)
{
sphereIndicator.transform.SetParent(closestSnapPointDetected.transform);
sphereIndicator.transform.localPosition = Vector3.zero;
}
}
else if (closestSnapPointDetected == null && sphereIndicator != null)
{
Destroy(sphereIndicator.gameObject);
}
}
/// <summary>
/// Finds closest snap point.
/// </summary>
/// <param name="snapPoints">Array of snap points</param>
/// <returns>Closest snap point.</returns>
private SnapPoint FindClosestPoint(SnapPoint[] snapPoints)
{
double minDist = double.MaxValue;
int i = 0;
int index = 0;
foreach (SnapPoint vertex in snapPoints)
{
Point3D vertexScreen = WorldToScreen(vertex);
Point2D currentScreen = new Point2D(mouseLocation.X, Size.Height - mouseLocation.Y);
double dist = Point2D.Distance(vertexScreen, currentScreen);
if (dist < minDist)
{
index = i;
minDist = dist;
}
i++;
}
SnapPoint snap = (SnapPoint)snapPoints.GetValue(index);
DisplaySnappedVertex(snap);
return(snap);
}
public override List <SnapPoint> GetSnapPoints()
{
List <SnapPoint> list = new List <SnapPoint>();
GetGridParameters(out int startX, out int startY, out int startItemIndex, out int endItemIndex);
_ = _itemsPerLine;
Rectangle viewCullingArea = base.Parent.GetViewCullingArea();
int num = endItemIndex - startItemIndex;
while (_dummySnapPoints.Count < num)
{
_dummySnapPoints.Add(new SnapPoint("CreativeInfinitesSlot", 0, Vector2.Zero, Vector2.Zero));
}
int num2 = 0;
Vector2 value = GetDimensions().Position();
for (int i = startItemIndex; i < endItemIndex; i++)
{
Point center = GetItemSlotHitbox(startX, startY, startItemIndex, i).Center;
if (viewCullingArea.Contains(center))
{
SnapPoint snapPoint = _dummySnapPoints[num2];
snapPoint.ThisIsAHackThatChangesTheSnapPointsInfo(Vector2.Zero, center.ToVector2() - value, num2);
snapPoint.Calculate(this);
num2++;
list.Add(snapPoint);
}
}
foreach (UIElement element in Elements)
{
list.AddRange(element.GetSnapPoints());
}
return(list);
}
public static SnapPoint Move(this SnapPoint snap, Vector offset)
{
var newPoint = snap.Point + offset;
switch (snap.Kind)
{
case SnapPointKind.Center:
return(new CenterPoint(newPoint));
case SnapPointKind.EndPoint:
return(new EndPoint(newPoint));
case SnapPointKind.Focus:
return(new FocusPoint(newPoint));
case SnapPointKind.MidPoint:
return(new MidPoint(newPoint));
case SnapPointKind.Quadrant:
return(new QuadrantPoint(newPoint));
case SnapPointKind.None:
default:
throw new ArgumentException("Invalid snap point type", "snap.Kind");
}
}
private void SetupGamepadPoints(SpriteBatch spriteBatch)
{
UILinkPointNavigator.Shortcuts.BackButtonCommand = 1;
int num = 3000;
int idRangeEndExclusive = num;
List <SnapPoint> snapPoints = GetSnapPoints();
UILinkPoint uILinkPoint = null;
for (int i = 0; i < snapPoints.Count; i++)
{
SnapPoint snapPoint = snapPoints[i];
string name = snapPoint.Name;
if (name == "GoBack")
{
uILinkPoint = _helper.MakeLinkPointFromSnapPoint(idRangeEndExclusive++, snapPoint);
}
}
if (PlayerInput.UsingGamepadUI)
{
_helper.MoveToVisuallyClosestPoint(num, idRangeEndExclusive);
}
if (Main.CreativeMenu.GamepadMoveToSearchButtonHack)
{
Main.CreativeMenu.GamepadMoveToSearchButtonHack = false;
if (uILinkPoint != null)
{
UILinkPointNavigator.ChangePoint(uILinkPoint.ID);
}
}
}
private bool EvaluateAnchorPoints(SnapPiece piece, SnapPiece otherPiece, out List <SnapPoint> pointsReadyToConnect)
{
pointsReadyToConnect = new List <SnapPoint>();
bool AllPointsCanConnect = true;
for (int i = 0; i < piece.SnapPoints.Count && AllPointsCanConnect; i++)
{
SnapPoint currentPoint = piece.SnapPoints[i];
if (!currentPoint.IsConnected)
{
for (int j = 0; j < otherPiece.SnapPoints.Count && AllPointsCanConnect; j++)
{
SnapPoint otherPoint = otherPiece.SnapPoints[j];
if (currentPoint.ConnectionID == otherPoint.ConnectionID && !otherPoint.IsConnected)
{
if (currentPoint.CanConnect && otherPoint.CanConnect)
{
pointsReadyToConnect.Add(currentPoint);
pointsReadyToConnect.Add(otherPoint);
}
else
{
AllPointsCanConnect = false;
pointsReadyToConnect = new List <SnapPoint>();
}
}
}
}
}
return(AllPointsCanConnect);
}
public void SnapPoints(Transform body, Transform piece)
{
SnapPoint bodySP = body.GetComponent <SnapPoint>();
SnapPoint pieceSP = piece.GetComponent <SnapPoint>();
storedAngle = piece.parent.eulerAngles.z;
connectedSP1 = bodySP;
connectedSP2 = pieceSP;
Vector2 offset = ((Vector2)pieceSP.corner1.position) - ((Vector2)bodySP.corner2.position);
piece.parent.position -= new Vector3(offset.x, offset.y, 0);
float angle = AngleBetween3Points((Vector2)pieceSP.corner2.position, (Vector2)bodySP.corner2.position, (Vector2)bodySP.corner1.position);
//Debug.Log(angle);
float storedAng = piece.eulerAngles.z;
Transform pieceP = piece.parent;
piece.parent = null;
pieceP.parent = piece;
piece.eulerAngles += new Vector3(0, 0, -angle);
pieceP.parent = null;
piece.parent = pieceP;
piece.eulerAngles = new Vector3(0, 0, storedAng);
offset = ((Vector2)pieceSP.corner1.position) - ((Vector2)bodySP.corner2.position);
piece.parent.position -= new Vector3(offset.x, offset.y, 0);
piece.parent.parent = body.parent;
}
public Line()
{
__start = new SnapPoint(this, PointType.start);
__end = new SnapPoint(this, PointType.end);
__mid = new SnapPoint(this, PointType.mid);
__edge = new SnapPoint(this, PointType.edge);
}
/// <summary>
/// Creates a default SnapPoint for this Snappable.
/// </summary>
/// <returns>An non-populated SnapPoint.</returns>
private SnapPoint GenerateSnapPoint()
{
SnapPoint record = SnapPoint.Create(this.transform);
this.snapPoints.Add(record);
return(record);
}
//public void Interact(SnapPoint snapPoint) // Think alot. maybe be interface? how behaviorController will change interaction??
//{
// Move(snapPoint);
// if (CurrentSnapPoint.Index.y == preset.AvaliableAttackRange)
// {
// Attack();
// }
// else
// {
// IsMoved = true;
// OnEndAttack.Invoke();
// }
//}
public void Move(SnapPoint positionToMove)
{
CurrentSnapPoint.IsFree = true;
CurrentSnapPoint = positionToMove;
transform.position = CurrentSnapPoint.Position;
CurrentSnapPoint.IsFree = false;
}
public void DetectSnapPoint()
{
Ray ray = Camera.main.ScreenPointToRay(currentTouchPosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, 100f, pickableLayers))
{
string hitTag = hit.collider.gameObject.tag;
SnapPoint otherPoint = hit.collider.gameObject.GetComponent <SnapPoint>();
if (hitTag == "AnchorPoint" && otherPoint != null)
{
if (selectedOtherPoint != otherPoint && snapPiece.CanConnectAt(otherPoint))
{
selectedOtherPoint = otherPoint;
woodPieceIcon.color = OverSnapPointDragColor;
}
}
else
{
ResetSelection();
}
}
else
{
ResetSelection();
}
previousTouchPosition = currentTouchPosition;
}
private void SetupGamepadPoints(SpriteBatch spriteBatch)
{
UILinkPointNavigator.Shortcuts.BackButtonCommand = 1;
int idRangeStartInclusive = 3000;
int idRangeEndExclusive = idRangeStartInclusive;
List <SnapPoint> snapPoints = this.GetSnapPoints();
UILinkPoint uiLinkPoint = (UILinkPoint)null;
for (int index = 0; index < snapPoints.Count; ++index)
{
SnapPoint snap = snapPoints[index];
if (snap.Name == "GoBack")
{
uiLinkPoint = this._helper.MakeLinkPointFromSnapPoint(idRangeEndExclusive++, snap);
}
}
if (PlayerInput.UsingGamepadUI)
{
this._helper.MoveToVisuallyClosestPoint(idRangeStartInclusive, idRangeEndExclusive);
}
if (!Main.CreativeMenu.GamepadMoveToSearchButtonHack)
{
return;
}
Main.CreativeMenu.GamepadMoveToSearchButtonHack = false;
if (uiLinkPoint == null)
{
return;
}
UILinkPointNavigator.ChangePoint(uiLinkPoint.ID);
}
/// <summary>
/// Distance between a point and the shape.
/// </summary>
/// <param name="pt">Test point</param>
/// <param name="mode">Snap modes to consider</param>
/// <returns>Distance from point to nearest point on shape</returns>
public override SnapPoint GetSnap(Vector2 pt, SnapPoint.Mode mode)
{
SnapPoint snap = new SnapPoint();
snap.point = position;
if ((mode & SnapPoint.Mode.Center) != 0)
{
snap.mode = SnapPoint.Mode.Center;
}
else if ((mode & SnapPoint.Mode.Endpoint) != 0)
{
snap.mode = SnapPoint.Mode.Endpoint;
}
else if ((mode & SnapPoint.Mode.Midpoint) != 0)
{
snap.mode = SnapPoint.Mode.Midpoint;
}
else if ((mode & SnapPoint.Mode.Edge) != 0)
{
snap.mode = SnapPoint.Mode.Edge;
}
return(snap);
}
private UILinkPoint MakeLinkPointFromSnapPoint(int id, SnapPoint snap)
{
UILinkPointNavigator.SetPosition(id, snap.Position);
UILinkPoint uILinkPoint = UILinkPointNavigator.Points[id];
uILinkPoint.Unlink();
return(uILinkPoint);
}
private void Start()
{
rectTransform = GetComponent <RectTransform>();
image = GetComponent <Image>();
_actualSnap = _startSnap;
_actualSnap.isEmpty = false;
snapped = true;
}
private void ResetSelection()
{
selectedOtherPoint = null;
if (woodPieceIcon != null)
{
woodPieceIcon.color = NeutralDragColor;
}
}
public UILinkPoint MakeLinkPointFromSnapPoint(int id, SnapPoint snap)
{
UILinkPointNavigator.SetPosition(id, snap.Position);
UILinkPoint point = UILinkPointNavigator.Points[id];
point.Unlink();
return(point);
}
/// <summary>
/// Creates a new SnapPoint from the stored data.
/// Mostly used to restore a SnapPoint that was stored during Play-Mode.
/// </summary>
/// <param name="data">The data of the SnapPoint.</param>
/// <returns>The geerated SnapPoint.</returns>
private SnapPoint LoadSnapPoint(SnapPointData data)
{
SnapPoint record = GenerateSnapPoint();
record.LoadData(data, this.transform);
record.LoadGhost(ghostProvider);
return(record);
}
private void CreatSegments(int count, float distance, int index)
{
for (int i = 0; i < count; i++)
{
CreatOnCircle(i * (360f / count), distance);
SnapPoints[i, index] = new SnapPoint(point, new Vector2Int(i, index));
}
}
/// <summary>
/// Distance between a point and the shape.
/// </summary>
/// <param name="pt">Test point</param>
/// <param name="mode">Snap modes to consider</param>
/// <returns>Distance from point to nearest point on shape</returns>
public override SnapPoint GetSnap(Vector2 pt, SnapPoint.Mode mode)
{
SnapPoint snap = new SnapPoint();
float distance = float.MaxValue;
if ((mode & SnapPoint.Mode.Center) != 0)
{
float d = Vector2.Distance(pt, position);
if (d < distance)
{
distance = d;
snap.mode = SnapPoint.Mode.Center;
snap.point = position;
}
}
if ((mode & SnapPoint.Mode.Midpoint) != 0)
{
float offset45 = 0.7071f * radius;
Vector2[] midPoints =
{
position + new Vector2(radius, 0f),
position + new Vector2(offset45, offset45),
position + new Vector2(0f, radius),
position + new Vector2(-offset45, offset45),
position + new Vector2(-radius, 0f),
position + new Vector2(-offset45, -offset45),
position + new Vector2(0f, -radius),
position + new Vector2(offset45, -offset45),
};
foreach (Vector2 testPt in midPoints)
{
float d = Vector2.Distance(pt, testPt);
if (d < distance)
{
distance = d;
snap.mode = SnapPoint.Mode.Midpoint;
snap.point = testPt;
}
}
}
if ((mode & SnapPoint.Mode.Edge) != 0)
{
float d = Distance(pt);
if (d < distance)
{
distance = d;
snap.mode = SnapPoint.Mode.Edge;
float angle = Mathf.Atan2(pt.y - position.y, pt.x - position.x);
snap.point.x = position.x + Mathf.Cos(angle) * radius;
snap.point.y = position.y + Mathf.Sin(angle) * radius;
}
}
return(snap);
}
public override SnapPoint[] GetSnapPoints()
{
SnapPoint[] cp = new SnapPoint[Points.Count];
for (int i = 0; i < Points.Count; i++)
{
cp[i] = new SnapPoint("Vertex (" + (i + 1).ToString() + ")", Points[i]);
}
return(cp);
}
void Awake () {
Canvas canvas = GetComponentInParent <Canvas>();
if (canvas != null) {
// canvasRectTransform = canvas.transform as RectTransform;
panelRectTransform = transform as RectTransform;
containerRectTransform = transform.parent as RectTransform;
}
this.currentLocation = homeLocation;
}
private SnapPoint getSnapPointInCollision(Collider other)
{
SnapPoint snapPoint = other.GetComponent <SnapPoint>();
if (snapPoint)
{
return(snapPoint);
}
return(null);
}
void OnTriggerExit(Collider other)
{
SnapPoint snapPoint = getSnapPointInCollision(other);
if (!snapPoint || snapPoint.ParentPiece == parentPiece)
{
return;
}
ParentPiece.removePotentialLink();
}
private void OnTriggerEnter(Collider other)
{
SnapPoint snapPoint = getSnapPointInCollision(other);
if (!snapPoint || snapPoint.ParentPiece == parentPiece)
{
return;
}
ParentPiece.addPotentialLink(this, snapPoint);
}
public static FeatureCollection ToFeatureCollection(this RouterDb routerDb, SnapPoint snapPoint)
{
var features = new FeatureCollection();
features.Add(routerDb.ToFeature(snapPoint.EdgeId));
var locationOnNetwork = routerDb.LocationOnNetwork(snapPoint);
features.Add(new Feature(new Point(new Coordinate(locationOnNetwork.Longitude, locationOnNetwork.Latitude)), new AttributesTable()));
return(features);
}
public void addPotentialLink(SnapPoint origin, SnapPoint target)
{
if (isBeingManipulated)
{
return;
}
//Debug.Log("Piece(" + this + "): Adding link to:" + target.ParentPiece);
potentialLink = new Link(origin, target);
//Debug.Log("addPotentialSnapPoint:" + potentialLink);
}
/// <summary>
/// Creates a new SnapPoint at the exact pose of a given hand.
/// Mostly used with Hand-Tracking at Play-Mode
/// </summary>
/// <param name="puppet">The user controlled hand.</param>
/// <returns>The generated SnapPoint.</returns>
public SnapPoint AddSnapPoint(HandPuppet puppet)
{
HandPose rawPose = puppet.TrackedPose(this.transform, true);
SnapPoint snapPoint = GenerateSnapPoint();
snapPoint.SetPose(rawPose, this.transform);
snapPoint.LoadGhost(ghostProvider);
return(snapPoint);
}
void OnEnable()
{
snapPoint = (SnapPoint)target;
if (snapPoint.connectablePipestyles == null)
{
snapPoint.connectablePipestyles = new List <PipeStyle>();
}
GetAllPipestyls();
}
private Link getLinkBySnapPoint(SnapPoint snapPoint)
{
foreach (Link link in linkList)
{
if (link.origin == snapPoint || link.target == snapPoint)
{
return(link);
}
}
return(null);
}
private void renderSnapInformation(XNAGame game, Matrix transformation, SnapInformation snapInformation, Dictionary <SnapType, Color> colorTypeMap)
{
for (int j = 0; j < snapInformation.SnapList.Count; j++)
{
SnapPoint point = snapInformation.SnapList[j];
Vector3 startPos = point.Position;
var color = colorTypeMap[point.SnapType];
game.LineManager3D.AddLine(Vector3.Transform(startPos, transformation), Vector3.Transform(startPos + point.Normal, transformation), color);
game.LineManager3D.AddLine(Vector3.Transform(startPos, transformation), Vector3.Transform(startPos + point.Up, transformation), color);
}
}
public RendererParams( Camera camera,
UserActionInEditor userActionInEditor,
Rectangle selectionRectangle,
EntityCreation entityCreation,
SnapPoint snapPoint )
{
Camera = camera ;
UserActionInEditor = userActionInEditor ;
SelectionRectangle = selectionRectangle ;
EntityCreation = entityCreation ;
SnapPoint = snapPoint ;
ItemsToRender=ItemsToRender.Everything;
}
public void OnEndDrag (PointerEventData data)
{
if (GameStateManager.GetInstance().GetCurrentState() == GameStateManager.GameState.SETTING_UP_SACRIFICE)
{
SnapPoint where = GameObject.FindObjectOfType<SnappingPointRegistry>().returnClosestSnapPoint(this.gameObject.transform);
if (where == null || Vector2.Distance(this.gameObject.transform.position, where.gameObject.transform.position) > snapRadius)
{
destination = homeLocation;
moving = true;
}
else
{
destination = where;
moving = true;
}
AudioManager.GetInstance().PlaySound("drop");
}
}
public void Update() {
if (true || GameStateManager.GetInstance().GetCurrentState() == GameStateManager.GameState.SETTING_UP_SACRIFICE)
{
if (this.moving && Time.frameCount > waitTick)
{
this.transform.position = Vector2.MoveTowards(this.transform.position, this.destination.gameObject.transform.position, snapSpeed * Time.deltaTime);
this.transform.localScale = Vector2.MoveTowards(this.transform.localScale, new Vector2(1,1), snapSpeed * Time.deltaTime);
if (Vector2.Distance(this.transform.position, this.destination.gameObject.transform.position) < .01 && Vector2.Distance(this.transform.localScale, new Vector2(1,1)) < .01)
{
this.moving = false;
this.dragging = false;
this.destination.occupied = true;
this.currentLocation.occupied = false;
this.currentLocation = this.destination;
this.destination = null;
this.waitTick = 0;
if (GameStateManager.GetInstance().GetCurrentState() == GameStateManager.GameState.GIVING_ITEMS)
{
SacrificeManager.GetInstance().toGive = null;
GameStateManager.GetInstance().RequestGameStateChange(GameStateManager.GameState.SCORING_KILL);
}
}
}
}
}
public void SnapPoints(Transform body, Transform piece)
{
SnapPoint bodySP = body.GetComponent<SnapPoint>();
SnapPoint pieceSP = piece.GetComponent<SnapPoint>();
storedAngle = piece.parent.eulerAngles.z;
connectedSP1 = bodySP;
connectedSP2 = pieceSP;
Vector2 offset = ((Vector2) pieceSP.corner1.position) - ((Vector2) bodySP.corner2.position);
piece.parent.position-= new Vector3(offset.x, offset.y,0);
float angle = AngleBetween3Points((Vector2)pieceSP.corner2.position,(Vector2) bodySP.corner2.position, (Vector2) bodySP.corner1.position);
//Debug.Log(angle);
float storedAng = piece.eulerAngles.z;
Transform pieceP = piece.parent;
piece.parent = null;
pieceP.parent = piece;
piece.eulerAngles += new Vector3(0,0,-angle);
pieceP.parent = null;
piece.parent = pieceP;
piece.eulerAngles = new Vector3(0,0,storedAng);
offset = ((Vector2) pieceSP.corner1.position) - ((Vector2) bodySP.corner2.position);
piece.parent.position-= new Vector3(offset.x, offset.y,0);
piece.parent.parent = body.parent;
}
public void GoHome()
{
this.destination = homeLocation;
moving = true;
}
public void GiveElement()
{
this.gameObject.SetActive(true);
Debug.Log("Giving Element");
this.transform.position = Spawn.position;
this.destination = homeLocation;
this.transform.localScale = new Vector2(5, 5);
this.moving = true;
this.waitTick = Time.frameCount + 60;
}
