public Cell FindEnemyNextBlankCell(Cell currentCell, TraversalDirection traversalDirection)
{
Cell lastEnemyCell = null;
while (true)
{
var targetCell = GetNextCell(currentCell, traversalDirection);
if (targetCell == null)
{
break;
}
currentCell = targetCell;
if (lastEnemyCell != null &&
targetCell.OccupiedColor == PlayerColor.None)
{
return(targetCell);
}
if (targetCell.OccupiedColor == playerColor)
{
return(null);
}
if (targetCell.OccupiedColor != PlayerColor.None &&
targetCell.OccupiedColor != playerColor)
{
lastEnemyCell = targetCell;
}
}
return(null);
}
public Cell GetNextCell(Cell currentCell, TraversalDirection traversalDirection)
{
int adjX = 0, adjY = 0;
switch (traversalDirection)
{
case TraversalDirection.Top:
adjY -= 1;
break;
case TraversalDirection.Bottom:
adjY += 1;
break;
case TraversalDirection.Left:
adjX -= 1;
break;
case TraversalDirection.Right:
adjX += 1;
break;
}
if (!map.CheckValidCellPosition(currentCell.X + adjX, currentCell.Y + adjY))
{
return(null);
}
return(map[currentCell.X + adjX, currentCell.Y + adjY]);
}
public _DirectionalPolicyDataEntry(
TraversalDirection direction,
FocusNode node)
{
this.direction = direction;
this.node = node;
}
/* bool Traversal(GridNode node , TraversalDirection dir,Vector2 size,int leftcount,int topcount)
* {
* if(node == null)return false;
*
* if(node.isFilled)return false;
*
* if(leftcount>=size.x)return true;
*
* leftcount++;
*
* return Traversal(GetNode(node,TraversalDirection.LEFT),TraversalDirection.LEFT,size ,leftcount,topcount);
*
*
* if(topcount>=size.y-1)return true;
*
* topcount++;
* leftcount =0;
*
* return Traversal(GetNode(node,TraversalDirection.TOP),TraversalDirection.TOP,size ,leftcount,topcount);
*
* }*/
bool Traversal(GridNode node, TraversalDirection dir, int toplimit, int limit, int traversalCount)
{
if (node == null)
{
return(false);
}
Debug.Log("***********************node" + node.row + "," + node.Column);
if (node.isFilled)
{
return(false);
}
bool leftcheck = SubTraversal(GetNode(node, TraversalDirection.RIGHT), TraversalDirection.RIGHT, limit, 1);
if (!leftcheck)
{
return(false);
}
if (traversalCount >= toplimit - 1)
{
return(true);
}
traversalCount++;
return(Traversal(GetNode(node, TraversalDirection.TOP), TraversalDirection.TOP, toplimit, limit, traversalCount));
}
public FileSystemItem(FileSystemInfo fileSystemInfo, TraversalDirection traversalDirection = TraversalDirection.Down)
{
TraversalDirection = traversalDirection;
_fileSystemInfo = fileSystemInfo;
IsDirectory = _fileSystemInfo is DirectoryInfo;
if (IsDirectory)
{
if ((Attributes & FileAttributes.System) != 0)
{
IconType = IconType.RestricedDirectory;
}
else
{
IconType = IconType.Directory;
}
}
else
{
if ((Attributes & FileAttributes.System) != 0)
{
IconType = IconType.RestrictedFile;
}
else
{
IconType = IconType.File;
}
}
}
public IEnumerable <FocusNode> _sortAndFilterHorizontally(
TraversalDirection direction,
Rect target,
FocusNode nearestScope)
{
D.assert(direction == TraversalDirection.left || direction == TraversalDirection.right);
IEnumerable <FocusNode> nodes = nearestScope.traversalDescendants;
D.assert(!nodes.Contains(nearestScope));
List <FocusNode> sorted = nodes.ToList();
FocusTravesalUtils.mergeSort <FocusNode>(sorted, compare: (FocusNode a, FocusNode b) => a.rect.center.dx.CompareTo(b.rect.center.dx));
IEnumerable <FocusNode> result = new List <FocusNode>();
switch (direction)
{
case TraversalDirection.left:
result = LinqUtils <FocusNode> .WhereList(sorted, ((FocusNode node) => node.rect != target && node.rect.center.dx <= target.left));
break;
case TraversalDirection.right:
result = LinqUtils <FocusNode> .WhereList(sorted, ((FocusNode node) => node.rect != target && node.rect.center.dx >= target.right));
break;
case TraversalDirection.up:
case TraversalDirection.down:
break;
}
return(result);
}
private IEnumerable <T> BreadthFirstEnumerable(TraversalDirection direction)
{
if (direction == TraversalDirection.TopDown)
{
var queue = new Queue <T>();
queue.Enqueue(this as T);
while (0 < queue.Count)
{
var node = queue.Dequeue();
foreach (var child in node._children)
{
queue.Enqueue(child);
}
yield return(node);
}
yield break;
}
var stack = new Stack <T>();
foreach (var node in BreadthFirstEnumerable(TraversalDirection.TopDown))
{
stack.Push(node);
}
while (stack.Count > 0)
{
yield return(stack.Pop());
}
}
public GridNode GetNextNode(GridNode node, TraversalDirection dir)
{
if (node == null)
{
return(null);
}
GridNode n = null;
switch (dir)
{
case TraversalDirection.TOP:
n = node.top;
break;
case TraversalDirection.BOTTOM:
n = node.bottom;
break;
case TraversalDirection.LEFT:
n = node.left;
break;
case TraversalDirection.RIGHT:
n = node.right;
break;
}
return(n);
}
private void MovingObstacle()
{
int count = 20;
TraversalDirection direction = TraversalDirection.LEFT;
GridNode node = CheckforScopeToMove(direction, count);
if (node == null)
{
direction = TraversalDirection.RIGHT;
node = CheckforScopeToMove(direction, count);
}
if (node == null)
{
direction = TraversalDirection.TOP;
node = CheckforScopeToMove(direction, count);
}
if (node == null)
{
direction = TraversalDirection.BOTTOM;
node = CheckforScopeToMove(direction, count);
}
if (node != null)
{
GameObject movingObs = gridManager.InstantiateObstacle(staticObstacleprefab_0, node, PoolManager.GetInstance().GetPoolContainer(false));
SnakeBlock block = movingObs.AddComponent <SnakeBlock>();
StartCoroutine(MoveObstacle(block, node, direction, count));
}
}
internal void SetNewLocation(NativeString64 roadId, int laneSectionIdx, int laneId,
TraversalDirection direction)
{
RoadId = roadId;
LaneSectionIdx = laneSectionIdx;
LaneId = laneId;
Direction = direction;
if (!AllRoadIds.HasBeenTraversed(roadId))
{
AllRoadIds.Traverse(roadId);
}
}
private static int GetNextLaneId(Lane laneCurrent, TraversalDirection direction)
{
var links = direction == TraversalDirection.Forward ? laneCurrent.link.successors : laneCurrent.link.predecessors;
// Check to see if current lane terminates
if (!links.Any())
{
// Zero is guaranteed to never be a valid lane value as the center is not a drivable lane
return(0);
}
// TODO: We need to deal with the fact that sometimes there will be multiple connections
return(links.First());
}
public IEnumerable <T> GetEnumerable(TraversalMode mode, TraversalDirection direction)
{
switch (mode)
{
case TraversalMode.DepthFirst:
return(DepthFirstEnumerable(direction));
case TraversalMode.BreadthFirst:
return(BreadthFirstEnumerable(direction));
default:
return(null);
}
}
TraversalDirection GetReverseDirection(TraversalDirection dir)
{
switch (dir)
{
case TraversalDirection.LEFT: return(TraversalDirection.RIGHT);
case TraversalDirection.RIGHT: return(TraversalDirection.LEFT);
case TraversalDirection.TOP: return(TraversalDirection.BOTTOM);
case TraversalDirection.BOTTOM: return(TraversalDirection.TOP);
}
return(TraversalDirection.NONE);
}
private Cube traverseIterative(Point start, ref bool[,] visited, System.Drawing.Color color, Cube cube = null)
{
TraversalDirection direction = TraversalDirection.None;
Cube current = cube ?? new Cube();
direction = traversePixels(ref start, visited, color, current);
while (direction != TraversalDirection.None)
{
direction = traversePixels(ref start, visited, color, current);
}
return(current);
}
private GridNode CheckforScopeToMove(TraversalDirection dir, int count)
{
GridNode node = gridManager.GetRandomPosition();
GridNode n = node;
for (int i = 0; i < count; i++)
{
node = gridManager.GetNextNode(node, dir);
if (node.isFilled)
{
return(null);
}
}
return(n);
}
private void GetInputFromPlayer(DIRECTION dir, Vector3 start, Vector3 end)
{
switch (dir)
{
case DIRECTION.UP:
if (currentDirection != TraversalDirection.BOTTOM)
{
currentDirection = TraversalDirection.TOP;
}
goto default;
case DIRECTION.DOWN:
if (currentDirection != TraversalDirection.TOP)
{
currentDirection = TraversalDirection.BOTTOM;
}
goto default;
case DIRECTION.LEFT:
if (currentDirection != TraversalDirection.RIGHT)
{
currentDirection = TraversalDirection.LEFT;
}
goto default;
case DIRECTION.RIGHT:
if (currentDirection != TraversalDirection.LEFT)
{
currentDirection = TraversalDirection.RIGHT;
}
goto default;
default:
//VFX
if (GameState == GAMESTATE.INITILIZECOMPLETE)
{
snakeController.SetPosition(currentNode);
GameState = GAMESTATE.GAMEPLAY;
}
VFXManager.OnInputLineVFX(start, end);
break;
}
}
public override FocusNode findFirstFocusInDirection(FocusNode currentNode, TraversalDirection direction)
{
D.assert(direction != null);
D.assert(currentNode != null);
switch (direction)
{
case TraversalDirection.up:
return(_sortAndFindInitial(currentNode, vertical: true, first: false));
case TraversalDirection.down:
return(_sortAndFindInitial(currentNode, vertical: true, first: true));
case TraversalDirection.left:
return(_sortAndFindInitial(currentNode, vertical: false, first: false));
case TraversalDirection.right:
return(_sortAndFindInitial(currentNode, vertical: false, first: true));
}
return(null);
}
internal static void BuildSamplesInsideLaneSection(
EcsRoadData road, int laneId, int numSamplesSection, int outputIdx, TraversalDirection samplingDirection,
ref SamplingStateEcsRoad samplingState, ref NativeArray <PointSampleGlobal> samplesOut)
{
var numSamplesOut = samplesOut.Length;
var numEdgesToSample = math.abs(laneId);
var numSamplesEdge = numEdgesToSample == 0 ? numSamplesOut : numSamplesOut * numEdgesToSample;
// We will need to sample the center line as well, if we are not between two lane edges
var shouldSampleCenter = numEdgesToSample <= 1;
var samplesEdges = new NativeArray <PointSampleGlobal>(numSamplesEdge, Allocator.Temp);
var side = ToSide(laneId);
var sectionStart = samplingDirection == TraversalDirection.Forward ? outputIdx : numSamplesSection + outputIdx - 1;
for (var sampleNum = 0; sampleNum < numSamplesSection; sampleNum++)
{
var sampleIdx = sectionStart + sampleNum * (int)samplingDirection;
var sRoad = samplingState.sRoadLastComputed;
SampleLanesOneSide(road, samplingState, side, sRoad, sampleIdx, ref samplesEdges,
numEdgesToSample);
// Lane index is lane ID - 1 because ID's start at 1, not 0
var laneSampleIdx = ComputeLaneSampleIdx(numEdgesToSample - 1, numSamplesOut, sampleIdx);
var poseOuterEdge = samplesEdges[laneSampleIdx].pose;
RigidTransform poseInnerEdge;
if (shouldSampleCenter)
{
poseInnerEdge = SampleCenter(road, samplingState, sRoad).pose;
}
else
{
var innerEdgeIdx = ComputeLaneSampleIdx(numEdgesToSample - 2, numSamplesOut, sampleIdx);
poseInnerEdge = samplesEdges[innerEdgeIdx].pose;
}
var positionMean = math.lerp(poseInnerEdge.pos, poseOuterEdge.pos, 0.5f);
var rotationMean = math.nlerp(poseInnerEdge.rot, poseOuterEdge.rot, 0.5f);
samplesOut[sampleIdx] = new PointSampleGlobal(rotationMean, positionMean);
samplingState.Step(road);
}
samplesEdges.Dispose();
}
IEnumerator MoveObstacle(SnakeBlock block, GridNode node, TraversalDirection dir, int moveCount)
{
int count = 0;
while (_cacheState == GAMESTATE.INITILIZECOMPLETE || _cacheState == GAMESTATE.GAMEPLAY)
{
if (count >= moveCount)
{
count = 0;
dir = GetReverseDirection(dir);
}
node = gridManager.GetNextNode(node, dir);
if (node.isFilled)
{
GameManager.OnGameStateChangeByOther(GAMESTATE.GAMEEND);
}
block.SetPosition(node);
count++;
yield return(new WaitForSeconds((1 / movingObstaclespeed)));
}
}
private IEnumerable <T> DepthFirstEnumerable(TraversalDirection direction)
{
if (direction == TraversalDirection.TopDown)
{
yield return(this as T);
}
foreach (var child in _children)
{
var childEnumerator = child.DepthFirstEnumerable(direction).GetEnumerator();
while (childEnumerator.MoveNext())
{
yield return(childEnumerator.Current);
}
}
if (direction == TraversalDirection.BottomUp)
{
yield return(this as T);
}
}
bool SubTraversal(GridNode node, TraversalDirection dir, int limit, int traversalCount)
{
if (node == null)
{
return(false);
}
Debug.Log("***********************node" + node.row + "," + node.Column);
if (node.isFilled)
{
return(false);
}
if (traversalCount >= limit - 1)
{
return(true);
}
traversalCount++;
return(SubTraversal(GetNode(node, dir), dir, limit, traversalCount));
}
public void _pushPolicyData(TraversalDirection direction, FocusScopeNode nearestScope, FocusNode focusedChild)
{
_DirectionalPolicyData policyData = _policyData[nearestScope];
if (policyData != null && !(policyData is _DirectionalPolicyData))
{
return;
}
_DirectionalPolicyDataEntry newEntry = new _DirectionalPolicyDataEntry(node: focusedChild, direction: direction);
if (policyData != null)
{
policyData.history.Add(newEntry);
}
else
{
_policyData[nearestScope] = new _DirectionalPolicyData(history: new List <_DirectionalPolicyDataEntry>()
{
newEntry
});
}
}
private bool IsValideMove(TraversalDirection dir)
{
currentNode = gridManager.GetNextNode(currentNode, dir);
if (currentNode == null)
{
return(false);
}
if (currentNode.isFilled)
{
return(false);
}
snakeController.SetPosition(currentNode);
if (fruitNode == currentNode)
{
SoundManager.AudioPlayEvent(ConstantsList.Sfx_Collect);
Score++;
snakeIntialSpeed -= Time.deltaTime * snakespeedIncreaserate;
snakeController.GenerateTail();
gridManager.SetCollectObject(fruitObj, PoolManager.GetInstance().GetPoolContainer(false), false, out fruitNode);
}
return(true);
}
IEnumerable <DoublyLinkedNode <TElement> > Traverse(TraversalDirection direction)
{
if (direction == TraversalDirection.Forwards)
{
var enumerator = this.Head;
while (enumerator != null)
{
yield return(enumerator);
enumerator = enumerator.Next;
}
}
else
{
var enumerator = this.Tail;
while (enumerator != null)
{
yield return(enumerator);
enumerator = enumerator.Previous;
}
}
}
public IEnumerable <FocusNode> _sortAndFilterVertically(
TraversalDirection direction,
Rect target,
IEnumerable <FocusNode> nodes)
{
List <FocusNode> sorted = nodes.ToList();
FocusTravesalUtils.mergeSort <FocusNode>(sorted, compare: (FocusNode a, FocusNode b) => a.rect.center.dy.CompareTo(b.rect.center.dy));
switch (direction)
{
case TraversalDirection.up:
return(LinqUtils <FocusNode> .WhereList(sorted, ((FocusNode node) => node.rect != target && node.rect.center.dy <= target.top)));
case TraversalDirection.down:
return(LinqUtils <FocusNode> .WhereList(sorted, ((FocusNode node) => node.rect != target && node.rect.center.dy >= target.bottom)));
case TraversalDirection.left:
case TraversalDirection.right:
break;
}
D.assert(direction == TraversalDirection.up || direction == TraversalDirection.down);
return(null);
}
/// <summary>
///
/// </summary>
/// <param name="activity"></param>
/// <param name="dir"></param>
/// <remarks>Corresponds to SB.2.4 in the SCORM 2004 Sequencing/Navigation manual, appendix C.</remarks>
private void ChoiceActivityTraversal(Activity activity, TraversalDirection dir)
{
if(dir == TraversalDirection.Forward)
{
if(SequencingRulesCheck(activity, activity.Sequencing.PreConditionRules, SequencingRuleAction.StopForwardTraversal))
{
throw new SequencingException(SequencingExceptionCode.SB_2_4__1);
}
}
else
{
Utilities.Assert(dir == TraversalDirection.Backward);
if(activity.Parent != null)
{
if(activity.Parent.Sequencing.ForwardOnly)
{
throw new SequencingException(SequencingExceptionCode.SB_2_4__2);
}
}
else
{
// Cannot walk backward from the root of the activity tree
throw new SequencingException(SequencingExceptionCode.SB_2_4__3);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="activity"></param>
/// <param name="dir"></param>
/// <param name="considerChildren"></param>
/// <param name="previousDirection"></param>
/// <param name="newDirection"></param>
/// <returns></returns>
/// <remarks>Corresponds to SB.2.1 in the SCORM 2004 Sequencing/Navigation manual, appendix C.</remarks>
private Activity FlowTreeTraversal(Activity activity, TraversalDirection dir, bool considerChildren, TraversalDirection previousDirection, out TraversalDirection newDirection)
{
bool reversed = false;
// Test if we have skipped all of the children in a forward only cluster moving backward
if(previousDirection == TraversalDirection.Backward && activity.Parent != null && activity.Next == null)
{
dir = TraversalDirection.Backward;
activity = (Activity)activity.Parent.Children[0];
reversed = true;
}
if(dir == TraversalDirection.Forward)
{
// Cannot walk off the activity tree
if(activity.IsLastActivityInTree)
{
throw new SequencingException(SequencingExceptionCode.SB_2_1__1);
}
if(activity.IsLeaf || !considerChildren)
{
if(activity.Next == null)
{
// Recursion - Move to the activity's parent's next forward sibling
return FlowTreeTraversal(activity.Parent, TraversalDirection.Forward, false, TraversalDirection.NotApplicable, out newDirection);
}
else
{
newDirection = dir;
return activity.Next;
}
}
else // Entering a cluster - Forward
{
if(activity.IsLeaf)
{
throw new SequencingException(SequencingExceptionCode.SB_2_1__2);
}
ApplyRandomization(activity);
newDirection = dir;
return (Activity)activity.Children[0];
}
}
else // direction is backwards
{
Utilities.Assert(dir == TraversalDirection.Backward);
if(activity.Parent == null) // Cannot walk off the root of the activity tree
{
throw new SequencingException(SequencingExceptionCode.SB_2_1__3);
}
if(activity.IsLeaf || !considerChildren)
{
if(!reversed) // Only test 'forward only' if we are not going to leave this forward only cluster.
{
if(activity.Parent.Sequencing.ForwardOnly) // Test the control mode before traversing
{
throw new SequencingException(SequencingExceptionCode.SB_2_1__4);
}
}
if(activity.Previous == null)
{
// Recursion - Move to the activity's parent's next backward sibling
return FlowTreeTraversal(activity.Parent, TraversalDirection.Backward, false, TraversalDirection.NotApplicable, out newDirection);
}
else
{
newDirection = dir;
return activity.Previous;
}
}
else // Entering a cluster - Backward
{
if(activity.IsLeaf)
{
throw new SequencingException(SequencingExceptionCode.SB_2_1__2);
}
ApplyRandomization(activity);
if(activity.Sequencing.ForwardOnly)
{
// Start at the beginning of a forward only cluster
newDirection = TraversalDirection.Forward;
return (Activity)activity.Children[0];
}
else
{
// Start at the end of the cluster if we are backing into it
newDirection = TraversalDirection.Backward;
return (Activity)activity.Children[activity.Children.Count - 1];
}
}
}
}
public override bool inDirection(FocusNode currentNode, TraversalDirection direction)
{
FocusScopeNode nearestScope = currentNode.nearestScope;
FocusNode focusedChild = nearestScope.focusedChild;
if (focusedChild == null)
{
FocusNode firstFocus = findFirstFocusInDirection(currentNode, direction) ?? currentNode;
switch (direction)
{
case TraversalDirection.up:
case TraversalDirection.left:
FocusTravesalUtils._focusAndEnsureVisible(
firstFocus,
alignmentPolicy: ScrollPositionAlignmentPolicy.keepVisibleAtStart
);
break;
case TraversalDirection.right:
case TraversalDirection.down:
FocusTravesalUtils._focusAndEnsureVisible(
firstFocus,
alignmentPolicy: ScrollPositionAlignmentPolicy.keepVisibleAtEnd
);
break;
}
return(true);
}
if (_popPolicyDataIfNeeded(direction, nearestScope, focusedChild))
{
return(true);
}
FocusNode found = null;
ScrollableState focusedScrollable = Scrollable.of(focusedChild.context);
switch (direction)
{
case TraversalDirection.down:
case TraversalDirection.up:
IEnumerable <FocusNode> eligibleNodes = _sortAndFilterVertically(
direction,
focusedChild.rect,
nearestScope.traversalDescendants
);
if (focusedScrollable != null && !focusedScrollable.position.atEdge())
{
IEnumerable <FocusNode> filteredEligibleNodes = LinqUtils <FocusNode> .WhereList(eligibleNodes, ((FocusNode node) => Scrollable.of(node.context) == focusedScrollable));
if (filteredEligibleNodes.Count() != 0)
{
eligibleNodes = filteredEligibleNodes;
}
}
if (eligibleNodes.Count() == 0)
{
break;
}
List <FocusNode> sorted = eligibleNodes.ToList();
if (direction == TraversalDirection.up)
{
//sorted = sorted.reversed.toList();
sorted.Reverse();
sorted = sorted.ToList();
}
Rect band = Rect.fromLTRB(focusedChild.rect.left, float.NegativeInfinity, focusedChild.rect.right, float.PositiveInfinity);
IEnumerable <FocusNode> inBand = LinqUtils <FocusNode> .WhereList(sorted, ((FocusNode node) => !node.rect.intersect(band).isEmpty));
if (inBand.Count() != 0)
{
found = inBand.First();
break;
}
FocusTravesalUtils.mergeSort <FocusNode>(sorted, compare: (FocusNode a, FocusNode b) => {
return((a.rect.center.dx - focusedChild.rect.center.dx).abs().CompareTo((b.rect.center.dx - focusedChild.rect.center.dx).abs()));
});
found = sorted.First();
break;
case TraversalDirection.right:
case TraversalDirection.left:
eligibleNodes = _sortAndFilterHorizontally(direction, focusedChild.rect, nearestScope);
if (focusedScrollable != null && !focusedScrollable.position.atEdge())
{
IEnumerable <FocusNode> filteredEligibleNodes = LinqUtils <FocusNode> .WhereList(eligibleNodes, ((FocusNode node) => Scrollable.of(node.context) == focusedScrollable));
if (filteredEligibleNodes.Count() != 0)
{
eligibleNodes = filteredEligibleNodes;
}
}
if (eligibleNodes.Count() == 0)
{
break;
}
sorted = eligibleNodes.ToList();
if (direction == TraversalDirection.left)
{
sorted.Reverse();
sorted = sorted.ToList();
//sorted = sorted.reversed.toList();
}
band = Rect.fromLTRB(float.NegativeInfinity, focusedChild.rect.top, float.PositiveInfinity, focusedChild.rect.bottom);
inBand = LinqUtils <FocusNode> .WhereList(sorted, ((FocusNode node) => !node.rect.intersect(band).isEmpty));
if (inBand.Count() != 0)
{
found = inBand.First();
break;
}
FocusTravesalUtils.mergeSort <FocusNode>(sorted, compare: (FocusNode a, FocusNode b) => {
return((a.rect.center.dy - focusedChild.rect.center.dy).abs().CompareTo((b.rect.center.dy - focusedChild.rect.center.dy).abs()));
});
found = sorted.First();
break;
}
if (found != null)
{
_pushPolicyData(direction, nearestScope, focusedChild);
switch (direction)
{
case TraversalDirection.up:
case TraversalDirection.left:
FocusTravesalUtils._focusAndEnsureVisible(
found,
alignmentPolicy: ScrollPositionAlignmentPolicy.keepVisibleAtStart
);
break;
case TraversalDirection.down:
case TraversalDirection.right:
FocusTravesalUtils._focusAndEnsureVisible(
found,
alignmentPolicy: ScrollPositionAlignmentPolicy.keepVisibleAtEnd
);
break;
}
return(true);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="activity"></param>
/// <param name="dir"></param>
/// <param name="previousDirection"></param>
/// <returns></returns>
/// <remarks>Corresponds to SB.2.2 in the SCORM 2004 Sequencing/Navigation manual, appendix C.</remarks>
private Activity FlowActivityTraversal(Activity activity, TraversalDirection dir, TraversalDirection previousDirection)
{
Resources.Culture = LocalizationManager.GetCurrentCulture();
if(!activity.Parent.Sequencing.Flow)
{
throw new SequencingException(SequencingExceptionCode.SB_2_2__1);
}
if(SequencingRulesCheck(activity, activity.Sequencing.PreConditionRules, SequencingRuleAction.Skip))
{
m_navigator.LogSequencing(SequencingEventType.IntermediateNavigation, m_command, Resources.SequencingPreConditionSkipped, activity.Key);
TraversalDirection newDirection;
Activity newActivity = FlowTreeTraversal(activity, dir, false, previousDirection, out newDirection);
m_navigator.LogSequencing(SequencingEventType.IntermediateNavigation, m_command, Resources.SequencingFlowingTo, newActivity.Key);
// Make sure the recursive call is considers the correct direction
if(previousDirection == TraversalDirection.Backward && newDirection == TraversalDirection.Backward)
{
// Recursive call - make sure the "next" activity is OK
newActivity = FlowActivityTraversal(newActivity, newDirection, TraversalDirection.NotApplicable);
}
else
{
// Recursive call - make sure the "next" activity is OK
newActivity = FlowActivityTraversal(newActivity, newDirection, previousDirection);
}
return newActivity;
}
if(CheckActivity(activity))
{
throw new SequencingException(SequencingExceptionCode.SB_2_2__2);
}
if(!activity.IsLeaf)
{
TraversalDirection newDirection;
Activity newActivity = FlowTreeTraversal(activity, dir, true, TraversalDirection.NotApplicable, out newDirection);
m_navigator.LogSequencing(SequencingEventType.IntermediateNavigation, m_command, Resources.SequencingFlowingTo, newActivity.Key);
// Check if we are flowing backward through a forward only cluster - must move forward instead
if(dir == TraversalDirection.Backward && newDirection == TraversalDirection.Forward)
{
// Recursive call - make sure the "next" activity is OK
newActivity = FlowActivityTraversal(newActivity, TraversalDirection.Forward, TraversalDirection.Backward);
}
else
{
// Recursive call - make sure the "next" activity is OK
newActivity = FlowActivityTraversal(newActivity, dir, TraversalDirection.NotApplicable);
}
return newActivity;
}
return activity;
}
public bool _popPolicyDataIfNeeded(TraversalDirection direction, FocusScopeNode nearestScope, FocusNode focusedChild)
{
_DirectionalPolicyData policyData = _policyData[nearestScope];
if (policyData != null && policyData.history.isNotEmpty() && policyData.history.First().direction != direction)
{
if (policyData.history.Last().node.parent == null)
{
invalidateScopeData(nearestScope);
return(false);
}
bool popOrInvalidate(TraversalDirection _direction)
{
FocusNode lastNode = policyData.history.removeLast().node;
if (Scrollable.of(lastNode.context) != Scrollable.of(FocusManagerUtils.primaryFocus.context))
{
invalidateScopeData(nearestScope);
return(false);
}
ScrollPositionAlignmentPolicy alignmentPolicy = ScrollPositionAlignmentPolicy.explicitPolicy;
switch (_direction)
{
case TraversalDirection.up:
case TraversalDirection.left:
alignmentPolicy = ScrollPositionAlignmentPolicy.keepVisibleAtStart;
break;
case TraversalDirection.right:
case TraversalDirection.down:
alignmentPolicy = ScrollPositionAlignmentPolicy.keepVisibleAtEnd;
break;
}
FocusTravesalUtils._focusAndEnsureVisible(
lastNode,
alignmentPolicy: alignmentPolicy
);
return(true);
}
switch (direction)
{
case TraversalDirection.down:
case TraversalDirection.up:
switch (policyData.history.First().direction)
{
case TraversalDirection.left:
case TraversalDirection.right:
invalidateScopeData(nearestScope);
break;
case TraversalDirection.up:
case TraversalDirection.down:
if (popOrInvalidate(direction))
{
return(true);
}
break;
}
break;
case TraversalDirection.left:
case TraversalDirection.right:
switch (policyData.history.First().direction)
{
case TraversalDirection.left:
case TraversalDirection.right:
if (popOrInvalidate(direction))
{
return(true);
}
break;
case TraversalDirection.up:
case TraversalDirection.down:
invalidateScopeData(nearestScope);
break;
}
break;
}
}
if (policyData != null && policyData.history.isEmpty())
{
invalidateScopeData(nearestScope);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="activity"></param>
/// <param name="dir"></param>
/// <param name="considerChildren"></param>
/// <returns></returns>
/// <remarks>Corresponds to SB.2.3 in the SCORM 2004 Sequencing/Navigation manual, appendix C.</remarks>
private Activity Flow(Activity activity, TraversalDirection dir, bool considerChildren)
{
TraversalDirection newDirection;
Resources.Culture = LocalizationManager.GetCurrentCulture();
activity = FlowTreeTraversal(activity, dir, considerChildren, TraversalDirection.NotApplicable, out newDirection);
m_navigator.LogSequencing(SequencingEventType.IntermediateNavigation, m_command, Resources.SequencingFlowingTo, activity.Key);
return FlowActivityTraversal(activity, dir, TraversalDirection.NotApplicable);
}
public abstract bool inDirection(FocusNode currentNode, TraversalDirection direction);
public abstract FocusNode findFirstFocusInDirection(FocusNode currentNode, TraversalDirection direction);
/// <summary>
///
/// </summary>
/// <param name="activity"></param>
/// <param name="dir"></param>
/// <returns></returns>
/// <remarks>Corresponds to SB.2.9.2 in the SCORM 2004 Sequencing/Navigation manual, appendix C.</remarks>
Activity ChoiceFlowTreeTraversal(Activity activity, TraversalDirection dir)
{
if(dir == TraversalDirection.Forward)
{
if(activity.IsLastActivityInTree)
{
return null;
}
if(activity.Next == null)
{
if(activity.Parent == null)
{
return null;
}
return ChoiceFlowTreeTraversal(activity.Parent, TraversalDirection.Forward);
}
return activity.Next;
}
else
{
Utilities.Assert(dir == TraversalDirection.Backward);
if(activity == m_navigator.RootActivity)
{
return null;
}
if(activity.Previous == null)
{
return ChoiceFlowTreeTraversal(activity.Parent, TraversalDirection.Backward);
}
return activity.Previous;
}
}
private void SetupMeasurement()
{
NextMeasure = Measurements.Left;
Direction = TraversalDirection.Right;
}
private static void RemoveContiguousWhitespace(IntermediateNodeCollection nodes, TraversalDirection direction)
{
var position = direction == TraversalDirection.Forwards ? 0 : nodes.Count - 1;
while (position >= 0 && position < nodes.Count)
{
var node = nodes[position];
bool shouldRemoveNode;
bool shouldContinueIteration;
switch (node)
{
case IntermediateToken intermediateToken:
shouldRemoveNode = string.IsNullOrWhiteSpace(intermediateToken.Content);
shouldContinueIteration = shouldRemoveNode;
break;
case HtmlContentIntermediateNode htmlContentIntermediateNode:
RemoveContiguousWhitespace(htmlContentIntermediateNode.Children, direction);
shouldRemoveNode = htmlContentIntermediateNode.Children.Count == 0;
shouldContinueIteration = shouldRemoveNode;
break;
case MarkupElementIntermediateNode _:
case CSharpExpressionIntermediateNode _:
case TagHelperIntermediateNode _:
// These node types may produce non-whitespace output at runtime
shouldRemoveNode = false;
shouldContinueIteration = false;
break;
case CSharpCodeIntermediateNode codeIntermediateNode:
shouldRemoveNode = false;
shouldContinueIteration = false;
break;
default:
shouldRemoveNode = false;
shouldContinueIteration = true; // Because other types of nodes don't produce output
break;
}
if (shouldRemoveNode)
{
nodes.RemoveAt(position);
if (direction == TraversalDirection.Forwards)
{
position--;
}
}
position += direction == TraversalDirection.Forwards ? 1 : -1;
if (!shouldContinueIteration)
{
break;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="activity"></param>
/// <param name="dir"></param>
/// <returns></returns>
/// <remarks>Corresponds to SB.2.9.1 in the SCORM 2004 Sequencing/Navigation manual, appendix C.</remarks>
Activity ChoiceFlow(Activity activity, TraversalDirection dir)
{
Activity a = ChoiceFlowTreeTraversal(activity, dir);
if(a == null)
{
return activity;
}
return a;
}
private void ContinueTraversal()
{
RadialDistanceMeasure currentMeasure = NextMeasure;
if (Direction == TraversalDirection.Left)
NextMeasure = currentMeasure.LeftNeighbour;
else
NextMeasure = currentMeasure.RightNeighbour;
if (NextMeasure == null)
{
Direction = (Direction == TraversalDirection.Left) ? TraversalDirection.Right : TraversalDirection.Left;
NextMeasure = currentMeasure;
ContinueTraversal();
return;
}
ServoBrick.SetPosition(ServoId, ConvertToServoAngle(NextMeasure.Angle));
}
