private bool ForceBridgeOn(Branch b)
{
Point p = b.Last();
foreach (Point d in Grid.Directions)
{
Point onceOver = Grid.NeigbourCoordinates(p, d);
Point twiceOver = Grid.NeigbourCoordinates(onceOver, d);
if (IsBridge(p, d) && !b.Contains(twiceOver))
{
b.Add(onceOver);
//Pokud jde o horizontální směr, zapamatuj si která barva je nahoře
if (d.Y == 0)
{
Cells[onceOver.X, onceOver.Y] = Cells[p.X, p.Y];
}
b.Add(twiceOver);
if (Cells[twiceOver.X, twiceOver.Y] == Cells[p.X, p.Y])
{
b.Solved = b.Other.Solved = true;
}
else
{
Cells[twiceOver.X, twiceOver.Y] = Cells[p.X, p.Y];
}
return(true);
}
}
return(false);
}
public IEnumerator TestMinionMovement_Straight()
{
SceneManager.LoadScene("Test_MinionMovement_Straight");
//MinionPool.Reset();
yield return(null);
Node origin = new Node(0, 0);
Path path = new Path(origin, NODE_DIRECTION.RIGHT); //1
Branch testBranch = path.Branches[path.OuterBranchIDs[0]];
testBranch.Add(NODE_DIRECTION.RIGHT); //2
testBranch.Add(NODE_DIRECTION.RIGHT); //3
testBranch.Add(NODE_DIRECTION.RIGHT); //4
Node startNode = testBranch.InNode;
Assert.That(startNode.VectorLocation, Is.EqualTo(new Vector2Int(4, 0)));
Minion minion = MinionPool.Instance.GetMinion();
minion.Activate(startNode);
float travelDuration = minion.MovementInterface.MoveInterval * Node.GetDistanceToOrigin(startNode) + 1f;
yield return(new WaitForSeconds(travelDuration));
Assert.That(minion.transform.position.RoundToVector2Int(), Is.EqualTo(origin.VectorLocation));
}
//Provede na větvi vynucený pohyb, pokud existuje
private bool ForcedMove(Branch b)
{
Point p = b.Last();
//Spojí dvě větve stejné barvy, pokud sousedí
foreach (Point d in Grid.Directions)
{
Point onceOver = Grid.NeigbourCoordinates(p, d);
if (Cells[onceOver.X, onceOver.Y] == Cells[p.X, p.Y] && !b.Contains(onceOver) && !IsWall(p, d))
{
if (b.Other.Last() == onceOver)
{
b.Add(onceOver);
b.Solved = b.Other.Solved = true;
return(true);
}
}
}
//Provede pohyb, pokud je z daného místa jediný možný
List <Point> possibleDirs = Grid.Directions.Where(d => IsEmpty(p, d) && !IsBridge(p, d) && !IsWall(p, d)).ToList();
if (possibleDirs.Count == 1)
{
Point d = possibleDirs[0];
Point p1 = Grid.NeigbourCoordinates(p, d);
Cells[p1.X, p1.Y] = Cells[p.X, p.Y];
b.Add(p1);
ForceBridgeOn(b);
return(true);
}
return(false);
}
public void Test_Path_Init_GetNodesAt()
{
NODE_DIRECTION initDir = NODE_DIRECTION.UP_LEFT_RIGHT;
Path path = new Path(origin, initDir);
foreach (int id in path.OuterBranchIDs)
{
Branch outerBranch = path.Branches[id];
switch (origin.DirectionOf(outerBranch.InNode))
{
case NODE_DIRECTION.LEFT:
outerBranch.Add(NODE_DIRECTION.UP);
outerBranch.Add(NODE_DIRECTION.RIGHT);
break;
case NODE_DIRECTION.RIGHT:
outerBranch.Add(NODE_DIRECTION.UP);
outerBranch.Add(NODE_DIRECTION.LEFT);
break;
default:
break;
}
}
Assert.That(path.GetNodesAt(2, 3).Length, Is.EqualTo(initDir.GetDirections().ToArray().Length));
}
public void Test_BranchAdd_Closed()
{
Node o = new Node(2, 2);
Branch b = new Branch(1, o, NODE_DIRECTION.UP);
b.Add(NODE_DIRECTION.UP_LEFT_RIGHT);
Assert.Throws <BranchException>(() => b.Add(NODE_DIRECTION.UP));
}
public void GeenDubbeleTest()
{
var boom = new Branch <int>(10);
boom.Add(5);
boom.Add(5);
Assert.AreEqual(2, boom.Count);
Assert.AreEqual(5, boom[0]);
Assert.AreEqual(10, boom[1]);
}
static void Main()
{
IUnit root = new Branch("US (Root)");
IUnit ny = new Office("A (Unit)");
IUnit ca = new Office("B (Unit)");
if (!root.IsLeaf)
{
root.Add(ny);
root.Add(ca);
}
IUnit rootHawaii = new Branch("Canada Branch (Branch)");
if (!root.IsLeaf)
{
root.Add(rootHawaii);
}
IUnit branchUk = new Branch("UK Branch (Branch)");
IUnit ldnc = new Office("C Office (Unit)");
IUnit ldnw = new Office("D Office (Unit)");
if (!branchUk.IsLeaf)
{
branchUk.Add(ldnc);
branchUk.Add(ldnw);
}
if (!root.IsLeaf)
{
root.Add(branchUk);
}
IUnit dummy = new Office("D Office");
if (!dummy.IsLeaf)
{
ldnc.Add(dummy);
}
root.GetChild(0);
if (!root.IsLeaf)
{
root.Remove(rootHawaii);
}
if (!branchUk.IsLeaf)
{
branchUk.Remove(ldnc);
}
Console.WriteLine("Remove Hawaii branch and London City office");
root.GetChild(0);
Console.ReadKey();
}
private bool BalanceBranch2(Branch left)
{
var right = (Branch)TopNode;
if (left.KeyCount + right.KeyCount < tree.maxKeyCount)
{
// Coalesce left: move pivot and right sibling nodes.
left.AddKey(GetPivot());
for (int ix1 = 0; ; ++ix1)
{
left.Add(right.GetChild(ix1));
if (ix1 >= right.KeyCount)
{
break;
}
left.AddKey(right.GetKey(ix1));
}
left.AdjustWeight(+right.Weight);
TiltLeft(+right.Weight);
// Pivot must still be removed.
return(true);
}
// Branch underflow?
if (tree.IsUnderflow(left.ChildCount))
{
// Balance branches to keep ratio. Rotate thru the pivot.
int shifts = (left.KeyCount + right.KeyCount - 1) / 2 - left.KeyCount;
left.AddKey(GetPivot());
int delta = 0;
for (int ix2 = 0; ; ++ix2)
{
left.Add(right.GetChild(ix2));
delta += right.GetChild(ix2).Weight;
if (ix2 >= shifts)
{
break;
}
left.AddKey(right.GetKey(ix2));
}
SetPivot(right.GetKey(shifts));
right.Remove(0, shifts + 1);
left.AdjustWeight(+delta);
right.AdjustWeight(-delta);
TiltLeft(delta);
}
return(false);
}
public void BinaryTreeBranchDoesntContrainNumberDeep()
{
//Arrange
Branch <int> tree = new Branch <int>(5);
//Act
tree.Add(3);
tree.Add(7);
//Arrange
Assert.IsFalse(tree.Contains(4));
}
public void BinaryTreeBranchDoesContrainNumberDeep()
{
//Arrange
Branch <int> tree = new Branch <int>(5);
//Act
tree.Add(3);
tree.Add(7);
tree.Add(9);
tree.Add(4);
//Arrange
Assert.AreEqual(true, tree.Contains(4));
}
public void BinaryTreeBranchCount()
{
//Arrange
Branch <int> tree = new Branch <int>(5);
//Act
tree.Add(3);
tree.Add(7);
tree.Add(9);
tree.Add(4);
//Arrange
Assert.AreEqual(5, tree.Count);
}
public void BinaryTreeBranchDepth5AddsReturn()
{
//Arrange
Branch <int> tree = new Branch <int>(5);
//Act
tree.Add(4);
tree.Add(3);
tree.Add(2);
tree.Add(1);
//Arrange
Assert.AreEqual(5, tree.Depth);
}
private void Search(int StartX, int StartY, int TargetX, int TargetY)
{
foreach (var item in Map)
{
item.IsMoved = false;
}
BranchList.Clear();
OverBranch = null;
SearchEnd = false;
int MaxSearchNum = MapSizeX * MapSizeY;
Branch branch = branchPools.GetItem(null);
branch.Endx = TargetX;
branch.Endy = TargetY;
branch.Add(Map[StartX, StartY]);
BranchList.Add(branch);
int Count = 0;
for (int i = 0; i < MaxSearchNum; i++)
{
if (SearchEnd)
{
return;
}
//步进
Count = BranchList.Count;
for (int j = 0; j < Count; j++)
{
GoNext(BranchList[j]);
}
}
}
// Use this for initialization
public void Start()
{
// Build the path out to the Init Widths in the init directions.
_path = new Path(new Node(Origin.x, Origin.y), InitDirection);
// Create the initial bounding rect
Vector2Int offset = new Vector2Int(InitXWidth, InitYWidth);
Rect bound = new Rect(Origin - offset, offset + offset + Vector2Int.one);
bool building = true;
while (building)
{
building = false;
foreach (int i in _path.OuterBranchIDs)
{
Branch b = _path.Branches[i];
if (bound.Contains(b.InNode.VectorLocation))
{
// if the branch in-node is in the bounding rect, set the building flag to true and add another node.
// This logic will cause the termination of the outer while loop when all outer branches have in-nodes
// outside of the bounding rect.
building = true;
NODE_DIRECTION dir = b.InNode.OutNode.DirectionOf(b.InNode);
b.Add(dir);
}
}
}
}
public void Test_BranchAdd_Multi_Closed()
{
Node o = new Node(2, 2);
Branch b = new Branch(1, o, NODE_DIRECTION.UP);
b.Add(NODE_DIRECTION.UP_LEFT_RIGHT);
Assert.That(!b.Open);
}
public void Test_BranchAdd_Multi_InNode()
{
Node o = new Node(2, 2);
Branch b = new Branch(1, o, NODE_DIRECTION.UP);
b.Add(NODE_DIRECTION.UP_LEFT_RIGHT);
Vector2Int ex = new Vector2Int(2, 3);
Assert.That(b.InNode.VectorLocation, Is.EqualTo(ex));
}
public void OnCallStart(Call call)
{
for (int i = 0; i < call.Options.Count; i++)
{
var button = ImageTextButtonFactory.Create(call.Options[i].Description, Vector2.Zero, call.Options[i].Go);
var smartButton = new SmartControl(button, (int)ClickUIPriorities.Pad);
_choices.Add(smartButton);
_grid.AddSpatial(smartButton, button.Transform, i + 1, 1);
Branch.Add(smartButton.Branch);
}
}
public void Test_BranchAdd_Multi_Return()
{
Node o = new Node(2, 2);
Branch b = new Branch(1, o, NODE_DIRECTION.UP);
NODE_DIRECTION[] act = b.Add(NODE_DIRECTION.UP_LEFT_RIGHT);
NODE_DIRECTION[] ex = { NODE_DIRECTION.UP, NODE_DIRECTION.LEFT, NODE_DIRECTION.RIGHT };
Assert.That(act, Is.EqualTo(ex));
}
public void BinaryTreeBranchIEnumerableLowest()
{
//Arrange
Branch <int> tree = new Branch <int>(5);
tree.Add(4);
tree.Add(3);
tree.Add(2);
tree.Add(1);
tree.Add(6);
int[] values = { 5, 4, 3, 2, 1, 6 };
int min;
//act
min = tree.Min();
//Arrange
Assert.AreEqual(1, min);
}
/// <summary>
/// Gets the branches details.
/// </summary>
/// <param name="countryId">The country identifier.</param>
/// <param name="cultureInfo">The culture information.</param>
/// <returns></returns>
public async Task GetBranchesDetails(int countryId, string cultureInfo)
{
try
{
SetActivityIndicatorBlurred(true);
ActOpacity = 1;
MainStackLayout = false;
PackingCygestPageLayoutOpacity = 0.4;
Status = "Loading data...";
var connected = CrossConnectivity.Current.IsConnected;
if (connected)
{
Branch = await _branchService.GetBranchDetailsAsync(countryId, cultureInfo, BrandId);
if (Branch.Count == 0 && _appViewModel.DefaultedCultureInfo != "fr-FR")
{
BranchModel tempBranch = new BranchModel
{
Id = 0,
Code = "Unknown",
Name = "Unknown"
};
Branch.Add(tempBranch);
}
else
{
BranchModel tempBranch = new BranchModel
{
Id = 0,
Code = "Inconnu",
Name = "Inconnu"
};
Branch.Add(tempBranch);
}
SetActivityIndicatorBlurred(false);
MainStackLayout = true;
PackingCygestPageLayoutOpacity = 1;
Status = "";
}
}
catch (Exception e)
{
await _pageService.DisplayAlert(LblError, LblNoConnection, LblOk);
DatabaseAccessAsync da = new DatabaseAccessAsync();
da.InsertException(new PackingCygestExceptionModel
{
Message = e.Message, StackTrace = e.StackTrace, TimeSpan = DateTime.Today.ToString(System.Globalization.CultureInfo.CurrentCulture), MethodName = e.Source
});
}
}
public void BinaryTreeWaardeToevoegenTweedeMaalLager()
{
//Arrange
Branch <int> tree = new Branch <int>(4);
//Act
tree.Add(3);
//Arrange
Assert.IsInstanceOfType(tree.LeftChild, typeof(Branch <int>));
Assert.AreEqual(3, (tree.LeftChild as Branch <int>).Value);
}
public void BinaryTreeBranchAbstraction()
{
//Arrange
Branch <int> tree = new Branch <int>(4);
//Act
tree.Add(3);
//Arrange
Assert.IsInstanceOfType(tree.LeftChild, typeof(Branch <int>));
Assert.AreEqual(3, (tree.LeftChild as Branch <int>).Value);
}
public IEnumerator Test_TowerAttacks_MinionsDieCorrectly()
{
SceneManager.LoadScene("Test_TowerAttacks_Aggro");
yield return(null);
GameObject tower = GameObject.Find("test_tower");
TowerAggro towerAgg = tower.GetComponentInChildren <TowerAggro>();
Node origin = new Node(0, 0);
Path path = new Path(origin, NODE_DIRECTION.RIGHT); //1
Branch testBranch = path.Branches[path.OuterBranchIDs[0]];
testBranch.Add(NODE_DIRECTION.RIGHT); //2
testBranch.Add(NODE_DIRECTION.RIGHT); //3
testBranch.Add(NODE_DIRECTION.RIGHT); //4
testBranch.Add(NODE_DIRECTION.RIGHT); //5
testBranch.Add(NODE_DIRECTION.RIGHT); //6
testBranch.Add(NODE_DIRECTION.RIGHT); //7
testBranch.Add(NODE_DIRECTION.RIGHT); //8
testBranch.Add(NODE_DIRECTION.RIGHT); //9
testBranch.Add(NODE_DIRECTION.RIGHT); //10
Node startNode = testBranch.InNode;
Minion minion = MinionPool.Instance.GetMinion();
minion.Activate(startNode);
float secondMinionSpawnDelay = 2.0f;
yield return(new WaitForSeconds(secondMinionSpawnDelay));
Minion minion2 = MinionPool.Instance.GetMinion();
minion2.Activate(startNode);
float travelDuration = minion.MovementInterface.MoveInterval * Node.GetDistanceToOrigin(startNode) + 1f - secondMinionSpawnDelay;
yield return(new WaitForSeconds(travelDuration));
Assert.That(towerAgg.Targets.Count, Is.EqualTo(0));
Assert.That(!minion.Alive);
}
public Models.Address.Abstract.BaseAssembly Populate(Models.Address.Abstract.BaseAssembly root)
{
for (int i = 0; i < 5; i++)
{
Branch x = new Branch("Name " + i.ToString());
for (int j = 0; j < 5; j++)
{
x.Add(new Leaf("Name " + j.ToString()));
}
root.Add(x);
}
return(root);
}
public void BinaryTreeBranchIEnumerableLoop()
{
//Arrange
Branch <int> tree = new Branch <int>(5);
tree.Add(4);
tree.Add(3);
tree.Add(2);
tree.Add(1);
tree.Add(6);
int count = 0;
int[] values = { 1, 2, 3, 4, 5, 6 };
//Assert
foreach (var item in tree)
{
Assert.AreEqual(values[count], item, $"{count} failed");
count++;
}
}
void MoveTo(Branch branch, int x, int y)
{
branch.Add(Map[x, y]);
if (isEnd(x, y, branch.Endx, branch.Endy))
{
SearchEnd = true;
OverBranch = branch;
return;
}
if (!BranchList.Contains(branch))
{
BranchList.Add(branch);
}
}
public void Test_Path_Branch_PostOuterBranchIDCount()
{
NODE_DIRECTION initDir = NODE_DIRECTION.UP, branchDir = NODE_DIRECTION.UP_LEFT_RIGHT;
Path path = new Path(origin, initDir);
int initBranchId = path.OuterBranchIDs[0];
Branch initBranch = path.Branches[initBranchId];
initBranch.Add(branchDir);
path.Branch(initBranchId);
Assert.That(path.OuterBranchIDs.Count, Is.EqualTo(3));
}
public void Test_Path_Branch_PostOuterBranchIDGone()
{
NODE_DIRECTION initDir = NODE_DIRECTION.UP, branchDir = NODE_DIRECTION.UP_LEFT_RIGHT;
Path path = new Path(origin, initDir);
int initBranchId = path.OuterBranchIDs[0];
Branch initBranch = path.Branches[initBranchId];
initBranch.Add(branchDir);
path.Branch(initBranchId);
Assert.That(path.OuterBranchIDs, !Contains.Item(initBranchId));
}
private static void UnFlattenHelper <T>(Dictionary <int, List <int> > skeleton, T[] meat, int parentIndex, Branch <T> parent)
{
if (skeleton.ContainsKey(parentIndex))
{
List <int> parentList = skeleton[parentIndex];
for (int i = 0; i < parentList.Count; i++)
{
int j = parent.Add(meat[parentList[i]]);
UnFlattenHelper(skeleton, meat, parentList[i], parent.Get(j));
}
}
else
{
//pass, this node has no children and will die alone.
}
}
private Node FillBranches(Branch branch, IElementBase previousElement, IElementBase element, List <IElementBase> passedElements)
{
branch.Add(element);
passedElements.Add(element); // мб сократить кол во вызовов add
foreach (var pin in element.Pins)
{
if (!previousElement.Equals(pin.ConnectedPin.Element))
{
if (pin.ConnectedPin.Element is Node)
{
branch.Node_2 = pin.ConnectedPin.Element as Node;
return(pin.ConnectedPin.Element as Node);
}
else
{
return(FillBranches(branch, element, pin.ConnectedPin.Element, passedElements));
}
}
}
throw new InvalidOperationException(); // Схема не замкнута?
}
