public static void Link(Pice pice1, LinkDirectory directory, Pice pice2) { // set pice1 { var info = new Linking(); info.directory = directory; info.pice = pice2; pice1.linkingList.Add(info); if (pice1.linkingList.Count == 1) { pice1.FlashAsLink(); } } // set pice2 { var info = new Linking(); info.directory = LinkDirectoryUtil.Reverse(directory); info.pice = pice1; pice2.linkingList.Add(info); if (pice2.linkingList.Count == 1) { pice2.FlashAsLink(); } } }
public override void Switch(Space newSpace, Link newLink) //WORKS! { Vector3 originalDirection = direction; Vector3 originalLocalDirection = localDirection; if (space == Space.World) { if (newSpace == Space.Self) //world > self { space = Space.Self; //auto keep offset value = offset.ReverseRotation( Linking.InverseTransformEuler(Quaternion.LookRotation(originalDirection), parent.rotation)) * Vector3.forward; } } else if (space == Space.Self) { if (newSpace == Space.World) //self > world { space = Space.World; value = direction; } } }
public override Quaternion GetTarget() { Quaternion target = new Quaternion(); if (space == Space.World) { target = value; } else if (space == Space.Self) { if (link == Link.Offset) { target = parentRot * value; //++++++++offset target = offset.ApplyRotation(this, target); } else if (link == Link.Match) { //if (!editorApply) { SetPrevious(); //} //target = parentRot * previous; //WORKS! target = Linking.TransformEuler(previous, parent.rotation); } } return(target); }
} //returns self public Vector3 GetPosition(Space relativeTo = Space.Self) { //gets position with specified space if (relativeTo == Space.Self) { if (factorScale) { if (offsetScale != 0f) //ALL WORKS! { return(Linking.InverseTransformPoint(operationalPosition, parentPos, parentRot, parentScale) / offsetScale); } else { return(Vector3.zero); } } else { return(Linking.InverseTransformPoint(operationalPosition, parentPos, parentRot)); //WORKS } } else { return(operationalPosition); //WORKS! } }
public override void Set(ILinkTarget target, Linking linking) { if (linking == Linking.AsConnection) { Clear(); } base.Set(target, linking); }
public Tuple <int, int> ChooseWhichStone(bool blackIsPlaying, Board.PlaceOnBoardIs[,] board) { int counter = 0; Tuple <int, int, int, int>[] almostMill = AlmostMill(blackIsPlaying, board); Tuple <int, int> tupleOfIndexes; short index; for (int i = 0; i < 60; i++) { if (almostMill[i] == null) { break; } else { counter++; } } if (counter > 0) { int num = random.Next(0, counter - 1); index = (short)random.Next(0, 1); if (index == 0) { return(tupleOfIndexes = new Tuple <int, int>(almostMill[num].Item1, almostMill[num].Item2)); } else { return(tupleOfIndexes = new Tuple <int, int>(almostMill[num].Item3, almostMill[num].Item4)); } } else { while (true) { index = (short)random.Next(0, 23); tupleOfIndexes = Linking.GetIndexesOnBoard(index); if (!blackIsPlaying) { if (board[tupleOfIndexes.Item1, tupleOfIndexes.Item2] == Board.PlaceOnBoardIs.blackOccupied) { return(tupleOfIndexes); } } else { if (board[tupleOfIndexes.Item1, tupleOfIndexes.Item2] == Board.PlaceOnBoardIs.whiteOccupied) { return(tupleOfIndexes); } } } } }
public void LoadInfo(PuzzleInfo info) { // 把所有 pice 拿起 foreach (var pice in PiceManager.list) { //pice.SetToFloating(); PiceMover.SetBlockToFloat(pice); pice.StopTween(); } // 逐个设置 pice 归属 foreach (var i in info.piceInfoList) { var index = i.index; var pice = PiceManager.GetByIndex(index); if (i.owner == PiceOwner.Board) { //pice.SetToBoard(i.boardX, i.boardY); PiceMover.SetBlockToBoard(pice, i.boardX, i.boardY); } else if (i.owner == PiceOwner.Side) { //pice.SetToSide(i.sideIndex); //side.Append(pice); PiceMover.SetToSide(pice, -1); } else if (i.owner == PiceOwner.Floating) { PiceMover.SetToSide(pice, -1); //pice.SetToSide(side.count - 1); } pice.isFixed = i.isFixed; pice.SortingOrder = i.sortingOrder; // linking pice.linkingList.Clear(); foreach (var linkingInfo in i.LinkingInfoList) { var linking = new Linking(); linking.directory = linkingInfo.directory; var linkingToPinceIndex = linkingInfo.piceIndex; var linkingToPice = PiceManager.GetByIndex(linkingToPinceIndex); linking.pice = linkingToPice; pice.linkingList.Add(linking); } // edge type pice.LeftType = i.leftType; pice.RightType = i.rightType; pice.BottomType = i.bottomType; pice.TopType = i.topType; } board.RepositionAllPiceNoAnimation(); side.RepositionPiceListNoAnimation(); LayerOrderDispatcher.next = info.nextOrder; }
public virtual void Set(ILinkTarget target, Linking linking) { if (linking == Linking.AsReference) { Reference = target; } else { SaveConnection((IPage)target); } }
public Quaternion SetRotationLocal(Vector3 rotation, Space relativeTo = Space.Self) { if (relativeTo == Space.Self) { return(Quaternion.Euler(rotation)); } else { return(Linking.InverseTransformEuler(Quaternion.Euler(rotation), parentRot)); } }
private Tuple <int, int, int, int>[] AlmostMill(bool blackIsPlaying, Board.PlaceOnBoardIs[,] board) { Tuple <int, int, int, int>[] almostMill = new Tuple <int, int, int, int> [60]; Tuple <int, int>[] OccupiedPositions = new Tuple <int, int> [4]; Tuple <int, int> tupleOfIndexes; int helper = 0; if (blackIsPlaying) { for (short i = 0; i < 24; i++) { tupleOfIndexes = Linking.GetIndexesOnBoard(i); if (board[tupleOfIndexes.Item1, tupleOfIndexes.Item2] == Board.PlaceOnBoardIs.whiteOccupied) { OccupiedPositions = GetOccupiedPositions(tupleOfIndexes.Item1, tupleOfIndexes.Item2, Board.PlaceOnBoardIs.whiteOccupied, board); for (int j = 0; j < 4; j++) { if (OccupiedPositions[j].Item1 != -1) { almostMill[helper] = new Tuple <int, int, int, int>(tupleOfIndexes.Item1, tupleOfIndexes.Item2, OccupiedPositions[j].Item1, OccupiedPositions[j].Item2); helper++; } } } } } else { for (short i = 0; i < 24; i++) { tupleOfIndexes = Linking.GetIndexesOnBoard(i); if (board[tupleOfIndexes.Item1, tupleOfIndexes.Item2] == Board.PlaceOnBoardIs.blackOccupied) { OccupiedPositions = GetOccupiedPositions(tupleOfIndexes.Item1, tupleOfIndexes.Item2, Board.PlaceOnBoardIs.blackOccupied, board); for (int j = 0; j < 4; j++) { if (OccupiedPositions[j].Item1 != -1) { almostMill[helper] = new Tuple <int, int, int, int>(tupleOfIndexes.Item1, tupleOfIndexes.Item2, OccupiedPositions[j].Item1, OccupiedPositions[j].Item2); helper++; } } } } } return(almostMill); }
public override Vector3 GetTarget() { Vector3 target = Vector3.zero; if (space == Space.World) { target = rigidbody.velocity; } else if (space == Space.Self) { target = (parent.TransformPoint(Linking.InverseTransformPoint(parentPos + rigidbody.velocity, parentPos, parentRot)) - parent.position).normalized * rigidbody.velocity.magnitude; } return(target); }
public void Stop() { _disposed = true; Linking.Wait(); Loading.Wait(); try { _network.Disconnect(); } catch { } try { _localClient.Disconnect(); } catch { } Save(); }
public override Vector3 GetTarget() { //get target position Vector3 target = Vector3.zero; if (space == Space.World) { target = value; } else if (space == Space.Self) { if (link == Link.Offset) { if (factorScale) { target = Linking.TransformPoint(value * offsetScale, parentPos, parentRot, parentScale); //WORKS! } else { target = Linking.TransformPoint(value, parentPos, parentRot); } target = offset.ApplyPosition(this, target); } else if (link == Link.Match) { Vector3 newTarget; //if (!editorApply) // (Cannot change position while applying to parent) { SetPrevious(); //} if (factorScale) { newTarget = Linking.TransformPoint(previous * offsetScale, parent.position, parent.rotation, parent.scale); } else { newTarget = Linking.TransformPoint(previousDirection, parent.position, parent.rotation); //++++++++ ATTENTION } target = newTarget; } } return(target); }
public Vector3 SetPosition(Vector3 position, Space relativeTo = Space.Self) { //sets position and returns world position if (relativeTo == Space.Self) { if (factorScale) { return(Linking.TransformPoint(position * offsetScale, parentPos, parentRot, parentScale)); //WORKS! } else { return(Linking.TransformPoint(position, parentPos, parentRot)); //WORKS! } } else { return(position); //WORKS! } } //returns world
} //returns world public Vector3 SetPositionLocal(Vector3 position, Space relativeTo = Space.Self) { //sets position and returns local position if (relativeTo == Space.Self) { return(position); } else { if (factorScale) { return(Linking.InverseTransformPoint(position, parentPos, parentRot, parentScale /* * offsetScale*/) / offsetScale); //WORKS! } else { return(Linking.InverseTransformPoint(position, parentPos, parentRot, parentScale).Divide(parentScale)); //WORKS! } } } //returns self
public Vector3 Translate(Vector3 translation, Space relativeTo = Space.Self) { //transform translate if (relativeTo == Space.Self) { if (factorScale) { return(operationalPosition + (Linking.TransformPoint(translation * offsetScale, parentPos, parentRot, parentScale) - parentPos)); //WORKS! } else { return(Linking.TransformPoint(operationalPosition + translation, parentPos, parentRot)); //WORKS! } } else { return(operationalPosition + translation); //WORKS! } }
} //works probably public Vector3 ReversePosition(Vector3 position, Quaternion rotation, Vector3 scale, Vector3?current = null) { Vector3 newPos; if (current != null) { newPos = (Vector3)current; } else { newPos = position; } if (variety == SpaceVariety.OneSided) { foreach (AxisApplied i in axes) { if (space == Space.Self) { newPos += Linking.TransformPoint(-(Vectors.axisDirections[i.axis] * i.units), position, rotation, scale); } else { newPos += -(Vectors.axisDirections[i.axis] * i.units); } } } else if (variety == SpaceVariety.Mixed) { foreach (AxisApplied i in axes) { if (i.space == Space.Self) { newPos += Linking.TransformPoint(-(Vectors.axisDirections[i.axis] * i.units), position, rotation, scale); } else { newPos += -(Vectors.axisDirections[i.axis] * i.units); } } } return(newPos); }
public Vector3 Translate(Vector3 from, Vector3 translation, Space relativeTo = Space.Self) { //transform translate if (relativeTo == Space.Self) { if (factorScale) { return(from + (Linking.TransformPoint(translation * offsetScale, parentPos, parentRot, parentScale) - parent.position)); //WORKS! } else { //return Vectors.DivideVector3(Linking.TransformPoint(from + translation, parentPos, parentRot, parentScale), parentScale); //WORKS! return(Linking.TransformPoint(from + translation, parentPos, parentRot)); } } else { return(from + translation); //WORKS! } }
private ITfsChangeset BuildTfsChangeset(Changeset changeset, GitTfsRemote remote) { var tfsChangeset = _container.With <ITfsHelper>(this).With <IChangeset>(_bridge.Wrap <WrapperForChangeset, Changeset>(changeset)).GetInstance <TfsChangeset>(); tfsChangeset.Summary = new TfsChangesetInfo { ChangesetId = changeset.ChangesetId, Remote = remote }; if (changeset.WorkItems != null) { tfsChangeset.Summary.Workitems = changeset.WorkItems.Select(wi => new TfsWorkitem { Id = wi.Id, Title = wi.Title, Description = wi.Description, Url = Linking.GetArtifactUrl(wi.Uri.AbsoluteUri) }); } return(tfsChangeset); }
private ITfsChangeset BuildTfsChangeset(Changeset changeset, IGitTfsRemote remote) { var tfsChangeset = _container.With <ITfsHelper>(this).With <IChangeset>(_bridge.Wrap <WrapperForChangeset, Changeset>(changeset)).GetInstance <TfsChangeset>(); tfsChangeset.Summary = new TfsChangesetInfo { ChangesetId = changeset.ChangesetId, Remote = remote }; if (HasWorkItems(changeset)) { tfsChangeset.Summary.Workitems = changeset.WorkItems.Select(wi => new TfsWorkitem { Id = wi.Id, Title = wi.Title, Description = wi.Description, Url = Linking.GetArtifactUrl(wi.Uri.AbsoluteUri) }); } foreach (var checkinNote in changeset.CheckinNote.Values) { switch (checkinNote.Name) { case GitTfsConstants.CodeReviewer: tfsChangeset.Summary.CodeReviewer = checkinNote.Value; break; case GitTfsConstants.SecurityReviewer: tfsChangeset.Summary.SecurityReviewer = checkinNote.Value; break; case GitTfsConstants.PerformanceReviewer: tfsChangeset.Summary.PerformanceReviewer = checkinNote.Value; break; } } tfsChangeset.Summary.PolicyOverrideComment = changeset.PolicyOverride.Comment; return(tfsChangeset); }
public override void SetPrevious() //WORKS! { if (factorScale) { if (offsetScale != 0f) { previous = Linking.InverseTransformPoint(operationalPosition, parentPos, parentRot, parentScale) / offsetScale; previousDirection = Linking.InverseTransformPoint(operationalPosition, parentPos, parentRot) / offsetScale; } else { previous = Vector3.zero; } } else { previous = Linking.InverseTransformPoint(operationalPosition, parentPos, parentRot, parentScale); previousDirection = Linking.InverseTransformPoint(operationalPosition, parentPos, parentRot); } }
//inspector methods public override void Switch(Space newSpace, Link newLink) { Quaternion originalRotation = rotation; Quaternion originalLocalRotation = localRotation; if (space == Space.World) { if (newSpace == Space.Self) { if (newLink == Link.Offset) //world > offset { space = Space.Self; link = Link.Offset; //auto keep offset SetToTarget(); value = offset.ReverseRotation(this, Linking.InverseTransformEuler(originalRotation, parent.rotation)); } else if (newLink == Link.Match) //world > match { space = Space.Self; link = Link.Match; } } } else if (space == Space.Self) { if (link == Link.Offset) { if (newSpace == Space.World) //offset > world { space = Space.World; rotation = originalRotation; } else { if (newLink == Link.Match) //offset > match { link = Link.Match; } } } else if (link == Link.Match) { if (newSpace == Space.World) //match > world { space = Space.World; rotation = originalRotation; } else { if (newLink == Link.Offset) //match > offset { link = Link.Offset; //auto keep offset SetToTarget(); value = offset.ReverseRotation(this, Linking.InverseTransformEuler(originalRotation, parent.rotation)); } } } } }
public override void SetPrevious() { previous = Linking.InverseTransformEuler(operationalRotation, parentRot); }
//inspector methods public override void Switch(Space newSpace, Link newLink) { //switch spaces and link Vector3 originalPositon = position; Vector3 originalLocalPosition = localPosition; if (space == Space.World) { if (newSpace == Space.Self) { if (newLink == Link.Offset) //world > offset { space = Space.Self; link = Link.Offset; //auto keep offset if (factorScale) //factor scale { SetToTarget(); Vector3 from = Linking.InverseTransformPoint(position, parent.position, parent.rotation, parent.scale * offsetScale); Vector3 to = Linking.InverseTransformPoint(originalPositon, parent.position, parent.rotation, parent.scale * offsetScale); value += to - from; } else //dont factor scale { SetToTarget(); Vector3 from = Linking.InverseTransformPoint(position, parent.position, parent.rotation); Vector3 to = Linking.InverseTransformPoint(originalPositon, parent.position, parent.rotation); value += to - from; } } else if (newLink == Link.Match) //world > match { space = Space.Self; link = Link.Match; } } } else if (space == Space.Self) { if (link == Link.Offset) { if (newSpace == Space.World) //offset > world { space = Space.World; position = originalPositon; } else { if (newLink == Link.Match) //offset > match { link = Link.Match; } } } else if (link == Link.Match) { if (newSpace == Space.World) //match > world { space = Space.World; position = originalPositon; } else { if (newLink == Link.Offset) //match > offset { link = Link.Offset; //auto keep offset if (factorScale) //factor scale { SetToTarget(); Vector3 from = Linking.InverseTransformPoint(position, parent.position, parent.rotation, parent.scale * offsetScale); Vector3 to = Linking.InverseTransformPoint(originalPositon, parent.position, parent.rotation, parent.scale * offsetScale); value += to - from; } else //dont factor scale { SetToTarget(); Vector3 from = Linking.InverseTransformPoint(position, parent.position, parent.rotation); Vector3 to = Linking.InverseTransformPoint(originalPositon, parent.position, parent.rotation); value += to - from; } } } } } }
public void CopyToContext(ICompilationContext other) { Linking.CopyTo(other.Linking, other.Generator.StreamPosition); other.Generator.Write(Generator.GetBufferSpan()); }
public override void MoveToTarget() { if (enabled) { transform.position += -((transform.parent.TransformPoint(localPosition) - transform.parent.position) - (Linking.TransformPoint(localPosition, parentPos, parentRot, parentScale) - parentPos)); transform.position += -(transform.parent.position - parentPos); if (!factorScale) { transform.localPosition = transform.localPosition.Divide(parentScale.Divide(transform.parent.localScale)); } } }