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 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));
}
}
}
